Attachment #20558 for bug #39380

View | Details | Raw Unified | Return to bug 39380
Collapse All | Expand All




apr_status_t cache_generate_key_default(request_rec *r, apr_pool_t* p,
                                        char**key)
{
    cache_request_rec *cache;
    char *port_str, *hn, *lcs;
    const char *hostname, *scheme;
    int i;

    cache = (cache_request_rec *) ap_get_module_config(r->request_config,
                                                       &cache_module);
    if (!cache) {
        /* This should never happen */
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
                     "cache: No cache request information available for key"
                     " generation");
        *key = "";
        return APR_EGENERAL;
    }
    if (cache->key) {
        /*
         * We have been here before during the processing of this request.
         * So return the key we already have.
         */
        *key = apr_pstrdup(p, cache->key);
        return APR_SUCCESS;
    }

    /*
     * Use the canonical name to improve cache hit rate, but only if this is
     * not a proxy request or if this is a reverse proxy request.

    *key = apr_pstrcat(p, scheme, "://", hostname, port_str,
                       r->parsed_uri.path, "?", r->args, NULL);

    /*
     * Store the key in the request_config for the cache as r->parsed_uri
     * might have changed in the time from our first visit here triggered by the
     * quick handler and our possible second visit triggered by the CACHE_SAVE
     * filter (e.g. r->parsed_uri got unescaped). In this case we would save the
     * resource in the cache under a key where it is never found by the quick
     * handler during following requests.
     */
    cache->key = apr_pstrdup(r->pool, *key);

    return APR_SUCCESS;
}




    age = ap_cache_current_age(info, age_c, r->request_time);

    /* extract s-maxage */
    if (cc_cresp && ap_cache_liststr(r->pool, cc_cresp, "s-maxage", &val)
        && val != NULL) {
        smaxage = apr_atoi64(val);
    }
    else {


    /* extract max-age from request */
    if (!conf->ignorecachecontrol
        && cc_req && ap_cache_liststr(r->pool, cc_req, "max-age", &val)
        && val != NULL) {
        maxage_req = apr_atoi64(val);
    }
    else {

    }

    /* extract max-age from response */
    if (cc_cresp && ap_cache_liststr(r->pool, cc_cresp, "max-age", &val)
        && val != NULL) {
        maxage_cresp = apr_atoi64(val);
    }
    else {


    /* extract max-stale */
    if (cc_req && ap_cache_liststr(r->pool, cc_req, "max-stale", &val)) {
        if(val != NULL) {
            maxstale = apr_atoi64(val);
        }
        else {
            /* If no value is assigned to max-stale, then the client is willing
             * to accept a stale response of any age */
            /* Let's pretend 100 years is enough, need margin some marging here
             * or the freshness calculation later will overflow */
            maxstale = APR_INT64_C(86400*365*100);
        }
    }
    else {
        maxstale = 0;


    /* extract min-fresh */
    if (!conf->ignorecachecontrol
        && cc_req && ap_cache_liststr(r->pool, cc_req, "min-fresh", &val)
        && val != NULL) {
        minfresh = apr_atoi64(val);
    }
    else {

                                                  next - val_start);
                        }
                    }
                    else {
                        *val = NULL;
                    }
                }
                return 1;
            }




         */
        reason = "No Last-Modified, Etag, or Expires headers";
    }
    else if (r->header_only && !cache->stale_handle) {
        /* HEAD requests */
        reason = "HTTP HEAD request";
    }

            cache->provider->remove_entity(cache->stale_handle);
            /* Treat the request as if it wasn't conditional. */
            cache->stale_handle = NULL;
            rv = !OK;
        }
    }

    /* no cache handle, create a new entity only for non-HEAD request */
    if (!cache->handle && !r->header_only) {
        rv = cache_create_entity(r, size);
        info = apr_pcalloc(r->pool, sizeof(cache_info));
        /* We only set info->status upon the initial creation. */

Lines 231-236 Link Here

(-)dist/modules/cache/mod_cache.h (+3 lines)
231	apr_time_t lastmod; /* last-modified time */	231	apr_time_t lastmod; /* last-modified time */
232	cache_info info; / current cache info */	232	cache_info info; / current cache info */
233	ap_filter_t remove_url_filter; / Enable us to remove the filter */	233	ap_filter_t remove_url_filter; / Enable us to remove the filter */
		234	char key; / The cache key created for this
		235	* request
		236	*/
234	} cache_request_rec;	237	} cache_request_rec;
235		238
236		239




#include "util_filter.h"
#include "util_script.h"
#include "util_charset.h"
#include "ap_mpm.h"
#include "mpm_common.h"

/*
 * mod_disk_cache: Disk Based HTTP 1.1 Cache.
 *
 * Flow to Find the right cache file:
 *   Incoming client requests an URL
 *   Generate <hash>.header from URL
 *   Open <hash>.header
 *   Read in <hash>.header file format identifier, which might be:
 *      VARY_FORMAT_VERSION - Vary headers
 *      DISK_FORMAT_VERSION - Metadata and headers for a cached file
 *      Anything else       - Unknown header format, remove and return.
 *      re-read in <hash>.header (must be format #2)
 *   read in <hash>.data
 *
 *   If VARY_FORMAT_VERSION (Contains a list of Vary Headers):
 *      Use each header name with our request values (headers_in) to
 *      regenerate <hash>.header using HeaderName+HeaderValue+URL,
 *      open it, read format (must be DISK_FORMAT_VERSION).
 *
 * VARY_FORMAT_VERSION:
 *   apr_uint32_t format;
 *   apr_time_t expire;
 *   apr_array_t vary_headers (delimited by CRLF)
 *
 * DISK_FORMAT_VERSION:
 *   disk_cache_info_t
 *   entity name (dobj->name) [length is in disk_cache_info_t->name_len]
 *   bodyfile (dobj->bodyfile) [length is in disk_cache_info_t->bodyname_len]
 *   optional filename (r->filename)
 *                      [length is in disk_cache_info_t->filename_len]
 *   r->headers_out (see on disk header format below)
 *   r->headers_in
 *
 * On disk headers are stored in the following format:
 *   apr_uint32_t totsize; - size of headers to follow
 *   totsize amount of headers, HeaderA\0ValueA\0...HeaderN\0ValueN\0
 */

module AP_MODULE_DECLARE_DATA disk_cache_module;

static apr_status_t read_array(request_rec *r, apr_array_header_t* arr,
                               apr_file_t *file);

/*
 * Local static functions
 */

#define CACHE_LOOP_INCTIME(x) x <<= 1
#define CACHE_LOOP_DECTIME(x) x >>= 1

static void cache_loop_sleep(apr_interval_time_t *t) {

    if(*t < CACHE_LOOP_MINSLEEP) {
        *t = CACHE_LOOP_MINSLEEP;
    }
    else if(*t > CACHE_LOOP_MAXSLEEP) {
        *t = CACHE_LOOP_MAXSLEEP;
    }

    apr_sleep(*t);
        return apr_pstrcat(p, dobj->prefix, CACHE_VDIR_SUFFIX, "/",
                           dobj->hashfile, CACHE_HEADER_SUFFIX, NULL);
     }
     else {
        return apr_pstrcat(p, conf->cache_root, "/", dobj->hashfile,
                           CACHE_HEADER_SUFFIX, NULL);
     }
}


/*
 * Modified file bucket implementation to be able to deliver files
 * while caching.
 */

/* Derived from apr_buckets_file.c */

#define BUCKET_IS_DISKCACHE(e)        ((e)->type == &bucket_type_diskcache)
static const apr_bucket_type_t bucket_type_diskcache;

static void diskcache_bucket_destroy(void *data)
{
    diskcache_bucket_data *f = data;
        dobj->hashfile = ap_cache_generate_name(p, conf->dirlevels,
                                                conf->dirlength, name);
    }

    if (apr_bucket_shared_destroy(f)) {
        /* no need to close files here; it will get
         * done automatically when the pool gets cleaned up */
        apr_bucket_free(f);
    }
        return apr_pstrcat(p, conf->cache_root, "/", dobj->hashfile,
                           CACHE_DATA_SUFFIX, NULL);
     }
}


/* The idea here is to convert diskcache buckets to regular file buckets
   as data becomes available */
static apr_status_t diskcache_bucket_read(apr_bucket *e, const char **str,
                                          apr_size_t *len, 
                                          apr_read_type_e block)
{
    diskcache_bucket_data *a = e->data;
    apr_file_t *f = a->fd;
    apr_bucket *b = NULL;
    char *buf;
    apr_status_t rv;
    apr_finfo_t finfo;
    apr_size_t filelength = e->length; /* bytes remaining in file past offset */
    apr_off_t fileoffset = e->start;
    apr_size_t available;
    apr_time_t start = apr_time_now();
#if APR_HAS_THREADS && !APR_HAS_XTHREAD_FILES
    apr_int32_t flags;
#endif

#if APR_HAS_THREADS && !APR_HAS_XTHREAD_FILES
    if ((flags = apr_file_flags_get(f)) & APR_XTHREAD) {
        /* this file descriptor is shared across multiple threads and
         * this OS doesn't support that natively, so as a workaround
         * we must reopen the file into a->readpool */
        const char *fname;
        apr_file_name_get(&fname, f);

        rv = apr_file_open(&f, fname, (flags & ~APR_XTHREAD), 0, a->readpool);
        if (rv != APR_SUCCESS)
            return rv;

        a->fd = f;
    }
#endif

    /* in case we die prematurely */
    *str = NULL;
    *len = 0;

    /* DEBUG
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
            "disk_cache: Called diskcache_bucket_read");
     */

    while(1) {
        /* Figure out how big the file is right now, sit here until
           it's grown enough or we get bored */
        rv = apr_file_info_get(&finfo, 
                        APR_FINFO_SIZE | APR_FINFO_MTIME | APR_FINFO_NLINK, f);
        if(rv != APR_SUCCESS) {
            return rv;
        }

        if(finfo.size >= fileoffset + MIN(filelength, CACHE_BUCKET_MINCHUNK)) {
        p = strchr(p, '/');
        if (!p)
            break;
        }

        /* No use to even wait for a deleted file */
        if(finfo.nlink == 0) {
            return APR_EGENERAL;
        }

        if(block == APR_NONBLOCK_READ) {
            return APR_EAGAIN;
        }

        /* Check for timeout */
        if(finfo.mtime < (apr_time_now() - a->updtimeout) ) {
            return APR_EGENERAL;
        }
        /* If we have progress within half the timeout period, return what
           we have so far */
        if(finfo.size > fileoffset &&
                start < (apr_time_now() - a->updtimeout/2) ) 
        {
            break;
        }

        /* Increase loop delay on each pass */
        cache_loop_sleep(&(a->polldelay));
        CACHE_LOOP_INCTIME(a->polldelay);
    }
    /* Decrease the loop delay a notch so the stored value is the actual
       delay needed */
    CACHE_LOOP_DECTIME(a->polldelay);

    /* Convert this bucket to a zero-length heap bucket so we won't be called
       again */
    buf = apr_bucket_alloc(0, e->list);
    apr_bucket_heap_make(e, buf, 0, apr_bucket_free);

    /* Wrap as much as possible into a regular file bucket */
    available = MIN(filelength, finfo.size-fileoffset);
    b = apr_bucket_file_create(f, fileoffset, available, a->readpool, e->list);
    APR_BUCKET_INSERT_AFTER(e, b);

    /* DEBUG
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
            "disk_cache: diskcache_bucket_read: Converted to regular file"
            " off %" APR_OFF_T_FMT " len %" APR_SIZE_T_FMT,
            fileoffset, available);
     */


    /* Put any remains in yet another bucket */
    if(available < filelength) {
        e=b;
        /* for efficiency, we can just build a new apr_bucket struct
         * to wrap around the existing bucket */
        b = apr_bucket_alloc(sizeof(*b), e->list);
        b->start  = fileoffset + available;
        b->length = filelength - available;
        b->data   = a;
        b->type   = &bucket_type_diskcache;
        b->free   = apr_bucket_free;
        b->list   = e->list;
        APR_BUCKET_INSERT_AFTER(e, b);
    }
    else {
        diskcache_bucket_destroy(a);
    }

    *str = buf;
    return APR_SUCCESS;
}

static apr_bucket * diskcache_bucket_make(apr_bucket *b,
                                                apr_file_t *fd,
                                                apr_off_t offset,
                                                apr_size_t len, 
                                                apr_interval_time_t timeout,
                                                apr_pool_t *p)
{
    diskcache_bucket_data *f;

    f = apr_bucket_alloc(sizeof(*f), b->list);
    f->fd = fd;
    f->readpool = p;
    f->updtimeout = timeout;
    f->polldelay = 0;

    b = apr_bucket_shared_make(b, f, offset, len);
    b->type = &bucket_type_diskcache;

    return b;
}
            apr_sleep(1000);

static apr_bucket * diskcache_bucket_create(apr_file_t *fd,
                                                  apr_off_t offset,
                                                  apr_size_t len, 
                                                  apr_interval_time_t timeout,
                                                  apr_pool_t *p,
                                                  apr_bucket_alloc_t *list)
{
    apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);

    APR_BUCKET_INIT(b);
    b->free = apr_bucket_free;
    b->list = list;
    return diskcache_bucket_make(b, fd, offset, len, timeout, p);
}


/* FIXME: This is probably only correct for the first case, that seems
   to be the one that occurs all the time... */
static apr_status_t diskcache_bucket_setaside(apr_bucket *data, 
                                              apr_pool_t *reqpool)
{
    diskcache_bucket_data *a = data->data;
    apr_file_t *fd = NULL;
    apr_file_t *f = a->fd;
    apr_pool_t *curpool = apr_file_pool_get(f);

    if (apr_pool_is_ancestor(curpool, reqpool)) {
        return APR_SUCCESS;
    }

    if (!apr_pool_is_ancestor(a->readpool, reqpool)) {
        /* FIXME: Figure out what needs to be done here */
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
                "disk_cache: diskcache_bucket_setaside: FIXME1");
        a->readpool = reqpool;
    }

    /* FIXME: Figure out what needs to be done here */
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
            "disk_cache: diskcache_bucket_setaside: FIXME2");

    apr_file_setaside(&fd, f, reqpool);
    a->fd = fd;
    return APR_SUCCESS;
}

static const apr_bucket_type_t bucket_type_diskcache = {
    "DISKCACHE", 5, APR_BUCKET_DATA,
    diskcache_bucket_destroy,
    diskcache_bucket_read,
    diskcache_bucket_setaside,
    apr_bucket_shared_split,
    apr_bucket_shared_copy
};

/* From apr_brigade.c */

/* A "safe" maximum bucket size, 1Gb */
#define MAX_BUCKET_SIZE (0x40000000)

static apr_bucket * diskcache_brigade_insert(apr_bucket_brigade *bb,
                                                   apr_file_t *f, apr_off_t
                                                   start, apr_off_t length,
                                                   apr_interval_time_t timeout,
                                                   apr_pool_t *p)
{
    apr_bucket *e;

    if (length < MAX_BUCKET_SIZE) {
        e = diskcache_bucket_create(f, start, (apr_size_t)length, timeout, p, 
                bb->bucket_alloc);
    }
    else {
        /* Several buckets are needed. */        
        e = diskcache_bucket_create(f, start, MAX_BUCKET_SIZE, timeout, p, 
                bb->bucket_alloc);

        while (length > MAX_BUCKET_SIZE) {
            apr_bucket *ce;
            apr_bucket_copy(e, &ce);
            APR_BRIGADE_INSERT_TAIL(bb, ce);
            e->start += MAX_BUCKET_SIZE;
            length -= MAX_BUCKET_SIZE;
        }
        e->length = (apr_size_t)length; /* Resize just the last bucket */
    }

    APR_BRIGADE_INSERT_TAIL(bb, e);
    return e;
}

/* --------------------------------------------------------------- */

/*
 * Local static functions
 */

