43 files changed, 2117 insertions, 408 deletions
diff --git a/Makefile b/Makefile
index 304521e..14b4df4 100644
--- a/Makefile
+++ b/Makefile
@@ -1,171 +1,244 @@
 CGIT_VERSION = v0.8.3.5
 CGIT_SCRIPT_NAME = cgit.cgi
 CGIT_SCRIPT_PATH = /var/www/htdocs/cgit
 CGIT_DATA_PATH = $(CGIT_SCRIPT_PATH)
 CGIT_CONFIG = /etc/cgitrc
 CACHE_ROOT = /var/cache/cgit
+prefix = /usr
+libdir = $(prefix)/lib
+filterdir = $(libdir)/cgit/filters
+docdir = $(prefix)/share/doc/cgit
+htmldir = $(docdir)
+pdfdir = $(docdir)
+mandir = $(prefix)/share/man
 SHA1_HEADER = <openssl/sha.h>
-GIT_VER = 1.7.3
+GIT_VER = 1.7.4
 GIT_URL = http://www.kernel.org/pub/software/scm/git/git-$(GIT_VER).tar.bz2
 INSTALL = install
+MAN5_TXT = $(wildcard *.5.txt)
+MAN_TXT  = $(MAN5_TXT)
+DOC_MAN5 = $(patsubst %.txt,%,$(MAN5_TXT))
+DOC_HTML = $(patsubst %.txt,%.html,$(MAN_TXT))
+DOC_PDF  = $(patsubst %.txt,%.pdf,$(MAN_TXT))
 # Define NO_STRCASESTR if you don't have strcasestr.
 #
+# Define NO_OPENSSL to disable linking with OpenSSL and use bundled SHA1
+# implementation (slower).
+#
 # Define NEEDS_LIBICONV if linking with libc is not enough (eg. Darwin).
 #
+# Define NO_C99_FORMAT if your formatted IO functions (printf/scanf et.al.)
+# do not support the 'size specifiers' introduced by C99, namely ll, hh,
+# j, z, t. (representing long long int, char, intmax_t, size_t, ptrdiff_t).
+# some C compilers supported these specifiers prior to C99 as an extension.
+#
 #-include config.mak
 #
 # Platform specific tweaks
 #
 uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
 uname_O := $(shell sh -c 'uname -o 2>/dev/null || echo not')
 uname_R := $(shell sh -c 'uname -r 2>/dev/null || echo not')
 ifeq ($(uname_O),Cygwin)
        NO_STRCASESTR = YesPlease
        NEEDS_LIBICONV = YesPlease
 endif
 #
 # Let the user override the above settings.
 #
 -include cgit.conf
 #
 # Define a way to invoke make in subdirs quietly, shamelessly ripped
 # from git.git
 #
 QUIET_SUBDIR0  = +$(MAKE) -C # space to separate -C and subdir
 QUIET_SUBDIR1  =
 ifneq ($(findstring $(MAKEFLAGS),w),w)
 PRINT_DIR = --no-print-directory
 else # "make -w"
 NO_SUBDIR = :
 endif
 ifndef V
        QUIET_CC       = @echo '   ' CC $@;
        QUIET_MM       = @echo '   ' MM $@;
        QUIET_SUBDIR0  = +@subdir=
        QUIET_SUBDIR1  = ;$(NO_SUBDIR) echo '   ' SUBDIR $$subdir; \
                         $(MAKE) $(PRINT_DIR) -C $$subdir
 endif
 #
 # Define a pattern rule for automatic dependency building
 #
 %.d: %.c
-        $(QUIET_MM)$(CC) $(CFLAGS) -MM $< | sed -e 's/\($*\)\.o:/\1.o $@:/g' >$@
+        $(QUIET_MM)$(CC) $(CFLAGS) -MM -MP $< | sed -e 's/\($*\)\.o:/\1.o $@:/g' >$@
 #
 # Define a pattern rule for silent object building
 #
 %.o: %.c
        $(QUIET_CC)$(CC) -o $*.o -c $(CFLAGS) $<
-EXTLIBS = git/libgit.a git/xdiff/lib.a -lz -lcrypto -lpthread
+EXTLIBS = git/libgit.a git/xdiff/lib.a -lz -lpthread
 OBJECTS =
 OBJECTS += cache.o
 OBJECTS += cgit.o
 OBJECTS += cmd.o
 OBJECTS += configfile.o
 OBJECTS += html.o
 OBJECTS += parsing.o
 OBJECTS += scan-tree.o
 OBJECTS += shared.o
 OBJECTS += ui-atom.o
 OBJECTS += ui-blob.o
 OBJECTS += ui-clone.o
 OBJECTS += ui-commit.o
 OBJECTS += ui-diff.o
 OBJECTS += ui-log.o
 OBJECTS += ui-patch.o
 OBJECTS += ui-plain.o
 OBJECTS += ui-refs.o
 OBJECTS += ui-repolist.o
 OBJECTS += ui-shared.o
 OBJECTS += ui-snapshot.o
+OBJECTS += ui-ssdiff.o
 OBJECTS += ui-stats.o
 OBJECTS += ui-summary.o
 OBJECTS += ui-tag.o
 OBJECTS += ui-tree.o
+OBJECTS += vector.o
 ifdef NEEDS_LIBICONV
        EXTLIBS += -liconv
 endif
 .PHONY: all libgit test install uninstall clean force-version get-git \
-        doc man-doc html-doc clean-doc
+        doc clean-doc install-doc install-man install-html install-pdf \
+        uninstall-doc uninstall-man uninstall-html uninstall-pdf
 all: cgit
 VERSION: force-version
        @./gen-version.sh "$(CGIT_VERSION)"
 -include VERSION
 CFLAGS += -g -Wall -Igit
 CFLAGS += -DSHA1_HEADER='$(SHA1_HEADER)'
 CFLAGS += -DCGIT_VERSION='"$(CGIT_VERSION)"'
 CFLAGS += -DCGIT_CONFIG='"$(CGIT_CONFIG)"'
 CFLAGS += -DCGIT_SCRIPT_NAME='"$(CGIT_SCRIPT_NAME)"'
 CFLAGS += -DCGIT_CACHE_ROOT='"$(CACHE_ROOT)"'
+GIT_OPTIONS = prefix=/usr
 ifdef NO_ICONV
        CFLAGS += -DNO_ICONV
 endif
 ifdef NO_STRCASESTR
        CFLAGS += -DNO_STRCASESTR
 endif
+ifdef NO_C99_FORMAT
+        CFLAGS += -DNO_C99_FORMAT
+endif
+ifdef NO_OPENSSL
+        CFLAGS += -DNO_OPENSSL
+        GIT_OPTIONS += NO_OPENSSL=1
+else
+        EXTLIBS += -lcrypto
+endif
 cgit: $(OBJECTS) libgit
        $(QUIET_CC)$(CC) $(CFLAGS) $(LDFLAGS) -o cgit $(OBJECTS) $(EXTLIBS)
 cgit.o: VERSION
-include $(OBJECTS:.o=.d)
+ifneq "$(MAKECMDGOALS)" "clean"
+  -include $(OBJECTS:.o=.d)
+endif
 libgit:
-        $(QUIET_SUBDIR0)git $(QUIET_SUBDIR1) NO_CURL=1 libgit.a
+        $(QUIET_SUBDIR0)git $(QUIET_SUBDIR1) NO_CURL=1 $(GIT_OPTIONS) libgit.a
-        $(QUIET_SUBDIR0)git $(QUIET_SUBDIR1) NO_CURL=1 xdiff/lib.a
+        $(QUIET_SUBDIR0)git $(QUIET_SUBDIR1) NO_CURL=1 $(GIT_OPTIONS) xdiff/lib.a
 test: all
        $(QUIET_SUBDIR0)tests $(QUIET_SUBDIR1) all
 install: all
        $(INSTALL) -m 0755 -d $(DESTDIR)$(CGIT_SCRIPT_PATH)
        $(INSTALL) -m 0755 cgit $(DESTDIR)$(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME)
        $(INSTALL) -m 0755 -d $(DESTDIR)$(CGIT_DATA_PATH)
        $(INSTALL) -m 0644 cgit.css $(DESTDIR)$(CGIT_DATA_PATH)/cgit.css
        $(INSTALL) -m 0644 cgit.png $(DESTDIR)$(CGIT_DATA_PATH)/cgit.png
+        $(INSTALL) -m 0755 -d $(DESTDIR)$(filterdir)
+        $(INSTALL) -m 0755 filters/* $(DESTDIR)$(filterdir)
+install-doc: install-man install-html install-pdf
+install-man: doc-man
+        $(INSTALL) -m 0755 -d $(DESTDIR)$(mandir)/man5
+        $(INSTALL) -m 0644 $(DOC_MAN5) $(DESTDIR)$(mandir)/man5
+install-html: doc-html
+        $(INSTALL) -m 0755 -d $(DESTDIR)$(htmldir)
+        $(INSTALL) -m 0644 $(DOC_HTML) $(DESTDIR)$(htmldir)
+install-pdf: doc-pdf
+        $(INSTALL) -m 0755 -d $(DESTDIR)$(pdfdir)
+        $(INSTALL) -m 0644 $(DOC_PDF) $(DESTDIR)$(pdfdir)
 uninstall:
        rm -f $(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME)
        rm -f $(CGIT_DATA_PATH)/cgit.css
        rm -f $(CGIT_DATA_PATH)/cgit.png
-doc: man-doc html-doc pdf-doc
+uninstall-doc: uninstall-man uninstall-html uninstall-pdf
+uninstall-man:
+        @for i in $(DOC_MAN5); do \
+            rm -fv $(DESTDIR)$(mandir)/man5/$$i; \
+        done
+uninstall-html:
+        @for i in $(DOC_HTML); do \
+            rm -fv $(DESTDIR)$(htmldir)/$$i; \
+        done
+uninstall-pdf:
+        @for i in $(DOC_PDF); do \
+            rm -fv $(DESTDIR)$(pdfdir)/$$i; \
+        done
+doc: doc-man doc-html doc-pdf
+doc-man: doc-man5
+doc-man5: $(DOC_MAN5)
+doc-html: $(DOC_HTML)
+doc-pdf: $(DOC_PDF)
-man-doc: cgitrc.5.txt
+%.5 : %.5.txt
-        a2x -f manpage cgitrc.5.txt
+        a2x -f manpage $<
-html-doc: cgitrc.5.txt
+$(DOC_HTML): %.html : %.txt
-        a2x -f xhtml --stylesheet=cgit-doc.css cgitrc.5.txt
+        a2x -f xhtml --stylesheet=cgit-doc.css $<
-pdf-doc: cgitrc.5.txt
+$(DOC_PDF): %.pdf : %.txt
        a2x -f pdf cgitrc.5.txt
 clean: clean-doc
        rm -f cgit VERSION *.o *.d
 clean-doc:
        rm -f cgitrc.5 cgitrc.5.html cgitrc.5.pdf cgitrc.5.xml cgitrc.5.fo
 get-git:
        curl $(GIT_URL) | tar -xjf - && rm -rf git && mv git-$(GIT_VER) git
diff --git a/README b/README
index 73ec332..050e21e 100644
--- a/README
+++ b/README
@@ -28,49 +28,49 @@ When either a) or b) has been performed, you can build and install cgit like
 this:
  $ make
  $ sudo make install
 This will install cgit.cgi and cgit.css into "/var/www/htdocs/cgit". You can
 configure this location (and a few other things) by providing a "cgit.conf"
 file (see the Makefile for details).
 Dependencies:
  -git 1.5.3
  -zip lib
  -crypto lib
  -openssl lib
 Apache configuration
 A new Directory-section must probably be added for cgit, possibly something
 like this:
  <Directory "/var/www/htdocs/cgit/">
      AllowOverride None
-      Options ExecCGI
+      Options +ExecCGI
      Order allow,deny
      Allow from all
  </Directory>
 Runtime configuration
 The file /etc/cgitrc is read by cgit before handling a request. In addition
 to runtime parameters, this file also contains a list of the repositories
 displayed by cgit.
 A template cgitrc is shipped with the sources, and all parameters and default
 values are documented in this file.
 The cache
 When cgit is invoked it looks for a cachefile matching the request and
 returns it to the client. If no such cachefile exist (or if it has expired),
 the content for the request is written into the proper cachefile before the
 file is returned.
 If the cachefile has expired but cgit is unable to obtain a lock for it, the
 stale cachefile is returned to the client. This is done to favour page
diff --git a/cache.h b/cache.h
index ac9276b..5cfdb4f 100644
--- a/cache.h
+++ b/cache.h
@@ -9,29 +9,30 @@
 typedef void (*cache_fill_fn)(void *cbdata);
 /* Print cached content to stdout, generate the content if necessary.
 *
 * Parameters
 *   size    max number of cache files
 *   path    directory used to store cache files
 *   key     the key used to lookup cache files
 *   ttl     max cache time in seconds for this key
 *   fn      content generator function for this key
 *   cbdata  user-supplied data to the content generator function
 *
 * Return value
 *   0 indicates success, everyting else is an error
 */
 extern int cache_process(int size, const char *path, const char *key, int ttl,
                         cache_fill_fn fn, void *cbdata);
 /* List info about all cache entries on stdout */
 extern int cache_ls(const char *path);
 /* Print a message to stdout */
+__attribute__((format (printf,1,2)))
 extern void cache_log(const char *format, ...);
 extern unsigned long hash_str(const char *str);
 #endif /* CGIT_CACHE_H */
diff --git a/cgit.c b/cgit.c
index af9832f..f4dd6ef 100644
--- a/cgit.c
+++ b/cgit.c
@@ -1,27 +1,28 @@
 /* cgit.c: cgi for the git scm
 *
 * Copyright (C) 2006 Lars Hjemli
+ * Copyright (C) 2010 Jason A. Donenfeld <Jason@zx2c4.com>
 *
 * 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 "ui-stats.h"
 #include "scan-tree.h"
 const char *cgit_version = CGIT_VERSION;
 void add_mimetype(const char *name, const char *value)
 {
        struct string_list_item *item;
        item = string_list_insert(&ctx.cfg.mimetypes, xstrdup(name));
        item->util = xstrdup(value);
 }
@@ -35,271 +36,324 @@ struct cgit_filter *new_filter(const char *cmd, int extra_args)
        f = xmalloc(sizeof(struct cgit_filter));
        f->cmd = xstrdup(cmd);
        f->argv = xmalloc((2 + extra_args) * sizeof(char *));
        f->argv[0] = f->cmd;
        f->argv[1] = NULL;
        return f;
 }
 static void process_cached_repolist(const char *path);
 void repo_config(struct cgit_repo *repo, const char *name, const char *value)
 {
        if (!strcmp(name, "name"))
                repo->name = xstrdup(value);
        else if (!strcmp(name, "clone-url"))
                repo->clone_url = xstrdup(value);
        else if (!strcmp(name, "desc"))
                repo->desc = xstrdup(value);
        else if (!strcmp(name, "owner"))
                repo->owner = xstrdup(value);
        else if (!strcmp(name, "defbranch"))
                repo->defbranch = xstrdup(value);
        else if (!strcmp(name, "snapshots"))
                repo->snapshots = ctx.cfg.snapshots & cgit_parse_snapshots_mask(value);
+        else if (!strcmp(name, "enable-commit-graph"))
+                repo->enable_commit_graph = ctx.cfg.enable_commit_graph * atoi(value);
        else if (!strcmp(name, "enable-log-filecount"))
                repo->enable_log_filecount = ctx.cfg.enable_log_filecount * atoi(value);
        else if (!strcmp(name, "enable-log-linecount"))
                repo->enable_log_linecount = ctx.cfg.enable_log_linecount * atoi(value);
+        else if (!strcmp(name, "enable-remote-branches"))
+                repo->enable_remote_branches = atoi(value);
+        else if (!strcmp(name, "enable-subject-links"))
+                repo->enable_subject_links = atoi(value);
        else if (!strcmp(name, "max-stats"))
                repo->max_stats = cgit_find_stats_period(value, NULL);
        else if (!strcmp(name, "module-link"))
                repo->module_link= xstrdup(value);
        else if (!strcmp(name, "section"))
                repo->section = xstrdup(value);
-        else if (!strcmp(name, "readme") && value != NULL) {
+        else if (!strcmp(name, "readme") && value != NULL)
-                if (*value == '/')
+                repo->readme = xstrdup(value);
-                        repo->readme = xstrdup(value);
+        else if (!strcmp(name, "logo") && value != NULL)
-                else
+                repo->logo = xstrdup(value);
-                        repo->readme = xstrdup(fmt("%s/%s", repo->path, value));
+        else if (!strcmp(name, "logo-link") && value != NULL)
-        } else if (ctx.cfg.enable_filter_overrides) {
+                repo->logo_link = xstrdup(value);
+        else if (ctx.cfg.enable_filter_overrides) {
                if (!strcmp(name, "about-filter"))
                        repo->about_filter = new_filter(value, 0);
                else if (!strcmp(name, "commit-filter"))
                        repo->commit_filter = new_filter(value, 0);
                else if (!strcmp(name, "source-filter"))
                        repo->source_filter = new_filter(value, 1);
        }
 }
 void config_cb(const char *name, const char *value)
 {
        if (!strcmp(name, "section") || !strcmp(name, "repo.group"))
                ctx.cfg.section = xstrdup(value);
        else if (!strcmp(name, "repo.url"))
                ctx.repo = cgit_add_repo(value);
        else if (ctx.repo && !strcmp(name, "repo.path"))
                ctx.repo->path = trim_end(value, '/');
        else if (ctx.repo && !prefixcmp(name, "repo."))
                repo_config(ctx.repo, name + 5, value);
+        else if (!strcmp(name, "readme"))
+                ctx.cfg.readme = xstrdup(value);
        else 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, "head-include"))
                ctx.cfg.head_include = xstrdup(value);
        else if (!strcmp(name, "header"))
                ctx.cfg.header = 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, "strict-export"))
+                ctx.cfg.strict_export = 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, "noplainemail"))
                ctx.cfg.noplainemail = atoi(value);
        else if (!strcmp(name, "noheader"))
                ctx.cfg.noheader = atoi(value);
        else if (!strcmp(name, "snapshots"))
                ctx.cfg.snapshots = cgit_parse_snapshots_mask(value);
        else if (!strcmp(name, "enable-filter-overrides"))
                ctx.cfg.enable_filter_overrides = atoi(value);
+        else if (!strcmp(name, "enable-gitweb-owner"))
+                ctx.cfg.enable_gitweb_owner = atoi(value);
        else if (!strcmp(name, "enable-index-links"))
                ctx.cfg.enable_index_links = atoi(value);
+        else if (!strcmp(name, "enable-commit-graph"))
+                ctx.cfg.enable_commit_graph = 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, "enable-remote-branches"))
+                ctx.cfg.enable_remote_branches = atoi(value);
+        else if (!strcmp(name, "enable-subject-links"))
+                ctx.cfg.enable_subject_links = atoi(value);
        else if (!strcmp(name, "enable-tree-linenumbers"))
                ctx.cfg.enable_tree_linenumbers = atoi(value);
        else if (!strcmp(name, "max-stats"))
                ctx.cfg.max_stats = cgit_find_stats_period(value, NULL);
        else if (!strcmp(name, "cache-size"))
                ctx.cfg.cache_size = atoi(value);
        else if (!strcmp(name, "cache-root"))
-                ctx.cfg.cache_root = xstrdup(value);
+                ctx.cfg.cache_root = xstrdup(expand_macros(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-scanrc-ttl"))
                ctx.cfg.cache_scanrc_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, "about-filter"))
                ctx.cfg.about_filter = new_filter(value, 0);
        else if (!strcmp(name, "commit-filter"))
                ctx.cfg.commit_filter = new_filter(value, 0);
        else if (!strcmp(name, "embedded"))
                ctx.cfg.embedded = atoi(value);
+        else if (!strcmp(name, "max-atom-items"))
+                ctx.cfg.max_atom_items = 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-blob-size"))
+                ctx.cfg.max_blob_size = 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, "project-list"))
+                ctx.cfg.project_list = xstrdup(expand_macros(value));
        else if (!strcmp(name, "scan-path"))
                if (!ctx.cfg.nocache && ctx.cfg.cache_size)
-                        process_cached_repolist(value);
+                        process_cached_repolist(expand_macros(value));
+                else if (ctx.cfg.project_list)
+                        scan_projects(expand_macros(value),
+                                      ctx.cfg.project_list, repo_config);
                else
-                        scan_tree(value, repo_config);
+                        scan_tree(expand_macros(value), repo_config);
+        else if (!strcmp(name, "scan-hidden-path"))
+                ctx.cfg.scan_hidden_path = atoi(value);
+        else if (!strcmp(name, "section-from-path"))
+                ctx.cfg.section_from_path = atoi(value);
        else if (!strcmp(name, "source-filter"))
                ctx.cfg.source_filter = new_filter(value, 1);
        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, "side-by-side-diffs"))
+                ctx.cfg.ssdiff = 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, "remove-suffix"))
+                ctx.cfg.remove_suffix = 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 (!prefixcmp(name, "mimetype."))
                add_mimetype(name + 9, value);
        else if (!strcmp(name, "include"))
-                parse_configfile(value, config_cb);
+                parse_configfile(expand_macros(value), config_cb);
 }
 static void querystring_cb(const char *name, const char *value)
 {
        if (!value)
                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")) {
+                if (*value == '/')
+                        value++;
                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);
        } else if (!strcmp(name, "s")){
                ctx.qry.sort = xstrdup(value);
        } else if (!strcmp(name, "showmsg")) {
                ctx.qry.showmsg = atoi(value);
        } else if (!strcmp(name, "period")) {
                ctx.qry.period = xstrdup(value);
+        } else if (!strcmp(name, "ss")) {
+                ctx.qry.ssdiff = atoi(value);
+        } else if (!strcmp(name, "all")) {
+                ctx.qry.show_all = atoi(value);
+        } else if (!strcmp(name, "context")) {
+                ctx.qry.context = atoi(value);
+        } else if (!strcmp(name, "ignorews")) {
+                ctx.qry.ignorews = atoi(value);
        }
 }
 char *xstrdupn(const char *str)
 {
        return (str ? xstrdup(str) : NULL);
 }
 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_scanrc_ttl = 15;
        ctx->cfg.cache_static_ttl = -1;
        ctx->cfg.css = "/cgit.css";
        ctx->cfg.logo = "/cgit.png";
        ctx->cfg.local_time = 0;
+        ctx->cfg.enable_gitweb_owner = 1;
        ctx->cfg.enable_tree_linenumbers = 1;
        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.max_blob_size = 0;
        ctx->cfg.max_stats = 0;
        ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s";
+        ctx->cfg.project_list = NULL;
        ctx->cfg.renamelimit = -1;
+        ctx->cfg.remove_suffix = 0;
        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.scan_hidden_path = 0;
        ctx->cfg.script_name = CGIT_SCRIPT_NAME;
        ctx->cfg.section = "";
        ctx->cfg.summary_branches = 10;
        ctx->cfg.summary_log = 10;
        ctx->cfg.summary_tags = 10;
+        ctx->cfg.max_atom_items = 10;
+        ctx->cfg.ssdiff = 0;
        ctx->env.cgit_config = xstrdupn(getenv("CGIT_CONFIG"));
        ctx->env.http_host = xstrdupn(getenv("HTTP_HOST"));
        ctx->env.https = xstrdupn(getenv("HTTPS"));
        ctx->env.no_http = xstrdupn(getenv("NO_HTTP"));
        ctx->env.path_info = xstrdupn(getenv("PATH_INFO"));
        ctx->env.query_string = xstrdupn(getenv("QUERY_STRING"));
        ctx->env.request_method = xstrdupn(getenv("REQUEST_METHOD"));
        ctx->env.script_name = xstrdupn(getenv("SCRIPT_NAME"));
        ctx->env.server_name = xstrdupn(getenv("SERVER_NAME"));
        ctx->env.server_port = xstrdupn(getenv("SERVER_PORT"));
        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;
        ctx->page.etag = NULL;
        memset(&ctx->cfg.mimetypes, 0, sizeof(struct string_list));
        if (ctx->env.script_name)
                ctx->cfg.script_name = ctx->env.script_name;
        if (ctx->env.query_string)
                ctx->qry.raw = ctx->env.query_string;
        if (!ctx->env.cgit_config)
                ctx->env.cgit_config = CGIT_CONFIG;
@@ -389,48 +443,54 @@ static int prepare_repo_cmd(struct cgit_context *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";
                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_vpath is set, assume ctx->qry.path contains a "virtual"
+         * in-project path limit to be made available at ctx->qry.vpath.
+         * Otherwise, no path limit is in effect (ctx->qry.vpath = NULL).
+         */
+        ctx->qry.vpath = cmd->want_vpath ? ctx->qry.path : NULL;
        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();
 }
