1 files changed, 102 insertions, 15 deletions
diff --git a/cgit.c b/cgit.c
index 4c14f77..09c857c 100644
--- a/cgit.c
+++ b/cgit.c
@@ -1,47 +1,65 @@
 #include "cgit.h"
 static 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";
 static const char cgit_error[] =
 "<div class='error'>%s</div>";
 static const char cgit_lib_error[] =
 "<div class='error'>%s: %s</div>";
+int htmlfd = 0;
-char *cgit_root         = "/var/git";
+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_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 = txt, *value = NULL, c;
+        char *t, *value = NULL, c;
        if (!txt)
                return 0;
+        t = txt = xstrdup(txt);
+ 
        while((c=*t) != '\0') {
                if (c=='=') {
                        *t = '\0';
                        value = t+1;
                } else if (c=='&') {
                        *t = '\0';
                        (*fn)(txt, value);
                        txt = t+1;
                        value = NULL;
                }
                t++;
        }
@@ -73,26 +91,31 @@ void cgit_repo_config_cb(const char *name, const char *value)
        else if (!strcmp(name, "desc"))
                cgit_repo_desc = xstrdup(value);
        else if (!strcmp(name, "owner"))
                cgit_repo_owner = xstrdup(value);
 }
 void cgit_querystring_cb(const char *name, const char *value)
 {
        if (!strcmp(name,"r"))
                cgit_query_repo = xstrdup(value);
        else if (!strcmp(name, "p"))
                cgit_query_page = xstrdup(value);
-        else if (!strcmp(name, "h"))
+        else if (!strcmp(name, "h")) {
                cgit_query_head = xstrdup(value);
+                cgit_query_has_symref = 1;
+        } else if (!strcmp(name, "id")) {
+                cgit_query_sha1 = xstrdup(value);
+                cgit_query_has_sha1 = 1;
+        }
 }
 char *cgit_repourl(const char *reponame)
 {
        if (cgit_virtual_root) {
                return fmt("%s/%s/", cgit_virtual_root, reponame);
        } else {
                return fmt("?r=%s", reponame);
        }
 }
 char *cgit_pageurl(const char *reponame, const char *pagename, 
@@ -127,27 +150,50 @@ static int cgit_print_branch_cb(const char *refname, const unsigned char *sha1,
                html_txt(buf);
                html("</td></tr>\n");
        } else {
                html("<tr><td>");
                html_txt(buf);
                html("</td><td>");
                htmlf("*** bad ref %s", sha1_to_hex(sha1));
                html("</td></tr>\n");
        }
        return 0;
 }
