author | Lars Hjemli <hjemli@gmail.com> | 2006-12-16 12:55:58 (UTC) |
---|---|---|
committer | Lars Hjemli <hjemli@gmail.com> | 2006-12-16 12:55:58 (UTC) |
commit | 7c849d94ec1cfecdec5a88d49f5af5c98f96ebca (patch) (unidiff) | |
tree | 294acaa3368cba880dcc74aac8fb95e22156be21 | |
parent | 61245ad18545ab09b22e9fcce5e49d5d36bf8176 (diff) | |
download | cgit-7c849d94ec1cfecdec5a88d49f5af5c98f96ebca.zip cgit-7c849d94ec1cfecdec5a88d49f5af5c98f96ebca.tar.gz cgit-7c849d94ec1cfecdec5a88d49f5af5c98f96ebca.tar.bz2 |
Allow relative paths for cgit_cache_root
Make sure we chdir(2) back to the original getcwd(2) when a page
has been generated. Also, if the cgit_cache_root do not exist,
try to create it.
This is a feature intended to ease testing/debugging.
Signed-off-by: Lars Hjemli <hjemli@gmail.com>
-rw-r--r-- | cache.c | 4 | ||||
-rw-r--r-- | cgit.c | 4 |
2 files changed, 8 insertions, 0 deletions
@@ -1,95 +1,99 @@ | |||
1 | /* cache.c: cache management | 1 | /* cache.c: cache management |
2 | * | 2 | * |
3 | * Copyright (C) 2006 Lars Hjemli | 3 | * Copyright (C) 2006 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 | 10 | ||
11 | const int NOLOCK = -1; | 11 | const int NOLOCK = -1; |
12 | 12 | ||
13 | void cache_prepare(struct cacheitem *item) | 13 | void cache_prepare(struct cacheitem *item) |
14 | { | 14 | { |
15 | if (!cgit_query_repo) { | 15 | if (!cgit_query_repo) { |
16 | item->name = xstrdup(fmt("%s/index.html", cgit_cache_root)); | 16 | item->name = xstrdup(fmt("%s/index.html", cgit_cache_root)); |
17 | item->ttl = cgit_cache_root_ttl; | 17 | item->ttl = cgit_cache_root_ttl; |
18 | } else if (!cgit_query_page) { | 18 | } else if (!cgit_query_page) { |
19 | item->name = xstrdup(fmt("%s/%s/index.html", cgit_cache_root, | 19 | item->name = xstrdup(fmt("%s/%s/index.html", cgit_cache_root, |
20 | cgit_query_repo)); | 20 | cgit_query_repo)); |
21 | item->ttl = cgit_cache_repo_ttl; | 21 | item->ttl = cgit_cache_repo_ttl; |
22 | } else { | 22 | } else { |
23 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root, | 23 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root, |
24 | cgit_query_repo, cgit_query_page, | 24 | cgit_query_repo, cgit_query_page, |
25 | cgit_querystring)); | 25 | cgit_querystring)); |
26 | if (cgit_query_has_symref) | 26 | if (cgit_query_has_symref) |
27 | item->ttl = cgit_cache_dynamic_ttl; | 27 | item->ttl = cgit_cache_dynamic_ttl; |
28 | else if (cgit_query_has_sha1) | 28 | else if (cgit_query_has_sha1) |
29 | item->ttl = cgit_cache_static_ttl; | 29 | item->ttl = cgit_cache_static_ttl; |
30 | else | 30 | else |
31 | item->ttl = cgit_cache_repo_ttl; | 31 | item->ttl = cgit_cache_repo_ttl; |
32 | } | 32 | } |
33 | } | 33 | } |
34 | 34 | ||
35 | int cache_exist(struct cacheitem *item) | 35 | int cache_exist(struct cacheitem *item) |
36 | { | 36 | { |
37 | if (stat(item->name, &item->st)) { | 37 | if (stat(item->name, &item->st)) { |
38 | item->st.st_mtime = 0; | 38 | item->st.st_mtime = 0; |
39 | return 0; | 39 | return 0; |
40 | } | 40 | } |
41 | return 1; | 41 | return 1; |
42 | } | 42 | } |
43 | 43 | ||
44 | int cache_create_dirs() | 44 | int cache_create_dirs() |
45 | { | 45 | { |
46 | char *path; | 46 | char *path; |
47 | 47 | ||
48 | path = fmt("%s", cgit_cache_root); | ||
49 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) | ||
50 | return 0; | ||
51 | |||
48 | if (!cgit_query_repo) | 52 | if (!cgit_query_repo) |
49 | return 0; | 53 | return 0; |
50 | 54 | ||
51 | path = fmt("%s/%s", cgit_cache_root, cgit_query_repo); | 55 | path = fmt("%s/%s", cgit_cache_root, cgit_query_repo); |
52 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) | 56 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
53 | return 0; | 57 | return 0; |
54 | 58 | ||
55 | if (cgit_query_page) { | 59 | if (cgit_query_page) { |
56 | path = fmt("%s/%s/%s", cgit_cache_root, cgit_query_repo, | 60 | path = fmt("%s/%s/%s", cgit_cache_root, cgit_query_repo, |
57 | cgit_query_page); | 61 | cgit_query_page); |
58 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) | 62 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
59 | return 0; | 63 | return 0; |
60 | } | 64 | } |
61 | return 1; | 65 | return 1; |
62 | } | 66 | } |
63 | 67 | ||
64 | int cache_refill_overdue(const char *lockfile) | 68 | int cache_refill_overdue(const char *lockfile) |
65 | { | 69 | { |
66 | struct stat st; | 70 | struct stat st; |
67 | 71 | ||
68 | if (stat(lockfile, &st)) | 72 | if (stat(lockfile, &st)) |
69 | return 0; | 73 | return 0; |
70 | else | 74 | else |
71 | return (time(NULL) - st.st_mtime > cgit_cache_max_create_time); | 75 | return (time(NULL) - st.st_mtime > cgit_cache_max_create_time); |
72 | } | 76 | } |
73 | 77 | ||
74 | int cache_lock(struct cacheitem *item) | 78 | int cache_lock(struct cacheitem *item) |
75 | { | 79 | { |
76 | int i = 0; | 80 | int i = 0; |
77 | char *lockfile = xstrdup(fmt("%s.lock", item->name)); | 81 | char *lockfile = xstrdup(fmt("%s.lock", item->name)); |
78 | 82 | ||
79 | top: | 83 | top: |
80 | if (++i > cgit_max_lock_attempts) | 84 | if (++i > cgit_max_lock_attempts) |
81 | die("cache_lock: unable to lock %s: %s", | 85 | die("cache_lock: unable to lock %s: %s", |
82 | item->name, strerror(errno)); | 86 | item->name, strerror(errno)); |
83 | 87 | ||
84 | item->fd = open(lockfile, O_WRONLY|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR); | 88 | item->fd = open(lockfile, O_WRONLY|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR); |
85 | 89 | ||
86 | if (item->fd == NOLOCK && errno == ENOENT && cache_create_dirs()) | 90 | if (item->fd == NOLOCK && errno == ENOENT && cache_create_dirs()) |
87 | goto top; | 91 | goto top; |
88 | 92 | ||
89 | if (item->fd == NOLOCK && errno == EEXIST && | 93 | if (item->fd == NOLOCK && errno == EEXIST && |
90 | cache_refill_overdue(lockfile) && !unlink(lockfile)) | 94 | cache_refill_overdue(lockfile) && !unlink(lockfile)) |
91 | goto top; | 95 | goto top; |
92 | 96 | ||
93 | free(lockfile); | 97 | free(lockfile); |
94 | return (item->fd > 0); | 98 | return (item->fd > 0); |
95 | } | 99 | } |
@@ -1,98 +1,102 @@ | |||
1 | /* cgit.c: cgi for the git scm | 1 | /* cgit.c: cgi for the git scm |
2 | * | 2 | * |
3 | * Copyright (C) 2006 Lars Hjemli | 3 | * Copyright (C) 2006 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 | 10 | ||
11 | const char cgit_version[] = CGIT_VERSION; | 11 | const char cgit_version[] = CGIT_VERSION; |
12 | 12 | ||
13 | static void cgit_print_repo_page(struct cacheitem *item) | 13 | static void cgit_print_repo_page(struct cacheitem *item) |
14 | { | 14 | { |
15 | if (chdir(fmt("%s/%s", cgit_root, cgit_query_repo)) || | 15 | if (chdir(fmt("%s/%s", cgit_root, cgit_query_repo)) || |
16 | cgit_read_config("info/cgit", cgit_repo_config_cb)) { | 16 | cgit_read_config("info/cgit", cgit_repo_config_cb)) { |
17 | char *title = fmt("%s - %s", cgit_root_title, "Bad request"); | 17 | char *title = fmt("%s - %s", cgit_root_title, "Bad request"); |
18 | cgit_print_docstart(title, item); | 18 | cgit_print_docstart(title, item); |
19 | cgit_print_pageheader(title); | 19 | cgit_print_pageheader(title); |
20 | cgit_print_error(fmt("Unable to scan repository: %s", | 20 | cgit_print_error(fmt("Unable to scan repository: %s", |
21 | strerror(errno))); | 21 | strerror(errno))); |
22 | cgit_print_docend(); | 22 | cgit_print_docend(); |
23 | return; | 23 | return; |
24 | } | 24 | } |
25 | setenv("GIT_DIR", fmt("%s/%s", cgit_root, cgit_query_repo), 1); | 25 | setenv("GIT_DIR", fmt("%s/%s", cgit_root, cgit_query_repo), 1); |
26 | char *title = fmt("%s - %s", cgit_repo_name, cgit_repo_desc); | 26 | char *title = fmt("%s - %s", cgit_repo_name, cgit_repo_desc); |
27 | cgit_print_docstart(title, item); | 27 | cgit_print_docstart(title, item); |
28 | cgit_print_pageheader(title); | 28 | cgit_print_pageheader(title); |
29 | if (!cgit_query_page) { | 29 | if (!cgit_query_page) { |
30 | cgit_print_summary(); | 30 | cgit_print_summary(); |
31 | } else if (!strcmp(cgit_query_page, "log")) { | 31 | } else if (!strcmp(cgit_query_page, "log")) { |
32 | cgit_print_log(cgit_query_head, cgit_query_ofs, 100); | 32 | cgit_print_log(cgit_query_head, cgit_query_ofs, 100); |
33 | } else if (!strcmp(cgit_query_page, "tree")) { | 33 | } else if (!strcmp(cgit_query_page, "tree")) { |
34 | cgit_print_tree(cgit_query_sha1); | 34 | cgit_print_tree(cgit_query_sha1); |
35 | } else if (!strcmp(cgit_query_page, "commit")) { | 35 | } else if (!strcmp(cgit_query_page, "commit")) { |
36 | cgit_print_commit(cgit_query_sha1); | 36 | cgit_print_commit(cgit_query_sha1); |
37 | } else if (!strcmp(cgit_query_page, "view")) { | 37 | } else if (!strcmp(cgit_query_page, "view")) { |
38 | cgit_print_view(cgit_query_sha1); | 38 | cgit_print_view(cgit_query_sha1); |
39 | } | 39 | } |
40 | cgit_print_docend(); | 40 | cgit_print_docend(); |
41 | } | 41 | } |
42 | 42 | ||
43 | static void cgit_fill_cache(struct cacheitem *item) | 43 | static void cgit_fill_cache(struct cacheitem *item) |
44 | { | 44 | { |
45 | static char buf[PATH_MAX]; | ||
46 | |||
47 | getcwd(buf, sizeof(buf)); | ||
45 | htmlfd = item->fd; | 48 | htmlfd = item->fd; |
46 | item->st.st_mtime = time(NULL); | 49 | item->st.st_mtime = time(NULL); |
47 | if (cgit_query_repo) | 50 | if (cgit_query_repo) |
48 | cgit_print_repo_page(item); | 51 | cgit_print_repo_page(item); |
49 | else | 52 | else |
50 | cgit_print_repolist(item); | 53 | cgit_print_repolist(item); |
54 | chdir(buf); | ||
51 | } | 55 | } |
52 | 56 | ||
53 | static void cgit_check_cache(struct cacheitem *item) | 57 | static void cgit_check_cache(struct cacheitem *item) |
54 | { | 58 | { |
55 | int i = 0; | 59 | int i = 0; |
56 | 60 | ||
57 | cache_prepare(item); | 61 | cache_prepare(item); |
58 | top: | 62 | top: |
59 | if (++i > cgit_max_lock_attempts) { | 63 | if (++i > cgit_max_lock_attempts) { |
60 | die("cgit_refresh_cache: unable to lock %s: %s", | 64 | die("cgit_refresh_cache: unable to lock %s: %s", |
61 | item->name, strerror(errno)); | 65 | item->name, strerror(errno)); |
62 | } | 66 | } |
63 | if (!cache_exist(item)) { | 67 | if (!cache_exist(item)) { |
64 | if (!cache_lock(item)) { | 68 | if (!cache_lock(item)) { |
65 | sleep(1); | 69 | sleep(1); |
66 | goto top; | 70 | goto top; |
67 | } | 71 | } |
68 | if (!cache_exist(item)) { | 72 | if (!cache_exist(item)) { |
69 | cgit_fill_cache(item); | 73 | cgit_fill_cache(item); |
70 | cache_unlock(item); | 74 | cache_unlock(item); |
71 | } else { | 75 | } else { |
72 | cache_cancel_lock(item); | 76 | cache_cancel_lock(item); |
73 | } | 77 | } |
74 | } else if (cache_expired(item) && cache_lock(item)) { | 78 | } else if (cache_expired(item) && cache_lock(item)) { |
75 | if (cache_expired(item)) { | 79 | if (cache_expired(item)) { |
76 | cgit_fill_cache(item); | 80 | cgit_fill_cache(item); |
77 | cache_unlock(item); | 81 | cache_unlock(item); |
78 | } else { | 82 | } else { |
79 | cache_cancel_lock(item); | 83 | cache_cancel_lock(item); |
80 | } | 84 | } |
81 | } | 85 | } |
82 | } | 86 | } |
83 | 87 | ||
84 | static void cgit_print_cache(struct cacheitem *item) | 88 | static void cgit_print_cache(struct cacheitem *item) |
85 | { | 89 | { |
86 | static char buf[4096]; | 90 | static char buf[4096]; |
87 | ssize_t i; | 91 | ssize_t i; |
88 | 92 | ||
89 | int fd = open(item->name, O_RDONLY); | 93 | int fd = open(item->name, O_RDONLY); |
90 | if (fd<0) | 94 | if (fd<0) |
91 | die("Unable to open cached file %s", item->name); | 95 | die("Unable to open cached file %s", item->name); |
92 | 96 | ||
93 | while((i=read(fd, buf, sizeof(buf))) > 0) | 97 | while((i=read(fd, buf, sizeof(buf))) > 0) |
94 | write(STDOUT_FILENO, buf, i); | 98 | write(STDOUT_FILENO, buf, i); |
95 | 99 | ||
96 | close(fd); | 100 | close(fd); |
97 | } | 101 | } |
98 | 102 | ||