|
diff --git a/shared.c b/shared.c index 6adf2b6..72ac140 100644 --- a/ shared.c+++ b/ shared.c |
|
@@ -1,88 +1,89 @@ |
1 | /* shared.c: global vars + some callback functions |
1 | /* shared.c: global vars + some callback functions |
2 | * |
2 | * |
3 | * Copyright (C) 2006 Lars Hjemli |
3 | * Copyright (C) 2006 Lars Hjemli |
4 | * |
4 | * |
5 | * Licensed under GNU General Public License v2 |
5 | * Licensed under GNU General Public License v2 |
6 | * (see COPYING for full license text) |
6 | * (see COPYING for full license text) |
7 | */ |
7 | */ |
8 | |
8 | |
9 | #include "cgit.h" |
9 | #include "cgit.h" |
10 | |
10 | |
11 | struct cgit_repolist cgit_repolist; |
11 | struct cgit_repolist cgit_repolist; |
12 | struct cgit_context ctx; |
12 | struct cgit_context ctx; |
13 | int cgit_cmd; |
| |
14 | |
13 | |
15 | int chk_zero(int result, char *msg) |
14 | int chk_zero(int result, char *msg) |
16 | { |
15 | { |
17 | if (result != 0) |
16 | if (result != 0) |
18 | die("%s: %s", msg, strerror(errno)); |
17 | die("%s: %s", msg, strerror(errno)); |
19 | return result; |
18 | return result; |
20 | } |
19 | } |
21 | |
20 | |
22 | int chk_positive(int result, char *msg) |
21 | int chk_positive(int result, char *msg) |
23 | { |
22 | { |
24 | if (result <= 0) |
23 | if (result <= 0) |
25 | die("%s: %s", msg, strerror(errno)); |
24 | die("%s: %s", msg, strerror(errno)); |
26 | return result; |
25 | return result; |
27 | } |
26 | } |
28 | |
27 | |
29 | int chk_non_negative(int result, char *msg) |
28 | int chk_non_negative(int result, char *msg) |
30 | { |
29 | { |
31 | if (result < 0) |
30 | if (result < 0) |
32 | die("%s: %s",msg, strerror(errno)); |
31 | die("%s: %s",msg, strerror(errno)); |
33 | return result; |
32 | return result; |
34 | } |
33 | } |
35 | |
34 | |
36 | struct cgit_repo *cgit_add_repo(const char *url) |
35 | struct cgit_repo *cgit_add_repo(const char *url) |
37 | { |
36 | { |
38 | struct cgit_repo *ret; |
37 | struct cgit_repo *ret; |
39 | |
38 | |
40 | if (++cgit_repolist.count > cgit_repolist.length) { |
39 | if (++cgit_repolist.count > cgit_repolist.length) { |
41 | if (cgit_repolist.length == 0) |
40 | if (cgit_repolist.length == 0) |
42 | cgit_repolist.length = 8; |
41 | cgit_repolist.length = 8; |
43 | else |
42 | else |
44 | cgit_repolist.length *= 2; |
43 | cgit_repolist.length *= 2; |
45 | cgit_repolist.repos = xrealloc(cgit_repolist.repos, |
44 | cgit_repolist.repos = xrealloc(cgit_repolist.repos, |
46 | cgit_repolist.length * |
45 | cgit_repolist.length * |
47 | sizeof(struct cgit_repo)); |
46 | sizeof(struct cgit_repo)); |
48 | } |
47 | } |
49 | |
48 | |
50 | ret = &cgit_repolist.repos[cgit_repolist.count-1]; |
49 | ret = &cgit_repolist.repos[cgit_repolist.count-1]; |
51 | memset(ret, 0, sizeof(struct cgit_repo)); |
50 | memset(ret, 0, sizeof(struct cgit_repo)); |
52 | ret->url = trim_end(url, '/'); |
51 | ret->url = trim_end(url, '/'); |
53 | ret->name = ret->url; |
52 | ret->name = ret->url; |
54 | ret->path = NULL; |
53 | ret->path = NULL; |
55 | ret->desc = "[no description]"; |
54 | ret->desc = "[no description]"; |
56 | ret->owner = NULL; |
55 | ret->owner = NULL; |
57 | ret->section = ctx.cfg.section; |
56 | ret->section = ctx.cfg.section; |
58 | ret->defbranch = "master"; |
57 | ret->defbranch = "master"; |
59 | ret->snapshots = ctx.cfg.snapshots; |
58 | ret->snapshots = ctx.cfg.snapshots; |
60 | ret->enable_log_filecount = ctx.cfg.enable_log_filecount; |
59 | ret->enable_log_filecount = ctx.cfg.enable_log_filecount; |
61 | ret->enable_log_linecount = ctx.cfg.enable_log_linecount; |
60 | ret->enable_log_linecount = ctx.cfg.enable_log_linecount; |
| |
61 | ret->enable_remote_branches = ctx.cfg.enable_remote_branches; |
| |
62 | ret->enable_subject_links = ctx.cfg.enable_subject_links; |
62 | ret->max_stats = ctx.cfg.max_stats; |
63 | ret->max_stats = ctx.cfg.max_stats; |
63 | ret->module_link = ctx.cfg.module_link; |
64 | ret->module_link = ctx.cfg.module_link; |
64 | ret->readme = NULL; |
65 | ret->readme = ctx.cfg.readme; |
65 | ret->mtime = -1; |
66 | ret->mtime = -1; |
66 | ret->about_filter = ctx.cfg.about_filter; |
67 | ret->about_filter = ctx.cfg.about_filter; |
67 | ret->commit_filter = ctx.cfg.commit_filter; |
68 | ret->commit_filter = ctx.cfg.commit_filter; |
68 | ret->source_filter = ctx.cfg.source_filter; |
69 | ret->source_filter = ctx.cfg.source_filter; |
69 | return ret; |
70 | return ret; |
70 | } |
71 | } |
71 | |
72 | |
72 | struct cgit_repo *cgit_get_repoinfo(const char *url) |
73 | struct cgit_repo *cgit_get_repoinfo(const char *url) |
73 | { |
74 | { |
74 | int i; |
75 | int i; |
75 | struct cgit_repo *repo; |
76 | struct cgit_repo *repo; |
76 | |
77 | |
77 | for (i=0; i<cgit_repolist.count; i++) { |
78 | for (i=0; i<cgit_repolist.count; i++) { |
78 | repo = &cgit_repolist.repos[i]; |
79 | repo = &cgit_repolist.repos[i]; |
79 | if (!strcmp(repo->url, url)) |
80 | if (!strcmp(repo->url, url)) |
80 | return repo; |
81 | return repo; |
81 | } |
82 | } |
82 | return NULL; |
83 | return NULL; |
83 | } |
84 | } |
84 | |
85 | |
85 | void *cgit_free_commitinfo(struct commitinfo *info) |
86 | void *cgit_free_commitinfo(struct commitinfo *info) |
86 | { |
87 | { |
87 | free(info->author); |
88 | free(info->author); |
88 | free(info->author_email); |
89 | free(info->author_email); |
@@ -241,125 +242,131 @@ int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf) |
241 | |
242 | |
242 | /* we have a complete line */ |
243 | /* we have a complete line */ |
243 | if (!diffbuf) { |
244 | if (!diffbuf) { |
244 | ((linediff_fn)priv)(mb[i].ptr, mb[i].size); |
245 | ((linediff_fn)priv)(mb[i].ptr, mb[i].size); |
245 | continue; |
246 | continue; |
246 | } |
247 | } |
247 | diffbuf = xrealloc(diffbuf, buflen + mb[i].size); |
248 | diffbuf = xrealloc(diffbuf, buflen + mb[i].size); |
248 | memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); |
249 | memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); |
249 | ((linediff_fn)priv)(diffbuf, buflen + mb[i].size); |
250 | ((linediff_fn)priv)(diffbuf, buflen + mb[i].size); |
250 | free(diffbuf); |
251 | free(diffbuf); |
251 | diffbuf = NULL; |
252 | diffbuf = NULL; |
252 | buflen = 0; |
253 | buflen = 0; |
253 | } |
254 | } |
254 | if (diffbuf) { |
255 | if (diffbuf) { |
255 | ((linediff_fn)priv)(diffbuf, buflen); |
256 | ((linediff_fn)priv)(diffbuf, buflen); |
256 | free(diffbuf); |
257 | free(diffbuf); |
257 | diffbuf = NULL; |
258 | diffbuf = NULL; |
258 | buflen = 0; |
259 | buflen = 0; |
259 | } |
260 | } |
260 | return 0; |
261 | return 0; |
261 | } |
262 | } |
262 | |
263 | |
263 | int cgit_diff_files(const unsigned char *old_sha1, |
264 | int cgit_diff_files(const unsigned char *old_sha1, |
264 | const unsigned char *new_sha1, unsigned long *old_size, |
265 | const unsigned char *new_sha1, unsigned long *old_size, |
265 | unsigned long *new_size, int *binary, linediff_fn fn) |
266 | unsigned long *new_size, int *binary, int context, |
| |
267 | int ignorews, linediff_fn fn) |
266 | { |
268 | { |
267 | mmfile_t file1, file2; |
269 | mmfile_t file1, file2; |
268 | xpparam_t diff_params; |
270 | xpparam_t diff_params; |
269 | xdemitconf_t emit_params; |
271 | xdemitconf_t emit_params; |
270 | xdemitcb_t emit_cb; |
272 | xdemitcb_t emit_cb; |
271 | |
273 | |
272 | if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1)) |
274 | if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1)) |
273 | return 1; |
275 | return 1; |
274 | |
276 | |
275 | *old_size = file1.size; |
277 | *old_size = file1.size; |
276 | *new_size = file2.size; |
278 | *new_size = file2.size; |
277 | |
279 | |
278 | if ((file1.ptr && buffer_is_binary(file1.ptr, file1.size)) || |
280 | if ((file1.ptr && buffer_is_binary(file1.ptr, file1.size)) || |
279 | (file2.ptr && buffer_is_binary(file2.ptr, file2.size))) { |
281 | (file2.ptr && buffer_is_binary(file2.ptr, file2.size))) { |
280 | *binary = 1; |
282 | *binary = 1; |
281 | if (file1.size) |
283 | if (file1.size) |
282 | free(file1.ptr); |
284 | free(file1.ptr); |
283 | if (file2.size) |
285 | if (file2.size) |
284 | free(file2.ptr); |
286 | free(file2.ptr); |
285 | return 0; |
287 | return 0; |
286 | } |
288 | } |
287 | |
289 | |
288 | memset(&diff_params, 0, sizeof(diff_params)); |
290 | memset(&diff_params, 0, sizeof(diff_params)); |
289 | memset(&emit_params, 0, sizeof(emit_params)); |
291 | memset(&emit_params, 0, sizeof(emit_params)); |
290 | memset(&emit_cb, 0, sizeof(emit_cb)); |
292 | memset(&emit_cb, 0, sizeof(emit_cb)); |
291 | diff_params.flags = XDF_NEED_MINIMAL; |
293 | diff_params.flags = XDF_NEED_MINIMAL; |
292 | emit_params.ctxlen = 3; |
294 | if (ignorews) |
| |
295 | diff_params.flags |= XDF_IGNORE_WHITESPACE; |
| |
296 | emit_params.ctxlen = context > 0 ? context : 3; |
293 | emit_params.flags = XDL_EMIT_FUNCNAMES; |
297 | emit_params.flags = XDL_EMIT_FUNCNAMES; |
294 | emit_cb.outf = filediff_cb; |
298 | emit_cb.outf = filediff_cb; |
295 | emit_cb.priv = fn; |
299 | emit_cb.priv = fn; |
296 | xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb); |
300 | xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb); |
297 | if (file1.size) |
301 | if (file1.size) |
298 | free(file1.ptr); |
302 | free(file1.ptr); |
299 | if (file2.size) |
303 | if (file2.size) |
300 | free(file2.ptr); |
304 | free(file2.ptr); |
301 | return 0; |
305 | return 0; |
302 | } |
306 | } |
303 | |
307 | |
304 | void cgit_diff_tree(const unsigned char *old_sha1, |
308 | void cgit_diff_tree(const unsigned char *old_sha1, |
305 | const unsigned char *new_sha1, |
309 | const unsigned char *new_sha1, |
306 | filepair_fn fn, const char *prefix) |
310 | filepair_fn fn, const char *prefix, int ignorews) |
307 | { |
311 | { |
308 | struct diff_options opt; |
312 | struct diff_options opt; |
309 | int ret; |
313 | int ret; |
310 | int prefixlen; |
314 | int prefixlen; |
311 | |
315 | |
312 | diff_setup(&opt); |
316 | diff_setup(&opt); |
313 | opt.output_format = DIFF_FORMAT_CALLBACK; |
317 | opt.output_format = DIFF_FORMAT_CALLBACK; |
314 | opt.detect_rename = 1; |
318 | opt.detect_rename = 1; |
315 | opt.rename_limit = ctx.cfg.renamelimit; |
319 | opt.rename_limit = ctx.cfg.renamelimit; |
316 | DIFF_OPT_SET(&opt, RECURSIVE); |
320 | DIFF_OPT_SET(&opt, RECURSIVE); |
| |
321 | if (ignorews) |
| |
322 | DIFF_XDL_SET(&opt, IGNORE_WHITESPACE); |
317 | opt.format_callback = cgit_diff_tree_cb; |
323 | opt.format_callback = cgit_diff_tree_cb; |
318 | opt.format_callback_data = fn; |
324 | opt.format_callback_data = fn; |
319 | if (prefix) { |
325 | if (prefix) { |
320 | opt.nr_paths = 1; |
326 | opt.nr_paths = 1; |
321 | opt.paths = &prefix; |
327 | opt.paths = &prefix; |
322 | prefixlen = strlen(prefix); |
328 | prefixlen = strlen(prefix); |
323 | opt.pathlens = &prefixlen; |
329 | opt.pathlens = &prefixlen; |
324 | } |
330 | } |
325 | diff_setup_done(&opt); |
331 | diff_setup_done(&opt); |
326 | |
332 | |
327 | if (old_sha1 && !is_null_sha1(old_sha1)) |
333 | if (old_sha1 && !is_null_sha1(old_sha1)) |
328 | ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt); |
334 | ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt); |
329 | else |
335 | else |
330 | ret = diff_root_tree_sha1(new_sha1, "", &opt); |
336 | ret = diff_root_tree_sha1(new_sha1, "", &opt); |
331 | diffcore_std(&opt); |
337 | diffcore_std(&opt); |
332 | diff_flush(&opt); |
338 | diff_flush(&opt); |
333 | } |
339 | } |
334 | |
340 | |
335 | void cgit_diff_commit(struct commit *commit, filepair_fn fn) |
341 | void cgit_diff_commit(struct commit *commit, filepair_fn fn) |
336 | { |
342 | { |
337 | unsigned char *old_sha1 = NULL; |
343 | unsigned char *old_sha1 = NULL; |
338 | |
344 | |
339 | if (commit->parents) |
345 | if (commit->parents) |
340 | old_sha1 = commit->parents->item->object.sha1; |
346 | old_sha1 = commit->parents->item->object.sha1; |
341 | 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); |
342 | } |
349 | } |
343 | |
350 | |
344 | int cgit_parse_snapshots_mask(const char *str) |
351 | int cgit_parse_snapshots_mask(const char *str) |
345 | { |
352 | { |
346 | const struct cgit_snapshot_format *f; |
353 | const struct cgit_snapshot_format *f; |
347 | static const char *delim = " \t,:/|;"; |
354 | static const char *delim = " \t,:/|;"; |
348 | int tl, sl, rv = 0; |
355 | int tl, sl, rv = 0; |
349 | |
356 | |
350 | /* favor legacy setting */ |
357 | /* favor legacy setting */ |
351 | if(atoi(str)) |
358 | if(atoi(str)) |
352 | return 1; |
359 | return 1; |
353 | for(;;) { |
360 | for(;;) { |
354 | str += strspn(str,delim); |
361 | str += strspn(str,delim); |
355 | tl = strcspn(str,delim); |
362 | tl = strcspn(str,delim); |
356 | if (!tl) |
363 | if (!tl) |
357 | break; |
364 | break; |
358 | for (f = cgit_snapshot_formats; f->suffix; f++) { |
365 | for (f = cgit_snapshot_formats; f->suffix; f++) { |
359 | sl = strlen(f->suffix); |
366 | sl = strlen(f->suffix); |
360 | if((tl == sl && !strncmp(f->suffix, str, tl)) || |
367 | if((tl == sl && !strncmp(f->suffix, str, tl)) || |
361 | (tl == sl-1 && !strncmp(f->suffix+1, str, tl-1))) { |
368 | (tl == sl-1 && !strncmp(f->suffix+1, str, tl-1))) { |
362 | rv |= f->bit; |
369 | rv |= f->bit; |
363 | break; |
370 | break; |
364 | } |
371 | } |
365 | } |
372 | } |
@@ -409,24 +416,95 @@ int cgit_close_filter(struct cgit_filter *filter) |
409 | int readfile(const char *path, char **buf, size_t *size) |
416 | int readfile(const char *path, char **buf, size_t *size) |
410 | { |
417 | { |
411 | int fd, e; |
418 | int fd, e; |
412 | struct stat st; |
419 | struct stat st; |
413 | |
420 | |
414 | fd = open(path, O_RDONLY); |
421 | fd = open(path, O_RDONLY); |
415 | if (fd == -1) |
422 | if (fd == -1) |
416 | return errno; |
423 | return errno; |
417 | if (fstat(fd, &st)) { |
424 | if (fstat(fd, &st)) { |
418 | e = errno; |
425 | e = errno; |
419 | close(fd); |
426 | close(fd); |
420 | return e; |
427 | return e; |
421 | } |
428 | } |
422 | if (!S_ISREG(st.st_mode)) { |
429 | if (!S_ISREG(st.st_mode)) { |
423 | close(fd); |
430 | close(fd); |
424 | return EISDIR; |
431 | return EISDIR; |
425 | } |
432 | } |
426 | *buf = xmalloc(st.st_size + 1); |
433 | *buf = xmalloc(st.st_size + 1); |
427 | *size = read_in_full(fd, *buf, st.st_size); |
434 | *size = read_in_full(fd, *buf, st.st_size); |
428 | e = errno; |
435 | e = errno; |
429 | (*buf)[*size] = '\0'; |
436 | (*buf)[*size] = '\0'; |
430 | close(fd); |
437 | close(fd); |
431 | return (*size == st.st_size ? 0 : e); |
438 | return (*size == st.st_size ? 0 : e); |
432 | } |
439 | } |
| |
440 | |
| |
441 | int is_token_char(char c) |
| |
442 | { |
| |
443 | return isalnum(c) || c == '_'; |
| |
444 | } |
| |
445 | |
| |
446 | /* Replace name with getenv(name), return pointer to zero-terminating char |
| |
447 | */ |
| |
448 | char *expand_macro(char *name, int maxlength) |
| |
449 | { |
| |
450 | char *value; |
| |
451 | int len; |
| |
452 | |
| |
453 | len = 0; |
| |
454 | value = getenv(name); |
| |
455 | if (value) { |
| |
456 | len = strlen(value); |
| |
457 | if (len > maxlength) |
| |
458 | len = maxlength; |
| |
459 | strncpy(name, value, len); |
| |
460 | } |
| |
461 | return name + len; |
| |
462 | } |
| |
463 | |
| |
464 | #define EXPBUFSIZE (1024 * 8) |
| |
465 | |
| |
466 | /* Replace all tokens prefixed by '$' in the specified text with the |
| |
467 | * value of the named environment variable. |
| |
468 | * NB: the return value is a static buffer, i.e. it must be strdup'd |
| |
469 | * by the caller. |
| |
470 | */ |
| |
471 | char *expand_macros(const char *txt) |
| |
472 | { |
| |
473 | static char result[EXPBUFSIZE]; |
| |
474 | char *p, *start; |
| |
475 | int len; |
| |
476 | |
| |
477 | p = result; |
| |
478 | start = NULL; |
| |
479 | while (p < result + EXPBUFSIZE - 1 && txt && *txt) { |
| |
480 | *p = *txt; |
| |
481 | if (start) { |
| |
482 | if (!is_token_char(*txt)) { |
| |
483 | if (p - start > 0) { |
| |
484 | *p = '\0'; |
| |
485 | len = result + EXPBUFSIZE - start - 1; |
| |
486 | p = expand_macro(start, len) - 1; |
| |
487 | } |
| |
488 | start = NULL; |
| |
489 | txt--; |
| |
490 | } |
| |
491 | p++; |
| |
492 | txt++; |
| |
493 | continue; |
| |
494 | } |
| |
495 | if (*txt == '$') { |
| |
496 | start = p; |
| |
497 | txt++; |
| |
498 | continue; |
| |
499 | } |
| |
500 | p++; |
| |
501 | txt++; |
| |
502 | } |
| |
503 | *p = '\0'; |
| |
504 | if (start && p - start > 0) { |
| |
505 | len = result + EXPBUFSIZE - start - 1; |
| |
506 | p = expand_macro(start, len); |
| |
507 | *p = '\0'; |
| |
508 | } |
| |
509 | return result; |
| |
510 | } |
|