cgit.c (view raw)
1/* cgit.c: cgi for the git scm
2 *
3 * Copyright (C) 2006 Lars Hjemli
4 *
5 * Licensed under GNU General Public License v2
6 * (see COPYING for full license text)
7 */
8
9#include "cgit.h"
10
11const char cgit_version[] = CGIT_VERSION;
12
13int htmlfd = 0;
14
15char *cgit_root = "/usr/src/git";
16char *cgit_root_title = "Git repository browser";
17char *cgit_css = "/cgit.css";
18char *cgit_logo = "/git-logo.png";
19char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/";
20char *cgit_virtual_root = NULL;
21
22char *cgit_cache_root = "/var/cache/cgit";
23
24int cgit_max_lock_attempts = 5;
25int cgit_cache_root_ttl = 5;
26int cgit_cache_repo_ttl = 5;
27int cgit_cache_dynamic_ttl = 5;
28int cgit_cache_static_ttl = -1;
29int cgit_cache_max_create_time = 5;
30
31char *cgit_repo_name = NULL;
32char *cgit_repo_desc = NULL;
33char *cgit_repo_owner = NULL;
34
35int cgit_query_has_symref = 0;
36int cgit_query_has_sha1 = 0;
37
38char *cgit_querystring = NULL;
39char *cgit_query_repo = NULL;
40char *cgit_query_page = NULL;
41char *cgit_query_head = NULL;
42char *cgit_query_sha1 = NULL;
43
44struct cacheitem cacheitem;
45
46void cgit_global_config_cb(const char *name, const char *value)
47{
48 if (!strcmp(name, "root"))
49 cgit_root = xstrdup(value);
50 else if (!strcmp(name, "root-title"))
51 cgit_root_title = xstrdup(value);
52 else if (!strcmp(name, "css"))
53 cgit_css = xstrdup(value);
54 else if (!strcmp(name, "logo"))
55 cgit_logo = xstrdup(value);
56 else if (!strcmp(name, "logo-link"))
57 cgit_logo_link = xstrdup(value);
58 else if (!strcmp(name, "virtual-root"))
59 cgit_virtual_root = xstrdup(value);
60}
61
62void cgit_repo_config_cb(const char *name, const char *value)
63{
64 if (!strcmp(name, "name"))
65 cgit_repo_name = xstrdup(value);
66 else if (!strcmp(name, "desc"))
67 cgit_repo_desc = xstrdup(value);
68 else if (!strcmp(name, "owner"))
69 cgit_repo_owner = xstrdup(value);
70}
71
72void cgit_querystring_cb(const char *name, const char *value)
73{
74 if (!strcmp(name,"r"))
75 cgit_query_repo = xstrdup(value);
76 else if (!strcmp(name, "p"))
77 cgit_query_page = xstrdup(value);
78 else if (!strcmp(name, "h")) {
79 cgit_query_head = xstrdup(value);
80 cgit_query_has_symref = 1;
81 } else if (!strcmp(name, "id")) {
82 cgit_query_sha1 = xstrdup(value);
83 cgit_query_has_sha1 = 1;
84 }
85}
86
87char *cgit_repourl(const char *reponame)
88{
89 if (cgit_virtual_root) {
90 return fmt("%s/%s/", cgit_virtual_root, reponame);
91 } else {
92 return fmt("?r=%s", reponame);
93 }
94}
95
96char *cgit_pageurl(const char *reponame, const char *pagename,
97 const char *query)
98{
99 if (cgit_virtual_root) {
100 return fmt("%s/%s/%s/?%s", cgit_virtual_root, reponame,
101 pagename, query);
102 } else {
103 return fmt("?r=%s&p=%s&%s", reponame, pagename, query);
104 }
105}
106
107static int cgit_print_branch_cb(const char *refname, const unsigned char *sha1,
108 int flags, void *cb_data)
109{
110 struct commit *commit;
111 char buf[256], *url;
112
113 commit = lookup_commit(sha1);
114 if (commit && !parse_commit(commit)){
115 html("<tr><td>");
116 url = cgit_pageurl(cgit_query_repo, "log",
117 fmt("h=%s", refname));
118 html_link_open(url, NULL, NULL);
119 strncpy(buf, refname, sizeof(buf));
120 html_txt(buf);
121 html_link_close();
122 html("</td><td>");
123 pretty_print_commit(CMIT_FMT_ONELINE, commit, ~0, buf,
124 sizeof(buf), 0, NULL, NULL, 0);
125 html_txt(buf);
126 html("</td></tr>\n");
127 } else {
128 html("<tr><td>");
129 html_txt(buf);
130 html("</td><td>");
131 htmlf("*** bad ref %s", sha1_to_hex(sha1));
132 html("</td></tr>\n");
133 }
134 return 0;
135}
136
137static void cgit_print_repolist(struct cacheitem *item)
138{
139 DIR *d;
140 struct dirent *de;
141 struct stat st;
142 char *name;
143
144 chdir(cgit_root);
145 cgit_print_docstart(cgit_root_title, item);
146 cgit_print_pageheader(cgit_root_title);
147
148 if (!(d = opendir("."))) {
149 cgit_print_error(fmt("Unable to scan repository directory: %s",
150 strerror(errno)));
151 cgit_print_docend();
152 return;
153 }
154
155 html("<h2>Repositories</h2>\n");
156 html("<table class='list'>");
157 html("<tr><th>Name</th><th>Description</th><th>Owner</th></tr>\n");
158 while ((de = readdir(d)) != NULL) {
159 if (de->d_name[0] == '.')
160 continue;
161 if (stat(de->d_name, &st) < 0)
162 continue;
163 if (!S_ISDIR(st.st_mode))
164 continue;
165
166 cgit_repo_name = cgit_repo_desc = cgit_repo_owner = NULL;
167 name = fmt("%s/info/cgit", de->d_name);
168 if (cgit_read_config(name, cgit_repo_config_cb))
169 continue;
170
171 html("<tr><td>");
172 html_link_open(cgit_repourl(de->d_name), NULL, NULL);
173 html_txt(cgit_repo_name);
174 html_link_close();
175 html("</td><td>");
176 html_txt(cgit_repo_desc);
177 html("</td><td>");
178 html_txt(cgit_repo_owner);
179 html("</td></tr>\n");
180 }
181 closedir(d);
182 html("</table>");
183 cgit_print_docend();
184}
185
186static void cgit_print_branches()
187{
188 html("<table class='list'>");
189 html("<tr><th>Branch name</th><th>Head commit</th></tr>\n");
190 for_each_branch_ref(cgit_print_branch_cb, NULL);
191 html("</table>");
192}
193
194static int get_one_line(char *txt)
195{
196 char *t;
197
198 for(t=txt; *t != '\n' && t != '\0'; t++)
199 ;
200 *t = '\0';
201 return t-txt-1;
202}
203
204static void cgit_print_commit_shortlog(struct commit *commit)
205{
206 char *h, *t, *p;
207 char *tree = NULL, *author = NULL, *subject = NULL;
208 int len;
209 time_t sec;
210 struct tm *time;
211 char buf[32];
212
213 h = t = commit->buffer;
214
215 if (strncmp(h, "tree ", 5))
216 die("Bad commit format: %s",
217 sha1_to_hex(commit->object.sha1));
218
219 len = get_one_line(h);
220 tree = h+5;
221 h += len + 2;
222
223 while (!strncmp(h, "parent ", 7))
224 h += get_one_line(h) + 2;
225
226 if (!strncmp(h, "author ", 7)) {
227 author = h+7;
228 h += get_one_line(h) + 2;
229 t = author;
230 while(t!=h && *t!='<')
231 t++;
232 *t='\0';
233 p = t;
234 while(--t!=author && *t==' ')
235 *t='\0';
236 while(++p!=h && *p!='>')
237 ;
238 while(++p!=h && !isdigit(*p))
239 ;
240
241 t = p;
242 while(++p && isdigit(*p))
243 ;
244 *p = '\0';
245 sec = atoi(t);
246 time = gmtime(&sec);
247 }
248
249 while((len = get_one_line(h)) > 0)
250 h += len+2;
251
252 h++;
253 len = get_one_line(h);
254
255 subject = h;
256
257 html("<tr><td>");
258 strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", time);
259 html_txt(buf);
260 html("</td><td>");
261 char *qry = fmt("id=%s", sha1_to_hex(commit->object.sha1));
262 char *url = cgit_pageurl(cgit_query_repo, "view", qry);
263 html_link_open(url, NULL, NULL);
264 html_txt(subject);
265 html_link_close();
266 html("</td><td>");
267 html_txt(author);
268 html("</td></tr>\n");
269}
270
271static void cgit_print_log(const char *tip, int ofs, int cnt)
272{
273 struct rev_info rev;
274 struct commit *commit;
275 const char *argv[2] = {NULL, tip};
276 int n = 0;
277
278 init_revisions(&rev, NULL);
279 rev.abbrev = DEFAULT_ABBREV;
280 rev.commit_format = CMIT_FMT_DEFAULT;
281 rev.verbose_header = 1;
282 rev.show_root_diff = 0;
283 setup_revisions(2, argv, &rev, NULL);
284 prepare_revision_walk(&rev);
285
286 html("<h2>Log</h2>");
287 html("<table class='list'>");
288 html("<tr><th>Date</th><th>Message</th><th>Author</th></tr>\n");
289 while ((commit = get_revision(&rev)) != NULL && n++ < 100) {
290 cgit_print_commit_shortlog(commit);
291 free(commit->buffer);
292 commit->buffer = NULL;
293 free_commit_list(commit->parents);
294 commit->parents = NULL;
295 }
296 html("</table>\n");
297}
298
299static void cgit_print_repo_summary()
300{
301 html("<h2>");
302 html_txt("Repo summary page");
303 html("</h2>");
304 cgit_print_branches();
305}
306
307static void cgit_print_object(char *hex)
308{
309 unsigned char sha1[20];
310 //struct object *object;
311 char type[20];
312 unsigned char *buf;
313 unsigned long size;
314
315 if (get_sha1_hex(hex, sha1)){
316 cgit_print_error(fmt("Bad hex value: %s", hex));
317 return;
318 }
319
320 if (sha1_object_info(sha1, type, NULL)){
321 cgit_print_error("Bad object name");
322 return;
323 }
324
325 buf = read_sha1_file(sha1, type, &size);
326 if (!buf) {
327 cgit_print_error("Error reading object");
328 return;
329 }
330
331 buf[size] = '\0';
332 html("<h2>Object view</h2>");
333 htmlf("sha1=%s<br/>type=%s<br/>size=%i<br/>", hex, type, size);
334 html("<pre>");
335 html_txt(buf);
336 html("</pre>");
337}
338
339static void cgit_print_repo_page(struct cacheitem *item)
340{
341 if (chdir(fmt("%s/%s", cgit_root, cgit_query_repo)) ||
342 cgit_read_config("info/cgit", cgit_repo_config_cb)) {
343 char *title = fmt("%s - %s", cgit_root_title, "Bad request");
344 cgit_print_docstart(title, item);
345 cgit_print_pageheader(title);
346 cgit_print_error(fmt("Unable to scan repository: %s",
347 strerror(errno)));
348 cgit_print_docend();
349 return;
350 }
351 setenv("GIT_DIR", fmt("%s/%s", cgit_root, cgit_query_repo), 1);
352 char *title = fmt("%s - %s", cgit_repo_name, cgit_repo_desc);
353 cgit_print_docstart(title, item);
354 cgit_print_pageheader(title);
355 if (!cgit_query_page)
356 cgit_print_repo_summary();
357 else if (!strcmp(cgit_query_page, "log")) {
358 cgit_print_log(cgit_query_head, 0, 100);
359 } else if (!strcmp(cgit_query_page, "view")) {
360 cgit_print_object(cgit_query_sha1);
361 }
362 cgit_print_docend();
363}
364
365static void cgit_fill_cache(struct cacheitem *item)
366{
367 htmlfd = item->fd;
368 item->st.st_mtime = time(NULL);
369 if (cgit_query_repo)
370 cgit_print_repo_page(item);
371 else
372 cgit_print_repolist(item);
373}
374
375static void cgit_refresh_cache(struct cacheitem *item)
376{
377 int i = 0;
378
379 cache_prepare(item);
380 top:
381 if (++i > cgit_max_lock_attempts) {
382 die("cgit_refresh_cache: unable to lock %s: %s",
383 item->name, strerror(errno));
384 }
385 if (!cache_exist(item)) {
386 if (!cache_lock(item)) {
387 sleep(1);
388 goto top;
389 }
390 if (!cache_exist(item))
391 cgit_fill_cache(item);
392 cache_unlock(item);
393 } else if (cache_expired(item) && cache_lock(item)) {
394 if (cache_expired(item))
395 cgit_fill_cache(item);
396 cache_unlock(item);
397 }
398}
399
400static void cgit_print_cache(struct cacheitem *item)
401{
402 static char buf[4096];
403 ssize_t i;
404
405 int fd = open(item->name, O_RDONLY);
406 if (fd<0)
407 die("Unable to open cached file %s", item->name);
408
409 while((i=read(fd, buf, sizeof(buf))) > 0)
410 write(STDOUT_FILENO, buf, i);
411
412 close(fd);
413}
414
415int main(int argc, const char **argv)
416{
417 cgit_read_config("/etc/cgitrc", cgit_global_config_cb);
418 cgit_querystring = xstrdup(getenv("QUERY_STRING"));
419 cgit_parse_query(cgit_querystring, cgit_querystring_cb);
420 cgit_refresh_cache(&cacheitem);
421 cgit_print_cache(&cacheitem);
422 return 0;
423}