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