@@ -470,48 +530,50 @@ char *get_first_line(char *txt)
 }
 void print_repo(FILE *f, struct cgit_repo *repo)
 {
        fprintf(f, "repo.url=%s\n", repo->url);
        fprintf(f, "repo.name=%s\n", repo->name);
        fprintf(f, "repo.path=%s\n", repo->path);
        if (repo->owner)
                fprintf(f, "repo.owner=%s\n", repo->owner);
        if (repo->desc) {
                char *tmp = get_first_line(repo->desc);
                fprintf(f, "repo.desc=%s\n", tmp);
                free(tmp);
        }
        if (repo->readme)
                fprintf(f, "repo.readme=%s\n", repo->readme);
        if (repo->defbranch)
                fprintf(f, "repo.defbranch=%s\n", repo->defbranch);
        if (repo->module_link)
                fprintf(f, "repo.module-link=%s\n", repo->module_link);
        if (repo->section)
                fprintf(f, "repo.section=%s\n", repo->section);
        if (repo->clone_url)
                fprintf(f, "repo.clone-url=%s\n", repo->clone_url);
+        fprintf(f, "repo.enable-commit-graph=%d\n",
+                repo->enable_commit_graph);
        fprintf(f, "repo.enable-log-filecount=%d\n",
                repo->enable_log_filecount);
        fprintf(f, "repo.enable-log-linecount=%d\n",
                repo->enable_log_linecount);
        if (repo->about_filter && repo->about_filter != ctx.cfg.about_filter)
                fprintf(f, "repo.about-filter=%s\n", repo->about_filter->cmd);
        if (repo->commit_filter && repo->commit_filter != ctx.cfg.commit_filter)
                fprintf(f, "repo.commit-filter=%s\n", repo->commit_filter->cmd);
        if (repo->source_filter && repo->source_filter != ctx.cfg.source_filter)
                fprintf(f, "repo.source-filter=%s\n", repo->source_filter->cmd);
        if (repo->snapshots != ctx.cfg.snapshots) {
                char *tmp = build_snapshot_setting(repo->snapshots);
                fprintf(f, "repo.snapshots=%s\n", tmp);
                free(tmp);
        }
        if (repo->max_stats != ctx.cfg.max_stats)
                fprintf(f, "repo.max-stats=%s\n",
                        cgit_find_stats_periodname(repo->max_stats));
        fprintf(f, "\n");
 }
 void print_repolist(FILE *f, struct cgit_repolist *list, int start)
 {
        int i;
@@ -520,73 +582,84 @@ void print_repolist(FILE *f, struct cgit_repolist *list, int start)
                print_repo(f, &list->repos[i]);
 }
 /* Scan 'path' for git repositories, save the resulting repolist in 'cached_rc'
 * and return 0 on success.
 */
 static int generate_cached_repolist(const char *path, const char *cached_rc)
 {
        char *locked_rc;
        int idx;
        FILE *f;
        locked_rc = xstrdup(fmt("%s.lock", cached_rc));
        f = fopen(locked_rc, "wx");
        if (!f) {
                /* Inform about the error unless the lockfile already existed,
                 * since that only means we've got concurrent requests.
                 */
                if (errno != EEXIST)
                        fprintf(stderr, "[cgit] Error opening %s: %s (%d)\n",
                                locked_rc, strerror(errno), errno);
                return errno;
        }
        idx = cgit_repolist.count;
-        scan_tree(path, repo_config);
+        if (ctx.cfg.project_list)
+                scan_projects(path, ctx.cfg.project_list, repo_config);
+        else
+                scan_tree(path, repo_config);
        print_repolist(f, &cgit_repolist, idx);
        if (rename(locked_rc, cached_rc))
                fprintf(stderr, "[cgit] Error renaming %s to %s: %s (%d)\n",
                        locked_rc, cached_rc, strerror(errno), errno);
        fclose(f);
        return 0;
 }
 static void process_cached_repolist(const char *path)
 {
        struct stat st;
        char *cached_rc;
        time_t age;
+        unsigned long hash;
-        cached_rc = xstrdup(fmt("%s/rc-%8x", ctx.cfg.cache_root,
+        hash = hash_str(path);
-                hash_str(path)));
+        if (ctx.cfg.project_list)
+                hash += hash_str(ctx.cfg.project_list);
+        cached_rc = xstrdup(fmt("%s/rc-%8lx", ctx.cfg.cache_root, hash));
        if (stat(cached_rc, &st)) {
                /* Nothing is cached, we need to scan without forking. And
                 * if we fail to generate a cached repolist, we need to
                 * invoke scan_tree manually.
                 */
-                if (generate_cached_repolist(path, cached_rc))
+                if (generate_cached_repolist(path, cached_rc)) {
-                        scan_tree(path, repo_config);
+                        if (ctx.cfg.project_list)
+                                scan_projects(path, ctx.cfg.project_list,
+                                              repo_config);
+                        else
+                                scan_tree(path, repo_config);
+                }
                return;
        }
        parse_configfile(cached_rc, config_cb);
        /* If the cached configfile hasn't expired, lets exit now */
        age = time(NULL) - st.st_mtime;
        if (age <= (ctx.cfg.cache_scanrc_ttl * 60))
                return;
        /* The cached repolist has been parsed, but it was old. So lets
         * rescan the specified path and generate a new cached repolist
         * in a child-process to avoid latency for the current request.
         */
        if (fork())
                return;
        exit(generate_cached_repolist(path, cached_rc));
 }
 static void cgit_parse_args(int argc, const char **argv)
 {
        int i;
        int scan = 0;
@@ -653,49 +726,49 @@ static int calc_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 *path;
        char *qry;
        int err, ttl;
        prepare_context(&ctx);
        cgit_repolist.length = 0;
        cgit_repolist.count = 0;
        cgit_repolist.repos = NULL;
        cgit_parse_args(argc, argv);
-        parse_configfile(ctx.env.cgit_config, config_cb);
+        parse_configfile(expand_macros(ctx.env.cgit_config), config_cb);
        ctx.repo = NULL;
        http_parse_querystring(ctx.qry.raw, querystring_cb);
        /* If virtual-root isn't specified in cgitrc, lets pretend
         * that virtual-root equals SCRIPT_NAME, minus any possibly
         * trailing slashes.
         */
        if (!ctx.cfg.virtual_root)
                ctx.cfg.virtual_root = trim_end(ctx.cfg.script_name, '/');
        /* If no url parameter is specified on the querystring, lets
         * 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).
         */
        path = ctx.env.path_info;
        if (!ctx.qry.url && 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);
diff --git a/cgit.css b/cgit.css
index c47ebc9..1d90057 100644
--- a/cgit.css
+++ b/cgit.css
@@ -43,146 +43,186 @@ table#header td.main a {
        color: #000;
 }
 table#header td.form {
        text-align: right;
        vertical-align: bottom;
        padding-right: 1em;
        padding-bottom: 2px;
        white-space: nowrap;
 }
 table#header td.form form,
 table#header td.form input,
 table#header td.form select {
        font-size: 90%;
 }
 table#header td.sub {
        color: #777;
        border-top: solid 1px #ccc;
        padding-left: 10px;
 }
 table.tabs {
-        /* border-bottom: solid 2px #ccc; */
+        border-bottom: solid 3px #ccc;
        border-collapse: collapse;
        margin-top: 2em;
        margin-bottom: 0px;
        width: 100%;
 }
 table.tabs td {
        padding: 0px 1em;
        vertical-align: bottom;
 }
 table.tabs td a {
        padding: 2px 0.75em;
        color: #777;
        font-size: 110%;
 }
 table.tabs td a.active {
        color: #000;
        background-color: #ccc;
 }
 table.tabs td.form {
        text-align: right;
 }
 table.tabs td.form form {
        padding-bottom: 2px;
        font-size: 90%;
        white-space: nowrap;
 }
 table.tabs td.form input,
 table.tabs td.form select {
        font-size: 90%;
 }
+div.path {
+        margin: 0px;
+        padding: 5px 2em 2px 2em;
+        color: #000;
+        background-color: #eee;
+}
 div.content {
        margin: 0px;
        padding: 2em;
-        border-top: solid 3px #ccc;
        border-bottom: solid 3px #ccc;
 }
 table.list {
        width: 100%;
        border: none;
        border-collapse: collapse;
 }
 table.list tr {
        background: white;
 }
 table.list tr.logheader {
        background: #eee;
 }
 table.list tr:hover {
        background: #eee;
 }
 table.list tr.nohover:hover {
        background: white;
 }
 table.list th {
        font-weight: bold;
        /* color: #888;
        border-top: dashed 1px #888;
        border-bottom: dashed 1px #888;
        */
        padding: 0.1em 0.5em 0.05em 0.5em;
        vertical-align: baseline;
 }
 table.list td {
        border: none;
        padding: 0.1em 0.5em 0.1em 0.5em;
 }
+table.list td.commitgraph {
+        font-family: monospace;
+        white-space: pre;
+}
+table.list td.commitgraph .column1 {
+        color: #a00;
+}
+table.list td.commitgraph .column2 {
+        color: #0a0;
+}
+table.list td.commitgraph .column3 {
+        color: #aa0;
+}
+table.list td.commitgraph .column4 {
+        color: #00a;
+}
+table.list td.commitgraph .column5 {
+        color: #a0a;
+}
+table.list td.commitgraph .column6 {
+        color: #0aa;
+}
 table.list td.logsubject {
        font-family: monospace;
        font-weight: bold;
 }
 table.list td.logmsg {
        font-family: monospace;
        white-space: pre;
-        padding: 1em 0.5em 2em 0.5em;
+        padding: 0 0.5em;
 }
 table.list td a {
        color: black;
 }
+table.list td a.ls-dir {
+        font-weight: bold;
+        color: #00f;
+}
 table.list td a:hover {
        color: #00f;
 }
 img {
        border: none;
 }
 input#switch-btn {
        margin: 2px 0px 0px 0px;
 }
 td#sidebar input.txt {
        width: 100%;
        margin: 2px 0px 0px 0px;
 }
 table#grid {
        margin: 0px;
 }
 td#content {
        vertical-align: top;
        padding: 1em 2em 1em 1em;
@@ -232,49 +272,49 @@ td.ls-mode {
 }
 table.blob {
        margin-top: 0.5em;
        border-top: solid 1px black;
 }
 table.blob td.lines {
        margin: 0; padding: 0 0 0 0.5em;
        vertical-align: top;
        color: black;
 }
 table.blob td.linenumbers {
        margin: 0; padding: 0 0.5em 0 0.5em;
        vertical-align: top;
        text-align: right;
        border-right: 1px solid gray;
 }
 table.blob pre {
        padding: 0; margin: 0;
 }
