1 file changed, 0 insertions, 475 deletions
diff --git a/cache.c b/cache.c
deleted file mode 100644
index e70af13..0000000
--- a/cache.c
+++ /dev/null
@@ -1,475 +0,0 @@
-/* cache.c: cache management
- *
- * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>
- *
- * Licensed under GNU General Public License v2
- *   (see COPYING for full license text)
- *
- *
- * The cache is just a directory structure where each file is a cache slot,
- * and each filename is based on the hash of some key (e.g. the cgit url).
- * Each file contains the full key followed by the cached content for that
- * key.
- *
- */
-
-#include "cgit.h"
-#include "cache.h"
-#include "html.h"
-#ifdef HAVE_LINUX_SENDFILE
-#include <sys/sendfile.h>
-#endif
-
-#define CACHE_BUFSIZE (1024 * 4)
-
-struct cache_slot {
-	const char *key;
-	size_t keylen;
-	int ttl;
-	cache_fill_fn fn;
-	int cache_fd;
-	int lock_fd;
-	int stdout_fd;
-	const char *cache_name;
-	const char *lock_name;
-	int match;
-	struct stat cache_st;
-	int bufsize;
-	char buf[CACHE_BUFSIZE];
-};
-
-/* Open an existing cache slot and fill the cache buffer with
- * (part of) the content of the cache file. Return 0 on success
- * and errno otherwise.
- */
-static int open_slot(struct cache_slot *slot)
-{
-	char *bufz;
-	ssize_t bufkeylen = -1;
-
-	slot->cache_fd = open(slot->cache_name, O_RDONLY);
-	if (slot->cache_fd == -1)
-		return errno;
-
-	if (fstat(slot->cache_fd, &slot->cache_st))
-		return errno;
-
-	slot->bufsize = xread(slot->cache_fd, slot->buf, sizeof(slot->buf));
-	if (slot->bufsize < 0)
-		return errno;
-
-	bufz = memchr(slot->buf, 0, slot->bufsize);
-	if (bufz)
-		bufkeylen = bufz - slot->buf;
-
-	if (slot->key)
-		slot->match = bufkeylen == slot->keylen &&
-		    !memcmp(slot->key, slot->buf, bufkeylen + 1);
-
-	return 0;
-}
-
-/* Close the active cache slot */
-static int close_slot(struct cache_slot *slot)
-{
-	int err = 0;
-	if (slot->cache_fd > 0) {
-		if (close(slot->cache_fd))
-			err = errno;
-		else
-			slot->cache_fd = -1;
-	}
-	return err;
-}
-
-/* Print the content of the active cache slot (but skip the key). */
-static int print_slot(struct cache_slot *slot)
-{
-	off_t off;
-#ifdef HAVE_LINUX_SENDFILE
-	off_t size;
-#endif
-
-	off = slot->keylen + 1;
-
-#ifdef HAVE_LINUX_SENDFILE
-	size = slot->cache_st.st_size;
-
-	do {
-		ssize_t ret;
-		ret = sendfile(STDOUT_FILENO, slot->cache_fd, &off, size - off);
-		if (ret < 0) {
-			if (errno == EAGAIN || errno == EINTR)
-				continue;
-			/* Fall back to read/write on EINVAL or ENOSYS */
-			if (errno == EINVAL || errno == ENOSYS)
-				break;
-			return errno;
-		}
-		if (off == size)
-			return 0;
-	} while (1);
-#endif
-
-	if (lseek(slot->cache_fd, off, SEEK_SET) != off)
-		return errno;
-
-	do {
-		ssize_t ret;
-		ret = xread(slot->cache_fd, slot->buf, sizeof(slot->buf));
-		if (ret < 0)
-			return errno;
-		if (ret == 0)
-			return 0;
-		if (write_in_full(STDOUT_FILENO, slot->buf, ret) < 0)
-			return errno;
-	} while (1);
-}
-
-/* Check if the slot has expired */
-static int is_expired(struct cache_slot *slot)
-{
-	if (slot->ttl < 0)
-		return 0;
-	else
-		return slot->cache_st.st_mtime + slot->ttl * 60 < time(NULL);
-}
-
-/* Check if the slot has been modified since we opened it.
- * NB: If stat() fails, we pretend the file is modified.
- */
-static int is_modified(struct cache_slot *slot)
-{
-	struct stat st;
-
-	if (stat(slot->cache_name, &st))
-		return 1;
-	return (st.st_ino != slot->cache_st.st_ino ||
-		st.st_mtime != slot->cache_st.st_mtime ||
-		st.st_size != slot->cache_st.st_size);
-}
-
-/* Close an open lockfile */
-static int close_lock(struct cache_slot *slot)
-{
-	int err = 0;
-	if (slot->lock_fd > 0) {
-		if (close(slot->lock_fd))
-			err = errno;
-		else
-			slot->lock_fd = -1;
-	}
-	return err;
-}
-
-/* Create a lockfile used to store the generated content for a cache
- * slot, and write the slot key + \0 into it.
- * Returns 0 on success and errno otherwise.
- */
-static int lock_slot(struct cache_slot *slot)
-{
-	struct flock lock = {
-		.l_type = F_WRLCK,
-		.l_whence = SEEK_SET,
-		.l_start = 0,
-		.l_len = 0,
-	};
-
-	slot->lock_fd = open(slot->lock_name, O_RDWR | O_CREAT,
-			     S_IRUSR | S_IWUSR);
-	if (slot->lock_fd == -1)
-		return errno;
-	if (fcntl(slot->lock_fd, F_SETLK, &lock) < 0) {
-		int saved_errno = errno;
-		close(slot->lock_fd);
-		slot->lock_fd = -1;
-		return saved_errno;
-	}
-	if (ftruncate(slot->lock_fd, 0) < 0)
-		return errno;
-	if (xwrite(slot->lock_fd, slot->key, slot->keylen + 1) < 0)
-		return errno;
-	return 0;
-}
-
-/* Release the current lockfile. If `replace_old_slot` is set the
- * lockfile replaces the old cache slot, otherwise the lockfile is
- * just deleted.
- */
-static int unlock_slot(struct cache_slot *slot, int replace_old_slot)
-{
-	int err;
-
-	if (replace_old_slot)
-		err = rename(slot->lock_name, slot->cache_name);
-	else
-		err = unlink(slot->lock_name);
-
-	/* Restore stdout and close the temporary FD. */
-	if (slot->stdout_fd >= 0) {
-		dup2(slot->stdout_fd, STDOUT_FILENO);
-		close(slot->stdout_fd);
-		slot->stdout_fd = -1;
-	}
-
-	if (err)
-		return errno;
-
-	return 0;
-}
-
-/* Generate the content for the current cache slot by redirecting
- * stdout to the lock-fd and invoking the callback function
- */
-static int fill_slot(struct cache_slot *slot)
-{
-	/* Preserve stdout */
-	slot->stdout_fd = dup(STDOUT_FILENO);
-	if (slot->stdout_fd == -1)
-		return errno;
-
-	/* Redirect stdout to lockfile */
-	if (dup2(slot->lock_fd, STDOUT_FILENO) == -1)
-		return errno;
-
-	/* Generate cache content */
-	slot->fn();
-
-	/* Make sure any buffered data is flushed to the file */
-	if (fflush(stdout))
-		return errno;
-
-	/* update stat info */
-	if (fstat(slot->lock_fd, &slot->cache_st))
-		return errno;
-
-	return 0;
-}
-
-/* Crude implementation of 32-bit FNV-1 hash algorithm,
- * see http://www.isthe.com/chongo/tech/comp/fnv/ for details
- * about the magic numbers.
- */
-#define FNV_OFFSET 0x811c9dc5
-#define FNV_PRIME  0x01000193
-
-unsigned long hash_str(const char *str)
-{
-	unsigned long h = FNV_OFFSET;
-	unsigned char *s = (unsigned char *)str;
-
-	if (!s)
-		return h;
-
-	while (*s) {
-		h *= FNV_PRIME;
-		h ^= *s++;
-	}
-	return h;
-}
-
-static int process_slot(struct cache_slot *slot)
-{
-	int err;
-
-	err = open_slot(slot);
-	if (!err && slot->match) {
-		if (is_expired(slot)) {
-			if (!lock_slot(slot)) {
-				/* If the cachefile has been replaced between
-				 * `open_slot` and `lock_slot`, we'll just
-				 * serve the stale content from the original
-				 * cachefile. This way we avoid pruning the
-				 * newly generated slot. The same code-path
-				 * is chosen if fill_slot() fails for some
-				 * reason.
-				 *
-				 * TODO? check if the new slot contains the
-				 * same key as the old one, since we would
-				 * prefer to serve the newest content.
-				 * This will require us to open yet another
-				 * file-descriptor and read and compare the
-				 * key from the new file, so for now we're
-				 * lazy and just ignore the new file.
-				 */
-				if (is_modified(slot) || fill_slot(slot)) {
-					unlock_slot(slot, 0);
-					close_lock(slot);
-				} else {
-					close_slot(slot);
-					unlock_slot(slot, 1);
-					slot->cache_fd = slot->lock_fd;
-				}
-			}
-		}
-		if ((err = print_slot(slot)) != 0) {
-			cache_log("[cgit] error printing cache %s: %s (%d)\n",
-				  slot->cache_name,
-				  strerror(err),
-				  err);
-		}
-		close_slot(slot);
-		return err;
-	}
-
-	/* If the cache slot does not exist (or its key doesn't match the
-	 * current key), lets try to create a new cache slot for this
-	 * request. If this fails (for whatever reason), lets just generate
-	 * the content without caching it and fool the caller to believe
-	 * everything worked out (but print a warning on stdout).
-	 */
-
-	close_slot(slot);
-	if ((err = lock_slot(slot)) != 0) {
-		cache_log("[cgit] Unable to lock slot %s: %s (%d)\n",
-			  slot->lock_name, strerror(err), err);
-		slot->fn();
-		return 0;
-	}
-
-	if ((err = fill_slot(slot)) != 0) {
-		cache_log("[cgit] Unable to fill slot %s: %s (%d)\n",
-			  slot->lock_name, strerror(err), err);
-		unlock_slot(slot, 0);
-		close_lock(slot);
-		slot->fn();
-		return 0;
-	}
-	// We've got a valid cache slot in the lock file, which
-	// is about to replace the old cache slot. But if we
-	// release the lockfile and then try to open the new cache
-	// slot, we might get a race condition with a concurrent
-	// writer for the same cache slot (with a different key).
-	// Lets avoid such a race by just printing the content of
-	// the lock file.
-	slot->cache_fd = slot->lock_fd;
-	unlock_slot(slot, 1);
-	if ((err = print_slot(slot)) != 0) {
-		cache_log("[cgit] error printing cache %s: %s (%d)\n",
-			  slot->cache_name,
-			  strerror(err),
-			  err);
-	}
-	close_slot(slot);
-	return err;
-}
-
-/* Print cached content to stdout, generate the content if necessary. */
-int cache_process(int size, const char *path, const char *key, int ttl,
-		  cache_fill_fn fn)
-{
-	unsigned long hash;
-	int i;
-	struct strbuf filename = STRBUF_INIT;
-	struct strbuf lockname = STRBUF_INIT;
-	struct cache_slot slot;
-	int result;
-
-	/* If the cache is disabled, just generate the content */
-	if (size <= 0 || ttl == 0) {
-		fn();
-		return 0;
-	}
-
-	/* Verify input, calculate filenames */
-	if (!path) {
-		cache_log("[cgit] Cache path not specified, caching is disabled\n");
-		fn();
-		return 0;
-	}
-	if (!key)
-		key = "";
-	hash = hash_str(key) % size;
-	strbuf_addstr(&filename, path);
-	strbuf_ensure_end(&filename, '/');
-	for (i = 0; i < 8; i++) {
-		strbuf_addf(&filename, "%x", (unsigned char)(hash & 0xf));
-		hash >>= 4;
-	}
-	strbuf_addbuf(&lockname, &filename);
-	strbuf_addstr(&lockname, ".lock");
-	slot.fn = fn;
-	slot.ttl = ttl;
-	slot.stdout_fd = -1;
-	slot.cache_name = filename.buf;
-	slot.lock_name = lockname.buf;
-	slot.key = key;
-	slot.keylen = strlen(key);
-	result = process_slot(&slot);
-
-	strbuf_release(&filename);
-	strbuf_release(&lockname);
-	return result;
-}
-
-/* Return a strftime formatted date/time
- * NB: the result from this function is to shared memory
- */
-static char *sprintftime(const char *format, time_t time)
-{
-	static char buf[64];
-	struct tm tm;
-
-	if (!time)
-		return NULL;
-	gmtime_r(&time, &tm);
-	strftime(buf, sizeof(buf)-1, format, &tm);
-	return buf;
-}
-
-int cache_ls(const char *path)
-{
-	DIR *dir;
-	struct dirent *ent;
-	int err = 0;
-	struct cache_slot slot = { NULL };
-	struct strbuf fullname = STRBUF_INIT;
-	size_t prefixlen;
-
-	if (!path) {
-		cache_log("[cgit] cache path not specified\n");
-		return -1;
-	}
-	dir = opendir(path);
-	if (!dir) {
-		err = errno;
-		cache_log("[cgit] unable to open path %s: %s (%d)\n",
-			  path, strerror(err), err);
-		return err;
-	}
-	strbuf_addstr(&fullname, path);
-	strbuf_ensure_end(&fullname, '/');
-	prefixlen = fullname.len;
-	while ((ent = readdir(dir)) != NULL) {
-		if (strlen(ent->d_name) != 8)
-			continue;
-		strbuf_setlen(&fullname, prefixlen);
-		strbuf_addstr(&fullname, ent->d_name);
-		slot.cache_name = fullname.buf;
-		if ((err = open_slot(&slot)) != 0) {
-			cache_log("[cgit] unable to open path %s: %s (%d)\n",
-				  fullname.buf, strerror(err), err);
-			continue;
-		}
-		htmlf("%s %s %10"PRIuMAX" %s\n",
-		      fullname.buf,
-		      sprintftime("%Y-%m-%d %H:%M:%S",
-				  slot.cache_st.st_mtime),
-		      (uintmax_t)slot.cache_st.st_size,
-		      slot.buf);
-		close_slot(&slot);
-	}
-	closedir(dir);
-	strbuf_release(&fullname);
-	return 0;
-}
-
-/* Print a message to stdout */
-void cache_log(const char *format, ...)
-{
-	va_list args;
-	va_start(args, format);
-	vfprintf(stderr, format, args);
-	va_end(args);
-}
-