|
diff --git a/cache.c b/cache.c index 0ffa502..2e1ef8c 100644 --- a/ cache.c+++ b/ cache.c |
|
@@ -1,98 +1,107 @@ |
1 | /* cache.c: cache management |
1 | /* cache.c: cache management |
2 | * |
2 | * |
3 | * Copyright (C) 2006 Lars Hjemli |
3 | * Copyright (C) 2006 Lars Hjemli |
4 | * |
4 | * |
5 | * Licensed under GNU General Public License v2 |
5 | * Licensed under GNU General Public License v2 |
6 | * (see COPYING for full license text) |
6 | * (see COPYING for full license text) |
7 | */ |
7 | */ |
8 | |
8 | |
9 | #include "cgit.h" |
9 | #include "cgit.h" |
10 | |
10 | |
11 | const int NOLOCK = -1; |
11 | const int NOLOCK = -1; |
12 | |
12 | |
13 | void cache_prepare(struct cacheitem *item) |
13 | void cache_prepare(struct cacheitem *item) |
14 | { |
14 | { |
15 | if (!cgit_query_repo) { |
15 | if (!cgit_query_repo) { |
16 | item->name = xstrdup(fmt("%s/index.html", cgit_cache_root)); |
16 | item->name = xstrdup(fmt("%s/index.html", cgit_cache_root)); |
17 | item->ttl = cgit_cache_root_ttl; |
17 | item->ttl = cgit_cache_root_ttl; |
18 | } else if (!cgit_query_page) { |
18 | } else if (!cgit_query_page) { |
19 | item->name = xstrdup(fmt("%s/%s/index.html", cgit_cache_root, |
19 | item->name = xstrdup(fmt("%s/%s/index.html", cgit_cache_root, |
20 | cgit_query_repo)); |
20 | cgit_query_repo)); |
21 | item->ttl = cgit_cache_repo_ttl; |
21 | item->ttl = cgit_cache_repo_ttl; |
22 | } else { |
22 | } else { |
23 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root, |
23 | item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root, |
24 | cgit_query_repo, cgit_query_page, |
24 | cgit_query_repo, cgit_query_page, |
25 | cgit_querystring)); |
25 | cgit_querystring)); |
26 | if (cgit_query_has_symref) |
26 | if (cgit_query_has_symref) |
27 | item->ttl = cgit_cache_dynamic_ttl; |
27 | item->ttl = cgit_cache_dynamic_ttl; |
28 | else if (cgit_query_has_sha1) |
28 | else if (cgit_query_has_sha1) |
29 | item->ttl = cgit_cache_static_ttl; |
29 | item->ttl = cgit_cache_static_ttl; |
30 | else |
30 | else |
31 | item->ttl = cgit_cache_repo_ttl; |
31 | item->ttl = cgit_cache_repo_ttl; |
32 | } |
32 | } |
33 | } |
33 | } |
34 | |
34 | |
35 | int cache_exist(struct cacheitem *item) |
35 | int cache_exist(struct cacheitem *item) |
36 | { |
36 | { |
37 | if (stat(item->name, &item->st)) { |
37 | if (stat(item->name, &item->st)) { |
38 | item->st.st_mtime = 0; |
38 | item->st.st_mtime = 0; |
39 | return 0; |
39 | return 0; |
40 | } |
40 | } |
41 | return 1; |
41 | return 1; |
42 | } |
42 | } |
43 | |
43 | |
44 | int cache_create_dirs() |
44 | int cache_create_dirs() |
45 | { |
45 | { |
46 | char *path; |
46 | char *path; |
47 | |
47 | |
48 | if (!cgit_query_repo) |
48 | if (!cgit_query_repo) |
49 | return 0; |
49 | return 0; |
50 | |
50 | |
51 | path = fmt("%s/%s", cgit_cache_root, cgit_query_repo); |
51 | path = fmt("%s/%s", cgit_cache_root, cgit_query_repo); |
52 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
52 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
53 | return 0; |
53 | return 0; |
54 | |
54 | |
55 | if (cgit_query_page) { |
55 | if (cgit_query_page) { |
56 | path = fmt("%s/%s/%s", cgit_cache_root, cgit_query_repo, |
56 | path = fmt("%s/%s/%s", cgit_cache_root, cgit_query_repo, |
57 | cgit_query_page); |
57 | cgit_query_page); |
58 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
58 | if (mkdir(path, S_IRWXU) && errno!=EEXIST) |
59 | return 0; |
59 | return 0; |
60 | } |
60 | } |
61 | return 1; |
61 | return 1; |
62 | } |
62 | } |
63 | |
63 | |
| |
64 | int cache_refill_overdue(const char *lockfile) |
| |
65 | { |
| |
66 | struct stat st; |
| |
67 | |
| |
68 | if (stat(lockfile, &st)) |
| |
69 | return 0; |
| |
70 | else |
| |
71 | return (time(NULL) - st.st_mtime > cgit_cache_max_create_time); |
| |
72 | } |
| |
73 | |
64 | int cache_lock(struct cacheitem *item) |
74 | int cache_lock(struct cacheitem *item) |
65 | { |
75 | { |
66 | int ret; |
76 | int i = 0; |
67 | char *lockfile = fmt("%s.lock", item->name); |
77 | char *lockfile = fmt("%s.lock", item->name); |
68 | |
78 | |
69 | top: |
79 | top: |
70 | item->fd = open(lockfile, O_WRONLY | O_CREAT | O_EXCL, S_IRUSR|S_IWUSR); |
80 | if (++i > cgit_max_lock_attempts) |
| |
81 | die("cache_lock: unable to lock %s: %s", |
| |
82 | item->name, strerror(errno)); |
| |
83 | |
| |
84 | item->fd = open(lockfile, O_WRONLY|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR); |
| |
85 | |
71 | if (item->fd == NOLOCK && errno == ENOENT && cache_create_dirs()) |
86 | if (item->fd == NOLOCK && errno == ENOENT && cache_create_dirs()) |
72 | goto top; |
87 | goto top; |
73 | if (item->fd == NOLOCK && errno == EEXIST) { |
88 | |
74 | struct stat st; |
89 | if (item->fd == NOLOCK && errno == EEXIST && |
75 | time_t t; |
90 | cache_refill_overdue(lockfile) && !unlink(lockfile)) |
76 | if (stat(lockfile, &st)) |
| |
77 | return ret; |
| |
78 | t = time(NULL); |
| |
79 | if (t-st.st_mtime > cgit_cache_max_create_time && |
| |
80 | !unlink(lockfile)) |
| |
81 | goto top; |
91 | goto top; |
82 | return 0; |
92 | |
83 | } |
| |
84 | return (item->fd > 0); |
93 | return (item->fd > 0); |
85 | } |
94 | } |
86 | |
95 | |
87 | int cache_unlock(struct cacheitem *item) |
96 | int cache_unlock(struct cacheitem *item) |
88 | { |
97 | { |
89 | close(item->fd); |
98 | close(item->fd); |
90 | return (rename(fmt("%s.lock", item->name), item->name) == 0); |
99 | return (rename(fmt("%s.lock", item->name), item->name) == 0); |
91 | } |
100 | } |
92 | |
101 | |
93 | int cache_expired(struct cacheitem *item) |
102 | int cache_expired(struct cacheitem *item) |
94 | { |
103 | { |
95 | if (item->ttl < 0) |
104 | if (item->ttl < 0) |
96 | return 0; |
105 | return 0; |
97 | return item->st.st_mtime + item->ttl * 60 < time(NULL); |
106 | return item->st.st_mtime + item->ttl * 60 < time(NULL); |
98 | } |
107 | } |
|
|
diff --git a/cgit.c b/cgit.c index 7f14016..dc91125 100644 --- a/ cgit.c+++ b/ cgit.c |
|
@@ -1,129 +1,130 @@ |
1 | /* cgit.c: cgi for the git scm |
1 | /* cgit.c: cgi for the git scm |
2 | * |
2 | * |
3 | * Copyright (C) 2006 Lars Hjemli |
3 | * Copyright (C) 2006 Lars Hjemli |
4 | * |
4 | * |
5 | * Licensed under GNU General Public License v2 |
5 | * Licensed under GNU General Public License v2 |
6 | * (see COPYING for full license text) |
6 | * (see COPYING for full license text) |
7 | */ |
7 | */ |
8 | |
8 | |
9 | #include "cgit.h" |
9 | #include "cgit.h" |
10 | |
10 | |
11 | const char cgit_version[] = CGIT_VERSION; |
11 | const char cgit_version[] = CGIT_VERSION; |
12 | |
12 | |
13 | const char cgit_doctype[] = |
13 | const char cgit_doctype[] = |
14 | "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n" |
14 | "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n" |
15 | " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"; |
15 | " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"; |
16 | |
16 | |
17 | const char cgit_error[] = |
17 | const char cgit_error[] = |
18 | "<div class='error'>%s</div>"; |
18 | "<div class='error'>%s</div>"; |
19 | |
19 | |
20 | const char cgit_lib_error[] = |
20 | const char cgit_lib_error[] = |
21 | "<div class='error'>%s: %s</div>"; |
21 | "<div class='error'>%s: %s</div>"; |
22 | |
22 | |
23 | int htmlfd = 0; |
23 | int htmlfd = 0; |
24 | |
24 | |
25 | char *cgit_root = "/usr/src/git"; |
25 | char *cgit_root = "/usr/src/git"; |
26 | char *cgit_root_title = "Git repository browser"; |
26 | char *cgit_root_title = "Git repository browser"; |
27 | char *cgit_css = "/cgit.css"; |
27 | char *cgit_css = "/cgit.css"; |
28 | char *cgit_logo = "/git-logo.png"; |
28 | char *cgit_logo = "/git-logo.png"; |
29 | char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; |
29 | char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; |
30 | char *cgit_virtual_root = NULL; |
30 | char *cgit_virtual_root = NULL; |
31 | |
31 | |
32 | char *cgit_cache_root = "/var/cache/cgit"; |
32 | char *cgit_cache_root = "/var/cache/cgit"; |
33 | |
33 | |
| |
34 | int cgit_max_lock_attempts = 5; |
34 | int cgit_cache_root_ttl = 5; |
35 | int cgit_cache_root_ttl = 5; |
35 | int cgit_cache_repo_ttl = 5; |
36 | int cgit_cache_repo_ttl = 5; |
36 | int cgit_cache_dynamic_ttl = 5; |
37 | int cgit_cache_dynamic_ttl = 5; |
37 | int cgit_cache_static_ttl = -1; |
38 | int cgit_cache_static_ttl = -1; |
38 | int cgit_cache_max_create_time = 5; |
39 | int cgit_cache_max_create_time = 5; |
39 | |
40 | |
40 | char *cgit_repo_name = NULL; |
41 | char *cgit_repo_name = NULL; |
41 | char *cgit_repo_desc = NULL; |
42 | char *cgit_repo_desc = NULL; |
42 | char *cgit_repo_owner = NULL; |
43 | char *cgit_repo_owner = NULL; |
43 | |
44 | |
44 | int cgit_query_has_symref = 0; |
45 | int cgit_query_has_symref = 0; |
45 | int cgit_query_has_sha1 = 0; |
46 | int cgit_query_has_sha1 = 0; |
46 | |
47 | |
47 | char *cgit_querystring = NULL; |
48 | char *cgit_querystring = NULL; |
48 | char *cgit_query_repo = NULL; |
49 | char *cgit_query_repo = NULL; |
49 | char *cgit_query_page = NULL; |
50 | char *cgit_query_page = NULL; |
50 | char *cgit_query_head = NULL; |
51 | char *cgit_query_head = NULL; |
51 | char *cgit_query_sha1 = NULL; |
52 | char *cgit_query_sha1 = NULL; |
52 | |
53 | |
53 | struct cacheitem cacheitem; |
54 | struct cacheitem cacheitem; |
54 | |
55 | |
55 | int cgit_parse_query(char *txt, configfn fn) |
56 | int cgit_parse_query(char *txt, configfn fn) |
56 | { |
57 | { |
57 | char *t, *value = NULL, c; |
58 | char *t, *value = NULL, c; |
58 | |
59 | |
59 | if (!txt) |
60 | if (!txt) |
60 | return 0; |
61 | return 0; |
61 | |
62 | |
62 | t = txt = xstrdup(txt); |
63 | t = txt = xstrdup(txt); |
63 | |
64 | |
64 | while((c=*t) != '\0') { |
65 | while((c=*t) != '\0') { |
65 | if (c=='=') { |
66 | if (c=='=') { |
66 | *t = '\0'; |
67 | *t = '\0'; |
67 | value = t+1; |
68 | value = t+1; |
68 | } else if (c=='&') { |
69 | } else if (c=='&') { |
69 | *t = '\0'; |
70 | *t = '\0'; |
70 | (*fn)(txt, value); |
71 | (*fn)(txt, value); |
71 | txt = t+1; |
72 | txt = t+1; |
72 | value = NULL; |
73 | value = NULL; |
73 | } |
74 | } |
74 | t++; |
75 | t++; |
75 | } |
76 | } |
76 | if (t!=txt) |
77 | if (t!=txt) |
77 | (*fn)(txt, value); |
78 | (*fn)(txt, value); |
78 | return 0; |
79 | return 0; |
79 | } |
80 | } |
80 | |
81 | |
81 | void cgit_global_config_cb(const char *name, const char *value) |
82 | void cgit_global_config_cb(const char *name, const char *value) |
82 | { |
83 | { |
83 | if (!strcmp(name, "root")) |
84 | if (!strcmp(name, "root")) |
84 | cgit_root = xstrdup(value); |
85 | cgit_root = xstrdup(value); |
85 | else if (!strcmp(name, "root-title")) |
86 | else if (!strcmp(name, "root-title")) |
86 | cgit_root_title = xstrdup(value); |
87 | cgit_root_title = xstrdup(value); |
87 | else if (!strcmp(name, "css")) |
88 | else if (!strcmp(name, "css")) |
88 | cgit_css = xstrdup(value); |
89 | cgit_css = xstrdup(value); |
89 | else if (!strcmp(name, "logo")) |
90 | else if (!strcmp(name, "logo")) |
90 | cgit_logo = xstrdup(value); |
91 | cgit_logo = xstrdup(value); |
91 | else if (!strcmp(name, "logo-link")) |
92 | else if (!strcmp(name, "logo-link")) |
92 | cgit_logo_link = xstrdup(value); |
93 | cgit_logo_link = xstrdup(value); |
93 | else if (!strcmp(name, "virtual-root")) |
94 | else if (!strcmp(name, "virtual-root")) |
94 | cgit_virtual_root = xstrdup(value); |
95 | cgit_virtual_root = xstrdup(value); |
95 | } |
96 | } |
96 | |
97 | |
97 | void cgit_repo_config_cb(const char *name, const char *value) |
98 | void cgit_repo_config_cb(const char *name, const char *value) |
98 | { |
99 | { |
99 | if (!strcmp(name, "name")) |
100 | if (!strcmp(name, "name")) |
100 | cgit_repo_name = xstrdup(value); |
101 | cgit_repo_name = xstrdup(value); |
101 | else if (!strcmp(name, "desc")) |
102 | else if (!strcmp(name, "desc")) |
102 | cgit_repo_desc = xstrdup(value); |
103 | cgit_repo_desc = xstrdup(value); |
103 | else if (!strcmp(name, "owner")) |
104 | else if (!strcmp(name, "owner")) |
104 | cgit_repo_owner = xstrdup(value); |
105 | cgit_repo_owner = xstrdup(value); |
105 | } |
106 | } |
106 | |
107 | |
107 | void cgit_querystring_cb(const char *name, const char *value) |
108 | void cgit_querystring_cb(const char *name, const char *value) |
108 | { |
109 | { |
109 | if (!strcmp(name,"r")) |
110 | if (!strcmp(name,"r")) |
110 | cgit_query_repo = xstrdup(value); |
111 | cgit_query_repo = xstrdup(value); |
111 | else if (!strcmp(name, "p")) |
112 | else if (!strcmp(name, "p")) |
112 | cgit_query_page = xstrdup(value); |
113 | cgit_query_page = xstrdup(value); |
113 | else if (!strcmp(name, "h")) { |
114 | else if (!strcmp(name, "h")) { |
114 | cgit_query_head = xstrdup(value); |
115 | cgit_query_head = xstrdup(value); |
115 | cgit_query_has_symref = 1; |
116 | cgit_query_has_symref = 1; |
116 | } else if (!strcmp(name, "id")) { |
117 | } else if (!strcmp(name, "id")) { |
117 | cgit_query_sha1 = xstrdup(value); |
118 | cgit_query_sha1 = xstrdup(value); |
118 | cgit_query_has_sha1 = 1; |
119 | cgit_query_has_sha1 = 1; |
119 | } |
120 | } |
120 | } |
121 | } |
121 | |
122 | |
122 | char *cgit_repourl(const char *reponame) |
123 | char *cgit_repourl(const char *reponame) |
123 | { |
124 | { |
124 | if (cgit_virtual_root) { |
125 | if (cgit_virtual_root) { |
125 | return fmt("%s/%s/", cgit_virtual_root, reponame); |
126 | return fmt("%s/%s/", cgit_virtual_root, reponame); |
126 | } else { |
127 | } else { |
127 | return fmt("?r=%s", reponame); |
128 | return fmt("?r=%s", reponame); |
128 | } |
129 | } |
129 | } |
130 | } |
@@ -372,137 +373,143 @@ static void cgit_print_log(const char *tip, int ofs, int cnt) |
372 | rev.verbose_header = 1; |
373 | rev.verbose_header = 1; |
373 | rev.show_root_diff = 0; |
374 | rev.show_root_diff = 0; |
374 | setup_revisions(2, argv, &rev, NULL); |
375 | setup_revisions(2, argv, &rev, NULL); |
375 | prepare_revision_walk(&rev); |
376 | prepare_revision_walk(&rev); |
376 | |
377 | |
377 | html("<h2>Log</h2>"); |
378 | html("<h2>Log</h2>"); |
378 | html("<table class='list'>"); |
379 | html("<table class='list'>"); |
379 | html("<tr><th>Date</th><th>Message</th><th>Author</th></tr>\n"); |
380 | html("<tr><th>Date</th><th>Message</th><th>Author</th></tr>\n"); |
380 | while ((commit = get_revision(&rev)) != NULL && n++ < 100) { |
381 | while ((commit = get_revision(&rev)) != NULL && n++ < 100) { |
381 | cgit_print_commit_shortlog(commit); |
382 | cgit_print_commit_shortlog(commit); |
382 | free(commit->buffer); |
383 | free(commit->buffer); |
383 | commit->buffer = NULL; |
384 | commit->buffer = NULL; |
384 | free_commit_list(commit->parents); |
385 | free_commit_list(commit->parents); |
385 | commit->parents = NULL; |
386 | commit->parents = NULL; |
386 | } |
387 | } |
387 | html("</table>\n"); |
388 | html("</table>\n"); |
388 | } |
389 | } |
389 | |
390 | |
390 | static void cgit_print_repo_summary() |
391 | static void cgit_print_repo_summary() |
391 | { |
392 | { |
392 | html("<h2>"); |
393 | html("<h2>"); |
393 | html_txt("Repo summary page"); |
394 | html_txt("Repo summary page"); |
394 | html("</h2>"); |
395 | html("</h2>"); |
395 | cgit_print_branches(); |
396 | cgit_print_branches(); |
396 | } |
397 | } |
397 | |
398 | |
398 | static void cgit_print_object(char *hex) |
399 | static void cgit_print_object(char *hex) |
399 | { |
400 | { |
400 | unsigned char sha1[20]; |
401 | unsigned char sha1[20]; |
401 | //struct object *object; |
402 | //struct object *object; |
402 | char type[20]; |
403 | char type[20]; |
403 | unsigned char *buf; |
404 | unsigned char *buf; |
404 | unsigned long size; |
405 | unsigned long size; |
405 | |
406 | |
406 | if (get_sha1_hex(hex, sha1)){ |
407 | if (get_sha1_hex(hex, sha1)){ |
407 | htmlf(cgit_error, "Bad hex value"); |
408 | htmlf(cgit_error, "Bad hex value"); |
408 | return; |
409 | return; |
409 | } |
410 | } |
410 | |
411 | |
411 | if (sha1_object_info(sha1, type, NULL)){ |
412 | if (sha1_object_info(sha1, type, NULL)){ |
412 | htmlf(cgit_error, "Bad object name"); |
413 | htmlf(cgit_error, "Bad object name"); |
413 | return; |
414 | return; |
414 | } |
415 | } |
415 | |
416 | |
416 | buf = read_sha1_file(sha1, type, &size); |
417 | buf = read_sha1_file(sha1, type, &size); |
417 | if (!buf) { |
418 | if (!buf) { |
418 | htmlf(cgit_error, "Error reading object"); |
419 | htmlf(cgit_error, "Error reading object"); |
419 | return; |
420 | return; |
420 | } |
421 | } |
421 | |
422 | |
422 | buf[size] = '\0'; |
423 | buf[size] = '\0'; |
423 | html("<h2>Object view</h2>"); |
424 | html("<h2>Object view</h2>"); |
424 | htmlf("sha1=%s<br/>type=%s<br/>size=%i<br/>", hex, type, size); |
425 | htmlf("sha1=%s<br/>type=%s<br/>size=%i<br/>", hex, type, size); |
425 | html("<pre>"); |
426 | html("<pre>"); |
426 | html_txt(buf); |
427 | html_txt(buf); |
427 | html("</pre>"); |
428 | html("</pre>"); |
428 | } |
429 | } |
429 | |
430 | |
430 | static void cgit_print_repo_page() |
431 | static void cgit_print_repo_page() |
431 | { |
432 | { |
432 | if (chdir(fmt("%s/%s", cgit_root, cgit_query_repo)) || |
433 | if (chdir(fmt("%s/%s", cgit_root, cgit_query_repo)) || |
433 | cgit_read_config("info/cgit", cgit_repo_config_cb)) { |
434 | cgit_read_config("info/cgit", cgit_repo_config_cb)) { |
434 | char *title = fmt("%s - %s", cgit_root_title, "Bad request"); |
435 | char *title = fmt("%s - %s", cgit_root_title, "Bad request"); |
435 | cgit_print_docstart(title); |
436 | cgit_print_docstart(title); |
436 | cgit_print_pageheader(title); |
437 | cgit_print_pageheader(title); |
437 | htmlf(cgit_lib_error, "Unable to scan repository", |
438 | htmlf(cgit_lib_error, "Unable to scan repository", |
438 | strerror(errno)); |
439 | strerror(errno)); |
439 | cgit_print_docend(); |
440 | cgit_print_docend(); |
440 | return; |
441 | return; |
441 | } |
442 | } |
442 | setenv("GIT_DIR", fmt("%s/%s", cgit_root, cgit_query_repo), 1); |
443 | setenv("GIT_DIR", fmt("%s/%s", cgit_root, cgit_query_repo), 1); |
443 | char *title = fmt("%s - %s", cgit_repo_name, cgit_repo_desc); |
444 | char *title = fmt("%s - %s", cgit_repo_name, cgit_repo_desc); |
444 | cgit_print_docstart(title); |
445 | cgit_print_docstart(title); |
445 | cgit_print_pageheader(title); |
446 | cgit_print_pageheader(title); |
446 | if (!cgit_query_page) |
447 | if (!cgit_query_page) |
447 | cgit_print_repo_summary(); |
448 | cgit_print_repo_summary(); |
448 | else if (!strcmp(cgit_query_page, "log")) { |
449 | else if (!strcmp(cgit_query_page, "log")) { |
449 | cgit_print_log(cgit_query_head, 0, 100); |
450 | cgit_print_log(cgit_query_head, 0, 100); |
450 | } else if (!strcmp(cgit_query_page, "view")) { |
451 | } else if (!strcmp(cgit_query_page, "view")) { |
451 | cgit_print_object(cgit_query_sha1); |
452 | cgit_print_object(cgit_query_sha1); |
452 | } |
453 | } |
453 | cgit_print_docend(); |
454 | cgit_print_docend(); |
454 | } |
455 | } |
455 | |
456 | |
456 | static void cgit_fill_cache(struct cacheitem *item) |
457 | static void cgit_fill_cache(struct cacheitem *item) |
457 | { |
458 | { |
458 | htmlfd = item->fd; |
459 | htmlfd = item->fd; |
459 | item->st.st_mtime = time(NULL); |
460 | item->st.st_mtime = time(NULL); |
460 | if (cgit_query_repo) |
461 | if (cgit_query_repo) |
461 | cgit_print_repo_page(); |
462 | cgit_print_repo_page(); |
462 | else |
463 | else |
463 | cgit_print_repolist(); |
464 | cgit_print_repolist(); |
464 | } |
465 | } |
465 | |
466 | |
466 | static void cgit_refresh_cache(struct cacheitem *item) |
467 | static void cgit_refresh_cache(struct cacheitem *item) |
467 | { |
468 | { |
| |
469 | int i = 0; |
| |
470 | |
468 | cache_prepare(item); |
471 | cache_prepare(item); |
469 | top: |
472 | top: |
| |
473 | if (++i > cgit_max_lock_attempts) { |
| |
474 | die("cgit_refresh_cache: unable to lock %s: %s", |
| |
475 | item->name, strerror(errno)); |
| |
476 | } |
470 | if (!cache_exist(item)) { |
477 | if (!cache_exist(item)) { |
471 | if (!cache_lock(item)) { |
478 | if (!cache_lock(item)) { |
472 | sched_yield(); |
479 | sleep(1); |
473 | goto top; |
480 | goto top; |
474 | } |
481 | } |
475 | if (!cache_exist(item)) |
482 | if (!cache_exist(item)) |
476 | cgit_fill_cache(item); |
483 | cgit_fill_cache(item); |
477 | cache_unlock(item); |
484 | cache_unlock(item); |
478 | } else if (cache_expired(item) && cache_lock(item)) { |
485 | } else if (cache_expired(item) && cache_lock(item)) { |
479 | if (cache_expired(item)) |
486 | if (cache_expired(item)) |
480 | cgit_fill_cache(item); |
487 | cgit_fill_cache(item); |
481 | cache_unlock(item); |
488 | cache_unlock(item); |
482 | } |
489 | } |
483 | } |
490 | } |
484 | |
491 | |
485 | static void cgit_print_cache(struct cacheitem *item) |
492 | static void cgit_print_cache(struct cacheitem *item) |
486 | { |
493 | { |
487 | static char buf[4096]; |
494 | static char buf[4096]; |
488 | ssize_t i; |
495 | ssize_t i; |
489 | |
496 | |
490 | int fd = open(item->name, O_RDONLY); |
497 | int fd = open(item->name, O_RDONLY); |
491 | if (fd<0) |
498 | if (fd<0) |
492 | die("Unable to open cached file %s", item->name); |
499 | die("Unable to open cached file %s", item->name); |
493 | |
500 | |
494 | while((i=read(fd, buf, sizeof(buf))) > 0) |
501 | while((i=read(fd, buf, sizeof(buf))) > 0) |
495 | write(STDOUT_FILENO, buf, i); |
502 | write(STDOUT_FILENO, buf, i); |
496 | |
503 | |
497 | close(fd); |
504 | close(fd); |
498 | } |
505 | } |
499 | |
506 | |
500 | int main(int argc, const char **argv) |
507 | int main(int argc, const char **argv) |
501 | { |
508 | { |
502 | cgit_read_config("/etc/cgitrc", cgit_global_config_cb); |
509 | cgit_read_config("/etc/cgitrc", cgit_global_config_cb); |
503 | cgit_querystring = xstrdup(getenv("QUERY_STRING")); |
510 | cgit_querystring = xstrdup(getenv("QUERY_STRING")); |
504 | cgit_parse_query(cgit_querystring, cgit_querystring_cb); |
511 | cgit_parse_query(cgit_querystring, cgit_querystring_cb); |
505 | cgit_refresh_cache(&cacheitem); |
512 | cgit_refresh_cache(&cacheitem); |
506 | cgit_print_cache(&cacheitem); |
513 | cgit_print_cache(&cacheitem); |
507 | return 0; |
514 | return 0; |
508 | } |
515 | } |
|
|
diff --git a/cgit.h b/cgit.h index 3b0994a..7e4bfef 100644 --- a/ cgit.h+++ b/ cgit.h |
|
@@ -1,65 +1,66 @@ |
1 | #ifndef CGIT_H |
1 | #ifndef CGIT_H |
2 | #define CGIT_H |
2 | #define CGIT_H |
3 | |
3 | |
4 | #include "git.h" |
4 | #include "git.h" |
5 | #include <openssl/sha.h> |
5 | #include <openssl/sha.h> |
6 | #include <ctype.h> |
6 | #include <ctype.h> |
7 | #include <sched.h> |
7 | #include <sched.h> |
8 | |
8 | |
9 | typedef void (*configfn)(const char *name, const char *value); |
9 | typedef void (*configfn)(const char *name, const char *value); |
10 | |
10 | |
11 | struct cacheitem { |
11 | struct cacheitem { |
12 | char *name; |
12 | char *name; |
13 | struct stat st; |
13 | struct stat st; |
14 | int ttl; |
14 | int ttl; |
15 | int fd; |
15 | int fd; |
16 | }; |
16 | }; |
17 | |
17 | |
18 | extern char *cgit_root; |
18 | extern char *cgit_root; |
19 | extern char *cgit_root_title; |
19 | extern char *cgit_root_title; |
20 | extern char *cgit_css; |
20 | extern char *cgit_css; |
21 | extern char *cgit_logo; |
21 | extern char *cgit_logo; |
22 | extern char *cgit_logo_link; |
22 | extern char *cgit_logo_link; |
23 | extern char *cgit_virtual_root; |
23 | extern char *cgit_virtual_root; |
24 | extern char *cgit_cache_root; |
24 | extern char *cgit_cache_root; |
25 | |
25 | |
| |
26 | extern int cgit_max_lock_attempts; |
26 | extern int cgit_cache_root_ttl; |
27 | extern int cgit_cache_root_ttl; |
27 | extern int cgit_cache_repo_ttl; |
28 | extern int cgit_cache_repo_ttl; |
28 | extern int cgit_cache_dynamic_ttl; |
29 | extern int cgit_cache_dynamic_ttl; |
29 | extern int cgit_cache_static_ttl; |
30 | extern int cgit_cache_static_ttl; |
30 | extern int cgit_cache_max_create_time; |
31 | extern int cgit_cache_max_create_time; |
31 | |
32 | |
32 | extern char *cgit_repo_name; |
33 | extern char *cgit_repo_name; |
33 | extern char *cgit_repo_desc; |
34 | extern char *cgit_repo_desc; |
34 | extern char *cgit_repo_owner; |
35 | extern char *cgit_repo_owner; |
35 | |
36 | |
36 | extern int cgit_query_has_symref; |
37 | extern int cgit_query_has_symref; |
37 | extern int cgit_query_has_sha1; |
38 | extern int cgit_query_has_sha1; |
38 | |
39 | |
39 | extern char *cgit_querystring; |
40 | extern char *cgit_querystring; |
40 | extern char *cgit_query_repo; |
41 | extern char *cgit_query_repo; |
41 | extern char *cgit_query_page; |
42 | extern char *cgit_query_page; |
42 | extern char *cgit_query_head; |
43 | extern char *cgit_query_head; |
43 | extern char *cgit_query_sha1; |
44 | extern char *cgit_query_sha1; |
44 | |
45 | |
45 | extern int htmlfd; |
46 | extern int htmlfd; |
46 | |
47 | |
47 | extern char *fmt(const char *format,...); |
48 | extern char *fmt(const char *format,...); |
48 | |
49 | |
49 | extern void html(const char *txt); |
50 | extern void html(const char *txt); |
50 | extern void htmlf(const char *format,...); |
51 | extern void htmlf(const char *format,...); |
51 | extern void html_txt(char *txt); |
52 | extern void html_txt(char *txt); |
52 | extern void html_attr(char *txt); |
53 | extern void html_attr(char *txt); |
53 | extern void html_link_open(char *url, char *title, char *class); |
54 | extern void html_link_open(char *url, char *title, char *class); |
54 | extern void html_link_close(void); |
55 | extern void html_link_close(void); |
55 | |
56 | |
56 | |
57 | |
57 | extern int cgit_read_config(const char *filename, configfn fn); |
58 | extern int cgit_read_config(const char *filename, configfn fn); |
58 | |
59 | |
59 | extern void cache_prepare(struct cacheitem *item); |
60 | extern void cache_prepare(struct cacheitem *item); |
60 | extern int cache_lock(struct cacheitem *item); |
61 | extern int cache_lock(struct cacheitem *item); |
61 | extern int cache_unlock(struct cacheitem *item); |
62 | extern int cache_unlock(struct cacheitem *item); |
62 | extern int cache_exist(struct cacheitem *item); |
63 | extern int cache_exist(struct cacheitem *item); |
63 | extern int cache_expired(struct cacheitem *item); |
64 | extern int cache_expired(struct cacheitem *item); |
64 | |
65 | |
65 | #endif /* CGIT_H */ |
66 | #endif /* CGIT_H */ |
|