3 files changed, 31 insertions, 14 deletions
diff --git a/cache.c b/cache.c
index 0ffa502..2e1ef8c 100644
--- a/cache.c
+++ b/cache.c
@@ -32,67 +32,76 @@ void cache_prepare(struct cacheitem *item)
        }
 }
 int cache_exist(struct cacheitem *item)
 {
        if (stat(item->name, &item->st)) {
                item->st.st_mtime = 0;
                return 0;
        }
        return 1;
 }
 int cache_create_dirs()
 {
        char *path;
        if (!cgit_query_repo)
                return 0;
        path = fmt("%s/%s", cgit_cache_root, cgit_query_repo);
        if (mkdir(path, S_IRWXU) && errno!=EEXIST)
                return 0;
        if (cgit_query_page) {
                path = fmt("%s/%s/%s", cgit_cache_root, cgit_query_repo, 
                           cgit_query_page);
                if (mkdir(path, S_IRWXU) && errno!=EEXIST)
                        return 0;
        }
        return 1;
 }
+int cache_refill_overdue(const char *lockfile)
+{
+        struct stat st;
+        if (stat(lockfile, &st))
+                return 0;
+        else
+                return (time(NULL) - st.st_mtime > cgit_cache_max_create_time);
+}
 int cache_lock(struct cacheitem *item)
 {
-        int ret;
+        int i = 0;
        char *lockfile = fmt("%s.lock", item->name);
- top:  
+ top:
-               item->fd = open(lockfile, O_WRONLY | O_CREAT | O_EXCL, S_IRUSR|S_IWUSR);
+        if (++i > cgit_max_lock_attempts)
+                die("cache_lock: unable to lock %s: %s",
+                    item->name, strerror(errno));
+               item->fd = open(lockfile, O_WRONLY|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR);
        if (item->fd == NOLOCK && errno == ENOENT && cache_create_dirs())
                goto top;
-        if (item->fd == NOLOCK && errno == EEXIST) {
-                struct stat st;
+        if (item->fd == NOLOCK && errno == EEXIST &&
-                time_t t;
+            cache_refill_overdue(lockfile) && !unlink(lockfile))
-                if (stat(lockfile, &st))
-                        return ret;
-                t = time(NULL);
-                if (t-st.st_mtime > cgit_cache_max_create_time && 
-                    !unlink(lockfile))
                        goto top;
-                return 0;
-        }
        return (item->fd > 0);
 }
 int cache_unlock(struct cacheitem *item)
 {
        close(item->fd);
        return (rename(fmt("%s.lock", item->name), item->name) == 0);
 }
 int cache_expired(struct cacheitem *item)
 {
        if (item->ttl < 0)
                return 0;
        return item->st.st_mtime + item->ttl * 60 < time(NULL);
 }
diff --git a/cgit.c b/cgit.c
index 7f14016..dc91125 100644
--- a/cgit.c
+++ b/cgit.c
@@ -2,64 +2,65 @@
 *
 * Copyright (C) 2006 Lars Hjemli
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include "cgit.h"
 const char cgit_version[] = CGIT_VERSION;
 const char cgit_doctype[] =
 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
 "  \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
 const char cgit_error[] =
 "<div class='error'>%s</div>";
 const char cgit_lib_error[] =
 "<div class='error'>%s: %s</div>";
 int htmlfd = 0;
 char *cgit_root         = "/usr/src/git";
 char *cgit_root_title   = "Git repository browser";
 char *cgit_css          = "/cgit.css";
 char *cgit_logo         = "/git-logo.png";
 char *cgit_logo_link    = "http://www.kernel.org/pub/software/scm/git/docs/";
 char *cgit_virtual_root = NULL;
 char *cgit_cache_root   = "/var/cache/cgit";