static char *cache_file(apr_pool_t *p, disk_cache_conf *conf,
                        const char *prefix, const char *name, 
                        const char *suffix)
{
    /* move the data over */
    if (dobj->tfd) {
        apr_status_t rv;

    char *hashfile;

    hashfile = ap_cache_generate_name(p, conf->dirlevels,
                                                conf->dirlength, name);
         * rather than a rename.
         */
        rv = apr_file_rename(dobj->tempfile, dobj->datafile, r->pool);
        if (rv != APR_SUCCESS) {
            /* XXX log */
        }

    /* This assumes that we always deal with Vary-stuff if there's a prefix */
    if (prefix) {
        return apr_pstrcat(p, prefix, CACHE_VDIR_SUFFIX, "/",
                hashfile, suffix, NULL);
    }
    else {
        return apr_pstrcat(p, conf->cache_root, "/", hashfile, suffix, NULL);
    }

    return APR_SUCCESS;
}


static apr_status_t mkdir_structure(const char *file, apr_pool_t *pool)
{
    apr_status_t rv;
    char *p;
    int i;

    p = strrchr((char *)file, '/');
    if(!p) {
        return APR_EGENERAL;
        apr_file_remove(dobj->tempfile, r->pool);
        dobj->tfd = NULL;
    }

    *p = '\0';

    /* Be stubborn to overcome racyness when others deletes directories
       while we're trying to create them */
    for(i=0; i < 10; i++) {
        rv = apr_dir_make_recursive(file, 
                                    APR_UREAD|APR_UWRITE|APR_UEXECUTE, pool);
        if(rv == APR_SUCCESS) {
            break;
        }
    }
    *p = '/';

    return rv;
}

/* htcacheclean may remove directories underneath us.
 * So, we'll try renaming three times at a cost of 0.002 seconds.
 * and written transparent to clients of this module
 */
static apr_status_t safe_file_rename(const char *src, const char *dest,
                                     apr_pool_t *pool)
{
    apr_status_t rv;
    char *urlbuff;
    disk_cache_info_t disk_info;
    apr_size_t len;

    rv = apr_file_rename(src, dest, pool);

    rv = apr_file_read_full(fd, &disk_info, len, &len);
    if (rv != APR_SUCCESS) {
        int i;

        for (i = 0; i < 2 && rv != APR_SUCCESS; i++) {
            mkdir_structure(dest, pool);

            rv = apr_file_rename(src, dest, pool);

            if(rv != APR_SUCCESS) {
                /* 1000 micro-seconds aka 0.001 seconds. */
                apr_sleep(1000);
            }
        }
    }

    return rv;
}

/* Close fd, remove file if it was opened for writing */
static void close_and_rm(apr_file_t *fd, const char *file, request_rec *r)
{
    apr_int32_t flags = apr_file_flags_get(fd);

    apr_file_close(fd);
    if(flags & APR_FOPEN_WRITE) {
        apr_file_remove(file, r->pool);
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                     "disk_cache: close_and_rm: Removed %s",
                     file);
    if (rv != APR_SUCCESS) {
        return rv;
    }
}


static apr_status_t file_cache_errorcleanup(disk_cache_object_t *dobj, 
                                            request_rec *r)
{
    /* Only remove files that are opened for write when called, files
       opened only for reading must be explicitly removed */
    if(dobj->hfd) {
        close_and_rm(dobj->hfd, dobj->hdrsfile, r);
        dobj->hfd = NULL;
    }
    if(dobj->bfd) {
        close_and_rm(dobj->bfd, dobj->bodyfile, r);
        dobj->bfd = NULL;
    }
    if (dobj->tfd) {
        close_and_rm(dobj->tfd, dobj->tempfile, r);
        dobj->tfd = NULL;
    }

    return APR_SUCCESS;
}


static const char* regen_key(apr_pool_t *p, apr_table_t *headers,
                             apr_array_header_t *varray, const char *oldkey)
{

/*
 * Hook and mod_cache callback functions
 */
static int create_entity(cache_handle_t *h, request_rec *r, const char *key, 
                         apr_off_t len)
{
    disk_cache_conf *conf = ap_get_module_config(r->server->module_config,
                                                 &disk_cache_module);

        return DECLINED;
    }

    /* Note, len is -1 if unknown so don't trust it too hard */
    if (len > conf->maxfs) {
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                     "disk_cache: URL %s failed the size check "
                     "(%" APR_OFF_T_FMT " > %" APR_OFF_T_FMT ")",
                     key, len, conf->maxfs);
        return DECLINED;
    }
    if (len >= 0 && len < conf->minfs) {
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                     "disk_cache: URL %s failed the size check "
                     "(%" APR_OFF_T_FMT " < %" APR_OFF_T_FMT ")",
                     key, len, conf->minfs);
        return DECLINED;
    }

    /* Allocate and initialize cache_object_t and disk_cache_object_t */
    h->cache_obj = obj = apr_pcalloc(r->pool, sizeof(*obj));
    obj->vobj = dobj = apr_pcalloc(r->pool, sizeof(*dobj));

    obj->key = apr_pstrdup(r->pool, key);

    dobj->name = obj->key;
    dobj->prefix = NULL;
    /* Save the cache root */
    dobj->root = apr_pstrndup(r->pool, conf->cache_root, conf->cache_root_len);
    dobj->root_len = conf->cache_root_len;
    dobj->hdrsfile = cache_file(r->pool, conf, NULL, key, CACHE_HEADER_SUFFIX);
    dobj->hdrsfile = header_file(r->pool, conf, dobj, key);
    dobj->tempfile = apr_pstrcat(r->pool, conf->cache_root, AP_TEMPFILE, NULL);
    dobj->initial_size = len;
    dobj->file_size = -1;
    dobj->lastmod = APR_DATE_BAD;
    dobj->updtimeout = conf->updtimeout;
    dobj->removedirs = conf->removedirs;
    dobj->header_only = r->header_only;

    if(r->filename != NULL && strlen(r->filename) > 0) {
        char buf[34];
        char *str;

        /* When possible, hash the body on dev:inode to minimize file
           duplication. */
        if( (r->finfo.valid & APR_FINFO_IDENT) == APR_FINFO_IDENT) {
            apr_uint64_t device = r->finfo.device; /* Avoid ifdef ... */
            apr_uint64_t inode  = r->finfo.inode;  /* ... type-mess */

            apr_snprintf(buf, sizeof(buf), "%016" APR_UINT64_T_HEX_FMT ":%016" 
                         APR_UINT64_T_HEX_FMT, device, inode);
            str = buf;
        }
        else {
            str = r->filename;
        }
        dobj->bodyfile = cache_file(r->pool, conf, NULL, str, 
                                    CACHE_BODY_SUFFIX);
        dobj->filename = r->filename;
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                     "disk_cache: File %s was hashed using %s into %s",
                     r->filename, str, dobj->bodyfile);
    }
    else {
        dobj->bodyfile = cache_file(r->pool, conf, NULL, key, 
                                    CACHE_BODY_SUFFIX);
    }

    return OK;
}


static apr_status_t file_read_timeout(apr_file_t *file, char * buf,
                                      apr_size_t len, apr_time_t timeout)
{
    apr_size_t left, done;
    apr_size_t len;
    const char *nkey;
    apr_status_t rc;
    static int error_logged = 0;
    disk_cache_conf *conf = ap_get_module_config(r->server->module_config,
                                                 &disk_cache_module);
    apr_finfo_t finfo;
    apr_status_t rc;
    apr_interval_time_t delay=0;
    disk_cache_object_t *dobj;
    int flags;

    done = 0;
    left = len;

    while(1) {
        rc = apr_file_read_full(file, buf+done, left, &len);
        if (rc == APR_SUCCESS) {
           break;
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
                         "disk_cache: Cannot cache files to disk without a CacheRoot specified.");
        }
        done += len;
        left -= len;

        if(!APR_STATUS_IS_EOF(rc)) {
            return rc;
        }
        rc = apr_file_info_get(&finfo, APR_FINFO_MTIME, file);
        if(rc != APR_SUCCESS) {
           return rc;
        }
        if(finfo.mtime < (apr_time_now() - timeout) ) {
            return APR_ETIMEDOUT;
        }
        cache_loop_sleep(&delay);
        CACHE_LOOP_INCTIME(delay);
    }

    return APR_SUCCESS;
}

    /* Open the headers file */
    dobj->prefix = NULL;

static apr_status_t open_header(cache_handle_t *h, request_rec *r, 
                                const char *key, disk_cache_conf *conf)
{
    int flags = APR_READ | APR_WRITE | APR_BINARY;
    disk_cache_format_t format;
    apr_status_t rc;
    const char *nkey = key;
    disk_cache_info_t disk_info;
    cache_object_t *obj = h->cache_obj;
    disk_cache_object_t *dobj = obj->vobj;

    /* Open header read/write so it's easy to rewrite it when needed */
    flags = APR_READ|APR_BINARY|APR_BUFFERED;
    rc = apr_file_open(&dobj->hfd, dobj->hdrsfile, flags, 0, r->pool);
    if (rc != APR_SUCCESS) {
        return CACHE_EDECLINED;
    }

    /* read the format from the cache file */
    rc = apr_file_read_full(dobj->hfd, &format, sizeof(format), NULL);
    if(APR_STATUS_IS_EOF(rc)) {
        return CACHE_ENODATA;
    }
    else if(rc != APR_SUCCESS) {
        return rc;
    }

    /* Vary-files are being written to tmpfile and moved in place, so
       the should always be complete */
    if (format == VARY_FORMAT_VERSION) {
        apr_array_header_t* varray;
        apr_time_t expire;
        char *p;

        rc = apr_file_read_full(dobj->hfd, &expire, sizeof(expire), NULL);
        if(rc != APR_SUCCESS) {
            return rc;
        }

        if (expire < r->request_time) {
            return CACHE_EDECLINED;
        }

        varray = apr_array_make(r->pool, 5, sizeof(char*));

            ap_log_error(APLOG_MARK, APLOG_ERR, rc, r->server,
                         "disk_cache: Cannot parse vary header file: %s",
                         dobj->hdrsfile);
            return CACHE_EDECLINED;
        }
        apr_file_close(dobj->hfd);

        nkey = regen_key(r->pool, r->headers_in, varray, key);

        dobj->hashfile = NULL;
        dobj->prefix = dobj->hdrsfile;
        p = strrchr((char *)dobj->prefix, '.');
        if(p) {
            /* Cut away the suffix */
            *p = '\0';
        }
        dobj->hdrsfile = cache_file(r->pool, conf, dobj->prefix, nkey,
                                    CACHE_HEADER_SUFFIX);

        flags = APR_READ|APR_BINARY|APR_BUFFERED;
        rc = apr_file_open(&dobj->hfd, dobj->hdrsfile, flags, 0, r->pool);
        if (rc != APR_SUCCESS) {
            dobj->hfd = NULL;
            return CACHE_EDECLINED;
        }
        rc = apr_file_read_full(dobj->hfd, &format, sizeof(format), NULL);
        if(APR_STATUS_IS_EOF(rc)) {
            return CACHE_ENODATA;
        }
        else if(rc != APR_SUCCESS) {
            return rc;
        }
    }

    if(format != DISK_FORMAT_VERSION) {
        ap_log_error(APLOG_MARK, APLOG_INFO, 0, r->server,
                     "disk_cache: File '%s' had a version mismatch. File had "
                     "version: %d (current is %d). Deleted.", dobj->hdrsfile,
                     format, DISK_FORMAT_VERSION);
        file_cache_errorcleanup(dobj, r);
        apr_file_remove(dobj->hdrsfile, r->pool);
        return CACHE_EDECLINED;
         * start of the file again, so that later reads work.
         */
        apr_file_seek(dobj->hfd, APR_SET, &offset);
        nkey = key;
    }

    obj->key = nkey;
    dobj->key = nkey;
    dobj->name = key;
    dobj->datafile = data_file(r->pool, conf, dobj, nkey);
    dobj->tempfile = apr_pstrcat(r->pool, conf->cache_root, AP_TEMPFILE, NULL);

    /* read the data from the header file */
    rc = apr_file_read_full(dobj->hfd, &disk_info, sizeof(disk_info), NULL);
    if(APR_STATUS_IS_EOF(rc)) {
        return CACHE_ENODATA;
#endif
    rc = apr_file_open(&dobj->fd, dobj->datafile, flags, 0, r->pool);
    if (rc != APR_SUCCESS) {
        /* XXX: Log message */
        return DECLINED;
    }
    else if(rc != APR_SUCCESS) {
        return rc;
    if (rc == APR_SUCCESS) {
        dobj->file_size = finfo.size;
    }

    /* Store it away so we can get it later. */
    dobj->disk_info = disk_info;
    if (rc != APR_SUCCESS) {
        /* XXX log message */
        return DECLINED;
    }

    return APR_SUCCESS;
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                 "disk_cache: Recalled cached URL info header %s",  dobj->name);
    return OK;
}


static apr_status_t open_header_timeout(cache_handle_t *h, request_rec *r, 
                                const char *key, disk_cache_conf *conf)
{
    apr_status_t rc;
    apr_finfo_t finfo;
    apr_interval_time_t delay = 0;
    cache_object_t *obj = h->cache_obj;
    disk_cache_object_t *dobj = obj->vobj;

    while(1) {
        if(dobj->hfd) {
            apr_file_close(dobj->hfd);
            dobj->hfd = NULL;
        }
        rc = open_header(h, r, key, conf);
        if(rc != APR_SUCCESS && rc != CACHE_ENODATA) {
            if(rc != CACHE_EDECLINED) {
                ap_log_error(APLOG_MARK, APLOG_ERR, rc, r->server,
                             "disk_cache: Cannot load header file: %s",
                             dobj->hdrsfile);
            }
            return rc;
        }

        /* Objects with unknown body size will have file_size == -1 until the
           entire body is written and the header updated with the actual size.
           And since we depend on knowing the body size we wait until the size
           is written */
        if(rc == APR_SUCCESS && dobj->disk_info.file_size >= 0) {
            break;
        }
        rc = apr_file_info_get(&finfo, APR_FINFO_MTIME, dobj->hfd);
        if(rc != APR_SUCCESS) {
            return rc;
        }
        if(finfo.mtime < (apr_time_now() - dobj->updtimeout)) {
            ap_log_error(APLOG_MARK, APLOG_WARNING, 0, r->server,
                         "disk_cache: Timed out waiting for header file %s for "
                         "URL %s - caching the body failed?", 
                         dobj->hdrsfile, key);
            return CACHE_EDECLINED;
        }
        cache_loop_sleep(&delay);
        CACHE_LOOP_INCTIME(delay);
    }

    return APR_SUCCESS;
}


static apr_status_t load_header_strings(request_rec *r,
                                        disk_cache_object_t *dobj)
{
    apr_size_t len;
    apr_status_t rc;
    char *urlbuff;

    if(dobj->disk_info.name_len > MAX_STRING_LEN ||
            dobj->disk_info.bodyname_len > MAX_STRING_LEN ||
            dobj->disk_info.filename_len > MAX_STRING_LEN) 
    {
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
                "disk_cache: Corrupt cache header for URL %s, deleting: %s",
                dobj->name, dobj->hdrsfile);
        file_cache_errorcleanup(dobj, r);
        apr_file_remove(dobj->hdrsfile, r->pool);
        return CACHE_EDECLINED;
    }

    /* FIXME: Enforce that url and bodyname is present */


    len = dobj->disk_info.name_len;
    urlbuff = apr_palloc(r->pool, len+1);
    if(urlbuff == NULL) {
        return APR_ENOMEM;
    }

    rc = file_read_timeout(dobj->hfd, urlbuff, len, dobj->updtimeout);
    if (rc == APR_ETIMEDOUT) {
        ap_log_error(APLOG_MARK, APLOG_WARNING, rc, r->server,
                     "disk_cache: Timed out waiting for urlbuff for "
                     "URL %s - caching failed?",  dobj->name);
        return CACHE_EDECLINED;
    }
    else if(rc != APR_SUCCESS) {
        ap_log_error(APLOG_MARK, APLOG_WARNING, rc, r->server,
                     "disk_cache: Error reading urlbuff for URL %s",
                     dobj->name);
        return CACHE_EDECLINED;
    }
    urlbuff[len] = '\0';

    /* check that we have the same URL */
    if (strcmp(urlbuff, dobj->name) != 0) {
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
                     "disk_cache: Cached URL %s didn't match requested "
                     "URL %s", urlbuff, dobj->name);
        file_cache_errorcleanup(dobj, r);
        apr_file_remove(dobj->hdrsfile, r->pool);
        apr_file_remove(dobj->bodyfile, r->pool);
        return CACHE_EDECLINED;
    }

    /* Read in the file the body is stored in */
    len = dobj->disk_info.bodyname_len;
    if(len > 0) {
        char *bodyfile = apr_palloc(r->pool, len+1);

        if(bodyfile == NULL) {
            return APR_ENOMEM;
        }

        rc = file_read_timeout(dobj->hfd, bodyfile, len, dobj->updtimeout);
        if (rc == APR_ETIMEDOUT) {
            ap_log_error(APLOG_MARK, APLOG_WARNING, rc, r->server,
                         "disk_cache: Timed out waiting for body cache "
                         "filename for URL %s - caching failed?", dobj->name);
            return CACHE_EDECLINED;
        }
        else if(rc != APR_SUCCESS) {
            ap_log_error(APLOG_MARK, APLOG_WARNING, rc, r->server,
                         "disk_cache: Error reading body cache filename for "
                         "URL %s", dobj->name);
            return CACHE_EDECLINED;
        }
        bodyfile[len] = '\0';
        dobj->bodyfile = apr_pstrcat(r->pool, dobj->root, "/", bodyfile, NULL);
    }

    /* Read in the filename */
    len = dobj->disk_info.filename_len;
    if(len > 0) {
        char *fnamebuf = apr_palloc(r->pool, len+1);

        if(fnamebuf == NULL) {
            return APR_ENOMEM;
        }

        rc = file_read_timeout(dobj->hfd, fnamebuf, len, dobj->updtimeout);
        if (rc == APR_ETIMEDOUT) {
            ap_log_error(APLOG_MARK, APLOG_WARNING, rc, r->server,
                         "disk_cache: Timed out waiting for filename for "
                         "URL %s - caching failed?", dobj->name);
            return CACHE_EDECLINED;
        }
        else if(rc != APR_SUCCESS) {
            ap_log_error(APLOG_MARK, APLOG_WARNING, rc, r->server,
                         "disk_cache: Error reading filename for URL %s",
                         dobj->name);
            return CACHE_EDECLINED;
        }
        fnamebuf[len] = '\0';

        dobj->filename = fnamebuf;
        /* We can't set r->filename here because for example mod_rewrite
           will exhibit different behaviour compared to a completely
           uncached entity (will happen if entity is revalidated for 
           example). */
        /* Save a pointer to r->filename so we can set it later on in
           recall_body which doesn't get r as an argument */
        dobj->rfilename = &(r->filename);
    }

    return APR_SUCCESS;
}


