author | Lars Hjemli <hjemli@gmail.com> | 2006-12-11 11:10:12 (UTC) |
---|---|---|
committer | Lars Hjemli <hjemli@gmail.com> | 2006-12-11 11:10:12 (UTC) |
commit | 318d106300102c19d114a4ea89265b0a4060d9cb (patch) (unidiff) | |
tree | 3752575abec74ee0a2b544e36e3cc8f9cdfa1e66 | |
parent | a581ed8d6c15b0734b082fbadf0a907c2b170423 (diff) | |
download | cgit-318d106300102c19d114a4ea89265b0a4060d9cb.zip cgit-318d106300102c19d114a4ea89265b0a4060d9cb.tar.gz cgit-318d106300102c19d114a4ea89265b0a4060d9cb.tar.bz2 |
Avoid infinite loops in caching layer
Add a global variable, cgit_max_lock_attemps, to avoid the possibility of
infinite loops when failing to acquire a lockfile. This could happen on
broken setups or under crazy server load.
Incidentally, this also fixes a lurking bug in cache_lock() where an
uninitialized returnvalue was used.
Signed-off-by: Lars Hjemli <hjemli@gmail.com>
-rw-r--r-- | cache.c | 35 | ||||
-rw-r--r-- | cgit.c | 9 | ||||
-rw-r--r-- | cgit.h | 1 |
3 files changed, 31 insertions, 14 deletions
@@ -1,98 +1,107 @@ | |||
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 | if (!cgit_query_repo) | 48 | if (!cgit_query_repo) |
49 | return 0; | 49 | return 0; |
50 | 50 | ||
51 | path = fmt("%s/%s", cgit_cache_root, cgit_query_repo); | 51 | path = fmt("%s/%s", cgit_cache_root, cgit_query_repo); |
52 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) | 52 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
53 | return 0; | 53 | return 0; |
54 | 54 | ||
55 | if (cgit_query_page) { | 55 | if (cgit_query_page) { |
56 | path = fmt("%s/%s/%s", cgit_cache_root, cgit_query_repo, | 56 | path = fmt("%s/%s/%s", cgit_cache_root, cgit_query_repo, |
57 | cgit_query_page); | 57 | cgit_query_page); |
58 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) | 58 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
59 | return 0; | 59 | return 0; |
60 | } | 60 | } |
61 | return 1; | 61 | return 1; |
62 | } | 62 | } |
63 | 63 | ||
64 | int cache_refill_overdue(const char *lockfile) | ||
65 | { | ||
66 | struct stat st; | ||
67 | |||
68 | if (stat(lockfile, &st)) | ||
69 | return 0; | ||
70 | else | ||
71 | return (time(NULL) - st.st_mtime > cgit_cache_max_create_time); | ||
72 | } | ||
73 | |||
64 | int cache_lock(struct cacheitem *item) | 74 | int cache_lock(struct cacheitem *item) |
65 | { | 75 | { |
66 | int ret; | 76 | int i = 0; |
67 | char *lockfile = fmt("%s.lock", item->name); | 77 | char *lockfile = fmt("%s.lock", item->name); |
68 | 78 | ||
69 | top: | 79 | top: |
70 | item->fd = open(lockfile, O_WRONLY | O_CREAT | O_EXCL, S_IRUSR|S_IWUSR); | 80 | if (++i > cgit_max_lock_attempts) |
81 | die("cache_lock: unable to lock %s: %s", | ||
82 | item->name, strerror(errno)); | ||
83 | |||
84 | item->fd = open(lockfile, O_WRONLY|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR); | ||
85 | |||
71 | if (item->fd == NOLOCK && errno == ENOENT && cache_create_dirs()) | 86 | if (item->fd == NOLOCK && errno == ENOENT && cache_create_dirs()) |
72 | goto top; | 87 | goto top; |
73 | if (item->fd == NOLOCK && errno == EEXIST) { | 88 | |
74 | struct stat st; | 89 | if (item->fd == NOLOCK && errno == EEXIST && |
75 | time_t t; | 90 | cache_refill_overdue(lockfile) && !unlink(lockfile)) |
76 | if (stat(lockfile, &st)) | ||
77 | return ret; | ||
78 | t = time(NULL); | ||
79 | if (t-st.st_mtime > cgit_cache_max_create_time && | ||
80 | !unlink(lockfile)) | ||
81 | goto top; | 91 | goto top; |
82 | return 0; | 92 | |
83 | } | ||
84 | return (item->fd > 0); | 93 | return (item->fd > 0); |
85 | } | 94 | } |
86 | 95 | ||
87 | int cache_unlock(struct cacheitem *item) | 96 | int cache_unlock(struct cacheitem *item) |
88 | { | 97 | { |
89 | close(item->fd); | 98 | close(item->fd); |
90 | return (rename(fmt("%s.lock", item->name), item->name) == 0); | 99 | return (rename(fmt("%s.lock", item->name), item->name) == 0); |
91 | } | 100 | } |
92 | 101 | ||
93 | int cache_expired(struct cacheitem *item) | 102 | int cache_expired(struct cacheitem *item) |
94 | { | 103 | { |
95 | if (item->ttl < 0) | 104 | if (item->ttl < 0) |
96 | return 0; | 105 | return 0; |
97 | return item->st.st_mtime + item->ttl * 60 < time(NULL); | 106 | return item->st.st_mtime + item->ttl * 60 < time(NULL); |
98 | } | 107 | } |
@@ -1,225 +1,226 @@ | |||
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 | const char cgit_doctype[] = | 13 | const char cgit_doctype[] = |
14 | "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n" | 14 | "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n" |
15 | " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"; | 15 | " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"; |
16 | 16 | ||
17 | const char cgit_error[] = | 17 | const char cgit_error[] = |
18 | "<div class='error'>%s</div>"; | 18 | "<div class='error'>%s</div>"; |
19 | 19 | ||
20 | const char cgit_lib_error[] = | 20 | const char cgit_lib_error[] = |
21 | "<div class='error'>%s: %s</div>"; | 21 | "<div class='error'>%s: %s</div>"; |
22 | 22 | ||
23 | int htmlfd = 0; | 23 | int htmlfd = 0; |
24 | 24 | ||
25 | char *cgit_root = "/usr/src/git"; | 25 | char *cgit_root = "/usr/src/git"; |
26 | char *cgit_root_title = "Git repository browser"; | 26 | char *cgit_root_title = "Git repository browser"; |
27 | char *cgit_css = "/cgit.css"; | 27 | char *cgit_css = "/cgit.css"; |
28 | char *cgit_logo = "/git-logo.png"; | 28 | char *cgit_logo = "/git-logo.png"; |
29 | char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; | 29 | char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; |
30 | char *cgit_virtual_root = NULL; | 30 | char *cgit_virtual_root = NULL; |
31 | 31 | ||
32 | char *cgit_cache_root = "/var/cache/cgit"; | 32 | char *cgit_cache_root = "/var/cache/cgit"; |
33 | 33 | ||
34 | int cgit_max_lock_attempts = 5; | ||
34 | int cgit_cache_root_ttl = 5; | 35 | int cgit_cache_root_ttl = 5; |
35 | int cgit_cache_repo_ttl = 5; | 36 | int cgit_cache_repo_ttl = 5; |
36 | int cgit_cache_dynamic_ttl = 5; | 37 | int cgit_cache_dynamic_ttl = 5; |
37 | int cgit_cache_static_ttl = -1; | 38 | int cgit_cache_static_ttl = -1; |
38 | int cgit_cache_max_create_time = 5; | 39 | int cgit_cache_max_create_time = 5; |
39 | 40 | ||
40 | char *cgit_repo_name = NULL; | 41 | char *cgit_repo_name = NULL; |
41 | char *cgit_repo_desc = NULL; | 42 | char *cgit_repo_desc = NULL; |
42 | char *cgit_repo_owner = NULL; | 43 | char *cgit_repo_owner = NULL; |
43 | 44 | ||
44 | int cgit_query_has_symref = 0; | 45 | int cgit_query_has_symref = 0; |
45 | int cgit_query_has_sha1 = 0; | 46 | int cgit_query_has_sha1 = 0; |
46 | 47 | ||
47 | char *cgit_querystring = NULL; | 48 | char *cgit_querystring = NULL; |
48 | char *cgit_query_repo = NULL; | 49 | char *cgit_query_repo = NULL; |
49 | char *cgit_query_page = NULL; | 50 | char *cgit_query_page = NULL; |
50 | char *cgit_query_head = NULL; | 51 | char *cgit_query_head = NULL; |
51 | char *cgit_query_sha1 = NULL; | 52 | char *cgit_query_sha1 = NULL; |
52 | 53 | ||
53 | struct cacheitem cacheitem; | 54 | struct cacheitem cacheitem; |
54 | 55 | ||
55 | int cgit_parse_query(char *txt, configfn fn) | 56 | int cgit_parse_query(char *txt, configfn fn) |
56 | { | 57 | { |
57 | char *t, *value = NULL, c; | 58 | char *t, *value = NULL, c; |
58 | 59 | ||
59 | if (!txt) | 60 | if (!txt) |
60 | return 0; | 61 | return 0; |
61 | 62 | ||
62 | t = txt = xstrdup(txt); | 63 | t = txt = xstrdup(txt); |
63 | 64 | ||
64 | while((c=*t) != '\0') { | 65 | while((c=*t) != '\0') { |
65 | if (c=='=') { | 66 | if (c=='=') { |
66 | *t = '\0'; | 67 | *t = '\0'; |
67 | value = t+1; | 68 | value = t+1; |
68 | } else if (c=='&') { | 69 | } else if (c=='&') { |
69 | *t = '\0'; | 70 | *t = '\0'; |
70 | (*fn)(txt, value); | 71 | (*fn)(txt, value); |
71 | txt = t+1; | 72 | txt = t+1; |
72 | value = NULL; | 73 | value = NULL; |
73 | } | 74 | } |
74 | t++; | 75 | t++; |
75 | } | 76 | } |
76 | if (t!=txt) | 77 | if (t!=txt) |
77 | (*fn)(txt, value); | 78 | (*fn)(txt, value); |
78 | return 0; | 79 | return 0; |
79 | } | 80 | } |
80 | 81 | ||
81 | void cgit_global_config_cb(const char *name, const char *value) | 82 | void cgit_global_config_cb(const char *name, const char *value) |
82 | { | 83 | { |
83 | if (!strcmp(name, "root")) | 84 | if (!strcmp(name, "root")) |
84 | cgit_root = xstrdup(value); | 85 | cgit_root = xstrdup(value); |
85 | else if (!strcmp(name, "root-title")) | 86 | else if (!strcmp(name, "root-title")) |
86 | cgit_root_title = xstrdup(value); | 87 | cgit_root_title = xstrdup(value); |
87 | else if (!strcmp(name, "css")) | 88 | else if (!strcmp(name, "css")) |
88 | cgit_css = xstrdup(value); | 89 | cgit_css = xstrdup(value); |
89 | else if (!strcmp(name, "logo")) | 90 | else if (!strcmp(name, "logo")) |
90 | cgit_logo = xstrdup(value); | 91 | cgit_logo = xstrdup(value); |
91 | else if (!strcmp(name, "logo-link")) | 92 | else if (!strcmp(name, "logo-link")) |
92 | cgit_logo_link = xstrdup(value); | 93 | cgit_logo_link = xstrdup(value); |
93 | else if (!strcmp(name, "virtual-root")) | 94 | else if (!strcmp(name, "virtual-root")) |
94 | cgit_virtual_root = xstrdup(value); | 95 | cgit_virtual_root = xstrdup(value); |
95 | } | 96 | } |
96 | 97 | ||
97 | void cgit_repo_config_cb(const char *name, const char *value) | 98 | void cgit_repo_config_cb(const char *name, const char *value) |
98 | { | 99 | { |
99 | if (!strcmp(name, "name")) | 100 | if (!strcmp(name, "name")) |
100 | cgit_repo_name = xstrdup(value); | 101 | cgit_repo_name = xstrdup(value); |
101 | else if (!strcmp(name, "desc")) | 102 | else if (!strcmp(name, "desc")) |
102 | cgit_repo_desc = xstrdup(value); | 103 | cgit_repo_desc = xstrdup(value); |
103 | else if (!strcmp(name, "owner")) | 104 | else if (!strcmp(name, "owner")) |
104 | cgit_repo_owner = xstrdup(value); | 105 | cgit_repo_owner = xstrdup(value); |
105 | } | 106 | } |
106 | 107 | ||
107 | void cgit_querystring_cb(const char *name, const char *value) | 108 | void cgit_querystring_cb(const char *name, const char *value) |
108 | { | 109 | { |
109 | if (!strcmp(name,"r")) | 110 | if (!strcmp(name,"r")) |
110 | cgit_query_repo = xstrdup(value); | 111 | cgit_query_repo = xstrdup(value); |
111 | else if (!strcmp(name, "p")) | 112 | else if (!strcmp(name, "p")) |
112 | cgit_query_page = xstrdup(value); | 113 | cgit_query_page = xstrdup(value); |
113 | else if (!strcmp(name, "h")) { | 114 | else if (!strcmp(name, "h")) { |
114 | cgit_query_head = xstrdup(value); | 115 | cgit_query_head = xstrdup(value); |
115 | cgit_query_has_symref = 1; | 116 | cgit_query_has_symref = 1; |
116 | } else if (!strcmp(name, "id")) { | 117 | } else if (!strcmp(name, "id")) { |
117 | cgit_query_sha1 = xstrdup(value); | 118 | cgit_query_sha1 = xstrdup(value); |
118 | cgit_query_has_sha1 = 1; | 119 | cgit_query_has_sha1 = 1; |
119 | } | 120 | } |
120 | } | 121 | } |
121 | 122 | ||
122 | char *cgit_repourl(const char *reponame) | 123 | char *cgit_repourl(const char *reponame) |
123 | { | 124 | { |
124 | if (cgit_virtual_root) { | 125 | if (cgit_virtual_root) { |
125 | return fmt("%s/%s/", cgit_virtual_root, reponame); | 126 | return fmt("%s/%s/", cgit_virtual_root, reponame); |
126 | } else { | 127 | } else { |
127 | return fmt("?r=%s", reponame); | 128 | return fmt("?r=%s", reponame); |
128 | } | 129 | } |
129 | } | 130 | } |
130 | 131 | ||
131 | char *cgit_pageurl(const char *reponame, const char *pagename, | 132 | char *cgit_pageurl(const char *reponame, const char *pagename, |
132 | const char *query) | 133 | const char *query) |
133 | { | 134 | { |
134 | if (cgit_virtual_root) { | 135 | if (cgit_virtual_root) { |
135 | return fmt("%s/%s/%s/?%s", cgit_virtual_root, reponame, | 136 | return fmt("%s/%s/%s/?%s", cgit_virtual_root, reponame, |
136 | pagename, query); | 137 | pagename, query); |
137 | } else { | 138 | } else { |
138 | return fmt("?r=%s&p=%s&%s", reponame, pagename, query); | 139 | return fmt("?r=%s&p=%s&%s", reponame, pagename, query); |
139 | } | 140 | } |
140 | } | 141 | } |
141 | 142 | ||
142 | static int cgit_print_branch_cb(const char *refname, const unsigned char *sha1, | 143 | static int cgit_print_branch_cb(const char *refname, const unsigned char *sha1, |
143 | int flags, void *cb_data) | 144 | int flags, void *cb_data) |
144 | { | 145 | { |
145 | struct commit *commit; | 146 | struct commit *commit; |
146 | char buf[256], *url; | 147 | char buf[256], *url; |
147 | 148 | ||
148 | commit = lookup_commit(sha1); | 149 | commit = lookup_commit(sha1); |
149 | if (commit && !parse_commit(commit)){ | 150 | if (commit && !parse_commit(commit)){ |
150 | html("<tr><td>"); | 151 | html("<tr><td>"); |
151 | url = cgit_pageurl(cgit_query_repo, "log", | 152 | url = cgit_pageurl(cgit_query_repo, "log", |
152 | fmt("h=%s", refname)); | 153 | fmt("h=%s", refname)); |
153 | html_link_open(url, NULL, NULL); | 154 | html_link_open(url, NULL, NULL); |
154 | strncpy(buf, refname, sizeof(buf)); | 155 | strncpy(buf, refname, sizeof(buf)); |
155 | html_txt(buf); | 156 | html_txt(buf); |
156 | html_link_close(); | 157 | html_link_close(); |
157 | html("</td><td>"); | 158 | html("</td><td>"); |
158 | pretty_print_commit(CMIT_FMT_ONELINE, commit, ~0, buf, | 159 | pretty_print_commit(CMIT_FMT_ONELINE, commit, ~0, buf, |
159 | sizeof(buf), 0, NULL, NULL, 0); | 160 | sizeof(buf), 0, NULL, NULL, 0); |
160 | html_txt(buf); | 161 | html_txt(buf); |
161 | html("</td></tr>\n"); | 162 | html("</td></tr>\n"); |
162 | } else { | 163 | } else { |
163 | html("<tr><td>"); | 164 | html("<tr><td>"); |
164 | html_txt(buf); | 165 | html_txt(buf); |
165 | html("</td><td>"); | 166 | html("</td><td>"); |
166 | htmlf("*** bad ref %s", sha1_to_hex(sha1)); | 167 | htmlf("*** bad ref %s", sha1_to_hex(sha1)); |
167 | html("</td></tr>\n"); | 168 | html("</td></tr>\n"); |
168 | } | 169 | } |
169 | return 0; | 170 | return 0; |
170 | } | 171 | } |
171 | 172 | ||
172 | /* Sun, 06 Nov 1994 08:49:37 GMT */ | 173 | /* Sun, 06 Nov 1994 08:49:37 GMT */ |
173 | static char *http_date(time_t t) | 174 | static char *http_date(time_t t) |
174 | { | 175 | { |
175 | static char day[][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; | 176 | static char day[][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; |
176 | static char month[][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", | 177 | static char month[][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", |
177 | "Jul", "Aug", "Sep", "Oct", "Now", "Dec"}; | 178 | "Jul", "Aug", "Sep", "Oct", "Now", "Dec"}; |
178 | struct tm *tm = gmtime(&t); | 179 | struct tm *tm = gmtime(&t); |
179 | return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday], | 180 | return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday], |
180 | tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year, | 181 | tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year, |
181 | tm->tm_hour, tm->tm_min, tm->tm_sec); | 182 | tm->tm_hour, tm->tm_min, tm->tm_sec); |
182 | } | 183 | } |
183 | 184 | ||
184 | static int ttl_seconds(int ttl) | 185 | static int ttl_seconds(int ttl) |
185 | { | 186 | { |
186 | if (ttl<0) | 187 | if (ttl<0) |
187 | return 60 * 60 * 24 * 365; | 188 | return 60 * 60 * 24 * 365; |
188 | else | 189 | else |
189 | return ttl * 60; | 190 | return ttl * 60; |
190 | } | 191 | } |
191 | 192 | ||
192 | static void cgit_print_docstart(char *title) | 193 | static void cgit_print_docstart(char *title) |
193 | { | 194 | { |
194 | html("Content-Type: text/html; charset=utf-8\n"); | 195 | html("Content-Type: text/html; charset=utf-8\n"); |
195 | htmlf("Last-Modified: %s\n", http_date(cacheitem.st.st_mtime)); | 196 | htmlf("Last-Modified: %s\n", http_date(cacheitem.st.st_mtime)); |
196 | htmlf("Expires: %s\n", http_date(cacheitem.st.st_mtime + | 197 | htmlf("Expires: %s\n", http_date(cacheitem.st.st_mtime + |
197 | ttl_seconds(cacheitem.ttl))); | 198 | ttl_seconds(cacheitem.ttl))); |
198 | html("\n"); | 199 | html("\n"); |
199 | html(cgit_doctype); | 200 | html(cgit_doctype); |
200 | html("<html>\n"); | 201 | html("<html>\n"); |
201 | html("<head>\n"); | 202 | html("<head>\n"); |
202 | html("<title>"); | 203 | html("<title>"); |
203 | html_txt(title); | 204 | html_txt(title); |
204 | html("</title>\n"); | 205 | html("</title>\n"); |
205 | htmlf("<meta name='generator' content='cgit v%s'/>\n", cgit_version); | 206 | htmlf("<meta name='generator' content='cgit v%s'/>\n", cgit_version); |
206 | html("<link rel='stylesheet' type='text/css' href='"); | 207 | html("<link rel='stylesheet' type='text/css' href='"); |
207 | html_attr(cgit_css); | 208 | html_attr(cgit_css); |
208 | html("'/>\n"); | 209 | html("'/>\n"); |
209 | html("</head>\n"); | 210 | html("</head>\n"); |
210 | html("<body>\n"); | 211 | html("<body>\n"); |
211 | } | 212 | } |
212 | 213 | ||
213 | static void cgit_print_docend() | 214 | static void cgit_print_docend() |
214 | { | 215 | { |
215 | html("</body>\n</html>\n"); | 216 | html("</body>\n</html>\n"); |
216 | } | 217 | } |
217 | 218 | ||
218 | static void cgit_print_pageheader(char *title) | 219 | static void cgit_print_pageheader(char *title) |
219 | { | 220 | { |
220 | html("<div id='header'>"); | 221 | html("<div id='header'>"); |
221 | htmlf("<a href='%s'>", cgit_logo_link); | 222 | htmlf("<a href='%s'>", cgit_logo_link); |
222 | htmlf("<img id='logo' src='%s'/>\n", cgit_logo); | 223 | htmlf("<img id='logo' src='%s'/>\n", cgit_logo); |
223 | htmlf("</a>"); | 224 | htmlf("</a>"); |
224 | html_txt(title); | 225 | html_txt(title); |
225 | html("</div>"); | 226 | html("</div>"); |
@@ -276,233 +277,239 @@ static void cgit_print_repolist() | |||
276 | 277 | ||
277 | static void cgit_print_branches() | 278 | static void cgit_print_branches() |
278 | { | 279 | { |
279 | html("<table class='list'>"); | 280 | html("<table class='list'>"); |
280 | html("<tr><th>Branch name</th><th>Head commit</th></tr>\n"); | 281 | html("<tr><th>Branch name</th><th>Head commit</th></tr>\n"); |
281 | for_each_branch_ref(cgit_print_branch_cb, NULL); | 282 | for_each_branch_ref(cgit_print_branch_cb, NULL); |
282 | html("</table>"); | 283 | html("</table>"); |
283 | } | 284 | } |
284 | 285 | ||
285 | static int get_one_line(char *txt) | 286 | static int get_one_line(char *txt) |
286 | { | 287 | { |
287 | char *t; | 288 | char *t; |
288 | 289 | ||
289 | for(t=txt; *t != '\n' && t != '\0'; t++) | 290 | for(t=txt; *t != '\n' && t != '\0'; t++) |
290 | ; | 291 | ; |
291 | *t = '\0'; | 292 | *t = '\0'; |
292 | return t-txt-1; | 293 | return t-txt-1; |
293 | } | 294 | } |
294 | 295 | ||
295 | static void cgit_print_commit_shortlog(struct commit *commit) | 296 | static void cgit_print_commit_shortlog(struct commit *commit) |
296 | { | 297 | { |
297 | char *h, *t, *p; | 298 | char *h, *t, *p; |
298 | char *tree = NULL, *author = NULL, *subject = NULL; | 299 | char *tree = NULL, *author = NULL, *subject = NULL; |
299 | int len; | 300 | int len; |
300 | time_t sec; | 301 | time_t sec; |
301 | struct tm *time; | 302 | struct tm *time; |
302 | char buf[32]; | 303 | char buf[32]; |
303 | 304 | ||
304 | h = t = commit->buffer; | 305 | h = t = commit->buffer; |
305 | 306 | ||
306 | if (strncmp(h, "tree ", 5)) | 307 | if (strncmp(h, "tree ", 5)) |
307 | die("Bad commit format: %s", | 308 | die("Bad commit format: %s", |
308 | sha1_to_hex(commit->object.sha1)); | 309 | sha1_to_hex(commit->object.sha1)); |
309 | 310 | ||
310 | len = get_one_line(h); | 311 | len = get_one_line(h); |
311 | tree = h+5; | 312 | tree = h+5; |
312 | h += len + 2; | 313 | h += len + 2; |
313 | 314 | ||
314 | while (!strncmp(h, "parent ", 7)) | 315 | while (!strncmp(h, "parent ", 7)) |
315 | h += get_one_line(h) + 2; | 316 | h += get_one_line(h) + 2; |
316 | 317 | ||
317 | if (!strncmp(h, "author ", 7)) { | 318 | if (!strncmp(h, "author ", 7)) { |
318 | author = h+7; | 319 | author = h+7; |
319 | h += get_one_line(h) + 2; | 320 | h += get_one_line(h) + 2; |
320 | t = author; | 321 | t = author; |
321 | while(t!=h && *t!='<') | 322 | while(t!=h && *t!='<') |
322 | t++; | 323 | t++; |
323 | *t='\0'; | 324 | *t='\0'; |
324 | p = t; | 325 | p = t; |
325 | while(--t!=author && *t==' ') | 326 | while(--t!=author && *t==' ') |
326 | *t='\0'; | 327 | *t='\0'; |
327 | while(++p!=h && *p!='>') | 328 | while(++p!=h && *p!='>') |
328 | ; | 329 | ; |
329 | while(++p!=h && !isdigit(*p)) | 330 | while(++p!=h && !isdigit(*p)) |
330 | ; | 331 | ; |
331 | 332 | ||
332 | t = p; | 333 | t = p; |
333 | while(++p && isdigit(*p)) | 334 | while(++p && isdigit(*p)) |
334 | ; | 335 | ; |
335 | *p = '\0'; | 336 | *p = '\0'; |
336 | sec = atoi(t); | 337 | sec = atoi(t); |
337 | time = gmtime(&sec); | 338 | time = gmtime(&sec); |
338 | } | 339 | } |
339 | 340 | ||
340 | while((len = get_one_line(h)) > 0) | 341 | while((len = get_one_line(h)) > 0) |
341 | h += len+2; | 342 | h += len+2; |
342 | 343 | ||
343 | h++; | 344 | h++; |
344 | len = get_one_line(h); | 345 | len = get_one_line(h); |
345 | 346 | ||
346 | subject = h; | 347 | subject = h; |
347 | 348 | ||
348 | html("<tr><td>"); | 349 | html("<tr><td>"); |
349 | strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", time); | 350 | strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", time); |
350 | html_txt(buf); | 351 | html_txt(buf); |
351 | html("</td><td>"); | 352 | html("</td><td>"); |
352 | char *qry = fmt("id=%s", sha1_to_hex(commit->object.sha1)); | 353 | char *qry = fmt("id=%s", sha1_to_hex(commit->object.sha1)); |
353 | char *url = cgit_pageurl(cgit_query_repo, "view", qry); | 354 | char *url = cgit_pageurl(cgit_query_repo, "view", qry); |
354 | html_link_open(url, NULL, NULL); | 355 | html_link_open(url, NULL, NULL); |
355 | html_txt(subject); | 356 | html_txt(subject); |
356 | html_link_close(); | 357 | html_link_close(); |
357 | html("</td><td>"); | 358 | html("</td><td>"); |
358 | html_txt(author); | 359 | html_txt(author); |
359 | html("</td></tr>\n"); | 360 | html("</td></tr>\n"); |
360 | } | 361 | } |
361 | 362 | ||
362 | static void cgit_print_log(const char *tip, int ofs, int cnt) | 363 | static void cgit_print_log(const char *tip, int ofs, int cnt) |
363 | { | 364 | { |
364 | struct rev_info rev; | 365 | struct rev_info rev; |
365 | struct commit *commit; | 366 | struct commit *commit; |
366 | const char *argv[2] = {NULL, tip}; | 367 | const char *argv[2] = {NULL, tip}; |
367 | int n = 0; | 368 | int n = 0; |
368 | 369 | ||
369 | init_revisions(&rev, NULL); | 370 | init_revisions(&rev, NULL); |
370 | rev.abbrev = DEFAULT_ABBREV; | 371 | rev.abbrev = DEFAULT_ABBREV; |
371 | rev.commit_format = CMIT_FMT_DEFAULT; | 372 | rev.commit_format = CMIT_FMT_DEFAULT; |
372 | rev.verbose_header = 1; | 373 | rev.verbose_header = 1; |
373 | rev.show_root_diff = 0; | 374 | rev.show_root_diff = 0; |
374 | setup_revisions(2, argv, &rev, NULL); | 375 | setup_revisions(2, argv, &rev, NULL); |
375 | prepare_revision_walk(&rev); | 376 | prepare_revision_walk(&rev); |
376 | 377 | ||
377 | html("<h2>Log</h2>"); | 378 | html("<h2>Log</h2>"); |
378 | html("<table class='list'>"); | 379 | html("<table class='list'>"); |
379 | html("<tr><th>Date</th><th>Message</th><th>Author</th></tr>\n"); | 380 | html("<tr><th>Date</th><th>Message</th><th>Author</th></tr>\n"); |
380 | while ((commit = get_revision(&rev)) != NULL && n++ < 100) { | 381 | while ((commit = get_revision(&rev)) != NULL && n++ < 100) { |
381 | cgit_print_commit_shortlog(commit); | 382 | cgit_print_commit_shortlog(commit); |
382 | free(commit->buffer); | 383 | free(commit->buffer); |
383 | commit->buffer = NULL; | 384 | commit->buffer = NULL; |
384 | free_commit_list(commit->parents); | 385 | free_commit_list(commit->parents); |
385 | commit->parents = NULL; | 386 | commit->parents = NULL; |
386 | } | 387 | } |
387 | html("</table>\n"); | 388 | html("</table>\n"); |
388 | } | 389 | } |
389 | 390 | ||
390 | static void cgit_print_repo_summary() | 391 | static void cgit_print_repo_summary() |
391 | { | 392 | { |
392 | html("<h2>"); | 393 | html("<h2>"); |
393 | html_txt("Repo summary page"); | 394 | html_txt("Repo summary page"); |
394 | html("</h2>"); | 395 | html("</h2>"); |
395 | cgit_print_branches(); | 396 | cgit_print_branches(); |
396 | } | 397 | } |
397 | 398 | ||
398 | static void cgit_print_object(char *hex) | 399 | static void cgit_print_object(char *hex) |
399 | { | 400 | { |
400 | unsigned char sha1[20]; | 401 | unsigned char sha1[20]; |
401 | //struct object *object; | 402 | //struct object *object; |
402 | char type[20]; | 403 | char type[20]; |
403 | unsigned char *buf; | 404 | unsigned char *buf; |
404 | unsigned long size; | 405 | unsigned long size; |
405 | 406 | ||
406 | if (get_sha1_hex(hex, sha1)){ | 407 | if (get_sha1_hex(hex, sha1)){ |
407 | htmlf(cgit_error, "Bad hex value"); | 408 | htmlf(cgit_error, "Bad hex value"); |
408 | return; | 409 | return; |
409 | } | 410 | } |
410 | 411 | ||
411 | if (sha1_object_info(sha1, type, NULL)){ | 412 | if (sha1_object_info(sha1, type, NULL)){ |
412 | htmlf(cgit_error, "Bad object name"); | 413 | htmlf(cgit_error, "Bad object name"); |
413 | return; | 414 | return; |
414 | } | 415 | } |
415 | 416 | ||
416 | buf = read_sha1_file(sha1, type, &size); | 417 | buf = read_sha1_file(sha1, type, &size); |
417 | if (!buf) { | 418 | if (!buf) { |
418 | htmlf(cgit_error, "Error reading object"); | 419 | htmlf(cgit_error, "Error reading object"); |
419 | return; | 420 | return; |
420 | } | 421 | } |
421 | 422 | ||
422 | buf[size] = '\0'; | 423 | buf[size] = '\0'; |
423 | html("<h2>Object view</h2>"); | 424 | html("<h2>Object view</h2>"); |
424 | htmlf("sha1=%s<br/>type=%s<br/>size=%i<br/>", hex, type, size); | 425 | htmlf("sha1=%s<br/>type=%s<br/>size=%i<br/>", hex, type, size); |
425 | html("<pre>"); | 426 | html("<pre>"); |
426 | html_txt(buf); | 427 | html_txt(buf); |
427 | html("</pre>"); | 428 | html("</pre>"); |
428 | } | 429 | } |
429 | 430 | ||
430 | static void cgit_print_repo_page() | 431 | static void cgit_print_repo_page() |
431 | { | 432 | { |
432 | if (chdir(fmt("%s/%s", cgit_root, cgit_query_repo)) || | 433 | if (chdir(fmt("%s/%s", cgit_root, cgit_query_repo)) || |
433 | cgit_read_config("info/cgit", cgit_repo_config_cb)) { | 434 | cgit_read_config("info/cgit", cgit_repo_config_cb)) { |
434 | char *title = fmt("%s - %s", cgit_root_title, "Bad request"); | 435 | char *title = fmt("%s - %s", cgit_root_title, "Bad request"); |
435 | cgit_print_docstart(title); | 436 | cgit_print_docstart(title); |
436 | cgit_print_pageheader(title); | 437 | cgit_print_pageheader(title); |
437 | htmlf(cgit_lib_error, "Unable to scan repository", | 438 | htmlf(cgit_lib_error, "Unable to scan repository", |
438 | strerror(errno)); | 439 | strerror(errno)); |
439 | cgit_print_docend(); | 440 | cgit_print_docend(); |
440 | return; | 441 | return; |
441 | } | 442 | } |
442 | setenv("GIT_DIR", fmt("%s/%s", cgit_root, cgit_query_repo), 1); | 443 | setenv("GIT_DIR", fmt("%s/%s", cgit_root, cgit_query_repo), 1); |
443 | char *title = fmt("%s - %s", cgit_repo_name, cgit_repo_desc); | 444 | char *title = fmt("%s - %s", cgit_repo_name, cgit_repo_desc); |
444 | cgit_print_docstart(title); | 445 | cgit_print_docstart(title); |
445 | cgit_print_pageheader(title); | 446 | cgit_print_pageheader(title); |
446 | if (!cgit_query_page) | 447 | if (!cgit_query_page) |
447 | cgit_print_repo_summary(); | 448 | cgit_print_repo_summary(); |
448 | else if (!strcmp(cgit_query_page, "log")) { | 449 | else if (!strcmp(cgit_query_page, "log")) { |
449 | cgit_print_log(cgit_query_head, 0, 100); | 450 | cgit_print_log(cgit_query_head, 0, 100); |
450 | } else if (!strcmp(cgit_query_page, "view")) { | 451 | } else if (!strcmp(cgit_query_page, "view")) { |
451 | cgit_print_object(cgit_query_sha1); | 452 | cgit_print_object(cgit_query_sha1); |
452 | } | 453 | } |
453 | cgit_print_docend(); | 454 | cgit_print_docend(); |
454 | } | 455 | } |
455 | 456 | ||
456 | static void cgit_fill_cache(struct cacheitem *item) | 457 | static void cgit_fill_cache(struct cacheitem *item) |
457 | { | 458 | { |
458 | htmlfd = item->fd; | 459 | htmlfd = item->fd; |
459 | item->st.st_mtime = time(NULL); | 460 | item->st.st_mtime = time(NULL); |
460 | if (cgit_query_repo) | 461 | if (cgit_query_repo) |
461 | cgit_print_repo_page(); | 462 | cgit_print_repo_page(); |
462 | else | 463 | else |
463 | cgit_print_repolist(); | 464 | cgit_print_repolist(); |
464 | } | 465 | } |
465 | 466 | ||
466 | static void cgit_refresh_cache(struct cacheitem *item) | 467 | static void cgit_refresh_cache(struct cacheitem *item) |
467 | { | 468 | { |
469 | int i = 0; | ||
470 | |||
468 | cache_prepare(item); | 471 | cache_prepare(item); |
469 | top: | 472 | top: |
473 | if (++i > cgit_max_lock_attempts) { | ||
474 | die("cgit_refresh_cache: unable to lock %s: %s", | ||
475 | item->name, strerror(errno)); | ||
476 | } | ||
470 | if (!cache_exist(item)) { | 477 | if (!cache_exist(item)) { |
471 | if (!cache_lock(item)) { | 478 | if (!cache_lock(item)) { |
472 | sched_yield(); | 479 | sleep(1); |
473 | goto top; | 480 | goto top; |
474 | } | 481 | } |
475 | if (!cache_exist(item)) | 482 | if (!cache_exist(item)) |
476 | cgit_fill_cache(item); | 483 | cgit_fill_cache(item); |
477 | cache_unlock(item); | 484 | cache_unlock(item); |
478 | } else if (cache_expired(item) && cache_lock(item)) { | 485 | } else if (cache_expired(item) && cache_lock(item)) { |
479 | if (cache_expired(item)) | 486 | if (cache_expired(item)) |
480 | cgit_fill_cache(item); | 487 | cgit_fill_cache(item); |
481 | cache_unlock(item); | 488 | cache_unlock(item); |
482 | } | 489 | } |
483 | } | 490 | } |
484 | 491 | ||
485 | static void cgit_print_cache(struct cacheitem *item) | 492 | static void cgit_print_cache(struct cacheitem *item) |
486 | { | 493 | { |
487 | static char buf[4096]; | 494 | static char buf[4096]; |
488 | ssize_t i; | 495 | ssize_t i; |
489 | 496 | ||
490 | int fd = open(item->name, O_RDONLY); | 497 | int fd = open(item->name, O_RDONLY); |
491 | if (fd<0) | 498 | if (fd<0) |
492 | die("Unable to open cached file %s", item->name); | 499 | die("Unable to open cached file %s", item->name); |
493 | 500 | ||
494 | while((i=read(fd, buf, sizeof(buf))) > 0) | 501 | while((i=read(fd, buf, sizeof(buf))) > 0) |
495 | write(STDOUT_FILENO, buf, i); | 502 | write(STDOUT_FILENO, buf, i); |
496 | 503 | ||
497 | close(fd); | 504 | close(fd); |
498 | } | 505 | } |
499 | 506 | ||
500 | int main(int argc, const char **argv) | 507 | int main(int argc, const char **argv) |
501 | { | 508 | { |
502 | cgit_read_config("/etc/cgitrc", cgit_global_config_cb); | 509 | cgit_read_config("/etc/cgitrc", cgit_global_config_cb); |
503 | cgit_querystring = xstrdup(getenv("QUERY_STRING")); | 510 | cgit_querystring = xstrdup(getenv("QUERY_STRING")); |
504 | cgit_parse_query(cgit_querystring, cgit_querystring_cb); | 511 | cgit_parse_query(cgit_querystring, cgit_querystring_cb); |
505 | cgit_refresh_cache(&cacheitem); | 512 | cgit_refresh_cache(&cacheitem); |
506 | cgit_print_cache(&cacheitem); | 513 | cgit_print_cache(&cacheitem); |
507 | return 0; | 514 | return 0; |
508 | } | 515 | } |
@@ -1,65 +1,66 @@ | |||
1 | #ifndef CGIT_H | 1 | #ifndef CGIT_H |
2 | #define CGIT_H | 2 | #define CGIT_H |
3 | 3 | ||
4 | #include "git.h" | 4 | #include "git.h" |
5 | #include <openssl/sha.h> | 5 | #include <openssl/sha.h> |
6 | #include <ctype.h> | 6 | #include <ctype.h> |
7 | #include <sched.h> | 7 | #include <sched.h> |
8 | 8 | ||
9 | typedef void (*configfn)(const char *name, const char *value); | 9 | typedef void (*configfn)(const char *name, const char *value); |
10 | 10 | ||
11 | struct cacheitem { | 11 | struct cacheitem { |
12 | char *name; | 12 | char *name; |
13 | struct stat st; | 13 | struct stat st; |
14 | int ttl; | 14 | int ttl; |
15 | int fd; | 15 | int fd; |
16 | }; | 16 | }; |
17 | 17 | ||
18 | extern char *cgit_root; | 18 | extern char *cgit_root; |
19 | extern char *cgit_root_title; | 19 | extern char *cgit_root_title; |
20 | extern char *cgit_css; | 20 | extern char *cgit_css; |
21 | extern char *cgit_logo; | 21 | extern char *cgit_logo; |
22 | extern char *cgit_logo_link; | 22 | extern char *cgit_logo_link; |
23 | extern char *cgit_virtual_root; | 23 | extern char *cgit_virtual_root; |
24 | extern char *cgit_cache_root; | 24 | extern char *cgit_cache_root; |
25 | 25 | ||
26 | extern int cgit_max_lock_attempts; | ||
26 | extern int cgit_cache_root_ttl; | 27 | extern int cgit_cache_root_ttl; |
27 | extern int cgit_cache_repo_ttl; | 28 | extern int cgit_cache_repo_ttl; |
28 | extern int cgit_cache_dynamic_ttl; | 29 | extern int cgit_cache_dynamic_ttl; |
29 | extern int cgit_cache_static_ttl; | 30 | extern int cgit_cache_static_ttl; |
30 | extern int cgit_cache_max_create_time; | 31 | extern int cgit_cache_max_create_time; |
31 | 32 | ||
32 | extern char *cgit_repo_name; | 33 | extern char *cgit_repo_name; |
33 | extern char *cgit_repo_desc; | 34 | extern char *cgit_repo_desc; |
34 | extern char *cgit_repo_owner; | 35 | extern char *cgit_repo_owner; |
35 | 36 | ||
36 | extern int cgit_query_has_symref; | 37 | extern int cgit_query_has_symref; |
37 | extern int cgit_query_has_sha1; | 38 | extern int cgit_query_has_sha1; |
38 | 39 | ||
39 | extern char *cgit_querystring; | 40 | extern char *cgit_querystring; |
40 | extern char *cgit_query_repo; | 41 | extern char *cgit_query_repo; |
41 | extern char *cgit_query_page; | 42 | extern char *cgit_query_page; |
42 | extern char *cgit_query_head; | 43 | extern char *cgit_query_head; |
43 | extern char *cgit_query_sha1; | 44 | extern char *cgit_query_sha1; |
44 | 45 | ||
45 | extern int htmlfd; | 46 | extern int htmlfd; |
46 | 47 | ||
47 | extern char *fmt(const char *format,...); | 48 | extern char *fmt(const char *format,...); |
48 | 49 | ||
49 | extern void html(const char *txt); | 50 | extern void html(const char *txt); |
50 | extern void htmlf(const char *format,...); | 51 | extern void htmlf(const char *format,...); |
51 | extern void html_txt(char *txt); | 52 | extern void html_txt(char *txt); |
52 | extern void html_attr(char *txt); | 53 | extern void html_attr(char *txt); |
53 | extern void html_link_open(char *url, char *title, char *class); | 54 | extern void html_link_open(char *url, char *title, char *class); |
54 | extern void html_link_close(void); | 55 | extern void html_link_close(void); |
55 | 56 | ||
56 | 57 | ||
57 | extern int cgit_read_config(const char *filename, configfn fn); | 58 | extern int cgit_read_config(const char *filename, configfn fn); |
58 | 59 | ||
59 | extern void cache_prepare(struct cacheitem *item); | 60 | extern void cache_prepare(struct cacheitem *item); |
60 | extern int cache_lock(struct cacheitem *item); | 61 | extern int cache_lock(struct cacheitem *item); |
61 | extern int cache_unlock(struct cacheitem *item); | 62 | extern int cache_unlock(struct cacheitem *item); |
62 | extern int cache_exist(struct cacheitem *item); | 63 | extern int cache_exist(struct cacheitem *item); |
63 | extern int cache_expired(struct cacheitem *item); | 64 | extern int cache_expired(struct cacheitem *item); |
64 | 65 | ||
65 | #endif /* CGIT_H */ | 66 | #endif /* CGIT_H */ |