summaryrefslogtreecommitdiffabout
authorLars Hjemli <hjemli@gmail.com>2007-06-29 18:32:08 (UTC)
committer Lars Hjemli <hjemli@gmail.com>2007-06-29 18:32:08 (UTC)
commit16a3d2779ccd56bf7954d98da547247d8796544b (patch) (unidiff)
tree86d2ed41adc3de842c7518d614ea49ca0200e4d2
parentf69250358a74efa5d7d9c562b2cdd80fad1430f1 (diff)
parent103940fe6b0914dc42b8b033d1d328f38135ca5f (diff)
downloadcgit-16a3d2779ccd56bf7954d98da547247d8796544b.zip
cgit-16a3d2779ccd56bf7954d98da547247d8796544b.tar.gz
cgit-16a3d2779ccd56bf7954d98da547247d8796544b.tar.bz2
Merge branch 'lh/menu'
* lh/menu: Add ofs argument to cgit_log_link and use it in ui-log.c Add trim_end() and use it to remove trailing slashes from repo paths Do not include current path in the "tree" menu link Add setting to enable/disable extra links on index page Change S/L/T to summary/log/tree Change "files" to "tree" Include querystring as part of cached filename for repo summary page Add more menuitems on repo pages
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--cgit.c10
-rw-r--r--cgit.css23
-rw-r--r--cgit.h4
-rw-r--r--cgitrc4
-rw-r--r--parsing.c2
-rw-r--r--shared.c27
-rw-r--r--ui-log.c16
-rw-r--r--ui-repolist.c35
-rw-r--r--ui-shared.c71
-rw-r--r--ui-summary.c2
-rw-r--r--ui-tree.c4
11 files changed, 145 insertions, 53 deletions
diff --git a/cgit.c b/cgit.c
index 11dff76..d9a03c2 100644
--- a/cgit.c
+++ b/cgit.c
@@ -1,163 +1,165 @@
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
11static int cgit_prepare_cache(struct cacheitem *item) 11static int cgit_prepare_cache(struct cacheitem *item)
12{ 12{
13 if (!cgit_repo && cgit_query_repo) { 13 if (!cgit_repo && cgit_query_repo) {
14 char *title = fmt("%s - %s", cgit_root_title, "Bad request"); 14 char *title = fmt("%s - %s", cgit_root_title, "Bad request");
15 cgit_print_docstart(title, item); 15 cgit_print_docstart(title, item);
16 cgit_print_pageheader(title, 0); 16 cgit_print_pageheader(title, 0);
17 cgit_print_error(fmt("Unknown repo: %s", cgit_query_repo)); 17 cgit_print_error(fmt("Unknown repo: %s", cgit_query_repo));
18 cgit_print_docend(); 18 cgit_print_docend();
19 return 0; 19 return 0;
20 } 20 }
21 21
22 if (!cgit_repo) { 22 if (!cgit_repo) {
23 item->name = xstrdup(fmt("%s/index.html", cgit_cache_root)); 23 item->name = xstrdup(fmt("%s/index.html", cgit_cache_root));
24 item->ttl = cgit_cache_root_ttl; 24 item->ttl = cgit_cache_root_ttl;
25 return 1; 25 return 1;
26 } 26 }
27 27
28 if (!cgit_cmd) { 28 if (!cgit_cmd) {
29 item->name = xstrdup(fmt("%s/%s/index.html", cgit_cache_root, 29 item->name = xstrdup(fmt("%s/%s/index.%s.html", cgit_cache_root,
30 cache_safe_filename(cgit_repo->url))); 30 cache_safe_filename(cgit_repo->url),
31 cache_safe_filename(cgit_querystring)));
31 item->ttl = cgit_cache_repo_ttl; 32 item->ttl = cgit_cache_repo_ttl;
32 } else { 33 } else {
33 item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root, 34 item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root,
34 cache_safe_filename(cgit_repo->url), cgit_query_page, 35 cache_safe_filename(cgit_repo->url),
35 cache_safe_filename(cgit_querystring))); 36 cgit_query_page,
37 cache_safe_filename(cgit_querystring)));
36 if (cgit_query_has_symref) 38 if (cgit_query_has_symref)
37 item->ttl = cgit_cache_dynamic_ttl; 39 item->ttl = cgit_cache_dynamic_ttl;
38 else if (cgit_query_has_sha1) 40 else if (cgit_query_has_sha1)
39 item->ttl = cgit_cache_static_ttl; 41 item->ttl = cgit_cache_static_ttl;
40 else 42 else
41 item->ttl = cgit_cache_repo_ttl; 43 item->ttl = cgit_cache_repo_ttl;
42 } 44 }
43 return 1; 45 return 1;
44} 46}
45 47
46static void cgit_print_repo_page(struct cacheitem *item) 48static void cgit_print_repo_page(struct cacheitem *item)
47{ 49{
48 char *title; 50 char *title;
49 int show_search; 51 int show_search;
50 52
51 if (!cgit_query_head) 53 if (!cgit_query_head)
52 cgit_query_head = cgit_repo->defbranch; 54 cgit_query_head = cgit_repo->defbranch;
53 55
54 if (chdir(cgit_repo->path)) { 56 if (chdir(cgit_repo->path)) {
55 title = fmt("%s - %s", cgit_root_title, "Bad request"); 57 title = fmt("%s - %s", cgit_root_title, "Bad request");
56 cgit_print_docstart(title, item); 58 cgit_print_docstart(title, item);
57 cgit_print_pageheader(title, 0); 59 cgit_print_pageheader(title, 0);
58 cgit_print_error(fmt("Unable to scan repository: %s", 60 cgit_print_error(fmt("Unable to scan repository: %s",
59 strerror(errno))); 61 strerror(errno)));
60 cgit_print_docend(); 62 cgit_print_docend();
61 return; 63 return;
62 } 64 }
63 65
64 title = fmt("%s - %s", cgit_repo->name, cgit_repo->desc); 66 title = fmt("%s - %s", cgit_repo->name, cgit_repo->desc);
65 show_search = 0; 67 show_search = 0;
66 setenv("GIT_DIR", cgit_repo->path, 1); 68 setenv("GIT_DIR", cgit_repo->path, 1);
67 69
68 if ((cgit_cmd == CMD_SNAPSHOT) && cgit_repo->snapshots) { 70 if ((cgit_cmd == CMD_SNAPSHOT) && cgit_repo->snapshots) {
69 cgit_print_snapshot(item, cgit_query_sha1, "zip", 71 cgit_print_snapshot(item, cgit_query_sha1, "zip",
70 cgit_repo->url, cgit_query_name); 72 cgit_repo->url, cgit_query_name);
71 return; 73 return;
72 } 74 }
73 75
74 if (cgit_cmd == CMD_BLOB) { 76 if (cgit_cmd == CMD_BLOB) {
75 cgit_print_blob(item, cgit_query_sha1, cgit_query_path); 77 cgit_print_blob(item, cgit_query_sha1, cgit_query_path);
76 return; 78 return;
77 } 79 }
78 80
79 show_search = (cgit_cmd == CMD_LOG); 81 show_search = (cgit_cmd == CMD_LOG);
80 cgit_print_docstart(title, item); 82 cgit_print_docstart(title, item);
81 if (!cgit_cmd) { 83 if (!cgit_cmd) {
82 cgit_print_pageheader("summary", show_search); 84 cgit_print_pageheader("summary", show_search);
83 cgit_print_summary(); 85 cgit_print_summary();
84 cgit_print_docend(); 86 cgit_print_docend();
85 return; 87 return;
86 } 88 }
87 89
88 cgit_print_pageheader(cgit_query_page, show_search); 90 cgit_print_pageheader(cgit_query_page, show_search);
89 91
90 switch(cgit_cmd) { 92 switch(cgit_cmd) {
91 case CMD_LOG: 93 case CMD_LOG:
92 cgit_print_log(cgit_query_sha1, cgit_query_ofs, 94 cgit_print_log(cgit_query_sha1, cgit_query_ofs,
93 cgit_max_commit_count, cgit_query_search, 95 cgit_max_commit_count, cgit_query_search,
94 cgit_query_path, 1); 96 cgit_query_path, 1);
95 break; 97 break;
96 case CMD_TREE: 98 case CMD_TREE:
97 cgit_print_tree(cgit_query_sha1, cgit_query_path); 99 cgit_print_tree(cgit_query_sha1, cgit_query_path);
98 break; 100 break;
99 case CMD_COMMIT: 101 case CMD_COMMIT:
100 cgit_print_commit(cgit_query_sha1); 102 cgit_print_commit(cgit_query_sha1);
101 break; 103 break;
102 case CMD_DIFF: 104 case CMD_DIFF:
103 cgit_print_diff(cgit_query_sha1, cgit_query_sha2); 105 cgit_print_diff(cgit_query_sha1, cgit_query_sha2);
104 break; 106 break;
105 default: 107 default:
106 cgit_print_error("Invalid request"); 108 cgit_print_error("Invalid request");
107 } 109 }
108 cgit_print_docend(); 110 cgit_print_docend();
109} 111}
110 112
111static void cgit_fill_cache(struct cacheitem *item, int use_cache) 113static void cgit_fill_cache(struct cacheitem *item, int use_cache)
112{ 114{
113 static char buf[PATH_MAX]; 115 static char buf[PATH_MAX];
114 int stdout2; 116 int stdout2;
115 117
116 getcwd(buf, sizeof(buf)); 118 getcwd(buf, sizeof(buf));
117 item->st.st_mtime = time(NULL); 119 item->st.st_mtime = time(NULL);
118 120
119 if (use_cache) { 121 if (use_cache) {
120 stdout2 = chk_positive(dup(STDOUT_FILENO), 122 stdout2 = chk_positive(dup(STDOUT_FILENO),
121 "Preserving STDOUT"); 123 "Preserving STDOUT");
122 chk_zero(close(STDOUT_FILENO), "Closing STDOUT"); 124 chk_zero(close(STDOUT_FILENO), "Closing STDOUT");
123 chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)"); 125 chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)");
124 } 126 }
125 127
126 if (cgit_repo) 128 if (cgit_repo)
127 cgit_print_repo_page(item); 129 cgit_print_repo_page(item);
128 else 130 else
129 cgit_print_repolist(item); 131 cgit_print_repolist(item);
130 132
131 if (use_cache) { 133 if (use_cache) {
132 chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT"); 134 chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT");
133 chk_positive(dup2(stdout2, STDOUT_FILENO), 135 chk_positive(dup2(stdout2, STDOUT_FILENO),
134 "Restoring original STDOUT"); 136 "Restoring original STDOUT");
135 chk_zero(close(stdout2), "Closing temporary STDOUT"); 137 chk_zero(close(stdout2), "Closing temporary STDOUT");
136 } 138 }
137 139
138 chdir(buf); 140 chdir(buf);
139} 141}
140 142
141static void cgit_check_cache(struct cacheitem *item) 143static void cgit_check_cache(struct cacheitem *item)
142{ 144{
143 int i = 0; 145 int i = 0;
144 146
145 top: 147 top:
146 if (++i > cgit_max_lock_attempts) { 148 if (++i > cgit_max_lock_attempts) {
147 die("cgit_refresh_cache: unable to lock %s: %s", 149 die("cgit_refresh_cache: unable to lock %s: %s",
148 item->name, strerror(errno)); 150 item->name, strerror(errno));
149 } 151 }
150 if (!cache_exist(item)) { 152 if (!cache_exist(item)) {
151 if (!cache_lock(item)) { 153 if (!cache_lock(item)) {
152 sleep(1); 154 sleep(1);
153 goto top; 155 goto top;
154 } 156 }
155 if (!cache_exist(item)) { 157 if (!cache_exist(item)) {
156 cgit_fill_cache(item, 1); 158 cgit_fill_cache(item, 1);
157 cache_unlock(item); 159 cache_unlock(item);
158 } else { 160 } else {
159 cache_cancel_lock(item); 161 cache_cancel_lock(item);
160 } 162 }
161 } else if (cache_expired(item) && cache_lock(item)) { 163 } else if (cache_expired(item) && cache_lock(item)) {
162 if (cache_expired(item)) { 164 if (cache_expired(item)) {
163 cgit_fill_cache(item, 1); 165 cgit_fill_cache(item, 1);
diff --git a/cgit.css b/cgit.css
index cda437e..112dac1 100644
--- a/cgit.css
+++ b/cgit.css
@@ -1,415 +1,426 @@
1body { 1body {
2 font-family: arial, sans-serif; 2 font-family: arial, sans-serif;
3 font-size: 11pt; 3 font-size: 11pt;
4 color: black; 4 color: black;
5 background: white; 5 background: white;
6} 6}
7 7
8body, table { 8body, table {
9 padding: 0em; 9 padding: 0em;
10 margin: 0em; 10 margin: 0em;
11} 11}
12 12
13table { 13table {
14 border-collapse: collapse; 14 border-collapse: collapse;
15} 15}
16 16
17h2 { 17h2 {
18 font-size: 120%; 18 font-size: 120%;
19 font-weight: bold; 19 font-weight: bold;
20 margin-top: 0em; 20 margin-top: 0em;
21 margin-bottom: 0.25em; 21 margin-bottom: 0.25em;
22} 22}
23 23
24h3 { 24h3 {
25 margin-top: 0em; 25 margin-top: 0em;
26 font-size: 100%; 26 font-size: 100%;
27 font-weight: normal; 27 font-weight: normal;
28} 28}
29 29
30h4 { 30h4 {
31 margin-top: 1.5em; 31 margin-top: 1.5em;
32 margin-bottom: 0.1em; 32 margin-bottom: 0.1em;
33 font-size: 100%; 33 font-size: 100%;
34 font-weight: bold; 34 font-weight: bold;
35} 35}
36 36
37a { 37a {
38 color: blue; 38 color: blue;
39 text-decoration: none; 39 text-decoration: none;
40} 40}
41 41
42a:hover { 42a:hover {
43 text-decoration: underline; 43 text-decoration: underline;
44} 44}
45 45
46table.list { 46table.list {
47 border: none; 47 border: none;
48 border-collapse: collapse; 48 border-collapse: collapse;
49} 49}
50 50
51table.list tr { 51table.list tr {
52 background: white; 52 background: white;
53} 53}
54 54
55table.list tr:hover { 55table.list tr:hover {
56 background: #eee; 56 background: #eee;
57} 57}
58 58
59table.list tr.nohover:hover { 59table.list tr.nohover:hover {
60 background: white; 60 background: white;
61} 61}
62 62
63table.list th { 63table.list th {
64 font-weight: bold; 64 font-weight: bold;
65 border-bottom: solid 1px #777; 65 border-bottom: solid 1px #777;
66 padding: 0.1em 0.5em 0.1em 0.5em; 66 padding: 0.1em 0.5em 0.1em 0.5em;
67 vertical-align: baseline; 67 vertical-align: baseline;
68} 68}
69 69
70table.list td { 70table.list td {
71 border: none; 71 border: none;
72 padding: 0.1em 0.5em 0.1em 0.5em; 72 padding: 0.1em 0.5em 0.1em 0.5em;
73} 73}
74 74
75img { 75img {
76 border: none; 76 border: none;
77} 77}
78 78
79table#layout { 79table#layout {
80 width: 100%; 80 width: 100%;
81 border-collapse: collapse; 81 border-collapse: collapse;
82 margin: 0px; 82 margin: 0px;
83} 83}
84 84
85td#header, td#logo { 85td#header, td#logo {
86 color: #666; 86 color: #666;
87 background-color: #ddd; 87 background-color: #ddd;
88 border-bottom: solid 1px #000; 88 border-bottom: solid 1px #000;
89} 89}
90 90
91td#header { 91td#header {
92 font-size: 150%; 92 font-size: 150%;
93 font-weight: bold; 93 font-weight: bold;
94 padding: 0.2em 0.5em; 94 padding: 0.2em 0.5em;
95 vertical-align: text-bottom; 95 vertical-align: text-bottom;
96} 96}
97 97
98td#header a {
99 color: #666;
100}
101
102td#header a:hoved {
103 text-decoration: underline;
104}
105
98td#logo { 106td#logo {
99 text-align: right; 107 text-align: right;
100 vertical-align: middle; 108 vertical-align: middle;
101 padding-right: 0.5em; 109 padding-right: 0.5em;
102} 110}
103 111
104td#crumb, td#search { 112td#crumb, td#search {
105 color: #ccc; 113 color: #ccc;
106 border-top: solid 3px #555; 114 border-top: solid 3px #555;
107 background-color: #666; 115 background-color: #666;
108 border-bottom: solid 1px #333; 116 border-bottom: solid 1px #333;
109 padding: 2px 1em; 117 padding: 2px 1em;
110} 118}
111 119
112td#crumb { 120td#crumb {
113 font-weight: bold; 121 font-weight: bold;
114} 122}
115 123
116td#crumb a { 124td#crumb a {
117 color: #ccc; 125 color: #ccc;
118 background-color: #666; 126 background-color: #666;
127 padding: 0em 0.5em 0em 0.5em;
119} 128}
120 129
121td#crumb a:hover { 130td#crumb a:hover {
122 color: #eee; 131 color: #666;
123 background-color: #666; 132 background-color: #ccc;
133 text-decoration: none;
124} 134}
125 135
126td#search { 136td#search {
127 text-align: right; 137 text-align: right;
128 vertical-align: middle; 138 vertical-align: middle;
129 padding-right: 0.5em; 139 padding-right: 0.5em;
130} 140}
131 141
132td#search form { 142td#search form {
133 margin: 0px; 143 margin: 0px;
134 padding: 0px; 144 padding: 0px;
135} 145}
136 146
137td#search input { 147td#search input {
138 font-size: 9pt; 148 font-size: 9pt;
139 padding: 0px; 149 padding: 0px;
140 width: 10em; 150 width: 10em;
141 border: solid 1px #333; 151 border: solid 1px #333;
142 color: #333; 152 color: #333;
143 background-color: #fff; 153 background-color: #fff;
144} 154}
145 155
146div#summary { 156div#summary {
147 vertical-align: top; 157 vertical-align: top;
148 margin-bottom: 1em; 158 margin-bottom: 1em;
149} 159}
150 160
151table#downloads { 161table#downloads {
152 float: right; 162 float: right;
153 border-collapse: collapse; 163 border-collapse: collapse;
154 border: solid 1px #777; 164 border: solid 1px #777;
155 margin-left: 0.5em; 165 margin-left: 0.5em;
156 margin-bottom: 0.5em; 166 margin-bottom: 0.5em;
157} 167}
158 168
159table#downloads th { 169table#downloads th {
160 background-color: #ccc; 170 background-color: #ccc;
161} 171}
162 172
163td#content { 173td#content {
164 padding: 1em 0.5em; 174 padding: 1em 0.5em;
165} 175}
166 176
167div#blob { 177div#blob {
168 border: solid 1px black; 178 border: solid 1px black;
169} 179}
170 180
171div.error { 181div.error {
172 color: red; 182 color: red;
173 font-weight: bold; 183 font-weight: bold;
174 margin: 1em 2em; 184 margin: 1em 2em;
175} 185}
176 186
177a.ls-blob, a.ls-dir, a.ls-mod { 187a.ls-blob, a.ls-dir, a.ls-mod {
178 font-family: monospace; 188 font-family: monospace;
179} 189}
180 190
181td.ls-size { 191td.ls-size {
182 text-align: right; 192 text-align: right;
183} 193}
184 194
185td.ls-size { 195td.ls-size {
186 font-family: monospace; 196 font-family: monospace;
187} 197}
188 198
189td.ls-mode { 199td.ls-mode {
190 font-family: monospace; 200 font-family: monospace;
191} 201}
192 202
193table.blob { 203table.blob {
194 margin-top: 0.5em; 204 margin-top: 0.5em;
195 border-top: solid 1px black; 205 border-top: solid 1px black;
196} 206}
197 207
198table.blob td.no { 208table.blob td.no {
199 border-right: solid 1px black; 209 border-right: solid 1px black;
200 color: black; 210 color: black;
201 background-color: #eee; 211 background-color: #eee;
202 text-align: right; 212 text-align: right;
203} 213}
204 214
205table.blob td.txt { 215table.blob td.txt {
206 white-space: pre; 216 white-space: pre;
207 font-family: monospace; 217 font-family: monospace;
208 padding-left: 0.5em; 218 padding-left: 0.5em;
209} 219}
210 220
211table.nowrap td { 221table.nowrap td {
212 white-space: nowrap; 222 white-space: nowrap;
213} 223}
214 224
215table.commit-info { 225table.commit-info {
216 border-collapse: collapse; 226 border-collapse: collapse;
217 margin-top: 1.5em; 227 margin-top: 1.5em;
218} 228}
219 229
220table.commit-info th { 230table.commit-info th {
221 text-align: left; 231 text-align: left;
222 font-weight: normal; 232 font-weight: normal;
223 padding: 0.1em 1em 0.1em 0.1em; 233 padding: 0.1em 1em 0.1em 0.1em;
224} 234}
225 235
226table.commit-info td { 236table.commit-info td {
227 font-weight: normal; 237 font-weight: normal;
228 padding: 0.1em 1em 0.1em 0.1em; 238 padding: 0.1em 1em 0.1em 0.1em;
229} 239}
230 240
231div.commit-subject { 241div.commit-subject {
232 font-weight: bold; 242 font-weight: bold;
233 font-size: 125%; 243 font-size: 125%;
234 margin: 1.5em 0em 0.5em 0em; 244 margin: 1.5em 0em 0.5em 0em;
235 padding: 0em; 245 padding: 0em;
236} 246}
237 247
238div.commit-msg { 248div.commit-msg {
239 white-space: pre; 249 white-space: pre;
240 font-family: monospace; 250 font-family: monospace;
241} 251}
242 252
243div.diffstat-header { 253div.diffstat-header {
244 font-weight: bold; 254 font-weight: bold;
245 padding-top: 1.5em; 255 padding-top: 1.5em;
246} 256}
247 257
248table.diffstat { 258table.diffstat {
249 border-collapse: collapse; 259 border-collapse: collapse;
250 width: 100%; 260 width: 100%;
251 border: solid 1px #aaa; 261 border: solid 1px #aaa;
252 background-color: #eee; 262 background-color: #eee;
253} 263}
254 264
255table.diffstat tr:hover { 265table.diffstat tr:hover {
256 background-color: #ccc; 266 background-color: #ccc;
257} 267}
258 268
259table.diffstat th { 269table.diffstat th {
260 font-weight: normal; 270 font-weight: normal;
261 text-align: left; 271 text-align: left;
262 text-decoration: underline; 272 text-decoration: underline;
263 padding: 0.1em 1em 0.1em 0.1em; 273 padding: 0.1em 1em 0.1em 0.1em;
264 font-size: 100%; 274 font-size: 100%;
265} 275}
266 276
267table.diffstat td { 277table.diffstat td {
268 padding: 0.2em 0.2em 0.1em 0.1em; 278 padding: 0.2em 0.2em 0.1em 0.1em;
269 font-size: 100%; 279 font-size: 100%;
270 border: none; 280 border: none;
271} 281}
272 282
273table.diffstat td.mode { 283table.diffstat td.mode {
274 white-space: nowrap; 284 white-space: nowrap;
275} 285}
276 286
277table.diffstat td span.modechange { 287table.diffstat td span.modechange {
278 padding-left: 1em; 288 padding-left: 1em;
279 color: red; 289 color: red;
280} 290}
281 291
282table.diffstat td.add a { 292table.diffstat td.add a {
283 color: green; 293 color: green;
284} 294}
285 295
286table.diffstat td.del a { 296table.diffstat td.del a {
287 color: red; 297 color: red;
288} 298}
289 299
290table.diffstat td.upd a { 300table.diffstat td.upd a {
291 color: blue; 301 color: blue;
292} 302}
293 303
294table.diffstat td.graph { 304table.diffstat td.graph {
295 width: 75%; 305 width: 75%;
296 vertical-align: middle; 306 vertical-align: middle;
297} 307}
298 308
299table.diffstat td.graph table { 309table.diffstat td.graph table {
300 border: none; 310 border: none;
301} 311}
302 312
303table.diffstat td.graph td { 313table.diffstat td.graph td {
304 padding: 0px; 314 padding: 0px;
305 border: 0px; 315 border: 0px;
306 height: 7pt; 316 height: 7pt;
307} 317}
308 318
309table.diffstat td.graph td.add { 319table.diffstat td.graph td.add {
310 background-color: #5c5; 320 background-color: #5c5;
311} 321}
312 322
313table.diffstat td.graph td.rem { 323table.diffstat td.graph td.rem {
314 background-color: #c55; 324 background-color: #c55;
315} 325}
316 326
317div.diffstat-summary { 327div.diffstat-summary {
318 color: #888; 328 color: #888;
319 padding-top: 0.5em; 329 padding-top: 0.5em;
320} 330}
321 331
322table.diff td { 332table.diff td {
323 font-family: monospace; 333 font-family: monospace;
324 white-space: pre; 334 white-space: pre;
325} 335}
326 336
327table.diff td div.head { 337table.diff td div.head {
328 font-weight: bold; 338 font-weight: bold;
329 padding-top: 1em; 339 padding-top: 1em;
330} 340}
331 341
332table.diff td div.hunk { 342table.diff td div.hunk {
333 color: #009; 343 color: #009;
334} 344}
335 345
336table.diff td div.add { 346table.diff td div.add {
337 color: green; 347 color: green;
338} 348}
339 349
340table.diff td div.del { 350table.diff td div.del {
341 color: red; 351 color: red;
342} 352}
343 353
344.sha1 { 354.sha1 {
345 font-family: monospace; 355 font-family: monospace;
346 font-size: 90%; 356 font-size: 90%;
347} 357}
348 358
349.left { 359.left {
350 text-align: left; 360 text-align: left;
351} 361}
352 362
353.right { 363.right {
354 text-align: right; 364 text-align: right;
355} 365}
356 366
357table.list td.repogroup { 367table.list td.repogroup {
358 font-style: italic; 368 font-style: italic;
359 color: #888; 369 color: #888;
360} 370}
361 371
362a.button { 372a.button {
363 font-size: 80%; 373 font-size: 80%;
364 color: #333; 374 color: #aaa;
365 background-color: #ccc; 375 background-color: #eee;
366 border: solid 1px #999; 376 border: solid 1px #aaa;
367 padding: 0em 0.5em; 377 padding: 0em 0.5em;
368 margin: 0.1em 0.25em; 378 margin: 0.1em 0.25em;
369} 379}
370 380
371a.button:hover { 381a.button:hover {
372 text-decoration: none; 382 text-decoration: none;
373 background-color: #eee; 383 color: #333;
384 background-color: #ccc;
374} 385}
375 386
376a.primary { 387a.primary {
377 font-size: 100%; 388 font-size: 100%;
378} 389}
379 390
380a.secondary { 391a.secondary {
381 font-size: 90%; 392 font-size: 90%;
382} 393}
383 394
384td.toplevel-repo { 395td.toplevel-repo {
385 396
386} 397}
387 398
388table.list td.sublevel-repo { 399table.list td.sublevel-repo {
389 padding-left: 1.5em; 400 padding-left: 1.5em;
390} 401}
391 402
392span.age-mins { 403span.age-mins {
393 font-weight: bold; 404 font-weight: bold;
394 color: #080; 405 color: #080;
395} 406}
396 407
397span.age-hours { 408span.age-hours {
398 color: #080; 409 color: #080;
399} 410}
400 411
401span.age-days { 412span.age-days {
402 color: #040; 413 color: #040;
403} 414}
404 415
405span.age-weeks { 416span.age-weeks {
406 color: #444; 417 color: #444;
407} 418}
408 419
409span.age-months { 420span.age-months {
410 color: #888; 421 color: #888;
411} 422}
412 423
413span.age-years { 424span.age-years {
414 color: #bbb; 425 color: #bbb;
415} 426}
diff --git a/cgit.h b/cgit.h
index 9558362..2ff5340 100644
--- a/cgit.h
+++ b/cgit.h
@@ -1,234 +1,236 @@
1#ifndef CGIT_H 1#ifndef CGIT_H
2#define CGIT_H 2#define CGIT_H
3 3
4 4
5#include <git-compat-util.h> 5#include <git-compat-util.h>
6#include <cache.h> 6#include <cache.h>
7#include <grep.h> 7#include <grep.h>
8#include <object.h> 8#include <object.h>
9#include <tree.h> 9#include <tree.h>
10#include <commit.h> 10#include <commit.h>
11#include <tag.h> 11#include <tag.h>
12#include <diff.h> 12#include <diff.h>
13#include <diffcore.h> 13#include <diffcore.h>
14#include <refs.h> 14#include <refs.h>
15#include <revision.h> 15#include <revision.h>
16#include <log-tree.h> 16#include <log-tree.h>
17#include <archive.h> 17#include <archive.h>
18#include <xdiff/xdiff.h> 18#include <xdiff/xdiff.h>
19 19
20 20
21/* 21/*
22 * The valid cgit repo-commands 22 * The valid cgit repo-commands
23 */ 23 */
24#define CMD_LOG 1 24#define CMD_LOG 1
25#define CMD_COMMIT 2 25#define CMD_COMMIT 2
26#define CMD_DIFF 3 26#define CMD_DIFF 3
27#define CMD_TREE 4 27#define CMD_TREE 4
28#define CMD_BLOB 5 28#define CMD_BLOB 5
29#define CMD_SNAPSHOT 6 29#define CMD_SNAPSHOT 6
30 30
31 31
32/* 32/*
33 * Dateformats used on misc. pages 33 * Dateformats used on misc. pages
34 */ 34 */
35#define FMT_LONGDATE "%Y-%m-%d %H:%M:%S" 35#define FMT_LONGDATE "%Y-%m-%d %H:%M:%S"
36#define FMT_SHORTDATE "%Y-%m-%d" 36#define FMT_SHORTDATE "%Y-%m-%d"
37 37
38 38
39/* 39/*
40 * Limits used for relative dates 40 * Limits used for relative dates
41 */ 41 */
42#define TM_MIN 60 42#define TM_MIN 60
43#define TM_HOUR (TM_MIN * 60) 43#define TM_HOUR (TM_MIN * 60)
44#define TM_DAY (TM_HOUR * 24) 44#define TM_DAY (TM_HOUR * 24)
45#define TM_WEEK (TM_DAY * 7) 45#define TM_WEEK (TM_DAY * 7)
46#define TM_YEAR (TM_DAY * 365) 46#define TM_YEAR (TM_DAY * 365)
47#define TM_MONTH (TM_YEAR / 12.0) 47#define TM_MONTH (TM_YEAR / 12.0)
48 48
49 49
50typedef void (*configfn)(const char *name, const char *value); 50typedef void (*configfn)(const char *name, const char *value);
51typedef void (*filepair_fn)(struct diff_filepair *pair); 51typedef void (*filepair_fn)(struct diff_filepair *pair);
52typedef void (*linediff_fn)(char *line, int len); 52typedef void (*linediff_fn)(char *line, int len);
53 53
54struct cacheitem { 54struct cacheitem {
55 char *name; 55 char *name;
56 struct stat st; 56 struct stat st;
57 int ttl; 57 int ttl;
58 int fd; 58 int fd;
59}; 59};
60 60
61struct repoinfo { 61struct repoinfo {
62 char *url; 62 char *url;
63 char *name; 63 char *name;
64 char *path; 64 char *path;
65 char *desc; 65 char *desc;
66 char *owner; 66 char *owner;
67 char *defbranch; 67 char *defbranch;
68 char *group; 68 char *group;
69 char *module_link; 69 char *module_link;
70 char *readme; 70 char *readme;
71 int snapshots; 71 int snapshots;
72 int enable_log_filecount; 72 int enable_log_filecount;
73 int enable_log_linecount; 73 int enable_log_linecount;
74}; 74};
75 75
76struct repolist { 76struct repolist {
77 int length; 77 int length;
78 int count; 78 int count;
79 struct repoinfo *repos; 79 struct repoinfo *repos;
80}; 80};
81 81
82struct commitinfo { 82struct commitinfo {
83 struct commit *commit; 83 struct commit *commit;
84 char *author; 84 char *author;
85 char *author_email; 85 char *author_email;
86 unsigned long author_date; 86 unsigned long author_date;
87 char *committer; 87 char *committer;
88 char *committer_email; 88 char *committer_email;
89 unsigned long committer_date; 89 unsigned long committer_date;
90 char *subject; 90 char *subject;
91 char *msg; 91 char *msg;
92}; 92};
93 93
94struct taginfo { 94struct taginfo {
95 char *tagger; 95 char *tagger;
96 char *tagger_email; 96 char *tagger_email;
97 int tagger_date; 97 int tagger_date;
98 char *msg; 98 char *msg;
99}; 99};
100 100
101extern const char *cgit_version; 101extern const char *cgit_version;
102 102
103extern struct repolist cgit_repolist; 103extern struct repolist cgit_repolist;
104extern struct repoinfo *cgit_repo; 104extern struct repoinfo *cgit_repo;
105extern int cgit_cmd; 105extern int cgit_cmd;
106 106
107extern char *cgit_root_title; 107extern char *cgit_root_title;
108extern char *cgit_css; 108extern char *cgit_css;
109extern char *cgit_logo; 109extern char *cgit_logo;
110extern char *cgit_index_header; 110extern char *cgit_index_header;
111extern char *cgit_logo_link; 111extern char *cgit_logo_link;
112extern char *cgit_module_link; 112extern char *cgit_module_link;
113extern char *cgit_agefile; 113extern char *cgit_agefile;
114extern char *cgit_virtual_root; 114extern char *cgit_virtual_root;
115extern char *cgit_script_name; 115extern char *cgit_script_name;
116extern char *cgit_cache_root; 116extern char *cgit_cache_root;
117extern char *cgit_repo_group; 117extern char *cgit_repo_group;
118 118
119extern int cgit_nocache; 119extern int cgit_nocache;
120extern int cgit_snapshots; 120extern int cgit_snapshots;
121extern int cgit_enable_index_links;
121extern int cgit_enable_log_filecount; 122extern int cgit_enable_log_filecount;
122extern int cgit_enable_log_linecount; 123extern int cgit_enable_log_linecount;
123extern int cgit_max_lock_attempts; 124extern int cgit_max_lock_attempts;
124extern int cgit_cache_root_ttl; 125extern int cgit_cache_root_ttl;
125extern int cgit_cache_repo_ttl; 126extern int cgit_cache_repo_ttl;
126extern int cgit_cache_dynamic_ttl; 127extern int cgit_cache_dynamic_ttl;
127extern int cgit_cache_static_ttl; 128extern int cgit_cache_static_ttl;
128extern int cgit_cache_max_create_time; 129extern int cgit_cache_max_create_time;
129extern int cgit_summary_log; 130extern int cgit_summary_log;
130 131
131extern int cgit_max_msg_len; 132extern int cgit_max_msg_len;
132extern int cgit_max_repodesc_len; 133extern int cgit_max_repodesc_len;
133extern int cgit_max_commit_count; 134extern int cgit_max_commit_count;
134 135
135extern int cgit_query_has_symref; 136extern int cgit_query_has_symref;
136extern int cgit_query_has_sha1; 137extern int cgit_query_has_sha1;
137 138
138extern char *cgit_querystring; 139extern char *cgit_querystring;
139extern char *cgit_query_repo; 140extern char *cgit_query_repo;
140extern char *cgit_query_page; 141extern char *cgit_query_page;
141extern char *cgit_query_search; 142extern char *cgit_query_search;
142extern char *cgit_query_head; 143extern char *cgit_query_head;
143extern char *cgit_query_sha1; 144extern char *cgit_query_sha1;
144extern char *cgit_query_sha2; 145extern char *cgit_query_sha2;
145extern char *cgit_query_path; 146extern char *cgit_query_path;
146extern char *cgit_query_name; 147extern char *cgit_query_name;
147extern int cgit_query_ofs; 148extern int cgit_query_ofs;
148 149
149extern int htmlfd; 150extern int htmlfd;
150 151
151extern int cgit_get_cmd_index(const char *cmd); 152extern int cgit_get_cmd_index(const char *cmd);
152extern struct repoinfo *cgit_get_repoinfo(const char *url); 153extern struct repoinfo *cgit_get_repoinfo(const char *url);
153extern void cgit_global_config_cb(const char *name, const char *value); 154extern void cgit_global_config_cb(const char *name, const char *value);
154extern void cgit_repo_config_cb(const char *name, const char *value); 155extern void cgit_repo_config_cb(const char *name, const char *value);
155extern void cgit_querystring_cb(const char *name, const char *value); 156extern void cgit_querystring_cb(const char *name, const char *value);
156 157
157extern int chk_zero(int result, char *msg); 158extern int chk_zero(int result, char *msg);
158extern int chk_positive(int result, char *msg); 159extern int chk_positive(int result, char *msg);
159 160
160extern int hextoint(char c); 161extern int hextoint(char c);
162extern char *trim_end(const char *str, char c);
161 163
162extern void *cgit_free_commitinfo(struct commitinfo *info); 164extern void *cgit_free_commitinfo(struct commitinfo *info);
163 165
164extern int cgit_diff_files(const unsigned char *old_sha1, 166extern int cgit_diff_files(const unsigned char *old_sha1,
165 const unsigned char *new_sha1, 167 const unsigned char *new_sha1,
166 linediff_fn fn); 168 linediff_fn fn);
167 169
168extern void cgit_diff_tree(const unsigned char *old_sha1, 170extern void cgit_diff_tree(const unsigned char *old_sha1,
169 const unsigned char *new_sha1, 171 const unsigned char *new_sha1,
170 filepair_fn fn); 172 filepair_fn fn);
171 173
172extern void cgit_diff_commit(struct commit *commit, filepair_fn fn); 174extern void cgit_diff_commit(struct commit *commit, filepair_fn fn);
173 175
174extern char *fmt(const char *format,...); 176extern char *fmt(const char *format,...);
175 177
176extern void html(const char *txt); 178extern void html(const char *txt);
177extern void htmlf(const char *format,...); 179extern void htmlf(const char *format,...);
178extern void html_txt(char *txt); 180extern void html_txt(char *txt);
179extern void html_ntxt(int len, char *txt); 181extern void html_ntxt(int len, char *txt);
180extern void html_attr(char *txt); 182extern void html_attr(char *txt);
181extern void html_hidden(char *name, char *value); 183extern void html_hidden(char *name, char *value);
182extern void html_link_open(char *url, char *title, char *class); 184extern void html_link_open(char *url, char *title, char *class);
183extern void html_link_close(void); 185extern void html_link_close(void);
184extern void html_filemode(unsigned short mode); 186extern void html_filemode(unsigned short mode);
185extern int html_include(const char *filename); 187extern int html_include(const char *filename);
186 188
187extern int cgit_read_config(const char *filename, configfn fn); 189extern int cgit_read_config(const char *filename, configfn fn);
188extern int cgit_parse_query(char *txt, configfn fn); 190extern int cgit_parse_query(char *txt, configfn fn);
189extern struct commitinfo *cgit_parse_commit(struct commit *commit); 191extern struct commitinfo *cgit_parse_commit(struct commit *commit);
190extern struct taginfo *cgit_parse_tag(struct tag *tag); 192extern struct taginfo *cgit_parse_tag(struct tag *tag);
191extern void cgit_parse_url(const char *url); 193extern void cgit_parse_url(const char *url);
192 194
193extern char *cache_safe_filename(const char *unsafe); 195extern char *cache_safe_filename(const char *unsafe);
194extern int cache_lock(struct cacheitem *item); 196extern int cache_lock(struct cacheitem *item);
195extern int cache_unlock(struct cacheitem *item); 197extern int cache_unlock(struct cacheitem *item);
196extern int cache_cancel_lock(struct cacheitem *item); 198extern int cache_cancel_lock(struct cacheitem *item);
197extern int cache_exist(struct cacheitem *item); 199extern int cache_exist(struct cacheitem *item);
198extern int cache_expired(struct cacheitem *item); 200extern int cache_expired(struct cacheitem *item);
199 201
200extern char *cgit_repourl(const char *reponame); 202extern char *cgit_repourl(const char *reponame);
201extern char *cgit_pageurl(const char *reponame, const char *pagename, 203extern char *cgit_pageurl(const char *reponame, const char *pagename,
202 const char *query); 204 const char *query);
203 205
204extern void cgit_tree_link(char *name, char *title, char *class, char *head, 206extern void cgit_tree_link(char *name, char *title, char *class, char *head,
205 char *rev, char *path); 207 char *rev, char *path);
206extern void cgit_log_link(char *name, char *title, char *class, char *head, 208extern void cgit_log_link(char *name, char *title, char *class, char *head,
207 char *rev, char *path); 209 char *rev, char *path, int ofs);
208extern void cgit_commit_link(char *name, char *title, char *class, char *head, 210extern void cgit_commit_link(char *name, char *title, char *class, char *head,
209 char *rev); 211 char *rev);
210extern void cgit_diff_link(char *name, char *title, char *class, char *head, 212extern void cgit_diff_link(char *name, char *title, char *class, char *head,
211 char *new_rev, char *old_rev, char *path); 213 char *new_rev, char *old_rev, char *path);
212 214
213extern void cgit_print_error(char *msg); 215extern void cgit_print_error(char *msg);
214extern void cgit_print_date(time_t secs, char *format); 216extern void cgit_print_date(time_t secs, char *format);
215extern void cgit_print_age(time_t t, time_t max_relative, char *format); 217extern void cgit_print_age(time_t t, time_t max_relative, char *format);
216extern void cgit_print_docstart(char *title, struct cacheitem *item); 218extern void cgit_print_docstart(char *title, struct cacheitem *item);
217extern void cgit_print_docend(); 219extern void cgit_print_docend();
218extern void cgit_print_pageheader(char *title, int show_search); 220extern void cgit_print_pageheader(char *title, int show_search);
219extern void cgit_print_snapshot_start(const char *mimetype, 221extern void cgit_print_snapshot_start(const char *mimetype,
220 const char *filename, 222 const char *filename,
221 struct cacheitem *item); 223 struct cacheitem *item);
222 224
223extern void cgit_print_repolist(struct cacheitem *item); 225extern void cgit_print_repolist(struct cacheitem *item);
224extern void cgit_print_summary(); 226extern void cgit_print_summary();
225extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *path, int pager); 227extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *path, int pager);
226extern void cgit_print_blob(struct cacheitem *item, const char *hex, char *path); 228extern void cgit_print_blob(struct cacheitem *item, const char *hex, char *path);
227extern void cgit_print_tree(const char *rev, char *path); 229extern void cgit_print_tree(const char *rev, char *path);
228extern void cgit_print_commit(char *hex); 230extern void cgit_print_commit(char *hex);
229extern void cgit_print_diff(const char *new_hex, const char *old_hex); 231extern void cgit_print_diff(const char *new_hex, const char *old_hex);
230extern void cgit_print_snapshot(struct cacheitem *item, const char *hex, 232extern void cgit_print_snapshot(struct cacheitem *item, const char *hex,
231 const char *format, const char *prefix, 233 const char *format, const char *prefix,
232 const char *filename); 234 const char *filename);
233 235
234#endif /* CGIT_H */ 236#endif /* CGIT_H */
diff --git a/cgitrc b/cgitrc
index 0f602e4..40877f8 100644
--- a/cgitrc
+++ b/cgitrc
@@ -1,116 +1,120 @@
1## 1##
2## cgitrc: template for /etc/cgitrc 2## cgitrc: template for /etc/cgitrc
3## 3##
4 4
5 5
6## Uncomment and set to 1 to deactivate caching of generated pages. Mostly 6## Uncomment and set to 1 to deactivate caching of generated pages. Mostly
7## usefull for testing. 7## usefull for testing.
8#nocache=0 8#nocache=0
9 9
10 10
11## Enable/disable snapshots by default. This can be overridden per repo 11## Enable/disable snapshots by default. This can be overridden per repo
12#snapshots=0 12#snapshots=0
13 13
14 14
15## Enable/disable extra links to summary/log/tree per repo on index page
16#enable-index-links=0
17
18
15## Enable/disable display of 'number of files changed' in log view 19## Enable/disable display of 'number of files changed' in log view
16#enable-log-filecount=0 20#enable-log-filecount=0
17 21
18 22
19## Enable/disable display of 'number of lines changed' in log view 23## Enable/disable display of 'number of lines changed' in log view
20#enable-log-linecount=0 24#enable-log-linecount=0
21 25
22 26
23## Enable/disable display of HEAD shortlog in summary view. Set it to maximum 27## Enable/disable display of HEAD shortlog in summary view. Set it to maximum
24## number of commits that should be displayed 28## number of commits that should be displayed
25#summary-log=0 29#summary-log=0
26 30
27 31
28## Specify a root for virtual urls. This makes cgit generate urls like 32## Specify a root for virtual urls. This makes cgit generate urls like
29## 33##
30## http://localhost/git/repo/log/?id=master 34## http://localhost/git/repo/log/?id=master
31## 35##
32## instead of 36## instead of
33## 37##
34## http://localhost/cgit/cgit.cgi?r=repo&p=log&id=master 38## http://localhost/cgit/cgit.cgi?r=repo&p=log&id=master
35## 39##
36## For this to work with apache, rewrite rules must be added to httpd.conf, 40## For this to work with apache, rewrite rules must be added to httpd.conf,
37## possibly looking something like this: 41## possibly looking something like this:
38## 42##
39## RewriteRule ^/git/$ /cgit/cgit.cgi [L,QSA] 43## RewriteRule ^/git/$ /cgit/cgit.cgi [L,QSA]
40## RewriteRule ^/git/([^/]+)/$ /cgit/cgit.cgi?r=$1 [L,QSA] 44## RewriteRule ^/git/([^/]+)/$ /cgit/cgit.cgi?r=$1 [L,QSA]
41## RewriteRule ^/git/([^/]+)/([^/]+)/$ /cgit/cgit.cgi?r=$1&p=$2 [L,QSA] 45## RewriteRule ^/git/([^/]+)/([^/]+)/$ /cgit/cgit.cgi?r=$1&p=$2 [L,QSA]
42## 46##
43## This setting is disabled by default. 47## This setting is disabled by default.
44#virtual-root=/git 48#virtual-root=/git
45 49
46 50
47## Set the title printed on the root page 51## Set the title printed on the root page
48#root-title=Git repository browser 52#root-title=Git repository browser
49 53
50 54
51## Link to css file 55## Link to css file
52#css=/cgit/cgit.css 56#css=/cgit/cgit.css
53 57
54 58
55## Link to logo file 59## Link to logo file
56#logo=/cgit/git-logo.png 60#logo=/cgit/git-logo.png
57 61
58 62
59## Url loaded when clicking the logo 63## Url loaded when clicking the logo
60#logo-link=http://www.kernel.org/pub/software/scm/git/docs/ 64#logo-link=http://www.kernel.org/pub/software/scm/git/docs/
61 65
62 66
63## Url loaded when clicking a submodule link 67## Url loaded when clicking a submodule link
64#module-link=./?repo=%s&page=commit&id=%s 68#module-link=./?repo=%s&page=commit&id=%s
65 69
66 70
67## Number of chars shown of repo description (in repolist view) 71## Number of chars shown of repo description (in repolist view)
68#max-repodesc-length=60 72#max-repodesc-length=60
69 73
70 74
71## Number of chars shown of commit subject message (in log view) 75## Number of chars shown of commit subject message (in log view)
72#max-message-length=60 76#max-message-length=60
73 77
74 78
75## Number of commits per page in log view 79## Number of commits per page in log view
76#max-commit-count=50 80#max-commit-count=50
77 81
78 82
79## Root of cached output 83## Root of cached output
80#cache-root=/var/cache/cgit 84#cache-root=/var/cache/cgit
81 85
82 86
83## Include another config-file 87## Include another config-file
84#include=/var/cgit/repolist 88#include=/var/cgit/repolist
85 89
86## 90##
87## Time-To-Live settings: specifies how long (in minutes) different pages 91## Time-To-Live settings: specifies how long (in minutes) different pages
88## should be cached (0 for instant expiration, -1 for immortal pages) 92## should be cached (0 for instant expiration, -1 for immortal pages)
89## 93##
90 94
91## ttl for root page 95## ttl for root page
92#cache-root-ttl=5 96#cache-root-ttl=5
93 97
94## ttl for repo summary page 98## ttl for repo summary page
95#cache-repo-ttl=5 99#cache-repo-ttl=5
96 100
97## ttl for other dynamic pages 101## ttl for other dynamic pages
98#cache-dynamic-ttl=5 102#cache-dynamic-ttl=5
99 103
100## ttl for static pages (addressed by SHA-1) 104## ttl for static pages (addressed by SHA-1)
101#cache-static-ttl=-1 105#cache-static-ttl=-1
102 106
103 107
104 108
105## Example repository entry. Required values are repo.url and repo.path (each 109## Example repository entry. Required values are repo.url and repo.path (each
106## repository section must start with repo.url). 110## repository section must start with repo.url).
107#repo.url=cgit 111#repo.url=cgit
108#repo.name=cgit 112#repo.name=cgit
109#repo.desc=the caching cgi for git 113#repo.desc=the caching cgi for git
110#repo.path=/pub/git/cgit 114#repo.path=/pub/git/cgit
111#repo.owner=Lars Hjemli 115#repo.owner=Lars Hjemli
112 #repo.snapshots=1 # override a sitewide snapshot-setting 116 #repo.snapshots=1 # override a sitewide snapshot-setting
113 #repo.enable-log-filecount=0 # override the default filecount setting 117 #repo.enable-log-filecount=0 # override the default filecount setting
114 #repo.enable-log-linecount=0 # override the default linecount setting 118 #repo.enable-log-linecount=0 # override the default linecount setting
115 #repo.module-link=/git/%s/commit/?id=%s # override the standard module-link 119 #repo.module-link=/git/%s/commit/?id=%s # override the standard module-link
116 #repo.readme=info/web/readme # specify a file to include on summary page 120 #repo.readme=info/web/readme # specify a file to include on summary page
diff --git a/parsing.c b/parsing.c
index 74a2484..2c05c09 100644
--- a/parsing.c
+++ b/parsing.c
@@ -43,257 +43,257 @@ int read_config_line(FILE *f, char *line, const char **value, int bufsize)
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
65int cgit_read_config(const char *filename, configfn fn) 65int cgit_read_config(const char *filename, configfn fn)
66{ 66{
67 static int nesting; 67 static int nesting;
68 int len; 68 int len;
69 char line[256]; 69 char line[256];
70 const char *value; 70 const char *value;
71 FILE *f; 71 FILE *f;
72 72
73 /* cancel deeply nested include-commands */ 73 /* cancel deeply nested include-commands */
74 if (nesting > 8) 74 if (nesting > 8)
75 return -1; 75 return -1;
76 if (!(f = fopen(filename, "r"))) 76 if (!(f = fopen(filename, "r")))
77 return -1; 77 return -1;
78 nesting++; 78 nesting++;
79 while((len = read_config_line(f, line, &value, sizeof(line))) > 0) 79 while((len = read_config_line(f, line, &value, sizeof(line))) > 0)
80 (*fn)(line, value); 80 (*fn)(line, value);
81 nesting--; 81 nesting--;
82 fclose(f); 82 fclose(f);
83 return 0; 83 return 0;
84} 84}
85 85
86char *convert_query_hexchar(char *txt) 86char *convert_query_hexchar(char *txt)
87{ 87{
88 int d1, d2; 88 int d1, d2;
89 if (strlen(txt) < 3) { 89 if (strlen(txt) < 3) {
90 *txt = '\0'; 90 *txt = '\0';
91 return txt-1; 91 return txt-1;
92 } 92 }
93 d1 = hextoint(*(txt+1)); 93 d1 = hextoint(*(txt+1));
94 d2 = hextoint(*(txt+2)); 94 d2 = hextoint(*(txt+2));
95 if (d1<0 || d2<0) { 95 if (d1<0 || d2<0) {
96 strcpy(txt, txt+3); 96 strcpy(txt, txt+3);
97 return txt-1; 97 return txt-1;
98 } else { 98 } else {
99 *txt = d1 * 16 + d2; 99 *txt = d1 * 16 + d2;
100 strcpy(txt+1, txt+3); 100 strcpy(txt+1, txt+3);
101 return txt; 101 return txt;
102 } 102 }
103} 103}
104 104
105int cgit_parse_query(char *txt, configfn fn) 105int cgit_parse_query(char *txt, configfn fn)
106{ 106{
107 char *t, *value = NULL, c; 107 char *t, *value = NULL, c;
108 108
109 if (!txt) 109 if (!txt)
110 return 0; 110 return 0;
111 111
112 t = txt = xstrdup(txt); 112 t = txt = xstrdup(txt);
113 113
114 while((c=*t) != '\0') { 114 while((c=*t) != '\0') {
115 if (c=='=') { 115 if (c=='=') {
116 *t = '\0'; 116 *t = '\0';
117 value = t+1; 117 value = t+1;
118 } else if (c=='+') { 118 } else if (c=='+') {
119 *t = ' '; 119 *t = ' ';
120 } else if (c=='%') { 120 } else if (c=='%') {
121 t = convert_query_hexchar(t); 121 t = convert_query_hexchar(t);
122 } else if (c=='&') { 122 } else if (c=='&') {
123 *t = '\0'; 123 *t = '\0';
124 (*fn)(txt, value); 124 (*fn)(txt, value);
125 txt = t+1; 125 txt = t+1;
126 value = NULL; 126 value = NULL;
127 } 127 }
128 t++; 128 t++;
129 } 129 }
130 if (t!=txt) 130 if (t!=txt)
131 (*fn)(txt, value); 131 (*fn)(txt, value);
132 return 0; 132 return 0;
133} 133}
134 134
135/* 135/*
136 * url syntax: [repo ['/' cmd [ '/' path]]] 136 * url syntax: [repo ['/' cmd [ '/' path]]]
137 * repo: any valid repo url, may contain '/' 137 * repo: any valid repo url, may contain '/'
138 * cmd: log | commit | diff | tree | view | blob | snapshot 138 * cmd: log | commit | diff | tree | view | blob | snapshot
139 * path: any valid path, may contain '/' 139 * path: any valid path, may contain '/'
140 * 140 *
141 */ 141 */
142void cgit_parse_url(const char *url) 142void cgit_parse_url(const char *url)
143{ 143{
144 char *cmd, *p; 144 char *cmd, *p;
145 145
146 cgit_repo = NULL; 146 cgit_repo = NULL;
147 if (!url || url[0] == '\0') 147 if (!url || url[0] == '\0')
148 return; 148 return;
149 149
150 cgit_repo = cgit_get_repoinfo(url); 150 cgit_repo = cgit_get_repoinfo(url);
151 if (cgit_repo) { 151 if (cgit_repo) {
152 cgit_query_repo = cgit_repo->url; 152 cgit_query_repo = cgit_repo->url;
153 return; 153 return;
154 } 154 }
155 155
156 cmd = strchr(url, '/'); 156 cmd = strchr(url, '/');
157 while (!cgit_repo && cmd) { 157 while (!cgit_repo && cmd) {
158 cmd[0] = '\0'; 158 cmd[0] = '\0';
159 cgit_repo = cgit_get_repoinfo(url); 159 cgit_repo = cgit_get_repoinfo(url);
160 if (cgit_repo == NULL) { 160 if (cgit_repo == NULL) {
161 cmd[0] = '/'; 161 cmd[0] = '/';
162 cmd = strchr(cmd + 1, '/'); 162 cmd = strchr(cmd + 1, '/');
163 continue; 163 continue;
164 } 164 }
165 165
166 cgit_query_repo = cgit_repo->url; 166 cgit_query_repo = cgit_repo->url;
167 p = strchr(cmd + 1, '/'); 167 p = strchr(cmd + 1, '/');
168 if (p) { 168 if (p) {
169 p[0] = '\0'; 169 p[0] = '\0';
170 if (p[1]) 170 if (p[1])
171 cgit_query_path = xstrdup(p + 1); 171 cgit_query_path = trim_end(p + 1, '/');
172 } 172 }
173 cgit_cmd = cgit_get_cmd_index(cmd + 1); 173 cgit_cmd = cgit_get_cmd_index(cmd + 1);
174 cgit_query_page = xstrdup(cmd + 1); 174 cgit_query_page = xstrdup(cmd + 1);
175 return; 175 return;
176 } 176 }
177} 177}
178 178
179char *substr(const char *head, const char *tail) 179char *substr(const char *head, const char *tail)
180{ 180{
181 char *buf; 181 char *buf;
182 182
183 buf = xmalloc(tail - head + 1); 183 buf = xmalloc(tail - head + 1);
184 strncpy(buf, head, tail - head); 184 strncpy(buf, head, tail - head);
185 buf[tail - head] = '\0'; 185 buf[tail - head] = '\0';
186 return buf; 186 return buf;
187} 187}
188 188
189struct commitinfo *cgit_parse_commit(struct commit *commit) 189struct commitinfo *cgit_parse_commit(struct commit *commit)
190{ 190{
191 struct commitinfo *ret; 191 struct commitinfo *ret;
192 char *p = commit->buffer, *t = commit->buffer; 192 char *p = commit->buffer, *t = commit->buffer;
193 193
194 ret = xmalloc(sizeof(*ret)); 194 ret = xmalloc(sizeof(*ret));
195 ret->commit = commit; 195 ret->commit = commit;
196 ret->author = NULL; 196 ret->author = NULL;
197 ret->author_email = NULL; 197 ret->author_email = NULL;
198 ret->committer = NULL; 198 ret->committer = NULL;
199 ret->committer_email = NULL; 199 ret->committer_email = NULL;
200 ret->subject = NULL; 200 ret->subject = NULL;
201 ret->msg = NULL; 201 ret->msg = NULL;
202 202
203 if (p == NULL) 203 if (p == NULL)
204 return ret; 204 return ret;
205 205
206 if (strncmp(p, "tree ", 5)) 206 if (strncmp(p, "tree ", 5))
207 die("Bad commit: %s", sha1_to_hex(commit->object.sha1)); 207 die("Bad commit: %s", sha1_to_hex(commit->object.sha1));
208 else 208 else
209 p += 46; // "tree " + hex[40] + "\n" 209 p += 46; // "tree " + hex[40] + "\n"
210 210
211 while (!strncmp(p, "parent ", 7)) 211 while (!strncmp(p, "parent ", 7))
212 p += 48; // "parent " + hex[40] + "\n" 212 p += 48; // "parent " + hex[40] + "\n"
213 213
214 if (!strncmp(p, "author ", 7)) { 214 if (!strncmp(p, "author ", 7)) {
215 p += 7; 215 p += 7;
216 t = strchr(p, '<') - 1; 216 t = strchr(p, '<') - 1;
217 ret->author = substr(p, t); 217 ret->author = substr(p, t);
218 p = t; 218 p = t;
219 t = strchr(t, '>') + 1; 219 t = strchr(t, '>') + 1;
220 ret->author_email = substr(p, t); 220 ret->author_email = substr(p, t);
221 ret->author_date = atol(++t); 221 ret->author_date = atol(++t);
222 p = strchr(t, '\n') + 1; 222 p = strchr(t, '\n') + 1;
223 } 223 }
224 224
225 if (!strncmp(p, "committer ", 9)) { 225 if (!strncmp(p, "committer ", 9)) {
226 p += 9; 226 p += 9;
227 t = strchr(p, '<') - 1; 227 t = strchr(p, '<') - 1;
228 ret->committer = substr(p, t); 228 ret->committer = substr(p, t);
229 p = t; 229 p = t;
230 t = strchr(t, '>') + 1; 230 t = strchr(t, '>') + 1;
231 ret->committer_email = substr(p, t); 231 ret->committer_email = substr(p, t);
232 ret->committer_date = atol(++t); 232 ret->committer_date = atol(++t);
233 p = strchr(t, '\n') + 1; 233 p = strchr(t, '\n') + 1;
234 } 234 }
235 235
236 while (*p == '\n') 236 while (*p == '\n')
237 p = strchr(p, '\n') + 1; 237 p = strchr(p, '\n') + 1;
238 238
239 t = strchr(p, '\n'); 239 t = strchr(p, '\n');
240 if (t) { 240 if (t) {
241 if (*t == '\0') 241 if (*t == '\0')
242 ret->subject = strdup("** empty **"); 242 ret->subject = strdup("** empty **");
243 else 243 else
244 ret->subject = substr(p, t); 244 ret->subject = substr(p, t);
245 p = t + 1; 245 p = t + 1;
246 246
247 while (*p == '\n') 247 while (*p == '\n')
248 p = strchr(p, '\n') + 1; 248 p = strchr(p, '\n') + 1;
249 ret->msg = p; 249 ret->msg = p;
250 } else 250 } else
251 ret->subject = substr(p, p+strlen(p)); 251 ret->subject = substr(p, p+strlen(p));
252 252
253 return ret; 253 return ret;
254} 254}
255 255
256 256
257struct taginfo *cgit_parse_tag(struct tag *tag) 257struct taginfo *cgit_parse_tag(struct tag *tag)
258{ 258{
259 void *data; 259 void *data;
260 enum object_type type; 260 enum object_type type;
261 unsigned long size; 261 unsigned long size;
262 char *p, *t; 262 char *p, *t;
263 struct taginfo *ret; 263 struct taginfo *ret;
264 264
265 data = read_sha1_file(tag->object.sha1, &type, &size); 265 data = read_sha1_file(tag->object.sha1, &type, &size);
266 if (!data || type != OBJ_TAG) { 266 if (!data || type != OBJ_TAG) {
267 free(data); 267 free(data);
268 return 0; 268 return 0;
269 } 269 }
270 270
271 ret = xmalloc(sizeof(*ret)); 271 ret = xmalloc(sizeof(*ret));
272 ret->tagger = NULL; 272 ret->tagger = NULL;
273 ret->tagger_email = NULL; 273 ret->tagger_email = NULL;
274 ret->tagger_date = 0; 274 ret->tagger_date = 0;
275 ret->msg = NULL; 275 ret->msg = NULL;
276 276
277 p = data; 277 p = data;
278 278
279 while (p && *p) { 279 while (p && *p) {
280 if (*p == '\n') 280 if (*p == '\n')
281 break; 281 break;
282 282
283 if (!strncmp(p, "tagger ", 7)) { 283 if (!strncmp(p, "tagger ", 7)) {
284 p += 7; 284 p += 7;
285 t = strchr(p, '<') - 1; 285 t = strchr(p, '<') - 1;
286 ret->tagger = substr(p, t); 286 ret->tagger = substr(p, t);
287 p = t; 287 p = t;
288 t = strchr(t, '>') + 1; 288 t = strchr(t, '>') + 1;
289 ret->tagger_email = substr(p, t); 289 ret->tagger_email = substr(p, t);
290 ret->tagger_date = atol(++t); 290 ret->tagger_date = atol(++t);
291 } 291 }
292 p = strchr(p, '\n') + 1; 292 p = strchr(p, '\n') + 1;
293 } 293 }
294 294
295 while (p && (*p == '\n')) 295 while (p && (*p == '\n'))
296 p = strchr(p, '\n') + 1; 296 p = strchr(p, '\n') + 1;
297 if (p && *p) 297 if (p && *p)
298 ret->msg = xstrdup(p); 298 ret->msg = xstrdup(p);
299 free(data); 299 free(data);
diff --git a/shared.c b/shared.c
index f7f43b2..1a5b866 100644
--- a/shared.c
+++ b/shared.c
@@ -1,380 +1,405 @@
1/* shared.c: global vars + some callback functions 1/* shared.c: global vars + some callback functions
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
11struct repolist cgit_repolist; 11struct repolist cgit_repolist;
12struct repoinfo *cgit_repo; 12struct repoinfo *cgit_repo;
13int cgit_cmd; 13int cgit_cmd;
14 14
15const char *cgit_version = CGIT_VERSION; 15const char *cgit_version = CGIT_VERSION;
16 16
17char *cgit_root_title = "Git repository browser"; 17char *cgit_root_title = "Git repository browser";
18char *cgit_css = "/cgit.css"; 18char *cgit_css = "/cgit.css";
19char *cgit_logo = "/git-logo.png"; 19char *cgit_logo = "/git-logo.png";
20char *cgit_index_header = NULL; 20char *cgit_index_header = NULL;
21char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; 21char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/";
22char *cgit_module_link = "./?repo=%s&page=commit&id=%s"; 22char *cgit_module_link = "./?repo=%s&page=commit&id=%s";
23char *cgit_agefile = "info/web/last-modified"; 23char *cgit_agefile = "info/web/last-modified";
24char *cgit_virtual_root = NULL; 24char *cgit_virtual_root = NULL;
25char *cgit_script_name = CGIT_SCRIPT_NAME; 25char *cgit_script_name = CGIT_SCRIPT_NAME;
26char *cgit_cache_root = "/var/cache/cgit"; 26char *cgit_cache_root = "/var/cache/cgit";
27char *cgit_repo_group = NULL; 27char *cgit_repo_group = NULL;
28 28
29int cgit_nocache = 0; 29int cgit_nocache = 0;
30int cgit_snapshots = 0; 30int cgit_snapshots = 0;
31int cgit_enable_index_links = 0;
31int cgit_enable_log_filecount = 0; 32int cgit_enable_log_filecount = 0;
32int cgit_enable_log_linecount = 0; 33int cgit_enable_log_linecount = 0;
33int cgit_max_lock_attempts = 5; 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;
39int cgit_summary_log = 0; 40int cgit_summary_log = 0;
40 41
41int cgit_max_msg_len = 60; 42int cgit_max_msg_len = 60;
42int cgit_max_repodesc_len = 60; 43int cgit_max_repodesc_len = 60;
43int cgit_max_commit_count = 50; 44int cgit_max_commit_count = 50;
44 45
45int cgit_query_has_symref = 0; 46int cgit_query_has_symref = 0;
46int cgit_query_has_sha1 = 0; 47int cgit_query_has_sha1 = 0;
47 48
48char *cgit_querystring = NULL; 49char *cgit_querystring = NULL;
49char *cgit_query_repo = NULL; 50char *cgit_query_repo = NULL;
50char *cgit_query_page = NULL; 51char *cgit_query_page = NULL;
51char *cgit_query_head = NULL; 52char *cgit_query_head = NULL;
52char *cgit_query_search = NULL; 53char *cgit_query_search = NULL;
53char *cgit_query_sha1 = NULL; 54char *cgit_query_sha1 = NULL;
54char *cgit_query_sha2 = NULL; 55char *cgit_query_sha2 = NULL;
55char *cgit_query_path = NULL; 56char *cgit_query_path = NULL;
56char *cgit_query_name = NULL; 57char *cgit_query_name = NULL;
57int cgit_query_ofs = 0; 58int cgit_query_ofs = 0;
58 59
59int htmlfd = 0; 60int htmlfd = 0;
60 61
61 62
62int cgit_get_cmd_index(const char *cmd) 63int cgit_get_cmd_index(const char *cmd)
63{ 64{
64 static char *cmds[] = {"log", "commit", "diff", "tree", "blob", 65 static char *cmds[] = {"log", "commit", "diff", "tree", "blob",
65 "snapshot", NULL}; 66 "snapshot", NULL};
66 int i; 67 int i;
67 68
68 for(i = 0; cmds[i]; i++) 69 for(i = 0; cmds[i]; i++)
69 if (!strcmp(cmd, cmds[i])) 70 if (!strcmp(cmd, cmds[i]))
70 return i + 1; 71 return i + 1;
71 return 0; 72 return 0;
72} 73}
73 74
74int chk_zero(int result, char *msg) 75int chk_zero(int result, char *msg)
75{ 76{
76 if (result != 0) 77 if (result != 0)
77 die("%s: %s", msg, strerror(errno)); 78 die("%s: %s", msg, strerror(errno));
78 return result; 79 return result;
79} 80}
80 81
81int chk_positive(int result, char *msg) 82int chk_positive(int result, char *msg)
82{ 83{
83 if (result <= 0) 84 if (result <= 0)
84 die("%s: %s", msg, strerror(errno)); 85 die("%s: %s", msg, strerror(errno));
85 return result; 86 return result;
86} 87}
87 88
88struct repoinfo *add_repo(const char *url) 89struct repoinfo *add_repo(const char *url)
89{ 90{
90 struct repoinfo *ret; 91 struct repoinfo *ret;
91 92
92 if (++cgit_repolist.count > cgit_repolist.length) { 93 if (++cgit_repolist.count > cgit_repolist.length) {
93 if (cgit_repolist.length == 0) 94 if (cgit_repolist.length == 0)
94 cgit_repolist.length = 8; 95 cgit_repolist.length = 8;
95 else 96 else
96 cgit_repolist.length *= 2; 97 cgit_repolist.length *= 2;
97 cgit_repolist.repos = xrealloc(cgit_repolist.repos, 98 cgit_repolist.repos = xrealloc(cgit_repolist.repos,
98 cgit_repolist.length * 99 cgit_repolist.length *
99 sizeof(struct repoinfo)); 100 sizeof(struct repoinfo));
100 } 101 }
101 102
102 ret = &cgit_repolist.repos[cgit_repolist.count-1]; 103 ret = &cgit_repolist.repos[cgit_repolist.count-1];
103 ret->url = xstrdup(url); 104 ret->url = xstrdup(url);
104 ret->name = ret->url; 105 ret->name = ret->url;
105 ret->path = NULL; 106 ret->path = NULL;
106 ret->desc = NULL; 107 ret->desc = NULL;
107 ret->owner = NULL; 108 ret->owner = NULL;
108 ret->group = cgit_repo_group; 109 ret->group = cgit_repo_group;
109 ret->defbranch = "master"; 110 ret->defbranch = "master";
110 ret->snapshots = cgit_snapshots; 111 ret->snapshots = cgit_snapshots;
111 ret->enable_log_filecount = cgit_enable_log_filecount; 112 ret->enable_log_filecount = cgit_enable_log_filecount;
112 ret->enable_log_linecount = cgit_enable_log_linecount; 113 ret->enable_log_linecount = cgit_enable_log_linecount;
113 ret->module_link = cgit_module_link; 114 ret->module_link = cgit_module_link;
114 ret->readme = NULL; 115 ret->readme = NULL;
115 return ret; 116 return ret;
116} 117}
117 118
118struct repoinfo *cgit_get_repoinfo(const char *url) 119struct repoinfo *cgit_get_repoinfo(const char *url)
119{ 120{
120 int i; 121 int i;
121 struct repoinfo *repo; 122 struct repoinfo *repo;
122 123
123 for (i=0; i<cgit_repolist.count; i++) { 124 for (i=0; i<cgit_repolist.count; i++) {
124 repo = &cgit_repolist.repos[i]; 125 repo = &cgit_repolist.repos[i];
125 if (!strcmp(repo->url, url)) 126 if (!strcmp(repo->url, url))
126 return repo; 127 return repo;
127 } 128 }
128 return NULL; 129 return NULL;
129} 130}
130 131
131void cgit_global_config_cb(const char *name, const char *value) 132void cgit_global_config_cb(const char *name, const char *value)
132{ 133{
133 if (!strcmp(name, "root-title")) 134 if (!strcmp(name, "root-title"))
134 cgit_root_title = xstrdup(value); 135 cgit_root_title = xstrdup(value);
135 else if (!strcmp(name, "css")) 136 else if (!strcmp(name, "css"))
136 cgit_css = xstrdup(value); 137 cgit_css = xstrdup(value);
137 else if (!strcmp(name, "logo")) 138 else if (!strcmp(name, "logo"))
138 cgit_logo = xstrdup(value); 139 cgit_logo = xstrdup(value);
139 else if (!strcmp(name, "index-header")) 140 else if (!strcmp(name, "index-header"))
140 cgit_index_header = xstrdup(value); 141 cgit_index_header = xstrdup(value);
141 else if (!strcmp(name, "logo-link")) 142 else if (!strcmp(name, "logo-link"))
142 cgit_logo_link = xstrdup(value); 143 cgit_logo_link = xstrdup(value);
143 else if (!strcmp(name, "module-link")) 144 else if (!strcmp(name, "module-link"))
144 cgit_module_link = xstrdup(value); 145 cgit_module_link = xstrdup(value);
145 else if (!strcmp(name, "virtual-root")) 146 else if (!strcmp(name, "virtual-root"))
146 cgit_virtual_root = xstrdup(value); 147 cgit_virtual_root = xstrdup(value);
147 else if (!strcmp(name, "nocache")) 148 else if (!strcmp(name, "nocache"))
148 cgit_nocache = atoi(value); 149 cgit_nocache = atoi(value);
149 else if (!strcmp(name, "snapshots")) 150 else if (!strcmp(name, "snapshots"))
150 cgit_snapshots = atoi(value); 151 cgit_snapshots = atoi(value);
152 else if (!strcmp(name, "enable-index-links"))
153 cgit_enable_index_links = atoi(value);
151 else if (!strcmp(name, "enable-log-filecount")) 154 else if (!strcmp(name, "enable-log-filecount"))
152 cgit_enable_log_filecount = atoi(value); 155 cgit_enable_log_filecount = atoi(value);
153 else if (!strcmp(name, "enable-log-linecount")) 156 else if (!strcmp(name, "enable-log-linecount"))
154 cgit_enable_log_linecount = atoi(value); 157 cgit_enable_log_linecount = atoi(value);
155 else if (!strcmp(name, "cache-root")) 158 else if (!strcmp(name, "cache-root"))
156 cgit_cache_root = xstrdup(value); 159 cgit_cache_root = xstrdup(value);
157 else if (!strcmp(name, "cache-root-ttl")) 160 else if (!strcmp(name, "cache-root-ttl"))
158 cgit_cache_root_ttl = atoi(value); 161 cgit_cache_root_ttl = atoi(value);
159 else if (!strcmp(name, "cache-repo-ttl")) 162 else if (!strcmp(name, "cache-repo-ttl"))
160 cgit_cache_repo_ttl = atoi(value); 163 cgit_cache_repo_ttl = atoi(value);
161 else if (!strcmp(name, "cache-static-ttl")) 164 else if (!strcmp(name, "cache-static-ttl"))
162 cgit_cache_static_ttl = atoi(value); 165 cgit_cache_static_ttl = atoi(value);
163 else if (!strcmp(name, "cache-dynamic-ttl")) 166 else if (!strcmp(name, "cache-dynamic-ttl"))
164 cgit_cache_dynamic_ttl = atoi(value); 167 cgit_cache_dynamic_ttl = atoi(value);
165 else if (!strcmp(name, "max-message-length")) 168 else if (!strcmp(name, "max-message-length"))
166 cgit_max_msg_len = atoi(value); 169 cgit_max_msg_len = atoi(value);
167 else if (!strcmp(name, "max-repodesc-length")) 170 else if (!strcmp(name, "max-repodesc-length"))
168 cgit_max_repodesc_len = atoi(value); 171 cgit_max_repodesc_len = atoi(value);
169 else if (!strcmp(name, "max-commit-count")) 172 else if (!strcmp(name, "max-commit-count"))
170 cgit_max_commit_count = atoi(value); 173 cgit_max_commit_count = atoi(value);
171 else if (!strcmp(name, "summary-log")) 174 else if (!strcmp(name, "summary-log"))
172 cgit_summary_log = atoi(value); 175 cgit_summary_log = atoi(value);
173 else if (!strcmp(name, "agefile")) 176 else if (!strcmp(name, "agefile"))
174 cgit_agefile = xstrdup(value); 177 cgit_agefile = xstrdup(value);
175 else if (!strcmp(name, "repo.group")) 178 else if (!strcmp(name, "repo.group"))
176 cgit_repo_group = xstrdup(value); 179 cgit_repo_group = xstrdup(value);
177 else if (!strcmp(name, "repo.url")) 180 else if (!strcmp(name, "repo.url"))
178 cgit_repo = add_repo(value); 181 cgit_repo = add_repo(value);
179 else if (!strcmp(name, "repo.name")) 182 else if (!strcmp(name, "repo.name"))
180 cgit_repo->name = xstrdup(value); 183 cgit_repo->name = xstrdup(value);
181 else if (cgit_repo && !strcmp(name, "repo.path")) 184 else if (cgit_repo && !strcmp(name, "repo.path"))
182 cgit_repo->path = xstrdup(value); 185 cgit_repo->path = xstrdup(value);
183 else if (cgit_repo && !strcmp(name, "repo.desc")) 186 else if (cgit_repo && !strcmp(name, "repo.desc"))
184 cgit_repo->desc = xstrdup(value); 187 cgit_repo->desc = xstrdup(value);
185 else if (cgit_repo && !strcmp(name, "repo.owner")) 188 else if (cgit_repo && !strcmp(name, "repo.owner"))
186 cgit_repo->owner = xstrdup(value); 189 cgit_repo->owner = xstrdup(value);
187 else if (cgit_repo && !strcmp(name, "repo.defbranch")) 190 else if (cgit_repo && !strcmp(name, "repo.defbranch"))
188 cgit_repo->defbranch = xstrdup(value); 191 cgit_repo->defbranch = xstrdup(value);
189 else if (cgit_repo && !strcmp(name, "repo.snapshots")) 192 else if (cgit_repo && !strcmp(name, "repo.snapshots"))
190 cgit_repo->snapshots = cgit_snapshots * atoi(value); 193 cgit_repo->snapshots = cgit_snapshots * atoi(value);
191 else if (cgit_repo && !strcmp(name, "repo.enable-log-filecount")) 194 else if (cgit_repo && !strcmp(name, "repo.enable-log-filecount"))
192 cgit_repo->enable_log_filecount = cgit_enable_log_filecount * atoi(value); 195 cgit_repo->enable_log_filecount = cgit_enable_log_filecount * atoi(value);
193 else if (cgit_repo && !strcmp(name, "repo.enable-log-linecount")) 196 else if (cgit_repo && !strcmp(name, "repo.enable-log-linecount"))
194 cgit_repo->enable_log_linecount = cgit_enable_log_linecount * atoi(value); 197 cgit_repo->enable_log_linecount = cgit_enable_log_linecount * atoi(value);
195 else if (cgit_repo && !strcmp(name, "repo.module-link")) 198 else if (cgit_repo && !strcmp(name, "repo.module-link"))
196 cgit_repo->module_link= xstrdup(value); 199 cgit_repo->module_link= xstrdup(value);
197 else if (cgit_repo && !strcmp(name, "repo.readme") && value != NULL) { 200 else if (cgit_repo && !strcmp(name, "repo.readme") && value != NULL) {
198 if (*value == '/') 201 if (*value == '/')
199 cgit_repo->readme = xstrdup(value); 202 cgit_repo->readme = xstrdup(value);
200 else 203 else
201 cgit_repo->readme = xstrdup(fmt("%s/%s", cgit_repo->path, value)); 204 cgit_repo->readme = xstrdup(fmt("%s/%s", cgit_repo->path, value));
202 } else if (!strcmp(name, "include")) 205 } else if (!strcmp(name, "include"))
203 cgit_read_config(value, cgit_global_config_cb); 206 cgit_read_config(value, cgit_global_config_cb);
204} 207}
205 208
206void cgit_querystring_cb(const char *name, const char *value) 209void cgit_querystring_cb(const char *name, const char *value)
207{ 210{
208 if (!strcmp(name,"r")) { 211 if (!strcmp(name,"r")) {
209 cgit_query_repo = xstrdup(value); 212 cgit_query_repo = xstrdup(value);
210 cgit_repo = cgit_get_repoinfo(value); 213 cgit_repo = cgit_get_repoinfo(value);
211 } else if (!strcmp(name, "p")) { 214 } else if (!strcmp(name, "p")) {
212 cgit_query_page = xstrdup(value); 215 cgit_query_page = xstrdup(value);
213 cgit_cmd = cgit_get_cmd_index(value); 216 cgit_cmd = cgit_get_cmd_index(value);
214 } else if (!strcmp(name, "url")) { 217 } else if (!strcmp(name, "url")) {
215 cgit_parse_url(value); 218 cgit_parse_url(value);
216 } else if (!strcmp(name, "q")) { 219 } else if (!strcmp(name, "q")) {
217 cgit_query_search = xstrdup(value); 220 cgit_query_search = xstrdup(value);
218 } else if (!strcmp(name, "h")) { 221 } else if (!strcmp(name, "h")) {
219 cgit_query_head = xstrdup(value); 222 cgit_query_head = xstrdup(value);
220 cgit_query_has_symref = 1; 223 cgit_query_has_symref = 1;
221 } else if (!strcmp(name, "id")) { 224 } else if (!strcmp(name, "id")) {
222 cgit_query_sha1 = xstrdup(value); 225 cgit_query_sha1 = xstrdup(value);
223 cgit_query_has_sha1 = 1; 226 cgit_query_has_sha1 = 1;
224 } else if (!strcmp(name, "id2")) { 227 } else if (!strcmp(name, "id2")) {
225 cgit_query_sha2 = xstrdup(value); 228 cgit_query_sha2 = xstrdup(value);
226 cgit_query_has_sha1 = 1; 229 cgit_query_has_sha1 = 1;
227 } else if (!strcmp(name, "ofs")) { 230 } else if (!strcmp(name, "ofs")) {
228 cgit_query_ofs = atoi(value); 231 cgit_query_ofs = atoi(value);
229 } else if (!strcmp(name, "path")) { 232 } else if (!strcmp(name, "path")) {
230 cgit_query_path = xstrdup(value); 233 cgit_query_path = trim_end(value, '/');
231 } else if (!strcmp(name, "name")) { 234 } else if (!strcmp(name, "name")) {
232 cgit_query_name = xstrdup(value); 235 cgit_query_name = xstrdup(value);
233 } 236 }
234} 237}
235 238
236void *cgit_free_commitinfo(struct commitinfo *info) 239void *cgit_free_commitinfo(struct commitinfo *info)
237{ 240{
238 free(info->author); 241 free(info->author);
239 free(info->author_email); 242 free(info->author_email);
240 free(info->committer); 243 free(info->committer);
241 free(info->committer_email); 244 free(info->committer_email);
242 free(info->subject); 245 free(info->subject);
243 free(info); 246 free(info);
244 return NULL; 247 return NULL;
245} 248}
246 249
247int hextoint(char c) 250int hextoint(char c)
248{ 251{
249 if (c >= 'a' && c <= 'f') 252 if (c >= 'a' && c <= 'f')
250 return 10 + c - 'a'; 253 return 10 + c - 'a';
251 else if (c >= 'A' && c <= 'F') 254 else if (c >= 'A' && c <= 'F')
252 return 10 + c - 'A'; 255 return 10 + c - 'A';
253 else if (c >= '0' && c <= '9') 256 else if (c >= '0' && c <= '9')
254 return c - '0'; 257 return c - '0';
255 else 258 else
256 return -1; 259 return -1;
257} 260}
258 261
262char *trim_end(const char *str, char c)
263{
264 int len;
265 char *s, *t;
266
267 if (str == NULL)
268 return NULL;
269 t = (char *)str;
270 len = strlen(t);
271 while(len > 0 && t[len - 1] == c)
272 len--;
273
274 if (len == 0)
275 return NULL;
276
277 c = t[len];
278 t[len] = '\0';
279 s = xstrdup(t);
280 t[len] = c;
281 return s;
282}
283
259void cgit_diff_tree_cb(struct diff_queue_struct *q, 284void cgit_diff_tree_cb(struct diff_queue_struct *q,
260 struct diff_options *options, void *data) 285 struct diff_options *options, void *data)
261{ 286{
262 int i; 287 int i;
263 288
264 for (i = 0; i < q->nr; i++) { 289 for (i = 0; i < q->nr; i++) {
265 if (q->queue[i]->status == 'U') 290 if (q->queue[i]->status == 'U')
266 continue; 291 continue;
267 ((filepair_fn)data)(q->queue[i]); 292 ((filepair_fn)data)(q->queue[i]);
268 } 293 }
269} 294}
270 295
271static int load_mmfile(mmfile_t *file, const unsigned char *sha1) 296static int load_mmfile(mmfile_t *file, const unsigned char *sha1)
272{ 297{
273 enum object_type type; 298 enum object_type type;
274 299
275 if (is_null_sha1(sha1)) { 300 if (is_null_sha1(sha1)) {
276 file->ptr = (char *)""; 301 file->ptr = (char *)"";
277 file->size = 0; 302 file->size = 0;
278 } else { 303 } else {
279 file->ptr = read_sha1_file(sha1, &type, &file->size); 304 file->ptr = read_sha1_file(sha1, &type, &file->size);
280 } 305 }
281 return 1; 306 return 1;
282} 307}
283 308
284/* 309/*
285 * Receive diff-buffers from xdiff and concatenate them as 310 * Receive diff-buffers from xdiff and concatenate them as
286 * needed across multiple callbacks. 311 * needed across multiple callbacks.
287 * 312 *
288 * This is basically a copy of xdiff-interface.c/xdiff_outf(), 313 * This is basically a copy of xdiff-interface.c/xdiff_outf(),
289 * ripped from git and modified to use globals instead of 314 * ripped from git and modified to use globals instead of
290 * a special callback-struct. 315 * a special callback-struct.
291 */ 316 */
292char *diffbuf = NULL; 317char *diffbuf = NULL;
293int buflen = 0; 318int buflen = 0;
294 319
295int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf) 320int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf)
296{ 321{
297 int i; 322 int i;
298 323
299 for (i = 0; i < nbuf; i++) { 324 for (i = 0; i < nbuf; i++) {
300 if (mb[i].ptr[mb[i].size-1] != '\n') { 325 if (mb[i].ptr[mb[i].size-1] != '\n') {
301 /* Incomplete line */ 326 /* Incomplete line */
302 diffbuf = xrealloc(diffbuf, buflen + mb[i].size); 327 diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
303 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); 328 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
304 buflen += mb[i].size; 329 buflen += mb[i].size;
305 continue; 330 continue;
306 } 331 }
307 332
308 /* we have a complete line */ 333 /* we have a complete line */
309 if (!diffbuf) { 334 if (!diffbuf) {
310 ((linediff_fn)priv)(mb[i].ptr, mb[i].size); 335 ((linediff_fn)priv)(mb[i].ptr, mb[i].size);
311 continue; 336 continue;
312 } 337 }
313 diffbuf = xrealloc(diffbuf, buflen + mb[i].size); 338 diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
314 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); 339 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
315 ((linediff_fn)priv)(diffbuf, buflen + mb[i].size); 340 ((linediff_fn)priv)(diffbuf, buflen + mb[i].size);
316 free(diffbuf); 341 free(diffbuf);
317 diffbuf = NULL; 342 diffbuf = NULL;
318 buflen = 0; 343 buflen = 0;
319 } 344 }
320 if (diffbuf) { 345 if (diffbuf) {
321 ((linediff_fn)priv)(diffbuf, buflen); 346 ((linediff_fn)priv)(diffbuf, buflen);
322 free(diffbuf); 347 free(diffbuf);
323 diffbuf = NULL; 348 diffbuf = NULL;
324 buflen = 0; 349 buflen = 0;
325 } 350 }
326 return 0; 351 return 0;
327} 352}
328 353
329int cgit_diff_files(const unsigned char *old_sha1, 354int cgit_diff_files(const unsigned char *old_sha1,
330 const unsigned char *new_sha1, 355 const unsigned char *new_sha1,
331 linediff_fn fn) 356 linediff_fn fn)
332{ 357{
333 mmfile_t file1, file2; 358 mmfile_t file1, file2;
334 xpparam_t diff_params; 359 xpparam_t diff_params;
335 xdemitconf_t emit_params; 360 xdemitconf_t emit_params;
336 xdemitcb_t emit_cb; 361 xdemitcb_t emit_cb;
337 362
338 if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1)) 363 if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1))
339 return 1; 364 return 1;
340 365
341 diff_params.flags = XDF_NEED_MINIMAL; 366 diff_params.flags = XDF_NEED_MINIMAL;
342 emit_params.ctxlen = 3; 367 emit_params.ctxlen = 3;
343 emit_params.flags = XDL_EMIT_FUNCNAMES; 368 emit_params.flags = XDL_EMIT_FUNCNAMES;
344 emit_cb.outf = filediff_cb; 369 emit_cb.outf = filediff_cb;
345 emit_cb.priv = fn; 370 emit_cb.priv = fn;
346 xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb); 371 xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb);
347 return 0; 372 return 0;
348} 373}
349 374
350void cgit_diff_tree(const unsigned char *old_sha1, 375void cgit_diff_tree(const unsigned char *old_sha1,
351 const unsigned char *new_sha1, 376 const unsigned char *new_sha1,
352 filepair_fn fn) 377 filepair_fn fn)
353{ 378{
354 struct diff_options opt; 379 struct diff_options opt;
355 int ret; 380 int ret;
356 381
357 diff_setup(&opt); 382 diff_setup(&opt);
358 opt.output_format = DIFF_FORMAT_CALLBACK; 383 opt.output_format = DIFF_FORMAT_CALLBACK;
359 opt.detect_rename = 1; 384 opt.detect_rename = 1;
360 opt.recursive = 1; 385 opt.recursive = 1;
361 opt.format_callback = cgit_diff_tree_cb; 386 opt.format_callback = cgit_diff_tree_cb;
362 opt.format_callback_data = fn; 387 opt.format_callback_data = fn;
363 diff_setup_done(&opt); 388 diff_setup_done(&opt);
364 389
365 if (old_sha1 && !is_null_sha1(old_sha1)) 390 if (old_sha1 && !is_null_sha1(old_sha1))
366 ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt); 391 ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt);
367 else 392 else
368 ret = diff_root_tree_sha1(new_sha1, "", &opt); 393 ret = diff_root_tree_sha1(new_sha1, "", &opt);
369 diffcore_std(&opt); 394 diffcore_std(&opt);
370 diff_flush(&opt); 395 diff_flush(&opt);
371} 396}
372 397
373void cgit_diff_commit(struct commit *commit, filepair_fn fn) 398void cgit_diff_commit(struct commit *commit, filepair_fn fn)
374{ 399{
375 unsigned char *old_sha1 = NULL; 400 unsigned char *old_sha1 = NULL;
376 401
377 if (commit->parents) 402 if (commit->parents)
378 old_sha1 = commit->parents->item->object.sha1; 403 old_sha1 = commit->parents->item->object.sha1;
379 cgit_diff_tree(old_sha1, commit->object.sha1, fn); 404 cgit_diff_tree(old_sha1, commit->object.sha1, fn);
380} 405}
diff --git a/ui-log.c b/ui-log.c
index 95cb453..d38e40a 100644
--- a/ui-log.c
+++ b/ui-log.c
@@ -1,130 +1,128 @@
1/* ui-log.c: functions for log output 1/* ui-log.c: functions for log output
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
11int files, lines; 11int files, lines;
12 12
13void count_lines(char *line, int size) 13void count_lines(char *line, int size)
14{ 14{
15 if (size>0 && (line[0] == '+' || line[0] == '-')) 15 if (size>0 && (line[0] == '+' || line[0] == '-'))
16 lines++; 16 lines++;
17} 17}
18 18
19void inspect_files(struct diff_filepair *pair) 19void inspect_files(struct diff_filepair *pair)
20{ 20{
21 files++; 21 files++;
22 if (cgit_repo->enable_log_linecount) 22 if (cgit_repo->enable_log_linecount)
23 cgit_diff_files(pair->one->sha1, pair->two->sha1, count_lines); 23 cgit_diff_files(pair->one->sha1, pair->two->sha1, count_lines);
24} 24}
25 25
26void print_commit(struct commit *commit) 26void print_commit(struct commit *commit)
27{ 27{
28 struct commitinfo *info; 28 struct commitinfo *info;
29 29
30 info = cgit_parse_commit(commit); 30 info = cgit_parse_commit(commit);
31 html("<tr><td>"); 31 html("<tr><td>");
32 cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE); 32 cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE);
33 html("</td><td>"); 33 html("</td><td>");
34 cgit_commit_link(info->subject, NULL, NULL, cgit_query_head, 34 cgit_commit_link(info->subject, NULL, NULL, cgit_query_head,
35 sha1_to_hex(commit->object.sha1)); 35 sha1_to_hex(commit->object.sha1));
36 if (cgit_repo->enable_log_filecount) { 36 if (cgit_repo->enable_log_filecount) {
37 files = 0; 37 files = 0;
38 lines = 0; 38 lines = 0;
39 cgit_diff_commit(commit, inspect_files); 39 cgit_diff_commit(commit, inspect_files);
40 html("</td><td class='right'>"); 40 html("</td><td class='right'>");
41 htmlf("%d", files); 41 htmlf("%d", files);
42 if (cgit_repo->enable_log_linecount) { 42 if (cgit_repo->enable_log_linecount) {
43 html("</td><td class='right'>"); 43 html("</td><td class='right'>");
44 htmlf("%d", lines); 44 htmlf("%d", lines);
45 } 45 }
46 } 46 }
47 html("</td><td>"); 47 html("</td><td>");
48 html_txt(info->author); 48 html_txt(info->author);
49 html("</td></tr>\n"); 49 html("</td></tr>\n");
50 cgit_free_commitinfo(info); 50 cgit_free_commitinfo(info);
51} 51}
52 52
53 53
54void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *path, int pager) 54void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *path, int pager)
55{ 55{
56 struct rev_info rev; 56 struct rev_info rev;
57 struct commit *commit; 57 struct commit *commit;
58 const char *argv[] = {NULL, tip, NULL, NULL, NULL}; 58 const char *argv[] = {NULL, tip, NULL, NULL, NULL};
59 int argc = 2; 59 int argc = 2;
60 int i; 60 int i;
61 61
62 if (!tip) 62 if (!tip)
63 argv[1] = cgit_query_head; 63 argv[1] = cgit_query_head;
64 64
65 if (grep) 65 if (grep)
66 argv[argc++] = fmt("--grep=%s", grep); 66 argv[argc++] = fmt("--grep=%s", grep);
67 if (path) { 67 if (path) {
68 argv[argc++] = "--"; 68 argv[argc++] = "--";
69 argv[argc++] = path; 69 argv[argc++] = path;
70 } 70 }
71 init_revisions(&rev, NULL); 71 init_revisions(&rev, NULL);
72 rev.abbrev = DEFAULT_ABBREV; 72 rev.abbrev = DEFAULT_ABBREV;
73 rev.commit_format = CMIT_FMT_DEFAULT; 73 rev.commit_format = CMIT_FMT_DEFAULT;
74 rev.verbose_header = 1; 74 rev.verbose_header = 1;
75 rev.show_root_diff = 0; 75 rev.show_root_diff = 0;
76 setup_revisions(argc, argv, &rev, NULL); 76 setup_revisions(argc, argv, &rev, NULL);
77 if (rev.grep_filter) { 77 if (rev.grep_filter) {
78 rev.grep_filter->regflags |= REG_ICASE; 78 rev.grep_filter->regflags |= REG_ICASE;
79 compile_grep_patterns(rev.grep_filter); 79 compile_grep_patterns(rev.grep_filter);
80 } 80 }
81 prepare_revision_walk(&rev); 81 prepare_revision_walk(&rev);
82 82
83 html("<table class='list nowrap'>"); 83 html("<table class='list nowrap'>");
84 html("<tr class='nohover'><th class='left'>Age</th>" 84 html("<tr class='nohover'><th class='left'>Age</th>"
85 "<th class='left'>Message</th>"); 85 "<th class='left'>Message</th>");
86 86
87 if (cgit_repo->enable_log_filecount) { 87 if (cgit_repo->enable_log_filecount) {
88 html("<th class='left'>Files</th>"); 88 html("<th class='left'>Files</th>");
89 if (cgit_repo->enable_log_linecount) 89 if (cgit_repo->enable_log_linecount)
90 html("<th class='left'>Lines</th>"); 90 html("<th class='left'>Lines</th>");
91 } 91 }
92 html("<th class='left'>Author</th></tr>\n"); 92 html("<th class='left'>Author</th></tr>\n");
93 93
94 if (ofs<0) 94 if (ofs<0)
95 ofs = 0; 95 ofs = 0;
96 96
97 for (i = 0; i < ofs && (commit = get_revision(&rev)) != NULL; i++) { 97 for (i = 0; i < ofs && (commit = get_revision(&rev)) != NULL; i++) {
98 free(commit->buffer); 98 free(commit->buffer);
99 commit->buffer = NULL; 99 commit->buffer = NULL;
100 free_commit_list(commit->parents); 100 free_commit_list(commit->parents);
101 commit->parents = NULL; 101 commit->parents = NULL;
102 } 102 }
103 103
104 for (i = 0; i < cnt && (commit = get_revision(&rev)) != NULL; i++) { 104 for (i = 0; i < cnt && (commit = get_revision(&rev)) != NULL; i++) {
105 print_commit(commit); 105 print_commit(commit);
106 free(commit->buffer); 106 free(commit->buffer);
107 commit->buffer = NULL; 107 commit->buffer = NULL;
108 free_commit_list(commit->parents); 108 free_commit_list(commit->parents);
109 commit->parents = NULL; 109 commit->parents = NULL;
110 } 110 }
111 html("</table>\n"); 111 html("</table>\n");
112 112
113 if (pager) { 113 if (pager) {
114 html("<div class='pager'>"); 114 html("<div class='pager'>");
115 if (ofs > 0) { 115 if (ofs > 0) {
116 html("&nbsp;<a href='"); 116 cgit_log_link("[prev]", NULL, NULL, cgit_query_head,
117 html(cgit_pageurl(cgit_query_repo, cgit_query_page, 117 cgit_query_sha1, cgit_query_path,
118 fmt("h=%s&amp;ofs=%d", tip, ofs-cnt))); 118 ofs - cnt);
119 html("'>[prev]</a>&nbsp;"); 119 html("&nbsp;");
120 } 120 }
121
122 if ((commit = get_revision(&rev)) != NULL) { 121 if ((commit = get_revision(&rev)) != NULL) {
123 html("&nbsp;<a href='"); 122 cgit_log_link("[next]", NULL, NULL, cgit_query_head,
124 html(cgit_pageurl(cgit_query_repo, "log", 123 cgit_query_sha1, cgit_query_path,
125 fmt("h=%s&amp;ofs=%d", tip, ofs+cnt))); 124 ofs + cnt);
126 html("'>[next]</a>&nbsp;");
127 } 125 }
128 html("</div>"); 126 html("</div>");
129 } 127 }
130} 128}
diff --git a/ui-repolist.c b/ui-repolist.c
index 2018dab..4c86543 100644
--- a/ui-repolist.c
+++ b/ui-repolist.c
@@ -1,98 +1,109 @@
1/* ui-repolist.c: functions for generating the repolist page 1/* ui-repolist.c: functions for generating the repolist page
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#include <time.h> 10#include <time.h>
11 11
12 12
13time_t read_agefile(char *path) 13time_t read_agefile(char *path)
14{ 14{
15 FILE *f; 15 FILE *f;
16 static char buf[64], buf2[64]; 16 static char buf[64], buf2[64];
17 17
18 if (!(f = fopen(path, "r"))) 18 if (!(f = fopen(path, "r")))
19 return -1; 19 return -1;
20 fgets(buf, sizeof(buf), f); 20 fgets(buf, sizeof(buf), f);
21 fclose(f); 21 fclose(f);
22 if (parse_date(buf, buf2, sizeof(buf2))) 22 if (parse_date(buf, buf2, sizeof(buf2)))
23 return strtoul(buf2, NULL, 10); 23 return strtoul(buf2, NULL, 10);
24 else 24 else
25 return 0; 25 return 0;
26} 26}
27 27
28static void print_modtime(struct repoinfo *repo) 28static void print_modtime(struct repoinfo *repo)
29{ 29{
30 char *path; 30 char *path;
31 struct stat s; 31 struct stat s;
32 32
33 path = fmt("%s/%s", repo->path, cgit_agefile); 33 path = fmt("%s/%s", repo->path, cgit_agefile);
34 if (stat(path, &s) == 0) { 34 if (stat(path, &s) == 0) {
35 cgit_print_age(read_agefile(path), -1, NULL); 35 cgit_print_age(read_agefile(path), -1, NULL);
36 return; 36 return;
37 } 37 }
38 38
39 path = fmt("%s/refs/heads/%s", repo->path, repo->defbranch); 39 path = fmt("%s/refs/heads/%s", repo->path, repo->defbranch);
40 if (stat(path, &s) != 0) 40 if (stat(path, &s) != 0)
41 return; 41 return;
42 cgit_print_age(s.st_mtime, -1, NULL); 42 cgit_print_age(s.st_mtime, -1, NULL);
43} 43}
44 44
45void cgit_print_repolist(struct cacheitem *item) 45void cgit_print_repolist(struct cacheitem *item)
46{ 46{
47 int i; 47 int i, columns = 4;
48 char *last_group = NULL; 48 char *last_group = NULL;
49 49
50 if (cgit_enable_index_links)
51 columns++;
52
50 cgit_print_docstart(cgit_root_title, item); 53 cgit_print_docstart(cgit_root_title, item);
51 cgit_print_pageheader(cgit_root_title, 0); 54 cgit_print_pageheader(cgit_root_title, 0);
52 55
53 html("<table class='list nowrap'>"); 56 html("<table class='list nowrap'>");
54 if (cgit_index_header) { 57 if (cgit_index_header) {
55 html("<tr class='nohover'><td colspan='5' class='include-block'>"); 58 htmlf("<tr class='nohover'><td colspan='%d' class='include-block'>",
59 columns);
56 html_include(cgit_index_header); 60 html_include(cgit_index_header);
57 html("</td></tr>"); 61 html("</td></tr>");
58 } 62 }
59 html("<tr class='nohover'>" 63 html("<tr class='nohover'>"
60 "<th class='left'>Name</th>" 64 "<th class='left'>Name</th>"
61 "<th class='left'>Description</th>" 65 "<th class='left'>Description</th>"
62 "<th class='left'>Owner</th>" 66 "<th class='left'>Owner</th>"
63 "<th class='left'>Idle</th>" 67 "<th class='left'>Idle</th>");
64 "<th>Links</th></tr>\n"); 68 if (cgit_enable_index_links)
69 html("<th>Links</th>");
70 html("</tr>\n");
65 71
66 for (i=0; i<cgit_repolist.count; i++) { 72 for (i=0; i<cgit_repolist.count; i++) {
67 cgit_repo = &cgit_repolist.repos[i]; 73 cgit_repo = &cgit_repolist.repos[i];
68 if ((last_group == NULL && cgit_repo->group != NULL) || 74 if ((last_group == NULL && cgit_repo->group != NULL) ||
69 (last_group != NULL && cgit_repo->group == NULL) || 75 (last_group != NULL && cgit_repo->group == NULL) ||
70 (last_group != NULL && cgit_repo->group != NULL && 76 (last_group != NULL && cgit_repo->group != NULL &&
71 strcmp(cgit_repo->group, last_group))) { 77 strcmp(cgit_repo->group, last_group))) {
72 html("<tr class='nohover'><td colspan='4' class='repogroup'>"); 78 htmlf("<tr class='nohover'><td colspan='%d' class='repogroup'>",
79 columns);
73 html_txt(cgit_repo->group); 80 html_txt(cgit_repo->group);
74 html("</td></tr>"); 81 html("</td></tr>");
75 last_group = cgit_repo->group; 82 last_group = cgit_repo->group;
76 } 83 }
77 htmlf("<tr><td class='%s'>", 84 htmlf("<tr><td class='%s'>",
78 cgit_repo->group ? "sublevel-repo" : "toplevel-repo"); 85 cgit_repo->group ? "sublevel-repo" : "toplevel-repo");
79 html_link_open(cgit_repourl(cgit_repo->url), NULL, NULL); 86 html_link_open(cgit_repourl(cgit_repo->url), NULL, NULL);
80 html_txt(cgit_repo->name); 87 html_txt(cgit_repo->name);
81 html_link_close(); 88 html_link_close();
82 html("</td><td>"); 89 html("</td><td>");
83 html_ntxt(cgit_max_repodesc_len, cgit_repo->desc); 90 html_ntxt(cgit_max_repodesc_len, cgit_repo->desc);
84 html("</td><td>"); 91 html("</td><td>");
85 html_txt(cgit_repo->owner); 92 html_txt(cgit_repo->owner);
86 html("</td><td>"); 93 html("</td><td>");
87 print_modtime(cgit_repo); 94 print_modtime(cgit_repo);
88 html("</td><td>"); 95 html("</td>");
89 html_link_open(cgit_repourl(cgit_repo->url), 96 if (cgit_enable_index_links) {
90 "Summary", "button"); 97 html("<td>");
91 html("S</a>"); 98 html_link_open(cgit_repourl(cgit_repo->url),
92 cgit_log_link("L", "Log", "button", NULL, NULL, NULL); 99 NULL, "button");
93 cgit_tree_link("F", "Files", "button", NULL, NULL, NULL); 100 html("summary</a>");
94 html("</td></tr>\n"); 101 cgit_log_link("log", NULL, "button", NULL, NULL, NULL, 0);
102 cgit_tree_link("tree", NULL, "button", NULL, NULL, NULL);
103 html("</td>");
104 }
105 html("</tr>\n");
95 } 106 }
96 html("</table>"); 107 html("</table>");
97 cgit_print_docend(); 108 cgit_print_docend();
98} 109}
diff --git a/ui-shared.c b/ui-shared.c
index 110c696..d4376ce 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -1,331 +1,370 @@
1/* ui-shared.c: common web output functions 1/* ui-shared.c: common web output functions
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_doctype[] = 11const char cgit_doctype[] =
12"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n" 12"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
13" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"; 13" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
14 14
15static char *http_date(time_t t) 15static char *http_date(time_t t)
16{ 16{
17 static char day[][4] = 17 static char day[][4] =
18 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; 18 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
19 static char month[][4] = 19 static char month[][4] =
20 {"Jan", "Feb", "Mar", "Apr", "May", "Jun", 20 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
21 "Jul", "Aug", "Sep", "Oct", "Now", "Dec"}; 21 "Jul", "Aug", "Sep", "Oct", "Now", "Dec"};
22 struct tm *tm = gmtime(&t); 22 struct tm *tm = gmtime(&t);
23 return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday], 23 return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday],
24 tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year, 24 tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year,
25 tm->tm_hour, tm->tm_min, tm->tm_sec); 25 tm->tm_hour, tm->tm_min, tm->tm_sec);
26} 26}
27 27
28static long ttl_seconds(long ttl) 28static long ttl_seconds(long ttl)
29{ 29{
30 if (ttl<0) 30 if (ttl<0)
31 return 60 * 60 * 24 * 365; 31 return 60 * 60 * 24 * 365;
32 else 32 else
33 return ttl * 60; 33 return ttl * 60;
34} 34}
35 35
36void cgit_print_error(char *msg) 36void cgit_print_error(char *msg)
37{ 37{
38 html("<div class='error'>"); 38 html("<div class='error'>");
39 html_txt(msg); 39 html_txt(msg);
40 html("</div>\n"); 40 html("</div>\n");
41} 41}
42 42
43char *cgit_rooturl() 43char *cgit_rooturl()
44{ 44{
45 if (cgit_virtual_root) 45 if (cgit_virtual_root)
46 return fmt("%s/", cgit_virtual_root); 46 return fmt("%s/", cgit_virtual_root);
47 else 47 else
48 return cgit_script_name; 48 return cgit_script_name;
49} 49}
50 50
51char *cgit_repourl(const char *reponame) 51char *cgit_repourl(const char *reponame)
52{ 52{
53 if (cgit_virtual_root) { 53 if (cgit_virtual_root) {
54 return fmt("%s/%s/", cgit_virtual_root, reponame); 54 return fmt("%s/%s/", cgit_virtual_root, reponame);
55 } else { 55 } else {
56 return fmt("?r=%s", reponame); 56 return fmt("?r=%s", reponame);
57 } 57 }
58} 58}
59 59
60char *cgit_pageurl(const char *reponame, const char *pagename, 60char *cgit_pageurl(const char *reponame, const char *pagename,
61 const char *query) 61 const char *query)
62{ 62{
63 if (cgit_virtual_root) { 63 if (cgit_virtual_root) {
64 if (query) 64 if (query)
65 return fmt("%s/%s/%s/?%s", cgit_virtual_root, reponame, 65 return fmt("%s/%s/%s/?%s", cgit_virtual_root, reponame,
66 pagename, query); 66 pagename, query);
67 else 67 else
68 return fmt("%s/%s/%s/", cgit_virtual_root, reponame, 68 return fmt("%s/%s/%s/", cgit_virtual_root, reponame,
69 pagename); 69 pagename);
70 } else { 70 } else {
71 if (query) 71 if (query)
72 return fmt("?r=%s&amp;p=%s&amp;%s", reponame, pagename, query); 72 return fmt("?r=%s&amp;p=%s&amp;%s", reponame, pagename, query);
73 else 73 else
74 return fmt("?r=%s&amp;p=%s", reponame, pagename); 74 return fmt("?r=%s&amp;p=%s", reponame, pagename);
75 } 75 }
76} 76}
77 77
78char *cgit_currurl() 78char *cgit_currurl()
79{ 79{
80 if (!cgit_virtual_root) 80 if (!cgit_virtual_root)
81 return cgit_script_name; 81 return cgit_script_name;
82 else if (cgit_query_page) 82 else if (cgit_query_page)
83 return fmt("%s/%s/%s/", cgit_virtual_root, cgit_query_repo, cgit_query_page); 83 return fmt("%s/%s/%s/", cgit_virtual_root, cgit_query_repo, cgit_query_page);
84 else if (cgit_query_repo) 84 else if (cgit_query_repo)
85 return fmt("%s/%s/", cgit_virtual_root, cgit_query_repo); 85 return fmt("%s/%s/", cgit_virtual_root, cgit_query_repo);
86 else 86 else
87 return fmt("%s/", cgit_virtual_root); 87 return fmt("%s/", cgit_virtual_root);
88} 88}
89 89
90static char *repolink(char *title, char *class, char *page, char *head, 90static char *repolink(char *title, char *class, char *page, char *head,
91 char *path) 91 char *path)
92{ 92{
93 char *delim = "?"; 93 char *delim = "?";
94 94
95 html("<a"); 95 html("<a");
96 if (title) { 96 if (title) {
97 html(" title='"); 97 html(" title='");
98 html_attr(title); 98 html_attr(title);
99 html("'"); 99 html("'");
100 } 100 }
101 if (class) { 101 if (class) {
102 html(" class='"); 102 html(" class='");
103 html_attr(class); 103 html_attr(class);
104 html("'"); 104 html("'");
105 } 105 }
106 html(" href='"); 106 html(" href='");
107 if (cgit_virtual_root) { 107 if (cgit_virtual_root) {
108 html_attr(cgit_virtual_root); 108 html_attr(cgit_virtual_root);
109 if (cgit_virtual_root[strlen(cgit_virtual_root) - 1] != '/') 109 if (cgit_virtual_root[strlen(cgit_virtual_root) - 1] != '/')
110 html("/"); 110 html("/");
111 html_attr(cgit_repo->url); 111 html_attr(cgit_repo->url);
112 if (cgit_repo->url[strlen(cgit_repo->url) - 1] != '/') 112 if (cgit_repo->url[strlen(cgit_repo->url) - 1] != '/')
113 html("/"); 113 html("/");
114 html(page); 114 if (page) {
115 html("/"); 115 html(page);
116 if (path) 116 html("/");
117 html_attr(path); 117 if (path)
118 html_attr(path);
119 }
118 } else { 120 } else {
119 html(cgit_script_name); 121 html(cgit_script_name);
120 html("?url="); 122 html("?url=");
121 html_attr(cgit_repo->url); 123 html_attr(cgit_repo->url);
122 if (cgit_repo->url[strlen(cgit_repo->url) - 1] != '/') 124 if (cgit_repo->url[strlen(cgit_repo->url) - 1] != '/')
123 html("/"); 125 html("/");
124 html(page); 126 if (page) {
125 html("/"); 127 html(page);
126 if (path) 128 html("/");
127 html_attr(path); 129 if (path)
130 html_attr(path);
131 }
128 delim = "&amp;"; 132 delim = "&amp;";
129 } 133 }
130 if (head && strcmp(head, cgit_repo->defbranch)) { 134 if (head && strcmp(head, cgit_repo->defbranch)) {
131 html(delim); 135 html(delim);
132 html("h="); 136 html("h=");
133 html_attr(head); 137 html_attr(head);
134 delim = "&amp;"; 138 delim = "&amp;";
135 } 139 }
136 return fmt("%s", delim); 140 return fmt("%s", delim);
137} 141}
138 142
139static void reporevlink(char *page, char *name, char *title, char *class, 143static void reporevlink(char *page, char *name, char *title, char *class,
140 char *head, char *rev, char *path) 144 char *head, char *rev, char *path)
141{ 145{
142 char *delim; 146 char *delim;
143 147
144 delim = repolink(title, class, page, head, path); 148 delim = repolink(title, class, page, head, path);
145 if (rev && strcmp(rev, cgit_query_head)) { 149 if (rev && strcmp(rev, cgit_query_head)) {
146 html(delim); 150 html(delim);
147 html("id="); 151 html("id=");
148 html_attr(rev); 152 html_attr(rev);
149 } 153 }
150 html("'>"); 154 html("'>");
151 html_txt(name); 155 html_txt(name);
152 html("</a>"); 156 html("</a>");
153} 157}
154 158
155void cgit_tree_link(char *name, char *title, char *class, char *head, 159void cgit_tree_link(char *name, char *title, char *class, char *head,
156 char *rev, char *path) 160 char *rev, char *path)
157{ 161{
158 reporevlink("tree", name, title, class, head, rev, path); 162 reporevlink("tree", name, title, class, head, rev, path);
159} 163}
160 164
161void cgit_log_link(char *name, char *title, char *class, char *head, 165void cgit_log_link(char *name, char *title, char *class, char *head,
162 char *rev, char *path) 166 char *rev, char *path, int ofs)
163{ 167{
164 reporevlink("log", name, title, class, head, rev, path); 168 char *delim;
169
170 delim = repolink(title, class, "log", head, path);
171 if (rev && strcmp(rev, cgit_query_head)) {
172 html(delim);
173 html("id=");
174 html_attr(rev);
175 delim = "&";
176 }
177 if (ofs > 0) {
178 html(delim);
179 html("ofs=");
180 htmlf("%d", ofs);
181 }
182 html("'>");
183 html_txt(name);
184 html("</a>");
165} 185}
166 186
167void cgit_commit_link(char *name, char *title, char *class, char *head, 187void cgit_commit_link(char *name, char *title, char *class, char *head,
168 char *rev) 188 char *rev)
169{ 189{
170 if (strlen(name) > cgit_max_msg_len && cgit_max_msg_len >= 15) { 190 if (strlen(name) > cgit_max_msg_len && cgit_max_msg_len >= 15) {
171 name[cgit_max_msg_len] = '\0'; 191 name[cgit_max_msg_len] = '\0';
172 name[cgit_max_msg_len - 1] = '.'; 192 name[cgit_max_msg_len - 1] = '.';
173 name[cgit_max_msg_len - 2] = '.'; 193 name[cgit_max_msg_len - 2] = '.';
174 name[cgit_max_msg_len - 3] = '.'; 194 name[cgit_max_msg_len - 3] = '.';
175 } 195 }
176 reporevlink("commit", name, title, class, head, rev, NULL); 196 reporevlink("commit", name, title, class, head, rev, NULL);
177} 197}
178 198
179void cgit_diff_link(char *name, char *title, char *class, char *head, 199void cgit_diff_link(char *name, char *title, char *class, char *head,
180 char *new_rev, char *old_rev, char *path) 200 char *new_rev, char *old_rev, char *path)
181{ 201{
182 char *delim; 202 char *delim;
183 203
184 delim = repolink(title, class, "diff", head, path); 204 delim = repolink(title, class, "diff", head, path);
185 if (new_rev && strcmp(new_rev, cgit_query_head)) { 205 if (new_rev && strcmp(new_rev, cgit_query_head)) {
186 html(delim); 206 html(delim);
187 html("id="); 207 html("id=");
188 html_attr(new_rev); 208 html_attr(new_rev);
189 delim = "&amp;"; 209 delim = "&amp;";
190 } 210 }
191 if (old_rev) { 211 if (old_rev) {
192 html(delim); 212 html(delim);
193 html("id2="); 213 html("id2=");
194 html_attr(old_rev); 214 html_attr(old_rev);
195 } 215 }
196 html("'>"); 216 html("'>");
197 html_txt(name); 217 html_txt(name);
198 html("</a>"); 218 html("</a>");
199} 219}
200 220
201void cgit_print_date(time_t secs, char *format) 221void cgit_print_date(time_t secs, char *format)
202{ 222{
203 char buf[64]; 223 char buf[64];
204 struct tm *time; 224 struct tm *time;
205 225
206 time = gmtime(&secs); 226 time = gmtime(&secs);
207 strftime(buf, sizeof(buf)-1, format, time); 227 strftime(buf, sizeof(buf)-1, format, time);
208 html_txt(buf); 228 html_txt(buf);
209} 229}
210 230
211void cgit_print_age(time_t t, time_t max_relative, char *format) 231void cgit_print_age(time_t t, time_t max_relative, char *format)
212{ 232{
213 time_t now, secs; 233 time_t now, secs;
214 234
215 time(&now); 235 time(&now);
216 secs = now - t; 236 secs = now - t;
217 237
218 if (secs > max_relative && max_relative >= 0) { 238 if (secs > max_relative && max_relative >= 0) {
219 cgit_print_date(t, format); 239 cgit_print_date(t, format);
220 return; 240 return;
221 } 241 }
222 242
223 if (secs < TM_HOUR * 2) { 243 if (secs < TM_HOUR * 2) {
224 htmlf("<span class='age-mins'>%.0f min.</span>", 244 htmlf("<span class='age-mins'>%.0f min.</span>",
225 secs * 1.0 / TM_MIN); 245 secs * 1.0 / TM_MIN);
226 return; 246 return;
227 } 247 }
228 if (secs < TM_DAY * 2) { 248 if (secs < TM_DAY * 2) {
229 htmlf("<span class='age-hours'>%.0f hours</span>", 249 htmlf("<span class='age-hours'>%.0f hours</span>",
230 secs * 1.0 / TM_HOUR); 250 secs * 1.0 / TM_HOUR);
231 return; 251 return;
232 } 252 }
233 if (secs < TM_WEEK * 2) { 253 if (secs < TM_WEEK * 2) {
234 htmlf("<span class='age-days'>%.0f days</span>", 254 htmlf("<span class='age-days'>%.0f days</span>",
235 secs * 1.0 / TM_DAY); 255 secs * 1.0 / TM_DAY);
236 return; 256 return;
237 } 257 }
238 if (secs < TM_MONTH * 2) { 258 if (secs < TM_MONTH * 2) {
239 htmlf("<span class='age-weeks'>%.0f weeks</span>", 259 htmlf("<span class='age-weeks'>%.0f weeks</span>",
240 secs * 1.0 / TM_WEEK); 260 secs * 1.0 / TM_WEEK);
241 return; 261 return;
242 } 262 }
243 if (secs < TM_YEAR * 2) { 263 if (secs < TM_YEAR * 2) {
244 htmlf("<span class='age-months'>%.0f months</span>", 264 htmlf("<span class='age-months'>%.0f months</span>",
245 secs * 1.0 / TM_MONTH); 265 secs * 1.0 / TM_MONTH);
246 return; 266 return;
247 } 267 }
248 htmlf("<span class='age-years'>%.0f years</span>", 268 htmlf("<span class='age-years'>%.0f years</span>",
249 secs * 1.0 / TM_YEAR); 269 secs * 1.0 / TM_YEAR);
250} 270}
251 271
252void cgit_print_docstart(char *title, struct cacheitem *item) 272void cgit_print_docstart(char *title, struct cacheitem *item)
253{ 273{
254 html("Content-Type: text/html; charset=utf-8\n"); 274 html("Content-Type: text/html; charset=utf-8\n");
255 htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime)); 275 htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime));
256 htmlf("Expires: %s\n", http_date(item->st.st_mtime + 276 htmlf("Expires: %s\n", http_date(item->st.st_mtime +
257 ttl_seconds(item->ttl))); 277 ttl_seconds(item->ttl)));
258 html("\n"); 278 html("\n");
259 html(cgit_doctype); 279 html(cgit_doctype);
260 html("<html>\n"); 280 html("<html>\n");
261 html("<head>\n"); 281 html("<head>\n");
262 html("<title>"); 282 html("<title>");
263 html_txt(title); 283 html_txt(title);
264 html("</title>\n"); 284 html("</title>\n");
265 htmlf("<meta name='generator' content='cgit %s'/>\n", cgit_version); 285 htmlf("<meta name='generator' content='cgit %s'/>\n", cgit_version);
266 html("<link rel='stylesheet' type='text/css' href='"); 286 html("<link rel='stylesheet' type='text/css' href='");
267 html_attr(cgit_css); 287 html_attr(cgit_css);
268 html("'/>\n"); 288 html("'/>\n");
269 html("</head>\n"); 289 html("</head>\n");
270 html("<body>\n"); 290 html("<body>\n");
271} 291}
272 292
273void cgit_print_docend() 293void cgit_print_docend()
274{ 294{
275 html("</td></tr></table>"); 295 html("</td></tr></table>");
276 html("</body>\n</html>\n"); 296 html("</body>\n</html>\n");
277} 297}
278 298
279void cgit_print_pageheader(char *title, int show_search) 299void cgit_print_pageheader(char *title, int show_search)
280{ 300{
281 html("<table id='layout'>"); 301 html("<table id='layout'>");
282 html("<tr><td id='header'>"); 302 html("<tr><td id='header'><a href='");
283 html(cgit_root_title); 303 html_attr(cgit_rooturl());
284 html("</td><td id='logo'>"); 304 html("'>");
305 html_txt(cgit_root_title);
306 html("</a></td><td id='logo'>");
285 html("<a href='"); 307 html("<a href='");
286 html_attr(cgit_logo_link); 308 html_attr(cgit_logo_link);
287 htmlf("'><img src='%s' alt='logo'/></a>", cgit_logo); 309 htmlf("'><img src='%s' alt='logo'/></a>", cgit_logo);
288 html("</td></tr>"); 310 html("</td></tr>");
289 html("<tr><td id='crumb'>"); 311 html("<tr><td id='crumb'>");
290 htmlf("<a href='%s'>root</a>", cgit_rooturl());
291 if (cgit_query_repo) { 312 if (cgit_query_repo) {
292 htmlf(" : <a href='%s'>", cgit_repourl(cgit_repo->url));
293 html_txt(cgit_repo->name); 313 html_txt(cgit_repo->name);
294 htmlf("</a> : %s", title); 314 html(" (");
315 html_txt(cgit_query_head);
316 html(") : &nbsp;");
317 reporevlink(NULL, "summary", NULL, NULL, cgit_query_head,
318 NULL, NULL);
319 html(" ");
320 cgit_log_link("log", NULL, NULL, cgit_query_head,
321 cgit_query_sha1, cgit_query_path, 0);
322 html(" ");
323 cgit_tree_link("tree", NULL, NULL, cgit_query_head,
324 cgit_query_sha1, NULL);
325 html(" ");
326 cgit_commit_link("commit", NULL, NULL, cgit_query_head,
327 cgit_query_sha1);
328 html(" ");
329 cgit_diff_link("diff", NULL, NULL, cgit_query_head,
330 cgit_query_sha1, cgit_query_sha2,
331 cgit_query_path);
332 } else {
333 html_txt("Index of repositories");
295 } 334 }
296 html("</td>"); 335 html("</td>");
297 html("<td id='search'>"); 336 html("<td id='search'>");
298 if (show_search) { 337 if (show_search) {
299 html("<form method='get' action='"); 338 html("<form method='get' action='");
300 html_attr(cgit_currurl()); 339 html_attr(cgit_currurl());
301 html("'>"); 340 html("'>");
302 if (!cgit_virtual_root) { 341 if (!cgit_virtual_root) {
303 if (cgit_query_repo) 342 if (cgit_query_repo)
304 html_hidden("r", cgit_query_repo); 343 html_hidden("r", cgit_query_repo);
305 if (cgit_query_page) 344 if (cgit_query_page)
306 html_hidden("p", cgit_query_page); 345 html_hidden("p", cgit_query_page);
307 } 346 }
308 if (cgit_query_head) 347 if (cgit_query_head)
309 html_hidden("h", cgit_query_head); 348 html_hidden("h", cgit_query_head);
310 if (cgit_query_sha1) 349 if (cgit_query_sha1)
311 html_hidden("id", cgit_query_sha1); 350 html_hidden("id", cgit_query_sha1);
312 if (cgit_query_sha2) 351 if (cgit_query_sha2)
313 html_hidden("id2", cgit_query_sha2); 352 html_hidden("id2", cgit_query_sha2);
314 html("<input type='text' name='q' value='"); 353 html("<input type='text' name='q' value='");
315 html_attr(cgit_query_search); 354 html_attr(cgit_query_search);
316 html("'/></form>"); 355 html("'/></form>");
317 } 356 }
318 html("</td></tr>"); 357 html("</td></tr>");
319 html("<tr><td id='content' colspan='2'>"); 358 html("<tr><td id='content' colspan='2'>");
320} 359}
321 360
322void cgit_print_snapshot_start(const char *mimetype, const char *filename, 361void cgit_print_snapshot_start(const char *mimetype, const char *filename,
323 struct cacheitem *item) 362 struct cacheitem *item)
324{ 363{
325 htmlf("Content-Type: %s\n", mimetype); 364 htmlf("Content-Type: %s\n", mimetype);
326 htmlf("Content-Disposition: inline; filename=\"%s\"\n", filename); 365 htmlf("Content-Disposition: inline; filename=\"%s\"\n", filename);
327 htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime)); 366 htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime));
328 htmlf("Expires: %s\n", http_date(item->st.st_mtime + 367 htmlf("Expires: %s\n", http_date(item->st.st_mtime +
329 ttl_seconds(item->ttl))); 368 ttl_seconds(item->ttl)));
330 html("\n"); 369 html("\n");
331} 370}
diff --git a/ui-summary.c b/ui-summary.c
index 03dd078..b4bc6d8 100644
--- a/ui-summary.c
+++ b/ui-summary.c
@@ -1,158 +1,158 @@
1/* ui-summary.c: functions for generating repo summary page 1/* ui-summary.c: functions for generating repo summary page
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
11static int header; 11static int header;
12 12
13static int cgit_print_branch_cb(const char *refname, const unsigned char *sha1, 13static int cgit_print_branch_cb(const char *refname, const unsigned char *sha1,
14 int flags, void *cb_data) 14 int flags, void *cb_data)
15{ 15{
16 struct commit *commit; 16 struct commit *commit;
17 struct commitinfo *info; 17 struct commitinfo *info;
18 char buf[256]; 18 char buf[256];
19 char *ref; 19 char *ref;
20 20
21 ref = xstrdup(refname); 21 ref = xstrdup(refname);
22 strncpy(buf, refname, sizeof(buf)); 22 strncpy(buf, refname, sizeof(buf));
23 commit = lookup_commit(sha1); 23 commit = lookup_commit(sha1);
24 // object is not really parsed at this point, because of some fallout 24 // object is not really parsed at this point, because of some fallout
25 // from previous calls to git functions in cgit_print_log() 25 // from previous calls to git functions in cgit_print_log()
26 commit->object.parsed = 0; 26 commit->object.parsed = 0;
27 if (commit && !parse_commit(commit)){ 27 if (commit && !parse_commit(commit)){
28 info = cgit_parse_commit(commit); 28 info = cgit_parse_commit(commit);
29 html("<tr><td>"); 29 html("<tr><td>");
30 cgit_log_link(ref, NULL, NULL, ref, NULL, NULL); 30 cgit_log_link(ref, NULL, NULL, ref, NULL, NULL, 0);
31 html("</td><td>"); 31 html("</td><td>");
32 cgit_print_age(commit->date, -1, NULL); 32 cgit_print_age(commit->date, -1, NULL);
33 html("</td><td>"); 33 html("</td><td>");
34 html_txt(info->author); 34 html_txt(info->author);
35 html("</td><td>"); 35 html("</td><td>");
36 cgit_commit_link(info->subject, NULL, NULL, ref, NULL); 36 cgit_commit_link(info->subject, NULL, NULL, ref, NULL);
37 html("</td></tr>\n"); 37 html("</td></tr>\n");
38 cgit_free_commitinfo(info); 38 cgit_free_commitinfo(info);
39 } else { 39 } else {
40 html("<tr><td>"); 40 html("<tr><td>");
41 html_txt(buf); 41 html_txt(buf);
42 html("</td><td colspan='3'>"); 42 html("</td><td colspan='3'>");
43 htmlf("*** bad ref %s ***", sha1_to_hex(sha1)); 43 htmlf("*** bad ref %s ***", sha1_to_hex(sha1));
44 html("</td></tr>\n"); 44 html("</td></tr>\n");
45 } 45 }
46 free(ref); 46 free(ref);
47 return 0; 47 return 0;
48} 48}
49 49
50 50
51static void cgit_print_object_ref(struct object *obj) 51static void cgit_print_object_ref(struct object *obj)
52{ 52{
53 char *page, *arg, *url; 53 char *page, *arg, *url;
54 54
55 if (obj->type == OBJ_COMMIT) { 55 if (obj->type == OBJ_COMMIT) {
56 cgit_commit_link(fmt("commit %s", sha1_to_hex(obj->sha1)), NULL, NULL, 56 cgit_commit_link(fmt("commit %s", sha1_to_hex(obj->sha1)), NULL, NULL,
57 cgit_query_head, sha1_to_hex(obj->sha1)); 57 cgit_query_head, sha1_to_hex(obj->sha1));
58 return; 58 return;
59 } else if (obj->type == OBJ_TREE) { 59 } else if (obj->type == OBJ_TREE) {
60 page = "tree"; 60 page = "tree";
61 arg = "id"; 61 arg = "id";
62 } else { 62 } else {
63 page = "view"; 63 page = "view";
64 arg = "id"; 64 arg = "id";
65 } 65 }
66 66
67 url = cgit_pageurl(cgit_query_repo, page, 67 url = cgit_pageurl(cgit_query_repo, page,
68 fmt("%s=%s", arg, sha1_to_hex(obj->sha1))); 68 fmt("%s=%s", arg, sha1_to_hex(obj->sha1)));
69 html_link_open(url, NULL, NULL); 69 html_link_open(url, NULL, NULL);
70 htmlf("%s %s", typename(obj->type), 70 htmlf("%s %s", typename(obj->type),
71 sha1_to_hex(obj->sha1)); 71 sha1_to_hex(obj->sha1));
72 html_link_close(); 72 html_link_close();
73} 73}
74 74
75static void print_tag_header() 75static void print_tag_header()
76{ 76{
77 html("<tr class='nohover'><th class='left'>Tag</th>" 77 html("<tr class='nohover'><th class='left'>Tag</th>"
78 "<th class='left'>Age</th>" 78 "<th class='left'>Age</th>"
79 "<th class='left'>Author</th>" 79 "<th class='left'>Author</th>"
80 "<th class='left'>Reference</th></tr>\n"); 80 "<th class='left'>Reference</th></tr>\n");
81 header = 1; 81 header = 1;
82} 82}
83 83
84static int cgit_print_tag_cb(const char *refname, const unsigned char *sha1, 84static int cgit_print_tag_cb(const char *refname, const unsigned char *sha1,
85 int flags, void *cb_data) 85 int flags, void *cb_data)
86{ 86{
87 struct tag *tag; 87 struct tag *tag;
88 struct taginfo *info; 88 struct taginfo *info;
89 struct object *obj; 89 struct object *obj;
90 char buf[256], *url; 90 char buf[256], *url;
91 91
92 strncpy(buf, refname, sizeof(buf)); 92 strncpy(buf, refname, sizeof(buf));
93 obj = parse_object(sha1); 93 obj = parse_object(sha1);
94 if (!obj) 94 if (!obj)
95 return 1; 95 return 1;
96 if (obj->type == OBJ_TAG) { 96 if (obj->type == OBJ_TAG) {
97 tag = lookup_tag(sha1); 97 tag = lookup_tag(sha1);
98 if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag))) 98 if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag)))
99 return 2; 99 return 2;
100 if (!header) 100 if (!header)
101 print_tag_header(); 101 print_tag_header();
102 html("<tr><td>"); 102 html("<tr><td>");
103 url = cgit_pageurl(cgit_query_repo, "view", 103 url = cgit_pageurl(cgit_query_repo, "view",
104 fmt("id=%s", sha1_to_hex(sha1))); 104 fmt("id=%s", sha1_to_hex(sha1)));
105 html_link_open(url, NULL, NULL); 105 html_link_open(url, NULL, NULL);
106 html_txt(buf); 106 html_txt(buf);
107 html_link_close(); 107 html_link_close();
108 html("</td><td>"); 108 html("</td><td>");
109 if (info->tagger_date > 0) 109 if (info->tagger_date > 0)
110 cgit_print_age(info->tagger_date, -1, NULL); 110 cgit_print_age(info->tagger_date, -1, NULL);
111 html("</td><td>"); 111 html("</td><td>");
112 if (info->tagger) 112 if (info->tagger)
113 html(info->tagger); 113 html(info->tagger);
114 html("</td><td>"); 114 html("</td><td>");
115 cgit_print_object_ref(tag->tagged); 115 cgit_print_object_ref(tag->tagged);
116 html("</td></tr>\n"); 116 html("</td></tr>\n");
117 } else { 117 } else {
118 if (!header) 118 if (!header)
119 print_tag_header(); 119 print_tag_header();
120 html("<tr><td>"); 120 html("<tr><td>");
121 html_txt(buf); 121 html_txt(buf);
122 html("</td><td colspan='2'/><td>"); 122 html("</td><td colspan='2'/><td>");
123 cgit_print_object_ref(obj); 123 cgit_print_object_ref(obj);
124 html("</td></tr>\n"); 124 html("</td></tr>\n");
125 } 125 }
126 return 0; 126 return 0;
127} 127}
128 128
129static int cgit_print_archive_cb(const char *refname, const unsigned char *sha1, 129static int cgit_print_archive_cb(const char *refname, const unsigned char *sha1,
130 int flags, void *cb_data) 130 int flags, void *cb_data)
131{ 131{
132 struct tag *tag; 132 struct tag *tag;
133 struct taginfo *info; 133 struct taginfo *info;
134 struct object *obj; 134 struct object *obj;
135 char buf[256], *url; 135 char buf[256], *url;
136 unsigned char fileid[20]; 136 unsigned char fileid[20];
137 137
138 if (prefixcmp(refname, "refs/archives")) 138 if (prefixcmp(refname, "refs/archives"))
139 return 0; 139 return 0;
140 strncpy(buf, refname+14, sizeof(buf)); 140 strncpy(buf, refname+14, sizeof(buf));
141 obj = parse_object(sha1); 141 obj = parse_object(sha1);
142 if (!obj) 142 if (!obj)
143 return 1; 143 return 1;
144 if (obj->type == OBJ_TAG) { 144 if (obj->type == OBJ_TAG) {
145 tag = lookup_tag(sha1); 145 tag = lookup_tag(sha1);
146 if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag))) 146 if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag)))
147 return 0; 147 return 0;
148 hashcpy(fileid, tag->tagged->sha1); 148 hashcpy(fileid, tag->tagged->sha1);
149 } else if (obj->type != OBJ_BLOB) { 149 } else if (obj->type != OBJ_BLOB) {
150 return 0; 150 return 0;
151 } else { 151 } else {
152 hashcpy(fileid, sha1); 152 hashcpy(fileid, sha1);
153 } 153 }
154 if (!header) { 154 if (!header) {
155 html("<table id='downloads'>"); 155 html("<table id='downloads'>");
156 html("<tr><th>Downloads</th></tr>"); 156 html("<tr><th>Downloads</th></tr>");
157 header = 1; 157 header = 1;
158 } 158 }
diff --git a/ui-tree.c b/ui-tree.c
index 1037c82..c5d64ff 100644
--- a/ui-tree.c
+++ b/ui-tree.c
@@ -1,209 +1,209 @@
1/* ui-tree.c: functions for tree output 1/* ui-tree.c: functions for tree output
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
11char *curr_rev; 11char *curr_rev;
12char *match_path; 12char *match_path;
13int header = 0; 13int header = 0;
14 14
15static void print_object(const unsigned char *sha1, char *path) 15static void print_object(const unsigned char *sha1, char *path)
16{ 16{
17 enum object_type type; 17 enum object_type type;
18 unsigned char *buf; 18 unsigned char *buf;
19 unsigned long size, lineno, start, idx; 19 unsigned long size, lineno, start, idx;
20 20
21 type = sha1_object_info(sha1, &size); 21 type = sha1_object_info(sha1, &size);
22 if (type == OBJ_BAD) { 22 if (type == OBJ_BAD) {
23 cgit_print_error(fmt("Bad object name: %s", 23 cgit_print_error(fmt("Bad object name: %s",
24 sha1_to_hex(sha1))); 24 sha1_to_hex(sha1)));
25 return; 25 return;
26 } 26 }
27 27
28 buf = read_sha1_file(sha1, &type, &size); 28 buf = read_sha1_file(sha1, &type, &size);
29 if (!buf) { 29 if (!buf) {
30 cgit_print_error(fmt("Error reading object %s", 30 cgit_print_error(fmt("Error reading object %s",
31 sha1_to_hex(sha1))); 31 sha1_to_hex(sha1)));
32 return; 32 return;
33 } 33 }
34 34
35 html("<table class='blob'>\n"); 35 html("<table class='blob'>\n");
36 idx = 0; 36 idx = 0;
37 start = 0; 37 start = 0;
38 lineno = 0; 38 lineno = 0;
39 while(idx < size) { 39 while(idx < size) {
40 if (buf[idx] == '\n') { 40 if (buf[idx] == '\n') {
41 buf[idx] = '\0'; 41 buf[idx] = '\0';
42 htmlf("<tr><td class='no'>%d</td><td class='txt'>", 42 htmlf("<tr><td class='no'>%d</td><td class='txt'>",
43 ++lineno); 43 ++lineno);
44 html_txt(buf + start); 44 html_txt(buf + start);
45 html("</td></tr>\n"); 45 html("</td></tr>\n");
46 start = idx + 1; 46 start = idx + 1;
47 } 47 }
48 idx++; 48 idx++;
49 } 49 }
50 html("</table>\n"); 50 html("</table>\n");
51} 51}
52 52
53 53
54static int ls_item(const unsigned char *sha1, const char *base, int baselen, 54static int ls_item(const unsigned char *sha1, const char *base, int baselen,
55 const char *pathname, unsigned int mode, int stage) 55 const char *pathname, unsigned int mode, int stage)
56{ 56{
57 char *name; 57 char *name;
58 char *fullpath; 58 char *fullpath;
59 enum object_type type; 59 enum object_type type;
60 unsigned long size = 0; 60 unsigned long size = 0;
61 61
62 name = xstrdup(pathname); 62 name = xstrdup(pathname);
63 fullpath = fmt("%s%s%s", cgit_query_path ? cgit_query_path : "", 63 fullpath = fmt("%s%s%s", cgit_query_path ? cgit_query_path : "",
64 cgit_query_path ? "/" : "", name); 64 cgit_query_path ? "/" : "", name);
65 65
66 type = sha1_object_info(sha1, &size); 66 type = sha1_object_info(sha1, &size);
67 if (type == OBJ_BAD && !S_ISDIRLNK(mode)) { 67 if (type == OBJ_BAD && !S_ISDIRLNK(mode)) {
68 htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>", 68 htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>",
69 name, 69 name,
70 sha1_to_hex(sha1)); 70 sha1_to_hex(sha1));
71 return 0; 71 return 0;
72 } 72 }
73 73
74 html("<tr><td class='ls-mode'>"); 74 html("<tr><td class='ls-mode'>");
75 html_filemode(mode); 75 html_filemode(mode);
76 html("</td><td>"); 76 html("</td><td>");
77 if (S_ISDIRLNK(mode)) { 77 if (S_ISDIRLNK(mode)) {
78 htmlf("<a class='ls-mod' href='"); 78 htmlf("<a class='ls-mod' href='");
79 html_attr(fmt(cgit_repo->module_link, 79 html_attr(fmt(cgit_repo->module_link,
80 name, 80 name,
81 sha1_to_hex(sha1))); 81 sha1_to_hex(sha1)));
82 html("'>"); 82 html("'>");
83 html_txt(name); 83 html_txt(name);
84 html("</a>"); 84 html("</a>");
85 } else if (S_ISDIR(mode)) { 85 } else if (S_ISDIR(mode)) {
86 cgit_tree_link(name, NULL, "ls-dir", cgit_query_head, 86 cgit_tree_link(name, NULL, "ls-dir", cgit_query_head,
87 curr_rev, fullpath); 87 curr_rev, fullpath);
88 } else { 88 } else {
89 cgit_tree_link(name, NULL, "ls-blob", cgit_query_head, 89 cgit_tree_link(name, NULL, "ls-blob", cgit_query_head,
90 curr_rev, fullpath); 90 curr_rev, fullpath);
91 } 91 }
92 htmlf("</td><td class='ls-size'>%li</td>", size); 92 htmlf("</td><td class='ls-size'>%li</td>", size);
93 93
94 html("<td>"); 94 html("<td>");
95 cgit_log_link("L", "Log", "button", cgit_query_head, curr_rev, 95 cgit_log_link("log", NULL, "button", cgit_query_head, curr_rev,
96 fullpath); 96 fullpath, 0);
97 html("</td></tr>\n"); 97 html("</td></tr>\n");
98 free(name); 98 free(name);
99 return 0; 99 return 0;
100} 100}
101 101
102static void ls_head() 102static void ls_head()
103{ 103{
104 html("<table class='list'>\n"); 104 html("<table class='list'>\n");
105 html("<tr class='nohover'>"); 105 html("<tr class='nohover'>");
106 html("<th class='left'>Mode</th>"); 106 html("<th class='left'>Mode</th>");
107 html("<th class='left'>Name</th>"); 107 html("<th class='left'>Name</th>");
108 html("<th class='right'>Size</th>"); 108 html("<th class='right'>Size</th>");
109 html("<th/>"); 109 html("<th/>");
110 html("</tr>\n"); 110 html("</tr>\n");
111 header = 1; 111 header = 1;
112} 112}
113 113
114static void ls_tail() 114static void ls_tail()
115{ 115{
116 if (!header) 116 if (!header)
117 return; 117 return;
118 html("</table>\n"); 118 html("</table>\n");
119 header = 0; 119 header = 0;
120} 120}
121 121
122static void ls_tree(const unsigned char *sha1, char *path) 122static void ls_tree(const unsigned char *sha1, char *path)
123{ 123{
124 struct tree *tree; 124 struct tree *tree;
125 125
126 tree = parse_tree_indirect(sha1); 126 tree = parse_tree_indirect(sha1);
127 if (!tree) { 127 if (!tree) {
128 cgit_print_error(fmt("Not a tree object: %s", 128 cgit_print_error(fmt("Not a tree object: %s",
129 sha1_to_hex(sha1))); 129 sha1_to_hex(sha1)));
130 return; 130 return;
131 } 131 }
132 132
133 ls_head(); 133 ls_head();
134 read_tree_recursive(tree, "", 0, 1, NULL, ls_item); 134 read_tree_recursive(tree, "", 0, 1, NULL, ls_item);
135 ls_tail(); 135 ls_tail();
136} 136}
137 137
138 138
139static int walk_tree(const unsigned char *sha1, const char *base, int baselen, 139static int walk_tree(const unsigned char *sha1, const char *base, int baselen,
140 const char *pathname, unsigned mode, int stage) 140 const char *pathname, unsigned mode, int stage)
141{ 141{
142 static int state; 142 static int state;
143 static char buffer[PATH_MAX]; 143 static char buffer[PATH_MAX];
144 char *url; 144 char *url;
145 145
146 if (state == 0) { 146 if (state == 0) {
147 memcpy(buffer, base, baselen); 147 memcpy(buffer, base, baselen);
148 strcpy(buffer+baselen, pathname); 148 strcpy(buffer+baselen, pathname);
149 url = cgit_pageurl(cgit_query_repo, "tree", 149 url = cgit_pageurl(cgit_query_repo, "tree",
150 fmt("h=%s&amp;path=%s", curr_rev, buffer)); 150 fmt("h=%s&amp;path=%s", curr_rev, buffer));
151 html("/"); 151 html("/");
152 cgit_tree_link(xstrdup(pathname), NULL, NULL, cgit_query_head, 152 cgit_tree_link(xstrdup(pathname), NULL, NULL, cgit_query_head,
153 curr_rev, buffer); 153 curr_rev, buffer);
154 154
155 if (strcmp(match_path, buffer)) 155 if (strcmp(match_path, buffer))
156 return READ_TREE_RECURSIVE; 156 return READ_TREE_RECURSIVE;
157 157
158 if (S_ISDIR(mode)) { 158 if (S_ISDIR(mode)) {
159 state = 1; 159 state = 1;
160 ls_head(); 160 ls_head();
161 return READ_TREE_RECURSIVE; 161 return READ_TREE_RECURSIVE;
162 } else { 162 } else {
163 print_object(sha1, buffer); 163 print_object(sha1, buffer);
164 return 0; 164 return 0;
165 } 165 }
166 } 166 }
167 ls_item(sha1, base, baselen, pathname, mode, stage); 167 ls_item(sha1, base, baselen, pathname, mode, stage);
168 return 0; 168 return 0;
169} 169}
170 170
171 171
172/* 172/*
173 * Show a tree or a blob 173 * Show a tree or a blob
174 * rev: the commit pointing at the root tree object 174 * rev: the commit pointing at the root tree object
175 * path: path to tree or blob 175 * path: path to tree or blob
176 */ 176 */
177void cgit_print_tree(const char *rev, char *path) 177void cgit_print_tree(const char *rev, char *path)
178{ 178{
179 unsigned char sha1[20]; 179 unsigned char sha1[20];
180 struct commit *commit; 180 struct commit *commit;
181 const char *paths[] = {path, NULL}; 181 const char *paths[] = {path, NULL};
182 182
183 if (!rev) 183 if (!rev)
184 rev = cgit_query_head; 184 rev = cgit_query_head;
185 185
186 curr_rev = xstrdup(rev); 186 curr_rev = xstrdup(rev);
187 if (get_sha1(rev, sha1)) { 187 if (get_sha1(rev, sha1)) {
188 cgit_print_error(fmt("Invalid revision name: %s", rev)); 188 cgit_print_error(fmt("Invalid revision name: %s", rev));
189 return; 189 return;
190 } 190 }
191 commit = lookup_commit_reference(sha1); 191 commit = lookup_commit_reference(sha1);
192 if (!commit || parse_commit(commit)) { 192 if (!commit || parse_commit(commit)) {
193 cgit_print_error(fmt("Invalid commit reference: %s", rev)); 193 cgit_print_error(fmt("Invalid commit reference: %s", rev));
194 return; 194 return;
195 } 195 }
196 196
197 html("path: <a href='"); 197 html("path: <a href='");
198 html_attr(cgit_pageurl(cgit_query_repo, "tree", fmt("h=%s", rev))); 198 html_attr(cgit_pageurl(cgit_query_repo, "tree", fmt("h=%s", rev)));
199 html("'>root</a>"); 199 html("'>root</a>");
200 200
201 if (path == NULL) { 201 if (path == NULL) {
202 ls_tree(commit->tree->object.sha1, NULL); 202 ls_tree(commit->tree->object.sha1, NULL);
203 return; 203 return;
204 } 204 }
205 205
206 match_path = path; 206 match_path = path;
207 read_tree_recursive(commit->tree, NULL, 0, 0, paths, walk_tree); 207 read_tree_recursive(commit->tree, NULL, 0, 0, paths, walk_tree);
208 ls_tail(); 208 ls_tail();
209} 209}