Add plain patch view

The new view mimics the output from `git format-patch`, making it possible
to cherry-pick directly from cgit with something like `curl $url | git am`.

Inspired by a patch to `git-apply` by Mike Hommey:
  http://thread.gmane.org/gmane.comp.version-control.git/67611/focus=67610

Signed-off-by: Lars Hjemli <hjemli@gmail.com>

6 files changed, 122 insertions, 2 deletions

diff --git a/Makefile b/Makefile
index 72c189c..eed59df 100644
--- a/Makefile
+++ b/Makefile
@@ -1,83 +1,83 @@
 CGIT_VERSION = v0.7.1
 CGIT_SCRIPT_NAME = cgit.cgi
 CGIT_SCRIPT_PATH = /var/www/htdocs/cgit
 CGIT_CONFIG = /etc/cgitrc
 CACHE_ROOT = /var/cache/cgit
 SHA1_HEADER = <openssl/sha.h>
 GIT_VER = 1.5.3.5
 GIT_URL = http://www.kernel.org/pub/software/scm/git/git-$(GIT_VER).tar.bz2
 
 #
 # Let the user override the above settings.
 #
 -include cgit.conf
 
 
 EXTLIBS = git/libgit.a git/xdiff/lib.a -lz -lcrypto
 OBJECTS = shared.o cache.o parsing.o html.o ui-shared.o ui-repolist.o \
 	ui-summary.o ui-log.o ui-tree.o ui-commit.o ui-diff.o \