static apr_status_t open_body_timeout(request_rec *r, cache_object_t *cache_obj)
{
    apr_status_t rc;
    apr_finfo_t finfo;
    int flags = APR_READ|APR_BINARY;
    apr_interval_time_t delay = 0;
    disk_cache_object_t *dobj = (disk_cache_object_t *) cache_obj->vobj;
    cache_info *info = &(cache_obj->info);
    
#if APR_HAS_SENDFILE
    core_dir_config *pdconf = ap_get_module_config(r->per_dir_config,
                                                   &core_module);
    flags |= ((pdconf->enable_sendfile == ENABLE_SENDFILE_OFF)
             ? 0 : APR_SENDFILE_ENABLED);
#endif  

    if(dobj->bodyfile == NULL || strlen(dobj->bodyfile) == 0) {
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
                     "disk_cache: open_body_timeout called with NULL "
                     "bodyfile for URL %s",
                     dobj->name);
        return APR_EGENERAL;
    }

    /* Wait here until we get a body cachefile, data in it, and do quick sanity
     * check */

    while(1) {
        if(dobj->bfd == NULL) {
            rc = apr_file_open(&dobj->bfd, dobj->bodyfile, flags, 0, r->pool);
            if(rc != APR_SUCCESS) {
                if(info->response_time < (apr_time_now() - dobj->updtimeout) ) {
                    /* This usually means that the body simply wasn't cached,
                       due to HEAD requests for example */
                    ap_log_error(APLOG_MARK, APLOG_DEBUG, rc, r->server,
                                 "disk_cache: Timed out waiting for bodyfile "
                                 "%s for URL %s - caching failed?", 
                                 dobj->bodyfile, dobj->name);
                    return CACHE_EDECLINED;
                }
                cache_loop_sleep(&delay);
                CACHE_LOOP_INCTIME(delay);
                continue;
            }
        }

        rc = apr_file_info_get(&finfo, APR_FINFO_SIZE | APR_FINFO_CSIZE | 
                                        APR_FINFO_MTIME | APR_FINFO_NLINK, 
                               dobj->bfd);
        if(rc != APR_SUCCESS && !APR_STATUS_IS_INCOMPLETE(rc)) {
            return rc;
        }
        if(finfo.valid & APR_FINFO_NLINK && finfo.nlink == 0) {
            /* This file has been deleted, close it and try again */
            apr_file_close(dobj->bfd);
            dobj->bfd = NULL;
            continue;
        }

        /* Argh!  Why have APR_FINFO_CSIZE when it's not even
           implemented on Unix, which is the simple platform to do it on?
         */
        if(finfo.valid & APR_FINFO_CSIZE) {
            /* Assume that files consuming less storage than size are broken.
               It really shouldn't happen, but for example XFS on Linux can
               leave such files after a system crash. We simply use the smaller
               of the sizes and let error handling do the rest. */
            dobj->file_size = MIN(finfo.size, finfo.csize);
        }
        else {
            dobj->file_size = finfo.size;
        }

        /* Note that the body might have been updated by another entity
           that uses the same body, which usually means that we should
           revalidate too. Don't freak out completely when this happens.
           We might have:
           - Body in sync with this header.
           - Body being cached.
           - Body that failed caching.
           - Body newer than this header. 
         */

        if(dobj->initial_size < dobj->file_size) {
            ap_log_error(APLOG_MARK, APLOG_INFO, 0, r->server,
                         "disk_cache: Cached body for too large for URL %s"
                         " - revalidating.", dobj->name);
            apr_file_remove(dobj->hdrsfile, r->pool);
            return CACHE_EDECLINED;
        }
        else if(dobj->initial_size > dobj->file_size) {
            /* Still caching or failed? */
            if(finfo.mtime < (apr_time_now() - dobj->updtimeout) ) {
                ap_log_error(APLOG_MARK, APLOG_INFO, rc, r->server,
                             "disk_cache: Cached body too small for URL %s"
                             " - revalidating.", dobj->name);
                apr_file_remove(dobj->hdrsfile, r->pool);
                return CACHE_EDECLINED;
            }
        }
        else {
            /* If right size, file has either the correct mtime or an mtime
               within the update timeout (in the window between finished
               copying and setting mtime) 
             */
            if(dobj->lastmod != APR_DATE_BAD &&
                    finfo.mtime != dobj->lastmod &&
                    finfo.mtime < (apr_time_now() - dobj->updtimeout) ) 
            {
                ap_log_error(APLOG_MARK, APLOG_INFO, rc, r->server,
                             "disk_cache: Cached body Last-Modified mismatch "
                             "for URL %s - revalidating.", dobj->name);
                apr_file_remove(dobj->hdrsfile, r->pool);
                return CACHE_EDECLINED;
            }
        }

        if(dobj->file_size > 0) {
            break;
        }
        cache_loop_sleep(&delay);
        CACHE_LOOP_INCTIME(delay);
    }

    return APR_SUCCESS;
}


static int open_entity(cache_handle_t *h, request_rec *r, const char *key)
{
    apr_status_t rc;
    disk_cache_object_t *dobj;
    cache_info *info;
    static int error_logged = 0;
    disk_cache_conf *conf = ap_get_module_config(r->server->module_config,
                                                 &disk_cache_module);

    h->cache_obj = NULL;

    /* Look up entity keyed to 'url' */
    if (conf->cache_root == NULL) {
        if (!error_logged) {
            error_logged = 1;
            ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
                         "disk_cache: Cannot cache files to disk without a "
                         "CacheRoot specified.");
        }
        return DECLINED;
    }

    /* Create and init the cache object */
    h->cache_obj = apr_pcalloc(r->pool, sizeof(cache_object_t));
    h->cache_obj->vobj = dobj = apr_pcalloc(r->pool, sizeof(disk_cache_object_t));
    info = &(h->cache_obj->info);

    /* Save the cache root */
    dobj->root = apr_pstrndup(r->pool, conf->cache_root, conf->cache_root_len);
    dobj->root_len = conf->cache_root_len;

    dobj->hdrsfile = cache_file(r->pool, conf, NULL, key, CACHE_HEADER_SUFFIX);

    dobj->updtimeout = conf->updtimeout;
    dobj->removedirs = conf->removedirs;
    dobj->header_only = r->header_only;

    /* Open header and read basic info, wait until header contains
       valid size information for the body */
    rc = open_header_timeout(h, r, key, conf);
    if(rc != APR_SUCCESS) {
        if(dobj->hfd != NULL) {
            apr_file_close(dobj->hfd);
            dobj->hfd = NULL;
        }
        return DECLINED;
    }

    info->status = dobj->disk_info.status;
    info->date = dobj->disk_info.date;
    info->expire = dobj->disk_info.expire;
    info->request_time = dobj->disk_info.request_time;
    info->response_time = dobj->disk_info.response_time;

    dobj->lastmod = dobj->disk_info.lastmod;
    dobj->initial_size = (apr_off_t) dobj->disk_info.file_size;
    dobj->tempfile = apr_pstrcat(r->pool, conf->cache_root, AP_TEMPFILE, NULL);

    /* Load and check strings (URL, bodyfile, filename) */
    rc = load_header_strings(r, dobj);
    if(rc != APR_SUCCESS) {
        if(dobj->hfd != NULL) {
            apr_file_close(dobj->hfd);
            dobj->hfd = NULL;
        }
        return DECLINED;
    }

    /* Only need body cachefile if we have a body and this isn't a HEAD
       request */
    if(dobj->initial_size > 0 && !dobj->header_only) {
        rc = open_body_timeout(r, h->cache_obj);
        if(rc != APR_SUCCESS) {
            if(dobj->hfd != NULL) {
                apr_file_close(dobj->hfd);
                dobj->hfd = NULL;
            }
            if(dobj->bfd != NULL) {
                apr_file_close(dobj->bfd);
                dobj->bfd = NULL;
            }
            return DECLINED;
        }
    }
    else {
        dobj->file_size = 0;
    }

    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                 "disk_cache: Recalled status for cached URL %s from file %s",
                 dobj->name, dobj->hdrsfile);
    return OK;
}


static int remove_entity(cache_handle_t *h)
{
    disk_cache_object_t *dobj;
    apr_finfo_t finfo;
    apr_pool_t *p;
    apr_status_t rv;

    /* Get disk cache object from cache handle */
    dobj = (disk_cache_object_t *) h->cache_obj->vobj;

    /* Null out the cache object pointer so next time we start from scratch */
    h->cache_obj = NULL;

    if(!dobj) {
        return OK;
    }

    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
            "disk_cache: remove_entity: %s", dobj->name);

    /* We really want to remove the cache files  here since mod_cache has
       deemed it stale, but it seems like an API miss that we don't
       have a pool? And why is this function separate from remove_url?
       Oh well, beware of kludge ;) */

    if(dobj->hfd != NULL) {
        /* Only remove file if fd isn't already unlinked. Not atomic, but
           the best we can do? */
        rv = apr_file_info_get(&finfo, APR_FINFO_NLINK, dobj->hfd);
        if(rv == APR_SUCCESS && finfo.nlink != 0) {
            p = apr_file_pool_get(dobj->hfd);
            apr_file_remove(dobj->hdrsfile, p);
            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
                         "disk_cache: remove_entity: Deleted %s from cache.",
                         dobj->hdrsfile);
        }
        apr_file_close(dobj->hfd);
        dobj->hfd = NULL;
    }
    if(dobj->bfd != NULL) {
        /* Only remove file if fd isn't already unlinked. Not atomic, but
           the best we can do? */
        rv = apr_file_info_get(&finfo, APR_FINFO_NLINK, dobj->bfd);
        if(rv == APR_SUCCESS && finfo.nlink != 0) {
            p = apr_file_pool_get(dobj->bfd);
            apr_file_remove(dobj->bodyfile, p);
            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
                    "disk_cache: remove_entity: Deleted %s from cache.",
                    dobj->bodyfile);
        }
        apr_file_close(dobj->bfd);
        dobj->bfd = NULL;
    }

    return OK;
}


/* FIXME: It would make sense to have the errorcleanup and this function
   to be the same */
static int remove_url(cache_handle_t *h, apr_pool_t *p)
{
    apr_status_t rc;
    disk_cache_object_t *dobj;

    /* Get disk cache object from cache handle */
    dobj = (disk_cache_object_t *) h->cache_obj->vobj;
    if (!dobj) {
        return DECLINED;
    }

    /* Delete headers file */
    if (dobj->hdrsfile) {
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
                     "disk_cache: Deleting %s from cache.", dobj->hdrsfile);


             * For reason see log_error_core for the case s == NULL.
             */
            ap_log_error(APLOG_MARK, APLOG_DEBUG, rc, NULL,
                         "disk_cache: Failed to delete headers file %s "
                         "from cache.", dobj->hdrsfile);
            return DECLINED;
        }
    }

    /* Only delete body cache file if it isn't backed by a real file */
    if(!dobj->filename && dobj->bodyfile) {
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
                     "disk_cache: Deleting %s from cache.", dobj->bodyfile);

        rc = apr_file_remove(dobj->bodyfile, p);
        if ((rc != APR_SUCCESS) && !APR_STATUS_IS_ENOENT(rc)) {
            /* Will only result in an output if httpd is started with -e debug.
             * For reason see log_error_core for the case s == NULL.
             */
            ap_log_error(APLOG_MARK, APLOG_DEBUG, rc, NULL,
                         "disk_cache: Failed to delete body file %s "
                         "from cache.", dobj->bodyfile);
            return DECLINED;
        }
    }

    if(!dobj->removedirs) {
        return OK;
    }

    /* now delete directories as far as possible up to our cache root */
    if (dobj->root) {
        const char *str_to_copy;

        str_to_copy = dobj->hdrsfile ? dobj->hdrsfile : dobj->bodyfile;
        if (str_to_copy) {
            char *dir, *slash, *q;


             * in the way as far as possible
             *
             * Note: due to the way we constructed the file names in
             * cache_file, we are guaranteed that the cache_root is suffixed by
             * at least one '/' which will be turned into a terminating null by
             * this loop.  Therefore, we won't either delete or go above our
             * cache root.
             */
            for (q = dir + dobj->root_len; *q ; ) {
                 ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,

        rv = apr_file_gets(w, MAX_STRING_LEN - 1, file);
        if (rv != APR_SUCCESS) {
            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
                          "disk_cache: Premature end of vary array.");
            return rv;
        }


                         &amt);
}

/* Load table stored by store_table */
static apr_status_t read_table(request_rec *r,
                               apr_table_t *table, apr_file_t *file)
{
    char *s, *k, *v;
    apr_uint32_t totsize = 0;
    int p;
    apr_status_t rv;

    rv = apr_file_read_full(file, &totsize, sizeof(totsize), NULL);
    if(rv != APR_SUCCESS) {
        return rv;
    }
        if (rv != APR_SUCCESS) {
            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
                          "Premature end of cache headers.");
            return rv;
        }

        /* Delete terminal (CR?)LF */

    s = apr_palloc(r->pool, totsize);
    if(s == NULL) {
        return APR_ENOMEM;
    }
        */
        if (p > 0 && w[p - 1] == '\n') {
            if (p > 1 && w[p - 2] == CR) {
                w[p - 2] = '\0';
            }
            else {
                w[p - 1] = '\0';
            }
        }

    rv = apr_file_read_full(file, s, totsize, NULL);
    if(rv != APR_SUCCESS) {
        return rv;
    }

    k=s;
    while(k < s + totsize) {
        /* FIXME: Do a pointer-loop instead of strlen to make sure we don't
                  walk outside of allocated memory if on-disk data has been
                  corrupted
         */
        v = k + strlen(k) + 1;
        apr_table_addn(table, k, v);
        k = v + strlen(v) + 1;
            apr_size_t inbytes_left, outbytes_left;

            for (cp = w; *cp != '\0'; ++cp) {
                native = apr_xlate_conv_byte(ap_hdrs_from_ascii, *cp);
                if (apr_isprint(*cp) && !apr_isprint(native))
                    ++maybeEBCDIC;
                if (!apr_isprint(*cp) && apr_isprint(native))
                    ++maybeASCII;
            }
            if (maybeASCII > maybeEBCDIC) {
                ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
                             "CGI Interface Error: Script headers apparently ASCII: (CGI = %s)",
                             r->filename);
                inbytes_left = outbytes_left = cp - w;
                apr_xlate_conv_buffer(ap_hdrs_from_ascii,
                                      w, &inbytes_left, w, &outbytes_left);
            }
        }
#endif /*APR_CHARSET_EBCDIC*/

        /* if we see a bogus header don't ignore it. Shout and scream */
        if (!(l = strchr(w, ':'))) {
            return APR_EGENERAL;
        }

        *l++ = '\0';
        while (*l && apr_isspace(*l)) {
            ++l;
        }

        apr_table_add(table, w, l);
    }

    return APR_SUCCESS;
}


