cache.c

   1 /* cache.c: cache management
   2  *
   3  * Copyright (C) 2006 Lars Hjemli
   4  *
   5  * Licensed under GNU General Public License v2
   6  *   (see COPYING for full license text)
   7  *
   8  *
   9  * The cache is just a directory structure where each file is a cache slot,
  10  * and each filename is based on the hash of some key (e.g. the cgit url).
  11  * Each file contains the full key followed by the cached content for that
  12  * key.
  13  *
  14  */
  15
  16 #include "cgit.h"
  17 #include "cache.h"
  18
  19 #define CACHE_BUFSIZE (1024 * 4)
  20
  21 struct cache_slot {
  22         const char *key;
  23         int keylen;
  24         int ttl;
  25         cache_fill_fn fn;
  26         void *cbdata;
  27         int cache_fd;
  28         int lock_fd;
  29         const char *cache_name;
  30         const char *lock_name;
  31         int match;
  32         struct stat cache_st;
  33         struct stat lock_st;
  34         int bufsize;
  35         char buf[CACHE_BUFSIZE];
  36 };
  37
  38 /* Open an existing cache slot and fill the cache buffer with
  39  * (part of) the content of the cache file. Return 0 on success
  40  * and errno otherwise.
  41  */
  42 static int open_slot(struct cache_slot *slot)
  43 {
  44         char *bufz;
  45         int bufkeylen = -1;
  46
  47         slot->cache_fd = open(slot->cache_name, O_RDONLY);
  48         if (slot->cache_fd == -1)
  49                 return errno;
  50
  51         if (fstat(slot->cache_fd, &slot->cache_st))
  52                 return errno;
  53
  54         slot->bufsize = read(slot->cache_fd, slot->buf, sizeof(slot->buf));
  55         if (slot->bufsize < 0)
  56                 return errno;
  57
  58         bufz = memchr(slot->buf, 0, slot->bufsize);
  59         if (bufz)
  60                 bufkeylen = bufz - slot->buf;
  61
  62         slot->match = bufkeylen == slot->keylen &&
  63             !memcmp(slot->key, slot->buf, bufkeylen + 1);
  64
  65         return 0;
  66 }
  67
  68 /* Close the active cache slot */
  69 static void close_slot(struct cache_slot *slot)
  70 {
  71         if (slot->cache_fd > 0) {
  72                 close(slot->cache_fd);
  73                 slot->cache_fd = -1;
  74         }
  75 }
  76
  77 /* Print the content of the active cache slot (but skip the key). */
  78 static int print_slot(struct cache_slot *slot)
  79 {
  80         ssize_t i, j = 0;
  81
  82         i = lseek(slot->cache_fd, slot->keylen + 1, SEEK_SET);
  83         if (i != slot->keylen + 1)
  84                 return errno;
  85
  86         while((i=read(slot->cache_fd, slot->buf, sizeof(slot->buf))) > 0)
  87                 j = write(STDOUT_FILENO, slot->buf, i);
  88
  89         if (j < 0)
  90                 return errno;
  91         else
  92                 return 0;
  93 }
  94
  95 /* Check if the slot has expired */
  96 static int is_expired(struct cache_slot *slot)
  97 {
  98         if (slot->ttl < 0)
  99                 return 0;
 100         else
 101                 return slot->cache_st.st_mtime + slot->ttl*60 < time(NULL);
 102 }
 103
 104 /* Check if the slot has been modified since we opened it.
 105  * NB: If stat() fails, we pretend the file is modified.
 106  */
 107 static int is_modified(struct cache_slot *slot)
 108 {
 109         struct stat st;
 110
 111         if (stat(slot->cache_name, &st))
 112                 return 1;
 113         return (st.st_ino != slot->cache_st.st_ino ||
 114                 st.st_mtime != slot->cache_st.st_mtime ||
 115                 st.st_size != slot->cache_st.st_size);
 116 }
 117
 118 /* Close an open lockfile */
 119 static void close_lock(struct cache_slot *slot)
 120 {
 121         if (slot->lock_fd > 0) {
 122                 close(slot->lock_fd);
 123                 slot->lock_fd = -1;
 124         }
 125 }
 126
 127 /* Create a lockfile used to store the generated content for a cache
 128  * slot, and write the slot key + \0 into it.
 129  * Returns 0 on success and errno otherwise.
 130  */
 131 static int lock_slot(struct cache_slot *slot)
 132 {
 133         slot->lock_fd = open(slot->lock_name, O_RDWR|O_CREAT|O_EXCL,
 134                              S_IRUSR|S_IWUSR);
 135         if (slot->lock_fd == -1)
 136                 return errno;
 137         write(slot->lock_fd, slot->key, slot->keylen + 1);
 138         return 0;
 139 }
 140
 141 /* Release the current lockfile. If `replace_old_slot` is set the
 142  * lockfile replaces the old cache slot, otherwise the lockfile is
 143  * just deleted.
 144  */
 145 static int unlock_slot(struct cache_slot *slot, int replace_old_slot)
 146 {
 147         int err;
 148
 149         if (replace_old_slot)
 150                 err = rename(slot->lock_name, slot->cache_name);
 151         else
 152                 err = unlink(slot->lock_name);
 153         return err;
 154 }
 155
 156 /* Generate the content for the current cache slot by redirecting
 157  * stdout to the lock-fd and invoking the callback function
 158  */
 159 static int fill_slot(struct cache_slot *slot)
 160 {
 161         int tmp;
 162
 163         /* Preserve stdout */
 164         tmp = dup(STDOUT_FILENO);
 165         if (tmp == -1)
 166                 return errno;
 167
 168         /* Redirect stdout to lockfile */
 169         if (dup2(slot->lock_fd, STDOUT_FILENO) == -1)
 170                 return errno;
 171
 172         /* Generate cache content */
 173         slot->fn(slot->cbdata);
 174
 175         /* Restore stdout */
 176         if (dup2(tmp, STDOUT_FILENO) == -1)
 177                 return errno;
 178
 179         /* Close the temporary filedescriptor */
 180         close(tmp);
 181         return 0;
 182 }
 183
 184 /* Crude implementation of 32-bit FNV-1 hash algorithm,
 185  * see http://www.isthe.com/chongo/tech/comp/fnv/ for details
 186  * about the magic numbers.
 187  */
 188 #define FNV_OFFSET 0x811c9dc5
 189 #define FNV_PRIME  0x01000193
 190
 191 unsigned long hash_str(const char *str)
 192 {
 193         unsigned long h = FNV_OFFSET;
 194         unsigned char *s = (unsigned char *)str;
 195
 196         if (!s)
 197                 return h;
 198
 199         while(*s) {
 200                 h *= FNV_PRIME;
 201                 h ^= *s++;
 202         }
 203         return h;
 204 }
 205
 206 static int process_slot(struct cache_slot *slot)
 207 {
 208         int err;
 209
 210         err = open_slot(slot);
 211         if (!err && slot->match) {
 212                 if (is_expired(slot)) {
 213                         if (!lock_slot(slot)) {
 214                                 /* If the cachefile has been replaced between
 215                                  * `open_slot` and `lock_slot`, we'll just
 216                                  * serve the stale content from the original
 217                                  * cachefile. This way we avoid pruning the
 218                                  * newly generated slot. The same code-path
 219                                  * is chosen if fill_slot() fails for some
 220                                  * reason.
 221                                  *
 222                                  * TODO? check if the new slot contains the
 223                                  * same key as the old one, since we would
 224                                  * prefer to serve the newest content.
 225                                  * This will require us to open yet another
 226                                  * file-descriptor and read and compare the
 227                                  * key from the new file, so for now we're
 228                                  * lazy and just ignore the new file.
 229                                  */
 230                                 if (is_modified(slot) || fill_slot(slot)) {
 231                                         unlock_slot(slot, 0);
 232                                         close_lock(slot);
 233                                 } else {
 234                                         close_slot(slot);
 235                                         unlock_slot(slot, 1);
 236                                         slot->cache_fd = slot->lock_fd;
 237                                 }
 238                         }
 239                 }
 240                 print_slot(slot);
 241                 close_slot(slot);
 242                 return 0;
 243         }
 244
 245         /* If the cache slot does not exist (or its key doesn't match the
 246          * current key), lets try to create a new cache slot for this
 247          * request. If this fails (for whatever reason), lets just generate
 248          * the content without caching it and fool the caller to belive
 249          * everything worked out (but print a warning on stdout).
 250          */
 251
 252         close_slot(slot);
 253         if ((err = lock_slot(slot)) != 0) {
 254                 cache_log("[cgit] Unable to lock slot %s: %s (%d)\n",
 255                           slot->lock_name, strerror(err), err);
 256                 slot->fn(slot->cbdata);
 257                 return 0;
 258         }
 259
 260         if ((err = fill_slot(slot)) != 0) {
 261                 cache_log("[cgit] Unable to fill slot %s: %s (%d)\n",
 262                           slot->lock_name, strerror(err), err);
 263                 unlock_slot(slot, 0);
 264                 close_lock(slot);
 265                 slot->fn(slot->cbdata);
 266                 return 0;
 267         }
 268         // We've got a valid cache slot in the lock file, which
 269         // is about to replace the old cache slot. But if we
 270         // release the lockfile and then try to open the new cache
 271         // slot, we might get a race condition with a concurrent
 272         // writer for the same cache slot (with a different key).
 273         // Lets avoid such a race by just printing the content of
 274         // the lock file.
 275         slot->cache_fd = slot->lock_fd;
 276         unlock_slot(slot, 1);
 277         err = print_slot(slot);
 278         close_slot(slot);
 279         return err;
 280 }
 281
 282 /* Print cached content to stdout, generate the content if necessary. */
 283 int cache_process(int size, const char *path, const char *key, int ttl,
 284                   cache_fill_fn fn, void *cbdata)
 285 {
 286         unsigned long hash;
 287         int len, i;
 288         char filename[1024];
 289         char lockname[1024 + 5];  /* 5 = ".lock" */
 290         struct cache_slot slot;
 291
 292         /* If the cache is disabled, just generate the content */
 293         if (size <= 0) {
 294                 fn(cbdata);
 295                 return 0;
 296         }
 297
 298         /* Verify input, calculate filenames */
 299         if (!path) {
 300                 cache_log("[cgit] Cache path not specified, caching is disabled\n");
 301                 fn(cbdata);
 302                 return 0;
 303         }
 304         len = strlen(path);
 305         if (len > sizeof(filename) - 10) { /* 10 = "/01234567\0" */
 306                 cache_log("[cgit] Cache path too long, caching is disabled: %s\n",
 307                           path);
 308                 fn(cbdata);
 309                 return 0;
 310         }
 311         if (!key)
 312                 key = "";
 313         hash = hash_str(key) % size;
 314         strcpy(filename, path);
 315         if (filename[len - 1] != '/')
 316                 filename[len++] = '/';
 317         for(i = 0; i < 8; i++) {
 318                 sprintf(filename + len++, "%x",
 319                         (unsigned char)(hash & 0xf));
 320                 hash >>= 4;
 321         }
 322         filename[len] = '\0';
 323         strcpy(lockname, filename);
 324         strcpy(lockname + len, ".lock");
 325         slot.fn = fn;
 326         slot.cbdata = cbdata;
 327         slot.ttl = ttl;
 328         slot.cache_name = filename;
 329         slot.lock_name = lockname;
 330         slot.key = key;
 331         slot.keylen = strlen(key);
 332         return process_slot(&slot);
 333 }
 334
 335 /* Return a strftime formatted date/time
 336  * NB: the result from this function is to shared memory
 337  */
 338 char *sprintftime(const char *format, time_t time)
 339 {
 340         static char buf[64];
 341         struct tm *tm;
 342
 343         if (!time)
 344                 return NULL;
 345         tm = gmtime(&time);
 346         strftime(buf, sizeof(buf)-1, format, tm);
 347         return buf;
 348 }
 349
 350 int cache_ls(const char *path)
 351 {
 352         DIR *dir;
 353         struct dirent *ent;
 354         int err = 0;
 355         struct cache_slot slot;
 356         char fullname[1024];
 357         char *name;
 358
 359         if (!path) {
 360                 cache_log("[cgit] cache path not specified\n");
 361                 return -1;
 362         }
 363         if (strlen(path) > 1024 - 10) {
 364                 cache_log("[cgit] cache path too long: %s\n",
 365                           path);
 366                 return -1;
 367         }
 368         dir = opendir(path);
 369         if (!dir) {
 370                 err = errno;
 371                 cache_log("[cgit] unable to open path %s: %s (%d)\n",
 372                           path, strerror(err), err);
 373                 return err;
 374         }
 375         strcpy(fullname, path);
 376         name = fullname + strlen(path);
 377         if (*(name - 1) != '/') {
 378                 *name++ = '/';
 379                 *name = '\0';
 380         }
 381         slot.cache_name = fullname;
 382         while((ent = readdir(dir)) != NULL) {
 383                 if (strlen(ent->d_name) != 8)
 384                         continue;
 385                 strcpy(name, ent->d_name);
 386                 if ((err = open_slot(&slot)) != 0) {
 387                         cache_log("[cgit] unable to open path %s: %s (%d)\n",
 388                                   fullname, strerror(err), err);
 389                         continue;
 390                 }
 391                 printf("%s %s %10lld %s\n",
 392                        name,
 393                        sprintftime("%Y-%m-%d %H:%M:%S",
 394                                    slot.cache_st.st_mtime),
 395                        slot.cache_st.st_size,
 396                        slot.buf);
 397                 close_slot(&slot);
 398         }
 399         closedir(dir);
 400         return 0;
 401 }
 402
 403 /* Print a message to stdout */
 404 void cache_log(const char *format, ...)
 405 {
 406         va_list args;
 407         va_start(args, format);
 408         vfprintf(stderr, format, args);
 409         va_end(args);
 410 }
 411