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