/*
 * Reads headers from a buffer and returns an array of headers.
 * Returns NULL on file error

static apr_status_t recall_headers(cache_handle_t *h, request_rec *r)
{
    disk_cache_object_t *dobj = (disk_cache_object_t *) h->cache_obj->vobj;
    apr_status_t rv;
    apr_off_t off;
    apr_finfo_t finfo;
    apr_interval_time_t delay = 0;

    /* This case should not happen... */
    if (!dobj->hfd) {
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
                     "disk_cache: recall_headers called without fd for URL %s",
                     dobj->name);
        return APR_NOTFOUND;
    }

    off = 0;
    rv = apr_file_seek(dobj->hfd, APR_CUR, &off);
    if(rv != APR_SUCCESS) {
        return rv;
    }

    h->resp_hdrs = apr_table_make(r->pool, 20);
    h->req_hdrs = apr_table_make(r->pool, 20);

    while(1) {
        rv = read_table(r, h->resp_hdrs, dobj->hfd);
        if(rv != APR_SUCCESS) {
            apr_table_clear(h->resp_hdrs);
        }
        else {
            rv = read_table(r, h->req_hdrs, dobj->hfd);
            if(rv != APR_SUCCESS) {
                apr_table_clear(h->req_hdrs);
            }
        }
        if(rv == APR_SUCCESS) {
            break;
        }
        if(!APR_STATUS_IS_EOF(rv)) {
            ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
                          "disk_cache: Error reading cache headers "
                          "URL %s", dobj->name);
            if(dobj->hfd != NULL) {
                apr_file_close(dobj->hfd);
                dobj->hfd = NULL;
            }
            if(dobj->bfd != NULL) {
                apr_file_close(dobj->bfd);
                dobj->bfd = NULL;
            }
            return rv;
        }

        /* FIXME: Check if header file deleted (nlinks==0) and reopen it if
         * that's the case */
        rv = apr_file_info_get(&finfo, APR_FINFO_MTIME, dobj->hfd);
        if(rv != APR_SUCCESS ||
                finfo.mtime < (apr_time_now() - dobj->updtimeout) ) 
        {
            ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
                          "disk_cache: Timed out waiting for cache headers "
                          "URL %s", dobj->name);
            if(dobj->hfd != NULL) {
                apr_file_close(dobj->hfd);
                dobj->hfd = NULL;
            }
            if(dobj->bfd != NULL) {
                apr_file_close(dobj->bfd);
                dobj->bfd = NULL;
            }
            return APR_EGENERAL;
        }
        rv = apr_file_seek(dobj->hfd, APR_SET, &off);
        if(rv != APR_SUCCESS) {
            return rv;
        }
        cache_loop_sleep(&delay);
        CACHE_LOOP_INCTIME(delay);
    }

    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                 "disk_cache: Recalled headers for URL %s",  dobj->name);

    apr_bucket *e;
    disk_cache_object_t *dobj = (disk_cache_object_t*) h->cache_obj->vobj;

    if(dobj->hfd != NULL) {
        /* Close header cache file, it won't be needed anymore */
        apr_file_close(dobj->hfd);
        dobj->hfd = NULL;
    }

    if(dobj->initial_size > 0 && !dobj->header_only && dobj->bfd == NULL) {
        /* This should never happen, really... */
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, NULL,
                     "disk_cache: recall_body: Called but no fd open, URL %s "
                     "from file %s", dobj->name, dobj->bodyfile);
        return APR_EGENERAL;
    }

    /* Restore r->filename if not present */
    if(dobj->filename != NULL && dobj->rfilename != NULL && 
            *(dobj->rfilename) == NULL) 
    {
        *(dobj->rfilename) = dobj->filename;
    }

    /* Insert as much as possible as regular file (ie. sendfile():able) */
    if(dobj->file_size > 0) {
        if(apr_brigade_insert_file(bb, dobj->bfd, 0, 
                                   dobj->file_size, p) == NULL) 
        {
            return APR_ENOMEM;
        }
    }

    /* Insert any remainder as read-while-caching bucket */
    if(dobj->file_size < dobj->initial_size) {
        if(diskcache_brigade_insert(bb, dobj->bfd, dobj->file_size, 
                                    dobj->initial_size - dobj->file_size,
                                    dobj->updtimeout, p
                    ) == NULL) 
        {
            return APR_ENOMEM;
        }
    }

    e = apr_bucket_eos_create(bb->bucket_alloc);
    APR_BRIGADE_INSERT_TAIL(bb, e);

    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
                 "disk_cache: recall_body: Succeeded for URL %s from file %s",
                 dobj->name, dobj->bodyfile);

    return APR_SUCCESS;
}

/* Store table on disk.
 * Format on disk: apr_uint32_t totsize - total size of data following totsize
 *                 totsize of data, consisting of key\0value\0...key\0value\0
 */
static apr_status_t store_table(apr_file_t *fd, apr_table_t *table,
                                request_rec *r)
{
    int i, nelts, niov;
    apr_status_t rv;
    struct iovec iov[4];
    apr_size_t amt;
    apr_uint32_t totsize = 0;
    apr_table_entry_t *elts;
    /* FIXME: Is this too big for putting on the stack? */
    struct iovec iov[APR_MAX_IOVEC_SIZE];

    nelts = apr_table_elts(table)->nelts;
    if(nelts > (APR_MAX_IOVEC_SIZE-1)/2) {
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
                     "disk_cache: store_table: %d header entries would "
                     "overflow iovec", nelts);
        return APR_EINVAL;
    }

    elts = (apr_table_entry_t *) apr_table_elts(table)->elts;
    niov = 1;
    for (i = 0; i < nelts; ++i) {
        if (elts[i].key != NULL) {
            iov[niov].iov_base = elts[i].key;
            iov[niov].iov_len = strlen(elts[i].key)+1;
            totsize += iov[niov++].iov_len;
            iov[niov].iov_base = elts[i].val;
            iov[niov].iov_len = strlen(elts[i].val)+1;
            totsize += iov[niov++].iov_len;
            iov[3].iov_base = CRLF;
            iov[3].iov_len = sizeof(CRLF) - 1;

            rv = apr_file_writev(fd, (const struct iovec *) &iov, 4,
                                 &amt);
            if (rv != APR_SUCCESS) {
                return rv;
            }
        }
    }
    iov[0].iov_base = &totsize;
    iov[0].iov_len = sizeof(totsize);
    rv = apr_file_writev(fd, (const struct iovec *) &iov, niov,
                         &amt);
    return rv;
}


static apr_status_t open_new_file(request_rec *r, const char *filename,
                                  apr_file_t **fd, disk_cache_conf *conf)
{
    int flags = APR_CREATE | APR_WRITE | APR_BINARY | APR_EXCL;
                                                 &disk_cache_module);
    apr_status_t rv;
    apr_size_t amt;
    disk_cache_object_t *dobj = (disk_cache_object_t*) h->cache_obj->vobj;

    disk_cache_info_t disk_info;
    struct iovec iov[2];

    /* This is flaky... we need to manage the cache_info differently */
    h->cache_obj->info = *info;

    if (r->headers_out) {
        const char *tmp;

        tmp = apr_table_get(r->headers_out, "Vary");

    while(1) {
        rv = apr_file_open(fd, filename, flags, 
                           APR_FPROT_UREAD | APR_FPROT_UWRITE, r->pool);

        ap_log_error(APLOG_MARK, APLOG_DEBUG, rv, r->server,
                     "disk_cache: open_new_file: Opening %s", filename);

        if(APR_STATUS_IS_EEXIST(rv)) {
            apr_finfo_t finfo;

            rv = apr_stat(&finfo, filename, APR_FINFO_MTIME, r->pool);
            if(APR_STATUS_IS_ENOENT(rv)) {
                /* Someone else has already removed it, try again */
                continue;
            }
            else if(rv != APR_SUCCESS) {
                return rv;
            }

            /* FIXME: We should really check for size and mtime that matches
               the source file too if available */
            if(finfo.mtime < (apr_time_now() - conf->updtimeout) ) {
                /* Something stale that's left around */

                rv = apr_file_remove(filename, r->pool);
                if(rv != APR_SUCCESS && !APR_STATUS_IS_ENOENT(rv)) {
                    ap_log_error(APLOG_MARK, APLOG_ERR, rv, r->server,
                                 "disk_cache: open_new_file: Failed to "
                                 "remove old %s", filename);
                    return rv;
                }
                continue;
            }
            else {
                /* Someone else has just created the file, return identifiable
                   status so calling function can do the right thing */

                return CACHE_EEXIST;
            }
        }
        else if(APR_STATUS_IS_ENOENT(rv)) {
            /* The directory for the file didn't exist */

            rv = mkdir_structure(filename, r->pool);
            if(rv != APR_SUCCESS) {
                ap_log_error(APLOG_MARK, APLOG_ERR, rv, r->server,
                             "disk_cache: open_new_file: Failed to make "
                             "directory for %s", filename);
                return rv;
            }
            continue;
        }
        else if(rv == APR_SUCCESS) {
            return APR_SUCCESS;
        }
        else {
            ap_log_error(APLOG_MARK, APLOG_ERR, rv, r->server,
                         "disk_cache: open_new_file: Failed to open %s",
                         filename);
            return rv;
        }
    }

    /* We should never get here, so */
    return APR_EGENERAL;
}

            amt = sizeof(info->expire);
            apr_file_write(dobj->tfd, &info->expire, &amt);

static apr_status_t store_vary_header(cache_handle_t *h, disk_cache_conf *conf,
                                       request_rec *r, cache_info *info,
                                       const char *varyhdr)
{
    disk_cache_object_t *dobj = (disk_cache_object_t*) h->cache_obj->vobj;
    apr_array_header_t* varray;
    const char *vfile;
    apr_status_t rv;
    int flags;
    disk_cache_format_t format = VARY_FORMAT_VERSION;
    struct iovec iov[2];
    apr_size_t amt;

    if(dobj->prefix != NULL) {
        vfile = dobj->prefix;
    }
    else {
        vfile = dobj->hdrsfile;
    }

    flags = APR_CREATE | APR_WRITE | APR_BINARY | APR_EXCL | APR_BUFFERED;
    rv = apr_file_mktemp(&dobj->tfd, dobj->tempfile, flags, r->pool);
    if (rv != APR_SUCCESS) {
        return rv;
    }

    iov[0].iov_base = (void*)&format;
    iov[0].iov_len = sizeof(format);

    iov[1].iov_base = (void*)&info->expire;
    iov[1].iov_len = sizeof(info->expire);
            if (rv != APR_SUCCESS) {
                ap_log_error(APLOG_MARK, APLOG_DEBUG, rv, r->server,
                    "disk_cache: rename tempfile to varyfile failed: %s -> %s",
                    dobj->tempfile, dobj->hdrsfile);
                return rv;
            }

    rv = apr_file_writev(dobj->tfd, (const struct iovec *) &iov, 2, &amt);
    if (rv != APR_SUCCESS) {
        file_cache_errorcleanup(dobj, r);
        return rv;
            dobj->datafile = data_file(r->pool, conf, dobj, tmp);
            dobj->hdrsfile = header_file(r->pool, conf, dobj, tmp);
        }
    }

    varray = apr_array_make(r->pool, 6, sizeof(char*));
    tokens_to_array(r->pool, varyhdr, varray);

    rv = store_array(dobj->tfd, varray);
    if (rv != APR_SUCCESS) {
        file_cache_errorcleanup(dobj, r);
        return rv;
    }

    rv = apr_file_close(dobj->tfd);
    dobj->tfd = NULL;
    if (rv != APR_SUCCESS) {
        file_cache_errorcleanup(dobj, r);
        apr_file_remove(dobj->tempfile, r->pool);
        return rv;
    }

    rv = safe_file_rename(dobj->tempfile, vfile, r->pool);
    if (rv != APR_SUCCESS) {
        ap_log_error(APLOG_MARK, APLOG_ERR, rv, r->server,
                     "disk_cache: rename tempfile to varyfile failed: "
                     "%s -> %s", dobj->tempfile, vfile);
        file_cache_errorcleanup(dobj, r);
        apr_file_remove(dobj->tempfile, r->pool);
        return rv;
    }

    dobj->tempfile = apr_pstrcat(r->pool, conf->cache_root, AP_TEMPFILE, NULL);

    if(dobj->prefix == NULL) {
        const char *tmp = regen_key(r->pool, r->headers_in, varray, dobj->name);
        char *p;

        dobj->prefix = dobj->hdrsfile;
        p = strrchr((char *)dobj->prefix, '.');
        if(p) {
            /* Cut away the suffix */
            *p = '\0';
        }
        dobj->hdrsfile = cache_file(r->pool, conf, dobj->prefix, tmp, 
                                    CACHE_HEADER_SUFFIX);
        dobj->bodyfile = cache_file(r->pool, conf, dobj->prefix, tmp, 
                                    CACHE_BODY_SUFFIX);
    }

    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                 "disk_cache: Stored vary header for URL %s", dobj->name);

    return APR_SUCCESS;
}


static apr_status_t store_disk_header(disk_cache_object_t *dobj,
                                       request_rec *r, cache_info *info)
{
    disk_cache_format_t format = DISK_FORMAT_VERSION;
    struct iovec iov[5];
    int niov;
    disk_cache_info_t disk_info;
    apr_size_t amt;
    apr_status_t rv;

    disk_info.format = DISK_FORMAT_VERSION;
    disk_info.date = info->date;
    disk_info.expire = info->expire;
    disk_info.entity_version = dobj->disk_info.entity_version++;
    disk_info.request_time = info->request_time;
    disk_info.response_time = info->response_time;
    disk_info.status = info->status;
    disk_info.file_size = dobj->initial_size;
    disk_info.lastmod = dobj->lastmod;

    niov = 0;
    iov[niov].iov_base = (void*)&format;
    iov[niov++].iov_len = sizeof(format);
    iov[niov].iov_base = (void*)&disk_info;
    iov[niov++].iov_len = sizeof(disk_cache_info_t);

    disk_info.name_len = strlen(dobj->name);
    iov[niov].iov_base = (void*)dobj->name;
    iov[niov++].iov_len = disk_info.name_len;

    if(dobj->initial_size > 0) {
        /* We know the bodyfile is root/bodyname ... */
        char *bodyname = (char *) dobj->bodyfile + dobj->root_len + 1;
        disk_info.bodyname_len = strlen(bodyname);
        iov[niov].iov_base = (void*)bodyname;
        iov[niov++].iov_len = disk_info.bodyname_len;
    }
    else {
        disk_info.bodyname_len = 0;
    }

    if(r->filename != NULL && strlen(r->filename) > 0) {
        disk_info.filename_len = strlen(r->filename);
        iov[niov].iov_base = (void*)r->filename;
        iov[niov++].iov_len = disk_info.filename_len;
    }
    else {
        disk_info.filename_len = 0;
    }

    rv = apr_file_writev(dobj->hfd, (const struct iovec *) &iov, niov, &amt);
    if (rv != APR_SUCCESS) {
        file_cache_errorcleanup(dobj, r);
        return rv;
    }



        headers_out = apr_table_overlay(r->pool, headers_out,
                                        r->err_headers_out);
        rv = store_table(dobj->hfd, headers_out, r);
        if (rv != APR_SUCCESS) {
            file_cache_errorcleanup(dobj, r);
            return rv;
        }
    }


        headers_in = ap_cache_cacheable_hdrs_out(r->pool, r->headers_in,
                                                 r->server);
        rv = store_table(dobj->hfd, headers_in, r);
        if (rv != APR_SUCCESS) {
            file_cache_errorcleanup(dobj, r);
            return rv;
        }
    }

    /* Store it away so we can get it later. */
    dobj->disk_info = disk_info;

    return APR_SUCCESS;
}


static apr_status_t store_headers(cache_handle_t *h, request_rec *r, 
                                  cache_info *info)
{
    disk_cache_conf *conf = ap_get_module_config(r->server->module_config,
                                                 &disk_cache_module);
    apr_status_t rv;
    int rewriting;
    disk_cache_object_t *dobj = (disk_cache_object_t*) h->cache_obj->vobj;
    const char *lastmods;


    /* This is flaky... we need to manage the cache_info differently */
    h->cache_obj->info = *info;

    /* Get last-modified timestamp */
    lastmods = apr_table_get(r->err_headers_out, "Last-Modified");
    if (lastmods == NULL) {
        lastmods = apr_table_get(r->headers_out, "Last-Modified");
    }
    if (lastmods != NULL) {
        dobj->lastmod = apr_date_parse_http(lastmods);
    }

    if(dobj->hfd) {
        rewriting = TRUE;

        /* Don't update header on disk if the following is met:
           - The body size is known.
           - If Last-Modified is known, it has to be identical.
           - It's not expired.
           - Date in cached header isn't older than updtimeout.
         */
        if( dobj->disk_info.file_size >= 0 && (dobj->lastmod == APR_DATE_BAD || 
                dobj->lastmod == dobj->disk_info.lastmod) &&
                dobj->disk_info.expire > r->request_time &&
                dobj->disk_info.date > info->date - dobj->updtimeout) 
        {
            dobj->skipstore = TRUE;

            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                         "disk_cache: store_headers: Headers current for URL "
                         "%s", dobj->name);
        }
        else {
            ap_log_error(APLOG_MARK, APLOG_INFO, 0, r->server,
                         "disk_cache: Rewriting headers for URL %s", 
                         dobj->name);
        }
    }
    else {
        rewriting = FALSE;

        ap_log_error(APLOG_MARK, APLOG_INFO, 0, r->server,
                     "disk_cache: Storing new headers for URL %s", dobj->name);
    }

    if (r->headers_out) {
        const char *tmp;

        tmp = apr_table_get(r->headers_out, "Vary");

        if (tmp) {
            rv = store_vary_header(h, conf, r, info, tmp);
            if(rv != APR_SUCCESS) {
                return rv;
            }
        }
    } 

    if(dobj->skipstore) {
        apr_file_close(dobj->hfd);
        dobj->hfd = NULL;
        return APR_SUCCESS;
    }

    if(rewriting) {
        apr_finfo_t     finfo;

        rv = apr_file_info_get(&finfo, APR_FINFO_MTIME, dobj->hfd);
        if(rv != APR_SUCCESS) {
            return rv;
        }

        /* FIXME: Isn't this a bit redundant? It probably causes more
           trouble than it's fixing, especially since we handle it above
           except for looking at mtime */
        /* Don't store disk headers more often than updtimeout */
        if(dobj->disk_info.file_size >= 0 &&
                dobj->disk_info.expire > r->request_time &&
                r->request_time < finfo.mtime + dobj->updtimeout) 
        {
            dobj->skipstore = TRUE;
        }
        else {
            /* This triggers bugs in APR when using APR_BUFFERED */
            apr_off_t off=0;
            rv = apr_file_seek(dobj->hfd, APR_SET, &off);
            if (rv != APR_SUCCESS) {
                return rv;
            }
            rv = apr_file_trunc(dobj->hfd, 0);
            if(rv != APR_SUCCESS) {
                return rv;
            }
        }

    }
    else {
        rv = open_new_file(r, dobj->hdrsfile, &(dobj->hfd), conf);
        if(rv == CACHE_EEXIST) {
            dobj->skipstore = TRUE;
        }
        else if(rv != APR_SUCCESS) {
            return rv;
        }
    }

    if(dobj->skipstore) {
        if(dobj->hfd) {
            apr_file_close(dobj->hfd);
            dobj->hfd = NULL;
        }
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                     "disk_cache: Skipping store for URL %s: Someone else "
                     "beat us to it",  dobj->name);
        return APR_SUCCESS;
    }

    rv = store_disk_header(dobj, r, info);
    if(rv != APR_SUCCESS) {
        return rv;
    }

    /* If the body size is unknown, the header file will be rewritten later
       so we can't close it */
    if(dobj->initial_size >= 0) {
        rv = apr_file_close(dobj->hfd);
        dobj->hfd = NULL;
        if(rv != APR_SUCCESS) {
            apr_file_remove(dobj->hdrsfile, r->pool);
            return rv;
        }
    }

    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                 "disk_cache: Stored headers for URL %s",  dobj->name);
    return APR_SUCCESS;
}