+int cgit_max_lock_attempts     =  5;
 int cgit_cache_root_ttl        =  5;
 int cgit_cache_repo_ttl        =  5;
 int cgit_cache_dynamic_ttl     =  5;
 int cgit_cache_static_ttl      = -1;
 int cgit_cache_max_create_time =  5;
 char *cgit_repo_name    = NULL;
 char *cgit_repo_desc    = NULL;
 char *cgit_repo_owner   = NULL;
 int cgit_query_has_symref = 0;
 int cgit_query_has_sha1   = 0;
 char *cgit_querystring  = NULL;
 char *cgit_query_repo   = NULL;
 char *cgit_query_page   = NULL;
 char *cgit_query_head   = NULL;
 char *cgit_query_sha1   = NULL;
 struct cacheitem cacheitem;
 int cgit_parse_query(char *txt, configfn fn)
 {
        char *t, *value = NULL, c;
        if (!txt)
                return 0;
        t = txt = xstrdup(txt);
 
        while((c=*t) != '\0') {
                if (c=='=') {
@@ -436,69 +437,75 @@ static void cgit_print_repo_page()
                cgit_print_pageheader(title);
                htmlf(cgit_lib_error, "Unable to scan repository",
                      strerror(errno));
                cgit_print_docend();
                return;
        }
        setenv("GIT_DIR", fmt("%s/%s", cgit_root, cgit_query_repo), 1);
        char *title = fmt("%s - %s", cgit_repo_name, cgit_repo_desc);
        cgit_print_docstart(title);
        cgit_print_pageheader(title);
        if (!cgit_query_page)
                cgit_print_repo_summary();
        else if (!strcmp(cgit_query_page, "log")) {
                cgit_print_log(cgit_query_head, 0, 100);
        } else if (!strcmp(cgit_query_page, "view")) {
                cgit_print_object(cgit_query_sha1);
        }
        cgit_print_docend();
 }
 static void cgit_fill_cache(struct cacheitem *item)
 {
        htmlfd = item->fd;
        item->st.st_mtime = time(NULL);
        if (cgit_query_repo)
                cgit_print_repo_page();
        else
                cgit_print_repolist();
 }
 static void cgit_refresh_cache(struct cacheitem *item)
 {
+        int i = 0;
        cache_prepare(item);
 top:
+        if (++i > cgit_max_lock_attempts) {
+                die("cgit_refresh_cache: unable to lock %s: %s",
+                    item->name, strerror(errno));
+        }
        if (!cache_exist(item)) {
                if (!cache_lock(item)) {
-                        sched_yield();
+                        sleep(1);
                        goto top;
                }
                if (!cache_exist(item))
                        cgit_fill_cache(item);
                cache_unlock(item);
        } else if (cache_expired(item) && cache_lock(item)) {
                if (cache_expired(item))
                        cgit_fill_cache(item);
                cache_unlock(item);
        }
 }
 static void cgit_print_cache(struct cacheitem *item)
 {
        static char buf[4096];
        ssize_t i;
        int fd = open(item->name, O_RDONLY);
        if (fd<0)
                die("Unable to open cached file %s", item->name);
        while((i=read(fd, buf, sizeof(buf))) > 0)
                write(STDOUT_FILENO, buf, i);
        close(fd);
 }
 int main(int argc, const char **argv)
 {
        cgit_read_config("/etc/cgitrc", cgit_global_config_cb);
        cgit_querystring = xstrdup(getenv("QUERY_STRING"));
        cgit_parse_query(cgit_querystring, cgit_querystring_cb);
diff --git a/cgit.h b/cgit.h
index 3b0994a..7e4bfef 100644
--- a/cgit.h
+++ b/cgit.h
@@ -1,57 +1,58 @@
 #ifndef CGIT_H
 #define CGIT_H
 #include "git.h"
 #include <openssl/sha.h>
 #include <ctype.h>
 #include <sched.h>
 typedef void (*configfn)(const char *name, const char *value);
 struct cacheitem {
        char *name;
        struct stat st;
        int ttl;
        int fd;
 };
 extern char *cgit_root;
 extern char *cgit_root_title;
 extern char *cgit_css;
 extern char *cgit_logo;
 extern char *cgit_logo_link;
 extern char *cgit_virtual_root;
 extern char *cgit_cache_root;
+extern int cgit_max_lock_attempts;
 extern int cgit_cache_root_ttl;
 extern int cgit_cache_repo_ttl;
 extern int cgit_cache_dynamic_ttl;
 extern int cgit_cache_static_ttl;
 extern int cgit_cache_max_create_time;
 extern char *cgit_repo_name;
 extern char *cgit_repo_desc;
 extern char *cgit_repo_owner;
 extern int cgit_query_has_symref;
 extern int cgit_query_has_sha1;
 extern char *cgit_querystring;
 extern char *cgit_query_repo;
 extern char *cgit_query_page;
 extern char *cgit_query_head;
 extern char *cgit_query_sha1;
 extern int htmlfd;
 extern char *fmt(const char *format,...);
 extern void html(const char *txt);
 extern void htmlf(const char *format,...);
 extern void html_txt(char *txt);
 extern void html_attr(char *txt);
 extern void html_link_open(char *url, char *title, char *class);
 extern void html_link_close(void);
 extern int cgit_read_config(const char *filename, configfn fn);

diff --git a/cache.c b/cache.c index 0ffa502..2e1ef8c 100644 --- a/cache.c +++ b/cache.c
@@ -32,67 +32,76 @@ void cache_prepare(struct cacheitem *item)
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
@@ -2,64 +2,65 @@
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=='=') {
@@ -436,69 +437,75 @@ static void cgit_print_repo_page()
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);


diff --git a/cgit.h b/cgit.h index 3b0994a..7e4bfef 100644 --- a/cgit.h +++ b/cgit.h
@@ -1,57 +1,58 @@
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);