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 = 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 */
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, j = 0;
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=read(slot->cache_fd, slot->buf, sizeof(slot->buf))) > 0)
91 j = write(STDOUT_FILENO, slot->buf, i);
92
93 if (j < 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 (write(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 print_slot(slot);
256 close_slot(slot);
257 return 0;
258 }
259
260 /* If the cache slot does not exist (or its key doesn't match the
261 * current key), lets try to create a new cache slot for this
262 * request. If this fails (for whatever reason), lets just generate
263 * the content without caching it and fool the caller to belive
264 * everything worked out (but print a warning on stdout).
265 */
266
267 close_slot(slot);
268 if ((err = lock_slot(slot)) != 0) {
269 cache_log("[cgit] Unable to lock slot %s: %s (%d)\n",
270 slot->lock_name, strerror(err), err);
271 slot->fn(slot->cbdata);
272 return 0;
273 }
274
275 if ((err = fill_slot(slot)) != 0) {
276 cache_log("[cgit] Unable to fill slot %s: %s (%d)\n",
277 slot->lock_name, strerror(err), err);
278 unlock_slot(slot, 0);
279 close_lock(slot);
280 slot->fn(slot->cbdata);
281 return 0;
282 }
283 // We've got a valid cache slot in the lock file, which
284 // is about to replace the old cache slot. But if we
285 // release the lockfile and then try to open the new cache
286 // slot, we might get a race condition with a concurrent
287 // writer for the same cache slot (with a different key).
288 // Lets avoid such a race by just printing the content of
289 // the lock file.
290 slot->cache_fd = slot->lock_fd;
291 unlock_slot(slot, 1);
292 err = print_slot(slot);
293 close_slot(slot);
294 return err;
295}
296
297/* Print cached content to stdout, generate the content if necessary. */
298int cache_process(int size, const char *path, const char *key, int ttl,
299 cache_fill_fn fn, void *cbdata)
300{
301 unsigned long hash;
302 int len, i;
303 char filename[1024];
304 char lockname[1024 + 5]; /* 5 = ".lock" */
305 struct cache_slot slot;
306
307 /* If the cache is disabled, just generate the content */
308 if (size <= 0) {
309 fn(cbdata);
310 return 0;
311 }
312
313 /* Verify input, calculate filenames */
314 if (!path) {
315 cache_log("[cgit] Cache path not specified, caching is disabled\n");
316 fn(cbdata);
317 return 0;
318 }
319 len = strlen(path);
320 if (len > sizeof(filename) - 10) { /* 10 = "/01234567\0" */
321 cache_log("[cgit] Cache path too long, caching is disabled: %s\n",
322 path);
323 fn(cbdata);
324 return 0;
325 }
326 if (!key)
327 key = "";
328 hash = hash_str(key) % size;
329 strcpy(filename, path);
330 if (filename[len - 1] != '/')
331 filename[len++] = '/';
332 for(i = 0; i < 8; i++) {
333 sprintf(filename + len++, "%x",
334 (unsigned char)(hash & 0xf));
335 hash >>= 4;
336 }
337 filename[len] = '\0';
338 strcpy(lockname, filename);
339 strcpy(lockname + len, ".lock");
340 slot.fn = fn;
341 slot.cbdata = cbdata;
342 slot.ttl = ttl;
343 slot.cache_name = filename;
344 slot.lock_name = lockname;
345 slot.key = key;
346 slot.keylen = strlen(key);
347 return process_slot(&slot);
348}
349
350/* Return a strftime formatted date/time
351 * NB: the result from this function is to shared memory
352 */
353char *sprintftime(const char *format, time_t time)
354{
355 static char buf[64];
356 struct tm *tm;
357
358 if (!time)
359 return NULL;
360 tm = gmtime(&time);
361 strftime(buf, sizeof(buf)-1, format, tm);
362 return buf;
363}
364
365int cache_ls(const char *path)
366{
367 DIR *dir;
368 struct dirent *ent;
369 int err = 0;
370 struct cache_slot slot;
371 char fullname[1024];
372 char *name;
373
374 if (!path) {
375 cache_log("[cgit] cache path not specified\n");
376 return -1;
377 }
378 if (strlen(path) > 1024 - 10) {
379 cache_log("[cgit] cache path too long: %s\n",
380 path);
381 return -1;
382 }
383 dir = opendir(path);
384 if (!dir) {
385 err = errno;
386 cache_log("[cgit] unable to open path %s: %s (%d)\n",
387 path, strerror(err), err);
388 return err;
389 }
390 strcpy(fullname, path);
391 name = fullname + strlen(path);
392 if (*(name - 1) != '/') {
393 *name++ = '/';
394 *name = '\0';
395 }
396 slot.cache_name = fullname;
397 while((ent = readdir(dir)) != NULL) {
398 if (strlen(ent->d_name) != 8)
399 continue;
400 strcpy(name, ent->d_name);
401 if ((err = open_slot(&slot)) != 0) {
402 cache_log("[cgit] unable to open path %s: %s (%d)\n",
403 fullname, strerror(err), err);
404 continue;
405 }
406 printf("%s %s %10lld %s\n",
407 name,
408 sprintftime("%Y-%m-%d %H:%M:%S",
409 slot.cache_st.st_mtime),
410 slot.cache_st.st_size,
411 slot.buf);
412 close_slot(&slot);
413 }
414 closedir(dir);
415 return 0;
416}
417
418/* Print a message to stdout */
419void cache_log(const char *format, ...)
420{
421 va_list args;
422 va_start(args, format);
423 vfprintf(stderr, format, args);
424 va_end(args);
425}
426