135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_lib.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_strings.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_file_io.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_file_info.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_pools.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_hash.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_thread_proc.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_signal.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_getopt.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_md5.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_ring.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_date.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "apr_buckets.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf#include "../modules/cache/mod_disk_cache.h"

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsf#if APR_HAVE_UNISTD_H

135c1278adef96d36fd421c536b1acc54a341cfbsf#include <unistd.h>

135c1278adef96d36fd421c536b1acc54a341cfbsf#endif

135c1278adef96d36fd421c536b1acc54a341cfbsf#if APR_HAVE_STDLIB_H

135c1278adef96d36fd421c536b1acc54a341cfbsf#include <stdlib.h>

135c1278adef96d36fd421c536b1acc54a341cfbsf#endif

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsf#undef DEBUG

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsf#define NICE_DELAY 10000 /* usecs */

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

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

135c1278adef96d36fd421c536b1acc54a341cfbsf#define STAT_DELAY 5000 /* usecs */

135c1278adef96d36fd421c536b1acc54a341cfbsf#define HEADER 1 /* headers file */

135c1278adef96d36fd421c536b1acc54a341cfbsf#define DATA 2 /* body file */

135c1278adef96d36fd421c536b1acc54a341cfbsf#define TEMP 4 /* temporary file */

135c1278adef96d36fd421c536b1acc54a341cfbsf#define HEADERDATA (HEADER|DATA)

135c1278adef96d36fd421c536b1acc54a341cfbsf#define MAXDEVIATION 3600 /* secs */

135c1278adef96d36fd421c536b1acc54a341cfbsf#define SECS_PER_MIN 60

135c1278adef96d36fd421c536b1acc54a341cfbsf#define KBYTE 1024

135c1278adef96d36fd421c536b1acc54a341cfbsf#define MBYTE 1048576

135c1278adef96d36fd421c536b1acc54a341cfbsf#define GBYTE 1073741824

135c1278adef96d36fd421c536b1acc54a341cfbsf

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

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsftypedef struct _direntry {

135c1278adef96d36fd421c536b1acc54a341cfbsf APR_RING_ENTRY(_direntry) link;

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

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_time_t htime; /* headers file modification time */

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_time_t dtime; /* body file modification time */

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_off_t hsize; /* headers file size */

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

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

135c1278adef96d36fd421c536b1acc54a341cfbsf} DIRENTRY;

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsftypedef struct _entry {

135c1278adef96d36fd421c536b1acc54a341cfbsf APR_RING_ENTRY(_entry) link;

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_time_t expire; /* cache entry exiration time */

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

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_time_t htime; /* headers file modification time */

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_time_t dtime; /* body file modification time */

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_off_t hsize; /* headers file size */

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

135c1278adef96d36fd421c536b1acc54a341cfbsf char *basename; /* fileset base name */

135c1278adef96d36fd421c536b1acc54a341cfbsf} ENTRY;

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsfstatic int delcount; /* file deletion count for nice mode */

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

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

135c1278adef96d36fd421c536b1acc54a341cfbsfstatic int verbose; /* flag: true means print statistics */

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

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

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

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

135c1278adef96d36fd421c536b1acc54a341cfbsfstatic apr_time_t now; /* start time of this processing run */

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsfstatic apr_file_t *errfile; /* stderr file handle */

135c1278adef96d36fd421c536b1acc54a341cfbsfstatic apr_off_t unsolicited; /* file size summary for deleted unsolicited

135c1278adef96d36fd421c536b1acc54a341cfbsfstatic APR_RING_ENTRY(_entry) root; /* ENTRY ring anchor */

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsfstatic const char *shortname = "htcacheclean";

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsfstruct stats {

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_off_t total;

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_off_t sum;

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_off_t max;

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_off_t etotal;

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_off_t entries;

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_off_t dfuture;

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_off_t dexpired;

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_off_t dfresh;

135c1278adef96d36fd421c536b1acc54a341cfbsf};

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsf

135c1278adef96d36fd421c536b1acc54a341cfbsf#ifdef DEBUG

