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