-table.blob a.no {
+table.blob a.no, table.ssdiff a.no {
        color: gray;
        text-align: right;
        text-decoration: none;
 }
 table.blob a.no a:hover {
        color: black;
 }
 table.bin-blob {
        margin-top: 0.5em;
        border: solid 1px black;
 }
 table.bin-blob th {
        font-family: monospace;
        white-space: pre;
        border: solid 1px #777;
        padding: 0.5em 1em;
 }
 table.bin-blob td {
        font-family: monospace;
        white-space: pre;
@@ -294,48 +334,66 @@ table.commit-info {
 table.commit-info th {
        text-align: left;
        font-weight: normal;
        padding: 0.1em 1em 0.1em 0.1em;
        vertical-align: top;
 }
 table.commit-info td {
        font-weight: normal;
        padding: 0.1em 1em 0.1em 0.1em;
 }
 div.commit-subject {
        font-weight: bold;
        font-size: 125%;
        margin: 1.5em 0em 0.5em 0em;
        padding: 0em;
 }
 div.commit-msg {
        white-space: pre;
        font-family: monospace;
 }
+div.notes-header {
+        font-weight: bold;
+        padding-top: 1.5em;
+}
+div.notes {
+        white-space: pre;
+        font-family: monospace;
+        border: solid 1px #ee9;
+        background-color: #ffd;
+        padding: 0.3em 2em 0.3em 1em;
+        float: left;
+}
+div.notes-footer {
+        clear: left;
+}
 div.diffstat-header {
        font-weight: bold;
        padding-top: 1.5em;
 }
 table.diffstat {
        border-collapse: collapse;
        border: solid 1px #aaa;
        background-color: #eee;
 }
 table.diffstat th {
        font-weight: normal;
        text-align: left;
        text-decoration: underline;
        padding: 0.1em 1em 0.1em 0.1em;
        font-size: 100%;
 }
 table.diffstat td {
        padding: 0.2em 0.2em 0.1em 0.1em;
        font-size: 100%;
        border: none;
 }
@@ -499,49 +557,52 @@ a.branch-deco {
        margin: 0px 0.5em;
        padding: 0px 0.25em;
        background-color: #88ff88;
        border: solid 1px #007700;
 }
 a.tag-deco {
        margin: 0px 0.5em;
        padding: 0px 0.25em;
        background-color: #ffff88;
        border: solid 1px #777700;
 }
 a.remote-deco {
        margin: 0px 0.5em;
        padding: 0px 0.25em;
        background-color: #ccccff;
        border: solid 1px #000077;
 }
 a.deco {
        margin: 0px 0.5em;
        padding: 0px 0.25em;
        background-color: #ff8888;
        border: solid 1px #770000;
 }
-div.commit-subject a {
+div.commit-subject a.branch-deco,
+div.commit-subject a.tag-deco,
+div.commit-subject a.remote-deco,
+div.commit-subject a.deco {
        margin-left: 1em;
        font-size: 75%;
 }
 table.stats {
        border: solid 1px black;
        border-collapse: collapse;
 }
 table.stats th {
        text-align: left;
        padding: 1px 0.5em;
        background-color: #eee;
        border: solid 1px black;
 }
 table.stats td {
        text-align: right;
        padding: 1px 0.5em;
        border: solid 1px black;
 }
 table.stats td.total {
        font-weight: bold;
@@ -580,24 +641,137 @@ table.vgraph div.bar {
        background-color: #eee;
 }
 table.hgraph {
        border: solid 1px black;
        width: 800px;
 }
 table.hgraph th {
        background-color: #eee;
        font-weight: bold;
        border: solid 1px black;
        padding: 1px 0.5em;
 }
 table.hgraph td {
        vertical-align: center;
        padding: 2px 2px;
 }
 table.hgraph div.bar {
        background-color: #eee;
        height: 1em;
 }
+table.ssdiff {
+        width: 100%;
+}
+table.ssdiff td {
+        font-size: 75%;
+        font-family: monospace;
+        white-space: pre;
+        padding: 1px 4px 1px 4px;
+        border-left: solid 1px #aaa;
+        border-right: solid 1px #aaa;
+}
+table.ssdiff td.add {
+        color: black;
+        background: #cfc;
+        min-width: 50%;
+}
+table.ssdiff td.add_dark {
+        color: black;
+        background: #aca;
+        min-width: 50%;
+}
+table.ssdiff span.add {
+        background: #cfc;
+        font-weight: bold;
+}
+table.ssdiff td.del {
+        color: black;
+        background: #fcc;
+        min-width: 50%;
+}
+table.ssdiff td.del_dark {
+        color: black;
+        background: #caa;
+        min-width: 50%;
+}
+table.ssdiff span.del {
+        background: #fcc;
+        font-weight: bold;
+}
+table.ssdiff td.changed {
+        color: black;
+        background: #ffc;
+        min-width: 50%;
+}
+table.ssdiff td.changed_dark {
+        color: black;
+        background: #cca;
+        min-width: 50%;
+}
+table.ssdiff td.lineno {
+        color: black;
+        background: #eee;
+        text-align: right;
+        width: 3em;
+        min-width: 3em;
+}
+table.ssdiff td.hunk {
+        color: #black;
+        background: #ccf;
+        border-top: solid 1px #aaa;
+        border-bottom: solid 1px #aaa;
+}
+table.ssdiff td.head {
+        border-top: solid 1px #aaa;
+        border-bottom: solid 1px #aaa;
+}
+table.ssdiff td.head div.head {
+        font-weight: bold;
+        color: black;
+}
+table.ssdiff td.foot {
+        border-top: solid 1px #aaa;
+        border-left: none;
+        border-right: none;
+        border-bottom: none;
+}
+table.ssdiff td.space {
+        border: none;
+}
+table.ssdiff td.space div {
+        min-height: 3em;
+}
+/* Syntax highlighting */
+table.blob .num  { color:#2928ff; }
+table.blob .esc  { color:#ff00ff; }
+table.blob .str  { color:#ff0000; }
+table.blob .dstr { color:#818100; }
+table.blob .slc  { color:#838183; font-style:italic; }
+table.blob .com  { color:#838183; font-style:italic; }
+table.blob .dir  { color:#008200; }
+table.blob .sym  { color:#000000; }
+table.blob .kwa  { color:#000000; font-weight:bold; }
+table.blob .kwb  { color:#830000; }
+table.blob .kwc  { color:#000000; font-weight:bold; }
+table.blob .kwd  { color:#010181; }
diff --git a/cgit.h b/cgit.h
index 6c6c460..b5f00fc 100644
--- a/cgit.h
+++ b/cgit.h
@@ -1,45 +1,47 @@
 #ifndef CGIT_H
 #define CGIT_H
 #include <git-compat-util.h>
 #include <cache.h>
 #include <grep.h>
 #include <object.h>
 #include <tree.h>
 #include <commit.h>
 #include <tag.h>
 #include <diff.h>
 #include <diffcore.h>
 #include <refs.h>
 #include <revision.h>
 #include <log-tree.h>
 #include <archive.h>
 #include <string-list.h>
 #include <xdiff-interface.h>
 #include <xdiff/xdiff.h>
 #include <utf8.h>
+#include <notes.h>
+#include <graph.h>
 /*
 * Dateformats used on misc. pages
 */
 #define FMT_LONGDATE "%Y-%m-%d %H:%M:%S (%Z)"
 #define FMT_SHORTDATE "%Y-%m-%d"
 #define FMT_ATOMDATE "%Y-%m-%dT%H:%M:%SZ"
 /*
 * Limits used for relative dates
 */
 #define TM_MIN    60
 #define TM_HOUR  (TM_MIN * 60)
 #define TM_DAY   (TM_HOUR * 24)
 #define TM_WEEK  (TM_DAY * 7)
 #define TM_YEAR  (TM_DAY * 365)
 #define TM_MONTH (TM_YEAR / 12.0)
 /*
 * Default encoding
 */
@@ -48,51 +50,56 @@
 typedef void (*configfn)(const char *name, const char *value);
 typedef void (*filepair_fn)(struct diff_filepair *pair);
 typedef void (*linediff_fn)(char *line, int len);
 struct cgit_filter {
        char *cmd;
        char **argv;
        int old_stdout;
        int pipe_fh[2];
        int pid;
        int exitstatus;
 };
 struct cgit_repo {
        char *url;
        char *name;
        char *path;
        char *desc;
        char *owner;
        char *defbranch;
        char *module_link;
        char *readme;
        char *section;
        char *clone_url;
+        char *logo;
+        char *logo_link;
        int snapshots;
+        int enable_commit_graph;
        int enable_log_filecount;
        int enable_log_linecount;
+        int enable_remote_branches;
+        int enable_subject_links;
        int max_stats;
        time_t mtime;
        struct cgit_filter *about_filter;
        struct cgit_filter *commit_filter;
        struct cgit_filter *source_filter;
 };
 typedef void (*repo_config_fn)(struct cgit_repo *repo, const char *name,
              const char *value);
 struct cgit_repolist {
        int length;
        int count;
        struct cgit_repo *repos;
 };
 struct commitinfo {
        struct commit *commit;
        char *author;
        char *author_email;
        unsigned long author_date;
        char *committer;
        char *committer_email;
        unsigned long committer_date;
@@ -122,99 +129,117 @@ struct reflist {
        int alloc;
        int count;
 };
 struct cgit_query {
        int has_symref;
        int has_sha1;
        char *raw;
        char *repo;
        char *page;
        char *search;
        char *grep;
        char *head;
        char *sha1;
        char *sha2;
        char *path;
        char *name;
        char *mimetype;
        char *url;
        char *period;
        int   ofs;
        int nohead;
        char *sort;
        int showmsg;
+        int ssdiff;
+        int show_all;
+        int context;
+        int ignorews;
+        char *vpath;
 };
 struct cgit_config {
        char *agefile;
        char *cache_root;
        char *clone_prefix;
        char *css;
        char *favicon;
        char *footer;
        char *head_include;
        char *header;
        char *index_header;
        char *index_info;
        char *logo;
        char *logo_link;
        char *module_link;
+        char *project_list;
+        char *readme;
        char *robots;
        char *root_title;
        char *root_desc;
        char *root_readme;
        char *script_name;
        char *section;
        char *virtual_root;
+        char *strict_export;
        int cache_size;
        int cache_dynamic_ttl;
        int cache_max_create_time;
        int cache_repo_ttl;
        int cache_root_ttl;
        int cache_scanrc_ttl;
        int cache_static_ttl;
        int embedded;
        int enable_filter_overrides;
+        int enable_gitweb_owner;
        int enable_index_links;
+        int enable_commit_graph;
        int enable_log_filecount;
        int enable_log_linecount;
+        int enable_remote_branches;
+        int enable_subject_links;
        int enable_tree_linenumbers;
        int local_time;
+        int max_atom_items;
        int max_repo_count;
        int max_commit_count;
        int max_lock_attempts;
        int max_msg_len;
        int max_repodesc_len;
+        int max_blob_size;
        int max_stats;
        int nocache;
        int noplainemail;
        int noheader;
        int renamelimit;
+        int remove_suffix;
+        int scan_hidden_path;
+        int section_from_path;
        int snapshots;
        int summary_branches;
        int summary_log;
        int summary_tags;
+        int ssdiff;
        struct string_list mimetypes;
        struct cgit_filter *about_filter;
        struct cgit_filter *commit_filter;
        struct cgit_filter *source_filter;
 };
 struct cgit_page {
        time_t modified;
        time_t expires;
        size_t size;
        char *mimetype;
        char *charset;
        char *filename;
        char *etag;
        char *title;
        int status;
        char *statusmsg;
 };
 struct cgit_environment {
        char *cgit_config;
        char *http_host;
        char *https;
        char *no_http;
@@ -247,48 +272,53 @@ extern struct cgit_repolist cgit_repolist;
 extern struct cgit_context ctx;
 extern const struct cgit_snapshot_format cgit_snapshot_formats[];
 extern struct cgit_repo *cgit_add_repo(const char *url);
 extern struct cgit_repo *cgit_get_repoinfo(const char *url);
 extern void cgit_repo_config_cb(const char *name, const char *value);
 extern int chk_zero(int result, char *msg);
 extern int chk_positive(int result, char *msg);
 extern int chk_non_negative(int result, char *msg);
 extern char *trim_end(const char *str, char c);
 extern char *strlpart(char *txt, int maxlen);
 extern char *strrpart(char *txt, int maxlen);
 extern void cgit_add_ref(struct reflist *list, struct refinfo *ref);
 extern int cgit_refs_cb(const char *refname, const unsigned char *sha1,
                        int flags, void *cb_data);
 extern void *cgit_free_commitinfo(struct commitinfo *info);
 extern int cgit_diff_files(const unsigned char *old_sha1,
                           const unsigned char *new_sha1,
                           unsigned long *old_size, unsigned long *new_size,
-                           int *binary, linediff_fn fn);
+                           int *binary, int context, int ignorews,
+                           linediff_fn fn);
 extern void cgit_diff_tree(const unsigned char *old_sha1,
                           const unsigned char *new_sha1,
-                           filepair_fn fn, const char *prefix);
+                           filepair_fn fn, const char *prefix, int ignorews);
-extern void cgit_diff_commit(struct commit *commit, filepair_fn fn);
+extern void cgit_diff_commit(struct commit *commit, filepair_fn fn,
+                             const char *prefix);
+__attribute__((format (printf,1,2)))
 extern char *fmt(const char *format,...);
 extern struct commitinfo *cgit_parse_commit(struct commit *commit);
 extern struct taginfo *cgit_parse_tag(struct tag *tag);
 extern void cgit_parse_url(const char *url);
 extern const char *cgit_repobasename(const char *reponame);
 extern int cgit_parse_snapshots_mask(const char *str);
 extern int cgit_open_filter(struct cgit_filter *filter);
 extern int cgit_close_filter(struct cgit_filter *filter);
 extern int readfile(const char *path, char **buf, size_t *size);
+extern char *expand_macros(const char *txt);
 #endif /* CGIT_H */
diff --git a/cgit.png b/cgit.png
index d7f70bc..0bdf5a7 100644
--- a/cgit.png
+++ b/cgit.png
Binary files differ
diff --git a/cgitrc.5.txt b/cgitrc.5.txt
index 0c13485..c3698a6 100644
--- a/cgitrc.5.txt
+++ b/cgitrc.5.txt
@@ -69,68 +69,89 @@ cache-static-ttl::
        Number which specifies the time-to-live, in minutes, for the cached
        version of repository pages accessed with a fixed SHA1. Default value:
        "5".
 clone-prefix::
        Space-separated list of common prefixes which, when combined with a
        repository url, generates valid clone urls for the repository. This
        setting is only used if `repo.clone-url` is unspecified. Default value:
        none.
 commit-filter::
        Specifies a command which will be invoked to format commit messages.
        The command will get the message on its STDIN, and the STDOUT from the
        command will be included verbatim as the commit message, i.e. this can
        be used to implement bugtracker integration. Default value: none.
 css::
        Url which specifies the css document to include in all cgit pages.
        Default value: "/cgit.css".
 embedded::
        Flag which, when set to "1", will make cgit generate a html fragment
        suitable for embedding in other html pages. Default value: none. See
        also: "noheader".
-        
+enable-commit-graph::
+        Flag which, when set to "1", will make cgit print an ASCII-art commit
+        history graph to the left of the commit messages in the repository
+        log page. Default value: "0".
 enable-filter-overrides::
        Flag which, when set to "1", allows all filter settings to be
        overridden in repository-specific cgitrc files. Default value: none.
+enable-gitweb-owner::
+        If set to "1" and scan-path is enabled, we first check each repository
+        for the git config value "gitweb.owner" to determine the owner.
+        Default value: "1". See also: scan-path.
 enable-index-links::
        Flag which, when set to "1", will make cgit generate extra links for
        each repo in the repository index (specifically, to the "summary",
        "commit" and "tree" pages). Default value: "0".
 enable-log-filecount::
        Flag which, when set to "1", will make cgit print the number of
        modified files for each commit on the repository log page. Default
        value: "0".
 enable-log-linecount::
        Flag which, when set to "1", will make cgit print the number of added
        and removed lines for each commit on the repository log page. Default
        value: "0".
+enable-remote-branches::
+        Flag which, when set to "1", will make cgit display remote branches
+        in the summary and refs views. Default value: "0". See also:
+        "repo.enable-remote-branches".
+enable-subject-links::
+        Flag which, when set to "1", will make cgit use the subject of the
+        parent commit as link text when generating links to parent commits
+        in commit view. Default value: "0". See also:
+        "repo.enable-subject-links".
 enable-tree-linenumbers::
        Flag which, when set to "1", will make cgit generate linenumber links
        for plaintext blobs printed in the tree view. Default value: "1".
 favicon::
        Url used as link to a shortcut icon for cgit. If specified, it is
        suggested to use the value "/favicon.ico" since certain browsers will
        ignore other values. Default value: none.
 footer::
        The content of the file specified with this option will be included
        verbatim at the bottom of all pages (i.e. it replaces the standard
        "generated by..." message. Default value: none.
 head-include::
        The content of the file specified with this option will be included
        verbatim in the html HEAD section on all pages. Default value: none.
 header::
        The content of the file specified with this option will be included
        verbatim at the top of all pages. Default value: none.
 include::
        Name of a configfile to include before the rest of the current config-
@@ -140,330 +161,407 @@ index-header::
        The content of the file specified with this option will be included
        verbatim above the repository index. This setting is deprecated, and
        will not be supported by cgit-1.0 (use root-readme instead). Default
        value: none.
 index-info::
        The content of the file specified with this option will be included
        verbatim below the heading on the repository index page. This setting
        is deprecated, and will not be supported by cgit-1.0 (use root-desc
        instead). Default value: none.
 local-time::
        Flag which, if set to "1", makes cgit print commit and tag times in the
        servers timezone. Default value: "0".
 logo::
        Url which specifies the source of an image which will be used as a logo
        on all cgit pages. Default value: "/cgit.png".
 logo-link::
        Url loaded when clicking on the cgit logo image. If unspecified the
        calculated url of the repository index page will be used. Default
        value: none.
+max-atom-items::
+        Specifies the number of items to display in atom feeds view. Default
+        value: "10".
 max-commit-count::
        Specifies the number of entries to list per page in "log" view. Default
        value: "50".
 max-message-length::
        Specifies the maximum number of commit message characters to display in
        "log" view. Default value: "80".
 max-repo-count::
                Specifies the number of entries to list per page on therepository
        index page. Default value: "50".
 max-repodesc-length::
        Specifies the maximum number of repo description characters to display
        on the repository index page. Default value: "80".
+max-blob-size::
+        Specifies the maximum size of a blob to display HTML for in KBytes.
+        Default value: "0" (limit disabled).
 max-stats::
        Set the default maximum statistics period. Valid values are "week",
        "month", "quarter" and "year". If unspecified, statistics are
        disabled. Default value: none. See also: "repo.max-stats".
 mimetype.<ext>::
        Set the mimetype for the specified filename extension. This is used
        by the `plain` command when returning blob content.
 module-link::
        Text which will be used as the formatstring for a hyperlink when a
        submodule is printed in a directory listing. The arguments for the
        formatstring are the path and SHA1 of the submodule commit. Default
        value: "./?repo=%s&page=commit&id=%s"
 nocache::
        If set to the value "1" caching will be disabled. This settings is
        deprecated, and will not be honored starting with cgit-1.0. Default
        value: "0".
 noplainemail::
        If set to "1" showing full author email adresses will be disabled.
        Default value: "0".
 noheader::
        Flag which, when set to "1", will make cgit omit the standard header
        on all pages. Default value: none. See also: "embedded".
+project-list::
+        A list of subdirectories inside of scan-path, relative to it, that
+        should loaded as git repositories. This must be defined prior to
+        scan-path. Default value: none. See also: scan-path.
+readme::
+        Text which will be used as default value for "repo.readme". Default
+        value: none.
+remove-suffix::
+        If set to "1" and scan-path is enabled, if any repositories are found
+        with a suffix of ".git", this suffix will be removed for the url and
+        name. Default value: "0". See also: scan-path.
 renamelimit::
        Maximum number of files to consider when detecting renames. The value
         "-1" uses the compiletime value in git (for further info, look at
          `man git-diff`). Default value: "-1".
 repo.group::
        Legacy alias for "section". This option is deprecated and will not be
        supported in cgit-1.0.
 robots::
        Text used as content for the "robots" meta-tag. Default value:
        "index, nofollow".
 root-desc::
        Text printed below the heading on the repository index page. Default
        value: "a fast webinterface for the git dscm".
 root-readme::
        The content of the file specified with this option will be included
        verbatim below the "about" link on the repository index page. Default
        value: none.
 root-title::
        Text printed as heading on the repository index page. Default value:
        "Git Repository Browser".
+scan-hidden-path::
+        If set to "1" and scan-path is enabled, scan-path will recurse into
+        directories whose name starts with a period ('.'). Otherwise,
+        scan-path will stay away from such directories (considered as
+        "hidden"). Note that this does not apply to the ".git" directory in
+        non-bare repos. This must be defined prior to scan-path.
+        Default value: 0. See also: scan-path.
 scan-path::
        A path which will be scanned for repositories. If caching is enabled,
        the result will be cached as a cgitrc include-file in the cache
-        directory. Default value: none. See also: cache-scanrc-ttl.
+        directory. If project-list has been defined prior to scan-path,
+        scan-path loads only the directories listed in the file pointed to by
+        project-list. Default value: none. See also: cache-scanrc-ttl,
+        project-list.
 section::
        The name of the current repository section - all repositories defined
        after this option will inherit the current section name. Default value:
        none.
+section-from-path::
+        A number which, if specified before scan-path, specifies how many
+        path elements from each repo path to use as a default section name.
+        If negative, cgit will discard the specified number of path elements
+        above the repo directory. Default value: 0.
+side-by-side-diffs::
+        If set to "1" shows side-by-side diffs instead of unidiffs per
+        default. Default value: "0".
 snapshots::
        Text which specifies the default set of snapshot formats generated by
        cgit. The value is a space-separated list of zero or more of the
        values "tar", "tar.gz", "tar.bz2" and "zip". Default value: none.
 source-filter::
        Specifies a command which will be invoked to format plaintext blobs
        in the tree view. The command will get the blob content on its STDIN
        and the name of the blob as its only command line argument. The STDOUT
        from the command will be included verbatim as the blob contents, i.e.
        this can be used to implement e.g. syntax highlighting. Default value:
        none.
 summary-branches::
        Specifies the number of branches to display in the repository "summary"
        view. Default value: "10".
 summary-log::
        Specifies the number of log entries to display in the repository
        "summary" view. Default value: "10".
 summary-tags::
        Specifies the number of tags to display in the repository "summary"
        view. Default value: "10".
+strict-export::
+        Filename which, if specified, needs to be present within the repository
+        for cgit to allow access to that repository. This can be used to emulate
+        gitweb's EXPORT_OK and STRICT_EXPORT functionality and limit cgit's
+        repositories to match those exported by git-daemon. This option MUST come
+        before 'scan-path'.
 virtual-root::
        Url which, if specified, will be used as root for all cgit links. It
        will also cause cgit to generate 'virtual urls', i.e. urls like
        '/cgit/tree/README' as opposed to '?r=cgit&p=tree&path=README'. Default
        value: none.
        NOTE: cgit has recently learned how to use PATH_INFO to achieve the
        same kind of virtual urls, so this option will probably be deprecated.
 REPOSITORY SETTINGS
 -------------------
 repo.about-filter::
        Override the default about-filter. Default value: none. See also:
        "enable-filter-overrides".
 repo.clone-url::
        A list of space-separated urls which can be used to clone this repo.
        Default value: none.
 repo.commit-filter::
        Override the default commit-filter. Default value: none. See also:
        "enable-filter-overrides".
 repo.defbranch::
        The name of the default branch for this repository. If no such branch
        exists in the repository, the first branch name (when sorted) is used
        as default instead. Default value: "master".
 repo.desc::
        The value to show as repository description. Default value: none.
+repo.enable-commit-graph::
+        A flag which can be used to disable the global setting
+        `enable-commit-graph'. Default value: none.
 repo.enable-log-filecount::
        A flag which can be used to disable the global setting
        `enable-log-filecount'. Default value: none.
 repo.enable-log-linecount::
        A flag which can be used to disable the global setting
        `enable-log-linecount'. Default value: none.
+repo.enable-remote-branches::
+        Flag which, when set to "1", will make cgit display remote branches
+        in the summary and refs views. Default value: <enable-remote-branches>.
+repo.enable-subject-links::
+        A flag which can be used to override the global setting
+        `enable-subject-links'. Default value: none.
+repo.logo::
+        Url which specifies the source of an image which will be used as a logo
+        on this repo's pages. Default value: global logo.
+repo.logo-link::
+        Url loaded when clicking on the cgit logo image. If unspecified the
+        calculated url of the repository index page will be used. Default
+        value: global logo-link.
 repo.max-stats::
        Override the default maximum statistics period. Valid values are equal
        to the values specified for the global "max-stats" setting. Default
        value: none.
 repo.name::
        The value to show as repository name. Default value: <repo.url>.
 repo.owner::
        A value used to identify the owner of the repository. Default value:
        none.
 repo.path::
        An absolute path to the repository directory. For non-bare repositories
        this is the .git-directory. Default value: none.
 repo.readme::
        A path (relative to <repo.path>) which specifies a file to include
-        verbatim as the "About" page for this repo. Default value: none.
+        verbatim as the "About" page for this repo. You may also specify a
+        git refspec by head or by hash by prepending the refspec followed by
+        a colon. For example, "master:docs/readme.mkd" Default value: <readme>.
 repo.snapshots::
        A mask of allowed snapshot-formats for this repo, restricted by the
        "snapshots" global setting. Default value: <snapshots>.
 repo.section::
        Override the current section name for this repository. Default value:
        none.
 repo.source-filter::
        Override the default source-filter. Default value: none. See also:
        "enable-filter-overrides".
 repo.url::
        The relative url used to access the repository. This must be the first
        setting specified for each repo. Default value: none.
 REPOSITORY-SPECIFIC CGITRC FILE
 -------------------------------
 When the option "scan-path" is used to auto-discover git repositories, cgit
 will try to parse the file "cgitrc" within any found repository. Such a
 repo-specific config file may contain any of the repo-specific options
 described above, except "repo.url" and "repo.path". Additionally, the "filter"
 options are only acknowledged in repo-specific config files when
 "enable-filter-overrides" is set to "1".
 Note: the "repo." prefix is dropped from the option names in repo-specific
 config files, e.g. "repo.desc" becomes "desc".
 EXAMPLE CGITRC FILE
 -------------------
 ....
 # Enable caching of up to 1000 output entriess
 cache-size=1000
 # Specify some default clone prefixes
-clone-prefix=git://foobar.com ssh://foobar.com/pub/git http://foobar.com/git
+clone-prefix=git://example.com ssh://example.com/pub/git http://example.com/git
 # Specify the css url
 css=/css/cgit.css
 # Show extra links for each repository on the index page
 enable-index-links=1
+# Enable ASCII art commit history graph on the log pages
+enable-commit-graph=1
 # Show number of affected files per commit on the log pages
 enable-log-filecount=1
 # Show number of added/removed lines per commit on the log pages
 enable-log-linecount=1
 # Add a cgit favicon
 favicon=/favicon.ico
 # Use a custom logo
 logo=/img/mylogo.png
 # Enable statistics per week, month and quarter
 max-stats=quarter
 # Set the title and heading of the repository index page
-root-title=foobar.com git repositories
+root-title=example.com git repositories
 # Set a subheading for the repository index page
 root-desc=tracking the foobar development
-# Include some more info about foobar.com on the index page
+# Include some more info about example.com on the index page
 root-readme=/var/www/htdocs/about.html
 # Allow download of tar.gz, tar.bz2 and zip-files
 snapshots=tar.gz tar.bz2 zip
 ##
 ## List of common mimetypes
 ##
-mimetype.git=image/git
+mimetype.gif=image/gif
 mimetype.html=text/html
 mimetype.jpg=image/jpeg
 mimetype.jpeg=image/jpeg
 mimetype.pdf=application/pdf
 mimetype.png=image/png
 mimetype.svg=image/svg+xml
 ##
 ## List of repositories.
 ## PS: Any repositories listed when section is unset will not be
 ##     displayed under a section heading
 ## PPS: This list could be kept in a different file (e.g. '/etc/cgitrepos')
 ##      and included like this:
 ##        include=/etc/cgitrepos
 ##
 repo.url=foo
 repo.path=/pub/git/foo.git
 repo.desc=the master foo repository
-repo.owner=fooman@foobar.com
+repo.owner=fooman@example.com
 repo.readme=info/web/about.html
 repo.url=bar
 repo.path=/pub/git/bar.git
 repo.desc=the bars for your foo
-repo.owner=barman@foobar.com
+repo.owner=barman@example.com
 repo.readme=info/web/about.html
 # The next repositories will be displayed under the 'extras' heading
 section=extras
 repo.url=baz
 repo.path=/pub/git/baz.git
 repo.desc=a set of extensions for bar users
 repo.url=wiz
 repo.path=/pub/git/wiz.git
 repo.desc=the wizard of foo
 # Add some mirrored repositories
 section=mirrors
 repo.url=git
 repo.path=/pub/git/git.git
 repo.desc=the dscm
@@ -478,24 +576,25 @@ repo.snapshots=0
 # Disable line-counts for this repo
 repo.enable-log-linecount=0
 # Restrict the max statistics period for this repo
 repo.max-stats=month
 ....
 BUGS
 ----
 Comments currently cannot appear on the same line as a setting; the comment
 will be included as part of the value. E.g. this line:
        robots=index  # allow indexing
 will generate the following html element:
        <meta name='robots' content='index  # allow indexing'/>
 AUTHOR
 ------
 Lars Hjemli <hjemli@gmail.com>
+Jason A. Donenfeld <Jason@zx2c4.com>
diff --git a/cmd.c b/cmd.c
index 766f903..536515b 100644
--- a/cmd.c
+++ b/cmd.c
@@ -12,160 +12,161 @@
 #include "ui-shared.h"
 #include "ui-atom.h"
 #include "ui-blob.h"
 #include "ui-clone.h"
 #include "ui-commit.h"
 #include "ui-diff.h"
 #include "ui-log.h"
 #include "ui-patch.h"
 #include "ui-plain.h"
 #include "ui-refs.h"
 #include "ui-repolist.h"
 #include "ui-snapshot.h"
 #include "ui-stats.h"
 #include "ui-summary.h"
 #include "ui-tag.h"
 #include "ui-tree.h"
 static void HEAD_fn(struct cgit_context *ctx)
 {
        cgit_clone_head(ctx);
 }
 static void atom_fn(struct cgit_context *ctx)
 {
-        cgit_print_atom(ctx->qry.head, ctx->qry.path, 10);
+        cgit_print_atom(ctx->qry.head, ctx->qry.path, ctx->cfg.max_atom_items);
 }
 static void about_fn(struct cgit_context *ctx)
 {
        if (ctx->repo)
                cgit_print_repo_readme(ctx->qry.path);
        else
                cgit_print_site_readme();
 }
 static void blob_fn(struct cgit_context *ctx)
 {
        cgit_print_blob(ctx->qry.sha1, ctx->qry.path, ctx->qry.head);
 }
 static void commit_fn(struct cgit_context *ctx)
 {
-        cgit_print_commit(ctx->qry.sha1);
+        cgit_print_commit(ctx->qry.sha1, ctx->qry.path);
 }
 static void diff_fn(struct cgit_context *ctx)
 {
        cgit_print_diff(ctx->qry.sha1, ctx->qry.sha2, ctx->qry.path);
 }
 static void info_fn(struct cgit_context *ctx)
 {
        cgit_clone_info(ctx);
 }
 static void log_fn(struct cgit_context *ctx)
 {
        cgit_print_log(ctx->qry.sha1, ctx->qry.ofs, ctx->cfg.max_commit_count,
-                       ctx->qry.grep, ctx->qry.search, ctx->qry.path, 1);
+                       ctx->qry.grep, ctx->qry.search, ctx->qry.path, 1,
+                       ctx->repo->enable_commit_graph);
 }
 static void ls_cache_fn(struct cgit_context *ctx)
 {
        ctx->page.mimetype = "text/plain";
        ctx->page.filename = "ls-cache.txt";
        cgit_print_http_headers(ctx);
        cache_ls(ctx->cfg.cache_root);
 }
 static void objects_fn(struct cgit_context *ctx)
 {
        cgit_clone_objects(ctx);
 }
 static void repolist_fn(struct cgit_context *ctx)
 {
        cgit_print_repolist();
 }
 static void patch_fn(struct cgit_context *ctx)
 {
-        cgit_print_patch(ctx->qry.sha1);
+        cgit_print_patch(ctx->qry.sha1, ctx->qry.path);
 }
 static void plain_fn(struct cgit_context *ctx)
 {
        cgit_print_plain(ctx);
 }
 static void refs_fn(struct cgit_context *ctx)
 {
        cgit_print_refs();
 }
 static void snapshot_fn(struct cgit_context *ctx)
 {
        cgit_print_snapshot(ctx->qry.head, ctx->qry.sha1, ctx->qry.path,
                            ctx->repo->snapshots, ctx->qry.nohead);
 }
 static void stats_fn(struct cgit_context *ctx)
 {
        cgit_show_stats(ctx);
 }
 static void summary_fn(struct cgit_context *ctx)
 {
        cgit_print_summary();
 }
 static void tag_fn(struct cgit_context *ctx)
 {
        cgit_print_tag(ctx->qry.sha1);
 }
 static void tree_fn(struct cgit_context *ctx)
 {
        cgit_print_tree(ctx->qry.sha1, ctx->qry.path);
 }
-#define def_cmd(name, want_repo, want_layout) \
+#define def_cmd(name, want_repo, want_layout, want_vpath) \
-        {#name, name##_fn, want_repo, want_layout}
+        {#name, name##_fn, want_repo, want_layout, want_vpath}
 struct cgit_cmd *cgit_get_cmd(struct cgit_context *ctx)
 {
        static struct cgit_cmd cmds[] = {
-                def_cmd(HEAD, 1, 0),
+                def_cmd(HEAD, 1, 0, 0),
-                def_cmd(atom, 1, 0),
+                def_cmd(atom, 1, 0, 0),
-                def_cmd(about, 0, 1),
+                def_cmd(about, 0, 1, 0),
-                def_cmd(blob, 1, 0),
+                def_cmd(blob, 1, 0, 0),
-                def_cmd(commit, 1, 1),
+                def_cmd(commit, 1, 1, 1),
-                def_cmd(diff, 1, 1),
+                def_cmd(diff, 1, 1, 1),
-                def_cmd(info, 1, 0),
+                def_cmd(info, 1, 0, 0),
-                def_cmd(log, 1, 1),
+                def_cmd(log, 1, 1, 1),
-                def_cmd(ls_cache, 0, 0),
+                def_cmd(ls_cache, 0, 0, 0),
-                def_cmd(objects, 1, 0),
+                def_cmd(objects, 1, 0, 0),
-                def_cmd(patch, 1, 0),
+                def_cmd(patch, 1, 0, 1),
-                def_cmd(plain, 1, 0),
+                def_cmd(plain, 1, 0, 0),
-                def_cmd(refs, 1, 1),
+                def_cmd(refs, 1, 1, 0),
-                def_cmd(repolist, 0, 0),
+                def_cmd(repolist, 0, 0, 0),
-                def_cmd(snapshot, 1, 0),
+                def_cmd(snapshot, 1, 0, 0),
-                def_cmd(stats, 1, 1),
+                def_cmd(stats, 1, 1, 1),
-                def_cmd(summary, 1, 1),
+                def_cmd(summary, 1, 1, 0),
-                def_cmd(tag, 1, 1),
+                def_cmd(tag, 1, 1, 0),
-                def_cmd(tree, 1, 1),
+                def_cmd(tree, 1, 1, 1),
        };
        int i;
        if (ctx->qry.page == NULL) {
                if (ctx->repo)
                        ctx->qry.page = "summary";
                else
                        ctx->qry.page = "repolist";
        }
        for(i = 0; i < sizeof(cmds)/sizeof(*cmds); i++)
                if (!strcmp(ctx->qry.page, cmds[i].name))
                        return &cmds[i];
        return NULL;
 }
diff --git a/cmd.h b/cmd.h
index ec9e691..8dc01bd 100644
--- a/cmd.h
+++ b/cmd.h
@@ -1,15 +1,16 @@
 #ifndef CMD_H
 #define CMD_H
 typedef void (*cgit_cmd_fn)(struct cgit_context *ctx);
 struct cgit_cmd {
        const char *name;
        cgit_cmd_fn fn;
        unsigned int want_repo:1,
-                want_layout:1;
+                want_layout:1,
+                want_vpath:1;
 };
 extern struct cgit_cmd *cgit_get_cmd(struct cgit_context *ctx);
 #endif /* CMD_H */
diff --git a/filters/commit-links.sh b/filters/commit-links.sh
index 165a533..110c609 100755
--- a/filters/commit-links.sh
+++ b/filters/commit-links.sh
@@ -1,12 +1,14 @@
 #!/bin/sh
-# This script can be used to generate links in commit messages - the first
+# This script can be used to generate links in commit messages.
-# sed expression generates links to commits referenced by their SHA1, while
-# the second expression generates links to a fictional bugtracker.
 #
 # To use this script, refer to this file with either the commit-filter or the
 # repo.commit-filter options in cgitrc.
-sed -re '
+# This expression generates links to commits referenced by their SHA1.
-s|\b([0-9a-fA-F]{8,40})\b|<a href="./?id=\1">\1</a>|g
+regex=$regex'
-s| #([0-9]+)\b|<a href="http://bugs.example.com/?bug=\1">#\1</a>|g
+s|\b([0-9a-fA-F]{8,40})\b|<a href="./?id=\1">\1</a>|g'
-'
+# This expression generates links to a fictional bugtracker.
+regex=$regex'
+s| #([0-9]+)\b|<a href="http://bugs.example.com/?bug=\1">#\1</a>|g'
+sed -re "$regex"
diff --git a/filters/syntax-highlighting.sh b/filters/syntax-highlighting.sh
index 999ad0c..6b1c576 100755
--- a/filters/syntax-highlighting.sh
+++ b/filters/syntax-highlighting.sh
@@ -1,39 +1,34 @@
 #!/bin/sh
 # This script can be used to implement syntax highlighting in the cgit
 # tree-view by refering to this file with the source-filter or repo.source-
 # filter options in cgitrc.
 #
+# This script requires a shell supporting the ${var##pattern} syntax.
+# It is supported by at least dash and bash, however busybox environments
+# might have to use an external call to sed instead.
+#
 # Note: the highlight command (http://www.andre-simon.de/) uses css for syntax
 # highlighting, so you'll probably want something like the following included
 # in your css file (generated by highlight 2.4.8 and adapted for cgit):
 #
 # table.blob .num  { color:#2928ff; }
 # table.blob .esc  { color:#ff00ff; }
 # table.blob .str  { color:#ff0000; }
 # table.blob .dstr { color:#818100; }
 # table.blob .slc  { color:#838183; font-style:italic; }
 # table.blob .com  { color:#838183; font-style:italic; }
 # table.blob .dir  { color:#008200; }
 # table.blob .sym  { color:#000000; }
 # table.blob .kwa  { color:#000000; font-weight:bold; }
 # table.blob .kwb  { color:#830000; }
 # table.blob .kwc  { color:#000000; font-weight:bold; }
 # table.blob .kwd  { color:#010181; }
-case "$1" in
+# store filename and extension in local vars
-        *.c)
+BASENAME="$1"
-                highlight -f -I -X -S c
+EXTENSION="${BASENAME##*.}"
-                ;;
-        *.h)
+# map Makefile and Makefile.* to .mk
-                highlight -f -I -X -S c
+[ "${BASENAME%%.*}" == "Makefile" ] && EXTENSION=mk
-                ;;
-        *.sh)
+exec highlight --force -f -I -X -S $EXTENSION 2>/dev/null
-                highlight -f -I -X -S sh
-                ;;
-        *.css)
-                highlight -f -I -X -S css
-                ;;
-        *)
-                highlight -f -I -X -S txt
-                ;;
-esac
diff --git a/git b/git
-Subproject 87b50542a08ac6caa083ddc376e674424e37940
+Subproject 7ed863a85a6ce2c4ac4476848310b8f917ab41f
diff --git a/html.c b/html.c
index 5336596..a60bc13 100644
--- a/html.c
+++ b/html.c
@@ -1,39 +1,65 @@
 /* html.c: helper functions for html output
 *
 * Copyright (C) 2006 Lars Hjemli
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 #include <errno.h>
+/* Percent-encoding of each character, except: a-zA-Z0-9!$()*,./:;@- */
+static const char* url_escape_table[256] = {
+        "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07", "%08", "%09",
+        "%0a", "%0b", "%0c", "%0d", "%0e", "%0f", "%10", "%11", "%12", "%13",
+        "%14", "%15", "%16", "%17", "%18", "%19", "%1a", "%1b", "%1c", "%1d",
+        "%1e", "%1f", "+", 0, "%22", "%23", 0, "%25", "%26", "%27", 0, 0, 0,
+        "%2b", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "%3c", "%3d",
+        "%3e", "%3f", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, "%5c", 0, "%5e", 0, "%60", 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "%7b",
+        "%7c", "%7d", 0, "%7f", "%80", "%81", "%82", "%83", "%84", "%85",
+        "%86", "%87", "%88", "%89", "%8a", "%8b", "%8c", "%8d", "%8e", "%8f",
+        "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97", "%98", "%99",
+        "%9a", "%9b", "%9c", "%9d", "%9e", "%9f", "%a0", "%a1", "%a2", "%a3",
+        "%a4", "%a5", "%a6", "%a7", "%a8", "%a9", "%aa", "%ab", "%ac", "%ad",
+        "%ae", "%af", "%b0", "%b1", "%b2", "%b3", "%b4", "%b5", "%b6", "%b7",
+        "%b8", "%b9", "%ba", "%bb", "%bc", "%bd", "%be", "%bf", "%c0", "%c1",
+        "%c2", "%c3", "%c4", "%c5", "%c6", "%c7", "%c8", "%c9", "%ca", "%cb",
+        "%cc", "%cd", "%ce", "%cf", "%d0", "%d1", "%d2", "%d3", "%d4", "%d5",
+        "%d6", "%d7", "%d8", "%d9", "%da", "%db", "%dc", "%dd", "%de", "%df",
+        "%e0", "%e1", "%e2", "%e3", "%e4", "%e5", "%e6", "%e7", "%e8", "%e9",
+        "%ea", "%eb", "%ec", "%ed", "%ee", "%ef", "%f0", "%f1", "%f2", "%f3",
+        "%f4", "%f5", "%f6", "%f7", "%f8", "%f9", "%fa", "%fb", "%fc", "%fd",
+        "%fe", "%ff"
+};
 int htmlfd = STDOUT_FILENO;
 char *fmt(const char *format, ...)
 {
        static char buf[8][1024];
        static int bufidx;
        int len;
        va_list args;
        bufidx++;
        bufidx &= 7;
        va_start(args, format);
        len = vsnprintf(buf[bufidx], sizeof(buf[bufidx]), format, args);
        va_end(args);
        if (len>sizeof(buf[bufidx])) {
                fprintf(stderr, "[html.c] string truncated: %s\n", format);
                exit(1);
        }
        return buf[bufidx];
 }
 void html_raw(const char *data, size_t size)
 {
@@ -42,251 +68,253 @@ void html_raw(const char *data, size_t size)
 void html(const char *txt)
 {
        write(htmlfd, txt, strlen(txt));
 }
 void htmlf(const char *format, ...)
 {
        static char buf[65536];
        va_list args;
        va_start(args, format);
        vsnprintf(buf, sizeof(buf), format, args);
        va_end(args);
        html(buf);
 }
 void html_status(int code, const char *msg, int more_headers)
 {
        htmlf("Status: %d %s\n", code, msg);
        if (!more_headers)
                html("\n");
 }
-void html_txt(char *txt)
+void html_txt(const char *txt)
 {
-        char *t = txt;
+        const char *t = txt;
        while(t && *t){
                int c = *t;
                if (c=='<' || c=='>' || c=='&') {
-                        write(htmlfd, txt, t - txt);
+                        html_raw(txt, t - txt);
                        if (c=='>')
                                html("&gt;");
                        else if (c=='<')
                                html("&lt;");
                        else if (c=='&')
                                html("&amp;");
                        txt = t+1;
                }
                t++;
        }
        if (t!=txt)
                html(txt);
 }
-void html_ntxt(int len, char *txt)
+void html_ntxt(int len, const char *txt)
 {
-        char *t = txt;
+        const char *t = txt;
        while(t && *t && len--){
                int c = *t;
                if (c=='<' || c=='>' || c=='&') {
-                        write(htmlfd, txt, t - txt);
+                        html_raw(txt, t - txt);
                        if (c=='>')
                                html("&gt;");
                        else if (c=='<')
                                html("&lt;");
                        else if (c=='&')
                                html("&amp;");
                        txt = t+1;
                }
                t++;
        }
        if (t!=txt)
-                write(htmlfd, txt, t - txt);
+                html_raw(txt, t - txt);
        if (len<0)
                html("...");
 }
-void html_attr(char *txt)
+void html_attr(const char *txt)
 {
-        char *t = txt;
+        const char *t = txt;
        while(t && *t){
                int c = *t;
                if (c=='<' || c=='>' || c=='\'' || c=='\"') {
-                        write(htmlfd, txt, t - txt);
+                        html_raw(txt, t - txt);
                        if (c=='>')
                                html("&gt;");
                        else if (c=='<')
                                html("&lt;");
                        else if (c=='\'')
                                html("&#x27;");
                        else if (c=='"')
                                html("&quot;");
                        txt = t+1;
                }
                t++;
        }
        if (t!=txt)
                html(txt);
 }
-void html_url_path(char *txt)
+void html_url_path(const char *txt)
 {
-        char *t = txt;
+        const char *t = txt;
        while(t && *t){
                int c = *t;
-                if (c=='"' || c=='#' || c=='\'' || c=='?') {
+                const char *e = url_escape_table[c];
-                        write(htmlfd, txt, t - txt);
+                if (e && c!='+' && c!='&' && c!='+') {
-                        write(htmlfd, fmt("%%%2x", c), 3);
+                        html_raw(txt, t - txt);
+                        html_raw(e, 3);
                        txt = t+1;
                }
                t++;
        }
        if (t!=txt)
                html(txt);
 }
-void html_url_arg(char *txt)
+void html_url_arg(const char *txt)
 {
-        char *t = txt;
+        const char *t = txt;
        while(t && *t){
                int c = *t;
-                if (c=='"' || c=='#' || c=='%' || c=='&' || c=='\'' || c=='+' || c=='?') {
+                const char *e = url_escape_table[c];
-                        write(htmlfd, txt, t - txt);
+                if (e) {
-                        write(htmlfd, fmt("%%%2x", c), 3);
+                        html_raw(txt, t - txt);
+                        html_raw(e, strlen(e));
                        txt = t+1;
                }
                t++;
        }
        if (t!=txt)
                html(txt);
 }
-void html_hidden(char *name, char *value)
+void html_hidden(const char *name, const char *value)
 {
        html("<input type='hidden' name='");
        html_attr(name);
        html("' value='");
        html_attr(value);
        html("'/>");
 }
-void html_option(char *value, char *text, char *selected_value)
+void html_option(const char *value, const char *text, const char *selected_value)
 {
        html("<option value='");
        html_attr(value);
        html("'");
        if (selected_value && !strcmp(selected_value, value))
                html(" selected='selected'");
        html(">");
        html_txt(text);
        html("</option>\n");
 }
-void html_link_open(char *url, char *title, char *class)
+void html_link_open(const char *url, const char *title, const char *class)
 {
        html("<a href='");
        html_attr(url);
        if (title) {
                html("' title='");
                html_attr(title);
        }
        if (class) {
                html("' class='");
                html_attr(class);
        }
        html("'>");
 }
 void html_link_close(void)
 {
        html("</a>");
 }
 void html_fileperm(unsigned short mode)
 {
        htmlf("%c%c%c", (mode & 4 ? 'r' : '-'),
              (mode & 2 ? 'w' : '-'), (mode & 1 ? 'x' : '-'));
 }
 int html_include(const char *filename)
 {
        FILE *f;
        char buf[4096];
        size_t len;
        if (!(f = fopen(filename, "r"))) {
                fprintf(stderr, "[cgit] Failed to include file %s: %s (%d).\n",
                        filename, strerror(errno), errno);
                return -1;
        }
        while((len = fread(buf, 1, 4096, f)) > 0)
-                write(htmlfd, buf, len);
+                html_raw(buf, len);
        fclose(f);
        return 0;
 }
 int hextoint(char c)
 {
        if (c >= 'a' && c <= 'f')
                return 10 + c - 'a';
        else if (c >= 'A' && c <= 'F')
                return 10 + c - 'A';
        else if (c >= '0' && c <= '9')
                return c - '0';
        else
                return -1;
 }
 char *convert_query_hexchar(char *txt)
 {
        int d1, d2, n;
        n = strlen(txt);
        if (n < 3) {
                *txt = '\0';
                return txt-1;
        }
        d1 = hextoint(*(txt+1));
        d2 = hextoint(*(txt+2));
        if (d1<0 || d2<0) {
                memmove(txt, txt+3, n-2);
                return txt-1;
        } else {
                *txt = d1 * 16 + d2;
                memmove(txt+1, txt+3, n-2);
                return txt;
        }
 }
-int http_parse_querystring(char *txt, void (*fn)(const char *name, const char *value))
+int http_parse_querystring(const char *txt_, void (*fn)(const char *name, const char *value))
 {
-        char *t, *value = NULL, c;
+        char *t, *txt, *value = NULL, c;
-        if (!txt)
+        if (!txt_)
                return 0;
-        t = txt = strdup(txt);
+        t = txt = strdup(txt_);
        if (t == NULL) {
                printf("Out of memory\n");
                exit(1);
        }
        while((c=*t) != '\0') {
                if (c=='=') {
                        *t = '\0';
                        value = t+1;
                } else if (c=='+') {
                        *t = ' ';
                } else if (c=='%') {
                        t = convert_query_hexchar(t);
                } else if (c=='&') {
                        *t = '\0';
                        (*fn)(txt, value);
                        txt = t+1;
                        value = NULL;
                }
                t++;
        }
        if (t!=txt)
                (*fn)(txt, value);
        return 0;
 }
diff --git a/html.h b/html.h
index a55d4b2..1135fb8 100644
--- a/html.h
+++ b/html.h
@@ -1,24 +1,27 @@
 #ifndef HTML_H
 #define HTML_H
 extern int htmlfd;
 extern void html_raw(const char *txt, size_t size);
 extern void html(const char *txt);
+__attribute__((format (printf,1,2)))
 extern void htmlf(const char *format,...);
 extern void html_status(int code, const char *msg, int more_headers);
-extern void html_txt(char *txt);
+extern void html_txt(const char *txt);
-extern void html_ntxt(int len, char *txt);
+extern void html_ntxt(int len, const char *txt);
-extern void html_attr(char *txt);
+extern void html_attr(const char *txt);
-extern void html_url_path(char *txt);
+extern void html_url_path(const char *txt);
-extern void html_url_arg(char *txt);
+extern void html_url_arg(const char *txt);
-extern void html_hidden(char *name, char *value);
+extern void html_hidden(const char *name, const char *value);
-extern void html_option(char *value, char *text, char *selected_value);
+extern void html_option(const char *value, const char *text, const char *selected_value);
-extern void html_link_open(char *url, char *title, char *class);
+extern void html_link_open(const char *url, const char *title, const char *class);
 extern void html_link_close(void);
 extern void html_fileperm(unsigned short mode);
 extern int html_include(const char *filename);
-extern int http_parse_querystring(char *txt, void (*fn)(const char *name, const char *value));
+extern int http_parse_querystring(const char *txt, void (*fn)(const char *name, const char *value));
 #endif /* HTML_H */
diff --git a/scan-tree.c b/scan-tree.c
index ebfd41e..627af1b 100644
--- a/scan-tree.c
+++ b/scan-tree.c
@@ -1,146 +1,241 @@
+/* scan-tree.c
+ * 
+ * Copyright (C) 2008-2009 Lars Hjemli
+ * Copyright (C) 2010 Jason A. Donenfeld <Jason@zx2c4.com>
+ *
+ * Licensed under GNU General Public License v2
+ *   (see COPYING for full license text)
+ */
 #include "cgit.h"
 #include "configfile.h"
 #include "html.h"
 #define MAX_PATH 4096
 /* return 1 if path contains a objects/ directory and a HEAD file */
 static int is_git_dir(const char *path)
 {
        struct stat st;
        static char buf[MAX_PATH];
        if (snprintf(buf, MAX_PATH, "%s/objects", path) >= MAX_PATH) {
                fprintf(stderr, "Insanely long path: %s\n", path);
                return 0;
        }
        if (stat(buf, &st)) {
                if (errno != ENOENT)
                        fprintf(stderr, "Error checking path %s: %s (%d)\n",
                                path, strerror(errno), errno);
                return 0;
        }
        if (!S_ISDIR(st.st_mode))
                return 0;
        sprintf(buf, "%s/HEAD", path);
        if (stat(buf, &st)) {
                if (errno != ENOENT)
                        fprintf(stderr, "Error checking path %s: %s (%d)\n",
                                path, strerror(errno), errno);
                return 0;
        }
        if (!S_ISREG(st.st_mode))
                return 0;
        return 1;
 }
 struct cgit_repo *repo;
 repo_config_fn config_fn;
+char *owner;
 static void repo_config(const char *name, const char *value)
 {
        config_fn(repo, name, value);
 }
+static int git_owner_config(const char *key, const char *value, void *cb)
+{
+        if (!strcmp(key, "gitweb.owner"))
+                owner = xstrdup(value);
+        return 0;
+}
+static char *xstrrchr(char *s, char *from, int c)
+{
+        while (from >= s && *from != c)
+                from--;
+        return from < s ? NULL : from;
+}
 static void add_repo(const char *base, const char *path, repo_config_fn fn)
 {
        struct stat st;
        struct passwd *pwd;
-        char *p;
+        char *rel, *p, *slash;
+        int n;
        size_t size;
        if (stat(path, &st)) {
                fprintf(stderr, "Error accessing %s: %s (%d)\n",
                        path, strerror(errno), errno);
                return;
        }
-        if ((pwd = getpwuid(st.st_uid)) == NULL) {
-                fprintf(stderr, "Error reading owner-info for %s: %s (%d)\n",
+        if (ctx.cfg.strict_export && stat(fmt("%s/%s", path, ctx.cfg.strict_export), &st))
-                        path, strerror(errno), errno);
                return;
-        }
+        if (!stat(fmt("%s/noweb", path), &st))
+                return;
+        owner = NULL;
+        if (ctx.cfg.enable_gitweb_owner)
+                git_config_from_file(git_owner_config, fmt("%s/config", path), NULL);
        if (base == path)
-                p = fmt("%s", path);
+                rel = xstrdup(fmt("%s", path));
        else
-                p = fmt("%s", path + strlen(base) + 1);
+                rel = xstrdup(fmt("%s", path + strlen(base) + 1));
-        if (!strcmp(p + strlen(p) - 5, "/.git"))
+        if (!strcmp(rel + strlen(rel) - 5, "/.git"))
-                p[strlen(p) - 5] = '\0';
+                rel[strlen(rel) - 5] = '\0';
-        repo = cgit_add_repo(xstrdup(p));
+        repo = cgit_add_repo(rel);
+        if (ctx.cfg.remove_suffix)
+                if ((p = strrchr(repo->url, '.')) && !strcmp(p, ".git"))
+                        *p = '\0';
        repo->name = repo->url;
        repo->path = xstrdup(path);
-        p = (pwd && pwd->pw_gecos) ? strchr(pwd->pw_gecos, ',') : NULL;
+        while (!owner) {
-        if (p)
+                if ((pwd = getpwuid(st.st_uid)) == NULL) {
-                *p = '\0';
+                        fprintf(stderr, "Error reading owner-info for %s: %s (%d)\n",
-        repo->owner = (pwd ? xstrdup(pwd->pw_gecos ? pwd->pw_gecos : pwd->pw_name) : "");
+                                path, strerror(errno), errno);
+                        break;
+                }
+                if (pwd->pw_gecos)
+                        if ((p = strchr(pwd->pw_gecos, ',')))
+                                *p = '\0';
+                owner = xstrdup(pwd->pw_gecos ? pwd->pw_gecos : pwd->pw_name);
+        }
+        repo->owner = owner;
        p = fmt("%s/description", path);
        if (!stat(p, &st))
                readfile(p, &repo->desc, &size);
-        p = fmt("%s/README.html", path);
+        if (!repo->readme) {
-        if (!stat(p, &st))
+                p = fmt("%s/README.html", path);
-                repo->readme = xstrdup(p);
+                if (!stat(p, &st))
+                        repo->readme = "README.html";
+        }
+        if (ctx.cfg.section_from_path) {
+                n  = ctx.cfg.section_from_path;
+                if (n > 0) {
+                        slash = rel;
+                        while (slash && n && (slash = strchr(slash, '/')))
+                                n--;
+                } else {
+                        slash = rel + strlen(rel);
+                        while (slash && n && (slash = xstrrchr(rel, slash, '/')))
+                                n++;
+                }
+                if (slash && !n) {
+                        *slash = '\0';
+                        repo->section = xstrdup(rel);
+                        *slash = '/';
+                        if (!prefixcmp(repo->name, repo->section)) {
+                                repo->name += strlen(repo->section);
+                                if (*repo->name == '/')
+                                        repo->name++;
+                        }
+                }
+        }
        p = fmt("%s/cgitrc", path);
        if (!stat(p, &st)) {
                config_fn = fn;
                parse_configfile(xstrdup(p), &repo_config);
        }
 }
 static void scan_path(const char *base, const char *path, repo_config_fn fn)
 {
-        DIR *dir;
+        DIR *dir = opendir(path);
        struct dirent *ent;
        char *buf;
        struct stat st;
+        if (!dir) {
+                fprintf(stderr, "Error opening directory %s: %s (%d)\n",
+                        path, strerror(errno), errno);
+                return;
+        }
        if (is_git_dir(path)) {
                add_repo(base, path, fn);
-                return;
+                goto end;
        }
        if (is_git_dir(fmt("%s/.git", path))) {
                add_repo(base, fmt("%s/.git", path), fn);
-                return;
+                goto end;
-        }
-        dir = opendir(path);
-        if (!dir) {
-                fprintf(stderr, "Error opening directory %s: %s (%d)\n",
-                        path, strerror(errno), errno);
-                return;
        }
        while((ent = readdir(dir)) != NULL) {
                if (ent->d_name[0] == '.') {
                        if (ent->d_name[1] == '\0')
                                continue;
                        if (ent->d_name[1] == '.' && ent->d_name[2] == '\0')
                                continue;
+                        if (!ctx.cfg.scan_hidden_path)
+                                continue;
                }
                buf = malloc(strlen(path) + strlen(ent->d_name) + 2);
                if (!buf) {
                        fprintf(stderr, "Alloc error on %s: %s (%d)\n",
                                path, strerror(errno), errno);
                        exit(1);
                }
                sprintf(buf, "%s/%s", path, ent->d_name);
                if (stat(buf, &st)) {
                        fprintf(stderr, "Error checking path %s: %s (%d)\n",
                                buf, strerror(errno), errno);
                        free(buf);
                        continue;
                }
                if (S_ISDIR(st.st_mode))
                        scan_path(base, buf, fn);
                free(buf);
        }
+end:
        closedir(dir);
 }
+#define lastc(s) s[strlen(s) - 1]
+void scan_projects(const char *path, const char *projectsfile, repo_config_fn fn)
+{
+        char line[MAX_PATH * 2], *z;
+        FILE *projects;
+        int err;
+        
+        projects = fopen(projectsfile, "r");
+        if (!projects) {
+                fprintf(stderr, "Error opening projectsfile %s: %s (%d)\n",
+                        projectsfile, strerror(errno), errno);
+        }
+        while (fgets(line, sizeof(line), projects) != NULL) {
+                for (z = &lastc(line);
+                     strlen(line) && strchr("\n\r", *z);
+                     z = &lastc(line))
+                        *z = '\0';
+                if (strlen(line))
+                        scan_path(path, fmt("%s/%s", path, line), fn);
+        }
+        if ((err = ferror(projects))) {
+                fprintf(stderr, "Error reading from projectsfile %s: %s (%d)\n",
+                        projectsfile, strerror(err), err);
+        }
+        fclose(projects);
+}
 void scan_tree(const char *path, repo_config_fn fn)
 {
        scan_path(path, path, fn);
 }
diff --git a/scan-tree.h b/scan-tree.h
index 11539f4..1afbd4b 100644
--- a/scan-tree.h
+++ b/scan-tree.h
@@ -1,3 +1,2 @@
+extern void scan_projects(const char *path, const char *projectsfile, repo_config_fn fn);
 extern void scan_tree(const char *path, repo_config_fn fn);
diff --git a/shared.c b/shared.c
index 6adf2b6..7ec2e19 100644
--- a/shared.c
+++ b/shared.c
@@ -1,88 +1,90 @@
 /* shared.c: global vars + some callback functions
 *
 * Copyright (C) 2006 Lars Hjemli
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include "cgit.h"
 struct cgit_repolist cgit_repolist;
 struct cgit_context ctx;
-int cgit_cmd;
 int chk_zero(int result, char *msg)
 {
        if (result != 0)
                die("%s: %s", msg, strerror(errno));
        return result;
 }
 int chk_positive(int result, char *msg)
 {
        if (result <= 0)
                die("%s: %s", msg, strerror(errno));
        return result;
 }
 int chk_non_negative(int result, char *msg)
 {
            if (result < 0)
                    die("%s: %s",msg, strerror(errno));
        return result;
 }
 struct cgit_repo *cgit_add_repo(const char *url)
 {
        struct cgit_repo *ret;
        if (++cgit_repolist.count > cgit_repolist.length) {
                if (cgit_repolist.length == 0)
                        cgit_repolist.length = 8;
                else
                        cgit_repolist.length *= 2;
                cgit_repolist.repos = xrealloc(cgit_repolist.repos,
                                               cgit_repolist.length *
                                               sizeof(struct cgit_repo));
        }
        ret = &cgit_repolist.repos[cgit_repolist.count-1];
        memset(ret, 0, sizeof(struct cgit_repo));
        ret->url = trim_end(url, '/');
        ret->name = ret->url;
        ret->path = NULL;
        ret->desc = "[no description]";
        ret->owner = NULL;
        ret->section = ctx.cfg.section;
        ret->defbranch = "master";
        ret->snapshots = ctx.cfg.snapshots;
+        ret->enable_commit_graph = ctx.cfg.enable_commit_graph;
        ret->enable_log_filecount = ctx.cfg.enable_log_filecount;
        ret->enable_log_linecount = ctx.cfg.enable_log_linecount;
+        ret->enable_remote_branches = ctx.cfg.enable_remote_branches;
+        ret->enable_subject_links = ctx.cfg.enable_subject_links;
        ret->max_stats = ctx.cfg.max_stats;
        ret->module_link = ctx.cfg.module_link;
-        ret->readme = NULL;
+        ret->readme = ctx.cfg.readme;
        ret->mtime = -1;
        ret->about_filter = ctx.cfg.about_filter;
        ret->commit_filter = ctx.cfg.commit_filter;
        ret->source_filter = ctx.cfg.source_filter;
        return ret;
 }
 struct cgit_repo *cgit_get_repoinfo(const char *url)
 {
        int i;
        struct cgit_repo *repo;
        for (i=0; i<cgit_repolist.count; i++) {
                repo = &cgit_repolist.repos[i];
                if (!strcmp(repo->url, url))
                        return repo;
        }
        return NULL;
 }
 void *cgit_free_commitinfo(struct commitinfo *info)
 {
        free(info->author);
        free(info->author_email);
@@ -241,125 +243,131 @@ int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf)
                /* we have a complete line */
                if (!diffbuf) {
                        ((linediff_fn)priv)(mb[i].ptr, mb[i].size);
                        continue;
                }
                diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
                memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
                ((linediff_fn)priv)(diffbuf, buflen + mb[i].size);
                free(diffbuf);
                diffbuf = NULL;
                buflen = 0;
        }
        if (diffbuf) {
                ((linediff_fn)priv)(diffbuf, buflen);
                free(diffbuf);
                diffbuf = NULL;
                buflen = 0;
        }
        return 0;
 }
 int cgit_diff_files(const unsigned char *old_sha1,
                    const unsigned char *new_sha1, unsigned long *old_size,
-                    unsigned long *new_size, int *binary, linediff_fn fn)
+                    unsigned long *new_size, int *binary, int context,
+                    int ignorews, linediff_fn fn)
 {
        mmfile_t file1, file2;
        xpparam_t diff_params;
        xdemitconf_t emit_params;
        xdemitcb_t emit_cb;
        if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1))
                return 1;
        *old_size = file1.size;
        *new_size = file2.size;
        if ((file1.ptr && buffer_is_binary(file1.ptr, file1.size)) ||
            (file2.ptr && buffer_is_binary(file2.ptr, file2.size))) {
                *binary = 1;
                if (file1.size)
                        free(file1.ptr);
                if (file2.size)
                        free(file2.ptr);
                return 0;
        }
        memset(&diff_params, 0, sizeof(diff_params));
        memset(&emit_params, 0, sizeof(emit_params));
        memset(&emit_cb, 0, sizeof(emit_cb));
        diff_params.flags = XDF_NEED_MINIMAL;
-        emit_params.ctxlen = 3;
+        if (ignorews)
+                diff_params.flags |= XDF_IGNORE_WHITESPACE;
+        emit_params.ctxlen = context > 0 ? context : 3;
        emit_params.flags = XDL_EMIT_FUNCNAMES;
        emit_cb.outf = filediff_cb;
        emit_cb.priv = fn;
        xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb);
        if (file1.size)
                free(file1.ptr);
        if (file2.size)
                free(file2.ptr);
        return 0;
 }
 void cgit_diff_tree(const unsigned char *old_sha1,
                    const unsigned char *new_sha1,
-                    filepair_fn fn, const char *prefix)
+                    filepair_fn fn, const char *prefix, int ignorews)
 {
        struct diff_options opt;
        int ret;
        int prefixlen;
        diff_setup(&opt);
        opt.output_format = DIFF_FORMAT_CALLBACK;
        opt.detect_rename = 1;
        opt.rename_limit = ctx.cfg.renamelimit;
        DIFF_OPT_SET(&opt, RECURSIVE);
+        if (ignorews)
+                DIFF_XDL_SET(&opt, IGNORE_WHITESPACE);
        opt.format_callback = cgit_diff_tree_cb;
        opt.format_callback_data = fn;
        if (prefix) {
                opt.nr_paths = 1;
                opt.paths = &prefix;
                prefixlen = strlen(prefix);
                opt.pathlens = &prefixlen;
        }
        diff_setup_done(&opt);
        if (old_sha1 && !is_null_sha1(old_sha1))
                ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt);
        else
                ret = diff_root_tree_sha1(new_sha1, "", &opt);
        diffcore_std(&opt);
        diff_flush(&opt);
 }
-void cgit_diff_commit(struct commit *commit, filepair_fn fn)
+void cgit_diff_commit(struct commit *commit, filepair_fn fn, const char *prefix)
 {
        unsigned char *old_sha1 = NULL;
        if (commit->parents)
                old_sha1 = commit->parents->item->object.sha1;
-        cgit_diff_tree(old_sha1, commit->object.sha1, fn, NULL);
+        cgit_diff_tree(old_sha1, commit->object.sha1, fn, prefix,
+                       ctx.qry.ignorews);
 }
 int cgit_parse_snapshots_mask(const char *str)
 {
        const struct cgit_snapshot_format *f;
        static const char *delim = " \t,:/|;";
        int tl, sl, rv = 0;
        /* favor legacy setting */
        if(atoi(str))
                return 1;
        for(;;) {
                str += strspn(str,delim);
                tl = strcspn(str,delim);
                if (!tl)
                        break;
                for (f = cgit_snapshot_formats; f->suffix; f++) {
                        sl = strlen(f->suffix);
                        if((tl == sl && !strncmp(f->suffix, str, tl)) ||
                           (tl == sl-1 && !strncmp(f->suffix+1, str, tl-1))) {
                                rv |= f->bit;
                                break;
                        }
                }
@@ -409,24 +417,95 @@ int cgit_close_filter(struct cgit_filter *filter)
 int readfile(const char *path, char **buf, size_t *size)
 {
        int fd, e;
        struct stat st;
        fd = open(path, O_RDONLY);
        if (fd == -1)
                return errno;
        if (fstat(fd, &st)) {
                e = errno;
                close(fd);
                return e;
        }
        if (!S_ISREG(st.st_mode)) {
                close(fd);
                return EISDIR;
        }
        *buf = xmalloc(st.st_size + 1);
        *size = read_in_full(fd, *buf, st.st_size);
        e = errno;
        (*buf)[*size] = '\0';
        close(fd);
        return (*size == st.st_size ? 0 : e);
 }
+int is_token_char(char c)
+{
+        return isalnum(c) || c == '_';
+}
+/* Replace name with getenv(name), return pointer to zero-terminating char
+ */
+char *expand_macro(char *name, int maxlength)
+{
+        char *value;
+        int len;
+        len = 0;
+        value = getenv(name);
+        if (value) {
+                len = strlen(value);
+                if (len > maxlength)
+                        len = maxlength;
+                strncpy(name, value, len);
+        }
+        return name + len;
+}
+#define EXPBUFSIZE (1024 * 8)
+/* Replace all tokens prefixed by '$' in the specified text with the
+ * value of the named environment variable.
+ * NB: the return value is a static buffer, i.e. it must be strdup'd
+ * by the caller.
+ */
+char *expand_macros(const char *txt)
+{
+        static char result[EXPBUFSIZE];
+        char *p, *start;
+        int len;
+        p = result;
+        start = NULL;
+        while (p < result + EXPBUFSIZE - 1 && txt && *txt) {
+                *p = *txt;
+                if (start) {
+                        if (!is_token_char(*txt)) {
+                                if (p - start > 0) {
+                                        *p = '\0';
+                                        len = result + EXPBUFSIZE - start - 1;
+                                        p = expand_macro(start, len) - 1;
+                                }
+                                start = NULL;
+                                txt--;
+                        }
+                        p++;
+                        txt++;
+                        continue;
+                }
+                if (*txt == '$') {
+                        start = p;
+                        txt++;
+                        continue;
+                }
+                p++;
+                txt++;
+        }
+        *p = '\0';
+        if (start && p - start > 0) {
+                len = result + EXPBUFSIZE - start - 1;
+                p = expand_macro(start, len);
+                *p = '\0';
+        }
+        return result;
+}
diff --git a/ui-atom.c b/ui-atom.c
index 881872c..b218456 100644
--- a/ui-atom.c
+++ b/ui-atom.c
@@ -3,49 +3,49 @@
 * Copyright (C) 2008 Lars Hjemli
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
 void add_entry(struct commit *commit, char *host)
 {
        char delim = '&';
        char *hex;
        char *mail, *t, *t2;
        struct commitinfo *info;
        info = cgit_parse_commit(commit);
        hex = sha1_to_hex(commit->object.sha1);
        html("<entry>\n");
        html("<title>");
        html_txt(info->subject);
        html("</title>\n");
        html("<updated>");
-        cgit_print_date(info->author_date, FMT_ATOMDATE, 0);
+        cgit_print_date(info->committer_date, FMT_ATOMDATE, 0);
        html("</updated>\n");
        html("<author>\n");
        if (info->author) {
                html("<name>");
                html_txt(info->author);
                html("</name>\n");
        }
        if (info->author_email && !ctx.cfg.noplainemail) {
                mail = xstrdup(info->author_email);
                t = strchr(mail, '<');
                if (t)
                        t++;
                else
                        t = mail;
                t2 = strchr(t, '>');
                if (t2)
                        *t2 = '\0';
                html("<email>");
                html_txt(t);
                html("</email>\n");
                free(mail);
        }
        html("</author>\n");
        html("<published>");
@@ -64,68 +64,78 @@ void add_entry(struct commit *commit, char *host)
        htmlf("<id>%s</id>\n", hex);
        html("<content type='text'>\n");
        html_txt(info->msg);
        html("</content>\n");
        html("<content type='xhtml'>\n");
        html("<div xmlns='http://www.w3.org/1999/xhtml'>\n");
        html("<pre>\n");
        html_txt(info->msg);
        html("</pre>\n");
        html("</div>\n");
        html("</content>\n");
        html("</entry>\n");
        cgit_free_commitinfo(info);
 }
 void cgit_print_atom(char *tip, char *path, int max_count)
 {
        char *host;
        const char *argv[] = {NULL, tip, NULL, NULL, NULL};
        struct commit *commit;
        struct rev_info rev;
        int argc = 2;
-        if (!tip)
+        if (ctx.qry.show_all)
+                argv[1] = "--all";
+        else if (!tip)
                argv[1] = ctx.qry.head;
        if (path) {
                argv[argc++] = "--";
                argv[argc++] = path;
        }
        init_revisions(&rev, NULL);
        rev.abbrev = DEFAULT_ABBREV;
        rev.commit_format = CMIT_FMT_DEFAULT;
        rev.verbose_header = 1;
        rev.show_root_diff = 0;
        rev.max_count = max_count;
        setup_revisions(argc, argv, &rev, NULL);
        prepare_revision_walk(&rev);
        host = cgit_hosturl();
        ctx.page.mimetype = "text/xml";
        ctx.page.charset = "utf-8";
        cgit_print_http_headers(&ctx);
        html("<feed xmlns='http://www.w3.org/2005/Atom'>\n");
        html("<title>");
        html_txt(ctx.repo->name);
+        if (path) {
+                html("/");
+                html_txt(path);
+        }
+        if (tip && !ctx.qry.show_all) {
+                html(", branch ");
+                html_txt(tip);
+        }
        html("</title>\n");
        html("<subtitle>");
        html_txt(ctx.repo->desc);
        html("</subtitle>\n");
        if (host) {
                html("<link rel='alternate' type='text/html' href='");
                html(cgit_httpscheme());
                html_attr(host);
                html_attr(cgit_repourl(ctx.repo->url));
                html("'/>\n");
        }
        while ((commit = get_revision(&rev)) != NULL) {
                add_entry(commit, host);
                free(commit->buffer);
                commit->buffer = NULL;
                free_commit_list(commit->parents);
                commit->parents = NULL;
        }
        html("</feed>\n");
 }
diff --git a/ui-blob.c b/ui-blob.c
index 89330ce..ec435e1 100644
--- a/ui-blob.c
+++ b/ui-blob.c
@@ -1,51 +1,84 @@
 /* ui-blob.c: show blob content
 *
 * Copyright (C) 2008 Lars Hjemli
+ * Copyright (C) 2010 Jason A. Donenfeld <Jason@zx2c4.com>
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
 static char *match_path;
 static unsigned char *matched_sha1;
+static int found_path;
 static int walk_tree(const unsigned char *sha1, const char *base,int baselen,
        const char *pathname, unsigned mode, int stage, void *cbdata) {
        if(strncmp(base,match_path,baselen)
                || strcmp(match_path+baselen,pathname) )
                return READ_TREE_RECURSIVE;
        memmove(matched_sha1,sha1,20);
+        found_path = 1;
        return 0;
 }
-void cgit_print_blob(const char *hex, char *path, const char *head)
+int cgit_print_file(char *path, const char *head)
 {
+        unsigned char sha1[20];
+        enum object_type type;
+        char *buf;
+        unsigned long size;
+        struct commit *commit;
+        const char *paths[] = {path, NULL};
+        if (get_sha1(head, sha1))
+                return -1;
+        type = sha1_object_info(sha1, &size);
+        if(type == OBJ_COMMIT && path) {
+                commit = lookup_commit_reference(sha1);
+                match_path = path;
+                matched_sha1 = sha1;
+                found_path = 0;
+                read_tree_recursive(commit->tree, "", 0, 0, paths, walk_tree, NULL);
+                if (!found_path)
+                        return -1;
+                type = sha1_object_info(sha1, &size);
+        }
+        if (type == OBJ_BAD)
+                return -1;
+        buf = read_sha1_file(sha1, &type, &size);
+        if (!buf)
+                return -1;
+        buf[size] = '\0';
+        html_raw(buf, size);
+        return 0;
+}
+void cgit_print_blob(const char *hex, char *path, const char *head)
+{
        unsigned char sha1[20];
        enum object_type type;
        char *buf;
        unsigned long size;
        struct commit *commit;
        const char *paths[] = {path, NULL};
        if (hex) {
                if (get_sha1_hex(hex, sha1)){
                        cgit_print_error(fmt("Bad hex value: %s", hex));
                        return;
                }
        } else {
                if (get_sha1(head,sha1)) {
                        cgit_print_error(fmt("Bad ref: %s", head));
                        return;
                }
        }
        type = sha1_object_info(sha1, &size);
        if((!hex) && type == OBJ_COMMIT && path) {
                commit = lookup_commit_reference(sha1);
                match_path = path;
@@ -54,26 +87,26 @@ void cgit_print_blob(const char *hex, char *path, const char *head)
                type = sha1_object_info(sha1,&size);
        }
        if (type == OBJ_BAD) {
                cgit_print_error(fmt("Bad object name: %s", hex));
                return;
        }
        buf = read_sha1_file(sha1, &type, &size);
        if (!buf) {
                cgit_print_error(fmt("Error reading object %s", hex));
                return;
        }
        buf[size] = '\0';
        ctx.page.mimetype = ctx.qry.mimetype;
        if (!ctx.page.mimetype) {
                if (buffer_is_binary(buf, size))
                        ctx.page.mimetype = "application/octet-stream";
                else
                        ctx.page.mimetype = "text/plain";
        }
        ctx.page.filename = path;
        cgit_print_http_headers(&ctx);
-        write(htmlfd, buf, size);
+        html_raw(buf, size);
 }
diff --git a/ui-blob.h b/ui-blob.h
index dad275a..d7e7d45 100644
--- a/ui-blob.h
+++ b/ui-blob.h
@@ -1,6 +1,7 @@
 #ifndef UI_BLOB_H
 #define UI_BLOB_H
+extern int cgit_print_file(char *path, const char *head);
 extern void cgit_print_blob(const char *hex, char *path, const char *head);
 #endif /* UI_BLOB_H */
diff --git a/ui-commit.c b/ui-commit.c
index f5b0ae5..2b4f677 100644
--- a/ui-commit.c
+++ b/ui-commit.c
@@ -1,118 +1,146 @@
 /* ui-commit.c: generate commit view
 *
 * Copyright (C) 2006 Lars Hjemli
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
 #include "ui-diff.h"
 #include "ui-log.h"
-void cgit_print_commit(char *hex)
+void cgit_print_commit(char *hex, const char *prefix)
 {
        struct commit *commit, *parent;
-        struct commitinfo *info;
+        struct commitinfo *info, *parent_info;
        struct commit_list *p;
+        struct strbuf notes = STRBUF_INIT;
        unsigned char sha1[20];
-        char *tmp;
+        char *tmp, *tmp2;
        int parents = 0;
        if (!hex)
                hex = ctx.qry.head;
        if (get_sha1(hex, sha1)) {
                cgit_print_error(fmt("Bad object id: %s", hex));
                return;
        }
        commit = lookup_commit_reference(sha1);
        if (!commit) {
                cgit_print_error(fmt("Bad commit reference: %s", hex));
                return;
        }
        info = cgit_parse_commit(commit);
+        format_note(NULL, sha1, &notes, PAGE_ENCODING, 0);
        load_ref_decorations(DECORATE_FULL_REFS);
        html("<table summary='commit info' class='commit-info'>\n");
        html("<tr><th>author</th><td>");
        html_txt(info->author);
        if (!ctx.cfg.noplainemail) {
                html(" ");
                html_txt(info->author_email);
        }
        html("</td><td class='right'>");
        cgit_print_date(info->author_date, FMT_LONGDATE, ctx.cfg.local_time);
        html("</td></tr>\n");
        html("<tr><th>committer</th><td>");
        html_txt(info->committer);
        if (!ctx.cfg.noplainemail) {
                html(" ");
                html_txt(info->committer_email);
        }
        html("</td><td class='right'>");
        cgit_print_date(info->committer_date, FMT_LONGDATE, ctx.cfg.local_time);
        html("</td></tr>\n");
        html("<tr><th>commit</th><td colspan='2' class='sha1'>");
        tmp = sha1_to_hex(commit->object.sha1);
-        cgit_commit_link(tmp, NULL, NULL, ctx.qry.head, tmp);
+        cgit_commit_link(tmp, NULL, NULL, ctx.qry.head, tmp, prefix, 0);
        html(" (");
-        cgit_patch_link("patch", NULL, NULL, NULL, tmp);
+        cgit_patch_link("patch", NULL, NULL, NULL, tmp, prefix);
+        html(") (");
+        if ((ctx.qry.ssdiff && !ctx.cfg.ssdiff) || (!ctx.qry.ssdiff && ctx.cfg.ssdiff))
+                cgit_commit_link("unidiff", NULL, NULL, ctx.qry.head, tmp, prefix, 1);
+        else
+                cgit_commit_link("side-by-side diff", NULL, NULL, ctx.qry.head, tmp, prefix, 1);
        html(")</td></tr>\n");
        html("<tr><th>tree</th><td colspan='2' class='sha1'>");
        tmp = xstrdup(hex);
        cgit_tree_link(sha1_to_hex(commit->tree->object.sha1), NULL, NULL,
                       ctx.qry.head, tmp, NULL);
+        if (prefix) {
+                html(" /");
+                cgit_tree_link(prefix, NULL, NULL, ctx.qry.head, tmp, prefix);
+        }
        html("</td></tr>\n");
              for (p = commit->parents; p ; p = p->next) {
                parent = lookup_commit_reference(p->item->object.sha1);
                if (!parent) {
                        html("<tr><td colspan='3'>");
                        cgit_print_error("Error reading parent commit");
                        html("</td></tr>");
                        continue;
                }
                html("<tr><th>parent</th>"
                     "<td colspan='2' class='sha1'>");
-                cgit_commit_link(sha1_to_hex(p->item->object.sha1), NULL, NULL,
+                tmp = tmp2 = sha1_to_hex(p->item->object.sha1);
-                                 ctx.qry.head, sha1_to_hex(p->item->object.sha1));
+                if (ctx.repo->enable_subject_links) {
+                        parent_info = cgit_parse_commit(parent);
+                        tmp2 = parent_info->subject;
+                }
+                cgit_commit_link(tmp2, NULL, NULL, ctx.qry.head, tmp, prefix, 0);
                html(" (");
                cgit_diff_link("diff", NULL, NULL, ctx.qry.head, hex,
-                               sha1_to_hex(p->item->object.sha1), NULL);
+                               sha1_to_hex(p->item->object.sha1), prefix, 0);
                html(")</td></tr>");
                parents++;
        }
        if (ctx.repo->snapshots) {
                html("<tr><th>download</th><td colspan='2' class='sha1'>");
                cgit_print_snapshot_links(ctx.qry.repo, ctx.qry.head,
                                          hex, ctx.repo->snapshots);
                html("</td></tr>");
        }
        html("</table>\n");
        html("<div class='commit-subject'>");
        if (ctx.repo->commit_filter)
                cgit_open_filter(ctx.repo->commit_filter);
        html_txt(info->subject);
        if (ctx.repo->commit_filter)
                cgit_close_filter(ctx.repo->commit_filter);
        show_commit_decorations(commit);
        html("</div>");
        html("<div class='commit-msg'>");
        if (ctx.repo->commit_filter)
                cgit_open_filter(ctx.repo->commit_filter);
        html_txt(info->msg);
        if (ctx.repo->commit_filter)
                cgit_close_filter(ctx.repo->commit_filter);
        html("</div>");
+        if (notes.len != 0) {
+                html("<div class='notes-header'>Notes</div>");
+                html("<div class='notes'>");
+                if (ctx.repo->commit_filter)
+                        cgit_open_filter(ctx.repo->commit_filter);
+                html_txt(notes.buf);
+                if (ctx.repo->commit_filter)
+                        cgit_close_filter(ctx.repo->commit_filter);
+                html("</div>");
+                html("<div class='notes-footer'></div>");
+        }
        if (parents < 3) {
                if (parents)
                        tmp = sha1_to_hex(commit->parents->item->object.sha1);
                else
                        tmp = NULL;
-                cgit_print_diff(ctx.qry.sha1, tmp, NULL);
+                cgit_print_diff(ctx.qry.sha1, tmp, prefix);
        }
+        strbuf_release(&notes);
        cgit_free_commitinfo(info);
 }
diff --git a/ui-commit.h b/ui-commit.h
index 40bcb31..8198b4b 100644
--- a/ui-commit.h
+++ b/ui-commit.h
@@ -1,6 +1,6 @@
 #ifndef UI_COMMIT_H
 #define UI_COMMIT_H
-extern void cgit_print_commit(char *hex);
+extern void cgit_print_commit(char *hex, const char *prefix);
 #endif /* UI_COMMIT_H */
diff --git a/ui-diff.c b/ui-diff.c
index 2196745..a53425d 100644
--- a/ui-diff.c
+++ b/ui-diff.c
@@ -1,58 +1,71 @@
 /* ui-diff.c: show diff between two blobs
 *
 * Copyright (C) 2006 Lars Hjemli
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
+#include "ui-ssdiff.h"
 unsigned char old_rev_sha1[20];
 unsigned char new_rev_sha1[20];
 static int files, slots;
 static int total_adds, total_rems, max_changes;
 static int lines_added, lines_removed;
 static struct fileinfo {
        char status;
        unsigned char old_sha1[20];
        unsigned char new_sha1[20];
        unsigned short old_mode;
        unsigned short new_mode;
        char *old_path;
        char *new_path;
        unsigned int added;
        unsigned int removed;
        unsigned long old_size;
        unsigned long new_size;
        int binary:1;
 } *items;
+static int use_ssdiff = 0;
+static struct diff_filepair *current_filepair;
+struct diff_filespec *cgit_get_current_old_file(void)
+{
+        return current_filepair->one;
+}
+struct diff_filespec *cgit_get_current_new_file(void)
+{
+        return current_filepair->two;
+}
 static void print_fileinfo(struct fileinfo *info)
 {
        char *class;
        switch (info->status) {
        case DIFF_STATUS_ADDED:
                class = "add";
                break;
        case DIFF_STATUS_COPIED:
                class = "cpy";
                break;
        case DIFF_STATUS_DELETED:
                class = "del";
                break;
        case DIFF_STATUS_MODIFIED:
                class = "upd";
                break;
        case DIFF_STATUS_RENAMED:
                class = "mov";
                break;
        case DIFF_STATUS_TYPE_CHANGED:
                class = "typ";
                break;
@@ -62,128 +75,144 @@ static void print_fileinfo(struct fileinfo *info)
        case DIFF_STATUS_UNMERGED:
                class = "stg";
                break;
        default:
                die("bug: unhandled diff status %c", info->status);
        }
        html("<tr>");
        htmlf("<td class='mode'>");
        if (is_null_sha1(info->new_sha1)) {
                cgit_print_filemode(info->old_mode);
        } else {
                cgit_print_filemode(info->new_mode);
        }
        if (info->old_mode != info->new_mode &&
            !is_null_sha1(info->old_sha1) &&
            !is_null_sha1(info->new_sha1)) {
                html("<span class='modechange'>[");
                cgit_print_filemode(info->old_mode);
                html("]</span>");
        }
        htmlf("</td><td class='%s'>", class);
        cgit_diff_link(info->new_path, NULL, NULL, ctx.qry.head, ctx.qry.sha1,
-                       ctx.qry.sha2, info->new_path);
+                       ctx.qry.sha2, info->new_path, 0);
        if (info->status == DIFF_STATUS_COPIED || info->status == DIFF_STATUS_RENAMED)
                htmlf(" (%s from %s)",
                      info->status == DIFF_STATUS_COPIED ? "copied" : "renamed",
                      info->old_path);
        html("</td><td class='right'>");
        if (info->binary) {
-                htmlf("bin</td><td class='graph'>%d -> %d bytes",
+                htmlf("bin</td><td class='graph'>%ld -> %ld bytes",
                      info->old_size, info->new_size);
                return;
        }
        htmlf("%d", info->added + info->removed);
        html("</td><td class='graph'>");
        htmlf("<table summary='file diffstat' width='%d%%'><tr>", (max_changes > 100 ? 100 : max_changes));
        htmlf("<td class='add' style='width: %.1f%%;'/>",
              info->added * 100.0 / max_changes);
        htmlf("<td class='rem' style='width: %.1f%%;'/>",
              info->removed * 100.0 / max_changes);
        htmlf("<td class='none' style='width: %.1f%%;'/>",
              (max_changes - info->removed - info->added) * 100.0 / max_changes);
        html("</tr></table></td></tr>\n");
 }
 static void count_diff_lines(char *line, int len)
 {
        if (line && (len > 0)) {
                if (line[0] == '+')
                        lines_added++;
                else if (line[0] == '-')
                        lines_removed++;
        }
 }
 static void inspect_filepair(struct diff_filepair *pair)
 {
        int binary = 0;
        unsigned long old_size = 0;
        unsigned long new_size = 0;
        files++;
        lines_added = 0;
        lines_removed = 0;
        cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, &new_size,
-                        &binary, count_diff_lines);
+                        &binary, 0, ctx.qry.ignorews, count_diff_lines);
        if (files >= slots) {
                if (slots == 0)
                        slots = 4;
                else
                        slots = slots * 2;
                items = xrealloc(items, slots * sizeof(struct fileinfo));
        }
        items[files-1].status = pair->status;
        hashcpy(items[files-1].old_sha1, pair->one->sha1);
        hashcpy(items[files-1].new_sha1, pair->two->sha1);
        items[files-1].old_mode = pair->one->mode;
        items[files-1].new_mode = pair->two->mode;
        items[files-1].old_path = xstrdup(pair->one->path);
        items[files-1].new_path = xstrdup(pair->two->path);
        items[files-1].added = lines_added;
        items[files-1].removed = lines_removed;
        items[files-1].old_size = old_size;
        items[files-1].new_size = new_size;
        items[files-1].binary = binary;
        if (lines_added + lines_removed > max_changes)
                max_changes = lines_added + lines_removed;
        total_adds += lines_added;
        total_rems += lines_removed;
 }
 void cgit_print_diffstat(const unsigned char *old_sha1,
-                         const unsigned char *new_sha1)
+                         const unsigned char *new_sha1, const char *prefix)
 {
-        int i;
+        int i, save_context = ctx.qry.context;
        html("<div class='diffstat-header'>");
        cgit_diff_link("Diffstat", NULL, NULL, ctx.qry.head, ctx.qry.sha1,
-                       ctx.qry.sha2, NULL);
+                       ctx.qry.sha2, NULL, 0);
+        if (prefix)
+                htmlf(" (limited to '%s')", prefix);
+        html(" (");
+        ctx.qry.context = (save_context > 0 ? save_context : 3) << 1;
+        cgit_self_link("more", NULL, NULL, &ctx);
+        html("/");
+        ctx.qry.context = (save_context > 3 ? save_context : 3) >> 1;
+        cgit_self_link("less", NULL, NULL, &ctx);
+        ctx.qry.context = save_context;
+        html(" context)");
+        html(" (");
+        ctx.qry.ignorews = (ctx.qry.ignorews + 1) % 2;
+        cgit_self_link(ctx.qry.ignorews ? "ignore" : "show", NULL, NULL, &ctx);
+        ctx.qry.ignorews = (ctx.qry.ignorews + 1) % 2;
+        html(" whitespace changes)");
        html("</div>");
        html("<table summary='diffstat' class='diffstat'>");
        max_changes = 0;
-        cgit_diff_tree(old_sha1, new_sha1, inspect_filepair, NULL);
+        cgit_diff_tree(old_sha1, new_sha1, inspect_filepair, prefix,
+                       ctx.qry.ignorews);
        for(i = 0; i<files; i++)
                print_fileinfo(&items[i]);
        html("</table>");
        html("<div class='diffstat-summary'>");
        htmlf("%d files changed, %d insertions, %d deletions",
              files, total_adds, total_rems);
        html("</div>");
 }
 /*
 * print a single line returned from xdiff
 */
 static void print_line(char *line, int len)
 {
        char *class = "ctx";
        char c = line[len-1];
        if (line[0] == '+')
                class = "add";
        else if (line[0] == '-')
                class = "del";
        else if (line[0] == '@')
                class = "hunk";
@@ -225,89 +254,130 @@ static void header(unsigned char *sha1, char *path1, int mode1,
                htmlf("<br/>index %s..%s", abbrev1, abbrev2);
                free(abbrev1);
                free(abbrev2);
                if (mode1 != 0 && mode2 != 0) {
                        htmlf(" %.6o", mode1);
                        if (mode2 != mode1)
                                htmlf("..%.6o", mode2);
                }
                html("<br/>--- a/");
                if (mode1 != 0)
                        cgit_tree_link(path1, NULL, NULL, ctx.qry.head,
                                       sha1_to_hex(old_rev_sha1), path1);
                else
                        html_txt(path1);
                html("<br/>+++ b/");
                if (mode2 != 0)
                        cgit_tree_link(path2, NULL, NULL, ctx.qry.head,
                                       sha1_to_hex(new_rev_sha1), path2);
                else
                        html_txt(path2);
        }
        html("</div>");
 }
+static void print_ssdiff_link()
+{
+        if (!strcmp(ctx.qry.page, "diff")) {
+                if (use_ssdiff)
+                        cgit_diff_link("Unidiff", NULL, NULL, ctx.qry.head,
+                                       ctx.qry.sha1, ctx.qry.sha2, ctx.qry.path, 1);
+                else
+                        cgit_diff_link("Side-by-side diff", NULL, NULL,
+                                       ctx.qry.head, ctx.qry.sha1,
+                                       ctx.qry.sha2, ctx.qry.path, 1);
+        }
+}
 static void filepair_cb(struct diff_filepair *pair)
 {
        unsigned long old_size = 0;
        unsigned long new_size = 0;
        int binary = 0;
+        linediff_fn print_line_fn = print_line;
+        current_filepair = pair;
+        if (use_ssdiff) {
+                cgit_ssdiff_header_begin();
+                print_line_fn = cgit_ssdiff_line_cb;
+        }
        header(pair->one->sha1, pair->one->path, pair->one->mode,
               pair->two->sha1, pair->two->path, pair->two->mode);
+        if (use_ssdiff)
+                cgit_ssdiff_header_end();
        if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) {
                if (S_ISGITLINK(pair->one->mode))
-                        print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52);
+                        print_line_fn(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52);
                if (S_ISGITLINK(pair->two->mode))
-                        print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52);
+                        print_line_fn(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52);
+                if (use_ssdiff)
+                        cgit_ssdiff_footer();
                return;
        }
-        if (cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, 
+        if (cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size,
-                            &new_size, &binary, print_line))
+                            &new_size, &binary, ctx.qry.context,
+                            ctx.qry.ignorews, print_line_fn))
                cgit_print_error("Error running diff");
-        if (binary)
+        if (binary) {
-                html("Binary files differ");
+                if (use_ssdiff)
+                        html("<tr><td colspan='4'>Binary files differ</td></tr>");
+                else
+                        html("Binary files differ");
+        }
+        if (use_ssdiff)
+                cgit_ssdiff_footer();
 }
 void cgit_print_diff(const char *new_rev, const char *old_rev, const char *prefix)
 {
        enum object_type type;
        unsigned long size;
        struct commit *commit, *commit2;
        if (!new_rev)
                new_rev = ctx.qry.head;
        get_sha1(new_rev, new_rev_sha1);
        type = sha1_object_info(new_rev_sha1, &size);
        if (type == OBJ_BAD) {
                cgit_print_error(fmt("Bad object name: %s", new_rev));
                return;
        }
        commit = lookup_commit_reference(new_rev_sha1);
        if (!commit || parse_commit(commit))
                cgit_print_error(fmt("Bad commit: %s", sha1_to_hex(new_rev_sha1)));
        if (old_rev)
                get_sha1(old_rev, old_rev_sha1);
        else if (commit->parents && commit->parents->item)
                hashcpy(old_rev_sha1, commit->parents->item->object.sha1);
        else
                hashclr(old_rev_sha1);
        if (!is_null_sha1(old_rev_sha1)) {
                type = sha1_object_info(old_rev_sha1, &size);
                if (type == OBJ_BAD) {
                        cgit_print_error(fmt("Bad object name: %s", sha1_to_hex(old_rev_sha1)));
                        return;
                }
                commit2 = lookup_commit_reference(old_rev_sha1);
                if (!commit2 || parse_commit(commit2))
                        cgit_print_error(fmt("Bad commit: %s", sha1_to_hex(old_rev_sha1)));
        }
-        cgit_print_diffstat(old_rev_sha1, new_rev_sha1);
-        html("<table summary='diff' class='diff'>");
+        if ((ctx.qry.ssdiff && !ctx.cfg.ssdiff) || (!ctx.qry.ssdiff && ctx.cfg.ssdiff))
-        html("<tr><td>");
+                use_ssdiff = 1;
-        cgit_diff_tree(old_rev_sha1, new_rev_sha1, filepair_cb, prefix);
-        html("</td></tr>");
+        print_ssdiff_link();
+        cgit_print_diffstat(old_rev_sha1, new_rev_sha1, prefix);
+        if (use_ssdiff) {
+                html("<table summary='ssdiff' class='ssdiff'>");
+        } else {
+                html("<table summary='diff' class='diff'>");
+                html("<tr><td>");
+        }
+        cgit_diff_tree(old_rev_sha1, new_rev_sha1, filepair_cb, prefix,
+                       ctx.qry.ignorews);
+        if (!use_ssdiff)
+                html("</td></tr>");
        html("</table>");
 }
diff --git a/ui-diff.h b/ui-diff.h
index 70b2926..12d0c62 100644
--- a/ui-diff.h
+++ b/ui-diff.h
@@ -1,10 +1,16 @@
 #ifndef UI_DIFF_H
 #define UI_DIFF_H
 extern void cgit_print_diffstat(const unsigned char *old_sha1,
                                const unsigned char *new_sha1);
 extern void cgit_print_diff(const char *new_hex, const char *old_hex,
                            const char *prefix);
+extern struct diff_filespec *cgit_get_current_old_file(void);
+extern struct diff_filespec *cgit_get_current_new_file(void);
+extern unsigned char old_rev_sha1[20];
+extern unsigned char new_rev_sha1[20];
 #endif /* UI_DIFF_H */
diff --git a/ui-log.c b/ui-log.c
index f3132c9..8add66a 100644
--- a/ui-log.c
+++ b/ui-log.c
@@ -1,234 +1,428 @@
 /* ui-log.c: functions for log output
 *
 * Copyright (C) 2006 Lars Hjemli
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
+#include "vector.h"
 int files, add_lines, rem_lines;
+/*
+ * The list of available column colors in the commit graph.
+ */
+static const char *column_colors_html[] = {
+        "<span class='column1'>",
+        "<span class='column2'>",
+        "<span class='column3'>",
+        "<span class='column4'>",
+        "<span class='column5'>",
+        "<span class='column6'>",
+        "</span>",
+};
+#define COLUMN_COLORS_HTML_MAX (ARRAY_SIZE(column_colors_html) - 1)
 void count_lines(char *line, int size)
 {
        if (size <= 0)
                return;
        if (line[0] == '+')
                add_lines++;
        else if (line[0] == '-')
                rem_lines++;
 }
 void inspect_files(struct diff_filepair *pair)
 {
        unsigned long old_size = 0;
        unsigned long new_size = 0;
        int binary = 0;
        files++;
        if (ctx.repo->enable_log_linecount)
                cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size,
-                                &new_size, &binary, count_lines);
+                                &new_size, &binary, 0, ctx.qry.ignorews,
+                                count_lines);
 }
 void show_commit_decorations(struct commit *commit)
 {
        struct name_decoration *deco;
        static char buf[1024];
        buf[sizeof(buf) - 1] = 0;
        deco = lookup_decoration(&name_decoration, &commit->object);
        while (deco) {
                if (!prefixcmp(deco->name, "refs/heads/")) {
                        strncpy(buf, deco->name + 11, sizeof(buf) - 1);
-                        cgit_log_link(buf, NULL, "branch-deco", buf, NULL, NULL,
+                        cgit_log_link(buf, NULL, "branch-deco", buf, NULL,
-                                0, NULL, NULL, ctx.qry.showmsg);
+                                      ctx.qry.vpath, 0, NULL, NULL,
+                                      ctx.qry.showmsg);
                }
                else if (!prefixcmp(deco->name, "tag: refs/tags/")) {
                        strncpy(buf, deco->name + 15, sizeof(buf) - 1);
                        cgit_tag_link(buf, NULL, "tag-deco", ctx.qry.head, buf);
                }
                else if (!prefixcmp(deco->name, "refs/tags/")) {
                        strncpy(buf, deco->name + 10, sizeof(buf) - 1);
                        cgit_tag_link(buf, NULL, "tag-deco", ctx.qry.head, buf);
                }
                else if (!prefixcmp(deco->name, "refs/remotes/")) {
                        strncpy(buf, deco->name + 13, sizeof(buf) - 1);
                        cgit_log_link(buf, NULL, "remote-deco", NULL,
-                                sha1_to_hex(commit->object.sha1), NULL,
+                                      sha1_to_hex(commit->object.sha1),
-                                0, NULL, NULL, ctx.qry.showmsg);
+                                      ctx.qry.vpath, 0, NULL, NULL,
+                                      ctx.qry.showmsg);
                }
                else {
                        strncpy(buf, deco->name, sizeof(buf) - 1);
                        cgit_commit_link(buf, NULL, "deco", ctx.qry.head,
-                                sha1_to_hex(commit->object.sha1));
+                                         sha1_to_hex(commit->object.sha1),
+                                         ctx.qry.vpath, 0);
                }
                deco = deco->next;
        }
 }
-void print_commit(struct commit *commit)
+void print_commit(struct commit *commit, struct rev_info *revs)
 {
        struct commitinfo *info;
        char *tmp;
-        int cols = 2;
+        int cols = revs->graph ? 3 : 2;
+        struct strbuf graphbuf = STRBUF_INIT;
+        struct strbuf msgbuf = STRBUF_INIT;
+        if (ctx.repo->enable_log_filecount) {
+                cols++;
+                if (ctx.repo->enable_log_linecount)
+                        cols++;
+        }
+        if (revs->graph) {
+                /* Advance graph until current commit */
+                while (!graph_next_line(revs->graph, &graphbuf)) {
+                        /* Print graph segment in otherwise empty table row */
+                        html("<tr class='nohover'><td class='commitgraph'>");
+                        html(graphbuf.buf);
+                        htmlf("</td><td colspan='%d' /></tr>\n", cols);
+                        strbuf_setlen(&graphbuf, 0);
+                }
+                /* Current commit's graph segment is now ready in graphbuf */
+        }
        info = cgit_parse_commit(commit);
-        htmlf("<tr%s><td>",
+        htmlf("<tr%s>", ctx.qry.showmsg ? " class='logheader'" : "");
-                ctx.qry.showmsg ? " class='logheader'" : "");
-        tmp = fmt("id=%s", sha1_to_hex(commit->object.sha1));
+        if (revs->graph) {
-        tmp = cgit_pageurl(ctx.repo->url, "commit", tmp);
+                /* Print graph segment for current commit */
-        html_link_open(tmp, NULL, NULL);
+                html("<td class='commitgraph'>");
-        cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE);
+                html(graphbuf.buf);
-        html_link_close();
+                html("</td>");
-        htmlf("</td><td%s>",
+                strbuf_setlen(&graphbuf, 0);
-                ctx.qry.showmsg ? " class='logsubject'" : "");
+        }
+        else {
+                html("<td>");
+                tmp = fmt("id=%s", sha1_to_hex(commit->object.sha1));
+                tmp = cgit_fileurl(ctx.repo->url, "commit", ctx.qry.vpath, tmp);
+                html_link_open(tmp, NULL, NULL);
+                cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE);
+                html_link_close();
+                html("</td>");
+        }
+        htmlf("<td%s>", ctx.qry.showmsg ? " class='logsubject'" : "");
+        if (ctx.qry.showmsg) {
+                /* line-wrap long commit subjects instead of truncating them */
+                size_t subject_len = strlen(info->subject);
+                if (subject_len > ctx.cfg.max_msg_len &&
+                    ctx.cfg.max_msg_len >= 15) {
+                        /* symbol for signaling line-wrap (in PAGE_ENCODING) */
+                        const char wrap_symbol[] = { ' ', 0xE2, 0x86, 0xB5, 0 };
+                        int i = ctx.cfg.max_msg_len - strlen(wrap_symbol);
+                        /* Rewind i to preceding space character */
+                        while (i > 0 && !isspace(info->subject[i]))
+                                --i;
+                        if (!i) /* Oops, zero spaces. Reset i */
+                                i = ctx.cfg.max_msg_len - strlen(wrap_symbol);
+                        /* add remainder starting at i to msgbuf */
+                        strbuf_add(&msgbuf, info->subject + i, subject_len - i);
+                        strbuf_trim(&msgbuf);
+                        strbuf_add(&msgbuf, "\n\n", 2);
+                        /* Place wrap_symbol at position i in info->subject */
+                        strcpy(info->subject + i, wrap_symbol);
+                }
+        }
        cgit_commit_link(info->subject, NULL, NULL, ctx.qry.head,
-                         sha1_to_hex(commit->object.sha1));
+                         sha1_to_hex(commit->object.sha1), ctx.qry.vpath, 0);
        show_commit_decorations(commit);
        html("</td><td>");
        html_txt(info->author);
