9 files changed, 194 insertions, 44 deletions

diff --git a/cgit.c b/cgit.c
index 4b91829..6597529 100644
--- a/cgit.c
+++ b/cgit.c
@@ -1,254 +1,256 @@
 /* cgit.c: cgi for the git scm
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 
 static int cgit_prepare_cache(struct cacheitem *item)
 {
 	if (!cgit_repo && cgit_query_repo) {
 		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_sha1, "zip",
-				    cgit_repo->url, cgit_query_name);
+		cgit_print_snapshot(item, cgit_query_sha1,
+				    cgit_repobasename(cgit_repo->url),
+				    cgit_query_name,
+				    cgit_repo->snapshots );
 		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_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_TAG:
 		cgit_print_tag(cgit_query_sha1);
 		break;
 	case CMD_DIFF:
 		cgit_print_diff(cgit_query_sha1, cgit_query_sha2);
 		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) {
 		chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT");
 		chk_positive(dup2(stdout2, STDOUT_FILENO),
 			     "Restoring original STDOUT");
 		chk_zero(close(stdout2), "Closing temporary STDOUT");
 	}
 
 	chdir(buf);
 }
 
 static void cgit_check_cache(struct cacheitem *item)
 {
 	int i = 0;
 
  top:
 	if (++i > cgit_max_lock_attempts) {
 		die("cgit_refresh_cache: unable to lock %s: %s",
 		    item->name, strerror(errno));
 	}
 	if (!cache_exist(item)) {
 		if (!cache_lock(item)) {
 			sleep(1);
 			goto top;
 		}
 		if (!cache_exist(item)) {
 			cgit_fill_cache(item, 1);
 			cache_unlock(item);
 		} else {
 			cache_cancel_lock(item);
 		}
 	} else if (cache_expired(item) && cache_lock(item)) {
 		if (cache_expired(item)) {
 			cgit_fill_cache(item, 1);
 			cache_unlock(item);
 		} else {
 			cache_cancel_lock(item);
 		}
 	}
 }
 
 static void cgit_print_cache(struct cacheitem *item)
 {
 	static char buf[4096];
 	ssize_t i;
 
 	int fd = open(item->name, O_RDONLY);
 	if (fd<0)
 		die("Unable to open cached file %s", item->name);
 
 	while((i=read(fd, buf, sizeof(buf))) > 0)
 		write(STDOUT_FILENO, buf, i);
 
 	close(fd);
 }
 
 static void cgit_parse_args(int argc, const char **argv)
 {
 	int i;
 
 	for (i = 1; i < argc; i++) {
 		if (!strncmp(argv[i], "--cache=", 8)) {
 			cgit_cache_root = xstrdup(argv[i]+8);
 		}
 		if (!strcmp(argv[i], "--nocache")) {
 			cgit_nocache = 1;
 		}
 		if (!strncmp(argv[i], "--query=", 8)) {
 			cgit_querystring = xstrdup(argv[i]+8);
 		}
 		if (!strncmp(argv[i], "--repo=", 7)) {
 			cgit_query_repo = xstrdup(argv[i]+7);
 		}
 		if (!strncmp(argv[i], "--page=", 7)) {
 			cgit_query_page = xstrdup(argv[i]+7);
 		}
 		if (!strncmp(argv[i], "--head=", 7)) {
 			cgit_query_head = xstrdup(argv[i]+7);
 			cgit_query_has_symref = 1;
 		}
 		if (!strncmp(argv[i], "--sha1=", 7)) {
 			cgit_query_sha1 = xstrdup(argv[i]+7);
 			cgit_query_has_sha1 = 1;
 		}
 		if (!strncmp(argv[i], "--ofs=", 6)) {
 			cgit_query_ofs = atoi(argv[i]+6);
 		}
 	}
 }
 
 int main(int argc, const char **argv)
 {
 	struct cacheitem item;
 	const char *cgit_config_env = getenv("CGIT_CONFIG");
 
 	htmlfd = STDOUT_FILENO;
 	item.st.st_mtime = time(NULL);
 	cgit_repolist.length = 0;
 	cgit_repolist.count = 0;
 	cgit_repolist.repos = NULL;
 
 	cgit_read_config(cgit_config_env ? cgit_config_env : CGIT_CONFIG,
 			 cgit_global_config_cb);
 	cgit_repo = NULL;
 	if (getenv("SCRIPT_NAME"))
 		cgit_script_name = xstrdup(getenv("SCRIPT_NAME"));
 	if (getenv("QUERY_STRING"))
 		cgit_querystring = xstrdup(getenv("QUERY_STRING"));
 	cgit_parse_args(argc, argv);
 	cgit_parse_query(cgit_querystring, cgit_querystring_cb);
 	if (!cgit_prepare_cache(&item))
 		return 0;
 	if (cgit_nocache) {
 		cgit_fill_cache(&item, 0);
 	} else {
 		cgit_check_cache(&item);
 		cgit_print_cache(&item);
 	}
 	return 0;
 }
diff --git a/cgit.css b/cgit.css
index 112dac1..43a40a3 100644
--- a/cgit.css
+++ b/cgit.css
@@ -1,426 +1,427 @@
 body {
 	font-family: arial, sans-serif;
 	font-size: 11pt;
 	color: black;
 	background: white;
 }
 
 body, table {
 	padding: 0em;
 	margin: 0em;
 }
 
 table {
       border-collapse: collapse;
 }
 
 h2 {
 	font-size: 120%;
 	font-weight: bold;
 	margin-top: 0em;
 	margin-bottom: 0.25em;
 }
 
 h3 {
 	margin-top: 0em;
 	font-size: 100%;
 	font-weight: normal;
 }
 
 h4 {
 	margin-top: 1.5em;
 	margin-bottom: 0.1em;
 	font-size: 100%;
 	font-weight: bold;
 }
 
 a {
 	color: blue;
 	text-decoration: none;
 }
 
 a:hover {
 	text-decoration: underline;
 }
 
 table.list {
 	border: none;
 	border-collapse: collapse;
 }
 
 table.list tr {
 	background: white;
 }
 
 table.list tr:hover {
 	background: #eee;
 }
 
 table.list tr.nohover:hover {
 	background: white;
 }
 
 table.list th {
 	font-weight: bold;
 	border-bottom: solid 1px #777;
 	padding: 0.1em 0.5em 0.1em 0.5em;
 	vertical-align: baseline;
 }
 
 table.list td {
 	border: none;
 	padding: 0.1em 0.5em 0.1em 0.5em;
 }
 
 img {
 	border: none;
 }
 
 table#layout {
 	width: 100%;
 	border-collapse: collapse;
 	margin: 0px;
 }
 
 td#header, td#logo {
 	color: #666;
 	background-color: #ddd;
 	border-bottom: solid 1px #000;
 }
 
 td#header {
 	font-size: 150%;
 	font-weight: bold;
 	padding: 0.2em 0.5em;
 	vertical-align: text-bottom;
 }
 
 td#header a {
 	color: #666;
 }
 
 td#header a:hoved {
 	text-decoration: underline;
 }
 
 td#logo {
 	text-align: right;
 	vertical-align: middle;
 	padding-right: 0.5em;
 }
 
 td#crumb, td#search {
 	color: #ccc;
 	border-top: solid 3px #555;
 	background-color: #666;
 	border-bottom: solid 1px #333;
 	padding: 2px 1em;
 }
 
 td#crumb {
 	font-weight: bold;
 }
 
 td#crumb a {
 	color: #ccc;
 	background-color: #666;
 	padding: 0em 0.5em 0em 0.5em;
 }
 
 td#crumb a:hover {
 	color: #666;
 	background-color: #ccc;
 	text-decoration: none;
 }
 
 td#search {
 	text-align: right;
 	vertical-align: middle;
 	padding-right: 0.5em;
 }
 
 td#search form {
 	margin: 0px;
 	padding: 0px;
 }
 
 td#search input {
 	font-size: 9pt;
 	padding: 0px;
 	width: 10em;
 	border: solid 1px #333;
 	color: #333;
 	background-color: #fff;
 }
 
 div#summary {
 	vertical-align: top;
 	margin-bottom: 1em;
 }
 
 table#downloads {
 	float: right;
 	border-collapse: collapse;
 	border: solid 1px #777;
 	margin-left: 0.5em;
 	margin-bottom: 0.5em;
 }
 
 table#downloads th {
 	background-color: #ccc;
 }
 
 td#content {
 	padding: 1em 0.5em;
 }
 
 div#blob {
 	border: solid 1px black;
 }
 
 div.error {
 	color: red;
 	font-weight: bold;
 	margin: 1em 2em;
 }
 
 a.ls-blob, a.ls-dir, a.ls-mod {
 	font-family: monospace;
 }
 
 td.ls-size {
 	text-align: right;
 }
 
 td.ls-size {
 	font-family: monospace;
 }
 
 td.ls-mode {
 	font-family: monospace;
 }
 
 table.blob {
 	margin-top: 0.5em;
 	border-top: solid 1px black;
 }
 
 table.blob td.no {
 	border-right: solid 1px black;
 	color: black;
 	background-color: #eee;
 	text-align: right;
 }
 
 table.blob td.txt {
 	white-space: pre;
 	font-family: monospace;
 	padding-left: 0.5em;
 }
 
 table.nowrap td {
 	white-space: nowrap;
 }
 
 table.commit-info {
 	border-collapse: collapse;
 	margin-top: 1.5em;
 }
 
 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.diffstat-header {
 	font-weight: bold;
 	padding-top: 1.5em;
 }
 
 table.diffstat {
 	border-collapse: collapse;
 	width: 100%;
 	border: solid 1px #aaa;
 	background-color: #eee;
 }
 
 table.diffstat tr:hover {
 	background-color: #ccc;
 }
 
 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;
 }
 
 table.diffstat td.mode {
 	white-space: nowrap;
 }
 
 table.diffstat td span.modechange {
 	padding-left: 1em;
 	color: red;
 }
 
 table.diffstat td.add a {
 	color: green;
 }
 
 table.diffstat td.del a {
 	color: red;
 }
 
 table.diffstat td.upd a {
 	color: blue;
 }
 
 table.diffstat td.graph {
 	width: 75%;
 	vertical-align: middle;
 }
 
 table.diffstat td.graph table {
 	border: none;
 }
 
 table.diffstat td.graph td {
 	padding: 0px;
 	border: 0px;
 	height: 7pt;
 }
 
 table.diffstat td.graph td.add {
 	background-color: #5c5;
 }
 
 table.diffstat td.graph td.rem {
 	background-color: #c55;
 }
 
 div.diffstat-summary {
 	color: #888;
 	padding-top: 0.5em;
 }
 
 table.diff td {
 	font-family: monospace;
 	white-space: pre;
 }
 
 table.diff td div.head {
 	font-weight: bold;
 	padding-top: 1em;
 }
 
 table.diff td div.hunk {
 	color: #009;
 }
 
 table.diff td div.add {
 	color: green;
 }
 
 table.diff td div.del {
 	color: red;
 }
 
 .sha1 {
 	font-family: monospace;
 	font-size: 90%;
 }
 
 .left {
 	text-align: left;
 }
 
 .right {
 	text-align: right;
 }
 
 table.list td.repogroup {
 	font-style: italic;
 	color: #888;
 }
 
 a.button {
 	font-size: 80%;
 	color: #aaa;
 	background-color: #eee;
 	border: solid 1px #aaa;
 	padding: 0em 0.5em;
 	margin: 0.1em 0.25em;
 }
 
 a.button:hover {
 	text-decoration: none;
 	color: #333;
 	background-color: #ccc;
 }
 
 a.primary {
 	font-size: 100%;
 }
 
 a.secondary {
 	font-size: 90%;
 }
 
 td.toplevel-repo {
 
 }
 
 table.list td.sublevel-repo {
 	padding-left: 1.5em;
 }
 
 span.age-mins {
 	font-weight: bold;
 	color: #080;
 }
 
 span.age-hours {
 	color: #080;
 }
 
 span.age-days {
 	color: #040;
 }
 
 span.age-weeks {
 	color: #444;
 }
 
 span.age-months {
 	color: #888;
 }
 
 span.age-years {
 	color: #bbb;
 }
diff --git a/cgit.h b/cgit.h
index 610a16d..eddcaa3 100644
--- a/cgit.h
+++ b/cgit.h
@@ -1,239 +1,246 @@
 #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>
 
 
 /*
  * 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
 
 /*
  * 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)
 
 
 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;
 	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;
 	unsigned long committer_date;
 	char *subject;
 	char *msg;
 };
 
 struct taginfo {
 	char *tagger;
 	char *tagger_email;
 	int tagger_date;
 	char *msg;
 };
 
 extern const char *cgit_version;
 
 extern struct repolist cgit_repolist;
 extern struct repoinfo *cgit_repo;
 extern int cgit_cmd;
 
 extern char *cgit_root_title;
 extern char *cgit_css;
 extern char *cgit_logo;
 extern char *cgit_index_header;
 extern char *cgit_logo_link;
 extern char *cgit_module_link;
 extern char *cgit_agefile;
 extern char *cgit_virtual_root;
 extern char *cgit_script_name;
 extern char *cgit_cache_root;
 extern char *cgit_repo_group;
 
 extern int cgit_nocache;
 extern int cgit_snapshots;
 extern int cgit_enable_index_links;
 extern int cgit_enable_log_filecount;
 extern int cgit_enable_log_linecount;
 extern int cgit_max_lock_attempts;
 extern int cgit_cache_root_ttl;
 extern int cgit_cache_repo_ttl;
 extern int cgit_cache_dynamic_ttl;
 extern int cgit_cache_static_ttl;
 extern int cgit_cache_max_create_time;
 extern int cgit_summary_log;
 
 extern int cgit_max_msg_len;
 extern int cgit_max_repodesc_len;
 extern int cgit_max_commit_count;
 
 extern int cgit_query_has_symref;
 extern int cgit_query_has_sha1;
 
 extern char *cgit_querystring;
 extern char *cgit_query_repo;
 extern char *cgit_query_page;
 extern char *cgit_query_search;
 extern char *cgit_query_head;
 extern char *cgit_query_sha1;
 extern char *cgit_query_sha2;
 extern char *cgit_query_path;
 extern char *cgit_query_name;
 extern int   cgit_query_ofs;
 
 extern int htmlfd;
 
 extern int cgit_get_cmd_index(const char *cmd);
 extern struct repoinfo *cgit_get_repoinfo(const char *url);
 extern void cgit_global_config_cb(const char *name, const char *value);
 extern void cgit_repo_config_cb(const char *name, const char *value);
 extern void cgit_querystring_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 int hextoint(char c);
 extern char *trim_end(const char *str, char c);
 
 extern void *cgit_free_commitinfo(struct commitinfo *info);
 
 extern int cgit_diff_files(const unsigned char *old_sha1,
 			   const unsigned char *new_sha1,
 			   linediff_fn fn);
 
 extern void cgit_diff_tree(const unsigned char *old_sha1,
 			   const unsigned char *new_sha1,
 			   filepair_fn fn);
 
 extern void cgit_diff_commit(struct commit *commit, filepair_fn fn);
 
 extern char *fmt(const char *format,...);
 
 extern void html(const char *txt);
 extern void htmlf(const char *format,...);
 extern void html_txt(char *txt);
 extern void html_ntxt(int len, char *txt);
 extern void html_attr(char *txt);
 extern void html_hidden(char *name, char *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);
 extern void cgit_commit_link(char *name, char *title, char *class, char *head,
 			     char *rev);
 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_repolist(struct cacheitem *item);
 extern void cgit_print_summary();
 extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, 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_tag(char *revname);
 extern void cgit_print_diff(const char *new_hex, const char *old_hex);
 extern void cgit_print_snapshot(struct cacheitem *item, const char *hex,
-				const char *format, const char *prefix,
-				const char *filename);
+				const char *prefix, const char *filename,
+				int snapshot);
+extern void cgit_print_snapshot_links(const char *repo, const char *hex,int snapshots);
+extern int cgit_parse_snapshots_mask(const char *str);
 
 #endif /* CGIT_H */