+/* Sun, 06 Nov 1994 08:49:37 GMT */
+static char *http_date(time_t t)
+{
+        static char day[][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+        static char month[][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                                  "Jul", "Aug", "Sep", "Oct", "Now", "Dec"};
+        struct tm *tm = gmtime(&t);
+        return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday],
+                   tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year,
+                   tm->tm_hour, tm->tm_min, tm->tm_sec);
+}
+static int ttl_seconds(int ttl)
+{
+        if (ttl<0)
+                return 60 * 60 * 24 * 365;
+        else 
+                return ttl * 60;
+}
 static void cgit_print_docstart(char *title)
 {
        html("Content-Type: text/html; charset=utf-8\n");
+        htmlf("Last-Modified: %s\n", http_date(cacheitem.st.st_mtime));
+        htmlf("Expires: %s\n", http_date(cacheitem.st.st_mtime + 
+                                         ttl_seconds(cacheitem.ttl)));
        html("\n");
        html(cgit_doctype);
        html("<html>\n");
        html("<head>\n");
        html("<title>");
        html_txt(title);
        html("</title>\n");
        html("<link rel='stylesheet' type='text/css' href='");
        html_attr(cgit_css);
        html("'/>\n");
        html("</head>\n");
        html("<body>\n");
@@ -166,47 +212,48 @@ static void cgit_print_pageheader(char *title)
        htmlf("</a>");
        html_txt(title);
        html("</div>");
 }
 static void cgit_print_repolist()
 {
        DIR *d;
        struct dirent *de;
        struct stat st;
        char *name;
+        chdir(cgit_root);
        cgit_print_docstart(cgit_root_title);
        cgit_print_pageheader(cgit_root_title);
        if (!(d = opendir("."))) {
                htmlf(cgit_lib_error, "Unable to scan repository directory",
                      strerror(errno));
                cgit_print_docend();
                return;
        }
        html("<h2>Repositories</h2>\n");
        html("<table class='list'>");
        html("<tr><th>Name</th><th>Description</th><th>Owner</th></tr>\n");
        while ((de = readdir(d)) != NULL) {
                if (de->d_name[0] == '.')
                        continue;
                if (stat(de->d_name, &st) < 0)
                        continue;
                if (!S_ISDIR(st.st_mode))
                        continue;
                cgit_repo_name = cgit_repo_desc = cgit_repo_owner = NULL;
-                name = fmt("%s/.git/info/cgit", de->d_name);
+                name = fmt("%s/info/cgit", de->d_name);
                if (cgit_read_config(name, cgit_repo_config_cb))
                        continue;
                html("<tr><td>");
                html_link_open(cgit_repourl(de->d_name), NULL, NULL);
                html_txt(cgit_repo_name);
                html_link_close();
                html("</td><td>");
                html_txt(cgit_repo_desc);
                html("</td><td>");
                html_txt(cgit_repo_owner);
                html("</td></tr>\n");
@@ -282,25 +329,25 @@ static void cgit_print_commit_shortlog(struct commit *commit)
        while((len = get_one_line(h)) > 0)
                h += len+2;
        h++;
        len = get_one_line(h);
        subject = h;
        html("<tr><td>");
        strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", time);
        html_txt(buf);
        html("</td><td>");
-        char *qry = fmt("h=%s", sha1_to_hex(commit->object.sha1));
+        char *qry = fmt("id=%s", sha1_to_hex(commit->object.sha1));
        char *url = cgit_pageurl(cgit_query_repo, "view", qry);
        html_link_open(url, NULL, NULL);
        html_txt(subject);
        html_link_close();
        html("</td><td>");
        html_txt(author);
        html("</td></tr>\n");
 }
 static void cgit_print_log(const char *tip, int ofs, int cnt)
 {
        struct rev_info rev;
@@ -362,49 +409,89 @@ static void cgit_print_object(char *hex)
        }
        buf[size] = '\0';
        html("<h2>Object view</h2>");
        htmlf("sha1=%s<br/>type=%s<br/>size=%i<br/>", hex, type, size);
        html("<pre>");
        html_txt(buf);
        html("</pre>");
 }
 static void cgit_print_repo_page()
 {
-        if (chdir(cgit_query_repo) || 
+        if (chdir(fmt("%s/%s", cgit_root, cgit_query_repo)) || 
-            cgit_read_config(".git/info/cgit", cgit_repo_config_cb)) {
+            cgit_read_config("info/cgit", cgit_repo_config_cb)) {
                char *title = fmt("%s - %s", cgit_root_title, "Bad request");
                cgit_print_docstart(title);
                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_head);
+                cgit_print_object(cgit_query_sha1);
        }
        cgit_print_docend();
 }
