summaryrefslogtreecommitdiffabout
Unidiff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--cache.c68
-rw-r--r--cache.h3
-rw-r--r--cmd.c21
3 files changed, 87 insertions, 5 deletions
diff --git a/cache.c b/cache.c
index e590d7b..b701e13 100644
--- a/cache.c
+++ b/cache.c
@@ -303,41 +303,109 @@ int cache_process(int size, const char *path, const char *key, int ttl,
303 } 303 }
304 len = strlen(path); 304 len = strlen(path);
305 if (len > sizeof(filename) - 10) { /* 10 = "/01234567\0" */ 305 if (len > sizeof(filename) - 10) { /* 10 = "/01234567\0" */
306 cache_log("[cgit] Cache path too long, caching is disabled: %s\n", 306 cache_log("[cgit] Cache path too long, caching is disabled: %s\n",
307 path); 307 path);
308 fn(cbdata); 308 fn(cbdata);
309 return 0; 309 return 0;
310 } 310 }
311 if (!key) 311 if (!key)
312 key = ""; 312 key = "";
313 hash = hash_str(key) % size; 313 hash = hash_str(key) % size;
314 strcpy(filename, path); 314 strcpy(filename, path);
315 if (filename[len - 1] != '/') 315 if (filename[len - 1] != '/')
316 filename[len++] = '/'; 316 filename[len++] = '/';
317 for(i = 0; i < 8; i++) { 317 for(i = 0; i < 8; i++) {
318 sprintf(filename + len++, "%x", 318 sprintf(filename + len++, "%x",
319 (unsigned char)(hash & 0xf)); 319 (unsigned char)(hash & 0xf));
320 hash >>= 4; 320 hash >>= 4;
321 } 321 }
322 filename[len] = '\0'; 322 filename[len] = '\0';
323 strcpy(lockname, filename); 323 strcpy(lockname, filename);
324 strcpy(lockname + len, ".lock"); 324 strcpy(lockname + len, ".lock");
325 slot.fn = fn; 325 slot.fn = fn;
326 slot.cbdata = cbdata; 326 slot.cbdata = cbdata;
327 slot.ttl = ttl; 327 slot.ttl = ttl;
328 slot.cache_name = filename; 328 slot.cache_name = filename;
329 slot.lock_name = lockname; 329 slot.lock_name = lockname;
330 slot.key = key; 330 slot.key = key;
331 slot.keylen = strlen(key); 331 slot.keylen = strlen(key);
332 return process_slot(&slot); 332 return process_slot(&slot);
333} 333}
334 334
335/* Return a strftime formatted date/time
336 * NB: the result from this function is to shared memory
337 */
338char *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
350int 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
335/* Print a message to stdout */ 403/* Print a message to stdout */
336void cache_log(const char *format, ...) 404void cache_log(const char *format, ...)
337{ 405{
338 va_list args; 406 va_list args;
339 va_start(args, format); 407 va_start(args, format);
340 vfprintf(stderr, format, args); 408 vfprintf(stderr, format, args);
341 va_end(args); 409 va_end(args);
342} 410}
343 411
diff --git a/cache.h b/cache.h
index 5f2178d..66cc41f 100644
--- a/cache.h
+++ b/cache.h
@@ -1,32 +1,35 @@
1/* 1/*
2 * Since git has it's own cache.h which we include, 2 * Since git has it's own cache.h which we include,
3 * lets test on CGIT_CACHE_H to avoid confusion 3 * lets test on CGIT_CACHE_H to avoid confusion
4 */ 4 */
5 5
6#ifndef CGIT_CACHE_H 6#ifndef CGIT_CACHE_H
7#define CGIT_CACHE_H 7#define CGIT_CACHE_H
8 8
9typedef void (*cache_fill_fn)(void *cbdata); 9typedef void (*cache_fill_fn)(void *cbdata);
10 10
11 11
12/* Print cached content to stdout, generate the content if necessary. 12/* Print cached content to stdout, generate the content if necessary.
13 * 13 *
14 * Parameters 14 * Parameters
15 * size max number of cache files 15 * size max number of cache files
16 * path directory used to store cache files 16 * path directory used to store cache files
17 * key the key used to lookup cache files 17 * key the key used to lookup cache files
18 * ttl max cache time in seconds for this key 18 * ttl max cache time in seconds for this key
19 * fn content generator function for this key 19 * fn content generator function for this key
20 * cbdata user-supplied data to the content generator function 20 * cbdata user-supplied data to the content generator function
21 * 21 *
22 * Return value 22 * Return value
23 * 0 indicates success, everyting else is an error 23 * 0 indicates success, everyting else is an error
24 */ 24 */
25extern int cache_process(int size, const char *path, const char *key, int ttl, 25extern int cache_process(int size, const char *path, const char *key, int ttl,
26 cache_fill_fn fn, void *cbdata); 26 cache_fill_fn fn, void *cbdata);
27 27
28 28
29/* List info about all cache entries on stdout */
30extern int cache_ls(const char *path);
31
29/* Print a message to stdout */ 32/* Print a message to stdout */
30extern void cache_log(const char *format, ...); 33extern void cache_log(const char *format, ...);
31 34
32#endif /* CGIT_CACHE_H */ 35#endif /* CGIT_CACHE_H */
diff --git a/cmd.c b/cmd.c
index e0eacbe..07f4707 100644
--- a/cmd.c
+++ b/cmd.c
@@ -1,112 +1,123 @@
1/* cmd.c: the cgit command dispatcher 1/* cmd.c: the cgit command dispatcher
2 * 2 *
3 * Copyright (C) 2008 Lars Hjemli 3 * Copyright (C) 2008 Lars Hjemli
4 * 4 *
5 * Licensed under GNU General Public License v2 5 * Licensed under GNU General Public License v2
6 * (see COPYING for full license text) 6 * (see COPYING for full license text)
7 */ 7 */
8 8
9#include "cgit.h" 9#include "cgit.h"
10#include "cmd.h" 10#include "cmd.h"
11#include "cache.h"
12#include "ui-shared.h"
11#include "ui-blob.h" 13#include "ui-blob.h"
12#include "ui-commit.h" 14#include "ui-commit.h"
13#include "ui-diff.h" 15#include "ui-diff.h"
14#include "ui-log.h" 16#include "ui-log.h"
15#include "ui-patch.h" 17#include "ui-patch.h"
16#include "ui-refs.h" 18#include "ui-refs.h"
17#include "ui-repolist.h" 19#include "ui-repolist.h"
18#include "ui-snapshot.h" 20#include "ui-snapshot.h"
19#include "ui-summary.h" 21#include "ui-summary.h"
20#include "ui-tag.h" 22#include "ui-tag.h"
21#include "ui-tree.h" 23#include "ui-tree.h"
22 24
23static void blob_fn(struct cgit_context *ctx) 25static void blob_fn(struct cgit_context *ctx)
24{ 26{
25 cgit_print_blob(ctx->qry.sha1, ctx->qry.path); 27 cgit_print_blob(ctx->qry.sha1, ctx->qry.path);
26} 28}
27 29
28static void commit_fn(struct cgit_context *ctx) 30static void commit_fn(struct cgit_context *ctx)
29{ 31{
30 cgit_print_commit(ctx->qry.sha1); 32 cgit_print_commit(ctx->qry.sha1);
31} 33}
32 34
33static void diff_fn(struct cgit_context *ctx) 35static void diff_fn(struct cgit_context *ctx)
34{ 36{
35 cgit_print_diff(ctx->qry.sha1, ctx->qry.sha2, ctx->qry.path); 37 cgit_print_diff(ctx->qry.sha1, ctx->qry.sha2, ctx->qry.path);
36} 38}
37 39
38static void repolist_fn(struct cgit_context *ctx)
39{
40 cgit_print_repolist();
41}
42
43static void log_fn(struct cgit_context *ctx) 40static void log_fn(struct cgit_context *ctx)
44{ 41{
45 cgit_print_log(ctx->qry.sha1, ctx->qry.ofs, ctx->cfg.max_commit_count, 42 cgit_print_log(ctx->qry.sha1, ctx->qry.ofs, ctx->cfg.max_commit_count,
46 ctx->qry.grep, ctx->qry.search, ctx->qry.path, 1); 43 ctx->qry.grep, ctx->qry.search, ctx->qry.path, 1);
47} 44}
48 45
46static void ls_cache_fn(struct cgit_context *ctx)
47{
48 ctx->page.mimetype = "text/plain";
49 ctx->page.filename = "ls-cache.txt";
50 cgit_print_http_headers(ctx);
51 cache_ls(ctx->cfg.cache_root);
52}
53
54static void repolist_fn(struct cgit_context *ctx)
55{
56 cgit_print_repolist();
57}
58
49static void patch_fn(struct cgit_context *ctx) 59static void patch_fn(struct cgit_context *ctx)
50{ 60{
51 cgit_print_patch(ctx->qry.sha1); 61 cgit_print_patch(ctx->qry.sha1);
52} 62}
53 63
54static void refs_fn(struct cgit_context *ctx) 64static void refs_fn(struct cgit_context *ctx)
55{ 65{
56 cgit_print_refs(); 66 cgit_print_refs();
57} 67}
58 68
59static void snapshot_fn(struct cgit_context *ctx) 69static void snapshot_fn(struct cgit_context *ctx)
60{ 70{
61 cgit_print_snapshot(ctx->qry.head, ctx->qry.sha1, 71 cgit_print_snapshot(ctx->qry.head, ctx->qry.sha1,
62 cgit_repobasename(ctx->repo->url), ctx->qry.path, 72 cgit_repobasename(ctx->repo->url), ctx->qry.path,
63 ctx->repo->snapshots); 73 ctx->repo->snapshots);
64} 74}
65 75
66static void summary_fn(struct cgit_context *ctx) 76static void summary_fn(struct cgit_context *ctx)
67{ 77{
68 cgit_print_summary(); 78 cgit_print_summary();
69} 79}
70 80
71static void tag_fn(struct cgit_context *ctx) 81static void tag_fn(struct cgit_context *ctx)
72{ 82{
73 cgit_print_tag(ctx->qry.sha1); 83 cgit_print_tag(ctx->qry.sha1);
74} 84}
75 85
76static void tree_fn(struct cgit_context *ctx) 86static void tree_fn(struct cgit_context *ctx)
77{ 87{
78 cgit_print_tree(ctx->qry.sha1, ctx->qry.path); 88 cgit_print_tree(ctx->qry.sha1, ctx->qry.path);
79} 89}
80 90
81#define def_cmd(name, want_repo, want_layout) \ 91#define def_cmd(name, want_repo, want_layout) \
82 {#name, name##_fn, want_repo, want_layout} 92 {#name, name##_fn, want_repo, want_layout}
83 93
84struct cgit_cmd *cgit_get_cmd(struct cgit_context *ctx) 94struct cgit_cmd *cgit_get_cmd(struct cgit_context *ctx)
85{ 95{
86 static struct cgit_cmd cmds[] = { 96 static struct cgit_cmd cmds[] = {
87 def_cmd(blob, 1, 0), 97 def_cmd(blob, 1, 0),
88 def_cmd(commit, 1, 1), 98 def_cmd(commit, 1, 1),
89 def_cmd(diff, 1, 1), 99 def_cmd(diff, 1, 1),
90 def_cmd(log, 1, 1), 100 def_cmd(log, 1, 1),
101 def_cmd(ls_cache, 0, 0),
91 def_cmd(patch, 1, 0), 102 def_cmd(patch, 1, 0),
92 def_cmd(refs, 1, 1), 103 def_cmd(refs, 1, 1),
93 def_cmd(repolist, 0, 0), 104 def_cmd(repolist, 0, 0),
94 def_cmd(snapshot, 1, 0), 105 def_cmd(snapshot, 1, 0),
95 def_cmd(summary, 1, 1), 106 def_cmd(summary, 1, 1),
96 def_cmd(tag, 1, 1), 107 def_cmd(tag, 1, 1),
97 def_cmd(tree, 1, 1), 108 def_cmd(tree, 1, 1),
98 }; 109 };
99 int i; 110 int i;
100 111
101 if (ctx->qry.page == NULL) { 112 if (ctx->qry.page == NULL) {
102 if (ctx->repo) 113 if (ctx->repo)
103 ctx->qry.page = "summary"; 114 ctx->qry.page = "summary";
104 else 115 else
105 ctx->qry.page = "repolist"; 116 ctx->qry.page = "repolist";
106 } 117 }
107 118
108 for(i = 0; i < sizeof(cmds)/sizeof(*cmds); i++) 119 for(i = 0; i < sizeof(cmds)/sizeof(*cmds); i++)
109 if (!strcmp(ctx->qry.page, cmds[i].name)) 120 if (!strcmp(ctx->qry.page, cmds[i].name))
110 return &cmds[i]; 121 return &cmds[i];
111 return NULL; 122 return NULL;
112} 123}