+        if (revs->graph) {
+                html("</td><td>");
+                tmp = fmt("id=%s", sha1_to_hex(commit->object.sha1));
+                tmp = cgit_fileurl(ctx.repo->url, "commit", ctx.qry.vpath, tmp);
+                html_link_open(tmp, NULL, NULL);
+                cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE);
+                html_link_close();
+        }
        if (ctx.repo->enable_log_filecount) {
                files = 0;
                add_lines = 0;
                rem_lines = 0;
-                cgit_diff_commit(commit, inspect_files);
+                cgit_diff_commit(commit, inspect_files, ctx.qry.vpath);
                html("</td><td>");
                htmlf("%d", files);
                if (ctx.repo->enable_log_linecount) {
                        html("</td><td>");
                        htmlf("-%d/+%d", rem_lines, add_lines);
                }
        }
        html("</td></tr>\n");
-        if (ctx.qry.showmsg) {
-                if (ctx.repo->enable_log_filecount) {
+        if (revs->graph || ctx.qry.showmsg) { /* Print a second table row */
-                        cols++;
+                html("<tr class='nohover'>");
-                        if (ctx.repo->enable_log_linecount)
-                                cols++;
+                if (ctx.qry.showmsg) {
+                        /* Concatenate commit message + notes in msgbuf */
+                        if (info->msg && *(info->msg)) {
+                                strbuf_addstr(&msgbuf, info->msg);
+                                strbuf_addch(&msgbuf, '\n');
+                        }
+                        format_note(NULL, commit->object.sha1, &msgbuf,
+                                    PAGE_ENCODING,
+                                    NOTES_SHOW_HEADER | NOTES_INDENT);
+                        strbuf_addch(&msgbuf, '\n');
+                        strbuf_ltrim(&msgbuf);
+                }
+                if (revs->graph) {
+                        int lines = 0;
+                        /* Calculate graph padding */
+                        if (ctx.qry.showmsg) {
+                                /* Count #lines in commit message + notes */
+                                const char *p = msgbuf.buf;
+                                lines = 1;
+                                while ((p = strchr(p, '\n'))) {
+                                        p++;
+                                        lines++;
+                                }
+                        }
+                        /* Print graph padding */
+                        html("<td class='commitgraph'>");
+                        while (lines > 0 || !graph_is_commit_finished(revs->graph)) {
+                                if (graphbuf.len)
+                                        html("\n");
+                                strbuf_setlen(&graphbuf, 0);
+                                graph_next_line(revs->graph, &graphbuf);
+                                html(graphbuf.buf);
+                                lines--;
+                        }
+                        html("</td>\n");
                }
-                htmlf("<tr class='nohover'><td/><td colspan='%d' class='logmsg'>",
+                else
-                        cols);
+                        html("<td/>"); /* Empty 'Age' column */
-                html_txt(info->msg);
+                /* Print msgbuf into remainder of table row */
+                htmlf("<td colspan='%d'%s>\n", cols,
+                        ctx.qry.showmsg ? " class='logmsg'" : "");
+                html_txt(msgbuf.buf);
                html("</td></tr>\n");
        }
+        strbuf_release(&msgbuf);
+        strbuf_release(&graphbuf);
        cgit_free_commitinfo(info);
 }
 static const char *disambiguate_ref(const char *ref)
 {
        unsigned char sha1[20];
        const char *longref;
        longref = fmt("refs/heads/%s", ref);
        if (get_sha1(longref, sha1) == 0)
                return longref;
        return ref;
 }
+static char *next_token(char **src)
+{
+        char *result;
+        if (!src || !*src)
+                return NULL;
+        while (isspace(**src))
+                (*src)++;
+        if (!**src)
+                return NULL;
+        result = *src;
+        while (**src) {
+                if (isspace(**src)) {
+                        **src = '\0';
+                        (*src)++;
+                        break;
+                }
+                (*src)++;
+        }
+        return result;
+}
 void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern,
-                    char *path, int pager)
+                    char *path, int pager, int commit_graph)
 {
        struct rev_info rev;
        struct commit *commit;
-        const char *argv[] = {NULL, NULL, NULL, NULL, NULL};
+        struct vector vec = VECTOR_INIT(char *);
-        int argc = 2;
        int i, columns = 3;
+        char *arg;
+        /* First argv is NULL */
+        vector_push(&vec, NULL, 0);
        if (!tip)
                tip = ctx.qry.head;
+        tip = disambiguate_ref(tip);
+        vector_push(&vec, &tip, 0);
-        argv[1] = disambiguate_ref(tip);
+        if (grep && pattern && *pattern) {
+                pattern = xstrdup(pattern);
-        if (grep && pattern && (!strcmp(grep, "grep") ||
+                if (!strcmp(grep, "grep") || !strcmp(grep, "author") ||
-                                !strcmp(grep, "author") ||
+                    !strcmp(grep, "committer")) {
-                                !strcmp(grep, "committer")))
+                        arg = fmt("--%s=%s", grep, pattern);
-                argv[argc++] = fmt("--%s=%s", grep, pattern);
+                        vector_push(&vec, &arg, 0);
+                }
+                if (!strcmp(grep, "range")) {
+                        /* Split the pattern at whitespace and add each token
+                         * as a revision expression. Do not accept other
+                         * rev-list options. Also, replace the previously
+                         * pushed tip (it's no longer relevant).
+                         */
+                        vec.count--;
+                        while ((arg = next_token(&pattern))) {
+                                if (*arg == '-') {
+                                        fprintf(stderr, "Bad range expr: %s\n",
+                                                arg);
+                                        break;
+                                }
+                                vector_push(&vec, &arg, 0);
+                        }
+                }
+        }
+        if (commit_graph) {
+                static const char *graph_arg = "--graph";
+                static const char *color_arg = "--color";
+                vector_push(&vec, &graph_arg, 0);
+                vector_push(&vec, &color_arg, 0);
+                graph_set_column_colors(column_colors_html,
+                                        COLUMN_COLORS_HTML_MAX);
+        }
        if (path) {
-                argv[argc++] = "--";
+                arg = "--";
-                argv[argc++] = path;
+                vector_push(&vec, &arg, 0);
+                vector_push(&vec, &path, 0);
        }
+        /* Make sure the vector is NULL-terminated */
+        vector_push(&vec, NULL, 0);
+        vec.count--;
        init_revisions(&rev, NULL);
        rev.abbrev = DEFAULT_ABBREV;
        rev.commit_format = CMIT_FMT_DEFAULT;
        rev.verbose_header = 1;
        rev.show_root_diff = 0;
-        setup_revisions(argc, argv, &rev, NULL);
+        setup_revisions(vec.count, vec.data, &rev, NULL);
        load_ref_decorations(DECORATE_FULL_REFS);
        rev.show_decorations = 1;
        rev.grep_filter.regflags |= REG_ICASE;
        compile_grep_patterns(&rev.grep_filter);
        prepare_revision_walk(&rev);
        if (pager)
                html("<table class='list nowrap'>");
-        html("<tr class='nohover'><th class='left'>Age</th>"
+        html("<tr class='nohover'>");
-              "<th class='left'>Commit message");
+        if (commit_graph)
+                html("<th></th>");
+        else
+                html("<th class='left'>Age</th>");
+        html("<th class='left'>Commit message");
        if (pager) {
                html(" (");
                cgit_log_link(ctx.qry.showmsg ? "Collapse" : "Expand", NULL,
                              NULL, ctx.qry.head, ctx.qry.sha1,
-                              ctx.qry.path, ctx.qry.ofs, ctx.qry.grep,
+                              ctx.qry.vpath, ctx.qry.ofs, ctx.qry.grep,
                              ctx.qry.search, ctx.qry.showmsg ? 0 : 1);
                html(")");
        }
        html("</th><th class='left'>Author</th>");
+        if (commit_graph)
+                html("<th class='left'>Age</th>");
        if (ctx.repo->enable_log_filecount) {
                html("<th class='left'>Files</th>");
                columns++;
                if (ctx.repo->enable_log_linecount) {
                        html("<th class='left'>Lines</th>");
                        columns++;
                }
        }
        html("</tr>\n");
        if (ofs<0)
                ofs = 0;
        for (i = 0; i < ofs && (commit = get_revision(&rev)) != NULL; i++) {
                free(commit->buffer);
                commit->buffer = NULL;
                free_commit_list(commit->parents);
                commit->parents = NULL;
        }
        for (i = 0; i < cnt && (commit = get_revision(&rev)) != NULL; i++) {
-                print_commit(commit);
+                print_commit(commit, &rev);
                free(commit->buffer);
                commit->buffer = NULL;
                free_commit_list(commit->parents);
                commit->parents = NULL;
        }
        if (pager) {
-                htmlf("</table><div class='pager'>",
+                html("</table><div class='pager'>");
-                     columns);
                if (ofs > 0) {
                        cgit_log_link("[prev]", NULL, NULL, ctx.qry.head,
-                                      ctx.qry.sha1, ctx.qry.path,
+                                      ctx.qry.sha1, ctx.qry.vpath,
                                      ofs - cnt, ctx.qry.grep,
                                      ctx.qry.search, ctx.qry.showmsg);
                        html("&nbsp;");
                }
                if ((commit = get_revision(&rev)) != NULL) {
                        cgit_log_link("[next]", NULL, NULL, ctx.qry.head,
-                                      ctx.qry.sha1, ctx.qry.path,
+                                      ctx.qry.sha1, ctx.qry.vpath,
                                      ofs + cnt, ctx.qry.grep,
                                      ctx.qry.search, ctx.qry.showmsg);
                }
                html("</div>");
        } else if ((commit = get_revision(&rev)) != NULL) {
                html("<tr class='nohover'><td colspan='3'>");
-                cgit_log_link("[...]", NULL, NULL, ctx.qry.head, NULL, NULL, 0,
+                cgit_log_link("[...]", NULL, NULL, ctx.qry.head, NULL,
-                              NULL, NULL, ctx.qry.showmsg);
+                              ctx.qry.vpath, 0, NULL, NULL, ctx.qry.showmsg);
                html("</td></tr>\n");
        }
 }