static apr_status_t check_destfd_timeout(apr_file_t *fd, apr_time_t now,
                                         apr_time_t updtimeout) 
{
    apr_status_t rc;
    apr_finfo_t finfo;

    /* Get mtime and nlink for our opened destfile */
    rc = apr_file_info_get(&finfo, APR_FINFO_MTIME | APR_FINFO_NLINK, fd);
    if(rc != APR_SUCCESS) {
        return rc;
    }

    /* If link count is zero, file is deleted */
    if(finfo.nlink == 0) {
        return APR_ETIMEDOUT;
    }

    /* Check if mtime on destfile shows us having timed out */
    if(now - finfo.mtime > updtimeout) {
        return APR_ETIMEDOUT;
    }

    return APR_SUCCESS;
}


static apr_status_t copy_body(apr_pool_t *p,
                              apr_file_t *srcfd, apr_off_t srcoff, 
                              apr_file_t *destfd, apr_off_t destoff, 
                              apr_off_t len, apr_interval_time_t updtimeout)
{
    apr_status_t rc;
    apr_size_t size;
    apr_finfo_t finfo;
    apr_time_t starttime = apr_time_now();
    apr_time_t last = starttime;
    apr_time_t lastcheck = 0;
    unsigned int i=0, freq=1;
    apr_interval_time_t minintvl = updtimeout/10;
    apr_interval_time_t maxintvl = minintvl*3;

    char *buf = apr_palloc(p, MIN(len, CACHE_BUF_SIZE));
    if (!buf) {
        return APR_ENOMEM;
    }

    if(srcoff != 0) {
        rc = apr_file_seek(srcfd, APR_SET, &srcoff);
        if(rc != APR_SUCCESS) {
            return rc;
        }
    }

    if(destoff != 0) {
        rc = apr_file_seek(destfd, APR_SET, &destoff);
        if(rc != APR_SUCCESS) {
            return rc;
        }
    }

    /* Tried doing this with mmap, but sendfile on Linux got confused when
       sending a file while it was being written to from an mmapped area.
       The traditional way seems to be good enough, and less complex.
     */
    while(len > 0) {
        size=MIN(len, CACHE_BUF_SIZE);

        rc = apr_file_read_full (srcfd, buf, size, NULL);
        if(rc != APR_SUCCESS) {
            return rc;
        }

        /* Do timeout checks before we do the write, this is what other clients
           will see. Don't waste resources by calling apr_time_now() on each
           iteration. */
        if(i++ % freq == 0) {
            apr_time_t now = apr_time_now();
            apr_time_t elapsed = now-last;

            /* Do closer inspection at updtimeout intervals */
            if(now-lastcheck > updtimeout) {
                rc = check_destfd_timeout(destfd, now, updtimeout);
                if(rc != APR_SUCCESS) {
                    return rc;
                }
                lastcheck = now;
            }

            if(elapsed > updtimeout) {
                if(freq > 1) {
                    /* The close inspection above will catch a timeout. 
                       If we get here, make sure we recalibrate at which
                       frequency we should check stuff */
                    freq = 1;
                }
            }
            else if(elapsed < minintvl) {
                freq <<= 1;
                freq |= 1;
            }
            else if(elapsed > maxintvl && freq > 1) {
                freq >>= 1;
            }
            last = now;
        }

        rc = apr_file_write_full(destfd, buf, size, NULL);
        if(rc != APR_SUCCESS) {
            return rc;
        }
        len -= size;
    }

    /* Make sure we are the one having cached the destfile */
    rc = check_destfd_timeout(destfd, apr_time_now(), updtimeout);
    if(rc != APR_SUCCESS) {
        return rc;
    }

    /* Check if file has changed during copying. This is not 100% foolproof
       due to NFS attribute caching when on NFS etc. */
    /* FIXME: Can we assume that we're always copying an entire file? In that
              case we can check if the current filesize matches the length
              we think it is */
    rc = apr_file_info_get(&finfo, APR_FINFO_MTIME, srcfd);
    if(rc != APR_SUCCESS) {
        return rc;
    }
    if(starttime < finfo.mtime) {
        return APR_EGENERAL;
    }

    return APR_SUCCESS;
}


/* Provide srcfile and srcinfo containing
   APR_FINFO_INODE|APR_FINFO_MTIME to make sure we have opened the right file
   (someone might have just replaced it which messes up things).
*/
static apr_status_t copy_body_nofd(apr_pool_t *p, const char *srcfile, 
                                   apr_off_t srcoff, apr_finfo_t *srcinfo,
                                   const char *destfile, apr_off_t destoff, 
                                   apr_off_t len, 
                                   apr_interval_time_t updtimeout)
{
    apr_status_t rc;
    apr_file_t *srcfd, *destfd;
    apr_finfo_t finfo;

    rc = apr_file_open(&srcfd, srcfile, APR_READ | APR_BINARY, 0, p);
    if(rc != APR_SUCCESS) {
        return rc;
    }
    rc = apr_file_info_get(&finfo, APR_FINFO_INODE|APR_FINFO_MTIME, srcfd);
    if(rc != APR_SUCCESS) {
        return rc;
    }
    /* FIXME: Should probably check device too */
    if(srcinfo->inode != finfo.inode || srcinfo->mtime < finfo.mtime) {
        return APR_EGENERAL;
    }

    rc = apr_file_open(&destfd, destfile, APR_WRITE | APR_BINARY, 0, p);
    if(rc != APR_SUCCESS) {
        return rc;
    }

    rc = copy_body(p, srcfd, srcoff, destfd, destoff, len, updtimeout);
    apr_file_close(srcfd);
    if(rc != APR_SUCCESS) {
        apr_file_close(destfd);
        return rc;
    }

    rc = apr_file_close(destfd);

    /* Set mtime on file */
    apr_file_mtime_set(destfile, finfo.mtime, p);

    return rc;
}


#if APR_HAS_THREADS
static apr_status_t bgcopy_thread_cleanup(void *data)
{
    copyinfo *ci = data;
    apr_status_t rc, ret;
    apr_pool_t *p;

    /* FIXME: Debug */
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ci->s,
                 "disk_cache: bgcopy_thread_cleanup: %s -> %s",
                 ci->srcfile, ci->destfile);

    rc = apr_thread_join(&ret, ci->t);
    if(rc != APR_SUCCESS) {
        ap_log_error(APLOG_MARK, APLOG_ERR, rc, ci->s,
                     "disk_cache: bgcopy_thread_cleanup: apr_thread_join "
                     "failed %s -> %s", ci->srcfile, ci->destfile);
        return rc;
    }
    if(ret != APR_SUCCESS) {
        ap_log_error(APLOG_MARK, APLOG_ERR, ret, ci->s,
                     "disk_cache: Background caching body %s -> %s failed",
                     ci->srcfile, ci->destfile);
    }

    /* FIXME: Debug */
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ci->s,
                 "disk_cache: bgcopy_thread_cleanup: SUCCESS %s -> %s",
                 ci->srcfile, ci->destfile);

    /* Destroy our private pool */
    p = ci->pool;
    apr_pool_destroy(p);

    return APR_SUCCESS;
}


static void *bgcopy_thread(apr_thread_t *t, void *data)
{
    copyinfo *ci = data;
    apr_pool_t *p;
    apr_status_t rc;

    p = apr_thread_pool_get(t);

    /* FIXME: Debug */
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ci->s,
                 "disk_cache: bgcopy_thread: start %s -> %s",
                 ci->srcfile, ci->destfile);

    rc = copy_body_nofd(p, ci->srcfile, ci->srcoff, &(ci->srcinfo), 
                        ci->destfile, ci->destoff, ci->len, ci->updtimeout);

    if(rc != APR_ETIMEDOUT && rc != APR_SUCCESS) {
        apr_file_remove(ci->destfile, p);
    }

    /* FIXME: Debug */
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ci->s,
                 "disk_cache: bgcopy_thread: done %s -> %s",
                 ci->srcfile, ci->destfile);

    apr_thread_exit(t, rc);
    return NULL;
}
#endif /* APR_HAS_THREADS */


#if APR_HAS_FORK
static apr_status_t bgcopy_child_cleanup(void *data) {
    copyinfo *ci = data;
    int status;
    apr_exit_why_e why;
    apr_pool_t *p;

    apr_proc_wait(ci->proc, &status, &why, APR_WAIT);
    if(why == APR_PROC_EXIT) {
        if(status != APR_SUCCESS) {
            ap_log_error(APLOG_MARK, APLOG_ERR, status, ci->s,
                         "disk_cache: Background caching body %s -> %s failed",
                         ci->srcfile, ci->destfile);
            return APR_SUCCESS;
        }
    }
    else if(status & (APR_PROC_SIGNAL | APR_PROC_SIGNAL_CORE) ) {
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, ci->s,
                     "disk_cache: Background caching body %s -> %s failed, "
                     "caught signal %d", ci->srcfile, ci->destfile, status);
        return APR_SUCCESS;
    }

    /* Destroy our private pool */
    p = ci->pool;
    apr_pool_destroy(p);

    return APR_SUCCESS;
}
#endif /* APR_HAS_FORK */


static apr_status_t do_bgcopy(apr_file_t *srcfd, apr_off_t srcoff, 
                              apr_file_t *destfd, apr_off_t destoff, 
                              apr_off_t len, apr_interval_time_t updtimeout,
                              conn_rec *c)
{
    copyinfo *ci;
    apr_status_t rv;
    apr_pool_t *newpool;
    const char *srcfile, *destfile;
    int mpm_query_info;

    /* It seems pool gets destroyed (ie. fd's closed) before our cleanup 
       function is called when an error occurs (a dropped connection, for
       example), so we need a pool of our own.
     */
    rv = apr_pool_create(&newpool, NULL);
    if (rv != APR_SUCCESS) {
        return rv;
    }

    ci = apr_palloc(newpool, sizeof(*ci));
    if(ci == NULL) {
        apr_pool_destroy(newpool);
        return APR_ENOMEM;
    }

    rv = apr_file_name_get(&srcfile, srcfd);
    if(rv != APR_SUCCESS) {
        return rv;
    }
    rv = apr_file_info_get(&(ci->srcinfo), APR_FINFO_INODE|APR_FINFO_MTIME,
                           srcfd);
    if(rv != APR_SUCCESS) {
        return rv;
    }

    rv = apr_file_name_get(&destfile, destfd);
    if(rv != APR_SUCCESS) {
        return rv;
    }

    ci->pool = newpool;
    ci->srcfile = apr_pstrdup(newpool, srcfile);
    ci->srcoff = srcoff;
    ci->destfile = apr_pstrdup(newpool, destfile);
    ci->destoff = destoff;
    ci->len = len;
    ci->updtimeout = updtimeout;
    ci->s = c->base_server;

#if APR_HAS_THREADS
    if(ap_mpm_query(AP_MPMQ_IS_THREADED, &mpm_query_info) == APR_SUCCESS) {
        apr_threadattr_t *ta;
        apr_thread_t *t;
        rv = apr_threadattr_create(&ta, newpool);
        if(rv != APR_SUCCESS) {
            apr_pool_destroy(newpool);
            return rv;
        }

        apr_threadattr_detach_set(ta, FALSE);

        /* FIXME: This makes module unloadable on AIX */
#if 0
#ifdef AP_MPM_WANT_SET_STACKSIZE
        if (ap_thread_stacksize != 0) {
            apr_threadattr_stacksize_set(ta, ap_thread_stacksize);
            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, c->base_server,
                    "disk_cache: BG thread stacksize set to %"
                    APR_SIZE_T_FMT, ap_thread_stacksize);
        }
#endif /* AP_MPM_WANT_SET_STACKSIZE */
#endif /* 0 */

        rv = apr_thread_create (&t, ta, bgcopy_thread, ci, newpool);
        if (rv != APR_SUCCESS) {
            apr_pool_destroy(newpool);
            return rv;
        }
        ci->t = t;

        apr_pool_cleanup_register(c->pool, ci, 
                                  bgcopy_thread_cleanup, apr_pool_cleanup_null);
    }
    else
#endif /* APR_HAS_THREADS */
#if APR_HAS_FORK
    if(ap_mpm_query(AP_MPMQ_IS_FORKED, &mpm_query_info) == APR_SUCCESS) {
        ci->proc = apr_palloc(newpool, sizeof(apr_proc_t));
        if(ci->proc == NULL) {
            apr_pool_destroy(newpool);
            return APR_ENOMEM;
        }
        rv = apr_proc_fork(ci->proc, newpool);
        if(rv == APR_INCHILD) {
            /* Child */
            rv = copy_body_nofd(ci->pool, ci->srcfile, ci->srcoff, 
                                &(ci->srcinfo), ci->destfile, ci->destoff, 
                                ci->len, ci->updtimeout);
            if(rv != APR_ETIMEDOUT && rv != APR_SUCCESS) {
                apr_file_remove(ci->destfile, ci->pool);
            }
            exit(rv);
        }
        else if(rv == APR_INPARENT) {
            apr_pool_cleanup_register(c->pool, ci, 
                                      bgcopy_child_cleanup, 
                                      apr_pool_cleanup_null);
        }
        else {
            return rv;
        }
    }
    else 
#endif /* APR_HAS_FORK */
    if(1)
    {
        rv = copy_body(newpool, srcfd, ci->srcoff, destfd, ci->destoff,
                       ci->len, ci->updtimeout);
        apr_pool_destroy(newpool);
    }

    return rv;
}


static apr_status_t replace_brigade_with_cache(cache_handle_t *h,
                                               request_rec *r,
                                               apr_bucket_brigade *bb)
{
    apr_status_t rv;
    apr_bucket *e;
    disk_cache_object_t *dobj = (disk_cache_object_t *) h->cache_obj->vobj;

    if(dobj->bfd) {
        apr_file_close(dobj->bfd);
        dobj->bfd = NULL;
    }

    rv = open_body_timeout(r, h->cache_obj);
    if(rv == CACHE_EDECLINED) {
        return APR_ETIMEDOUT;
    }
    else if(rv != APR_SUCCESS) {
        ap_log_error(APLOG_MARK, APLOG_ERR, rv, r->server,
                     "disk_cache: Error opening bodyfile %s for URL %s",
                     dobj->bodyfile, dobj->name);
        return rv;
    }

    /* First, empty the brigade */
    e  = APR_BRIGADE_FIRST(bb);
    while (e != APR_BRIGADE_SENTINEL(bb)) {
        apr_bucket *d;
        d = e;
        e = APR_BUCKET_NEXT(e);
        apr_bucket_delete(d);
    }

    /* Then, populate it with our cached instance */
    rv = recall_body(h, r->pool, bb);
    if (rv != APR_SUCCESS) {
        ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
                     "disk_cache: Error serving URL %s from cache", dobj->name);
        return rv;
    }
    ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                 "disk_cache: Serving cached body for URL %s", dobj->name);

    return APR_SUCCESS;
}


