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