One Level Up Top Level

src/http/ngx_http_file_cache.c - nginx-1.7.10

Global variables defined

Functions 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>
  11. #include <ngx_md5.h>


  14. static ngx_int_t ngx_http_file_cache_lock(ngx_http_request_t *r,
  15.     ngx_http_cache_t *c);
  16. static void ngx_http_file_cache_lock_wait_handler(ngx_event_t *ev);
  17. static void ngx_http_file_cache_lock_wait(ngx_http_request_t *r,
  18.     ngx_http_cache_t *c);
  19. static ngx_int_t ngx_http_file_cache_read(ngx_http_request_t *r,
  20.     ngx_http_cache_t *c);
  21. static ssize_t ngx_http_file_cache_aio_read(ngx_http_request_t *r,
  22.     ngx_http_cache_t *c);
  23. #if (NGX_HAVE_FILE_AIO)
  24. static void ngx_http_cache_aio_event_handler(ngx_event_t *ev);
  25. #endif
  26. static ngx_int_t ngx_http_file_cache_exists(ngx_http_file_cache_t *cache,
  27.     ngx_http_cache_t *c);
  28. static ngx_int_t ngx_http_file_cache_name(ngx_http_request_t *r,
  29.     ngx_path_t *path);
  30. static ngx_http_file_cache_node_t *
  31.     ngx_http_file_cache_lookup(ngx_http_file_cache_t *cache, u_char *key);
  32. static void ngx_http_file_cache_rbtree_insert_value(ngx_rbtree_node_t *temp,
  33.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
  34. static void ngx_http_file_cache_vary(ngx_http_request_t *r, u_char *vary,
  35.     size_t len, u_char *hash);
  36. static void ngx_http_file_cache_vary_header(ngx_http_request_t *r,
  37.     ngx_md5_t *md5, ngx_str_t *name);
  38. static ngx_int_t ngx_http_file_cache_reopen(ngx_http_request_t *r,
  39.     ngx_http_cache_t *c);
  40. static ngx_int_t ngx_http_file_cache_update_variant(ngx_http_request_t *r,
  41.     ngx_http_cache_t *c);
  42. static void ngx_http_file_cache_cleanup(void *data);
  43. static time_t ngx_http_file_cache_forced_expire(ngx_http_file_cache_t *cache);
  44. static time_t ngx_http_file_cache_expire(ngx_http_file_cache_t *cache);
  45. static void ngx_http_file_cache_delete(ngx_http_file_cache_t *cache,
  46.     ngx_queue_t *q, u_char *name);
  47. static void ngx_http_file_cache_loader_sleep(ngx_http_file_cache_t *cache);
  48. static ngx_int_t ngx_http_file_cache_noop(ngx_tree_ctx_t *ctx,
  49.     ngx_str_t *path);
  50. static ngx_int_t ngx_http_file_cache_manage_file(ngx_tree_ctx_t *ctx,
  51.     ngx_str_t *path);
  52. static ngx_int_t ngx_http_file_cache_manage_directory(ngx_tree_ctx_t *ctx,
  53.     ngx_str_t *path);
  54. static ngx_int_t ngx_http_file_cache_add_file(ngx_tree_ctx_t *ctx,
  55.     ngx_str_t *path);
  56. static ngx_int_t ngx_http_file_cache_add(ngx_http_file_cache_t *cache,
  57.     ngx_http_cache_t *c);
  58. static ngx_int_t ngx_http_file_cache_delete_file(ngx_tree_ctx_t *ctx,
  59.     ngx_str_t *path);


  62. ‌ngx_str_t  ngx_http_cache_status[] = {
  63.     ngx_string("MISS"),
  64.     ngx_string("BYPASS"),
  65.     ngx_string("EXPIRED"),
  66.     ngx_string("STALE"),
  67.     ngx_string("UPDATING"),
  68.     ngx_string("REVALIDATED"),
  69.     ngx_string("HIT")
  70. };


  73. ‌static u_char  ngx_http_file_cache_key[] = { LF, 'K', 'E', 'Y', ':', ' ' };


  76. static ngx_int_t
  77. ‌ngx_http_file_cache_init(ngx_shm_zone_t *shm_zone, void *data)
  78. {
  79.     ngx_http_file_cache_t  *ocache = data;

  81.     size_t                  len;
  82.     ngx_uint_t              n;
  83.     ngx_http_file_cache_t  *cache;

  85.     cache = shm_zone->data;

  87.     if (ocache) {
  88.         if (ngx_strcmp(cache->path->name.data, ocache->path->name.data) != 0) {
  89.             ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
  90.                           "cache \"%V\" uses the \"%V\" cache path "
  91.                           "while previously it used the \"%V\" cache path",
  92.                           &shm_zone->shm.name, &cache->path->name,
  93.                           &ocache->path->name);

  95.             return NGX_ERROR;
  96.         }

  98.         for (n = 0; n < 3; n++) {
  99.             if (cache->path->level[n] != ocache->path->level[n]) {
  100.                 ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
  101.                               "cache \"%V\" had previously different levels",
  102.                               &shm_zone->shm.name);
  103.                 return NGX_ERROR;
  104.             }
  105.         }

  107.         cache->sh = ocache->sh;

  109.         cache->shpool = ocache->shpool;
  110.         cache->bsize = ocache->bsize;

  112.         cache->max_size /= cache->bsize;

  114.         if (!cache->sh->cold || cache->sh->loading) {
  115.             cache->path->loader = NULL;
  116.         }

  118.         return NGX_OK;
  119.     }

  121.     cache->shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  123.     if (shm_zone->shm.exists) {
  124.         cache->sh = cache->shpool->data;
  125.         cache->bsize = ngx_fs_bsize(cache->path->name.data);

  127.         return NGX_OK;
  128.     }

  130.     cache->sh = ngx_slab_alloc(cache->shpool, sizeof(ngx_http_file_cache_sh_t));
  131.     if (cache->sh == NULL) {
  132.         return NGX_ERROR;
  133.     }

  135.     cache->shpool->data = cache->sh;

  137.     ngx_rbtree_init(&cache->sh->rbtree, &cache->sh->sentinel,
  138.                     ngx_http_file_cache_rbtree_insert_value);

  140.     ngx_queue_init(&cache->sh->queue);

  142.     cache->sh->cold = 1;
  143.     cache->sh->loading = 0;
  144.     cache->sh->size = 0;

  146.     cache->bsize = ngx_fs_bsize(cache->path->name.data);

  148.     cache->max_size /= cache->bsize;

  150.     len = sizeof(" in cache keys zone \"\"") + shm_zone->shm.name.len;

  152.     cache->shpool->log_ctx = ngx_slab_alloc(cache->shpool, len);
  153.     if (cache->shpool->log_ctx == NULL) {
  154.         return NGX_ERROR;
  155.     }

  157.     ngx_sprintf(cache->shpool->log_ctx, " in cache keys zone \"%V\"%Z",
  158.                 &shm_zone->shm.name);

  160.     cache->shpool->log_nomem = 0;

  162.     return NGX_OK;
  163. }


  166. ngx_int_t
  167. ‌ngx_http_file_cache_new(ngx_http_request_t *r)
  168. {
  169.     ngx_http_cache_t  *c;

  171.     c = ngx_pcalloc(r->pool, sizeof(ngx_http_cache_t));
  172.     if (c == NULL) {
  173.         return NGX_ERROR;
  174.     }

  176.     if (ngx_array_init(&c->keys, r->pool, 4, sizeof(ngx_str_t)) != NGX_OK) {
  177.         return NGX_ERROR;
  178.     }

  180.     r->cache = c;
  181.     c->file.log = r->connection->log;
  182.     c->file.fd = NGX_INVALID_FILE;

  184.     c->last_modified = -1;

  186.     return NGX_OK;
  187. }


  190. ngx_int_t
  191. ‌ngx_http_file_cache_create(ngx_http_request_t *r)
  192. {
  193.     ngx_http_cache_t       *c;
  194.     ngx_pool_cleanup_t     *cln;
  195.     ngx_http_file_cache_t  *cache;

  197.     c = r->cache;
  198.     cache = c->file_cache;

  200.     cln = ngx_pool_cleanup_add(r->pool, 0);
  201.     if (cln == NULL) {
  202.         return NGX_ERROR;
  203.     }

  205.     cln->handler = ngx_http_file_cache_cleanup;
  206.     cln->data = c;

  208.     if (ngx_http_file_cache_exists(cache, c) == NGX_ERROR) {
  209.         return NGX_ERROR;
  210.     }

  212.     if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
  213.         return NGX_ERROR;
  214.     }

  216.     return NGX_OK;
  217. }


  220. void
  221. ‌ngx_http_file_cache_create_key(ngx_http_request_t *r)
  222. {
  223.     size_t             len;
  224.     ngx_str_t         *key;
  225.     ngx_uint_t         i;
  226.     ngx_md5_t          md5;
  227.     ngx_http_cache_t  *c;

  229.     c = r->cache;

  231.     len = 0;

  233.     ngx_crc32_init(c->crc32);
  234.     ngx_md5_init(&md5);

  236.     key = c->keys.elts;
  237.     for (i = 0; i < c->keys.nelts; i++) {
  238.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  239.                        "http cache key: \"%V\"", &key[i]);

  241.         len += key[i].len;

  243.         ngx_crc32_update(&c->crc32, key[i].data, key[i].len);
  244.         ngx_md5_update(&md5, key[i].data, key[i].len);
  245.     }

  247.     c->header_start = sizeof(ngx_http_file_cache_header_t)
  248.                       + sizeof(ngx_http_file_cache_key) + len + 1;

  250.     ngx_crc32_final(c->crc32);
  251.     ngx_md5_final(c->key, &md5);

  253.     ngx_memcpy(c->main, c->key, NGX_HTTP_CACHE_KEY_LEN);
  254. }


  257. ngx_int_t
  258. ‌ngx_http_file_cache_open(ngx_http_request_t *r)
  259. {
  260.     ngx_int_t                  rc, rv;
  261.     ngx_uint_t                 cold, test;
  262.     ngx_http_cache_t          *c;
  263.     ngx_pool_cleanup_t        *cln;
  264.     ngx_open_file_info_t       of;
  265.     ngx_http_file_cache_t     *cache;
  266.     ngx_http_core_loc_conf_t  *clcf;

  268.     c = r->cache;

  270.     if (c->waiting) {
  271.         return NGX_AGAIN;
  272.     }

  274.     if (c->reading) {
  275.         return ngx_http_file_cache_read(r, c);
  276.     }

  278.     cache = c->file_cache;

  280.     if (c->node == NULL) {
  281.         cln = ngx_pool_cleanup_add(r->pool, 0);
  282.         if (cln == NULL) {
  283.             return NGX_ERROR;
  284.         }

  286.         cln->handler = ngx_http_file_cache_cleanup;
  287.         cln->data = c;
  288.     }

  290.     rc = ngx_http_file_cache_exists(cache, c);

  292.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  293.                    "http file cache exists: %i e:%d", rc, c->exists);

  295.     if (rc == NGX_ERROR) {
  296.         return rc;
  297.     }

  299.     if (rc == NGX_AGAIN) {
  300.         return NGX_HTTP_CACHE_SCARCE;
  301.     }

  303.     cold = cache->sh->cold;

  305.     if (rc == NGX_OK) {

  307.         if (c->error) {
  308.             return c->error;
  309.         }

  311.         c->temp_file = 1;
  312.         test = c->exists ? 1 : 0;
  313.         rv = NGX_DECLINED;

  315.     } else { /* rc == NGX_DECLINED */

  317.         if (c->min_uses > 1) {

  319.             if (!cold) {
  320.                 return NGX_HTTP_CACHE_SCARCE;
  321.             }

  323.             test = 1;
  324.             rv = NGX_HTTP_CACHE_SCARCE;

  326.         } else {
  327.             c->temp_file = 1;
  328.             test = cold ? 1 : 0;
  329.             rv = NGX_DECLINED;
  330.         }
  331.     }

  333.     if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
  334.         return NGX_ERROR;
  335.     }

  337.     if (!test) {
  338.         goto done;
  339.     }

  341.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  345.     of.uniq = c->uniq;
  346.     of.valid = clcf->open_file_cache_valid;
  347.     of.min_uses = clcf->open_file_cache_min_uses;
  348.     of.events = clcf->open_file_cache_events;
  349.     of.directio = NGX_OPEN_FILE_DIRECTIO_OFF;
  350.     of.read_ahead = clcf->read_ahead;

  352.     if (ngx_open_cached_file(clcf->open_file_cache, &c->file.name, &of, r->pool)
  353.         != NGX_OK)
  354.     {
  355.         switch (of.err) {

  357.         case 0:
  358.             return NGX_ERROR;

  360.         case NGX_ENOENT:
  361.         case NGX_ENOTDIR:
  362.             goto done;

  364.         default:
  365.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, of.err,
  366.                           ngx_open_file_n " \"%s\" failed", c->file.name.data);
  367.             return NGX_ERROR;
  368.         }
  369.     }

  371.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  372.                    "http file cache fd: %d", of.fd);

  374.     c->file.fd = of.fd;
  375.     c->file.log = r->connection->log;
  376.     c->uniq = of.uniq;
  377.     c->length = of.size;
  378.     c->fs_size = (of.fs_size + cache->bsize - 1) / cache->bsize;

  380.     c->buf = ngx_create_temp_buf(r->pool, c->body_start);
  381.     if (c->buf == NULL) {
  382.         return NGX_ERROR;
  383.     }

  385.     return ngx_http_file_cache_read(r, c);

  387. done:

  389.     if (rv == NGX_DECLINED) {
  390.         return ngx_http_file_cache_lock(r, c);
  391.     }

  393.     return rv;
  394. }


  397. static ngx_int_t
  398. ‌ngx_http_file_cache_lock(ngx_http_request_t *r, ngx_http_cache_t *c)
  399. {
  400.     ngx_msec_t                 now, timer;
  401.     ngx_http_file_cache_t     *cache;

  403.     if (!c->lock) {
  404.         return NGX_DECLINED;
  405.     }

  407.     now = ngx_current_msec;

  409.     cache = c->file_cache;

  411.     ngx_shmtx_lock(&cache->shpool->mutex);

  413.     timer = c->node->lock_time - now;

  415.     if (!c->node->updating || (ngx_msec_int_t) timer <= 0) {
  416.         c->node->updating = 1;
  417.         c->node->lock_time = now + c->lock_age;
  418.         c->updating = 1;
  419.         c->lock_time = c->node->lock_time;
  420.     }

  422.     ngx_shmtx_unlock(&cache->shpool->mutex);

  424.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  425.                    "http file cache lock u:%d wt:%M",
  426.                    c->updating, c->wait_time);

  428.     if (c->updating) {
  429.         return NGX_DECLINED;
  430.     }

  432.     if (c->lock_timeout == 0) {
  433.         return NGX_HTTP_CACHE_SCARCE;
  434.     }

  436.     c->waiting = 1;

  438.     if (c->wait_time == 0) {
  439.         c->wait_time = now + c->lock_timeout;

  441.         c->wait_event.handler = ngx_http_file_cache_lock_wait_handler;
  442.         c->wait_event.data = r;
  443.         c->wait_event.log = r->connection->log;
  444.     }

  446.     timer = c->wait_time - now;

  448.     ngx_add_timer(&c->wait_event, (timer > 500) ? 500 : timer);

  450.     r->main->blocked++;

  452.     return NGX_AGAIN;
  453. }


  456. static void
  457. ‌ngx_http_file_cache_lock_wait_handler(ngx_event_t *ev)
  458. {
  459.     ngx_connection_t    *c;
  460.     ngx_http_request_t  *r;

  462.     r = ev->data;
  463.     c = r->connection;

  465.     ngx_http_set_log_request(c->log, r);

  467.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  468.                    "http file cache wait: \"%V?%V\"", &r->uri, &r->args);

  470.     ngx_http_file_cache_lock_wait(r, r->cache);

  472.     ngx_http_run_posted_requests(c);
  473. }


  476. static void
  477. ‌ngx_http_file_cache_lock_wait(ngx_http_request_t *r, ngx_http_cache_t *c)
  478. {
  479.     ngx_uint_t              wait;
  480.     ngx_msec_t              now, timer;
  481.     ngx_http_file_cache_t  *cache;

  483.     now = ngx_current_msec;

  485.     timer = c->wait_time - now;

  487.     if ((ngx_msec_int_t) timer <= 0) {
  488.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  489.                       "cache lock timeout");
  490.         c->lock_timeout = 0;
  491.         goto wakeup;
  492.     }

  494.     cache = c->file_cache;
  495.     wait = 0;

  497.     ngx_shmtx_lock(&cache->shpool->mutex);

  499.     timer = c->node->lock_time - now;

  501.     if (c->node->updating && (ngx_msec_int_t) timer > 0) {
  502.         wait = 1;
  503.     }

  505.     ngx_shmtx_unlock(&cache->shpool->mutex);

  507.     if (wait) {
  508.         ngx_add_timer(&c->wait_event, (timer > 500) ? 500 : timer);
  509.         return;
  510.     }

  512. wakeup:

  514.     c->waiting = 0;
  515.     r->main->blocked--;
  516.     r->write_event_handler(r);
  517. }


  520. static ngx_int_t
  521. ‌ngx_http_file_cache_read(ngx_http_request_t *r, ngx_http_cache_t *c)
  522. {
  523.     time_t                         now;
  524.     ssize_t                        n;
  525.     ngx_int_t                      rc;
  526.     ngx_http_file_cache_t         *cache;
  527.     ngx_http_file_cache_header_t  *h;

  529.     n = ngx_http_file_cache_aio_read(r, c);

  531.     if (n < 0) {
  532.         return n;
  533.     }

  535.     if ((size_t) n < c->header_start) {
  536.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  537.                       "cache file \"%s\" is too small", c->file.name.data);
  538.         return NGX_DECLINED;
  539.     }

  541.     h = (ngx_http_file_cache_header_t *) c->buf->pos;

  543.     if (h->version != NGX_HTTP_CACHE_VERSION) {
  544.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  545.                       "cache file \"%s\" version mismatch", c->file.name.data);
  546.         return NGX_DECLINED;
  547.     }

  549.     if (h->crc32 != c->crc32) {
  550.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  551.                       "cache file \"%s\" has md5 collision", c->file.name.data);
  552.         return NGX_DECLINED;
  553.     }

  555.     if ((size_t) h->body_start > c->body_start) {
  556.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  557.                       "cache file \"%s\" has too long header",
  558.                       c->file.name.data);
  559.         return NGX_DECLINED;
  560.     }

  562.     if (h->vary_len > NGX_HTTP_CACHE_VARY_LEN) {
  563.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  564.                       "cache file \"%s\" has incorrect vary length",
  565.                       c->file.name.data);
  566.         return NGX_DECLINED;
  567.     }

  569.     if (h->vary_len) {
  570.         ngx_http_file_cache_vary(r, h->vary, h->vary_len, c->variant);

  572.         if (ngx_memcmp(c->variant, h->variant, NGX_HTTP_CACHE_KEY_LEN) != 0) {
  573.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  574.                            "http file cache vary mismatch");
  575.             return ngx_http_file_cache_reopen(r, c);
  576.         }
  577.     }

  579.     c->buf->last += n;

  581.     c->valid_sec = h->valid_sec;
  582.     c->last_modified = h->last_modified;
  583.     c->date = h->date;
  584.     c->valid_msec = h->valid_msec;
  585.     c->header_start = h->header_start;
  586.     c->body_start = h->body_start;
  587.     c->etag.len = h->etag_len;
  588.     c->etag.data = h->etag;

  590.     r->cached = 1;

  592.     cache = c->file_cache;

  594.     if (cache->sh->cold) {

  596.         ngx_shmtx_lock(&cache->shpool->mutex);

  598.         if (!c->node->exists) {
  599.             c->node->uses = 1;
  600.             c->node->body_start = c->body_start;
  601.             c->node->exists = 1;
  602.             c->node->uniq = c->uniq;
  603.             c->node->fs_size = c->fs_size;

  605.             cache->sh->size += c->fs_size;
  606.         }

  608.         ngx_shmtx_unlock(&cache->shpool->mutex);
  609.     }

  611.     now = ngx_time();

  613.     if (c->valid_sec < now) {

  615.         ngx_shmtx_lock(&cache->shpool->mutex);

  617.         if (c->node->updating) {
  618.             rc = NGX_HTTP_CACHE_UPDATING;

  620.         } else {
  621.             c->node->updating = 1;
  622.             c->updating = 1;
  623.             c->lock_time = c->node->lock_time;
  624.             rc = NGX_HTTP_CACHE_STALE;
  625.         }

  627.         ngx_shmtx_unlock(&cache->shpool->mutex);

  629.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  630.                        "http file cache expired: %i %T %T",
  631.                        rc, c->valid_sec, now);

  633.         return rc;
  634.     }

  636.     return NGX_OK;
  637. }


  640. static ssize_t
  641. ‌ngx_http_file_cache_aio_read(ngx_http_request_t *r, ngx_http_cache_t *c)
  642. {
  643. #if (NGX_HAVE_FILE_AIO)
  644.     ssize_t                    n;
  645.     ngx_http_core_loc_conf_t  *clcf;

  647.     if (!ngx_file_aio) {
  648.         goto noaio;
  649.     }

  651.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  653.     if (!clcf->aio) {
  654.         goto noaio;
  655.     }

  657.     n = ngx_file_aio_read(&c->file, c->buf->pos, c->body_start, 0, r->pool);

  659.     if (n != NGX_AGAIN) {
  660.         c->reading = 0;
  661.         return n;
  662.     }

  664.     c->reading = 1;

  666.     c->file.aio->data = r;
  667.     c->file.aio->handler = ngx_http_cache_aio_event_handler;

  669.     r->main->blocked++;
  670.     r->aio = 1;

  672.     return NGX_AGAIN;

  674. noaio:

  676. #endif

  678.     return ngx_read_file(&c->file, c->buf->pos, c->body_start, 0);
  679. }


  682. #if (NGX_HAVE_FILE_AIO)

  684. static void
  685. ‌ngx_http_cache_aio_event_handler(ngx_event_t *ev)
  686. {
  687.     ngx_event_aio_t     *aio;
  688.     ngx_connection_t    *c;
  689.     ngx_http_request_t  *r;

  691.     aio = ev->data;
  692.     r = aio->data;
  693.     c = r->connection;

  695.     ngx_http_set_log_request(c->log, r);

  697.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, c->log, 0,
  698.                    "http file cache aio: \"%V?%V\"", &r->uri, &r->args);

  700.     r->main->blocked--;
  701.     r->aio = 0;

  703.     r->write_event_handler(r);

  705.     ngx_http_run_posted_requests(c);
  706. }

  708. #endif


  711. static ngx_int_t
  712. ‌ngx_http_file_cache_exists(ngx_http_file_cache_t *cache, ngx_http_cache_t *c)
  713. {
  714.     ngx_int_t                    rc;
  715.     ngx_http_file_cache_node_t  *fcn;

  717.     ngx_shmtx_lock(&cache->shpool->mutex);

  719.     fcn = c->node;

  721.     if (fcn == NULL) {
  722.         fcn = ngx_http_file_cache_lookup(cache, c->key);
  723.     }

  725.     if (fcn) {
  726.         ngx_queue_remove(&fcn->queue);

  728.         if (c->node == NULL) {
  729.             fcn->uses++;
  730.             fcn->count++;
  731.         }

  733.         if (fcn->error) {

  735.             if (fcn->valid_sec < ngx_time()) {
  736.                 goto renew;
  737.             }

  739.             rc = NGX_OK;

  741.             goto done;
  742.         }

  744.         if (fcn->exists || fcn->uses >= c->min_uses) {

  746.             c->exists = fcn->exists;
  747.             if (fcn->body_start) {
  748.                 c->body_start = fcn->body_start;
  749.             }

  751.             rc = NGX_OK;

  753.             goto done;
  754.         }

  756.         rc = NGX_AGAIN;

  758.         goto done;
  759.     }

  761.     fcn = ngx_slab_calloc_locked(cache->shpool,
  762.                                  sizeof(ngx_http_file_cache_node_t));
  763.     if (fcn == NULL) {
  764.         ngx_shmtx_unlock(&cache->shpool->mutex);

  766.         (void) ngx_http_file_cache_forced_expire(cache);

  768.         ngx_shmtx_lock(&cache->shpool->mutex);

  770.         fcn = ngx_slab_calloc_locked(cache->shpool,
  771.                                      sizeof(ngx_http_file_cache_node_t));
  772.         if (fcn == NULL) {
  773.             ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  774.                           "could not allocate node%s", cache->shpool->log_ctx);
  775.             rc = NGX_ERROR;
  776.             goto failed;
  777.         }
  778.     }

  780.     ngx_memcpy((u_char *) &fcn->node.key, c->key, sizeof(ngx_rbtree_key_t));

  782.     ngx_memcpy(fcn->key, &c->key[sizeof(ngx_rbtree_key_t)],
  783.                NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));

  785.     ngx_rbtree_insert(&cache->sh->rbtree, &fcn->node);

  787.     fcn->uses = 1;
  788.     fcn->count = 1;

  790. renew:

  792.     rc = NGX_DECLINED;

  794.     fcn->valid_msec = 0;
  795.     fcn->error = 0;
  796.     fcn->exists = 0;
  797.     fcn->valid_sec = 0;
  798.     fcn->uniq = 0;
  799.     fcn->body_start = 0;
  800.     fcn->fs_size = 0;

  802. done:

  804.     fcn->expire = ngx_time() + cache->inactive;

  806.     ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);

  808.     c->uniq = fcn->uniq;
  809.     c->error = fcn->error;
  810.     c->node = fcn;

  812. failed:

  814.     ngx_shmtx_unlock(&cache->shpool->mutex);

  816.     return rc;
  817. }


  820. static ngx_int_t
  821. ‌ngx_http_file_cache_name(ngx_http_request_t *r, ngx_path_t *path)
  822. {
  823.     u_char            *p;
  824.     ngx_http_cache_t  *c;

  826.     c = r->cache;

  828.     if (c->file.name.len) {
  829.         return NGX_OK;
  830.     }

  832.     c->file.name.len = path->name.len + 1 + path->len
  833.                        + 2 * NGX_HTTP_CACHE_KEY_LEN;

  835.     c->file.name.data = ngx_pnalloc(r->pool, c->file.name.len + 1);
  836.     if (c->file.name.data == NULL) {
  837.         return NGX_ERROR;
  838.     }

  840.     ngx_memcpy(c->file.name.data, path->name.data, path->name.len);

  842.     p = c->file.name.data + path->name.len + 1 + path->len;
  843.     p = ngx_hex_dump(p, c->key, NGX_HTTP_CACHE_KEY_LEN);
  844.     *p = '\0';

  846.     ngx_create_hashed_filename(path, c->file.name.data, c->file.name.len);

  848.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  849.                    "cache file: \"%s\"", c->file.name.data);

  851.     return NGX_OK;
  852. }


  855. static ngx_http_file_cache_node_t *
  856. ‌ngx_http_file_cache_lookup(ngx_http_file_cache_t *cache, u_char *key)
  857. {
  858.     ngx_int_t                    rc;
  859.     ngx_rbtree_key_t             node_key;
  860.     ngx_rbtree_node_t           *node, *sentinel;
  861.     ngx_http_file_cache_node_t  *fcn;

  863.     ngx_memcpy((u_char *) &node_key, key, sizeof(ngx_rbtree_key_t));

  865.     node = cache->sh->rbtree.root;
  866.     sentinel = cache->sh->rbtree.sentinel;

  868.     while (node != sentinel) {

  870.         if (node_key < node->key) {
  871.             node = node->left;
  872.             continue;
  873.         }

  875.         if (node_key > node->key) {
  876.             node = node->right;
  877.             continue;
  878.         }

  880.         /* node_key == node->key */

  882.         fcn = (ngx_http_file_cache_node_t *) node;

  884.         rc = ngx_memcmp(&key[sizeof(ngx_rbtree_key_t)], fcn->key,
  885.                         NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));

  887.         if (rc == 0) {
  888.             return fcn;
  889.         }

  891.         node = (rc < 0) ? node->left : node->right;
  892.     }

  894.     /* not found */

  896.     return NULL;
  897. }


  900. static void
  901. ‌ngx_http_file_cache_rbtree_insert_value(ngx_rbtree_node_t *temp,
  902.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  903. {
  904.     ngx_rbtree_node_t           **p;
  905.     ngx_http_file_cache_node_t   *cn, *cnt;

  907.     for ( ;; ) {

  909.         if (node->key < temp->key) {

  911.             p = &temp->left;

  913.         } else if (node->key > temp->key) {

  915.             p = &temp->right;

  917.         } else { /* node->key == temp->key */

  919.             cn = (ngx_http_file_cache_node_t *) node;
  920.             cnt = (ngx_http_file_cache_node_t *) temp;

  922.             p = (ngx_memcmp(cn->key, cnt->key,
  923.                             NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t))
  924.                  < 0)
  925.                     ? &temp->left : &temp->right;
  926.         }

  928.         if (*p == sentinel) {
  929.             break;
  930.         }

  932.         temp = *p;
  933.     }

  935.     *p = node;
  936.     node->parent = temp;
  937.     node->left = sentinel;
  938.     node->right = sentinel;
  939.     ngx_rbt_red(node);
  940. }


  943. static void
  944. ‌ngx_http_file_cache_vary(ngx_http_request_t *r, u_char *vary, size_t len,
  945.     u_char *hash)
  946. {
  947.     u_char     *p, *last;
  948.     ngx_str_t   name;
  949.     ngx_md5_t   md5;
  950.     u_char      buf[NGX_HTTP_CACHE_VARY_LEN];

  952.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  953.                    "http file cache vary: \"%*s\"", len, vary);

  955.     ngx_md5_init(&md5);
  956.     ngx_md5_update(&md5, r->cache->main, NGX_HTTP_CACHE_KEY_LEN);

  958.     ngx_strlow(buf, vary, len);

  960.     p = buf;
  961.     last = buf + len;

  963.     while (p < last) {

  965.         while (p < last && (*p == ' ' || *p == ',')) { p++; }

  967.         name.data = p;

  969.         while (p < last && *p != ',' && *p != ' ') { p++; }

  971.         name.len = p - name.data;

  973.         if (name.len == 0) {
  974.             break;
  975.         }

  977.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  978.                        "http file cache vary: %V", &name);

  980.         ngx_md5_update(&md5, name.data, name.len);
  981.         ngx_md5_update(&md5, (u_char *) ":", sizeof(":") - 1);

  983.         ngx_http_file_cache_vary_header(r, &md5, &name);

  985.         ngx_md5_update(&md5, (u_char *) CRLF, sizeof(CRLF) - 1);
  986.     }

  988.     ngx_md5_final(hash, &md5);
  989. }


  992. static void
  993. ‌ngx_http_file_cache_vary_header(ngx_http_request_t *r, ngx_md5_t *md5,
  994.     ngx_str_t *name)
  995. {
  996.     size_t            len;
  997.     u_char           *p, *start, *last;
  998.     ngx_uint_t        i, multiple, normalize;
  999.     ngx_list_part_t  *part;
  1000.     ngx_table_elt_t  *header;

  1002.     multiple = 0;
  1003.     normalize = 0;

  1005.     if (name->len == sizeof("Accept-Charset") - 1
  1006.         && ngx_strncasecmp(name->data, (u_char *) "Accept-Charset",
  1007.                            sizeof("Accept-Charset") - 1) == 0)
  1008.     {
  1009.         normalize = 1;

  1011.     } else if (name->len == sizeof("Accept-Encoding") - 1
  1012.         && ngx_strncasecmp(name->data, (u_char *) "Accept-Encoding",
  1013.                            sizeof("Accept-Encoding") - 1) == 0)
  1014.     {
  1015.         normalize = 1;

  1017.     } else if (name->len == sizeof("Accept-Language") - 1
  1018.         && ngx_strncasecmp(name->data, (u_char *) "Accept-Language",
  1019.                            sizeof("Accept-Language") - 1) == 0)
  1020.     {
  1021.         normalize = 1;
  1022.     }

  1024.     part = &r->headers_in.headers.part;
  1025.     header = part->elts;

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

  1029.         if (i >= part->nelts) {
  1030.             if (part->next == NULL) {
  1031.                 break;
  1032.             }

  1034.             part = part->next;
  1035.             header = part->elts;
  1036.             i = 0;
  1037.         }

  1039.         if (header[i].hash == 0) {
  1040.             continue;
  1041.         }

  1043.         if (header[i].key.len != name->len) {
  1044.             continue;
  1045.         }

  1047.         if (ngx_strncasecmp(header[i].key.data, name->data, name->len) != 0) {
  1048.             continue;
  1049.         }

  1051.         if (!normalize) {

  1053.             if (multiple) {
  1054.                 ngx_md5_update(md5, (u_char *) ",", sizeof(",") - 1);
  1055.             }

  1057.             ngx_md5_update(md5, header[i].value.data, header[i].value.len);

  1059.             multiple = 1;

  1061.             continue;
  1062.         }

  1064.         /* normalize spaces */

  1066.         p = header[i].value.data;
  1067.         last = p + header[i].value.len;

  1069.         while (p < last) {

  1071.             while (p < last && (*p == ' ' || *p == ',')) { p++; }

  1073.             start = p;

  1075.             while (p < last && *p != ',' && *p != ' ') { p++; }

  1077.             len = p - start;

  1079.             if (len == 0) {
  1080.                 break;
  1081.             }

  1083.             if (multiple) {
  1084.                 ngx_md5_update(md5, (u_char *) ",", sizeof(",") - 1);
  1085.             }

  1087.             ngx_md5_update(md5, start, len);

  1089.             multiple = 1;
  1090.         }
  1091.     }
  1092. }


  1095. static ngx_int_t
  1096. ‌ngx_http_file_cache_reopen(ngx_http_request_t *r, ngx_http_cache_t *c)
  1097. {
  1098.     ngx_http_file_cache_t  *cache;

  1100.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
  1101.                    "http file cache reopen");

  1103.     if (c->secondary) {
  1104.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  1105.                       "cache file \"%s\" has incorrect vary hash",
  1106.                       c->file.name.data);
  1107.         return NGX_DECLINED;
  1108.     }

  1110.     cache = c->file_cache;

  1112.     ngx_shmtx_lock(&cache->shpool->mutex);

  1114.     c->node->count--;
  1115.     c->node = NULL;

  1117.     ngx_shmtx_unlock(&cache->shpool->mutex);

  1119.     c->secondary = 1;
  1120.     c->file.name.len = 0;
  1121.     c->body_start = c->buf->end - c->buf->start;

  1123.     ngx_memcpy(c->key, c->variant, NGX_HTTP_CACHE_KEY_LEN);

  1125.     return ngx_http_file_cache_open(r);
  1126. }


  1129. ngx_int_t
  1130. ‌ngx_http_file_cache_set_header(ngx_http_request_t *r, u_char *buf)
  1131. {
  1132.     ngx_http_file_cache_header_t  *h = (ngx_http_file_cache_header_t *) buf;

  1134.     u_char            *p;
  1135.     ngx_str_t         *key;
  1136.     ngx_uint_t         i;
  1137.     ngx_http_cache_t  *c;

  1139.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1140.                    "http file cache set header");

  1142.     c = r->cache;

  1144.     ngx_memzero(h, sizeof(ngx_http_file_cache_header_t));

  1146.     h->version = NGX_HTTP_CACHE_VERSION;
  1147.     h->valid_sec = c->valid_sec;
  1148.     h->last_modified = c->last_modified;
  1149.     h->date = c->date;
  1150.     h->crc32 = c->crc32;
  1151.     h->valid_msec = (u_short) c->valid_msec;
  1152.     h->header_start = (u_short) c->header_start;
  1153.     h->body_start = (u_short) c->body_start;

  1155.     if (c->etag.len <= NGX_HTTP_CACHE_ETAG_LEN) {
  1156.         h->etag_len = (u_char) c->etag.len;
  1157.         ngx_memcpy(h->etag, c->etag.data, c->etag.len);
  1158.     }

  1160.     if (c->vary.len) {
  1161.         if (c->vary.len > NGX_HTTP_CACHE_VARY_LEN) {
  1162.             /* should not happen */
  1163.             c->vary.len = NGX_HTTP_CACHE_VARY_LEN;
  1164.         }

  1166.         h->vary_len = (u_char) c->vary.len;
  1167.         ngx_memcpy(h->vary, c->vary.data, c->vary.len);

  1169.         ngx_http_file_cache_vary(r, c->vary.data, c->vary.len, c->variant);
  1170.         ngx_memcpy(h->variant, c->variant, NGX_HTTP_CACHE_KEY_LEN);
  1171.     }

  1173.     if (ngx_http_file_cache_update_variant(r, c) != NGX_OK) {
  1174.         return NGX_ERROR;
  1175.     }

  1177.     p = buf + sizeof(ngx_http_file_cache_header_t);

  1179.     p = ngx_cpymem(p, ngx_http_file_cache_key, sizeof(ngx_http_file_cache_key));

  1181.     key = c->keys.elts;
  1182.     for (i = 0; i < c->keys.nelts; i++) {
  1183.         p = ngx_copy(p, key[i].data, key[i].len);
  1184.     }

  1186.     *p = LF;

  1188.     return NGX_OK;
  1189. }


  1192. static ngx_int_t
  1193. ‌ngx_http_file_cache_update_variant(ngx_http_request_t *r, ngx_http_cache_t *c)
  1194. {
  1195.     ngx_http_file_cache_t  *cache;

  1197.     if (!c->secondary) {
  1198.         return NGX_OK;
  1199.     }

  1201.     if (c->vary.len
  1202.         && ngx_memcmp(c->variant, c->key, NGX_HTTP_CACHE_KEY_LEN) == 0)
  1203.     {
  1204.         return NGX_OK;
  1205.     }

  1207.     /*
  1208.      * if the variant hash doesn't match one we used as a secondary
  1209.      * cache key, switch back to the original key
  1210.      */

  1212.     cache = c->file_cache;

  1214.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1215.                    "http file cache main key");

  1217.     ngx_shmtx_lock(&cache->shpool->mutex);

  1219.     c->node->count--;
  1220.     c->node->updating = 0;
  1221.     c->node = NULL;

  1223.     ngx_shmtx_unlock(&cache->shpool->mutex);

  1225.     c->file.name.len = 0;

  1227.     ngx_memcpy(c->key, c->main, NGX_HTTP_CACHE_KEY_LEN);

  1229.     if (ngx_http_file_cache_exists(cache, c) == NGX_ERROR) {
  1230.         return NGX_ERROR;
  1231.     }

  1233.     if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
  1234.         return NGX_ERROR;
  1235.     }

  1237.     return NGX_OK;
  1238. }


  1241. void
  1242. ‌ngx_http_file_cache_update(ngx_http_request_t *r, ngx_temp_file_t *tf)
  1243. {
  1244.     off_t                   fs_size;
  1245.     ngx_int_t               rc;
  1246.     ngx_file_uniq_t         uniq;
  1247.     ngx_file_info_t         fi;
  1248.     ngx_http_cache_t        *c;
  1249.     ngx_ext_rename_file_t   ext;
  1250.     ngx_http_file_cache_t  *cache;

  1252.     c = r->cache;

  1254.     if (c->updated) {
  1255.         return;
  1256.     }

  1258.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1259.                    "http file cache update");

  1261.     cache = c->file_cache;

  1263.     c->updated = 1;
  1264.     c->updating = 0;

  1266.     uniq = 0;
  1267.     fs_size = 0;

  1269.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1270.                    "http file cache rename: \"%s\" to \"%s\"",
  1271.                    tf->file.name.data, c->file.name.data);

  1273.     ext.access = NGX_FILE_OWNER_ACCESS;
  1274.     ext.path_access = NGX_FILE_OWNER_ACCESS;
  1275.     ext.time = -1;
  1276.     ext.create_path = 1;
  1277.     ext.delete_file = 1;
  1278.     ext.log = r->connection->log;

  1280.     rc = ngx_ext_rename_file(&tf->file.name, &c->file.name, &ext);

  1282.     if (rc == NGX_OK) {

  1284.         if (ngx_fd_info(tf->file.fd, &fi) == NGX_FILE_ERROR) {
  1285.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  1286.                           ngx_fd_info_n " \"%s\" failed", tf->file.name.data);

  1288.             rc = NGX_ERROR;

  1290.         } else {
  1291.             uniq = ngx_file_uniq(&fi);
  1292.             fs_size = (ngx_file_fs_size(&fi) + cache->bsize - 1) / cache->bsize;
  1293.         }
  1294.     }

  1296.     ngx_shmtx_lock(&cache->shpool->mutex);

  1298.     c->node->count--;
  1299.     c->node->uniq = uniq;
  1300.     c->node->body_start = c->body_start;

  1302.     cache->sh->size += fs_size - c->node->fs_size;
  1303.     c->node->fs_size = fs_size;

  1305.     if (rc == NGX_OK) {
  1306.         c->node->exists = 1;
  1307.     }

  1309.     c->node->updating = 0;

  1311.     ngx_shmtx_unlock(&cache->shpool->mutex);
  1312. }


  1315. void
  1316. ‌ngx_http_file_cache_update_header(ngx_http_request_t *r)
  1317. {
  1318.     ssize_t                        n;
  1319.     ngx_err_t                      err;
  1320.     ngx_file_t                     file;
  1321.     ngx_file_info_t                fi;
  1322.     ngx_http_cache_t              *c;
  1323.     ngx_http_file_cache_header_t   h;

  1325.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1326.                    "http file cache update header");

  1328.     c = r->cache;

  1330.     ngx_memzero(&file, sizeof(ngx_file_t));

  1332.     file.name = c->file.name;
  1333.     file.log = r->connection->log;
  1334.     file.fd = ngx_open_file(file.name.data, NGX_FILE_RDWR, NGX_FILE_OPEN, 0);

  1336.     if (file.fd == NGX_INVALID_FILE) {
  1337.         err = ngx_errno;

  1339.         /* cache file may have been deleted */

  1341.         if (err == NGX_ENOENT) {
  1342.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1343.                            "http file cache \"%s\" not found",
  1344.                            file.name.data);
  1345.             return;
  1346.         }

  1348.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, err,
  1349.                       ngx_open_file_n " \"%s\" failed", file.name.data);
  1350.         return;
  1351.     }

  1353.     /*
  1354.      * make sure cache file wasn't replaced;
  1355.      * if it was, do nothing
  1356.      */

  1358.     if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
  1359.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  1360.                       ngx_fd_info_n " \"%s\" failed", file.name.data);
  1361.         goto done;
  1362.     }

  1364.     if (c->uniq != ngx_file_uniq(&fi)
  1365.         || c->length != ngx_file_size(&fi))
  1366.     {
  1367.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1368.                        "http file cache \"%s\" changed",
  1369.                        file.name.data);
  1370.         goto done;
  1371.     }

  1373.     n = ngx_read_file(&file, (u_char *) &h,
  1374.                       sizeof(ngx_http_file_cache_header_t), 0);

  1376.     if (n == NGX_ERROR) {
  1377.         goto done;
  1378.     }

  1380.     if ((size_t) n != sizeof(ngx_http_file_cache_header_t)) {
  1381.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  1382.                       ngx_read_file_n " read only %z of %z from \"%s\"",
  1383.                       n, sizeof(ngx_http_file_cache_header_t), file.name.data);
  1384.         goto done;
  1385.     }

  1387.     if (h.version != NGX_HTTP_CACHE_VERSION
  1388.         || h.last_modified != c->last_modified
  1389.         || h.crc32 != c->crc32
  1390.         || h.header_start != c->header_start
  1391.         || h.body_start != c->body_start)
  1392.     {
  1393.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1394.                        "http file cache \"%s\" content changed",
  1395.                        file.name.data);
  1396.         goto done;
  1397.     }

  1399.     /*
  1400.      * update cache file header with new data,
  1401.      * notably h.valid_sec and h.date
  1402.      */

  1404.     ngx_memzero(&h, sizeof(ngx_http_file_cache_header_t));

  1406.     h.version = NGX_HTTP_CACHE_VERSION;
  1407.     h.valid_sec = c->valid_sec;
  1408.     h.last_modified = c->last_modified;
  1409.     h.date = c->date;
  1410.     h.crc32 = c->crc32;
  1411.     h.valid_msec = (u_short) c->valid_msec;
  1412.     h.header_start = (u_short) c->header_start;
  1413.     h.body_start = (u_short) c->body_start;

  1415.     if (c->etag.len <= NGX_HTTP_CACHE_ETAG_LEN) {
  1416.         h.etag_len = (u_char) c->etag.len;
  1417.         ngx_memcpy(h.etag, c->etag.data, c->etag.len);
  1418.     }

  1420.     if (c->vary.len) {
  1421.         if (c->vary.len > NGX_HTTP_CACHE_VARY_LEN) {
  1422.             /* should not happen */
  1423.             c->vary.len = NGX_HTTP_CACHE_VARY_LEN;
  1424.         }

  1426.         h.vary_len = (u_char) c->vary.len;
  1427.         ngx_memcpy(h.vary, c->vary.data, c->vary.len);

  1429.         ngx_http_file_cache_vary(r, c->vary.data, c->vary.len, c->variant);
  1430.         ngx_memcpy(h.variant, c->variant, NGX_HTTP_CACHE_KEY_LEN);
  1431.     }

  1433.     (void) ngx_write_file(&file, (u_char *) &h,
  1434.                           sizeof(ngx_http_file_cache_header_t), 0);

  1436. done:

  1438.     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  1439.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, ngx_errno,
  1440.                       ngx_close_file_n " \"%s\" failed", file.name.data);
  1441.     }
  1442. }


  1445. ngx_int_t
  1446. ‌ngx_http_cache_send(ngx_http_request_t *r)
  1447. {
  1448.     ngx_int_t          rc;
  1449.     ngx_buf_t         *b;
  1450.     ngx_chain_t        out;
  1451.     ngx_http_cache_t  *c;

  1453.     c = r->cache;

  1455.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1456.                    "http file cache send: %s", c->file.name.data);

  1458.     if (r != r->main && c->length - c->body_start == 0) {
  1459.         return ngx_http_send_header(r);
  1460.     }

  1462.     /* we need to allocate all before the header would be sent */

  1464.     b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
  1465.     if (b == NULL) {
  1466.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1467.     }

  1469.     b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
  1470.     if (b->file == NULL) {
  1471.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1472.     }

  1474.     rc = ngx_http_send_header(r);

  1476.     if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
  1477.         return rc;
  1478.     }

  1480.     b->file_pos = c->body_start;
  1481.     b->file_last = c->length;

  1483.     b->in_file = (c->length - c->body_start) ? 1: 0;
  1484.     b->last_buf = (r == r->main) ? 1: 0;
  1485.     b->last_in_chain = 1;

  1487.     b->file->fd = c->file.fd;
  1488.     b->file->name = c->file.name;
  1489.     b->file->log = r->connection->log;

  1491.     out.buf = b;
  1492.     out.next = NULL;

  1494.     return ngx_http_output_filter(r, &out);
  1495. }


  1498. void
  1499. ‌ngx_http_file_cache_free(ngx_http_cache_t *c, ngx_temp_file_t *tf)
  1500. {
  1501.     ngx_http_file_cache_t       *cache;
  1502.     ngx_http_file_cache_node_t  *fcn;

  1504.     if (c->updated || c->node == NULL) {
  1505.         return;
  1506.     }

  1508.     cache = c->file_cache;

  1510.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
  1511.                    "http file cache free, fd: %d", c->file.fd);

  1513.     ngx_shmtx_lock(&cache->shpool->mutex);

  1515.     fcn = c->node;
  1516.     fcn->count--;

  1518.     if (c->updating && fcn->lock_time == c->lock_time) {
  1519.         fcn->updating = 0;
  1520.     }

  1522.     if (c->error) {
  1523.         fcn->error = c->error;

  1525.         if (c->valid_sec) {
  1526.             fcn->valid_sec = c->valid_sec;
  1527.             fcn->valid_msec = c->valid_msec;
  1528.         }

  1530.     } else if (!fcn->exists && fcn->count == 0 && c->min_uses == 1) {
  1531.         ngx_queue_remove(&fcn->queue);
  1532.         ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
  1533.         ngx_slab_free_locked(cache->shpool, fcn);
  1534.         c->node = NULL;
  1535.     }

  1537.     ngx_shmtx_unlock(&cache->shpool->mutex);

  1539.     c->updated = 1;
  1540.     c->updating = 0;

  1542.     if (c->temp_file) {
  1543.         if (tf && tf->file.fd != NGX_INVALID_FILE) {
  1544.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
  1545.                            "http file cache incomplete: \"%s\"",
  1546.                            tf->file.name.data);

  1548.             if (ngx_delete_file(tf->file.name.data) == NGX_FILE_ERROR) {
  1549.                 ngx_log_error(NGX_LOG_CRIT, c->file.log, ngx_errno,
  1550.                               ngx_delete_file_n " \"%s\" failed",
  1551.                               tf->file.name.data);
  1552.             }
  1553.         }
  1554.     }

  1556.     if (c->wait_event.timer_set) {
  1557.         ngx_del_timer(&c->wait_event);
  1558.     }
  1559. }


  1562. static void
  1563. ‌ngx_http_file_cache_cleanup(void *data)
  1564. {
  1565.     ngx_http_cache_t  *c = data;

  1567.     if (c->updated) {
  1568.         return;
  1569.     }

  1571.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
  1572.                    "http file cache cleanup");

  1574.     if (c->updating) {
  1575.         ngx_log_error(NGX_LOG_ALERT, c->file.log, 0,
  1576.                       "stalled cache updating, error:%ui", c->error);
  1577.     }

  1579.     ngx_http_file_cache_free(c, NULL);
  1580. }


  1583. static time_t
  1584. ‌ngx_http_file_cache_forced_expire(ngx_http_file_cache_t *cache)
  1585. {
  1586.     u_char                      *name;
  1587.     size_t                       len;
  1588.     time_t                       wait;
  1589.     ngx_uint_t                   tries;
  1590.     ngx_path_t                  *path;
  1591.     ngx_queue_t                 *q;
  1592.     ngx_http_file_cache_node_t  *fcn;

  1594.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1595.                    "http file cache forced expire");

  1597.     path = cache->path;
  1598.     len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;

  1600.     name = ngx_alloc(len + 1, ngx_cycle->log);
  1601.     if (name == NULL) {
  1602.         return 10;
  1603.     }

  1605.     ngx_memcpy(name, path->name.data, path->name.len);

  1607.     wait = 10;
  1608.     tries = 20;

  1610.     ngx_shmtx_lock(&cache->shpool->mutex);

  1612.     for (q = ngx_queue_last(&cache->sh->queue);
  1613.          q != ngx_queue_sentinel(&cache->sh->queue);
  1614.          q = ngx_queue_prev(q))
  1615.     {
  1616.         fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);

  1618.         ngx_log_debug6(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1619.                   "http file cache forced expire: #%d %d %02xd%02xd%02xd%02xd",
  1620.                   fcn->count, fcn->exists,
  1621.                   fcn->key[0], fcn->key[1], fcn->key[2], fcn->key[3]);

  1623.         if (fcn->count == 0) {
  1624.             ngx_http_file_cache_delete(cache, q, name);
  1625.             wait = 0;

  1627.         } else {
  1628.             if (--tries) {
  1629.                 continue;
  1630.             }

  1632.             wait = 1;
  1633.         }

  1635.         break;
  1636.     }

  1638.     ngx_shmtx_unlock(&cache->shpool->mutex);

  1640.     ngx_free(name);

  1642.     return wait;
  1643. }


  1646. static time_t
  1647. ‌ngx_http_file_cache_expire(ngx_http_file_cache_t *cache)
  1648. {
  1649.     u_char                      *name, *p;
  1650.     size_t                       len;
  1651.     time_t                       now, wait;
  1652.     ngx_path_t                  *path;
  1653.     ngx_queue_t                 *q;
  1654.     ngx_http_file_cache_node_t  *fcn;
  1655.     u_char                       key[2 * NGX_HTTP_CACHE_KEY_LEN];

  1657.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1658.                    "http file cache expire");

  1660.     path = cache->path;
  1661.     len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;

  1663.     name = ngx_alloc(len + 1, ngx_cycle->log);
  1664.     if (name == NULL) {
  1665.         return 10;
  1666.     }

  1668.     ngx_memcpy(name, path->name.data, path->name.len);

  1670.     now = ngx_time();

  1672.     ngx_shmtx_lock(&cache->shpool->mutex);

  1674.     for ( ;; ) {

  1676.         if (ngx_quit || ngx_terminate) {
  1677.             wait = 1;
  1678.             break;
  1679.         }

  1681.         if (ngx_queue_empty(&cache->sh->queue)) {
  1682.             wait = 10;
  1683.             break;
  1684.         }

  1686.         q = ngx_queue_last(&cache->sh->queue);

  1688.         fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);

  1690.         wait = fcn->expire - now;

  1692.         if (wait > 0) {
  1693.             wait = wait > 10 ? 10 : wait;
  1694.             break;
  1695.         }

  1697.         ngx_log_debug6(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1698.                        "http file cache expire: #%d %d %02xd%02xd%02xd%02xd",
  1699.                        fcn->count, fcn->exists,
  1700.                        fcn->key[0], fcn->key[1], fcn->key[2], fcn->key[3]);

  1702.         if (fcn->count == 0) {
  1703.             ngx_http_file_cache_delete(cache, q, name);
  1704.             continue;
  1705.         }

  1707.         if (fcn->deleting) {
  1708.             wait = 1;
  1709.             break;
  1710.         }

  1712.         p = ngx_hex_dump(key, (u_char *) &fcn->node.key,
  1713.                          sizeof(ngx_rbtree_key_t));
  1714.         len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
  1715.         (void) ngx_hex_dump(p, fcn->key, len);

  1717.         /*
  1718.          * abnormally exited workers may leave locked cache entries,
  1719.          * and although it may be safe to remove them completely,
  1720.          * we prefer to just move them to the top of the inactive queue
  1721.          */

  1723.         ngx_queue_remove(q);
  1724.         fcn->expire = ngx_time() + cache->inactive;
  1725.         ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);

  1727.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  1728.                       "ignore long locked inactive cache entry %*s, count:%d",
  1729.                       2 * NGX_HTTP_CACHE_KEY_LEN, key, fcn->count);
  1730.     }

  1732.     ngx_shmtx_unlock(&cache->shpool->mutex);

  1734.     ngx_free(name);

  1736.     return wait;
  1737. }


  1740. static void
  1741. ‌ngx_http_file_cache_delete(ngx_http_file_cache_t *cache, ngx_queue_t *q,
  1742.     u_char *name)
  1743. {
  1744.     u_char                      *p;
  1745.     size_t                       len;
  1746.     ngx_path_t                  *path;
  1747.     ngx_http_file_cache_node_t  *fcn;

  1749.     fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);

  1751.     if (fcn->exists) {
  1752.         cache->sh->size -= fcn->fs_size;

  1754.         path = cache->path;
  1755.         p = name + path->name.len + 1 + path->len;
  1756.         p = ngx_hex_dump(p, (u_char *) &fcn->node.key,
  1757.                          sizeof(ngx_rbtree_key_t));
  1758.         len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
  1759.         p = ngx_hex_dump(p, fcn->key, len);
  1760.         *p = '\0';

  1762.         fcn->count++;
  1763.         fcn->deleting = 1;
  1764.         ngx_shmtx_unlock(&cache->shpool->mutex);

  1766.         len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;
  1767.         ngx_create_hashed_filename(path, name, len);

  1769.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1770.                        "http file cache expire: \"%s\"", name);

  1772.         if (ngx_delete_file(name) == NGX_FILE_ERROR) {
  1773.             ngx_log_error(NGX_LOG_CRIT, ngx_cycle->log, ngx_errno,
  1774.                           ngx_delete_file_n " \"%s\" failed", name);
  1775.         }

  1777.         ngx_shmtx_lock(&cache->shpool->mutex);
  1778.         fcn->count--;
  1779.         fcn->deleting = 0;
  1780.     }

  1782.     if (fcn->count == 0) {
  1783.         ngx_queue_remove(q);
  1784.         ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
  1785.         ngx_slab_free_locked(cache->shpool, fcn);
  1786.     }
  1787. }


  1790. static time_t
  1791. ‌ngx_http_file_cache_manager(void *data)
  1792. {
  1793.     ngx_http_file_cache_t  *cache = data;

  1795.     off_t   size;
  1796.     time_t  next, wait;

  1798.     next = ngx_http_file_cache_expire(cache);

  1800.     cache->last = ngx_current_msec;
  1801.     cache->files = 0;

  1803.     for ( ;; ) {
  1804.         ngx_shmtx_lock(&cache->shpool->mutex);

  1806.         size = cache->sh->size;

  1808.         ngx_shmtx_unlock(&cache->shpool->mutex);

  1810.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1811.                        "http file cache size: %O", size);

  1813.         if (size < cache->max_size) {
  1814.             return next;
  1815.         }

  1817.         wait = ngx_http_file_cache_forced_expire(cache);

  1819.         if (wait > 0) {
  1820.             return wait;
  1821.         }

  1823.         if (ngx_quit || ngx_terminate) {
  1824.             return next;
  1825.         }
  1826.     }
  1827. }


  1830. static void
  1831. ‌ngx_http_file_cache_loader(void *data)
  1832. {
  1833.     ngx_http_file_cache_t  *cache = data;

  1835.     ngx_tree_ctx_t  tree;

  1837.     if (!cache->sh->cold || cache->sh->loading) {
  1838.         return;
  1839.     }

  1841.     if (!ngx_atomic_cmp_set(&cache->sh->loading, 0, ngx_pid)) {
  1842.         return;
  1843.     }

  1845.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1846.                    "http file cache loader");

  1848.     tree.init_handler = NULL;
  1849.     tree.file_handler = ngx_http_file_cache_manage_file;
  1850.     tree.pre_tree_handler = ngx_http_file_cache_manage_directory;
  1851.     tree.post_tree_handler = ngx_http_file_cache_noop;
  1852.     tree.spec_handler = ngx_http_file_cache_delete_file;
  1853.     tree.data = cache;
  1854.     tree.alloc = 0;
  1855.     tree.log = ngx_cycle->log;

  1857.     cache->last = ngx_current_msec;
  1858.     cache->files = 0;

  1860.     if (ngx_walk_tree(&tree, &cache->path->name) == NGX_ABORT) {
  1861.         cache->sh->loading = 0;
  1862.         return;
  1863.     }

  1865.     cache->sh->cold = 0;
  1866.     cache->sh->loading = 0;

  1868.     ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0,
  1869.                   "http file cache: %V %.3fM, bsize: %uz",
  1870.                   &cache->path->name,
  1871.                   ((double) cache->sh->size * cache->bsize) / (1024 * 1024),
  1872.                   cache->bsize);
  1873. }


  1876. static ngx_int_t
  1877. ‌ngx_http_file_cache_noop(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  1878. {
  1879.     return NGX_OK;
  1880. }


  1883. static ngx_int_t
  1884. ‌ngx_http_file_cache_manage_file(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  1885. {
  1886.     ngx_msec_t              elapsed;
  1887.     ngx_http_file_cache_t  *cache;

  1889.     cache = ctx->data;

  1891.     if (ngx_http_file_cache_add_file(ctx, path) != NGX_OK) {
  1892.         (void) ngx_http_file_cache_delete_file(ctx, path);
  1893.     }

  1895.     if (++cache->files >= cache->loader_files) {
  1896.         ngx_http_file_cache_loader_sleep(cache);

  1898.     } else {
  1899.         ngx_time_update();

  1901.         elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

  1903.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  1904.                        "http file cache loader time elapsed: %M", elapsed);

  1906.         if (elapsed >= cache->loader_threshold) {
  1907.             ngx_http_file_cache_loader_sleep(cache);
  1908.         }
  1909.     }

  1911.     return (ngx_quit || ngx_terminate) ? NGX_ABORT : NGX_OK;
  1912. }


  1915. static ngx_int_t
  1916. ‌ngx_http_file_cache_manage_directory(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  1917. {
  1918.     if (path->len >= 5
  1919.         && ngx_strncmp(path->data + path->len - 5, "/temp", 5) == 0)
  1920.     {
  1921.         return NGX_DECLINED;
  1922.     }

  1924.     return NGX_OK;
  1925. }


  1928. static void
  1929. ‌ngx_http_file_cache_loader_sleep(ngx_http_file_cache_t *cache)
  1930. {
  1931.     ngx_msleep(cache->loader_sleep);

  1933.     ngx_time_update();

  1935.     cache->last = ngx_current_msec;
  1936.     cache->files = 0;
  1937. }


  1940. static ngx_int_t
  1941. ‌ngx_http_file_cache_add_file(ngx_tree_ctx_t *ctx, ngx_str_t *name)
  1942. {
  1943.     u_char                 *p;
  1944.     ngx_int_t               n;
  1945.     ngx_uint_t              i;
  1946.     ngx_http_cache_t        c;
  1947.     ngx_http_file_cache_t  *cache;

  1949.     if (name->len < 2 * NGX_HTTP_CACHE_KEY_LEN) {
  1950.         return NGX_ERROR;
  1951.     }

  1953.     if (ctx->size < (off_t) sizeof(ngx_http_file_cache_header_t)) {
  1954.         ngx_log_error(NGX_LOG_CRIT, ctx->log, 0,
  1955.                       "cache file \"%s\" is too small", name->data);
  1956.         return NGX_ERROR;
  1957.     }

  1959.     ngx_memzero(&c, sizeof(ngx_http_cache_t));
  1960.     cache = ctx->data;

  1962.     c.length = ctx->size;
  1963.     c.fs_size = (ctx->fs_size + cache->bsize - 1) / cache->bsize;

  1965.     p = &name->data[name->len - 2 * NGX_HTTP_CACHE_KEY_LEN];

  1967.     for (i = 0; i < NGX_HTTP_CACHE_KEY_LEN; i++) {
  1968.         n = ngx_hextoi(p, 2);

  1970.         if (n == NGX_ERROR) {
  1971.             return NGX_ERROR;
  1972.         }

  1974.         p += 2;

  1976.         c.key[i] = (u_char) n;
  1977.     }

  1979.     return ngx_http_file_cache_add(cache, &c);
  1980. }


  1983. static ngx_int_t
  1984. ‌ngx_http_file_cache_add(ngx_http_file_cache_t *cache, ngx_http_cache_t *c)
  1985. {
  1986.     ngx_http_file_cache_node_t  *fcn;

  1988.     ngx_shmtx_lock(&cache->shpool->mutex);

  1990.     fcn = ngx_http_file_cache_lookup(cache, c->key);

  1992.     if (fcn == NULL) {

  1994.         fcn = ngx_slab_calloc_locked(cache->shpool,
  1995.                                      sizeof(ngx_http_file_cache_node_t));
  1996.         if (fcn == NULL) {
  1997.             ngx_shmtx_unlock(&cache->shpool->mutex);
  1998.             return NGX_ERROR;
  1999.         }

  2001.         ngx_memcpy((u_char *) &fcn->node.key, c->key, sizeof(ngx_rbtree_key_t));

  2003.         ngx_memcpy(fcn->key, &c->key[sizeof(ngx_rbtree_key_t)],
  2004.                    NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t));

  2006.         ngx_rbtree_insert(&cache->sh->rbtree, &fcn->node);

  2008.         fcn->uses = 1;
  2009.         fcn->exists = 1;
  2010.         fcn->fs_size = c->fs_size;

  2012.         cache->sh->size += c->fs_size;

  2014.     } else {
  2015.         ngx_queue_remove(&fcn->queue);
  2016.     }

  2018.     fcn->expire = ngx_time() + cache->inactive;

  2020.     ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);

  2022.     ngx_shmtx_unlock(&cache->shpool->mutex);

  2024.     return NGX_OK;
  2025. }


  2028. static ngx_int_t
  2029. ‌ngx_http_file_cache_delete_file(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  2030. {
  2031.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
  2032.                    "http file cache delete: \"%s\"", path->data);

  2034.     if (ngx_delete_file(path->data) == NGX_FILE_ERROR) {
  2035.         ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
  2036.                       ngx_delete_file_n " \"%s\" failed", path->data);
  2037.     }

  2039.     return NGX_OK;
  2040. }


  2043. time_t
  2044. ‌ngx_http_file_cache_valid(ngx_array_t *cache_valid, ngx_uint_t status)
  2045. {
  2046.     ngx_uint_t               i;
  2047.     ngx_http_cache_valid_t  *valid;

  2049.     if (cache_valid == NULL) {
  2050.         return 0;
  2051.     }

  2053.     valid = cache_valid->elts;
  2054.     for (i = 0; i < cache_valid->nelts; i++) {

  2056.         if (valid[i].status == 0) {
  2057.             return valid[i].valid;
  2058.         }

  2060.         if (valid[i].status == status) {
  2061.             return valid[i].valid;
  2062.         }
  2063.     }

  2065.     return 0;
  2066. }


  2069. char *
  2070. ‌ngx_http_file_cache_set_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2071. {
  2072.     char  *confp = conf;

  2074.     off_t                   max_size;
  2075.     u_char                 *last, *p;
  2076.     time_t                  inactive;
  2077.     size_t                  len;
  2078.     ssize_t                 size;
  2079.     ngx_str_t               s, name, *value;
  2080.     ngx_int_t               loader_files;
  2081.     ngx_msec_t              loader_sleep, loader_threshold;
  2082.     ngx_uint_t              i, n, use_temp_path;
  2083.     ngx_array_t            *caches;
  2084.     ngx_http_file_cache_t  *cache, **ce;

  2086.     cache = ngx_pcalloc(cf->pool, sizeof(ngx_http_file_cache_t));
  2087.     if (cache == NULL) {
  2088.         return NGX_CONF_ERROR;
  2089.     }

  2091.     cache->path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
  2092.     if (cache->path == NULL) {
  2093.         return NGX_CONF_ERROR;
  2094.     }

  2096.     use_temp_path = 1;

  2098.     inactive = 600;
  2099.     loader_files = 100;
  2100.     loader_sleep = 50;
  2101.     loader_threshold = 200;

  2103.     name.len = 0;
  2104.     size = 0;
  2105.     max_size = NGX_MAX_OFF_T_VALUE;

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

  2109.     cache->path->name = value[1];

  2111.     if (cache->path->name.data[cache->path->name.len - 1] == '/') {
  2112.         cache->path->name.len--;
  2113.     }

  2115.     if (ngx_conf_full_name(cf->cycle, &cache->path->name, 0) != NGX_OK) {
  2116.         return NGX_CONF_ERROR;
  2117.     }

  2119.     for (i = 2; i < cf->args->nelts; i++) {

  2121.         if (ngx_strncmp(value[i].data, "levels=", 7) == 0) {

  2123.             p = value[i].data + 7;
  2124.             last = value[i].data + value[i].len;

  2126.             for (n = 0; n < 3 && p < last; n++) {

  2128.                 if (*p > '0' && *p < '3') {

  2130.                     cache->path->level[n] = *p++ - '0';
  2131.                     cache->path->len += cache->path->level[n] + 1;

  2133.                     if (p == last) {
  2134.                         break;
  2135.                     }

  2137.                     if (*p++ == ':' && n < 2 && p != last) {
  2138.                         continue;
  2139.                     }

  2141.                     goto invalid_levels;
  2142.                 }

  2144.                 goto invalid_levels;
  2145.             }

  2147.             if (cache->path->len < 10 + 3) {
  2148.                 continue;
  2149.             }

  2151.         invalid_levels:

  2153.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2154.                                "invalid \"levels\" \"%V\"", &value[i]);
  2155.             return NGX_CONF_ERROR;
  2156.         }

  2158.         if (ngx_strncmp(value[i].data, "use_temp_path=", 14) == 0) {

  2160.             if (ngx_strcmp(&value[i].data[14], "on") == 0) {
  2161.                 use_temp_path = 1;

  2163.             } else if (ngx_strcmp(&value[i].data[14], "off") == 0) {
  2164.                 use_temp_path = 0;

  2166.             } else {
  2167.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2168.                                    "invalid use_temp_path value \"%V\", "
  2169.                                    "it must be \"on\" or \"off\"",
  2170.                                    &value[i]);
  2171.                 return NGX_CONF_ERROR;
  2172.             }

  2174.             continue;
  2175.         }

  2177.         if (ngx_strncmp(value[i].data, "keys_zone=", 10) == 0) {

  2179.             name.data = value[i].data + 10;

  2181.             p = (u_char *) ngx_strchr(name.data, ':');

  2183.             if (p) {
  2184.                 name.len = p - name.data;

  2186.                 p++;

  2188.                 s.len = value[i].data + value[i].len - p;
  2189.                 s.data = p;

  2191.                 size = ngx_parse_size(&s);
  2192.                 if (size > 8191) {
  2193.                     continue;
  2194.                 }
  2195.             }

  2197.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2198.                                "invalid keys zone size \"%V\"", &value[i]);
  2199.             return NGX_CONF_ERROR;
  2200.         }

  2202.         if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

  2204.             s.len = value[i].len - 9;
  2205.             s.data = value[i].data + 9;

  2207.             inactive = ngx_parse_time(&s, 1);
  2208.             if (inactive == (time_t) NGX_ERROR) {
  2209.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2210.                                    "invalid inactive value \"%V\"", &value[i]);
  2211.                 return NGX_CONF_ERROR;
  2212.             }

  2214.             continue;
  2215.         }

  2217.         if (ngx_strncmp(value[i].data, "max_size=", 9) == 0) {

  2219.             s.len = value[i].len - 9;
  2220.             s.data = value[i].data + 9;

  2222.             max_size = ngx_parse_offset(&s);
  2223.             if (max_size < 0) {
  2224.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2225.                                    "invalid max_size value \"%V\"", &value[i]);
  2226.                 return NGX_CONF_ERROR;
  2227.             }

  2229.             continue;
  2230.         }

  2232.         if (ngx_strncmp(value[i].data, "loader_files=", 13) == 0) {

  2234.             loader_files = ngx_atoi(value[i].data + 13, value[i].len - 13);
  2235.             if (loader_files == NGX_ERROR) {
  2236.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2237.                            "invalid loader_files value \"%V\"", &value[i]);
  2238.                 return NGX_CONF_ERROR;
  2239.             }

  2241.             continue;
  2242.         }

  2244.         if (ngx_strncmp(value[i].data, "loader_sleep=", 13) == 0) {

  2246.             s.len = value[i].len - 13;
  2247.             s.data = value[i].data + 13;

  2249.             loader_sleep = ngx_parse_time(&s, 0);
  2250.             if (loader_sleep == (ngx_msec_t) NGX_ERROR) {
  2251.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2252.                            "invalid loader_sleep value \"%V\"", &value[i]);
  2253.                 return NGX_CONF_ERROR;
  2254.             }

  2256.             continue;
  2257.         }

  2259.         if (ngx_strncmp(value[i].data, "loader_threshold=", 17) == 0) {

  2261.             s.len = value[i].len - 17;
  2262.             s.data = value[i].data + 17;

  2264.             loader_threshold = ngx_parse_time(&s, 0);
  2265.             if (loader_threshold == (ngx_msec_t) NGX_ERROR) {
  2266.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2267.                            "invalid loader_threshold value \"%V\"", &value[i]);
  2268.                 return NGX_CONF_ERROR;
  2269.             }

  2271.             continue;
  2272.         }

  2274.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2275.                            "invalid parameter \"%V\"", &value[i]);
  2276.         return NGX_CONF_ERROR;
  2277.     }

  2279.     if (name.len == 0 || size == 0) {
  2280.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2281.                            "\"%V\" must have \"keys_zone\" parameter",
  2282.                            &cmd->name);
  2283.         return NGX_CONF_ERROR;
  2284.     }

  2286.     cache->path->manager = ngx_http_file_cache_manager;
  2287.     cache->path->loader = ngx_http_file_cache_loader;
  2288.     cache->path->data = cache;
  2289.     cache->path->conf_file = cf->conf_file->file.name.data;
  2290.     cache->path->line = cf->conf_file->line;
  2291.     cache->loader_files = loader_files;
  2292.     cache->loader_sleep = loader_sleep;
  2293.     cache->loader_threshold = loader_threshold;

  2295.     if (ngx_add_path(cf, &cache->path) != NGX_OK) {
  2296.         return NGX_CONF_ERROR;
  2297.     }

  2299.     if (!use_temp_path) {
  2300.         cache->temp_path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
  2301.         if (cache->temp_path == NULL) {
  2302.             return NGX_CONF_ERROR;
  2303.         }

  2305.         len = cache->path->name.len + sizeof("/temp") - 1;

  2307.         p = ngx_pnalloc(cf->pool, len + 1);
  2308.         if (p == NULL) {
  2309.             return NGX_CONF_ERROR;
  2310.         }

  2312.         cache->temp_path->name.len = len;
  2313.         cache->temp_path->name.data = p;

  2315.         p = ngx_cpymem(p, cache->path->name.data, cache->path->name.len);
  2316.         ngx_memcpy(p, "/temp", sizeof("/temp"));

  2318.         ngx_memcpy(&cache->temp_path->level, &cache->path->level,
  2319.                    3 * sizeof(size_t));

  2321.         cache->temp_path->len = cache->path->len;
  2322.         cache->temp_path->conf_file = cf->conf_file->file.name.data;
  2323.         cache->temp_path->line = cf->conf_file->line;

  2325.         if (ngx_add_path(cf, &cache->temp_path) != NGX_OK) {
  2326.             return NGX_CONF_ERROR;
  2327.         }
  2328.     }

  2330.     cache->shm_zone = ngx_shared_memory_add(cf, &name, size, cmd->post);
  2331.     if (cache->shm_zone == NULL) {
  2332.         return NGX_CONF_ERROR;
  2333.     }

  2335.     if (cache->shm_zone->data) {
  2336.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2337.                            "duplicate zone \"%V\"", &name);
  2338.         return NGX_CONF_ERROR;
  2339.     }


  2342.     cache->shm_zone->init = ngx_http_file_cache_init;
  2343.     cache->shm_zone->data = cache;

  2345.     cache->inactive = inactive;
  2346.     cache->max_size = max_size;

  2348.     caches = (ngx_array_t *) (confp + cmd->offset);

  2350.     ce = ngx_array_push(caches);
  2351.     if (ce == NULL) {
  2352.         return NGX_CONF_ERROR;
  2353.     }

  2355.     *ce = cache;

  2357.     return NGX_CONF_OK;
  2358. }


  2361. char *
  2362. ‌ngx_http_file_cache_valid_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  2363.     void *conf)
  2364. {
  2365.     char  *p = conf;

  2367.     time_t                    valid;
  2368.     ngx_str_t                *value;
  2369.     ngx_uint_t                i, n, status;
  2370.     ngx_array_t             **a;
  2371.     ngx_http_cache_valid_t   *v;
  2372.     static ngx_uint_t         statuses[] = { 200, 301, 302 };

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

  2376.     if (*a == NGX_CONF_UNSET_PTR) {
  2377.         *a = ngx_array_create(cf->pool, 1, sizeof(ngx_http_cache_valid_t));
  2378.         if (*a == NULL) {
  2379.             return NGX_CONF_ERROR;
  2380.         }
  2381.     }

  2383.     value = cf->args->elts;
  2384.     n = cf->args->nelts - 1;

  2386.     valid = ngx_parse_time(&value[n], 1);
  2387.     if (valid == (time_t) NGX_ERROR) {
  2388.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2389.                            "invalid time value \"%V\"", &value[n]);
  2390.         return NGX_CONF_ERROR;
  2391.     }

  2393.     if (n == 1) {

  2395.         for (i = 0; i < 3; i++) {
  2396.             v = ngx_array_push(*a);
  2397.             if (v == NULL) {
  2398.                 return NGX_CONF_ERROR;
  2399.             }

  2401.             v->status = statuses[i];
  2402.             v->valid = valid;
  2403.         }

  2405.         return NGX_CONF_OK;
  2406.     }

  2408.     for (i = 1; i < n; i++) {

  2410.         if (ngx_strcmp(value[i].data, "any") == 0) {

  2412.             status = 0;

  2414.         } else {

  2416.             status = ngx_atoi(value[i].data, value[i].len);
  2417.             if (status < 100) {
  2418.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2419.                                    "invalid status \"%V\"", &value[i]);
  2420.                 return NGX_CONF_ERROR;
  2421.             }
  2422.         }

  2424.         v = ngx_array_push(*a);
  2425.         if (v == NULL) {
  2426.             return NGX_CONF_ERROR;
  2427.         }

  2429.         v->status = status;
  2430.         v->valid = valid;
  2431.     }

  2433.     return NGX_CONF_OK;
  2434. }

One Level Up Top Level