Avoid SEGFAULT on invalid requests

When an unknown page is requested, either on the querystring or via
PATH_INFO, we end up with a null-referencing cgit_cmd. This null-
pointer is then used as argument to the hc() function (which decides
what tab to render as 'active'), but this function failed to check if a
valid cmd was specified and a SEGFAULT would occur. This patch fixes the
issue by introducing a 'fallback-cmd' which specifies what tab to render
as 'active' when no valid cmd is requested.

While at it, we now also keep track of the active repository even if an
invalid cmd was requested since we want to show the error message about
the invalid request in the correct context.

Noticed-by: Robin Redeker <elmex@ta-sa.org>
Signed-off-by: Lars Hjemli <hjemli@gmail.com>

2 files changed, 6 insertions, 2 deletions

diff --git a/cgit.c b/cgit.c
index c82587b..6e5215e 100644
--- a/cgit.c
+++ b/cgit.c
@@ -1,472 +1,471 @@
 /* cgit.c: cgi for the git scm
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "cache.h"
 #include "cmd.h"
 #include "configfile.h"
 #include "html.h"
 #include "ui-shared.h"
 #include "scan-tree.h"
 
 const char *cgit_version = CGIT_VERSION;
 
 void config_cb(const char *name, const char *value)
 {
         if (!strcmp(name, "root-title"))
                 ctx.cfg.root_title = xstrdup(value);
         else if (!strcmp(name, "root-desc"))
                 ctx.cfg.root_desc = xstrdup(value);
         else if (!strcmp(name, "root-readme"))
                 ctx.cfg.root_readme = xstrdup(value);
         else if (!strcmp(name, "css"))
                 ctx.cfg.css = xstrdup(value);
         else if (!strcmp(name, "favicon"))
                 ctx.cfg.favicon = xstrdup(value);
         else if (!strcmp(name, "footer"))
                 ctx.cfg.footer = xstrdup(value);
         else if (!strcmp(name, "logo"))
                 ctx.cfg.logo = xstrdup(value);
         else if (!strcmp(name, "index-header"))
                 ctx.cfg.index_header = xstrdup(value);
         else if (!strcmp(name, "index-info"))
                 ctx.cfg.index_info = xstrdup(value);
         else if (!strcmp(name, "logo-link"))
                 ctx.cfg.logo_link = xstrdup(value);
         else if (!strcmp(name, "module-link"))
                 ctx.cfg.module_link = xstrdup(value);
         else if (!strcmp(name, "virtual-root")) {
                 ctx.cfg.virtual_root = trim_end(value, '/');
                 if (!ctx.cfg.virtual_root && (!strcmp(value, "/")))
                         ctx.cfg.virtual_root = "";
         } else if (!strcmp(name, "nocache"))
                 ctx.cfg.nocache = atoi(value);
         else if (!strcmp(name, "snapshots"))
                 ctx.cfg.snapshots = cgit_parse_snapshots_mask(value);
         else if (!strcmp(name, "enable-index-links"))
                 ctx.cfg.enable_index_links = atoi(value);
         else if (!strcmp(name, "enable-log-filecount"))
                 ctx.cfg.enable_log_filecount = atoi(value);
         else if (!strcmp(name, "enable-log-linecount"))
                 ctx.cfg.enable_log_linecount = atoi(value);
         else if (!strcmp(name, "cache-size"))
                 ctx.cfg.cache_size = atoi(value);
         else if (!strcmp(name, "cache-root"))
                 ctx.cfg.cache_root = xstrdup(value);
         else if (!strcmp(name, "cache-root-ttl"))
                 ctx.cfg.cache_root_ttl = atoi(value);
         else if (!strcmp(name, "cache-repo-ttl"))
                 ctx.cfg.cache_repo_ttl = atoi(value);
         else if (!strcmp(name, "cache-static-ttl"))
                 ctx.cfg.cache_static_ttl = atoi(value);
         else if (!strcmp(name, "cache-dynamic-ttl"))
                 ctx.cfg.cache_dynamic_ttl = atoi(value);
         else if (!strcmp(name, "max-message-length"))
                 ctx.cfg.max_msg_len = atoi(value);
         else if (!strcmp(name, "max-repodesc-length"))
                 ctx.cfg.max_repodesc_len = atoi(value);
         else if (!strcmp(name, "max-repo-count"))
                 ctx.cfg.max_repo_count = atoi(value);
         else if (!strcmp(name, "max-commit-count"))
                 ctx.cfg.max_commit_count = atoi(value);
         else if (!strcmp(name, "summary-log"))
                 ctx.cfg.summary_log = atoi(value);
         else if (!strcmp(name, "summary-branches"))
                 ctx.cfg.summary_branches = atoi(value);
         else if (!strcmp(name, "summary-tags"))
                 ctx.cfg.summary_tags = atoi(value);
         else if (!strcmp(name, "agefile"))
                 ctx.cfg.agefile = xstrdup(value);
         else if (!strcmp(name, "renamelimit"))
                 ctx.cfg.renamelimit = atoi(value);
         else if (!strcmp(name, "robots"))
                 ctx.cfg.robots = xstrdup(value);
         else if (!strcmp(name, "clone-prefix"))
                 ctx.cfg.clone_prefix = xstrdup(value);
         else if (!strcmp(name, "local-time"))
                 ctx.cfg.local_time = atoi(value);
         else if (!strcmp(name, "repo.group"))
                 ctx.cfg.repo_group = xstrdup(value);
         else if (!strcmp(name, "repo.url"))
                 ctx.repo = cgit_add_repo(value);
         else if (!strcmp(name, "repo.name"))
                 ctx.repo->name = xstrdup(value);
         else if (ctx.repo && !strcmp(name, "repo.path"))
                 ctx.repo->path = trim_end(value, '/');
         else if (ctx.repo && !strcmp(name, "repo.clone-url"))
                 ctx.repo->clone_url = xstrdup(value);
         else if (ctx.repo && !strcmp(name, "repo.desc"))
                 ctx.repo->desc = xstrdup(value);
         else if (ctx.repo && !strcmp(name, "repo.owner"))
                 ctx.repo->owner = xstrdup(value);
         else if (ctx.repo && !strcmp(name, "repo.defbranch"))
                 ctx.repo->defbranch = xstrdup(value);
         else if (ctx.repo && !strcmp(name, "repo.snapshots"))
                 ctx.repo->snapshots = ctx.cfg.snapshots & cgit_parse_snapshots_mask(value); /* XXX: &? */
         else if (ctx.repo && !strcmp(name, "repo.enable-log-filecount"))
                 ctx.repo->enable_log_filecount = ctx.cfg.enable_log_filecount * atoi(value);
         else if (ctx.repo && !strcmp(name, "repo.enable-log-linecount"))
                 ctx.repo->enable_log_linecount = ctx.cfg.enable_log_linecount * atoi(value);
         else if (ctx.repo && !strcmp(name, "repo.module-link"))
                 ctx.repo->module_link= xstrdup(value);
         else if (ctx.repo && !strcmp(name, "repo.readme") && value != NULL) {
                 if (*value == '/')
                         ctx.repo->readme = xstrdup(value);
                 else
                         ctx.repo->readme = xstrdup(fmt("%s/%s", ctx.repo->path, value));
         } else if (!strcmp(name, "include"))
                 parse_configfile(value, config_cb);
 }
 
 static void querystring_cb(const char *name, const char *value)
 {
         if (!strcmp(name,"r")) {
                 ctx.qry.repo = xstrdup(value);
                 ctx.repo = cgit_get_repoinfo(value);
         } else if (!strcmp(name, "p")) {
                 ctx.qry.page = xstrdup(value);
         } else if (!strcmp(name, "url")) {
                 ctx.qry.url = xstrdup(value);
                 cgit_parse_url(value);
         } else if (!strcmp(name, "qt")) {
                 ctx.qry.grep = xstrdup(value);
         } else if (!strcmp(name, "q")) {
                 ctx.qry.search = xstrdup(value);
         } else if (!strcmp(name, "h")) {
                 ctx.qry.head = xstrdup(value);
                 ctx.qry.has_symref = 1;
         } else if (!strcmp(name, "id")) {
                 ctx.qry.sha1 = xstrdup(value);
                 ctx.qry.has_sha1 = 1;
         } else if (!strcmp(name, "id2")) {
                 ctx.qry.sha2 = xstrdup(value);
                 ctx.qry.has_sha1 = 1;
         } else if (!strcmp(name, "ofs")) {
                 ctx.qry.ofs = atoi(value);
         } else if (!strcmp(name, "path")) {
                 ctx.qry.path = trim_end(value, '/');
         } else if (!strcmp(name, "name")) {
                 ctx.qry.name = xstrdup(value);
         } else if (!strcmp(name, "mimetype")) {
                 ctx.qry.mimetype = xstrdup(value);
         }
 }
 
 static void prepare_context(struct cgit_context *ctx)
 {
         memset(ctx, 0, sizeof(ctx));
         ctx->cfg.agefile = "info/web/last-modified";
         ctx->cfg.nocache = 0;
         ctx->cfg.cache_size = 0;
         ctx->cfg.cache_dynamic_ttl = 5;
         ctx->cfg.cache_max_create_time = 5;
         ctx->cfg.cache_repo_ttl = 5;
         ctx->cfg.cache_root = CGIT_CACHE_ROOT;
         ctx->cfg.cache_root_ttl = 5;
         ctx->cfg.cache_static_ttl = -1;
         ctx->cfg.css = "/cgit.css";
         ctx->cfg.logo = "/git-logo.png";
         ctx->cfg.local_time = 0;
         ctx->cfg.max_repo_count = 50;
         ctx->cfg.max_commit_count = 50;
         ctx->cfg.max_lock_attempts = 5;
         ctx->cfg.max_msg_len = 80;
         ctx->cfg.max_repodesc_len = 80;
         ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s";
         ctx->cfg.renamelimit = -1;
         ctx->cfg.robots = "index, nofollow";
         ctx->cfg.root_title = "Git repository browser";
         ctx->cfg.root_desc = "a fast webinterface for the git dscm";
         ctx->cfg.script_name = CGIT_SCRIPT_NAME;
         ctx->cfg.summary_branches = 10;
         ctx->cfg.summary_log = 10;
         ctx->cfg.summary_tags = 10;
         ctx->page.mimetype = "text/html";
         ctx->page.charset = PAGE_ENCODING;
         ctx->page.filename = NULL;
         ctx->page.size = 0;
         ctx->page.modified = time(NULL);
         ctx->page.expires = ctx->page.modified;
 }
 
 struct refmatch {
         char *req_ref;
         char *first_ref;
         int match;
 };
 
 int find_current_ref(const char *refname, const unsigned char *sha1,
                      int flags, void *cb_data)
 {
         struct refmatch *info;
 
         info = (struct refmatch *)cb_data;
         if (!strcmp(refname, info->req_ref))
                 info->match = 1;
         if (!info->first_ref)
                 info->first_ref = xstrdup(refname);
         return info->match;
 }
 
 char *find_default_branch(struct cgit_repo *repo)
 {
         struct refmatch info;
         char *ref;
 
         info.req_ref = repo->defbranch;
         info.first_ref = NULL;
         info.match = 0;
         for_each_branch_ref(find_current_ref, &info);
         if (info.match)
                 ref = info.req_ref;
         else
                 ref = info.first_ref;
         if (ref)
                 ref = xstrdup(ref);
         return ref;
 }
 
 static int prepare_repo_cmd(struct cgit_context *ctx)
 {
         char *tmp;
         unsigned char sha1[20];
         int nongit = 0;
 
         setenv("GIT_DIR", ctx->repo->path, 1);
         setup_git_directory_gently(&nongit);
         if (nongit) {
                 ctx->page.title = fmt("%s - %s", ctx->cfg.root_title,
                                       "config error");
                 tmp = fmt("Not a git repository: '%s'", ctx->repo->path);
                 ctx->repo = NULL;
                 cgit_print_http_headers(ctx);
                 cgit_print_docstart(ctx);
                 cgit_print_pageheader(ctx);
                 cgit_print_error(tmp);
                 cgit_print_docend();
                 return 1;
         }
         ctx->page.title = fmt("%s - %s", ctx->repo->name, ctx->repo->desc);
 
         if (!ctx->qry.head) {
                 ctx->qry.nohead = 1;
                 ctx->qry.head = find_default_branch(ctx->repo);
                 ctx->repo->defbranch = ctx->qry.head;
         }
 
         if (!ctx->qry.head) {
                 cgit_print_http_headers(ctx);
                 cgit_print_docstart(ctx);
                 cgit_print_pageheader(ctx);
                 cgit_print_error("Repository seems to be empty");
                 cgit_print_docend();
                 return 1;
         }
 
         if (get_sha1(ctx->qry.head, sha1)) {
                 tmp = xstrdup(ctx->qry.head);
                 ctx->qry.head = ctx->repo->defbranch;
                 cgit_print_http_headers(ctx);
                 cgit_print_docstart(ctx);
                 cgit_print_pageheader(ctx);
                 cgit_print_error(fmt("Invalid branch: %s", tmp));
                 cgit_print_docend();
                 return 1;
         }
         return 0;
 }
 
 static void process_request(void *cbdata)
 {
         struct cgit_context *ctx = cbdata;
         struct cgit_cmd *cmd;
 
         cmd = cgit_get_cmd(ctx);
         if (!cmd) {
                 ctx->page.title = "cgit error";
-                ctx->repo = NULL;
                 cgit_print_http_headers(ctx);
                 cgit_print_docstart(ctx);
                 cgit_print_pageheader(ctx);
                 cgit_print_error("Invalid request");
                 cgit_print_docend();
                 return;
         }
 
         if (cmd->want_repo && !ctx->repo) {
                 cgit_print_http_headers(ctx);
                 cgit_print_docstart(ctx);
                 cgit_print_pageheader(ctx);
                 cgit_print_error(fmt("No repository selected"));
                 cgit_print_docend();
                 return;
         }
 
         if (ctx->repo && prepare_repo_cmd(ctx))
                 return;
 
         if (cmd->want_layout) {
                 cgit_print_http_headers(ctx);
                 cgit_print_docstart(ctx);
                 cgit_print_pageheader(ctx);
         }
 
         cmd->fn(ctx);
 
         if (cmd->want_layout)
                 cgit_print_docend();
 }
 
 int cmp_repos(const void *a, const void *b)
 {
         const struct cgit_repo *ra = a, *rb = b;
         return strcmp(ra->url, rb->url);
 }
 
 void print_repo(struct cgit_repo *repo)
 {
         printf("repo.url=%s\n", repo->url);
         printf("repo.name=%s\n", repo->name);
         printf("repo.path=%s\n", repo->path);
         if (repo->owner)
                 printf("repo.owner=%s\n", repo->owner);
         if (repo->desc)
                 printf("repo.desc=%s\n", repo->desc);
         if (repo->readme)
                 printf("repo.readme=%s\n", repo->readme);
         printf("\n");
 }
 
 void print_repolist(struct cgit_repolist *list)
 {
         int i;
 
         for(i = 0; i < list->count; i++)
                 print_repo(&list->repos[i]);
 }
 
 
 static void cgit_parse_args(int argc, const char **argv)
 {
         int i;
         int scan = 0;
 
         for (i = 1; i < argc; i++) {
                 if (!strncmp(argv[i], "--cache=", 8)) {
                         ctx.cfg.cache_root = xstrdup(argv[i]+8);
                 }
                 if (!strcmp(argv[i], "--nocache")) {
                         ctx.cfg.nocache = 1;
                 }
                 if (!strncmp(argv[i], "--query=", 8)) {
                         ctx.qry.raw = xstrdup(argv[i]+8);
                 }
                 if (!strncmp(argv[i], "--repo=", 7)) {
                         ctx.qry.repo = xstrdup(argv[i]+7);
                 }
                 if (!strncmp(argv[i], "--page=", 7)) {
                         ctx.qry.page = xstrdup(argv[i]+7);
                 }
                 if (!strncmp(argv[i], "--head=", 7)) {
                         ctx.qry.head = xstrdup(argv[i]+7);
                         ctx.qry.has_symref = 1;
                 }
                 if (!strncmp(argv[i], "--sha1=", 7)) {
                         ctx.qry.sha1 = xstrdup(argv[i]+7);
                         ctx.qry.has_sha1 = 1;
                 }
                 if (!strncmp(argv[i], "--ofs=", 6)) {
                         ctx.qry.ofs = atoi(argv[i]+6);
                 }
                 if (!strncmp(argv[i], "--scan-tree=", 12)) {
                         scan++;
                         scan_tree(argv[i] + 12);
                 }
         }
         if (scan) {
                 qsort(cgit_repolist.repos, cgit_repolist.count,
                         sizeof(struct cgit_repo), cmp_repos);
                 print_repolist(&cgit_repolist);
                 exit(0);
         }
 }
 
 static int calc_ttl()
 {
         if (!ctx.repo)
                 return ctx.cfg.cache_root_ttl;
 
         if (!ctx.qry.page)
                 return ctx.cfg.cache_repo_ttl;
 
         if (ctx.qry.has_symref)
                 return ctx.cfg.cache_dynamic_ttl;
 
         if (ctx.qry.has_sha1)
                 return ctx.cfg.cache_static_ttl;
 
         return ctx.cfg.cache_repo_ttl;
 }
 
 int main(int argc, const char **argv)
 {
         const char *cgit_config_env = getenv("CGIT_CONFIG");
         const char *path;
         char *qry;
         int err, ttl;
 
         prepare_context(&ctx);
         cgit_repolist.length = 0;
         cgit_repolist.count = 0;
         cgit_repolist.repos = NULL;
 
         if (getenv("SCRIPT_NAME"))
                 ctx.cfg.script_name = xstrdup(getenv("SCRIPT_NAME"));
         if (getenv("QUERY_STRING"))
                 ctx.qry.raw = xstrdup(getenv("QUERY_STRING"));
         cgit_parse_args(argc, argv);
         parse_configfile(cgit_config_env ? cgit_config_env : CGIT_CONFIG,
                          config_cb);
         ctx.repo = NULL;
         http_parse_querystring(ctx.qry.raw, querystring_cb);
 
         /* If virtual-root isn't specified in cgitrc and no url
          * parameter is specified on the querystring, lets pretend
          * that virtualroot equals SCRIPT_NAME and use PATH_INFO as
          * url. This allows cgit to work with virtual urls without
          * the need for rewriterules in the webserver (as long as
          * PATH_INFO is included in the cache lookup key).
          */
         if (!ctx.cfg.virtual_root && !ctx.qry.url) {
                 ctx.cfg.virtual_root = ctx.cfg.script_name;
                 path = getenv("PATH_INFO");
                 if (path) {
                         if (path[0] == '/')
                                 path++;
                         ctx.qry.url = xstrdup(path);
                         if (ctx.qry.raw) {
                                 qry = ctx.qry.raw;
                                 ctx.qry.raw = xstrdup(fmt("%s?%s", path, qry));
                                 free(qry);
                         } else
                                 ctx.qry.raw = ctx.qry.url;
                         cgit_parse_url(ctx.qry.url);
                 }
         }
 
         ttl = calc_ttl();
         ctx.page.expires += ttl*60;
         if (ctx.cfg.nocache)
                 ctx.cfg.cache_size = 0;
         err = cache_process(ctx.cfg.cache_size, ctx.cfg.cache_root,
                             ctx.qry.raw, ttl, process_request, &ctx);
         if (err)
                 cgit_print_error(fmt("Error processing page: %s (%d)",
                                      strerror(err), err));
         return err;
 }