-	ui-snapshot.o ui-blob.o ui-tag.o ui-refs.o
+	ui-snapshot.o ui-blob.o ui-tag.o ui-refs.o ui-patch.o
 
 
 ifdef NEEDS_LIBICONV
 	EXTLIBS += -liconv
 endif
 
 
 .PHONY: all git test install clean distclean emptycache force-version get-git
 
 all: cgit git
 
 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)"'
 
 
 cgit: cgit.c $(OBJECTS)
 	$(CC) $(CFLAGS) cgit.c -o cgit $(OBJECTS) $(EXTLIBS)
 
 $(OBJECTS): cgit.h git/xdiff/lib.a git/libgit.a VERSION
 
 git/xdiff/lib.a: | git
 
 git/libgit.a: | git
 
 git:
 	cd git && $(MAKE) xdiff/lib.a
 	cd git && $(MAKE) libgit.a
 
 test: all
 	$(MAKE) -C tests
 
 install: all
 	mkdir -p $(DESTDIR)$(CGIT_SCRIPT_PATH)
 	install cgit $(DESTDIR)$(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME)
 	install cgit.css $(DESTDIR)$(CGIT_SCRIPT_PATH)/cgit.css
 	install cgit.png $(DESTDIR)$(CGIT_SCRIPT_PATH)/cgit.png
 
 uninstall:
 	rm -f $(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME)
 	rm -f $(CGIT_SCRIPT_PATH)/cgit.css
 	rm -f $(CGIT_SCRIPT_PATH)/cgit.png
 
 clean:
 	rm -f cgit VERSION *.o
 	cd git && $(MAKE) clean
 
 distclean: clean
 	git clean -d -x
 	cd git && git clean -d -x
 
 emptycache:
 	rm -rf $(DESTDIR)$(CACHE_ROOT)/*
 
 get-git:
 	curl $(GIT_URL) | tar -xj && rm -rf git && mv git-$(GIT_VER) git
diff --git a/cgit.c b/cgit.c
index 142e416..9ca93a7 100644
--- a/cgit.c
+++ b/cgit.c
@@ -14,128 +14,133 @@ static int cgit_prepare_cache(struct cacheitem *item)
 		char *title = fmt("%s - %s", cgit_root_title, "Bad request");
 		cgit_print_docstart(title, item);
 		cgit_print_pageheader(title, 0);
 		cgit_print_error(fmt("Unknown repo: %s", cgit_query_repo));
 		cgit_print_docend();
 		return 0;
 	}
 
 	if (!cgit_repo) {
 		item->name = xstrdup(fmt("%s/index.html", cgit_cache_root));
 		item->ttl = cgit_cache_root_ttl;
 		return 1;
 	}
 
 	if (!cgit_cmd) {
 		item->name = xstrdup(fmt("%s/%s/index.%s.html", cgit_cache_root,
 					 cache_safe_filename(cgit_repo->url),
 					 cache_safe_filename(cgit_querystring)));
 		item->ttl = cgit_cache_repo_ttl;
 	} else {
 		item->name = xstrdup(fmt("%s/%s/%s/%s.html", cgit_cache_root,
 					 cache_safe_filename(cgit_repo->url),
 					 cgit_query_page,
 					 cache_safe_filename(cgit_querystring)));
 		if (cgit_query_has_symref)
 			item->ttl = cgit_cache_dynamic_ttl;
 		else if (cgit_query_has_sha1)
 			item->ttl = cgit_cache_static_ttl;
 		else
 			item->ttl = cgit_cache_repo_ttl;
 	}
 	return 1;
 }
 
 static void cgit_print_repo_page(struct cacheitem *item)
 {
 	char *title;
 	int show_search;
 
 	if (!cgit_query_head)
 		cgit_query_head = cgit_repo->defbranch;
 
 	if (chdir(cgit_repo->path)) {
 		title = fmt("%s - %s", cgit_root_title, "Bad request");
 		cgit_print_docstart(title, item);
 		cgit_print_pageheader(title, 0);
 		cgit_print_error(fmt("Unable to scan repository: %s",
 				     strerror(errno)));
 		cgit_print_docend();
 		return;
 	}
 
 	title = fmt("%s - %s", cgit_repo->name, cgit_repo->desc);
 	show_search = 0;
 	setenv("GIT_DIR", cgit_repo->path, 1);
 
 	if ((cgit_cmd == CMD_SNAPSHOT) && cgit_repo->snapshots) {
 		cgit_print_snapshot(item, cgit_query_head, cgit_query_sha1,
 				    cgit_repobasename(cgit_repo->url),
 				    cgit_query_path,
 				    cgit_repo->snapshots );
 		return;
 	}
 
+	if (cgit_cmd == CMD_PATCH) {
+		cgit_print_patch(cgit_query_sha1, item);
+		return;
+	}
+
 	if (cgit_cmd == CMD_BLOB) {
 		cgit_print_blob(item, cgit_query_sha1, cgit_query_path);
 		return;
 	}
 
 	show_search = (cgit_cmd == CMD_LOG);
 	cgit_print_docstart(title, item);
 	if (!cgit_cmd) {
 		cgit_print_pageheader("summary", show_search);
 		cgit_print_summary();
 		cgit_print_docend();
 		return;
 	}
 
 	cgit_print_pageheader(cgit_query_page, show_search);
 
 	switch(cgit_cmd) {
 	case CMD_LOG:
 		cgit_print_log(cgit_query_sha1, cgit_query_ofs,
 			       cgit_max_commit_count, cgit_query_grep, cgit_query_search,
 			       cgit_query_path, 1);
 		break;
 	case CMD_TREE:
 		cgit_print_tree(cgit_query_sha1, cgit_query_path);
 		break;
 	case CMD_COMMIT:
 		cgit_print_commit(cgit_query_sha1);
 		break;
 	case CMD_REFS:
 		cgit_print_refs();
 		break;
 	case CMD_TAG:
 		cgit_print_tag(cgit_query_sha1);
 		break;
 	case CMD_DIFF:
 		cgit_print_diff(cgit_query_sha1, cgit_query_sha2, cgit_query_path);
 		break;
 	default:
 		cgit_print_error("Invalid request");
 	}
 	cgit_print_docend();
 }
 
 static void cgit_fill_cache(struct cacheitem *item, int use_cache)
 {
 	static char buf[PATH_MAX];
 	int stdout2;
 
 	getcwd(buf, sizeof(buf));
 	item->st.st_mtime = time(NULL);
 
 	if (use_cache) {
 		stdout2 = chk_positive(dup(STDOUT_FILENO),
 				       "Preserving STDOUT");
 		chk_zero(close(STDOUT_FILENO), "Closing STDOUT");
 		chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)");
 	}
 
 	if (cgit_repo)
 		cgit_print_repo_page(item);
 	else
 		cgit_print_repolist(item);
 
 	if (use_cache) {
diff --git a/cgit.h b/cgit.h
index f223dbc..66c40b9 100644
--- a/cgit.h
+++ b/cgit.h
@@ -1,96 +1,97 @@
 #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 <xdiff/xdiff.h>
 #include <utf8.h>
 
 
 /*
  * The valid cgit repo-commands
  */
 #define CMD_LOG      1
 #define CMD_COMMIT   2
 #define CMD_DIFF     3
 #define CMD_TREE     4
 #define CMD_BLOB     5
 #define CMD_SNAPSHOT 6
 #define CMD_TAG      7
 #define CMD_REFS     8