static apr_status_t store_body(cache_handle_t *h, request_rec *r,
                               apr_bucket_brigade *bb)
{
    apr_bucket *e;
    apr_status_t rv;
    int copy_file = FALSE, first_call = FALSE, did_bgcopy = FALSE;
    disk_cache_object_t *dobj = (disk_cache_object_t *) h->cache_obj->vobj;
    disk_cache_conf *conf = ap_get_module_config(r->server->module_config,
                                                 &disk_cache_module);

    if(r->no_cache) {
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                     "disk_cache: store_body called for URL %s even though"
                     "no_cache is set", dobj->name);
        file_cache_errorcleanup(dobj, r);
        return APR_EGENERAL;
    }

    if(dobj->initial_size == 0) {
        /* Don't waste a body cachefile on a 0 length body */
        return APR_SUCCESS;
    }

    /* Only perform these actions when called the first time */
    if(dobj->bfd == NULL) {
        first_call = TRUE;

        if(dobj->lastmod != APR_DATE_BAD) {
            apr_finfo_t finfo;
            rv = apr_stat(&finfo, dobj->bodyfile, 
                          APR_FINFO_MTIME | APR_FINFO_SIZE | APR_FINFO_CSIZE, 
                          r->pool);
            if(rv == APR_SUCCESS || APR_STATUS_IS_INCOMPLETE(rv)) {
                /* Dest-file will have same mtime as source if it's
                   current */
                /* FIXME: This code and the one used in open_body should
                   probably be identical... */
                if(dobj->lastmod <= finfo.mtime && 
                        dobj->initial_size == finfo.size &&
                        !(finfo.valid & APR_FINFO_CSIZE && finfo.csize < finfo.size))
                {
                    /* Assume it's a valid cached body there already */
                    dobj->skipstore = TRUE;
                }
            }
        }

        if(!dobj->skipstore) {
            /* FIXME: We should pass the source file's size and mtime so
               open_new_file() can more reliably determine if the target
               file is current or stale. */
            rv = open_new_file(r, dobj->bodyfile, &(dobj->bfd), conf);
            if(rv == CACHE_EEXIST) {
                /* Someone else beat us to storing this */
                dobj->skipstore = TRUE;
            }
            else if(rv != APR_SUCCESS) {
                file_cache_errorcleanup(dobj, r);
                apr_file_remove(dobj->hdrsfile, r->pool);
                return rv;
            }
            else {
                dobj->file_size = 0;
            }
        }

        if(dobj->skipstore) {
            /* Someone else beat us to storing this object */
            if( dobj->initial_size > 0 &&
                    APR_BUCKET_IS_EOS(APR_BRIGADE_LAST(bb)) )
            {
                /* Yay, we can replace the body with the cached instance */
                return replace_brigade_with_cache(h, r, bb);
            }

            return APR_SUCCESS;
        }
        dobj->file_size = 0;
    }

    /* Check if this is a complete single sequential file, eligable for
     * file copy.
     */
    /* FIXME: Make the min size to do file copy run-time config? */
    if(dobj->file_size == 0 && 
            dobj->initial_size > APR_BUCKET_BUFF_SIZE &&
            APR_BUCKET_IS_EOS(APR_BRIGADE_LAST(bb)) )
    {
        apr_off_t begin = -1;
        apr_off_t pos = -1;
        apr_file_t *fd = NULL;
        apr_bucket_file *a;

        copy_file = TRUE;

        for (e = APR_BRIGADE_FIRST(bb);
                e != APR_BRIGADE_SENTINEL(bb);
                e = APR_BUCKET_NEXT(e))
        {
            if(APR_BUCKET_IS_EOS(e)) {
                break;
            }
            if(!APR_BUCKET_IS_FILE(e)) {
                copy_file = FALSE;
                break;
            }

            a = e->data;

            if(begin < 0) {
                begin = pos = e->start;
                fd = a->fd;
            }

            if(fd != a->fd || pos != e->start) {
                copy_file = FALSE;
                break;
            }

            pos += e->length;
        }

        if(copy_file) {
            dobj->file_size = pos;
        }
    }

    if(copy_file) {
        apr_bucket_file *a;

        ap_log_error(APLOG_MARK, APLOG_INFO, 0, r->server,
                     "disk_cache: Copying body for URL %s, len %"
                     APR_OFF_T_FMT, dobj->name, dobj->file_size);

        e = APR_BRIGADE_FIRST(bb);
        a = e->data;

        if(dobj->file_size > conf->minbgsize) {
            rv = do_bgcopy(a->fd, e->start, dobj->bfd, 0, dobj->file_size,
                           dobj->updtimeout, r->connection);
            did_bgcopy = TRUE;
        }
        else {
            rv = copy_body(r->pool, a->fd, e->start, dobj->bfd, 0,
                           dobj->file_size, dobj->updtimeout);
        }
        if(rv != APR_SUCCESS) {
            ap_log_error(APLOG_MARK, APLOG_ERR, rv, r->server,
                         "disk_cache: Copying body failed, "
                         "URL %s", dobj->name);
            if(rv != APR_ETIMEDOUT) {
                file_cache_errorcleanup(dobj, r);
                apr_file_remove(dobj->bodyfile, r->pool);
            }
            return rv;
        }

    }
    else {
        if(first_call) {
            ap_log_error(APLOG_MARK, APLOG_INFO, 0, r->server,
                         "disk_cache: Caching body for URL %s, len %"
                         APR_OFF_T_FMT, dobj->name, dobj->initial_size);
        }

        for (e = APR_BRIGADE_FIRST(bb);
                e != APR_BRIGADE_SENTINEL(bb);
                e = APR_BUCKET_NEXT(e))
        {   
            const char *str;
            apr_size_t length, written;

            /* Ignore the non-data-buckets */
            if(APR_BUCKET_IS_METADATA(e)) {
                continue;
            }

            rv = apr_bucket_read(e, &str, &length, APR_BLOCK_READ);
            if (rv != APR_SUCCESS) {
                ap_log_error(APLOG_MARK, APLOG_ERR, rv, r->server,
                             "disk_cache: Error when reading bucket for URL %s",
                             dobj->name);
                file_cache_errorcleanup(dobj, r);
                apr_file_remove(dobj->hdrsfile, r->pool);
                apr_file_remove(dobj->bodyfile, r->pool);
                return rv;
            }
            rv = apr_file_write_full(dobj->bfd, str, length, &written);
            if (rv != APR_SUCCESS) {
                ap_log_error(APLOG_MARK, APLOG_ERR, rv, r->server,
                             "disk_cache: Error when writing cache file for "
                             "URL %s", dobj->name);
                file_cache_errorcleanup(dobj, r);
                apr_file_remove(dobj->hdrsfile, r->pool);
                apr_file_remove(dobj->bodyfile, r->pool);
                return rv;
            }
            dobj->file_size += written;
            if (dobj->file_size > conf->maxfs) {
                ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                             "disk_cache: URL %s failed the size check "
                             "(%" APR_OFF_T_FMT " > %" APR_OFF_T_FMT ")",
                             dobj->name, dobj->file_size, conf->maxfs);
                file_cache_errorcleanup(dobj, r);
                apr_file_remove(dobj->hdrsfile, r->pool);
                apr_file_remove(dobj->bodyfile, r->pool);
                return APR_EGENERAL;
            }
        }
    }


    /* Drop out here if this wasn't the end */
    if (!APR_BUCKET_IS_EOS(APR_BRIGADE_LAST(bb))) {
        return APR_SUCCESS;
    }

    if(!copy_file) {
        ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                     "disk_cache: Done caching URL %s, len %" APR_OFF_T_FMT,
                     dobj->name, dobj->file_size);

        /* FIXME: Do we really need to check r->no_cache here since we checked
           it in the beginning? */
        /* Assume that if we've got an initial size then bucket brigade
           was complete and there's no danger in keeping it even if the
           connection was aborted */
        if (r->no_cache || (r->connection->aborted && dobj->initial_size < 0)) {
            ap_log_error(APLOG_MARK, APLOG_INFO, 0, r->server,
                         "disk_cache: Discarding body for URL %s "
                         "because connection has been aborted.",
                         dobj->name);
            /* Remove the intermediate cache file and return non-APR_SUCCESS */
            file_cache_errorcleanup(dobj, r);
            apr_file_remove(dobj->hdrsfile, r->pool);
            apr_file_remove(dobj->bodyfile, r->pool);
            return APR_EGENERAL;
        }

        if (dobj->file_size < conf->minfs) {
            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                         "disk_cache: URL %s failed the size check "
                         "(%" APR_OFF_T_FMT " < %" APR_OFF_T_FMT ")",
                         dobj->name, dobj->file_size, conf->minfs);
            /* Remove the intermediate cache file and return non-APR_SUCCESS */
            file_cache_errorcleanup(dobj, r);
            apr_file_remove(dobj->hdrsfile, r->pool);
            apr_file_remove(dobj->bodyfile, r->pool);
            return APR_EGENERAL;
        }

        if(dobj->initial_size < 0) {
            /* Update header information now that we know the size */
            dobj->initial_size = dobj->file_size;
            rv = store_headers(h, r, &(h->cache_obj->info));
            if(rv != APR_SUCCESS) {
                file_cache_errorcleanup(dobj, r);
                apr_file_remove(dobj->hdrsfile, r->pool);
                apr_file_remove(dobj->bodyfile, r->pool);
                return rv;
            }
        }
        else if(dobj->initial_size != dobj->file_size) {
            ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, r->server,
                         "disk_cache: URL %s - body size mismatch: suggested %"
                         APR_OFF_T_FMT "  file_size %" APR_OFF_T_FMT ")",
                         dobj->name, dobj->initial_size, dobj->file_size);
            file_cache_errorcleanup(dobj, r);
            apr_file_remove(dobj->hdrsfile, r->pool);
            apr_file_remove(dobj->bodyfile, r->pool);
            return APR_EGENERAL;
        }
    }

    /* All checks were fine, close output file */
    rv = apr_file_close(dobj->bfd);
    dobj->bfd = NULL;
    if(rv != APR_SUCCESS) {
        apr_file_remove(dobj->bodyfile, r->pool);
        file_cache_errorcleanup(dobj, r);
        return rv;
    }

    /* Set mtime on body file */
    if(!did_bgcopy && dobj->lastmod != APR_DATE_BAD) {
        apr_file_mtime_set(dobj->bodyfile, dobj->lastmod, r->pool);
    }


    /* Redirect to cachefile if we copied a plain file */
    if(copy_file) {
        rv = replace_brigade_with_cache(h, r, bb);
        if(rv != APR_SUCCESS) {
            return rv;
        }
    }

    return APR_SUCCESS;

    conf->dirlength = DEFAULT_DIRLENGTH;
    conf->maxfs = DEFAULT_MAX_FILE_SIZE;
    conf->minfs = DEFAULT_MIN_FILE_SIZE;
    conf->updtimeout = DEFAULT_UPDATE_TIMEOUT;
    conf->minbgsize = DEFAULT_MIN_BACKGROUND_SIZE;

    conf->cache_root = NULL;
    conf->cache_root_len = 0;

    conf->dirlevels = val;
    return NULL;
}

static const char
*set_cache_dirlength(cmd_parms *parms, void *in_struct_ptr, const char *arg)
{

    {
        return "CacheMaxFileSize argument must be a non-negative integer representing the max size of a file to cache in bytes.";
    }

    return NULL;
}


static const char
*set_cache_updtimeout(cmd_parms *parms, void *in_struct_ptr, const char *arg)
{
    apr_int64_t val;
    disk_cache_conf *conf = ap_get_module_config(parms->server->module_config,
                                                 &disk_cache_module);

    if (apr_strtoff(&val, arg, NULL, 0) != APR_SUCCESS || val < 0) 
    {
        return "CacheUpdateTimeout argument must be a non-negative integer representing the timeout in milliseconds for cache update operations";
    }

    conf->updtimeout = val * 1000;

    return NULL;
}


static const char
*set_cache_minbgsize(cmd_parms *parms, void *in_struct_ptr, const char *arg)
{
    disk_cache_conf *conf = ap_get_module_config(parms->server->module_config,
                                                 &disk_cache_module);

    if (apr_strtoff(&conf->minbgsize, arg, NULL, 0) != APR_SUCCESS ||
            conf->minbgsize < 0) 
    {
        return "CacheMinBGSize argument must be a non-negative integer representing the min size in bytes for a file to be eligable for background caching";
    }

    return NULL;
}


static const char
*set_cache_removedirs(cmd_parms *parms, void *in_struct_ptr, const char *arg)
{
    disk_cache_conf *conf = ap_get_module_config(parms->server->module_config,
                                                 &disk_cache_module);

    if (strcasecmp(arg, "on") == 0 || strcasecmp(arg, "true")) {
        conf->removedirs = TRUE;
    }
    else if (strcasecmp(arg, "off") == 0 || strcasecmp(arg, "false")) {
        conf->removedirs = FALSE;
    }
    else {
        return "CacheRemoveDirectories argument must be either on, true, off or false";
    }

    return NULL;
}


static const command_rec disk_cache_cmds[] =
{
    AP_INIT_TAKE1("CacheRoot", set_cache_root, NULL, RSRC_CONF,

                  "The minimum file size to cache a document"),
    AP_INIT_TAKE1("CacheMaxFileSize", set_cache_maxfs, NULL, RSRC_CONF,
                  "The maximum file size to cache a document"),
    AP_INIT_TAKE1("CacheUpdateTimeout", set_cache_updtimeout, NULL, RSRC_CONF,
                  "Timeout in ms for cache updates"),
    AP_INIT_TAKE1("CacheMinBGSize", set_cache_minbgsize, NULL, RSRC_CONF,
                  "The minimum file size for background caching"),
    AP_INIT_TAKE1("CacheRemoveDirectories", set_cache_removedirs, NULL, RSRC_CONF,
                  "Should we try to remove directories when we remove expired cache files."),
    {NULL}
};


Lines 22-33 Link Here

(-)dist/modules/cache/mod_disk_cache.h (-21 / +131 lines)
22	*/	22	*/
23		23
24	#define VARY_FORMAT_VERSION 3	24	#define VARY_FORMAT_VERSION 3
25	#define DISK_FORMAT_VERSION 4	25	#define DISK_FORMAT_VERSION_OLD 4
		26	#define DISK_FORMAT_VERSION_OLD2 5
		27	#define DISK_FORMAT_VERSION_OLD3 7
		28	#define DISK_FORMAT_VERSION 8
26		29
27	#define CACHE_HEADER_SUFFIX ".header"	30	#define CACHE_HEADER_SUFFIX ".header"
28	#define CACHE_DATA_SUFFIX ".data"	31	#define CACHE_BODY_SUFFIX ".body"
29	#define CACHE_VDIR_SUFFIX ".vary"	32	#define CACHE_VDIR_SUFFIX ".vary"
30		33
		34	/* Size of buffer used when copying files */
		35	#define CACHE_BUF_SIZE 262144
		36
		37	/* How much the file on disk must have grown beyond the current offset
		38	before diskcache_bucket_read breaks out of the stat/sleep-loop */
		39	#define CACHE_BUCKET_MINCHUNK 524288
		40
		41	/* How long to sleep before retrying while looping (micro-seconds) */
		42	#define CACHE_LOOP_MINSLEEP 10000
		43	#define CACHE_LOOP_MAXSLEEP 1000000
		44
31	#define AP_TEMPFILE_PREFIX "/"	45	#define AP_TEMPFILE_PREFIX "/"
32	#define AP_TEMPFILE_BASE "aptmp"	46	#define AP_TEMPFILE_BASE "aptmp"
33	#define AP_TEMPFILE_SUFFIX "XXXXXX"	47	#define AP_TEMPFILE_SUFFIX "XXXXXX"
Lines 35-56 Link Here
35	#define AP_TEMPFILE_NAMELEN strlen(AP_TEMPFILE_BASE AP_TEMPFILE_SUFFIX)	49	#define AP_TEMPFILE_NAMELEN strlen(AP_TEMPFILE_BASE AP_TEMPFILE_SUFFIX)
36	#define AP_TEMPFILE AP_TEMPFILE_PREFIX AP_TEMPFILE_BASE AP_TEMPFILE_SUFFIX	50	#define AP_TEMPFILE AP_TEMPFILE_PREFIX AP_TEMPFILE_BASE AP_TEMPFILE_SUFFIX
37		51
		52	typedef apr_uint32_t disk_cache_format_t;
		53
38	typedef struct {	54	typedef struct {
39	/* Indicates the format of the header struct stored on-disk. */
40	apr_uint32_t format;
41	/* The HTTP status code returned for this response. */	55	/* The HTTP status code returned for this response. */
42	int status;	56	apr_int32_t status;
43	/* The size of the entity name that follows. */
44	apr_size_t name_len;
45	/* The number of times we've cached this entity. */	57	/* The number of times we've cached this entity. */
46	apr_size_t entity_version;	58	apr_uint32_t entity_version;
47	/* Miscellaneous time values. */	59	/* Miscellaneous time values. */
48	apr_time_t date;	60	apr_time_t date;
49	apr_time_t expire;	61	apr_time_t expire;
50	apr_time_t request_time;	62	apr_time_t request_time;
51	apr_time_t response_time;	63	apr_time_t response_time;
		64	apr_time_t lastmod; /* Last-Modified (if present) */
		65
		66	/* The body size forced to 64bit to not break when people go from non-LFS
		67	* to LFS builds */
		68	apr_int64_t file_size;
		69
		70	/* The size of the entity name that follows. */
		71	apr_uint32_t name_len;
		72	/* The size of the body cache filename */
		73	apr_uint32_t bodyname_len;
		74	/* The size of the filename that follows, to fill in r->filename */
		75	apr_uint32_t filename_len;
		76
		77	/* On disk:
		78	* name_len long string of entity name.
		79	* bodyname_len long string of body cache filename (without cacheroot).
		80	* filename_len long string of filename
		81	*/
52	} disk_cache_info_t;	82	} disk_cache_info_t;
53		83
		84
		85	/* Don't expose module-related stuff unless needed */
		86	#ifdef AP_FILTER_H