-int main(int argc, const char **argv)
+static void cgit_fill_cache(struct cacheitem *item)
 {
-        if (cgit_read_config("/etc/cgitrc", cgit_global_config_cb))
+        htmlfd = item->fd;
-                die("Error reading config: %d %s", errno, strerror(errno));
+        item->st.st_mtime = time(NULL);
-        chdir(cgit_root);
-        cgit_parse_query(getenv("QUERY_STRING"), cgit_querystring_cb);
        if (cgit_query_repo)
                cgit_print_repo_page();
        else
                cgit_print_repolist();
+}
+static void cgit_refresh_cache(struct cacheitem *item)
+{
+ top:
+        if (!cache_lookup(item)) {
+                if (cache_lock(item)) {
+                        cgit_fill_cache(item);
+                        cache_unlock(item);
+                } else {
+                        sched_yield();
+                        goto top;
+                }
+        } else if (cache_expired(item)) {
+                if (cache_lock(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);
+        cgit_refresh_cache(&cacheitem);
+        cgit_print_cache(&cacheitem);
        return 0;
 }

diff --git a/cgit.c b/cgit.c index 4c14f77..09c857c 100644 --- a/cgit.c +++ b/cgit.c
@@ -1,47 +1,65 @@
1	#include "cgit.h"	1	#include "cgit.h"
2		2
3	static const char cgit_doctype[] =	3	static const char cgit_doctype[] =
4	"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"	4	"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
5	" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";	5	" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
6		6
7	static const char cgit_error[] =	7	static const char cgit_error[] =
8	"<div class='error'>%s</div>";	8	"<div class='error'>%s</div>";
9		9
10	static const char cgit_lib_error[] =	10	static const char cgit_lib_error[] =
11	"<div class='error'>%s: %s</div>";	11	"<div class='error'>%s: %s</div>";
12		12
		13	int htmlfd = 0;
13		14
14	char *cgit_root = "/var/git";	15	char *cgit_root = "/usr/src/git";
15	char *cgit_root_title = "Git repository browser";	16	char *cgit_root_title = "Git repository browser";
16	char *cgit_css = "/cgit.css";	17	char *cgit_css = "/cgit.css";
17	char *cgit_logo = "/git-logo.png";	18	char *cgit_logo = "/git-logo.png";
18	char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/";	19	char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/";
19	char *cgit_virtual_root = NULL;	20	char *cgit_virtual_root = NULL;
20		21
		22	char *cgit_cache_root = "/var/cache/cgit";
		23
		24	int cgit_cache_root_ttl = 5;
		25	int cgit_cache_repo_ttl = 5;
		26	int cgit_cache_dynamic_ttl = 5;
		27	int cgit_cache_static_ttl = -1;
		28	int cgit_cache_max_create_time = 5;
		29
21	char *cgit_repo_name = NULL;	30	char *cgit_repo_name = NULL;
22	char *cgit_repo_desc = NULL;	31	char *cgit_repo_desc = NULL;
23	char *cgit_repo_owner = NULL;	32	char *cgit_repo_owner = NULL;
24		33
		34	int cgit_query_has_symref = 0;
		35	int cgit_query_has_sha1 = 0;
		36
		37	char *cgit_querystring = NULL;
25	char *cgit_query_repo = NULL;	38	char *cgit_query_repo = NULL;
26	char *cgit_query_page = NULL;	39	char *cgit_query_page = NULL;
27	char *cgit_query_head = NULL;	40	char *cgit_query_head = NULL;
		41	char *cgit_query_sha1 = NULL;
		42
		43	struct cacheitem cacheitem;
28		44
29	int cgit_parse_query(char *txt, configfn fn)	45	int cgit_parse_query(char *txt, configfn fn)
30	{	46	{
31	char t = txt, value = NULL, c;	47	char t, value = NULL, c;
32		48
33	if (!txt)	49	if (!txt)
34	return 0;	50	return 0;
35		51
		52	t = txt = xstrdup(txt);
		53
36	while((c=*t) != '\0') {	54	while((c=*t) != '\0') {
37	if (c=='=') {	55	if (c=='=') {
38	*t = '\0';	56	*t = '\0';
39	value = t+1;	57	value = t+1;
40	} else if (c=='&') {	58	} else if (c=='&') {
41	*t = '\0';	59	*t = '\0';
42	(*fn)(txt, value);	60	(*fn)(txt, value);
43	txt = t+1;	61	txt = t+1;
44	value = NULL;	62	value = NULL;
45	}	63	}
46	t++;	64	t++;
47	}	65	}
@@ -73,26 +91,31 @@ void cgit_repo_config_cb(const char name, const char value)
73	else if (!strcmp(name, "desc"))	91	else if (!strcmp(name, "desc"))
74	cgit_repo_desc = xstrdup(value);	92	cgit_repo_desc = xstrdup(value);
75	else if (!strcmp(name, "owner"))	93	else if (!strcmp(name, "owner"))
76	cgit_repo_owner = xstrdup(value);	94	cgit_repo_owner = xstrdup(value);
77	}	95	}
78		96
79	void cgit_querystring_cb(const char name, const char value)	97	void cgit_querystring_cb(const char name, const char value)
80	{	98	{
81	if (!strcmp(name,"r"))	99	if (!strcmp(name,"r"))
82	cgit_query_repo = xstrdup(value);	100	cgit_query_repo = xstrdup(value);
83	else if (!strcmp(name, "p"))	101	else if (!strcmp(name, "p"))
84	cgit_query_page = xstrdup(value);	102	cgit_query_page = xstrdup(value);
85	else if (!strcmp(name, "h"))	103	else if (!strcmp(name, "h")) {
86	cgit_query_head = xstrdup(value);	104	cgit_query_head = xstrdup(value);
		105	cgit_query_has_symref = 1;
		106	} else if (!strcmp(name, "id")) {
		107	cgit_query_sha1 = xstrdup(value);
		108	cgit_query_has_sha1 = 1;
		109	}
87	}	110	}
88		111
89	char cgit_repourl(const char reponame)	112	char cgit_repourl(const char reponame)
90	{	113	{
91	if (cgit_virtual_root) {	114	if (cgit_virtual_root) {
92	return fmt("%s/%s/", cgit_virtual_root, reponame);	115	return fmt("%s/%s/", cgit_virtual_root, reponame);
93	} else {	116	} else {
94	return fmt("?r=%s", reponame);	117	return fmt("?r=%s", reponame);
95	}	118	}
96	}	119	}
97		120
98	char cgit_pageurl(const char reponame, const char *pagename,	121	char cgit_pageurl(const char reponame, const char *pagename,
@@ -127,27 +150,50 @@ static int cgit_print_branch_cb(const char refname, const unsigned char sha1,
127	html_txt(buf);	150	html_txt(buf);
128	html("</td></tr>\n");	151	html("</td></tr>\n");
129	} else {	152	} else {
130	html("<tr><td>");	153	html("<tr><td>");
131	html_txt(buf);	154	html_txt(buf);
132	html("</td><td>");	155	html("</td><td>");
133	htmlf("*** bad ref %s", sha1_to_hex(sha1));	156	htmlf("*** bad ref %s", sha1_to_hex(sha1));
134	html("</td></tr>\n");	157	html("</td></tr>\n");
135	}	158	}
136	return 0;	159	return 0;
137	}	160	}
138		161
		162	/* Sun, 06 Nov 1994 08:49:37 GMT */
		163	static char *http_date(time_t t)
		164	{
		165	static char day[][4] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
		166	static char month[][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
		167	"Jul", "Aug", "Sep", "Oct", "Now", "Dec"};
		168	struct tm *tm = gmtime(&t);
		169	return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday],
		170	tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year,
		171	tm->tm_hour, tm->tm_min, tm->tm_sec);
		172	}
		173
		174	static int ttl_seconds(int ttl)
		175	{
		176	if (ttl<0)
		177	return 60 * 60 * 24 * 365;
		178	else
		179	return ttl * 60;
		180	}
		181