135c1278adef96d36fd421c536b1acc54a341cfbsf#define apr_file_remove fake_file_remove

135c1278adef96d36fd421c536b1acc54a341cfbsfstatic void fake_file_remove(char *pathname, apr_pool_t *p)

135c1278adef96d36fd421c536b1acc54a341cfbsf{

135c1278adef96d36fd421c536b1acc54a341cfbsf apr_finfo_t info;

135c1278adef96d36fd421c536b1acc54a341cfbsf

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

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

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

135c1278adef96d36fd421c536b1acc54a341cfbsf}

135c1278adef96d36fd421c536b1acc54a341cfbsf#endif

static void setterm(int unused)

{

#ifdef DEBUG

apr_file_printf(errfile, "interrupt" APR_EOL_STR);

#endif

interrupted = 1;

}

static int oom(int unused)

{

static int called = 0;

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

if (!called) {

called = 1;

exit(1);

}

return APR_ENOMEM;

}

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

{

char ttype, stype, mtype, utype;

apr_off_t tfrag, sfrag, ufrag;

if (!verbose) {

return;

}

ttype = 'K';

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

s->total /= KBYTE;

if (s->total >= KBYTE) {

ttype = 'M';

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

s->total /= KBYTE;

}

stype = 'K';

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

s->sum /= KBYTE;

if (s->sum >= KBYTE) {

stype = 'M';

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

s->sum /= KBYTE;

}

mtype = 'K';

s->max /= KBYTE;

if (s->max >= KBYTE) {

mtype = 'M';

s->max /= KBYTE;

}

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

if (unsolicited) {

utype = 'K';

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

unsolicited /= KBYTE;

if (unsolicited >= KBYTE) {

utype = 'M';

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

unsolicited /= KBYTE;

}

if (!unsolicited && !ufrag) {

ufrag = 1;

}

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

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

}

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

(int)(s->max), mtype);

apr_file_printf(errfile, "total size was %d.%d%c, total size now "

"%d.%d%c" APR_EOL_STR,

(int)(s->total), (int)(tfrag), ttype,

(int)(s->sum), (int)(sfrag), stype);

apr_file_printf(errfile, "total entries was %d, total entries now %d"

APR_EOL_STR, (int)(s->etotal),

(int)(s->entries));

apr_file_printf(errfile, "%d entries deleted (%d from future, %d "

"expired, %d fresh)" APR_EOL_STR,

(int)(s->etotal - s->entries), (int)(s->dfuture),

(int)(s->dexpired), (int)(s->dfresh));

}

static void delete_file(char *path, char *basename, apr_pool_t *pool)

{

char *nextpath;

apr_pool_t *p;

if (dryrun) {

return;

}

/* 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);

apr_pool_destroy(p);

if (benice) {

if (++delcount >= DELETE_NICE) {

apr_sleep(NICE_DELAY);

delcount = 0;

}

}

}

static void delete_entry(char *path, char *basename, apr_pool_t *pool)

{

char *nextpath;

apr_pool_t *p;

if (dryrun) {

return;

}

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

apr_pool_create(&p, pool);

nextpath = apr_pstrcat(p, path, "/", basename, CACHE_HEADER_SUFFIX, 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);

if (benice) {

delcount += 2;

if (delcount >= DELETE_NICE) {

apr_sleep(NICE_DELAY);

delcount = 0;

}

}

}

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

{

apr_dir_t *dir;

apr_pool_t *p;

apr_hash_t *h;

apr_hash_index_t *i;

apr_file_t *fd;

apr_status_t status;

apr_finfo_t info;

apr_size_t len;

apr_time_t current, deviation;

char *nextpath, *base, *ext, *orig_basename;

APR_RING_ENTRY(_direntry) anchor;

DIRENTRY *d, *t, *n;

ENTRY *e;

int skip, retries;

disk_cache_info_t disk_info;

APR_RING_INIT(&anchor, _direntry, link);

apr_pool_create(&p, pool);

h = apr_hash_make(p);

fd = NULL;

skip = 0;

deviation = MAXDEVIATION * APR_USEC_PER_SEC;

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

return 1;

}

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

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

continue;

}

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

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

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

}

apr_dir_close(dir);

if (interrupted) {

return 1;

}

skip = baselen + 1;

for (d = APR_RING_FIRST(&anchor);

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

d=n) {

n = APR_RING_NEXT(d, link);

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

if (!base++) {

base = d->basename;

}

ext = strchr(base, '.');

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

if (!ext && !realclean) {

if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)

&& strlen(base) == AP_TEMPFILE_NAMELEN) {

continue;

}

}

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

retries = STAT_ATTEMPTS;

status = APR_SUCCESS;

do {

if (status != APR_SUCCESS) {

apr_sleep(STAT_DELAY);

}

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

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

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

if (status != APR_SUCCESS) {

if (!realclean && !interrupted) {

continue;

}

return 1;

}

if (info.filetype == APR_DIR) {

/* Make a copy of the basename, as process_dir modifies it */

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

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

return 1;

}

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