54	/*	87	/*
55	* disk_cache_object_t	88	* disk_cache_object_t
56	* Pointed to by cache_object_t::vobj	89	* Pointed to by cache_object_t::vobj
Lines 58-75 Link Here
58	typedef struct disk_cache_object {	91	typedef struct disk_cache_object {
59	const char root; / the location of the cache directory */	92	const char root; / the location of the cache directory */
60	apr_size_t root_len;	93	apr_size_t root_len;
61	char tempfile; / temp file tohold the content */	94
62	const char *prefix;	95	/* Temporary file */
63	const char datafile; / name of file where the data will go */	96	apr_file_t *tfd;
64	const char hdrsfile; / name of file where the hdrs will go */	97	char *tempfile;
65	const char hashfile; / Computed hash key for this URI */	98
66	const char name; / Requested URI without vary bits - suitable for mortals. */	99	/* Header cache file */
67	const char key; / On-disk prefix; URI with Vary bits (if present) */	100	apr_file_t *hfd;
68	apr_file_t fd; / data file */	101	const char *hdrsfile;
69	apr_file_t hfd; / headers file */	102
70	apr_file_t tfd; / temporary file for data */	103	/* Body cache file */
71	apr_off_t file_size; /* File size of the cached data file */	104	apr_file_t *bfd;
72	disk_cache_info_t disk_info; /* Header information. */	105	const char *bodyfile;
		106
		107	const char name; / Requested URI without vary bits -
		108	suitable for mortals. */
		109	const char prefix; / Prefix to deal with Vary headers */
		110	char filename; / Filename of requested URL (if present) */
		111	char *rfilename; / Pointer to r->filename */
		112
		113	apr_off_t initial_size; /* Size of body as reported upstreams */
		114	apr_off_t file_size; /* File size of the cached body */
		115
		116	apr_time_t lastmod; /* Last-Modified (if present) */
		117
		118	int skipstore; /* Set if we should skip storing stuff */
		119
		120	int removedirs; /* Set it we should rmdir when doing rm */
		121
		122	int header_only; /* Copy of r->header_only */
		123
		124	apr_interval_time_t updtimeout; /* Cache update timeout */
		125
		126	disk_cache_info_t disk_info; /* Disk header information. */
73	} disk_cache_object_t;	127	} disk_cache_object_t;
74		128
75		129
Lines 82-95 Link Here
82	#define DEFAULT_DIRLENGTH 2	136	#define DEFAULT_DIRLENGTH 2
83	#define DEFAULT_MIN_FILE_SIZE 1	137	#define DEFAULT_MIN_FILE_SIZE 1
84	#define DEFAULT_MAX_FILE_SIZE 1000000	138	#define DEFAULT_MAX_FILE_SIZE 1000000
		139	/* Background caching disabled by default */
		140	#define DEFAULT_MIN_BACKGROUND_SIZE DEFAULT_MAX_FILE_SIZE
		141	#define DEFAULT_UPDATE_TIMEOUT apr_time_from_sec(10)
85		142
86	typedef struct {	143	typedef struct {
87	const char* cache_root;	144	const char* cache_root;
88	apr_size_t cache_root_len;	145	apr_size_t cache_root_len;
89	int dirlevels; /* Number of levels of subdirectories */	146	int dirlevels; /* Number of levels of subdirectories */
90	int dirlength; /* Length of subdirectory names */	147	int dirlength; /* Length of subdirectory names */
91	apr_off_t minfs; /* minimum file size for cached files */	148	apr_off_t minfs; /* minumum file size for cached files */
92	apr_off_t maxfs; /* maximum file size for cached files */	149	apr_off_t maxfs; /* maximum file size for cached files */
		150	apr_off_t minbgsize; /* minimum file size to do bg caching */
		151	apr_interval_time_t updtimeout; /* Cache update timeout */
		152	int removedirs; /* Should we try to remove directories? */
93	} disk_cache_conf;	153	} disk_cache_conf;
94		154
		155	typedef struct diskcache_bucket_data diskcache_bucket_data;
		156	struct diskcache_bucket_data {
		157	/** Number of buckets using this memory */
		158	apr_bucket_refcount refcount;
		159	apr_file_t *fd;
		160	/** The pool into which any needed structures should
		161	* be created while reading from this file bucket */
		162	apr_pool_t *readpool;
		163	/* Cache update timeout */
		164	apr_interval_time_t updtimeout;
		165	/* Adaptive loop delay timeout */
		166	apr_interval_time_t polldelay;
		167	};
		168
		169	/* Stuff needed by the background copy thread */
		170	typedef struct copyinfo copyinfo;
		171	struct copyinfo {
		172	apr_off_t len;
		173	/* Source info */
		174	const char *srcfile;
		175	apr_finfo_t srcinfo;
		176	apr_off_t srcoff;
		177	/* Destination info */
		178	const char *destfile;
		179	apr_off_t destoff;
		180
		181	/* Cache update timeout */
		182	apr_interval_time_t updtimeout;
		183
		184	/* Our private pool */
		185	apr_pool_t *pool;
		186
		187	#if APR_HAS_THREADS
		188	/* Background process info */
		189	apr_thread_t *t;
		190	#endif /* APR_HAS_THREADS */
		191	#if APR_HAS_FORK
		192	apr_proc_t *proc;
		193	#endif /* APR_HAS_FORK */
		194
		195	/* For logging */
		196	const server_rec *s;
		197	};
		198
		199	#define CACHE_ENODATA (APR_OS_START_USERERR+1)
		200	#define CACHE_EDECLINED (APR_OS_START_USERERR+2)
		201	#define CACHE_EEXIST (APR_OS_START_USERERR+3)
		202
		203	#endif /* AP_FILTER_H */
		204
95	#endif /MOD_DISK_CACHE_H/	205	#endif /MOD_DISK_CACHE_H/




    apr_time_ansi_put(&finfo->atime, info->st_atime);
    apr_time_ansi_put(&finfo->mtime, info->st_mtime);
    apr_time_ansi_put(&finfo->ctime, info->st_ctime);
    /* FIXME: ACC: Needs a configure-test to make sure st_blocks is present */
    if (wanted & APR_FINFO_CSIZE) {
        finfo->csize = info->st_blocks * 512;
        finfo->valid |= APR_FINFO_CSIZE;
    }
     */
}

APR_DECLARE(apr_status_t) apr_file_info_get(apr_finfo_t *finfo, 




typedef struct _direntry {
    APR_RING_ENTRY(_direntry) link;
    int type;         /* type of file/fileset: TEMP, HEADER, DATA, HEADERDATA */
    apr_time_t htime; /* file modification time */
    apr_off_t hsize;  /* file size */
    apr_off_t hsize;  /* headers file size */
    apr_off_t dsize;  /* body or temporary file size */
    char *basename;   /* file/fileset base name */
} DIRENTRY;


    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;         /* file modification time */
    apr_off_t hsize;          /* file size */
    apr_off_t hsize;          /* headers file size */
    apr_off_t dsize;          /* body or temporary file size */
    char *basename;           /* fileset base name */
    char *name;               /* entity name */
} ENTRY;



    /* temp pool, otherwise lots of memory could be allocated */
    apr_pool_create(&p, pool);

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

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

    apr_pool_destroy(p);

    apr_finfo_t info;
    apr_size_t len;
    apr_time_t current, deviation;
    char *nextpath, *base, *orig_basename;
    APR_RING_ENTRY(_direntry) anchor;
    DIRENTRY *d, *t, *n;
    ENTRY *e;

        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 (!realclean) {
            if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)
                && strlen(base) == AP_TEMPFILE_NAMELEN) {
                continue;

            continue;
        }

        if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)
            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;
            d->type = TEMP;
            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;
        }

        /* Assume that everything else are cachefiles */
        d->basename += skip;
        t = apr_hash_get(h, d->basename, APR_HASH_KEY_STRING);
        if (t) {
            d = t;
        }
        d->type |= HEADERDATA;
        d->htime = info.mtime;
        d->hsize = info.size;
        apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
            }
            d->type |= DATA;
            d->dtime = info.mtime;
            d->dsize = info.size;
            apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
        }
    }

    if (interrupted) {


        switch(d->type) {
        case HEADERDATA:
            nextpath = apr_pstrcat(p, path, "/", d->basename, NULL);
                                   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, &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_palloc(pool,
                                                     strlen(d->basename) + 1);
                            strcpy(e->basename, d->basename);
                            e->name = apr_palloc(pool, disk_info.name_len+1);
                            if(apr_file_read_full(fd, e->name,
                                                  disk_info.name_len, NULL)
                                    == APR_SUCCESS)
                            {
                                e->name[disk_info.name_len] = '\0';
                            }
                            else {
                                e->name = "UNKNOWN";
                            }
                            apr_file_close(fd);
                            break;
                        }
                        else {

                    }
                    else if (format == VARY_FORMAT_VERSION) {
                        /* This must be a URL that added Vary headers later,
                         * so kill the orphaned cachefile
                         */
                        apr_file_close(fd);
                        apr_file_remove(apr_pstrcat(p, path, "/", d->basename,
                                                    NULL),
                                        p);
                    }
                }

                || d->htime > current + deviation) {
                delete_entry(path, d->basename, 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);

                        apr_file_read_full(fd, &expires, len, &len);

                        apr_file_close(fd);

                        if (expires < current) {
                            delete_entry(path, d->basename, p);
                        }
                        break;
                    }
                }
                apr_file_close(fd);
            }

            if (realclean || d->htime < current - deviation
                || d->htime > current + deviation) {
                delete_entry(path, d->basename, p);
                unsolicited += d->hsize;
            }
            break;

        case DATA:
            current = apr_time_now();
            if (realclean || d->dtime < current - deviation
                || d->dtime > current + deviation) {
                delete_entry(path, d->basename, p);
                unsolicited += d->dsize;
            }
            break;


         */
        case TEMP:
            delete_file(path, d->basename, p);
            unsolicited += d->hsize;
            break;
        }
    }

         e != APR_RING_SENTINEL(&root, _entry, link);
         e = APR_RING_NEXT(e, link)) {
        sum += e->hsize;
        sum += e->dsize;
        entries++;
    }


    for (e = APR_RING_FIRST(&root);
         e != APR_RING_SENTINEL(&root, _entry, link) && !interrupted;) {
        n = APR_RING_NEXT(e, link);
        if (e->response_time > now || e->htime > now ) {
            delete_entry(path, e->basename, pool);
            sum -= e->hsize;
            sum -= e->dsize;
            entries--;
            APR_RING_REMOVE(e, link);
            if (sum <= max) {

        n = APR_RING_NEXT(e, link);
        if (e->expire != APR_DATE_BAD && e->expire < now) {
            delete_entry(path, e->basename, pool);
            if(verbose > 1) {
                apr_file_printf(errfile, "Expired: %s\n", e->name);
            }
            sum -= e->hsize;
            sum -= e->dsize;
            entries--;
            APR_RING_REMOVE(e, link);
            if (sum <= max) {

        for (e = APR_RING_NEXT(oldest, link);
             e != APR_RING_SENTINEL(&root, _entry, link);
             e = APR_RING_NEXT(e, link)) {
            if (e->htime < oldest->htime) {
                oldest = e;
            }
        }

        delete_entry(path, oldest->basename, pool);
        if(verbose > 1) {
            apr_file_printf(errfile, "Old: (%d s) "
                            "(%" APR_OFF_T_FMT " b) %s\n", 
                            (int) apr_time_sec(apr_time_now() - oldest->htime),
                            oldest->hsize, oldest->name);
        }
        sum -= oldest->hsize;
        sum -= oldest->dsize;
        entries--;
        APR_RING_REMOVE(oldest, link);
    }

                break;

            case 'v':
                verbose++;
                    usage();
                }
                verbose = 1;
                break;

            case 'r':

Return to bug 39380

Lines 331-340 Link Here

(-)dist/modules/cache/cache_storage.c (+30 lines)
331	apr_status_t cache_generate_key_default(request_rec r, apr_pool_t p,	331	apr_status_t cache_generate_key_default(request_rec r, apr_pool_t p,
332	char**key)	332	char**key)
333	{	333	{
		334	cache_request_rec *cache;
334	char port_str, hn, *lcs;	335	char port_str, hn, *lcs;
335	const char hostname, scheme;	336	const char hostname, scheme;
336	int i;	337	int i;
337		338
		339	cache = (cache_request_rec *) ap_get_module_config(r->request_config,
		340	&cache_module);
		341	if (!cache) {
		342	/* This should never happen */
		343	ap_log_error(APLOG_MARK, APLOG_ERR, 0, r->server,
		344	"cache: No cache request information available for key"
		345	" generation");
		346	*key = "";
		347	return APR_EGENERAL;
		348	}
		349	if (cache->key) {
		350	/*
		351	* We have been here before during the processing of this request.
		352	* So return the key we already have.
		353	*/
		354	*key = apr_pstrdup(p, cache->key);
		355	return APR_SUCCESS;
		356	}
		357
338	/*	358	/*
339	* Use the canonical name to improve cache hit rate, but only if this is	359	* Use the canonical name to improve cache hit rate, but only if this is
340	* not a proxy request or if this is a reverse proxy request.	360	* not a proxy request or if this is a reverse proxy request.
Lines 429-433 Link Here
429	*key = apr_pstrcat(p, scheme, "://", hostname, port_str,	449	*key = apr_pstrcat(p, scheme, "://", hostname, port_str,
430	r->parsed_uri.path, "?", r->args, NULL);	450	r->parsed_uri.path, "?", r->args, NULL);
431		451
		452	/*
		453	* Store the key in the request_config for the cache as r->parsed_uri
		454	* might have changed in the time from our first visit here triggered by the
		455	* quick handler and our possible second visit triggered by the CACHE_SAVE
		456	* filter (e.g. r->parsed_uri got unescaped). In this case we would save the
		457	* resource in the cache under a key where it is never found by the quick
		458	* handler during following requests.
		459	*/
		460	cache->key = apr_pstrdup(r->pool, *key);
		461
432	return APR_SUCCESS;	462	return APR_SUCCESS;
433	}	463	}

Lines 243-249 Link Here

(-)dist/modules/cache/cache_util.c (-5 / +21 lines)
243	age = ap_cache_current_age(info, age_c, r->request_time);	243	age = ap_cache_current_age(info, age_c, r->request_time);
244		244
245	/* extract s-maxage */	245	/* extract s-maxage */
246	if (cc_cresp && ap_cache_liststr(r->pool, cc_cresp, "s-maxage", &val)) {	246	if (cc_cresp && ap_cache_liststr(r->pool, cc_cresp, "s-maxage", &val)
		247	&& val != NULL) {
247	smaxage = apr_atoi64(val);	248	smaxage = apr_atoi64(val);
248	}	249	}
249	else {	250	else {
Lines 252-258 Link Here
252		253
253	/* extract max-age from request */	254	/* extract max-age from request */
254	if (!conf->ignorecachecontrol	255	if (!conf->ignorecachecontrol
255	&& cc_req && ap_cache_liststr(r->pool, cc_req, "max-age", &val)) {	256	&& cc_req && ap_cache_liststr(r->pool, cc_req, "max-age", &val)
		257	&& val != NULL) {
256	maxage_req = apr_atoi64(val);	258	maxage_req = apr_atoi64(val);
257	}	259	}
258	else {	260	else {
Lines 260-266 Link Here
260	}	262	}
261		263
262	/* extract max-age from response */	264	/* extract max-age from response */
263	if (cc_cresp && ap_cache_liststr(r->pool, cc_cresp, "max-age", &val)) {	265	if (cc_cresp && ap_cache_liststr(r->pool, cc_cresp, "max-age", &val)
		266	&& val != NULL) {
264	maxage_cresp = apr_atoi64(val);	267	maxage_cresp = apr_atoi64(val);
265	}	268	}
266	else {	269	else {
Lines 282-288 Link Here
282		285
283	/* extract max-stale */	286	/* extract max-stale */
284	if (cc_req && ap_cache_liststr(r->pool, cc_req, "max-stale", &val)) {	287	if (cc_req && ap_cache_liststr(r->pool, cc_req, "max-stale", &val)) {
285	maxstale = apr_atoi64(val);	288	if(val != NULL) {
		289	maxstale = apr_atoi64(val);
		290	}
		291	else {
		292	/* If no value is assigned to max-stale, then the client is willing
		293	* to accept a stale response of any age */
		294	/* Let's pretend 100 years is enough, need margin some marging here
		295	* or the freshness calculation later will overflow */
		296	maxstale = APR_INT64_C(86400365100);
		297	}
286	}	298	}
287	else {	299	else {
288	maxstale = 0;	300	maxstale = 0;
Lines 290-296 Link Here
290		302
291	/* extract min-fresh */	303	/* extract min-fresh */
292	if (!conf->ignorecachecontrol	304	if (!conf->ignorecachecontrol
293	&& cc_req && ap_cache_liststr(r->pool, cc_req, "min-fresh", &val)) {	305	&& cc_req && ap_cache_liststr(r->pool, cc_req, "min-fresh", &val)
		306	&& val != NULL) {
294	minfresh = apr_atoi64(val);	307	minfresh = apr_atoi64(val);
295	}	308	}
296	else {	309	else {
Lines 419-424 Link Here
419	next - val_start);	432	next - val_start);
420	}	433	}
421	}	434	}
		435	else {
		436	*val = NULL;
		437	}
422	}	438	}
423	return 1;	439	return 1;
424	}	440	}

Lines 456-462 Link Here

(-)dist/modules/cache/mod_cache.c (-3 / +4 lines)
456	*/	456	*/
457	reason = "No Last-Modified, Etag, or Expires headers";	457	reason = "No Last-Modified, Etag, or Expires headers";
458	}	458	}
459	else if (r->header_only) {	459	else if (r->header_only && !cache->stale_handle) {
460	/* HEAD requests */	460	/* HEAD requests */
461	reason = "HTTP HEAD request";	461	reason = "HTTP HEAD request";
462	}	462	}
Lines 589-599 Link Here
589	cache->provider->remove_entity(cache->stale_handle);	589	cache->provider->remove_entity(cache->stale_handle);
590	/* Treat the request as if it wasn't conditional. */	590	/* Treat the request as if it wasn't conditional. */
591	cache->stale_handle = NULL;	591	cache->stale_handle = NULL;
		592	rv = !OK;
