1 files changed, 1 insertions, 1 deletions
diff --git a/cgit.c b/cgit.c
index c86d290..1b85b15 100644
--- a/cgit.c
+++ b/cgit.c
@@ -1,256 +1,256 @@
 /* cgit.c: cgi for the git scm
 *
 * Copyright (C) 2006 Lars Hjemli
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include "cgit.h"
 static int cgit_prepare_cache(struct cacheitem *item)
 {
        if (!cgit_repo && cgit_query_repo) {
                char *title = fmt("%s - %s", cgit_root_title, "Bad request");
                cgit_print_docstart(title, item);
                cgit_print_pageheader(title, 0);
                cgit_print_error(fmt("Unknown repo: %s", cgit_query_repo));
                cgit_print_docend();
                return 0;
        }
        if (!cgit_repo) {
                item->name = xstrdup(fmt("%s/index.html", cgit_cache_root));
                item->ttl = cgit_cache_root_ttl;
                return 1;
        }
        if (!cgit_cmd) {
                item->name = xstrdup(fmt("%s/%s/index.%s.html", cgit_cache_root,
                                         cache_safe_filename(cgit_repo->url),
                                         cache_safe_filename(cgit_querystring)));
                item->ttl = cgit_cache_repo_ttl;
        } else {
                item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root,
                                         cache_safe_filename(cgit_repo->url),
                                         cgit_query_page,
                                         cache_safe_filename(cgit_querystring)));
                if (cgit_query_has_symref)
                        item->ttl = cgit_cache_dynamic_ttl;
                else if (cgit_query_has_sha1)
                        item->ttl = cgit_cache_static_ttl;
                else
                        item->ttl = cgit_cache_repo_ttl;
        }
        return 1;
 }
 static void cgit_print_repo_page(struct cacheitem *item)
 {
        char *title;
        int show_search;
        if (!cgit_query_head)
                cgit_query_head = cgit_repo->defbranch;
        if (chdir(cgit_repo->path)) {
                title = fmt("%s - %s", cgit_root_title, "Bad request");
                cgit_print_docstart(title, item);
                cgit_print_pageheader(title, 0);
                cgit_print_error(fmt("Unable to scan repository: %s",
                                     strerror(errno)));
                cgit_print_docend();
                return;
        }
        title = fmt("%s - %s", cgit_repo->name, cgit_repo->desc);
        show_search = 0;
        setenv("GIT_DIR", cgit_repo->path, 1);
        if ((cgit_cmd == CMD_SNAPSHOT) && cgit_repo->snapshots) {
                cgit_print_snapshot(item, cgit_query_head, cgit_query_sha1,
                                    cgit_repobasename(cgit_repo->url),
                                    cgit_query_path,
                                    cgit_repo->snapshots );
                return;
        }
        if (cgit_cmd == CMD_BLOB) {
                cgit_print_blob(item, cgit_query_sha1, cgit_query_path);
                return;
        }
        show_search = (cgit_cmd == CMD_LOG);
        cgit_print_docstart(title, item);
        if (!cgit_cmd) {
                cgit_print_pageheader("summary", show_search);
                cgit_print_summary();
                cgit_print_docend();
                return;
        }
        cgit_print_pageheader(cgit_query_page, show_search);
        switch(cgit_cmd) {
        case CMD_LOG:
                cgit_print_log(cgit_query_sha1, cgit_query_ofs,
                               cgit_max_commit_count, cgit_query_search,
                               cgit_query_path, 1);
                break;
        case CMD_TREE:
                cgit_print_tree(cgit_query_sha1, cgit_query_path);
                break;
        case CMD_COMMIT:
                cgit_print_commit(cgit_query_sha1);
                break;
        case CMD_TAG:
                cgit_print_tag(cgit_query_sha1);
                break;
        case CMD_DIFF:
-                cgit_print_diff(cgit_query_sha1, cgit_query_sha2);
+                cgit_print_diff(cgit_query_sha1, cgit_query_sha2, cgit_query_path);
                break;
        default:
                cgit_print_error("Invalid request");
        }
        cgit_print_docend();
 }
 static void cgit_fill_cache(struct cacheitem *item, int use_cache)
 {
        static char buf[PATH_MAX];
        int stdout2;
        getcwd(buf, sizeof(buf));
        item->st.st_mtime = time(NULL);
        if (use_cache) {
                stdout2 = chk_positive(dup(STDOUT_FILENO),
                                       "Preserving STDOUT");
                chk_zero(close(STDOUT_FILENO), "Closing STDOUT");
                chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)");
        }
        if (cgit_repo)
                cgit_print_repo_page(item);
        else
                cgit_print_repolist(item);
        if (use_cache) {
                chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT");
                chk_positive(dup2(stdout2, STDOUT_FILENO),
                             "Restoring original STDOUT");
                chk_zero(close(stdout2), "Closing temporary STDOUT");
        }
        chdir(buf);
 }
 static void cgit_check_cache(struct cacheitem *item)
 {
        int i = 0;
 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)) {
                        sleep(1);
                        goto top;
                }
                if (!cache_exist(item)) {
                        cgit_fill_cache(item, 1);
                        cache_unlock(item);
                } else {
                        cache_cancel_lock(item);
                }
        } else if (cache_expired(item) && cache_lock(item)) {
                if (cache_expired(item)) {
                        cgit_fill_cache(item, 1);
                        cache_unlock(item);
                } else {
                        cache_cancel_lock(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);
 }
 static void cgit_parse_args(int argc, const char **argv)
 {
        int i;
        for (i = 1; i < argc; i++) {
                if (!strncmp(argv[i], "--cache=", 8)) {
                        cgit_cache_root = xstrdup(argv[i]+8);
                }
                if (!strcmp(argv[i], "--nocache")) {
                        cgit_nocache = 1;
                }
                if (!strncmp(argv[i], "--query=", 8)) {
                        cgit_querystring = xstrdup(argv[i]+8);
                }
                if (!strncmp(argv[i], "--repo=", 7)) {
                        cgit_query_repo = xstrdup(argv[i]+7);
                }
                if (!strncmp(argv[i], "--page=", 7)) {
                        cgit_query_page = xstrdup(argv[i]+7);
                }
                if (!strncmp(argv[i], "--head=", 7)) {
                        cgit_query_head = xstrdup(argv[i]+7);
                        cgit_query_has_symref = 1;
                }
                if (!strncmp(argv[i], "--sha1=", 7)) {
                        cgit_query_sha1 = xstrdup(argv[i]+7);
                        cgit_query_has_sha1 = 1;
                }
                if (!strncmp(argv[i], "--ofs=", 6)) {
                        cgit_query_ofs = atoi(argv[i]+6);
                }
        }
 }
 int main(int argc, const char **argv)
 {
        struct cacheitem item;
        const char *cgit_config_env = getenv("CGIT_CONFIG");
        htmlfd = STDOUT_FILENO;
        item.st.st_mtime = time(NULL);
        cgit_repolist.length = 0;
        cgit_repolist.count = 0;
        cgit_repolist.repos = NULL;
        cgit_read_config(cgit_config_env ? cgit_config_env : CGIT_CONFIG,
                         cgit_global_config_cb);
        cgit_repo = NULL;
        if (getenv("SCRIPT_NAME"))
                cgit_script_name = xstrdup(getenv("SCRIPT_NAME"));
        if (getenv("QUERY_STRING"))
                cgit_querystring = xstrdup(getenv("QUERY_STRING"));
        cgit_parse_args(argc, argv);
        cgit_parse_query(cgit_querystring, cgit_querystring_cb);
        if (!cgit_prepare_cache(&item))
                return 0;
        if (cgit_nocache) {
                cgit_fill_cache(&item, 0);
        } else {
                cgit_check_cache(&item);
                cgit_print_cache(&item);
        }
        return 0;
 }

diff --git a/cgit.c b/cgit.c index c86d290..1b85b15 100644 --- a/cgit.c +++ b/cgit.c
@@ -1,256 +1,256 @@
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	static int cgit_prepare_cache(struct cacheitem *item)	11	static int cgit_prepare_cache(struct cacheitem *item)
12	{	12	{
13	if (!cgit_repo && cgit_query_repo) {	13	if (!cgit_repo && cgit_query_repo) {
14	char *title = fmt("%s - %s", cgit_root_title, "Bad request");	14	char *title = fmt("%s - %s", cgit_root_title, "Bad request");
15	cgit_print_docstart(title, item);	15	cgit_print_docstart(title, item);
16	cgit_print_pageheader(title, 0);	16	cgit_print_pageheader(title, 0);
17	cgit_print_error(fmt("Unknown repo: %s", cgit_query_repo));	17	cgit_print_error(fmt("Unknown repo: %s", cgit_query_repo));
18	cgit_print_docend();	18	cgit_print_docend();
19	return 0;	19	return 0;
20	}	20	}
21		21
22	if (!cgit_repo) {	22	if (!cgit_repo) {
23	item->name = xstrdup(fmt("%s/index.html", cgit_cache_root));	23	item->name = xstrdup(fmt("%s/index.html", cgit_cache_root));
24	item->ttl = cgit_cache_root_ttl;	24	item->ttl = cgit_cache_root_ttl;
25	return 1;	25	return 1;
26	}	26	}
27		27
28	if (!cgit_cmd) {	28	if (!cgit_cmd) {
29	item->name = xstrdup(fmt("%s/%s/index.%s.html", cgit_cache_root,	29	item->name = xstrdup(fmt("%s/%s/index.%s.html", cgit_cache_root,
30	cache_safe_filename(cgit_repo->url),	30	cache_safe_filename(cgit_repo->url),
31	cache_safe_filename(cgit_querystring)));	31	cache_safe_filename(cgit_querystring)));
32	item->ttl = cgit_cache_repo_ttl;	32	item->ttl = cgit_cache_repo_ttl;
33	} else {	33	} else {
34	item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root,	34	item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root,
35	cache_safe_filename(cgit_repo->url),	35	cache_safe_filename(cgit_repo->url),
36	cgit_query_page,	36	cgit_query_page,
37	cache_safe_filename(cgit_querystring)));	37	cache_safe_filename(cgit_querystring)));
38	if (cgit_query_has_symref)	38	if (cgit_query_has_symref)
39	item->ttl = cgit_cache_dynamic_ttl;	39	item->ttl = cgit_cache_dynamic_ttl;
40	else if (cgit_query_has_sha1)	40	else if (cgit_query_has_sha1)
41	item->ttl = cgit_cache_static_ttl;	41	item->ttl = cgit_cache_static_ttl;
42	else	42	else
43	item->ttl = cgit_cache_repo_ttl;	43	item->ttl = cgit_cache_repo_ttl;
44	}	44	}
45	return 1;	45	return 1;
46	}	46	}
47		47
48	static void cgit_print_repo_page(struct cacheitem *item)	48	static void cgit_print_repo_page(struct cacheitem *item)
49	{	49	{
50	char *title;	50	char *title;
51	int show_search;	51	int show_search;
52		52
53	if (!cgit_query_head)	53	if (!cgit_query_head)
54	cgit_query_head = cgit_repo->defbranch;	54	cgit_query_head = cgit_repo->defbranch;
55		55
56	if (chdir(cgit_repo->path)) {	56	if (chdir(cgit_repo->path)) {
57	title = fmt("%s - %s", cgit_root_title, "Bad request");	57	title = fmt("%s - %s", cgit_root_title, "Bad request");
58	cgit_print_docstart(title, item);	58	cgit_print_docstart(title, item);
59	cgit_print_pageheader(title, 0);	59	cgit_print_pageheader(title, 0);
60	cgit_print_error(fmt("Unable to scan repository: %s",	60	cgit_print_error(fmt("Unable to scan repository: %s",
61	strerror(errno)));	61	strerror(errno)));
62	cgit_print_docend();	62	cgit_print_docend();
63	return;	63	return;
64	}	64	}
65		65
66	title = fmt("%s - %s", cgit_repo->name, cgit_repo->desc);	66	title = fmt("%s - %s", cgit_repo->name, cgit_repo->desc);
67	show_search = 0;	67	show_search = 0;
68	setenv("GIT_DIR", cgit_repo->path, 1);	68	setenv("GIT_DIR", cgit_repo->path, 1);
69		69
70	if ((cgit_cmd == CMD_SNAPSHOT) && cgit_repo->snapshots) {	70	if ((cgit_cmd == CMD_SNAPSHOT) && cgit_repo->snapshots) {
71	cgit_print_snapshot(item, cgit_query_head, cgit_query_sha1,	71	cgit_print_snapshot(item, cgit_query_head, cgit_query_sha1,
72	cgit_repobasename(cgit_repo->url),	72	cgit_repobasename(cgit_repo->url),
73	cgit_query_path,	73	cgit_query_path,
74	cgit_repo->snapshots );	74	cgit_repo->snapshots );
75	return;	75	return;
76	}	76	}
77		77
78	if (cgit_cmd == CMD_BLOB) {	78	if (cgit_cmd == CMD_BLOB) {
79	cgit_print_blob(item, cgit_query_sha1, cgit_query_path);	79	cgit_print_blob(item, cgit_query_sha1, cgit_query_path);
80	return;	80	return;
81	}	81	}
82		82
83	show_search = (cgit_cmd == CMD_LOG);	83	show_search = (cgit_cmd == CMD_LOG);
84	cgit_print_docstart(title, item);	84	cgit_print_docstart(title, item);
85	if (!cgit_cmd) {	85	if (!cgit_cmd) {
86	cgit_print_pageheader("summary", show_search);	86	cgit_print_pageheader("summary", show_search);
87	cgit_print_summary();	87	cgit_print_summary();
88	cgit_print_docend();	88	cgit_print_docend();
89	return;	89	return;
90	}	90	}
91		91
92	cgit_print_pageheader(cgit_query_page, show_search);	92	cgit_print_pageheader(cgit_query_page, show_search);
93		93
94	switch(cgit_cmd) {	94	switch(cgit_cmd) {
95	case CMD_LOG:	95	case CMD_LOG:
96	cgit_print_log(cgit_query_sha1, cgit_query_ofs,	96	cgit_print_log(cgit_query_sha1, cgit_query_ofs,
97	cgit_max_commit_count, cgit_query_search,	97	cgit_max_commit_count, cgit_query_search,
98	cgit_query_path, 1);	98	cgit_query_path, 1);
99	break;	99	break;
100	case CMD_TREE:	100	case CMD_TREE:
101	cgit_print_tree(cgit_query_sha1, cgit_query_path);	101	cgit_print_tree(cgit_query_sha1, cgit_query_path);
102	break;	102	break;
103	case CMD_COMMIT:	103	case CMD_COMMIT:
104	cgit_print_commit(cgit_query_sha1);	104	cgit_print_commit(cgit_query_sha1);
105	break;	105	break;
106	case CMD_TAG:	106	case CMD_TAG:
107	cgit_print_tag(cgit_query_sha1);	107	cgit_print_tag(cgit_query_sha1);
108	break;	108	break;
109	case CMD_DIFF:	109	case CMD_DIFF:
110	cgit_print_diff(cgit_query_sha1, cgit_query_sha2);	110	cgit_print_diff(cgit_query_sha1, cgit_query_sha2, cgit_query_path);
111	break;	111	break;
112	default:	112	default:
113	cgit_print_error("Invalid request");	113	cgit_print_error("Invalid request");
114	}	114	}
115	cgit_print_docend();	115	cgit_print_docend();
116	}	116	}
117		117
118	static void cgit_fill_cache(struct cacheitem *item, int use_cache)	118	static void cgit_fill_cache(struct cacheitem *item, int use_cache)
119	{	119	{
120	static char buf[PATH_MAX];	120	static char buf[PATH_MAX];
121	int stdout2;	121	int stdout2;
122		122
123	getcwd(buf, sizeof(buf));	123	getcwd(buf, sizeof(buf));
124	item->st.st_mtime = time(NULL);	124	item->st.st_mtime = time(NULL);
125		125
126	if (use_cache) {	126	if (use_cache) {
127	stdout2 = chk_positive(dup(STDOUT_FILENO),	127	stdout2 = chk_positive(dup(STDOUT_FILENO),
128	"Preserving STDOUT");	128	"Preserving STDOUT");
129	chk_zero(close(STDOUT_FILENO), "Closing STDOUT");	129	chk_zero(close(STDOUT_FILENO), "Closing STDOUT");
130	chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)");	130	chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)");
131	}	131	}
132		132
133	if (cgit_repo)	133	if (cgit_repo)
134	cgit_print_repo_page(item);	134	cgit_print_repo_page(item);
135	else	135	else
136	cgit_print_repolist(item);	136	cgit_print_repolist(item);
137		137
138	if (use_cache) {	138	if (use_cache) {
139	chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT");	139	chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT");
140	chk_positive(dup2(stdout2, STDOUT_FILENO),	140	chk_positive(dup2(stdout2, STDOUT_FILENO),
141	"Restoring original STDOUT");	141	"Restoring original STDOUT");
142	chk_zero(close(stdout2), "Closing temporary STDOUT");	142	chk_zero(close(stdout2), "Closing temporary STDOUT");
143	}	143	}
144		144
145	chdir(buf);	145	chdir(buf);
146	}	146	}
147		147
148	static void cgit_check_cache(struct cacheitem *item)	148	static void cgit_check_cache(struct cacheitem *item)
149	{	149	{
150	int i = 0;	150	int i = 0;
151		151
152	top:	152	top:
153	if (++i > cgit_max_lock_attempts) {	153	if (++i > cgit_max_lock_attempts) {
154	die("cgit_refresh_cache: unable to lock %s: %s",	154	die("cgit_refresh_cache: unable to lock %s: %s",
155	item->name, strerror(errno));	155	item->name, strerror(errno));
156	}	156	}
157	if (!cache_exist(item)) {	157	if (!cache_exist(item)) {
158	if (!cache_lock(item)) {	158	if (!cache_lock(item)) {
159	sleep(1);	159	sleep(1);
160	goto top;	160	goto top;
161	}	161	}
162	if (!cache_exist(item)) {	162	if (!cache_exist(item)) {
163	cgit_fill_cache(item, 1);	163	cgit_fill_cache(item, 1);
164	cache_unlock(item);	164	cache_unlock(item);
165	} else {	165	} else {
166	cache_cancel_lock(item);	166	cache_cancel_lock(item);
167	}	167	}
168	} else if (cache_expired(item) && cache_lock(item)) {	168	} else if (cache_expired(item) && cache_lock(item)) {
169	if (cache_expired(item)) {	169	if (cache_expired(item)) {
170	cgit_fill_cache(item, 1);	170	cgit_fill_cache(item, 1);
171	cache_unlock(item);	171	cache_unlock(item);
172	} else {	172	} else {
173	cache_cancel_lock(item);	173	cache_cancel_lock(item);
174	}	174	}
175	}	175	}
176	}	176	}
177		177
178	static void cgit_print_cache(struct cacheitem *item)	178	static void cgit_print_cache(struct cacheitem *item)
179	{	179	{
180	static char buf[4096];	180	static char buf[4096];
181	ssize_t i;	181	ssize_t i;
182		182
183	int fd = open(item->name, O_RDONLY);	183	int fd = open(item->name, O_RDONLY);
184	if (fd<0)	184	if (fd<0)
185	die("Unable to open cached file %s", item->name);	185	die("Unable to open cached file %s", item->name);
186		186
187	while((i=read(fd, buf, sizeof(buf))) > 0)	187	while((i=read(fd, buf, sizeof(buf))) > 0)
188	write(STDOUT_FILENO, buf, i);	188	write(STDOUT_FILENO, buf, i);
189		189
190	close(fd);	190	close(fd);
191	}	191	}
192		192
193	static void cgit_parse_args(int argc, const char **argv)	193	static void cgit_parse_args(int argc, const char **argv)
194	{	194	{
195	int i;	195	int i;
196		196
197	for (i = 1; i < argc; i++) {	197	for (i = 1; i < argc; i++) {
198	if (!strncmp(argv[i], "--cache=", 8)) {	198	if (!strncmp(argv[i], "--cache=", 8)) {
199	cgit_cache_root = xstrdup(argv[i]+8);	199	cgit_cache_root = xstrdup(argv[i]+8);
200	}	200	}
201	if (!strcmp(argv[i], "--nocache")) {	201	if (!strcmp(argv[i], "--nocache")) {
202	cgit_nocache = 1;	202	cgit_nocache = 1;
203	}	203	}
204	if (!strncmp(argv[i], "--query=", 8)) {	204	if (!strncmp(argv[i], "--query=", 8)) {
205	cgit_querystring = xstrdup(argv[i]+8);	205	cgit_querystring = xstrdup(argv[i]+8);
206	}	206	}
207	if (!strncmp(argv[i], "--repo=", 7)) {	207	if (!strncmp(argv[i], "--repo=", 7)) {
208	cgit_query_repo = xstrdup(argv[i]+7);	208	cgit_query_repo = xstrdup(argv[i]+7);
209	}	209	}
210	if (!strncmp(argv[i], "--page=", 7)) {	210	if (!strncmp(argv[i], "--page=", 7)) {
211	cgit_query_page = xstrdup(argv[i]+7);	211	cgit_query_page = xstrdup(argv[i]+7);
212	}	212	}
213	if (!strncmp(argv[i], "--head=", 7)) {	213	if (!strncmp(argv[i], "--head=", 7)) {
214	cgit_query_head = xstrdup(argv[i]+7);	214	cgit_query_head = xstrdup(argv[i]+7);
215	cgit_query_has_symref = 1;	215	cgit_query_has_symref = 1;
216	}	216	}
217	if (!strncmp(argv[i], "--sha1=", 7)) {	217	if (!strncmp(argv[i], "--sha1=", 7)) {
218	cgit_query_sha1 = xstrdup(argv[i]+7);	218	cgit_query_sha1 = xstrdup(argv[i]+7);
219	cgit_query_has_sha1 = 1;	219	cgit_query_has_sha1 = 1;
220	}	220	}
221	if (!strncmp(argv[i], "--ofs=", 6)) {	221	if (!strncmp(argv[i], "--ofs=", 6)) {
222	cgit_query_ofs = atoi(argv[i]+6);	222	cgit_query_ofs = atoi(argv[i]+6);
223	}	223	}
224	}	224	}
225	}	225	}
226		226
227	int main(int argc, const char **argv)	227	int main(int argc, const char **argv)
228	{	228	{
229	struct cacheitem item;	229	struct cacheitem item;
230	const char *cgit_config_env = getenv("CGIT_CONFIG");	230	const char *cgit_config_env = getenv("CGIT_CONFIG");
231		231
232	htmlfd = STDOUT_FILENO;	232	htmlfd = STDOUT_FILENO;
233	item.st.st_mtime = time(NULL);	233	item.st.st_mtime = time(NULL);
234	cgit_repolist.length = 0;	234	cgit_repolist.length = 0;
235	cgit_repolist.count = 0;	235	cgit_repolist.count = 0;
236	cgit_repolist.repos = NULL;	236	cgit_repolist.repos = NULL;
237		237
238	cgit_read_config(cgit_config_env ? cgit_config_env : CGIT_CONFIG,	238	cgit_read_config(cgit_config_env ? cgit_config_env : CGIT_CONFIG,
239	cgit_global_config_cb);	239	cgit_global_config_cb);
240	cgit_repo = NULL;	240	cgit_repo = NULL;
241	if (getenv("SCRIPT_NAME"))	241	if (getenv("SCRIPT_NAME"))
242	cgit_script_name = xstrdup(getenv("SCRIPT_NAME"));	242	cgit_script_name = xstrdup(getenv("SCRIPT_NAME"));
243	if (getenv("QUERY_STRING"))	243	if (getenv("QUERY_STRING"))
244	cgit_querystring = xstrdup(getenv("QUERY_STRING"));	244	cgit_querystring = xstrdup(getenv("QUERY_STRING"));
245	cgit_parse_args(argc, argv);	245	cgit_parse_args(argc, argv);
246	cgit_parse_query(cgit_querystring, cgit_querystring_cb);	246	cgit_parse_query(cgit_querystring, cgit_querystring_cb);
247	if (!cgit_prepare_cache(&item))	247	if (!cgit_prepare_cache(&item))
248	return 0;	248	return 0;
249	if (cgit_nocache) {	249	if (cgit_nocache) {
250	cgit_fill_cache(&item, 0);	250	cgit_fill_cache(&item, 0);
251	} else {	251	} else {
252	cgit_check_cache(&item);	252	cgit_check_cache(&item);
253	cgit_print_cache(&item);	253	cgit_print_cache(&item);
254	}	254	}
255	return 0;	255	return 0;
256	}	256	}