+#define CMD_PATCH    9
 
 /*
  * Dateformats used on misc. pages
  */
 #define FMT_LONGDATE "%Y-%m-%d %H:%M:%S"
 #define FMT_SHORTDATE "%Y-%m-%d"
 
 
 /*
  * 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
  */
 #define PAGE_ENCODING "UTF-8"
 
 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 cacheitem {
 	char *name;
 	struct stat st;
 	int ttl;
 	int fd;
 };
 
 struct repoinfo {
 	char *url;
 	char *name;
 	char *path;
 	char *desc;
 	char *owner;
 	char *defbranch;
 	char *group;
 	char *module_link;
 	char *readme;
 	char *clone_url;
 	int snapshots;
 	int enable_log_filecount;
 	int enable_log_linecount;
 };
 
 struct repolist {
 	int length;
 	int count;
 	struct repoinfo *repos;
 };
 
 struct commitinfo {
 	struct commit *commit;
 	char *author;
 	char *author_email;
 	unsigned long author_date;
 	char *committer;
 	char *committer_email;
@@ -222,72 +223,73 @@ extern void html_option(char *value, char *text, char *selected_value);
 extern void html_link_open(char *url, char *title, char *class);
 extern void html_link_close(void);
 extern void html_filemode(unsigned short mode);
 extern int html_include(const char *filename);
 
 extern int cgit_read_config(const char *filename, configfn fn);
 extern int cgit_parse_query(char *txt, configfn fn);
 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 char *cache_safe_filename(const char *unsafe);
 extern int cache_lock(struct cacheitem *item);
 extern int cache_unlock(struct cacheitem *item);
 extern int cache_cancel_lock(struct cacheitem *item);
 extern int cache_exist(struct cacheitem *item);
 extern int cache_expired(struct cacheitem *item);
 
 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 const char *cgit_repobasename(const char *reponame);
 
 extern void cgit_tree_link(char *name, char *title, char *class, char *head,
 			   char *rev, char *path);
 extern void cgit_log_link(char *name, char *title, char *class, char *head,
 			  char *rev, char *path, int ofs, char *grep,
 			  char *pattern);
 extern void cgit_commit_link(char *name, char *title, char *class, char *head,
 			     char *rev);
 extern void cgit_refs_link(char *name, char *title, char *class, char *head,
 			   char *rev, char *path);
 extern void cgit_snapshot_link(char *name, char *title, char *class,
 			       char *head, char *rev, char *archivename);
 extern void cgit_diff_link(char *name, char *title, char *class, char *head,
 			   char *new_rev, char *old_rev, char *path);
 
 extern void cgit_object_link(struct object *obj);
 
 extern void cgit_print_error(char *msg);
 extern void cgit_print_date(time_t secs, char *format);
 extern void cgit_print_age(time_t t, time_t max_relative, char *format);
 extern void cgit_print_docstart(char *title, struct cacheitem *item);
 extern void cgit_print_docend();
 extern void cgit_print_pageheader(char *title, int show_search);
 extern void cgit_print_snapshot_start(const char *mimetype,
 				      const char *filename,
 				      struct cacheitem *item);
 extern void cgit_print_branches(int maxcount);
 extern void cgit_print_tags(int maxcount);
 
 extern void cgit_print_repolist(struct cacheitem *item);
 extern void cgit_print_summary();
 extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep,
 			   char *pattern, char *path, int pager);
 extern void cgit_print_blob(struct cacheitem *item, const char *hex, char *path);
 extern void cgit_print_tree(const char *rev, char *path);
 extern void cgit_print_commit(char *hex);
 extern void cgit_print_refs();
 extern void cgit_print_tag(char *revname);
 extern void cgit_print_diff(const char *new_hex, const char *old_hex, const char *prefix);
