/* Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/*

 * htcacheclean.c: simple program for cleaning of

 * the disk cache of the Apache HTTP server

 *

 * Contributed by Andreas Steinmetz <ast domdv.de>

 * 8 Oct 2004

 */

#include "apr.h"

#include "apr_lib.h"

#include "apr_strings.h"

#include "apr_file_io.h"

#include "apr_file_info.h"

#include "apr_pools.h"

#include "apr_hash.h"

#include "apr_thread_proc.h"

#include "apr_signal.h"

#include "apr_getopt.h"

#include "apr_md5.h"

#include "apr_ring.h"

#include "apr_date.h"

#include "apr_buckets.h"

#include "../modules/cache/cache_common.h"

#include "../modules/cache/cache_disk_common.h"

#if APR_HAVE_UNISTD_H

#include <unistd.h>

#endif

#if APR_HAVE_STDLIB_H

#include <stdlib.h>

#endif

/* define the following for debugging */

#undef DEBUG

/*

 * Note: on Linux delays <= 2ms are busy waits without

 *       scheduling, so never use a delay <= 2ms below

 */

#define NICE_DELAY    10000     /* usecs */

#define DELETE_NICE   10        /* be nice after this amount of delete ops */

#define STAT_ATTEMPTS 10        /* maximum stat attempts for a file */

#define STAT_DELAY    5000      /* usecs */

#define HEADER        1         /* headers file */

#define DATA          2         /* body file */

#define TEMP          4         /* temporary file */

#define HEADERDATA    (HEADER|DATA)

#define MAXDEVIATION  3600      /* secs */

#define SECS_PER_MIN  60

#define KBYTE         1024

#define MBYTE         1048576

#define GBYTE         1073741824

#define DIRINFO (APR_FINFO_MTIME|APR_FINFO_SIZE|APR_FINFO_TYPE|APR_FINFO_LINK)

typedef struct _direntry {

    APR_RING_ENTRY(_direntry) link;

    int type;         /* type of file/fileset: TEMP, HEADER, DATA, HEADERDATA */

    apr_time_t htime; /* headers file modification time */

    apr_time_t dtime; /* body file modification time */

    apr_off_t hsize;  /* headers file size */

    apr_off_t dsize;  /* body or temporary file size */

    char *basename;   /* file/fileset base name */

} DIRENTRY;

typedef struct _entry {

    APR_RING_ENTRY(_entry) link;

    apr_time_t expire;        /* cache entry exiration time */

    apr_time_t response_time; /* cache entry time of last response to client */

    apr_time_t htime;         /* headers file modification time */

    apr_time_t dtime;         /* body file modification time */

    apr_off_t hsize;          /* headers file size */

    apr_off_t dsize;          /* body or temporary file size */

    char *basename;           /* fileset base name */

} ENTRY;

static int delcount;    /* file deletion count for nice mode */

static int interrupted; /* flag: true if SIGINT or SIGTERM occurred */

static int realclean;   /* flag: true means user said apache is not running */

static int verbose;     /* flag: true means print statistics */

static int benice;      /* flag: true means nice mode is activated */

static int dryrun;      /* flag: true means dry run, don't actually delete

                                 anything */

static int deldirs;     /* flag: true means directories should be deleted */

static int listurls;    /* flag: true means list cached urls */

static int listextended;/* flag: true means list cached urls */

static int baselen;     /* string length of the path to the proxy directory */

static apr_time_t now;  /* start time of this processing run */

static apr_file_t *errfile;   /* stderr file handle */

static apr_file_t *outfile;   /* stdout file handle */

static apr_off_t unsolicited; /* file size summary for deleted unsolicited

                                 files */

static APR_RING_ENTRY(_entry) root; /* ENTRY ring anchor */

/* short program name as called */

static const char *shortname = "htcacheclean";

/* what did we clean? */

struct stats {

    apr_off_t total;

    apr_off_t sum;

    apr_off_t max;

    apr_off_t ntotal;

    apr_off_t nodes;

    apr_off_t inodes;

    apr_off_t etotal;

    apr_off_t entries;

    apr_off_t dfuture;

    apr_off_t dexpired;

    apr_off_t dfresh;

};

#ifdef DEBUG

/*

 * fake delete for debug purposes

 */

#define apr_file_remove fake_file_remove

static void fake_file_remove(char *pathname, apr_pool_t *p)

