summaryrefslogtreecommitdiffabout
Unidiff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--shared.c9
-rw-r--r--ui-shared.c2
2 files changed, 8 insertions, 3 deletions
diff --git a/shared.c b/shared.c
index d7b2d5a..a27ab30 100644
--- a/shared.c
+++ b/shared.c
@@ -25,393 +25,398 @@ int chk_positive(int result, char *msg)
25 die("%s: %s", msg, strerror(errno)); 25 die("%s: %s", msg, strerror(errno));
26 return result; 26 return result;
27} 27}
28 28
29int chk_non_negative(int result, char *msg) 29int chk_non_negative(int result, char *msg)
30{ 30{
31 if (result < 0) 31 if (result < 0)
32 die("%s: %s",msg, strerror(errno)); 32 die("%s: %s",msg, strerror(errno));
33 return result; 33 return result;
34} 34}
35 35
36struct cgit_repo *cgit_add_repo(const char *url) 36struct cgit_repo *cgit_add_repo(const char *url)
37{ 37{
38 struct cgit_repo *ret; 38 struct cgit_repo *ret;
39 39
40 if (++cgit_repolist.count > cgit_repolist.length) { 40 if (++cgit_repolist.count > cgit_repolist.length) {
41 if (cgit_repolist.length == 0) 41 if (cgit_repolist.length == 0)
42 cgit_repolist.length = 8; 42 cgit_repolist.length = 8;
43 else 43 else
44 cgit_repolist.length *= 2; 44 cgit_repolist.length *= 2;
45 cgit_repolist.repos = xrealloc(cgit_repolist.repos, 45 cgit_repolist.repos = xrealloc(cgit_repolist.repos,
46 cgit_repolist.length * 46 cgit_repolist.length *
47 sizeof(struct cgit_repo)); 47 sizeof(struct cgit_repo));
48 } 48 }
49 49
50 ret = &cgit_repolist.repos[cgit_repolist.count-1]; 50 ret = &cgit_repolist.repos[cgit_repolist.count-1];
51 memset(ret, 0, sizeof(struct cgit_repo)); 51 memset(ret, 0, sizeof(struct cgit_repo));
52 ret->url = trim_end(url, '/'); 52 ret->url = trim_end(url, '/');
53 ret->name = ret->url; 53 ret->name = ret->url;
54 ret->path = NULL; 54 ret->path = NULL;
55 ret->desc = "[no description]"; 55 ret->desc = "[no description]";
56 ret->owner = NULL; 56 ret->owner = NULL;
57 ret->section = ctx.cfg.section; 57 ret->section = ctx.cfg.section;
58 ret->defbranch = "master"; 58 ret->defbranch = "master";
59 ret->snapshots = ctx.cfg.snapshots; 59 ret->snapshots = ctx.cfg.snapshots;
60 ret->enable_log_filecount = ctx.cfg.enable_log_filecount; 60 ret->enable_log_filecount = ctx.cfg.enable_log_filecount;
61 ret->enable_log_linecount = ctx.cfg.enable_log_linecount; 61 ret->enable_log_linecount = ctx.cfg.enable_log_linecount;
62 ret->max_stats = ctx.cfg.max_stats; 62 ret->max_stats = ctx.cfg.max_stats;
63 ret->module_link = ctx.cfg.module_link; 63 ret->module_link = ctx.cfg.module_link;
64 ret->readme = NULL; 64 ret->readme = NULL;
65 ret->mtime = -1; 65 ret->mtime = -1;
66 ret->about_filter = ctx.cfg.about_filter; 66 ret->about_filter = ctx.cfg.about_filter;
67 ret->commit_filter = ctx.cfg.commit_filter; 67 ret->commit_filter = ctx.cfg.commit_filter;
68 ret->source_filter = ctx.cfg.source_filter; 68 ret->source_filter = ctx.cfg.source_filter;
69 return ret; 69 return ret;
70} 70}
71 71
72struct cgit_repo *cgit_get_repoinfo(const char *url) 72struct cgit_repo *cgit_get_repoinfo(const char *url)
73{ 73{
74 int i; 74 int i;
75 struct cgit_repo *repo; 75 struct cgit_repo *repo;
76 76
77 for (i=0; i<cgit_repolist.count; i++) { 77 for (i=0; i<cgit_repolist.count; i++) {
78 repo = &cgit_repolist.repos[i]; 78 repo = &cgit_repolist.repos[i];
79 if (!strcmp(repo->url, url)) 79 if (!strcmp(repo->url, url))
80 return repo; 80 return repo;
81 } 81 }
82 return NULL; 82 return NULL;
83} 83}
84 84
85void *cgit_free_commitinfo(struct commitinfo *info) 85void *cgit_free_commitinfo(struct commitinfo *info)
86{ 86{
87 free(info->author); 87 free(info->author);
88 free(info->author_email); 88 free(info->author_email);
89 free(info->committer); 89 free(info->committer);
90 free(info->committer_email); 90 free(info->committer_email);
91 free(info->subject); 91 free(info->subject);
92 free(info->msg); 92 free(info->msg);
93 free(info->msg_encoding); 93 free(info->msg_encoding);
94 free(info); 94 free(info);
95 return NULL; 95 return NULL;
96} 96}
97 97
98char *trim_end(const char *str, char c) 98char *trim_end(const char *str, char c)
99{ 99{
100 int len; 100 int len;
101 char *s, *t; 101 char *s, *t;
102 102
103 if (str == NULL) 103 if (str == NULL)
104 return NULL; 104 return NULL;
105 t = (char *)str; 105 t = (char *)str;
106 len = strlen(t); 106 len = strlen(t);
107 while(len > 0 && t[len - 1] == c) 107 while(len > 0 && t[len - 1] == c)
108 len--; 108 len--;
109 109
110 if (len == 0) 110 if (len == 0)
111 return NULL; 111 return NULL;
112 112
113 c = t[len]; 113 c = t[len];
114 t[len] = '\0'; 114 t[len] = '\0';
115 s = xstrdup(t); 115 s = xstrdup(t);
116 t[len] = c; 116 t[len] = c;
117 return s; 117 return s;
118} 118}
119 119
120char *strlpart(char *txt, int maxlen) 120char *strlpart(char *txt, int maxlen)
121{ 121{
122 char *result; 122 char *result;
123 123
124 if (!txt) 124 if (!txt)
125 return txt; 125 return txt;
126 126
127 if (strlen(txt) <= maxlen) 127 if (strlen(txt) <= maxlen)
128 return txt; 128 return txt;
129 result = xmalloc(maxlen + 1); 129 result = xmalloc(maxlen + 1);
130 memcpy(result, txt, maxlen - 3); 130 memcpy(result, txt, maxlen - 3);
131 result[maxlen-1] = result[maxlen-2] = result[maxlen-3] = '.'; 131 result[maxlen-1] = result[maxlen-2] = result[maxlen-3] = '.';
132 result[maxlen] = '\0'; 132 result[maxlen] = '\0';
133 return result; 133 return result;
134} 134}
135 135
136char *strrpart(char *txt, int maxlen) 136char *strrpart(char *txt, int maxlen)
137{ 137{
138 char *result; 138 char *result;
139 139
140 if (!txt) 140 if (!txt)
141 return txt; 141 return txt;
142 142
143 if (strlen(txt) <= maxlen) 143 if (strlen(txt) <= maxlen)
144 return txt; 144 return txt;
145 result = xmalloc(maxlen + 1); 145 result = xmalloc(maxlen + 1);
146 memcpy(result + 3, txt + strlen(txt) - maxlen + 4, maxlen - 3); 146 memcpy(result + 3, txt + strlen(txt) - maxlen + 4, maxlen - 3);
147 result[0] = result[1] = result[2] = '.'; 147 result[0] = result[1] = result[2] = '.';
148 return result; 148 return result;
149} 149}
150 150
151void cgit_add_ref(struct reflist *list, struct refinfo *ref) 151void cgit_add_ref(struct reflist *list, struct refinfo *ref)
152{ 152{
153 size_t size; 153 size_t size;
154 154
155 if (list->count >= list->alloc) { 155 if (list->count >= list->alloc) {
156 list->alloc += (list->alloc ? list->alloc : 4); 156 list->alloc += (list->alloc ? list->alloc : 4);
157 size = list->alloc * sizeof(struct refinfo *); 157 size = list->alloc * sizeof(struct refinfo *);
158 list->refs = xrealloc(list->refs, size); 158 list->refs = xrealloc(list->refs, size);
159 } 159 }
160 list->refs[list->count++] = ref; 160 list->refs[list->count++] = ref;
161} 161}
162 162
163struct refinfo *cgit_mk_refinfo(const char *refname, const unsigned char *sha1) 163struct refinfo *cgit_mk_refinfo(const char *refname, const unsigned char *sha1)
164{ 164{
165 struct refinfo *ref; 165 struct refinfo *ref;
166 166
167 ref = xmalloc(sizeof (struct refinfo)); 167 ref = xmalloc(sizeof (struct refinfo));
168 ref->refname = xstrdup(refname); 168 ref->refname = xstrdup(refname);
169 ref->object = parse_object(sha1); 169 ref->object = parse_object(sha1);
170 switch (ref->object->type) { 170 switch (ref->object->type) {
171 case OBJ_TAG: 171 case OBJ_TAG:
172 ref->tag = cgit_parse_tag((struct tag *)ref->object); 172 ref->tag = cgit_parse_tag((struct tag *)ref->object);
173 break; 173 break;
174 case OBJ_COMMIT: 174 case OBJ_COMMIT:
175 ref->commit = cgit_parse_commit((struct commit *)ref->object); 175 ref->commit = cgit_parse_commit((struct commit *)ref->object);
176 break; 176 break;
177 } 177 }
178 return ref; 178 return ref;
179} 179}
180 180
181int cgit_refs_cb(const char *refname, const unsigned char *sha1, int flags, 181int cgit_refs_cb(const char *refname, const unsigned char *sha1, int flags,
182 void *cb_data) 182 void *cb_data)
183{ 183{
184 struct reflist *list = (struct reflist *)cb_data; 184 struct reflist *list = (struct reflist *)cb_data;
185 struct refinfo *info = cgit_mk_refinfo(refname, sha1); 185 struct refinfo *info = cgit_mk_refinfo(refname, sha1);
186 186
187 if (info) 187 if (info)
188 cgit_add_ref(list, info); 188 cgit_add_ref(list, info);
189 return 0; 189 return 0;
190} 190}
191 191
192void cgit_diff_tree_cb(struct diff_queue_struct *q, 192void cgit_diff_tree_cb(struct diff_queue_struct *q,
193 struct diff_options *options, void *data) 193 struct diff_options *options, void *data)
194{ 194{
195 int i; 195 int i;
196 196
197 for (i = 0; i < q->nr; i++) { 197 for (i = 0; i < q->nr; i++) {
198 if (q->queue[i]->status == 'U') 198 if (q->queue[i]->status == 'U')
199 continue; 199 continue;
200 ((filepair_fn)data)(q->queue[i]); 200 ((filepair_fn)data)(q->queue[i]);
201 } 201 }
202} 202}
203 203
204static int load_mmfile(mmfile_t *file, const unsigned char *sha1) 204static int load_mmfile(mmfile_t *file, const unsigned char *sha1)
205{ 205{
206 enum object_type type; 206 enum object_type type;
207 207
208 if (is_null_sha1(sha1)) { 208 if (is_null_sha1(sha1)) {
209 file->ptr = (char *)""; 209 file->ptr = (char *)"";
210 file->size = 0; 210 file->size = 0;
211 } else { 211 } else {
212 file->ptr = read_sha1_file(sha1, &type, 212 file->ptr = read_sha1_file(sha1, &type,
213 (unsigned long *)&file->size); 213 (unsigned long *)&file->size);
214 } 214 }
215 return 1; 215 return 1;
216} 216}
217 217
218/* 218/*
219 * Receive diff-buffers from xdiff and concatenate them as 219 * Receive diff-buffers from xdiff and concatenate them as
220 * needed across multiple callbacks. 220 * needed across multiple callbacks.
221 * 221 *
222 * This is basically a copy of xdiff-interface.c/xdiff_outf(), 222 * This is basically a copy of xdiff-interface.c/xdiff_outf(),
223 * ripped from git and modified to use globals instead of 223 * ripped from git and modified to use globals instead of
224 * a special callback-struct. 224 * a special callback-struct.
225 */ 225 */
226char *diffbuf = NULL; 226char *diffbuf = NULL;
227int buflen = 0; 227int buflen = 0;
228 228
229int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf) 229int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf)
230{ 230{
231 int i; 231 int i;
232 232
233 for (i = 0; i < nbuf; i++) { 233 for (i = 0; i < nbuf; i++) {
234 if (mb[i].ptr[mb[i].size-1] != '\n') { 234 if (mb[i].ptr[mb[i].size-1] != '\n') {
235 /* Incomplete line */ 235 /* Incomplete line */
236 diffbuf = xrealloc(diffbuf, buflen + mb[i].size); 236 diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
237 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); 237 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
238 buflen += mb[i].size; 238 buflen += mb[i].size;
239 continue; 239 continue;
240 } 240 }
241 241
242 /* we have a complete line */ 242 /* we have a complete line */
243 if (!diffbuf) { 243 if (!diffbuf) {
244 ((linediff_fn)priv)(mb[i].ptr, mb[i].size); 244 ((linediff_fn)priv)(mb[i].ptr, mb[i].size);
245 continue; 245 continue;
246 } 246 }
247 diffbuf = xrealloc(diffbuf, buflen + mb[i].size); 247 diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
248 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); 248 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
249 ((linediff_fn)priv)(diffbuf, buflen + mb[i].size); 249 ((linediff_fn)priv)(diffbuf, buflen + mb[i].size);
250 free(diffbuf); 250 free(diffbuf);
251 diffbuf = NULL; 251 diffbuf = NULL;
252 buflen = 0; 252 buflen = 0;
253 } 253 }
254 if (diffbuf) { 254 if (diffbuf) {
255 ((linediff_fn)priv)(diffbuf, buflen); 255 ((linediff_fn)priv)(diffbuf, buflen);
256 free(diffbuf); 256 free(diffbuf);
257 diffbuf = NULL; 257 diffbuf = NULL;
258 buflen = 0; 258 buflen = 0;
259 } 259 }
260 return 0; 260 return 0;
261} 261}
262 262
263int cgit_diff_files(const unsigned char *old_sha1, 263int cgit_diff_files(const unsigned char *old_sha1,
264 const unsigned char *new_sha1, unsigned long *old_size, 264 const unsigned char *new_sha1, unsigned long *old_size,
265 unsigned long *new_size, int *binary, linediff_fn fn) 265 unsigned long *new_size, int *binary, linediff_fn fn)
266{ 266{
267 mmfile_t file1, file2; 267 mmfile_t file1, file2;
268 xpparam_t diff_params; 268 xpparam_t diff_params;
269 xdemitconf_t emit_params; 269 xdemitconf_t emit_params;
270 xdemitcb_t emit_cb; 270 xdemitcb_t emit_cb;
271 271
272 if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1)) 272 if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1))
273 return 1; 273 return 1;
274 274
275 *old_size = file1.size; 275 *old_size = file1.size;
276 *new_size = file2.size; 276 *new_size = file2.size;
277 277
278 if ((file1.ptr && buffer_is_binary(file1.ptr, file1.size)) || 278 if ((file1.ptr && buffer_is_binary(file1.ptr, file1.size)) ||
279 (file2.ptr && buffer_is_binary(file2.ptr, file2.size))) { 279 (file2.ptr && buffer_is_binary(file2.ptr, file2.size))) {
280 *binary = 1; 280 *binary = 1;
281 return 0; 281 return 0;
282 } 282 }
283 283
284 memset(&diff_params, 0, sizeof(diff_params)); 284 memset(&diff_params, 0, sizeof(diff_params));
285 memset(&emit_params, 0, sizeof(emit_params)); 285 memset(&emit_params, 0, sizeof(emit_params));
286 memset(&emit_cb, 0, sizeof(emit_cb)); 286 memset(&emit_cb, 0, sizeof(emit_cb));
287 diff_params.flags = XDF_NEED_MINIMAL; 287 diff_params.flags = XDF_NEED_MINIMAL;
288 emit_params.ctxlen = 3; 288 emit_params.ctxlen = 3;
289 emit_params.flags = XDL_EMIT_FUNCNAMES; 289 emit_params.flags = XDL_EMIT_FUNCNAMES;
290 emit_cb.outf = filediff_cb; 290 emit_cb.outf = filediff_cb;
291 emit_cb.priv = fn; 291 emit_cb.priv = fn;
292 xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb); 292 xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb);
293 return 0; 293 return 0;
294} 294}
295 295
296void cgit_diff_tree(const unsigned char *old_sha1, 296void cgit_diff_tree(const unsigned char *old_sha1,
297 const unsigned char *new_sha1, 297 const unsigned char *new_sha1,
298 filepair_fn fn, const char *prefix) 298 filepair_fn fn, const char *prefix)
299{ 299{
300 struct diff_options opt; 300 struct diff_options opt;
301 int ret; 301 int ret;
302 int prefixlen; 302 int prefixlen;
303 303
304 diff_setup(&opt); 304 diff_setup(&opt);
305 opt.output_format = DIFF_FORMAT_CALLBACK; 305 opt.output_format = DIFF_FORMAT_CALLBACK;
306 opt.detect_rename = 1; 306 opt.detect_rename = 1;
307 opt.rename_limit = ctx.cfg.renamelimit; 307 opt.rename_limit = ctx.cfg.renamelimit;
308 DIFF_OPT_SET(&opt, RECURSIVE); 308 DIFF_OPT_SET(&opt, RECURSIVE);
309 opt.format_callback = cgit_diff_tree_cb; 309 opt.format_callback = cgit_diff_tree_cb;
310 opt.format_callback_data = fn; 310 opt.format_callback_data = fn;
311 if (prefix) { 311 if (prefix) {
312 opt.nr_paths = 1; 312 opt.nr_paths = 1;
313 opt.paths = &prefix; 313 opt.paths = &prefix;
314 prefixlen = strlen(prefix); 314 prefixlen = strlen(prefix);
315 opt.pathlens = &prefixlen; 315 opt.pathlens = &prefixlen;
316 } 316 }
317 diff_setup_done(&opt); 317 diff_setup_done(&opt);
318 318
319 if (old_sha1 && !is_null_sha1(old_sha1)) 319 if (old_sha1 && !is_null_sha1(old_sha1))
320 ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt); 320 ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt);
321 else 321 else
322 ret = diff_root_tree_sha1(new_sha1, "", &opt); 322 ret = diff_root_tree_sha1(new_sha1, "", &opt);
323 diffcore_std(&opt); 323 diffcore_std(&opt);
324 diff_flush(&opt); 324 diff_flush(&opt);
325} 325}
326 326
327void cgit_diff_commit(struct commit *commit, filepair_fn fn) 327void cgit_diff_commit(struct commit *commit, filepair_fn fn)
328{ 328{
329 unsigned char *old_sha1 = NULL; 329 unsigned char *old_sha1 = NULL;
330 330
331 if (commit->parents) 331 if (commit->parents)
332 old_sha1 = commit->parents->item->object.sha1; 332 old_sha1 = commit->parents->item->object.sha1;
333 cgit_diff_tree(old_sha1, commit->object.sha1, fn, NULL); 333 cgit_diff_tree(old_sha1, commit->object.sha1, fn, NULL);
334} 334}
335 335
336int cgit_parse_snapshots_mask(const char *str) 336int cgit_parse_snapshots_mask(const char *str)
337{ 337{
338 const struct cgit_snapshot_format *f; 338 const struct cgit_snapshot_format *f;
339 static const char *delim = " \t,:/|;"; 339 static const char *delim = " \t,:/|;";
340 int tl, sl, rv = 0; 340 int tl, sl, rv = 0;
341 341
342 /* favor legacy setting */ 342 /* favor legacy setting */
343 if(atoi(str)) 343 if(atoi(str))
344 return 1; 344 return 1;
345 for(;;) { 345 for(;;) {
346 str += strspn(str,delim); 346 str += strspn(str,delim);
347 tl = strcspn(str,delim); 347 tl = strcspn(str,delim);
348 if (!tl) 348 if (!tl)
349 break; 349 break;
350 for (f = cgit_snapshot_formats; f->suffix; f++) { 350 for (f = cgit_snapshot_formats; f->suffix; f++) {
351 sl = strlen(f->suffix); 351 sl = strlen(f->suffix);
352 if((tl == sl && !strncmp(f->suffix, str, tl)) || 352 if((tl == sl && !strncmp(f->suffix, str, tl)) ||
353 (tl == sl-1 && !strncmp(f->suffix+1, str, tl-1))) { 353 (tl == sl-1 && !strncmp(f->suffix+1, str, tl-1))) {
354 rv |= f->bit; 354 rv |= f->bit;
355 break; 355 break;
356 } 356 }
357 } 357 }
358 str += tl; 358 str += tl;
359 } 359 }
360 return rv; 360 return rv;
361} 361}
362 362
363int cgit_open_filter(struct cgit_filter *filter) 363int cgit_open_filter(struct cgit_filter *filter)
364{ 364{
365 365
366 filter->old_stdout = chk_positive(dup(STDOUT_FILENO), 366 filter->old_stdout = chk_positive(dup(STDOUT_FILENO),
367 "Unable to duplicate STDOUT"); 367 "Unable to duplicate STDOUT");
368 chk_zero(pipe(filter->pipe_fh), "Unable to create pipe to subprocess"); 368 chk_zero(pipe(filter->pipe_fh), "Unable to create pipe to subprocess");
369 filter->pid = chk_non_negative(fork(), "Unable to create subprocess"); 369 filter->pid = chk_non_negative(fork(), "Unable to create subprocess");
370 if (filter->pid == 0) { 370 if (filter->pid == 0) {
371 close(filter->pipe_fh[1]); 371 close(filter->pipe_fh[1]);
372 chk_non_negative(dup2(filter->pipe_fh[0], STDIN_FILENO), 372 chk_non_negative(dup2(filter->pipe_fh[0], STDIN_FILENO),
373 "Unable to use pipe as STDIN"); 373 "Unable to use pipe as STDIN");
374 execvp(filter->cmd, filter->argv); 374 execvp(filter->cmd, filter->argv);
375 die("Unable to exec subprocess %s: %s (%d)", filter->cmd, 375 die("Unable to exec subprocess %s: %s (%d)", filter->cmd,
376 strerror(errno), errno); 376 strerror(errno), errno);
377 } 377 }
378 close(filter->pipe_fh[0]); 378 close(filter->pipe_fh[0]);
379 chk_non_negative(dup2(filter->pipe_fh[1], STDOUT_FILENO), 379 chk_non_negative(dup2(filter->pipe_fh[1], STDOUT_FILENO),
380 "Unable to use pipe as STDOUT"); 380 "Unable to use pipe as STDOUT");
381 close(filter->pipe_fh[1]); 381 close(filter->pipe_fh[1]);
382 return 0; 382 return 0;
383} 383}
384 384
385int cgit_close_filter(struct cgit_filter *filter) 385int cgit_close_filter(struct cgit_filter *filter)
386{ 386{
387 chk_non_negative(dup2(filter->old_stdout, STDOUT_FILENO), 387 chk_non_negative(dup2(filter->old_stdout, STDOUT_FILENO),
388 "Unable to restore STDOUT"); 388 "Unable to restore STDOUT");
389 close(filter->old_stdout); 389 close(filter->old_stdout);
390 if (filter->pid < 0) 390 if (filter->pid < 0)
391 return 0; 391 return 0;
392 waitpid(filter->pid, &filter->exitstatus, 0); 392 waitpid(filter->pid, &filter->exitstatus, 0);
393 if (WIFEXITED(filter->exitstatus) && !WEXITSTATUS(filter->exitstatus)) 393 if (WIFEXITED(filter->exitstatus) && !WEXITSTATUS(filter->exitstatus))
394 return 0; 394 return 0;
395 die("Subprocess %s exited abnormally", filter->cmd); 395 die("Subprocess %s exited abnormally", filter->cmd);
396} 396}
397 397
398/* Read the content of the specified file into a newly allocated buffer, 398/* Read the content of the specified file into a newly allocated buffer,
399 * zeroterminate the buffer and return 0 on success, errno otherwise. 399 * zeroterminate the buffer and return 0 on success, errno otherwise.
400 */ 400 */
401int readfile(const char *path, char **buf, size_t *size) 401int readfile(const char *path, char **buf, size_t *size)
402{ 402{
403 int fd; 403 int fd;
404 struct stat st; 404 struct stat st;
405 405
406 fd = open(path, O_RDONLY); 406 fd = open(path, O_RDONLY);
407 if (fd == -1) 407 if (fd == -1)
408 return errno; 408 return errno;
409 if (fstat(fd, &st)) 409 if (fstat(fd, &st)) {
410 close(fd);
410 return errno; 411 return errno;
411 if (!S_ISREG(st.st_mode)) 412 }
413 if (!S_ISREG(st.st_mode)) {
414 close(fd);
412 return EISDIR; 415 return EISDIR;
416 }
413 *buf = xmalloc(st.st_size + 1); 417 *buf = xmalloc(st.st_size + 1);
414 *size = read_in_full(fd, *buf, st.st_size); 418 *size = read_in_full(fd, *buf, st.st_size);
415 (*buf)[*size] = '\0'; 419 (*buf)[*size] = '\0';
420 close(fd);
416 return (*size == st.st_size ? 0 : errno); 421 return (*size == st.st_size ? 0 : errno);
417} 422}
diff --git a/ui-shared.c b/ui-shared.c
index 6cb7edb..3a9e67b 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -1,407 +1,407 @@
1/* ui-shared.c: common web output functions 1/* ui-shared.c: common web output functions
2 * 2 *
3 * Copyright (C) 2006 Lars Hjemli 3 * Copyright (C) 2006 Lars Hjemli
4 * 4 *
5 * Licensed under GNU General Public License v2 5 * Licensed under GNU General Public License v2
6 * (see COPYING for full license text) 6 * (see COPYING for full license text)
7 */ 7 */
8 8
9#include "cgit.h" 9#include "cgit.h"
10#include "cmd.h" 10#include "cmd.h"
11#include "html.h" 11#include "html.h"
12 12
13const char cgit_doctype[] = 13const char cgit_doctype[] =
14"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n" 14"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
15" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"; 15" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
16 16
17static char *http_date(time_t t) 17static char *http_date(time_t t)
18{ 18{
19 static char day[][4] = 19 static char day[][4] =
20 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; 20 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
21 static char month[][4] = 21 static char month[][4] =
22 {"Jan", "Feb", "Mar", "Apr", "May", "Jun", 22 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
23 "Jul", "Aug", "Sep", "Oct", "Now", "Dec"}; 23 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
24 struct tm *tm = gmtime(&t); 24 struct tm *tm = gmtime(&t);
25 return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday], 25 return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday],
26 tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year, 26 tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year,
27 tm->tm_hour, tm->tm_min, tm->tm_sec); 27 tm->tm_hour, tm->tm_min, tm->tm_sec);
28} 28}
29 29
30void cgit_print_error(char *msg) 30void cgit_print_error(char *msg)
31{ 31{
32 html("<div class='error'>"); 32 html("<div class='error'>");
33 html_txt(msg); 33 html_txt(msg);
34 html("</div>\n"); 34 html("</div>\n");
35} 35}
36 36
37char *cgit_httpscheme() 37char *cgit_httpscheme()
38{ 38{
39 if (ctx.env.https && !strcmp(ctx.env.https, "on")) 39 if (ctx.env.https && !strcmp(ctx.env.https, "on"))
40 return "https://"; 40 return "https://";
41 else 41 else
42 return "http://"; 42 return "http://";
43} 43}
44 44
45char *cgit_hosturl() 45char *cgit_hosturl()
46{ 46{
47 if (ctx.env.http_host) 47 if (ctx.env.http_host)
48 return ctx.env.http_host; 48 return ctx.env.http_host;
49 if (!ctx.env.server_name) 49 if (!ctx.env.server_name)
50 return NULL; 50 return NULL;
51 if (!ctx.env.server_port || atoi(ctx.env.server_port) == 80) 51 if (!ctx.env.server_port || atoi(ctx.env.server_port) == 80)
52 return ctx.env.server_name; 52 return ctx.env.server_name;
53 return xstrdup(fmt("%s:%s", ctx.env.server_name, ctx.env.server_port)); 53 return xstrdup(fmt("%s:%s", ctx.env.server_name, ctx.env.server_port));
54} 54}
55 55
56char *cgit_rooturl() 56char *cgit_rooturl()
57{ 57{
58 if (ctx.cfg.virtual_root) 58 if (ctx.cfg.virtual_root)
59 return fmt("%s/", ctx.cfg.virtual_root); 59 return fmt("%s/", ctx.cfg.virtual_root);
60 else 60 else
61 return ctx.cfg.script_name; 61 return ctx.cfg.script_name;
62} 62}
63 63
64char *cgit_repourl(const char *reponame) 64char *cgit_repourl(const char *reponame)
65{ 65{
66 if (ctx.cfg.virtual_root) { 66 if (ctx.cfg.virtual_root) {
67 return fmt("%s/%s/", ctx.cfg.virtual_root, reponame); 67 return fmt("%s/%s/", ctx.cfg.virtual_root, reponame);
68 } else { 68 } else {
69 return fmt("?r=%s", reponame); 69 return fmt("?r=%s", reponame);
70 } 70 }
71} 71}
72 72
73char *cgit_fileurl(const char *reponame, const char *pagename, 73char *cgit_fileurl(const char *reponame, const char *pagename,
74 const char *filename, const char *query) 74 const char *filename, const char *query)
75{ 75{
76 char *tmp; 76 char *tmp;
77 char *delim; 77 char *delim;
78 78
79 if (ctx.cfg.virtual_root) { 79 if (ctx.cfg.virtual_root) {
80 tmp = fmt("%s/%s/%s/%s", ctx.cfg.virtual_root, reponame, 80 tmp = fmt("%s/%s/%s/%s", ctx.cfg.virtual_root, reponame,
81 pagename, (filename ? filename:"")); 81 pagename, (filename ? filename:""));
82 delim = "?"; 82 delim = "?";
83 } else { 83 } else {
84 tmp = fmt("?url=%s/%s/%s", reponame, pagename, 84 tmp = fmt("?url=%s/%s/%s", reponame, pagename,
85 (filename ? filename : "")); 85 (filename ? filename : ""));
86 delim = "&"; 86 delim = "&";
87 } 87 }
88 if (query) 88 if (query)
89 tmp = fmt("%s%s%s", tmp, delim, query); 89 tmp = fmt("%s%s%s", tmp, delim, query);
90 return tmp; 90 return tmp;
91} 91}
92 92
93char *cgit_pageurl(const char *reponame, const char *pagename, 93char *cgit_pageurl(const char *reponame, const char *pagename,
94 const char *query) 94 const char *query)
95{ 95{
96 return cgit_fileurl(reponame,pagename,0,query); 96 return cgit_fileurl(reponame,pagename,0,query);
97} 97}
98 98
99const char *cgit_repobasename(const char *reponame) 99const char *cgit_repobasename(const char *reponame)
100{ 100{
101 /* I assume we don't need to store more than one repo basename */ 101 /* I assume we don't need to store more than one repo basename */
102 static char rvbuf[1024]; 102 static char rvbuf[1024];
103 int p; 103 int p;
104 const char *rv; 104 const char *rv;
105 strncpy(rvbuf,reponame,sizeof(rvbuf)); 105 strncpy(rvbuf,reponame,sizeof(rvbuf));
106 if(rvbuf[sizeof(rvbuf)-1]) 106 if(rvbuf[sizeof(rvbuf)-1])
107 die("cgit_repobasename: truncated repository name '%s'", reponame); 107 die("cgit_repobasename: truncated repository name '%s'", reponame);
108 p = strlen(rvbuf)-1; 108 p = strlen(rvbuf)-1;
109 /* strip trailing slashes */ 109 /* strip trailing slashes */
110 while(p && rvbuf[p]=='/') rvbuf[p--]=0; 110 while(p && rvbuf[p]=='/') rvbuf[p--]=0;
111 /* strip trailing .git */ 111 /* strip trailing .git */
112 if(p>=3 && !strncmp(&rvbuf[p-3],".git",4)) { 112 if(p>=3 && !strncmp(&rvbuf[p-3],".git",4)) {
113 p -= 3; rvbuf[p--] = 0; 113 p -= 3; rvbuf[p--] = 0;
114 } 114 }
115 /* strip more trailing slashes if any */ 115 /* strip more trailing slashes if any */
116 while( p && rvbuf[p]=='/') rvbuf[p--]=0; 116 while( p && rvbuf[p]=='/') rvbuf[p--]=0;
117 /* find last slash in the remaining string */ 117 /* find last slash in the remaining string */
118 rv = strrchr(rvbuf,'/'); 118 rv = strrchr(rvbuf,'/');
119 if(rv) 119 if(rv)
120 return ++rv; 120 return ++rv;
121 return rvbuf; 121 return rvbuf;
122} 122}
123 123
124char *cgit_currurl() 124char *cgit_currurl()
125{ 125{
126 if (!ctx.cfg.virtual_root) 126 if (!ctx.cfg.virtual_root)
127 return ctx.cfg.script_name; 127 return ctx.cfg.script_name;
128 else if (ctx.qry.page) 128 else if (ctx.qry.page)
129 return fmt("%s/%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo, ctx.qry.page); 129 return fmt("%s/%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo, ctx.qry.page);
130 else if (ctx.qry.repo) 130 else if (ctx.qry.repo)
131 return fmt("%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo); 131 return fmt("%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo);
132 else 132 else
133 return fmt("%s/", ctx.cfg.virtual_root); 133 return fmt("%s/", ctx.cfg.virtual_root);
134} 134}
135 135
136static void site_url(char *page, char *search, int ofs) 136static void site_url(char *page, char *search, int ofs)
137{ 137{
138 char *delim = "?"; 138 char *delim = "?";
139 139
140 if (ctx.cfg.virtual_root) { 140 if (ctx.cfg.virtual_root) {
141 html_attr(ctx.cfg.virtual_root); 141 html_attr(ctx.cfg.virtual_root);
142 if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/') 142 if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/')
143 html("/"); 143 html("/");
144 } else 144 } else
145 html(ctx.cfg.script_name); 145 html(ctx.cfg.script_name);
146 146
147 if (page) { 147 if (page) {
148 htmlf("?p=%s", page); 148 htmlf("?p=%s", page);
149 delim = "&"; 149 delim = "&";
150 } 150 }
151 if (search) { 151 if (search) {
152 html(delim); 152 html(delim);
153 html("q="); 153 html("q=");
154 html_attr(search); 154 html_attr(search);
155 delim = "&"; 155 delim = "&";
156 } 156 }
157 if (ofs) { 157 if (ofs) {
158 html(delim); 158 html(delim);
159 htmlf("ofs=%d", ofs); 159 htmlf("ofs=%d", ofs);
160 } 160 }
161} 161}
162 162
163static void site_link(char *page, char *name, char *title, char *class, 163static void site_link(char *page, char *name, char *title, char *class,
164 char *search, int ofs) 164 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(char *name, char *title, char *class, char *pattern, 184void cgit_index_link(char *name, char *title, char *class, char *pattern,
185 int ofs) 185 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(char *title, char *class, char *page, char *head, 190static char *repolink(char *title, char *class, char *page, char *head,
191 char *path) 191 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(char *page, char *name, char *title, char *class, 243static void reporevlink(char *page, char *name, char *title, char *class,
244 char *head, char *rev, char *path) 244 char *head, char *rev, char *path)
245{ 245{
246 char *delim; 246 char *delim;
247 247
248 delim = repolink(title, class, page, head, path); 248 delim = repolink(title, class, page, head, path);
249 if (rev && strcmp(rev, ctx.qry.head)) { 249 if (rev && strcmp(rev, ctx.qry.head)) {
250 html(delim); 250 html(delim);
251 html("id="); 251 html("id=");
252 html_url_arg(rev); 252 html_url_arg(rev);
253 } 253 }
254 html("'>"); 254 html("'>");
255 html_txt(name); 255 html_txt(name);
256 html("</a>"); 256 html("</a>");
257} 257}
258 258
259void cgit_summary_link(char *name, char *title, char *class, char *head) 259void cgit_summary_link(char *name, char *title, char *class, char *head)
260{ 260{
261 reporevlink(NULL, name, title, class, head, NULL, NULL); 261 reporevlink(NULL, name, title, class, head, NULL, NULL);
262} 262}
263 263
264void cgit_tag_link(char *name, char *title, char *class, char *head, 264void cgit_tag_link(char *name, char *title, char *class, char *head,
265 char *rev) 265 char *rev)
266{ 266{
267 reporevlink("tag", name, title, class, head, rev, NULL); 267 reporevlink("tag", name, title, class, head, rev, NULL);
268} 268}
269 269
270void cgit_tree_link(char *name, char *title, char *class, char *head, 270void cgit_tree_link(char *name, char *title, char *class, char *head,
271 char *rev, char *path) 271 char *rev, char *path)
272{ 272{
273 reporevlink("tree", name, title, class, head, rev, path); 273 reporevlink("tree", name, title, class, head, rev, path);
274} 274}
275 275
276void cgit_plain_link(char *name, char *title, char *class, char *head, 276void cgit_plain_link(char *name, char *title, char *class, char *head,
277 char *rev, char *path) 277 char *rev, char *path)
278{ 278{
279 reporevlink("plain", name, title, class, head, rev, path); 279 reporevlink("plain", name, title, class, head, rev, path);
280} 280}
281 281
282void cgit_log_link(char *name, char *title, char *class, char *head, 282void cgit_log_link(char *name, char *title, char *class, char *head,
283 char *rev, char *path, int ofs, char *grep, char *pattern, 283 char *rev, char *path, int ofs, char *grep, char *pattern,
284 int showmsg) 284 int showmsg)
285{ 285{
286 char *delim; 286 char *delim;
287 287
288 delim = repolink(title, class, "log", head, path); 288 delim = repolink(title, class, "log", head, path);
289 if (rev && strcmp(rev, ctx.qry.head)) { 289 if (rev && strcmp(rev, ctx.qry.head)) {
290 html(delim); 290 html(delim);
291 html("id="); 291 html("id=");
292 html_url_arg(rev); 292 html_url_arg(rev);
293 delim = "&"; 293 delim = "&";
294 } 294 }
295 if (grep && pattern) { 295 if (grep && pattern) {
296 html(delim); 296 html(delim);
297 html("qt="); 297 html("qt=");
298 html_url_arg(grep); 298 html_url_arg(grep);
299 delim = "&"; 299 delim = "&";
300 html(delim); 300 html(delim);
301 html("q="); 301 html("q=");
302 html_url_arg(pattern); 302 html_url_arg(pattern);
303 } 303 }
304 if (ofs > 0) { 304 if (ofs > 0) {
305 html(delim); 305 html(delim);
306 html("ofs="); 306 html("ofs=");
307 htmlf("%d", ofs); 307 htmlf("%d", ofs);
308 delim = "&"; 308 delim = "&";
309 } 309 }
310 if (showmsg) { 310 if (showmsg) {
311 html(delim); 311 html(delim);
312 html("showmsg=1"); 312 html("showmsg=1");
313 } 313 }
314 html("'>"); 314 html("'>");
315 html_txt(name); 315 html_txt(name);
316 html("</a>"); 316 html("</a>");
317} 317}
318 318
319void cgit_commit_link(char *name, char *title, char *class, char *head, 319void cgit_commit_link(char *name, char *title, char *class, char *head,
320 char *rev) 320 char *rev)
321{ 321{
322 if (strlen(name) > ctx.cfg.max_msg_len && ctx.cfg.max_msg_len >= 15) { 322 if (strlen(name) > ctx.cfg.max_msg_len && ctx.cfg.max_msg_len >= 15) {
323 name[ctx.cfg.max_msg_len] = '\0'; 323 name[ctx.cfg.max_msg_len] = '\0';
324 name[ctx.cfg.max_msg_len - 1] = '.'; 324 name[ctx.cfg.max_msg_len - 1] = '.';
325 name[ctx.cfg.max_msg_len - 2] = '.'; 325 name[ctx.cfg.max_msg_len - 2] = '.';
326 name[ctx.cfg.max_msg_len - 3] = '.'; 326 name[ctx.cfg.max_msg_len - 3] = '.';
327 } 327 }
328 reporevlink("commit", name, title, class, head, rev, NULL); 328 reporevlink("commit", name, title, class, head, rev, NULL);
329} 329}
330 330
331void cgit_refs_link(char *name, char *title, char *class, char *head, 331void cgit_refs_link(char *name, char *title, char *class, char *head,
332 char *rev, char *path) 332 char *rev, char *path)
333{ 333{
334 reporevlink("refs", name, title, class, head, rev, path); 334 reporevlink("refs", name, title, class, head, rev, path);
335} 335}
336 336
337void cgit_snapshot_link(char *name, char *title, char *class, char *head, 337void cgit_snapshot_link(char *name, char *title, char *class, char *head,
338 char *rev, char *archivename) 338 char *rev, char *archivename)
339{ 339{
340 reporevlink("snapshot", name, title, class, head, rev, archivename); 340 reporevlink("snapshot", name, title, class, head, rev, archivename);
341} 341}
342 342
343void cgit_diff_link(char *name, char *title, char *class, char *head, 343void cgit_diff_link(char *name, char *title, char *class, char *head,
344 char *new_rev, char *old_rev, char *path) 344 char *new_rev, char *old_rev, char *path)
345{ 345{
346 char *delim; 346 char *delim;
347 347
348 delim = repolink(title, class, "diff", head, path); 348 delim = repolink(title, class, "diff", head, path);
349 if (new_rev && strcmp(new_rev, ctx.qry.head)) { 349 if (new_rev && strcmp(new_rev, ctx.qry.head)) {
350 html(delim); 350 html(delim);
351 html("id="); 351 html("id=");
352 html_url_arg(new_rev); 352 html_url_arg(new_rev);
353 delim = "&amp;"; 353 delim = "&amp;";
354 } 354 }
355 if (old_rev) { 355 if (old_rev) {
356 html(delim); 356 html(delim);
357 html("id2="); 357 html("id2=");
358 html_url_arg(old_rev); 358 html_url_arg(old_rev);
359 } 359 }
360 html("'>"); 360 html("'>");
361 html_txt(name); 361 html_txt(name);
362 html("</a>"); 362 html("</a>");
363} 363}
364 364
365void cgit_patch_link(char *name, char *title, char *class, char *head, 365void cgit_patch_link(char *name, char *title, char *class, char *head,
366 char *rev) 366 char *rev)
367{ 367{
368 reporevlink("patch", name, title, class, head, rev, NULL); 368 reporevlink("patch", name, title, class, head, rev, NULL);
369} 369}
370 370
371void cgit_stats_link(char *name, char *title, char *class, char *head, 371void cgit_stats_link(char *name, char *title, char *class, char *head,
372 char *path) 372 char *path)
373{ 373{
374 reporevlink("stats", name, title, class, head, NULL, path); 374 reporevlink("stats", name, title, class, head, NULL, path);
375} 375}
376 376
377void cgit_object_link(struct object *obj) 377void cgit_object_link(struct object *obj)
378{ 378{
379 char *page, *shortrev, *fullrev, *name; 379 char *page, *shortrev, *fullrev, *name;
380 380
381 fullrev = sha1_to_hex(obj->sha1); 381 fullrev = sha1_to_hex(obj->sha1);
382 shortrev = xstrdup(fullrev); 382 shortrev = xstrdup(fullrev);
383 shortrev[10] = '\0'; 383 shortrev[10] = '\0';
384 if (obj->type == OBJ_COMMIT) { 384 if (obj->type == OBJ_COMMIT) {
385 cgit_commit_link(fmt("commit %s...", shortrev), NULL, NULL, 385 cgit_commit_link(fmt("commit %s...", shortrev), NULL, NULL,
386 ctx.qry.head, fullrev); 386 ctx.qry.head, fullrev);
387 return; 387 return;
388 } else if (obj->type == OBJ_TREE) 388 } else if (obj->type == OBJ_TREE)
389 page = "tree"; 389 page = "tree";
390 else if (obj->type == OBJ_TAG) 390 else if (obj->type == OBJ_TAG)
391 page = "tag"; 391 page = "tag";
392 else 392 else
393 page = "blob"; 393 page = "blob";
394 name = fmt("%s %s...", typename(obj->type), shortrev); 394 name = fmt("%s %s...", typename(obj->type), shortrev);
395 reporevlink(page, name, NULL, NULL, ctx.qry.head, fullrev, NULL); 395 reporevlink(page, name, NULL, NULL, ctx.qry.head, fullrev, NULL);
396} 396}
397 397
398void cgit_print_date(time_t secs, char *format, int local_time) 398void cgit_print_date(time_t secs, char *format, int local_time)
399{ 399{
400 char buf[64]; 400 char buf[64];
401 struct tm *time; 401 struct tm *time;
402 402
403 if (!secs) 403 if (!secs)
404 return; 404 return;
405 if(local_time) 405 if(local_time)
406 time = localtime(&secs); 406 time = localtime(&secs);
407 else 407 else