+extern void cgit_print_patch(char *hex, struct cacheitem *item);
 extern void cgit_print_snapshot(struct cacheitem *item, const char *head,
 				const char *hex, const char *prefix,
 				const char *filename, int snapshot);
 extern void cgit_print_snapshot_links(const char *repo, const char *head,
 				      const char *hex, int snapshots);
 extern int cgit_parse_snapshots_mask(const char *str);
 
 #endif /* CGIT_H */
diff --git a/shared.c b/shared.c
index 2c309f5..9c992c8 100644
--- a/shared.c
+++ b/shared.c
@@ -9,129 +9,129 @@
 #include "cgit.h"
 
 struct repolist cgit_repolist;
 struct repoinfo *cgit_repo;
 int cgit_cmd;
 
 const char *cgit_version = CGIT_VERSION;
 
 char *cgit_root_title   = "Git repository browser";
 char *cgit_css          = "/cgit.css";
 char *cgit_logo         = "/git-logo.png";
 char *cgit_index_header = NULL;
 char *cgit_index_info   = NULL;
 char *cgit_logo_link    = "http://www.kernel.org/pub/software/scm/git/docs/";
 char *cgit_module_link  = "./?repo=%s&page=commit&id=%s";
 char *cgit_agefile      = "info/web/last-modified";
 char *cgit_virtual_root = NULL;
 char *cgit_script_name  = CGIT_SCRIPT_NAME;
 char *cgit_cache_root   = CGIT_CACHE_ROOT;
 char *cgit_repo_group   = NULL;
 char *cgit_robots       = "index, nofollow";
 char *cgit_clone_prefix = NULL;
 
 int cgit_nocache               =  0;
 int cgit_snapshots             =  0;
 int cgit_enable_index_links    =  0;
 int cgit_enable_log_filecount  =  0;
 int cgit_enable_log_linecount  =  0;
 int cgit_max_lock_attempts     =  5;
 int cgit_cache_root_ttl        =  5;
 int cgit_cache_repo_ttl        =  5;
 int cgit_cache_dynamic_ttl     =  5;
 int cgit_cache_static_ttl      = -1;
 int cgit_cache_max_create_time =  5;
 int cgit_summary_log           =  0;
 int cgit_summary_tags          =  0;
 int cgit_summary_branches      =  0;
 int cgit_renamelimit           = -1;
 
 int cgit_max_msg_len = 60;
 int cgit_max_repodesc_len = 60;
 int cgit_max_commit_count = 50;
 
 int cgit_query_has_symref = 0;
 int cgit_query_has_sha1   = 0;
 
 char *cgit_querystring  = NULL;
 char *cgit_query_repo   = NULL;
 char *cgit_query_page   = NULL;
 char *cgit_query_head   = NULL;
 char *cgit_query_search = NULL;
 char *cgit_query_grep   = NULL;
 char *cgit_query_sha1   = NULL;
 char *cgit_query_sha2   = NULL;
 char *cgit_query_path   = NULL;
 char *cgit_query_name   = NULL;
 int   cgit_query_ofs    = 0;
 
 int htmlfd = 0;
 
 
 int cgit_get_cmd_index(const char *cmd)
 {
 	static char *cmds[] = {"log", "commit", "diff", "tree", "blob",
-			       "snapshot", "tag", "refs", NULL};
+			       "snapshot", "tag", "refs", "patch", NULL};
 	int i;
 
 	for(i = 0; cmds[i]; i++)
 		if (!strcmp(cmd, cmds[i]))
 			return i + 1;
 	return 0;
 }
 
 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 repoinfo *add_repo(const char *url)
 {
 	struct repoinfo *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 repoinfo));
 	}
 
 	ret = &cgit_repolist.repos[cgit_repolist.count-1];
 	ret->url = trim_end(url, '/');
 	ret->name = ret->url;
 	ret->path = NULL;
 	ret->desc = NULL;
 	ret->owner = NULL;
 	ret->group = cgit_repo_group;
 	ret->defbranch = "master";
 	ret->snapshots = cgit_snapshots;
 	ret->enable_log_filecount = cgit_enable_log_filecount;
 	ret->enable_log_linecount = cgit_enable_log_linecount;
 	ret->module_link = cgit_module_link;
 	ret->readme = NULL;
 	return ret;
 }
 
 struct repoinfo *cgit_get_repoinfo(const char *url)
 {
 	int i;
 	struct repoinfo *repo;
 
diff --git a/ui-patch.c b/ui-patch.c
new file mode 100644
index 0000000..ef79c7c
--- a/dev/null
+++ b/ui-patch.c
@@ -0,0 +1,105 @@
+/* ui-patch.c: generate patch view
+ *
+ * Copyright (C) 2007 Lars Hjemli
+ *
+ * Licensed under GNU General Public License v2
+ *   (see COPYING for full license text)
+ */
+
+#include "cgit.h"
+
+static void print_line(char *line, int len)
+{
+	char c = line[len-1];
+
+	line[len-1] = '\0';
+	htmlf("%s\n", line);
+	line[len-1] = c;
+}
+
+static void header(unsigned char *sha1, char *path1, int mode1,
+		   unsigned char *sha2, char *path2, int mode2)
+{
+	char *abbrev1, *abbrev2;
+	int subproject;
+
+	subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2));
+	htmlf("diff --git a/%s b/%s\n", path1, path2);
+
+	if (is_null_sha1(sha1))
+		path1 = "dev/null";
+	if (is_null_sha1(sha2))
+		path2 = "dev/null";
+
+	if (mode1 == 0)
+		htmlf("new file mode %.6o\n", mode2);
+
+	if (mode2 == 0)
+		htmlf("deleted file mode %.6o\n", mode1);
+
+	if (!subproject) {
+		abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV));
+		abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV));
+		htmlf("index %s..%s", abbrev1, abbrev2);
+		free(abbrev1);
+		free(abbrev2);
+		if (mode1 != 0 && mode2 != 0) {
+			htmlf(" %.6o", 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)
+{
+	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, print_line))
+		html("Error running diff");
+}
+
+void cgit_print_patch(char *hex, struct cacheitem *item)
+{
+	struct commit *commit;
+	struct commitinfo *info;
+	unsigned char sha1[20], old_sha1[20];
+	char *patchname;
+
+	if (!hex)
+		hex = cgit_query_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);
+	hashcpy(old_sha1, commit->parents->item->object.sha1);
+
+	patchname = fmt("%s.patch", sha1_to_hex(sha1));
+	cgit_print_snapshot_start("text/plain", patchname, item);
+	htmlf("From %s Mon Sep 17 00:00:00 2001\n", sha1_to_hex(sha1));
+	htmlf("From: %s%s\n", info->author, info->author_email);
+	html("Date: ");
+	cgit_print_date(info->author_date, "%a, %d  %b  %Y  %H:%M:%S  %z%n");
+	htmlf("Subject: %s\n\n%s", info->subject, info->msg);
+	html("---\n");
+	cgit_diff_tree(old_sha1, sha1, filepair_cb, NULL);
+	html("--\n");
+	htmlf("cgit %s\n", CGIT_VERSION);
+	cgit_free_commitinfo(info);
+}
diff --git a/ui-shared.c b/ui-shared.c
index ece041c..60aa2e3 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -211,128 +211,134 @@ void cgit_log_link(char *name, char *title, char *class, char *head,
 		html(delim);
 		html("qt=");
 		html_attr(grep);
 		delim = "&";
 		html(delim);
 		html("q=");
 		html_attr(pattern);
 	}
 	if (ofs > 0) {
 		html(delim);
 		html("ofs=");
 		htmlf("%d", ofs);
 	}
 	html("'>");
 	html_txt(name);
 	html("</a>");
 }
 
 void cgit_commit_link(char *name, char *title, char *class, char *head,
 		      char *rev)
 {
 	if (strlen(name) > cgit_max_msg_len && cgit_max_msg_len >= 15) {
 		name[cgit_max_msg_len] = '\0';
 		name[cgit_max_msg_len - 1] = '.';
 		name[cgit_max_msg_len - 2] = '.';
 		name[cgit_max_msg_len - 3] = '.';
 	}
 	reporevlink("commit", name, title, class, head, rev, NULL);
 }
 
 void cgit_refs_link(char *name, char *title, char *class, char *head,
 		    char *rev, char *path)
 {
 	reporevlink("refs", name, title, class, head, rev, path);
 }
 
 void cgit_snapshot_link(char *name, char *title, char *class, char *head,
 			char *rev, char *archivename)
 {
 	reporevlink("snapshot", name, title, class, head, rev, archivename);
 }
 
 void cgit_diff_link(char *name, char *title, char *class, char *head,
 		    char *new_rev, char *old_rev, char *path)
 {
 	char *delim;
 
 	delim = repolink(title, class, "diff", head, path);
 	if (new_rev && strcmp(new_rev, cgit_query_head)) {
 		html(delim);
 		html("id=");
 		html_attr(new_rev);
 		delim = "&amp;";
 	}
 	if (old_rev) {
 		html(delim);
 		html("id2=");
 		html_attr(old_rev);
 	}
 	html("'>");
 	html_txt(name);
 	html("</a>");
 }
 