{

    apr_finfo_t info;

    /* stat and printing to simulate some deletion system load and to

       display what would actually have happened */

    apr_stat(&info, pathname, DIRINFO, p);

    apr_file_printf(errfile, "would delete %s" APR_EOL_STR, pathname);

}

#endif

/*

 * called on SIGINT or SIGTERM

 */

static void setterm(int unused)

{

#ifdef DEBUG

    apr_file_printf(errfile, "interrupt" APR_EOL_STR);

#endif

    interrupted = 1;

}

/*

 * called in out of memory condition

 */

static int oom(int unused)

{

    static int called = 0;

    /* be careful to call exit() only once */

    if (!called) {

        called = 1;

        exit(1);

    }

    return APR_ENOMEM;

}

/*

 * print purge statistics

 */

static void printstats(char *path, struct stats *s)

{

    char ttype, stype, mtype, utype;

    apr_off_t tfrag, sfrag, ufrag;

    if (!verbose) {

        return;

    }

    ttype = 'K';

    tfrag = ((s->total * 10) / KBYTE) % 10;

    s->total /= KBYTE;

    if (s->total >= KBYTE) {

        ttype = 'M';

        tfrag = ((s->total * 10) / KBYTE) % 10;

        s->total /= KBYTE;

    }

    stype = 'K';

    sfrag = ((s->sum * 10) / KBYTE) % 10;

    s->sum /= KBYTE;

    if (s->sum >= KBYTE) {

        stype = 'M';

        sfrag = ((s->sum * 10) / KBYTE) % 10;

        s->sum /= KBYTE;

    }

    mtype = 'K';

    s->max /= KBYTE;

    if (s->max >= KBYTE) {

        mtype = 'M';

        s->max /= KBYTE;

    }

    apr_file_printf(errfile, "Cleaned %s. Statistics:" APR_EOL_STR, path);

    if (unsolicited) {

        utype = 'K';

        ufrag = ((unsolicited * 10) / KBYTE) % 10;

        unsolicited /= KBYTE;

        if (unsolicited >= KBYTE) {

            utype = 'M';

            ufrag = ((unsolicited * 10) / KBYTE) % 10;

            unsolicited /= KBYTE;

        }

        if (!unsolicited && !ufrag) {

            ufrag = 1;

        }

        apr_file_printf(errfile, "unsolicited size %d.%d%c" APR_EOL_STR,

                        (int)(unsolicited), (int)(ufrag), utype);

    }

    apr_file_printf(errfile, "size limit %" APR_OFF_T_FMT ".0%c" APR_EOL_STR,

            s->max, mtype);

    apr_file_printf(errfile, "inodes limit %" APR_OFF_T_FMT APR_EOL_STR,

            s->inodes);

    apr_file_printf(

            errfile,

            "total size was %" APR_OFF_T_FMT ".%" APR_OFF_T_FMT "%c, total size now "

            "%" APR_OFF_T_FMT ".%" APR_OFF_T_FMT "%c" APR_EOL_STR, s->total,

            tfrag, ttype, s->sum, sfrag, stype);

    apr_file_printf(errfile, "total inodes was %" APR_OFF_T_FMT

            ", total %sinodes now "

            "%" APR_OFF_T_FMT APR_EOL_STR, s->ntotal, dryrun && deldirs ? "estimated "

            : "", s->nodes);

    apr_file_printf(

            errfile,

            "total entries was %" APR_OFF_T_FMT ", total entries now %" APR_OFF_T_FMT

            APR_EOL_STR, s->etotal, s->entries);

    apr_file_printf(

            errfile,

            "%" APR_OFF_T_FMT " entries deleted (%" APR_OFF_T_FMT " from future, %"

            APR_OFF_T_FMT " expired, %" APR_OFF_T_FMT " fresh)" APR_EOL_STR,

            (s->etotal - s->entries), s->dfuture, s->dexpired, s->dfresh);

}

/**

 * Round the value up to the given threshold.

 */

static apr_size_t round_up(apr_size_t val, apr_off_t round) {

    if (round > 1) {

        return (apr_size_t)(((val + round - 1) / round) * round);

    }

    return val;

}

/*

 * delete parent directories

 */

static void delete_parent(const char *path, const char *basename,

        apr_off_t *nodes, apr_pool_t *pool)