diff --git a/cgitrc b/cgitrc
index 40877f8..1040997 100644
--- a/cgitrc
+++ b/cgitrc
@@ -1,120 +1,121 @@
 ##
 ## cgitrc: template for /etc/cgitrc
 ##
 
 
 ## Uncomment and set to 1 to deactivate caching of generated pages. Mostly
 ## usefull for testing.
 #nocache=0
 
 
-## Enable/disable snapshots by default. This can be overridden per repo
+## Set allowed snapshot types by default. Can be overridden per repo
+# can be any combination of zip/tar.gz/tar.bz2/tar
 #snapshots=0
 
 
 ## Enable/disable extra links to summary/log/tree per repo on index page
 #enable-index-links=0
 
 
 ## Enable/disable display of 'number of files changed' in log view
 #enable-log-filecount=0
 
 
 ## Enable/disable display of 'number of lines changed' in log view
 #enable-log-linecount=0
 
 
 ## Enable/disable display of HEAD shortlog in summary view. Set it to maximum
 ## number of commits that should be displayed
 #summary-log=0
 
 
 ## Specify a root for virtual urls. This makes cgit generate urls like
 ##
 ##    http://localhost/git/repo/log/?id=master
 ##
 ## instead of
 ##
 ##    http://localhost/cgit/cgit.cgi?r=repo&p=log&id=master
 ##
 ## For this to work with apache, rewrite rules must be added to httpd.conf,
 ## possibly looking something like this:
 ##
 ##   RewriteRule ^/git/$ /cgit/cgit.cgi                            [L,QSA]
 ##   RewriteRule ^/git/([^/]+)/$ /cgit/cgit.cgi?r=$1               [L,QSA]
 ##   RewriteRule ^/git/([^/]+)/([^/]+)/$ /cgit/cgit.cgi?r=$1&p=$2  [L,QSA]
 ##
 ## This setting is disabled by default.
 #virtual-root=/git
 
 
 ## Set the title printed on the root page
 #root-title=Git repository browser
 
 
 ## Link to css file
 #css=/cgit/cgit.css
 
 
 ## Link to logo file
 #logo=/cgit/git-logo.png
 
 
 ## Url loaded when clicking the logo
 #logo-link=http://www.kernel.org/pub/software/scm/git/docs/
 
 
 ## Url loaded when clicking a submodule link
 #module-link=./?repo=%s&page=commit&id=%s
 
 
 ## Number of chars shown of repo description (in repolist view)
 #max-repodesc-length=60
 
 
 ## Number of chars shown of commit subject message (in log view)
 #max-message-length=60
 
 
 ## Number of commits per page in log view
 #max-commit-count=50
 
 
 ## Root of cached output
 #cache-root=/var/cache/cgit
 
 
 ## Include another config-file
 #include=/var/cgit/repolist
 
 ##
 ## Time-To-Live settings: specifies how long (in minutes) different pages
 ## should be cached (0 for instant expiration, -1 for immortal pages)
 ##
 
 ## ttl for root page
 #cache-root-ttl=5
 
 ## ttl for repo summary page
 #cache-repo-ttl=5
 
 ## ttl for other dynamic pages
 #cache-dynamic-ttl=5
 
 ## ttl for static pages (addressed by SHA-1)
 #cache-static-ttl=-1
 
 
 
 ## Example repository entry. Required values are repo.url and repo.path (each
 ## repository section must start with repo.url).
 #repo.url=cgit
 #repo.name=cgit
 #repo.desc=the caching cgi for git
 #repo.path=/pub/git/cgit
 #repo.owner=Lars Hjemli
