ui-patch: Apply path limit to generated patch

Also indicate in the comment section of the patch that a path limit was
applied, too easily see when a generated patch is only partial.

Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Lars Hjemli <hjemli@gmail.com>

6 files changed, 10 insertions, 8 deletions

diff --git a/cmd.c b/cmd.c
index 893ae25..605876b 100644
--- a/cmd.c
+++ b/cmd.c
@@ -1,171 +1,171 @@
 /* cmd.c: the cgit command dispatcher
  *
  * Copyright (C) 2008 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "cmd.h"
 #include "cache.h"
 #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);
 }
 
 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, 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);
 }
 
 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, want_vpath) \
 	{#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, 0),
 		def_cmd(atom, 1, 0, 0),
 		def_cmd(about, 0, 1, 0),
 		def_cmd(blob, 1, 0, 0),
 		def_cmd(commit, 1, 1, 1),
 		def_cmd(diff, 1, 1, 1),
 		def_cmd(info, 1, 0, 0),
 		def_cmd(log, 1, 1, 1),
 		def_cmd(ls_cache, 0, 0, 0),
 		def_cmd(objects, 1, 0, 0),
 		def_cmd(patch, 1, 0, 1),
 		def_cmd(plain, 1, 0, 0),
 		def_cmd(refs, 1, 1, 0),
 		def_cmd(repolist, 0, 0, 0),
 		def_cmd(snapshot, 1, 0, 0),
 		def_cmd(stats, 1, 1, 1),
 		def_cmd(summary, 1, 1, 0),
 		def_cmd(tag, 1, 1, 0),
 		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/ui-commit.c b/ui-commit.c
index 2f4c6d4..b3a2063 100644
--- a/ui-commit.c
+++ b/ui-commit.c
@@ -1,123 +1,123 @@
 /* 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, const char *prefix)
 {
 	struct commit *commit, *parent;
 	struct commitinfo *info;
 	struct commit_list *p;
 	unsigned char sha1[20];
 	char *tmp;
 	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);
 
 	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, 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, 1);
 	else
 		cgit_commit_link("side-by-side diff", NULL, NULL, ctx.qry.head, tmp, 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);
 	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,
 				 ctx.qry.head, sha1_to_hex(p->item->object.sha1), 0);
 		html(" (");
 		cgit_diff_link("diff", NULL, NULL, ctx.qry.head, hex,
 			       sha1_to_hex(p->item->object.sha1), NULL, 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 (parents < 3) {
 		if (parents)
 			tmp = sha1_to_hex(commit->parents->item->object.sha1);
 		else
 			tmp = NULL;
 		cgit_print_diff(ctx.qry.sha1, tmp, prefix);
 	}
 	cgit_free_commitinfo(info);
 }
diff --git a/ui-patch.c b/ui-patch.c
index 2a8f7a5..25dc9fe 100644
--- a/ui-patch.c
+++ b/ui-patch.c
@@ -1,129 +1,131 @@
 /* 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"
 #include "html.h"
 #include "ui-shared.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)
 {
 	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))
 		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);
 	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-shared.c b/ui-shared.c
index 4fa506f..d5c4c10 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -199,387 +199,387 @@ static char *repolink(const char *title, const char *class, const char *page,
 		html("'");
 	}
 	if (class) {
 		html(" class='");
 		html_attr(class);
 		html("'");
 	}
 	html(" href='");
 	if (ctx.cfg.virtual_root) {
 		html_url_path(ctx.cfg.virtual_root);
 		if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/')
 			html("/");
 		html_url_path(ctx.repo->url);
 		if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/')
 			html("/");
 		if (page) {
 			html_url_path(page);
 			html("/");
 			if (path)
 				html_url_path(path);
 		}
 	} else {
 		html(ctx.cfg.script_name);
 		html("?url=");
 		html_url_arg(ctx.repo->url);
 		if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/')
 			html("/");
 		if (page) {
 			html_url_arg(page);
 			html("/");
 			if (path)
 				html_url_arg(path);
 		}
 		delim = "&amp;";
 	}
 	if (head && strcmp(head, ctx.repo->defbranch)) {
 		html(delim);
 		html("h=");
 		html_url_arg(head);
 		delim = "&amp;";
 	}
 	return fmt("%s", delim);
 }
 
 static void reporevlink(const char *page, const char *name, const char *title,
 			const char *class, const char *head, const char *rev,
 			const char *path)
 {
 	char *delim;
 
 	delim = repolink(title, class, page, head, path);
 	if (rev && ctx.qry.head != NULL && strcmp(rev, ctx.qry.head)) {
 		html(delim);
 		html("id=");
 		html_url_arg(rev);
 	}
 	html("'>");
 	html_txt(name);
 	html("</a>");
 }
 
 void cgit_summary_link(const char *name, const char *title, const char *class,
 		       const char *head)
 {
 	reporevlink(NULL, name, title, class, head, NULL, NULL);
 }
 
 void cgit_tag_link(const char *name, const char *title, const char *class,
 		   const char *head, const char *rev)
 {
 	reporevlink("tag", name, title, class, head, rev, NULL);
 }
 
 void cgit_tree_link(const char *name, const char *title, const char *class,
 		    const char *head, const char *rev, const char *path)
 {
 	reporevlink("tree", name, title, class, head, rev, path);
 }
 
 void cgit_plain_link(const char *name, const char *title, const char *class,
 		     const char *head, const char *rev, const char *path)
 {
 	reporevlink("plain", name, title, class, head, rev, path);
 }
 
 void cgit_log_link(const char *name, const char *title, const char *class,
 		   const char *head, const char *rev, const char *path,
 		   int ofs, const char *grep, const char *pattern, int showmsg)
 {
 	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, const char *title, const char *class,
 		      const char *head, const char *rev, 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] = '.';
 	}
 
 	char *delim;
 
 	delim = repolink(title, class, "commit", head, NULL);
 	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");
 	}
 	html("'>");
 	html_txt(name);
 	html("</a>");
 }
 
 void cgit_refs_link(const char *name, const char *title, const char *class,
 		    const char *head, const char *rev, const char *path)
 {
 	reporevlink("refs", name, title, class, head, rev, path);
 }
 
 void cgit_snapshot_link(const char *name, const char *title, const char *class,
 			const char *head, const char *rev,
 			const char *archivename)
 {
 	reporevlink("snapshot", name, title, class, head, rev, archivename);
 }
 
 void cgit_diff_link(const char *name, const char *title, const char *class,
 		    const char *head, const char *new_rev, const char *old_rev,
 		    const char *path, 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");
 	}
 	html("'>");
 	html_txt(name);
 	html("</a>");
 }
 
 void cgit_patch_link(const char *name, const char *title, const char *class,
-		     const char *head, const char *rev)
+		     const char *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(const char *name, const char *title, const char *class,
 		     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, 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, 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, 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) {
 		htmlf("<span class='age-days'>%.0f days</span>",
 		      secs * 1.0 / TM_DAY);
 		return;
 	}
 	if (secs < TM_MONTH * 2) {
 		htmlf("<span class='age-weeks'>%.0f weeks</span>",
 		      secs * 1.0 / TM_WEEK);
 		return;
 	}
 	if (secs < TM_YEAR * 2) {
 		htmlf("<span class='age-months'>%.0f months</span>",
 		      secs * 1.0 / TM_MONTH);
 		return;
 	}
 	htmlf("<span class='age-years'>%.0f years</span>",
 	      secs * 1.0 / TM_YEAR);
 }
 
 void cgit_print_http_headers(struct cgit_context *ctx)
 {
 	if (ctx->env.no_http && !strcmp(ctx->env.no_http, "1"))
 		return;
 
 	if (ctx->page.status)
 		htmlf("Status: %d %s\n", ctx->page.status, ctx->page.statusmsg);
 	if (ctx->page.mimetype && ctx->page.charset)
 		htmlf("Content-Type: %s; charset=%s\n", ctx->page.mimetype,
 		      ctx->page.charset);
 	else if (ctx->page.mimetype)
 		htmlf("Content-Type: %s\n", ctx->page.mimetype);
 	if (ctx->page.size)
 		htmlf("Content-Length: %ld\n", ctx->page.size);
 	if (ctx->page.filename)
 		htmlf("Content-Disposition: inline; filename=\"%s\"\n",
 		      ctx->page.filename);
 	htmlf("Last-Modified: %s\n", http_date(ctx->page.modified));
 	htmlf("Expires: %s\n", http_date(ctx->page.expires));
 	if (ctx->page.etag)
 		htmlf("ETag: \"%s\"\n", ctx->page.etag);
 	html("\n");
 	if (ctx->env.request_method && !strcmp(ctx->env.request_method, "HEAD"))
 		exit(0);
 }
 
 void cgit_print_docstart(struct cgit_context *ctx)
 {
 	if (ctx->cfg.embedded) {
 		if (ctx->cfg.header)
 			html_include(ctx->cfg.header);
 		return;
 	}
 
 	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");
diff --git a/ui-shared.h b/ui-shared.h
index 3df5464..c0e5c55 100644
--- a/ui-shared.h
+++ b/ui-shared.h
@@ -1,65 +1,65 @@
 #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(const char *name, const char *title,
 			    const char *class, const char *pattern, int ofs);
 extern void cgit_summary_link(const char *name, const char *title,
 			      const char *class, const char *head);
 extern void cgit_tag_link(const char *name, const char *title,
 			  const char *class, const char *head,
 			  const char *rev);
 extern void cgit_tree_link(const char *name, const char *title,
 			   const char *class, const char *head,
 			   const char *rev, const char *path);
 extern void cgit_plain_link(const char *name, const char *title,
 			    const char *class, const char *head,
 			    const char *rev, const char *path);
 extern void cgit_log_link(const char *name, const char *title,
 			  const char *class, const char *head, const char *rev,
 			  const char *path, int ofs, const char *grep,
 			  const char *pattern, int showmsg);
 extern void cgit_commit_link(char *name, const char *title,
 			     const char *class, const char *head,
 			     const char *rev, int toggle_ssdiff);
 extern void cgit_patch_link(const char *name, const char *title,
 			    const char *class, const char *head,
-			    const char *rev);
+			    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(const char *msg);
 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, 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,
 				       const char *page);
 #endif /* UI_SHARED_H */