if (deldirs && !dryrun) {

apr_dir_remove(orig_basename, pool);

}

continue;

}

if (info.filetype != APR_REG) {

continue;

}

if (!ext) {

if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)

&& strlen(base) == AP_TEMPFILE_NAMELEN) {

d->basename += skip;

d->type = TEMP;

d->dsize = info.size;

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

}

continue;

}

if (!strcasecmp(ext, CACHE_HEADER_SUFFIX)) {

*ext = '\0';

d->basename += skip;

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

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

continue;

}

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

if (t) {

d = t;

}

d->type |= HEADER;

d->htime = info.mtime;

d->hsize = info.size;

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

continue;

}

if (!strcasecmp(ext, CACHE_DATA_SUFFIX)) {

*ext = '\0';

d->basename += skip;

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

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

continue;

}

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

if (t) {

d = t;

}

d->type |= DATA;

d->dtime = info.mtime;

d->dsize = info.size;

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

}

}

if (interrupted) {

return 1;

}

path[baselen] = '\0';

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

void *hvalue;

apr_uint32_t format;

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

d = hvalue;

switch(d->type) {

case HEADERDATA:

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

CACHE_HEADER_SUFFIX, NULL);

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

APR_OS_DEFAULT, p) == APR_SUCCESS) {

len = sizeof(format);

if (apr_file_read_full(fd, &format, len,

&len) == APR_SUCCESS) {

if (format == DISK_FORMAT_VERSION) {

apr_off_t offset = 0;

apr_file_seek(fd, APR_SET, &offset);

len = sizeof(disk_cache_info_t);

if (apr_file_read_full(fd, &disk_info, len,

&len) == APR_SUCCESS) {

apr_file_close(fd);

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

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

e->expire = disk_info.expire;

e->response_time = disk_info.response_time;

e->htime = d->htime;

e->dtime = d->dtime;

e->hsize = d->hsize;

e->dsize = d->dsize;

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

break;

}

else {

apr_file_close(fd);

}

}

else if (format == VARY_FORMAT_VERSION) {

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

apr_file_close(fd);

apr_file_remove(apr_pstrcat(p, path, "/", d->basename,

CACHE_DATA_SUFFIX, NULL),

p);

break;

}

else {

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

apr_file_close(fd);

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

break;

}

}

else {

apr_file_close(fd);

}

}

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

current = apr_time_now();

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

|| 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

case HEADER:

current = apr_time_now();

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

CACHE_HEADER_SUFFIX, NULL);

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