diff --git a/ui-shared.c b/ui-shared.c
index 224e5f3..76cd00d 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -1,714 +1,719 @@
 /* ui-shared.c: common web output functions
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "cmd.h"
 #include "html.h"
 
 const char cgit_doctype[] =
 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
 "  \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
 
 static char *http_date(time_t t)
 {
         static char day[][4] =
                 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
         static char month[][4] =
                 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
                  "Jul", "Aug", "Sep", "Oct", "Now", "Dec"};
         struct tm *tm = gmtime(&t);
         return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday],
                    tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year,
                    tm->tm_hour, tm->tm_min, tm->tm_sec);
 }
 
 void cgit_print_error(char *msg)
 {
         html("<div class='error'>");
         html_txt(msg);
         html("</div>\n");
 }
 
 char *cgit_hosturl()
 {
         char *host, *port;
 
         host = getenv("HTTP_HOST");
         if (host) {
                 host = xstrdup(host);
         } else {
                 host = getenv("SERVER_NAME");
                 if (!host)
                         return NULL;
                 port = getenv("SERVER_PORT");
                 if (port && atoi(port) != 80)
                         host = xstrdup(fmt("%s:%d", host, atoi(port)));
                 else
                         host = xstrdup(host);
         }
         return host;
 }
 
 char *cgit_rooturl()
 {
         if (ctx.cfg.virtual_root)
                 return fmt("%s/", ctx.cfg.virtual_root);
         else
                 return ctx.cfg.script_name;
 }
 
 char *cgit_repourl(const char *reponame)
 {
         if (ctx.cfg.virtual_root) {
                 return fmt("%s/%s/", ctx.cfg.virtual_root, reponame);
         } else {
                 return fmt("?r=%s", reponame);
         }
 }
 
 char *cgit_fileurl(const char *reponame, const char *pagename,
                    const char *filename, const char *query)
 {
         char *tmp;
         char *delim;
 
         if (ctx.cfg.virtual_root) {
                 tmp = fmt("%s/%s/%s/%s", ctx.cfg.virtual_root, reponame,
                           pagename, (filename ? filename:""));
                 delim = "?";
         } else {
                 tmp = fmt("?url=%s/%s/%s", reponame, pagename,
                           (filename ? filename : ""));
                 delim = "&";
         }
         if (query)
                 tmp = fmt("%s%s%s", tmp, delim, query);
         return tmp;
 }
 
 char *cgit_pageurl(const char *reponame, const char *pagename,
                    const char *query)
 {
         return cgit_fileurl(reponame,pagename,0,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;
         strncpy(rvbuf,reponame,sizeof(rvbuf));
         if(rvbuf[sizeof(rvbuf)-1])
                 die("cgit_repobasename: truncated repository name '%s'", reponame);
         p = strlen(rvbuf)-1;
         /* strip trailing slashes */
         while(p && rvbuf[p]=='/') rvbuf[p--]=0;
         /* strip trailing .git */
         if(p>=3 && !strncmp(&rvbuf[p-3],".git",4)) {
                 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;
 }
 
 char *cgit_currurl()
 {
         if (!ctx.cfg.virtual_root)
                 return ctx.cfg.script_name;
         else if (ctx.qry.page)
                 return fmt("%s/%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo, ctx.qry.page);
         else if (ctx.qry.repo)
                 return fmt("%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo);
         else
                 return fmt("%s/", ctx.cfg.virtual_root);
 }
 
 static void site_url(char *page, char *search, int ofs)
 {
         char *delim = "?";
 
         if (ctx.cfg.virtual_root) {
                 html_attr(ctx.cfg.virtual_root);
                 if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/')
                         html("/");
         } else
                 html(ctx.cfg.script_name);
 
         if (page) {
                 htmlf("?p=%s", page);
                 delim = "&";
         }
         if (search) {
                 html(delim);
                 html("q=");
                 html_attr(search);
                 delim = "&";
         }
         if (ofs) {
                 html(delim);
                 htmlf("ofs=%d", ofs);
         }
 }
 
 static void site_link(char *page, char *name, char *title, char *class,
                       char *search, int ofs)
 {
         html("<a");
         if (title) {
                 html(" title='");
                 html_attr(title);
                 html("'");
         }
         if (class) {
                 html(" class='");
                 html_attr(class);
                 html("'");
         }
         html(" href='");
         site_url(page, search, ofs);
         html("'>");
         html_txt(name);
         html("</a>");
 }
 
 void cgit_index_link(char *name, char *title, char *class, char *pattern,
                      int ofs)
 {
         site_link(NULL, name, title, class, pattern, ofs);
 }
 
 static char *repolink(char *title, char *class, char *page, char *head,
                       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);
                 if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/')
                         html("/");
                 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(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 = "&amp;";
         }
         if (head && strcmp(head, ctx.repo->defbranch)) {
                 html(delim);
                 html("h=");
                 html_url_arg(head);
                 delim = "&amp;";
         }
         return fmt("%s", delim);
 }
 
 static void reporevlink(char *page, char *name, char *title, char *class,
                         char *head, char *rev, char *path)
 {
         char *delim;
 
         delim = repolink(title, class, page, head, path);
         if (rev && strcmp(rev, ctx.qry.head)) {
                 html(delim);
                 html("id=");
                 html_url_arg(rev);
         }
         html("'>");
         html_txt(name);
         html("</a>");
 }
 
 void cgit_summary_link(char *name, char *title, char *class, char *head)
 {
         reporevlink(NULL, name, title, class, head, NULL, NULL);
 }
 
 void cgit_tag_link(char *name, char *title, char *class, char *head,
                    char *rev)
 {
         reporevlink("tag", name, title, class, head, rev, NULL);
 }
 
 void cgit_tree_link(char *name, char *title, char *class, char *head,
                     char *rev, char *path)
 {
         reporevlink("tree", name, title, class, head, rev, path);
 }
 
 void cgit_plain_link(char *name, char *title, char *class, char *head,
                      char *rev, char *path)
 {
         reporevlink("plain", name, title, class, head, rev, path);
 }
 
 void cgit_log_link(char *name, char *title, char *class, char *head,
                    char *rev, char *path, int ofs, char *grep, char *pattern)
 {
         char *delim;
 
         delim = repolink(title, class, "log", head, path);
         if (rev && 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);
         }
         html("'>");
         html_txt(name);
         html("</a>");
 }
 
 void cgit_commit_link(char *name, char *title, char *class, char *head,
                       char *rev)
 {
         if (strlen(name) > ctx.cfg.max_msg_len && ctx.cfg.max_msg_len >= 15) {
                 name[ctx.cfg.max_msg_len] = '\0';
                 name[ctx.cfg.max_msg_len - 1] = '.';
                 name[ctx.cfg.max_msg_len - 2] = '.';
                 name[ctx.cfg.max_msg_len - 3] = '.';
         }
         reporevlink("commit", name, title, class, head, rev, NULL);
 }
 
 void cgit_refs_link(char *name, char *title, char *class, char *head,
                     char *rev, char *path)
 {
         reporevlink("refs", name, title, class, head, rev, path);
 }
 
 void cgit_snapshot_link(char *name, char *title, char *class, char *head,
                         char *rev, char *archivename)
 {
         reporevlink("snapshot", name, title, class, head, rev, archivename);
 }
 
 void cgit_diff_link(char *name, char *title, char *class, char *head,
                     char *new_rev, char *old_rev, char *path)
 {
         char *delim;
 
         delim = repolink(title, class, "diff", head, path);
         if (new_rev && strcmp(new_rev, ctx.qry.head)) {
                 html(delim);
                 html("id=");
                 html_url_arg(new_rev);
                 delim = "&amp;";
         }
         if (old_rev) {
                 html(delim);
                 html("id2=");
                 html_url_arg(old_rev);
         }
         html("'>");
         html_txt(name);
         html("</a>");
 }
 
 void cgit_patch_link(char *name, char *title, char *class, char *head,
                      char *rev)
 {
         reporevlink("patch", name, title, class, head, rev, NULL);
 }
 
 void cgit_object_link(struct object *obj)
 {
         char *page, *rev, *name;
 
         if (obj->type == OBJ_COMMIT) {
                 cgit_commit_link(fmt("commit %s", sha1_to_hex(obj->sha1)), NULL, NULL,
                                  ctx.qry.head, sha1_to_hex(obj->sha1));
                 return;
         } else if (obj->type == OBJ_TREE)
                 page = "tree";
         else if (obj->type == OBJ_TAG)
                 page = "tag";
         else
                 page = "blob";
         rev = sha1_to_hex(obj->sha1);
         name = fmt("%s %s", typename(obj->type), rev);
         reporevlink(page, name, NULL, NULL, ctx.qry.head, rev, NULL);
 }
 
 void cgit_print_date(time_t secs, char *format, int local_time)
 {
         char buf[64];
         struct tm *time;
 
         if (!secs)
                 return;
         if(local_time)
                 time = localtime(&secs);
         else
                 time = gmtime(&secs);
         strftime(buf, sizeof(buf)-1, format, time);
         html_txt(buf);
 }
 
 void cgit_print_age(time_t t, time_t max_relative, char *format)
 {
         time_t now, secs;
 
         if (!t)
                 return;
         time(&now);
         secs = now - t;
 
         if (secs > max_relative && max_relative >= 0) {
                 cgit_print_date(t, format, ctx.cfg.local_time);
                 return;
         }
 
         if (secs < TM_HOUR * 2) {
                 htmlf("<span class='age-mins'>%.0f min.</span>",
                       secs * 1.0 / TM_MIN);
                 return;
         }
         if (secs < TM_DAY * 2) {
                 htmlf("<span class='age-hours'>%.0f hours</span>",
                       secs * 1.0 / TM_HOUR);
                 return;
         }
         if (secs < TM_WEEK * 2) {
                 htmlf("<span class='age-days'>%.0f days</span>",
                       secs * 1.0 / TM_DAY);
                 return;
         }
         if (secs < TM_MONTH * 2) {
                 htmlf("<span class='age-weeks'>%.0f weeks</span>",
                       secs * 1.0 / TM_WEEK);
                 return;
         }
         if (secs < TM_YEAR * 2) {
                 htmlf("<span class='age-months'>%.0f months</span>",
                       secs * 1.0 / TM_MONTH);
                 return;
         }
         htmlf("<span class='age-years'>%.0f years</span>",
               secs * 1.0 / TM_YEAR);
 }
 
 void cgit_print_http_headers(struct cgit_context *ctx)
 {
         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: %ld\n", ctx->page.size);
         if (ctx->page.filename)
                 htmlf("Content-Disposition: inline; filename=\"%s\"\n",
                       ctx->page.filename);
         htmlf("Last-Modified: %s\n", http_date(ctx->page.modified));
         htmlf("Expires: %s\n", http_date(ctx->page.expires));
         html("\n");
 }
 
 void cgit_print_docstart(struct cgit_context *ctx)
 {
         char *host = cgit_hosturl();
         html(cgit_doctype);
         html("<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en' 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);
         html("<link rel='stylesheet' type='text/css' href='");
         html_attr(ctx->cfg.css);
         html("'/>\n");
         if (ctx->cfg.favicon) {
                 html("<link rel='shortcut icon' href='");
                 html_attr(ctx->cfg.favicon);
                 html("'/>\n");
         }
         if (host && ctx->repo) {
                 html("<link rel='alternate' title='Atom feed' href='http://");
                 html_attr(cgit_hosturl());
                 html_attr(cgit_fileurl(ctx->repo->url, "atom", ctx->qry.path,
                                        fmt("h=%s", ctx->qry.head)));
                 html("' type='application/atom+xml'/>");
         }
         html("</head>\n");
         html("<body>\n");
 }
 
 void cgit_print_docend()
 {
         html("</div>");
         if (ctx.cfg.footer)
                 html_include(ctx.cfg.footer);
         else {
                 htmlf("<div class='footer'>generated  by cgit %s at ",
                         cgit_version);
                 cgit_print_date(time(NULL), FMT_LONGDATE, ctx.cfg.local_time);
                 html("</div>\n");
         }
         html("</body>\n</html>\n");
 }
 
 int print_branch_option(const char *refname, const unsigned char *sha1,
                         int flags, void *cb_data)
 {
         char *name = (char *)refname;
         html_option(name, name, ctx.qry.head);
         return 0;
 }
 
 int print_archive_ref(const char *refname, const unsigned char *sha1,
                        int flags, void *cb_data)
 {
         struct tag *tag;
         struct taginfo *info;
         struct object *obj;
         char buf[256], *url;
         unsigned char fileid[20];
         int *header = (int *)cb_data;
 
         if (prefixcmp(refname, "refs/archives"))
                 return 0;
         strncpy(buf, refname+14, sizeof(buf));
         obj = parse_object(sha1);
         if (!obj)
                 return 1;
         if (obj->type == OBJ_TAG) {
                 tag = lookup_tag(sha1);
                 if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag)))
                         return 0;
                 hashcpy(fileid, tag->tagged->sha1);
         } else if (obj->type != OBJ_BLOB) {
                 return 0;
         } else {
                 hashcpy(fileid, sha1);
         }
         if (!*header) {
                 html("<h1>download</h1>\n");
                 *header = 1;
         }
         url = cgit_pageurl(ctx.qry.repo, "blob",
                            fmt("id=%s&amp;path=%s", sha1_to_hex(fileid),
                                buf));
         html_link_open(url, NULL, "menu");
         html_txt(strlpart(buf, 20));
         html_link_close();
         return 0;
 }
 
 void add_hidden_formfields(int incl_head, int incl_search, char *page)
 {
         char *url;
 
         if (!ctx.cfg.virtual_root) {
                 url = fmt("%s/%s", ctx.qry.repo, page);
                 if (ctx.qry.path)
                         url = fmt("%s/%s", url, ctx.qry.path);
                 html_hidden("url", url);
         }
 
         if (incl_head && ctx.qry.head && ctx.repo->defbranch &&
             strcmp(ctx.qry.head, ctx.repo->defbranch))
                 html_hidden("h", ctx.qry.head);
 
         if (ctx.qry.sha1)
                 html_hidden("id", ctx.qry.sha1);
         if (ctx.qry.sha2)
                 html_hidden("id2", ctx.qry.sha2);
 
         if (incl_search) {
                 if (ctx.qry.grep)
                         html_hidden("qt", ctx.qry.grep);
                 if (ctx.qry.search)
                         html_hidden("q", ctx.qry.search);
         }
 }
 