139	static void cgit_print_docstart(char *title)	182	static void cgit_print_docstart(char *title)
140	{	183	{
141	html("Content-Type: text/html; charset=utf-8\n");	184	html("Content-Type: text/html; charset=utf-8\n");
		185	htmlf("Last-Modified: %s\n", http_date(cacheitem.st.st_mtime));
		186	htmlf("Expires: %s\n", http_date(cacheitem.st.st_mtime +
		187	ttl_seconds(cacheitem.ttl)));
142	html("\n");	188	html("\n");
143	html(cgit_doctype);	189	html(cgit_doctype);
144	html("<html>\n");	190	html("<html>\n");
145	html("<head>\n");	191	html("<head>\n");
146	html("<title>");	192	html("<title>");
147	html_txt(title);	193	html_txt(title);
148	html("</title>\n");	194	html("</title>\n");
149	html("<link rel='stylesheet' type='text/css' href='");	195	html("<link rel='stylesheet' type='text/css' href='");
150	html_attr(cgit_css);	196	html_attr(cgit_css);
151	html("'/>\n");	197	html("'/>\n");
152	html("</head>\n");	198	html("</head>\n");
153	html("<body>\n");	199	html("<body>\n");
@@ -166,47 +212,48 @@ static void cgit_print_pageheader(char *title)
166	htmlf("</a>");	212	htmlf("</a>");
167	html_txt(title);	213	html_txt(title);
168	html("</div>");	214	html("</div>");
169	}	215	}
170		216
171	static void cgit_print_repolist()	217	static void cgit_print_repolist()
172	{	218	{
173	DIR *d;	219	DIR *d;
174	struct dirent *de;	220	struct dirent *de;
175	struct stat st;	221	struct stat st;
176	char *name;	222	char *name;
177		223
		224	chdir(cgit_root);
178	cgit_print_docstart(cgit_root_title);	225	cgit_print_docstart(cgit_root_title);
179	cgit_print_pageheader(cgit_root_title);	226	cgit_print_pageheader(cgit_root_title);
180		227
181	if (!(d = opendir("."))) {	228	if (!(d = opendir("."))) {
182	htmlf(cgit_lib_error, "Unable to scan repository directory",	229	htmlf(cgit_lib_error, "Unable to scan repository directory",
183	strerror(errno));	230	strerror(errno));
184	cgit_print_docend();	231	cgit_print_docend();
185	return;	232	return;
186	}	233	}
187		234
188	html("<h2>Repositories</h2>\n");	235	html("<h2>Repositories</h2>\n");
189	html("<table class='list'>");	236	html("<table class='list'>");
190	html("<tr><th>Name</th><th>Description</th><th>Owner</th></tr>\n");	237	html("<tr><th>Name</th><th>Description</th><th>Owner</th></tr>\n");
191	while ((de = readdir(d)) != NULL) {	238	while ((de = readdir(d)) != NULL) {
192	if (de->d_name[0] == '.')	239	if (de->d_name[0] == '.')
193	continue;	240	continue;
194	if (stat(de->d_name, &st) < 0)	241	if (stat(de->d_name, &st) < 0)
195	continue;	242	continue;
196	if (!S_ISDIR(st.st_mode))	243	if (!S_ISDIR(st.st_mode))
197	continue;	244	continue;
198		245
199	cgit_repo_name = cgit_repo_desc = cgit_repo_owner = NULL;	246	cgit_repo_name = cgit_repo_desc = cgit_repo_owner = NULL;
200	name = fmt("%s/.git/info/cgit", de->d_name);	247	name = fmt("%s/info/cgit", de->d_name);
201	if (cgit_read_config(name, cgit_repo_config_cb))	248	if (cgit_read_config(name, cgit_repo_config_cb))
202	continue;	249	continue;
203		250
204	html("<tr><td>");	251	html("<tr><td>");
205	html_link_open(cgit_repourl(de->d_name), NULL, NULL);	252	html_link_open(cgit_repourl(de->d_name), NULL, NULL);
206	html_txt(cgit_repo_name);	253	html_txt(cgit_repo_name);
207	html_link_close();	254	html_link_close();
208	html("</td><td>");	255	html("</td><td>");
209	html_txt(cgit_repo_desc);	256	html_txt(cgit_repo_desc);
210	html("</td><td>");	257	html("</td><td>");
211	html_txt(cgit_repo_owner);	258	html_txt(cgit_repo_owner);
212	html("</td></tr>\n");	259	html("</td></tr>\n");
@@ -282,25 +329,25 @@ static void cgit_print_commit_shortlog(struct commit *commit)
282	while((len = get_one_line(h)) > 0)	329	while((len = get_one_line(h)) > 0)
283	h += len+2;	330	h += len+2;
284		331
285	h++;	332	h++;
286	len = get_one_line(h);	333	len = get_one_line(h);
287		334
288	subject = h;	335	subject = h;
289		336
290	html("<tr><td>");	337	html("<tr><td>");
291	strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", time);	338	strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", time);
292	html_txt(buf);	339	html_txt(buf);
293	html("</td><td>");	340	html("</td><td>");
294	char *qry = fmt("h=%s", sha1_to_hex(commit->object.sha1));	341	char *qry = fmt("id=%s", sha1_to_hex(commit->object.sha1));
295	char *url = cgit_pageurl(cgit_query_repo, "view", qry);	342	char *url = cgit_pageurl(cgit_query_repo, "view", qry);
296	html_link_open(url, NULL, NULL);	343	html_link_open(url, NULL, NULL);
297	html_txt(subject);	344	html_txt(subject);
298	html_link_close();	345	html_link_close();
299	html("</td><td>");	346	html("</td><td>");
300	html_txt(author);	347	html_txt(author);
301	html("</td></tr>\n");	348	html("</td></tr>\n");
302	}	349	}
303		350
304	static void cgit_print_log(const char *tip, int ofs, int cnt)	351	static void cgit_print_log(const char *tip, int ofs, int cnt)
305	{	352	{
306	struct rev_info rev;	353	struct rev_info rev;
@@ -362,49 +409,89 @@ static void cgit_print_object(char *hex)
362	}	409	}
363		410
364	buf[size] = '\0';	411	buf[size] = '\0';
365	html("<h2>Object view</h2>");	412	html("<h2>Object view</h2>");
366	htmlf("sha1=%s<br/>type=%s<br/>size=%i<br/>", hex, type, size);	413	htmlf("sha1=%s<br/>type=%s<br/>size=%i<br/>", hex, type, size);
367	html("<pre>");	414	html("<pre>");
368	html_txt(buf);	415	html_txt(buf);
369	html("</pre>");	416	html("</pre>");
370	}	417	}
371		418
372	static void cgit_print_repo_page()	419	static void cgit_print_repo_page()
373	{	420	{
374	if (chdir(cgit_query_repo) \|\|	421	if (chdir(fmt("%s/%s", cgit_root, cgit_query_repo)) \|\|
375	cgit_read_config(".git/info/cgit", cgit_repo_config_cb)) {	422	cgit_read_config("info/cgit", cgit_repo_config_cb)) {
376	char *title = fmt("%s - %s", cgit_root_title, "Bad request");	423	char *title = fmt("%s - %s", cgit_root_title, "Bad request");
377	cgit_print_docstart(title);	424	cgit_print_docstart(title);
378	cgit_print_pageheader(title);	425	cgit_print_pageheader(title);
379	htmlf(cgit_lib_error, "Unable to scan repository",	426	htmlf(cgit_lib_error, "Unable to scan repository",
380	strerror(errno));	427	strerror(errno));
381	cgit_print_docend();	428	cgit_print_docend();
382	return;	429	return;
383	}	430	}
384		431	setenv("GIT_DIR", fmt("%s/%s", cgit_root, cgit_query_repo), 1);
385	char *title = fmt("%s - %s", cgit_repo_name, cgit_repo_desc);	432	char *title = fmt("%s - %s", cgit_repo_name, cgit_repo_desc);
386	cgit_print_docstart(title);	433	cgit_print_docstart(title);
387	cgit_print_pageheader(title);	434	cgit_print_pageheader(title);
388	if (!cgit_query_page)	435	if (!cgit_query_page)
389	cgit_print_repo_summary();	436	cgit_print_repo_summary();
390	else if (!strcmp(cgit_query_page, "log")) {	437	else if (!strcmp(cgit_query_page, "log")) {
391	cgit_print_log(cgit_query_head, 0, 100);	438	cgit_print_log(cgit_query_head, 0, 100);
392	} else if (!strcmp(cgit_query_page, "view")) {	439	} else if (!strcmp(cgit_query_page, "view")) {
393	cgit_print_object(cgit_query_head);	440	cgit_print_object(cgit_query_sha1);
394	}	441	}
395	cgit_print_docend();	442	cgit_print_docend();
396	}	443	}
397		444
398	int main(int argc, const char **argv)	445	static void cgit_fill_cache(struct cacheitem *item)
399	{	446	{
400	if (cgit_read_config("/etc/cgitrc", cgit_global_config_cb))	447	htmlfd = item->fd;
401	die("Error reading config: %d %s", errno, strerror(errno));	448	item->st.st_mtime = time(NULL);
402
403	chdir(cgit_root);
404	cgit_parse_query(getenv("QUERY_STRING"), cgit_querystring_cb);
405	if (cgit_query_repo)	449	if (cgit_query_repo)
406	cgit_print_repo_page();	450	cgit_print_repo_page();
407	else	451	else
408	cgit_print_repolist();	452	cgit_print_repolist();
		453	}
		454
		455	static void cgit_refresh_cache(struct cacheitem *item)
		456	{
		457	top:
		458	if (!cache_lookup(item)) {
		459	if (cache_lock(item)) {
		460	cgit_fill_cache(item);
		461	cache_unlock(item);
		462	} else {
		463	sched_yield();
		464	goto top;
		465	}
		466	} else if (cache_expired(item)) {
		467	if (cache_lock(item)) {
		468	cgit_fill_cache(item);
		469	cache_unlock(item);
		470	}
		471	}
		472	}
		473
		474	static void cgit_print_cache(struct cacheitem *item)
		475	{
		476	static char buf[4096];
		477	ssize_t i;
		478
		479	int fd = open(item->name, O_RDONLY);
		480	if (fd<0)
		481	die("Unable to open cached file %s", item->name);
		482
		483	while((i=read(fd, buf, sizeof(buf))) > 0)
		484	write(STDOUT_FILENO, buf, i);
		485
		486	close(fd);
		487	}
		488
		489	int main(int argc, const char **argv)
		490	{
		491	cgit_read_config("/etc/cgitrc", cgit_global_config_cb);
		492	cgit_querystring = xstrdup(getenv("QUERY_STRING"));
		493	cgit_parse_query(cgit_querystring, cgit_querystring_cb);
		494	cgit_refresh_cache(&cacheitem);
		495	cgit_print_cache(&cacheitem);
409	return 0;	496	return 0;
410	}	497	}