{

    char *nextpath, *name;

    apr_pool_t *p;

    /* temp pool, otherwise lots of memory could be allocated */

    apr_pool_create(&p, pool);

    name = apr_pstrdup(p, basename);

    /* If asked to delete dirs, do so now. We don't care if it fails.

     * If it fails, it likely means there was something else there.

     */

    if (deldirs && !dryrun) {

        const char *vary;

        char *end = strrchr(name, '/');

        while (end) {

            *end = 0;

            /* remove the directory */

            nextpath = apr_pstrcat(p, path, "/", name, NULL);

            if (!apr_dir_remove(nextpath, p)) {

                (*nodes)--;

                /* vary directory found? */

                vary = strstr(name, CACHE_VDIR_SUFFIX);

                if (vary && !vary[sizeof(CACHE_VDIR_SUFFIX) - 1]) {

                    nextpath = apr_pstrcat(p, path, "/", apr_pstrndup(p, name, vary

                            - name), NULL);

                    if (!apr_file_remove(nextpath, p)) {

                        (*nodes)--;

                    }

                }

            }

            else {

                break;

            }

            end = strrchr(name, '/');

        }

    }

    apr_pool_destroy(p);

    if (benice) {

        if (++delcount >= DELETE_NICE) {

            apr_sleep(NICE_DELAY);

            delcount = 0;

        }

    }

}

/*

 * delete a single file

 */

static void delete_file(char *path, char *basename, apr_off_t *nodes,

        apr_pool_t *pool)

{

    char *nextpath;

    apr_pool_t *p;

    /* temp pool, otherwise lots of memory could be allocated */

    apr_pool_create(&p, pool);

    nextpath = apr_pstrcat(p, path, "/", basename, NULL);

    if (dryrun) {

        apr_finfo_t finfo;

        if (!apr_stat(&finfo, nextpath, APR_FINFO_NLINK, p)) {

            (*nodes)--;

        }

    }

    else if (!apr_file_remove(nextpath, p)) {

        (*nodes)--;

    }

    apr_pool_destroy(p);

    if (benice) {

        if (++delcount >= DELETE_NICE) {

            apr_sleep(NICE_DELAY);

            delcount = 0;

        }

    }

    delete_parent(path, basename, nodes, pool);

}

/*

 * delete cache file set

 */

static void delete_entry(char *path, char *basename, apr_off_t *nodes,

        apr_pool_t *pool)

{

    char *nextpath;

    apr_pool_t *p;

    /* temp pool, otherwise lots of memory could be allocated */

    apr_pool_create(&p, pool);

    nextpath = apr_pstrcat(p, path, "/", basename, CACHE_HEADER_SUFFIX, NULL);

    if (dryrun) {

        apr_finfo_t finfo;

        if (!apr_stat(&finfo, nextpath, APR_FINFO_NLINK, p)) {

            (*nodes)--;

        }

    }

    else if (!apr_file_remove(nextpath, p)) {

        (*nodes)--;

    }

    nextpath = apr_pstrcat(p, path, "/", basename, CACHE_DATA_SUFFIX, NULL);

    if (dryrun) {

        apr_finfo_t finfo;

        if (!apr_stat(&finfo, nextpath, APR_FINFO_NLINK, p)) {

            (*nodes)--;

        }

    }

    else if (!apr_file_remove(nextpath, p)) {

        (*nodes)--;

    }

    apr_pool_destroy(p);

    if (benice) {

        delcount += 2;

        if (delcount >= DELETE_NICE) {

            apr_sleep(NICE_DELAY);

            delcount = 0;

        }

    }

    delete_parent(path, basename, nodes, pool);

}

/*

 * list the cache directory tree

 */

static int list_urls(char *path, apr_pool_t *pool, apr_off_t round)

