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,220 +1,227 @@
 #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,
                         int flags, void *cb_data);
 
 extern void *cgit_free_commitinfo(struct commitinfo *info);
 
 extern int cgit_diff_files(const unsigned char *old_sha1,
                            const unsigned char *new_sha1,
                            linediff_fn fn);
 
 extern void cgit_diff_tree(const unsigned char *old_sha1,
                            const unsigned char *new_sha1,
                            filepair_fn fn, const char *prefix);
 
 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_option(char *value, char *text, char *selected_value);
 extern void html_link_open(char *url, char *title, char *class);
 extern void html_link_close(void);
 extern void html_filemode(unsigned short mode);
 extern int html_include(const char *filename);
 
 extern int cgit_read_config(const char *filename, configfn fn);
 extern int cgit_parse_query(char *txt, configfn fn);
 extern struct commitinfo *cgit_parse_commit(struct commit *commit);
 extern struct taginfo *cgit_parse_tag(struct tag *tag);
diff --git a/parsing.c b/parsing.c
index 30e7648..e8c7ab9 100644
--- a/parsing.c
+++ b/parsing.c
@@ -74,234 +74,259 @@ int cgit_read_config(const char *filename, configfn fn)
         if (nesting > 8)
                 return -1;
         if (!(f = fopen(filename, "r")))
                 return -1;
         nesting++;
         while((len = read_config_line(f, line, &value, sizeof(line))) > 0)
                 (*fn)(line, value);
         nesting--;
         fclose(f);
         return 0;
 }
 
 char *convert_query_hexchar(char *txt)
 {
         int d1, d2;
         if (strlen(txt) < 3) {
                 *txt = '\0';
                 return txt-1;
         }
         d1 = hextoint(*(txt+1));
         d2 = hextoint(*(txt+2));
         if (d1<0 || d2<0) {
                 strcpy(txt, txt+3);
                 return txt-1;
         } else {
                 *txt = d1 * 16 + d2;
                 strcpy(txt+1, txt+3);
                 return txt;
         }
 }
 
 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
@@ -140,256 +140,258 @@ struct repoinfo *cgit_get_repoinfo(const char *url)
         }
         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, "index-info"))
                 cgit_index_info = 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 = trim_end(value, '/');
         else if (!strcmp(name, "nocache"))
                 cgit_nocache = atoi(value);
         else if (!strcmp(name, "snapshots"))
                 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, "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;
         }
         return ref;
 }
 
 int cgit_refs_cb(const char *refname, const unsigned char *sha1, int flags,
                   void *cb_data)
 {
         struct reflist *list = (struct reflist *)cb_data;
         struct refinfo *info = cgit_mk_refinfo(refname, sha1);
 
         if (info)
                 cgit_add_ref(list, info);
         return 0;
 }
 
 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 *)"";
diff --git a/ui-shared.c b/ui-shared.c
index 72a7b44..7c69f60 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -227,257 +227,257 @@ void cgit_log_link(char *name, char *title, char *class, char *head,
 }
 
 void cgit_commit_link(char *name, char *title, char *class, char *head,
                       char *rev)
 {
         if (strlen(name) > cgit_max_msg_len && cgit_max_msg_len >= 15) {
                 name[cgit_max_msg_len] = '\0';
                 name[cgit_max_msg_len - 1] = '.';
                 name[cgit_max_msg_len - 2] = '.';
                 name[cgit_max_msg_len - 3] = '.';
         }
         reporevlink("commit", name, title, class, head, rev, NULL);
 }
 
 void cgit_refs_link(char *name, char *title, char *class, char *head,
                     char *rev, char *path)
 {
         reporevlink("refs", name, title, class, head, rev, path);
 }
 
 void cgit_snapshot_link(char *name, char *title, char *class, char *head,
                         char *rev, char *archivename)
 {
         reporevlink("snapshot", name, title, class, head, rev, archivename);
 }
 
 void cgit_diff_link(char *name, char *title, char *class, char *head,
                     char *new_rev, char *old_rev, char *path)
 {
         char *delim;
 
         delim = repolink(title, class, "diff", head, path);
         if (new_rev && strcmp(new_rev, cgit_query_head)) {
                 html(delim);
                 html("id=");
                 html_attr(new_rev);
                 delim = "&amp;";
         }
         if (old_rev) {
                 html(delim);
                 html("id2=");
                 html_attr(old_rev);
         }
         html("'>");
         html_txt(name);
         html("</a>");
 }
 
 void cgit_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);
         }
 }
 
 void cgit_print_pageheader(char *title, int show_search)
 {
         static const char *default_info = "This is cgit, a fast webinterface for git repositories";
         int header = 0;
 
         html("<div id='sidebar'>\n");
         html("<a href='");
         html_attr(cgit_rooturl());
         htmlf("'><div id='logo'><img src='%s' alt='cgit'/></div></a>\n",
               cgit_logo);
         html("<div class='infobox'>");
         if (cgit_query_repo) {
                 html("<h1>");
                 html_txt(strrpart(cgit_repo->name, 20));
                 html("</h1>\n");
                 html_txt(cgit_repo->desc);
                 if (cgit_repo->owner) {
                         html("<p>\n<h1>owner</h1>\n");
                         html_txt(cgit_repo->owner);
                 }
                 html("<p>\n<h1>navigate</h1>\n");
                 reporevlink(NULL, "summary", NULL, "menu", cgit_query_head,
                             NULL, NULL);
                 cgit_log_link("log", NULL, "menu", cgit_query_head, NULL, NULL,
                               0, NULL, NULL);
                 cgit_tree_link("tree", NULL, "menu", cgit_query_head,
                                cgit_query_sha1, NULL);
                 cgit_commit_link("commit", NULL, "menu", cgit_query_head,
                               cgit_query_sha1);
                 cgit_diff_link("diff", NULL, "menu", cgit_query_head,
                                cgit_query_sha1, cgit_query_sha2, NULL);