One Level Up Top Level

src/http/ngx_http_file_cache.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

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 ngx_int_t 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. #if (NGX_THREADS)
  27. static ngx_int_t ngx_http_cache_thread_handler(ngx_thread_task_t *task,
  28.     ngx_file_t *file);
  29. static void ngx_http_cache_thread_event_handler(ngx_event_t *ev);
  30. #endif
  31. static ngx_int_t ngx_http_file_cache_exists(ngx_http_file_cache_t *cache,
  32.     ngx_http_cache_t *c);
  33. static ngx_int_t ngx_http_file_cache_name(ngx_http_request_t *r,
  34.     ngx_path_t *path);
  35. static ngx_http_file_cache_node_t *
  36.     ngx_http_file_cache_lookup(ngx_http_file_cache_t *cache, u_char *key);
  37. static void ngx_http_file_cache_rbtree_insert_value(ngx_rbtree_node_t *temp,
  38.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);
  39. static void ngx_http_file_cache_vary(ngx_http_request_t *r, u_char *vary,
  40.     size_t len, u_char *hash);
  41. static void ngx_http_file_cache_vary_header(ngx_http_request_t *r,
  42.     ngx_md5_t *md5, ngx_str_t *name);
  43. static ngx_int_t ngx_http_file_cache_reopen(ngx_http_request_t *r,
  44.     ngx_http_cache_t *c);
  45. static ngx_int_t ngx_http_file_cache_update_variant(ngx_http_request_t *r,
  46.     ngx_http_cache_t *c);
  47. static void ngx_http_file_cache_cleanup(void *data);
  48. static time_t ngx_http_file_cache_forced_expire(ngx_http_file_cache_t *cache);
  49. static time_t ngx_http_file_cache_expire(ngx_http_file_cache_t *cache);
  50. static void ngx_http_file_cache_delete(ngx_http_file_cache_t *cache,
  51.     ngx_queue_t *q, u_char *name);
  52. static void ngx_http_file_cache_loader_sleep(ngx_http_file_cache_t *cache);
  53. static ngx_int_t ngx_http_file_cache_noop(ngx_tree_ctx_t *ctx,
  54.     ngx_str_t *path);
  55. static ngx_int_t ngx_http_file_cache_manage_file(ngx_tree_ctx_t *ctx,
  56.     ngx_str_t *path);
  57. static ngx_int_t ngx_http_file_cache_manage_directory(ngx_tree_ctx_t *ctx,
  58.     ngx_str_t *path);
  59. static ngx_int_t ngx_http_file_cache_add_file(ngx_tree_ctx_t *ctx,
  60.     ngx_str_t *path);
  61. static ngx_int_t ngx_http_file_cache_add(ngx_http_file_cache_t *cache,
  62.     ngx_http_cache_t *c);
  63. static ngx_int_t ngx_http_file_cache_delete_file(ngx_tree_ctx_t *ctx,
  64.     ngx_str_t *path);
  65. static void ngx_http_file_cache_set_watermark(ngx_http_file_cache_t *cache);


  68. ‌ngx_str_t  ngx_http_cache_status[] = {
  69.     ngx_string("MISS"),
  70.     ngx_string("BYPASS"),
  71.     ngx_string("EXPIRED"),
  72.     ngx_string("STALE"),
  73.     ngx_string("UPDATING"),
  74.     ngx_string("REVALIDATED"),
  75.     ngx_string("HIT")
  76. };


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


  82. static ngx_int_t
  83. ‌ngx_http_file_cache_init(ngx_shm_zone_t *shm_zone, void *data)
  84. {
  85.     ngx_http_file_cache_t  *ocache = data;

  87.     size_t                  len;
  88.     ngx_uint_t              n;
  89.     ngx_http_file_cache_t  *cache;

  91.     cache = shm_zone->data;

  93.     if (ocache) {
  94.         if (ngx_strcmp(cache->path->name.data, ocache->path->name.data) != 0) {
  95.             ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
  96.                           "cache \"%V\" uses the \"%V\" cache path "
  97.                           "while previously it used the \"%V\" cache path",
  98.                           &shm_zone->shm.name, &cache->path->name,
  99.                           &ocache->path->name);

  101.             return NGX_ERROR;
  102.         }

  104.         for (n = 0; n < NGX_MAX_PATH_LEVEL; n++) {
  105.             if (cache->path->level[n] != ocache->path->level[n]) {
  106.                 ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
  107.                               "cache \"%V\" had previously different levels",
  108.                               &shm_zone->shm.name);
  109.                 return NGX_ERROR;
  110.             }
  111.         }

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

  115.         cache->shpool = ocache->shpool;
  116.         cache->bsize = ocache->bsize;

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

  120.         if (!cache->sh->cold || cache->sh->loading) {
  121.             cache->path->loader = NULL;
  122.         }

  124.         return NGX_OK;
  125.     }

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

  129.     if (shm_zone->shm.exists) {
  130.         cache->sh = cache->shpool->data;
  131.         cache->bsize = ngx_fs_bsize(cache->path->name.data);
  132.         cache->max_size /= cache->bsize;

  134.         return NGX_OK;
  135.     }

  137.     cache->sh = ngx_slab_alloc(cache->shpool, sizeof(ngx_http_file_cache_sh_t));
  138.     if (cache->sh == NULL) {
  139.         return NGX_ERROR;
  140.     }

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

  144.     ngx_rbtree_init(&cache->sh->rbtree, &cache->sh->sentinel,
  145.                     ngx_http_file_cache_rbtree_insert_value);

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

  149.     cache->sh->cold = 1;
  150.     cache->sh->loading = 0;
  151.     cache->sh->size = 0;
  152.     cache->sh->count = 0;
  153.     cache->sh->watermark = (ngx_uint_t) -1;

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

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

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

  161.     cache->shpool->log_ctx = ngx_slab_alloc(cache->shpool, len);
  162.     if (cache->shpool->log_ctx == NULL) {
  163.         return NGX_ERROR;
  164.     }

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

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

  171.     return NGX_OK;
  172. }


  175. ngx_int_t
  176. ‌ngx_http_file_cache_new(ngx_http_request_t *r)
  177. {
  178.     ngx_http_cache_t  *c;

  180.     c = ngx_pcalloc(r->pool, sizeof(ngx_http_cache_t));
  181.     if (c == NULL) {
  182.         return NGX_ERROR;
  183.     }

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

  189.     r->cache = c;
  190.     c->file.log = r->connection->log;
  191.     c->file.fd = NGX_INVALID_FILE;

  193.     return NGX_OK;
  194. }


  197. ngx_int_t
  198. ‌ngx_http_file_cache_create(ngx_http_request_t *r)
  199. {
  200.     ngx_http_cache_t       *c;
  201.     ngx_pool_cleanup_t     *cln;
  202.     ngx_http_file_cache_t  *cache;

  204.     c = r->cache;
  205.     cache = c->file_cache;

  207.     cln = ngx_pool_cleanup_add(r->pool, 0);
  208.     if (cln == NULL) {
  209.         return NGX_ERROR;
  210.     }

  212.     cln->handler = ngx_http_file_cache_cleanup;
  213.     cln->data = c;

  215.     if (ngx_http_file_cache_exists(cache, c) == NGX_ERROR) {
  216.         return NGX_ERROR;
  217.     }

  219.     if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
  220.         return NGX_ERROR;
  221.     }

  223.     return NGX_OK;
  224. }


  227. void
  228. ‌ngx_http_file_cache_create_key(ngx_http_request_t *r)
  229. {
  230.     size_t             len;
  231.     ngx_str_t         *key;
  232.     ngx_uint_t         i;
  233.     ngx_md5_t          md5;
  234.     ngx_http_cache_t  *c;

  236.     c = r->cache;

  238.     len = 0;

  240.     ngx_crc32_init(c->crc32);
  241.     ngx_md5_init(&md5);

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

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

  250.         ngx_crc32_update(&c->crc32, key[i].data, key[i].len);
  251.         ngx_md5_update(&md5, key[i].data, key[i].len);
  252.     }

  254.     c->header_start = sizeof(ngx_http_file_cache_header_t)
  255.                       + sizeof(ngx_http_file_cache_key) + len + 1;

  257.     ngx_crc32_final(c->crc32);
  258.     ngx_md5_final(c->key, &md5);

  260.     ngx_memcpy(c->main, c->key, NGX_HTTP_CACHE_KEY_LEN);
  261. }


  264. ngx_int_t
  265. ‌ngx_http_file_cache_open(ngx_http_request_t *r)
  266. {
  267.     ngx_int_t                  rc, rv;
  268.     ngx_uint_t                 test;
  269.     ngx_http_cache_t          *c;
  270.     ngx_pool_cleanup_t        *cln;
  271.     ngx_open_file_info_t       of;
  272.     ngx_http_file_cache_t     *cache;
  273.     ngx_http_core_loc_conf_t  *clcf;

  275.     c = r->cache;

  277.     if (c->waiting) {
  278.         return NGX_AGAIN;
  279.     }

  281.     if (c->reading) {
  282.         return ngx_http_file_cache_read(r, c);
  283.     }

  285.     cache = c->file_cache;

  287.     if (c->node == NULL) {
  288.         cln = ngx_pool_cleanup_add(r->pool, 0);
  289.         if (cln == NULL) {
  290.             return NGX_ERROR;
  291.         }

  293.         cln->handler = ngx_http_file_cache_cleanup;
  294.         cln->data = c;
  295.     }

  297.     c->buffer_size = c->body_start;

  299.     rc = ngx_http_file_cache_exists(cache, c);

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

  304.     if (rc == NGX_ERROR) {
  305.         return rc;
  306.     }

  308.     if (rc == NGX_AGAIN) {
  309.         return NGX_HTTP_CACHE_SCARCE;
  310.     }

  312.     if (rc == NGX_OK) {

  314.         if (c->error) {
  315.             return c->error;
  316.         }

  318.         c->temp_file = 1;
  319.         test = c->exists ? 1 : 0;
  320.         rv = NGX_DECLINED;

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

  324.         test = cache->sh->cold ? 1 : 0;

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

  328.             if (!test) {
  329.                 return NGX_HTTP_CACHE_SCARCE;
  330.             }

  332.             rv = NGX_HTTP_CACHE_SCARCE;

  334.         } else {
  335.             c->temp_file = 1;
  336.             rv = NGX_DECLINED;
  337.         }
  338.     }

  340.     if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
  341.         return NGX_ERROR;
  342.     }

  344.     if (!test) {
  345.         goto done;
  346.     }

  348.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  352.     of.uniq = c->uniq;
  353.     of.valid = clcf->open_file_cache_valid;
  354.     of.min_uses = clcf->open_file_cache_min_uses;
  355.     of.events = clcf->open_file_cache_events;
  356.     of.directio = NGX_OPEN_FILE_DIRECTIO_OFF;
  357.     of.read_ahead = clcf->read_ahead;

  359.     if (ngx_open_cached_file(clcf->open_file_cache, &c->file.name, &of, r->pool)
  360.         != NGX_OK)
  361.     {
  362.         switch (of.err) {

  364.         case 0:
  365.             return NGX_ERROR;

  367.         case NGX_ENOENT:
  368.         case NGX_ENOTDIR:
  369.             goto done;

  371.         default:
  372.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, of.err,
  373.                           ngx_open_file_n " \"%s\" failed", c->file.name.data);
  374.             return NGX_ERROR;
  375.         }
  376.     }

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

  381.     c->file.fd = of.fd;
  382.     c->file.log = r->connection->log;
  383.     c->uniq = of.uniq;
  384.     c->length = of.size;
  385.     c->fs_size = (of.fs_size + cache->bsize - 1) / cache->bsize;

  387.     c->buf = ngx_create_temp_buf(r->pool, c->body_start);
  388.     if (c->buf == NULL) {
  389.         return NGX_ERROR;
  390.     }

  392.     return ngx_http_file_cache_read(r, c);

  394. done:

  396.     if (rv == NGX_DECLINED) {
  397.         return ngx_http_file_cache_lock(r, c);
  398.     }

  400.     return rv;
  401. }


  404. static ngx_int_t
  405. ‌ngx_http_file_cache_lock(ngx_http_request_t *r, ngx_http_cache_t *c)
  406. {
  407.     ngx_msec_t                 now, timer;
  408.     ngx_http_file_cache_t     *cache;

  410.     if (!c->lock) {
  411.         return NGX_DECLINED;
  412.     }

  414.     now = ngx_current_msec;

  416.     cache = c->file_cache;

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

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

  422.     if (!c->node->updating || (ngx_msec_int_t) timer <= 0) {
  423.         c->node->updating = 1;
  424.         c->node->lock_time = now + c->lock_age;
  425.         c->updating = 1;
  426.         c->lock_time = c->node->lock_time;
  427.     }

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

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

  435.     if (c->updating) {
  436.         return NGX_DECLINED;
  437.     }

  439.     if (c->lock_timeout == 0) {
  440.         return NGX_HTTP_CACHE_SCARCE;
  441.     }

  443.     if (r->main->blocked >= NGX_HTTP_MAX_BLOCKED) {
  444.         return NGX_HTTP_CACHE_SCARCE;
  445.     }

  447.     c->waiting = 1;

  449.     if (c->wait_time == 0) {
  450.         c->wait_time = now + c->lock_timeout;

  452.         c->wait_event.handler = ngx_http_file_cache_lock_wait_handler;
  453.         c->wait_event.data = r;
  454.         c->wait_event.log = r->connection->log;
  455.     }

  457.     timer = c->wait_time - now;

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

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

  463.     return NGX_AGAIN;
  464. }


  467. static void
  468. ‌ngx_http_file_cache_lock_wait_handler(ngx_event_t *ev)
  469. {
  470.     ngx_int_t            rc;
  471.     ngx_connection_t    *c;
  472.     ngx_http_request_t  *r;

  474.     r = ev->data;
  475.     c = r->connection;

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

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

  482.     rc = ngx_http_file_cache_lock_wait(r, r->cache);

  484.     if (rc == NGX_AGAIN) {
  485.         return;
  486.     }

  488.     r->cache->waiting = 0;
  489.     r->main->blocked--;

  491.     if (r->main->terminated) {
  492.         /*
  493.          * trigger connection event handler if the request was
  494.          * terminated
  495.          */

  497.         c->write->handler(c->write);

  499.     } else {
  500.         r->write_event_handler(r);
  501.         ngx_http_run_posted_requests(c);
  502.     }
  503. }


  506. static ngx_int_t
  507. ‌ngx_http_file_cache_lock_wait(ngx_http_request_t *r, ngx_http_cache_t *c)
  508. {
  509.     ngx_uint_t              wait;
  510.     ngx_msec_t              now, timer;
  511.     ngx_http_file_cache_t  *cache;

  513.     now = ngx_current_msec;

  515.     timer = c->wait_time - now;

  517.     if ((ngx_msec_int_t) timer <= 0) {
  518.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  519.                       "cache lock timeout");
  520.         c->lock_timeout = 0;
  521.         return NGX_OK;
  522.     }

  524.     cache = c->file_cache;
  525.     wait = 0;

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

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

  531.     if (c->node->updating && (ngx_msec_int_t) timer > 0) {
  532.         wait = 1;
  533.     }

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

  537.     if (wait) {
  538.         ngx_add_timer(&c->wait_event, (timer > 500) ? 500 : timer);
  539.         return NGX_AGAIN;
  540.     }

  542.     return NGX_OK;
  543. }


  546. static ngx_int_t
  547. ‌ngx_http_file_cache_read(ngx_http_request_t *r, ngx_http_cache_t *c)
  548. {
  549.     u_char                        *p;
  550.     time_t                         now;
  551.     ssize_t                        n;
  552.     ngx_str_t                     *key;
  553.     ngx_int_t                      rc;
  554.     ngx_uint_t                     i;
  555.     ngx_http_file_cache_t         *cache;
  556.     ngx_http_file_cache_header_t  *h;

  558.     n = ngx_http_file_cache_aio_read(r, c);

  560.     if (n < 0) {
  561.         return n;
  562.     }

  564.     if ((size_t) n < c->header_start) {
  565.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  566.                       "cache file \"%s\" is too small", c->file.name.data);
  567.         return NGX_DECLINED;
  568.     }

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

  572.     if (h->version != NGX_HTTP_CACHE_VERSION) {
  573.         ngx_log_error(NGX_LOG_INFO, r->connection->log, 0,
  574.                       "cache file \"%s\" version mismatch", c->file.name.data);
  575.         return NGX_DECLINED;
  576.     }

  578.     if (h->crc32 != c->crc32 || (size_t) h->header_start != c->header_start) {
  579.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  580.                       "cache file \"%s\" has md5 collision", c->file.name.data);
  581.         return NGX_DECLINED;
  582.     }

  584.     p = c->buf->pos + sizeof(ngx_http_file_cache_header_t)
  585.         + sizeof(ngx_http_file_cache_key);

  587.     key = c->keys.elts;
  588.     for (i = 0; i < c->keys.nelts; i++) {
  589.         if (ngx_memcmp(p, key[i].data, key[i].len) != 0) {
  590.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  591.                           "cache file \"%s\" has md5 collision",
  592.                           c->file.name.data);
  593.             return NGX_DECLINED;
  594.         }

  596.         p += key[i].len;
  597.     }

  599.     if ((size_t) h->body_start > c->body_start) {
  600.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  601.                       "cache file \"%s\" has too long header",
  602.                       c->file.name.data);
  603.         return NGX_DECLINED;
  604.     }

  606.     if (h->vary_len > NGX_HTTP_CACHE_VARY_LEN) {
  607.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  608.                       "cache file \"%s\" has incorrect vary length",
  609.                       c->file.name.data);
  610.         return NGX_DECLINED;
  611.     }

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

  616.         if (ngx_memcmp(c->variant, h->variant, NGX_HTTP_CACHE_KEY_LEN) != 0) {
  617.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  618.                            "http file cache vary mismatch");
  619.             return ngx_http_file_cache_reopen(r, c);
  620.         }
  621.     }

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

  625.     c->valid_sec = h->valid_sec;
  626.     c->updating_sec = h->updating_sec;
  627.     c->error_sec = h->error_sec;
  628.     c->last_modified = h->last_modified;
  629.     c->date = h->date;
  630.     c->valid_msec = h->valid_msec;
  631.     c->body_start = h->body_start;
  632.     c->etag.len = h->etag_len;
  633.     c->etag.data = h->etag;

  635.     r->cached = 1;

  637.     cache = c->file_cache;

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

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

  643.         if (!c->node->exists) {
  644.             c->node->uses = 1;
  645.             c->node->body_start = c->body_start;
  646.             c->node->exists = 1;
  647.             c->node->uniq = c->uniq;
  648.             c->node->fs_size = c->fs_size;

  650.             cache->sh->size += c->fs_size;
  651.         }

  653.         ngx_shmtx_unlock(&cache->shpool->mutex);
  654.     }

  656.     now = ngx_time();

  658.     if (c->valid_sec < now) {
  659.         c->stale_updating = c->valid_sec + c->updating_sec >= now;
  660.         c->stale_error = c->valid_sec + c->error_sec >= now;

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

  664.         if (c->node->updating) {
  665.             rc = NGX_HTTP_CACHE_UPDATING;

  667.         } else {
  668.             c->node->updating = 1;
  669.             c->updating = 1;
  670.             c->lock_time = c->node->lock_time;
  671.             rc = NGX_HTTP_CACHE_STALE;
  672.         }

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

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

  680.         return rc;
  681.     }

  683.     return NGX_OK;
  684. }


  687. static ssize_t
  688. ‌ngx_http_file_cache_aio_read(ngx_http_request_t *r, ngx_http_cache_t *c)
  689. {
  690. #if (NGX_HAVE_FILE_AIO || NGX_THREADS)
  691.     ssize_t                    n;
  692.     ngx_http_core_loc_conf_t  *clcf;

  694.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  695. #endif

  697. #if (NGX_HAVE_FILE_AIO)

  699.     if (clcf->aio == NGX_HTTP_AIO_ON && ngx_file_aio
  700.         && r->main->blocked < NGX_HTTP_MAX_BLOCKED)
  701.     {
  702.         n = ngx_file_aio_read(&c->file, c->buf->pos, c->body_start, 0, r->pool);

  704.         if (n != NGX_AGAIN) {
  705.             c->reading = 0;
  706.             return n;
  707.         }

  709.         c->reading = 1;

  711.         c->file.aio->data = r;
  712.         c->file.aio->handler = ngx_http_cache_aio_event_handler;

  714.         ngx_add_timer(&c->file.aio->event, 60000);

  716.         r->main->blocked++;
  717.         r->aio = 1;

  719.         return NGX_AGAIN;
  720.     }

  722. #endif

  724. #if (NGX_THREADS)

  726.     if (clcf->aio == NGX_HTTP_AIO_THREADS
  727.         && r->main->blocked < NGX_HTTP_MAX_BLOCKED)
  728.     {
  729.         c->file.thread_task = c->thread_task;
  730.         c->file.thread_handler = ngx_http_cache_thread_handler;
  731.         c->file.thread_ctx = r;

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

  735.         c->thread_task = c->file.thread_task;
  736.         c->reading = (n == NGX_AGAIN);

  738.         return n;
  739.     }

  741. #endif

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


  747. #if (NGX_HAVE_FILE_AIO)

  749. static void
  750. ‌ngx_http_cache_aio_event_handler(ngx_event_t *ev)
  751. {
  752.     ngx_event_aio_t     *aio;
  753.     ngx_connection_t    *c;
  754.     ngx_http_request_t  *r;

  756.     aio = ev->data;
  757.     r = aio->data;
  758.     c = r->connection;

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

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

  765.     if (ev->timedout) {
  766.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  767.                       "aio operation took too long");
  768.         ev->timedout = 0;
  769.         return;
  770.     }

  772.     if (ev->timer_set) {
  773.         ngx_del_timer(ev);
  774.     }

  776.     r->main->blocked--;
  777.     r->aio = 0;

  779.     if (r->main->terminated) {
  780.         /*
  781.          * trigger connection event handler if the request was
  782.          * terminated
  783.          */

  785.         c->write->handler(c->write);

  787.     } else {
  788.         r->write_event_handler(r);
  789.         ngx_http_run_posted_requests(c);
  790.     }
  791. }

  793. #endif


  796. #if (NGX_THREADS)

  798. static ngx_int_t
  799. ‌ngx_http_cache_thread_handler(ngx_thread_task_t *task, ngx_file_t *file)
  800. {
  801.     ngx_str_t                  name;
  802.     ngx_thread_pool_t         *tp;
  803.     ngx_http_request_t        *r;
  804.     ngx_http_core_loc_conf_t  *clcf;

  806.     r = file->thread_ctx;

  808.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
  809.     tp = clcf->thread_pool;

  811.     if (tp == NULL) {
  812.         if (ngx_http_complex_value(r, clcf->thread_pool_value, &name)
  813.             != NGX_OK)
  814.         {
  815.             return NGX_ERROR;
  816.         }

  818.         tp = ngx_thread_pool_get((ngx_cycle_t *) ngx_cycle, &name);

  820.         if (tp == NULL) {
  821.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  822.                           "thread pool \"%V\" not found", &name);
  823.             return NGX_ERROR;
  824.         }
  825.     }

  827.     task->event.data = r;
  828.     task->event.handler = ngx_http_cache_thread_event_handler;

  830.     if (ngx_thread_task_post(tp, task) != NGX_OK) {
  831.         return NGX_ERROR;
  832.     }

  834.     ngx_add_timer(&task->event, 60000);

  836.     r->main->blocked++;
  837.     r->aio = 1;

  839.     return NGX_OK;
  840. }


  843. static void
  844. ‌ngx_http_cache_thread_event_handler(ngx_event_t *ev)
  845. {
  846.     ngx_connection_t    *c;
  847.     ngx_http_request_t  *r;

  849.     r = ev->data;
  850.     c = r->connection;

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

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

  857.     if (ev->timedout) {
  858.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  859.                       "thread operation took too long");
  860.         ev->timedout = 0;
  861.         return;
  862.     }

  864.     if (ev->timer_set) {
  865.         ngx_del_timer(ev);
  866.     }

  868.     r->main->blocked--;
  869.     r->aio = 0;

  871.     if (r->main->terminated) {
  872.         /*
  873.          * trigger connection event handler if the request was
  874.          * terminated
  875.          */

  877.         c->write->handler(c->write);

  879.     } else {
  880.         r->write_event_handler(r);
  881.         ngx_http_run_posted_requests(c);
  882.     }
  883. }

  885. #endif


  888. static ngx_int_t
  889. ‌ngx_http_file_cache_exists(ngx_http_file_cache_t *cache, ngx_http_cache_t *c)
  890. {
  891.     ngx_int_t                    rc;
  892.     ngx_http_file_cache_node_t  *fcn;

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

  896.     fcn = c->node;

  898.     if (fcn == NULL) {
  899.         fcn = ngx_http_file_cache_lookup(cache, c->key);
  900.     }

  902.     if (fcn) {
  903.         ngx_queue_remove(&fcn->queue);

  905.         if (c->node == NULL) {
  906.             fcn->uses++;
  907.             fcn->count++;
  908.         }

  910.         if (fcn->error) {

  912.             if (fcn->valid_sec < ngx_time()) {
  913.                 goto renew;
  914.             }

  916.             rc = NGX_OK;

  918.             goto done;
  919.         }

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

  923.             c->exists = fcn->exists;
  924.             if (fcn->body_start && !c->update_variant) {
  925.                 c->body_start = fcn->body_start;
  926.             }

  928.             rc = NGX_OK;

  930.             goto done;
  931.         }

  933.         rc = NGX_AGAIN;

  935.         goto done;
  936.     }

  938.     fcn = ngx_slab_calloc_locked(cache->shpool,
  939.                                  sizeof(ngx_http_file_cache_node_t));
  940.     if (fcn == NULL) {
  941.         ngx_http_file_cache_set_watermark(cache);

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

  945.         (void) ngx_http_file_cache_forced_expire(cache);

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

  949.         fcn = ngx_slab_calloc_locked(cache->shpool,
  950.                                      sizeof(ngx_http_file_cache_node_t));
  951.         if (fcn == NULL) {
  952.             ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  953.                           "could not allocate node%s", cache->shpool->log_ctx);
  954.             rc = NGX_ERROR;
  955.             goto failed;
  956.         }
  957.     }

  959.     cache->sh->count++;

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

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

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

  968.     fcn->uses = 1;
  969.     fcn->count = 1;

  971. renew:

  973.     rc = NGX_DECLINED;

  975.     fcn->valid_msec = 0;
  976.     fcn->error = 0;
  977.     fcn->exists = 0;
  978.     fcn->valid_sec = 0;
  979.     fcn->uniq = 0;
  980.     fcn->body_start = 0;
  981.     fcn->fs_size = 0;

  983. done:

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

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

  989.     c->uniq = fcn->uniq;
  990.     c->error = fcn->error;
  991.     c->node = fcn;

  993. failed:

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

  997.     return rc;
  998. }


  1001. static ngx_int_t
  1002. ‌ngx_http_file_cache_name(ngx_http_request_t *r, ngx_path_t *path)
  1003. {
  1004.     u_char            *p;
  1005.     ngx_http_cache_t  *c;

  1007.     c = r->cache;

  1009.     if (c->file.name.len) {
  1010.         return NGX_OK;
  1011.     }

  1013.     c->file.name.len = path->name.len + 1 + path->len
  1014.                        + 2 * NGX_HTTP_CACHE_KEY_LEN;

  1016.     c->file.name.data = ngx_pnalloc(r->pool, c->file.name.len + 1);
  1017.     if (c->file.name.data == NULL) {
  1018.         return NGX_ERROR;
  1019.     }

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

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

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

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

  1032.     return NGX_OK;
  1033. }


  1036. static ngx_http_file_cache_node_t *
  1037. ‌ngx_http_file_cache_lookup(ngx_http_file_cache_t *cache, u_char *key)
  1038. {
  1039.     ngx_int_t                    rc;
  1040.     ngx_rbtree_key_t             node_key;
  1041.     ngx_rbtree_node_t           *node, *sentinel;
  1042.     ngx_http_file_cache_node_t  *fcn;

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

  1046.     node = cache->sh->rbtree.root;
  1047.     sentinel = cache->sh->rbtree.sentinel;

  1049.     while (node != sentinel) {

  1051.         if (node_key < node->key) {
  1052.             node = node->left;
  1053.             continue;
  1054.         }

  1056.         if (node_key > node->key) {
  1057.             node = node->right;
  1058.             continue;
  1059.         }

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

  1063.         fcn = (ngx_http_file_cache_node_t *) node;

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

  1068.         if (rc == 0) {
  1069.             return fcn;
  1070.         }

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

  1075.     /* not found */

  1077.     return NULL;
  1078. }


  1081. static void
  1082. ‌ngx_http_file_cache_rbtree_insert_value(ngx_rbtree_node_t *temp,
  1083.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  1084. {
  1085.     ngx_rbtree_node_t           **p;
  1086.     ngx_http_file_cache_node_t   *cn, *cnt;

  1088.     for ( ;; ) {

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

  1092.             p = &temp->left;

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

  1096.             p = &temp->right;

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

  1100.             cn = (ngx_http_file_cache_node_t *) node;
  1101.             cnt = (ngx_http_file_cache_node_t *) temp;

  1103.             p = (ngx_memcmp(cn->key, cnt->key,
  1104.                             NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t))
  1105.                  < 0)
  1106.                     ? &temp->left : &temp->right;
  1107.         }

  1109.         if (*p == sentinel) {
  1110.             break;
  1111.         }

  1113.         temp = *p;
  1114.     }

  1116.     *p = node;
  1117.     node->parent = temp;
  1118.     node->left = sentinel;
  1119.     node->right = sentinel;
  1120.     ngx_rbt_red(node);
  1121. }


  1124. static void
  1125. ‌ngx_http_file_cache_vary(ngx_http_request_t *r, u_char *vary, size_t len,
  1126.     u_char *hash)
  1127. {
  1128.     u_char     *p, *last;
  1129.     ngx_str_t   name;
  1130.     ngx_md5_t   md5;
  1131.     u_char      buf[NGX_HTTP_CACHE_VARY_LEN];

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

  1136.     ngx_md5_init(&md5);
  1137.     ngx_md5_update(&md5, r->cache->main, NGX_HTTP_CACHE_KEY_LEN);

  1139.     ngx_strlow(buf, vary, len);

  1141.     p = buf;
  1142.     last = buf + len;

  1144.     while (p < last) {

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

  1148.         name.data = p;

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

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

  1154.         if (name.len == 0) {
  1155.             break;
  1156.         }

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

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

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

  1166.         ngx_md5_update(&md5, (u_char *) CRLF, sizeof(CRLF) - 1);
  1167.     }

  1169.     ngx_md5_final(hash, &md5);
  1170. }


  1173. static void
  1174. ‌ngx_http_file_cache_vary_header(ngx_http_request_t *r, ngx_md5_t *md5,
  1175.     ngx_str_t *name)
  1176. {
  1177.     size_t            len;
  1178.     u_char           *p, *start, *last;
  1179.     ngx_uint_t        i, multiple, normalize;
  1180.     ngx_list_part_t  *part;
  1181.     ngx_table_elt_t  *header;

  1183.     multiple = 0;
  1184.     normalize = 0;

  1186.     if (name->len == sizeof("Accept-Charset") - 1
  1187.         && ngx_strncasecmp(name->data, (u_char *) "Accept-Charset",
  1188.                            sizeof("Accept-Charset") - 1) == 0)
  1189.     {
  1190.         normalize = 1;

  1192.     } else if (name->len == sizeof("Accept-Encoding") - 1
  1193.         && ngx_strncasecmp(name->data, (u_char *) "Accept-Encoding",
  1194.                            sizeof("Accept-Encoding") - 1) == 0)
  1195.     {
  1196.         normalize = 1;

  1198.     } else if (name->len == sizeof("Accept-Language") - 1
  1199.         && ngx_strncasecmp(name->data, (u_char *) "Accept-Language",
  1200.                            sizeof("Accept-Language") - 1) == 0)
  1201.     {
  1202.         normalize = 1;
  1203.     }

  1205.     part = &r->headers_in.headers.part;
  1206.     header = part->elts;

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

  1210.         if (i >= part->nelts) {
  1211.             if (part->next == NULL) {
  1212.                 break;
  1213.             }

  1215.             part = part->next;
  1216.             header = part->elts;
  1217.             i = 0;
  1218.         }

  1220.         if (header[i].hash == 0) {
  1221.             continue;
  1222.         }

  1224.         if (header[i].key.len != name->len) {
  1225.             continue;
  1226.         }

  1228.         if (ngx_strncasecmp(header[i].key.data, name->data, name->len) != 0) {
  1229.             continue;
  1230.         }

  1232.         if (!normalize) {

  1234.             if (multiple) {
  1235.                 ngx_md5_update(md5, (u_char *) ",", sizeof(",") - 1);
  1236.             }

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

  1240.             multiple = 1;

  1242.             continue;
  1243.         }

  1245.         /* normalize spaces */

  1247.         p = header[i].value.data;
  1248.         last = p + header[i].value.len;

  1250.         while (p < last) {

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

  1254.             start = p;

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

  1258.             len = p - start;

  1260.             if (len == 0) {
  1261.                 break;
  1262.             }

  1264.             if (multiple) {
  1265.                 ngx_md5_update(md5, (u_char *) ",", sizeof(",") - 1);
  1266.             }

  1268.             ngx_md5_update(md5, start, len);

  1270.             multiple = 1;
  1271.         }
  1272.     }
  1273. }


  1276. static ngx_int_t
  1277. ‌ngx_http_file_cache_reopen(ngx_http_request_t *r, ngx_http_cache_t *c)
  1278. {
  1279.     ngx_http_file_cache_t  *cache;

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

  1284.     if (c->secondary) {
  1285.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  1286.                       "cache file \"%s\" has incorrect vary hash",
  1287.                       c->file.name.data);
  1288.         return NGX_DECLINED;
  1289.     }

  1291.     cache = c->file_cache;

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

  1295.     c->node->count--;
  1296.     c->node = NULL;

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

  1300.     c->secondary = 1;
  1301.     c->file.name.len = 0;
  1302.     c->body_start = c->buffer_size;

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

  1306.     return ngx_http_file_cache_open(r);
  1307. }


  1310. ngx_int_t
  1311. ‌ngx_http_file_cache_set_header(ngx_http_request_t *r, u_char *buf)
  1312. {
  1313.     ngx_http_file_cache_header_t  *h = (ngx_http_file_cache_header_t *) buf;

  1315.     u_char            *p;
  1316.     ngx_str_t         *key;
  1317.     ngx_uint_t         i;
  1318.     ngx_http_cache_t  *c;

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

  1323.     c = r->cache;

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

  1327.     h->version = NGX_HTTP_CACHE_VERSION;
  1328.     h->valid_sec = c->valid_sec;
  1329.     h->updating_sec = c->updating_sec;
  1330.     h->error_sec = c->error_sec;
  1331.     h->last_modified = c->last_modified;
  1332.     h->date = c->date;
  1333.     h->crc32 = c->crc32;
  1334.     h->valid_msec = (u_short) c->valid_msec;
  1335.     h->header_start = (u_short) c->header_start;
  1336.     h->body_start = (u_short) c->body_start;

  1338.     if (c->etag.len <= NGX_HTTP_CACHE_ETAG_LEN) {
  1339.         h->etag_len = (u_char) c->etag.len;
  1340.         ngx_memcpy(h->etag, c->etag.data, c->etag.len);
  1341.     }

  1343.     if (c->vary.len) {
  1344.         if (c->vary.len > NGX_HTTP_CACHE_VARY_LEN) {
  1345.             /* should not happen */
  1346.             c->vary.len = NGX_HTTP_CACHE_VARY_LEN;
  1347.         }

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

  1352.         ngx_http_file_cache_vary(r, c->vary.data, c->vary.len, c->variant);
  1353.         ngx_memcpy(h->variant, c->variant, NGX_HTTP_CACHE_KEY_LEN);
  1354.     }

  1356.     if (ngx_http_file_cache_update_variant(r, c) != NGX_OK) {
  1357.         return NGX_ERROR;
  1358.     }

  1360.     p = buf + sizeof(ngx_http_file_cache_header_t);

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

  1364.     key = c->keys.elts;
  1365.     for (i = 0; i < c->keys.nelts; i++) {
  1366.         p = ngx_copy(p, key[i].data, key[i].len);
  1367.     }

  1369.     *p = LF;

  1371.     return NGX_OK;
  1372. }


  1375. static ngx_int_t
  1376. ‌ngx_http_file_cache_update_variant(ngx_http_request_t *r, ngx_http_cache_t *c)
  1377. {
  1378.     ngx_http_file_cache_t  *cache;

  1380.     if (!c->secondary) {
  1381.         return NGX_OK;
  1382.     }

  1384.     if (c->vary.len
  1385.         && ngx_memcmp(c->variant, c->key, NGX_HTTP_CACHE_KEY_LEN) == 0)
  1386.     {
  1387.         return NGX_OK;
  1388.     }

  1390.     /*
  1391.      * if the variant hash doesn't match one we used as a secondary
  1392.      * cache key, switch back to the original key
  1393.      */

  1395.     cache = c->file_cache;

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

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

  1402.     c->node->count--;
  1403.     c->node->updating = 0;
  1404.     c->node = NULL;

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

  1408.     c->file.name.len = 0;
  1409.     c->update_variant = 1;

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

  1413.     if (ngx_http_file_cache_exists(cache, c) == NGX_ERROR) {
  1414.         return NGX_ERROR;
  1415.     }

  1417.     if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) {
  1418.         return NGX_ERROR;
  1419.     }

  1421.     return NGX_OK;
  1422. }


  1425. void
  1426. ‌ngx_http_file_cache_update(ngx_http_request_t *r, ngx_temp_file_t *tf)
  1427. {
  1428.     off_t                   fs_size;
  1429.     ngx_int_t               rc;
  1430.     ngx_file_uniq_t         uniq;
  1431.     ngx_file_info_t         fi;
  1432.     ngx_http_cache_t        *c;
  1433.     ngx_ext_rename_file_t   ext;
  1434.     ngx_http_file_cache_t  *cache;

  1436.     c = r->cache;

  1438.     if (c->updated) {
  1439.         return;
  1440.     }

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

  1445.     cache = c->file_cache;

  1447.     c->updated = 1;
  1448.     c->updating = 0;

  1450.     uniq = 0;
  1451.     fs_size = 0;

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

  1457.     ext.access = NGX_FILE_OWNER_ACCESS;
  1458.     ext.path_access = NGX_FILE_OWNER_ACCESS;
  1459.     ext.time = -1;
  1460.     ext.create_path = 1;
  1461.     ext.delete_file = 1;
  1462.     ext.log = r->connection->log;

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

  1466.     if (rc == NGX_OK) {

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

  1472.             rc = NGX_ERROR;

  1474.         } else {
  1475.             uniq = ngx_file_uniq(&fi);
  1476.             fs_size = (ngx_file_fs_size(&fi) + cache->bsize - 1) / cache->bsize;
  1477.         }
  1478.     }

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

  1482.     c->node->count--;
  1483.     c->node->error = 0;
  1484.     c->node->uniq = uniq;
  1485.     c->node->body_start = c->body_start;

  1487.     cache->sh->size += fs_size - c->node->fs_size;
  1488.     c->node->fs_size = fs_size;

  1490.     if (rc == NGX_OK) {
  1491.         c->node->exists = 1;
  1492.     }

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

  1496.     ngx_shmtx_unlock(&cache->shpool->mutex);
  1497. }


  1500. void
  1501. ‌ngx_http_file_cache_update_header(ngx_http_request_t *r)
  1502. {
  1503.     ssize_t                        n;
  1504.     ngx_err_t                      err;
  1505.     ngx_file_t                     file;
  1506.     ngx_file_info_t                fi;
  1507.     ngx_http_cache_t              *c;
  1508.     ngx_http_file_cache_header_t   h;

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

  1513.     c = r->cache;

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

  1517.     file.name = c->file.name;
  1518.     file.log = r->connection->log;
  1519.     file.fd = ngx_open_file(file.name.data, NGX_FILE_RDWR, NGX_FILE_OPEN, 0);

  1521.     if (file.fd == NGX_INVALID_FILE) {
  1522.         err = ngx_errno;

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

  1526.         if (err == NGX_ENOENT) {
  1527.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1528.                            "http file cache \"%s\" not found",
  1529.                            file.name.data);
  1530.             return;
  1531.         }

  1533.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, err,
  1534.                       ngx_open_file_n " \"%s\" failed", file.name.data);
  1535.         return;
  1536.     }

  1538.     /*
  1539.      * make sure cache file wasn't replaced;
  1540.      * if it was, do nothing
  1541.      */

  1543.     if (ngx_fd_info(file.fd, &fi) == NGX_FILE_ERROR) {
  1544.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, ngx_errno,
  1545.                       ngx_fd_info_n " \"%s\" failed", file.name.data);
  1546.         goto done;
  1547.     }

  1549.     if (c->uniq != ngx_file_uniq(&fi)
  1550.         || c->length != ngx_file_size(&fi))
  1551.     {
  1552.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1553.                        "http file cache \"%s\" changed",
  1554.                        file.name.data);
  1555.         goto done;
  1556.     }

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

  1561.     if (n == NGX_ERROR) {
  1562.         goto done;
  1563.     }

  1565.     if ((size_t) n != sizeof(ngx_http_file_cache_header_t)) {
  1566.         ngx_log_error(NGX_LOG_CRIT, r->connection->log, 0,
  1567.                       ngx_read_file_n " read only %z of %z from \"%s\"",
  1568.                       n, sizeof(ngx_http_file_cache_header_t), file.name.data);
  1569.         goto done;
  1570.     }

  1572.     if (h.version != NGX_HTTP_CACHE_VERSION
  1573.         || h.last_modified != c->last_modified
  1574.         || h.crc32 != c->crc32
  1575.         || (size_t) h.header_start != c->header_start
  1576.         || (size_t) h.body_start != c->body_start)
  1577.     {
  1578.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1579.                        "http file cache \"%s\" content changed",
  1580.                        file.name.data);
  1581.         goto done;
  1582.     }

  1584.     /*
  1585.      * update cache file header with new data,
  1586.      * notably h.valid_sec and h.date
  1587.      */

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

  1591.     h.version = NGX_HTTP_CACHE_VERSION;
  1592.     h.valid_sec = c->valid_sec;
  1593.     h.updating_sec = c->updating_sec;
  1594.     h.error_sec = c->error_sec;
  1595.     h.last_modified = c->last_modified;
  1596.     h.date = c->date;
  1597.     h.crc32 = c->crc32;
  1598.     h.valid_msec = (u_short) c->valid_msec;
  1599.     h.header_start = (u_short) c->header_start;
  1600.     h.body_start = (u_short) c->body_start;

  1602.     if (c->etag.len <= NGX_HTTP_CACHE_ETAG_LEN) {
  1603.         h.etag_len = (u_char) c->etag.len;
  1604.         ngx_memcpy(h.etag, c->etag.data, c->etag.len);
  1605.     }

  1607.     if (c->vary.len) {
  1608.         if (c->vary.len > NGX_HTTP_CACHE_VARY_LEN) {
  1609.             /* should not happen */
  1610.             c->vary.len = NGX_HTTP_CACHE_VARY_LEN;
  1611.         }

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

  1616.         ngx_http_file_cache_vary(r, c->vary.data, c->vary.len, c->variant);
  1617.         ngx_memcpy(h.variant, c->variant, NGX_HTTP_CACHE_KEY_LEN);
  1618.     }

  1620.     (void) ngx_write_file(&file, (u_char *) &h,
  1621.                           sizeof(ngx_http_file_cache_header_t), 0);

  1623. done:

  1625.     if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
  1626.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, ngx_errno,
  1627.                       ngx_close_file_n " \"%s\" failed", file.name.data);
  1628.     }
  1629. }


  1632. ngx_int_t
  1633. ‌ngx_http_cache_send(ngx_http_request_t *r)
  1634. {
  1635.     ngx_int_t          rc;
  1636.     ngx_buf_t         *b;
  1637.     ngx_chain_t        out;
  1638.     ngx_http_cache_t  *c;

  1640.     c = r->cache;

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

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

  1647.     b = ngx_calloc_buf(r->pool);
  1648.     if (b == NULL) {
  1649.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1650.     }

  1652.     b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
  1653.     if (b->file == NULL) {
  1654.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  1655.     }

  1657.     rc = ngx_http_send_header(r);

  1659.     if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
  1660.         return rc;
  1661.     }

  1663.     b->file_pos = c->body_start;
  1664.     b->file_last = c->length;

  1666.     b->in_file = (c->length - c->body_start) ? 1 : 0;
  1667.     b->last_buf = (r == r->main) ? 1 : 0;
  1668.     b->last_in_chain = 1;
  1669.     b->sync = (b->last_buf || b->in_file) ? 0 : 1;

  1671.     b->file->fd = c->file.fd;
  1672.     b->file->name = c->file.name;
  1673.     b->file->log = r->connection->log;

  1675.     out.buf = b;
  1676.     out.next = NULL;

  1678.     return ngx_http_output_filter(r, &out);
  1679. }


  1682. void
  1683. ‌ngx_http_file_cache_free(ngx_http_cache_t *c, ngx_temp_file_t *tf)
  1684. {
  1685.     ngx_http_file_cache_t       *cache;
  1686.     ngx_http_file_cache_node_t  *fcn;

  1688.     if (c->updated || c->node == NULL) {
  1689.         return;
  1690.     }

  1692.     cache = c->file_cache;

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

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

  1699.     fcn = c->node;
  1700.     fcn->count--;

  1702.     if (c->updating && fcn->lock_time == c->lock_time) {
  1703.         fcn->updating = 0;
  1704.     }

  1706.     if (c->error) {
  1707.         fcn->error = c->error;

  1709.         if (c->valid_sec) {
  1710.             fcn->valid_sec = c->valid_sec;
  1711.             fcn->valid_msec = c->valid_msec;
  1712.         }

  1714.     } else if (!fcn->exists && fcn->count == 0 && c->min_uses == 1) {
  1715.         ngx_queue_remove(&fcn->queue);
  1716.         ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
  1717.         ngx_slab_free_locked(cache->shpool, fcn);
  1718.         cache->sh->count--;
  1719.         c->node = NULL;
  1720.     }

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

  1724.     c->updated = 1;
  1725.     c->updating = 0;

  1727.     if (c->temp_file) {
  1728.         if (tf && tf->file.fd != NGX_INVALID_FILE) {
  1729.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->file.log, 0,
  1730.                            "http file cache incomplete: \"%s\"",
  1731.                            tf->file.name.data);

  1733.             if (ngx_delete_file(tf->file.name.data) == NGX_FILE_ERROR) {
  1734.                 ngx_log_error(NGX_LOG_CRIT, c->file.log, ngx_errno,
  1735.                               ngx_delete_file_n " \"%s\" failed",
  1736.                               tf->file.name.data);
  1737.             }
  1738.         }
  1739.     }

  1741.     if (c->wait_event.timer_set) {
  1742.         ngx_del_timer(&c->wait_event);
  1743.     }
  1744. }


  1747. static void
  1748. ‌ngx_http_file_cache_cleanup(void *data)
  1749. {
  1750.     ngx_http_cache_t  *c = data;

  1752.     if (c->updated) {
  1753.         return;
  1754.     }

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

  1759.     if (c->updating && !c->background) {
  1760.         ngx_log_error(NGX_LOG_ALERT, c->file.log, 0,
  1761.                       "stalled cache updating, error:%ui", c->error);
  1762.     }

  1764.     ngx_http_file_cache_free(c, NULL);
  1765. }


  1768. static time_t
  1769. ‌ngx_http_file_cache_forced_expire(ngx_http_file_cache_t *cache)
  1770. {
  1771.     u_char                      *name, *p;
  1772.     size_t                       len;
  1773.     time_t                       wait;
  1774.     ngx_uint_t                   tries;
  1775.     ngx_path_t                  *path;
  1776.     ngx_queue_t                 *q, *sentinel;
  1777.     ngx_http_file_cache_node_t  *fcn;
  1778.     u_char                       key[2 * NGX_HTTP_CACHE_KEY_LEN];

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

  1783.     path = cache->path;
  1784.     len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;

  1786.     name = ngx_alloc(len + 1, ngx_cycle->log);
  1787.     if (name == NULL) {
  1788.         return 10;
  1789.     }

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

  1793.     wait = 10;
  1794.     tries = 20;
  1795.     sentinel = NULL;

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

  1799.     for ( ;; ) {
  1800.         if (ngx_queue_empty(&cache->sh->queue)) {
  1801.             break;
  1802.         }

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

  1806.         if (q == sentinel) {
  1807.             break;
  1808.         }

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

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

  1817.         if (fcn->count == 0) {
  1818.             ngx_http_file_cache_delete(cache, q, name);
  1819.             wait = 0;
  1820.             break;
  1821.         }

  1823.         if (fcn->deleting) {
  1824.             wait = 1;
  1825.             break;
  1826.         }

  1828.         p = ngx_hex_dump(key, (u_char *) &fcn->node.key,
  1829.                          sizeof(ngx_rbtree_key_t));
  1830.         len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
  1831.         (void) ngx_hex_dump(p, fcn->key, len);

  1833.         /*
  1834.          * abnormally exited workers may leave locked cache entries,
  1835.          * and although it may be safe to remove them completely,
  1836.          * we prefer to just move them to the top of the inactive queue
  1837.          */

  1839.         ngx_queue_remove(q);
  1840.         fcn->expire = ngx_time() + cache->inactive;
  1841.         ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);

  1843.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  1844.                       "ignore long locked inactive cache entry %*s, count:%d",
  1845.                       (size_t) 2 * NGX_HTTP_CACHE_KEY_LEN, key, fcn->count);

  1847.         if (sentinel == NULL) {
  1848.             sentinel = q;
  1849.         }

  1851.         if (--tries) {
  1852.             continue;
  1853.         }

  1855.         wait = 1;
  1856.         break;
  1857.     }

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

  1861.     ngx_free(name);

  1863.     return wait;
  1864. }


  1867. static time_t
  1868. ‌ngx_http_file_cache_expire(ngx_http_file_cache_t *cache)
  1869. {
  1870.     u_char                      *name, *p;
  1871.     size_t                       len;
  1872.     time_t                       now, wait;
  1873.     ngx_path_t                  *path;
  1874.     ngx_msec_t                   elapsed;
  1875.     ngx_queue_t                 *q;
  1876.     ngx_http_file_cache_node_t  *fcn;
  1877.     u_char                       key[2 * NGX_HTTP_CACHE_KEY_LEN];

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

  1882.     path = cache->path;
  1883.     len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;

  1885.     name = ngx_alloc(len + 1, ngx_cycle->log);
  1886.     if (name == NULL) {
  1887.         return 10;
  1888.     }

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

  1892.     now = ngx_time();

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

  1896.     for ( ;; ) {

  1898.         if (ngx_quit || ngx_terminate) {
  1899.             wait = 1;
  1900.             break;
  1901.         }

  1903.         if (ngx_queue_empty(&cache->sh->queue)) {
  1904.             wait = 10;
  1905.             break;
  1906.         }

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

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

  1912.         wait = fcn->expire - now;

  1914.         if (wait > 0) {
  1915.             wait = wait > 10 ? 10 : wait;
  1916.             break;
  1917.         }

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

  1924.         if (fcn->count == 0) {
  1925.             ngx_http_file_cache_delete(cache, q, name);
  1926.             goto next;
  1927.         }

  1929.         if (fcn->deleting) {
  1930.             wait = 1;
  1931.             break;
  1932.         }

  1934.         p = ngx_hex_dump(key, (u_char *) &fcn->node.key,
  1935.                          sizeof(ngx_rbtree_key_t));
  1936.         len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
  1937.         (void) ngx_hex_dump(p, fcn->key, len);

  1939.         /*
  1940.          * abnormally exited workers may leave locked cache entries,
  1941.          * and although it may be safe to remove them completely,
  1942.          * we prefer to just move them to the top of the inactive queue
  1943.          */

  1945.         ngx_queue_remove(q);
  1946.         fcn->expire = ngx_time() + cache->inactive;
  1947.         ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);

  1949.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  1950.                       "ignore long locked inactive cache entry %*s, count:%d",
  1951.                       (size_t) 2 * NGX_HTTP_CACHE_KEY_LEN, key, fcn->count);

  1953. next:

  1955.         if (++cache->files >= cache->manager_files) {
  1956.             wait = 0;
  1957.             break;
  1958.         }

  1960.         ngx_time_update();

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

  1964.         if (elapsed >= cache->manager_threshold) {
  1965.             wait = 0;
  1966.             break;
  1967.         }
  1968.     }

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

  1972.     ngx_free(name);

  1974.     return wait;
  1975. }


  1978. static void
  1979. ‌ngx_http_file_cache_delete(ngx_http_file_cache_t *cache, ngx_queue_t *q,
  1980.     u_char *name)
  1981. {
  1982.     u_char                      *p;
  1983.     size_t                       len;
  1984.     ngx_path_t                  *path;
  1985.     ngx_http_file_cache_node_t  *fcn;

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

  1989.     if (fcn->exists) {
  1990.         cache->sh->size -= fcn->fs_size;

  1992.         path = cache->path;
  1993.         p = name + path->name.len + 1 + path->len;
  1994.         p = ngx_hex_dump(p, (u_char *) &fcn->node.key,
  1995.                          sizeof(ngx_rbtree_key_t));
  1996.         len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
  1997.         p = ngx_hex_dump(p, fcn->key, len);
  1998.         *p = '\0';

  2000.         fcn->count++;
  2001.         fcn->deleting = 1;
  2002.         ngx_shmtx_unlock(&cache->shpool->mutex);

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

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

  2010.         if (ngx_delete_file(name) == NGX_FILE_ERROR) {
  2011.             ngx_log_error(NGX_LOG_CRIT, ngx_cycle->log, ngx_errno,
  2012.                           ngx_delete_file_n " \"%s\" failed", name);
  2013.         }

  2015.         ngx_shmtx_lock(&cache->shpool->mutex);
  2016.         fcn->count--;
  2017.         fcn->deleting = 0;
  2018.     }

  2020.     if (fcn->count == 0) {
  2021.         ngx_queue_remove(q);
  2022.         ngx_rbtree_delete(&cache->sh->rbtree, &fcn->node);
  2023.         ngx_slab_free_locked(cache->shpool, fcn);
  2024.         cache->sh->count--;
  2025.     }
  2026. }


  2029. static ngx_msec_t
  2030. ‌ngx_http_file_cache_manager(void *data)
  2031. {
  2032.     ngx_http_file_cache_t  *cache = data;

  2034.     off_t       size, free;
  2035.     time_t      wait;
  2036.     ngx_msec_t  elapsed, next;
  2037.     ngx_uint_t  count, watermark;

  2039.     cache->last = ngx_current_msec;
  2040.     cache->files = 0;

  2042.     next = (ngx_msec_t) ngx_http_file_cache_expire(cache) * 1000;

  2044.     if (next == 0) {
  2045.         next = cache->manager_sleep;
  2046.         goto done;
  2047.     }

  2049.     for ( ;; ) {
  2050.         ngx_shmtx_lock(&cache->shpool->mutex);

  2052.         size = cache->sh->size;
  2053.         count = cache->sh->count;
  2054.         watermark = cache->sh->watermark;

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

  2058.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  2059.                        "http file cache size: %O c:%ui w:%i",
  2060.                        size, count, (ngx_int_t) watermark);

  2062.         if (size < cache->max_size && count < watermark) {

  2064.             if (!cache->min_free) {
  2065.                 break;
  2066.             }

  2068.             free = ngx_fs_available(cache->path->name.data);

  2070.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  2071.                            "http file cache free: %O", free);

  2073.             if (free > cache->min_free) {
  2074.                 break;
  2075.             }
  2076.         }

  2078.         wait = ngx_http_file_cache_forced_expire(cache);

  2080.         if (wait > 0) {
  2081.             next = (ngx_msec_t) wait * 1000;
  2082.             break;
  2083.         }

  2085.         if (ngx_quit || ngx_terminate) {
  2086.             break;
  2087.         }

  2089.         if (++cache->files >= cache->manager_files) {
  2090.             next = cache->manager_sleep;
  2091.             break;
  2092.         }

  2094.         ngx_time_update();

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

  2098.         if (elapsed >= cache->manager_threshold) {
  2099.             next = cache->manager_sleep;
  2100.             break;
  2101.         }
  2102.     }

  2104. done:

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

  2108.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  2109.                    "http file cache manager: %ui e:%M n:%M",
  2110.                    cache->files, elapsed, next);

  2112.     return next;
  2113. }


  2116. static void
  2117. ‌ngx_http_file_cache_loader(void *data)
  2118. {
  2119.     ngx_http_file_cache_t  *cache = data;

  2121.     ngx_tree_ctx_t  tree;

  2123.     if (!cache->sh->cold || cache->sh->loading) {
  2124.         return;
  2125.     }

  2127.     if (!ngx_atomic_cmp_set(&cache->sh->loading, 0, ngx_pid)) {
  2128.         return;
  2129.     }

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

  2134.     tree.init_handler = NULL;
  2135.     tree.file_handler = ngx_http_file_cache_manage_file;
  2136.     tree.pre_tree_handler = ngx_http_file_cache_manage_directory;
  2137.     tree.post_tree_handler = ngx_http_file_cache_noop;
  2138.     tree.spec_handler = ngx_http_file_cache_delete_file;
  2139.     tree.data = cache;
  2140.     tree.alloc = 0;
  2141.     tree.log = ngx_cycle->log;

  2143.     cache->last = ngx_current_msec;
  2144.     cache->files = 0;

  2146.     if (ngx_walk_tree(&tree, &cache->path->name) == NGX_ABORT) {
  2147.         cache->sh->loading = 0;
  2148.         return;
  2149.     }

  2151.     cache->sh->cold = 0;
  2152.     cache->sh->loading = 0;

  2154.     ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0,
  2155.                   "http file cache: %V %.3fM, bsize: %uz",
  2156.                   &cache->path->name,
  2157.                   ((double) cache->sh->size * cache->bsize) / (1024 * 1024),
  2158.                   cache->bsize);
  2159. }


  2162. static ngx_int_t
  2163. ‌ngx_http_file_cache_noop(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  2164. {
  2165.     return NGX_OK;
  2166. }


  2169. static ngx_int_t
  2170. ‌ngx_http_file_cache_manage_file(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  2171. {
  2172.     ngx_msec_t              elapsed;
  2173.     ngx_http_file_cache_t  *cache;

  2175.     cache = ctx->data;

  2177.     if (ngx_http_file_cache_add_file(ctx, path) != NGX_OK) {
  2178.         (void) ngx_http_file_cache_delete_file(ctx, path);
  2179.     }

  2181.     if (++cache->files >= cache->loader_files) {
  2182.         ngx_http_file_cache_loader_sleep(cache);

  2184.     } else {
  2185.         ngx_time_update();

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

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

  2192.         if (elapsed >= cache->loader_threshold) {
  2193.             ngx_http_file_cache_loader_sleep(cache);
  2194.         }
  2195.     }

  2197.     return (ngx_quit || ngx_terminate) ? NGX_ABORT : NGX_OK;
  2198. }


  2201. static ngx_int_t
  2202. ‌ngx_http_file_cache_manage_directory(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  2203. {
  2204.     if (path->len >= 5
  2205.         && ngx_strncmp(path->data + path->len - 5, "/temp", 5) == 0)
  2206.     {
  2207.         return NGX_DECLINED;
  2208.     }

  2210.     return NGX_OK;
  2211. }


  2214. static void
  2215. ‌ngx_http_file_cache_loader_sleep(ngx_http_file_cache_t *cache)
  2216. {
  2217.     ngx_msleep(cache->loader_sleep);

  2219.     ngx_time_update();

  2221.     cache->last = ngx_current_msec;
  2222.     cache->files = 0;
  2223. }


  2226. static ngx_int_t
  2227. ‌ngx_http_file_cache_add_file(ngx_tree_ctx_t *ctx, ngx_str_t *name)
  2228. {
  2229.     u_char                 *p;
  2230.     ngx_int_t               n;
  2231.     ngx_uint_t              i;
  2232.     ngx_http_cache_t        c;
  2233.     ngx_http_file_cache_t  *cache;

  2235.     if (name->len < 2 * NGX_HTTP_CACHE_KEY_LEN) {
  2236.         return NGX_ERROR;
  2237.     }

  2239.     /*
  2240.      * Temporary files in cache have a suffix consisting of a dot
  2241.      * followed by 10 digits.
  2242.      */

  2244.     if (name->len >= 2 * NGX_HTTP_CACHE_KEY_LEN + 1 + 10
  2245.         && name->data[name->len - 10 - 1] == '.')
  2246.     {
  2247.         return NGX_OK;
  2248.     }

  2250.     if (ctx->size < (off_t) sizeof(ngx_http_file_cache_header_t)) {
  2251.         ngx_log_error(NGX_LOG_CRIT, ctx->log, 0,
  2252.                       "cache file \"%s\" is too small", name->data);
  2253.         return NGX_ERROR;
  2254.     }

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

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

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

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

  2267.         if (n == NGX_ERROR) {
  2268.             return NGX_ERROR;
  2269.         }

  2271.         p += 2;

  2273.         c.key[i] = (u_char) n;
  2274.     }

  2276.     return ngx_http_file_cache_add(cache, &c);
  2277. }


  2280. static ngx_int_t
  2281. ‌ngx_http_file_cache_add(ngx_http_file_cache_t *cache, ngx_http_cache_t *c)
  2282. {
  2283.     ngx_http_file_cache_node_t  *fcn;

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

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

  2289.     if (fcn == NULL) {

  2291.         fcn = ngx_slab_calloc_locked(cache->shpool,
  2292.                                      sizeof(ngx_http_file_cache_node_t));
  2293.         if (fcn == NULL) {
  2294.             ngx_http_file_cache_set_watermark(cache);

  2296.             if (cache->fail_time != ngx_time()) {
  2297.                 cache->fail_time = ngx_time();
  2298.                 ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  2299.                            "could not allocate node%s", cache->shpool->log_ctx);
  2300.             }

  2302.             ngx_shmtx_unlock(&cache->shpool->mutex);
  2303.             return NGX_ERROR;
  2304.         }

  2306.         cache->sh->count++;

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

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

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

  2315.         fcn->uses = 1;
  2316.         fcn->exists = 1;
  2317.         fcn->fs_size = c->fs_size;

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

  2321.     } else {
  2322.         ngx_queue_remove(&fcn->queue);
  2323.     }

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

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

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

  2331.     return NGX_OK;
  2332. }


  2335. static ngx_int_t
  2336. ‌ngx_http_file_cache_delete_file(ngx_tree_ctx_t *ctx, ngx_str_t *path)
  2337. {
  2338.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->log, 0,
  2339.                    "http file cache delete: \"%s\"", path->data);

  2341.     if (ngx_delete_file(path->data) == NGX_FILE_ERROR) {
  2342.         ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
  2343.                       ngx_delete_file_n " \"%s\" failed", path->data);
  2344.     }

  2346.     return NGX_OK;
  2347. }


  2350. static void
  2351. ‌ngx_http_file_cache_set_watermark(ngx_http_file_cache_t *cache)
  2352. {
  2353.     cache->sh->watermark = cache->sh->count - cache->sh->count / 8;

  2355.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
  2356.                    "http file cache watermark: %ui", cache->sh->watermark);
  2357. }


  2360. time_t
  2361. ‌ngx_http_file_cache_valid(ngx_array_t *cache_valid, ngx_uint_t status)
  2362. {
  2363.     ngx_uint_t               i;
  2364.     ngx_http_cache_valid_t  *valid;

  2366.     if (cache_valid == NULL) {
  2367.         return 0;
  2368.     }

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

  2373.         if (valid[i].status == 0) {
  2374.             return valid[i].valid;
  2375.         }

  2377.         if (valid[i].status == status) {
  2378.             return valid[i].valid;
  2379.         }
  2380.     }

  2382.     return 0;
  2383. }


  2386. char *
  2387. ‌ngx_http_file_cache_set_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  2388. {
  2389.     char  *confp = conf;

  2391.     off_t                   max_size, min_free;
  2392.     u_char                 *last, *p;
  2393.     time_t                  inactive;
  2394.     ssize_t                 size;
  2395.     ngx_str_t               s, name, *value;
  2396.     ngx_int_t               loader_files, manager_files;
  2397.     ngx_msec_t              loader_sleep, manager_sleep, loader_threshold,
  2398.                             manager_threshold;
  2399.     ngx_uint_t              i, n, use_temp_path;
  2400.     ngx_array_t            *caches;
  2401.     ngx_http_file_cache_t  *cache, **ce;

  2403.     cache = ngx_pcalloc(cf->pool, sizeof(ngx_http_file_cache_t));
  2404.     if (cache == NULL) {
  2405.         return NGX_CONF_ERROR;
  2406.     }

  2408.     cache->path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
  2409.     if (cache->path == NULL) {
  2410.         return NGX_CONF_ERROR;
  2411.     }

  2413.     use_temp_path = 1;

  2415.     inactive = 600;

  2417.     loader_files = 100;
  2418.     loader_sleep = 50;
  2419.     loader_threshold = 200;

  2421.     manager_files = 100;
  2422.     manager_sleep = 50;
  2423.     manager_threshold = 200;

  2425.     name.len = 0;
  2426.     size = 0;
  2427.     max_size = NGX_MAX_OFF_T_VALUE;
  2428.     min_free = 0;

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

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

  2434.     if (cache->path->name.data[cache->path->name.len - 1] == '/') {
  2435.         cache->path->name.len--;
  2436.     }

  2438.     if (ngx_conf_full_name(cf->cycle, &cache->path->name, 0) != NGX_OK) {
  2439.         return NGX_CONF_ERROR;
  2440.     }

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

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

  2446.             p = value[i].data + 7;
  2447.             last = value[i].data + value[i].len;

  2449.             for (n = 0; n < NGX_MAX_PATH_LEVEL && p < last; n++) {

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

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

  2456.                     if (p == last) {
  2457.                         break;
  2458.                     }

  2460.                     if (*p++ == ':' && n < NGX_MAX_PATH_LEVEL - 1 && p < last) {
  2461.                         continue;
  2462.                     }

  2464.                     goto invalid_levels;
  2465.                 }

  2467.                 goto invalid_levels;
  2468.             }

  2470.             if (cache->path->len < 10 + NGX_MAX_PATH_LEVEL) {
  2471.                 continue;
  2472.             }

  2474.         invalid_levels:

  2476.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2477.                                "invalid \"levels\" \"%V\"", &value[i]);
  2478.             return NGX_CONF_ERROR;
  2479.         }

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

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

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

  2489.             } else {
  2490.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2491.                                    "invalid use_temp_path value \"%V\", "
  2492.                                    "it must be \"on\" or \"off\"",
  2493.                                    &value[i]);
  2494.                 return NGX_CONF_ERROR;
  2495.             }

  2497.             continue;
  2498.         }

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

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

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

  2506.             if (p == NULL) {
  2507.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2508.                                    "invalid keys zone size \"%V\"", &value[i]);
  2509.                 return NGX_CONF_ERROR;
  2510.             }

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

  2514.             s.data = p + 1;
  2515.             s.len = value[i].data + value[i].len - s.data;

  2517.             size = ngx_parse_size(&s);

  2519.             if (size == NGX_ERROR) {
  2520.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2521.                                    "invalid keys zone size \"%V\"", &value[i]);
  2522.                 return NGX_CONF_ERROR;
  2523.             }

  2525.             if (size < (ssize_t) (2 * ngx_pagesize)) {
  2526.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2527.                                    "keys zone \"%V\" is too small", &value[i]);
  2528.                 return NGX_CONF_ERROR;
  2529.             }

  2531.             continue;
  2532.         }

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

  2536.             s.len = value[i].len - 9;
  2537.             s.data = value[i].data + 9;

  2539.             inactive = ngx_parse_time(&s, 1);
  2540.             if (inactive == (time_t) NGX_ERROR) {
  2541.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2542.                                    "invalid inactive value \"%V\"", &value[i]);
  2543.                 return NGX_CONF_ERROR;
  2544.             }

  2546.             continue;
  2547.         }

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

  2551.             s.len = value[i].len - 9;
  2552.             s.data = value[i].data + 9;

  2554.             max_size = ngx_parse_offset(&s);
  2555.             if (max_size < 0) {
  2556.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2557.                                    "invalid max_size value \"%V\"", &value[i]);
  2558.                 return NGX_CONF_ERROR;
  2559.             }

  2561.             continue;
  2562.         }

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

  2566. #if (NGX_WIN32 || NGX_HAVE_STATFS || NGX_HAVE_STATVFS)

  2568.             s.len = value[i].len - 9;
  2569.             s.data = value[i].data + 9;

  2571.             min_free = ngx_parse_offset(&s);
  2572.             if (min_free < 0) {
  2573.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2574.                                    "invalid min_free value \"%V\"", &value[i]);
  2575.                 return NGX_CONF_ERROR;
  2576.             }

  2578. #else
  2579.             ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  2580.                                "min_free is not supported "
  2581.                                "on this platform, ignored");
  2582. #endif

  2584.             continue;
  2585.         }

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

  2589.             loader_files = ngx_atoi(value[i].data + 13, value[i].len - 13);
  2590.             if (loader_files == NGX_ERROR) {
  2591.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2592.                            "invalid loader_files value \"%V\"", &value[i]);
  2593.                 return NGX_CONF_ERROR;
  2594.             }

  2596.             continue;
  2597.         }

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

  2601.             s.len = value[i].len - 13;
  2602.             s.data = value[i].data + 13;

  2604.             loader_sleep = ngx_parse_time(&s, 0);
  2605.             if (loader_sleep == (ngx_msec_t) NGX_ERROR) {
  2606.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2607.                            "invalid loader_sleep value \"%V\"", &value[i]);
  2608.                 return NGX_CONF_ERROR;
  2609.             }

  2611.             continue;
  2612.         }

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

  2616.             s.len = value[i].len - 17;
  2617.             s.data = value[i].data + 17;

  2619.             loader_threshold = ngx_parse_time(&s, 0);
  2620.             if (loader_threshold == (ngx_msec_t) NGX_ERROR) {
  2621.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2622.                            "invalid loader_threshold value \"%V\"", &value[i]);
  2623.                 return NGX_CONF_ERROR;
  2624.             }

  2626.             continue;
  2627.         }

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

  2631.             manager_files = ngx_atoi(value[i].data + 14, value[i].len - 14);
  2632.             if (manager_files == NGX_ERROR) {
  2633.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2634.                            "invalid manager_files value \"%V\"", &value[i]);
  2635.                 return NGX_CONF_ERROR;
  2636.             }

  2638.             continue;
  2639.         }

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

  2643.             s.len = value[i].len - 14;
  2644.             s.data = value[i].data + 14;

  2646.             manager_sleep = ngx_parse_time(&s, 0);
  2647.             if (manager_sleep == (ngx_msec_t) NGX_ERROR) {
  2648.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2649.                            "invalid manager_sleep value \"%V\"", &value[i]);
  2650.                 return NGX_CONF_ERROR;
  2651.             }

  2653.             continue;
  2654.         }

  2656.         if (ngx_strncmp(value[i].data, "manager_threshold=", 18) == 0) {

  2658.             s.len = value[i].len - 18;
  2659.             s.data = value[i].data + 18;

  2661.             manager_threshold = ngx_parse_time(&s, 0);
  2662.             if (manager_threshold == (ngx_msec_t) NGX_ERROR) {
  2663.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2664.                            "invalid manager_threshold value \"%V\"", &value[i]);
  2665.                 return NGX_CONF_ERROR;
  2666.             }

  2668.             continue;
  2669.         }

  2671.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2672.                            "invalid parameter \"%V\"", &value[i]);
  2673.         return NGX_CONF_ERROR;
  2674.     }

  2676.     if (name.len == 0 || size == 0) {
  2677.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2678.                            "\"%V\" must have \"keys_zone\" parameter",
  2679.                            &cmd->name);
  2680.         return NGX_CONF_ERROR;
  2681.     }

  2683.     cache->path->manager = ngx_http_file_cache_manager;
  2684.     cache->path->loader = ngx_http_file_cache_loader;
  2685.     cache->path->data = cache;
  2686.     cache->path->conf_file = cf->conf_file->file.name.data;
  2687.     cache->path->line = cf->conf_file->line;
  2688.     cache->loader_files = loader_files;
  2689.     cache->loader_sleep = loader_sleep;
  2690.     cache->loader_threshold = loader_threshold;
  2691.     cache->manager_files = manager_files;
  2692.     cache->manager_sleep = manager_sleep;
  2693.     cache->manager_threshold = manager_threshold;

  2695.     if (ngx_add_path(cf, &cache->path) != NGX_OK) {
  2696.         return NGX_CONF_ERROR;
  2697.     }

  2699.     cache->shm_zone = ngx_shared_memory_add(cf, &name, size, cmd->post);
  2700.     if (cache->shm_zone == NULL) {
  2701.         return NGX_CONF_ERROR;
  2702.     }

  2704.     if (cache->shm_zone->data) {
  2705.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2706.                            "duplicate zone \"%V\"", &name);
  2707.         return NGX_CONF_ERROR;
  2708.     }


  2711.     cache->shm_zone->init = ngx_http_file_cache_init;
  2712.     cache->shm_zone->data = cache;

  2714.     cache->use_temp_path = use_temp_path;

  2716.     cache->inactive = inactive;
  2717.     cache->max_size = max_size;
  2718.     cache->min_free = min_free;

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

  2722.     ce = ngx_array_push(caches);
  2723.     if (ce == NULL) {
  2724.         return NGX_CONF_ERROR;
  2725.     }

  2727.     *ce = cache;

  2729.     return NGX_CONF_OK;
  2730. }


  2733. char *
  2734. ‌ngx_http_file_cache_valid_set_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  2735.     void *conf)
  2736. {
  2737.     char  *p = conf;

  2739.     time_t                    valid;
  2740.     ngx_str_t                *value;
  2741.     ngx_int_t                 status;
  2742.     ngx_uint_t                i, n;
  2743.     ngx_array_t             **a;
  2744.     ngx_http_cache_valid_t   *v;
  2745.     static ngx_uint_t         statuses[] = { 200, 301, 302 };

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

  2749.     if (*a == NGX_CONF_UNSET_PTR) {
  2750.         *a = ngx_array_create(cf->pool, 1, sizeof(ngx_http_cache_valid_t));
  2751.         if (*a == NULL) {
  2752.             return NGX_CONF_ERROR;
  2753.         }
  2754.     }

  2756.     value = cf->args->elts;
  2757.     n = cf->args->nelts - 1;

  2759.     valid = ngx_parse_time(&value[n], 1);
  2760.     if (valid == (time_t) NGX_ERROR) {
  2761.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2762.                            "invalid time value \"%V\"", &value[n]);
  2763.         return NGX_CONF_ERROR;
  2764.     }

  2766.     if (n == 1) {

  2768.         for (i = 0; i < 3; i++) {
  2769.             v = ngx_array_push(*a);
  2770.             if (v == NULL) {
  2771.                 return NGX_CONF_ERROR;
  2772.             }

  2774.             v->status = statuses[i];
  2775.             v->valid = valid;
  2776.         }

  2778.         return NGX_CONF_OK;
  2779.     }

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

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

  2785.             status = 0;

  2787.         } else {

  2789.             status = ngx_atoi(value[i].data, value[i].len);
  2790.             if (status < 100 || status > 599) {
  2791.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  2792.                                    "invalid status \"%V\"", &value[i]);
  2793.                 return NGX_CONF_ERROR;
  2794.             }
  2795.         }

  2797.         v = ngx_array_push(*a);
  2798.         if (v == NULL) {
  2799.             return NGX_CONF_ERROR;
  2800.         }

  2802.         v->status = status;
  2803.         v->valid = valid;
  2804.     }

  2806.     return NGX_CONF_OK;
  2807. }

One Level Up Top Level