summaryrefslogtreecommitdiffabout
Unidiff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--cache.c35
-rw-r--r--cgit.c9
-rw-r--r--cgit.h1
3 files changed, 31 insertions, 14 deletions
diff --git a/cache.c b/cache.c
index 0ffa502..2e1ef8c 100644
--- a/cache.c
+++ b/cache.c
@@ -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
11const int NOLOCK = -1; 11const int NOLOCK = -1;
12 12
13void cache_prepare(struct cacheitem *item) 13void 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
35int cache_exist(struct cacheitem *item) 35int 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
44int cache_create_dirs() 44int 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
64int 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
64int cache_lock(struct cacheitem *item) 74int 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
87int cache_unlock(struct cacheitem *item) 96int 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
93int cache_expired(struct cacheitem *item) 102int 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}
diff --git a/cgit.c b/cgit.c
index 7f14016..dc91125 100644
--- a/cgit.c
+++ b/cgit.c
@@ -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
11const char cgit_version[] = CGIT_VERSION; 11const char cgit_version[] = CGIT_VERSION;
12 12
13const char cgit_doctype[] = 13const 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
17const char cgit_error[] = 17const char cgit_error[] =
18"<div class='error'>%s</div>"; 18"<div class='error'>%s</div>";
19 19
20const char cgit_lib_error[] = 20const char cgit_lib_error[] =
21"<div class='error'>%s: %s</div>"; 21"<div class='error'>%s: %s</div>";
22 22
23int htmlfd = 0; 23int htmlfd = 0;
24 24
25char *cgit_root = "/usr/src/git"; 25char *cgit_root = "/usr/src/git";
26char *cgit_root_title = "Git repository browser"; 26char *cgit_root_title = "Git repository browser";
27char *cgit_css = "/cgit.css"; 27char *cgit_css = "/cgit.css";
28char *cgit_logo = "/git-logo.png"; 28char *cgit_logo = "/git-logo.png";
29char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; 29char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/";
30char *cgit_virtual_root = NULL; 30char *cgit_virtual_root = NULL;
31 31
32char *cgit_cache_root = "/var/cache/cgit"; 32char *cgit_cache_root = "/var/cache/cgit";
33 33
34int cgit_max_lock_attempts = 5;
34int cgit_cache_root_ttl = 5; 35int cgit_cache_root_ttl = 5;
35int cgit_cache_repo_ttl = 5; 36int cgit_cache_repo_ttl = 5;
36int cgit_cache_dynamic_ttl = 5; 37int cgit_cache_dynamic_ttl = 5;
37int cgit_cache_static_ttl = -1; 38int cgit_cache_static_ttl = -1;
38int cgit_cache_max_create_time = 5; 39int cgit_cache_max_create_time = 5;
39 40
40char *cgit_repo_name = NULL; 41char *cgit_repo_name = NULL;
41char *cgit_repo_desc = NULL; 42char *cgit_repo_desc = NULL;
42char *cgit_repo_owner = NULL; 43char *cgit_repo_owner = NULL;
43 44
44int cgit_query_has_symref = 0; 45int cgit_query_has_symref = 0;
45int cgit_query_has_sha1 = 0; 46int cgit_query_has_sha1 = 0;
46 47
47char *cgit_querystring = NULL; 48char *cgit_querystring = NULL;
48char *cgit_query_repo = NULL; 49char *cgit_query_repo = NULL;
49char *cgit_query_page = NULL; 50char *cgit_query_page = NULL;
50char *cgit_query_head = NULL; 51char *cgit_query_head = NULL;
51char *cgit_query_sha1 = NULL; 52char *cgit_query_sha1 = NULL;
52 53
53struct cacheitem cacheitem; 54struct cacheitem cacheitem;
54 55
55int cgit_parse_query(char *txt, configfn fn) 56int 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
81void cgit_global_config_cb(const char *name, const char *value) 82void 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
97void cgit_repo_config_cb(const char *name, const char *value) 98void 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
107void cgit_querystring_cb(const char *name, const char *value) 108void 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
122char *cgit_repourl(const char *reponame) 123char *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
131char *cgit_pageurl(const char *reponame, const char *pagename, 132char *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
142static int cgit_print_branch_cb(const char *refname, const unsigned char *sha1, 143static 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 */
173static char *http_date(time_t t) 174static 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
184static int ttl_seconds(int ttl) 185static 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
192static void cgit_print_docstart(char *title) 193static 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
213static void cgit_print_docend() 214static void cgit_print_docend()
214{ 215{
215 html("</body>\n</html>\n"); 216 html("</body>\n</html>\n");
216} 217}
217 218
218static void cgit_print_pageheader(char *title) 219static 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
277static void cgit_print_branches() 278static 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
285static int get_one_line(char *txt) 286static 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
295static void cgit_print_commit_shortlog(struct commit *commit) 296static 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
362static void cgit_print_log(const char *tip, int ofs, int cnt) 363static 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
390static void cgit_print_repo_summary() 391static 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
398static void cgit_print_object(char *hex) 399static 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
430static void cgit_print_repo_page() 431static 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
456static void cgit_fill_cache(struct cacheitem *item) 457static 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
466static void cgit_refresh_cache(struct cacheitem *item) 467static 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
485static void cgit_print_cache(struct cacheitem *item) 492static 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
500int main(int argc, const char **argv) 507int 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}
diff --git a/cgit.h b/cgit.h
index 3b0994a..7e4bfef 100644
--- a/cgit.h
+++ b/cgit.h
@@ -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
9typedef void (*configfn)(const char *name, const char *value); 9typedef void (*configfn)(const char *name, const char *value);
10 10
11struct cacheitem { 11struct 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
18extern char *cgit_root; 18extern char *cgit_root;
19extern char *cgit_root_title; 19extern char *cgit_root_title;
20extern char *cgit_css; 20extern char *cgit_css;
21extern char *cgit_logo; 21extern char *cgit_logo;
22extern char *cgit_logo_link; 22extern char *cgit_logo_link;
23extern char *cgit_virtual_root; 23extern char *cgit_virtual_root;
24extern char *cgit_cache_root; 24extern char *cgit_cache_root;
25 25
26extern int cgit_max_lock_attempts;
26extern int cgit_cache_root_ttl; 27extern int cgit_cache_root_ttl;
27extern int cgit_cache_repo_ttl; 28extern int cgit_cache_repo_ttl;
28extern int cgit_cache_dynamic_ttl; 29extern int cgit_cache_dynamic_ttl;
29extern int cgit_cache_static_ttl; 30extern int cgit_cache_static_ttl;
30extern int cgit_cache_max_create_time; 31extern int cgit_cache_max_create_time;
31 32
32extern char *cgit_repo_name; 33extern char *cgit_repo_name;
33extern char *cgit_repo_desc; 34extern char *cgit_repo_desc;
34extern char *cgit_repo_owner; 35extern char *cgit_repo_owner;
35 36
36extern int cgit_query_has_symref; 37extern int cgit_query_has_symref;
37extern int cgit_query_has_sha1; 38extern int cgit_query_has_sha1;
38 39
39extern char *cgit_querystring; 40extern char *cgit_querystring;
40extern char *cgit_query_repo; 41extern char *cgit_query_repo;
41extern char *cgit_query_page; 42extern char *cgit_query_page;
42extern char *cgit_query_head; 43extern char *cgit_query_head;
43extern char *cgit_query_sha1; 44extern char *cgit_query_sha1;
44 45
45extern int htmlfd; 46extern int htmlfd;
46 47
47extern char *fmt(const char *format,...); 48extern char *fmt(const char *format,...);
48 49
49extern void html(const char *txt); 50extern void html(const char *txt);
50extern void htmlf(const char *format,...); 51extern void htmlf(const char *format,...);
51extern void html_txt(char *txt); 52extern void html_txt(char *txt);
52extern void html_attr(char *txt); 53extern void html_attr(char *txt);
53extern void html_link_open(char *url, char *title, char *class); 54extern void html_link_open(char *url, char *title, char *class);
54extern void html_link_close(void); 55extern void html_link_close(void);
55 56
56 57
57extern int cgit_read_config(const char *filename, configfn fn); 58extern int cgit_read_config(const char *filename, configfn fn);
58 59
59extern void cache_prepare(struct cacheitem *item); 60extern void cache_prepare(struct cacheitem *item);
60extern int cache_lock(struct cacheitem *item); 61extern int cache_lock(struct cacheitem *item);
61extern int cache_unlock(struct cacheitem *item); 62extern int cache_unlock(struct cacheitem *item);
62extern int cache_exist(struct cacheitem *item); 63extern int cache_exist(struct cacheitem *item);
63extern int cache_expired(struct cacheitem *item); 64extern int cache_expired(struct cacheitem *item);
64 65
65#endif /* CGIT_H */ 66#endif /* CGIT_H */