-#repo.snapshots=1				# override a sitewide snapshot-setting
+#repo.snapshots=tar.bz2				# override a sitewide snapshot-setting
 #repo.enable-log-filecount=0			# override the default filecount setting
 #repo.enable-log-linecount=0			# override the default linecount setting
 #repo.module-link=/git/%s/commit/?id=%s		# override the standard module-link
 #repo.readme=info/web/readme			# specify a file to include on summary page
diff --git a/shared.c b/shared.c
index 06693b0..077934f 100644
--- a/shared.c
+++ b/shared.c
@@ -1,405 +1,412 @@
 /* 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 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_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   = "/var/cache/cgit";
 char *cgit_repo_group   = 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_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_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", 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 = xstrdup(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;
 
 	for (i=0; i<cgit_repolist.count; i++) {
 		repo = &cgit_repolist.repos[i];
 		if (!strcmp(repo->url, url))
 			return repo;
 	}
 	return NULL;
 }
 
 void cgit_global_config_cb(const char *name, const char *value)
 {
 	if (!strcmp(name, "root-title"))
 		cgit_root_title = xstrdup(value);
 	else if (!strcmp(name, "css"))
 		cgit_css = xstrdup(value);
 	else if (!strcmp(name, "logo"))
 		cgit_logo = xstrdup(value);
 	else if (!strcmp(name, "index-header"))
 		cgit_index_header = xstrdup(value);
 	else if (!strcmp(name, "logo-link"))
 		cgit_logo_link = xstrdup(value);
 	else if (!strcmp(name, "module-link"))
 		cgit_module_link = xstrdup(value);
 	else if (!strcmp(name, "virtual-root"))
 		cgit_virtual_root = xstrdup(value);
 	else if (!strcmp(name, "nocache"))
 		cgit_nocache = atoi(value);
 	else if (!strcmp(name, "snapshots"))
-		cgit_snapshots = atoi(value);
+		cgit_snapshots = cgit_parse_snapshots_mask(value);
 	else if (!strcmp(name, "enable-index-links"))
 		cgit_enable_index_links = atoi(value);
 	else if (!strcmp(name, "enable-log-filecount"))
 		cgit_enable_log_filecount = atoi(value);
 	else if (!strcmp(name, "enable-log-linecount"))
 		cgit_enable_log_linecount = atoi(value);
 	else if (!strcmp(name, "cache-root"))
 		cgit_cache_root = xstrdup(value);
 	else if (!strcmp(name, "cache-root-ttl"))
 		cgit_cache_root_ttl = atoi(value);
 	else if (!strcmp(name, "cache-repo-ttl"))
 		cgit_cache_repo_ttl = atoi(value);
 	else if (!strcmp(name, "cache-static-ttl"))
 		cgit_cache_static_ttl = atoi(value);
 	else if (!strcmp(name, "cache-dynamic-ttl"))
 		cgit_cache_dynamic_ttl = atoi(value);
 	else if (!strcmp(name, "max-message-length"))
 		cgit_max_msg_len = atoi(value);
 	else if (!strcmp(name, "max-repodesc-length"))
 		cgit_max_repodesc_len = atoi(value);
 	else if (!strcmp(name, "max-commit-count"))
 		cgit_max_commit_count = atoi(value);
 	else if (!strcmp(name, "summary-log"))
 		cgit_summary_log = atoi(value);
 	else if (!strcmp(name, "agefile"))
 		cgit_agefile = xstrdup(value);
 	else if (!strcmp(name, "repo.group"))
 		cgit_repo_group = xstrdup(value);
 	else if (!strcmp(name, "repo.url"))
 		cgit_repo = add_repo(value);
 	else if (!strcmp(name, "repo.name"))
 		cgit_repo->name = xstrdup(value);
 	else if (cgit_repo && !strcmp(name, "repo.path"))
 		cgit_repo->path = xstrdup(value);
 	else if (cgit_repo && !strcmp(name, "repo.desc"))
 		cgit_repo->desc = xstrdup(value);
 	else if (cgit_repo && !strcmp(name, "repo.owner"))
 		cgit_repo->owner = xstrdup(value);
 	else if (cgit_repo && !strcmp(name, "repo.defbranch"))
 		cgit_repo->defbranch = xstrdup(value);
 	else if (cgit_repo && !strcmp(name, "repo.snapshots"))
-		cgit_repo->snapshots = cgit_snapshots * atoi(value);
+		cgit_repo->snapshots = cgit_snapshots & cgit_parse_snapshots_mask(value); /* XXX: &? */
 	else if (cgit_repo && !strcmp(name, "repo.enable-log-filecount"))
 		cgit_repo->enable_log_filecount = cgit_enable_log_filecount * atoi(value);
 	else if (cgit_repo && !strcmp(name, "repo.enable-log-linecount"))
 		cgit_repo->enable_log_linecount = cgit_enable_log_linecount * atoi(value);
 	else if (cgit_repo && !strcmp(name, "repo.module-link"))
 		cgit_repo->module_link= xstrdup(value);
 	else if (cgit_repo && !strcmp(name, "repo.readme") && value != NULL) {
 		if (*value == '/')
 			cgit_repo->readme = xstrdup(value);
 		else
 			cgit_repo->readme = xstrdup(fmt("%s/%s", cgit_repo->path, value));
 	} else if (!strcmp(name, "include"))
 		cgit_read_config(value, cgit_global_config_cb);
 }
 
 void cgit_querystring_cb(const char *name, const char *value)
 {
 	if (!strcmp(name,"r")) {
 		cgit_query_repo = xstrdup(value);
 		cgit_repo = cgit_get_repoinfo(value);
 	} else if (!strcmp(name, "p")) {
 		cgit_query_page = xstrdup(value);
 		cgit_cmd = cgit_get_cmd_index(value);
 	} else if (!strcmp(name, "url")) {
 		cgit_parse_url(value);
 	} else if (!strcmp(name, "q")) {
 		cgit_query_search = xstrdup(value);
 	} else if (!strcmp(name, "h")) {
 		cgit_query_head = xstrdup(value);
 		cgit_query_has_symref = 1;
 	} else if (!strcmp(name, "id")) {
 		cgit_query_sha1 = xstrdup(value);
 		cgit_query_has_sha1 = 1;
 	} else if (!strcmp(name, "id2")) {
 		cgit_query_sha2 = xstrdup(value);
 		cgit_query_has_sha1 = 1;
 	} else if (!strcmp(name, "ofs")) {
 		cgit_query_ofs = atoi(value);
 	} else if (!strcmp(name, "path")) {
 		cgit_query_path = trim_end(value, '/');
 	} else if (!strcmp(name, "name")) {
 		cgit_query_name = xstrdup(value);
 	}
 }
 
 void *cgit_free_commitinfo(struct commitinfo *info)
 {
 	free(info->author);
 	free(info->author_email);
 	free(info->committer);
 	free(info->committer_email);
 	free(info->subject);
 	free(info);
 	return NULL;
 }
 
 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 *trim_end(const char *str, char c)
 {
 	int len;
 	char *s, *t;
 
 	if (str == NULL)
 		return NULL;
 	t = (char *)str;
 	len = strlen(t);
 	while(len > 0 && t[len - 1] == c)
 		len--;
 
 	if (len == 0)
 		return NULL;
 
 	c = t[len];
 	t[len] = '\0';
 	s = xstrdup(t);
 	t[len] = c;
 	return s;
 }
 
 void cgit_diff_tree_cb(struct diff_queue_struct *q,
 		       struct diff_options *options, void *data)
 {
 	int i;
 
 	for (i = 0; i < q->nr; i++) {
 		if (q->queue[i]->status == 'U')
 			continue;
 		((filepair_fn)data)(q->queue[i]);
 	}
 }
 
 static int load_mmfile(mmfile_t *file, const unsigned char *sha1)
 {
 	enum object_type type;
 
 	if (is_null_sha1(sha1)) {
 		file->ptr = (char *)"";
 		file->size = 0;
 	} else {
 		file->ptr = read_sha1_file(sha1, &type, &file->size);
 	}
 	return 1;
 }
 
 /*
  * Receive diff-buffers from xdiff and concatenate them as
  * needed across multiple callbacks.
  *
  * This is basically a copy of xdiff-interface.c/xdiff_outf(),
  * ripped from git and modified to use globals instead of
  * a special callback-struct.
  */
 char *diffbuf = NULL;
 int buflen = 0;
 
 int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf)
 {
 	int i;
 
 	for (i = 0; i < nbuf; i++) {
 		if (mb[i].ptr[mb[i].size-1] != '\n') {
 			/* Incomplete line */
 			diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
 			memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
 			buflen += mb[i].size;
 			continue;
 		}
 
 		/* 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,
 		     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;
 
 	diff_params.flags = XDF_NEED_MINIMAL;
 	emit_params.ctxlen = 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);
 	return 0;
 }
 
 void cgit_diff_tree(const unsigned char *old_sha1,
 		    const unsigned char *new_sha1,
 		    filepair_fn fn)
 {
 	struct diff_options opt;
 	int ret;
 
 	diff_setup(&opt);
 	opt.output_format = DIFF_FORMAT_CALLBACK;
 	opt.detect_rename = 1;
 	opt.recursive = 1;
 	opt.format_callback = cgit_diff_tree_cb;
 	opt.format_callback_data = fn;
 	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)
 {
 	unsigned char *old_sha1 = NULL;
 
 	if (commit->parents)
 		old_sha1 = commit->parents->item->object.sha1;
 	cgit_diff_tree(old_sha1, commit->object.sha1, fn);
 }
diff --git a/ui-commit.c b/ui-commit.c
index 2679b59..50e9e11 100644
--- a/ui-commit.c
+++ b/ui-commit.c
@@ -1,228 +1,225 @@
 /* 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"
 
 static int files, slots;
 static int total_adds, total_rems, max_changes;
 static int lines_added, lines_removed;
 static char *curr_rev;
 
 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;
 } *items;
 
 
 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;
 	case DIFF_STATUS_UNKNOWN:
 		class = "unk";
 		break;
 	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)) {
 		html_filemode(info->old_mode);
 	} else {
 		html_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'>[");
 		html_filemode(info->old_mode);
 		html("]</span>");
 	}
 	htmlf("</td><td class='%s'>", class);
 	cgit_tree_link(info->new_path, NULL, NULL, cgit_query_head, curr_rev,
 		       info->new_path);
 	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'>");
 	htmlf("%d", info->added + info->removed);
 	html("</td><td class='graph'>");
 	htmlf("<table 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");
 }
 
 void cgit_count_diff_lines(char *line, int len)
 {
 	if (line && (len > 0)) {
 		if (line[0] == '+')
 			lines_added++;
 		else if (line[0] == '-')
 			lines_removed++;
 	}
 }
 
 void inspect_filepair(struct diff_filepair *pair)
 {
 	files++;
 	lines_added = 0;
 	lines_removed = 0;
 	cgit_diff_files(pair->one->sha1, pair->two->sha1, cgit_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;
 	if (lines_added + lines_removed > max_changes)
 		max_changes = lines_added + lines_removed;
 	total_adds += lines_added;
 	total_rems += lines_removed;
 }
 
 
 void cgit_print_commit(char *hex)
 {
 	struct commit *commit, *parent;
 	struct commitinfo *info;
 	struct commit_list *p;
 	unsigned char sha1[20];
-	char *filename;
 	char *tmp;
 	int i;
 
 	if (!hex)
 		hex = cgit_query_head;
 	curr_rev = hex;
 
 	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);
 
 	html("<table class='commit-info'>\n");
 	html("<tr><th>author</th><td>");
 	html_txt(info->author);
 	html(" ");
 	html_txt(info->author_email);
 	html("</td><td class='right'>");
 	cgit_print_date(info->author_date, FMT_LONGDATE);
 	html("</td></tr>\n");
 	html("<tr><th>committer</th><td>");
 	html_txt(info->committer);
 	html(" ");
 	html_txt(info->committer_email);
 	html("</td><td class='right'>");
 	cgit_print_date(info->committer_date, FMT_LONGDATE);
 	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,
 		       cgit_query_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,
 				 cgit_query_head, sha1_to_hex(p->item->object.sha1));
 		html(" (");
 		cgit_diff_link("diff", NULL, NULL, cgit_query_head, hex,
 			       sha1_to_hex(p->item->object.sha1), NULL);
 		html(")</td></tr>");
 	}
 	if (cgit_repo->snapshots) {
-		htmlf("<tr><th>download</th><td colspan='2' class='sha1'><a href='");
-		filename = fmt("%s-%s.zip", cgit_query_repo, hex);
-		html_attr(cgit_pageurl(cgit_query_repo, "snapshot",
-				       fmt("id=%s&amp;name=%s", hex, filename)));
-		htmlf("'>%s</a></td></tr>", filename);
+		html("<tr><th>download</th><td colspan='2' class='sha1'>");
+		cgit_print_snapshot_links(cgit_query_repo,hex,cgit_repo->snapshots);
+		html("</td></tr>");
 	}
 	html("</table>\n");
 	html("<div class='commit-subject'>");
 	html_txt(info->subject);
 	html("</div>");
 	html("<div class='commit-msg'>");
 	html_txt(info->msg);
 	html("</div>");
 	if (!(commit->parents && commit->parents->next && commit->parents->next->next)) {
 		html("<div class='diffstat-header'>Diffstat</div>");
 		html("<table class='diffstat'>");
 		max_changes = 0;
 		cgit_diff_commit(commit, inspect_filepair);
 		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);
 		cgit_diff_link("show diff", NULL, NULL, cgit_query_head, hex,
 			       NULL, NULL);
 		html(")</div>");
 	}
 	cgit_free_commitinfo(info);
 }
diff --git a/ui-shared.c b/ui-shared.c
index fd71c12..ca2ee82 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -1,394 +1,427 @@
 /* ui-shared.c: common web output functions
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 
 const char cgit_doctype[] =
 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
 "  \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
 
 static char *http_date(time_t t)
 {
 	static char day[][4] =
 		{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
 	static char month[][4] =
 		{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
 		 "Jul", "Aug", "Sep", "Oct", "Now", "Dec"};
 	struct tm *tm = gmtime(&t);
 	return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday],
 		   tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year,
 		   tm->tm_hour, tm->tm_min, tm->tm_sec);
 }
 
 static long ttl_seconds(long ttl)
 {
 	if (ttl<0)
 		return 60 * 60 * 24 * 365;
 	else
 		return ttl * 60;
 }
 
 void cgit_print_error(char *msg)
 {
 	html("<div class='error'>");
 	html_txt(msg);
 	html("</div>\n");
 }
 
 char *cgit_rooturl()
 {
 	if (cgit_virtual_root)
 		return fmt("%s/", cgit_virtual_root);
 	else
 		return cgit_script_name;
 }
 
 char *cgit_repourl(const char *reponame)
 {
 	if (cgit_virtual_root) {
 		return fmt("%s/%s/", cgit_virtual_root, reponame);
 	} else {
 		return fmt("?r=%s", reponame);
 	}
 }
 
-char *cgit_pageurl(const char *reponame, const char *pagename,
-		   const char *query)
+char *cgit_fileurl(const char *reponame, const char *pagename,
+		   const char *filename, const char *query)
 {
 	if (cgit_virtual_root) {
 		if (query)
-			return fmt("%s/%s/%s/?%s", cgit_virtual_root, reponame,
-				   pagename, query);
+			return fmt("%s/%s/%s/%s?%s", cgit_virtual_root, reponame,
+				   pagename, filename?filename:"", query);
 		else
 			return fmt("%s/%s/%s/", cgit_virtual_root, reponame,
 				   pagename);
 	} else {
 		if (query)
 			return fmt("?r=%s&amp;p=%s&amp;%s", reponame, pagename, query);
 		else
 			return fmt("?r=%s&amp;p=%s", reponame, pagename);
 	}
 }
 
+char *cgit_pageurl(const char *reponame, const char *pagename,
+		   const char *query)
+{
+	return cgit_fileurl(reponame,pagename,0,query);
+}
+
+const char *cgit_repobasename(const char *reponame)
+{
+	/* I assume we don't need to store more than one repo basename */
+	static char rvbuf[1024];
+	int p;
+	const char *rv;
+	strncpy(rvbuf,reponame,sizeof(rvbuf));
+	if(rvbuf[sizeof(rvbuf)-1])
+		die("cgit_repobasename: truncated repository name '%s'", reponame);
+	p = strlen(rvbuf)-1;
+	/* strip trailing slashes */
+	while(p && rvbuf[p]=='/') rvbuf[p--]=0;
+	/* strip trailing .git */
+	if(p>=3 && !strncmp(&rvbuf[p-3],".git",4)) {
+		p -= 3; rvbuf[p--] = 0;
+	}
+	/* strip more trailing slashes if any */
+	while( p && rvbuf[p]=='/') rvbuf[p--]=0;
+	/* find last slash in the remaining string */
+	rv = strrchr(rvbuf,'/');
+	if(rv)
+		return ++rv;
+	return rvbuf;
+}
+
 char *cgit_currurl()
 {
 	if (!cgit_virtual_root)
 		return cgit_script_name;
 	else if (cgit_query_page)
 		return fmt("%s/%s/%s/", cgit_virtual_root, cgit_query_repo, cgit_query_page);
 	else if (cgit_query_repo)
 		return fmt("%s/%s/", cgit_virtual_root, cgit_query_repo);
 	else
 		return fmt("%s/", cgit_virtual_root);
 }
 
 static char *repolink(char *title, char *class, char *page, char *head,
 		      char *path)
 {
 	char *delim = "?";
 
 	html("<a");
 	if (title) {
 		html(" title='");
 		html_attr(title);
 		html("'");
 	}
 	if (class) {
 		html(" class='");
 		html_attr(class);
 		html("'");
 	}
 	html(" href='");
 	if (cgit_virtual_root) {
 		html_attr(cgit_virtual_root);
 		if (cgit_virtual_root[strlen(cgit_virtual_root) - 1] != '/')
 			html("/");
 		html_attr(cgit_repo->url);
 		if (cgit_repo->url[strlen(cgit_repo->url) - 1] != '/')
 			html("/");
 		if (page) {
 			html(page);
 			html("/");
 			if (path)
 				html_attr(path);
 		}
 	} else {
 		html(cgit_script_name);
 		html("?url=");
 		html_attr(cgit_repo->url);
 		if (cgit_repo->url[strlen(cgit_repo->url) - 1] != '/')
 			html("/");
 		if (page) {
 			html(page);
 			html("/");
 			if (path)
 				html_attr(path);
 		}
 		delim = "&amp;";
 	}
 	if (head && strcmp(head, cgit_repo->defbranch)) {
 		html(delim);
 		html("h=");
 		html_attr(head);
 		delim = "&amp;";
 	}
 	return fmt("%s", delim);
 }
 
 static void reporevlink(char *page, char *name, char *title, char *class,
 			char *head, char *rev, char *path)
 {
 	char *delim;
 
 	delim = repolink(title, class, page, head, path);
 	if (rev && strcmp(rev, cgit_query_head)) {
 		html(delim);
 		html("id=");
 		html_attr(rev);
 	}
 	html("'>");
 	html_txt(name);
 	html("</a>");
 }
 
 void cgit_tree_link(char *name, char *title, char *class, char *head,
 		    char *rev, char *path)
 {
 	reporevlink("tree", name, title, class, head, rev, path);
 }
 
 void cgit_log_link(char *name, char *title, char *class, char *head,
 		   char *rev, char *path, int ofs)
 {
 	char *delim;
 
 	delim = repolink(title, class, "log", head, path);
 	if (rev && strcmp(rev, cgit_query_head)) {
 		html(delim);
 		html("id=");
 		html_attr(rev);
 		delim = "&";
 	}
 	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_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_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 {
 		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;
 
 	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;
 
 	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) {
 		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_docstart(char *title, struct cacheitem *item)
 {
 	html("Content-Type: text/html; charset=utf-8\n");
 	htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime));
 	htmlf("Expires: %s\n", http_date(item->st.st_mtime +
 					 ttl_seconds(item->ttl)));
 	html("\n");
 	html(cgit_doctype);
 	html("<html>\n");
 	html("<head>\n");
 	html("<title>");
 	html_txt(title);
 	html("</title>\n");
 	htmlf("<meta name='generator' content='cgit %s'/>\n", cgit_version);
 	html("<link rel='stylesheet' type='text/css' href='");
 	html_attr(cgit_css);
 	html("'/>\n");
 	html("</head>\n");
 	html("<body>\n");
 }
 
 void cgit_print_docend()
 {
 	html("</td></tr></table>");
 	html("</body>\n</html>\n");
 }
 
 void cgit_print_pageheader(char *title, int show_search)
 {
 	html("<table id='layout'>");
 	html("<tr><td id='header'><a href='");
 	html_attr(cgit_rooturl());
 	html("'>");
 	html_txt(cgit_root_title);
 	html("</a></td><td id='logo'>");
 	html("<a href='");
 	html_attr(cgit_logo_link);
 	htmlf("'><img src='%s' alt='logo'/></a>", cgit_logo);
 	html("</td></tr>");
 	html("<tr><td id='crumb'>");
 	if (cgit_query_repo) {
 		html_txt(cgit_repo->name);
 		html(" (");
 		html_txt(cgit_query_head);
 		html(") : &nbsp;");
 		reporevlink(NULL, "summary", NULL, NULL, cgit_query_head,
 			    NULL, NULL);
 		html(" ");
 		cgit_log_link("log", NULL, NULL, cgit_query_head,
 			      cgit_query_sha1, cgit_query_path, 0);
 		html(" ");
 		cgit_tree_link("tree", NULL, NULL, cgit_query_head,
 			       cgit_query_sha1, NULL);
 		html(" ");
 		cgit_commit_link("commit", NULL, NULL, cgit_query_head,
 			      cgit_query_sha1);
 		html(" ");
 		cgit_diff_link("diff", NULL, NULL, cgit_query_head,
 			       cgit_query_sha1, cgit_query_sha2,
 			       cgit_query_path);
 	} else {
 		html_txt("Index of repositories");
 	}
 	html("</td>");
 	html("<td id='search'>");
 	if (show_search) {
 		html("<form method='get' action='");
 		html_attr(cgit_currurl());
 		html("'>");
 		if (!cgit_virtual_root) {
 			if (cgit_query_repo)
 				html_hidden("r", cgit_query_repo);
 			if (cgit_query_page)
 				html_hidden("p", cgit_query_page);
 		}
 		if (cgit_query_head)
 			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);
 		html("<input type='text' name='q' value='");
 		html_attr(cgit_query_search);
 		html("'/></form>");
 	}
 	html("</td></tr>");
 	html("<tr><td id='content' colspan='2'>");
 }
 
 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));
 	htmlf("Expires: %s\n", http_date(item->st.st_mtime +
 					 ttl_seconds(item->ttl)));
 	html("\n");
 }
+
+/* vim:set sw=8: */
diff --git a/ui-snapshot.c b/ui-snapshot.c
index 2257d6b..d6be55b 100644
--- a/ui-snapshot.c
+++ b/ui-snapshot.c
@@ -1,47 +1,145 @@
 /* ui-snapshot.c: generate snapshot of a commit
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 
-static void cgit_print_zip(struct cacheitem *item, const char *hex, 
-			   const char *prefix, const char *filename)
+static int write_compressed_tar_archive(struct archiver_args *args,const char *filter)
 {
-	struct archiver_args args;
-	struct commit *commit;
-	unsigned char sha1[20];
+	int rw[2];
+	pid_t gzpid;
+	int stdout2;
+	int status;
+	int rv;
 
-	if (get_sha1(hex, sha1)) {
-		cgit_print_error(fmt("Bad object id: %s", hex));
-		return;
+	stdout2 = chk_non_negative(dup(STDIN_FILENO), "Preserving STDOUT before compressing");
+	chk_zero(pipe(rw), "Opening pipe from compressor subprocess");
+	gzpid = chk_non_negative(fork(), "Forking compressor subprocess");
+	if(gzpid==0) {
+		/* child */
+		chk_zero(close(rw[1]), "Closing write end of pipe in child");
+		chk_zero(close(STDIN_FILENO), "Closing STDIN");
+		chk_non_negative(dup2(rw[0],STDIN_FILENO), "Redirecting compressor input to stdin");
+		execlp(filter,filter,NULL);
+		_exit(-1);
 	}
-	commit = lookup_commit_reference(sha1);
+	/* parent */
+	chk_zero(close(rw[0]), "Closing read end of pipe");
+	chk_non_negative(dup2(rw[1],STDOUT_FILENO), "Redirecting output to compressor");
+	
+	rv = write_tar_archive(args);
 
-	if (!commit) {
-		cgit_print_error(fmt("Not a commit reference: %s", hex));
-		return;
-	}
+	chk_zero(close(STDOUT_FILENO), "Closing STDOUT redirected to compressor");
+	chk_non_negative(dup2(stdout2,STDOUT_FILENO), "Restoring uncompressed STDOUT");
+	chk_zero(close(stdout2), "Closing uncompressed STDOUT");
+	chk_zero(close(rw[1]), "Closing write end of pipe in parent");
+	chk_positive(waitpid(gzpid,&status,0), "Waiting on compressor process");
+	if(! ( WIFEXITED(status) && WEXITSTATUS(status)==0 ) )
+		cgit_print_error("Failed to compress archive");
 
-	memset(&args, 0, sizeof(args));
-	args.base = fmt("%s/", prefix);
-	args.tree = commit->tree;
-	
-	cgit_print_snapshot_start("application/x-zip", filename, item);
-	write_zip_archive(&args);
+	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 const struct snapshot_archive_t {
+    	const char *suffix;
+	const char *mimetype;
+	write_archive_fn_t write_func;
+	int bit;
+}	snapshot_archives[] = {
+	{ ".zip", "application/x-zip", write_zip_archive, 0x1 },
+	{ ".tar.gz", "application/x-tar", write_tar_gzip_archive, 0x2 },
+	{ ".tar.bz2", "application/x-tar", write_tar_bzip2_archive, 0x4 },
+	{ ".tar", "application/x-tar", write_tar_archive, 0x8 }
+};
 
 void cgit_print_snapshot(struct cacheitem *item, const char *hex, 
-			 const char *format, const char *prefix,
-			 const char *filename)
+			 const char *prefix, const char *filename,
+			 int snapshots)
+{
+	int fnl = strlen(filename);
+	int f;
+    	for(f=0;f<(sizeof(snapshot_archives)/sizeof(*snapshot_archives));++f) {
+		const struct snapshot_archive_t* sat = &snapshot_archives[f];
+		int sl;
+		if(!(snapshots&sat->bit)) continue;
+		sl = strlen(sat->suffix);
+		if(fnl<sl || strcmp(&filename[fnl-sl],sat->suffix))
+			continue;
+
+		struct archiver_args args;
+		struct commit *commit;
+		unsigned char sha1[20];
+
+		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("Not a commit reference: %s", hex));
+			return;;
+		}
+
+		memset(&args,0,sizeof(args));
+		args.base = fmt("%s/", prefix);
+		args.tree = commit->tree;
+
+		cgit_print_snapshot_start(sat->mimetype, filename, item);
+		(*sat->write_func)(&args);
+		return;
+	}
+	cgit_print_error(fmt("Unsupported snapshot format: %s", filename));
+}
+
+void cgit_print_snapshot_links(const char *repo,const char *hex,int snapshots)
 {
-	if (!strcmp(format, "zip"))
-		cgit_print_zip(item, hex, prefix, filename);
-	else
-		cgit_print_error(fmt("Unsupported snapshot format: %s", 
-				     format));
+    	char *filename;
+	int f;
+    	for(f=0;f<(sizeof(snapshot_archives)/sizeof(*snapshot_archives));++f) {
+		const struct snapshot_archive_t* sat = &snapshot_archives[f];
+		if(!(snapshots&sat->bit)) continue;
+		filename = fmt("%s-%s%s",cgit_repobasename(repo),hex,sat->suffix);
+		htmlf("<a href='%s'>%s</a><br/>",
+			cgit_fileurl(repo,"snapshot",filename,
+			    fmt("id=%s&amp;name=%s",hex,filename)), filename);
+	}
+}
+
+int cgit_parse_snapshots_mask(const char *str)
+{
+	static const char *delim = " \t,:/|;";
+	int f, tl, rv = 0;
+	/* favor legacy setting */
+	if(atoi(str)) return 1;
+	for(;;) {
+		str += strspn(str,delim);
+		tl = strcspn(str,delim);
+		if(!tl)
+			break;
+		for(f=0;f<(sizeof(snapshot_archives)/sizeof(*snapshot_archives));++f) {
+			const struct snapshot_archive_t* sat = &snapshot_archives[f];
+			if(! ( strncmp(sat->suffix,str,tl) && strncmp(sat->suffix+1,str,tl-1) ) ) {
+				rv |= sat->bit;
+				break;
+			}
+		}
+		str += tl;
+	}
+	return rv;
 }
+
+/* vim:set sw=8: */
diff --git a/ui-tree.c b/ui-tree.c
index c5d64ff..75ce449 100644
--- a/ui-tree.c
+++ b/ui-tree.c
@@ -1,209 +1,213 @@
 /* ui-tree.c: functions for tree output
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 
 char *curr_rev;
 char *match_path;
 int header = 0;
 
 static void print_object(const unsigned char *sha1, char *path)
 {
 	enum object_type type;
 	unsigned char *buf;
 	unsigned long size, lineno, start, idx;
 
 	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(" blob: <a href='");
+	html_attr(cgit_pageurl(cgit_query_repo, "blob", fmt("id=%s", sha1_to_hex(sha1))));
+	htmlf("'>%s</a>",sha1_to_hex(sha1));
+
 	html("<table class='blob'>\n");
 	idx = 0;
 	start = 0;
 	lineno = 0;
 	while(idx < size) {
 		if (buf[idx] == '\n') {
 			buf[idx] = '\0';
 			htmlf("<tr><td class='no'>%d</td><td class='txt'>",
 			      ++lineno);
 			html_txt(buf + start);
 			html("</td></tr>\n");
 			start = idx + 1;
 		}
 		idx++;
 	}
 	html("</table>\n");
 }
 
 
 static int ls_item(const unsigned char *sha1, const char *base, int baselen,
 		   const char *pathname, unsigned int mode, int stage)
 {
 	char *name;
 	char *fullpath;
 	enum object_type type;
 	unsigned long size = 0;
 
 	name = xstrdup(pathname);
 	fullpath = fmt("%s%s%s", cgit_query_path ? cgit_query_path : "",
 		       cgit_query_path ? "/" : "", name);
 
 	type = sha1_object_info(sha1, &size);
 	if (type == OBJ_BAD && !S_ISDIRLNK(mode)) {
 		htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>",
 		      name,
 		      sha1_to_hex(sha1));
 		return 0;
 	}
 
 	html("<tr><td class='ls-mode'>");
 	html_filemode(mode);
 	html("</td><td>");
 	if (S_ISDIRLNK(mode)) {
 		htmlf("<a class='ls-mod' href='");
 		html_attr(fmt(cgit_repo->module_link,
 			      name,
 			      sha1_to_hex(sha1)));
 		html("'>");
 		html_txt(name);
 		html("</a>");
 	} else if (S_ISDIR(mode)) {
 		cgit_tree_link(name, NULL, "ls-dir", cgit_query_head,
 			       curr_rev, fullpath);
 	} else {
 		cgit_tree_link(name, NULL, "ls-blob", cgit_query_head,
 			       curr_rev, fullpath);
 	}
 	htmlf("</td><td class='ls-size'>%li</td>", size);
 
 	html("<td>");
 	cgit_log_link("log", NULL, "button", cgit_query_head, curr_rev,
 		      fullpath, 0);
 	html("</td></tr>\n");
 	free(name);
 	return 0;
 }
 
 static void ls_head()
 {
 	html("<table 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);
 	ls_tail();
 }
 
 
 static int walk_tree(const unsigned char *sha1, const char *base, int baselen,
 		     const char *pathname, unsigned mode, int stage)
 {
 	static int state;
 	static char buffer[PATH_MAX];
 	char *url;
 
 	if (state == 0) {
 		memcpy(buffer, base, baselen);
 		strcpy(buffer+baselen, pathname);
 		url = cgit_pageurl(cgit_query_repo, "tree",
 				   fmt("h=%s&amp;path=%s", curr_rev, buffer));
 		html("/");
 		cgit_tree_link(xstrdup(pathname), NULL, NULL, cgit_query_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);
 			return 0;
 		}
 	}
 	ls_item(sha1, base, baselen, pathname, mode, stage);
 	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 = cgit_query_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(cgit_query_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, NULL, 0, 0, paths, walk_tree);
 	ls_tail();
 }