diff --git a/ui-log.h b/ui-log.h
index 6034055..d0cb779 100644
--- a/ui-log.h
+++ b/ui-log.h
@@ -1,8 +1,9 @@
 #ifndef UI_LOG_H
 #define UI_LOG_H
 extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep,
-                           char *pattern, char *path, int pager);
+                           char *pattern, char *path, int pager,
+                           int commit_graph);
 extern void show_commit_decorations(struct commit *commit);
 #endif /* UI_LOG_H */
diff --git a/ui-patch.c b/ui-patch.c
index 2a8f7a5..ca008f3 100644
--- a/ui-patch.c
+++ b/ui-patch.c
@@ -50,80 +50,82 @@ static void header(unsigned char *sha1, char *path1, int mode1,
                        if (mode2 != mode1)
                                htmlf("..%.6o", mode2);
                }
                htmlf("\n--- a/%s\n", path1);
                htmlf("+++ b/%s\n", path2);
        }
 }
 static void filepair_cb(struct diff_filepair *pair)
 {
        unsigned long old_size = 0;
        unsigned long new_size = 0;
        int binary = 0;
        header(pair->one->sha1, pair->one->path, pair->one->mode,
               pair->two->sha1, pair->two->path, pair->two->mode);
        if (S_ISGITLINK(pair->one->mode) || S_ISGITLINK(pair->two->mode)) {
                if (S_ISGITLINK(pair->one->mode))
                        print_line(fmt("-Subproject %s", sha1_to_hex(pair->one->sha1)), 52);
                if (S_ISGITLINK(pair->two->mode))
                        print_line(fmt("+Subproject %s", sha1_to_hex(pair->two->sha1)), 52);
                return;
        }
        if (cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size,
-                            &new_size, &binary, print_line))
+                            &new_size, &binary, 0, 0, print_line))
                html("Error running diff");
        if (binary)
                html("Binary files differ\n");
 }