{

    apr_dir_t *dir;

    apr_finfo_t info;

    apr_size_t len;

    apr_pool_t *p;

    apr_file_t *fd;

    const char *ext, *nextpath;

    char *url;

    apr_uint32_t format;

    disk_cache_info_t disk_info;

    apr_pool_create(&p, pool);

    if (apr_dir_open(&dir, path, p) != APR_SUCCESS) {

        return 1;

    }

    while (apr_dir_read(&info, APR_FINFO_TYPE, dir) == APR_SUCCESS && !interrupted) {

        if (info.filetype == APR_DIR) {

            if (!strcmp(info.name, ".") || !strcmp(info.name, "..")) {

                continue;

            }

            if (list_urls(apr_pstrcat(p, path, "/", info.name, NULL), pool, round)) {

                return 1;

            }

        }

        else if (info.filetype == APR_REG) {

            ext = strchr(info.name, '.');

            if (ext && !strcasecmp(ext, CACHE_HEADER_SUFFIX)) {

                nextpath = apr_pstrcat(p, path, "/", info.name, NULL);

                if (apr_file_open(&fd, nextpath, APR_FOPEN_READ

                        | APR_FOPEN_BINARY, APR_OS_DEFAULT, p) == APR_SUCCESS) {

                    len = sizeof(format);

                    if (apr_file_read_full(fd, &format, len, &len)

                            == APR_SUCCESS) {

                        if (format == DISK_FORMAT_VERSION) {

                            apr_off_t offset = 0;

                            apr_file_seek(fd, APR_SET, &offset);

                            len = sizeof(disk_cache_info_t);

                            if (apr_file_read_full(fd, &disk_info, len, &len)

                                    == APR_SUCCESS) {

                                len = disk_info.name_len;

                                url = apr_palloc(p, len + 1);

                                url[len] = 0;

                                if (apr_file_read_full(fd, url, len, &len)

                                        == APR_SUCCESS) {

                                    if (listextended) {

                                        apr_finfo_t hinfo, dinfo;

                                        /* stat the header file */

                                        if (APR_SUCCESS != apr_file_info_get(

                                                &hinfo, APR_FINFO_SIZE, fd)) {

                                            /* ignore the file */

                                        }

                                        else if (disk_info.has_body && APR_SUCCESS

                                                != apr_stat(

                                                        &dinfo,

                                                        apr_pstrcat(

                                                                p,

                                                                path,

                                                                "/",

                                                                apr_pstrndup(

                                                                        p,

                                                                        info.name,

                                                                        ext

                                                                                - info.name),

                                                                CACHE_DATA_SUFFIX,

                                                                NULL),

                                                        APR_FINFO_SIZE

                                                                | APR_FINFO_IDENT,

                                                        p)) {

                                            /* ignore the file */

                                        }

                                        else if (disk_info.has_body && (dinfo.device

                                                != disk_info.device

                                                || dinfo.inode

                                                        != disk_info.inode)) {

                                            /* ignore the file */

                                        }

                                        else {

                                            apr_file_printf(

                                                    outfile,

                                                    "%s %" APR_SIZE_T_FMT

                                                    " %" APR_SIZE_T_FMT

                                                    " %d %" APR_SIZE_T_FMT

                                                    " %" APR_TIME_T_FMT

                                                    " %" APR_TIME_T_FMT

                                                    " %" APR_TIME_T_FMT

                                                    " %" APR_TIME_T_FMT

                                                    " %d %d\n",

                                                    url,

                                                    round_up((apr_size_t)hinfo.size, round),

                                                    round_up(

                                                            disk_info.has_body ? (apr_size_t)dinfo.size

                                                                    : 0, round),

                                                    disk_info.status,

                                                    disk_info.entity_version,

                                                    disk_info.date,

                                                    disk_info.expire,

                                                    disk_info.request_time,

                                                    disk_info.response_time,

                                                    disk_info.has_body,

                                                    disk_info.header_only);

                                        }

                                    }

                                    else {

                                        apr_finfo_t dinfo;

                                        /* stat the data file */

                                        if (disk_info.has_body && APR_SUCCESS

                                                != apr_stat(

                                                        &dinfo,

                                                        apr_pstrcat(

                                                                p,

                                                                path,

                                                                "/",

                                                                apr_pstrndup(

                                                                        p,

                                                                        info.name,

                                                                        ext

                                                                                - info.name),

                                                                CACHE_DATA_SUFFIX,

                                                                NULL),

                                                        APR_FINFO_SIZE

                                                                | APR_FINFO_IDENT,

                                                        p)) {

                                            /* ignore the file */

                                        }

                                        else if (disk_info.has_body && (dinfo.device

                                                != disk_info.device

                                                || dinfo.inode

                                                        != disk_info.inode)) {

                                            /* ignore the file */

                                        }

                                        else {

                                            apr_file_printf(outfile, "%s\n",

                                                    url);

                                        }

                                    }

                                }

                                break;

                            }

                        }

                    }

                    apr_file_close(fd);

                }

            }

        }

    }

    apr_dir_close(dir);

    if (interrupted) {

        return 1;

    }

    apr_pool_destroy(p);

    if (benice) {

        apr_sleep(NICE_DELAY);

    }

    if (interrupted) {

        return 1;

    }

    return 0;

}

/*

 * walk the cache directory tree

 */

static int process_dir(char *path, apr_pool_t *pool, apr_off_t *nodes)