APR_OS_DEFAULT, p) == APR_SUCCESS) {

len = sizeof(format);

if (apr_file_read_full(fd, &format, len,

&len) == APR_SUCCESS) {

if (format == VARY_FORMAT_VERSION) {

apr_time_t expires;

len = sizeof(expires);

if (apr_file_read_full(fd, &expires, len,

&len) == APR_SUCCESS) {

apr_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;

/* temp files may only be deleted in realclean mode which

case TEMP:

delete_file(path, d->basename, p);

unsolicited += d->dsize;

break;

}

}

if (interrupted) {

return 1;

}

apr_pool_destroy(p);

if (benice) {

apr_sleep(NICE_DELAY);

}

if (interrupted) {

return 1;

}

return 0;

}

static void purge(char *path, apr_pool_t *pool, apr_off_t max)

{

ENTRY *e, *n, *oldest;

struct stats s;

s.sum = 0;

s.entries = 0;

s.dfuture = 0;

s.dexpired = 0;

s.dfresh = 0;

s.max = max;

for (e = APR_RING_FIRST(&root);

e != APR_RING_SENTINEL(&root, _entry, link);

e = APR_RING_NEXT(e, link)) {

s.sum += e->hsize;

s.sum += e->dsize;

s.entries++;

}

s.total = s.sum;

s.etotal = s.entries;

if (s.sum <= s.max) {

printstats(path, &s);

return;

}

/* process all entries with a timestamp in the future, this may

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 || e->dtime > now) {

delete_entry(path, e->basename, pool);

s.sum -= e->hsize;

s.sum -= e->dsize;

s.entries--;

s.dfuture++;

APR_RING_REMOVE(e, link);

if (s.sum <= s.max) {

if (!interrupted) {

printstats(path, &s);

}

return;

}

}

e = n;

}

if (interrupted) {

return;

}

/* process all entries with are expired */

for (e = APR_RING_FIRST(&root);

e != APR_RING_SENTINEL(&root, _entry, link) && !interrupted;) {

n = APR_RING_NEXT(e, link);

if (e->expire != APR_DATE_BAD && e->expire < now) {

delete_entry(path, e->basename, pool);

s.sum -= e->hsize;

s.sum -= e->dsize;

s.entries--;

s.dexpired++;

APR_RING_REMOVE(e, link);

if (s.sum <= s.max) {

if (!interrupted) {

printstats(path, &s);

}

return;

}

}

e = n;

}

if (interrupted) {

return;

}

/* process remaining entries oldest to newest, the check for an emtpy

while (s.sum > s.max && !interrupted

&& !APR_RING_EMPTY(&root, _entry, link)) {

oldest = APR_RING_FIRST(&root);

for (e = APR_RING_NEXT(oldest, link);

e != APR_RING_SENTINEL(&root, _entry, link);

e = APR_RING_NEXT(e, link)) {

if (e->dtime < oldest->dtime) {

oldest = e;

}

}

delete_entry(path, oldest->basename, pool);

s.sum -= oldest->hsize;

s.sum -= oldest->dsize;

s.entries--;

s.dfresh++;

APR_RING_REMOVE(oldest, link);

}

if (!interrupted) {

printstats(path, &s);

}

}

static apr_status_t remove_directory(apr_pool_t *pool, const char *dir)

{

apr_status_t rv;

apr_dir_t *dirp;

apr_finfo_t dirent;

rv = apr_dir_open(&dirp, dir, pool);

if (rv == APR_ENOENT) {

return rv;

}

if (rv != APR_SUCCESS) {

char errmsg[120];

apr_file_printf(errfile, "Could not open directory %s: %s" APR_EOL_STR,

dir, apr_strerror(rv, errmsg, sizeof errmsg));

return rv;

}

while (apr_dir_read(&dirent, APR_FINFO_DIRENT | APR_FINFO_TYPE, dirp)

== APR_SUCCESS) {

if (dirent.filetype == APR_DIR) {

if (strcmp(dirent.name, ".") && strcmp(dirent.name, "..")) {

rv = remove_directory(pool, apr_pstrcat(pool, dir, "/",

dirent.name, NULL));

/* tolerate the directory not being empty, the cache may have

if (APR_SUCCESS != rv && APR_ENOTEMPTY != rv) {

break;

}

}

} else {

const char *file = apr_pstrcat(pool, dir, "/", dirent.name, NULL);

rv = apr_file_remove(file, pool);

if (APR_SUCCESS != rv) {

char errmsg[120];

apr_file_printf(errfile,

"Could not remove file '%s': %s" APR_EOL_STR, file,

apr_strerror(rv, errmsg, sizeof errmsg));

break;

}

}

}

apr_dir_close(dirp);

if (rv == APR_SUCCESS) {

rv = apr_dir_remove(dir, pool);

if (APR_ENOTEMPTY == rv) {

rv = APR_SUCCESS;

}

if (rv != APR_SUCCESS) {

char errmsg[120];

apr_file_printf(errfile, "Could not remove directory %s: %s" APR_EOL_STR,

dir, apr_strerror(rv, errmsg, sizeof errmsg));

}

}

return rv;

}

static apr_status_t find_directory(apr_pool_t *pool, const char *base,

const char *rest)

{

apr_status_t rv;

apr_dir_t *dirp;

apr_finfo_t dirent;

int found = 0, files = 0;

const char *header = apr_pstrcat(pool, rest, CACHE_HEADER_SUFFIX, NULL);

const char *data = apr_pstrcat(pool, rest, CACHE_DATA_SUFFIX, NULL);

const char *vdir = apr_pstrcat(pool, rest, CACHE_HEADER_SUFFIX,

CACHE_VDIR_SUFFIX, NULL);

const char *dirname = NULL;

rv = apr_dir_open(&dirp, base, pool);

if (rv != APR_SUCCESS) {

char errmsg[120];

apr_file_printf(errfile, "Could not open directory %s: %s" APR_EOL_STR,

base, apr_strerror(rv, errmsg, sizeof errmsg));

return rv;

}

rv = APR_ENOENT;

while (apr_dir_read(&dirent, APR_FINFO_DIRENT | APR_FINFO_TYPE, dirp)

== APR_SUCCESS) {

int len = strlen(dirent.name);

int restlen = strlen(rest);

if (dirent.filetype == APR_DIR && !strncmp(rest, dirent.name, len)) {

dirname = apr_pstrcat(pool, base, "/", dirent.name, NULL);

rv = find_directory(pool, dirname, rest + (len < restlen ? len

: restlen));

if (APR_SUCCESS == rv) {

found = 1;

}

}

if (dirent.filetype == APR_DIR) {

if (!strcmp(dirent.name, vdir)) {

files = 1;

}

}

if (dirent.filetype == APR_REG) {

if (!strcmp(dirent.name, header) || !strcmp(dirent.name, data)) {

files = 1;

}

}

}

apr_dir_close(dirp);

if (files) {

rv = APR_SUCCESS;

if (!dryrun) {

const char *remove;

apr_status_t status;

remove = apr_pstrcat(pool, base, "/", header, NULL);

status = apr_file_remove(remove, pool);

if (status != APR_SUCCESS && status != APR_ENOENT) {

char errmsg[120];

apr_file_printf(errfile, "Could not remove file %s: %s" APR_EOL_STR,

remove, apr_strerror(status, errmsg, sizeof errmsg));

rv = status;

}

remove = apr_pstrcat(pool, base, "/", data, NULL);

status = apr_file_remove(remove, pool);

if (status != APR_SUCCESS && status != APR_ENOENT) {

char errmsg[120];

apr_file_printf(errfile, "Could not remove file %s: %s" APR_EOL_STR,

remove, apr_strerror(status, errmsg, sizeof errmsg));

rv = status;

}

status = remove_directory(pool, apr_pstrcat(pool, base, "/", vdir, NULL));

if (status != APR_SUCCESS && status != APR_ENOENT) {

rv = status;

}

}

}

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

if (dirname && deldirs && !dryrun) {

apr_dir_remove(dirname, pool);

}

if (found) {

return APR_SUCCESS;

}

return rv;

}

static apr_status_t delete_url(apr_pool_t *pool, const char *proxypath, const char *url)

{

apr_md5_ctx_t context;

unsigned char digest[16];

char tmp[23];

int i, k;

unsigned int x;

static const char enc_table[64] =

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_@";

apr_md5_init(&context);

apr_md5_update(&context, (const unsigned char *) url, strlen(url));

apr_md5_final(digest, &context);

/* encode 128 bits as 22 characters, using a modified uuencoding

for (i = 0, k = 0; i < 15; i += 3) {

x = (digest[i] << 16) | (digest[i + 1] << 8) | digest[i + 2];

tmp[k++] = enc_table[x >> 18];

tmp[k++] = enc_table[(x >> 12) & 0x3f];

tmp[k++] = enc_table[(x >> 6) & 0x3f];

tmp[k++] = enc_table[x & 0x3f];

}

/* one byte left */

x = digest[15];

tmp[k++] = enc_table[x >> 2]; /* use up 6 bits */

tmp[k++] = enc_table[(x << 4) & 0x3f];

tmp[k] = 0;

/* automatically find the directory levels */

return find_directory(pool, proxypath, tmp);

}

#define NL APR_EOL_STR

static void usage(const char *error)

{

if (error) {

apr_file_printf(errfile, "%s error: %s\n", shortname, error);

}

apr_file_printf(errfile,

"%s -- program for cleaning the disk cache." NL

"Usage: %s [-Dvtrn] -pPATH -lLIMIT [-PPIDFILE]" NL

" %s [-nti] -dINTERVAL -pPATH -lLIMIT [-PPIDFILE]" NL

" %s [-Dvt] -pPATH URL ..." NL

NL

"Options:" NL

" -d Daemonize and repeat cache cleaning every INTERVAL minutes." NL

" This option is mutually exclusive with the -D, -v and -r" NL

" options." NL

NL

" -D Do a dry run and don't delete anything. This option is mutually" NL

" exclusive with the -d option." NL

NL

" -v Be verbose and print statistics. This option is mutually" NL

" exclusive with the -d option." NL

NL

" -r Clean thoroughly. This assumes that the Apache web server is " NL

" not running. This option is mutually exclusive with the -d" NL

" option and implies -t." NL

NL

" -n Be nice. This causes slower processing in favour of other" NL

" processes." NL

NL

" -t Delete all empty directories. By default only cache files are" NL

" removed, however with some configurations the large number of" NL

" directories created may require attention." NL

NL

" -p Specify PATH as the root directory of the disk cache." NL

NL

" -P Specify PIDFILE as the file to write the pid to." NL

NL

" -l Specify LIMIT as the total disk cache size limit. Attach 'K'" NL

" or 'M' to the number for specifying KBytes or MBytes." NL

NL

" -i Be intelligent and run only when there was a modification of" NL

" the disk cache. This option is only possible together with the" NL

" -d option." NL

NL

"Should an URL be provided on the command line, the URL will be" NL

"deleted from the cache. A reverse proxied URL is made up as follows:" NL

"http://<hostname>:<port><path>?[query]. So, for the path \"/\" on the" NL

"host \"localhost\" and port 80, the URL to delete becomes" NL

"\"http://localhost:80/?\". Note the '?' in the URL must always be" NL

"specified explicitly, whether a query string is present or not." NL,

shortname,

shortname,

shortname,

shortname

);

exit(1);

}

#undef NL

static void usage_repeated_arg(apr_pool_t *pool, char option) {

usage(apr_psprintf(pool,

"The option '%c' cannot be specified more than once",

option));

}

static void log_pid(apr_pool_t *pool, const char *pidfilename, apr_file_t **pidfile)

{

apr_status_t status;

char errmsg[120];

pid_t mypid = getpid();

if (APR_SUCCESS == (status = apr_file_open(pidfile, pidfilename,

APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE |

APR_FOPEN_DELONCLOSE, APR_FPROT_UREAD | APR_FPROT_UWRITE |

APR_FPROT_GREAD | APR_FPROT_WREAD, pool))) {

apr_file_printf(*pidfile, "%" APR_PID_T_FMT APR_EOL_STR, mypid);

}

else {

if (errfile) {

apr_file_printf(errfile,

"Could not write the pid file '%s': %s" APR_EOL_STR,

pidfilename,

apr_strerror(status, errmsg, sizeof errmsg));

}

exit(1);

}

}

int main(int argc, const char * const argv[])

{

apr_off_t max;

apr_time_t current, repeat, delay, previous;

apr_status_t status;

apr_pool_t *pool, *instance;

apr_getopt_t *o;

apr_finfo_t info;

apr_file_t *pidfile;

int retries, isdaemon, limit_found, intelligent, dowork;

char opt;

const char *arg;

char *proxypath, *path, *pidfilename;

char errmsg[1024];

interrupted = 0;

repeat = 0;

isdaemon = 0;

dryrun = 0;

limit_found = 0;

max = 0;

verbose = 0;

realclean = 0;

benice = 0;

deldirs = 0;

intelligent = 0;

previous = 0; /* avoid compiler warning */

proxypath = NULL;

pidfilename = NULL;

if (apr_app_initialize(&argc, &argv, NULL) != APR_SUCCESS) {

return 1;

}

atexit(apr_terminate);

if (argc) {

shortname = apr_filepath_name_get(argv[0]);

}

if (apr_pool_create(&pool, NULL) != APR_SUCCESS) {

return 1;

}

apr_pool_abort_set(oom, pool);

apr_file_open_stderr(&errfile, pool);

apr_signal(SIGINT, setterm);

apr_signal(SIGTERM, setterm);

apr_getopt_init(&o, pool, argc, argv);

while (1) {

status = apr_getopt(o, "iDnvrtd:l:L:p:P:", &opt, &arg);

if (status == APR_EOF) {

break;

}

else if (status != APR_SUCCESS) {

usage(NULL);

}

else {

switch (opt) {

case 'i':

if (intelligent) {

usage_repeated_arg(pool, opt);

}

intelligent = 1;

break;

case 'D':

if (dryrun) {

usage_repeated_arg(pool, opt);

}

dryrun = 1;

break;

case 'n':

if (benice) {

usage_repeated_arg(pool, opt);

}

benice = 1;

break;

case 't':

if (deldirs) {

usage_repeated_arg(pool, opt);

}

deldirs = 1;

break;

case 'v':

if (verbose) {

usage_repeated_arg(pool, opt);

}

verbose = 1;

break;

case 'r':

if (realclean) {

usage_repeated_arg(pool, opt);

}

realclean = 1;

deldirs = 1;

break;

case 'd':

if (isdaemon) {

usage_repeated_arg(pool, opt);

}

isdaemon = 1;

repeat = apr_atoi64(arg);

repeat *= SECS_PER_MIN;

repeat *= APR_USEC_PER_SEC;

break;

case 'l':

if (limit_found) {

usage_repeated_arg(pool, opt);

}

limit_found = 1;

do {

apr_status_t rv;

char *end;

rv = apr_strtoff(&max, arg, &end, 10);

if (rv == APR_SUCCESS) {

if ((*end == 'K' || *end == 'k') && !end[1]) {

max *= KBYTE;

}

else if ((*end == 'M' || *end == 'm') && !end[1]) {

max *= MBYTE;

}

else if ((*end == 'G' || *end == 'g') && !end[1]) {

max *= GBYTE;

}

else if (*end && /* neither empty nor [Bb] */

((*end != 'B' && *end != 'b') || end[1])) {

rv = APR_EGENERAL;

}

}

if (rv != APR_SUCCESS) {

usage(apr_psprintf(pool, "Invalid limit: %s"

APR_EOL_STR APR_EOL_STR, arg));

}

} while(0);

break;

case 'p':

if (proxypath) {

usage_repeated_arg(pool, opt);

}

proxypath = apr_pstrdup(pool, arg);

if ((status = apr_filepath_set(proxypath, pool)) != APR_SUCCESS) {

usage(apr_psprintf(pool, "Could not set filepath to '%s': %s",

proxypath, apr_strerror(status, errmsg, sizeof errmsg)));

}

break;

case 'P':

if (pidfilename) {

usage_repeated_arg(pool, opt);

}

pidfilename = apr_pstrdup(pool, arg);

break;

} /* switch */

} /* else */

} /* while */

if (argc <= 1) {

usage(NULL);

}

if (o->ind < argc) {

int deleted = 0;

int error = 0;

if (isdaemon) {

usage("Option -d cannot be used with URL arguments, aborting");

}

if (intelligent) {

usage("Option -i cannot be used with URL arguments, aborting");

}

if (limit_found) {

usage("Option -l cannot be used with URL arguments, aborting");

}

while (o->ind < argc) {

status = delete_url(pool, proxypath, argv[o->ind]);

if (APR_SUCCESS == status) {

if (verbose) {

apr_file_printf(errfile, "Removed: %s" APR_EOL_STR,

argv[o->ind]);

}

deleted = 1;

}

else if (APR_ENOENT == status) {

if (verbose) {

apr_file_printf(errfile, "Not cached: %s" APR_EOL_STR,

argv[o->ind]);

}

}

else {

if (verbose) {

apr_file_printf(errfile, "Error while removed: %s" APR_EOL_STR,

argv[o->ind]);

}

error = 1;

}

o->ind++;

}

return error ? 1 : deleted ? 0 : 2;

}

if (isdaemon && repeat <= 0) {

usage("Option -d must be greater than zero");

}

if (isdaemon && (verbose || realclean || dryrun)) {

usage("Option -d cannot be used with -v, -r or -D");

}

if (!isdaemon && intelligent) {

usage("Option -i cannot be used without -d");

}

if (!proxypath) {

usage("Option -p must be specified");

}

if (max <= 0) {

usage("Option -l must be greater than zero");

}

if (apr_filepath_get(&path, 0, pool) != APR_SUCCESS) {

usage(apr_psprintf(pool, "Could not get the filepath: %s",

apr_strerror(status, errmsg, sizeof errmsg)));

}

baselen = strlen(path);

if (pidfilename) {

log_pid(pool, pidfilename, &pidfile); /* before daemonizing, so we

}

#ifndef DEBUG

if (isdaemon) {

apr_file_close(errfile);

errfile = NULL;

if (pidfilename) {

apr_file_close(pidfile); /* delete original pidfile only in parent */

}

apr_proc_detach(APR_PROC_DETACH_DAEMONIZE);

if (pidfilename) {

log_pid(pool, pidfilename, &pidfile);

}

}

#endif

do {

apr_pool_create(&instance, pool);

now = apr_time_now();

APR_RING_INIT(&root, _entry, link);

delcount = 0;

unsolicited = 0;

dowork = 0;

switch (intelligent) {

case 0:

dowork = 1;

break;

case 1:

retries = STAT_ATTEMPTS;

status = APR_SUCCESS;

do {

if (status != APR_SUCCESS) {

apr_sleep(STAT_DELAY);

}

status = apr_stat(&info, path, APR_FINFO_MTIME, instance);

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

if (status == APR_SUCCESS) {

previous = info.mtime;

intelligent = 2;

}

dowork = 1;

break;

case 2:

retries = STAT_ATTEMPTS;

status = APR_SUCCESS;

do {

if (status != APR_SUCCESS) {

apr_sleep(STAT_DELAY);

}

status = apr_stat(&info, path, APR_FINFO_MTIME, instance);

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

if (status == APR_SUCCESS) {

if (previous != info.mtime) {

dowork = 1;

}

previous = info.mtime;

break;

}

intelligent = 1;

dowork = 1;

break;

}

if (dowork && !interrupted) {

if (!process_dir(path, instance) && !interrupted) {

purge(path, instance, max);

}

else if (!isdaemon && !interrupted) {

apr_file_printf(errfile, "An error occurred, cache cleaning "

"aborted." APR_EOL_STR);

return 1;

}

if (intelligent && !interrupted) {

retries = STAT_ATTEMPTS;

status = APR_SUCCESS;