-void cgit_print_patch(char *hex)
+void cgit_print_patch(char *hex, const char *prefix)
 {
        struct commit *commit;
        struct commitinfo *info;
        unsigned char sha1[20], old_sha1[20];
        char *patchname;
        if (!hex)
                hex = ctx.qry.head;
        if (get_sha1(hex, sha1)) {
                cgit_print_error(fmt("Bad object id: %s", hex));
                return;
        }
        commit = lookup_commit_reference(sha1);
        if (!commit) {
                cgit_print_error(fmt("Bad commit reference: %s", hex));
                return;
        }
        info = cgit_parse_commit(commit);
        if (commit->parents && commit->parents->item)
                hashcpy(old_sha1, commit->parents->item->object.sha1);
        else
                hashclr(old_sha1);
        patchname = fmt("%s.patch", sha1_to_hex(sha1));
        ctx.page.mimetype = "text/plain";
        ctx.page.filename = patchname;
        cgit_print_http_headers(&ctx);
        htmlf("From %s Mon Sep 17 00:00:00 2001\n", sha1_to_hex(sha1));
        htmlf("From: %s", info->author);
        if (!ctx.cfg.noplainemail) {
                htmlf(" %s", info->author_email);
        }
        html("\n");
        html("Date: ");
        cgit_print_date(info->author_date, "%a, %d %b %Y %H:%M:%S %z%n", ctx.cfg.local_time);
        htmlf("Subject: %s\n\n", info->subject);
        if (info->msg && *info->msg) {
                htmlf("%s", info->msg);
                if (info->msg[strlen(info->msg) - 1] != '\n')
                        html("\n");
        }
        html("---\n");
-        cgit_diff_tree(old_sha1, sha1, filepair_cb, NULL);
+        if (prefix)
+                htmlf("(limited to '%s')\n\n", prefix);
+        cgit_diff_tree(old_sha1, sha1, filepair_cb, prefix, 0);
        html("--\n");
        htmlf("cgit %s\n", CGIT_VERSION);
        cgit_free_commitinfo(info);
 }
diff --git a/ui-patch.h b/ui-patch.h
index 9f68212..1641cea 100644
--- a/ui-patch.h
+++ b/ui-patch.h
@@ -1,6 +1,6 @@
 #ifndef UI_PATCH_H
 #define UI_PATCH_H
-extern void cgit_print_patch(char *hex);
+extern void cgit_print_patch(char *hex, const char *prefix);
 #endif /* UI_PATCH_H */
diff --git a/ui-plain.c b/ui-plain.c
index 5569a7c..1b2b672 100644
--- a/ui-plain.c
+++ b/ui-plain.c
@@ -1,94 +1,146 @@
 /* ui-plain.c: functions for output of plain blobs by path
 *
 * Copyright (C) 2008 Lars Hjemli
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
-char *curr_rev;
+int match_baselen;
-char *match_path;
 int match;
 static void print_object(const unsigned char *sha1, const char *path)
 {
        enum object_type type;
        char *buf, *ext;
        unsigned long size;
        struct string_list_item *mime;
        type = sha1_object_info(sha1, &size);
        if (type == OBJ_BAD) {
                html_status(404, "Not found", 0);
                return;
        }
        buf = read_sha1_file(sha1, &type, &size);
        if (!buf) {
                html_status(404, "Not found", 0);
                return;
        }
        ctx.page.mimetype = NULL;
        ext = strrchr(path, '.');
        if (ext && *(++ext)) {
                mime = string_list_lookup(&ctx.cfg.mimetypes, ext);
                if (mime)
                        ctx.page.mimetype = (char *)mime->util;
        }
        if (!ctx.page.mimetype) {
                if (buffer_is_binary(buf, size))
                        ctx.page.mimetype = "application/octet-stream";
                else
                        ctx.page.mimetype = "text/plain";
        }
        ctx.page.filename = fmt("%s", path);
        ctx.page.size = size;
        ctx.page.etag = sha1_to_hex(sha1);
        cgit_print_http_headers(&ctx);
        html_raw(buf, size);
        match = 1;
 }
+static void print_dir(const unsigned char *sha1, const char *path,
+                      const char *base)
+{
+        char *fullpath;
+        if (path[0] || base[0])
+                fullpath = fmt("/%s%s/", base, path);
+        else
+                fullpath = "/";
+        ctx.page.etag = sha1_to_hex(sha1);
+        cgit_print_http_headers(&ctx);
+        htmlf("<html><head><title>%s</title></head>\n<body>\n"
+              " <h2>%s</h2>\n <ul>\n", fullpath, fullpath);
+        if (path[0] || base[0])
+              html("  <li><a href=\"../\">../</a></li>\n");
+        match = 2;
+}
+static void print_dir_entry(const unsigned char *sha1, const char *path,
+                            unsigned mode)
+{
+        const char *sep = "";
+        if (S_ISDIR(mode))
+                sep = "/";
+        htmlf("  <li><a href=\"%s%s\">%s%s</a></li>\n", path, sep, path, sep);
+        match = 2;
+}
+static void print_dir_tail(void)
+{
+        html(" </ul>\n</body></html>\n");
+}
 static int walk_tree(const unsigned char *sha1, const char *base, int baselen,
                     const char *pathname, unsigned mode, int stage,
                     void *cbdata)
 {
-        if (S_ISDIR(mode))
+        if (baselen == match_baselen) {
+                if (S_ISREG(mode))
+                        print_object(sha1, pathname);
+                else if (S_ISDIR(mode)) {
+                        print_dir(sha1, pathname, base);
+                        return READ_TREE_RECURSIVE;
+                }
+        }
+        else if (baselen > match_baselen)
+                print_dir_entry(sha1, pathname, mode);
+        else if (S_ISDIR(mode))
                return READ_TREE_RECURSIVE;
-        if (S_ISREG(mode) && !strncmp(base, match_path, baselen) &&
+        return 0;
-            !strcmp(pathname, match_path + baselen))
+}
-                print_object(sha1, pathname);
+static int basedir_len(const char *path)
+{
+        char *p = strrchr(path, '/');
+        if (p)
+                return p - path + 1;
        return 0;
 }
 void cgit_print_plain(struct cgit_context *ctx)
 {
        const char *rev = ctx->qry.sha1;
        unsigned char sha1[20];
        struct commit *commit;
        const char *paths[] = {ctx->qry.path, NULL};
        if (!rev)
                rev = ctx->qry.head;
-        curr_rev = xstrdup(rev);
        if (get_sha1(rev, sha1)) {
                html_status(404, "Not found", 0);
                return;
        }
        commit = lookup_commit_reference(sha1);
        if (!commit || parse_commit(commit)) {
                html_status(404, "Not found", 0);
                return;
        }
-        match_path = ctx->qry.path;
+        if (!paths[0]) {
+                paths[0] = "";
+                match_baselen = -1;
+                print_dir(commit->tree->object.sha1, "", "");
+        }
+        else
+                match_baselen = basedir_len(paths[0]);
        read_tree_recursive(commit->tree, "", 0, 0, paths, walk_tree, NULL);
        if (!match)
                html_status(404, "Not found", 0);
+        else if (match == 2)
+                print_dir_tail();
 }
diff --git a/ui-refs.c b/ui-refs.c
index 6571cc4..caddfbc 100644
--- a/ui-refs.c
+++ b/ui-refs.c
@@ -55,49 +55,49 @@ static int get_ref_age(struct refinfo *ref)
        return 0;
 }
 static int cmp_tag_age(const void *a, const void *b)
 {
        struct refinfo *r1 = *(struct refinfo **)a;
        struct refinfo *r2 = *(struct refinfo **)b;
        return cmp_age(get_ref_age(r1), get_ref_age(r2));
 }
 static int print_branch(struct refinfo *ref)
 {
        struct commitinfo *info = ref->commit;
        char *name = (char *)ref->refname;
        if (!info)
                return 1;
        html("<tr><td>");
        cgit_log_link(name, NULL, NULL, name, NULL, NULL, 0, NULL, NULL,
                      ctx.qry.showmsg);
        html("</td><td>");
        if (ref->object->type == OBJ_COMMIT) {
-                cgit_commit_link(info->subject, NULL, NULL, name, NULL);
+                cgit_commit_link(info->subject, NULL, NULL, name, NULL, NULL, 0);
                html("</td><td>");
                html_txt(info->author);
                html("</td><td colspan='2'>");
                cgit_print_age(info->commit->date, -1, NULL);
        } else {
                html("</td><td></td><td>");
                cgit_object_link(ref->object);
        }
        html("</td></tr>\n");
        return 0;
 }
 static void print_tag_header()
 {
        html("<tr class='nohover'><th class='left'>Tag</th>"
             "<th class='left'>Download</th>"
             "<th class='left'>Author</th>"
             "<th class='left' colspan='2'>Age</th></tr>\n");
        header = 1;
 }
 static void print_tag_downloads(const struct cgit_repo *repo, const char *ref)
 {
        const struct cgit_snapshot_format* f;
@@ -168,48 +168,50 @@ static int print_tag(struct refinfo *ref)
        }
        return 0;
 }
 static void print_refs_link(char *path)
 {
        html("<tr class='nohover'><td colspan='4'>");
        cgit_refs_link("[...]", NULL, NULL, ctx.qry.head, NULL, path);
        html("</td></tr>");
 }
 void cgit_print_branches(int maxcount)
 {
        struct reflist list;
        int i;
        html("<tr class='nohover'><th class='left'>Branch</th>"
             "<th class='left'>Commit message</th>"
             "<th class='left'>Author</th>"
             "<th class='left' colspan='2'>Age</th></tr>\n");
        list.refs = NULL;
        list.alloc = list.count = 0;
        for_each_branch_ref(cgit_refs_cb, &list);
+        if (ctx.repo->enable_remote_branches)
+                for_each_remote_ref(cgit_refs_cb, &list);
        if (maxcount == 0 || maxcount > list.count)
                maxcount = list.count;
        if (maxcount < list.count) {
                qsort(list.refs, list.count, sizeof(*list.refs), cmp_branch_age);
                qsort(list.refs, maxcount, sizeof(*list.refs), cmp_ref_name);
        }
        for(i=0; i<maxcount; i++)
                print_branch(list.refs[i]);
        if (maxcount < list.count)
                print_refs_link("heads");
 }
 void cgit_print_tags(int maxcount)
 {
        struct reflist list;
        int i;
        header = 0;
        list.refs = NULL;
        list.alloc = list.count = 0;
diff --git a/ui-repolist.c b/ui-repolist.c
index 0a0b6ca..2c98668 100644
--- a/ui-repolist.c
+++ b/ui-repolist.c
@@ -1,38 +1,32 @@
 /* ui-repolist.c: functions for generating the repolist page
 *
 * Copyright (C) 2006 Lars Hjemli
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
-/* This is needed for strcasestr to be defined by <string.h> */
-#define _GNU_SOURCE 1
-#include <string.h>
-#include <time.h>
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
 time_t read_agefile(char *path)
 {
        time_t result;
        size_t size;
        char *buf;
        static char buf2[64];
        if (readfile(path, &buf, &size))
                return -1;
        if (parse_date(buf, buf2, sizeof(buf2)))
                result = strtoul(buf2, NULL, 10);
        else
                result = 0;
        free(buf);
        return result;
 }
 static int get_repo_modtime(const struct cgit_repo *repo, time_t *mtime)
 {
diff --git a/ui-shared.c b/ui-shared.c
index d1b020b..5aa9119 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -6,49 +6,49 @@
 *   (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", "Nov", "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)
+void cgit_print_error(const char *msg)
 {
        html("<div class='error'>");
        html_txt(msg);
        html("</div>\n");
 }
 char *cgit_httpscheme()
 {
        if (ctx.env.https && !strcmp(ctx.env.https, "on"))
                return "https://";
        else
                return "http://";
 }
 char *cgit_hosturl()
 {
        if (ctx.env.http_host)
                return ctx.env.http_host;
        if (!ctx.env.server_name)
                return NULL;
        if (!ctx.env.server_port || atoi(ctx.env.server_port) == 80)
                return ctx.env.server_name;
        return xstrdup(fmt("%s:%s", ctx.env.server_name, ctx.env.server_port));
 }
@@ -112,104 +112,104 @@ const char *cgit_repobasename(const char *reponame)
        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)
+static void site_url(const char *page, const 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,
+static void site_link(const char *page, const char *name, const char *title,
-                      char *search, int ofs)
+                      const char *class, const 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,
+void cgit_index_link(const char *name, const char *title, const char *class,
-                     int ofs)
+                     const char *pattern, int ofs)
 {
        site_link(NULL, name, title, class, pattern, ofs);
 }
-static char *repolink(char *title, char *class, char *page, char *head,
+static char *repolink(const char *title, const char *class, const char *page,
-                      char *path)
+                      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);
                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);
@@ -219,219 +219,327 @@ static char *repolink(char *title, char *class, char *page, char *head,
                }
        } 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,
+static void reporevlink(const char *page, const char *name, const char *title,
-                        char *head, char *rev, char *path)
+                        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(char *name, char *title, char *class, char *head)
+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(char *name, char *title, char *class, char *head,
+void cgit_tag_link(const char *name, const char *title, const char *class,
-                   char *rev)
+                   const char *head, const char *rev)
 {
        reporevlink("tag", name, title, class, head, rev, NULL);
 }
-void cgit_tree_link(char *name, char *title, char *class, char *head,
+void cgit_tree_link(const char *name, const char *title, const char *class,
-                    char *rev, char *path)
+                    const char *head, const char *rev, const char *path)
 {
        reporevlink("tree", name, title, class, head, rev, path);
 }
-void cgit_plain_link(char *name, char *title, char *class, char *head,
+void cgit_plain_link(const char *name, const char *title, const char *class,
-                     char *rev, char *path)
+                     const char *head, const char *rev, const char *path)
 {
        reporevlink("plain", name, title, class, head, rev, path);
 }
-void cgit_log_link(char *name, char *title, char *class, char *head,
+void cgit_log_link(const char *name, const char *title, const char *class,
-                   char *rev, char *path, int ofs, char *grep, char *pattern,
+                   const char *head, const char *rev, const char *path,
-                   int showmsg)
+                   int ofs, const char *grep, const char *pattern, int showmsg)
 {
        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);
                delim = "&";
        }
        if (showmsg) {
                html(delim);
                html("showmsg=1");
        }
        html("'>");
        html_txt(name);
        html("</a>");
 }
-void cgit_commit_link(char *name, char *title, char *class, char *head,
+void cgit_commit_link(char *name, const char *title, const char *class,
-                      char *rev)
+                      const char *head, const char *rev, const char *path,
+                      int toggle_ssdiff)
 {
        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);