{

    apr_dir_t *dir;

    apr_pool_t *p;

    apr_hash_t *h;

    apr_hash_index_t *i;

    apr_file_t *fd;

    apr_status_t status;

    apr_finfo_t info;

    apr_size_t len;

    apr_time_t current, deviation;

    char *nextpath, *base, *ext;

    APR_RING_ENTRY(_direntry) anchor;

    DIRENTRY *d, *t, *n;

    ENTRY *e;

    int skip, retries;

    disk_cache_info_t disk_info;

    APR_RING_INIT(&anchor, _direntry, link);

    apr_pool_create(&p, pool);

    h = apr_hash_make(p);

    fd = NULL;

    deviation = MAXDEVIATION * APR_USEC_PER_SEC;

    if (apr_dir_open(&dir, path, p) != APR_SUCCESS) {

        return 1;

    }

    while (apr_dir_read(&info, 0, dir) == APR_SUCCESS && !interrupted) {

        if (!strcmp(info.name, ".") || !strcmp(info.name, "..")) {

            continue;

        }

        d = apr_pcalloc(p, sizeof(DIRENTRY));

        d->basename = apr_pstrcat(p, path, "/", info.name, NULL);

        APR_RING_INSERT_TAIL(&anchor, d, _direntry, link);

        (*nodes)++;

    }

    apr_dir_close(dir);

    if (interrupted) {

        return 1;

    }

    skip = baselen + 1;

    for (d = APR_RING_FIRST(&anchor);

         !interrupted && d != APR_RING_SENTINEL(&anchor, _direntry, link);

         d=n) {

        n = APR_RING_NEXT(d, link);

        base = strrchr(d->basename, '/');

        if (!base++) {

            base = d->basename;

        }

        ext = strchr(base, '.');

        /* there may be temporary files which may be gone before

         * processing, always skip these if not in realclean mode

         */

        if (!ext && !realclean) {

            if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)

                && strlen(base) == AP_TEMPFILE_NAMELEN) {

                continue;

            }

        }

        /* this may look strange but apr_stat() may return an error which

         * is system dependent and there may be transient failures,

         * so just blindly retry for a short while

         */

        retries = STAT_ATTEMPTS;

        status = APR_SUCCESS;

        do {

            if (status != APR_SUCCESS) {

                apr_sleep(STAT_DELAY);

            }

            status = apr_stat(&info, d->basename, DIRINFO, p);

        } while (status != APR_SUCCESS && !interrupted && --retries);

        /* what may happen here is that apache did create a file which

         * we did detect but then does delete the file before we can

         * get file information, so if we don't get any file information

         * we will ignore the file in this case

         */

        if (status != APR_SUCCESS) {

            if (!realclean && !interrupted) {

                continue;

            }

            return 1;

        }

        if (info.filetype == APR_DIR) {

            if (process_dir(d->basename, pool, nodes)) {

                return 1;

            }

            continue;

        }

        if (info.filetype != APR_REG) {

            continue;

        }

        if (!ext) {

            if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)

                && strlen(base) == AP_TEMPFILE_NAMELEN) {

                d->basename += skip;

                d->type = TEMP;

                d->dsize = info.size;

                apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);

            }

            continue;

        }

        if (!strcasecmp(ext, CACHE_HEADER_SUFFIX)) {

            *ext = '\0';

            d->basename += skip;

            /* if a user manually creates a '.header' file */

            if (d->basename[0] == '\0') {

                continue;

            }

            t = apr_hash_get(h, d->basename, APR_HASH_KEY_STRING);

            if (t) {

                d = t;

            }

            d->type |= HEADER;

            d->htime = info.mtime;

            d->hsize = info.size;

            apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);

            continue;

        }

        if (!strcasecmp(ext, CACHE_DATA_SUFFIX)) {

            *ext = '\0';

            d->basename += skip;

            /* if a user manually creates a '.data' file */

            if (d->basename[0] == '\0') {

                continue;

            }

            t = apr_hash_get(h, d->basename, APR_HASH_KEY_STRING);

            if (t) {

                d = t;

            }

            d->type |= DATA;

            d->dtime = info.mtime;

            d->dsize = info.size;

            apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);

        }

    }

    if (interrupted) {

        return 1;

    }

    path[baselen] = '\0';

    for (i = apr_hash_first(p, h); i && !interrupted; i = apr_hash_next(i)) {

        void *hvalue;

        apr_uint32_t format;

        apr_hash_this(i, NULL, NULL, &hvalue);

        d = hvalue;

        switch(d->type) {

        case HEADERDATA:

            nextpath = apr_pstrcat(p, path, "/", d->basename,

                                   CACHE_HEADER_SUFFIX, NULL);

            if (apr_file_open(&fd, nextpath, APR_FOPEN_READ | APR_FOPEN_BINARY,

                              APR_OS_DEFAULT, p) == APR_SUCCESS) {

                len = sizeof(format);

                if (apr_file_read_full(fd, &format, len,

                                       &len) == APR_SUCCESS) {

                    if (format == DISK_FORMAT_VERSION) {

                        apr_off_t offset = 0;

                        apr_file_seek(fd, APR_SET, &offset);

                        len = sizeof(disk_cache_info_t);

                        if (apr_file_read_full(fd, &disk_info, len,

                                               &len) == APR_SUCCESS) {

                            apr_file_close(fd);

                            e = apr_palloc(pool, sizeof(ENTRY));

                            APR_RING_INSERT_TAIL(&root, e, _entry, link);

                            e->expire = disk_info.expire;

                            e->response_time = disk_info.response_time;

                            e->htime = d->htime;

                            e->dtime = d->dtime;

                            e->hsize = d->hsize;

                            e->dsize = d->dsize;

                            e->basename = apr_pstrdup(pool, d->basename);

                            if (!disk_info.has_body) {

                                delete_file(path, apr_pstrcat(p, path, "/",

                                        d->basename, CACHE_DATA_SUFFIX, NULL),

                                        nodes, p);

                            }

                            break;

                        }

                        else {

                            apr_file_close(fd);

                        }

                    }

                    else if (format == VARY_FORMAT_VERSION) {

                        apr_finfo_t finfo;

                        /* This must be a URL that added Vary headers later,

                         * so kill the orphaned .data file

                         */

                        apr_file_close(fd);

                        if (apr_stat(&finfo, apr_pstrcat(p, nextpath,

                                CACHE_VDIR_SUFFIX, NULL), APR_FINFO_TYPE, p)

                                || finfo.filetype != APR_DIR) {

                            delete_entry(path, d->basename, nodes, p);

                        }

                        else {

                            delete_file(path, apr_pstrcat(p, path, "/",

                                    d->basename, CACHE_DATA_SUFFIX, NULL),

                                    nodes, p);

                        }

                        break;

                    }

                    else {

                        /* We didn't recognise the format, kill the files */

                        apr_file_close(fd);

                        delete_entry(path, d->basename, nodes, p);

                        break;

                    }

                }

                else {

                    apr_file_close(fd);

                }

            }

            /* we have a somehow unreadable headers file which is associated

             * with a data file. this may be caused by apache currently

             * rewriting the headers file. thus we may delete the file set

             * either in realclean mode or if the headers file modification

             * timestamp is not within a specified positive or negative offset

             * to the current time.

             */

            current = apr_time_now();

            if (realclean || d->htime < current - deviation

                || d->htime > current + deviation) {

                delete_entry(path, d->basename, nodes, p);

                unsolicited += d->hsize;

                unsolicited += d->dsize;

            }

            break;

        /* single data and header files may be deleted either in realclean

         * mode or if their modification timestamp is not within a

         * specified positive or negative offset to the current time.

         * this handling is necessary due to possible race conditions

         * between apache and this process

         */

        case HEADER:

            current = apr_time_now();

            nextpath = apr_pstrcat(p, path, "/", d->basename,

                                   CACHE_HEADER_SUFFIX, NULL);

            if (apr_file_open(&fd, nextpath, APR_FOPEN_READ | APR_FOPEN_BINARY,

                              APR_OS_DEFAULT, p) == APR_SUCCESS) {

                len = sizeof(format);

                if (apr_file_read_full(fd, &format, len,

                                       &len) == APR_SUCCESS) {

                    if (format == VARY_FORMAT_VERSION) {

                        apr_time_t expires;

                        len = sizeof(expires);

                        if (apr_file_read_full(fd, &expires, len,

                                               &len) == APR_SUCCESS) {

                            apr_finfo_t finfo;

                            apr_file_close(fd);

                            if (apr_stat(&finfo, apr_pstrcat(p, nextpath,

                                    CACHE_VDIR_SUFFIX, NULL), APR_FINFO_TYPE, p)

                                    || finfo.filetype != APR_DIR) {

                                delete_entry(path, d->basename, nodes, p);

                            }

                            else if (expires < current) {

                                delete_entry(path, d->basename, nodes, p);

                            }

                            break;

                        }