| /* ui-shared.c: common web output functions | |
| * | |
| * Copyright (C) 2006-2017 cgit Development Team <cgit@lists.zx2c4.com> | |
| * | |
| * Licensed under GNU General Public License v2 | |
| * (see COPYING for full license text) | |
| */ | |
| #define USE_THE_REPOSITORY_VARIABLE | |
| #include "cgit.h" | |
| #include "ui-shared.h" | |
| #include "cmd.h" | |
| #include "html.h" | |
| #include "url.h" | |
| #include "version.h" | |
| static const char cgit_doctype[] = | |
| "<!DOCTYPE html>\n"; | |
| static char *http_date(time_t t) | |
| { | |
| static char day[][4] = | |
| {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; | |
| static char month[][4] = | |
| {"Jan", "Feb", "Mar", "Apr", "May", "Jun", | |
| "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; | |
| struct tm tm; | |
| gmtime_r(&t, &tm); | |
| return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm.tm_wday], | |
| tm.tm_mday, month[tm.tm_mon], 1900 + tm.tm_year, | |
| tm.tm_hour, tm.tm_min, tm.tm_sec); | |
| } | |
| void cgit_print_error(const char *fmt, ...) | |
| { | |
| va_list ap; | |
| va_start(ap, fmt); | |
| cgit_vprint_error(fmt, ap); | |
| va_end(ap); | |
| } | |
| void cgit_vprint_error(const char *fmt, va_list ap) | |
| { | |
| va_list cp; | |
| html("<div class='error'>"); | |
| va_copy(cp, ap); | |
| html_vtxtf(fmt, cp); | |
| va_end(cp); | |
| html("</div>\n"); | |
| } | |
| const char *cgit_httpscheme(void) | |
| { | |
| if (ctx.env.https && !strcmp(ctx.env.https, "on")) | |
| return "https://"; | |
| else | |
| return "http://"; | |
| } | |
| char *cgit_hosturl(void) | |
| { | |
| if (ctx.env.http_host) | |
| return xstrdup(ctx.env.http_host); | |
| if (!ctx.env.server_name) | |
| return NULL; | |
| if (!ctx.env.server_port || atoi(ctx.env.server_port) == 80) | |
| return xstrdup(ctx.env.server_name); | |
| return fmtalloc("%s:%s", ctx.env.server_name, ctx.env.server_port); | |
| } | |
| char *cgit_currenturl(void) | |
| { | |
| const char *root = cgit_rooturl(); | |
| if (!ctx.qry.url) | |
| return xstrdup(root); | |
| if (root[0] && root[strlen(root) - 1] == '/') | |
| return fmtalloc("%s%s", root, ctx.qry.url); | |
| return fmtalloc("%s/%s", root, ctx.qry.url); | |
| } | |
| char *cgit_currentfullurl(void) | |
| { | |
| const char *root = cgit_rooturl(); | |
| const char *orig_query = ctx.env.query_string ? ctx.env.query_string : ""; | |
| size_t len = strlen(orig_query); | |
| char *query = xmalloc(len + 2), *start_url, *ret; | |
| /* Remove all url=... parts from query string */ | |
| memcpy(query + 1, orig_query, len + 1); | |
| query[0] = '?'; | |
| start_url = query; | |
| while ((start_url = strstr(start_url, "url=")) != NULL) { | |
| if (start_url[-1] == '?' || start_url[-1] == '&') { | |
| const char *end_url = strchr(start_url, '&'); | |
| if (end_url) | |
| memmove(start_url, end_url + 1, strlen(end_url)); | |
| else | |
| start_url[0] = '\0'; | |
| } else | |
| ++start_url; | |
| } | |
| if (!query[1]) | |
| query[0] = '\0'; | |
| if (!ctx.qry.url) | |
| ret = fmtalloc("%s%s", root, query); | |
| else if (root[0] && root[strlen(root) - 1] == '/') | |
| ret = fmtalloc("%s%s%s", root, ctx.qry.url, query); | |
| else | |
| ret = fmtalloc("%s/%s%s", root, ctx.qry.url, query); | |
| free(query); | |
| return ret; | |
| } | |
| const char *cgit_rooturl(void) | |
| { | |
| if (ctx.cfg.virtual_root) | |
| return ctx.cfg.virtual_root; | |
| else | |
| return ctx.cfg.script_name; | |
| } | |
| const char *cgit_loginurl(void) | |
| { | |
| static const char *login_url; | |
| if (!login_url) | |
| login_url = fmtalloc("%s?p=login", cgit_rooturl()); | |
| return login_url; | |
| } | |
| char *cgit_repourl(const char *reponame) | |
| { | |
| if (ctx.cfg.virtual_root) | |
| return fmtalloc("%s%s/", ctx.cfg.virtual_root, reponame); | |
| else | |
| return fmtalloc("?r=%s", reponame); | |
| } | |
| char *cgit_fileurl(const char *reponame, const char *pagename, | |
| const char *filename, const char *query) | |
| { | |
| struct strbuf sb = STRBUF_INIT; | |
| char *delim; | |
| if (ctx.cfg.virtual_root) { | |
| strbuf_addf(&sb, "%s%s/%s/%s", ctx.cfg.virtual_root, reponame, | |
| pagename, (filename ? filename:"")); | |
| delim = "?"; | |
| } else { | |
| strbuf_addf(&sb, "?url=%s/%s/%s", reponame, pagename, | |
| (filename ? filename : "")); | |
| delim = "&"; | |
| } | |
| if (query) | |
| strbuf_addf(&sb, "%s%s", delim, query); | |
| return strbuf_detach(&sb, NULL); | |
| } | |
| char *cgit_pageurl(const char *reponame, const char *pagename, | |
| const char *query) | |
| { | |
| return cgit_fileurl(reponame, pagename, NULL, query); | |
| } | |
| const char *cgit_repobasename(const char *reponame) | |
| { | |
| /* I assume we don't need to store more than one repo basename */ | |
| static char rvbuf[1024]; | |
| int p; | |
| const char *rv; | |
| size_t len; | |
| len = strlcpy(rvbuf, reponame, sizeof(rvbuf)); | |
| if (len >= sizeof(rvbuf)) | |
| die("cgit_repobasename: truncated repository name '%s'", reponame); | |
| p = len - 1; | |
| /* strip trailing slashes */ | |
| while (p && rvbuf[p] == '/') | |
| rvbuf[p--] = '\0'; | |
| /* strip trailing .git */ | |
| if (p >= 3 && starts_with(&rvbuf[p-3], ".git")) { | |
| p -= 3; | |
| rvbuf[p--] = '\0'; | |
| } | |
| /* strip more trailing slashes if any */ | |
| while (p && rvbuf[p] == '/') | |
| rvbuf[p--] = '\0'; | |
| /* find last slash in the remaining string */ | |
| rv = strrchr(rvbuf, '/'); | |
| if (rv) | |
| return ++rv; | |
| return rvbuf; | |
| } | |
| const char *cgit_snapshot_prefix(const struct cgit_repo *repo) | |
| { | |
| if (repo->snapshot_prefix) | |
| return repo->snapshot_prefix; | |
| return cgit_repobasename(repo->url); | |
| } | |
| static void site_url(const char *page, const char *search, const char *sort, int ofs, int always_root) | |
| { | |
| char *delim = "?"; | |
| if (always_root || page) | |
| html_attr(cgit_rooturl()); | |
| else { | |
| char *currenturl = cgit_currenturl(); | |
| html_attr(currenturl); | |
| free(currenturl); | |
| } | |
| if (page) { | |
| htmlf("?p=%s", page); | |
| delim = "&"; | |
| } | |
| if (search) { | |
| html(delim); | |
| html("q="); | |
| html_attr(search); | |
| delim = "&"; | |
| } | |
| if (sort) { | |
| html(delim); | |
| html("s="); | |
| html_attr(sort); | |
| delim = "&"; | |
| } | |
| if (ofs) { | |
| html(delim); | |
| htmlf("ofs=%d", ofs); | |
| } | |
| } | |
| static void site_link(const char *page, const char *name, const char *title, | |
| const char *class, const char *search, const char *sort, int ofs, int always_root) | |
| { | |
| html("<a"); | |
| if (title) { | |
| html(" title='"); | |
| html_attr(title); | |
| html("'"); | |
| } | |
| if (class) { | |
| html(" class='"); | |
| html_attr(class); | |
| html("'"); | |
| } | |
| html(" href='"); | |
| site_url(page, search, sort, ofs, always_root); | |
| html("'>"); | |
| html_txt(name); | |
| html("</a>"); | |
| } | |
| void cgit_index_link(const char *name, const char *title, const char *class, | |
| const char *pattern, const char *sort, int ofs, int always_root) | |
| { | |
| site_link(NULL, name, title, class, pattern, sort, ofs, always_root); | |
| } | |
| static char *repolink(const char *title, const char *class, const char *page, | |
| const char *head, const char *path) | |
| { | |
| char *delim = "?"; | |
| html("<a"); | |
| if (title) { | |
| html(" title='"); | |
| html_attr(title); | |
| html("'"); | |
| } | |
| if (class) { | |
| html(" class='"); | |
| html_attr(class); | |
| html("'"); | |
| } | |
| html(" href='"); | |
| if (ctx.cfg.virtual_root) { | |
| html_url_path(ctx.cfg.virtual_root); | |
| html_url_path(ctx.repo->url); | |
| if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/') | |
| html("/"); | |
| if (page) { | |
| html_url_path(page); | |
| html("/"); | |
| if (path) | |
| html_url_path(path); | |
| } | |
| } else { | |
| html_url_path(ctx.cfg.script_name); | |
| html("?url="); | |
| html_url_arg(ctx.repo->url); | |
| if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/') | |
| html("/"); | |
| if (page) { | |
| html_url_arg(page); | |
| html("/"); | |
| if (path) | |
| html_url_arg(path); | |
| } | |
| delim = "&"; | |
| } | |
| if (head && ctx.repo->defbranch && strcmp(head, ctx.repo->defbranch)) { | |
| html(delim); | |
| html("h="); | |
| html_url_arg(head); | |
| delim = "&"; | |
| } | |
| return fmt("%s", delim); | |
| } | |
| static void reporevlink(const char *page, const char *name, const char *title, | |
| const char *class, const char *head, const char *rev, | |
| const char *path) | |
| { | |
| char *delim; | |
| delim = repolink(title, class, page, head, path); | |
| if (rev && ctx.qry.head != NULL && strcmp(rev, ctx.qry.head)) { | |
| html(delim); | |
| html("id="); | |
| html_url_arg(rev); | |
| } | |
| html("'>"); | |
| html_txt(name); | |
| html("</a>"); | |
| } | |
| void cgit_summary_link(const char *name, const char *title, const char *class, | |
| const char *head) | |
| { | |
| reporevlink(NULL, name, title, class, head, NULL, NULL); | |
| } | |
| void cgit_tag_link(const char *name, const char *title, const char *class, | |
| const char *tag) | |
| { | |
| reporevlink("tag", name, title, class, tag, NULL, NULL); | |
| } | |
| void cgit_tree_link(const char *name, const char *title, const char *class, | |
| const char *head, const char *rev, const char *path) | |
| { | |
| reporevlink("tree", name, title, class, head, rev, path); | |
| } | |
| void cgit_plain_link(const char *name, const char *title, const char *class, | |
| const char *head, const char *rev, const char *path) | |
| { | |
| reporevlink("plain", name, title, class, head, rev, path); | |
| } | |
| void cgit_blame_link(const char *name, const char *title, const char *class, | |
| const char *head, const char *rev, const char *path) | |
| { | |
| reporevlink("blame", name, title, class, head, rev, path); | |
| } | |
| void cgit_log_link(const char *name, const char *title, const char *class, | |
| const char *head, const char *rev, const char *path, | |
| int ofs, const char *grep, const char *pattern, int showmsg, | |
| int follow) | |
| { | |
| char *delim; | |
| delim = repolink(title, class, "log", head, path); | |
| if (rev && ctx.qry.head && strcmp(rev, ctx.qry.head)) { | |
| html(delim); | |
| html("id="); | |
| html_url_arg(rev); | |
| delim = "&"; | |
| } | |
| if (grep && pattern) { | |
| html(delim); | |
| html("qt="); | |
| html_url_arg(grep); | |
| delim = "&"; | |
| html(delim); | |
| html("q="); | |
| html_url_arg(pattern); | |
| } | |
| if (ofs > 0) { | |
| html(delim); | |
| html("ofs="); | |
| htmlf("%d", ofs); | |
| delim = "&"; | |
| } | |
| if (showmsg) { | |
| html(delim); | |
| html("showmsg=1"); | |
| delim = "&"; | |
| } | |
| if (follow) { | |
| html(delim); | |
| html("follow=1"); | |
| } | |
| html("'>"); | |
| html_txt(name); | |
| html("</a>"); | |
| } | |
| void cgit_commit_link(const char *name, const char *title, const char *class, | |
| const char *head, const char *rev, const char *path) | |
| { | |
| char *delim; | |
| delim = repolink(title, class, "commit", head, path); | |
| if (rev && ctx.qry.head && strcmp(rev, ctx.qry.head)) { | |
| html(delim); | |
| html("id="); | |
| html_url_arg(rev); | |
| delim = "&"; | |
| } | |
| if (ctx.qry.difftype) { | |
| html(delim); | |
| htmlf("dt=%d", ctx.qry.difftype); | |
| delim = "&"; | |
| } | |
| if (ctx.qry.context > 0 && ctx.qry.context != 3) { | |
| html(delim); | |
| html("context="); | |
| htmlf("%d", ctx.qry.context); | |
| delim = "&"; | |
| } | |
| if (ctx.qry.ignorews) { | |
| html(delim); | |
| html("ignorews=1"); | |
| delim = "&"; | |
| } | |
| if (ctx.qry.follow) { | |
| html(delim); | |
| html("follow=1"); | |
| } | |
| html("'>"); | |
| if (name[0] != '\0') { | |
| if (strlen(name) > ctx.cfg.max_msg_len && ctx.cfg.max_msg_len >= 15) { | |
| html_ntxt(name, ctx.cfg.max_msg_len - 3); | |
| html("..."); | |
| } else | |
| html_txt(name); | |
| } else | |
| html_txt("(no commit message)"); | |
| html("</a>"); | |
| } | |
| void cgit_refs_link(const char *name, const char *title, const char *class, | |
| const char *head, const char *rev, const char *path) | |
| { | |
| reporevlink("refs", name, title, class, head, rev, path); | |
| } | |
| void cgit_snapshot_link(const char *name, const char *title, const char *class, | |
| const char *head, const char *rev, | |
| const char *archivename) | |
| { | |
| reporevlink("snapshot", name, title, class, head, rev, archivename); | |
| } | |
| void cgit_diff_link(const char *name, const char *title, const char *class, | |
| const char *head, const char *new_rev, const char *old_rev, | |
| const char *path) | |
| { | |
| char *delim; | |
| delim = repolink(title, class, "diff", head, path); | |
| if (new_rev && ctx.qry.head != NULL && strcmp(new_rev, ctx.qry.head)) { | |
| html(delim); | |
| html("id="); | |
| html_url_arg(new_rev); | |
| delim = "&"; | |
| } | |
| if (old_rev) { | |
| html(delim); | |
| html("id2="); | |
| html_url_arg(old_rev); | |
| delim = "&"; | |
| } | |
| if (ctx.qry.difftype) { | |
| html(delim); | |
| htmlf("dt=%d", ctx.qry.difftype); | |
| delim = "&"; | |
| } | |
| if (ctx.qry.context > 0 && ctx.qry.context != 3) { | |
| html(delim); | |
| html("context="); | |
| htmlf("%d", ctx.qry.context); | |
| delim = "&"; | |
| } | |
| if (ctx.qry.ignorews) { | |
| html(delim); | |
| html("ignorews=1"); | |
| delim = "&"; | |
| } | |
| if (ctx.qry.follow) { | |
| html(delim); | |
| html("follow=1"); | |
| } | |
| html("'>"); | |
| html_txt(name); | |
| html("</a>"); | |
| } | |
| void cgit_patch_link(const char *name, const char *title, const char *class, | |
| const char *head, const char *rev, const char *path) | |
| { | |
| reporevlink("patch", name, title, class, head, rev, path); | |
| } | |
| void cgit_stats_link(const char *name, const char *title, const char *class, | |
| const char *head, const char *path) | |
| { | |
| reporevlink("stats", name, title, class, head, NULL, path); | |
| } | |
| static void cgit_self_link(char *name, const char *title, const char *class) | |
| { | |
| if (!strcmp(ctx.qry.page, "repolist")) | |
| cgit_index_link(name, title, class, ctx.qry.search, ctx.qry.sort, | |
| ctx.qry.ofs, 1); | |
| else if (!strcmp(ctx.qry.page, "summary")) | |
| cgit_summary_link(name, title, class, ctx.qry.head); | |
| else if (!strcmp(ctx.qry.page, "tag")) | |
| cgit_tag_link(name, title, class, ctx.qry.has_oid ? | |
| ctx.qry.oid : ctx.qry.head); | |
| else if (!strcmp(ctx.qry.page, "tree")) | |
| cgit_tree_link(name, title, class, ctx.qry.head, | |
| ctx.qry.has_oid ? ctx.qry.oid : NULL, | |
| ctx.qry.path); | |
| else if (!strcmp(ctx.qry.page, "plain")) | |
| cgit_plain_link(name, title, class, ctx.qry.head, | |
| ctx.qry.has_oid ? ctx.qry.oid : NULL, | |
| ctx.qry.path); | |
| else if (!strcmp(ctx.qry.page, "blame")) | |
| cgit_blame_link(name, title, class, ctx.qry.head, | |
| ctx.qry.has_oid ? ctx.qry.oid : NULL, | |
| ctx.qry.path); | |
| else if (!strcmp(ctx.qry.page, "log")) | |
| cgit_log_link(name, title, class, ctx.qry.head, | |
| ctx.qry.has_oid ? ctx.qry.oid : NULL, | |
| ctx.qry.path, ctx.qry.ofs, | |
| ctx.qry.grep, ctx.qry.search, | |
| ctx.qry.showmsg, ctx.qry.follow); | |
| else if (!strcmp(ctx.qry.page, "commit")) | |
| cgit_commit_link(name, title, class, ctx.qry.head, | |
| ctx.qry.has_oid ? ctx.qry.oid : NULL, | |
| ctx.qry.path); | |
| else if (!strcmp(ctx.qry.page, "patch")) | |
| cgit_patch_link(name, title, class, ctx.qry.head, | |
| ctx.qry.has_oid ? ctx.qry.oid : NULL, | |
| ctx.qry.path); | |
| else if (!strcmp(ctx.qry.page, "refs")) | |
| cgit_refs_link(name, title, class, ctx.qry.head, | |
| ctx.qry.has_oid ? ctx.qry.oid : NULL, | |
| ctx.qry.path); | |
| else if (!strcmp(ctx.qry.page, "snapshot")) | |
| cgit_snapshot_link(name, title, class, ctx.qry.head, | |
| ctx.qry.has_oid ? ctx.qry.oid : NULL, | |
| ctx.qry.path); | |
| else if (!strcmp(ctx.qry.page, "diff")) | |
| cgit_diff_link(name, title, class, ctx.qry.head, | |
| ctx.qry.oid, ctx.qry.oid2, | |
| ctx.qry.path); | |
| else if (!strcmp(ctx.qry.page, "stats")) | |
| cgit_stats_link(name, title, class, ctx.qry.head, | |
| ctx.qry.path); | |
| else { | |
| /* Don't known how to make link for this page */ | |
| repolink(title, class, ctx.qry.page, ctx.qry.head, ctx.qry.path); | |
| html("><!-- cgit_self_link() doesn't know how to make link for page '"); | |
| html_txt(ctx.qry.page); | |
| html("' -->"); | |
| html_txt(name); | |
| html("</a>"); | |
| } | |
| } | |
| void cgit_object_link(struct object *obj) | |
| { | |
| char *page, *shortrev, *fullrev, *name; | |
| fullrev = oid_to_hex(&obj->oid); | |
| shortrev = xstrdup(fullrev); | |
| shortrev[10] = '\0'; | |
| if (obj->type == OBJ_COMMIT) { | |
| cgit_commit_link(fmt("commit %s...", shortrev), NULL, NULL, | |
| ctx.qry.head, fullrev, NULL); | |
| return; | |
| } else if (obj->type == OBJ_TREE) | |
| page = "tree"; | |
| else if (obj->type == OBJ_TAG) | |
| page = "tag"; | |
| else | |
| page = "blob"; | |
| name = fmt("%s %s...", type_name(obj->type), shortrev); | |
| reporevlink(page, name, NULL, NULL, ctx.qry.head, fullrev, NULL); | |
| } | |
| static struct string_list_item *lookup_path(struct string_list *list, | |
| const char *path) | |
| { | |
| struct string_list_item *item; | |
| while (path && path[0]) { | |
| if ((item = string_list_lookup(list, path))) | |
| return item; | |
| if (!(path = strchr(path, '/'))) | |
| break; | |
| path++; | |
| } | |
| return NULL; | |
| } | |
| void cgit_submodule_link(const char *class, char *path, const char *rev) | |
| { | |
| struct string_list *list; | |
| struct string_list_item *item; | |
| char tail, *dir; | |
| size_t len; | |
| len = 0; | |
| tail = 0; | |
| list = &ctx.repo->submodules; | |
| item = lookup_path(list, path); | |
| if (!item) { | |
| len = strlen(path); | |
| tail = path[len - 1]; | |
| if (tail == '/') { | |
| path[len - 1] = 0; | |
| item = lookup_path(list, path); | |
| } | |
| } | |
| if (item || ctx.repo->module_link) { | |
| html("<a "); | |
| if (class) | |
| htmlf("class='%s' ", class); | |
| html("href='"); | |
| if (item) { | |
| html_attrf(item->util, rev); | |
| } else { | |
| dir = strrchr(path, '/'); | |
| if (dir) | |
| dir++; | |
| else | |
| dir = path; | |
| html_attrf(ctx.repo->module_link, dir, rev); | |
| } | |
| html("'>"); | |
| html_txt(path); | |
| html("</a>"); | |
| } else { | |
| html("<span"); | |
| if (class) | |
| htmlf(" class='%s'", class); | |
| html(">"); | |
| html_txt(path); | |
| html("</span>"); | |
| } | |
| html_txtf(" @ %.7s", rev); | |
| if (item && tail) | |
| path[len - 1] = tail; | |
| } | |
| const struct date_mode cgit_date_mode(enum date_mode_type type) | |
| { | |
| static struct date_mode mode; | |
| mode.type = type; | |
| mode.local = ctx.cfg.local_time; | |
| return mode; | |
| } | |
| static void print_rel_date(time_t t, int tz, double value, | |
| const char *class, const char *suffix) | |
| { | |
| htmlf("<span class='%s' data-ut='%" PRIu64 "' title='", class, (uint64_t)t); | |
| html_attr(show_date(t, tz, cgit_date_mode(DATE_ISO8601))); | |
| htmlf("'>%.0f %s</span>", value, suffix); | |
| } | |
| void cgit_print_age(time_t t, int tz, time_t max_relative) | |
| { | |
| time_t now, secs; | |
| if (!t) | |
| return; | |
| time(&now); | |
| secs = now - t; | |
| if (secs < 0) | |
| secs = 0; | |
| if (secs > max_relative && max_relative >= 0) { | |
| html("<span title='"); | |
| html_attr(show_date(t, tz, cgit_date_mode(DATE_ISO8601))); | |
| html("'>"); | |
| html_txt(show_date(t, tz, cgit_date_mode(DATE_SHORT))); | |
| html("</span>"); | |
| return; | |
| } | |
| if (secs < TM_HOUR * 2) { | |
| print_rel_date(t, tz, secs * 1.0 / TM_MIN, "age-mins", "min."); | |
| return; | |
| } | |
| if (secs < TM_DAY * 2) { | |
| print_rel_date(t, tz, secs * 1.0 / TM_HOUR, "age-hours", "hours"); | |
| return; | |
| } | |
| if (secs < TM_WEEK * 2) { | |
| print_rel_date(t, tz, secs * 1.0 / TM_DAY, "age-days", "days"); | |
| return; | |
| } | |
| if (secs < TM_MONTH * 2) { | |
| print_rel_date(t, tz, secs * 1.0 / TM_WEEK, "age-weeks", "weeks"); | |
| return; | |
| } | |
| if (secs < TM_YEAR * 2) { | |
| print_rel_date(t, tz, secs * 1.0 / TM_MONTH, "age-months", "months"); | |
| return; | |
| } | |
| print_rel_date(t, tz, secs * 1.0 / TM_YEAR, "age-years", "years"); | |
| } | |
| void cgit_print_http_headers(void) | |
| { | |
| if (ctx.env.no_http && !strcmp(ctx.env.no_http, "1")) | |
| return; | |
| if (ctx.page.status) | |
| htmlf("Status: %d %s\n", ctx.page.status, ctx.page.statusmsg); | |
| if (ctx.page.mimetype && ctx.page.charset) | |
| htmlf("Content-Type: %s; charset=%s\n", ctx.page.mimetype, | |
| ctx.page.charset); | |
| else if (ctx.page.mimetype) | |
| htmlf("Content-Type: %s\n", ctx.page.mimetype); | |
| if (ctx.page.size) | |
| htmlf("Content-Length: %zd\n", ctx.page.size); | |
| if (ctx.page.filename) { | |
| html("Content-Disposition: inline; filename=\""); | |
| html_header_arg_in_quotes(ctx.page.filename); | |
| html("\"\n"); | |
| } | |
| if (!ctx.env.authenticated) | |
| html("Cache-Control: no-cache, no-store\n"); | |
| htmlf("Last-Modified: %s\n", http_date(ctx.page.modified)); | |
| htmlf("Expires: %s\n", http_date(ctx.page.expires)); | |
| if (ctx.page.etag) | |
| htmlf("ETag: \"%s\"\n", ctx.page.etag); | |
| html("\n"); | |
| if (ctx.env.request_method && !strcmp(ctx.env.request_method, "HEAD")) | |
| exit(0); | |
| } | |
| /* Emit a query string into a response header. The query is already | |
| * URL-encoded, so its reserved characters ('?', '&', '=', '%') and any | |
| * high-bit bytes have to pass through untouched; only control bytes -- CR | |
| * and LF above all -- are percent-encoded. A raw CR/LF reaching us in the | |
| * query string would otherwise terminate the Location header early and let | |
| * the request splice headers of its own onto the response. | |
| */ | |
| static void emit_header_query(const char *query) | |
| { | |
| const char *p; | |
| for (p = query; *p; p++) { | |
| unsigned char c = *p; | |
| if (c < 0x20 || c == 0x7f) | |
| htmlf("%%%02X", c); | |
| else | |
| html_raw(p, 1); | |
| } | |
| } | |
| static void redirect(const char *path, const char *query, bool permanent) | |
| { | |
| htmlf("Status: %d %s\n", permanent ? 301 : 302, permanent ? "Moved" : "Found"); | |
| html("Location: "); | |
| html_url_path(path); | |
| if (query && *query) { | |
| html("?"); | |
| emit_header_query(query); | |
| } | |
| html("\n\n"); | |
| } | |
| void cgit_redirect(const char *url, bool permanent) | |
| { | |
| redirect(url, NULL, permanent); | |
| } | |
| /* Redirect to 'path' with 'query' appended. The path is escaped as a URL | |
| * path, which would mangle a query string; the query is emitted as given, | |
| * because its only source is the query string of the request being answered. | |
| */ | |
| void cgit_redirect_query(const char *path, const char *query, bool permanent) | |
| { | |
| redirect(path, query, permanent); | |
| } | |
| /* Copy the query string, dropping any parameter whose name matches an | |
| * entry in the NULL-terminated drop list. | |
| */ | |
| static void copy_query_without(struct strbuf *sb, const char * const *drop) | |
| { | |
| const char *q = ctx.env.query_string; | |
| while (q && *q) { | |
| const char *end = strchrnul(q, '&'); | |
| size_t len = end - q; | |
| const char *namep = q; | |
| char *decoded = url_decode_parameter_name(&namep); | |
| const char * const *name; | |
| for (name = drop; *name; name++) | |
| if (!strcmp(decoded, *name)) | |
| break; | |
| free(decoded); | |
| if (!*name) { | |
| if (sb->len) | |
| strbuf_addch(sb, '&'); | |
| strbuf_add(sb, q, len); | |
| } | |
| q = *end ? end + 1 : end; | |
| } | |
| } | |
| /* Copy the query string, substituting a new value for h= and dropping | |
| * url= entirely (the caller reconstructs the path from ctx.qry.url). | |
| */ | |
| static void copy_query_replacing_head(struct strbuf *sb, const char *newhead) | |
| { | |
| const char *q = ctx.env.query_string; | |
| while (q && *q) { | |
| const char *end = strchrnul(q, '&'); | |
| size_t len = end - q; | |
| const char *namep = q; | |
| char *decoded = url_decode_parameter_name(&namep); | |
| int is_url = !strcmp(decoded, "url"); | |
| int is_head = !strcmp(decoded, "h"); | |
| free(decoded); | |
| if (is_url) { | |
| q = *end ? end + 1 : end; | |
| continue; | |
| } | |
| if (sb->len) | |
| strbuf_addch(sb, '&'); | |
| if (is_head) { | |
| strbuf_addstr(sb, "h="); | |
| strbuf_add_percentencode(sb, newhead, 0); | |
| } else { | |
| strbuf_add(sb, q, len); | |
| } | |
| q = *end ? end + 1 : end; | |
| } | |
| } | |
| /* Copy the query string, substituting a new value for id= and/or id2=. | |
| * Either substitution may be NULL, meaning that parameter is copied through | |
| * unchanged. url= is dropped entirely, since the caller reconstructs the | |
| * path from ctx.qry.url. | |
| */ | |
| static void copy_query_replacing_ids(struct strbuf *sb, const char *newid, const char *newid2) | |
| { | |
| const char *q = ctx.env.query_string; | |
| while (q && *q) { | |
| const char *end = strchrnul(q, '&'); | |
| size_t len = end - q; | |
| const char *namep = q; | |
| char *decoded = url_decode_parameter_name(&namep); | |
| int is_url = !strcmp(decoded, "url"); | |
| int is_id = !strcmp(decoded, "id"); | |
| int is_id2 = !strcmp(decoded, "id2"); | |
| free(decoded); | |
| if (is_url) { | |
| q = *end ? end + 1 : end; | |
| continue; | |
| } | |
| if (sb->len) | |
| strbuf_addch(sb, '&'); | |
| if (newid && is_id) { | |
| strbuf_addstr(sb, "id="); | |
| strbuf_add_percentencode(sb, newid, 0); | |
| } else if (newid2 && is_id2) { | |
| strbuf_addstr(sb, "id2="); | |
| strbuf_add_percentencode(sb, newid2, 0); | |
| } else { | |
| strbuf_add(sb, q, len); | |
| } | |
| q = *end ? end + 1 : end; | |
| } | |
| } | |
| /* Drop h= from the current request and send the visitor to what remains. */ | |
| static void redirect_dropping_head(void) | |
| { | |
| struct strbuf query = STRBUF_INIT; | |
| static const char * const drop[] = { "h", "url", NULL }; | |
| char *path; | |
| copy_query_without(&query, drop); | |
| path = cgit_currenturl(); | |
| cgit_redirect_query(path, query.buf, true); | |
| free(path); | |
| strbuf_release(&query); | |
| } | |
| /* Whether 'oid' is an ancestor of the reference 'refname', as a tri-state: 1 | |
| * yes, 0 no, -1 the question could not be answered. That last case covers a | |
| * reference that does not resolve, an object that is not commit-ish, and an | |
| * error out of the traversal, and every caller below treats it as a reason to | |
| * leave the request alone rather than act on a guess. | |
| * | |
| * Like cgit_oid_is_reachable(), this walks history, and is only affordable | |
| * where the repository has a commit-graph to bound the walk. | |
| */ | |
| static int oid_is_on_branch(const struct object_id *oid, const char *refname) | |
| { | |
| struct object_id tip_oid; | |
| struct commit *commit, *tip; | |
| int ret; | |
| if (repo_get_oid(the_repository, refname, &tip_oid)) | |
| return -1; | |
| commit = lookup_commit_reference_gently(the_repository, oid, 1); | |
| tip = lookup_commit_reference_gently(the_repository, &tip_oid, 1); | |
| if (!commit || !tip) | |
| return -1; | |
| ret = repo_in_merge_bases_many(the_repository, commit, 1, &tip, 1); | |
| return ret < 0 ? -1 : !!ret; | |
| } | |
| /* Reconcile h= with id= on a request that carries both. | |
| * | |
| * h= is cgit's branch selector, not a second way of saying what to display: it | |
| * decides where the navigation links and the branch switcher point, and it | |
| * survives from page to page. So a request that pins its content with id= and | |
| * still names a branch is not saying the same thing twice -- it is saying | |
| * "this commit, reached from that branch" -- and dropping h= would quietly | |
| * return the visitor to the default branch. | |
| * | |
| * What is worth collapsing is a branch that adds nothing. A commit reached by | |
| * walking one branch's log is usually on the default branch too, and then | |
| * every branch containing it spells the same page a different way. So: | |
| * | |
| * - a commit on the default branch is served from a single URL, h= dropped; | |
| * - a commit only on the named branch keeps h=, since the branch is the one | |
| * thing recording where the visitor is; | |
| * - a commit on neither is refused, as an object outside the repository is. | |
| * | |
| * That leaves one URL for the overwhelming majority of history and at most one | |
| * more for the rest, in place of one per branch a commit happens to be on. | |
| * | |
| * A two-revision diff is exempt from the refusal: comparing commits across | |
| * branches is a legitimate thing to ask for. Both revisions still go through | |
| * the reachability check that follows. | |
| * | |
| * Returns 1 when a response has been sent. | |
| */ | |
| enum cgit_reconcile_result cgit_reconcile_head_and_oid(void) | |
| { | |
| struct object_id oid; | |
| int on_default, on_head; | |
| if (!ctx.repo || !ctx.qry.head || ctx.qry.nohead) | |
| return CGIT_RECONCILE_CONTINUE; | |
| /* h= naming the default branch adds nothing to any request, pinned or | |
| * not: it is the branch cgit would have selected for itself. | |
| */ | |
| if (ctx.repo->defbranch && !strcmp(ctx.qry.head, ctx.repo->defbranch)) { | |
| redirect_dropping_head(); | |
| return CGIT_RECONCILE_ANSWERED; | |
| } | |
| /* Any other h= carries information on its own, and only a request that | |
| * also pins its content can be collapsed further -- at the price of a | |
| * walk, so only where the operator has asked for one. | |
| */ | |
| if (!ctx.qry.oid || !ctx.repo->enable_object_reachability_check) | |
| return CGIT_RECONCILE_CONTINUE; | |
| if (repo_get_oid(the_repository, ctx.qry.oid, &oid)) | |
| return CGIT_RECONCILE_CONTINUE; | |
| on_default = ctx.repo->defbranch ? | |
| oid_is_on_branch(&oid, ctx.repo->defbranch) : -1; | |
| if (on_default > 0) { | |
| redirect_dropping_head(); | |
| return CGIT_RECONCILE_ANSWERED; | |
| } | |
| on_head = oid_is_on_branch(&oid, ctx.qry.head); | |
| if (on_head > 0) { | |
| /* The walk just placed the object on h=, so if h= is one of | |
| * the references this repository publishes, the object is | |
| * reachable from it and the broader check has nothing left to | |
| * find. Saying so here spares the caller a second walk, this | |
| * one over every published tip. | |
| */ | |
| if (cgit_ref_is_published(the_repository, ctx.repo, | |
| ctx.qry.head)) | |
| return CGIT_RECONCILE_OID_PUBLISHED; | |
| return CGIT_RECONCILE_CONTINUE; | |
| } | |
| if (on_head < 0 || on_default < 0 || ctx.qry.oid2) | |
| return CGIT_RECONCILE_CONTINUE; | |
| cgit_print_error_page(404, "Not found", | |
| "Object %s is not on branch %s", | |
| ctx.qry.oid, ctx.qry.head); | |
| return CGIT_RECONCILE_ANSWERED; | |
| } | |
| /* Collapse an explicit refs/heads/ prefix on h= down to the branch name | |
| * alone, provided a tag by the same name doesn't exist (a tag would | |
| * shadow the bare name in gitrevisions(7) resolution order). | |
| */ | |
| int cgit_redirect_canonical_head(void) | |
| { | |
| const char *branch; | |
| struct strbuf tagref = STRBUF_INIT; | |
| struct strbuf query = STRBUF_INIT; | |
| char *path; | |
| int shadowed; | |
| if (!ctx.repo || !ctx.qry.head || ctx.qry.nohead) | |
| return 0; | |
| if (!skip_prefix(ctx.qry.head, "refs/heads/", &branch) || !*branch) | |
| return 0; | |
| strbuf_addf(&tagref, "refs/tags/%s", branch); | |
| shadowed = refs_ref_exists(get_main_ref_store(the_repository), tagref.buf); | |
| strbuf_release(&tagref); | |
| if (shadowed) | |
| return 0; | |
| /* The short name may itself be the default branch, in which case the | |
| * request has no use for h= at all. Answer with the URL the visitor | |
| * would have been sent to anyway, rather than spending a round trip on | |
| * a spelling that is about to be dropped. | |
| */ | |
| if (ctx.repo->defbranch && !strcmp(branch, ctx.repo->defbranch)) { | |
| redirect_dropping_head(); | |
| return 1; | |
| } | |
| copy_query_replacing_head(&query, branch); | |
| path = cgit_currenturl(); | |
| cgit_redirect_query(path, query.buf, true); | |
| free(path); | |
| strbuf_release(&query); | |
| return 1; | |
| } | |
| static int is_commit_diff_page(const char *page) | |
| { | |
| static const char * const pages[] = { | |
| "commit", "diff", "patch", "rawdiff", NULL | |
| }; | |
| const char * const *p; | |
| for (p = pages; *p; p++) | |
| if (!strcmp(page, *p)) | |
| return 1; | |
| return 0; | |
| } | |
| static int path_touched_by_commit; | |
| static void mark_path_touched(struct diff_filepair *pair) | |
| { | |
| path_touched_by_commit = 1; | |
| } | |
| /* Whether path= changes anything on a commit/diff/patch/rawdiff page: | |
| * if the pinned commit doesn't touch that path, the page's output would | |
| * be identical without it. | |
| */ | |
| /* The canonical URL for this page with no in-project path: the repository | |
| * and the page, and nothing else. cgit_currenturl() cannot serve here -- | |
| * when the request arrived as PATH_INFO the path is part of ctx.qry.url, so | |
| * rebuilding from it would keep the very path this redirect drops and send | |
| * the request straight back to itself. | |
| */ | |
| static char *pathless_commit_url(void) | |
| { | |
| const char *root = cgit_rooturl(); | |
| struct strbuf url = STRBUF_INIT; | |
| strbuf_addstr(&url, root); | |
| if (url.len && url.buf[url.len - 1] != '/') | |
| strbuf_addch(&url, '/'); | |
| strbuf_addf(&url, "%s/%s", ctx.repo->url, ctx.qry.page); | |
| return strbuf_detach(&url, NULL); | |
| } | |
| int cgit_redirect_pathless_commit(void) | |
| { | |
| struct object_id oid; | |
| struct commit *commit; | |
| struct strbuf query = STRBUF_INIT; | |
| static const char * const drop[] = { "path", "url", NULL }; | |
| char *path; | |
| if (!ctx.repo || !ctx.qry.path || !*ctx.qry.path) | |
| return 0; | |
| if (ctx.qry.oid2) | |
| return 0; | |
| if (!ctx.qry.page || !is_commit_diff_page(ctx.qry.page)) | |
| return 0; | |
| if (!ctx.qry.oid || repo_get_oid(the_repository, ctx.qry.oid, &oid)) | |
| return 0; | |
| commit = lookup_commit_reference(the_repository, &oid); | |
| if (!commit || repo_parse_commit(the_repository, commit)) | |
| return 0; | |
| path_touched_by_commit = 0; | |
| cgit_diff_commit(commit, mark_path_touched, ctx.qry.path); | |
| if (path_touched_by_commit) | |
| return 0; | |
| copy_query_without(&query, drop); | |
| path = pathless_commit_url(); | |
| cgit_redirect_query(path, query.buf, true); | |
| free(path); | |
| strbuf_release(&query); | |
| return 1; | |
| } | |
| /* Whether a string is entirely hex digits and shorter than a full object id | |
| * -- i.e. plausibly an abbreviated sha, as opposed to a ref name or a | |
| * revision expression like "HEAD~2" that repo_get_oid() would also accept. | |
| * Redirecting those would be wrong: "id=HEAD" is meant to keep tracking the | |
| * tip, and pinning it to today's resolution would break that. | |
| */ | |
| static int looks_like_abbreviated_oid(const char *s) | |
| { | |
| size_t len = strlen(s); | |
| if (!len || len >= the_hash_algo->hexsz) | |
| return 0; | |
| while (*s) | |
| if (!isxdigit((unsigned char)*s++)) | |
| return 0; | |
| return 1; | |
| } | |
| /* Redirect an abbreviated id= and/or id2= to the full-length object id it | |
| * resolves to. repo_get_oid() already rejects an ambiguous abbreviation, so | |
| * reaching the redirect means the abbreviation named exactly one object. | |
| */ | |
| int cgit_redirect_full_oid(void) | |
| { | |
| struct object_id oid, oid2; | |
| char fullhex[GIT_MAX_HEXSZ + 1], fullhex2[GIT_MAX_HEXSZ + 1]; | |
| const char *full = NULL, *full2 = NULL; | |
| struct strbuf query = STRBUF_INIT; | |
| char *path; | |
| if (!ctx.repo) | |
| return 0; | |
| if (ctx.qry.oid && looks_like_abbreviated_oid(ctx.qry.oid) && | |
| !repo_get_oid(the_repository, ctx.qry.oid, &oid)) { | |
| oid_to_hex_r(fullhex, &oid); | |
| full = fullhex; | |
| } | |
| if (ctx.qry.oid2 && looks_like_abbreviated_oid(ctx.qry.oid2) && | |
| !repo_get_oid(the_repository, ctx.qry.oid2, &oid2)) { | |
| oid_to_hex_r(fullhex2, &oid2); | |
| full2 = fullhex2; | |
| } | |
| if (!full && !full2) | |
| return 0; | |
| copy_query_replacing_ids(&query, full, full2); | |
| path = cgit_currenturl(); | |
| cgit_redirect_query(path, query.buf, true); | |
| free(path); | |
| strbuf_release(&query); | |
| return 1; | |
| } | |
| static void print_rel_vcs_link(const char *url) | |
| { | |
| html("<link rel='vcs-git' href='"); | |
| html_attr(url); | |
| html("' title='"); | |
| html_attr(ctx.repo->name); | |
| html(" Git repository'/>\n"); | |
| } | |
| static int emit_css_link(struct string_list_item *s, void *arg) | |
| { | |
| /* Do not emit anything if css= is specified. */ | |
| if (s && *s->string == '\0') | |
| return 0; | |
| html("<link rel='stylesheet' type='text/css' href='"); | |
| if (s) | |
| html_attr(s->string); | |
| else | |
| html_attr((const char *)arg); | |
| html("'/>\n"); | |
| return 0; | |
| } | |
| static int emit_js_link(struct string_list_item *s, void *arg) | |
| { | |
| /* Do not emit anything if js= is specified. */ | |
| if (s && *s->string == '\0') | |
| return 0; | |
| html("<script type='text/javascript' src='"); | |
| if (s) | |
| html_attr(s->string); | |
| else | |
| html_attr((const char *)arg); | |
| html("'></script>\n"); | |
| return 0; | |
| } | |
| void cgit_print_docstart(void) | |
| { | |
| char *host = cgit_hosturl(); | |
| if (ctx.cfg.embedded) { | |
| if (ctx.cfg.header) | |
| html_include(ctx.cfg.header); | |
| return; | |
| } | |
| html(cgit_doctype); | |
| html("<html lang='en'>\n"); | |
| html("<head>\n"); | |
| html("<title>"); | |
| html_txt(ctx.page.title); | |
| html("</title>\n"); | |
| htmlf("<meta name='generator' content='cgit %s'/>\n", cgit_version); | |
| if (ctx.cfg.robots && *ctx.cfg.robots) | |
| htmlf("<meta name='robots' content='%s'/>\n", ctx.cfg.robots); | |
| if (ctx.cfg.css.items) | |
| for_each_string_list(&ctx.cfg.css, emit_css_link, NULL); | |
| else | |
| emit_css_link(NULL, "/cgit.css"); | |
| if (ctx.cfg.js.items) | |
| for_each_string_list(&ctx.cfg.js, emit_js_link, NULL); | |
| else | |
| emit_js_link(NULL, "/cgit.js"); | |
| if (ctx.cfg.favicon && *ctx.cfg.favicon) { | |
| html("<link rel='shortcut icon' href='"); | |
| html_attr(ctx.cfg.favicon); | |
| html("'/>\n"); | |
| } | |
| if (host && ctx.repo && ctx.qry.head) { | |
| char *fileurl; | |
| struct strbuf sb = STRBUF_INIT; | |
| strbuf_addf(&sb, "h=%s", ctx.qry.head); | |
| html("<link rel='alternate' title='Atom feed' href='"); | |
| html(cgit_httpscheme()); | |
| html_attr(host); | |
| fileurl = cgit_fileurl(ctx.repo->url, "atom", ctx.qry.vpath, | |
| sb.buf); | |
| html_attr(fileurl); | |
| html("' type='application/atom+xml'/>\n"); | |
| strbuf_release(&sb); | |
| free(fileurl); | |
| } | |
| if (ctx.repo) | |
| cgit_add_clone_urls(print_rel_vcs_link); | |
| if (ctx.cfg.head_include) | |
| html_include(ctx.cfg.head_include); | |
| if (ctx.repo && ctx.repo->extra_head_content) | |
| html(ctx.repo->extra_head_content); | |
| html("</head>\n"); | |
| html("<body>\n"); | |
| if (ctx.cfg.header) | |
| html_include(ctx.cfg.header); | |
| free(host); | |
| } | |
| void cgit_print_docend(void) | |
| { | |
| html("</div> <!-- class=content -->\n"); | |
| if (ctx.cfg.embedded) { | |
| html("</div> <!-- id=cgit -->\n"); | |
| if (ctx.cfg.footer) | |
| html_include(ctx.cfg.footer); | |
| return; | |
| } | |
| if (ctx.cfg.footer) | |
| html_include(ctx.cfg.footer); | |
| else { | |
| htmlf("<div class='footer'>generated by <a href='https://git.zx2c4.com/cgit/about/'>cgit %s</a> " | |
| "(<a href='https://git-scm.com/'>git %s</a>) at ", cgit_version, git_version_string); | |
| html_txt(show_date(time(NULL), 0, cgit_date_mode(DATE_ISO8601))); | |
| html("</div>\n"); | |
| } | |
| html("</div> <!-- id=cgit -->\n"); | |
| html("</body>\n</html>\n"); | |
| } | |
| /* Reject a request for an object that this repository does not publish. This | |
| * only matters where several repositories share an object database: an object | |
| * is then readable from every one of them, and each has as many valid URLs for | |
| * it as there are repositories. | |
| * | |
| * A revision that does not resolve at all is left to the page handler, which | |
| * reports it in its own words. Conflating the two would tell the visitor that | |
| * an object is unknown when in fact it exists and simply does not belong here. | |
| */ | |
| int cgit_reject_unreachable_object(const char *rev) | |
| { | |
| struct object_id oid; | |
| if (!ctx.repo || !ctx.repo->enable_object_reachability_check) | |
| return 0; | |
| if (!rev || repo_get_oid(the_repository, rev, &oid)) | |
| return 0; | |
| if (cgit_oid_is_reachable(the_repository, ctx.repo, &oid)) | |
| return 0; | |
| cgit_print_error_page(404, "Not found", | |
| "Object %s is not reachable from any reference " | |
| "in this repository", rev); | |
| return 1; | |
| } | |
| /* Copy the query string of the request, dropping the parameters the canonical | |
| * URL restates for itself. | |
| * | |
| * The repository is being replaced, so the parameters naming it go. So does | |
| * h=: the branch it names belongs to the fork, not to the repository we are | |
| * handing the visitor to, and a request pinned by id= resolves its content | |
| * from id= alone. And so do id= and id2=, which are reissued as full object | |
| * names, because cgit accepts a reference there and a reference resolved | |
| * against the canonical repository would name a different commit. | |
| * | |
| * Parameter names are compared without decoding them. Encoding a name is | |
| * legal but nothing produces it, and a name that arrives encoded is simply | |
| * carried across unrecognised, which costs the visitor one redundant | |
| * parameter and nothing else. | |
| */ | |
| static void copy_query_without_repo(struct strbuf *sb) | |
| { | |
| static const char *drop[] = { "r", "h", "url", "id", "id2", NULL }; | |
| const char *q = ctx.env.query_string; | |
| while (q && *q) { | |
| const char *end = strchrnul(q, '&'); | |
| size_t len = end - q; | |
| const char *namep = q; | |
| char *decoded = url_decode_parameter_name(&namep); | |
| const char **name; | |
| for (name = drop; *name; name++) | |
| if (!strcmp(decoded, *name)) | |
| break; | |
| free(decoded); | |
| if (!*name) { | |
| if (sb->len) | |
| strbuf_addch(sb, '&'); | |
| strbuf_add(sb, q, len); | |
| } | |
| q = *end ? end + 1 : end; | |
| } | |
| } | |
| /* Build the same request against 'repo'. Only the repository changes: the | |
| * page, the path and every remaining parameter are those the visitor sent, | |
| * so the page they arrive at is the page they asked for. | |
| */ | |
| static char *canonical_repo_url(const struct cgit_repo *repo, | |
| const struct object_id *oid, | |
| const struct object_id *oid2, | |
| struct strbuf *query) | |
| { | |
| struct strbuf url = STRBUF_INIT; | |
| copy_query_without_repo(query); | |
| if (query->len) | |
| strbuf_insertstr(query, 0, "&"); | |
| if (oid2) | |
| strbuf_insertf(query, 0, "&id2=%s", oid_to_hex(oid2)); | |
| strbuf_insertf(query, 0, "id=%s", oid_to_hex(oid)); | |
| strbuf_addstr(&url, ctx.cfg.virtual_root ? ctx.cfg.virtual_root : "/"); | |
| if (ctx.qry.url) { | |
| /* Whether it arrived as PATH_INFO or as url=, ctx.qry.url is | |
| * the repository followed by the page and path. Replacing the | |
| * one leaves the others untouched. | |
| */ | |
| strbuf_addstr(&url, repo->url); | |
| strbuf_addstr(&url, ctx.qry.url + strlen(ctx.repo->url)); | |
| } else { | |
| /* A request that named its repository with r= keeps its page | |
| * and path in the query string, so only r= has to come back. | |
| */ | |
| strbuf_insertf(query, 0, "r=%s&", repo->url); | |
| } | |
| return strbuf_detach(&url, NULL); | |
| } | |
| /* Whether 'repo' publishes 'oid', in the sense the redirect needs: it has to | |
| * hold the object before the question of reachability arises. | |
| * | |
| * cgit_oid_is_reachable() reports an object it cannot find as published, | |
| * because there refusing to serve a page is the more damaging way to be | |
| * wrong. Here the damaging answer is the other one -- a redirect would send | |
| * the visitor to a repository that has no copy of what they asked for -- so | |
| * the absent object is ruled out before it is asked about. | |
| */ | |
| static int repo_publishes_oid(const struct cgit_repo *repo, | |
| struct repository *r, | |
| const struct object_id *oid) | |
| { | |
| if (!odb_has_object(r->objects, oid, 0)) | |
| return 0; | |
| return cgit_oid_is_reachable(r, repo, oid); | |
| } | |
| /* Pages with no navigation of their own: no page header, no repo tabs, no | |
| * outbound links to other views of the same repository. Landing on one by | |
| * redirect leaves nothing to click but the back button, so there is nothing | |
| * for a visitor to be confused by. A page that carries the ordinary chrome | |
| * -- commit, diff, log, tree and the rest -- would otherwise send someone | |
| * on to browse a repository they never chose, with no indication that the | |
| * ground shifted under them. | |
| */ | |
| static int is_terminal_page(const char *page) | |
| { | |
| static const char * const pages[] = { | |
| "blob", "patch", "plain", "rawdiff", "snapshot", NULL | |
| }; | |
| const char * const *p; | |
| for (p = pages; *p; p++) | |
| if (!strcmp(page, *p)) | |
| return 1; | |
| return 0; | |
| } | |
| /* Which canonical repository, if any, publishes 'oid' (and 'oid2', when | |
| * given). Shared by the redirect on terminal pages and the abbreviated | |
| * "merged elsewhere" notice on commit/diff pages -- both are answering the | |
| * same question, just acting on it differently. | |
| * | |
| * A repository named as canonical never matches, including against another | |
| * repository on the list. It is where visitors are being pointed at, and a | |
| * site with several of them -- a mainline and the stable trees maintained | |
| * alongside it, say -- means each of them is the right answer for its own | |
| * URLs, not that they should chase each other. | |
| */ | |
| struct cgit_repo *cgit_find_canonical_repo(const struct object_id *oid, | |
| const struct object_id *oid2) | |
| { | |
| struct string_list_item *item; | |
| if (!ctx.repo || !ctx.cfg.canonical_repos.nr) | |
| return NULL; | |
| for_each_string_list_item(item, &ctx.cfg.canonical_repos) | |
| if (!strcmp(item->string, ctx.repo->url)) | |
| return NULL; | |
| for_each_string_list_item(item, &ctx.cfg.canonical_repos) { | |
| struct cgit_repo *repo = cgit_get_repoinfo(item->string); | |
| struct repository canon; | |
| int publishes; | |
| if (!repo || repo_init(&canon, repo->path, NULL)) | |
| continue; | |
| publishes = repo_publishes_oid(repo, &canon, oid) && | |
| (!oid2 || repo_publishes_oid(repo, &canon, oid2)); | |
| /* Deliberately not repo_clear(&canon): closing canon's | |
| * commit-graph wipes commit_graph_data_slab, which is shared | |
| * by every repository open in this process, corrupting a | |
| * graph position another repository (e.g. the_repository's) | |
| * already has cached. Disabling canon's commit-graph instead | |
| * would dodge that, but cgit_oid_is_reachable() depends on its | |
| * generation numbers to stay affordable on deep history. | |
| * cmd_main() serves one request per process and exits, so | |
| * leaking canon here is the cheaper trade. | |
| */ | |
| if (publishes) | |
| return repo; | |
| } | |
| return NULL; | |
| } | |
| /* Redirect a request pinned to an object that a canonical repository | |
| * publishes. Where forks share an object database every one of them can | |
| * render every object, so a single commit has as many valid URLs as there | |
| * are forks; naming the repositories that history is merged into lets the | |
| * rest of them hand such a request over instead of answering it. | |
| * | |
| * Only a request pinned by id= can be redirected. Anything else names a | |
| * reference, and a reference belongs to the repository that publishes it | |
| * however much history the two repositories share. A diff names two objects | |
| * and is redirected only when the canonical repository publishes both. | |
| * | |
| * Restricted to is_terminal_page(): a redirect substitutes a different | |
| * repository for the one in the URL, and a page with its own navigation | |
| * would carry that substitution forward invisibly -- someone landing on | |
| * their own fork's commit page ends up browsing another repository's log | |
| * and tree without ever being told so. | |
| */ | |
| int cgit_redirect_to_canonical_repo(void) | |
| { | |
| struct object_id oid, oid2; | |
| int have_oid2 = 0; | |
| struct cgit_repo *repo; | |
| struct strbuf query = STRBUF_INIT; | |
| char *url; | |
| if (!ctx.repo || !ctx.qry.oid || !ctx.cfg.canonical_repos.nr) | |
| return 0; | |
| if (!ctx.qry.page || !is_terminal_page(ctx.qry.page)) | |
| return 0; | |
| if (repo_get_oid(the_repository, ctx.qry.oid, &oid)) | |
| return 0; | |
| if (ctx.qry.oid2) { | |
| if (repo_get_oid(the_repository, ctx.qry.oid2, &oid2)) | |
| return 0; | |
| have_oid2 = 1; | |
| } | |
| repo = cgit_find_canonical_repo(&oid, have_oid2 ? &oid2 : NULL); | |
| if (!repo) | |
| return 0; | |
| url = canonical_repo_url(repo, &oid, have_oid2 ? &oid2 : NULL, &query); | |
| cgit_redirect_query(url, query.buf, true); | |
| strbuf_release(&query); | |
| free(url); | |
| return 1; | |
| } | |
| /* Print the notice that stands in for a commit's or diff's own content once | |
| * a canonical repository already publishes it. Unlike the terminal-page | |
| * redirect, this doesn't send the visitor away -- these two pages carry | |
| * chrome of their own, breadcrumbs and repo tabs among it -- so instead it | |
| * prints a link to the same object in the repository that publishes it, and | |
| * the caller skips rendering the diff. That's both the expensive part of | |
| * these two pages and the part every fork sharing an object database with | |
| * the canonical repository would render identically, so skipping it is what | |
| * actually shrinks the crawlable surface. | |
| */ | |
| void cgit_print_merged_notice(struct cgit_repo *repo, | |
| const struct object_id *oid, | |
| const struct object_id *oid2, | |
| const char *what) | |
| { | |
| struct strbuf query = STRBUF_INIT; | |
| char *url = canonical_repo_url(repo, oid, oid2, &query); | |
| html("<div class='merged-notice'>"); | |
| htmlf("This %s has been merged to ", what); | |
| html_txt(repo->url); | |
| html(".<br/>\n"); | |
| html("<a href='"); | |
| html_url_path(url); | |
| if (query.len) { | |
| html("?"); | |
| html_attr(query.buf); | |
| } | |
| html("'>View in the target repository</a>."); | |
| html("</div>\n"); | |
| strbuf_release(&query); | |
| free(url); | |
| } | |
| void cgit_print_error_page(int code, const char *msg, const char *fmt, ...) | |
| { | |
| va_list ap; | |
| va_start(ap, fmt); | |
| cgit_vprint_error_page(code, msg, fmt, ap); | |
| va_end(ap); | |
| } | |
| void cgit_vprint_error_page(int code, const char *msg, const char *fmt, va_list ap) | |
| { | |
| ctx.page.expires = ctx.cfg.cache_dynamic_ttl; | |
| ctx.page.status = code; | |
| ctx.page.statusmsg = msg; | |
| cgit_print_layout_start(); | |
| cgit_vprint_error(fmt, ap); | |
| cgit_print_layout_end(); | |
| } | |
| void cgit_print_layout_start(void) | |
| { | |
| cgit_print_http_headers(); | |
| cgit_print_docstart(); | |
| cgit_print_pageheader(); | |
| } | |
| void cgit_print_layout_end(void) | |
| { | |
| cgit_print_docend(); | |
| } | |
| static void add_clone_urls(void (*fn)(const char *), char *txt, char *suffix) | |
| { | |
| struct strbuf **url_list = strbuf_split_str(txt, ' ', 0); | |
| int i; | |
| for (i = 0; url_list[i]; i++) { | |
| strbuf_rtrim(url_list[i]); | |
| if (url_list[i]->len == 0) | |
| continue; | |
| if (suffix && *suffix) | |
| strbuf_addf(url_list[i], "/%s", suffix); | |
| fn(url_list[i]->buf); | |
| } | |
| strbuf_list_free(url_list); | |
| } | |
| void cgit_add_clone_urls(void (*fn)(const char *)) | |
| { | |
| if (ctx.repo->clone_url) | |
| add_clone_urls(fn, expand_macros(ctx.repo->clone_url), NULL); | |
| else if (ctx.cfg.clone_prefix) | |
| add_clone_urls(fn, ctx.cfg.clone_prefix, ctx.repo->url); | |
| } | |
| static int print_branch_option(const struct reference *ref, void *cb_data) | |
| { | |
| char *name = (char *)ref->name; | |
| html_option(name, name, ctx.qry.head); | |
| return 0; | |
| } | |
| /* Emit the hidden fields that let a form resubmit the request it was | |
| * rendered from. 'incl_head' and 'incl_rev' say whether the branch and the | |
| * pinned revision are part of that: a form that re-renders the same page | |
| * with different options -- the diff controls, the log search -- needs both, | |
| * so that submitting it changes only what it set out to change. | |
| * | |
| * The branch switcher needs neither. It supplies its own h=, and a revision | |
| * carried alongside would go on deciding what the page displays, so picking | |
| * a different branch would appear to do nothing at all. | |
| */ | |
| void cgit_add_hidden_formfields(int incl_head, int incl_rev, int incl_search, | |
| const char *page) | |
| { | |
| if (!ctx.cfg.virtual_root) { | |
| struct strbuf url = STRBUF_INIT; | |
| strbuf_addf(&url, "%s/%s", ctx.qry.repo, page); | |
| if (ctx.qry.vpath) | |
| strbuf_addf(&url, "/%s", ctx.qry.vpath); | |
| html_hidden("url", url.buf); | |
| strbuf_release(&url); | |
| } | |
| if (incl_head && ctx.qry.head && ctx.repo->defbranch && | |
| strcmp(ctx.qry.head, ctx.repo->defbranch)) | |
| html_hidden("h", ctx.qry.head); | |
| if (incl_rev) { | |
| if (ctx.qry.oid) | |
| html_hidden("id", ctx.qry.oid); | |
| if (ctx.qry.oid2) | |
| html_hidden("id2", ctx.qry.oid2); | |
| } | |
| if (ctx.qry.showmsg) | |
| html_hidden("showmsg", "1"); | |
| if (incl_search) { | |
| if (ctx.qry.grep) | |
| html_hidden("qt", ctx.qry.grep); | |
| if (ctx.qry.search) | |
| html_hidden("q", ctx.qry.search); | |
| } | |
| } | |
| static const char *hc(const char *page) | |
| { | |
| if (!ctx.qry.page) | |
| return NULL; | |
| return strcmp(ctx.qry.page, page) ? NULL : "active"; | |
| } | |
| static void cgit_print_path_crumbs(char *path) | |
| { | |
| char *old_path = ctx.qry.path; | |
| char *p = path, *q, *end = path + strlen(path); | |
| int levels = 0; | |
| ctx.qry.path = NULL; | |
| cgit_self_link("root", NULL, NULL); | |
| ctx.qry.path = p = path; | |
| while (p < end) { | |
| if (!(q = strchr(p, '/')) || levels > 15) | |
| q = end; | |
| *q = '\0'; | |
| html_txt("/"); | |
| cgit_self_link(p, NULL, NULL); | |
| if (q < end) | |
| *q = '/'; | |
| p = q + 1; | |
| ++levels; | |
| } | |
| ctx.qry.path = old_path; | |
| } | |
| static void print_header(void) | |
| { | |
| char *logo = NULL, *logo_link = NULL; | |
| html("<table id='header'>\n"); | |
| html("<tr>\n"); | |
| if (ctx.repo && ctx.repo->logo && *ctx.repo->logo) | |
| logo = ctx.repo->logo; | |
| else | |
| logo = ctx.cfg.logo; | |
| if (ctx.repo && ctx.repo->logo_link && *ctx.repo->logo_link) | |
| logo_link = ctx.repo->logo_link; | |
| else | |
| logo_link = ctx.cfg.logo_link; | |
| if (logo && *logo) { | |
| html("<td class='logo' rowspan='2'><a href='"); | |
| if (logo_link && *logo_link) | |
| html_attr(logo_link); | |
| else | |
| html_attr(cgit_rooturl()); | |
| html("'><img src='"); | |
| html_attr(logo); | |
| html("' alt='cgit logo'/></a></td>\n"); | |
| } | |
| html("<td class='main'>"); | |
| if (ctx.repo) { | |
| cgit_index_link("index", NULL, NULL, NULL, NULL, 0, 1); | |
| html(" : "); | |
| cgit_summary_link(ctx.repo->name, NULL, NULL, NULL); | |
| if (ctx.env.authenticated) { | |
| html("</td><td class='form'>"); | |
| html("<form method='get'>\n"); | |
| cgit_add_hidden_formfields(0, 0, 1, ctx.qry.page); | |
| html("<select name='h' onchange='this.form.submit();'>\n"); | |
| refs_for_each_branch_ref(get_main_ref_store(the_repository), | |
| print_branch_option, ctx.qry.head); | |
| if (ctx.repo->enable_remote_branches) | |
| refs_for_each_remote_ref(get_main_ref_store(the_repository), | |
| print_branch_option, ctx.qry.head); | |
| html("</select> "); | |
| html("<input type='submit' value='switch'/>"); | |
| html("</form>"); | |
| } | |
| } else | |
| html_txt(ctx.cfg.root_title); | |
| html("</td></tr>\n"); | |
| html("<tr><td class='sub'>"); | |
| if (ctx.repo) { | |
| html_txt(ctx.repo->desc); | |
| html("</td><td class='sub right'>"); | |
| if (ctx.repo->owner_filter) { | |
| cgit_open_filter(ctx.repo->owner_filter); | |
| html_txt(ctx.repo->owner); | |
| cgit_close_filter(ctx.repo->owner_filter); | |
| } else { | |
| html_txt(ctx.repo->owner); | |
| } | |
| } else { | |
| if (ctx.cfg.root_desc) | |
| html_txt(ctx.cfg.root_desc); | |
| } | |
| html("</td></tr></table>\n"); | |
| } | |
| void cgit_print_pageheader(void) | |
| { | |
| html("<div id='cgit'>"); | |
| if (!ctx.env.authenticated || !ctx.cfg.noheader) | |
| print_header(); | |
| html("<table class='tabs'><tr><td>\n"); | |
| if (ctx.env.authenticated && ctx.repo) { | |
| if (ctx.repo->readme.nr) | |
| reporevlink("about", "about", NULL, | |
| hc("about"), ctx.qry.head, NULL, | |
| NULL); | |
| cgit_summary_link("summary", NULL, hc("summary"), | |
| ctx.qry.head); | |
| cgit_refs_link("refs", NULL, hc("refs"), ctx.qry.head, | |
| ctx.qry.oid, NULL); | |
| cgit_log_link("log", NULL, hc("log"), ctx.qry.head, | |
| NULL, ctx.qry.vpath, 0, NULL, NULL, | |
| ctx.qry.showmsg, ctx.qry.follow); | |
| if (ctx.qry.page && !strcmp(ctx.qry.page, "blame")) | |
| cgit_blame_link("blame", NULL, hc("blame"), ctx.qry.head, | |
| ctx.qry.oid, ctx.qry.vpath); | |
| else | |
| cgit_tree_link("tree", NULL, hc("tree"), ctx.qry.head, | |
| ctx.qry.oid, ctx.qry.vpath); | |
| cgit_commit_link("commit", NULL, hc("commit"), | |
| ctx.qry.head, ctx.qry.oid, ctx.qry.vpath); | |
| cgit_diff_link("diff", NULL, hc("diff"), ctx.qry.head, | |
| ctx.qry.oid, ctx.qry.oid2, ctx.qry.vpath); | |
| if (ctx.repo->max_stats) | |
| cgit_stats_link("stats", NULL, hc("stats"), | |
| ctx.qry.head, ctx.qry.vpath); | |
| if (ctx.repo->homepage) { | |
| html("<a href='"); | |
| html_attr(ctx.repo->homepage); | |
| html("'>homepage</a>"); | |
| } | |
| html("</td><td class='form'>"); | |
| html("<form class='right' method='get' action='"); | |
| if (ctx.cfg.virtual_root) { | |
| char *fileurl = cgit_fileurl(ctx.qry.repo, "log", | |
| ctx.qry.vpath, NULL); | |
| html_url_path(fileurl); | |
| free(fileurl); | |
| } | |
| html("'>\n"); | |
| cgit_add_hidden_formfields(1, 1, 0, "log"); | |
| html("<select name='qt'>\n"); | |
| html_option("grep", "log msg", ctx.qry.grep); | |
| html_option("author", "author", ctx.qry.grep); | |
| html_option("committer", "committer", ctx.qry.grep); | |
| html_option("range", "range", ctx.qry.grep); | |
| html("</select>\n"); | |
| html("<input class='txt' type='search' size='10' name='q' value='"); | |
| html_attr(ctx.qry.search); | |
| html("'/>\n"); | |
| html("<input type='submit' value='search'/>\n"); | |
| html("</form>\n"); | |
| } else if (ctx.env.authenticated) { | |
| char *currenturl = cgit_currenturl(); | |
| site_link(NULL, "index", NULL, hc("repolist"), NULL, NULL, 0, 1); | |
| if (ctx.cfg.root_readme) | |
| site_link("about", "about", NULL, hc("about"), | |
| NULL, NULL, 0, 1); | |
| html("</td><td class='form'>"); | |
| html("<form method='get' action='"); | |
| html_attr(currenturl); | |
| html("'>\n"); | |
| html("<input type='search' name='q' size='10' value='"); | |
| html_attr(ctx.qry.search); | |
| html("'/>\n"); | |
| html("<input type='submit' value='search'/>\n"); | |
| html("</form>"); | |
| free(currenturl); | |
| } | |
| html("</td></tr></table>\n"); | |
| if (ctx.env.authenticated && ctx.repo && ctx.qry.vpath) { | |
| html("<div class='path'>"); | |
| html("path: "); | |
| cgit_print_path_crumbs(ctx.qry.vpath); | |
| if (ctx.repo->enable_follow_links && !strcmp(ctx.qry.page, "log")) { | |
| html(" ("); | |
| ctx.qry.follow = !ctx.qry.follow; | |
| cgit_self_link(ctx.qry.follow ? "follow" : "unfollow", | |
| NULL, NULL); | |
| ctx.qry.follow = !ctx.qry.follow; | |
| html(")"); | |
| } | |
| html("</div>"); | |
| } | |
| html("<div class='content'>"); | |
| } | |
| void cgit_print_filemode(unsigned short mode) | |
| { | |
| if (S_ISDIR(mode)) | |
| html("d"); | |
| else if (S_ISLNK(mode)) | |
| html("l"); | |
| else if (S_ISGITLINK(mode)) | |
| html("m"); | |
| else | |
| html("-"); | |
| html_fileperm(mode >> 6); | |
| html_fileperm(mode >> 3); | |
| html_fileperm(mode); | |
| } | |
| void cgit_compose_snapshot_prefix(struct strbuf *filename, const char *base, | |
| const char *ref) | |
| { | |
| struct object_id oid; | |
| /* | |
| * Prettify snapshot names by stripping leading "v" or "V" if the tag | |
| * name starts with {v,V}[0-9] and the prettify mapping is injective, | |
| * i.e. each stripped tag can be inverted without ambiguities. | |
| */ | |
| if (repo_get_oid(the_repository, fmt("refs/tags/%s", ref), &oid) == 0 && | |
| (ref[0] == 'v' || ref[0] == 'V') && isdigit(ref[1]) && | |
| ((repo_get_oid(the_repository, fmt("refs/tags/%s", ref + 1), &oid) == 0) + | |
| (repo_get_oid(the_repository, fmt("refs/tags/v%s", ref + 1), &oid) == 0) + | |
| (repo_get_oid(the_repository, fmt("refs/tags/V%s", ref + 1), &oid) == 0) == 1)) | |
| ref++; | |
| strbuf_addf(filename, "%s-%s", base, ref); | |
| } | |
| void cgit_print_snapshot_links(const struct cgit_repo *repo, const char *ref, | |
| const char *separator) | |
| { | |
| const struct cgit_snapshot_format *f; | |
| struct strbuf filename = STRBUF_INIT; | |
| const char *basename; | |
| size_t prefixlen; | |
| basename = cgit_snapshot_prefix(repo); | |
| if (starts_with(ref, basename)) | |
| strbuf_addstr(&filename, ref); | |
| else | |
| cgit_compose_snapshot_prefix(&filename, basename, ref); | |
| prefixlen = filename.len; | |
| for (f = cgit_snapshot_formats; f->suffix; f++) { | |
| if (!(repo->snapshots & cgit_snapshot_format_bit(f))) | |
| continue; | |
| strbuf_setlen(&filename, prefixlen); | |
| strbuf_addstr(&filename, f->suffix); | |
| cgit_snapshot_link(filename.buf, NULL, NULL, NULL, NULL, | |
| filename.buf); | |
| if (cgit_snapshot_get_sig(ref, f)) { | |
| strbuf_addstr(&filename, ".asc"); | |
| html(" ("); | |
| cgit_snapshot_link("sig", NULL, NULL, NULL, NULL, | |
| filename.buf); | |
| html(")"); | |
| } else if (starts_with(f->suffix, ".tar") && cgit_snapshot_get_sig(ref, &cgit_snapshot_formats[0])) { | |
| strbuf_setlen(&filename, strlen(filename.buf) - strlen(f->suffix)); | |
| strbuf_addstr(&filename, ".tar.asc"); | |
| html(" ("); | |
| cgit_snapshot_link("sig", NULL, NULL, NULL, NULL, | |
| filename.buf); | |
| html(")"); | |
| } | |
| html(separator); | |
| } | |
| strbuf_release(&filename); | |
| } | |
| void cgit_set_title_from_path(const char *path) | |
| { | |
| struct strbuf sb = STRBUF_INIT; | |
| const char *slash, *last_slash; | |
| if (!path) | |
| return; | |
| for (last_slash = path + strlen(path); (slash = memrchr(path, '/', last_slash - path)) != NULL; last_slash = slash) { | |
| strbuf_add(&sb, slash + 1, last_slash - slash - 1); | |
| strbuf_addstr(&sb, " \xc2\xab "); | |
| } | |
| strbuf_add(&sb, path, last_slash - path); | |
| strbuf_addf(&sb, " - %s", ctx.page.title); | |
| ctx.page.title = strbuf_detach(&sb, NULL); | |
| } |