+        char *delim;
+        delim = repolink(title, class, "commit", head, path);
+        if (rev && strcmp(rev, ctx.qry.head)) {
+                html(delim);
+                html("id=");
+                html_url_arg(rev);
+                delim = "&amp;";
+        }
+        if ((ctx.qry.ssdiff && !toggle_ssdiff) || (!ctx.qry.ssdiff && toggle_ssdiff)) {
+                html(delim);
+                html("ss=1");
+                delim = "&amp;";
+        }
+        if (ctx.qry.context > 0 && ctx.qry.context != 3) {
+                html(delim);
+                html("context=");
+                htmlf("%d", ctx.qry.context);
+                delim = "&amp;";
+        }
+        if (ctx.qry.ignorews) {
+                html(delim);
+                html("ignorews=1");
+                delim = "&amp;";
+        }
+        html("'>");
+        html_txt(name);
+        html("</a>");
 }
-void cgit_refs_link(char *name, char *title, char *class, char *head,
+void cgit_refs_link(const char *name, const char *title, const char *class,
-                    char *rev, char *path)
+                    const char *head, const char *rev, const char *path)
 {
        reporevlink("refs", name, title, class, head, rev, path);
 }
-void cgit_snapshot_link(char *name, char *title, char *class, char *head,
+void cgit_snapshot_link(const char *name, const char *title, const char *class,
-                        char *rev, char *archivename)
+                        const char *head, const char *rev,
+                        const char *archivename)
 {
        reporevlink("snapshot", name, title, class, head, rev, archivename);
 }
-void cgit_diff_link(char *name, char *title, char *class, char *head,
+void cgit_diff_link(const char *name, const char *title, const char *class,
-                    char *new_rev, char *old_rev, char *path)
+                    const char *head, const char *new_rev, const char *old_rev,
+                    const char *path, int toggle_ssdiff)
 {
        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 = "&amp;";
        }
        if (old_rev) {
                html(delim);
                html("id2=");
                html_url_arg(old_rev);
+                delim = "&amp;";
+        }
+        if ((ctx.qry.ssdiff && !toggle_ssdiff) || (!ctx.qry.ssdiff && toggle_ssdiff)) {
+                html(delim);
+                html("ss=1");
+                delim = "&amp;";
+        }
+        if (ctx.qry.context > 0 && ctx.qry.context != 3) {
+                html(delim);
+                html("context=");
+                htmlf("%d", ctx.qry.context);
+                delim = "&amp;";
+        }
+        if (ctx.qry.ignorews) {
+                html(delim);
+                html("ignorews=1");
+                delim = "&amp;";
        }
        html("'>");
        html_txt(name);
        html("</a>");
 }
-void cgit_patch_link(char *name, char *title, char *class, char *head,
+void cgit_patch_link(const char *name, const char *title, const char *class,
-                     char *rev)
+                     const char *head, const char *rev, const char *path)
 {
-        reporevlink("patch", name, title, class, head, rev, NULL);
+        reporevlink("patch", name, title, class, head, rev, path);
 }
-void cgit_stats_link(char *name, char *title, char *class, char *head,
+void cgit_stats_link(const char *name, const char *title, const char *class,
-                     char *path)
+                     const char *head, const char *path)
 {
        reporevlink("stats", name, title, class, head, NULL, path);
 }
+void cgit_self_link(char *name, const char *title, const char *class,
+                    struct cgit_context *ctx)
+{
+        if (!strcmp(ctx->qry.page, "repolist"))
+                return cgit_index_link(name, title, class, ctx->qry.search,
+                                       ctx->qry.ofs);
+        else if (!strcmp(ctx->qry.page, "summary"))
+                return cgit_summary_link(name, title, class, ctx->qry.head);
+        else if (!strcmp(ctx->qry.page, "tag"))
+                return cgit_tag_link(name, title, class, ctx->qry.head,
+                                     ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL);
+        else if (!strcmp(ctx->qry.page, "tree"))
+                return cgit_tree_link(name, title, class, ctx->qry.head,
+                                      ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
+                                      ctx->qry.path);
+        else if (!strcmp(ctx->qry.page, "plain"))
+                return cgit_plain_link(name, title, class, ctx->qry.head,
+                                      ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
+                                      ctx->qry.path);
+        else if (!strcmp(ctx->qry.page, "log"))
+                return cgit_log_link(name, title, class, ctx->qry.head,
+                                      ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
+                                      ctx->qry.path, ctx->qry.ofs,
+                                      ctx->qry.grep, ctx->qry.search,
+                                      ctx->qry.showmsg);
+        else if (!strcmp(ctx->qry.page, "commit"))
+                return cgit_commit_link(name, title, class, ctx->qry.head,
+                                      ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
+                                      ctx->qry.path, 0);
+        else if (!strcmp(ctx->qry.page, "patch"))
+                return cgit_patch_link(name, title, class, ctx->qry.head,
+                                      ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
+                                      ctx->qry.path);
+        else if (!strcmp(ctx->qry.page, "refs"))
+                return cgit_refs_link(name, title, class, ctx->qry.head,
+                                      ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
+                                      ctx->qry.path);
+        else if (!strcmp(ctx->qry.page, "snapshot"))
+                return cgit_snapshot_link(name, title, class, ctx->qry.head,
+                                      ctx->qry.has_sha1 ? ctx->qry.sha1 : NULL,
+                                      ctx->qry.path);
+        else if (!strcmp(ctx->qry.page, "diff"))
+                return cgit_diff_link(name, title, class, ctx->qry.head,
+                                      ctx->qry.sha1, ctx->qry.sha2,
+                                      ctx->qry.path, 0);
+        else if (!strcmp(ctx->qry.page, "stats"))
+                return cgit_stats_link(name, title, class, ctx->qry.head,
+                                      ctx->qry.path);
+        /* 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 = sha1_to_hex(obj->sha1);
        shortrev = xstrdup(fullrev);
        shortrev[10] = '\0';
        if (obj->type == OBJ_COMMIT) {
                cgit_commit_link(fmt("commit %s...", shortrev), NULL, NULL,
-                                 ctx.qry.head, fullrev);
+                                 ctx.qry.head, fullrev, NULL, 0);
                return;
        } else if (obj->type == OBJ_TREE)
                page = "tree";
        else if (obj->type == OBJ_TAG)
                page = "tag";
        else
                page = "blob";
        name = fmt("%s %s...", typename(obj->type), shortrev);
        reporevlink(page, name, NULL, NULL, ctx.qry.head, fullrev, NULL);
 }
-void cgit_print_date(time_t secs, char *format, int local_time)
+void cgit_print_date(time_t secs, const 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)
+void cgit_print_age(time_t t, time_t max_relative, const 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) {
@@ -488,49 +596,49 @@ 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='");
                html(cgit_httpscheme());
                html_attr(cgit_hosturl());
-                html_attr(cgit_fileurl(ctx->repo->url, "atom", ctx->qry.path,
+                html_attr(cgit_fileurl(ctx->repo->url, "atom", ctx->qry.vpath,
                                       fmt("h=%s", ctx->qry.head)));
                html("' type='application/atom+xml'/>\n");
        }
        if (ctx->cfg.head_include)
                html_include(ctx->cfg.head_include);
        html("</head>\n");
        html("<body>\n");
        if (ctx->cfg.header)
                html_include(ctx->cfg.header);
 }
 void cgit_print_docend()
 {
        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 cgit %s at ",
@@ -568,206 +676,244 @@ int print_archive_ref(const char *refname, const unsigned char *sha1,
                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 cgit_add_hidden_formfields(int incl_head, int incl_search, char *page)
+void cgit_add_hidden_formfields(int incl_head, int incl_search,
+                                const char *page)
 {
        char *url;
        if (!ctx.cfg.virtual_root) {
                url = fmt("%s/%s", ctx.qry.repo, page);
-                if (ctx.qry.path)
+                if (ctx.qry.vpath)
-                        url = fmt("%s/%s", url, ctx.qry.path);
+                        url = fmt("%s/%s", url, ctx.qry.vpath);
                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 (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);
        }
 }
-const char *fallback_cmd = "repolist";
+static const char *hc(struct cgit_context *ctx, const char *page)
+{
+        return strcmp(ctx->qry.page, page) ? NULL : "active";
+}
-char *hc(struct cgit_cmd *cmd, const char *page)
+static void cgit_print_path_crumbs(struct cgit_context *ctx, char *path)
 {
-        return (strcmp(cmd ? cmd->name : fallback_cmd, page) ? NULL : "active");
+        char *old_path = ctx->qry.path;
+        char *p = path, *q, *end = path + strlen(path);
+        ctx->qry.path = NULL;
+        cgit_self_link("root", NULL, NULL, ctx);
+        ctx->qry.path = p = path;
+        while (p < end) {
+                if (!(q = strchr(p, '/')))
+                        q = end;
+                *q = '\0';
+                html_txt("/");
+                cgit_self_link(p, NULL, NULL, ctx);
+                if (q < end)
+                        *q = '/';
+                p = q + 1;
+        }
+        ctx->qry.path = old_path;
 }
 static void print_header(struct cgit_context *ctx)
 {
+        char *logo = NULL, *logo_link = NULL;
        html("<table id='header'>\n");
        html("<tr>\n");
-        if (ctx->cfg.logo && ctx->cfg.logo[0] != 0) {
+        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 (ctx->cfg.logo_link)
+                if (logo_link && *logo_link)
-                        html_attr(ctx->cfg.logo_link);
+                        html_attr(logo_link);
                else
                        html_attr(cgit_rooturl());
                html("'><img src='");
-                html_attr(ctx->cfg.logo);
+                html_attr(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");
                cgit_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");
 }
 void cgit_print_pageheader(struct cgit_context *ctx)
 {
-        struct cgit_cmd *cmd = cgit_get_cmd(ctx);
-        if (!cmd && ctx->repo)
-                fallback_cmd = "summary";
        html("<div id='cgit'>");
        if (!ctx->cfg.noheader)
                print_header(ctx);
        html("<table class='tabs'><tr><td>\n");
        if (ctx->repo) {
-                cgit_summary_link("summary", NULL, hc(cmd, "summary"),
+                cgit_summary_link("summary", NULL, hc(ctx, "summary"),
                                  ctx->qry.head);
-                cgit_refs_link("refs", NULL, hc(cmd, "refs"), ctx->qry.head,
+                cgit_refs_link("refs", NULL, hc(ctx, "refs"), ctx->qry.head,
                               ctx->qry.sha1, NULL);
-                cgit_log_link("log", NULL, hc(cmd, "log"), ctx->qry.head,
+                cgit_log_link("log", NULL, hc(ctx, "log"), ctx->qry.head,
-                              NULL, NULL, 0, NULL, NULL, ctx->qry.showmsg);
+                              NULL, ctx->qry.vpath, 0, NULL, NULL,
-                cgit_tree_link("tree", NULL, hc(cmd, "tree"), ctx->qry.head,
+                              ctx->qry.showmsg);
-                               ctx->qry.sha1, NULL);
+                cgit_tree_link("tree", NULL, hc(ctx, "tree"), ctx->qry.head,
-                cgit_commit_link("commit", NULL, hc(cmd, "commit"),
+                               ctx->qry.sha1, ctx->qry.vpath);
-                                 ctx->qry.head, ctx->qry.sha1);
+                cgit_commit_link("commit", NULL, hc(ctx, "commit"),
-                cgit_diff_link("diff", NULL, hc(cmd, "diff"), ctx->qry.head,
+                                 ctx->qry.head, ctx->qry.sha1, ctx->qry.vpath, 0);
-                               ctx->qry.sha1, ctx->qry.sha2, NULL);
+                cgit_diff_link("diff", NULL, hc(ctx, "diff"), ctx->qry.head,
+                               ctx->qry.sha1, ctx->qry.sha2, ctx->qry.vpath, 0);
                if (ctx->repo->max_stats)
-                        cgit_stats_link("stats", NULL, hc(cmd, "stats"),
+                        cgit_stats_link("stats", NULL, hc(ctx, "stats"),
-                                        ctx->qry.head, NULL);
+                                        ctx->qry.head, ctx->qry.vpath);
                if (ctx->repo->readme)
                        reporevlink("about", "about", NULL,
-                                    hc(cmd, "about"), ctx->qry.head, NULL,
+                                    hc(ctx, "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));
+                                                   ctx->qry.vpath, NULL));
                html("'>\n");
                cgit_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_option("range", "range", 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);
+                site_link(NULL, "index", NULL, hc(ctx, "repolist"), NULL, 0);
                if (ctx->cfg.root_readme)
-                        site_link("about", "about", NULL, hc(cmd, "about"),
+                        site_link("about", "about", NULL, hc(ctx, "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");
+        if (ctx->qry.vpath) {
+                html("<div class='path'>");
+                html("path: ");
+                cgit_print_path_crumbs(ctx, ctx->qry.vpath);
+                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_print_snapshot_links(const char *repo, const char *head,
                               const char *hex, int snapshots)
 {
        const struct cgit_snapshot_format* f;
+        char *prefix;
            char *filename;
+        unsigned char sha1[20];
+        if (get_sha1(fmt("refs/tags/%s", hex), sha1) == 0 &&
+            (hex[0] == 'v' || hex[0] == 'V') && isdigit(hex[1]))
+                hex++;
+        prefix = xstrdup(fmt("%s-%s", cgit_repobasename(repo), hex));
        for (f = cgit_snapshot_formats; f->suffix; f++) {
                if (!(snapshots & f->bit))
                        continue;
-                filename = fmt("%s-%s%s", cgit_repobasename(repo), hex,
+                filename = fmt("%s%s", prefix, f->suffix);
-                               f->suffix);
                cgit_snapshot_link(filename, NULL, NULL, NULL, NULL, filename);
                html("<br/>");
        }
 }
diff --git a/ui-shared.h b/ui-shared.h
index b12aa89..3cc1258 100644
--- a/ui-shared.h
+++ b/ui-shared.h
@@ -1,51 +1,66 @@
 #ifndef UI_SHARED_H
 #define UI_SHARED_H
 extern char *cgit_httpscheme();
 extern char *cgit_hosturl();
 extern char *cgit_rooturl();
 extern char *cgit_repourl(const char *reponame);
 extern char *cgit_fileurl(const char *reponame, const char *pagename,
                          const char *filename, const char *query);
 extern char *cgit_pageurl(const char *reponame, const char *pagename,
                          const char *query);
-extern void cgit_index_link(char *name, char *title, char *class,
+extern void cgit_index_link(const char *name, const char *title,
-                            char *pattern, int ofs);
+                            const char *class, const char *pattern, int ofs);
-extern void cgit_summary_link(char *name, char *title, char *class, char *head);
+extern void cgit_summary_link(const char *name, const char *title,
-extern void cgit_tag_link(char *name, char *title, char *class, char *head,
+                              const char *class, const char *head);
-                          char *rev);
+extern void cgit_tag_link(const char *name, const char *title,
-extern void cgit_tree_link(char *name, char *title, char *class, char *head,
+                          const char *class, const char *head,
-                           char *rev, char *path);
+                          const char *rev);
-extern void cgit_plain_link(char *name, char *title, char *class, char *head,
+extern void cgit_tree_link(const char *name, const char *title,
-                            char *rev, char *path);
+                           const char *class, const char *head,
-extern void cgit_log_link(char *name, char *title, char *class, char *head,
+                           const char *rev, const char *path);
-                          char *rev, char *path, int ofs, char *grep,
+extern void cgit_plain_link(const char *name, const char *title,
-                          char *pattern, int showmsg);
+                            const char *class, const char *head,
-extern void cgit_commit_link(char *name, char *title, char *class, char *head,
+                            const char *rev, const char *path);
-                             char *rev);
+extern void cgit_log_link(const char *name, const char *title,
-extern void cgit_patch_link(char *name, char *title, char *class, char *head,
+                          const char *class, const char *head, const char *rev,
-                            char *rev);
+                          const char *path, int ofs, const char *grep,
-extern void cgit_refs_link(char *name, char *title, char *class, char *head,
+                          const char *pattern, int showmsg);
-                           char *rev, char *path);
+extern void cgit_commit_link(char *name, const char *title,
-extern void cgit_snapshot_link(char *name, char *title, char *class,
+                             const char *class, const char *head,
-                               char *head, char *rev, char *archivename);
+                             const char *rev, const char *path,
-extern void cgit_diff_link(char *name, char *title, char *class, char *head,
+                             int toggle_ssdiff);
-                           char *new_rev, char *old_rev, char *path);
+extern void cgit_patch_link(const char *name, const char *title,
-extern void cgit_stats_link(char *name, char *title, char *class, char *head,
+                            const char *class, const char *head,
-                            char *path);
+                            const char *rev, const char *path);
+extern void cgit_refs_link(const char *name, const char *title,
+                           const char *class, const char *head,
+                           const char *rev, const char *path);
+extern void cgit_snapshot_link(const char *name, const char *title,
+                               const char *class, const char *head,
+                               const char *rev, const char *archivename);
+extern 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, int toggle_ssdiff);
+extern void cgit_stats_link(const char *name, const char *title,
+                            const char *class, const char *head,
+                            const char *path);
+extern void cgit_self_link(char *name, const char *title,
+                           const char *class, struct cgit_context *ctx);
 extern void cgit_object_link(struct object *obj);
-extern void cgit_print_error(char *msg);
+extern void cgit_print_error(const char *msg);
-extern void cgit_print_date(time_t secs, char *format, int local_time);
+extern void cgit_print_date(time_t secs, const char *format, int local_time);
-extern void cgit_print_age(time_t t, time_t max_relative, char *format);
+extern void cgit_print_age(time_t t, time_t max_relative, const char *format);
 extern void cgit_print_http_headers(struct cgit_context *ctx);
 extern void cgit_print_docstart(struct cgit_context *ctx);
 extern void cgit_print_docend();
 extern void cgit_print_pageheader(struct cgit_context *ctx);
 extern void cgit_print_filemode(unsigned short mode);
 extern void cgit_print_snapshot_links(const char *repo, const char *head,
                                      const char *hex, int snapshots);
 extern void cgit_add_hidden_formfields(int incl_head, int incl_search,
-                                       char *page);
+                                       const char *page);
 #endif /* UI_SHARED_H */
diff --git a/ui-snapshot.c b/ui-snapshot.c
index dbb5564..6e3412c 100644
--- a/ui-snapshot.c
+++ b/ui-snapshot.c
@@ -14,53 +14,59 @@ static int write_compressed_tar_archive(struct archiver_args *args,const char *f
 {
        int rv;
        struct cgit_filter f;
        f.cmd = xstrdup(filter);
        f.argv = malloc(2 * sizeof(char *));
        f.argv[0] = f.cmd;
        f.argv[1] = NULL;
        cgit_open_filter(&f);
        rv = write_tar_archive(args);
        cgit_close_filter(&f);
        return rv;
 }
 static int write_tar_gzip_archive(struct archiver_args *args)
 {
        return write_compressed_tar_archive(args,"gzip");
 }
 static int write_tar_bzip2_archive(struct archiver_args *args)
 {
        return write_compressed_tar_archive(args,"bzip2");
 }
+static int write_tar_xz_archive(struct archiver_args *args)
+{
+        return write_compressed_tar_archive(args,"xz");
+}
 const struct cgit_snapshot_format cgit_snapshot_formats[] = {
-        { ".zip", "application/x-zip", write_zip_archive, 0x1 },
+        { ".zip", "application/x-zip", write_zip_archive, 0x01 },
-        { ".tar.gz", "application/x-gzip", write_tar_gzip_archive, 0x2 },
+        { ".tar.gz", "application/x-gzip", write_tar_gzip_archive, 0x02 },
-        { ".tar.bz2", "application/x-bzip2", write_tar_bzip2_archive, 0x4 },
+        { ".tar.bz2", "application/x-bzip2", write_tar_bzip2_archive, 0x04 },
-        { ".tar", "application/x-tar", write_tar_archive, 0x8 },
+        { ".tar", "application/x-tar", write_tar_archive, 0x08 },
+        { ".tar.xz", "application/x-xz", write_tar_xz_archive, 0x10 },
        {}
 };
 static const struct cgit_snapshot_format *get_format(const char *filename)
 {
        const struct cgit_snapshot_format *fmt;
        int fl, sl;
        fl = strlen(filename);
        for(fmt = cgit_snapshot_formats; fmt->suffix; fmt++) {
                sl = strlen(fmt->suffix);
                if (sl >= fl)
                        continue;
                if (!strcmp(fmt->suffix, filename + fl - sl))
                        return fmt;
        }
        return NULL;
 }
 static int make_snapshot(const struct cgit_snapshot_format *format,
                         const char *hex, const char *prefix,
                         const char *filename)
 {
        struct archiver_args args;
diff --git a/ui-ssdiff.c b/ui-ssdiff.c
new file mode 100644
index 0000000..2481585
--- a/dev/null
+++ b/ui-ssdiff.c
@@ -0,0 +1,383 @@
+#include "cgit.h"
+#include "html.h"
+#include "ui-shared.h"
+#include "ui-diff.h"
+extern int use_ssdiff;
+static int current_old_line, current_new_line;
+struct deferred_lines {
+        int line_no;
+        char *line;
+        struct deferred_lines *next;
+};
+static struct deferred_lines *deferred_old, *deferred_old_last;
+static struct deferred_lines *deferred_new, *deferred_new_last;
+static char *longest_common_subsequence(char *A, char *B)
+{
+        int i, j, ri;
+        int m = strlen(A);
+        int n = strlen(B);
+        int L[m + 1][n + 1];
+        int tmp1, tmp2;
+        int lcs_length;
+        char *result;
+        for (i = m; i >= 0; i--) {
+                for (j = n; j >= 0; j--) {
+                        if (A[i] == '\0' || B[j] == '\0') {
+                                L[i][j] = 0;
+                        } else if (A[i] == B[j]) {
+                                L[i][j] = 1 + L[i + 1][j + 1];
+                        } else {
+                                tmp1 = L[i + 1][j];
+                                tmp2 = L[i][j + 1];
+                                L[i][j] = (tmp1 > tmp2 ? tmp1 : tmp2);
+                        }
+                }
+        }
+        lcs_length = L[0][0];
+        result = xmalloc(lcs_length + 2);
+        memset(result, 0, sizeof(*result) * (lcs_length + 2));
+        ri = 0;
+        i = 0;
+        j = 0;
+        while (i < m && j < n) {
+                if (A[i] == B[j]) {
+                        result[ri] = A[i];
+                        ri += 1;
+                        i += 1;
+                        j += 1;
+                } else if (L[i + 1][j] >= L[i][j + 1]) {
+                        i += 1;
+                } else {
+                        j += 1;
+                }
+        }
+        return result;
+}
+static int line_from_hunk(char *line, char type)
+{
+        char *buf1, *buf2;
+        int len;
+        buf1 = strchr(line, type);
+        if (buf1 == NULL)
+                return 0;
+        buf1 += 1;
+        buf2 = strchr(buf1, ',');
+        if (buf2 == NULL)
+                return 0;
+        len = buf2 - buf1;
+        buf2 = xmalloc(len + 1);
+        strncpy(buf2, buf1, len);
+        buf2[len] = '\0';
+        int res = atoi(buf2);
+        free(buf2);
+        return res;
+}
+static char *replace_tabs(char *line)
+{
+        char *prev_buf = line;
+        char *cur_buf;
+        int linelen = strlen(line);
+        int n_tabs = 0;
+        int i;
+        char *result;
+        char *spaces = "        ";
+        if (linelen == 0) {
+                result = xmalloc(1);
+                result[0] = '\0';
+                return result;
+        }
+        for (i = 0; i < linelen; i++)
+                if (line[i] == '\t')
+                        n_tabs += 1;
+        result = xmalloc(linelen + n_tabs * 8 + 1);
+        result[0] = '\0';
+        while (1) {
+                cur_buf = strchr(prev_buf, '\t');
+                if (!cur_buf) {
+                        strcat(result, prev_buf);
+                        break;
+                } else {
+                        strcat(result, " ");
+                        strncat(result, spaces, 8 - (strlen(result) % 8));
+                        strncat(result, prev_buf, cur_buf - prev_buf);
+                }
+                prev_buf = cur_buf + 1;
+        }
+        return result;
+}
+static int calc_deferred_lines(struct deferred_lines *start)
+{
+        struct deferred_lines *item = start;
+        int result = 0;
+        while (item) {
+                result += 1;
+                item = item->next;
+        }
+        return result;
+}
+static void deferred_old_add(char *line, int line_no)
+{
+        struct deferred_lines *item = xmalloc(sizeof(struct deferred_lines));
+        item->line = xstrdup(line);
+        item->line_no = line_no;
+        item->next = NULL;
+        if (deferred_old) {
+                deferred_old_last->next = item;
+                deferred_old_last = item;
+        } else {
+                deferred_old = deferred_old_last = item;
+        }
+}
+static void deferred_new_add(char *line, int line_no)
+{
+        struct deferred_lines *item = xmalloc(sizeof(struct deferred_lines));
+        item->line = xstrdup(line);
+        item->line_no = line_no;
+        item->next = NULL;
+        if (deferred_new) {
+                deferred_new_last->next = item;
+                deferred_new_last = item;
+        } else {
+                deferred_new = deferred_new_last = item;
+        }
+}
+static void print_part_with_lcs(char *class, char *line, char *lcs)
+{
+        int line_len = strlen(line);
+        int i, j;
+        char c[2] = " ";
+        int same = 1;
+        j = 0;
+        for (i = 0; i < line_len; i++) {
+                c[0] = line[i];
+                if (same) {
+                        if (line[i] == lcs[j])
+                                j += 1;
+                        else {
+                                same = 0;
+                                htmlf("<span class='%s'>", class);
+                        }
+                } else if (line[i] == lcs[j]) {
+                        same = 1;
+                        htmlf("</span>");
+                        j += 1;
+                }
+                html_txt(c);
+        }
+}
+static void print_ssdiff_line(char *class,
+                              int old_line_no,
+                              char *old_line,
+                              int new_line_no,
+                              char *new_line, int individual_chars)
+{
+        char *lcs = NULL;
+        if (old_line)
+                old_line = replace_tabs(old_line + 1);
+        if (new_line)
+                new_line = replace_tabs(new_line + 1);
+        if (individual_chars && old_line && new_line)
+                lcs = longest_common_subsequence(old_line, new_line);
+        html("<tr>\n");
+        if (old_line_no > 0) {
+                struct diff_filespec *old_file = cgit_get_current_old_file();
+                char *lineno_str = fmt("n%d", old_line_no);
+                char *id_str = fmt("%s#%s", is_null_sha1(old_file->sha1)?"HEAD":sha1_to_hex(old_rev_sha1), lineno_str);
+                html("<td class='lineno'><a class='no' href='");
+                html(cgit_fileurl(ctx.repo->url, "tree", old_file->path, id_str));
+                htmlf("' id='%s' name='%s'>%s</a>", lineno_str, lineno_str, lineno_str + 1);
+                html("</td>");
+                htmlf("<td class='%s'>", class);
+        } else if (old_line)
+                htmlf("<td class='lineno'></td><td class='%s'>", class);
+        else
+                htmlf("<td class='lineno'></td><td class='%s_dark'>", class);
+        if (old_line) {
+                if (lcs)
+                        print_part_with_lcs("del", old_line, lcs);
+                else
+                        html_txt(old_line);
+        }
+        html("</td>\n");
+        if (new_line_no > 0) {
+                struct diff_filespec *new_file = cgit_get_current_new_file();
+                char *lineno_str = fmt("n%d", new_line_no);
+                char *id_str = fmt("%s#%s", is_null_sha1(new_file->sha1)?"HEAD":sha1_to_hex(new_rev_sha1), lineno_str);
+                html("<td class='lineno'><a class='no' href='");
+                html(cgit_fileurl(ctx.repo->url, "tree", new_file->path, id_str));
+                htmlf("' id='%s' name='%s'>%s</a>", lineno_str, lineno_str, lineno_str + 1);
+                html("</td>");
+                htmlf("<td class='%s'>", class);
+        } else if (new_line)
+                htmlf("<td class='lineno'></td><td class='%s'>", class);
+        else
+                htmlf("<td class='lineno'></td><td class='%s_dark'>", class);
+        if (new_line) {
+                if (lcs)
+                        print_part_with_lcs("add", new_line, lcs);
+                else
+                        html_txt(new_line);
+        }
+        html("</td></tr>");
+        if (lcs)
+                free(lcs);
+        if (new_line)
+                free(new_line);
+        if (old_line)
+                free(old_line);
+}
+static void print_deferred_old_lines()
+{
+        struct deferred_lines *iter_old, *tmp;
+        iter_old = deferred_old;
+        while (iter_old) {
+                print_ssdiff_line("del", iter_old->line_no,
+                                  iter_old->line, -1, NULL, 0);
+                tmp = iter_old->next;
+                free(iter_old);
+                iter_old = tmp;
+        }
+}
+static void print_deferred_new_lines()
+{
+        struct deferred_lines *iter_new, *tmp;
+        iter_new = deferred_new;
+        while (iter_new) {
+                print_ssdiff_line("add", -1, NULL,
+                                  iter_new->line_no, iter_new->line, 0);
+                tmp = iter_new->next;
+                free(iter_new);
+                iter_new = tmp;
+        }
+}
+static void print_deferred_changed_lines()
+{
+        struct deferred_lines *iter_old, *iter_new, *tmp;
+        int n_old_lines = calc_deferred_lines(deferred_old);
+        int n_new_lines = calc_deferred_lines(deferred_new);
+        int individual_chars = (n_old_lines == n_new_lines ? 1 : 0);
+        iter_old = deferred_old;
+        iter_new = deferred_new;
+        while (iter_old || iter_new) {
+                if (iter_old && iter_new)
+                        print_ssdiff_line("changed", iter_old->line_no,
+                                          iter_old->line,
+                                          iter_new->line_no, iter_new->line,
+                                          individual_chars);
+                else if (iter_old)
+                        print_ssdiff_line("changed", iter_old->line_no,
+                                          iter_old->line, -1, NULL, 0);
+                else if (iter_new)
+                        print_ssdiff_line("changed", -1, NULL,
+                                          iter_new->line_no, iter_new->line, 0);
+                if (iter_old) {
+                        tmp = iter_old->next;
+                        free(iter_old);
+                        iter_old = tmp;
+                }
+                if (iter_new) {
+                        tmp = iter_new->next;
+                        free(iter_new);
+                        iter_new = tmp;
+                }
+        }
+}
+void cgit_ssdiff_print_deferred_lines()
+{
+        if (!deferred_old && !deferred_new)
+                return;
+        if (deferred_old && !deferred_new)
+                print_deferred_old_lines();
+        else if (!deferred_old && deferred_new)
+                print_deferred_new_lines();
+        else
+                print_deferred_changed_lines();
+        deferred_old = deferred_old_last = NULL;
+        deferred_new = deferred_new_last = NULL;
+}
+/*
+ * print a single line returned from xdiff
+ */
+void cgit_ssdiff_line_cb(char *line, int len)
+{
+        char c = line[len - 1];
+        line[len - 1] = '\0';
+        if (line[0] == '@') {
+                current_old_line = line_from_hunk(line, '-');
+                current_new_line = line_from_hunk(line, '+');
+        }
+        if (line[0] == ' ') {
+                if (deferred_old || deferred_new)
+                        cgit_ssdiff_print_deferred_lines();
+                print_ssdiff_line("ctx", current_old_line, line,
+                                  current_new_line, line, 0);
+                current_old_line += 1;
+                current_new_line += 1;
+        } else if (line[0] == '+') {
+                deferred_new_add(line, current_new_line);
+                current_new_line += 1;
+        } else if (line[0] == '-') {
+                deferred_old_add(line, current_old_line);
+                current_old_line += 1;
+        } else if (line[0] == '@') {
+                html("<tr><td colspan='4' class='hunk'>");
+                html_txt(line);
+                html("</td></tr>");
+        } else {
+                html("<tr><td colspan='4' class='ctx'>");
+                html_txt(line);
+                html("</td></tr>");
+        }
+        line[len - 1] = c;
+}
+void cgit_ssdiff_header_begin()
+{
+        current_old_line = -1;
+        current_new_line = -1;
+        html("<tr><td class='space' colspan='4'><div></div></td></tr>");
+        html("<tr><td class='head' colspan='4'>");
+}
+void cgit_ssdiff_header_end()
+{
+        html("</td><tr>");
+}
+void cgit_ssdiff_footer()
+{
+        if (deferred_old || deferred_new)
+                cgit_ssdiff_print_deferred_lines();
+        html("<tr><td class='foot' colspan='4'></td></tr>");
+}
diff --git a/ui-ssdiff.h b/ui-ssdiff.h
new file mode 100644
index 0000000..64b4b12
--- a/dev/null
+++ b/ui-ssdiff.h
@@ -0,0 +1,13 @@
+#ifndef UI_SSDIFF_H
+#define UI_SSDIFF_H
+extern void cgit_ssdiff_print_deferred_lines();
+extern void cgit_ssdiff_line_cb(char *line, int len);
+extern void cgit_ssdiff_header_begin();
+extern void cgit_ssdiff_header_end();
+extern void cgit_ssdiff_footer();
+#endif /* UI_SSDIFF_H */
diff --git a/ui-stats.c b/ui-stats.c
index 50c2540..2a0c174 100644
--- a/ui-stats.c
+++ b/ui-stats.c
@@ -1,31 +1,35 @@
-#include <string-list.h>
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
 #include "ui-stats.h"
+#ifdef NO_C99_FORMAT
+#define SZ_FMT "%u"
+#else
+#define SZ_FMT "%zu"
+#endif
 #define MONTHS 6
 struct authorstat {
        long total;
        struct string_list list;
 };
 #define DAY_SECS (60 * 60 * 24)
 #define WEEK_SECS (DAY_SECS * 7)
 static void trunc_week(struct tm *tm)
 {
        time_t t = timegm(tm);
        t -= ((tm->tm_wday + 6) % 7) * DAY_SECS;
                gmtime_r(&t, tm);
 }
 static void dec_week(struct tm *tm)
 {
        time_t t = timegm(tm);
        t -= WEEK_SECS;
                gmtime_r(&t, tm);
 }
@@ -262,133 +266,133 @@ void print_combined_authorrow(struct string_list *authors, int from, int to,
        struct tm *tm;
        char *tmp;
        time(&now);
        tm = gmtime(&now);
        period->trunc(tm);
        for (i = 1; i < period->count; i++)
                period->dec(tm);
        total = 0;
        htmlf("<tr><td class='%s'>%s</td>", leftclass,
                fmt(name, to - from + 1));
        for (j = 0; j < period->count; j++) {
                tmp = period->pretty(tm);
                period->inc(tm);
                subtotal = 0;
                for (i = from; i <= to; i++) {
                        author = &authors->items[i];
                        authorstat = author->util;
                        items = &authorstat->list;
                        date = string_list_lookup(items, tmp);
                        if (date)
                                subtotal += (size_t)date->util;
                }
-                htmlf("<td class='%s'>%d</td>", centerclass, subtotal);
+                htmlf("<td class='%s'>%ld</td>", centerclass, subtotal);
                total += subtotal;
        }
-        htmlf("<td class='%s'>%d</td></tr>", rightclass, total);
+        htmlf("<td class='%s'>%ld</td></tr>", rightclass, total);
 }
 void print_authors(struct string_list *authors, int top,
                   struct cgit_period *period)
 {
        struct string_list_item *author;
        struct authorstat *authorstat;
        struct string_list *items;
        struct string_list_item *date;
        time_t now;
        long i, j, total;
        struct tm *tm;
        char *tmp;
        time(&now);
        tm = gmtime(&now);
        period->trunc(tm);
        for (i = 1; i < period->count; i++)
                period->dec(tm);
        html("<table class='stats'><tr><th>Author</th>");
        for (j = 0; j < period->count; j++) {
                tmp = period->pretty(tm);
                htmlf("<th>%s</th>", tmp);
                period->inc(tm);
        }
        html("<th>Total</th></tr>\n");
        if (top <= 0 || top > authors->nr)
                top = authors->nr;
        for (i = 0; i < top; i++) {
                author = &authors->items[i];
                html("<tr><td class='left'>");
                html_txt(author->string);
                html("</td>");
                authorstat = author->util;
                items = &authorstat->list;
                total = 0;
                for (j = 0; j < period->count; j++)
                        period->dec(tm);
                for (j = 0; j < period->count; j++) {
                        tmp = period->pretty(tm);
                        period->inc(tm);
                        date = string_list_lookup(items, tmp);
                        if (!date)
                                html("<td>0</td>");
                        else {
-                                htmlf("<td>%d</td>", date->util);
+                                htmlf("<td>"SZ_FMT"</td>", (size_t)date->util);
                                total += (size_t)date->util;
                        }
                }
-                htmlf("<td class='sum'>%d</td></tr>", total);
+                htmlf("<td class='sum'>%ld</td></tr>", total);
        }
        if (top < authors->nr)
                print_combined_authorrow(authors, top, authors->nr - 1,
-                        "Others (%d)", "left", "", "sum", period);
+                        "Others (%ld)", "left", "", "sum", period);
        print_combined_authorrow(authors, 0, authors->nr - 1, "Total",
                "total", "sum", "sum", period);
        html("</table>");
 }
 /* Create a sorted string_list with one entry per author. The util-field
 * for each author is another string_list which is used to calculate the
 * number of commits per time-interval.
 */
 void cgit_show_stats(struct cgit_context *ctx)
 {
        struct string_list authors;
        struct cgit_period *period;
        int top, i;
        const char *code = "w";
        if (ctx->qry.period)
                code = ctx->qry.period;
        i = cgit_find_stats_period(code, &period);
        if (!i) {
-                cgit_print_error(fmt("Unknown statistics type: %c", code));
+                cgit_print_error(fmt("Unknown statistics type: %c", code[0]));
                return;
        }
        if (i > ctx->repo->max_stats) {
                cgit_print_error(fmt("Statistics type disabled: %s",
                                     period->name));
                return;
        }
        authors = collect_stats(ctx, period);
        qsort(authors.items, authors.nr, sizeof(struct string_list_item),
                cmp_total_commits);
        top = ctx->qry.ofs;
        if (!top)
                top = 10;
        htmlf("<h2>Commits per author per %s", period->name);
        if (ctx->qry.path) {
                html(" (path '");
                html_txt(ctx->qry.path);
                html("')");
        }
        html("</h2>");
        html("<form method='get' action='' style='float: right; text-align: right;'>");
        cgit_add_hidden_formfields(1, 0, "stats");
diff --git a/ui-summary.c b/ui-summary.c
index a2c018e..5be2545 100644
--- a/ui-summary.c
+++ b/ui-summary.c
@@ -1,92 +1,124 @@
 /* ui-summary.c: functions for generating repo summary page
 *
 * Copyright (C) 2006 Lars Hjemli
+ * Copyright (C) 2010 Jason A. Donenfeld <Jason@zx2c4.com>
 *
 * Licensed under GNU General Public License v2
 *   (see COPYING for full license text)
 */
 #include "cgit.h"
 #include "html.h"
 #include "ui-log.h"
 #include "ui-refs.h"
+#include "ui-blob.h"
 int urls = 0;
 static void print_url(char *base, char *suffix)
 {
        if (!base || !*base)
                return;
        if (urls++ == 0) {
                html("<tr class='nohover'><td colspan='4'>&nbsp;</td></tr>");
                html("<tr><th class='left' colspan='4'>Clone</th></tr>\n");
        }
        if (suffix && *suffix)
                base = fmt("%s/%s", base, suffix);
        html("<tr><td colspan='4'><a href='");
        html_url_path(base);
        html("'>");
        html_txt(base);
        html("</a></td></tr>\n");
 }
 static void print_urls(char *txt, char *suffix)
 {
        char *h = txt, *t, c;
        while (h && *h) {
                while (h && *h == ' ')
                        h++;
                t = h;
                while (t && *t && *t != ' ')
                        t++;
                c = *t;
                *t = 0;
                print_url(h, suffix);
                *t = c;
                h = t;
        }
 }
 void cgit_print_summary()
 {
        html("<table summary='repository info' class='list nowrap'>");
        cgit_print_branches(ctx.cfg.summary_branches);
        html("<tr class='nohover'><td colspan='4'>&nbsp;</td></tr>");
        cgit_print_tags(ctx.cfg.summary_tags);
        if (ctx.cfg.summary_log > 0) {
                html("<tr class='nohover'><td colspan='4'>&nbsp;</td></tr>");
                cgit_print_log(ctx.qry.head, 0, ctx.cfg.summary_log, NULL,
-                               NULL, NULL, 0);
+                               NULL, NULL, 0, 0);
        }
        if (ctx.repo->clone_url)
                print_urls(ctx.repo->clone_url, NULL);
        else if (ctx.cfg.clone_prefix)
                print_urls(ctx.cfg.clone_prefix, ctx.repo->url);
        html("</table>");
 }
 void cgit_print_repo_readme(char *path)
 {
-        char *slash, *tmp;
+        char *slash, *tmp, *colon, *ref;
-        if (!ctx.repo->readme)
+        if (!ctx.repo->readme || !(*ctx.repo->readme))
                return;
+        ref = NULL;
+        /* Check if the readme is tracked in the git repo. */
+        colon = strchr(ctx.repo->readme, ':');
+        if (colon && strlen(colon) > 1) {
+                *colon = '\0';
+                ref = ctx.repo->readme;
+                ctx.repo->readme = colon + 1;
+                if (!(*ctx.repo->readme))
+                        return;
+        }
+        /* Prepend repo path to relative readme path unless tracked. */
+        if (!ref && *ctx.repo->readme != '/')
+                ctx.repo->readme = xstrdup(fmt("%s/%s", ctx.repo->path,
+                                               ctx.repo->readme));
+        /* If a subpath is specified for the about page, make it relative
+         * to the directory containing the configured readme.
+         */
        if (path) {
                slash = strrchr(ctx.repo->readme, '/');
-                if (!slash)
+                if (!slash) {
-                        return;
+                        if (!colon)
+                                return;
+                        slash = colon;
+                }
                tmp = xmalloc(slash - ctx.repo->readme + 1 + strlen(path) + 1);
                strncpy(tmp, ctx.repo->readme, slash - ctx.repo->readme + 1);
                strcpy(tmp + (slash - ctx.repo->readme + 1), path);
        } else
                tmp = ctx.repo->readme;
+        /* Print the calculated readme, either from the git repo or from the
+         * filesystem, while applying the about-filter.
+         */
        html("<div id='summary'>");
        if (ctx.repo->about_filter)
                cgit_open_filter(ctx.repo->about_filter);
-        html_include(tmp);
+        if (ref)
+                cgit_print_file(tmp, ref);
+        else
+                html_include(tmp);
        if (ctx.repo->about_filter)
                cgit_close_filter(ctx.repo->about_filter);
        html("</div>");
 }
diff --git a/ui-tag.c b/ui-tag.c
index c2d72af..39e4cb8 100644
--- a/ui-tag.c
+++ b/ui-tag.c
@@ -9,84 +9,96 @@
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
 static void print_tag_content(char *buf)
 {
        char *p;
        if (!buf)
                return;
        html("<div class='commit-subject'>");
        p = strchr(buf, '\n');
        if (p)
                *p = '\0';
        html_txt(buf);
        html("</div>");
        if (p) {
                html("<div class='commit-msg'>");
                html_txt(++p);
                html("</div>");
        }
 }
+void print_download_links(char *revname)
+{
+        html("<tr><th>download</th><td class='sha1'>");
+        cgit_print_snapshot_links(ctx.qry.repo, ctx.qry.head,
+                                  revname, ctx.repo->snapshots);
+        html("</td></tr>");
+}
 void cgit_print_tag(char *revname)
 {
        unsigned char sha1[20];
        struct object *obj;
        struct tag *tag;
        struct taginfo *info;
        if (!revname)
                revname = ctx.qry.head;
        if (get_sha1(fmt("refs/tags/%s", revname), sha1)) {
                cgit_print_error(fmt("Bad tag reference: %s", revname));
                return;
        }
        obj = parse_object(sha1);
        if (!obj) {
                cgit_print_error(fmt("Bad object id: %s", sha1_to_hex(sha1)));
                return;
        }
        if (obj->type == OBJ_TAG) {
                tag = lookup_tag(sha1);
                if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag))) {
                        cgit_print_error(fmt("Bad tag object: %s", revname));
                        return;
                }
                html("<table class='commit-info'>\n");
-                htmlf("<tr><td>Tag name</td><td>");
+                htmlf("<tr><td>tag name</td><td>");
                html_txt(revname);
                htmlf(" (%s)</td></tr>\n", sha1_to_hex(sha1));
                if (info->tagger_date > 0) {
-                        html("<tr><td>Tag date</td><td>");
+                        html("<tr><td>tag date</td><td>");
                        cgit_print_date(info->tagger_date, FMT_LONGDATE, ctx.cfg.local_time);
                        html("</td></tr>\n");
                }
                if (info->tagger) {
-                        html("<tr><td>Tagged by</td><td>");
+                        html("<tr><td>tagged by</td><td>");
                        html_txt(info->tagger);
                        if (info->tagger_email && !ctx.cfg.noplainemail) {
                                html(" ");
                                html_txt(info->tagger_email);
                        }
                        html("</td></tr>\n");
                }
-                html("<tr><td>Tagged object</td><td>");
+                html("<tr><td>tagged object</td><td class='sha1'>");
                cgit_object_link(tag->tagged);
                html("</td></tr>\n");
+                if (ctx.repo->snapshots)
+                        print_download_links(revname);
                html("</table>\n");
                print_tag_content(info->msg);
        } else {
                html("<table class='commit-info'>\n");
-                htmlf("<tr><td>Tag name</td><td>");
+                htmlf("<tr><td>tag name</td><td>");
                html_txt(revname);
                html("</td></tr>\n");
-                html("<tr><td>Tagged object</td><td>");
+                html("<tr><td>Tagged object</td><td class='sha1'>");
                cgit_object_link(obj);
                html("</td></tr>\n");
+                if (ctx.repo->snapshots)
+                        print_download_links(revname);
                html("</table>\n");
        }
        return;
 }