592	}	593	}
593	}	594	}
594		595
595	/* no cache handle, create a new entity */	596	/* no cache handle, create a new entity only for non-HEAD request */
596	if (!cache->handle) {	597	if (!cache->handle && !r->header_only) {
597	rv = cache_create_entity(r, size);	598	rv = cache_create_entity(r, size);
598	info = apr_pcalloc(r->pool, sizeof(cache_info));	599	info = apr_pcalloc(r->pool, sizeof(cache_info));
599	/* We only set info->status upon the initial creation. */	600	/* We only set info->status upon the initial creation. */

Lines 83-94 Link Here

(-)dist/srclib/apr/file_io/unix/filestat.c (-6 / +5 lines)
83	apr_time_ansi_put(&finfo->atime, info->st_atime);	83	apr_time_ansi_put(&finfo->atime, info->st_atime);
84	apr_time_ansi_put(&finfo->mtime, info->st_mtime);	84	apr_time_ansi_put(&finfo->mtime, info->st_mtime);
85	apr_time_ansi_put(&finfo->ctime, info->st_ctime);	85	apr_time_ansi_put(&finfo->ctime, info->st_ctime);
86	/* ### needs to be revisited	86	/* FIXME: ACC: Needs a configure-test to make sure st_blocks is present */
87	* if (wanted & APR_FINFO_CSIZE) {	87	if (wanted & APR_FINFO_CSIZE) {
88	* finfo->csize = info->st_blocks * 512;	88	finfo->csize = info->st_blocks * 512;
89	* finfo->valid \|= APR_FINFO_CSIZE;	89	finfo->valid \|= APR_FINFO_CSIZE;
90	* }	90	}
91	*/
92	}	91	}
93		92
94	APR_DECLARE(apr_status_t) apr_file_info_get(apr_finfo_t *finfo,	93	APR_DECLARE(apr_status_t) apr_file_info_get(apr_finfo_t *finfo,

Lines 70-79 Link Here

(-)dist/support/htcacheclean.c (-121 / +47 lines)
70	typedef struct _direntry {	70	typedef struct _direntry {
71	APR_RING_ENTRY(_direntry) link;	71	APR_RING_ENTRY(_direntry) link;
72	int type; /* type of file/fileset: TEMP, HEADER, DATA, HEADERDATA */	72	int type; /* type of file/fileset: TEMP, HEADER, DATA, HEADERDATA */
73	apr_time_t htime; /* headers file modification time */	73	apr_time_t htime; /* file modification time */
74	apr_time_t dtime; /* body file modification time */	74	apr_off_t hsize; /* file size */
75	apr_off_t hsize; /* headers file size */
76	apr_off_t dsize; /* body or temporary file size */
77	char basename; / file/fileset base name */	75	char basename; / file/fileset base name */
78	} DIRENTRY;	76	} DIRENTRY;
79		77
Lines 81-91 Link Here
81	APR_RING_ENTRY(_entry) link;	79	APR_RING_ENTRY(_entry) link;
82	apr_time_t expire; /* cache entry exiration time */	80	apr_time_t expire; /* cache entry exiration time */
83	apr_time_t response_time; /* cache entry time of last response to client */	81	apr_time_t response_time; /* cache entry time of last response to client */
84	apr_time_t htime; /* headers file modification time */	82	apr_time_t htime; /* file modification time */
85	apr_time_t dtime; /* body file modification time */	83	apr_off_t hsize; /* file size */
86	apr_off_t hsize; /* headers file size */
87	apr_off_t dsize; /* body or temporary file size */
88	char basename; / fileset base name */	84	char basename; / fileset base name */
		85	char name; / entity name */
89	} ENTRY;	86	} ENTRY;
90		87
91		88
Lines 255-264 Link Here
255	/* temp pool, otherwise lots of memory could be allocated */	252	/* temp pool, otherwise lots of memory could be allocated */
256	apr_pool_create(&p, pool);	253	apr_pool_create(&p, pool);
257		254
258	nextpath = apr_pstrcat(p, path, "/", basename, CACHE_HEADER_SUFFIX, NULL);	255	nextpath = apr_pstrcat(p, path, "/", basename, NULL);
259	apr_file_remove(nextpath, p);
260
261	nextpath = apr_pstrcat(p, path, "/", basename, CACHE_DATA_SUFFIX, NULL);
262	apr_file_remove(nextpath, p);	256	apr_file_remove(nextpath, p);
263		257
264	apr_pool_destroy(p);	258	apr_pool_destroy(p);
Lines 286-292 Link Here
286	apr_finfo_t info;	280	apr_finfo_t info;
287	apr_size_t len;	281	apr_size_t len;
288	apr_time_t current, deviation;	282	apr_time_t current, deviation;
289	char nextpath, base, ext, orig_basename;	283	char nextpath, base, *orig_basename;
290	APR_RING_ENTRY(_direntry) anchor;	284	APR_RING_ENTRY(_direntry) anchor;
291	DIRENTRY d, t, *n;	285	DIRENTRY d, t, *n;
292	ENTRY *e;	286	ENTRY *e;
Lines 329-340 Link Here
329	if (!base++) {	323	if (!base++) {
330	base = d->basename;	324	base = d->basename;
331	}	325	}
332	ext = strchr(base, '.');
333		326
334	/* there may be temporary files which may be gone before	327	/* there may be temporary files which may be gone before
335	* processing, always skip these if not in realclean mode	328	* processing, always skip these if not in realclean mode
336	*/	329	*/
337	if (!ext && !realclean) {	330	if (!realclean) {
338	if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)	331	if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)
339	&& strlen(base) == AP_TEMPFILE_NAMELEN) {	332	&& strlen(base) == AP_TEMPFILE_NAMELEN) {
340	continue;	333	continue;
Lines 386-436 Link Here
386	continue;	379	continue;
387	}	380	}
388		381
389	if (!ext) {	382	if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)
390	if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)
391	&& strlen(base) == AP_TEMPFILE_NAMELEN) {	383	&& strlen(base) == AP_TEMPFILE_NAMELEN) {
392	d->basename += skip;
393	d->type = TEMP;
394	d->dsize = info.size;
395	apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
396	}
397	continue;
398	}
399
400	if (!strcasecmp(ext, CACHE_HEADER_SUFFIX)) {
401	*ext = '\0';
402	d->basename += skip;	384	d->basename += skip;
403	/* if a user manually creates a '.header' file */	385	d->type = TEMP;
404	if (d->basename[0] == '\0') {
405	continue;
406	}
407	t = apr_hash_get(h, d->basename, APR_HASH_KEY_STRING);
408	if (t) {
409	d = t;
410	}
411	d->type \|= HEADER;
412	d->htime = info.mtime;
413	d->hsize = info.size;	386	d->hsize = info.size;
414	apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);	387	apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
415	continue;	388	continue;
416	}	389	}
417		390
418	if (!strcasecmp(ext, CACHE_DATA_SUFFIX)) {	391	/* Assume that everything else are cachefiles */
419	*ext = '\0';	392	d->basename += skip;
420	d->basename += skip;	393	t = apr_hash_get(h, d->basename, APR_HASH_KEY_STRING);
421	/* if a user manually creates a '.data' file */	394	if (t) {
422	if (d->basename[0] == '\0') {	395	d = t;
423	continue;	396	}
424	}	397	d->type \|= HEADERDATA;
425	t = apr_hash_get(h, d->basename, APR_HASH_KEY_STRING);	398	d->htime = info.mtime;
426	if (t) {	399	d->hsize = info.size;
427	d = t;	400	apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
428	}
429	d->type \|= DATA;
430	d->dtime = info.mtime;
431	d->dsize = info.size;
432	apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
433	}
434	}	401	}
435		402
436	if (interrupted) {	403	if (interrupted) {
Lines 448-455 Link Here
448		415
449	switch(d->type) {	416	switch(d->type) {
450	case HEADERDATA:	417	case HEADERDATA:
451	nextpath = apr_pstrcat(p, path, "/", d->basename,	418	nextpath = apr_pstrcat(p, path, "/", d->basename, NULL);
452	CACHE_HEADER_SUFFIX, NULL);
453	if (apr_file_open(&fd, nextpath, APR_FOPEN_READ \| APR_FOPEN_BINARY,	419	if (apr_file_open(&fd, nextpath, APR_FOPEN_READ \| APR_FOPEN_BINARY,
454	APR_OS_DEFAULT, p) == APR_SUCCESS) {	420	APR_OS_DEFAULT, p) == APR_SUCCESS) {
455	len = sizeof(format);	421	len = sizeof(format);
Lines 464-481 Link Here
464		430
465	if (apr_file_read_full(fd, &disk_info, len,	431	if (apr_file_read_full(fd, &disk_info, len,
466	&len) == APR_SUCCESS) {	432	&len) == APR_SUCCESS) {
467	apr_file_close(fd);
468	e = apr_palloc(pool, sizeof(ENTRY));	433	e = apr_palloc(pool, sizeof(ENTRY));
469	APR_RING_INSERT_TAIL(&root, e, _entry, link);	434	APR_RING_INSERT_TAIL(&root, e, _entry, link);
470	e->expire = disk_info.expire;	435	e->expire = disk_info.expire;
471	e->response_time = disk_info.response_time;	436	e->response_time = disk_info.response_time;
472	e->htime = d->htime;	437	e->htime = d->htime;
473	e->dtime = d->dtime;
474	e->hsize = d->hsize;	438	e->hsize = d->hsize;
475	e->dsize = d->dsize;
476	e->basename = apr_palloc(pool,	439	e->basename = apr_palloc(pool,
477	strlen(d->basename) + 1);	440	strlen(d->basename) + 1);
478	strcpy(e->basename, d->basename);	441	strcpy(e->basename, d->basename);
		442	e->name = apr_palloc(pool, disk_info.name_len+1);
		443	if(apr_file_read_full(fd, e->name,
		444	disk_info.name_len, NULL)
		445	== APR_SUCCESS)
		446	{
		447	e->name[disk_info.name_len] = '\0';
		448	}
		449	else {
		450	e->name = "UNKNOWN";
		451	}
		452	apr_file_close(fd);
479	break;	453	break;
480	}	454	}
481	else {	455	else {
Lines 484-494 Link Here
484	}	458	}
485	else if (format == VARY_FORMAT_VERSION) {	459	else if (format == VARY_FORMAT_VERSION) {
486	/* This must be a URL that added Vary headers later,	460	/* This must be a URL that added Vary headers later,
487	* so kill the orphaned .data file	461	* so kill the orphaned cachefile
488	*/	462	*/
489	apr_file_close(fd);	463	apr_file_close(fd);
490	apr_file_remove(apr_pstrcat(p, path, "/", d->basename,	464	apr_file_remove(apr_pstrcat(p, path, "/", d->basename,
491	CACHE_DATA_SUFFIX, NULL),	465	NULL),
492	p);	466	p);
493	}	467	}
494	}	468	}
Lines 509-564 Link Here
509	\|\| d->htime > current + deviation) {	483	\|\| d->htime > current + deviation) {
510	delete_entry(path, d->basename, p);	484	delete_entry(path, d->basename, p);
511	unsolicited += d->hsize;	485	unsolicited += d->hsize;
512	unsolicited += d->dsize;
513	}
514	break;
515
516	/* single data and header files may be deleted either in realclean
517	* mode or if their modification timestamp is not within a
518	* specified positive or negative offset to the current time.
519	* this handling is necessary due to possible race conditions
520	* between apache and this process
521	*/
522	case HEADER:
523	current = apr_time_now();
524	nextpath = apr_pstrcat(p, path, "/", d->basename,
525	CACHE_HEADER_SUFFIX, NULL);
526	if (apr_file_open(&fd, nextpath, APR_FOPEN_READ \| APR_FOPEN_BINARY,
527	APR_OS_DEFAULT, p) == APR_SUCCESS) {
528	len = sizeof(format);
529	if (apr_file_read_full(fd, &format, len,
530	&len) == APR_SUCCESS) {
531	if (format == VARY_FORMAT_VERSION) {
532	apr_time_t expires;
533
534	len = sizeof(expires);
535
536	apr_file_read_full(fd, &expires, len, &len);
537
538	apr_file_close(fd);
539
540	if (expires < current) {
541	delete_entry(path, d->basename, p);
542	}
543	break;
544	}
545	}
546	apr_file_close(fd);
547	}
548
549	if (realclean \|\| d->htime < current - deviation
550	\|\| d->htime > current + deviation) {
551	delete_entry(path, d->basename, p);
552	unsolicited += d->hsize;
553	}
554	break;
555
556	case DATA:
557	current = apr_time_now();
558	if (realclean \|\| d->dtime < current - deviation
559	\|\| d->dtime > current + deviation) {
560	delete_entry(path, d->basename, p);
561	unsolicited += d->dsize;
562	}	486	}
563	break;	487	break;
564		488
Lines 567-573 Link Here
567	*/	491	*/
568	case TEMP:	492	case TEMP:
569	delete_file(path, d->basename, p);	493	delete_file(path, d->basename, p);
570	unsolicited += d->dsize;	494	unsolicited += d->hsize;
571	break;	495	break;
572	}	496	}
573	}	497	}
Lines 604-610 Link Here
604	e != APR_RING_SENTINEL(&root, _entry, link);	528	e != APR_RING_SENTINEL(&root, _entry, link);
605	e = APR_RING_NEXT(e, link)) {	529	e = APR_RING_NEXT(e, link)) {
606	sum += e->hsize;	530	sum += e->hsize;
607	sum += e->dsize;
608	entries++;	531	entries++;
609	}	532	}
610		533
Lines 623-632 Link Here
623	for (e = APR_RING_FIRST(&root);	546	for (e = APR_RING_FIRST(&root);
624	e != APR_RING_SENTINEL(&root, _entry, link) && !interrupted;) {	547	e != APR_RING_SENTINEL(&root, _entry, link) && !interrupted;) {
625	n = APR_RING_NEXT(e, link);	548	n = APR_RING_NEXT(e, link);
626	if (e->response_time > now \|\| e->htime > now \|\| e->dtime > now) {	549	if (e->response_time > now \|\| e->htime > now ) {
627	delete_entry(path, e->basename, pool);	550	delete_entry(path, e->basename, pool);
628	sum -= e->hsize;	551	sum -= e->hsize;
629	sum -= e->dsize;
630	entries--;	552	entries--;
631	APR_RING_REMOVE(e, link);	553	APR_RING_REMOVE(e, link);
632	if (sum <= max) {	554	if (sum <= max) {
Lines 649-656 Link Here
649	n = APR_RING_NEXT(e, link);	571	n = APR_RING_NEXT(e, link);
650	if (e->expire != APR_DATE_BAD && e->expire < now) {	572	if (e->expire != APR_DATE_BAD && e->expire < now) {
651	delete_entry(path, e->basename, pool);	573	delete_entry(path, e->basename, pool);
		574	if(verbose > 1) {
		575	apr_file_printf(errfile, "Expired: %s\n", e->name);
		576	}
652	sum -= e->hsize;	577	sum -= e->hsize;
653	sum -= e->dsize;
654	entries--;	578	entries--;
655	APR_RING_REMOVE(e, link);	579	APR_RING_REMOVE(e, link);
656	if (sum <= max) {	580	if (sum <= max) {
Lines 678-691 Link Here
678	for (e = APR_RING_NEXT(oldest, link);	602	for (e = APR_RING_NEXT(oldest, link);
679	e != APR_RING_SENTINEL(&root, _entry, link);	603	e != APR_RING_SENTINEL(&root, _entry, link);
680	e = APR_RING_NEXT(e, link)) {	604	e = APR_RING_NEXT(e, link)) {
681	if (e->dtime < oldest->dtime) {	605	if (e->htime < oldest->htime) {
682	oldest = e;	606	oldest = e;
683	}	607	}
684	}	608	}
685		609
686	delete_entry(path, oldest->basename, pool);	610	delete_entry(path, oldest->basename, pool);
		611	if(verbose > 1) {
		612	apr_file_printf(errfile, "Old: (%d s) "
		613	"(%" APR_OFF_T_FMT " b) %s\n",
		614	(int) apr_time_sec(apr_time_now() - oldest->htime),
		615	oldest->hsize, oldest->name);
		616	}
687	sum -= oldest->hsize;	617	sum -= oldest->hsize;
688	sum -= oldest->dsize;
689	entries--;	618	entries--;
690	APR_RING_REMOVE(oldest, link);	619	APR_RING_REMOVE(oldest, link);
691	}	620	}
Lines 833-842 Link Here
833	break;	762	break;
834		763
835	case 'v':	764	case 'v':
836	if (verbose) {	765	verbose++;
837	usage();
838	}
839	verbose = 1;
840	break;	766	break;
841		767
842	case 'r':	768	case 'r':