summaryrefslogtreecommitdiffabout
Unidiff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--cgit.c2
-rw-r--r--cgit.h6
-rw-r--r--shared.c11
-rw-r--r--ui-diff.c16
-rw-r--r--ui-log.c3
-rw-r--r--ui-patch.c4
-rw-r--r--ui-shared.c10
7 files changed, 40 insertions, 12 deletions
diff --git a/cgit.c b/cgit.c
index fde0757..c263872 100644
--- a/cgit.c
+++ b/cgit.c
@@ -71,384 +71,386 @@ void repo_config(struct cgit_repo *repo, const char *name, const char *value)
71 else if (!strcmp(name, "section")) 71 else if (!strcmp(name, "section"))
72 repo->section = xstrdup(value); 72 repo->section = xstrdup(value);
73 else if (!strcmp(name, "readme") && value != NULL) { 73 else if (!strcmp(name, "readme") && value != NULL) {
74 if (*value == '/') 74 if (*value == '/')
75 repo->readme = xstrdup(value); 75 repo->readme = xstrdup(value);
76 else 76 else
77 repo->readme = xstrdup(fmt("%s/%s", repo->path, value)); 77 repo->readme = xstrdup(fmt("%s/%s", repo->path, value));
78 } else if (ctx.cfg.enable_filter_overrides) { 78 } else if (ctx.cfg.enable_filter_overrides) {
79 if (!strcmp(name, "about-filter")) 79 if (!strcmp(name, "about-filter"))
80 repo->about_filter = new_filter(value, 0); 80 repo->about_filter = new_filter(value, 0);
81 else if (!strcmp(name, "commit-filter")) 81 else if (!strcmp(name, "commit-filter"))
82 repo->commit_filter = new_filter(value, 0); 82 repo->commit_filter = new_filter(value, 0);
83 else if (!strcmp(name, "source-filter")) 83 else if (!strcmp(name, "source-filter"))
84 repo->source_filter = new_filter(value, 1); 84 repo->source_filter = new_filter(value, 1);
85 } 85 }
86} 86}
87 87
88void config_cb(const char *name, const char *value) 88void config_cb(const char *name, const char *value)
89{ 89{
90 if (!strcmp(name, "section") || !strcmp(name, "repo.group")) 90 if (!strcmp(name, "section") || !strcmp(name, "repo.group"))
91 ctx.cfg.section = xstrdup(value); 91 ctx.cfg.section = xstrdup(value);
92 else if (!strcmp(name, "repo.url")) 92 else if (!strcmp(name, "repo.url"))
93 ctx.repo = cgit_add_repo(value); 93 ctx.repo = cgit_add_repo(value);
94 else if (ctx.repo && !strcmp(name, "repo.path")) 94 else if (ctx.repo && !strcmp(name, "repo.path"))
95 ctx.repo->path = trim_end(value, '/'); 95 ctx.repo->path = trim_end(value, '/');
96 else if (ctx.repo && !prefixcmp(name, "repo.")) 96 else if (ctx.repo && !prefixcmp(name, "repo."))
97 repo_config(ctx.repo, name + 5, value); 97 repo_config(ctx.repo, name + 5, value);
98 else if (!strcmp(name, "root-title")) 98 else if (!strcmp(name, "root-title"))
99 ctx.cfg.root_title = xstrdup(value); 99 ctx.cfg.root_title = xstrdup(value);
100 else if (!strcmp(name, "root-desc")) 100 else if (!strcmp(name, "root-desc"))
101 ctx.cfg.root_desc = xstrdup(value); 101 ctx.cfg.root_desc = xstrdup(value);
102 else if (!strcmp(name, "root-readme")) 102 else if (!strcmp(name, "root-readme"))
103 ctx.cfg.root_readme = xstrdup(value); 103 ctx.cfg.root_readme = xstrdup(value);
104 else if (!strcmp(name, "css")) 104 else if (!strcmp(name, "css"))
105 ctx.cfg.css = xstrdup(value); 105 ctx.cfg.css = xstrdup(value);
106 else if (!strcmp(name, "favicon")) 106 else if (!strcmp(name, "favicon"))
107 ctx.cfg.favicon = xstrdup(value); 107 ctx.cfg.favicon = xstrdup(value);
108 else if (!strcmp(name, "footer")) 108 else if (!strcmp(name, "footer"))
109 ctx.cfg.footer = xstrdup(value); 109 ctx.cfg.footer = xstrdup(value);
110 else if (!strcmp(name, "head-include")) 110 else if (!strcmp(name, "head-include"))
111 ctx.cfg.head_include = xstrdup(value); 111 ctx.cfg.head_include = xstrdup(value);
112 else if (!strcmp(name, "header")) 112 else if (!strcmp(name, "header"))
113 ctx.cfg.header = xstrdup(value); 113 ctx.cfg.header = xstrdup(value);
114 else if (!strcmp(name, "logo")) 114 else if (!strcmp(name, "logo"))
115 ctx.cfg.logo = xstrdup(value); 115 ctx.cfg.logo = xstrdup(value);
116 else if (!strcmp(name, "index-header")) 116 else if (!strcmp(name, "index-header"))
117 ctx.cfg.index_header = xstrdup(value); 117 ctx.cfg.index_header = xstrdup(value);
118 else if (!strcmp(name, "index-info")) 118 else if (!strcmp(name, "index-info"))
119 ctx.cfg.index_info = xstrdup(value); 119 ctx.cfg.index_info = xstrdup(value);
120 else if (!strcmp(name, "logo-link")) 120 else if (!strcmp(name, "logo-link"))
121 ctx.cfg.logo_link = xstrdup(value); 121 ctx.cfg.logo_link = xstrdup(value);
122 else if (!strcmp(name, "module-link")) 122 else if (!strcmp(name, "module-link"))
123 ctx.cfg.module_link = xstrdup(value); 123 ctx.cfg.module_link = xstrdup(value);
124 else if (!strcmp(name, "virtual-root")) { 124 else if (!strcmp(name, "virtual-root")) {
125 ctx.cfg.virtual_root = trim_end(value, '/'); 125 ctx.cfg.virtual_root = trim_end(value, '/');
126 if (!ctx.cfg.virtual_root && (!strcmp(value, "/"))) 126 if (!ctx.cfg.virtual_root && (!strcmp(value, "/")))
127 ctx.cfg.virtual_root = ""; 127 ctx.cfg.virtual_root = "";
128 } else if (!strcmp(name, "nocache")) 128 } else if (!strcmp(name, "nocache"))
129 ctx.cfg.nocache = atoi(value); 129 ctx.cfg.nocache = atoi(value);
130 else if (!strcmp(name, "noplainemail")) 130 else if (!strcmp(name, "noplainemail"))
131 ctx.cfg.noplainemail = atoi(value); 131 ctx.cfg.noplainemail = atoi(value);
132 else if (!strcmp(name, "noheader")) 132 else if (!strcmp(name, "noheader"))
133 ctx.cfg.noheader = atoi(value); 133 ctx.cfg.noheader = atoi(value);
134 else if (!strcmp(name, "snapshots")) 134 else if (!strcmp(name, "snapshots"))
135 ctx.cfg.snapshots = cgit_parse_snapshots_mask(value); 135 ctx.cfg.snapshots = cgit_parse_snapshots_mask(value);
136 else if (!strcmp(name, "enable-filter-overrides")) 136 else if (!strcmp(name, "enable-filter-overrides"))
137 ctx.cfg.enable_filter_overrides = atoi(value); 137 ctx.cfg.enable_filter_overrides = atoi(value);
138 else if (!strcmp(name, "enable-index-links")) 138 else if (!strcmp(name, "enable-index-links"))
139 ctx.cfg.enable_index_links = atoi(value); 139 ctx.cfg.enable_index_links = atoi(value);
140 else if (!strcmp(name, "enable-log-filecount")) 140 else if (!strcmp(name, "enable-log-filecount"))
141 ctx.cfg.enable_log_filecount = atoi(value); 141 ctx.cfg.enable_log_filecount = atoi(value);
142 else if (!strcmp(name, "enable-log-linecount")) 142 else if (!strcmp(name, "enable-log-linecount"))
143 ctx.cfg.enable_log_linecount = atoi(value); 143 ctx.cfg.enable_log_linecount = atoi(value);
144 else if (!strcmp(name, "enable-remote-branches")) 144 else if (!strcmp(name, "enable-remote-branches"))
145 ctx.cfg.enable_remote_branches = atoi(value); 145 ctx.cfg.enable_remote_branches = atoi(value);
146 else if (!strcmp(name, "enable-subject-links")) 146 else if (!strcmp(name, "enable-subject-links"))
147 ctx.cfg.enable_subject_links = atoi(value); 147 ctx.cfg.enable_subject_links = atoi(value);
148 else if (!strcmp(name, "enable-tree-linenumbers")) 148 else if (!strcmp(name, "enable-tree-linenumbers"))
149 ctx.cfg.enable_tree_linenumbers = atoi(value); 149 ctx.cfg.enable_tree_linenumbers = atoi(value);
150 else if (!strcmp(name, "max-stats")) 150 else if (!strcmp(name, "max-stats"))
151 ctx.cfg.max_stats = cgit_find_stats_period(value, NULL); 151 ctx.cfg.max_stats = cgit_find_stats_period(value, NULL);
152 else if (!strcmp(name, "cache-size")) 152 else if (!strcmp(name, "cache-size"))
153 ctx.cfg.cache_size = atoi(value); 153 ctx.cfg.cache_size = atoi(value);
154 else if (!strcmp(name, "cache-root")) 154 else if (!strcmp(name, "cache-root"))
155 ctx.cfg.cache_root = xstrdup(expand_macros(value)); 155 ctx.cfg.cache_root = xstrdup(expand_macros(value));
156 else if (!strcmp(name, "cache-root-ttl")) 156 else if (!strcmp(name, "cache-root-ttl"))
157 ctx.cfg.cache_root_ttl = atoi(value); 157 ctx.cfg.cache_root_ttl = atoi(value);
158 else if (!strcmp(name, "cache-repo-ttl")) 158 else if (!strcmp(name, "cache-repo-ttl"))
159 ctx.cfg.cache_repo_ttl = atoi(value); 159 ctx.cfg.cache_repo_ttl = atoi(value);
160 else if (!strcmp(name, "cache-scanrc-ttl")) 160 else if (!strcmp(name, "cache-scanrc-ttl"))
161 ctx.cfg.cache_scanrc_ttl = atoi(value); 161 ctx.cfg.cache_scanrc_ttl = atoi(value);
162 else if (!strcmp(name, "cache-static-ttl")) 162 else if (!strcmp(name, "cache-static-ttl"))
163 ctx.cfg.cache_static_ttl = atoi(value); 163 ctx.cfg.cache_static_ttl = atoi(value);
164 else if (!strcmp(name, "cache-dynamic-ttl")) 164 else if (!strcmp(name, "cache-dynamic-ttl"))
165 ctx.cfg.cache_dynamic_ttl = atoi(value); 165 ctx.cfg.cache_dynamic_ttl = atoi(value);
166 else if (!strcmp(name, "about-filter")) 166 else if (!strcmp(name, "about-filter"))
167 ctx.cfg.about_filter = new_filter(value, 0); 167 ctx.cfg.about_filter = new_filter(value, 0);
168 else if (!strcmp(name, "commit-filter")) 168 else if (!strcmp(name, "commit-filter"))
169 ctx.cfg.commit_filter = new_filter(value, 0); 169 ctx.cfg.commit_filter = new_filter(value, 0);
170 else if (!strcmp(name, "embedded")) 170 else if (!strcmp(name, "embedded"))
171 ctx.cfg.embedded = atoi(value); 171 ctx.cfg.embedded = atoi(value);
172 else if (!strcmp(name, "max-atom-items")) 172 else if (!strcmp(name, "max-atom-items"))
173 ctx.cfg.max_atom_items = atoi(value); 173 ctx.cfg.max_atom_items = atoi(value);
174 else if (!strcmp(name, "max-message-length")) 174 else if (!strcmp(name, "max-message-length"))
175 ctx.cfg.max_msg_len = atoi(value); 175 ctx.cfg.max_msg_len = atoi(value);
176 else if (!strcmp(name, "max-repodesc-length")) 176 else if (!strcmp(name, "max-repodesc-length"))
177 ctx.cfg.max_repodesc_len = atoi(value); 177 ctx.cfg.max_repodesc_len = atoi(value);
178 else if (!strcmp(name, "max-blob-size")) 178 else if (!strcmp(name, "max-blob-size"))
179 ctx.cfg.max_blob_size = atoi(value); 179 ctx.cfg.max_blob_size = atoi(value);
180 else if (!strcmp(name, "max-repo-count")) 180 else if (!strcmp(name, "max-repo-count"))
181 ctx.cfg.max_repo_count = atoi(value); 181 ctx.cfg.max_repo_count = atoi(value);
182 else if (!strcmp(name, "max-commit-count")) 182 else if (!strcmp(name, "max-commit-count"))
183 ctx.cfg.max_commit_count = atoi(value); 183 ctx.cfg.max_commit_count = atoi(value);
184 else if (!strcmp(name, "scan-path")) 184 else if (!strcmp(name, "scan-path"))
185 if (!ctx.cfg.nocache && ctx.cfg.cache_size) 185 if (!ctx.cfg.nocache && ctx.cfg.cache_size)
186 process_cached_repolist(expand_macros(value)); 186 process_cached_repolist(expand_macros(value));
187 else 187 else
188 scan_tree(expand_macros(value), repo_config); 188 scan_tree(expand_macros(value), repo_config);
189 else if (!strcmp(name, "source-filter")) 189 else if (!strcmp(name, "source-filter"))
190 ctx.cfg.source_filter = new_filter(value, 1); 190 ctx.cfg.source_filter = new_filter(value, 1);
191 else if (!strcmp(name, "summary-log")) 191 else if (!strcmp(name, "summary-log"))
192 ctx.cfg.summary_log = atoi(value); 192 ctx.cfg.summary_log = atoi(value);
193 else if (!strcmp(name, "summary-branches")) 193 else if (!strcmp(name, "summary-branches"))
194 ctx.cfg.summary_branches = atoi(value); 194 ctx.cfg.summary_branches = atoi(value);
195 else if (!strcmp(name, "summary-tags")) 195 else if (!strcmp(name, "summary-tags"))
196 ctx.cfg.summary_tags = atoi(value); 196 ctx.cfg.summary_tags = atoi(value);
197 else if (!strcmp(name, "side-by-side-diffs")) 197 else if (!strcmp(name, "side-by-side-diffs"))
198 ctx.cfg.ssdiff = atoi(value); 198 ctx.cfg.ssdiff = atoi(value);
199 else if (!strcmp(name, "agefile")) 199 else if (!strcmp(name, "agefile"))
200 ctx.cfg.agefile = xstrdup(value); 200 ctx.cfg.agefile = xstrdup(value);
201 else if (!strcmp(name, "renamelimit")) 201 else if (!strcmp(name, "renamelimit"))
202 ctx.cfg.renamelimit = atoi(value); 202 ctx.cfg.renamelimit = atoi(value);
203 else if (!strcmp(name, "robots")) 203 else if (!strcmp(name, "robots"))
204 ctx.cfg.robots = xstrdup(value); 204 ctx.cfg.robots = xstrdup(value);
205 else if (!strcmp(name, "clone-prefix")) 205 else if (!strcmp(name, "clone-prefix"))
206 ctx.cfg.clone_prefix = xstrdup(value); 206 ctx.cfg.clone_prefix = xstrdup(value);
207 else if (!strcmp(name, "local-time")) 207 else if (!strcmp(name, "local-time"))
208 ctx.cfg.local_time = atoi(value); 208 ctx.cfg.local_time = atoi(value);
209 else if (!prefixcmp(name, "mimetype.")) 209 else if (!prefixcmp(name, "mimetype."))
210 add_mimetype(name + 9, value); 210 add_mimetype(name + 9, value);
211 else if (!strcmp(name, "include")) 211 else if (!strcmp(name, "include"))
212 parse_configfile(expand_macros(value), config_cb); 212 parse_configfile(expand_macros(value), config_cb);
213} 213}
214 214
215static void querystring_cb(const char *name, const char *value) 215static void querystring_cb(const char *name, const char *value)
216{ 216{
217 if (!value) 217 if (!value)
218 value = ""; 218 value = "";
219 219
220 if (!strcmp(name,"r")) { 220 if (!strcmp(name,"r")) {
221 ctx.qry.repo = xstrdup(value); 221 ctx.qry.repo = xstrdup(value);
222 ctx.repo = cgit_get_repoinfo(value); 222 ctx.repo = cgit_get_repoinfo(value);
223 } else if (!strcmp(name, "p")) { 223 } else if (!strcmp(name, "p")) {
224 ctx.qry.page = xstrdup(value); 224 ctx.qry.page = xstrdup(value);
225 } else if (!strcmp(name, "url")) { 225 } else if (!strcmp(name, "url")) {
226 if (*value == '/') 226 if (*value == '/')
227 value++; 227 value++;
228 ctx.qry.url = xstrdup(value); 228 ctx.qry.url = xstrdup(value);
229 cgit_parse_url(value); 229 cgit_parse_url(value);
230 } else if (!strcmp(name, "qt")) { 230 } else if (!strcmp(name, "qt")) {
231 ctx.qry.grep = xstrdup(value); 231 ctx.qry.grep = xstrdup(value);
232 } else if (!strcmp(name, "q")) { 232 } else if (!strcmp(name, "q")) {
233 ctx.qry.search = xstrdup(value); 233 ctx.qry.search = xstrdup(value);
234 } else if (!strcmp(name, "h")) { 234 } else if (!strcmp(name, "h")) {
235 ctx.qry.head = xstrdup(value); 235 ctx.qry.head = xstrdup(value);
236 ctx.qry.has_symref = 1; 236 ctx.qry.has_symref = 1;
237 } else if (!strcmp(name, "id")) { 237 } else if (!strcmp(name, "id")) {
238 ctx.qry.sha1 = xstrdup(value); 238 ctx.qry.sha1 = xstrdup(value);
239 ctx.qry.has_sha1 = 1; 239 ctx.qry.has_sha1 = 1;
240 } else if (!strcmp(name, "id2")) { 240 } else if (!strcmp(name, "id2")) {
241 ctx.qry.sha2 = xstrdup(value); 241 ctx.qry.sha2 = xstrdup(value);
242 ctx.qry.has_sha1 = 1; 242 ctx.qry.has_sha1 = 1;
243 } else if (!strcmp(name, "ofs")) { 243 } else if (!strcmp(name, "ofs")) {
244 ctx.qry.ofs = atoi(value); 244 ctx.qry.ofs = atoi(value);
245 } else if (!strcmp(name, "path")) { 245 } else if (!strcmp(name, "path")) {
246 ctx.qry.path = trim_end(value, '/'); 246 ctx.qry.path = trim_end(value, '/');
247 } else if (!strcmp(name, "name")) { 247 } else if (!strcmp(name, "name")) {
248 ctx.qry.name = xstrdup(value); 248 ctx.qry.name = xstrdup(value);
249 } else if (!strcmp(name, "mimetype")) { 249 } else if (!strcmp(name, "mimetype")) {
250 ctx.qry.mimetype = xstrdup(value); 250 ctx.qry.mimetype = xstrdup(value);
251 } else if (!strcmp(name, "s")){ 251 } else if (!strcmp(name, "s")){
252 ctx.qry.sort = xstrdup(value); 252 ctx.qry.sort = xstrdup(value);
253 } else if (!strcmp(name, "showmsg")) { 253 } else if (!strcmp(name, "showmsg")) {
254 ctx.qry.showmsg = atoi(value); 254 ctx.qry.showmsg = atoi(value);
255 } else if (!strcmp(name, "period")) { 255 } else if (!strcmp(name, "period")) {
256 ctx.qry.period = xstrdup(value); 256 ctx.qry.period = xstrdup(value);
257 } else if (!strcmp(name, "ss")) { 257 } else if (!strcmp(name, "ss")) {
258 ctx.qry.ssdiff = atoi(value); 258 ctx.qry.ssdiff = atoi(value);
259 } else if (!strcmp(name, "all")) { 259 } else if (!strcmp(name, "all")) {
260 ctx.qry.show_all = atoi(value); 260 ctx.qry.show_all = atoi(value);
261 } else if (!strcmp(name, "context")) { 261 } else if (!strcmp(name, "context")) {
262 ctx.qry.context = atoi(value); 262 ctx.qry.context = atoi(value);
263 } else if (!strcmp(name, "ignorews")) {
264 ctx.qry.ignorews = atoi(value);
263 } 265 }
264} 266}
265 267
266char *xstrdupn(const char *str) 268char *xstrdupn(const char *str)
267{ 269{
268 return (str ? xstrdup(str) : NULL); 270 return (str ? xstrdup(str) : NULL);
269} 271}
270 272
271static void prepare_context(struct cgit_context *ctx) 273static void prepare_context(struct cgit_context *ctx)
272{ 274{
273 memset(ctx, 0, sizeof(*ctx)); 275 memset(ctx, 0, sizeof(*ctx));
274 ctx->cfg.agefile = "info/web/last-modified"; 276 ctx->cfg.agefile = "info/web/last-modified";
275 ctx->cfg.nocache = 0; 277 ctx->cfg.nocache = 0;
276 ctx->cfg.cache_size = 0; 278 ctx->cfg.cache_size = 0;
277 ctx->cfg.cache_dynamic_ttl = 5; 279 ctx->cfg.cache_dynamic_ttl = 5;
278 ctx->cfg.cache_max_create_time = 5; 280 ctx->cfg.cache_max_create_time = 5;
279 ctx->cfg.cache_repo_ttl = 5; 281 ctx->cfg.cache_repo_ttl = 5;
280 ctx->cfg.cache_root = CGIT_CACHE_ROOT; 282 ctx->cfg.cache_root = CGIT_CACHE_ROOT;
281 ctx->cfg.cache_root_ttl = 5; 283 ctx->cfg.cache_root_ttl = 5;
282 ctx->cfg.cache_scanrc_ttl = 15; 284 ctx->cfg.cache_scanrc_ttl = 15;
283 ctx->cfg.cache_static_ttl = -1; 285 ctx->cfg.cache_static_ttl = -1;
284 ctx->cfg.css = "/cgit.css"; 286 ctx->cfg.css = "/cgit.css";
285 ctx->cfg.logo = "/cgit.png"; 287 ctx->cfg.logo = "/cgit.png";
286 ctx->cfg.local_time = 0; 288 ctx->cfg.local_time = 0;
287 ctx->cfg.enable_tree_linenumbers = 1; 289 ctx->cfg.enable_tree_linenumbers = 1;
288 ctx->cfg.max_repo_count = 50; 290 ctx->cfg.max_repo_count = 50;
289 ctx->cfg.max_commit_count = 50; 291 ctx->cfg.max_commit_count = 50;
290 ctx->cfg.max_lock_attempts = 5; 292 ctx->cfg.max_lock_attempts = 5;
291 ctx->cfg.max_msg_len = 80; 293 ctx->cfg.max_msg_len = 80;
292 ctx->cfg.max_repodesc_len = 80; 294 ctx->cfg.max_repodesc_len = 80;
293 ctx->cfg.max_blob_size = 0; 295 ctx->cfg.max_blob_size = 0;
294 ctx->cfg.max_stats = 0; 296 ctx->cfg.max_stats = 0;
295 ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s"; 297 ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s";
296 ctx->cfg.renamelimit = -1; 298 ctx->cfg.renamelimit = -1;
297 ctx->cfg.robots = "index, nofollow"; 299 ctx->cfg.robots = "index, nofollow";
298 ctx->cfg.root_title = "Git repository browser"; 300 ctx->cfg.root_title = "Git repository browser";
299 ctx->cfg.root_desc = "a fast webinterface for the git dscm"; 301 ctx->cfg.root_desc = "a fast webinterface for the git dscm";
300 ctx->cfg.script_name = CGIT_SCRIPT_NAME; 302 ctx->cfg.script_name = CGIT_SCRIPT_NAME;
301 ctx->cfg.section = ""; 303 ctx->cfg.section = "";
302 ctx->cfg.summary_branches = 10; 304 ctx->cfg.summary_branches = 10;
303 ctx->cfg.summary_log = 10; 305 ctx->cfg.summary_log = 10;
304 ctx->cfg.summary_tags = 10; 306 ctx->cfg.summary_tags = 10;
305 ctx->cfg.max_atom_items = 10; 307 ctx->cfg.max_atom_items = 10;
306 ctx->cfg.ssdiff = 0; 308 ctx->cfg.ssdiff = 0;
307 ctx->env.cgit_config = xstrdupn(getenv("CGIT_CONFIG")); 309 ctx->env.cgit_config = xstrdupn(getenv("CGIT_CONFIG"));
308 ctx->env.http_host = xstrdupn(getenv("HTTP_HOST")); 310 ctx->env.http_host = xstrdupn(getenv("HTTP_HOST"));
309 ctx->env.https = xstrdupn(getenv("HTTPS")); 311 ctx->env.https = xstrdupn(getenv("HTTPS"));
310 ctx->env.no_http = xstrdupn(getenv("NO_HTTP")); 312 ctx->env.no_http = xstrdupn(getenv("NO_HTTP"));
311 ctx->env.path_info = xstrdupn(getenv("PATH_INFO")); 313 ctx->env.path_info = xstrdupn(getenv("PATH_INFO"));
312 ctx->env.query_string = xstrdupn(getenv("QUERY_STRING")); 314 ctx->env.query_string = xstrdupn(getenv("QUERY_STRING"));
313 ctx->env.request_method = xstrdupn(getenv("REQUEST_METHOD")); 315 ctx->env.request_method = xstrdupn(getenv("REQUEST_METHOD"));
314 ctx->env.script_name = xstrdupn(getenv("SCRIPT_NAME")); 316 ctx->env.script_name = xstrdupn(getenv("SCRIPT_NAME"));
315 ctx->env.server_name = xstrdupn(getenv("SERVER_NAME")); 317 ctx->env.server_name = xstrdupn(getenv("SERVER_NAME"));
316 ctx->env.server_port = xstrdupn(getenv("SERVER_PORT")); 318 ctx->env.server_port = xstrdupn(getenv("SERVER_PORT"));
317 ctx->page.mimetype = "text/html"; 319 ctx->page.mimetype = "text/html";
318 ctx->page.charset = PAGE_ENCODING; 320 ctx->page.charset = PAGE_ENCODING;
319 ctx->page.filename = NULL; 321 ctx->page.filename = NULL;
320 ctx->page.size = 0; 322 ctx->page.size = 0;
321 ctx->page.modified = time(NULL); 323 ctx->page.modified = time(NULL);
322 ctx->page.expires = ctx->page.modified; 324 ctx->page.expires = ctx->page.modified;
323 ctx->page.etag = NULL; 325 ctx->page.etag = NULL;
324 memset(&ctx->cfg.mimetypes, 0, sizeof(struct string_list)); 326 memset(&ctx->cfg.mimetypes, 0, sizeof(struct string_list));
325 if (ctx->env.script_name) 327 if (ctx->env.script_name)
326 ctx->cfg.script_name = ctx->env.script_name; 328 ctx->cfg.script_name = ctx->env.script_name;
327 if (ctx->env.query_string) 329 if (ctx->env.query_string)
328 ctx->qry.raw = ctx->env.query_string; 330 ctx->qry.raw = ctx->env.query_string;
329 if (!ctx->env.cgit_config) 331 if (!ctx->env.cgit_config)
330 ctx->env.cgit_config = CGIT_CONFIG; 332 ctx->env.cgit_config = CGIT_CONFIG;
331} 333}
332 334
333struct refmatch { 335struct refmatch {
334 char *req_ref; 336 char *req_ref;
335 char *first_ref; 337 char *first_ref;
336 int match; 338 int match;
337}; 339};
338 340
339int find_current_ref(const char *refname, const unsigned char *sha1, 341int find_current_ref(const char *refname, const unsigned char *sha1,
340 int flags, void *cb_data) 342 int flags, void *cb_data)
341{ 343{
342 struct refmatch *info; 344 struct refmatch *info;
343 345
344 info = (struct refmatch *)cb_data; 346 info = (struct refmatch *)cb_data;
345 if (!strcmp(refname, info->req_ref)) 347 if (!strcmp(refname, info->req_ref))
346 info->match = 1; 348 info->match = 1;
347 if (!info->first_ref) 349 if (!info->first_ref)
348 info->first_ref = xstrdup(refname); 350 info->first_ref = xstrdup(refname);
349 return info->match; 351 return info->match;
350} 352}
351 353
352char *find_default_branch(struct cgit_repo *repo) 354char *find_default_branch(struct cgit_repo *repo)
353{ 355{
354 struct refmatch info; 356 struct refmatch info;
355 char *ref; 357 char *ref;
356 358
357 info.req_ref = repo->defbranch; 359 info.req_ref = repo->defbranch;
358 info.first_ref = NULL; 360 info.first_ref = NULL;
359 info.match = 0; 361 info.match = 0;
360 for_each_branch_ref(find_current_ref, &info); 362 for_each_branch_ref(find_current_ref, &info);
361 if (info.match) 363 if (info.match)
362 ref = info.req_ref; 364 ref = info.req_ref;
363 else 365 else
364 ref = info.first_ref; 366 ref = info.first_ref;
365 if (ref) 367 if (ref)
366 ref = xstrdup(ref); 368 ref = xstrdup(ref);
367 return ref; 369 return ref;
368} 370}
369 371
370static int prepare_repo_cmd(struct cgit_context *ctx) 372static int prepare_repo_cmd(struct cgit_context *ctx)
371{ 373{
372 char *tmp; 374 char *tmp;
373 unsigned char sha1[20]; 375 unsigned char sha1[20];
374 int nongit = 0; 376 int nongit = 0;
375 377
376 setenv("GIT_DIR", ctx->repo->path, 1); 378 setenv("GIT_DIR", ctx->repo->path, 1);
377 setup_git_directory_gently(&nongit); 379 setup_git_directory_gently(&nongit);
378 if (nongit) { 380 if (nongit) {
379 ctx->page.title = fmt("%s - %s", ctx->cfg.root_title, 381 ctx->page.title = fmt("%s - %s", ctx->cfg.root_title,
380 "config error"); 382 "config error");
381 tmp = fmt("Not a git repository: '%s'", ctx->repo->path); 383 tmp = fmt("Not a git repository: '%s'", ctx->repo->path);
382 ctx->repo = NULL; 384 ctx->repo = NULL;
383 cgit_print_http_headers(ctx); 385 cgit_print_http_headers(ctx);
384 cgit_print_docstart(ctx); 386 cgit_print_docstart(ctx);
385 cgit_print_pageheader(ctx); 387 cgit_print_pageheader(ctx);
386 cgit_print_error(tmp); 388 cgit_print_error(tmp);
387 cgit_print_docend(); 389 cgit_print_docend();
388 return 1; 390 return 1;
389 } 391 }
390 ctx->page.title = fmt("%s - %s", ctx->repo->name, ctx->repo->desc); 392 ctx->page.title = fmt("%s - %s", ctx->repo->name, ctx->repo->desc);
391 393
392 if (!ctx->qry.head) { 394 if (!ctx->qry.head) {
393 ctx->qry.nohead = 1; 395 ctx->qry.nohead = 1;
394 ctx->qry.head = find_default_branch(ctx->repo); 396 ctx->qry.head = find_default_branch(ctx->repo);
395 ctx->repo->defbranch = ctx->qry.head; 397 ctx->repo->defbranch = ctx->qry.head;
396 } 398 }
397 399
398 if (!ctx->qry.head) { 400 if (!ctx->qry.head) {
399 cgit_print_http_headers(ctx); 401 cgit_print_http_headers(ctx);
400 cgit_print_docstart(ctx); 402 cgit_print_docstart(ctx);
401 cgit_print_pageheader(ctx); 403 cgit_print_pageheader(ctx);
402 cgit_print_error("Repository seems to be empty"); 404 cgit_print_error("Repository seems to be empty");
403 cgit_print_docend(); 405 cgit_print_docend();
404 return 1; 406 return 1;
405 } 407 }
406 408
407 if (get_sha1(ctx->qry.head, sha1)) { 409 if (get_sha1(ctx->qry.head, sha1)) {
408 tmp = xstrdup(ctx->qry.head); 410 tmp = xstrdup(ctx->qry.head);
409 ctx->qry.head = ctx->repo->defbranch; 411 ctx->qry.head = ctx->repo->defbranch;
410 ctx->page.status = 404; 412 ctx->page.status = 404;
411 ctx->page.statusmsg = "not found"; 413 ctx->page.statusmsg = "not found";
412 cgit_print_http_headers(ctx); 414 cgit_print_http_headers(ctx);
413 cgit_print_docstart(ctx); 415 cgit_print_docstart(ctx);
414 cgit_print_pageheader(ctx); 416 cgit_print_pageheader(ctx);
415 cgit_print_error(fmt("Invalid branch: %s", tmp)); 417 cgit_print_error(fmt("Invalid branch: %s", tmp));
416 cgit_print_docend(); 418 cgit_print_docend();
417 return 1; 419 return 1;
418 } 420 }
419 return 0; 421 return 0;
420} 422}
421 423
422static void process_request(void *cbdata) 424static void process_request(void *cbdata)
423{ 425{
424 struct cgit_context *ctx = cbdata; 426 struct cgit_context *ctx = cbdata;
425 struct cgit_cmd *cmd; 427 struct cgit_cmd *cmd;
426 428
427 cmd = cgit_get_cmd(ctx); 429 cmd = cgit_get_cmd(ctx);
428 if (!cmd) { 430 if (!cmd) {
429 ctx->page.title = "cgit error"; 431 ctx->page.title = "cgit error";
430 cgit_print_http_headers(ctx); 432 cgit_print_http_headers(ctx);
431 cgit_print_docstart(ctx); 433 cgit_print_docstart(ctx);
432 cgit_print_pageheader(ctx); 434 cgit_print_pageheader(ctx);
433 cgit_print_error("Invalid request"); 435 cgit_print_error("Invalid request");
434 cgit_print_docend(); 436 cgit_print_docend();
435 return; 437 return;
436 } 438 }
437 439
438 /* If cmd->want_vpath is set, assume ctx->qry.path contains a "virtual" 440 /* If cmd->want_vpath is set, assume ctx->qry.path contains a "virtual"
439 * in-project path limit to be made available at ctx->qry.vpath. 441 * in-project path limit to be made available at ctx->qry.vpath.
440 * Otherwise, no path limit is in effect (ctx->qry.vpath = NULL). 442 * Otherwise, no path limit is in effect (ctx->qry.vpath = NULL).
441 */ 443 */
442 ctx->qry.vpath = cmd->want_vpath ? ctx->qry.path : NULL; 444 ctx->qry.vpath = cmd->want_vpath ? ctx->qry.path : NULL;
443 445
444 if (cmd->want_repo && !ctx->repo) { 446 if (cmd->want_repo && !ctx->repo) {
445 cgit_print_http_headers(ctx); 447 cgit_print_http_headers(ctx);
446 cgit_print_docstart(ctx); 448 cgit_print_docstart(ctx);
447 cgit_print_pageheader(ctx); 449 cgit_print_pageheader(ctx);
448 cgit_print_error(fmt("No repository selected")); 450 cgit_print_error(fmt("No repository selected"));
449 cgit_print_docend(); 451 cgit_print_docend();
450 return; 452 return;
451 } 453 }
452 454
453 if (ctx->repo && prepare_repo_cmd(ctx)) 455 if (ctx->repo && prepare_repo_cmd(ctx))
454 return; 456 return;
diff --git a/cgit.h b/cgit.h
index 2bf6ab0..e9e2718 100644
--- a/cgit.h
+++ b/cgit.h
@@ -1,307 +1,309 @@
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 <string-list.h> 18#include <string-list.h>
19#include <xdiff-interface.h> 19#include <xdiff-interface.h>
20#include <xdiff/xdiff.h> 20#include <xdiff/xdiff.h>
21#include <utf8.h> 21#include <utf8.h>
22 22
23 23
24/* 24/*
25 * Dateformats used on misc. pages 25 * Dateformats used on misc. pages
26 */ 26 */
27#define FMT_LONGDATE "%Y-%m-%d %H:%M:%S (%Z)" 27#define FMT_LONGDATE "%Y-%m-%d %H:%M:%S (%Z)"
28#define FMT_SHORTDATE "%Y-%m-%d" 28#define FMT_SHORTDATE "%Y-%m-%d"
29#define FMT_ATOMDATE "%Y-%m-%dT%H:%M:%SZ" 29#define FMT_ATOMDATE "%Y-%m-%dT%H:%M:%SZ"
30 30
31 31
32/* 32/*
33 * Limits used for relative dates 33 * Limits used for relative dates
34 */ 34 */
35#define TM_MIN 60 35#define TM_MIN 60
36#define TM_HOUR (TM_MIN * 60) 36#define TM_HOUR (TM_MIN * 60)
37#define TM_DAY (TM_HOUR * 24) 37#define TM_DAY (TM_HOUR * 24)
38#define TM_WEEK (TM_DAY * 7) 38#define TM_WEEK (TM_DAY * 7)
39#define TM_YEAR (TM_DAY * 365) 39#define TM_YEAR (TM_DAY * 365)
40#define TM_MONTH (TM_YEAR / 12.0) 40#define TM_MONTH (TM_YEAR / 12.0)
41 41
42 42
43/* 43/*
44 * Default encoding 44 * Default encoding
45 */ 45 */
46#define PAGE_ENCODING "UTF-8" 46#define PAGE_ENCODING "UTF-8"
47 47
48typedef void (*configfn)(const char *name, const char *value); 48typedef void (*configfn)(const char *name, const char *value);
49typedef void (*filepair_fn)(struct diff_filepair *pair); 49typedef void (*filepair_fn)(struct diff_filepair *pair);
50typedef void (*linediff_fn)(char *line, int len); 50typedef void (*linediff_fn)(char *line, int len);
51 51
52struct cgit_filter { 52struct cgit_filter {
53 char *cmd; 53 char *cmd;
54 char **argv; 54 char **argv;
55 int old_stdout; 55 int old_stdout;
56 int pipe_fh[2]; 56 int pipe_fh[2];
57 int pid; 57 int pid;
58 int exitstatus; 58 int exitstatus;
59}; 59};
60 60
61struct cgit_repo { 61struct cgit_repo {
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 *module_link; 68 char *module_link;
69 char *readme; 69 char *readme;
70 char *section; 70 char *section;
71 char *clone_url; 71 char *clone_url;
72 int snapshots; 72 int snapshots;
73 int enable_log_filecount; 73 int enable_log_filecount;
74 int enable_log_linecount; 74 int enable_log_linecount;
75 int enable_remote_branches; 75 int enable_remote_branches;
76 int enable_subject_links; 76 int enable_subject_links;
77 int max_stats; 77 int max_stats;
78 time_t mtime; 78 time_t mtime;
79 struct cgit_filter *about_filter; 79 struct cgit_filter *about_filter;
80 struct cgit_filter *commit_filter; 80 struct cgit_filter *commit_filter;
81 struct cgit_filter *source_filter; 81 struct cgit_filter *source_filter;
82}; 82};
83 83
84typedef void (*repo_config_fn)(struct cgit_repo *repo, const char *name, 84typedef void (*repo_config_fn)(struct cgit_repo *repo, const char *name,
85 const char *value); 85 const char *value);
86 86
87struct cgit_repolist { 87struct cgit_repolist {
88 int length; 88 int length;
89 int count; 89 int count;
90 struct cgit_repo *repos; 90 struct cgit_repo *repos;
91}; 91};
92 92
93struct commitinfo { 93struct commitinfo {
94 struct commit *commit; 94 struct commit *commit;
95 char *author; 95 char *author;
96 char *author_email; 96 char *author_email;
97 unsigned long author_date; 97 unsigned long author_date;
98 char *committer; 98 char *committer;
99 char *committer_email; 99 char *committer_email;
100 unsigned long committer_date; 100 unsigned long committer_date;
101 char *subject; 101 char *subject;
102 char *msg; 102 char *msg;
103 char *msg_encoding; 103 char *msg_encoding;
104}; 104};
105 105
106struct taginfo { 106struct taginfo {
107 char *tagger; 107 char *tagger;
108 char *tagger_email; 108 char *tagger_email;
109 unsigned long tagger_date; 109 unsigned long tagger_date;
110 char *msg; 110 char *msg;
111}; 111};
112 112
113struct refinfo { 113struct refinfo {
114 const char *refname; 114 const char *refname;
115 struct object *object; 115 struct object *object;
116 union { 116 union {
117 struct taginfo *tag; 117 struct taginfo *tag;
118 struct commitinfo *commit; 118 struct commitinfo *commit;
119 }; 119 };
120}; 120};
121 121
122struct reflist { 122struct reflist {
123 struct refinfo **refs; 123 struct refinfo **refs;
124 int alloc; 124 int alloc;
125 int count; 125 int count;
126}; 126};
127 127
128struct cgit_query { 128struct cgit_query {
129 int has_symref; 129 int has_symref;
130 int has_sha1; 130 int has_sha1;
131 char *raw; 131 char *raw;
132 char *repo; 132 char *repo;
133 char *page; 133 char *page;
134 char *search; 134 char *search;
135 char *grep; 135 char *grep;
136 char *head; 136 char *head;
137 char *sha1; 137 char *sha1;
138 char *sha2; 138 char *sha2;
139 char *path; 139 char *path;
140 char *name; 140 char *name;
141 char *mimetype; 141 char *mimetype;
142 char *url; 142 char *url;
143 char *period; 143 char *period;
144 int ofs; 144 int ofs;
145 int nohead; 145 int nohead;
146 char *sort; 146 char *sort;
147 int showmsg; 147 int showmsg;
148 int ssdiff; 148 int ssdiff;
149 int show_all; 149 int show_all;
150 int context; 150 int context;
151 int ignorews;
151 char *vpath; 152 char *vpath;
152}; 153};
153 154
154struct cgit_config { 155struct cgit_config {
155 char *agefile; 156 char *agefile;
156 char *cache_root; 157 char *cache_root;
157 char *clone_prefix; 158 char *clone_prefix;
158 char *css; 159 char *css;
159 char *favicon; 160 char *favicon;
160 char *footer; 161 char *footer;
161 char *head_include; 162 char *head_include;
162 char *header; 163 char *header;
163 char *index_header; 164 char *index_header;
164 char *index_info; 165 char *index_info;
165 char *logo; 166 char *logo;
166 char *logo_link; 167 char *logo_link;
167 char *module_link; 168 char *module_link;
168 char *robots; 169 char *robots;
169 char *root_title; 170 char *root_title;
170 char *root_desc; 171 char *root_desc;
171 char *root_readme; 172 char *root_readme;
172 char *script_name; 173 char *script_name;
173 char *section; 174 char *section;
174 char *virtual_root; 175 char *virtual_root;
175 int cache_size; 176 int cache_size;
176 int cache_dynamic_ttl; 177 int cache_dynamic_ttl;
177 int cache_max_create_time; 178 int cache_max_create_time;
178 int cache_repo_ttl; 179 int cache_repo_ttl;
179 int cache_root_ttl; 180 int cache_root_ttl;
180 int cache_scanrc_ttl; 181 int cache_scanrc_ttl;
181 int cache_static_ttl; 182 int cache_static_ttl;
182 int embedded; 183 int embedded;
183 int enable_filter_overrides; 184 int enable_filter_overrides;
184 int enable_index_links; 185 int enable_index_links;
185 int enable_log_filecount; 186 int enable_log_filecount;
186 int enable_log_linecount; 187 int enable_log_linecount;
187 int enable_remote_branches; 188 int enable_remote_branches;
188 int enable_subject_links; 189 int enable_subject_links;
189 int enable_tree_linenumbers; 190 int enable_tree_linenumbers;
190 int local_time; 191 int local_time;
191 int max_atom_items; 192 int max_atom_items;
192 int max_repo_count; 193 int max_repo_count;
193 int max_commit_count; 194 int max_commit_count;
194 int max_lock_attempts; 195 int max_lock_attempts;
195 int max_msg_len; 196 int max_msg_len;
196 int max_repodesc_len; 197 int max_repodesc_len;
197 int max_blob_size; 198 int max_blob_size;
198 int max_stats; 199 int max_stats;
199 int nocache; 200 int nocache;
200 int noplainemail; 201 int noplainemail;
201 int noheader; 202 int noheader;
202 int renamelimit; 203 int renamelimit;
203 int snapshots; 204 int snapshots;
204 int summary_branches; 205 int summary_branches;
205 int summary_log; 206 int summary_log;
206 int summary_tags; 207 int summary_tags;
207 int ssdiff; 208 int ssdiff;
208 struct string_list mimetypes; 209 struct string_list mimetypes;
209 struct cgit_filter *about_filter; 210 struct cgit_filter *about_filter;
210 struct cgit_filter *commit_filter; 211 struct cgit_filter *commit_filter;
211 struct cgit_filter *source_filter; 212 struct cgit_filter *source_filter;
212}; 213};
213 214
214struct cgit_page { 215struct cgit_page {
215 time_t modified; 216 time_t modified;
216 time_t expires; 217 time_t expires;
217 size_t size; 218 size_t size;
218 char *mimetype; 219 char *mimetype;
219 char *charset; 220 char *charset;
220 char *filename; 221 char *filename;
221 char *etag; 222 char *etag;
222 char *title; 223 char *title;
223 int status; 224 int status;
224 char *statusmsg; 225 char *statusmsg;
225}; 226};
226 227
227struct cgit_environment { 228struct cgit_environment {
228 char *cgit_config; 229 char *cgit_config;
229 char *http_host; 230 char *http_host;
230 char *https; 231 char *https;
231 char *no_http; 232 char *no_http;
232 char *path_info; 233 char *path_info;
233 char *query_string; 234 char *query_string;
234 char *request_method; 235 char *request_method;
235 char *script_name; 236 char *script_name;
236 char *server_name; 237 char *server_name;
237 char *server_port; 238 char *server_port;
238}; 239};
239 240
240struct cgit_context { 241struct cgit_context {
241 struct cgit_environment env; 242 struct cgit_environment env;
242 struct cgit_query qry; 243 struct cgit_query qry;
243 struct cgit_config cfg; 244 struct cgit_config cfg;
244 struct cgit_repo *repo; 245 struct cgit_repo *repo;
245 struct cgit_page page; 246 struct cgit_page page;
246}; 247};
247 248
248struct cgit_snapshot_format { 249struct cgit_snapshot_format {
249 const char *suffix; 250 const char *suffix;
250 const char *mimetype; 251 const char *mimetype;
251 write_archive_fn_t write_func; 252 write_archive_fn_t write_func;
252 int bit; 253 int bit;
253}; 254};
254 255
255extern const char *cgit_version; 256extern const char *cgit_version;
256 257
257extern struct cgit_repolist cgit_repolist; 258extern struct cgit_repolist cgit_repolist;
258extern struct cgit_context ctx; 259extern struct cgit_context ctx;
259extern const struct cgit_snapshot_format cgit_snapshot_formats[]; 260extern const struct cgit_snapshot_format cgit_snapshot_formats[];
260 261
261extern struct cgit_repo *cgit_add_repo(const char *url); 262extern struct cgit_repo *cgit_add_repo(const char *url);
262extern struct cgit_repo *cgit_get_repoinfo(const char *url); 263extern struct cgit_repo *cgit_get_repoinfo(const char *url);
263extern void cgit_repo_config_cb(const char *name, const char *value); 264extern void cgit_repo_config_cb(const char *name, const char *value);
264 265
265extern int chk_zero(int result, char *msg); 266extern int chk_zero(int result, char *msg);
266extern int chk_positive(int result, char *msg); 267extern int chk_positive(int result, char *msg);
267extern int chk_non_negative(int result, char *msg); 268extern int chk_non_negative(int result, char *msg);
268 269
269extern char *trim_end(const char *str, char c); 270extern char *trim_end(const char *str, char c);
270extern char *strlpart(char *txt, int maxlen); 271extern char *strlpart(char *txt, int maxlen);
271extern char *strrpart(char *txt, int maxlen); 272extern char *strrpart(char *txt, int maxlen);
272 273
273extern void cgit_add_ref(struct reflist *list, struct refinfo *ref); 274extern void cgit_add_ref(struct reflist *list, struct refinfo *ref);
274extern int cgit_refs_cb(const char *refname, const unsigned char *sha1, 275extern int cgit_refs_cb(const char *refname, const unsigned char *sha1,
275 int flags, void *cb_data); 276 int flags, void *cb_data);
276 277
277extern void *cgit_free_commitinfo(struct commitinfo *info); 278extern void *cgit_free_commitinfo(struct commitinfo *info);
278 279
279extern int cgit_diff_files(const unsigned char *old_sha1, 280extern int cgit_diff_files(const unsigned char *old_sha1,
280 const unsigned char *new_sha1, 281 const unsigned char *new_sha1,
281 unsigned long *old_size, unsigned long *new_size, 282 unsigned long *old_size, unsigned long *new_size,
282 int *binary, int context, linediff_fn fn); 283 int *binary, int context, int ignorews,
284 linediff_fn fn);
283 285
284extern void cgit_diff_tree(const unsigned char *old_sha1, 286extern void cgit_diff_tree(const unsigned char *old_sha1,
285 const unsigned char *new_sha1, 287 const unsigned char *new_sha1,
286 filepair_fn fn, const char *prefix); 288 filepair_fn fn, const char *prefix, int ignorews);
287 289
288extern void cgit_diff_commit(struct commit *commit, filepair_fn fn); 290extern void cgit_diff_commit(struct commit *commit, filepair_fn fn);
289 291
290extern char *fmt(const char *format,...); 292extern char *fmt(const char *format,...);
291 293
292extern struct commitinfo *cgit_parse_commit(struct commit *commit); 294extern struct commitinfo *cgit_parse_commit(struct commit *commit);
293extern struct taginfo *cgit_parse_tag(struct tag *tag); 295extern struct taginfo *cgit_parse_tag(struct tag *tag);
294extern void cgit_parse_url(const char *url); 296extern void cgit_parse_url(const char *url);
295 297
296extern const char *cgit_repobasename(const char *reponame); 298extern const char *cgit_repobasename(const char *reponame);
297 299
298extern int cgit_parse_snapshots_mask(const char *str); 300extern int cgit_parse_snapshots_mask(const char *str);
299 301
300extern int cgit_open_filter(struct cgit_filter *filter); 302extern int cgit_open_filter(struct cgit_filter *filter);
301extern int cgit_close_filter(struct cgit_filter *filter); 303extern int cgit_close_filter(struct cgit_filter *filter);
302 304
303extern int readfile(const char *path, char **buf, size_t *size); 305extern int readfile(const char *path, char **buf, size_t *size);
304 306
305extern char *expand_macros(const char *txt); 307extern char *expand_macros(const char *txt);
306 308
307#endif /* CGIT_H */ 309#endif /* CGIT_H */
diff --git a/shared.c b/shared.c
index 9f7d6a5..b42c2a2 100644
--- a/shared.c
+++ b/shared.c
@@ -75,431 +75,436 @@ struct cgit_repo *cgit_get_repoinfo(const char *url)
75 int i; 75 int i;
76 struct cgit_repo *repo; 76 struct cgit_repo *repo;
77 77
78 for (i=0; i<cgit_repolist.count; i++) { 78 for (i=0; i<cgit_repolist.count; i++) {
79 repo = &cgit_repolist.repos[i]; 79 repo = &cgit_repolist.repos[i];
80 if (!strcmp(repo->url, url)) 80 if (!strcmp(repo->url, url))
81 return repo; 81 return repo;
82 } 82 }
83 return NULL; 83 return NULL;
84} 84}
85 85
86void *cgit_free_commitinfo(struct commitinfo *info) 86void *cgit_free_commitinfo(struct commitinfo *info)
87{ 87{
88 free(info->author); 88 free(info->author);
89 free(info->author_email); 89 free(info->author_email);
90 free(info->committer); 90 free(info->committer);
91 free(info->committer_email); 91 free(info->committer_email);
92 free(info->subject); 92 free(info->subject);
93 free(info->msg); 93 free(info->msg);
94 free(info->msg_encoding); 94 free(info->msg_encoding);
95 free(info); 95 free(info);
96 return NULL; 96 return NULL;
97} 97}
98 98
99char *trim_end(const char *str, char c) 99char *trim_end(const char *str, char c)
100{ 100{
101 int len; 101 int len;
102 char *s, *t; 102 char *s, *t;
103 103
104 if (str == NULL) 104 if (str == NULL)
105 return NULL; 105 return NULL;
106 t = (char *)str; 106 t = (char *)str;
107 len = strlen(t); 107 len = strlen(t);
108 while(len > 0 && t[len - 1] == c) 108 while(len > 0 && t[len - 1] == c)
109 len--; 109 len--;
110 110
111 if (len == 0) 111 if (len == 0)
112 return NULL; 112 return NULL;
113 113
114 c = t[len]; 114 c = t[len];
115 t[len] = '\0'; 115 t[len] = '\0';
116 s = xstrdup(t); 116 s = xstrdup(t);
117 t[len] = c; 117 t[len] = c;
118 return s; 118 return s;
119} 119}
120 120
121char *strlpart(char *txt, int maxlen) 121char *strlpart(char *txt, int maxlen)
122{ 122{
123 char *result; 123 char *result;
124 124
125 if (!txt) 125 if (!txt)
126 return txt; 126 return txt;
127 127
128 if (strlen(txt) <= maxlen) 128 if (strlen(txt) <= maxlen)
129 return txt; 129 return txt;
130 result = xmalloc(maxlen + 1); 130 result = xmalloc(maxlen + 1);
131 memcpy(result, txt, maxlen - 3); 131 memcpy(result, txt, maxlen - 3);
132 result[maxlen-1] = result[maxlen-2] = result[maxlen-3] = '.'; 132 result[maxlen-1] = result[maxlen-2] = result[maxlen-3] = '.';
133 result[maxlen] = '\0'; 133 result[maxlen] = '\0';
134 return result; 134 return result;
135} 135}
136 136
137char *strrpart(char *txt, int maxlen) 137char *strrpart(char *txt, int maxlen)
138{ 138{
139 char *result; 139 char *result;
140 140
141 if (!txt) 141 if (!txt)
142 return txt; 142 return txt;
143 143
144 if (strlen(txt) <= maxlen) 144 if (strlen(txt) <= maxlen)
145 return txt; 145 return txt;
146 result = xmalloc(maxlen + 1); 146 result = xmalloc(maxlen + 1);
147 memcpy(result + 3, txt + strlen(txt) - maxlen + 4, maxlen - 3); 147 memcpy(result + 3, txt + strlen(txt) - maxlen + 4, maxlen - 3);
148 result[0] = result[1] = result[2] = '.'; 148 result[0] = result[1] = result[2] = '.';
149 return result; 149 return result;
150} 150}
151 151
152void cgit_add_ref(struct reflist *list, struct refinfo *ref) 152void cgit_add_ref(struct reflist *list, struct refinfo *ref)
153{ 153{
154 size_t size; 154 size_t size;
155 155
156 if (list->count >= list->alloc) { 156 if (list->count >= list->alloc) {
157 list->alloc += (list->alloc ? list->alloc : 4); 157 list->alloc += (list->alloc ? list->alloc : 4);
158 size = list->alloc * sizeof(struct refinfo *); 158 size = list->alloc * sizeof(struct refinfo *);
159 list->refs = xrealloc(list->refs, size); 159 list->refs = xrealloc(list->refs, size);
160 } 160 }
161 list->refs[list->count++] = ref; 161 list->refs[list->count++] = ref;
162} 162}
163 163
164struct refinfo *cgit_mk_refinfo(const char *refname, const unsigned char *sha1) 164struct refinfo *cgit_mk_refinfo(const char *refname, const unsigned char *sha1)
165{ 165{
166 struct refinfo *ref; 166 struct refinfo *ref;
167 167
168 ref = xmalloc(sizeof (struct refinfo)); 168 ref = xmalloc(sizeof (struct refinfo));
169 ref->refname = xstrdup(refname); 169 ref->refname = xstrdup(refname);
170 ref->object = parse_object(sha1); 170 ref->object = parse_object(sha1);
171 switch (ref->object->type) { 171 switch (ref->object->type) {
172 case OBJ_TAG: 172 case OBJ_TAG:
173 ref->tag = cgit_parse_tag((struct tag *)ref->object); 173 ref->tag = cgit_parse_tag((struct tag *)ref->object);
174 break; 174 break;
175 case OBJ_COMMIT: 175 case OBJ_COMMIT:
176 ref->commit = cgit_parse_commit((struct commit *)ref->object); 176 ref->commit = cgit_parse_commit((struct commit *)ref->object);
177 break; 177 break;
178 } 178 }
179 return ref; 179 return ref;
180} 180}
181 181
182int cgit_refs_cb(const char *refname, const unsigned char *sha1, int flags, 182int cgit_refs_cb(const char *refname, const unsigned char *sha1, int flags,
183 void *cb_data) 183 void *cb_data)
184{ 184{
185 struct reflist *list = (struct reflist *)cb_data; 185 struct reflist *list = (struct reflist *)cb_data;
186 struct refinfo *info = cgit_mk_refinfo(refname, sha1); 186 struct refinfo *info = cgit_mk_refinfo(refname, sha1);
187 187
188 if (info) 188 if (info)
189 cgit_add_ref(list, info); 189 cgit_add_ref(list, info);
190 return 0; 190 return 0;
191} 191}
192 192
193void cgit_diff_tree_cb(struct diff_queue_struct *q, 193void cgit_diff_tree_cb(struct diff_queue_struct *q,
194 struct diff_options *options, void *data) 194 struct diff_options *options, void *data)
195{ 195{
196 int i; 196 int i;
197 197
198 for (i = 0; i < q->nr; i++) { 198 for (i = 0; i < q->nr; i++) {
199 if (q->queue[i]->status == 'U') 199 if (q->queue[i]->status == 'U')
200 continue; 200 continue;
201 ((filepair_fn)data)(q->queue[i]); 201 ((filepair_fn)data)(q->queue[i]);
202 } 202 }
203} 203}
204 204
205static int load_mmfile(mmfile_t *file, const unsigned char *sha1) 205static int load_mmfile(mmfile_t *file, const unsigned char *sha1)
206{ 206{
207 enum object_type type; 207 enum object_type type;
208 208
209 if (is_null_sha1(sha1)) { 209 if (is_null_sha1(sha1)) {
210 file->ptr = (char *)""; 210 file->ptr = (char *)"";
211 file->size = 0; 211 file->size = 0;
212 } else { 212 } else {
213 file->ptr = read_sha1_file(sha1, &type, 213 file->ptr = read_sha1_file(sha1, &type,
214 (unsigned long *)&file->size); 214 (unsigned long *)&file->size);
215 } 215 }
216 return 1; 216 return 1;
217} 217}
218 218
219/* 219/*
220 * Receive diff-buffers from xdiff and concatenate them as 220 * Receive diff-buffers from xdiff and concatenate them as
221 * needed across multiple callbacks. 221 * needed across multiple callbacks.
222 * 222 *
223 * This is basically a copy of xdiff-interface.c/xdiff_outf(), 223 * This is basically a copy of xdiff-interface.c/xdiff_outf(),
224 * ripped from git and modified to use globals instead of 224 * ripped from git and modified to use globals instead of
225 * a special callback-struct. 225 * a special callback-struct.
226 */ 226 */
227char *diffbuf = NULL; 227char *diffbuf = NULL;
228int buflen = 0; 228int buflen = 0;
229 229
230int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf) 230int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf)
231{ 231{
232 int i; 232 int i;
233 233
234 for (i = 0; i < nbuf; i++) { 234 for (i = 0; i < nbuf; i++) {
235 if (mb[i].ptr[mb[i].size-1] != '\n') { 235 if (mb[i].ptr[mb[i].size-1] != '\n') {
236 /* Incomplete line */ 236 /* Incomplete line */
237 diffbuf = xrealloc(diffbuf, buflen + mb[i].size); 237 diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
238 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); 238 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
239 buflen += mb[i].size; 239 buflen += mb[i].size;
240 continue; 240 continue;
241 } 241 }
242 242
243 /* we have a complete line */ 243 /* we have a complete line */
244 if (!diffbuf) { 244 if (!diffbuf) {
245 ((linediff_fn)priv)(mb[i].ptr, mb[i].size); 245 ((linediff_fn)priv)(mb[i].ptr, mb[i].size);
246 continue; 246 continue;
247 } 247 }
248 diffbuf = xrealloc(diffbuf, buflen + mb[i].size); 248 diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
249 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); 249 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
250 ((linediff_fn)priv)(diffbuf, buflen + mb[i].size); 250 ((linediff_fn)priv)(diffbuf, buflen + mb[i].size);
251 free(diffbuf); 251 free(diffbuf);
252 diffbuf = NULL; 252 diffbuf = NULL;
253 buflen = 0; 253 buflen = 0;
254 } 254 }
255 if (diffbuf) { 255 if (diffbuf) {
256 ((linediff_fn)priv)(diffbuf, buflen); 256 ((linediff_fn)priv)(diffbuf, buflen);
257 free(diffbuf); 257 free(diffbuf);
258 diffbuf = NULL; 258 diffbuf = NULL;
259 buflen = 0; 259 buflen = 0;
260 } 260 }
261 return 0; 261 return 0;
262} 262}
263 263
264int cgit_diff_files(const unsigned char *old_sha1, 264int cgit_diff_files(const unsigned char *old_sha1,
265 const unsigned char *new_sha1, unsigned long *old_size, 265 const unsigned char *new_sha1, unsigned long *old_size,
266 unsigned long *new_size, int *binary, int context, 266 unsigned long *new_size, int *binary, int context,
267 linediff_fn fn) 267 int ignorews, linediff_fn fn)
268{ 268{
269 mmfile_t file1, file2; 269 mmfile_t file1, file2;
270 xpparam_t diff_params; 270 xpparam_t diff_params;
271 xdemitconf_t emit_params; 271 xdemitconf_t emit_params;
272 xdemitcb_t emit_cb; 272 xdemitcb_t emit_cb;
273 273
274 if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1)) 274 if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1))
275 return 1; 275 return 1;
276 276
277 *old_size = file1.size; 277 *old_size = file1.size;
278 *new_size = file2.size; 278 *new_size = file2.size;
279 279
280 if ((file1.ptr && buffer_is_binary(file1.ptr, file1.size)) || 280 if ((file1.ptr && buffer_is_binary(file1.ptr, file1.size)) ||
281 (file2.ptr && buffer_is_binary(file2.ptr, file2.size))) { 281 (file2.ptr && buffer_is_binary(file2.ptr, file2.size))) {
282 *binary = 1; 282 *binary = 1;
283 if (file1.size) 283 if (file1.size)
284 free(file1.ptr); 284 free(file1.ptr);
285 if (file2.size) 285 if (file2.size)
286 free(file2.ptr); 286 free(file2.ptr);
287 return 0; 287 return 0;
288 } 288 }
289 289
290 memset(&diff_params, 0, sizeof(diff_params)); 290 memset(&diff_params, 0, sizeof(diff_params));
291 memset(&emit_params, 0, sizeof(emit_params)); 291 memset(&emit_params, 0, sizeof(emit_params));
292 memset(&emit_cb, 0, sizeof(emit_cb)); 292 memset(&emit_cb, 0, sizeof(emit_cb));
293 diff_params.flags = XDF_NEED_MINIMAL; 293 diff_params.flags = XDF_NEED_MINIMAL;
294 if (ignorews)
295 diff_params.flags |= XDF_IGNORE_WHITESPACE;
294 emit_params.ctxlen = context > 0 ? context : 3; 296 emit_params.ctxlen = context > 0 ? context : 3;
295 emit_params.flags = XDL_EMIT_FUNCNAMES; 297 emit_params.flags = XDL_EMIT_FUNCNAMES;
296 emit_cb.outf = filediff_cb; 298 emit_cb.outf = filediff_cb;
297 emit_cb.priv = fn; 299 emit_cb.priv = fn;
298 xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb); 300 xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb);
299 if (file1.size) 301 if (file1.size)
300 free(file1.ptr); 302 free(file1.ptr);
301 if (file2.size) 303 if (file2.size)
302 free(file2.ptr); 304 free(file2.ptr);
303 return 0; 305 return 0;
304} 306}
305 307
306void cgit_diff_tree(const unsigned char *old_sha1, 308void cgit_diff_tree(const unsigned char *old_sha1,
307 const unsigned char *new_sha1, 309 const unsigned char *new_sha1,
308 filepair_fn fn, const char *prefix) 310 filepair_fn fn, const char *prefix, int ignorews)
309{ 311{
310 struct diff_options opt; 312 struct diff_options opt;
311 int ret; 313 int ret;
312 int prefixlen; 314 int prefixlen;
313 315
314 diff_setup(&opt); 316 diff_setup(&opt);
315 opt.output_format = DIFF_FORMAT_CALLBACK; 317 opt.output_format = DIFF_FORMAT_CALLBACK;
316 opt.detect_rename = 1; 318 opt.detect_rename = 1;
317 opt.rename_limit = ctx.cfg.renamelimit; 319 opt.rename_limit = ctx.cfg.renamelimit;
318 DIFF_OPT_SET(&opt, RECURSIVE); 320 DIFF_OPT_SET(&opt, RECURSIVE);
321 if (ignorews)
322 DIFF_XDL_SET(&opt, IGNORE_WHITESPACE);
319 opt.format_callback = cgit_diff_tree_cb; 323 opt.format_callback = cgit_diff_tree_cb;
320 opt.format_callback_data = fn; 324 opt.format_callback_data = fn;
321 if (prefix) { 325 if (prefix) {
322 opt.nr_paths = 1; 326 opt.nr_paths = 1;
323 opt.paths = &prefix; 327 opt.paths = &prefix;
324 prefixlen = strlen(prefix); 328 prefixlen = strlen(prefix);
325 opt.pathlens = &prefixlen; 329 opt.pathlens = &prefixlen;
326 } 330 }
327 diff_setup_done(&opt); 331 diff_setup_done(&opt);
328 332
329 if (old_sha1 && !is_null_sha1(old_sha1)) 333 if (old_sha1 && !is_null_sha1(old_sha1))
330 ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt); 334 ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt);
331 else 335 else
332 ret = diff_root_tree_sha1(new_sha1, "", &opt); 336 ret = diff_root_tree_sha1(new_sha1, "", &opt);
333 diffcore_std(&opt); 337 diffcore_std(&opt);
334 diff_flush(&opt); 338 diff_flush(&opt);
335} 339}
336 340
337void cgit_diff_commit(struct commit *commit, filepair_fn fn) 341void cgit_diff_commit(struct commit *commit, filepair_fn fn)
338{ 342{
339 unsigned char *old_sha1 = NULL; 343 unsigned char *old_sha1 = NULL;
340 344
341 if (commit->parents) 345 if (commit->parents)
342 old_sha1 = commit->parents->item->object.sha1; 346 old_sha1 = commit->parents->item->object.sha1;
343 cgit_diff_tree(old_sha1, commit->object.sha1, fn, NULL); 347 cgit_diff_tree(old_sha1, commit->object.sha1, fn, NULL,
348 ctx.qry.ignorews);
344} 349}
345 350
346int cgit_parse_snapshots_mask(const char *str) 351int cgit_parse_snapshots_mask(const char *str)
347{ 352{
348 const struct cgit_snapshot_format *f; 353 const struct cgit_snapshot_format *f;
349 static const char *delim = " \t,:/|;"; 354 static const char *delim = " \t,:/|;";
350 int tl, sl, rv = 0; 355 int tl, sl, rv = 0;
351 356
352 /* favor legacy setting */ 357 /* favor legacy setting */
353 if(atoi(str)) 358 if(atoi(str))
354 return 1; 359 return 1;
355 for(;;) { 360 for(;;) {
356 str += strspn(str,delim); 361 str += strspn(str,delim);
357 tl = strcspn(str,delim); 362 tl = strcspn(str,delim);
358 if (!tl) 363 if (!tl)
359 break; 364 break;
360 for (f = cgit_snapshot_formats; f->suffix; f++) { 365 for (f = cgit_snapshot_formats; f->suffix; f++) {
361 sl = strlen(f->suffix); 366 sl = strlen(f->suffix);
362 if((tl == sl && !strncmp(f->suffix, str, tl)) || 367 if((tl == sl && !strncmp(f->suffix, str, tl)) ||
363 (tl == sl-1 && !strncmp(f->suffix+1, str, tl-1))) { 368 (tl == sl-1 && !strncmp(f->suffix+1, str, tl-1))) {
364 rv |= f->bit; 369 rv |= f->bit;
365 break; 370 break;
366 } 371 }
367 } 372 }
368 str += tl; 373 str += tl;
369 } 374 }
370 return rv; 375 return rv;
371} 376}
372 377
373int cgit_open_filter(struct cgit_filter *filter) 378int cgit_open_filter(struct cgit_filter *filter)
374{ 379{
375 380
376 filter->old_stdout = chk_positive(dup(STDOUT_FILENO), 381 filter->old_stdout = chk_positive(dup(STDOUT_FILENO),
377 "Unable to duplicate STDOUT"); 382 "Unable to duplicate STDOUT");
378 chk_zero(pipe(filter->pipe_fh), "Unable to create pipe to subprocess"); 383 chk_zero(pipe(filter->pipe_fh), "Unable to create pipe to subprocess");
379 filter->pid = chk_non_negative(fork(), "Unable to create subprocess"); 384 filter->pid = chk_non_negative(fork(), "Unable to create subprocess");
380 if (filter->pid == 0) { 385 if (filter->pid == 0) {
381 close(filter->pipe_fh[1]); 386 close(filter->pipe_fh[1]);
382 chk_non_negative(dup2(filter->pipe_fh[0], STDIN_FILENO), 387 chk_non_negative(dup2(filter->pipe_fh[0], STDIN_FILENO),
383 "Unable to use pipe as STDIN"); 388 "Unable to use pipe as STDIN");
384 execvp(filter->cmd, filter->argv); 389 execvp(filter->cmd, filter->argv);
385 die("Unable to exec subprocess %s: %s (%d)", filter->cmd, 390 die("Unable to exec subprocess %s: %s (%d)", filter->cmd,
386 strerror(errno), errno); 391 strerror(errno), errno);
387 } 392 }
388 close(filter->pipe_fh[0]); 393 close(filter->pipe_fh[0]);
389 chk_non_negative(dup2(filter->pipe_fh[1], STDOUT_FILENO), 394 chk_non_negative(dup2(filter->pipe_fh[1], STDOUT_FILENO),
390 "Unable to use pipe as STDOUT"); 395 "Unable to use pipe as STDOUT");
391 close(filter->pipe_fh[1]); 396 close(filter->pipe_fh[1]);
392 return 0; 397 return 0;
393} 398}
394 399
395int cgit_close_filter(struct cgit_filter *filter) 400int cgit_close_filter(struct cgit_filter *filter)
396{ 401{
397 chk_non_negative(dup2(filter->old_stdout, STDOUT_FILENO), 402 chk_non_negative(dup2(filter->old_stdout, STDOUT_FILENO),
398 "Unable to restore STDOUT"); 403 "Unable to restore STDOUT");
399 close(filter->old_stdout); 404 close(filter->old_stdout);
400 if (filter->pid < 0) 405 if (filter->pid < 0)
401 return 0; 406 return 0;
402 waitpid(filter->pid, &filter->exitstatus, 0); 407 waitpid(filter->pid, &filter->exitstatus, 0);
403 if (WIFEXITED(filter->exitstatus) && !WEXITSTATUS(filter->exitstatus)) 408 if (WIFEXITED(filter->exitstatus) && !WEXITSTATUS(filter->exitstatus))
404 return 0; 409 return 0;
405 die("Subprocess %s exited abnormally", filter->cmd); 410 die("Subprocess %s exited abnormally", filter->cmd);
406} 411}
407 412
408/* Read the content of the specified file into a newly allocated buffer, 413/* Read the content of the specified file into a newly allocated buffer,
409 * zeroterminate the buffer and return 0 on success, errno otherwise. 414 * zeroterminate the buffer and return 0 on success, errno otherwise.
410 */ 415 */
411int readfile(const char *path, char **buf, size_t *size) 416int readfile(const char *path, char **buf, size_t *size)
412{ 417{
413 int fd, e; 418 int fd, e;
414 struct stat st; 419 struct stat st;
415 420
416 fd = open(path, O_RDONLY); 421 fd = open(path, O_RDONLY);
417 if (fd == -1) 422 if (fd == -1)
418 return errno; 423 return errno;
419 if (fstat(fd, &st)) { 424 if (fstat(fd, &st)) {
420 e = errno; 425 e = errno;
421 close(fd); 426 close(fd);
422 return e; 427 return e;
423 } 428 }
424 if (!S_ISREG(st.st_mode)) { 429 if (!S_ISREG(st.st_mode)) {
425 close(fd); 430 close(fd);
426 return EISDIR; 431 return EISDIR;
427 } 432 }
428 *buf = xmalloc(st.st_size + 1); 433 *buf = xmalloc(st.st_size + 1);
429 *size = read_in_full(fd, *buf, st.st_size); 434 *size = read_in_full(fd, *buf, st.st_size);
430 e = errno; 435 e = errno;
431 (*buf)[*size] = '\0'; 436 (*buf)[*size] = '\0';
432 close(fd); 437 close(fd);
433 return (*size == st.st_size ? 0 : e); 438 return (*size == st.st_size ? 0 : e);
434} 439}
435 440
436int is_token_char(char c) 441int is_token_char(char c)
437{ 442{
438 return isalnum(c) || c == '_'; 443 return isalnum(c) || c == '_';
439} 444}
440 445
441/* Replace name with getenv(name), return pointer to zero-terminating char 446/* Replace name with getenv(name), return pointer to zero-terminating char
442 */ 447 */
443char *expand_macro(char *name, int maxlength) 448char *expand_macro(char *name, int maxlength)
444{ 449{
445 char *value; 450 char *value;
446 int len; 451 int len;
447 452
448 len = 0; 453 len = 0;
449 value = getenv(name); 454 value = getenv(name);
450 if (value) { 455 if (value) {
451 len = strlen(value); 456 len = strlen(value);
452 if (len > maxlength) 457 if (len > maxlength)
453 len = maxlength; 458 len = maxlength;
454 strncpy(name, value, len); 459 strncpy(name, value, len);
455 } 460 }
456 return name + len; 461 return name + len;
457} 462}
458 463
459#define EXPBUFSIZE (1024 * 8) 464#define EXPBUFSIZE (1024 * 8)
460 465
461/* Replace all tokens prefixed by '$' in the specified text with the 466/* Replace all tokens prefixed by '$' in the specified text with the
462 * value of the named environment variable. 467 * value of the named environment variable.
463 * NB: the return value is a static buffer, i.e. it must be strdup'd 468 * NB: the return value is a static buffer, i.e. it must be strdup'd
464 * by the caller. 469 * by the caller.
465 */ 470 */
466char *expand_macros(const char *txt) 471char *expand_macros(const char *txt)
467{ 472{
468 static char result[EXPBUFSIZE]; 473 static char result[EXPBUFSIZE];
469 char *p, *start; 474 char *p, *start;
470 int len; 475 int len;
471 476
472 p = result; 477 p = result;
473 start = NULL; 478 start = NULL;
474 while (p < result + EXPBUFSIZE - 1 && txt && *txt) { 479 while (p < result + EXPBUFSIZE - 1 && txt && *txt) {
475 *p = *txt; 480 *p = *txt;
476 if (start) { 481 if (start) {
477 if (!is_token_char(*txt)) { 482 if (!is_token_char(*txt)) {
478 if (p - start > 0) { 483 if (p - start > 0) {
479 *p = '\0'; 484 *p = '\0';
480 len = result + EXPBUFSIZE - start - 1; 485 len = result + EXPBUFSIZE - start - 1;
481 p = expand_macro(start, len) - 1; 486 p = expand_macro(start, len) - 1;
482 } 487 }
483 start = NULL; 488 start = NULL;
484 txt--; 489 txt--;
485 } 490 }
486 p++; 491 p++;
487 txt++; 492 txt++;
488 continue; 493 continue;
489 } 494 }
490 if (*txt == '$') { 495 if (*txt == '$') {
491 start = p; 496 start = p;
492 txt++; 497 txt++;
493 continue; 498 continue;
494 } 499 }
495 p++; 500 p++;
496 txt++; 501 txt++;
497 } 502 }
498 *p = '\0'; 503 *p = '\0';
499 if (start && p - start > 0) { 504 if (start && p - start > 0) {
500 len = result + EXPBUFSIZE - start - 1; 505 len = result + EXPBUFSIZE - start - 1;
501 p = expand_macro(start, len); 506 p = expand_macro(start, len);
502 *p = '\0'; 507 *p = '\0';
503 } 508 }
504 return result; 509 return result;
505} 510}
diff --git a/ui-diff.c b/ui-diff.c
index e0a72f7..0dcabe9 100644
--- a/ui-diff.c
+++ b/ui-diff.c
@@ -1,363 +1,371 @@
1/* ui-diff.c: show diff between two blobs 1/* ui-diff.c: show diff between two blobs
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 "html.h" 10#include "html.h"
11#include "ui-shared.h" 11#include "ui-shared.h"
12#include "ui-ssdiff.h" 12#include "ui-ssdiff.h"
13 13
14unsigned char old_rev_sha1[20]; 14unsigned char old_rev_sha1[20];
15unsigned char new_rev_sha1[20]; 15unsigned char new_rev_sha1[20];
16 16
17static int files, slots; 17static int files, slots;
18static int total_adds, total_rems, max_changes; 18static int total_adds, total_rems, max_changes;
19static int lines_added, lines_removed; 19static int lines_added, lines_removed;
20 20
21static struct fileinfo { 21static struct fileinfo {
22 char status; 22 char status;
23 unsigned char old_sha1[20]; 23 unsigned char old_sha1[20];
24 unsigned char new_sha1[20]; 24 unsigned char new_sha1[20];
25 unsigned short old_mode; 25 unsigned short old_mode;
26 unsigned short new_mode; 26 unsigned short new_mode;
27 char *old_path; 27 char *old_path;
28 char *new_path; 28 char *new_path;
29 unsigned int added; 29 unsigned int added;
30 unsigned int removed; 30 unsigned int removed;
31 unsigned long old_size; 31 unsigned long old_size;
32 unsigned long new_size; 32 unsigned long new_size;
33 int binary:1; 33 int binary:1;
34} *items; 34} *items;
35 35
36static int use_ssdiff = 0; 36static int use_ssdiff = 0;
37 37
38static void print_fileinfo(struct fileinfo *info) 38static void print_fileinfo(struct fileinfo *info)
39{ 39{
40 char *class; 40 char *class;
41 41
42 switch (info->status) { 42 switch (info->status) {
43 case DIFF_STATUS_ADDED: 43 case DIFF_STATUS_ADDED:
44 class = "add"; 44 class = "add";
45 break; 45 break;
46 case DIFF_STATUS_COPIED: 46 case DIFF_STATUS_COPIED:
47 class = "cpy"; 47 class = "cpy";
48 break; 48 break;
49 case DIFF_STATUS_DELETED: 49 case DIFF_STATUS_DELETED:
50 class = "del"; 50 class = "del";
51 break; 51 break;
52 case DIFF_STATUS_MODIFIED: 52 case DIFF_STATUS_MODIFIED:
53 class = "upd"; 53 class = "upd";
54 break; 54 break;
55 case DIFF_STATUS_RENAMED: 55 case DIFF_STATUS_RENAMED:
56 class = "mov"; 56 class = "mov";
57 break; 57 break;
58 case DIFF_STATUS_TYPE_CHANGED: 58 case DIFF_STATUS_TYPE_CHANGED:
59 class = "typ"; 59 class = "typ";
60 break; 60 break;
61 case DIFF_STATUS_UNKNOWN: 61 case DIFF_STATUS_UNKNOWN:
62 class = "unk"; 62 class = "unk";
63 break; 63 break;
64 case DIFF_STATUS_UNMERGED: 64 case DIFF_STATUS_UNMERGED:
65 class = "stg"; 65 class = "stg";
66 break; 66 break;
67 default: 67 default:
68 die("bug: unhandled diff status %c", info->status); 68 die("bug: unhandled diff status %c", info->status);
69 } 69 }
70 70
71 html("<tr>"); 71 html("<tr>");
72 htmlf("<td class='mode'>"); 72 htmlf("<td class='mode'>");
73 if (is_null_sha1(info->new_sha1)) { 73 if (is_null_sha1(info->new_sha1)) {
74 cgit_print_filemode(info->old_mode); 74 cgit_print_filemode(info->old_mode);
75 } else { 75 } else {
76 cgit_print_filemode(info->new_mode); 76 cgit_print_filemode(info->new_mode);
77 } 77 }
78 78
79 if (info->old_mode != info->new_mode && 79 if (info->old_mode != info->new_mode &&
80 !is_null_sha1(info->old_sha1) && 80 !is_null_sha1(info->old_sha1) &&
81 !is_null_sha1(info->new_sha1)) { 81 !is_null_sha1(info->new_sha1)) {
82 html("<span class='modechange'>["); 82 html("<span class='modechange'>[");
83 cgit_print_filemode(info->old_mode); 83 cgit_print_filemode(info->old_mode);
84 html("]</span>"); 84 html("]</span>");
85 } 85 }
86 htmlf("</td><td class='%s'>", class); 86 htmlf("</td><td class='%s'>", class);
87 cgit_diff_link(info->new_path, NULL, NULL, ctx.qry.head, ctx.qry.sha1, 87 cgit_diff_link(info->new_path, NULL, NULL, ctx.qry.head, ctx.qry.sha1,
88 ctx.qry.sha2, info->new_path, 0); 88 ctx.qry.sha2, info->new_path, 0);
89 if (info->status == DIFF_STATUS_COPIED || info->status == DIFF_STATUS_RENAMED) 89 if (info->status == DIFF_STATUS_COPIED || info->status == DIFF_STATUS_RENAMED)
90 htmlf(" (%s from %s)", 90 htmlf(" (%s from %s)",
91 info->status == DIFF_STATUS_COPIED ? "copied" : "renamed", 91 info->status == DIFF_STATUS_COPIED ? "copied" : "renamed",
92 info->old_path); 92 info->old_path);
93 html("</td><td class='right'>"); 93 html("</td><td class='right'>");
94 if (info->binary) { 94 if (info->binary) {
95 htmlf("bin</td><td class='graph'>%d -> %d bytes", 95 htmlf("bin</td><td class='graph'>%d -> %d bytes",
96 info->old_size, info->new_size); 96 info->old_size, info->new_size);
97 return; 97 return;
98 } 98 }
99 htmlf("%d", info->added + info->removed); 99 htmlf("%d", info->added + info->removed);
100 html("</td><td class='graph'>"); 100 html("</td><td class='graph'>");
101 htmlf("<table summary='file diffstat' width='%d%%'><tr>", (max_changes > 100 ? 100 : max_changes)); 101 htmlf("<table summary='file diffstat' width='%d%%'><tr>", (max_changes > 100 ? 100 : max_changes));
102 htmlf("<td class='add' style='width: %.1f%%;'/>", 102 htmlf("<td class='add' style='width: %.1f%%;'/>",
103 info->added * 100.0 / max_changes); 103 info->added * 100.0 / max_changes);
104 htmlf("<td class='rem' style='width: %.1f%%;'/>", 104 htmlf("<td class='rem' style='width: %.1f%%;'/>",
105 info->removed * 100.0 / max_changes); 105 info->removed * 100.0 / max_changes);
106 htmlf("<td class='none' style='width: %.1f%%;'/>", 106 htmlf("<td class='none' style='width: %.1f%%;'/>",
107 (max_changes - info->removed - info->added) * 100.0 / max_changes); 107 (max_changes - info->removed - info->added) * 100.0 / max_changes);
108 html("</tr></table></td></tr>\n"); 108 html("</tr></table></td></tr>\n");
109} 109}
110 110
111static void count_diff_lines(char *line, int len) 111static void count_diff_lines(char *line, int len)
112{ 112{
113 if (line && (len > 0)) { 113 if (line && (len > 0)) {
114 if (line[0] == '+') 114 if (line[0] == '+')
115 lines_added++; 115 lines_added++;
116 else if (line[0] == '-') 116 else if (line[0] == '-')
117 lines_removed++; 117 lines_removed++;
118 } 118 }
119} 119}
120 120
121static void inspect_filepair(struct diff_filepair *pair) 121static void inspect_filepair(struct diff_filepair *pair)
122{ 122{
123 int binary = 0; 123 int binary = 0;
124 unsigned long old_size = 0; 124 unsigned long old_size = 0;
125 unsigned long new_size = 0; 125 unsigned long new_size = 0;
126 files++; 126 files++;
127 lines_added = 0; 127 lines_added = 0;
128 lines_removed = 0; 128 lines_removed = 0;
129 cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, &new_size, 129 cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, &new_size,
130 &binary, 0, count_diff_lines); 130 &binary, 0, ctx.qry.ignorews, count_diff_lines);
131 if (files >= slots) { 131 if (files >= slots) {
132 if (slots == 0) 132 if (slots == 0)
133 slots = 4; 133 slots = 4;
134 else 134 else
135 slots = slots * 2; 135 slots = slots * 2;
136 items = xrealloc(items, slots * sizeof(struct fileinfo)); 136 items = xrealloc(items, slots * sizeof(struct fileinfo));
137 } 137 }
138 items[files-1].status = pair->status; 138 items[files-1].status = pair->status;
139 hashcpy(items[files-1].old_sha1, pair->one->sha1); 139 hashcpy(items[files-1].old_sha1, pair->one->sha1);
140 hashcpy(items[files-1].new_sha1, pair->two->sha1); 140 hashcpy(items[files-1].new_sha1, pair->two->sha1);
141 items[files-1].old_mode = pair->one->mode; 141 items[files-1].old_mode = pair->one->mode;
142 items[files-1].new_mode = pair->two->mode; 142 items[files-1].new_mode = pair->two->mode;
143 items[files-1].old_path = xstrdup(pair->one->path); 143 items[files-1].old_path = xstrdup(pair->one->path);
144 items[files-1].new_path = xstrdup(pair->two->path); 144 items[files-1].new_path = xstrdup(pair->two->path);
145 items[files-1].added = lines_added; 145 items[files-1].added = lines_added;
146 items[files-1].removed = lines_removed; 146 items[files-1].removed = lines_removed;
147 items[files-1].old_size = old_size; 147 items[files-1].old_size = old_size;
148 items[files-1].new_size = new_size; 148 items[files-1].new_size = new_size;
149 items[files-1].binary = binary; 149 items[files-1].binary = binary;
150 if (lines_added + lines_removed > max_changes) 150 if (lines_added + lines_removed > max_changes)
151 max_changes = lines_added + lines_removed; 151 max_changes = lines_added + lines_removed;
152 total_adds += lines_added; 152 total_adds += lines_added;
153 total_rems += lines_removed; 153 total_rems += lines_removed;
154} 154}
155 155
156void cgit_print_diffstat(const unsigned char *old_sha1, 156void cgit_print_diffstat(const unsigned char *old_sha1,
157 const unsigned char *new_sha1, const char *prefix) 157 const unsigned char *new_sha1, const char *prefix)
158{ 158{
159 int i, save_context = ctx.qry.context; 159 int i, save_context = ctx.qry.context;
160 160
161 html("<div class='diffstat-header'>"); 161 html("<div class='diffstat-header'>");
162 cgit_diff_link("Diffstat", NULL, NULL, ctx.qry.head, ctx.qry.sha1, 162 cgit_diff_link("Diffstat", NULL, NULL, ctx.qry.head, ctx.qry.sha1,
163 ctx.qry.sha2, NULL, 0); 163 ctx.qry.sha2, NULL, 0);
164 if (prefix) 164 if (prefix)
165 htmlf(" (limited to '%s')", prefix); 165 htmlf(" (limited to '%s')", prefix);
166 html(" ("); 166 html(" (");
167 ctx.qry.context = (save_context > 0 ? save_context : 3) << 1; 167 ctx.qry.context = (save_context > 0 ? save_context : 3) << 1;
168 cgit_self_link("more", NULL, NULL, &ctx); 168 cgit_self_link("more", NULL, NULL, &ctx);
169 html("/"); 169 html("/");
170 ctx.qry.context = (save_context > 3 ? save_context : 3) >> 1; 170 ctx.qry.context = (save_context > 3 ? save_context : 3) >> 1;
171 cgit_self_link("less", NULL, NULL, &ctx); 171 cgit_self_link("less", NULL, NULL, &ctx);
172 ctx.qry.context = save_context; 172 ctx.qry.context = save_context;
173 html(" context)"); 173 html(" context)");
174 html(" (");
175 ctx.qry.ignorews = (ctx.qry.ignorews + 1) % 2;
176 cgit_self_link(ctx.qry.ignorews ? "ignore" : "show", NULL, NULL, &ctx);
177 ctx.qry.ignorews = (ctx.qry.ignorews + 1) % 2;
178 html(" whitespace changes)");
174 html("</div>"); 179 html("</div>");
175 html("<table summary='diffstat' class='diffstat'>"); 180 html("<table summary='diffstat' class='diffstat'>");
176 max_changes = 0; 181 max_changes = 0;
177 cgit_diff_tree(old_sha1, new_sha1, inspect_filepair, prefix); 182 cgit_diff_tree(old_sha1, new_sha1, inspect_filepair, prefix,
183 ctx.qry.ignorews);
178 for(i = 0; i<files; i++) 184 for(i = 0; i<files; i++)
179 print_fileinfo(&items[i]); 185 print_fileinfo(&items[i]);
180 html("</table>"); 186 html("</table>");
181 html("<div class='diffstat-summary'>"); 187 html("<div class='diffstat-summary'>");
182 htmlf("%d files changed, %d insertions, %d deletions", 188 htmlf("%d files changed, %d insertions, %d deletions",
183 files, total_adds, total_rems); 189 files, total_adds, total_rems);
184 html("</div>"); 190 html("</div>");
185} 191}
186 192
187 193
188/* 194/*
189 * print a single line returned from xdiff 195 * print a single line returned from xdiff
190 */ 196 */
191static void print_line(char *line, int len) 197static void print_line(char *line, int len)
192{ 198{
193 char *class = "ctx"; 199 char *class = "ctx";
194 char c = line[len-1]; 200 char c = line[len-1];
195 201
196 if (line[0] == '+') 202 if (line[0] == '+')
197 class = "add"; 203 class = "add";
198 else if (line[0] == '-') 204 else if (line[0] == '-')
199 class = "del"; 205 class = "del";
200 else if (line[0] == '@') 206 else if (line[0] == '@')
201 class = "hunk"; 207 class = "hunk";
202 208
203 htmlf("<div class='%s'>", class); 209 htmlf("<div class='%s'>", class);
204 line[len-1] = '\0'; 210 line[len-1] = '\0';
205 html_txt(line); 211 html_txt(line);
206 html("</div>"); 212 html("</div>");
207 line[len-1] = c; 213 line[len-1] = c;
208} 214}
209 215
210static void header(unsigned char *sha1, char *path1, int mode1, 216static void header(unsigned char *sha1, char *path1, int mode1,
211 unsigned char *sha2, char *path2, int mode2) 217 unsigned char *sha2, char *path2, int mode2)
212{ 218{
213 char *abbrev1, *abbrev2; 219 char *abbrev1, *abbrev2;
214 int subproject; 220 int subproject;
215 221
216 subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2)); 222 subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2));
217 html("<div class='head'>"); 223 html("<div class='head'>");
218 html("diff --git a/"); 224 html("diff --git a/");
219 html_txt(path1); 225 html_txt(path1);
220 html(" b/"); 226 html(" b/");
221 html_txt(path2); 227 html_txt(path2);
222 228
223 if (is_null_sha1(sha1)) 229 if (is_null_sha1(sha1))
224 path1 = "dev/null"; 230 path1 = "dev/null";
225 if (is_null_sha1(sha2)) 231 if (is_null_sha1(sha2))
226 path2 = "dev/null"; 232 path2 = "dev/null";
227 233
228 if (mode1 == 0) 234 if (mode1 == 0)
229 htmlf("<br/>new file mode %.6o", mode2); 235 htmlf("<br/>new file mode %.6o", mode2);
230 236
231 if (mode2 == 0) 237 if (mode2 == 0)
232 htmlf("<br/>deleted file mode %.6o", mode1); 238 htmlf("<br/>deleted file mode %.6o", mode1);
233 239
234 if (!subproject) { 240 if (!subproject) {
235 abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV)); 241 abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV));
236 abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV)); 242 abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV));
237 htmlf("<br/>index %s..%s", abbrev1, abbrev2); 243 htmlf("<br/>index %s..%s", abbrev1, abbrev2);
238 free(abbrev1); 244 free(abbrev1);
239 free(abbrev2); 245 free(abbrev2);
240 if (mode1 != 0 && mode2 != 0) { 246 if (mode1 != 0 && mode2 != 0) {
241 htmlf(" %.6o", mode1); 247 htmlf(" %.6o", mode1);
242 if (mode2 != mode1) 248 if (mode2 != mode1)
243 htmlf("..%.6o", mode2); 249 htmlf("..%.6o", mode2);
244 } 250 }
245 html("<br/>--- a/"); 251 html("<br/>--- a/");
246 if (mode1 != 0) 252 if (mode1 != 0)
247 cgit_tree_link(path1, NULL, NULL, ctx.qry.head, 253 cgit_tree_link(path1, NULL, NULL, ctx.qry.head,
248 sha1_to_hex(old_rev_sha1), path1); 254 sha1_to_hex(old_rev_sha1), path1);
249 else 255 else
250 html_txt(path1); 256 html_txt(path1);
251 html("<br/>+++ b/"); 257 html("<br/>+++ b/");
252 if (mode2 != 0) 258 if (mode2 != 0)
253 cgit_tree_link(path2, NULL, NULL, ctx.qry.head, 259 cgit_tree_link(path2, NULL, NULL, ctx.qry.head,
254 sha1_to_hex(new_rev_sha1), path2); 260 sha1_to_hex(new_rev_sha1), path2);
255 else 261 else
256 html_txt(path2); 262 html_txt(path2);
257 } 263 }
258 html("</div>"); 264 html("</div>");
259} 265}
260 266
261static void print_ssdiff_link() 267static void print_ssdiff_link()
262{ 268{
263 if (!strcmp(ctx.qry.page, "diff")) { 269 if (!strcmp(ctx.qry.page, "diff")) {
264 if (use_ssdiff) 270 if (use_ssdiff)
265 cgit_diff_link("Unidiff", NULL, NULL, ctx.qry.head, 271 cgit_diff_link("Unidiff", NULL, NULL, ctx.qry.head,
266 ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path, 1); 272 ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path, 1);
267 else 273 else
268 cgit_diff_link("Side-by-side diff", NULL, NULL, 274 cgit_diff_link("Side-by-side diff", NULL, NULL,
269 ctx.qry.head, ctx.qry.sha1, 275 ctx.qry.head, ctx.qry.sha1,
270 ctx.qry.sha2, ctx.qry.path, 1); 276 ctx.qry.sha2, ctx.qry.path, 1);
271 } 277 }
272} 278}
273 279
274static void filepair_cb(struct diff_filepair *pair) 280static void filepair_cb(struct diff_filepair *pair)
275{ 281{
276 unsigned long old_size = 0; 282 unsigned long old_size = 0;
277 unsigned long new_size = 0; 283 unsigned long new_size = 0;
278 int binary = 0; 284 int binary = 0;
279 linediff_fn print_line_fn = print_line; 285 linediff_fn print_line_fn = print_line;
280 286
281 if (use_ssdiff) { 287 if (use_ssdiff) {
282 cgit_ssdiff_header_begin(); 288 cgit_ssdiff_header_begin();
283 print_line_fn = cgit_ssdiff_line_cb; 289 print_line_fn = cgit_ssdiff_line_cb;
284 } 290 }
285 header(pair->one->sha1, pair->one->path, pair->one->mode, 291 header(pair->one->sha1, pair->one->path, pair->one->mode,
286 pair->two->sha1, pair->two->path, pair->two->mode); 292 pair->two->sha1, pair->two->path, pair->two->mode);
287 if (use_ssdiff) 293 if (use_ssdiff)
288 cgit_ssdiff_header_end(); 294 cgit_ssdiff_header_end();
289 if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) { 295 if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) {
290 if (S_ISGITLINK(pair->one->mode)) 296 if (S_ISGITLINK(pair->one->mode))
291 print_line_fn(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52); 297 print_line_fn(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52);
292 if (S_ISGITLINK(pair->two->mode)) 298 if (S_ISGITLINK(pair->two->mode))
293 print_line_fn(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52); 299 print_line_fn(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52);
294 if (use_ssdiff) 300 if (use_ssdiff)
295 cgit_ssdiff_footer(); 301 cgit_ssdiff_footer();
296 return; 302 return;
297 } 303 }
298 if (cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, 304 if (cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size,
299 &new_size, &binary, ctx.qry.context, print_line_fn)) 305 &new_size, &binary, ctx.qry.context,
306 ctx.qry.ignorews, print_line_fn))
300 cgit_print_error("Error running diff"); 307 cgit_print_error("Error running diff");
301 if (binary) { 308 if (binary) {
302 if (use_ssdiff) 309 if (use_ssdiff)
303 html("<tr><td colspan='4'>Binary files differ</td></tr>"); 310 html("<tr><td colspan='4'>Binary files differ</td></tr>");
304 else 311 else
305 html("Binary files differ"); 312 html("Binary files differ");
306 } 313 }
307 if (use_ssdiff) 314 if (use_ssdiff)
308 cgit_ssdiff_footer(); 315 cgit_ssdiff_footer();
309} 316}
310 317
311void cgit_print_diff(const char *new_rev, const char *old_rev, const char *prefix) 318void cgit_print_diff(const char *new_rev, const char *old_rev, const char *prefix)
312{ 319{
313 enum object_type type; 320 enum object_type type;
314 unsigned long size; 321 unsigned long size;
315 struct commit *commit, *commit2; 322 struct commit *commit, *commit2;
316 323
317 if (!new_rev) 324 if (!new_rev)
318 new_rev = ctx.qry.head; 325 new_rev = ctx.qry.head;
319 get_sha1(new_rev, new_rev_sha1); 326 get_sha1(new_rev, new_rev_sha1);
320 type = sha1_object_info(new_rev_sha1, &size); 327 type = sha1_object_info(new_rev_sha1, &size);
321 if (type == OBJ_BAD) { 328 if (type == OBJ_BAD) {
322 cgit_print_error(fmt("Bad object name: %s", new_rev)); 329 cgit_print_error(fmt("Bad object name: %s", new_rev));
323 return; 330 return;
324 } 331 }
325 commit = lookup_commit_reference(new_rev_sha1); 332 commit = lookup_commit_reference(new_rev_sha1);
326 if (!commit || parse_commit(commit)) 333 if (!commit || parse_commit(commit))
327 cgit_print_error(fmt("Bad commit: %s", sha1_to_hex(new_rev_sha1))); 334 cgit_print_error(fmt("Bad commit: %s", sha1_to_hex(new_rev_sha1)));
328 335
329 if (old_rev) 336 if (old_rev)
330 get_sha1(old_rev, old_rev_sha1); 337 get_sha1(old_rev, old_rev_sha1);
331 else if (commit->parents && commit->parents->item) 338 else if (commit->parents && commit->parents->item)
332 hashcpy(old_rev_sha1, commit->parents->item->object.sha1); 339 hashcpy(old_rev_sha1, commit->parents->item->object.sha1);
333 else 340 else
334 hashclr(old_rev_sha1); 341 hashclr(old_rev_sha1);
335 342
336 if (!is_null_sha1(old_rev_sha1)) { 343 if (!is_null_sha1(old_rev_sha1)) {
337 type = sha1_object_info(old_rev_sha1, &size); 344 type = sha1_object_info(old_rev_sha1, &size);
338 if (type == OBJ_BAD) { 345 if (type == OBJ_BAD) {
339 cgit_print_error(fmt("Bad object name: %s", sha1_to_hex(old_rev_sha1))); 346 cgit_print_error(fmt("Bad object name: %s", sha1_to_hex(old_rev_sha1)));
340 return; 347 return;
341 } 348 }
342 commit2 = lookup_commit_reference(old_rev_sha1); 349 commit2 = lookup_commit_reference(old_rev_sha1);
343 if (!commit2 || parse_commit(commit2)) 350 if (!commit2 || parse_commit(commit2))
344 cgit_print_error(fmt("Bad commit: %s", sha1_to_hex(old_rev_sha1))); 351 cgit_print_error(fmt("Bad commit: %s", sha1_to_hex(old_rev_sha1)));
345 } 352 }
346 353
347 if ((ctx.qry.ssdiff && !ctx.cfg.ssdiff) || (!ctx.qry.ssdiff && ctx.cfg.ssdiff)) 354 if ((ctx.qry.ssdiff && !ctx.cfg.ssdiff) || (!ctx.qry.ssdiff && ctx.cfg.ssdiff))
348 use_ssdiff = 1; 355 use_ssdiff = 1;
349 356
350 print_ssdiff_link(); 357 print_ssdiff_link();
351 cgit_print_diffstat(old_rev_sha1, new_rev_sha1, prefix); 358 cgit_print_diffstat(old_rev_sha1, new_rev_sha1, prefix);
352 359
353 if (use_ssdiff) { 360 if (use_ssdiff) {
354 html("<table summary='ssdiff' class='ssdiff'>"); 361 html("<table summary='ssdiff' class='ssdiff'>");
355 } else { 362 } else {
356 html("<table summary='diff' class='diff'>"); 363 html("<table summary='diff' class='diff'>");
357 html("<tr><td>"); 364 html("<tr><td>");
358 } 365 }
359 cgit_diff_tree(old_rev_sha1, new_rev_sha1, filepair_cb, prefix); 366 cgit_diff_tree(old_rev_sha1, new_rev_sha1, filepair_cb, prefix,
367 ctx.qry.ignorews);
360 if (!use_ssdiff) 368 if (!use_ssdiff)
361 html("</td></tr>"); 369 html("</td></tr>");
362 html("</table>"); 370 html("</table>");
363} 371}
diff --git a/ui-log.c b/ui-log.c
index 33ec8a9..ee93653 100644
--- a/ui-log.c
+++ b/ui-log.c
@@ -1,228 +1,229 @@
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#include "html.h" 10#include "html.h"
11#include "ui-shared.h" 11#include "ui-shared.h"
12 12
13int files, add_lines, rem_lines; 13int files, add_lines, rem_lines;
14 14
15void count_lines(char *line, int size) 15void count_lines(char *line, int size)
16{ 16{
17 if (size <= 0) 17 if (size <= 0)
18 return; 18 return;
19 19
20 if (line[0] == '+') 20 if (line[0] == '+')
21 add_lines++; 21 add_lines++;
22 22
23 else if (line[0] == '-') 23 else if (line[0] == '-')
24 rem_lines++; 24 rem_lines++;
25} 25}
26 26
27void inspect_files(struct diff_filepair *pair) 27void inspect_files(struct diff_filepair *pair)
28{ 28{
29 unsigned long old_size = 0; 29 unsigned long old_size = 0;
30 unsigned long new_size = 0; 30 unsigned long new_size = 0;
31 int binary = 0; 31 int binary = 0;
32 32
33 files++; 33 files++;
34 if (ctx.repo->enable_log_linecount) 34 if (ctx.repo->enable_log_linecount)
35 cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, 35 cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size,
36 &new_size, &binary, 0, count_lines); 36 &new_size, &binary, 0, ctx.qry.ignorews,
37 count_lines);
37} 38}
38 39
39void show_commit_decorations(struct commit *commit) 40void show_commit_decorations(struct commit *commit)
40{ 41{
41 struct name_decoration *deco; 42 struct name_decoration *deco;
42 static char buf[1024]; 43 static char buf[1024];
43 44
44 buf[sizeof(buf) - 1] = 0; 45 buf[sizeof(buf) - 1] = 0;
45 deco = lookup_decoration(&name_decoration, &commit->object); 46 deco = lookup_decoration(&name_decoration, &commit->object);
46 while (deco) { 47 while (deco) {
47 if (!prefixcmp(deco->name, "refs/heads/")) { 48 if (!prefixcmp(deco->name, "refs/heads/")) {
48 strncpy(buf, deco->name + 11, sizeof(buf) - 1); 49 strncpy(buf, deco->name + 11, sizeof(buf) - 1);
49 cgit_log_link(buf, NULL, "branch-deco", buf, NULL, 50 cgit_log_link(buf, NULL, "branch-deco", buf, NULL,
50 ctx.qry.vpath, 0, NULL, NULL, 51 ctx.qry.vpath, 0, NULL, NULL,
51 ctx.qry.showmsg); 52 ctx.qry.showmsg);
52 } 53 }
53 else if (!prefixcmp(deco->name, "tag: refs/tags/")) { 54 else if (!prefixcmp(deco->name, "tag: refs/tags/")) {
54 strncpy(buf, deco->name + 15, sizeof(buf) - 1); 55 strncpy(buf, deco->name + 15, sizeof(buf) - 1);
55 cgit_tag_link(buf, NULL, "tag-deco", ctx.qry.head, buf); 56 cgit_tag_link(buf, NULL, "tag-deco", ctx.qry.head, buf);
56 } 57 }
57 else if (!prefixcmp(deco->name, "refs/tags/")) { 58 else if (!prefixcmp(deco->name, "refs/tags/")) {
58 strncpy(buf, deco->name + 10, sizeof(buf) - 1); 59 strncpy(buf, deco->name + 10, sizeof(buf) - 1);
59 cgit_tag_link(buf, NULL, "tag-deco", ctx.qry.head, buf); 60 cgit_tag_link(buf, NULL, "tag-deco", ctx.qry.head, buf);
60 } 61 }
61 else if (!prefixcmp(deco->name, "refs/remotes/")) { 62 else if (!prefixcmp(deco->name, "refs/remotes/")) {
62 strncpy(buf, deco->name + 13, sizeof(buf) - 1); 63 strncpy(buf, deco->name + 13, sizeof(buf) - 1);
63 cgit_log_link(buf, NULL, "remote-deco", NULL, 64 cgit_log_link(buf, NULL, "remote-deco", NULL,
64 sha1_to_hex(commit->object.sha1), 65 sha1_to_hex(commit->object.sha1),
65 ctx.qry.vpath, 0, NULL, NULL, 66 ctx.qry.vpath, 0, NULL, NULL,
66 ctx.qry.showmsg); 67 ctx.qry.showmsg);
67 } 68 }
68 else { 69 else {
69 strncpy(buf, deco->name, sizeof(buf) - 1); 70 strncpy(buf, deco->name, sizeof(buf) - 1);
70 cgit_commit_link(buf, NULL, "deco", ctx.qry.head, 71 cgit_commit_link(buf, NULL, "deco", ctx.qry.head,
71 sha1_to_hex(commit->object.sha1), 72 sha1_to_hex(commit->object.sha1),
72 ctx.qry.vpath, 0); 73 ctx.qry.vpath, 0);
73 } 74 }
74 deco = deco->next; 75 deco = deco->next;
75 } 76 }
76} 77}
77 78
78void print_commit(struct commit *commit) 79void print_commit(struct commit *commit)
79{ 80{
80 struct commitinfo *info; 81 struct commitinfo *info;
81 char *tmp; 82 char *tmp;
82 int cols = 2; 83 int cols = 2;
83 84
84 info = cgit_parse_commit(commit); 85 info = cgit_parse_commit(commit);
85 htmlf("<tr%s><td>", 86 htmlf("<tr%s><td>",
86 ctx.qry.showmsg ? " class='logheader'" : ""); 87 ctx.qry.showmsg ? " class='logheader'" : "");
87 tmp = fmt("id=%s", sha1_to_hex(commit->object.sha1)); 88 tmp = fmt("id=%s", sha1_to_hex(commit->object.sha1));
88 tmp = cgit_fileurl(ctx.repo->url, "commit", ctx.qry.vpath, tmp); 89 tmp = cgit_fileurl(ctx.repo->url, "commit", ctx.qry.vpath, tmp);
89 html_link_open(tmp, NULL, NULL); 90 html_link_open(tmp, NULL, NULL);
90 cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE); 91 cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE);
91 html_link_close(); 92 html_link_close();
92 htmlf("</td><td%s>", 93 htmlf("</td><td%s>",
93 ctx.qry.showmsg ? " class='logsubject'" : ""); 94 ctx.qry.showmsg ? " class='logsubject'" : "");
94 cgit_commit_link(info->subject, NULL, NULL, ctx.qry.head, 95 cgit_commit_link(info->subject, NULL, NULL, ctx.qry.head,
95 sha1_to_hex(commit->object.sha1), ctx.qry.vpath, 0); 96 sha1_to_hex(commit->object.sha1), ctx.qry.vpath, 0);
96 show_commit_decorations(commit); 97 show_commit_decorations(commit);
97 html("</td><td>"); 98 html("</td><td>");
98 html_txt(info->author); 99 html_txt(info->author);
99 if (ctx.repo->enable_log_filecount) { 100 if (ctx.repo->enable_log_filecount) {
100 files = 0; 101 files = 0;
101 add_lines = 0; 102 add_lines = 0;
102 rem_lines = 0; 103 rem_lines = 0;
103 cgit_diff_commit(commit, inspect_files); 104 cgit_diff_commit(commit, inspect_files);
104 html("</td><td>"); 105 html("</td><td>");
105 htmlf("%d", files); 106 htmlf("%d", files);
106 if (ctx.repo->enable_log_linecount) { 107 if (ctx.repo->enable_log_linecount) {
107 html("</td><td>"); 108 html("</td><td>");
108 htmlf("-%d/+%d", rem_lines, add_lines); 109 htmlf("-%d/+%d", rem_lines, add_lines);
109 } 110 }
110 } 111 }
111 html("</td></tr>\n"); 112 html("</td></tr>\n");
112 if (ctx.qry.showmsg) { 113 if (ctx.qry.showmsg) {
113 if (ctx.repo->enable_log_filecount) { 114 if (ctx.repo->enable_log_filecount) {
114 cols++; 115 cols++;
115 if (ctx.repo->enable_log_linecount) 116 if (ctx.repo->enable_log_linecount)
116 cols++; 117 cols++;
117 } 118 }
118 htmlf("<tr class='nohover'><td/><td colspan='%d' class='logmsg'>", 119 htmlf("<tr class='nohover'><td/><td colspan='%d' class='logmsg'>",
119 cols); 120 cols);
120 html_txt(info->msg); 121 html_txt(info->msg);
121 html("</td></tr>\n"); 122 html("</td></tr>\n");
122 } 123 }
123 cgit_free_commitinfo(info); 124 cgit_free_commitinfo(info);
124} 125}
125 126
126static const char *disambiguate_ref(const char *ref) 127static const char *disambiguate_ref(const char *ref)
127{ 128{
128 unsigned char sha1[20]; 129 unsigned char sha1[20];
129 const char *longref; 130 const char *longref;
130 131
131 longref = fmt("refs/heads/%s", ref); 132 longref = fmt("refs/heads/%s", ref);
132 if (get_sha1(longref, sha1) == 0) 133 if (get_sha1(longref, sha1) == 0)
133 return longref; 134 return longref;
134 135
135 return ref; 136 return ref;
136} 137}
137 138
138void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern, 139void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern,
139 char *path, int pager) 140 char *path, int pager)
140{ 141{
141 struct rev_info rev; 142 struct rev_info rev;
142 struct commit *commit; 143 struct commit *commit;
143 const char *argv[] = {NULL, NULL, NULL, NULL, NULL}; 144 const char *argv[] = {NULL, NULL, NULL, NULL, NULL};
144 int argc = 2; 145 int argc = 2;
145 int i, columns = 3; 146 int i, columns = 3;
146 147
147 if (!tip) 148 if (!tip)
148 tip = ctx.qry.head; 149 tip = ctx.qry.head;
149 150
150 argv[1] = disambiguate_ref(tip); 151 argv[1] = disambiguate_ref(tip);
151 152
152 if (grep && pattern) { 153 if (grep && pattern) {
153 if (!strcmp(grep, "grep") || !strcmp(grep, "author") || 154 if (!strcmp(grep, "grep") || !strcmp(grep, "author") ||
154 !strcmp(grep, "committer")) 155 !strcmp(grep, "committer"))
155 argv[argc++] = fmt("--%s=%s", grep, pattern); 156 argv[argc++] = fmt("--%s=%s", grep, pattern);
156 if (!strcmp(grep, "range")) 157 if (!strcmp(grep, "range"))
157 argv[1] = pattern; 158 argv[1] = pattern;
158 } 159 }
159 160
160 if (path) { 161 if (path) {
161 argv[argc++] = "--"; 162 argv[argc++] = "--";
162 argv[argc++] = path; 163 argv[argc++] = path;
163 } 164 }
164 init_revisions(&rev, NULL); 165 init_revisions(&rev, NULL);
165 rev.abbrev = DEFAULT_ABBREV; 166 rev.abbrev = DEFAULT_ABBREV;
166 rev.commit_format = CMIT_FMT_DEFAULT; 167 rev.commit_format = CMIT_FMT_DEFAULT;
167 rev.verbose_header = 1; 168 rev.verbose_header = 1;
168 rev.show_root_diff = 0; 169 rev.show_root_diff = 0;
169 setup_revisions(argc, argv, &rev, NULL); 170 setup_revisions(argc, argv, &rev, NULL);
170 load_ref_decorations(DECORATE_FULL_REFS); 171 load_ref_decorations(DECORATE_FULL_REFS);
171 rev.show_decorations = 1; 172 rev.show_decorations = 1;
172 rev.grep_filter.regflags |= REG_ICASE; 173 rev.grep_filter.regflags |= REG_ICASE;
173 compile_grep_patterns(&rev.grep_filter); 174 compile_grep_patterns(&rev.grep_filter);
174 prepare_revision_walk(&rev); 175 prepare_revision_walk(&rev);
175 176
176 if (pager) 177 if (pager)
177 html("<table class='list nowrap'>"); 178 html("<table class='list nowrap'>");
178 179
179 html("<tr class='nohover'><th class='left'>Age</th>" 180 html("<tr class='nohover'><th class='left'>Age</th>"
180 "<th class='left'>Commit message"); 181 "<th class='left'>Commit message");
181 if (pager) { 182 if (pager) {
182 html(" ("); 183 html(" (");
183 cgit_log_link(ctx.qry.showmsg ? "Collapse" : "Expand", NULL, 184 cgit_log_link(ctx.qry.showmsg ? "Collapse" : "Expand", NULL,
184 NULL, ctx.qry.head, ctx.qry.sha1, 185 NULL, ctx.qry.head, ctx.qry.sha1,
185 ctx.qry.vpath, ctx.qry.ofs, ctx.qry.grep, 186 ctx.qry.vpath, ctx.qry.ofs, ctx.qry.grep,
186 ctx.qry.search, ctx.qry.showmsg ? 0 : 1); 187 ctx.qry.search, ctx.qry.showmsg ? 0 : 1);
187 html(")"); 188 html(")");
188 } 189 }
189 html("</th><th class='left'>Author</th>"); 190 html("</th><th class='left'>Author</th>");
190 if (ctx.repo->enable_log_filecount) { 191 if (ctx.repo->enable_log_filecount) {
191 html("<th class='left'>Files</th>"); 192 html("<th class='left'>Files</th>");
192 columns++; 193 columns++;
193 if (ctx.repo->enable_log_linecount) { 194 if (ctx.repo->enable_log_linecount) {
194 html("<th class='left'>Lines</th>"); 195 html("<th class='left'>Lines</th>");
195 columns++; 196 columns++;
196 } 197 }
197 } 198 }
198 html("</tr>\n"); 199 html("</tr>\n");
199 200
200 if (ofs<0) 201 if (ofs<0)
201 ofs = 0; 202 ofs = 0;
202 203
203 for (i = 0; i < ofs && (commit = get_revision(&rev)) != NULL; i++) { 204 for (i = 0; i < ofs && (commit = get_revision(&rev)) != NULL; i++) {
204 free(commit->buffer); 205 free(commit->buffer);
205 commit->buffer = NULL; 206 commit->buffer = NULL;
206 free_commit_list(commit->parents); 207 free_commit_list(commit->parents);
207 commit->parents = NULL; 208 commit->parents = NULL;
208 } 209 }
209 210
210 for (i = 0; i < cnt && (commit = get_revision(&rev)) != NULL; i++) { 211 for (i = 0; i < cnt && (commit = get_revision(&rev)) != NULL; i++) {
211 print_commit(commit); 212 print_commit(commit);
212 free(commit->buffer); 213 free(commit->buffer);
213 commit->buffer = NULL; 214 commit->buffer = NULL;
214 free_commit_list(commit->parents); 215 free_commit_list(commit->parents);
215 commit->parents = NULL; 216 commit->parents = NULL;
216 } 217 }
217 if (pager) { 218 if (pager) {
218 htmlf("</table><div class='pager'>", 219 htmlf("</table><div class='pager'>",
219 columns); 220 columns);
220 if (ofs > 0) { 221 if (ofs > 0) {
221 cgit_log_link("[prev]", NULL, NULL, ctx.qry.head, 222 cgit_log_link("[prev]", NULL, NULL, ctx.qry.head,
222 ctx.qry.sha1, ctx.qry.vpath, 223 ctx.qry.sha1, ctx.qry.vpath,
223 ofs - cnt, ctx.qry.grep, 224 ofs - cnt, ctx.qry.grep,
224 ctx.qry.search, ctx.qry.showmsg); 225 ctx.qry.search, ctx.qry.showmsg);
225 html("&nbsp;"); 226 html("&nbsp;");
226 } 227 }
227 if ((commit = get_revision(&rev)) != NULL) { 228 if ((commit = get_revision(&rev)) != NULL) {
228 cgit_log_link("[next]", NULL, NULL, ctx.qry.head, 229 cgit_log_link("[next]", NULL, NULL, ctx.qry.head,
diff --git a/ui-patch.c b/ui-patch.c
index d13104c..ca008f3 100644
--- a/ui-patch.c
+++ b/ui-patch.c
@@ -1,131 +1,131 @@
1/* ui-patch.c: generate patch view 1/* ui-patch.c: generate patch view
2 * 2 *
3 * Copyright (C) 2007 Lars Hjemli 3 * Copyright (C) 2007 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 "html.h" 10#include "html.h"
11#include "ui-shared.h" 11#include "ui-shared.h"
12 12
13static void print_line(char *line, int len) 13static void print_line(char *line, int len)
14{ 14{
15 char c = line[len-1]; 15 char c = line[len-1];
16 16
17 line[len-1] = '\0'; 17 line[len-1] = '\0';
18 htmlf("%s\n", line); 18 htmlf("%s\n", line);
19 line[len-1] = c; 19 line[len-1] = c;
20} 20}
21 21
22static void header(unsigned char *sha1, char *path1, int mode1, 22static void header(unsigned char *sha1, char *path1, int mode1,
23 unsigned char *sha2, char *path2, int mode2) 23 unsigned char *sha2, char *path2, int mode2)
24{ 24{
25 char *abbrev1, *abbrev2; 25 char *abbrev1, *abbrev2;
26 int subproject; 26 int subproject;
27 27
28 subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2)); 28 subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2));
29 htmlf("diff --git a/%s b/%s\n", path1, path2); 29 htmlf("diff --git a/%s b/%s\n", path1, path2);
30 30
31 if (is_null_sha1(sha1)) 31 if (is_null_sha1(sha1))
32 path1 = "dev/null"; 32 path1 = "dev/null";
33 if (is_null_sha1(sha2)) 33 if (is_null_sha1(sha2))
34 path2 = "dev/null"; 34 path2 = "dev/null";
35 35
36 if (mode1 == 0) 36 if (mode1 == 0)
37 htmlf("new file mode %.6o\n", mode2); 37 htmlf("new file mode %.6o\n", mode2);
38 38
39 if (mode2 == 0) 39 if (mode2 == 0)
40 htmlf("deleted file mode %.6o\n", mode1); 40 htmlf("deleted file mode %.6o\n", mode1);
41 41
42 if (!subproject) { 42 if (!subproject) {
43 abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV)); 43 abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV));
44 abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV)); 44 abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV));
45 htmlf("index %s..%s", abbrev1, abbrev2); 45 htmlf("index %s..%s", abbrev1, abbrev2);
46 free(abbrev1); 46 free(abbrev1);
47 free(abbrev2); 47 free(abbrev2);
48 if (mode1 != 0 && mode2 != 0) { 48 if (mode1 != 0 && mode2 != 0) {
49 htmlf(" %.6o", mode1); 49 htmlf(" %.6o", mode1);
50 if (mode2 != mode1) 50 if (mode2 != mode1)
51 htmlf("..%.6o", mode2); 51 htmlf("..%.6o", mode2);
52 } 52 }
53 htmlf("\n--- a/%s\n", path1); 53 htmlf("\n--- a/%s\n", path1);
54 htmlf("+++ b/%s\n", path2); 54 htmlf("+++ b/%s\n", path2);
55 } 55 }
56} 56}
57 57
58static void filepair_cb(struct diff_filepair *pair) 58static void filepair_cb(struct diff_filepair *pair)
59{ 59{
60 unsigned long old_size = 0; 60 unsigned long old_size = 0;
61 unsigned long new_size = 0; 61 unsigned long new_size = 0;
62 int binary = 0; 62 int binary = 0;
63 63
64 header(pair->one->sha1, pair->one->path, pair->one->mode, 64 header(pair->one->sha1, pair->one->path, pair->one->mode,
65 pair->two->sha1, pair->two->path, pair->two->mode); 65 pair->two->sha1, pair->two->path, pair->two->mode);
66 if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) { 66 if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) {
67 if (S_ISGITLINK(pair->one->mode)) 67 if (S_ISGITLINK(pair->one->mode))
68 print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52); 68 print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52);
69 if (S_ISGITLINK(pair->two->mode)) 69 if (S_ISGITLINK(pair->two->mode))
70 print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52); 70 print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52);
71 return; 71 return;
72 } 72 }
73 if (cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, 73 if (cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size,
74 &new_size, &binary, 0, print_line)) 74 &new_size, &binary, 0, 0, print_line))
75 html("Error running diff"); 75 html("Error running diff");
76 if (binary) 76 if (binary)
77 html("Binary files differ\n"); 77 html("Binary files differ\n");
78} 78}
79 79
80void cgit_print_patch(char *hex, const char *prefix) 80void cgit_print_patch(char *hex, const char *prefix)
81{ 81{
82 struct commit *commit; 82 struct commit *commit;
83 struct commitinfo *info; 83 struct commitinfo *info;
84 unsigned char sha1[20], old_sha1[20]; 84 unsigned char sha1[20], old_sha1[20];
85 char *patchname; 85 char *patchname;
86 86
87 if (!hex) 87 if (!hex)
88 hex = ctx.qry.head; 88 hex = ctx.qry.head;
89 89
90 if (get_sha1(hex, sha1)) { 90 if (get_sha1(hex, sha1)) {
91 cgit_print_error(fmt("Bad object id: %s", hex)); 91 cgit_print_error(fmt("Bad object id: %s", hex));
92 return; 92 return;
93 } 93 }
94 commit = lookup_commit_reference(sha1); 94 commit = lookup_commit_reference(sha1);
95 if (!commit) { 95 if (!commit) {
96 cgit_print_error(fmt("Bad commit reference: %s", hex)); 96 cgit_print_error(fmt("Bad commit reference: %s", hex));
97 return; 97 return;
98 } 98 }
99 info = cgit_parse_commit(commit); 99 info = cgit_parse_commit(commit);
100 100
101 if (commit->parents && commit->parents->item) 101 if (commit->parents && commit->parents->item)
102 hashcpy(old_sha1, commit->parents->item->object.sha1); 102 hashcpy(old_sha1, commit->parents->item->object.sha1);
103 else 103 else
104 hashclr(old_sha1); 104 hashclr(old_sha1);
105 105
106 patchname = fmt("%s.patch", sha1_to_hex(sha1)); 106 patchname = fmt("%s.patch", sha1_to_hex(sha1));
107 ctx.page.mimetype = "text/plain"; 107 ctx.page.mimetype = "text/plain";
108 ctx.page.filename = patchname; 108 ctx.page.filename = patchname;
109 cgit_print_http_headers(&ctx); 109 cgit_print_http_headers(&ctx);
110 htmlf("From %s Mon Sep 17 00:00:00 2001\n", sha1_to_hex(sha1)); 110 htmlf("From %s Mon Sep 17 00:00:00 2001\n", sha1_to_hex(sha1));
111 htmlf("From: %s", info->author); 111 htmlf("From: %s", info->author);
112 if (!ctx.cfg.noplainemail) { 112 if (!ctx.cfg.noplainemail) {
113 htmlf(" %s", info->author_email); 113 htmlf(" %s", info->author_email);
114 } 114 }
115 html("\n"); 115 html("\n");
116 html("Date: "); 116 html("Date: ");
117 cgit_print_date(info->author_date, "%a, %d %b %Y %H:%M:%S %z%n", ctx.cfg.local_time); 117 cgit_print_date(info->author_date, "%a, %d %b %Y %H:%M:%S %z%n", ctx.cfg.local_time);
118 htmlf("Subject: %s\n\n", info->subject); 118 htmlf("Subject: %s\n\n", info->subject);
119 if (info->msg && *info->msg) { 119 if (info->msg && *info->msg) {
120 htmlf("%s", info->msg); 120 htmlf("%s", info->msg);
121 if (info->msg[strlen(info->msg) - 1] != '\n') 121 if (info->msg[strlen(info->msg) - 1] != '\n')
122 html("\n"); 122 html("\n");
123 } 123 }
124 html("---\n"); 124 html("---\n");
125 if (prefix) 125 if (prefix)
126 htmlf("(limited to '%s')\n\n", prefix); 126 htmlf("(limited to '%s')\n\n", prefix);
127 cgit_diff_tree(old_sha1, sha1, filepair_cb, prefix); 127 cgit_diff_tree(old_sha1, sha1, filepair_cb, prefix, 0);
128 html("--\n"); 128 html("--\n");
129 htmlf("cgit %s\n", CGIT_VERSION); 129 htmlf("cgit %s\n", CGIT_VERSION);
130 cgit_free_commitinfo(info); 130 cgit_free_commitinfo(info);
131} 131}
diff --git a/ui-shared.c b/ui-shared.c
index c398d7a..ae29615 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -160,432 +160,442 @@ static void site_url(const char *page, const char *search, int ofs)
160 } 160 }
161} 161}
162 162
163static void site_link(const char *page, const char *name, const char *title, 163static void site_link(const char *page, const char *name, const char *title,
164 const char *class, const char *search, int ofs) 164 const char *class, const char *search, int ofs)
165{ 165{
166 html("<a"); 166 html("<a");
167 if (title) { 167 if (title) {
168 html(" title='"); 168 html(" title='");
169 html_attr(title); 169 html_attr(title);
170 html("'"); 170 html("'");
171 } 171 }
172 if (class) { 172 if (class) {
173 html(" class='"); 173 html(" class='");
174 html_attr(class); 174 html_attr(class);
175 html("'"); 175 html("'");
176 } 176 }
177 html(" href='"); 177 html(" href='");
178 site_url(page, search, ofs); 178 site_url(page, search, ofs);
179 html("'>"); 179 html("'>");
180 html_txt(name); 180 html_txt(name);
181 html("</a>"); 181 html("</a>");
182} 182}
183 183
184void cgit_index_link(const char *name, const char *title, const char *class, 184void cgit_index_link(const char *name, const char *title, const char *class,
185 const char *pattern, int ofs) 185 const char *pattern, int ofs)
186{ 186{
187 site_link(NULL, name, title, class, pattern, ofs); 187 site_link(NULL, name, title, class, pattern, ofs);
188} 188}
189 189
190static char *repolink(const char *title, const char *class, const char *page, 190static char *repolink(const char *title, const char *class, const char *page,
191 const char *head, const char *path) 191 const char *head, const char *path)
192{ 192{
193 char *delim = "?"; 193 char *delim = "?";
194 194
195 html("<a"); 195 html("<a");
196 if (title) { 196 if (title) {
197 html(" title='"); 197 html(" title='");
198 html_attr(title); 198 html_attr(title);
199 html("'"); 199 html("'");
200 } 200 }
201 if (class) { 201 if (class) {
202 html(" class='"); 202 html(" class='");
203 html_attr(class); 203 html_attr(class);
204 html("'"); 204 html("'");
205 } 205 }
206 html(" href='"); 206 html(" href='");
207 if (ctx.cfg.virtual_root) { 207 if (ctx.cfg.virtual_root) {
208 html_url_path(ctx.cfg.virtual_root); 208 html_url_path(ctx.cfg.virtual_root);
209 if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/') 209 if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/')
210 html("/"); 210 html("/");
211 html_url_path(ctx.repo->url); 211 html_url_path(ctx.repo->url);
212 if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/') 212 if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/')
213 html("/"); 213 html("/");
214 if (page) { 214 if (page) {
215 html_url_path(page); 215 html_url_path(page);
216 html("/"); 216 html("/");
217 if (path) 217 if (path)
218 html_url_path(path); 218 html_url_path(path);
219 } 219 }
220 } else { 220 } else {
221 html(ctx.cfg.script_name); 221 html(ctx.cfg.script_name);
222 html("?url="); 222 html("?url=");
223 html_url_arg(ctx.repo->url); 223 html_url_arg(ctx.repo->url);
224 if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/') 224 if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/')
225 html("/"); 225 html("/");
226 if (page) { 226 if (page) {
227 html_url_arg(page); 227 html_url_arg(page);
228 html("/"); 228 html("/");
229 if (path) 229 if (path)
230 html_url_arg(path); 230 html_url_arg(path);
231 } 231 }
232 delim = "&amp;"; 232 delim = "&amp;";
233 } 233 }
234 if (head && strcmp(head, ctx.repo->defbranch)) { 234 if (head && strcmp(head, ctx.repo->defbranch)) {
235 html(delim); 235 html(delim);
236 html("h="); 236 html("h=");
237 html_url_arg(head); 237 html_url_arg(head);
238 delim = "&amp;"; 238 delim = "&amp;";
239 } 239 }
240 return fmt("%s", delim); 240 return fmt("%s", delim);
241} 241}
242 242
243static void reporevlink(const char *page, const char *name, const char *title, 243static void reporevlink(const char *page, const char *name, const char *title,
244 const char *class, const char *head, const char *rev, 244 const char *class, const char *head, const char *rev,
245 const char *path) 245 const char *path)
246{ 246{
247 char *delim; 247 char *delim;
248 248
249 delim = repolink(title, class, page, head, path); 249 delim = repolink(title, class, page, head, path);
250 if (rev && ctx.qry.head != NULL && strcmp(rev, ctx.qry.head)) { 250 if (rev && ctx.qry.head != NULL && strcmp(rev, ctx.qry.head)) {
251 html(delim); 251 html(delim);
252 html("id="); 252 html("id=");
253 html_url_arg(rev); 253 html_url_arg(rev);
254 } 254 }
255 html("'>"); 255 html("'>");
256 html_txt(name); 256 html_txt(name);
257 html("</a>"); 257 html("</a>");
258} 258}
259 259
260void cgit_summary_link(const char *name, const char *title, const char *class, 260void cgit_summary_link(const char *name, const char *title, const char *class,
261 const char *head) 261 const char *head)
262{ 262{
263 reporevlink(NULL, name, title, class, head, NULL, NULL); 263 reporevlink(NULL, name, title, class, head, NULL, NULL);
264} 264}
265 265
266void cgit_tag_link(const char *name, const char *title, const char *class, 266void cgit_tag_link(const char *name, const char *title, const char *class,
267 const char *head, const char *rev) 267 const char *head, const char *rev)
268{ 268{
269 reporevlink("tag", name, title, class, head, rev, NULL); 269 reporevlink("tag", name, title, class, head, rev, NULL);
270} 270}
271 271
272void cgit_tree_link(const char *name, const char *title, const char *class, 272void cgit_tree_link(const char *name, const char *title, const char *class,
273 const char *head, const char *rev, const char *path) 273 const char *head, const char *rev, const char *path)
274{ 274{
275 reporevlink("tree", name, title, class, head, rev, path); 275 reporevlink("tree", name, title, class, head, rev, path);
276} 276}
277 277
278void cgit_plain_link(const char *name, const char *title, const char *class, 278void cgit_plain_link(const char *name, const char *title, const char *class,
279 const char *head, const char *rev, const char *path) 279 const char *head, const char *rev, const char *path)
280{ 280{
281 reporevlink("plain", name, title, class, head, rev, path); 281 reporevlink("plain", name, title, class, head, rev, path);
282} 282}
283 283
284void cgit_log_link(const char *name, const char *title, const char *class, 284void cgit_log_link(const char *name, const char *title, const char *class,
285 const char *head, const char *rev, const char *path, 285 const char *head, const char *rev, const char *path,
286 int ofs, const char *grep, const char *pattern, int showmsg) 286 int ofs, const char *grep, const char *pattern, int showmsg)
287{ 287{
288 char *delim; 288 char *delim;
289 289
290 delim = repolink(title, class, "log", head, path); 290 delim = repolink(title, class, "log", head, path);
291 if (rev && strcmp(rev, ctx.qry.head)) { 291 if (rev && strcmp(rev, ctx.qry.head)) {
292 html(delim); 292 html(delim);
293 html("id="); 293 html("id=");
294 html_url_arg(rev); 294 html_url_arg(rev);
295 delim = "&"; 295 delim = "&";
296 } 296 }
297 if (grep && pattern) { 297 if (grep && pattern) {
298 html(delim); 298 html(delim);
299 html("qt="); 299 html("qt=");
300 html_url_arg(grep); 300 html_url_arg(grep);
301 delim = "&"; 301 delim = "&";
302 html(delim); 302 html(delim);
303 html("q="); 303 html("q=");
304 html_url_arg(pattern); 304 html_url_arg(pattern);
305 } 305 }
306 if (ofs > 0) { 306 if (ofs > 0) {
307 html(delim); 307 html(delim);
308 html("ofs="); 308 html("ofs=");
309 htmlf("%d", ofs); 309 htmlf("%d", ofs);
310 delim = "&"; 310 delim = "&";
311 } 311 }
312 if (showmsg) { 312 if (showmsg) {
313 html(delim); 313 html(delim);
314 html("showmsg=1"); 314 html("showmsg=1");
315 } 315 }
316 html("'>"); 316 html("'>");
317 html_txt(name); 317 html_txt(name);
318 html("</a>"); 318 html("</a>");
319} 319}
320 320
321void cgit_commit_link(char *name, const char *title, const char *class, 321void cgit_commit_link(char *name, const char *title, const char *class,
322 const char *head, const char *rev, const char *path, 322 const char *head, const char *rev, const char *path,
323 int toggle_ssdiff) 323 int toggle_ssdiff)
324{ 324{
325 if (strlen(name) > ctx.cfg.max_msg_len && ctx.cfg.max_msg_len >= 15) { 325 if (strlen(name) > ctx.cfg.max_msg_len && ctx.cfg.max_msg_len >= 15) {
326 name[ctx.cfg.max_msg_len] = '\0'; 326 name[ctx.cfg.max_msg_len] = '\0';
327 name[ctx.cfg.max_msg_len - 1] = '.'; 327 name[ctx.cfg.max_msg_len - 1] = '.';
328 name[ctx.cfg.max_msg_len - 2] = '.'; 328 name[ctx.cfg.max_msg_len - 2] = '.';
329 name[ctx.cfg.max_msg_len - 3] = '.'; 329 name[ctx.cfg.max_msg_len - 3] = '.';
330 } 330 }
331 331
332 char *delim; 332 char *delim;
333 333
334 delim = repolink(title, class, "commit", head, path); 334 delim = repolink(title, class, "commit", head, path);
335 if (rev && strcmp(rev, ctx.qry.head)) { 335 if (rev && strcmp(rev, ctx.qry.head)) {
336 html(delim); 336 html(delim);
337 html("id="); 337 html("id=");
338 html_url_arg(rev); 338 html_url_arg(rev);
339 delim = "&amp;"; 339 delim = "&amp;";
340 } 340 }
341 if ((ctx.qry.ssdiff && !toggle_ssdiff) || (!ctx.qry.ssdiff && toggle_ssdiff)) { 341 if ((ctx.qry.ssdiff && !toggle_ssdiff) || (!ctx.qry.ssdiff && toggle_ssdiff)) {
342 html(delim); 342 html(delim);
343 html("ss=1"); 343 html("ss=1");
344 delim = "&amp;"; 344 delim = "&amp;";
345 } 345 }
346 if (ctx.qry.context > 0 && ctx.qry.context != 3) { 346 if (ctx.qry.context > 0 && ctx.qry.context != 3) {
347 html(delim); 347 html(delim);
348 html("context="); 348 html("context=");
349 htmlf("%d", ctx.qry.context); 349 htmlf("%d", ctx.qry.context);
350 delim = "&amp;"; 350 delim = "&amp;";
351 } 351 }
352 if (ctx.qry.ignorews) {
353 html(delim);
354 html("ignorews=1");
355 delim = "&amp;";
356 }
352 html("'>"); 357 html("'>");
353 html_txt(name); 358 html_txt(name);
354 html("</a>"); 359 html("</a>");
355} 360}
356 361
357void cgit_refs_link(const char *name, const char *title, const char *class, 362void cgit_refs_link(const char *name, const char *title, const char *class,
358 const char *head, const char *rev, const char *path) 363 const char *head, const char *rev, const char *path)
359{ 364{
360 reporevlink("refs", name, title, class, head, rev, path); 365 reporevlink("refs", name, title, class, head, rev, path);
361} 366}
362 367
363void cgit_snapshot_link(const char *name, const char *title, const char *class, 368void cgit_snapshot_link(const char *name, const char *title, const char *class,
364 const char *head, const char *rev, 369 const char *head, const char *rev,
365 const char *archivename) 370 const char *archivename)
366{ 371{
367 reporevlink("snapshot", name, title, class, head, rev, archivename); 372 reporevlink("snapshot", name, title, class, head, rev, archivename);
368} 373}
369 374
370void cgit_diff_link(const char *name, const char *title, const char *class, 375void cgit_diff_link(const char *name, const char *title, const char *class,
371 const char *head, const char *new_rev, const char *old_rev, 376 const char *head, const char *new_rev, const char *old_rev,
372 const char *path, int toggle_ssdiff) 377 const char *path, int toggle_ssdiff)
373{ 378{
374 char *delim; 379 char *delim;
375 380
376 delim = repolink(title, class, "diff", head, path); 381 delim = repolink(title, class, "diff", head, path);
377 if (new_rev && ctx.qry.head != NULL && strcmp(new_rev, ctx.qry.head)) { 382 if (new_rev && ctx.qry.head != NULL && strcmp(new_rev, ctx.qry.head)) {
378 html(delim); 383 html(delim);
379 html("id="); 384 html("id=");
380 html_url_arg(new_rev); 385 html_url_arg(new_rev);
381 delim = "&amp;"; 386 delim = "&amp;";
382 } 387 }
383 if (old_rev) { 388 if (old_rev) {
384 html(delim); 389 html(delim);
385 html("id2="); 390 html("id2=");
386 html_url_arg(old_rev); 391 html_url_arg(old_rev);
387 delim = "&amp;"; 392 delim = "&amp;";
388 } 393 }
389 if ((ctx.qry.ssdiff && !toggle_ssdiff) || (!ctx.qry.ssdiff && toggle_ssdiff)) { 394 if ((ctx.qry.ssdiff && !toggle_ssdiff) || (!ctx.qry.ssdiff && toggle_ssdiff)) {
390 html(delim); 395 html(delim);
391 html("ss=1"); 396 html("ss=1");
392 delim = "&amp;"; 397 delim = "&amp;";
393 } 398 }
394 if (ctx.qry.context > 0 && ctx.qry.context != 3) { 399 if (ctx.qry.context > 0 && ctx.qry.context != 3) {
395 html(delim); 400 html(delim);
396 html("context="); 401 html("context=");
397 htmlf("%d", ctx.qry.context); 402 htmlf("%d", ctx.qry.context);
398 delim = "&amp;"; 403 delim = "&amp;";
399 } 404 }
405 if (ctx.qry.ignorews) {
406 html(delim);
407 html("ignorews=1");
408 delim = "&amp;";
409 }
400 html("'>"); 410 html("'>");
401 html_txt(name); 411 html_txt(name);
402 html("</a>"); 412 html("</a>");
403} 413}
404 414
405void cgit_patch_link(const char *name, const char *title, const char *class, 415void cgit_patch_link(const char *name, const char *title, const char *class,
406 const char *head, const char *rev, const char *path) 416 const char *head, const char *rev, const char *path)
407{ 417{
408 reporevlink("patch", name, title, class, head, rev, path); 418 reporevlink("patch", name, title, class, head, rev, path);
409} 419}
410 420
411void cgit_stats_link(const char *name, const char *title, const char *class, 421void cgit_stats_link(const char *name, const char *title, const char *class,
412 const char *head, const char *path) 422 const char *head, const char *path)
413{ 423{
414 reporevlink("stats", name, title, class, head, NULL, path); 424 reporevlink("stats", name, title, class, head, NULL, path);
415} 425}
416 426
417void cgit_self_link(char *name, const char *title, const char *class, 427void cgit_self_link(char *name, const char *title, const char *class,
418 struct cgit_context *ctx) 428 struct cgit_context *ctx)
419{ 429{
420 if (!strcmp(ctx->qry.page, "repolist")) 430 if (!strcmp(ctx->qry.page, "repolist"))
421 return cgit_index_link(name, title, class, ctx->qry.search, 431 return cgit_index_link(name, title, class, ctx->qry.search,
422 ctx->qry.ofs); 432 ctx->qry.ofs);
423 else if (!strcmp(ctx->qry.page, "summary")) 433 else if (!strcmp(ctx->qry.page, "summary"))
424 return cgit_summary_link(name, title, class, ctx->qry.head); 434 return cgit_summary_link(name, title, class, ctx->qry.head);
425 else if (!strcmp(ctx->qry.page, "tag")) 435 else if (!strcmp(ctx->qry.page, "tag"))
426 return cgit_tag_link(name, title, class, ctx->qry.head, 436 return cgit_tag_link(name, title, class, ctx->qry.head,
427 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL); 437 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL);
428 else if (!strcmp(ctx->qry.page, "tree")) 438 else if (!strcmp(ctx->qry.page, "tree"))
429 return cgit_tree_link(name, title, class, ctx->qry.head, 439 return cgit_tree_link(name, title, class, ctx->qry.head,
430 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL, 440 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
431 ctx->qry.path); 441 ctx->qry.path);
432 else if (!strcmp(ctx->qry.page, "plain")) 442 else if (!strcmp(ctx->qry.page, "plain"))
433 return cgit_plain_link(name, title, class, ctx->qry.head, 443 return cgit_plain_link(name, title, class, ctx->qry.head,
434 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL, 444 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
435 ctx->qry.path); 445 ctx->qry.path);
436 else if (!strcmp(ctx->qry.page, "log")) 446 else if (!strcmp(ctx->qry.page, "log"))
437 return cgit_log_link(name, title, class, ctx->qry.head, 447 return cgit_log_link(name, title, class, ctx->qry.head,
438 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL, 448 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
439 ctx->qry.path, ctx->qry.ofs, 449 ctx->qry.path, ctx->qry.ofs,
440 ctx->qry.grep, ctx->qry.search, 450 ctx->qry.grep, ctx->qry.search,
441 ctx->qry.showmsg); 451 ctx->qry.showmsg);
442 else if (!strcmp(ctx->qry.page, "commit")) 452 else if (!strcmp(ctx->qry.page, "commit"))
443 return cgit_commit_link(name, title, class, ctx->qry.head, 453 return cgit_commit_link(name, title, class, ctx->qry.head,
444 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL, 454 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
445 ctx->qry.path, 0); 455 ctx->qry.path, 0);
446 else if (!strcmp(ctx->qry.page, "patch")) 456 else if (!strcmp(ctx->qry.page, "patch"))
447 return cgit_patch_link(name, title, class, ctx->qry.head, 457 return cgit_patch_link(name, title, class, ctx->qry.head,
448 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL, 458 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
449 ctx->qry.path); 459 ctx->qry.path);
450 else if (!strcmp(ctx->qry.page, "refs")) 460 else if (!strcmp(ctx->qry.page, "refs"))
451 return cgit_refs_link(name, title, class, ctx->qry.head, 461 return cgit_refs_link(name, title, class, ctx->qry.head,
452 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL, 462 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
453 ctx->qry.path); 463 ctx->qry.path);
454 else if (!strcmp(ctx->qry.page, "snapshot")) 464 else if (!strcmp(ctx->qry.page, "snapshot"))
455 return cgit_snapshot_link(name, title, class, ctx->qry.head, 465 return cgit_snapshot_link(name, title, class, ctx->qry.head,
456 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL, 466 ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
457 ctx->qry.path); 467 ctx->qry.path);
458 else if (!strcmp(ctx->qry.page, "diff")) 468 else if (!strcmp(ctx->qry.page, "diff"))
459 return cgit_diff_link(name, title, class, ctx->qry.head, 469 return cgit_diff_link(name, title, class, ctx->qry.head,
460 ctx->qry.sha1, ctx->qry.sha2, 470 ctx->qry.sha1, ctx->qry.sha2,
461 ctx->qry.path, 0); 471 ctx->qry.path, 0);
462 else if (!strcmp(ctx->qry.page, "stats")) 472 else if (!strcmp(ctx->qry.page, "stats"))
463 return cgit_stats_link(name, title, class, ctx->qry.head, 473 return cgit_stats_link(name, title, class, ctx->qry.head,
464 ctx->qry.path); 474 ctx->qry.path);
465 475
466 /* Don't known how to make link for this page */ 476 /* Don't known how to make link for this page */
467 repolink(title, class, ctx->qry.page, ctx->qry.head, ctx->qry.path); 477 repolink(title, class, ctx->qry.page, ctx->qry.head, ctx->qry.path);
468 html("><!-- cgit_self_link() doesn't know how to make link for page '"); 478 html("><!-- cgit_self_link() doesn't know how to make link for page '");
469 html_txt(ctx->qry.page); 479 html_txt(ctx->qry.page);
470 html("' -->"); 480 html("' -->");
471 html_txt(name); 481 html_txt(name);
472 html("</a>"); 482 html("</a>");
473} 483}
474 484
475void cgit_object_link(struct object *obj) 485void cgit_object_link(struct object *obj)
476{ 486{
477 char *page, *shortrev, *fullrev, *name; 487 char *page, *shortrev, *fullrev, *name;
478 488
479 fullrev = sha1_to_hex(obj->sha1); 489 fullrev = sha1_to_hex(obj->sha1);
480 shortrev = xstrdup(fullrev); 490 shortrev = xstrdup(fullrev);
481 shortrev[10] = '\0'; 491 shortrev[10] = '\0';
482 if (obj->type == OBJ_COMMIT) { 492 if (obj->type == OBJ_COMMIT) {
483 cgit_commit_link(fmt("commit %s...", shortrev), NULL, NULL, 493 cgit_commit_link(fmt("commit %s...", shortrev), NULL, NULL,
484 ctx.qry.head, fullrev, NULL, 0); 494 ctx.qry.head, fullrev, NULL, 0);
485 return; 495 return;
486 } else if (obj->type == OBJ_TREE) 496 } else if (obj->type == OBJ_TREE)
487 page = "tree"; 497 page = "tree";
488 else if (obj->type == OBJ_TAG) 498 else if (obj->type == OBJ_TAG)
489 page = "tag"; 499 page = "tag";
490 else 500 else
491 page = "blob"; 501 page = "blob";
492 name = fmt("%s %s...", typename(obj->type), shortrev); 502 name = fmt("%s %s...", typename(obj->type), shortrev);
493 reporevlink(page, name, NULL, NULL, ctx.qry.head, fullrev, NULL); 503 reporevlink(page, name, NULL, NULL, ctx.qry.head, fullrev, NULL);
494} 504}
495 505
496void cgit_print_date(time_t secs, const char *format, int local_time) 506void cgit_print_date(time_t secs, const char *format, int local_time)
497{ 507{
498 char buf[64]; 508 char buf[64];
499 struct tm *time; 509 struct tm *time;
500 510
501 if (!secs) 511 if (!secs)
502 return; 512 return;
503 if(local_time) 513 if(local_time)
504 time = localtime(&secs); 514 time = localtime(&secs);
505 else 515 else
506 time = gmtime(&secs); 516 time = gmtime(&secs);
507 strftime(buf, sizeof(buf)-1, format, time); 517 strftime(buf, sizeof(buf)-1, format, time);
508 html_txt(buf); 518 html_txt(buf);
509} 519}
510 520
511void cgit_print_age(time_t t, time_t max_relative, const char *format) 521void cgit_print_age(time_t t, time_t max_relative, const char *format)
512{ 522{
513 time_t now, secs; 523 time_t now, secs;
514 524
515 if (!t) 525 if (!t)
516 return; 526 return;
517 time(&now); 527 time(&now);
518 secs = now - t; 528 secs = now - t;
519 529
520 if (secs > max_relative && max_relative >= 0) { 530 if (secs > max_relative && max_relative >= 0) {
521 cgit_print_date(t, format, ctx.cfg.local_time); 531 cgit_print_date(t, format, ctx.cfg.local_time);
522 return; 532 return;
523 } 533 }
524 534
525 if (secs < TM_HOUR * 2) { 535 if (secs < TM_HOUR * 2) {
526 htmlf("<span class='age-mins'>%.0f min.</span>", 536 htmlf("<span class='age-mins'>%.0f min.</span>",
527 secs * 1.0 / TM_MIN); 537 secs * 1.0 / TM_MIN);
528 return; 538 return;
529 } 539 }
530 if (secs < TM_DAY * 2) { 540 if (secs < TM_DAY * 2) {
531 htmlf("<span class='age-hours'>%.0f hours</span>", 541 htmlf("<span class='age-hours'>%.0f hours</span>",
532 secs * 1.0 / TM_HOUR); 542 secs * 1.0 / TM_HOUR);
533 return; 543 return;
534 } 544 }
535 if (secs < TM_WEEK * 2) { 545 if (secs < TM_WEEK * 2) {
536 htmlf("<span class='age-days'>%.0f days</span>", 546 htmlf("<span class='age-days'>%.0f days</span>",
537 secs * 1.0 / TM_DAY); 547 secs * 1.0 / TM_DAY);
538 return; 548 return;
539 } 549 }
540 if (secs < TM_MONTH * 2) { 550 if (secs < TM_MONTH * 2) {
541 htmlf("<span class='age-weeks'>%.0f weeks</span>", 551 htmlf("<span class='age-weeks'>%.0f weeks</span>",
542 secs * 1.0 / TM_WEEK); 552 secs * 1.0 / TM_WEEK);
543 return; 553 return;
544 } 554 }
545 if (secs < TM_YEAR * 2) { 555 if (secs < TM_YEAR * 2) {
546 htmlf("<span class='age-months'>%.0f months</span>", 556 htmlf("<span class='age-months'>%.0f months</span>",
547 secs * 1.0 / TM_MONTH); 557 secs * 1.0 / TM_MONTH);
548 return; 558 return;
549 } 559 }
550 htmlf("<span class='age-years'>%.0f years</span>", 560 htmlf("<span class='age-years'>%.0f years</span>",
551 secs * 1.0 / TM_YEAR); 561 secs * 1.0 / TM_YEAR);
552} 562}
553 563
554void cgit_print_http_headers(struct cgit_context *ctx) 564void cgit_print_http_headers(struct cgit_context *ctx)
555{ 565{
556 if (ctx->env.no_http && !strcmp(ctx->env.no_http, "1")) 566 if (ctx->env.no_http && !strcmp(ctx->env.no_http, "1"))
557 return; 567 return;
558 568
559 if (ctx->page.status) 569 if (ctx->page.status)
560 htmlf("Status: %d %s\n", ctx->page.status, ctx->page.statusmsg); 570 htmlf("Status: %d %s\n", ctx->page.status, ctx->page.statusmsg);
561 if (ctx->page.mimetype && ctx->page.charset) 571 if (ctx->page.mimetype && ctx->page.charset)
562 htmlf("Content-Type: %s; charset=%s\n", ctx->page.mimetype, 572 htmlf("Content-Type: %s; charset=%s\n", ctx->page.mimetype,
563 ctx->page.charset); 573 ctx->page.charset);
564 else if (ctx->page.mimetype) 574 else if (ctx->page.mimetype)
565 htmlf("Content-Type: %s\n", ctx->page.mimetype); 575 htmlf("Content-Type: %s\n", ctx->page.mimetype);
566 if (ctx->page.size) 576 if (ctx->page.size)
567 htmlf("Content-Length: %ld\n", ctx->page.size); 577 htmlf("Content-Length: %ld\n", ctx->page.size);
568 if (ctx->page.filename) 578 if (ctx->page.filename)
569 htmlf("Content-Disposition: inline; filename=\"%s\"\n", 579 htmlf("Content-Disposition: inline; filename=\"%s\"\n",
570 ctx->page.filename); 580 ctx->page.filename);
571 htmlf("Last-Modified: %s\n", http_date(ctx->page.modified)); 581 htmlf("Last-Modified: %s\n", http_date(ctx->page.modified));
572 htmlf("Expires: %s\n", http_date(ctx->page.expires)); 582 htmlf("Expires: %s\n", http_date(ctx->page.expires));
573 if (ctx->page.etag) 583 if (ctx->page.etag)
574 htmlf("ETag: \"%s\"\n", ctx->page.etag); 584 htmlf("ETag: \"%s\"\n", ctx->page.etag);
575 html("\n"); 585 html("\n");
576 if (ctx->env.request_method && !strcmp(ctx->env.request_method, "HEAD")) 586 if (ctx->env.request_method && !strcmp(ctx->env.request_method, "HEAD"))
577 exit(0); 587 exit(0);
578} 588}
579 589
580void cgit_print_docstart(struct cgit_context *ctx) 590void cgit_print_docstart(struct cgit_context *ctx)
581{ 591{
582 if (ctx->cfg.embedded) { 592 if (ctx->cfg.embedded) {
583 if (ctx->cfg.header) 593 if (ctx->cfg.header)
584 html_include(ctx->cfg.header); 594 html_include(ctx->cfg.header);
585 return; 595 return;
586 } 596 }
587 597
588 char *host = cgit_hosturl(); 598 char *host = cgit_hosturl();
589 html(cgit_doctype); 599 html(cgit_doctype);
590 html("<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en' lang='en'>\n"); 600 html("<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en' lang='en'>\n");
591 html("<head>\n"); 601 html("<head>\n");