diff --git a/ui-tree.c b/ui-tree.c
index a164767..0b1b531 100644
--- a/ui-tree.c
+++ b/ui-tree.c
@@ -25,108 +25,114 @@ static void print_text_buffer(const char *name, char *buf, unsigned long size)
        if (ctx.cfg.enable_tree_linenumbers) {
                html("<tr><td class='linenumbers'><pre>");
                idx = 0;
                lineno = 0;
        
                if (size) {
                        htmlf(numberfmt, ++lineno);
                        while(idx < size - 1) { // skip absolute last newline
                                if (buf[idx] == '\n')
                                        htmlf(numberfmt, ++lineno);
                                idx++;
                        }
                }
                html("</pre></td>\n");
        }
        else {
                html("<tr>\n");
        }
        if (ctx.repo->source_filter) {
                html("<td class='lines'><pre><code>");
                ctx.repo->source_filter->argv[1] = xstrdup(name);
                cgit_open_filter(ctx.repo->source_filter);
-                write(STDOUT_FILENO, buf, size);
+                html_raw(buf, size);
                cgit_close_filter(ctx.repo->source_filter);
                html("</code></pre></td></tr></table>\n");
                return;
        }
        html("<td class='lines'><pre><code>");
        html_txt(buf);
        html("</code></pre></td></tr></table>\n");
 }
 #define ROWLEN 32
 static void print_binary_buffer(char *buf, unsigned long size)
 {
        unsigned long ofs, idx;
        static char ascii[ROWLEN + 1];
        html("<table summary='blob content' class='bin-blob'>\n");
        html("<tr><th>ofs</th><th>hex dump</th><th>ascii</th></tr>");
        for (ofs = 0; ofs < size; ofs += ROWLEN, buf += ROWLEN) {
-                htmlf("<tr><td class='right'>%04x</td><td class='hex'>", ofs);
+                htmlf("<tr><td class='right'>%04lx</td><td class='hex'>", ofs);
                for (idx = 0; idx < ROWLEN && ofs + idx < size; idx++)
                        htmlf("%*s%02x",
                              idx == 16 ? 4 : 1, "",
                              buf[idx] & 0xff);
                html(" </td><td class='hex'>");
                for (idx = 0; idx < ROWLEN && ofs + idx < size; idx++)
                        ascii[idx] = isgraph(buf[idx]) ? buf[idx] : '.';
                ascii[idx] = '\0';
                html_txt(ascii);
                html("</td></tr>\n");
        }
        html("</table>\n");
 }
 static void print_object(const unsigned char *sha1, char *path, const char *basename)
 {
        enum object_type type;
        char *buf;
        unsigned long size;
        type = sha1_object_info(sha1, &size);
        if (type == OBJ_BAD) {
                cgit_print_error(fmt("Bad object name: %s",
                                     sha1_to_hex(sha1)));
                return;
        }
        buf = read_sha1_file(sha1, &type, &size);
        if (!buf) {
                cgit_print_error(fmt("Error reading object %s",
                                     sha1_to_hex(sha1)));
                return;
        }
-        html(" (");
+        htmlf("blob: %s (", sha1_to_hex(sha1));
        cgit_plain_link("plain", NULL, NULL, ctx.qry.head,
                        curr_rev, path);
-        htmlf(")<br/>blob: %s\n", sha1_to_hex(sha1));
+        html(")\n");
+        if (ctx.cfg.max_blob_size && size / 1024 > ctx.cfg.max_blob_size) {
+                htmlf("<div class='error'>blob size (%ldKB) exceeds display size limit (%dKB).</div>",
+                                size / 1024, ctx.cfg.max_blob_size);
+                return;
+        }
        if (buffer_is_binary(buf, size))
                print_binary_buffer(buf, size);
        else
                print_text_buffer(basename, buf, size);
 }
 static int ls_item(const unsigned char *sha1, const char *base, int baselen,
                   const char *pathname, unsigned int mode, int stage,
                   void *cbdata)
 {
        char *name;
        char *fullpath;
        char *class;
        enum object_type type;
        unsigned long size = 0;
        name = xstrdup(pathname);
        fullpath = fmt("%s%s%s", ctx.qry.path ? ctx.qry.path : "",
                       ctx.qry.path ? "/" : "", name);
        if (!S_ISGITLINK(mode)) {
                type = sha1_object_info(sha1, &size);
@@ -148,138 +154,129 @@ static int ls_item(const unsigned char *sha1, const char *base, int baselen,
                              sha1_to_hex(sha1)));
                html("'>");
                html_txt(name);
                html("</a>");
        } else if (S_ISDIR(mode)) {
                cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head,
                               curr_rev, fullpath);
        } else {
                class = strrchr(name, '.');
                if (class != NULL) {
                        class = fmt("ls-blob %s", class + 1);
                } else
                        class = "ls-blob";
                cgit_tree_link(name, NULL, class, ctx.qry.head,
                               curr_rev, fullpath);
        }
        htmlf("</td><td class='ls-size'>%li</td>", size);
        html("<td>");
        cgit_log_link("log", NULL, "button", ctx.qry.head, curr_rev,
                      fullpath, 0, NULL, NULL, ctx.qry.showmsg);
        if (ctx.repo->max_stats)
                cgit_stats_link("stats", NULL, "button", ctx.qry.head,
                                fullpath);
+        cgit_plain_link("plain", NULL, "button", ctx.qry.head, curr_rev,
+                        fullpath);
        html("</td></tr>\n");
        free(name);
        return 0;
 }
 static void ls_head()
 {
        html("<table summary='tree listing' class='list'>\n");
        html("<tr class='nohover'>");
        html("<th class='left'>Mode</th>");
        html("<th class='left'>Name</th>");
        html("<th class='right'>Size</th>");
        html("<th/>");
        html("</tr>\n");
        header = 1;
 }
 static void ls_tail()
 {
        if (!header)
                return;
        html("</table>\n");
        header = 0;
 }
 static void ls_tree(const unsigned char *sha1, char *path)
 {
        struct tree *tree;
        tree = parse_tree_indirect(sha1);
        if (!tree) {
                cgit_print_error(fmt("Not a tree object: %s",
                                     sha1_to_hex(sha1)));
                return;
        }
        ls_head();
        read_tree_recursive(tree, "", 0, 1, NULL, ls_item, NULL);
        ls_tail();
 }
 static int walk_tree(const unsigned char *sha1, const char *base, int baselen,
                     const char *pathname, unsigned mode, int stage,
                     void *cbdata)
 {
        static int state;
        static char buffer[PATH_MAX];
-        char *url;
        if (state == 0) {
                memcpy(buffer, base, baselen);
                strcpy(buffer+baselen, pathname);
-                url = cgit_pageurl(ctx.qry.repo, "tree",
-                                   fmt("h=%s&amp;path=%s", curr_rev, buffer));
-                html("/");
-                cgit_tree_link(xstrdup(pathname), NULL, NULL, ctx.qry.head,
-                               curr_rev, buffer);
                if (strcmp(match_path, buffer))
                        return READ_TREE_RECURSIVE;
                if (S_ISDIR(mode)) {
                        state = 1;
                        ls_head();
                        return READ_TREE_RECURSIVE;
                } else {
                        print_object(sha1, buffer, pathname);
                        return 0;
                }
        }
        ls_item(sha1, base, baselen, pathname, mode, stage, NULL);
        return 0;
 }
 /*
 * Show a tree or a blob
 *   rev:  the commit pointing at the root tree object
 *   path: path to tree or blob
 */
 void cgit_print_tree(const char *rev, char *path)
 {
        unsigned char sha1[20];
        struct commit *commit;
        const char *paths[] = {path, NULL};
        if (!rev)
                rev = ctx.qry.head;
        curr_rev = xstrdup(rev);
        if (get_sha1(rev, sha1)) {
                cgit_print_error(fmt("Invalid revision name: %s", rev));
                return;
        }
        commit = lookup_commit_reference(sha1);
        if (!commit || parse_commit(commit)) {
                cgit_print_error(fmt("Invalid commit reference: %s", rev));
                return;
        }
-        html("path: <a href='");
-        html_attr(cgit_pageurl(ctx.qry.repo, "tree", fmt("h=%s", rev)));
-        html("'>root</a>");
        if (path == NULL) {
                ls_tree(commit->tree->object.sha1, NULL);
                return;
        }
        match_path = path;
        read_tree_recursive(commit->tree, "", 0, 0, paths, walk_tree, NULL);
        ls_tail();
 }
diff --git a/vector.c b/vector.c
new file mode 100644
index 0000000..0863908
--- a/dev/null
+++ b/vector.c
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include "vector.h"
+static int grow(struct vector *vec, int gently)
+{
+        size_t new_alloc;
+        void *new_data;
+        new_alloc = vec->alloc * 3 / 2;
+        if (!new_alloc)
+                new_alloc = 8;
+        new_data = realloc(vec->data, new_alloc * vec->size);
+        if (!new_data) {
+                if (gently)
+                        return ENOMEM;
+                perror("vector.c:grow()");
+                exit(1);
+        }
+        vec->data = new_data;
+        vec->alloc = new_alloc;
+        return 0;
+}
+int vector_push(struct vector *vec, const void *data, int gently)
+{
+        int rc;
+        if (vec->count == vec->alloc && (rc = grow(vec, gently)))
+                return rc;
+        if (data)
+                memmove(vec->data + vec->count * vec->size, data, vec->size);
+        else
+                memset(vec->data + vec->count * vec->size, 0, vec->size);
+        vec->count++;
+        return 0;
+}
diff --git a/vector.h b/vector.h
new file mode 100644
index 0000000..c64eb1f
--- a/dev/null
+++ b/vector.h
@@ -0,0 +1,17 @@
+#ifndef CGIT_VECTOR_H
+#define CGIT_VECTOR_H
+#include <stdlib.h>
+struct vector {
+        size_t size;
+        size_t count;
+        size_t alloc;
+        void *data;
+};
+#define VECTOR_INIT(type) {sizeof(type), 0, 0, NULL}
+int vector_push(struct vector *vec, const void *data, int gently);
+#endif /* CGIT_VECTOR_H */