+const char *fallback_cmd = "repolist";
+
 char *hc(struct cgit_cmd *cmd, const char *page)
 {
-        return (strcmp(cmd->name, page) ? NULL : "active");
+        return (strcmp(cmd ? cmd->name : fallback_cmd, page) ? NULL : "active");
 }
 
 void cgit_print_pageheader(struct cgit_context *ctx)
 {
         struct cgit_cmd *cmd = cgit_get_cmd(ctx);
 
+        if (!cmd && ctx->repo)
+                fallback_cmd = "summary";
+
         html("<table id='header'>\n");
         html("<tr>\n");
         html("<td class='logo' rowspan='2'><a href='");
         if (ctx->cfg.logo_link)
                 html_attr(ctx->cfg.logo_link);
         else
                 html_attr(cgit_rooturl());
         html("'><img src='");
         html_attr(ctx->cfg.logo);
         html("' alt='cgit logo'/></a></td>\n");
 
         html("<td class='main'>");
         if (ctx->repo) {
                 cgit_index_link("index", NULL, NULL, NULL, 0);
                 html(" : ");
                 cgit_summary_link(ctx->repo->name, ctx->repo->name, NULL, NULL);
                 html("</td><td class='form'>");
                 html("<form method='get' action=''>\n");
                 add_hidden_formfields(0, 1, ctx->qry.page);
                 html("<select name='h' onchange='this.form.submit();'>\n");
                 for_each_branch_ref(print_branch_option, ctx->qry.head);
                 html("</select> ");
                 html("<input type='submit' name='' 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'>");
                 html_txt(ctx->repo->owner);
         } else {
                 if (ctx->cfg.root_desc)
                         html_txt(ctx->cfg.root_desc);
                 else if (ctx->cfg.index_info)
                         html_include(ctx->cfg.index_info);
         }
         html("</td></tr></table>\n");
 
         html("<table class='tabs'><tr><td>\n");
         if (ctx->repo) {
                 cgit_summary_link("summary", NULL, hc(cmd, "summary"),
                                   ctx->qry.head);
                 cgit_refs_link("refs", NULL, hc(cmd, "refs"), ctx->qry.head,
                                ctx->qry.sha1, NULL);
                 cgit_log_link("log", NULL, hc(cmd, "log"), ctx->qry.head,
                               NULL, NULL, 0, NULL, NULL);
                 cgit_tree_link("tree", NULL, hc(cmd, "tree"), ctx->qry.head,
                                ctx->qry.sha1, NULL);
                 cgit_commit_link("commit", NULL, hc(cmd, "commit"),
                                  ctx->qry.head, ctx->qry.sha1);
                 cgit_diff_link("diff", NULL, hc(cmd, "diff"), ctx->qry.head,
                                ctx->qry.sha1, ctx->qry.sha2, NULL);
                 if (ctx->repo->readme)
                         reporevlink("about", "about", NULL,
                                     hc(cmd, "about"), ctx->qry.head, NULL,
                                     NULL);
                 html("</td><td class='form'>");
                 html("<form class='right' method='get' action='");
                 if (ctx->cfg.virtual_root)
                         html_url_path(cgit_fileurl(ctx->qry.repo, "log",
                                                    ctx->qry.path, NULL));
                 html("'>\n");
                 add_hidden_formfields(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("</select>\n");
                 html("<input class='txt' type='text' size='10' name='q' value='");
                 html_attr(ctx->qry.search);
                 html("'/>\n");
                 html("<input type='submit' value='search'/>\n");
                 html("</form>\n");
         } else {
                 site_link(NULL, "index", NULL, hc(cmd, "repolist"), NULL, 0);
                 if (ctx->cfg.root_readme)
                         site_link("about", "about", NULL, hc(cmd, "about"),
                                   NULL, 0);
                 html("</td><td class='form'>");
                 html("<form method='get' action='");
                 html_attr(cgit_rooturl());
                 html("'>\n");
                 html("<input type='text' name='q' size='10' value='");
                 html_attr(ctx->qry.search);
                 html("'/>\n");
                 html("<input type='submit' value='search'/>\n");
                 html("</form>");
         }
         html("</td></tr></table>\n");
         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_print_snapshot_links(const char *repo, const char *head,
                                const char *hex, int snapshots)
 {
         const struct cgit_snapshot_format* f;
             char *filename;
 
         for (f = cgit_snapshot_formats; f->suffix; f++) {
                 if (!(snapshots & f->bit))
                         continue;
                 filename = fmt("%s-%s%s", cgit_repobasename(repo), hex,
                                f->suffix);
                 cgit_snapshot_link(filename, NULL, NULL, (char *)head,
                                    (char *)hex, filename);
                 html("<br/>");
         }
 }