+void cgit_patch_link(char *name, char *title, char *class, char *head,
+		     char *rev)
+{
+	reporevlink("patch", name, title, class, head, rev, NULL);
+}
+
 void cgit_object_link(struct object *obj)
 {
 	char *page, *arg, *url;
 
 	if (obj->type == OBJ_COMMIT) {
                 cgit_commit_link(fmt("commit %s", sha1_to_hex(obj->sha1)), NULL, NULL,
 				 cgit_query_head, sha1_to_hex(obj->sha1));
 		return;
 	} else if (obj->type == OBJ_TREE) {
 		page = "tree";
 		arg = "id";
 	} else if (obj->type == OBJ_TAG) {
 		page = "tag";
 		arg = "id";
 	} else {
 		page = "blob";
 		arg = "id";
 	}
 
 	url = cgit_pageurl(cgit_query_repo, page,
 			   fmt("%s=%s", arg, sha1_to_hex(obj->sha1)));
 	html_link_open(url, NULL, NULL);
 	htmlf("%s %s", typename(obj->type),
 	      sha1_to_hex(obj->sha1));
 	html_link_close();
 }
 
 void cgit_print_date(time_t secs, char *format)
 {
 	char buf[64];
 	struct tm *time;
 
 	if (!secs)
 		return;
 	time = gmtime(&secs);
 	strftime(buf, sizeof(buf)-1, format, time);
 	html_txt(buf);
 }
 
 void cgit_print_age(time_t t, time_t max_relative, char *format)
 {
 	time_t now, secs;
 
 	if (!t)
 		return;
 	time(&now);
 	secs = now - t;
 
 	if (secs > max_relative && max_relative >= 0) {
 		cgit_print_date(t, format);
 		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) {
@@ -429,128 +435,130 @@ int print_archive_ref(const char *refname, const unsigned char *sha1,
 	return 0;
 }
 
 void add_hidden_formfields(int incl_head, int incl_search, char *page)
 {
 	char *url;
 
 	if (!cgit_virtual_root) {
 		url = fmt("%s/%s", cgit_query_repo, page);
 		if (cgit_query_path)
 			url = fmt("%s/%s", url, cgit_query_path);
 		html_hidden("url", url);
 	}
 
 	if (incl_head && strcmp(cgit_query_head, cgit_repo->defbranch))
 		html_hidden("h", cgit_query_head);
 
 	if (cgit_query_sha1)
 		html_hidden("id", cgit_query_sha1);
 	if (cgit_query_sha2)
 		html_hidden("id2", cgit_query_sha2);
 
 	if (incl_search) {
 		if (cgit_query_grep)
 			html_hidden("qt", cgit_query_grep);
 		if (cgit_query_search)
 			html_hidden("q", cgit_query_search);
 	}
 }
 
 void cgit_print_pageheader(char *title, int show_search)
 {
 	static const char *default_info = "This is cgit, a fast webinterface for git repositories";
 	int header = 0;
 	char *url;
 
 	html("<table id='layout' summary=''>\n");
 	html("<tr><td id='sidebar'>\n");
 	html("<table class='sidebar' cellspacing='0' summary=''>\n");
 	html("<tr><td class='sidebar'>\n<a href='");
 	html_attr(cgit_rooturl());
 	htmlf("'><img src='%s' alt='cgit'/></a>\n",
 	      cgit_logo);
 	html("</td></tr>\n<tr><td class='sidebar'>\n");
 	if (cgit_query_repo) {
 		html("<h1 class='first'>");
 		html_txt(strrpart(cgit_repo->name, 20));
 		html("</h1>\n");
 		html_txt(cgit_repo->desc);
 		if (cgit_repo->owner) {
 			html("<h1>owner</h1>\n");
 			html_txt(cgit_repo->owner);
 		}
 		html("<h1>navigate</h1>\n");
 		reporevlink(NULL, "summary", NULL, "menu", cgit_query_head,
 			    NULL, NULL);
 		cgit_log_link("log", NULL, "menu", cgit_query_head, NULL, NULL,
 			      0, NULL, NULL);
 		cgit_tree_link("tree", NULL, "menu", cgit_query_head,
 			       cgit_query_sha1, NULL);
 		cgit_commit_link("commit", NULL, "menu", cgit_query_head,
 			      cgit_query_sha1);
 		cgit_diff_link("diff", NULL, "menu", cgit_query_head,
 			       cgit_query_sha1, cgit_query_sha2, NULL);
+		cgit_patch_link("patch", NULL, "menu", cgit_query_head,
+				cgit_query_sha1);
 
 		for_each_ref(print_archive_ref, &header);
 
 		if (cgit_repo->clone_url || cgit_clone_prefix) {
 			html("<h1>clone</h1>\n");
 			if (cgit_repo->clone_url)
 				url = cgit_repo->clone_url;
 			else
 				url = fmt("%s%s", cgit_clone_prefix,
 					  cgit_repo->url);
 			html("<a class='menu' href='");
 			html_attr(url);
 			html("' title='");
 			html_attr(url);
 			html("'>\n");
 			html_txt(strrpart(url, 20));
 			html("</a>\n");
 		}
 
 		html("<h1>branch</h1>\n");
 		html("<form method='get' action=''>\n");
 		add_hidden_formfields(0, 1, cgit_query_page);
 //		html("<table summary='branch selector' class='grid'><tr><td id='branch-dropdown-cell'>");
 		html("<select name='h' onchange='this.form.submit();'>\n");
 		for_each_branch_ref(print_branch_option, cgit_query_head);
 		html("</select>\n");
 //		html("</td><td>");
 		html("<noscript><input type='submit' id='switch-btn' value='switch'/></noscript>\n");
 //		html("</td></tr></table>");
 		html("</form>\n");
 
 		html("<h1>search</h1>\n");
 		html("<form method='get' action='");
 		if (cgit_virtual_root)
 			html_attr(cgit_fileurl(cgit_query_repo, "log",
 					       cgit_query_path, NULL));
 		html("'>\n");
 		add_hidden_formfields(1, 0, "log");
 		html("<select name='qt'>\n");
 		html_option("grep", "log msg", cgit_query_grep);
 		html_option("author", "author", cgit_query_grep);
 		html_option("committer", "committer", cgit_query_grep);
 		html("</select>\n");
 		html("<input class='txt' type='text' name='q' value='");
 		html_attr(cgit_query_search);
 		html("'/>\n");
 		html("</form>\n");
 	} else {
 		if (!cgit_index_info || html_include(cgit_index_info))
 			html(default_info);
 	}
 
 	html("</td></tr></table></td>\n");
 
 	html("<td id='content'>\n");
 }
 
 
 void cgit_print_snapshot_start(const char *mimetype, const char *filename,
 			       struct cacheitem *item)
 {
 	htmlf("Content-Type: %s\n", mimetype);
 	htmlf("Content-Disposition: inline; filename=\"%s\"\n", filename);
 	htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime));