Merge branch 'iconv-rebased' of http://x2a.org/pub/git/cgit

* 'iconv-rebased' of http://x2a.org/pub/git/cgit:
  Use utf8::reencode_string from git
  Convert subject and message with iconv_msg.
  Add iconv_msg function.
  Set msg_encoding according to the header.
  Add commit->msg_encoding, allocate msg dynamicly.

4 files changed, 35 insertions, 1 deletions

diff --git a/cgit.h b/cgit.h
index 163f355..6291c58 100644
--- a/cgit.h
+++ b/cgit.h
@@ -1,188 +1,195 @@
 #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
 
 /*
  * 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;
 	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;
+	char *msg_encoding;
 };
 
 struct taginfo {
 	char *tagger;
 	char *tagger_email;
 	int tagger_date;
 	char *msg;
 };
 
 struct refinfo {
 	const char *refname;
 	struct object *object;
 	union {
 		struct taginfo *tag;
 		struct commitinfo *commit;
 	};
 };
 
 struct reflist {
 	struct refinfo **refs;
 	int alloc;
 	int count;
 };
 
 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_index_info;
 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_summary_tags;
 extern int cgit_summary_branches;
 
 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_grep;
 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 char *strlpart(char *txt, int maxlen);
 extern char *strrpart(char *txt, int maxlen);
 
 extern void cgit_add_ref(struct reflist *list, struct refinfo *ref);
 extern int cgit_refs_cb(const char *refname, const unsigned char *sha1,
diff --git a/parsing.c b/parsing.c
index 30e7648..e8c7ab9 100644
--- a/parsing.c
+++ b/parsing.c
@@ -106,202 +106,227 @@ int cgit_parse_query(char *txt, configfn fn)
 {
 	char *t, *value = NULL, c;
 
 	if (!txt)
 		return 0;
 
 	t = txt = xstrdup(txt);
 
 	while((c=*t) != '\0') {
 		if (c=='=') {
 			*t = '\0';
 			value = t+1;
 		} else if (c=='+') {
 			*t = ' ';
 		} else if (c=='%') {
 			t = convert_query_hexchar(t);
 		} else if (c=='&') {
 			*t = '\0';
 			(*fn)(txt, value);
 			txt = t+1;
 			value = NULL;
 		}
 		t++;
 	}
 	if (t!=txt)
 		(*fn)(txt, value);
 	return 0;
 }
 
 /*
  * url syntax: [repo ['/' cmd [ '/' path]]]
  *   repo: any valid repo url, may contain '/'
  *   cmd:  log | commit | diff | tree | view | blob | snapshot
  *   path: any valid path, may contain '/'
  *
  */
 void cgit_parse_url(const char *url)
 {
 	char *cmd, *p;
 
 	cgit_repo = NULL;
 	if (!url || url[0] == '\0')
 		return;
 
 	cgit_repo = cgit_get_repoinfo(url);
 	if (cgit_repo) {
 		cgit_query_repo = cgit_repo->url;
 		return;
 	}
 
 	cmd = strchr(url, '/');
 	while (!cgit_repo && cmd) {
 		cmd[0] = '\0';
 		cgit_repo = cgit_get_repoinfo(url);
 		if (cgit_repo == NULL) {
 			cmd[0] = '/';
 			cmd = strchr(cmd + 1, '/');
 			continue;
 		}
 
 		cgit_query_repo = cgit_repo->url;
 		p = strchr(cmd + 1, '/');
 		if (p) {
 			p[0] = '\0';
 			if (p[1])
 				cgit_query_path = trim_end(p + 1, '/');
 		}
 		cgit_cmd = cgit_get_cmd_index(cmd + 1);
 		cgit_query_page = xstrdup(cmd + 1);
 		return;
 	}
 }
 
 char *substr(const char *head, const char *tail)
 {
 	char *buf;
 
 	buf = xmalloc(tail - head + 1);
 	strncpy(buf, head, tail - head);
 	buf[tail - head] = '\0';
 	return buf;
 }
 
 struct commitinfo *cgit_parse_commit(struct commit *commit)
 {
 	struct commitinfo *ret;
 	char *p = commit->buffer, *t = commit->buffer;
 
 	ret = xmalloc(sizeof(*ret));
 	ret->commit = commit;
 	ret->author = NULL;
 	ret->author_email = NULL;
 	ret->committer = NULL;
 	ret->committer_email = NULL;
 	ret->subject = NULL;
 	ret->msg = NULL;
+	ret->msg_encoding = NULL;
 
 	if (p == NULL)
 		return ret;
 
 	if (strncmp(p, "tree ", 5))
 		die("Bad commit: %s", sha1_to_hex(commit->object.sha1));
 	else
 		p += 46; // "tree " + hex[40] + "\n"
 
 	while (!strncmp(p, "parent ", 7))
 		p += 48; // "parent " + hex[40] + "\n"
 
 	if (!strncmp(p, "author ", 7)) {
 		p += 7;
 		t = strchr(p, '<') - 1;
 		ret->author = substr(p, t);
 		p = t;
 		t = strchr(t, '>') + 1;
 		ret->author_email = substr(p, t);
 		ret->author_date = atol(++t);
 		p = strchr(t, '\n') + 1;
 	}
 
 	if (!strncmp(p, "committer ", 9)) {
 		p += 9;
 		t = strchr(p, '<') - 1;
 		ret->committer = substr(p, t);
 		p = t;
 		t = strchr(t, '>') + 1;
 		ret->committer_email = substr(p, t);
 		ret->committer_date = atol(++t);
 		p = strchr(t, '\n') + 1;
 	}
 
+	if (!strncmp(p, "encoding ", 9)) {
+		p += 9;
+		t = strchr(p, '\n') + 1;
+		ret->msg_encoding = substr(p, t);
+		p = t;
+	} else
+		ret->msg_encoding = xstrdup(PAGE_ENCODING);
+
 	while (*p && (*p != '\n'))
 		p = strchr(p, '\n') + 1; // skip unknown header fields
 
 	while (*p == '\n')
 		p = strchr(p, '\n') + 1;
 
 	t = strchr(p, '\n');
 	if (t) {
 		if (*t == '\0')
 			ret->subject = "** empty **";
 		else
 			ret->subject = substr(p, t);
 		p = t + 1;
 
 		while (*p == '\n')
 			p = strchr(p, '\n') + 1;
 		ret->msg = xstrdup(p);
 	} else
 		ret->subject = substr(p, p+strlen(p));
 
+	if(strcmp(ret->msg_encoding, PAGE_ENCODING)) {
+		t = reencode_string(ret->subject, PAGE_ENCODING,
+				    ret->msg_encoding);
+		if(t) {
+			free(ret->subject);
+			ret->subject = t;
+		}
+
+		t = reencode_string(ret->msg, PAGE_ENCODING,
+				    ret->msg_encoding);
+		if(t) {
+			free(ret->msg);
+			ret->msg = t;
+		}
+	}
+
 	return ret;
 }
 
 
 struct taginfo *cgit_parse_tag(struct tag *tag)
 {
 	void *data;
 	enum object_type type;
 	unsigned long size;
 	char *p, *t;
 	struct taginfo *ret;
 
 	data = read_sha1_file(tag->object.sha1, &type, &size);
 	if (!data || type != OBJ_TAG) {
 		free(data);
 		return 0;
 	}
 
 	ret = xmalloc(sizeof(*ret));
 	ret->tagger = NULL;
 	ret->tagger_email = NULL;
 	ret->tagger_date = 0;
 	ret->msg = NULL;
 
 	p = data;
 
 	while (p && *p) {
 		if (*p == '\n')
 			break;
 
 		if (!strncmp(p, "tagger ", 7)) {
 			p += 7;
 			t = strchr(p, '<') - 1;
 			ret->tagger = substr(p, t);
 			p = t;
 			t = strchr(t, '>') + 1;
 			ret->tagger_email = substr(p, t);
 			ret->tagger_date = atol(++t);
 		}
 		p = strchr(p, '\n') + 1;
 	}
 
 	while (p && *p && (*p != '\n'))
 		p = strchr(p, '\n') + 1; // skip unknown tag fields
 
 	while (p && (*p == '\n'))
 		p = strchr(p, '\n') + 1;
 	if (p && *p)
 		ret->msg = xstrdup(p);
 	free(data);
 	return ret;
 }
diff --git a/shared.c b/shared.c
index e06df91..a04c4dc 100644
--- a/shared.c
+++ b/shared.c
@@ -172,192 +172,194 @@ void cgit_global_config_cb(const char *name, const char *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, "summary-branches"))
 		cgit_summary_branches = atoi(value);
 	else if (!strcmp(name, "summary-tags"))
 		cgit_summary_tags = atoi(value);
 	else if (!strcmp(name, "agefile"))
 		cgit_agefile = xstrdup(value);
 	else if (!strcmp(name, "renamelimit"))
 		cgit_renamelimit = atoi(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 = trim_end(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 & 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, "qt")) {
 		cgit_query_grep = xstrdup(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->msg);
+	free(info->msg_encoding);
 	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;
 }
 
 char *strlpart(char *txt, int maxlen)
 {
 	char *result;
 
 	if (!txt)
 		return txt;
 
 	if (strlen(txt) <= maxlen)
 		return txt;
 	result = xmalloc(maxlen + 1);
 	memcpy(result, txt, maxlen - 3);
 	result[maxlen-1] = result[maxlen-2] = result[maxlen-3] = '.';
 	result[maxlen] = '\0';
 	return result;
 }
 
 char *strrpart(char *txt, int maxlen)
 {
 	char *result;
 
 	if (!txt)
 		return txt;
 
 	if (strlen(txt) <= maxlen)
 		return txt;
 	result = xmalloc(maxlen + 1);
 	memcpy(result + 3, txt + strlen(txt) - maxlen + 4, maxlen - 3);
 	result[0] = result[1] = result[2] = '.';
 	return result;
 }
 
 void cgit_add_ref(struct reflist *list, struct refinfo *ref)
 {
 	size_t size;
 
 	if (list->count >= list->alloc) {
 		list->alloc += (list->alloc ? list->alloc : 4);
 		size = list->alloc * sizeof(struct refinfo *);
 		list->refs = xrealloc(list->refs, size);
 	}
 	list->refs[list->count++] = ref;
 }
 
 struct refinfo *cgit_mk_refinfo(const char *refname, const unsigned char *sha1)
 {
 	struct refinfo *ref;
 
 	ref = xmalloc(sizeof (struct refinfo));
 	ref->refname = xstrdup(refname);
 	ref->object = parse_object(sha1);
 	switch (ref->object->type) {
 	case OBJ_TAG:
 		ref->tag = cgit_parse_tag((struct tag *)ref->object);
 		break;
 	case OBJ_COMMIT:
 		ref->commit = cgit_parse_commit((struct commit *)ref->object);
 		break;
 	}
diff --git a/ui-shared.c b/ui-shared.c
index 72a7b44..7c69f60 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -259,193 +259,193 @@ void cgit_diff_link(char *name, char *title, char *class, char *head,
 	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 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;
 
 	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");
+	html("Content-Type: text/html; charset=" PAGE_ENCODING "\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>\n</tr>\n<table>\n</body>\n</html>\n");
 }
 
 int print_branch_option(const char *refname, const unsigned char *sha1,
 			int flags, void *cb_data)
 {
 	char *name = (char *)refname;
 	html_option(name, name, cgit_query_head);
 	return 0;
 }
 
 int print_archive_ref(const char *refname, const unsigned char *sha1,
 		       int flags, void *cb_data)
 {
 	struct tag *tag;
 	struct taginfo *info;
 	struct object *obj;
 	char buf[256], *url;
 	unsigned char fileid[20];
 	int *header = (int *)cb_data;
 
 	if (prefixcmp(refname, "refs/archives"))
 		return 0;
 	strncpy(buf, refname+14, sizeof(buf));
 	obj = parse_object(sha1);
 	if (!obj)
 		return 1;
 	if (obj->type == OBJ_TAG) {
 		tag = lookup_tag(sha1);
 		if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag)))
 			return 0;
 		hashcpy(fileid, tag->tagged->sha1);
 	} else if (obj->type != OBJ_BLOB) {
 		return 0;
 	} else {
 		hashcpy(fileid, sha1);
 	}
 	if (!*header) {
 		html("<p><h1>download</h1>");
 		*header = 1;
 	}
 	url = cgit_pageurl(cgit_query_repo, "blob",
 			   fmt("id=%s&amp;path=%s", sha1_to_hex(fileid),
 			       buf));
 	html_link_open(url, NULL, "menu");
 	html_txt(strlpart(buf, 20));
 	html_link_close();
 	return 0;
 }
 
 void add_hidden_formfields(int incl_head, int incl_search, char *page)
 {
 	char *url;
 
 	if (!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);
 	}
 }