neocgit

a more 'modern' version of cgit
Log | Files | Refs | Submodules | README | LICENSE | git clone https://git.ne02ptzero.me/git/neocgit

cgit.c (34652B)


      1 /* cgit.c: cgi for the git scm
      2  *
      3  * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>
      4  *
      5  * Licensed under GNU General Public License v2
      6  *   (see COPYING for full license text)
      7  */
      8 
      9 #include "cgit.h"
     10 #include "cache.h"
     11 #include "cmd.h"
     12 #include "configfile.h"
     13 #include "html.h"
     14 #include "ui-shared.h"
     15 #include "ui-stats.h"
     16 #include "ui-blob.h"
     17 #include "ui-summary.h"
     18 #include "scan-tree.h"
     19 
     20 const char *cgit_version = CGIT_VERSION;
     21 
     22 static void add_mimetype(const char *name, const char *value)
     23 {
     24 	struct string_list_item *item;
     25 
     26 	item = string_list_insert(&ctx.cfg.mimetypes, name);
     27 	item->util = xstrdup(value);
     28 }
     29 
     30 static void process_cached_repolist(const char *path);
     31 
     32 static void repo_config(struct cgit_repo *repo, const char *name, const char *value)
     33 {
     34 	const char *path;
     35 	struct string_list_item *item;
     36 
     37 	if (!strcmp(name, "name"))
     38 		repo->name = xstrdup(value);
     39 	else if (!strcmp(name, "clone-url"))
     40 		repo->clone_url = xstrdup(value);
     41 	else if (!strcmp(name, "desc"))
     42 		repo->desc = xstrdup(value);
     43 	else if (!strcmp(name, "owner"))
     44 		repo->owner = xstrdup(value);
     45 	else if (!strcmp(name, "homepage"))
     46 		repo->homepage = xstrdup(value);
     47 	else if (!strcmp(name, "defbranch"))
     48 		repo->defbranch = xstrdup(value);
     49 	else if (!strcmp(name, "snapshots"))
     50 		repo->snapshots = ctx.cfg.snapshots & cgit_parse_snapshots_mask(value);
     51 	else if (!strcmp(name, "enable-commit-graph"))
     52 		repo->enable_commit_graph = atoi(value);
     53 	else if (!strcmp(name, "enable-log-filecount"))
     54 		repo->enable_log_filecount = atoi(value);
     55 	else if (!strcmp(name, "enable-log-linecount"))
     56 		repo->enable_log_linecount = atoi(value);
     57 	else if (!strcmp(name, "enable-remote-branches"))
     58 		repo->enable_remote_branches = atoi(value);
     59 	else if (!strcmp(name, "enable-subject-links"))
     60 		repo->enable_subject_links = atoi(value);
     61 	else if (!strcmp(name, "enable-html-serving"))
     62 		repo->enable_html_serving = atoi(value);
     63 	else if (!strcmp(name, "branch-sort")) {
     64 		if (!strcmp(value, "age"))
     65 			repo->branch_sort = 1;
     66 		if (!strcmp(value, "name"))
     67 			repo->branch_sort = 0;
     68 	} else if (!strcmp(name, "commit-sort")) {
     69 		if (!strcmp(value, "date"))
     70 			repo->commit_sort = 1;
     71 		if (!strcmp(value, "topo"))
     72 			repo->commit_sort = 2;
     73 	} else if (!strcmp(name, "max-stats"))
     74 		repo->max_stats = cgit_find_stats_period(value, NULL);
     75 	else if (!strcmp(name, "module-link"))
     76 		repo->module_link= xstrdup(value);
     77 	else if (skip_prefix(name, "module-link.", &path)) {
     78 		item = string_list_append(&repo->submodules, xstrdup(path));
     79 		item->util = xstrdup(value);
     80 	} else if (!strcmp(name, "section"))
     81 		repo->section = xstrdup(value);
     82 	else if (!strcmp(name, "snapshot-prefix"))
     83 		repo->snapshot_prefix = xstrdup(value);
     84 	else if (!strcmp(name, "readme") && value != NULL) {
     85 		if (repo->readme.items == ctx.cfg.readme.items)
     86 			memset(&repo->readme, 0, sizeof(repo->readme));
     87 		string_list_append(&repo->readme, xstrdup(value));
     88 	} else if (!strcmp(name, "logo") && value != NULL)
     89 		repo->logo = xstrdup(value);
     90 	else if (!strcmp(name, "logo-link") && value != NULL)
     91 		repo->logo_link = xstrdup(value);
     92 	else if (!strcmp(name, "hide"))
     93 		repo->hide = atoi(value);
     94 	else if (!strcmp(name, "ignore"))
     95 		repo->ignore = atoi(value);
     96 	else if (ctx.cfg.enable_filter_overrides) {
     97 		if (!strcmp(name, "about-filter"))
     98 			repo->about_filter = cgit_new_filter(value, ABOUT);
     99 		else if (!strcmp(name, "commit-filter"))
    100 			repo->commit_filter = cgit_new_filter(value, COMMIT);
    101 		else if (!strcmp(name, "source-filter"))
    102 			repo->source_filter = cgit_new_filter(value, SOURCE);
    103 		else if (!strcmp(name, "email-filter"))
    104 			repo->email_filter = cgit_new_filter(value, EMAIL);
    105 		else if (!strcmp(name, "owner-filter"))
    106 			repo->owner_filter = cgit_new_filter(value, OWNER);
    107 	}
    108 }
    109 
    110 static void config_cb(const char *name, const char *value)
    111 {
    112 	const char *arg;
    113 
    114 	if (!strcmp(name, "section"))
    115 		ctx.cfg.section = xstrdup(value);
    116 	else if (!strcmp(name, "repo.url"))
    117 		ctx.repo = cgit_add_repo(value);
    118 	else if (ctx.repo && !strcmp(name, "repo.path"))
    119 		ctx.repo->path = trim_end(value, '/');
    120 	else if (ctx.repo && skip_prefix(name, "repo.", &arg))
    121 		repo_config(ctx.repo, arg, value);
    122 	else if (!strcmp(name, "readme"))
    123 		string_list_append(&ctx.cfg.readme, xstrdup(value));
    124 	else if (!strcmp(name, "root-title"))
    125 		ctx.cfg.root_title = xstrdup(value);
    126 	else if (!strcmp(name, "root-desc"))
    127 		ctx.cfg.root_desc = xstrdup(value);
    128 	else if (!strcmp(name, "root-readme"))
    129 		ctx.cfg.root_readme = xstrdup(value);
    130 	else if (!strcmp(name, "css"))
    131 		ctx.cfg.css = xstrdup(value);
    132 	else if (!strcmp(name, "favicon"))
    133 		ctx.cfg.favicon = xstrdup(value);
    134 	else if (!strcmp(name, "footer"))
    135 		ctx.cfg.footer = xstrdup(value);
    136 	else if (!strcmp(name, "head-include"))
    137 		ctx.cfg.head_include = xstrdup(value);
    138 	else if (!strcmp(name, "header"))
    139 		ctx.cfg.header = xstrdup(value);
    140 	else if (!strcmp(name, "logo"))
    141 		ctx.cfg.logo = xstrdup(value);
    142 	else if (!strcmp(name, "logo-link"))
    143 		ctx.cfg.logo_link = xstrdup(value);
    144 	else if (!strcmp(name, "module-link"))
    145 		ctx.cfg.module_link = xstrdup(value);
    146 	else if (!strcmp(name, "strict-export"))
    147 		ctx.cfg.strict_export = xstrdup(value);
    148 	else if (!strcmp(name, "virtual-root"))
    149 		ctx.cfg.virtual_root = ensure_end(value, '/');
    150 	else if (!strcmp(name, "noplainemail"))
    151 		ctx.cfg.noplainemail = atoi(value);
    152 	else if (!strcmp(name, "noheader"))
    153 		ctx.cfg.noheader = atoi(value);
    154 	else if (!strcmp(name, "snapshots"))
    155 		ctx.cfg.snapshots = cgit_parse_snapshots_mask(value);
    156 	else if (!strcmp(name, "enable-filter-overrides"))
    157 		ctx.cfg.enable_filter_overrides = atoi(value);
    158 	else if (!strcmp(name, "enable-follow-links"))
    159 		ctx.cfg.enable_follow_links = atoi(value);
    160 	else if (!strcmp(name, "enable-http-clone"))
    161 		ctx.cfg.enable_http_clone = atoi(value);
    162 	else if (!strcmp(name, "enable-index-links"))
    163 		ctx.cfg.enable_index_links = atoi(value);
    164 	else if (!strcmp(name, "enable-index-owner"))
    165 		ctx.cfg.enable_index_owner = atoi(value);
    166 	else if (!strcmp(name, "enable-blame"))
    167 		ctx.cfg.enable_blame = atoi(value);
    168 	else if (!strcmp(name, "enable-commit-graph"))
    169 		ctx.cfg.enable_commit_graph = atoi(value);
    170 	else if (!strcmp(name, "enable-log-filecount"))
    171 		ctx.cfg.enable_log_filecount = atoi(value);
    172 	else if (!strcmp(name, "enable-log-linecount"))
    173 		ctx.cfg.enable_log_linecount = atoi(value);
    174 	else if (!strcmp(name, "enable-remote-branches"))
    175 		ctx.cfg.enable_remote_branches = atoi(value);
    176 	else if (!strcmp(name, "enable-subject-links"))
    177 		ctx.cfg.enable_subject_links = atoi(value);
    178 	else if (!strcmp(name, "enable-html-serving"))
    179 		ctx.cfg.enable_html_serving = atoi(value);
    180 	else if (!strcmp(name, "enable-tree-linenumbers"))
    181 		ctx.cfg.enable_tree_linenumbers = atoi(value);
    182 	else if (!strcmp(name, "enable-git-config"))
    183 		ctx.cfg.enable_git_config = atoi(value);
    184 	else if (!strcmp(name, "max-stats"))
    185 		ctx.cfg.max_stats = cgit_find_stats_period(value, NULL);
    186 	else if (!strcmp(name, "cache-size"))
    187 		ctx.cfg.cache_size = atoi(value);
    188 	else if (!strcmp(name, "cache-root"))
    189 		ctx.cfg.cache_root = xstrdup(expand_macros(value));
    190 	else if (!strcmp(name, "cache-root-ttl"))
    191 		ctx.cfg.cache_root_ttl = atoi(value);
    192 	else if (!strcmp(name, "cache-repo-ttl"))
    193 		ctx.cfg.cache_repo_ttl = atoi(value);
    194 	else if (!strcmp(name, "cache-scanrc-ttl"))
    195 		ctx.cfg.cache_scanrc_ttl = atoi(value);
    196 	else if (!strcmp(name, "cache-static-ttl"))
    197 		ctx.cfg.cache_static_ttl = atoi(value);
    198 	else if (!strcmp(name, "cache-dynamic-ttl"))
    199 		ctx.cfg.cache_dynamic_ttl = atoi(value);
    200 	else if (!strcmp(name, "cache-about-ttl"))
    201 		ctx.cfg.cache_about_ttl = atoi(value);
    202 	else if (!strcmp(name, "cache-snapshot-ttl"))
    203 		ctx.cfg.cache_snapshot_ttl = atoi(value);
    204 	else if (!strcmp(name, "case-sensitive-sort"))
    205 		ctx.cfg.case_sensitive_sort = atoi(value);
    206 	else if (!strcmp(name, "about-filter"))
    207 		ctx.cfg.about_filter = cgit_new_filter(value, ABOUT);
    208 	else if (!strcmp(name, "commit-filter"))
    209 		ctx.cfg.commit_filter = cgit_new_filter(value, COMMIT);
    210 	else if (!strcmp(name, "email-filter"))
    211 		ctx.cfg.email_filter = cgit_new_filter(value, EMAIL);
    212 	else if (!strcmp(name, "owner-filter"))
    213 		ctx.cfg.owner_filter = cgit_new_filter(value, OWNER);
    214 	else if (!strcmp(name, "auth-filter"))
    215 		ctx.cfg.auth_filter = cgit_new_filter(value, AUTH);
    216 	else if (!strcmp(name, "embedded"))
    217 		ctx.cfg.embedded = atoi(value);
    218 	else if (!strcmp(name, "max-atom-items"))
    219 		ctx.cfg.max_atom_items = atoi(value);
    220 	else if (!strcmp(name, "max-message-length"))
    221 		ctx.cfg.max_msg_len = atoi(value);
    222 	else if (!strcmp(name, "max-repodesc-length"))
    223 		ctx.cfg.max_repodesc_len = atoi(value);
    224 	else if (!strcmp(name, "max-blob-size"))
    225 		ctx.cfg.max_blob_size = atoi(value);
    226 	else if (!strcmp(name, "max-repo-count"))
    227 		ctx.cfg.max_repo_count = atoi(value);
    228 	else if (!strcmp(name, "max-commit-count"))
    229 		ctx.cfg.max_commit_count = atoi(value);
    230 	else if (!strcmp(name, "project-list"))
    231 		ctx.cfg.project_list = xstrdup(expand_macros(value));
    232 	else if (!strcmp(name, "scan-path"))
    233 		if (ctx.cfg.cache_size)
    234 			process_cached_repolist(expand_macros(value));
    235 		else if (ctx.cfg.project_list)
    236 			scan_projects(expand_macros(value),
    237 				      ctx.cfg.project_list, repo_config);
    238 		else
    239 			scan_tree(expand_macros(value), repo_config);
    240 	else if (!strcmp(name, "scan-hidden-path"))
    241 		ctx.cfg.scan_hidden_path = atoi(value);
    242 	else if (!strcmp(name, "section-from-path"))
    243 		ctx.cfg.section_from_path = atoi(value);
    244 	else if (!strcmp(name, "repository-sort"))
    245 		ctx.cfg.repository_sort = xstrdup(value);
    246 	else if (!strcmp(name, "section-sort"))
    247 		ctx.cfg.section_sort = atoi(value);
    248 	else if (!strcmp(name, "source-filter"))
    249 		ctx.cfg.source_filter = cgit_new_filter(value, SOURCE);
    250 	else if (!strcmp(name, "summary-log"))
    251 		ctx.cfg.summary_log = atoi(value);
    252 	else if (!strcmp(name, "summary-branches"))
    253 		ctx.cfg.summary_branches = atoi(value);
    254 	else if (!strcmp(name, "summary-tags"))
    255 		ctx.cfg.summary_tags = atoi(value);
    256 	else if (!strcmp(name, "side-by-side-diffs"))
    257 		ctx.cfg.difftype = atoi(value) ? DIFF_SSDIFF : DIFF_UNIFIED;
    258 	else if (!strcmp(name, "agefile"))
    259 		ctx.cfg.agefile = xstrdup(value);
    260 	else if (!strcmp(name, "mimetype-file"))
    261 		ctx.cfg.mimetype_file = xstrdup(value);
    262 	else if (!strcmp(name, "renamelimit"))
    263 		ctx.cfg.renamelimit = atoi(value);
    264 	else if (!strcmp(name, "remove-suffix"))
    265 		ctx.cfg.remove_suffix = atoi(value);
    266 	else if (!strcmp(name, "robots"))
    267 		ctx.cfg.robots = xstrdup(value);
    268 	else if (!strcmp(name, "clone-prefix"))
    269 		ctx.cfg.clone_prefix = xstrdup(value);
    270 	else if (!strcmp(name, "clone-url"))
    271 		ctx.cfg.clone_url = xstrdup(value);
    272 	else if (!strcmp(name, "local-time"))
    273 		ctx.cfg.local_time = atoi(value);
    274 	else if (!strcmp(name, "commit-sort")) {
    275 		if (!strcmp(value, "date"))
    276 			ctx.cfg.commit_sort = 1;
    277 		if (!strcmp(value, "topo"))
    278 			ctx.cfg.commit_sort = 2;
    279 	} else if (!strcmp(name, "branch-sort")) {
    280 		if (!strcmp(value, "age"))
    281 			ctx.cfg.branch_sort = 1;
    282 		if (!strcmp(value, "name"))
    283 			ctx.cfg.branch_sort = 0;
    284 	} else if (skip_prefix(name, "mimetype.", &arg))
    285 		add_mimetype(arg, value);
    286 	else if (!strcmp(name, "include"))
    287 		parse_configfile(expand_macros(value), config_cb);
    288 }
    289 
    290 static void querystring_cb(const char *name, const char *value)
    291 {
    292 	if (!value)
    293 		value = "";
    294 
    295 	if (!strcmp(name,"r")) {
    296 		ctx.qry.repo = xstrdup(value);
    297 		ctx.repo = cgit_get_repoinfo(value);
    298 	} else if (!strcmp(name, "p")) {
    299 		ctx.qry.page = xstrdup(value);
    300 	} else if (!strcmp(name, "url")) {
    301 		if (*value == '/')
    302 			value++;
    303 		ctx.qry.url = xstrdup(value);
    304 		cgit_parse_url(value);
    305 	} else if (!strcmp(name, "qt")) {
    306 		ctx.qry.grep = xstrdup(value);
    307 	} else if (!strcmp(name, "q")) {
    308 		ctx.qry.search = xstrdup(value);
    309 	} else if (!strcmp(name, "h")) {
    310 		ctx.qry.head = xstrdup(value);
    311 		ctx.qry.has_symref = 1;
    312 	} else if (!strcmp(name, "id")) {
    313 		ctx.qry.sha1 = xstrdup(value);
    314 		ctx.qry.has_sha1 = 1;
    315 	} else if (!strcmp(name, "id2")) {
    316 		ctx.qry.sha2 = xstrdup(value);
    317 		ctx.qry.has_sha1 = 1;
    318 	} else if (!strcmp(name, "ofs")) {
    319 		ctx.qry.ofs = atoi(value);
    320 	} else if (!strcmp(name, "path")) {
    321 		ctx.qry.path = trim_end(value, '/');
    322 	} else if (!strcmp(name, "name")) {
    323 		ctx.qry.name = xstrdup(value);
    324 	} else if (!strcmp(name, "s")) {
    325 		ctx.qry.sort = xstrdup(value);
    326 	} else if (!strcmp(name, "showmsg")) {
    327 		ctx.qry.showmsg = atoi(value);
    328 	} else if (!strcmp(name, "period")) {
    329 		ctx.qry.period = xstrdup(value);
    330 	} else if (!strcmp(name, "dt")) {
    331 		ctx.qry.difftype = atoi(value);
    332 		ctx.qry.has_difftype = 1;
    333 	} else if (!strcmp(name, "ss")) {
    334 		/* No longer generated, but there may be links out there. */
    335 		ctx.qry.difftype = atoi(value) ? DIFF_SSDIFF : DIFF_UNIFIED;
    336 		ctx.qry.has_difftype = 1;
    337 	} else if (!strcmp(name, "all")) {
    338 		ctx.qry.show_all = atoi(value);
    339 	} else if (!strcmp(name, "context")) {
    340 		ctx.qry.context = atoi(value);
    341 	} else if (!strcmp(name, "ignorews")) {
    342 		ctx.qry.ignorews = atoi(value);
    343 	} else if (!strcmp(name, "follow")) {
    344 		ctx.qry.follow = atoi(value);
    345 	}
    346 }
    347 
    348 static void prepare_context(void)
    349 {
    350 	memset(&ctx, 0, sizeof(ctx));
    351 	ctx.cfg.agefile = "info/web/last-modified";
    352 	ctx.cfg.cache_size = 0;
    353 	ctx.cfg.cache_max_create_time = 5;
    354 	ctx.cfg.cache_root = CGIT_CACHE_ROOT;
    355 	ctx.cfg.cache_about_ttl = 15;
    356 	ctx.cfg.cache_snapshot_ttl = 5;
    357 	ctx.cfg.cache_repo_ttl = 5;
    358 	ctx.cfg.cache_root_ttl = 5;
    359 	ctx.cfg.cache_scanrc_ttl = 15;
    360 	ctx.cfg.cache_dynamic_ttl = 5;
    361 	ctx.cfg.cache_static_ttl = -1;
    362 	ctx.cfg.case_sensitive_sort = 1;
    363 	ctx.cfg.branch_sort = 0;
    364 	ctx.cfg.commit_sort = 0;
    365 	ctx.cfg.css = "/cgit.css";
    366 	ctx.cfg.logo = "/cgit.png";
    367 	ctx.cfg.favicon = "/favicon.ico";
    368 	ctx.cfg.local_time = 0;
    369 	ctx.cfg.enable_http_clone = 1;
    370 	ctx.cfg.enable_index_owner = 1;
    371 	ctx.cfg.enable_tree_linenumbers = 1;
    372 	ctx.cfg.enable_git_config = 0;
    373 	ctx.cfg.max_repo_count = 50;
    374 	ctx.cfg.max_commit_count = 50;
    375 	ctx.cfg.max_lock_attempts = 5;
    376 	ctx.cfg.max_msg_len = 80;
    377 	ctx.cfg.max_repodesc_len = 80;
    378 	ctx.cfg.max_blob_size = 0;
    379 	ctx.cfg.max_stats = 0;
    380 	ctx.cfg.project_list = NULL;
    381 	ctx.cfg.renamelimit = -1;
    382 	ctx.cfg.remove_suffix = 0;
    383 	ctx.cfg.robots = "index, nofollow";
    384 	ctx.cfg.root_title = "Git repository browser";
    385 	ctx.cfg.root_desc = "a fast webinterface for the git dscm";
    386 	ctx.cfg.scan_hidden_path = 0;
    387 	ctx.cfg.script_name = CGIT_SCRIPT_NAME;
    388 	ctx.cfg.section = "";
    389 	ctx.cfg.repository_sort = "name";
    390 	ctx.cfg.section_sort = 1;
    391 	ctx.cfg.summary_branches = 10;
    392 	ctx.cfg.summary_log = 10;
    393 	ctx.cfg.summary_tags = 10;
    394 	ctx.cfg.max_atom_items = 10;
    395 	ctx.cfg.difftype = DIFF_UNIFIED;
    396 	ctx.env.cgit_config = getenv("CGIT_CONFIG");
    397 	ctx.env.http_host = getenv("HTTP_HOST");
    398 	ctx.env.https = getenv("HTTPS");
    399 	ctx.env.no_http = getenv("NO_HTTP");
    400 	ctx.env.path_info = getenv("PATH_INFO");
    401 	ctx.env.query_string = getenv("QUERY_STRING");
    402 	ctx.env.request_method = getenv("REQUEST_METHOD");
    403 	ctx.env.script_name = getenv("SCRIPT_NAME");
    404 	ctx.env.server_name = getenv("SERVER_NAME");
    405 	ctx.env.server_port = getenv("SERVER_PORT");
    406 	ctx.env.http_cookie = getenv("HTTP_COOKIE");
    407 	ctx.env.http_referer = getenv("HTTP_REFERER");
    408 	ctx.env.content_length = getenv("CONTENT_LENGTH") ? strtoul(getenv("CONTENT_LENGTH"), NULL, 10) : 0;
    409 	ctx.env.authenticated = 0;
    410 	ctx.page.mimetype = "text/html";
    411 	ctx.page.charset = PAGE_ENCODING;
    412 	ctx.page.filename = NULL;
    413 	ctx.page.size = 0;
    414 	ctx.page.modified = time(NULL);
    415 	ctx.page.expires = ctx.page.modified;
    416 	ctx.page.etag = NULL;
    417 	string_list_init(&ctx.cfg.mimetypes, 1);
    418 	if (ctx.env.script_name)
    419 		ctx.cfg.script_name = xstrdup(ctx.env.script_name);
    420 	if (ctx.env.query_string)
    421 		ctx.qry.raw = xstrdup(ctx.env.query_string);
    422 	if (!ctx.env.cgit_config)
    423 		ctx.env.cgit_config = CGIT_CONFIG;
    424 }
    425 
    426 struct refmatch {
    427 	char *req_ref;
    428 	char *first_ref;
    429 	int match;
    430 };
    431 
    432 static int find_current_ref(const char *refname, const struct object_id *oid,
    433 			    int flags, void *cb_data)
    434 {
    435 	struct refmatch *info;
    436 
    437 	info = (struct refmatch *)cb_data;
    438 	if (!strcmp(refname, info->req_ref))
    439 		info->match = 1;
    440 	if (!info->first_ref)
    441 		info->first_ref = xstrdup(refname);
    442 	return info->match;
    443 }
    444 
    445 static void free_refmatch_inner(struct refmatch *info)
    446 {
    447 	if (info->first_ref)
    448 		free(info->first_ref);
    449 }
    450 
    451 static char *find_default_branch(struct cgit_repo *repo)
    452 {
    453 	struct refmatch info;
    454 	char *ref;
    455 
    456 	info.req_ref = repo->defbranch;
    457 	info.first_ref = NULL;
    458 	info.match = 0;
    459 	for_each_branch_ref(find_current_ref, &info);
    460 	if (info.match)
    461 		ref = info.req_ref;
    462 	else
    463 		ref = info.first_ref;
    464 	if (ref)
    465 		ref = xstrdup(ref);
    466 	free_refmatch_inner(&info);
    467 
    468 	return ref;
    469 }
    470 
    471 static char *guess_defbranch(void)
    472 {
    473 	const char *ref, *refname;
    474 	struct object_id oid;
    475 
    476 	ref = resolve_ref_unsafe("HEAD", 0, &oid, NULL);
    477 	if (!ref || !skip_prefix(ref, "refs/heads/", &refname))
    478 		return "master";
    479 	return xstrdup(refname);
    480 }
    481 
    482 /* The caller must free filename and ref after calling this. */
    483 static inline void parse_readme(const char *readme, char **filename, char **ref, struct cgit_repo *repo)
    484 {
    485 	const char *colon;
    486 
    487 	*filename = NULL;
    488 	*ref = NULL;
    489 
    490 	if (!readme || !readme[0])
    491 		return;
    492 
    493 	/* Check if the readme is tracked in the git repo. */
    494 	colon = strchr(readme, ':');
    495 	if (colon && strlen(colon) > 1) {
    496 		/* If it starts with a colon, we want to use
    497 		 * the default branch */
    498 		if (colon == readme && repo->defbranch)
    499 			*ref = xstrdup(repo->defbranch);
    500 		else
    501 			*ref = xstrndup(readme, colon - readme);
    502 		readme = colon + 1;
    503 	}
    504 
    505 	/* Prepend repo path to relative readme path unless tracked. */
    506 	if (!(*ref) && readme[0] != '/')
    507 		*filename = fmtalloc("%s/%s", repo->path, readme);
    508 	else
    509 		*filename = xstrdup(readme);
    510 }
    511 static void choose_readme(struct cgit_repo *repo)
    512 {
    513 	int found;
    514 	char *filename, *ref;
    515 	struct string_list_item *entry;
    516 
    517 	if (!repo->readme.nr)
    518 		return;
    519 
    520 	found = 0;
    521 	for_each_string_list_item(entry, &repo->readme) {
    522 		parse_readme(entry->string, &filename, &ref, repo);
    523 		if (!filename) {
    524 			free(filename);
    525 			free(ref);
    526 			continue;
    527 		}
    528 		if (ref) {
    529 			if (cgit_ref_path_exists(filename, ref, 1)) {
    530 				found = 1;
    531 				break;
    532 			}
    533 		}
    534 		else if (!access(filename, R_OK)) {
    535 			found = 1;
    536 			break;
    537 		}
    538 		free(filename);
    539 		free(ref);
    540 	}
    541 	repo->readme.strdup_strings = 1;
    542 	string_list_clear(&repo->readme, 0);
    543 	repo->readme.strdup_strings = 0;
    544 	if (found)
    545 		string_list_append(&repo->readme, filename)->util = ref;
    546 }
    547 
    548 static void print_no_repo_clone_urls(const char *url)
    549 {
    550         html("<tr><td><a rel='vcs-git' href='");
    551         html_url_path(url);
    552         html("' title='");
    553         html_attr(ctx.repo->name);
    554         html(" Git repository'>");
    555         html_txt(url);
    556         html("</a></td></tr>\n");
    557 }
    558 
    559 static void prepare_repo_env(int *nongit)
    560 {
    561 	/* The path to the git repository. */
    562 	setenv("GIT_DIR", ctx.repo->path, 1);
    563 
    564 	/* Do not look in /etc/ for gitconfig and gitattributes. */
    565 	setenv("GIT_CONFIG_NOSYSTEM", "1", 1);
    566 	setenv("GIT_ATTR_NOSYSTEM", "1", 1);
    567 	unsetenv("HOME");
    568 	unsetenv("XDG_CONFIG_HOME");
    569 
    570 	/* Setup the git directory and initialize the notes system. Both of these
    571 	 * load local configuration from the git repository, so we do them both while
    572 	 * the HOME variables are unset. */
    573 	setup_git_directory_gently(nongit);
    574 	init_display_notes(NULL);
    575 }
    576 static int prepare_repo_cmd(int nongit)
    577 {
    578 	struct object_id oid;
    579 	int rc;
    580 
    581 	if (nongit) {
    582 		const char *name = ctx.repo->name;
    583 		rc = errno;
    584 		ctx.page.title = fmtalloc("%s - %s", ctx.cfg.root_title,
    585 						"config error");
    586 		ctx.repo = NULL;
    587 		cgit_print_http_headers();
    588 		cgit_print_docstart();
    589 		cgit_print_pageheader();
    590 		cgit_print_error("Failed to open %s: %s", name,
    591 				 rc ? strerror(rc) : "Not a valid git repository");
    592 		cgit_print_docend();
    593 		return 1;
    594 	}
    595 	ctx.page.title = fmtalloc("%s - %s", ctx.repo->name, ctx.repo->desc);
    596 
    597 	if (!ctx.repo->defbranch)
    598 		ctx.repo->defbranch = guess_defbranch();
    599 
    600 	if (!ctx.qry.head) {
    601 		ctx.qry.nohead = 1;
    602 		ctx.qry.head = find_default_branch(ctx.repo);
    603 	}
    604 
    605 	if (!ctx.qry.head) {
    606 		cgit_print_http_headers();
    607 		cgit_print_docstart();
    608 		cgit_print_pageheader();
    609 		cgit_print_error("Repository seems to be empty");
    610 		if (!strcmp(ctx.qry.page, "summary")) {
    611 			html("<table class='list'><tr class='nohover'><td>&nbsp;</td></tr><tr class='nohover'><th class='left'>Clone</th></tr>\n");
    612 			cgit_prepare_repo_env(ctx.repo);
    613 			cgit_add_clone_urls(print_no_repo_clone_urls);
    614 			html("</table>\n");
    615 		}
    616 		cgit_print_docend();
    617 		return 1;
    618 	}
    619 
    620 	if (get_oid(ctx.qry.head, &oid)) {
    621 		char *old_head = ctx.qry.head;
    622 		ctx.qry.head = xstrdup(ctx.repo->defbranch);
    623 		cgit_print_error_page(404, "Not found",
    624 				"Invalid branch: %s", old_head);
    625 		free(old_head);
    626 		return 1;
    627 	}
    628 	string_list_sort(&ctx.repo->submodules);
    629 	cgit_prepare_repo_env(ctx.repo);
    630 	choose_readme(ctx.repo);
    631 	return 0;
    632 }
    633 
    634 static inline void open_auth_filter(const char *function)
    635 {
    636 	cgit_open_filter(ctx.cfg.auth_filter, function,
    637 		ctx.env.http_cookie ? ctx.env.http_cookie : "",
    638 		ctx.env.request_method ? ctx.env.request_method : "",
    639 		ctx.env.query_string ? ctx.env.query_string : "",
    640 		ctx.env.http_referer ? ctx.env.http_referer : "",
    641 		ctx.env.path_info ? ctx.env.path_info : "",
    642 		ctx.env.http_host ? ctx.env.http_host : "",
    643 		ctx.env.https ? ctx.env.https : "",
    644 		ctx.qry.repo ? ctx.qry.repo : "",
    645 		ctx.qry.page ? ctx.qry.page : "",
    646 		ctx.qry.url ? ctx.qry.url : "",
    647 		cgit_loginurl());
    648 }
    649 
    650 /* We intentionally keep this rather small, instead of looping and
    651  * feeding it to the filter a couple bytes at a time. This way, the
    652  * filter itself does not need to handle any denial of service or
    653  * buffer bloat issues. If this winds up being too small, people
    654  * will complain on the mailing list, and we'll increase it as needed. */
    655 #define MAX_AUTHENTICATION_POST_BYTES 4096
    656 /* The filter is expected to spit out "Status: " and all headers. */
    657 static inline void authenticate_post(void)
    658 {
    659 	char buffer[MAX_AUTHENTICATION_POST_BYTES];
    660 	unsigned int len;
    661 
    662 	open_auth_filter("authenticate-post");
    663 	len = ctx.env.content_length;
    664 	if (len > MAX_AUTHENTICATION_POST_BYTES)
    665 		len = MAX_AUTHENTICATION_POST_BYTES;
    666 	if (read(STDIN_FILENO, buffer, len) < 0)
    667 		die_errno("Could not read POST from stdin");
    668 	if (write(STDOUT_FILENO, buffer, len) < 0)
    669 		die_errno("Could not write POST to stdout");
    670 	cgit_close_filter(ctx.cfg.auth_filter);
    671 	exit(0);
    672 }
    673 
    674 static inline void authenticate_cookie(void)
    675 {
    676 	/* If we don't have an auth_filter, consider all cookies valid, and thus return early. */
    677 	if (!ctx.cfg.auth_filter) {
    678 		ctx.env.authenticated = 1;
    679 		return;
    680 	}
    681 
    682 	/* If we're having something POST'd to /login, we're authenticating POST,
    683 	 * instead of the cookie, so call authenticate_post and bail out early.
    684 	 * This pattern here should match /?p=login with POST. */
    685 	if (ctx.env.request_method && ctx.qry.page && !ctx.repo && \
    686 	    !strcmp(ctx.env.request_method, "POST") && !strcmp(ctx.qry.page, "login")) {
    687 		authenticate_post();
    688 		return;
    689 	}
    690 
    691 	/* If we've made it this far, we're authenticating the cookie for real, so do that. */
    692 	open_auth_filter("authenticate-cookie");
    693 	ctx.env.authenticated = cgit_close_filter(ctx.cfg.auth_filter);
    694 }
    695 
    696 static void process_request(void)
    697 {
    698 	struct cgit_cmd *cmd;
    699 	int nongit = 0;
    700 
    701 	/* If we're not yet authenticated, no matter what page we're on,
    702 	 * display the authentication body from the auth_filter. This should
    703 	 * never be cached. */
    704 	if (!ctx.env.authenticated) {
    705 		ctx.page.title = "Authentication Required";
    706 		cgit_print_http_headers();
    707 		cgit_print_docstart();
    708 		cgit_print_pageheader();
    709 		open_auth_filter("body");
    710 		cgit_close_filter(ctx.cfg.auth_filter);
    711 		cgit_print_docend();
    712 		return;
    713 	}
    714 
    715 	if (ctx.repo)
    716 		prepare_repo_env(&nongit);
    717 
    718 	cmd = cgit_get_cmd();
    719 	if (!cmd) {
    720 		ctx.page.title = "cgit error";
    721 		cgit_print_error_page(404, "Not found", "Invalid request");
    722 		return;
    723 	}
    724 
    725 	if (!ctx.cfg.enable_http_clone && cmd->is_clone) {
    726 		ctx.page.title = "cgit error";
    727 		cgit_print_error_page(404, "Not found", "Invalid request");
    728 		return;
    729 	}
    730 
    731 	if (cmd->want_repo && !ctx.repo) {
    732 		cgit_print_error_page(400, "Bad request",
    733 				"No repository selected");
    734 		return;
    735 	}
    736 
    737 	/* If cmd->want_vpath is set, assume ctx.qry.path contains a "virtual"
    738 	 * in-project path limit to be made available at ctx.qry.vpath.
    739 	 * Otherwise, no path limit is in effect (ctx.qry.vpath = NULL).
    740 	 */
    741 	ctx.qry.vpath = cmd->want_vpath ? ctx.qry.path : NULL;
    742 
    743 	if (ctx.repo && prepare_repo_cmd(nongit))
    744 		return;
    745 
    746 	cmd->fn();
    747 }
    748 
    749 static int cmp_repos(const void *a, const void *b)
    750 {
    751 	const struct cgit_repo *ra = a, *rb = b;
    752 	return strcmp(ra->url, rb->url);
    753 }
    754 
    755 static char *build_snapshot_setting(int bitmap)
    756 {
    757 	const struct cgit_snapshot_format *f;
    758 	struct strbuf result = STRBUF_INIT;
    759 
    760 	for (f = cgit_snapshot_formats; f->suffix; f++) {
    761 		if (cgit_snapshot_format_bit(f) & bitmap) {
    762 			if (result.len)
    763 				strbuf_addch(&result, ' ');
    764 			strbuf_addstr(&result, f->suffix);
    765 		}
    766 	}
    767 	return strbuf_detach(&result, NULL);
    768 }
    769 
    770 static char *get_first_line(char *txt)
    771 {
    772 	char *t = xstrdup(txt);
    773 	char *p = strchr(t, '\n');
    774 	if (p)
    775 		*p = '\0';
    776 	return t;
    777 }
    778 
    779 static void print_repo(FILE *f, struct cgit_repo *repo)
    780 {
    781 	struct string_list_item *item;
    782 	fprintf(f, "repo.url=%s\n", repo->url);
    783 	fprintf(f, "repo.name=%s\n", repo->name);
    784 	fprintf(f, "repo.path=%s\n", repo->path);
    785 	if (repo->owner)
    786 		fprintf(f, "repo.owner=%s\n", repo->owner);
    787 	if (repo->desc) {
    788 		char *tmp = get_first_line(repo->desc);
    789 		fprintf(f, "repo.desc=%s\n", tmp);
    790 		free(tmp);
    791 	}
    792 	for_each_string_list_item(item, &repo->readme) {
    793 		if (item->util)
    794 			fprintf(f, "repo.readme=%s:%s\n", (char *)item->util, item->string);
    795 		else
    796 			fprintf(f, "repo.readme=%s\n", item->string);
    797 	}
    798 	if (repo->defbranch)
    799 		fprintf(f, "repo.defbranch=%s\n", repo->defbranch);
    800 	if (repo->module_link)
    801 		fprintf(f, "repo.module-link=%s\n", repo->module_link);
    802 	if (repo->section)
    803 		fprintf(f, "repo.section=%s\n", repo->section);
    804 	if (repo->homepage)
    805 		fprintf(f, "repo.homepage=%s\n", repo->homepage);
    806 	if (repo->clone_url)
    807 		fprintf(f, "repo.clone-url=%s\n", repo->clone_url);
    808 	fprintf(f, "repo.enable-commit-graph=%d\n",
    809 	        repo->enable_commit_graph);
    810 	fprintf(f, "repo.enable-log-filecount=%d\n",
    811 	        repo->enable_log_filecount);
    812 	fprintf(f, "repo.enable-log-linecount=%d\n",
    813 	        repo->enable_log_linecount);
    814 	if (repo->about_filter && repo->about_filter != ctx.cfg.about_filter)
    815 		cgit_fprintf_filter(repo->about_filter, f, "repo.about-filter=");
    816 	if (repo->commit_filter && repo->commit_filter != ctx.cfg.commit_filter)
    817 		cgit_fprintf_filter(repo->commit_filter, f, "repo.commit-filter=");
    818 	if (repo->source_filter && repo->source_filter != ctx.cfg.source_filter)
    819 		cgit_fprintf_filter(repo->source_filter, f, "repo.source-filter=");
    820 	if (repo->email_filter && repo->email_filter != ctx.cfg.email_filter)
    821 		cgit_fprintf_filter(repo->email_filter, f, "repo.email-filter=");
    822 	if (repo->owner_filter && repo->owner_filter != ctx.cfg.owner_filter)
    823 		cgit_fprintf_filter(repo->owner_filter, f, "repo.owner-filter=");
    824 	if (repo->snapshots != ctx.cfg.snapshots) {
    825 		char *tmp = build_snapshot_setting(repo->snapshots);
    826 		fprintf(f, "repo.snapshots=%s\n", tmp ? tmp : "");
    827 		free(tmp);
    828 	}
    829 	if (repo->max_stats != ctx.cfg.max_stats)
    830 		fprintf(f, "repo.max-stats=%s\n",
    831 		        cgit_find_stats_periodname(repo->max_stats));
    832 	if (repo->logo)
    833 		fprintf(f, "repo.logo=%s\n", repo->logo);
    834 	if (repo->logo_link)
    835 		fprintf(f, "repo.logo-link=%s\n", repo->logo_link);
    836 	fprintf(f, "repo.enable-remote-branches=%d\n", repo->enable_remote_branches);
    837 	fprintf(f, "repo.enable-subject-links=%d\n", repo->enable_subject_links);
    838 	fprintf(f, "repo.enable-html-serving=%d\n", repo->enable_html_serving);
    839 	if (repo->branch_sort == 1)
    840 		fprintf(f, "repo.branch-sort=age\n");
    841 	if (repo->commit_sort) {
    842 		if (repo->commit_sort == 1)
    843 			fprintf(f, "repo.commit-sort=date\n");
    844 		else if (repo->commit_sort == 2)
    845 			fprintf(f, "repo.commit-sort=topo\n");
    846 	}
    847 	fprintf(f, "repo.hide=%d\n", repo->hide);
    848 	fprintf(f, "repo.ignore=%d\n", repo->ignore);
    849 	fprintf(f, "\n");
    850 }
    851 
    852 static void print_repolist(FILE *f, struct cgit_repolist *list, int start)
    853 {
    854 	int i;
    855 
    856 	for (i = start; i < list->count; i++)
    857 		print_repo(f, &list->repos[i]);
    858 }
    859 
    860 /* Scan 'path' for git repositories, save the resulting repolist in 'cached_rc'
    861  * and return 0 on success.
    862  */
    863 static int generate_cached_repolist(const char *path, const char *cached_rc)
    864 {
    865 	struct strbuf locked_rc = STRBUF_INIT;
    866 	int result = 0;
    867 	int idx;
    868 	FILE *f;
    869 
    870 	strbuf_addf(&locked_rc, "%s.lock", cached_rc);
    871 	f = fopen(locked_rc.buf, "wx");
    872 	if (!f) {
    873 		/* Inform about the error unless the lockfile already existed,
    874 		 * since that only means we've got concurrent requests.
    875 		 */
    876 		result = errno;
    877 		if (result != EEXIST)
    878 			fprintf(stderr, "[cgit] Error opening %s: %s (%d)\n",
    879 				locked_rc.buf, strerror(result), result);
    880 		goto out;
    881 	}
    882 	idx = cgit_repolist.count;
    883 	if (ctx.cfg.project_list)
    884 		scan_projects(path, ctx.cfg.project_list, repo_config);
    885 	else
    886 		scan_tree(path, repo_config);
    887 	print_repolist(f, &cgit_repolist, idx);
    888 	if (rename(locked_rc.buf, cached_rc))
    889 		fprintf(stderr, "[cgit] Error renaming %s to %s: %s (%d)\n",
    890 			locked_rc.buf, cached_rc, strerror(errno), errno);
    891 	fclose(f);
    892 out:
    893 	strbuf_release(&locked_rc);
    894 	return result;
    895 }
    896 
    897 static void process_cached_repolist(const char *path)
    898 {
    899 	struct stat st;
    900 	struct strbuf cached_rc = STRBUF_INIT;
    901 	time_t age;
    902 	unsigned long hash;
    903 
    904 	hash = hash_str(path);
    905 	if (ctx.cfg.project_list)
    906 		hash += hash_str(ctx.cfg.project_list);
    907 	strbuf_addf(&cached_rc, "%s/rc-%8lx", ctx.cfg.cache_root, hash);
    908 
    909 	if (stat(cached_rc.buf, &st)) {
    910 		/* Nothing is cached, we need to scan without forking. And
    911 		 * if we fail to generate a cached repolist, we need to
    912 		 * invoke scan_tree manually.
    913 		 */
    914 		if (generate_cached_repolist(path, cached_rc.buf)) {
    915 			if (ctx.cfg.project_list)
    916 				scan_projects(path, ctx.cfg.project_list,
    917 					      repo_config);
    918 			else
    919 				scan_tree(path, repo_config);
    920 		}
    921 		goto out;
    922 	}
    923 
    924 	parse_configfile(cached_rc.buf, config_cb);
    925 
    926 	/* If the cached configfile hasn't expired, lets exit now */
    927 	age = time(NULL) - st.st_mtime;
    928 	if (age <= (ctx.cfg.cache_scanrc_ttl * 60))
    929 		goto out;
    930 
    931 	/* The cached repolist has been parsed, but it was old. So lets
    932 	 * rescan the specified path and generate a new cached repolist
    933 	 * in a child-process to avoid latency for the current request.
    934 	 */
    935 	if (fork())
    936 		goto out;
    937 
    938 	exit(generate_cached_repolist(path, cached_rc.buf));
    939 out:
    940 	strbuf_release(&cached_rc);
    941 }
    942 
    943 static void cgit_parse_args(int argc, const char **argv)
    944 {
    945 	int i;
    946 	const char *arg;
    947 	int scan = 0;
    948 
    949 	for (i = 1; i < argc; i++) {
    950 		if (!strcmp(argv[i], "--version")) {
    951 			printf("CGit %s | https://git.zx2c4.com/cgit/\n\nCompiled in features:\n", CGIT_VERSION);
    952 #ifdef NO_LUA
    953 			printf("[-] ");
    954 #else
    955 			printf("[+] ");
    956 #endif
    957 			printf("Lua scripting\n");
    958 #ifndef HAVE_LINUX_SENDFILE
    959 			printf("[-] ");
    960 #else
    961 			printf("[+] ");
    962 #endif
    963 			printf("Linux sendfile() usage\n");
    964 
    965 			exit(0);
    966 		}
    967 		if (skip_prefix(argv[i], "--cache=", &arg)) {
    968 			ctx.cfg.cache_root = xstrdup(arg);
    969 		} else if (!strcmp(argv[i], "--nohttp")) {
    970 			ctx.env.no_http = "1";
    971 		} else if (skip_prefix(argv[i], "--query=", &arg)) {
    972 			ctx.qry.raw = xstrdup(arg);
    973 		} else if (skip_prefix(argv[i], "--repo=", &arg)) {
    974 			ctx.qry.repo = xstrdup(arg);
    975 		} else if (skip_prefix(argv[i], "--page=", &arg)) {
    976 			ctx.qry.page = xstrdup(arg);
    977 		} else if (skip_prefix(argv[i], "--head=", &arg)) {
    978 			ctx.qry.head = xstrdup(arg);
    979 			ctx.qry.has_symref = 1;
    980 		} else if (skip_prefix(argv[i], "--sha1=", &arg)) {
    981 			ctx.qry.sha1 = xstrdup(arg);
    982 			ctx.qry.has_sha1 = 1;
    983 		} else if (skip_prefix(argv[i], "--ofs=", &arg)) {
    984 			ctx.qry.ofs = atoi(arg);
    985 		} else if (skip_prefix(argv[i], "--scan-tree=", &arg) ||
    986 		           skip_prefix(argv[i], "--scan-path=", &arg)) {
    987 			/*
    988 			 * HACK: The global snapshot bit mask defines the set
    989 			 * of allowed snapshot formats, but the config file
    990 			 * hasn't been parsed yet so the mask is currently 0.
    991 			 * By setting all bits high before scanning we make
    992 			 * sure that any in-repo cgitrc snapshot setting is
    993 			 * respected by scan_tree().
    994 			 *
    995 			 * NOTE: We assume that there aren't more than 8
    996 			 * different snapshot formats supported by cgit...
    997 			 */
    998 			ctx.cfg.snapshots = 0xFF;
    999 			scan++;
   1000 			scan_tree(arg, repo_config);
   1001 		}
   1002 	}
   1003 	if (scan) {
   1004 		qsort(cgit_repolist.repos, cgit_repolist.count,
   1005 			sizeof(struct cgit_repo), cmp_repos);
   1006 		print_repolist(stdout, &cgit_repolist, 0);
   1007 		exit(0);
   1008 	}
   1009 }
   1010 
   1011 static int calc_ttl(void)
   1012 {
   1013 	if (!ctx.repo)
   1014 		return ctx.cfg.cache_root_ttl;
   1015 
   1016 	if (!ctx.qry.page)
   1017 		return ctx.cfg.cache_repo_ttl;
   1018 
   1019 	if (!strcmp(ctx.qry.page, "about"))
   1020 		return ctx.cfg.cache_about_ttl;
   1021 
   1022 	if (!strcmp(ctx.qry.page, "snapshot"))
   1023 		return ctx.cfg.cache_snapshot_ttl;
   1024 
   1025 	if (ctx.qry.has_sha1)
   1026 		return ctx.cfg.cache_static_ttl;
   1027 
   1028 	if (ctx.qry.has_symref)
   1029 		return ctx.cfg.cache_dynamic_ttl;
   1030 
   1031 	return ctx.cfg.cache_repo_ttl;
   1032 }
   1033 
   1034 int cmd_main(int argc, const char **argv)
   1035 {
   1036 	const char *path;
   1037 	int err, ttl;
   1038 
   1039 	cgit_init_filters();
   1040 	atexit(cgit_cleanup_filters);
   1041 
   1042 	prepare_context();
   1043 	cgit_repolist.length = 0;
   1044 	cgit_repolist.count = 0;
   1045 	cgit_repolist.repos = NULL;
   1046 
   1047 	cgit_parse_args(argc, argv);
   1048 	parse_configfile(expand_macros(ctx.env.cgit_config), config_cb);
   1049 	ctx.repo = NULL;
   1050 	http_parse_querystring(ctx.qry.raw, querystring_cb);
   1051 
   1052 	/* If virtual-root isn't specified in cgitrc, lets pretend
   1053 	 * that virtual-root equals SCRIPT_NAME, minus any possibly
   1054 	 * trailing slashes.
   1055 	 */
   1056 	if (!ctx.cfg.virtual_root && ctx.cfg.script_name)
   1057 		ctx.cfg.virtual_root = ensure_end(ctx.cfg.script_name, '/');
   1058 
   1059 	/* If no url parameter is specified on the querystring, lets
   1060 	 * use PATH_INFO as url. This allows cgit to work with virtual
   1061 	 * urls without the need for rewriterules in the webserver (as
   1062 	 * long as PATH_INFO is included in the cache lookup key).
   1063 	 */
   1064 	path = ctx.env.path_info;
   1065 	if (!ctx.qry.url && path) {
   1066 		if (path[0] == '/')
   1067 			path++;
   1068 		ctx.qry.url = xstrdup(path);
   1069 		if (ctx.qry.raw) {
   1070 			char *newqry = fmtalloc("%s?%s", path, ctx.qry.raw);
   1071 			free(ctx.qry.raw);
   1072 			ctx.qry.raw = newqry;
   1073 		} else
   1074 			ctx.qry.raw = xstrdup(ctx.qry.url);
   1075 		cgit_parse_url(ctx.qry.url);
   1076 	}
   1077 
   1078 	/* Before we go any further, we set ctx.env.authenticated by checking to see
   1079 	 * if the supplied cookie is valid. All cookies are valid if there is no
   1080 	 * auth_filter. If there is an auth_filter, the filter decides. */
   1081 	authenticate_cookie();
   1082 
   1083 	ttl = calc_ttl();
   1084 	if (ttl < 0)
   1085 		ctx.page.expires += 10 * 365 * 24 * 60 * 60; /* 10 years */
   1086 	else
   1087 		ctx.page.expires += ttl * 60;
   1088 	if (!ctx.env.authenticated || (ctx.env.request_method && !strcmp(ctx.env.request_method, "HEAD")))
   1089 		ctx.cfg.cache_size = 0;
   1090 	err = cache_process(ctx.cfg.cache_size, ctx.cfg.cache_root,
   1091 			    ctx.qry.raw, ttl, process_request);
   1092 	cgit_cleanup_filters();
   1093 	if (err)
   1094 		cgit_print_error("Error processing page: %s (%d)",
   1095 				 strerror(err), err);
   1096 	return err;
   1097 }