summaryrefslogtreecommitdiffabout
authorLars Hjemli <hjemli@gmail.com>2007-11-05 23:38:18 (UTC)
committer Lars Hjemli <hjemli@gmail.com>2007-11-05 23:38:18 (UTC)
commit55ac326ecb01161bf62865ae3350acf85db97d63 (patch) (unidiff)
treee37bcd8fef5523aa627ec9fdcd3401105f8e579d
parentd04c4734bcf40b1d17c55b18fba2aa8344678e8f (diff)
parenta2ebbd6948da96172108db5e9c02c141923ad05c (diff)
downloadcgit-55ac326ecb01161bf62865ae3350acf85db97d63.zip
cgit-55ac326ecb01161bf62865ae3350acf85db97d63.tar.gz
cgit-55ac326ecb01161bf62865ae3350acf85db97d63.tar.bz2
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.
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--cgit.h7
-rw-r--r--parsing.c25
-rw-r--r--shared.c2
-rw-r--r--ui-shared.c2
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,283 +1,290 @@
1#ifndef CGIT_H 1#ifndef CGIT_H
2#define CGIT_H 2#define CGIT_H
3 3
4 4
5#include <git-compat-util.h> 5#include <git-compat-util.h>
6#include <cache.h> 6#include <cache.h>
7#include <grep.h> 7#include <grep.h>
8#include <object.h> 8#include <object.h>
9#include <tree.h> 9#include <tree.h>
10#include <commit.h> 10#include <commit.h>
11#include <tag.h> 11#include <tag.h>
12#include <diff.h> 12#include <diff.h>
13#include <diffcore.h> 13#include <diffcore.h>
14#include <refs.h> 14#include <refs.h>
15#include <revision.h> 15#include <revision.h>
16#include <log-tree.h> 16#include <log-tree.h>
17#include <archive.h> 17#include <archive.h>
18#include <xdiff/xdiff.h> 18#include <xdiff/xdiff.h>
19#include <utf8.h>
19 20
20 21
21/* 22/*
22 * The valid cgit repo-commands 23 * The valid cgit repo-commands
23 */ 24 */
24#define CMD_LOG 1 25#define CMD_LOG 1
25#define CMD_COMMIT 2 26#define CMD_COMMIT 2
26#define CMD_DIFF 3 27#define CMD_DIFF 3
27#define CMD_TREE 4 28#define CMD_TREE 4
28#define CMD_BLOB 5 29#define CMD_BLOB 5
29#define CMD_SNAPSHOT 6 30#define CMD_SNAPSHOT 6
30#define CMD_TAG 7 31#define CMD_TAG 7
31#define CMD_REFS 8 32#define CMD_REFS 8
32 33
33/* 34/*
34 * Dateformats used on misc. pages 35 * Dateformats used on misc. pages
35 */ 36 */
36#define FMT_LONGDATE "%Y-%m-%d %H:%M:%S" 37#define FMT_LONGDATE "%Y-%m-%d %H:%M:%S"
37#define FMT_SHORTDATE "%Y-%m-%d" 38#define FMT_SHORTDATE "%Y-%m-%d"
38 39
39 40
40/* 41/*
41 * Limits used for relative dates 42 * Limits used for relative dates
42 */ 43 */
43#define TM_MIN 60 44#define TM_MIN 60
44#define TM_HOUR (TM_MIN * 60) 45#define TM_HOUR (TM_MIN * 60)
45#define TM_DAY (TM_HOUR * 24) 46#define TM_DAY (TM_HOUR * 24)
46#define TM_WEEK (TM_DAY * 7) 47#define TM_WEEK (TM_DAY * 7)
47#define TM_YEAR (TM_DAY * 365) 48#define TM_YEAR (TM_DAY * 365)
48#define TM_MONTH (TM_YEAR / 12.0) 49#define TM_MONTH (TM_YEAR / 12.0)
49 50
50 51
52/*
53 * Default encoding
54 */
55#define PAGE_ENCODING "UTF-8"
56
51typedef void (*configfn)(const char *name, const char *value); 57typedef void (*configfn)(const char *name, const char *value);
52typedef void (*filepair_fn)(struct diff_filepair *pair); 58typedef void (*filepair_fn)(struct diff_filepair *pair);
53typedef void (*linediff_fn)(char *line, int len); 59typedef void (*linediff_fn)(char *line, int len);
54 60
55struct cacheitem { 61struct cacheitem {
56 char *name; 62 char *name;
57 struct stat st; 63 struct stat st;
58 int ttl; 64 int ttl;
59 int fd; 65 int fd;
60}; 66};
61 67
62struct repoinfo { 68struct repoinfo {
63 char *url; 69 char *url;
64 char *name; 70 char *name;
65 char *path; 71 char *path;
66 char *desc; 72 char *desc;
67 char *owner; 73 char *owner;
68 char *defbranch; 74 char *defbranch;
69 char *group; 75 char *group;
70 char *module_link; 76 char *module_link;
71 char *readme; 77 char *readme;
72 int snapshots; 78 int snapshots;
73 int enable_log_filecount; 79 int enable_log_filecount;
74 int enable_log_linecount; 80 int enable_log_linecount;
75}; 81};
76 82
77struct repolist { 83struct repolist {
78 int length; 84 int length;
79 int count; 85 int count;
80 struct repoinfo *repos; 86 struct repoinfo *repos;
81}; 87};
82 88
83struct commitinfo { 89struct commitinfo {
84 struct commit *commit; 90 struct commit *commit;
85 char *author; 91 char *author;
86 char *author_email; 92 char *author_email;
87 unsigned long author_date; 93 unsigned long author_date;
88 char *committer; 94 char *committer;
89 char *committer_email; 95 char *committer_email;
90 unsigned long committer_date; 96 unsigned long committer_date;
91 char *subject; 97 char *subject;
92 char *msg; 98 char *msg;
99 char *msg_encoding;
93}; 100};
94 101
95struct taginfo { 102struct taginfo {
96 char *tagger; 103 char *tagger;
97 char *tagger_email; 104 char *tagger_email;
98 int tagger_date; 105 int tagger_date;
99 char *msg; 106 char *msg;
100}; 107};
101 108
102struct refinfo { 109struct refinfo {
103 const char *refname; 110 const char *refname;
104 struct object *object; 111 struct object *object;
105 union { 112 union {
106 struct taginfo *tag; 113 struct taginfo *tag;
107 struct commitinfo *commit; 114 struct commitinfo *commit;
108 }; 115 };
109}; 116};
110 117
111struct reflist { 118struct reflist {
112 struct refinfo **refs; 119 struct refinfo **refs;
113 int alloc; 120 int alloc;
114 int count; 121 int count;
115}; 122};
116 123
117extern const char *cgit_version; 124extern const char *cgit_version;
118 125
119extern struct repolist cgit_repolist; 126extern struct repolist cgit_repolist;
120extern struct repoinfo *cgit_repo; 127extern struct repoinfo *cgit_repo;
121extern int cgit_cmd; 128extern int cgit_cmd;
122 129
123extern char *cgit_root_title; 130extern char *cgit_root_title;
124extern char *cgit_css; 131extern char *cgit_css;
125extern char *cgit_logo; 132extern char *cgit_logo;
126extern char *cgit_index_header; 133extern char *cgit_index_header;
127extern char *cgit_index_info; 134extern char *cgit_index_info;
128extern char *cgit_logo_link; 135extern char *cgit_logo_link;
129extern char *cgit_module_link; 136extern char *cgit_module_link;
130extern char *cgit_agefile; 137extern char *cgit_agefile;
131extern char *cgit_virtual_root; 138extern char *cgit_virtual_root;
132extern char *cgit_script_name; 139extern char *cgit_script_name;
133extern char *cgit_cache_root; 140extern char *cgit_cache_root;
134extern char *cgit_repo_group; 141extern char *cgit_repo_group;
135 142
136extern int cgit_nocache; 143extern int cgit_nocache;
137extern int cgit_snapshots; 144extern int cgit_snapshots;
138extern int cgit_enable_index_links; 145extern int cgit_enable_index_links;
139extern int cgit_enable_log_filecount; 146extern int cgit_enable_log_filecount;
140extern int cgit_enable_log_linecount; 147extern int cgit_enable_log_linecount;
141extern int cgit_max_lock_attempts; 148extern int cgit_max_lock_attempts;
142extern int cgit_cache_root_ttl; 149extern int cgit_cache_root_ttl;
143extern int cgit_cache_repo_ttl; 150extern int cgit_cache_repo_ttl;
144extern int cgit_cache_dynamic_ttl; 151extern int cgit_cache_dynamic_ttl;
145extern int cgit_cache_static_ttl; 152extern int cgit_cache_static_ttl;
146extern int cgit_cache_max_create_time; 153extern int cgit_cache_max_create_time;
147extern int cgit_summary_log; 154extern int cgit_summary_log;
148extern int cgit_summary_tags; 155extern int cgit_summary_tags;
149extern int cgit_summary_branches; 156extern int cgit_summary_branches;
150 157
151extern int cgit_max_msg_len; 158extern int cgit_max_msg_len;
152extern int cgit_max_repodesc_len; 159extern int cgit_max_repodesc_len;
153extern int cgit_max_commit_count; 160extern int cgit_max_commit_count;
154 161
155extern int cgit_query_has_symref; 162extern int cgit_query_has_symref;
156extern int cgit_query_has_sha1; 163extern int cgit_query_has_sha1;
157 164
158extern char *cgit_querystring; 165extern char *cgit_querystring;
159extern char *cgit_query_repo; 166extern char *cgit_query_repo;
160extern char *cgit_query_page; 167extern char *cgit_query_page;
161extern char *cgit_query_search; 168extern char *cgit_query_search;
162extern char *cgit_query_grep; 169extern char *cgit_query_grep;
163extern char *cgit_query_head; 170extern char *cgit_query_head;
164extern char *cgit_query_sha1; 171extern char *cgit_query_sha1;
165extern char *cgit_query_sha2; 172extern char *cgit_query_sha2;
166extern char *cgit_query_path; 173extern char *cgit_query_path;
167extern char *cgit_query_name; 174extern char *cgit_query_name;
168extern int cgit_query_ofs; 175extern int cgit_query_ofs;
169 176
170extern int htmlfd; 177extern int htmlfd;
171 178
172extern int cgit_get_cmd_index(const char *cmd); 179extern int cgit_get_cmd_index(const char *cmd);
173extern struct repoinfo *cgit_get_repoinfo(const char *url); 180extern struct repoinfo *cgit_get_repoinfo(const char *url);
174extern void cgit_global_config_cb(const char *name, const char *value); 181extern void cgit_global_config_cb(const char *name, const char *value);
175extern void cgit_repo_config_cb(const char *name, const char *value); 182extern void cgit_repo_config_cb(const char *name, const char *value);
176extern void cgit_querystring_cb(const char *name, const char *value); 183extern void cgit_querystring_cb(const char *name, const char *value);
177 184
178extern int chk_zero(int result, char *msg); 185extern int chk_zero(int result, char *msg);
179extern int chk_positive(int result, char *msg); 186extern int chk_positive(int result, char *msg);
180extern int chk_non_negative(int result, char *msg); 187extern int chk_non_negative(int result, char *msg);
181 188
182extern int hextoint(char c); 189extern int hextoint(char c);
183extern char *trim_end(const char *str, char c); 190extern char *trim_end(const char *str, char c);
184extern char *strlpart(char *txt, int maxlen); 191extern char *strlpart(char *txt, int maxlen);
185extern char *strrpart(char *txt, int maxlen); 192extern char *strrpart(char *txt, int maxlen);
186 193
187extern void cgit_add_ref(struct reflist *list, struct refinfo *ref); 194extern void cgit_add_ref(struct reflist *list, struct refinfo *ref);
188extern int cgit_refs_cb(const char *refname, const unsigned char *sha1, 195extern int cgit_refs_cb(const char *refname, const unsigned char *sha1,
189 int flags, void *cb_data); 196 int flags, void *cb_data);
190 197
191extern void *cgit_free_commitinfo(struct commitinfo *info); 198extern void *cgit_free_commitinfo(struct commitinfo *info);
192 199
193extern int cgit_diff_files(const unsigned char *old_sha1, 200extern int cgit_diff_files(const unsigned char *old_sha1,
194 const unsigned char *new_sha1, 201 const unsigned char *new_sha1,
195 linediff_fn fn); 202 linediff_fn fn);
196 203
197extern void cgit_diff_tree(const unsigned char *old_sha1, 204extern void cgit_diff_tree(const unsigned char *old_sha1,
198 const unsigned char *new_sha1, 205 const unsigned char *new_sha1,
199 filepair_fn fn, const char *prefix); 206 filepair_fn fn, const char *prefix);
200 207
201extern void cgit_diff_commit(struct commit *commit, filepair_fn fn); 208extern void cgit_diff_commit(struct commit *commit, filepair_fn fn);
202 209
203extern char *fmt(const char *format,...); 210extern char *fmt(const char *format,...);
204 211
205extern void html(const char *txt); 212extern void html(const char *txt);
206extern void htmlf(const char *format,...); 213extern void htmlf(const char *format,...);
207extern void html_txt(char *txt); 214extern void html_txt(char *txt);
208extern void html_ntxt(int len, char *txt); 215extern void html_ntxt(int len, char *txt);
209extern void html_attr(char *txt); 216extern void html_attr(char *txt);
210extern void html_hidden(char *name, char *value); 217extern void html_hidden(char *name, char *value);
211extern void html_option(char *value, char *text, char *selected_value); 218extern void html_option(char *value, char *text, char *selected_value);
212extern void html_link_open(char *url, char *title, char *class); 219extern void html_link_open(char *url, char *title, char *class);
213extern void html_link_close(void); 220extern void html_link_close(void);
214extern void html_filemode(unsigned short mode); 221extern void html_filemode(unsigned short mode);
215extern int html_include(const char *filename); 222extern int html_include(const char *filename);
216 223
217extern int cgit_read_config(const char *filename, configfn fn); 224extern int cgit_read_config(const char *filename, configfn fn);
218extern int cgit_parse_query(char *txt, configfn fn); 225extern int cgit_parse_query(char *txt, configfn fn);
219extern struct commitinfo *cgit_parse_commit(struct commit *commit); 226extern struct commitinfo *cgit_parse_commit(struct commit *commit);
220extern struct taginfo *cgit_parse_tag(struct tag *tag); 227extern struct taginfo *cgit_parse_tag(struct tag *tag);
221extern void cgit_parse_url(const char *url); 228extern void cgit_parse_url(const char *url);
222 229
223extern char *cache_safe_filename(const char *unsafe); 230extern char *cache_safe_filename(const char *unsafe);
224extern int cache_lock(struct cacheitem *item); 231extern int cache_lock(struct cacheitem *item);
225extern int cache_unlock(struct cacheitem *item); 232extern int cache_unlock(struct cacheitem *item);
226extern int cache_cancel_lock(struct cacheitem *item); 233extern int cache_cancel_lock(struct cacheitem *item);
227extern int cache_exist(struct cacheitem *item); 234extern int cache_exist(struct cacheitem *item);
228extern int cache_expired(struct cacheitem *item); 235extern int cache_expired(struct cacheitem *item);
229 236
230extern char *cgit_repourl(const char *reponame); 237extern char *cgit_repourl(const char *reponame);
231extern char *cgit_fileurl(const char *reponame, const char *pagename, 238extern char *cgit_fileurl(const char *reponame, const char *pagename,
232 const char *filename, const char *query); 239 const char *filename, const char *query);
233extern char *cgit_pageurl(const char *reponame, const char *pagename, 240extern char *cgit_pageurl(const char *reponame, const char *pagename,
234 const char *query); 241 const char *query);
235 242
236extern const char *cgit_repobasename(const char *reponame); 243extern const char *cgit_repobasename(const char *reponame);
237 244
238extern void cgit_tree_link(char *name, char *title, char *class, char *head, 245extern void cgit_tree_link(char *name, char *title, char *class, char *head,
239 char *rev, char *path); 246 char *rev, char *path);
240extern void cgit_log_link(char *name, char *title, char *class, char *head, 247extern void cgit_log_link(char *name, char *title, char *class, char *head,
241 char *rev, char *path, int ofs, char *grep, 248 char *rev, char *path, int ofs, char *grep,
242 char *pattern); 249 char *pattern);
243extern void cgit_commit_link(char *name, char *title, char *class, char *head, 250extern void cgit_commit_link(char *name, char *title, char *class, char *head,
244 char *rev); 251 char *rev);
245extern void cgit_refs_link(char *name, char *title, char *class, char *head, 252extern void cgit_refs_link(char *name, char *title, char *class, char *head,
246 char *rev, char *path); 253 char *rev, char *path);
247extern void cgit_snapshot_link(char *name, char *title, char *class, 254extern void cgit_snapshot_link(char *name, char *title, char *class,
248 char *head, char *rev, char *archivename); 255 char *head, char *rev, char *archivename);
249extern void cgit_diff_link(char *name, char *title, char *class, char *head, 256extern void cgit_diff_link(char *name, char *title, char *class, char *head,
250 char *new_rev, char *old_rev, char *path); 257 char *new_rev, char *old_rev, char *path);
251 258
252extern void cgit_object_link(struct object *obj); 259extern void cgit_object_link(struct object *obj);
253 260
254extern void cgit_print_error(char *msg); 261extern void cgit_print_error(char *msg);
255extern void cgit_print_date(time_t secs, char *format); 262extern void cgit_print_date(time_t secs, char *format);
256extern void cgit_print_age(time_t t, time_t max_relative, char *format); 263extern void cgit_print_age(time_t t, time_t max_relative, char *format);
257extern void cgit_print_docstart(char *title, struct cacheitem *item); 264extern void cgit_print_docstart(char *title, struct cacheitem *item);
258extern void cgit_print_docend(); 265extern void cgit_print_docend();
259extern void cgit_print_pageheader(char *title, int show_search); 266extern void cgit_print_pageheader(char *title, int show_search);
260extern void cgit_print_snapshot_start(const char *mimetype, 267extern void cgit_print_snapshot_start(const char *mimetype,
261 const char *filename, 268 const char *filename,
262 struct cacheitem *item); 269 struct cacheitem *item);
263extern void cgit_print_branches(int maxcount); 270extern void cgit_print_branches(int maxcount);
264extern void cgit_print_tags(int maxcount); 271extern void cgit_print_tags(int maxcount);
265 272
266extern void cgit_print_repolist(struct cacheitem *item); 273extern void cgit_print_repolist(struct cacheitem *item);
267extern void cgit_print_summary(); 274extern void cgit_print_summary();
268extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, 275extern void cgit_print_log(const char *tip, int ofs, int cnt, char *grep,
269 char *pattern, char *path, int pager); 276 char *pattern, char *path, int pager);
270extern void cgit_print_blob(struct cacheitem *item, const char *hex, char *path); 277extern void cgit_print_blob(struct cacheitem *item, const char *hex, char *path);
271extern void cgit_print_tree(const char *rev, char *path); 278extern void cgit_print_tree(const char *rev, char *path);
272extern void cgit_print_commit(char *hex); 279extern void cgit_print_commit(char *hex);
273extern void cgit_print_refs(); 280extern void cgit_print_refs();
274extern void cgit_print_tag(char *revname); 281extern void cgit_print_tag(char *revname);
275extern void cgit_print_diff(const char *new_hex, const char *old_hex, const char *prefix); 282extern void cgit_print_diff(const char *new_hex, const char *old_hex, const char *prefix);
276extern void cgit_print_snapshot(struct cacheitem *item, const char *head, 283extern void cgit_print_snapshot(struct cacheitem *item, const char *head,
277 const char *hex, const char *prefix, 284 const char *hex, const char *prefix,
278 const char *filename, int snapshot); 285 const char *filename, int snapshot);
279extern void cgit_print_snapshot_links(const char *repo, const char *head, 286extern void cgit_print_snapshot_links(const char *repo, const char *head,
280 const char *hex, int snapshots); 287 const char *hex, int snapshots);
281extern int cgit_parse_snapshots_mask(const char *str); 288extern int cgit_parse_snapshots_mask(const char *str);
282 289
283#endif /* CGIT_H */ 290#endif /* CGIT_H */
diff --git a/parsing.c b/parsing.c
index 30e7648..e8c7ab9 100644
--- a/parsing.c
+++ b/parsing.c
@@ -1,307 +1,332 @@
1/* config.c: parsing of config files 1/* config.c: parsing of config files
2 * 2 *
3 * Copyright (C) 2006 Lars Hjemli 3 * Copyright (C) 2006 Lars Hjemli
4 * 4 *
5 * Licensed under GNU General Public License v2 5 * Licensed under GNU General Public License v2
6 * (see COPYING for full license text) 6 * (see COPYING for full license text)
7 */ 7 */
8 8
9#include "cgit.h" 9#include "cgit.h"
10 10
11int next_char(FILE *f) 11int next_char(FILE *f)
12{ 12{
13 int c = fgetc(f); 13 int c = fgetc(f);
14 if (c=='\r') { 14 if (c=='\r') {
15 c = fgetc(f); 15 c = fgetc(f);
16 if (c!='\n') { 16 if (c!='\n') {
17 ungetc(c, f); 17 ungetc(c, f);
18 c = '\r'; 18 c = '\r';
19 } 19 }
20 } 20 }
21 return c; 21 return c;
22} 22}
23 23
24void skip_line(FILE *f) 24void skip_line(FILE *f)
25{ 25{
26 int c; 26 int c;
27 27
28 while((c=next_char(f)) && c!='\n' && c!=EOF) 28 while((c=next_char(f)) && c!='\n' && c!=EOF)
29 ; 29 ;
30} 30}
31 31
32int read_config_line(FILE *f, char *line, const char **value, int bufsize) 32int read_config_line(FILE *f, char *line, const char **value, int bufsize)
33{ 33{
34 int i = 0, isname = 0; 34 int i = 0, isname = 0;
35 35
36 *value = NULL; 36 *value = NULL;
37 while(i<bufsize-1) { 37 while(i<bufsize-1) {
38 int c = next_char(f); 38 int c = next_char(f);
39 if (!isname && (c=='#' || c==';')) { 39 if (!isname && (c=='#' || c==';')) {
40 skip_line(f); 40 skip_line(f);
41 continue; 41 continue;
42 } 42 }
43 if (!isname && isspace(c)) 43 if (!isname && isspace(c))
44 continue; 44 continue;
45 45
46 if (c=='=' && !*value) { 46 if (c=='=' && !*value) {
47 line[i] = 0; 47 line[i] = 0;
48 *value = &line[i+1]; 48 *value = &line[i+1];
49 } else if (c=='\n' && !isname) { 49 } else if (c=='\n' && !isname) {
50 i = 0; 50 i = 0;
51 continue; 51 continue;
52 } else if (c=='\n' || c==EOF) { 52 } else if (c=='\n' || c==EOF) {
53 line[i] = 0; 53 line[i] = 0;
54 break; 54 break;
55 } else { 55 } else {
56 line[i]=c; 56 line[i]=c;
57 } 57 }
58 isname = 1; 58 isname = 1;
59 i++; 59 i++;
60 } 60 }
61 line[i+1] = 0; 61 line[i+1] = 0;
62 return i; 62 return i;
63} 63}
64 64
65int cgit_read_config(const char *filename, configfn fn) 65int cgit_read_config(const char *filename, configfn fn)
66{ 66{
67 static int nesting; 67 static int nesting;
68 int len; 68 int len;
69 char line[256]; 69 char line[256];
70 const char *value; 70 const char *value;
71 FILE *f; 71 FILE *f;
72 72
73 /* cancel deeply nested include-commands */ 73 /* cancel deeply nested include-commands */
74 if (nesting > 8) 74 if (nesting > 8)
75 return -1; 75 return -1;
76 if (!(f = fopen(filename, "r"))) 76 if (!(f = fopen(filename, "r")))
77 return -1; 77 return -1;
78 nesting++; 78 nesting++;
79 while((len = read_config_line(f, line, &value, sizeof(line))) > 0) 79 while((len = read_config_line(f, line, &value, sizeof(line))) > 0)
80 (*fn)(line, value); 80 (*fn)(line, value);
81 nesting--; 81 nesting--;
82 fclose(f); 82 fclose(f);
83 return 0; 83 return 0;
84} 84}
85 85
86char *convert_query_hexchar(char *txt) 86char *convert_query_hexchar(char *txt)
87{ 87{
88 int d1, d2; 88 int d1, d2;
89 if (strlen(txt) < 3) { 89 if (strlen(txt) < 3) {
90 *txt = '\0'; 90 *txt = '\0';
91 return txt-1; 91 return txt-1;
92 } 92 }
93 d1 = hextoint(*(txt+1)); 93 d1 = hextoint(*(txt+1));
94 d2 = hextoint(*(txt+2)); 94 d2 = hextoint(*(txt+2));
95 if (d1<0 || d2<0) { 95 if (d1<0 || d2<0) {
96 strcpy(txt, txt+3); 96 strcpy(txt, txt+3);
97 return txt-1; 97 return txt-1;
98 } else { 98 } else {
99 *txt = d1 * 16 + d2; 99 *txt = d1 * 16 + d2;
100 strcpy(txt+1, txt+3); 100 strcpy(txt+1, txt+3);
101 return txt; 101 return txt;
102 } 102 }
103} 103}
104 104
105int cgit_parse_query(char *txt, configfn fn) 105int cgit_parse_query(char *txt, configfn fn)
106{ 106{
107 char *t, *value = NULL, c; 107 char *t, *value = NULL, c;
108 108
109 if (!txt) 109 if (!txt)
110 return 0; 110 return 0;
111 111
112 t = txt = xstrdup(txt); 112 t = txt = xstrdup(txt);
113 113
114 while((c=*t) != '\0') { 114 while((c=*t) != '\0') {
115 if (c=='=') { 115 if (c=='=') {
116 *t = '\0'; 116 *t = '\0';
117 value = t+1; 117 value = t+1;
118 } else if (c=='+') { 118 } else if (c=='+') {
119 *t = ' '; 119 *t = ' ';
120 } else if (c=='%') { 120 } else if (c=='%') {
121 t = convert_query_hexchar(t); 121 t = convert_query_hexchar(t);
122 } else if (c=='&') { 122 } else if (c=='&') {
123 *t = '\0'; 123 *t = '\0';
124 (*fn)(txt, value); 124 (*fn)(txt, value);
125 txt = t+1; 125 txt = t+1;
126 value = NULL; 126 value = NULL;
127 } 127 }
128 t++; 128 t++;
129 } 129 }
130 if (t!=txt) 130 if (t!=txt)
131 (*fn)(txt, value); 131 (*fn)(txt, value);
132 return 0; 132 return 0;
133} 133}
134 134
135/* 135/*
136 * url syntax: [repo ['/' cmd [ '/' path]]] 136 * url syntax: [repo ['/' cmd [ '/' path]]]
137 * repo: any valid repo url, may contain '/' 137 * repo: any valid repo url, may contain '/'
138 * cmd: log | commit | diff | tree | view | blob | snapshot 138 * cmd: log | commit | diff | tree | view | blob | snapshot
139 * path: any valid path, may contain '/' 139 * path: any valid path, may contain '/'
140 * 140 *
141 */ 141 */
142void cgit_parse_url(const char *url) 142void cgit_parse_url(const char *url)
143{ 143{
144 char *cmd, *p; 144 char *cmd, *p;
145 145
146 cgit_repo = NULL; 146 cgit_repo = NULL;
147 if (!url || url[0] == '\0') 147 if (!url || url[0] == '\0')
148 return; 148 return;
149 149
150 cgit_repo = cgit_get_repoinfo(url); 150 cgit_repo = cgit_get_repoinfo(url);
151 if (cgit_repo) { 151 if (cgit_repo) {
152 cgit_query_repo = cgit_repo->url; 152 cgit_query_repo = cgit_repo->url;
153 return; 153 return;
154 } 154 }
155 155
156 cmd = strchr(url, '/'); 156 cmd = strchr(url, '/');
157 while (!cgit_repo && cmd) { 157 while (!cgit_repo && cmd) {
158 cmd[0] = '\0'; 158 cmd[0] = '\0';
159 cgit_repo = cgit_get_repoinfo(url); 159 cgit_repo = cgit_get_repoinfo(url);
160 if (cgit_repo == NULL) { 160 if (cgit_repo == NULL) {
161 cmd[0] = '/'; 161 cmd[0] = '/';
162 cmd = strchr(cmd + 1, '/'); 162 cmd = strchr(cmd + 1, '/');
163 continue; 163 continue;
164 } 164 }
165 165
166 cgit_query_repo = cgit_repo->url; 166 cgit_query_repo = cgit_repo->url;
167 p = strchr(cmd + 1, '/'); 167 p = strchr(cmd + 1, '/');
168 if (p) { 168 if (p) {
169 p[0] = '\0'; 169 p[0] = '\0';
170 if (p[1]) 170 if (p[1])
171 cgit_query_path = trim_end(p + 1, '/'); 171 cgit_query_path = trim_end(p + 1, '/');
172 } 172 }
173 cgit_cmd = cgit_get_cmd_index(cmd + 1); 173 cgit_cmd = cgit_get_cmd_index(cmd + 1);
174 cgit_query_page = xstrdup(cmd + 1); 174 cgit_query_page = xstrdup(cmd + 1);
175 return; 175 return;
176 } 176 }
177} 177}
178 178
179char *substr(const char *head, const char *tail) 179char *substr(const char *head, const char *tail)
180{ 180{
181 char *buf; 181 char *buf;
182 182
183 buf = xmalloc(tail - head + 1); 183 buf = xmalloc(tail - head + 1);
184 strncpy(buf, head, tail - head); 184 strncpy(buf, head, tail - head);
185 buf[tail - head] = '\0'; 185 buf[tail - head] = '\0';
186 return buf; 186 return buf;
187} 187}
188 188
189struct commitinfo *cgit_parse_commit(struct commit *commit) 189struct commitinfo *cgit_parse_commit(struct commit *commit)
190{ 190{
191 struct commitinfo *ret; 191 struct commitinfo *ret;
192 char *p = commit->buffer, *t = commit->buffer; 192 char *p = commit->buffer, *t = commit->buffer;
193 193
194 ret = xmalloc(sizeof(*ret)); 194 ret = xmalloc(sizeof(*ret));
195 ret->commit = commit; 195 ret->commit = commit;
196 ret->author = NULL; 196 ret->author = NULL;
197 ret->author_email = NULL; 197 ret->author_email = NULL;
198 ret->committer = NULL; 198 ret->committer = NULL;
199 ret->committer_email = NULL; 199 ret->committer_email = NULL;
200 ret->subject = NULL; 200 ret->subject = NULL;
201 ret->msg = NULL; 201 ret->msg = NULL;
202 ret->msg_encoding = NULL;
202 203
203 if (p == NULL) 204 if (p == NULL)
204 return ret; 205 return ret;
205 206
206 if (strncmp(p, "tree ", 5)) 207 if (strncmp(p, "tree ", 5))
207 die("Bad commit: %s", sha1_to_hex(commit->object.sha1)); 208 die("Bad commit: %s", sha1_to_hex(commit->object.sha1));
208 else 209 else
209 p += 46; // "tree " + hex[40] + "\n" 210 p += 46; // "tree " + hex[40] + "\n"
210 211
211 while (!strncmp(p, "parent ", 7)) 212 while (!strncmp(p, "parent ", 7))
212 p += 48; // "parent " + hex[40] + "\n" 213 p += 48; // "parent " + hex[40] + "\n"
213 214
214 if (!strncmp(p, "author ", 7)) { 215 if (!strncmp(p, "author ", 7)) {
215 p += 7; 216 p += 7;
216 t = strchr(p, '<') - 1; 217 t = strchr(p, '<') - 1;
217 ret->author = substr(p, t); 218 ret->author = substr(p, t);
218 p = t; 219 p = t;
219 t = strchr(t, '>') + 1; 220 t = strchr(t, '>') + 1;
220 ret->author_email = substr(p, t); 221 ret->author_email = substr(p, t);
221 ret->author_date = atol(++t); 222 ret->author_date = atol(++t);
222 p = strchr(t, '\n') + 1; 223 p = strchr(t, '\n') + 1;
223 } 224 }
224 225
225 if (!strncmp(p, "committer ", 9)) { 226 if (!strncmp(p, "committer ", 9)) {
226 p += 9; 227 p += 9;
227 t = strchr(p, '<') - 1; 228 t = strchr(p, '<') - 1;
228 ret->committer = substr(p, t); 229 ret->committer = substr(p, t);
229 p = t; 230 p = t;
230 t = strchr(t, '>') + 1; 231 t = strchr(t, '>') + 1;
231 ret->committer_email = substr(p, t); 232 ret->committer_email = substr(p, t);
232 ret->committer_date = atol(++t); 233 ret->committer_date = atol(++t);
233 p = strchr(t, '\n') + 1; 234 p = strchr(t, '\n') + 1;
234 } 235 }
235 236
237 if (!strncmp(p, "encoding ", 9)) {
238 p += 9;
239 t = strchr(p, '\n') + 1;
240 ret->msg_encoding = substr(p, t);
241 p = t;
242 } else
243 ret->msg_encoding = xstrdup(PAGE_ENCODING);
244
236 while (*p && (*p != '\n')) 245 while (*p && (*p != '\n'))
237 p = strchr(p, '\n') + 1; // skip unknown header fields 246 p = strchr(p, '\n') + 1; // skip unknown header fields
238 247
239 while (*p == '\n') 248 while (*p == '\n')
240 p = strchr(p, '\n') + 1; 249 p = strchr(p, '\n') + 1;
241 250
242 t = strchr(p, '\n'); 251 t = strchr(p, '\n');
243 if (t) { 252 if (t) {
244 if (*t == '\0') 253 if (*t == '\0')
245 ret->subject = "** empty **"; 254 ret->subject = "** empty **";
246 else 255 else
247 ret->subject = substr(p, t); 256 ret->subject = substr(p, t);
248 p = t + 1; 257 p = t + 1;
249 258
250 while (*p == '\n') 259 while (*p == '\n')
251 p = strchr(p, '\n') + 1; 260 p = strchr(p, '\n') + 1;
252 ret->msg = xstrdup(p); 261 ret->msg = xstrdup(p);
253 } else 262 } else
254 ret->subject = substr(p, p+strlen(p)); 263 ret->subject = substr(p, p+strlen(p));
255 264
265 if(strcmp(ret->msg_encoding, PAGE_ENCODING)) {
266 t = reencode_string(ret->subject, PAGE_ENCODING,
267 ret->msg_encoding);
268 if(t) {
269 free(ret->subject);
270 ret->subject = t;
271 }
272
273 t = reencode_string(ret->msg, PAGE_ENCODING,
274 ret->msg_encoding);
275 if(t) {
276 free(ret->msg);
277 ret->msg = t;
278 }
279 }
280
256 return ret; 281 return ret;
257} 282}
258 283
259 284
260struct taginfo *cgit_parse_tag(struct tag *tag) 285struct taginfo *cgit_parse_tag(struct tag *tag)
261{ 286{
262 void *data; 287 void *data;
263 enum object_type type; 288 enum object_type type;
264 unsigned long size; 289 unsigned long size;
265 char *p, *t; 290 char *p, *t;
266 struct taginfo *ret; 291 struct taginfo *ret;
267 292
268 data = read_sha1_file(tag->object.sha1, &type, &size); 293 data = read_sha1_file(tag->object.sha1, &type, &size);
269 if (!data || type != OBJ_TAG) { 294 if (!data || type != OBJ_TAG) {
270 free(data); 295 free(data);
271 return 0; 296 return 0;
272 } 297 }
273 298
274 ret = xmalloc(sizeof(*ret)); 299 ret = xmalloc(sizeof(*ret));
275 ret->tagger = NULL; 300 ret->tagger = NULL;
276 ret->tagger_email = NULL; 301 ret->tagger_email = NULL;
277 ret->tagger_date = 0; 302 ret->tagger_date = 0;
278 ret->msg = NULL; 303 ret->msg = NULL;
279 304
280 p = data; 305 p = data;
281 306
282 while (p && *p) { 307 while (p && *p) {
283 if (*p == '\n') 308 if (*p == '\n')
284 break; 309 break;
285 310
286 if (!strncmp(p, "tagger ", 7)) { 311 if (!strncmp(p, "tagger ", 7)) {
287 p += 7; 312 p += 7;
288 t = strchr(p, '<') - 1; 313 t = strchr(p, '<') - 1;
289 ret->tagger = substr(p, t); 314 ret->tagger = substr(p, t);
290 p = t; 315 p = t;
291 t = strchr(t, '>') + 1; 316 t = strchr(t, '>') + 1;
292 ret->tagger_email = substr(p, t); 317 ret->tagger_email = substr(p, t);
293 ret->tagger_date = atol(++t); 318 ret->tagger_date = atol(++t);
294 } 319 }
295 p = strchr(p, '\n') + 1; 320 p = strchr(p, '\n') + 1;
296 } 321 }
297 322
298 while (p && *p && (*p != '\n')) 323 while (p && *p && (*p != '\n'))
299 p = strchr(p, '\n') + 1; // skip unknown tag fields 324 p = strchr(p, '\n') + 1; // skip unknown tag fields
300 325
301 while (p && (*p == '\n')) 326 while (p && (*p == '\n'))
302 p = strchr(p, '\n') + 1; 327 p = strchr(p, '\n') + 1;
303 if (p && *p) 328 if (p && *p)
304 ret->msg = xstrdup(p); 329 ret->msg = xstrdup(p);
305 free(data); 330 free(data);
306 return ret; 331 return ret;
307} 332}
diff --git a/shared.c b/shared.c
index e06df91..a04c4dc 100644
--- a/shared.c
+++ b/shared.c
@@ -1,509 +1,511 @@
1/* shared.c: global vars + some callback functions 1/* shared.c: global vars + some callback functions
2 * 2 *
3 * Copyright (C) 2006 Lars Hjemli 3 * Copyright (C) 2006 Lars Hjemli
4 * 4 *
5 * Licensed under GNU General Public License v2 5 * Licensed under GNU General Public License v2
6 * (see COPYING for full license text) 6 * (see COPYING for full license text)
7 */ 7 */
8 8
9#include "cgit.h" 9#include "cgit.h"
10 10
11struct repolist cgit_repolist; 11struct repolist cgit_repolist;
12struct repoinfo *cgit_repo; 12struct repoinfo *cgit_repo;
13int cgit_cmd; 13int cgit_cmd;
14 14
15const char *cgit_version = CGIT_VERSION; 15const char *cgit_version = CGIT_VERSION;
16 16
17char *cgit_root_title = "Git repository browser"; 17char *cgit_root_title = "Git repository browser";
18char *cgit_css = "/cgit.css"; 18char *cgit_css = "/cgit.css";
19char *cgit_logo = "/git-logo.png"; 19char *cgit_logo = "/git-logo.png";
20char *cgit_index_header = NULL; 20char *cgit_index_header = NULL;
21char *cgit_index_info = NULL; 21char *cgit_index_info = NULL;
22char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/"; 22char *cgit_logo_link = "http://www.kernel.org/pub/software/scm/git/docs/";
23char *cgit_module_link = "./?repo=%s&page=commit&id=%s"; 23char *cgit_module_link = "./?repo=%s&page=commit&id=%s";
24char *cgit_agefile = "info/web/last-modified"; 24char *cgit_agefile = "info/web/last-modified";
25char *cgit_virtual_root = NULL; 25char *cgit_virtual_root = NULL;
26char *cgit_script_name = CGIT_SCRIPT_NAME; 26char *cgit_script_name = CGIT_SCRIPT_NAME;
27char *cgit_cache_root = CGIT_CACHE_ROOT; 27char *cgit_cache_root = CGIT_CACHE_ROOT;
28char *cgit_repo_group = NULL; 28char *cgit_repo_group = NULL;
29 29
30int cgit_nocache = 0; 30int cgit_nocache = 0;
31int cgit_snapshots = 0; 31int cgit_snapshots = 0;
32int cgit_enable_index_links = 0; 32int cgit_enable_index_links = 0;
33int cgit_enable_log_filecount = 0; 33int cgit_enable_log_filecount = 0;
34int cgit_enable_log_linecount = 0; 34int cgit_enable_log_linecount = 0;
35int cgit_max_lock_attempts = 5; 35int cgit_max_lock_attempts = 5;
36int cgit_cache_root_ttl = 5; 36int cgit_cache_root_ttl = 5;
37int cgit_cache_repo_ttl = 5; 37int cgit_cache_repo_ttl = 5;
38int cgit_cache_dynamic_ttl = 5; 38int cgit_cache_dynamic_ttl = 5;
39int cgit_cache_static_ttl = -1; 39int cgit_cache_static_ttl = -1;
40int cgit_cache_max_create_time = 5; 40int cgit_cache_max_create_time = 5;
41int cgit_summary_log = 0; 41int cgit_summary_log = 0;
42int cgit_summary_tags = 0; 42int cgit_summary_tags = 0;
43int cgit_summary_branches = 0; 43int cgit_summary_branches = 0;
44int cgit_renamelimit = -1; 44int cgit_renamelimit = -1;
45 45
46int cgit_max_msg_len = 60; 46int cgit_max_msg_len = 60;
47int cgit_max_repodesc_len = 60; 47int cgit_max_repodesc_len = 60;
48int cgit_max_commit_count = 50; 48int cgit_max_commit_count = 50;
49 49
50int cgit_query_has_symref = 0; 50int cgit_query_has_symref = 0;
51int cgit_query_has_sha1 = 0; 51int cgit_query_has_sha1 = 0;
52 52
53char *cgit_querystring = NULL; 53char *cgit_querystring = NULL;
54char *cgit_query_repo = NULL; 54char *cgit_query_repo = NULL;
55char *cgit_query_page = NULL; 55char *cgit_query_page = NULL;
56char *cgit_query_head = NULL; 56char *cgit_query_head = NULL;
57char *cgit_query_search = NULL; 57char *cgit_query_search = NULL;
58char *cgit_query_grep = NULL; 58char *cgit_query_grep = NULL;
59char *cgit_query_sha1 = NULL; 59char *cgit_query_sha1 = NULL;
60char *cgit_query_sha2 = NULL; 60char *cgit_query_sha2 = NULL;
61char *cgit_query_path = NULL; 61char *cgit_query_path = NULL;
62char *cgit_query_name = NULL; 62char *cgit_query_name = NULL;
63int cgit_query_ofs = 0; 63int cgit_query_ofs = 0;
64 64
65int htmlfd = 0; 65int htmlfd = 0;
66 66
67 67
68int cgit_get_cmd_index(const char *cmd) 68int cgit_get_cmd_index(const char *cmd)
69{ 69{
70 static char *cmds[] = {"log", "commit", "diff", "tree", "blob", 70 static char *cmds[] = {"log", "commit", "diff", "tree", "blob",
71 "snapshot", "tag", "refs", NULL}; 71 "snapshot", "tag", "refs", NULL};
72 int i; 72 int i;
73 73
74 for(i = 0; cmds[i]; i++) 74 for(i = 0; cmds[i]; i++)
75 if (!strcmp(cmd, cmds[i])) 75 if (!strcmp(cmd, cmds[i]))
76 return i + 1; 76 return i + 1;
77 return 0; 77 return 0;
78} 78}
79 79
80int chk_zero(int result, char *msg) 80int chk_zero(int result, char *msg)
81{ 81{
82 if (result != 0) 82 if (result != 0)
83 die("%s: %s", msg, strerror(errno)); 83 die("%s: %s", msg, strerror(errno));
84 return result; 84 return result;
85} 85}
86 86
87int chk_positive(int result, char *msg) 87int chk_positive(int result, char *msg)
88{ 88{
89 if (result <= 0) 89 if (result <= 0)
90 die("%s: %s", msg, strerror(errno)); 90 die("%s: %s", msg, strerror(errno));
91 return result; 91 return result;
92} 92}
93 93
94int chk_non_negative(int result, char *msg) 94int chk_non_negative(int result, char *msg)
95{ 95{
96 if (result < 0) 96 if (result < 0)
97 die("%s: %s",msg, strerror(errno)); 97 die("%s: %s",msg, strerror(errno));
98 return result; 98 return result;
99} 99}
100 100
101struct repoinfo *add_repo(const char *url) 101struct repoinfo *add_repo(const char *url)
102{ 102{
103 struct repoinfo *ret; 103 struct repoinfo *ret;
104 104
105 if (++cgit_repolist.count > cgit_repolist.length) { 105 if (++cgit_repolist.count > cgit_repolist.length) {
106 if (cgit_repolist.length == 0) 106 if (cgit_repolist.length == 0)
107 cgit_repolist.length = 8; 107 cgit_repolist.length = 8;
108 else 108 else
109 cgit_repolist.length *= 2; 109 cgit_repolist.length *= 2;
110 cgit_repolist.repos = xrealloc(cgit_repolist.repos, 110 cgit_repolist.repos = xrealloc(cgit_repolist.repos,
111 cgit_repolist.length * 111 cgit_repolist.length *
112 sizeof(struct repoinfo)); 112 sizeof(struct repoinfo));
113 } 113 }
114 114
115 ret = &cgit_repolist.repos[cgit_repolist.count-1]; 115 ret = &cgit_repolist.repos[cgit_repolist.count-1];
116 ret->url = trim_end(url, '/'); 116 ret->url = trim_end(url, '/');
117 ret->name = ret->url; 117 ret->name = ret->url;
118 ret->path = NULL; 118 ret->path = NULL;
119 ret->desc = NULL; 119 ret->desc = NULL;
120 ret->owner = NULL; 120 ret->owner = NULL;
121 ret->group = cgit_repo_group; 121 ret->group = cgit_repo_group;
122 ret->defbranch = "master"; 122 ret->defbranch = "master";
123 ret->snapshots = cgit_snapshots; 123 ret->snapshots = cgit_snapshots;
124 ret->enable_log_filecount = cgit_enable_log_filecount; 124 ret->enable_log_filecount = cgit_enable_log_filecount;
125 ret->enable_log_linecount = cgit_enable_log_linecount; 125 ret->enable_log_linecount = cgit_enable_log_linecount;
126 ret->module_link = cgit_module_link; 126 ret->module_link = cgit_module_link;
127 ret->readme = NULL; 127 ret->readme = NULL;
128 return ret; 128 return ret;
129} 129}
130 130
131struct repoinfo *cgit_get_repoinfo(const char *url) 131struct repoinfo *cgit_get_repoinfo(const char *url)
132{ 132{
133 int i; 133 int i;
134 struct repoinfo *repo; 134 struct repoinfo *repo;
135 135
136 for (i=0; i<cgit_repolist.count; i++) { 136 for (i=0; i<cgit_repolist.count; i++) {
137 repo = &cgit_repolist.repos[i]; 137 repo = &cgit_repolist.repos[i];
138 if (!strcmp(repo->url, url)) 138 if (!strcmp(repo->url, url))
139 return repo; 139 return repo;
140 } 140 }
141 return NULL; 141 return NULL;
142} 142}
143 143
144void cgit_global_config_cb(const char *name, const char *value) 144void cgit_global_config_cb(const char *name, const char *value)
145{ 145{
146 if (!strcmp(name, "root-title")) 146 if (!strcmp(name, "root-title"))
147 cgit_root_title = xstrdup(value); 147 cgit_root_title = xstrdup(value);
148 else if (!strcmp(name, "css")) 148 else if (!strcmp(name, "css"))
149 cgit_css = xstrdup(value); 149 cgit_css = xstrdup(value);
150 else if (!strcmp(name, "logo")) 150 else if (!strcmp(name, "logo"))
151 cgit_logo = xstrdup(value); 151 cgit_logo = xstrdup(value);
152 else if (!strcmp(name, "index-header")) 152 else if (!strcmp(name, "index-header"))
153 cgit_index_header = xstrdup(value); 153 cgit_index_header = xstrdup(value);
154 else if (!strcmp(name, "index-info")) 154 else if (!strcmp(name, "index-info"))
155 cgit_index_info = xstrdup(value); 155 cgit_index_info = xstrdup(value);
156 else if (!strcmp(name, "logo-link")) 156 else if (!strcmp(name, "logo-link"))
157 cgit_logo_link = xstrdup(value); 157 cgit_logo_link = xstrdup(value);
158 else if (!strcmp(name, "module-link")) 158 else if (!strcmp(name, "module-link"))
159 cgit_module_link = xstrdup(value); 159 cgit_module_link = xstrdup(value);
160 else if (!strcmp(name, "virtual-root")) 160 else if (!strcmp(name, "virtual-root"))
161 cgit_virtual_root = trim_end(value, '/'); 161 cgit_virtual_root = trim_end(value, '/');
162 else if (!strcmp(name, "nocache")) 162 else if (!strcmp(name, "nocache"))
163 cgit_nocache = atoi(value); 163 cgit_nocache = atoi(value);
164 else if (!strcmp(name, "snapshots")) 164 else if (!strcmp(name, "snapshots"))
165 cgit_snapshots = cgit_parse_snapshots_mask(value); 165 cgit_snapshots = cgit_parse_snapshots_mask(value);
166 else if (!strcmp(name, "enable-index-links")) 166 else if (!strcmp(name, "enable-index-links"))
167 cgit_enable_index_links = atoi(value); 167 cgit_enable_index_links = atoi(value);
168 else if (!strcmp(name, "enable-log-filecount")) 168 else if (!strcmp(name, "enable-log-filecount"))
169 cgit_enable_log_filecount = atoi(value); 169 cgit_enable_log_filecount = atoi(value);
170 else if (!strcmp(name, "enable-log-linecount")) 170 else if (!strcmp(name, "enable-log-linecount"))
171 cgit_enable_log_linecount = atoi(value); 171 cgit_enable_log_linecount = atoi(value);
172 else if (!strcmp(name, "cache-root")) 172 else if (!strcmp(name, "cache-root"))
173 cgit_cache_root = xstrdup(value); 173 cgit_cache_root = xstrdup(value);
174 else if (!strcmp(name, "cache-root-ttl")) 174 else if (!strcmp(name, "cache-root-ttl"))
175 cgit_cache_root_ttl = atoi(value); 175 cgit_cache_root_ttl = atoi(value);
176 else if (!strcmp(name, "cache-repo-ttl")) 176 else if (!strcmp(name, "cache-repo-ttl"))
177 cgit_cache_repo_ttl = atoi(value); 177 cgit_cache_repo_ttl = atoi(value);
178 else if (!strcmp(name, "cache-static-ttl")) 178 else if (!strcmp(name, "cache-static-ttl"))
179 cgit_cache_static_ttl = atoi(value); 179 cgit_cache_static_ttl = atoi(value);
180 else if (!strcmp(name, "cache-dynamic-ttl")) 180 else if (!strcmp(name, "cache-dynamic-ttl"))
181 cgit_cache_dynamic_ttl = atoi(value); 181 cgit_cache_dynamic_ttl = atoi(value);
182 else if (!strcmp(name, "max-message-length")) 182 else if (!strcmp(name, "max-message-length"))
183 cgit_max_msg_len = atoi(value); 183 cgit_max_msg_len = atoi(value);
184 else if (!strcmp(name, "max-repodesc-length")) 184 else if (!strcmp(name, "max-repodesc-length"))
185 cgit_max_repodesc_len = atoi(value); 185 cgit_max_repodesc_len = atoi(value);
186 else if (!strcmp(name, "max-commit-count")) 186 else if (!strcmp(name, "max-commit-count"))
187 cgit_max_commit_count = atoi(value); 187 cgit_max_commit_count = atoi(value);
188 else if (!strcmp(name, "summary-log")) 188 else if (!strcmp(name, "summary-log"))
189 cgit_summary_log = atoi(value); 189 cgit_summary_log = atoi(value);
190 else if (!strcmp(name, "summary-branches")) 190 else if (!strcmp(name, "summary-branches"))
191 cgit_summary_branches = atoi(value); 191 cgit_summary_branches = atoi(value);
192 else if (!strcmp(name, "summary-tags")) 192 else if (!strcmp(name, "summary-tags"))
193 cgit_summary_tags = atoi(value); 193 cgit_summary_tags = atoi(value);
194 else if (!strcmp(name, "agefile")) 194 else if (!strcmp(name, "agefile"))
195 cgit_agefile = xstrdup(value); 195 cgit_agefile = xstrdup(value);
196 else if (!strcmp(name, "renamelimit")) 196 else if (!strcmp(name, "renamelimit"))
197 cgit_renamelimit = atoi(value); 197 cgit_renamelimit = atoi(value);
198 else if (!strcmp(name, "repo.group")) 198 else if (!strcmp(name, "repo.group"))
199 cgit_repo_group = xstrdup(value); 199 cgit_repo_group = xstrdup(value);
200 else if (!strcmp(name, "repo.url")) 200 else if (!strcmp(name, "repo.url"))
201 cgit_repo = add_repo(value); 201 cgit_repo = add_repo(value);
202 else if (!strcmp(name, "repo.name")) 202 else if (!strcmp(name, "repo.name"))
203 cgit_repo->name = xstrdup(value); 203 cgit_repo->name = xstrdup(value);
204 else if (cgit_repo && !strcmp(name, "repo.path")) 204 else if (cgit_repo && !strcmp(name, "repo.path"))
205 cgit_repo->path = trim_end(value, '/'); 205 cgit_repo->path = trim_end(value, '/');
206 else if (cgit_repo && !strcmp(name, "repo.desc")) 206 else if (cgit_repo && !strcmp(name, "repo.desc"))
207 cgit_repo->desc = xstrdup(value); 207 cgit_repo->desc = xstrdup(value);
208 else if (cgit_repo && !strcmp(name, "repo.owner")) 208 else if (cgit_repo && !strcmp(name, "repo.owner"))
209 cgit_repo->owner = xstrdup(value); 209 cgit_repo->owner = xstrdup(value);
210 else if (cgit_repo && !strcmp(name, "repo.defbranch")) 210 else if (cgit_repo && !strcmp(name, "repo.defbranch"))
211 cgit_repo->defbranch = xstrdup(value); 211 cgit_repo->defbranch = xstrdup(value);
212 else if (cgit_repo && !strcmp(name, "repo.snapshots")) 212 else if (cgit_repo && !strcmp(name, "repo.snapshots"))
213 cgit_repo->snapshots = cgit_snapshots & cgit_parse_snapshots_mask(value); /* XXX: &? */ 213 cgit_repo->snapshots = cgit_snapshots & cgit_parse_snapshots_mask(value); /* XXX: &? */
214 else if (cgit_repo && !strcmp(name, "repo.enable-log-filecount")) 214 else if (cgit_repo && !strcmp(name, "repo.enable-log-filecount"))
215 cgit_repo->enable_log_filecount = cgit_enable_log_filecount * atoi(value); 215 cgit_repo->enable_log_filecount = cgit_enable_log_filecount * atoi(value);
216 else if (cgit_repo && !strcmp(name, "repo.enable-log-linecount")) 216 else if (cgit_repo && !strcmp(name, "repo.enable-log-linecount"))
217 cgit_repo->enable_log_linecount = cgit_enable_log_linecount * atoi(value); 217 cgit_repo->enable_log_linecount = cgit_enable_log_linecount * atoi(value);
218 else if (cgit_repo && !strcmp(name, "repo.module-link")) 218 else if (cgit_repo && !strcmp(name, "repo.module-link"))
219 cgit_repo->module_link= xstrdup(value); 219 cgit_repo->module_link= xstrdup(value);
220 else if (cgit_repo && !strcmp(name, "repo.readme") && value != NULL) { 220 else if (cgit_repo && !strcmp(name, "repo.readme") && value != NULL) {
221 if (*value == '/') 221 if (*value == '/')
222 cgit_repo->readme = xstrdup(value); 222 cgit_repo->readme = xstrdup(value);
223 else 223 else
224 cgit_repo->readme = xstrdup(fmt("%s/%s", cgit_repo->path, value)); 224 cgit_repo->readme = xstrdup(fmt("%s/%s", cgit_repo->path, value));
225 } else if (!strcmp(name, "include")) 225 } else if (!strcmp(name, "include"))
226 cgit_read_config(value, cgit_global_config_cb); 226 cgit_read_config(value, cgit_global_config_cb);
227} 227}
228 228
229void cgit_querystring_cb(const char *name, const char *value) 229void cgit_querystring_cb(const char *name, const char *value)
230{ 230{
231 if (!strcmp(name,"r")) { 231 if (!strcmp(name,"r")) {
232 cgit_query_repo = xstrdup(value); 232 cgit_query_repo = xstrdup(value);
233 cgit_repo = cgit_get_repoinfo(value); 233 cgit_repo = cgit_get_repoinfo(value);
234 } else if (!strcmp(name, "p")) { 234 } else if (!strcmp(name, "p")) {
235 cgit_query_page = xstrdup(value); 235 cgit_query_page = xstrdup(value);
236 cgit_cmd = cgit_get_cmd_index(value); 236 cgit_cmd = cgit_get_cmd_index(value);
237 } else if (!strcmp(name, "url")) { 237 } else if (!strcmp(name, "url")) {
238 cgit_parse_url(value); 238 cgit_parse_url(value);
239 } else if (!strcmp(name, "qt")) { 239 } else if (!strcmp(name, "qt")) {
240 cgit_query_grep = xstrdup(value); 240 cgit_query_grep = xstrdup(value);
241 } else if (!strcmp(name, "q")) { 241 } else if (!strcmp(name, "q")) {
242 cgit_query_search = xstrdup(value); 242 cgit_query_search = xstrdup(value);
243 } else if (!strcmp(name, "h")) { 243 } else if (!strcmp(name, "h")) {
244 cgit_query_head = xstrdup(value); 244 cgit_query_head = xstrdup(value);
245 cgit_query_has_symref = 1; 245 cgit_query_has_symref = 1;
246 } else if (!strcmp(name, "id")) { 246 } else if (!strcmp(name, "id")) {
247 cgit_query_sha1 = xstrdup(value); 247 cgit_query_sha1 = xstrdup(value);
248 cgit_query_has_sha1 = 1; 248 cgit_query_has_sha1 = 1;
249 } else if (!strcmp(name, "id2")) { 249 } else if (!strcmp(name, "id2")) {
250 cgit_query_sha2 = xstrdup(value); 250 cgit_query_sha2 = xstrdup(value);
251 cgit_query_has_sha1 = 1; 251 cgit_query_has_sha1 = 1;
252 } else if (!strcmp(name, "ofs")) { 252 } else if (!strcmp(name, "ofs")) {
253 cgit_query_ofs = atoi(value); 253 cgit_query_ofs = atoi(value);
254 } else if (!strcmp(name, "path")) { 254 } else if (!strcmp(name, "path")) {
255 cgit_query_path = trim_end(value, '/'); 255 cgit_query_path = trim_end(value, '/');
256 } else if (!strcmp(name, "name")) { 256 } else if (!strcmp(name, "name")) {
257 cgit_query_name = xstrdup(value); 257 cgit_query_name = xstrdup(value);
258 } 258 }
259} 259}
260 260
261void *cgit_free_commitinfo(struct commitinfo *info) 261void *cgit_free_commitinfo(struct commitinfo *info)
262{ 262{
263 free(info->author); 263 free(info->author);
264 free(info->author_email); 264 free(info->author_email);
265 free(info->committer); 265 free(info->committer);
266 free(info->committer_email); 266 free(info->committer_email);
267 free(info->subject); 267 free(info->subject);
268 free(info->msg);
269 free(info->msg_encoding);
268 free(info); 270 free(info);
269 return NULL; 271 return NULL;
270} 272}
271 273
272int hextoint(char c) 274int hextoint(char c)
273{ 275{
274 if (c >= 'a' && c <= 'f') 276 if (c >= 'a' && c <= 'f')
275 return 10 + c - 'a'; 277 return 10 + c - 'a';
276 else if (c >= 'A' && c <= 'F') 278 else if (c >= 'A' && c <= 'F')
277 return 10 + c - 'A'; 279 return 10 + c - 'A';
278 else if (c >= '0' && c <= '9') 280 else if (c >= '0' && c <= '9')
279 return c - '0'; 281 return c - '0';
280 else 282 else
281 return -1; 283 return -1;
282} 284}
283 285
284char *trim_end(const char *str, char c) 286char *trim_end(const char *str, char c)
285{ 287{
286 int len; 288 int len;
287 char *s, *t; 289 char *s, *t;
288 290
289 if (str == NULL) 291 if (str == NULL)
290 return NULL; 292 return NULL;
291 t = (char *)str; 293 t = (char *)str;
292 len = strlen(t); 294 len = strlen(t);
293 while(len > 0 && t[len - 1] == c) 295 while(len > 0 && t[len - 1] == c)
294 len--; 296 len--;
295 297
296 if (len == 0) 298 if (len == 0)
297 return NULL; 299 return NULL;
298 300
299 c = t[len]; 301 c = t[len];
300 t[len] = '\0'; 302 t[len] = '\0';
301 s = xstrdup(t); 303 s = xstrdup(t);
302 t[len] = c; 304 t[len] = c;
303 return s; 305 return s;
304} 306}
305 307
306char *strlpart(char *txt, int maxlen) 308char *strlpart(char *txt, int maxlen)
307{ 309{
308 char *result; 310 char *result;
309 311
310 if (!txt) 312 if (!txt)
311 return txt; 313 return txt;
312 314
313 if (strlen(txt) <= maxlen) 315 if (strlen(txt) <= maxlen)
314 return txt; 316 return txt;
315 result = xmalloc(maxlen + 1); 317 result = xmalloc(maxlen + 1);
316 memcpy(result, txt, maxlen - 3); 318 memcpy(result, txt, maxlen - 3);
317 result[maxlen-1] = result[maxlen-2] = result[maxlen-3] = '.'; 319 result[maxlen-1] = result[maxlen-2] = result[maxlen-3] = '.';
318 result[maxlen] = '\0'; 320 result[maxlen] = '\0';
319 return result; 321 return result;
320} 322}
321 323
322char *strrpart(char *txt, int maxlen) 324char *strrpart(char *txt, int maxlen)
323{ 325{
324 char *result; 326 char *result;
325 327
326 if (!txt) 328 if (!txt)
327 return txt; 329 return txt;
328 330
329 if (strlen(txt) <= maxlen) 331 if (strlen(txt) <= maxlen)
330 return txt; 332 return txt;
331 result = xmalloc(maxlen + 1); 333 result = xmalloc(maxlen + 1);
332 memcpy(result + 3, txt + strlen(txt) - maxlen + 4, maxlen - 3); 334 memcpy(result + 3, txt + strlen(txt) - maxlen + 4, maxlen - 3);
333 result[0] = result[1] = result[2] = '.'; 335 result[0] = result[1] = result[2] = '.';
334 return result; 336 return result;
335} 337}
336 338
337void cgit_add_ref(struct reflist *list, struct refinfo *ref) 339void cgit_add_ref(struct reflist *list, struct refinfo *ref)
338{ 340{
339 size_t size; 341 size_t size;
340 342
341 if (list->count >= list->alloc) { 343 if (list->count >= list->alloc) {
342 list->alloc += (list->alloc ? list->alloc : 4); 344 list->alloc += (list->alloc ? list->alloc : 4);
343 size = list->alloc * sizeof(struct refinfo *); 345 size = list->alloc * sizeof(struct refinfo *);
344 list->refs = xrealloc(list->refs, size); 346 list->refs = xrealloc(list->refs, size);
345 } 347 }
346 list->refs[list->count++] = ref; 348 list->refs[list->count++] = ref;
347} 349}
348 350
349struct refinfo *cgit_mk_refinfo(const char *refname, const unsigned char *sha1) 351struct refinfo *cgit_mk_refinfo(const char *refname, const unsigned char *sha1)
350{ 352{
351 struct refinfo *ref; 353 struct refinfo *ref;
352 354
353 ref = xmalloc(sizeof (struct refinfo)); 355 ref = xmalloc(sizeof (struct refinfo));
354 ref->refname = xstrdup(refname); 356 ref->refname = xstrdup(refname);
355 ref->object = parse_object(sha1); 357 ref->object = parse_object(sha1);
356 switch (ref->object->type) { 358 switch (ref->object->type) {
357 case OBJ_TAG: 359 case OBJ_TAG:
358 ref->tag = cgit_parse_tag((struct tag *)ref->object); 360 ref->tag = cgit_parse_tag((struct tag *)ref->object);
359 break; 361 break;
360 case OBJ_COMMIT: 362 case OBJ_COMMIT:
361 ref->commit = cgit_parse_commit((struct commit *)ref->object); 363 ref->commit = cgit_parse_commit((struct commit *)ref->object);
362 break; 364 break;
363 } 365 }
364 return ref; 366 return ref;
365} 367}
366 368
367int cgit_refs_cb(const char *refname, const unsigned char *sha1, int flags, 369int cgit_refs_cb(const char *refname, const unsigned char *sha1, int flags,
368 void *cb_data) 370 void *cb_data)
369{ 371{
370 struct reflist *list = (struct reflist *)cb_data; 372 struct reflist *list = (struct reflist *)cb_data;
371 struct refinfo *info = cgit_mk_refinfo(refname, sha1); 373 struct refinfo *info = cgit_mk_refinfo(refname, sha1);
372 374
373 if (info) 375 if (info)
374 cgit_add_ref(list, info); 376 cgit_add_ref(list, info);
375 return 0; 377 return 0;
376} 378}
377 379
378void cgit_diff_tree_cb(struct diff_queue_struct *q, 380void cgit_diff_tree_cb(struct diff_queue_struct *q,
379 struct diff_options *options, void *data) 381 struct diff_options *options, void *data)
380{ 382{
381 int i; 383 int i;
382 384
383 for (i = 0; i < q->nr; i++) { 385 for (i = 0; i < q->nr; i++) {
384 if (q->queue[i]->status == 'U') 386 if (q->queue[i]->status == 'U')
385 continue; 387 continue;
386 ((filepair_fn)data)(q->queue[i]); 388 ((filepair_fn)data)(q->queue[i]);
387 } 389 }
388} 390}
389 391
390static int load_mmfile(mmfile_t *file, const unsigned char *sha1) 392static int load_mmfile(mmfile_t *file, const unsigned char *sha1)
391{ 393{
392 enum object_type type; 394 enum object_type type;
393 395
394 if (is_null_sha1(sha1)) { 396 if (is_null_sha1(sha1)) {
395 file->ptr = (char *)""; 397 file->ptr = (char *)"";
396 file->size = 0; 398 file->size = 0;
397 } else { 399 } else {
398 file->ptr = read_sha1_file(sha1, &type, 400 file->ptr = read_sha1_file(sha1, &type,
399 (unsigned long *)&file->size); 401 (unsigned long *)&file->size);
400 } 402 }
401 return 1; 403 return 1;
402} 404}
403 405
404/* 406/*
405 * Receive diff-buffers from xdiff and concatenate them as 407 * Receive diff-buffers from xdiff and concatenate them as
406 * needed across multiple callbacks. 408 * needed across multiple callbacks.
407 * 409 *
408 * This is basically a copy of xdiff-interface.c/xdiff_outf(), 410 * This is basically a copy of xdiff-interface.c/xdiff_outf(),
409 * ripped from git and modified to use globals instead of 411 * ripped from git and modified to use globals instead of
410 * a special callback-struct. 412 * a special callback-struct.
411 */ 413 */
412char *diffbuf = NULL; 414char *diffbuf = NULL;
413int buflen = 0; 415int buflen = 0;
414 416
415int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf) 417int filediff_cb(void *priv, mmbuffer_t *mb, int nbuf)
416{ 418{
417 int i; 419 int i;
418 420
419 for (i = 0; i < nbuf; i++) { 421 for (i = 0; i < nbuf; i++) {
420 if (mb[i].ptr[mb[i].size-1] != '\n') { 422 if (mb[i].ptr[mb[i].size-1] != '\n') {
421 /* Incomplete line */ 423 /* Incomplete line */
422 diffbuf = xrealloc(diffbuf, buflen + mb[i].size); 424 diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
423 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); 425 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
424 buflen += mb[i].size; 426 buflen += mb[i].size;
425 continue; 427 continue;
426 } 428 }
427 429
428 /* we have a complete line */ 430 /* we have a complete line */
429 if (!diffbuf) { 431 if (!diffbuf) {
430 ((linediff_fn)priv)(mb[i].ptr, mb[i].size); 432 ((linediff_fn)priv)(mb[i].ptr, mb[i].size);
431 continue; 433 continue;
432 } 434 }
433 diffbuf = xrealloc(diffbuf, buflen + mb[i].size); 435 diffbuf = xrealloc(diffbuf, buflen + mb[i].size);
434 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size); 436 memcpy(diffbuf + buflen, mb[i].ptr, mb[i].size);
435 ((linediff_fn)priv)(diffbuf, buflen + mb[i].size); 437 ((linediff_fn)priv)(diffbuf, buflen + mb[i].size);
436 free(diffbuf); 438 free(diffbuf);
437 diffbuf = NULL; 439 diffbuf = NULL;
438 buflen = 0; 440 buflen = 0;
439 } 441 }
440 if (diffbuf) { 442 if (diffbuf) {
441 ((linediff_fn)priv)(diffbuf, buflen); 443 ((linediff_fn)priv)(diffbuf, buflen);
442 free(diffbuf); 444 free(diffbuf);
443 diffbuf = NULL; 445 diffbuf = NULL;
444 buflen = 0; 446 buflen = 0;
445 } 447 }
446 return 0; 448 return 0;
447} 449}
448 450
449int cgit_diff_files(const unsigned char *old_sha1, 451int cgit_diff_files(const unsigned char *old_sha1,
450 const unsigned char *new_sha1, 452 const unsigned char *new_sha1,
451 linediff_fn fn) 453 linediff_fn fn)
452{ 454{
453 mmfile_t file1, file2; 455 mmfile_t file1, file2;
454 xpparam_t diff_params; 456 xpparam_t diff_params;
455 xdemitconf_t emit_params; 457 xdemitconf_t emit_params;
456 xdemitcb_t emit_cb; 458 xdemitcb_t emit_cb;
457 459
458 if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1)) 460 if (!load_mmfile(&file1, old_sha1) || !load_mmfile(&file2, new_sha1))
459 return 1; 461 return 1;
460 462
461 diff_params.flags = XDF_NEED_MINIMAL; 463 diff_params.flags = XDF_NEED_MINIMAL;
462 emit_params.ctxlen = 3; 464 emit_params.ctxlen = 3;
463 emit_params.flags = XDL_EMIT_FUNCNAMES; 465 emit_params.flags = XDL_EMIT_FUNCNAMES;
464 emit_params.find_func = NULL; 466 emit_params.find_func = NULL;
465 emit_cb.outf = filediff_cb; 467 emit_cb.outf = filediff_cb;
466 emit_cb.priv = fn; 468 emit_cb.priv = fn;
467 xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb); 469 xdl_diff(&file1, &file2, &diff_params, &emit_params, &emit_cb);
468 return 0; 470 return 0;
469} 471}
470 472
471void cgit_diff_tree(const unsigned char *old_sha1, 473void cgit_diff_tree(const unsigned char *old_sha1,
472 const unsigned char *new_sha1, 474 const unsigned char *new_sha1,
473 filepair_fn fn, const char *prefix) 475 filepair_fn fn, const char *prefix)
474{ 476{
475 struct diff_options opt; 477 struct diff_options opt;
476 int ret; 478 int ret;
477 int prefixlen; 479 int prefixlen;
478 480
479 diff_setup(&opt); 481 diff_setup(&opt);
480 opt.output_format = DIFF_FORMAT_CALLBACK; 482 opt.output_format = DIFF_FORMAT_CALLBACK;
481 opt.detect_rename = 1; 483 opt.detect_rename = 1;
482 opt.rename_limit = cgit_renamelimit; 484 opt.rename_limit = cgit_renamelimit;
483 opt.recursive = 1; 485 opt.recursive = 1;
484 opt.format_callback = cgit_diff_tree_cb; 486 opt.format_callback = cgit_diff_tree_cb;
485 opt.format_callback_data = fn; 487 opt.format_callback_data = fn;
486 if (prefix) { 488 if (prefix) {
487 opt.nr_paths = 1; 489 opt.nr_paths = 1;
488 opt.paths = &prefix; 490 opt.paths = &prefix;
489 prefixlen = strlen(prefix); 491 prefixlen = strlen(prefix);
490 opt.pathlens = &prefixlen; 492 opt.pathlens = &prefixlen;
491 } 493 }
492 diff_setup_done(&opt); 494 diff_setup_done(&opt);
493 495
494 if (old_sha1 && !is_null_sha1(old_sha1)) 496 if (old_sha1 && !is_null_sha1(old_sha1))
495 ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt); 497 ret = diff_tree_sha1(old_sha1, new_sha1, "", &opt);
496 else 498 else
497 ret = diff_root_tree_sha1(new_sha1, "", &opt); 499 ret = diff_root_tree_sha1(new_sha1, "", &opt);
498 diffcore_std(&opt); 500 diffcore_std(&opt);
499 diff_flush(&opt); 501 diff_flush(&opt);
500} 502}
501 503
502void cgit_diff_commit(struct commit *commit, filepair_fn fn) 504void cgit_diff_commit(struct commit *commit, filepair_fn fn)
503{ 505{
504 unsigned char *old_sha1 = NULL; 506 unsigned char *old_sha1 = NULL;
505 507
506 if (commit->parents) 508 if (commit->parents)
507 old_sha1 = commit->parents->item->object.sha1; 509 old_sha1 = commit->parents->item->object.sha1;
508 cgit_diff_tree(old_sha1, commit->object.sha1, fn, NULL); 510 cgit_diff_tree(old_sha1, commit->object.sha1, fn, NULL);
509} 511}
diff --git a/ui-shared.c b/ui-shared.c
index 72a7b44..7c69f60 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -1,537 +1,537 @@
1/* ui-shared.c: common web output functions 1/* ui-shared.c: common web output functions
2 * 2 *
3 * Copyright (C) 2006 Lars Hjemli 3 * Copyright (C) 2006 Lars Hjemli
4 * 4 *
5 * Licensed under GNU General Public License v2 5 * Licensed under GNU General Public License v2
6 * (see COPYING for full license text) 6 * (see COPYING for full license text)
7 */ 7 */
8 8
9#include "cgit.h" 9#include "cgit.h"
10 10
11const char cgit_doctype[] = 11const char cgit_doctype[] =
12"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n" 12"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
13" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"; 13" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
14 14
15static char *http_date(time_t t) 15static char *http_date(time_t t)
16{ 16{
17 static char day[][4] = 17 static char day[][4] =
18 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; 18 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
19 static char month[][4] = 19 static char month[][4] =
20 {"Jan", "Feb", "Mar", "Apr", "May", "Jun", 20 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
21 "Jul", "Aug", "Sep", "Oct", "Now", "Dec"}; 21 "Jul", "Aug", "Sep", "Oct", "Now", "Dec"};
22 struct tm *tm = gmtime(&t); 22 struct tm *tm = gmtime(&t);
23 return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday], 23 return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday],
24 tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year, 24 tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year,
25 tm->tm_hour, tm->tm_min, tm->tm_sec); 25 tm->tm_hour, tm->tm_min, tm->tm_sec);
26} 26}
27 27
28static long ttl_seconds(long ttl) 28static long ttl_seconds(long ttl)
29{ 29{
30 if (ttl<0) 30 if (ttl<0)
31 return 60 * 60 * 24 * 365; 31 return 60 * 60 * 24 * 365;
32 else 32 else
33 return ttl * 60; 33 return ttl * 60;
34} 34}
35 35
36void cgit_print_error(char *msg) 36void cgit_print_error(char *msg)
37{ 37{
38 html("<div class='error'>"); 38 html("<div class='error'>");
39 html_txt(msg); 39 html_txt(msg);
40 html("</div>\n"); 40 html("</div>\n");
41} 41}
42 42
43char *cgit_rooturl() 43char *cgit_rooturl()
44{ 44{
45 if (cgit_virtual_root) 45 if (cgit_virtual_root)
46 return fmt("%s/", cgit_virtual_root); 46 return fmt("%s/", cgit_virtual_root);
47 else 47 else
48 return cgit_script_name; 48 return cgit_script_name;
49} 49}
50 50
51char *cgit_repourl(const char *reponame) 51char *cgit_repourl(const char *reponame)
52{ 52{
53 if (cgit_virtual_root) { 53 if (cgit_virtual_root) {
54 return fmt("%s/%s/", cgit_virtual_root, reponame); 54 return fmt("%s/%s/", cgit_virtual_root, reponame);
55 } else { 55 } else {
56 return fmt("?r=%s", reponame); 56 return fmt("?r=%s", reponame);
57 } 57 }
58} 58}
59 59
60char *cgit_fileurl(const char *reponame, const char *pagename, 60char *cgit_fileurl(const char *reponame, const char *pagename,
61 const char *filename, const char *query) 61 const char *filename, const char *query)
62{ 62{
63 char *tmp; 63 char *tmp;
64 char *delim; 64 char *delim;
65 65
66 if (cgit_virtual_root) { 66 if (cgit_virtual_root) {
67 tmp = fmt("%s/%s/%s/%s", cgit_virtual_root, reponame, 67 tmp = fmt("%s/%s/%s/%s", cgit_virtual_root, reponame,
68 pagename, (filename ? filename:"")); 68 pagename, (filename ? filename:""));
69 delim = "?"; 69 delim = "?";
70 } else { 70 } else {
71 tmp = fmt("?url=%s/%s/%s", reponame, pagename, 71 tmp = fmt("?url=%s/%s/%s", reponame, pagename,
72 (filename ? filename : "")); 72 (filename ? filename : ""));
73 delim = "&"; 73 delim = "&";
74 } 74 }
75 if (query) 75 if (query)
76 tmp = fmt("%s%s%s", tmp, delim, query); 76 tmp = fmt("%s%s%s", tmp, delim, query);
77 return tmp; 77 return tmp;
78} 78}
79 79
80char *cgit_pageurl(const char *reponame, const char *pagename, 80char *cgit_pageurl(const char *reponame, const char *pagename,
81 const char *query) 81 const char *query)
82{ 82{
83 return cgit_fileurl(reponame,pagename,0,query); 83 return cgit_fileurl(reponame,pagename,0,query);
84} 84}
85 85
86const char *cgit_repobasename(const char *reponame) 86const char *cgit_repobasename(const char *reponame)
87{ 87{
88 /* I assume we don't need to store more than one repo basename */ 88 /* I assume we don't need to store more than one repo basename */
89 static char rvbuf[1024]; 89 static char rvbuf[1024];
90 int p; 90 int p;
91 const char *rv; 91 const char *rv;
92 strncpy(rvbuf,reponame,sizeof(rvbuf)); 92 strncpy(rvbuf,reponame,sizeof(rvbuf));
93 if(rvbuf[sizeof(rvbuf)-1]) 93 if(rvbuf[sizeof(rvbuf)-1])
94 die("cgit_repobasename: truncated repository name '%s'", reponame); 94 die("cgit_repobasename: truncated repository name '%s'", reponame);
95 p = strlen(rvbuf)-1; 95 p = strlen(rvbuf)-1;
96 /* strip trailing slashes */ 96 /* strip trailing slashes */
97 while(p && rvbuf[p]=='/') rvbuf[p--]=0; 97 while(p && rvbuf[p]=='/') rvbuf[p--]=0;
98 /* strip trailing .git */ 98 /* strip trailing .git */
99 if(p>=3 && !strncmp(&rvbuf[p-3],".git",4)) { 99 if(p>=3 && !strncmp(&rvbuf[p-3],".git",4)) {
100 p -= 3; rvbuf[p--] = 0; 100 p -= 3; rvbuf[p--] = 0;
101 } 101 }
102 /* strip more trailing slashes if any */ 102 /* strip more trailing slashes if any */
103 while( p && rvbuf[p]=='/') rvbuf[p--]=0; 103 while( p && rvbuf[p]=='/') rvbuf[p--]=0;
104 /* find last slash in the remaining string */ 104 /* find last slash in the remaining string */
105 rv = strrchr(rvbuf,'/'); 105 rv = strrchr(rvbuf,'/');
106 if(rv) 106 if(rv)
107 return ++rv; 107 return ++rv;
108 return rvbuf; 108 return rvbuf;
109} 109}
110 110
111char *cgit_currurl() 111char *cgit_currurl()
112{ 112{
113 if (!cgit_virtual_root) 113 if (!cgit_virtual_root)
114 return cgit_script_name; 114 return cgit_script_name;
115 else if (cgit_query_page) 115 else if (cgit_query_page)
116 return fmt("%s/%s/%s/", cgit_virtual_root, cgit_query_repo, cgit_query_page); 116 return fmt("%s/%s/%s/", cgit_virtual_root, cgit_query_repo, cgit_query_page);
117 else if (cgit_query_repo) 117 else if (cgit_query_repo)
118 return fmt("%s/%s/", cgit_virtual_root, cgit_query_repo); 118 return fmt("%s/%s/", cgit_virtual_root, cgit_query_repo);
119 else 119 else
120 return fmt("%s/", cgit_virtual_root); 120 return fmt("%s/", cgit_virtual_root);
121} 121}
122 122
123static char *repolink(char *title, char *class, char *page, char *head, 123static char *repolink(char *title, char *class, char *page, char *head,
124 char *path) 124 char *path)
125{ 125{
126 char *delim = "?"; 126 char *delim = "?";
127 127
128 html("<a"); 128 html("<a");
129 if (title) { 129 if (title) {
130 html(" title='"); 130 html(" title='");
131 html_attr(title); 131 html_attr(title);
132 html("'"); 132 html("'");
133 } 133 }
134 if (class) { 134 if (class) {
135 html(" class='"); 135 html(" class='");
136 html_attr(class); 136 html_attr(class);
137 html("'"); 137 html("'");
138 } 138 }
139 html(" href='"); 139 html(" href='");
140 if (cgit_virtual_root) { 140 if (cgit_virtual_root) {
141 html_attr(cgit_virtual_root); 141 html_attr(cgit_virtual_root);
142 if (cgit_virtual_root[strlen(cgit_virtual_root) - 1] != '/') 142 if (cgit_virtual_root[strlen(cgit_virtual_root) - 1] != '/')
143 html("/"); 143 html("/");
144 html_attr(cgit_repo->url); 144 html_attr(cgit_repo->url);
145 if (cgit_repo->url[strlen(cgit_repo->url) - 1] != '/') 145 if (cgit_repo->url[strlen(cgit_repo->url) - 1] != '/')
146 html("/"); 146 html("/");
147 if (page) { 147 if (page) {
148 html(page); 148 html(page);
149 html("/"); 149 html("/");
150 if (path) 150 if (path)
151 html_attr(path); 151 html_attr(path);
152 } 152 }
153 } else { 153 } else {
154 html(cgit_script_name); 154 html(cgit_script_name);
155 html("?url="); 155 html("?url=");
156 html_attr(cgit_repo->url); 156 html_attr(cgit_repo->url);
157 if (cgit_repo->url[strlen(cgit_repo->url) - 1] != '/') 157 if (cgit_repo->url[strlen(cgit_repo->url) - 1] != '/')
158 html("/"); 158 html("/");
159 if (page) { 159 if (page) {
160 html(page); 160 html(page);
161 html("/"); 161 html("/");
162 if (path) 162 if (path)
163 html_attr(path); 163 html_attr(path);
164 } 164 }
165 delim = "&amp;"; 165 delim = "&amp;";
166 } 166 }
167 if (head && strcmp(head, cgit_repo->defbranch)) { 167 if (head && strcmp(head, cgit_repo->defbranch)) {
168 html(delim); 168 html(delim);
169 html("h="); 169 html("h=");
170 html_attr(head); 170 html_attr(head);
171 delim = "&amp;"; 171 delim = "&amp;";
172 } 172 }
173 return fmt("%s", delim); 173 return fmt("%s", delim);
174} 174}
175 175
176static void reporevlink(char *page, char *name, char *title, char *class, 176static void reporevlink(char *page, char *name, char *title, char *class,
177 char *head, char *rev, char *path) 177 char *head, char *rev, char *path)
178{ 178{
179 char *delim; 179 char *delim;
180 180
181 delim = repolink(title, class, page, head, path); 181 delim = repolink(title, class, page, head, path);
182 if (rev && strcmp(rev, cgit_query_head)) { 182 if (rev && strcmp(rev, cgit_query_head)) {
183 html(delim); 183 html(delim);
184 html("id="); 184 html("id=");
185 html_attr(rev); 185 html_attr(rev);
186 } 186 }
187 html("'>"); 187 html("'>");
188 html_txt(name); 188 html_txt(name);
189 html("</a>"); 189 html("</a>");
190} 190}
191 191
192void cgit_tree_link(char *name, char *title, char *class, char *head, 192void cgit_tree_link(char *name, char *title, char *class, char *head,
193 char *rev, char *path) 193 char *rev, char *path)
194{ 194{
195 reporevlink("tree", name, title, class, head, rev, path); 195 reporevlink("tree", name, title, class, head, rev, path);
196} 196}
197 197
198void cgit_log_link(char *name, char *title, char *class, char *head, 198void cgit_log_link(char *name, char *title, char *class, char *head,
199 char *rev, char *path, int ofs, char *grep, char *pattern) 199 char *rev, char *path, int ofs, char *grep, char *pattern)
200{ 200{
201 char *delim; 201 char *delim;
202 202
203 delim = repolink(title, class, "log", head, path); 203 delim = repolink(title, class, "log", head, path);
204 if (rev && strcmp(rev, cgit_query_head)) { 204 if (rev && strcmp(rev, cgit_query_head)) {
205 html(delim); 205 html(delim);
206 html("id="); 206 html("id=");
207 html_attr(rev); 207 html_attr(rev);
208 delim = "&"; 208 delim = "&";
209 } 209 }
210 if (grep && pattern) { 210 if (grep && pattern) {
211 html(delim); 211 html(delim);
212 html("qt="); 212 html("qt=");
213 html_attr(grep); 213 html_attr(grep);
214 delim = "&"; 214 delim = "&";
215 html(delim); 215 html(delim);
216 html("q="); 216 html("q=");
217 html_attr(pattern); 217 html_attr(pattern);
218 } 218 }
219 if (ofs > 0) { 219 if (ofs > 0) {
220 html(delim); 220 html(delim);
221 html("ofs="); 221 html("ofs=");
222 htmlf("%d", ofs); 222 htmlf("%d", ofs);
223 } 223 }
224 html("'>"); 224 html("'>");
225 html_txt(name); 225 html_txt(name);
226 html("</a>"); 226 html("</a>");
227} 227}
228 228
229void cgit_commit_link(char *name, char *title, char *class, char *head, 229void cgit_commit_link(char *name, char *title, char *class, char *head,
230 char *rev) 230 char *rev)
231{ 231{
232 if (strlen(name) > cgit_max_msg_len && cgit_max_msg_len >= 15) { 232 if (strlen(name) > cgit_max_msg_len && cgit_max_msg_len >= 15) {
233 name[cgit_max_msg_len] = '\0'; 233 name[cgit_max_msg_len] = '\0';
234 name[cgit_max_msg_len - 1] = '.'; 234 name[cgit_max_msg_len - 1] = '.';
235 name[cgit_max_msg_len - 2] = '.'; 235 name[cgit_max_msg_len - 2] = '.';
236 name[cgit_max_msg_len - 3] = '.'; 236 name[cgit_max_msg_len - 3] = '.';
237 } 237 }
238 reporevlink("commit", name, title, class, head, rev, NULL); 238 reporevlink("commit", name, title, class, head, rev, NULL);
239} 239}
240 240
241void cgit_refs_link(char *name, char *title, char *class, char *head, 241void cgit_refs_link(char *name, char *title, char *class, char *head,
242 char *rev, char *path) 242 char *rev, char *path)
243{ 243{
244 reporevlink("refs", name, title, class, head, rev, path); 244 reporevlink("refs", name, title, class, head, rev, path);
245} 245}
246 246
247void cgit_snapshot_link(char *name, char *title, char *class, char *head, 247void cgit_snapshot_link(char *name, char *title, char *class, char *head,
248 char *rev, char *archivename) 248 char *rev, char *archivename)
249{ 249{
250 reporevlink("snapshot", name, title, class, head, rev, archivename); 250 reporevlink("snapshot", name, title, class, head, rev, archivename);
251} 251}
252 252
253void cgit_diff_link(char *name, char *title, char *class, char *head, 253void cgit_diff_link(char *name, char *title, char *class, char *head,
254 char *new_rev, char *old_rev, char *path) 254 char *new_rev, char *old_rev, char *path)
255{ 255{
256 char *delim; 256 char *delim;
257 257
258 delim = repolink(title, class, "diff", head, path); 258 delim = repolink(title, class, "diff", head, path);
259 if (new_rev && strcmp(new_rev, cgit_query_head)) { 259 if (new_rev && strcmp(new_rev, cgit_query_head)) {
260 html(delim); 260 html(delim);
261 html("id="); 261 html("id=");
262 html_attr(new_rev); 262 html_attr(new_rev);
263 delim = "&amp;"; 263 delim = "&amp;";
264 } 264 }
265 if (old_rev) { 265 if (old_rev) {
266 html(delim); 266 html(delim);
267 html("id2="); 267 html("id2=");
268 html_attr(old_rev); 268 html_attr(old_rev);
269 } 269 }
270 html("'>"); 270 html("'>");
271 html_txt(name); 271 html_txt(name);
272 html("</a>"); 272 html("</a>");
273} 273}
274 274
275void cgit_object_link(struct object *obj) 275void cgit_object_link(struct object *obj)
276{ 276{
277 char *page, *arg, *url; 277 char *page, *arg, *url;
278 278
279 if (obj->type == OBJ_COMMIT) { 279 if (obj->type == OBJ_COMMIT) {
280 cgit_commit_link(fmt("commit %s", sha1_to_hex(obj->sha1)), NULL, NULL, 280 cgit_commit_link(fmt("commit %s", sha1_to_hex(obj->sha1)), NULL, NULL,
281 cgit_query_head, sha1_to_hex(obj->sha1)); 281 cgit_query_head, sha1_to_hex(obj->sha1));
282 return; 282 return;
283 } else if (obj->type == OBJ_TREE) { 283 } else if (obj->type == OBJ_TREE) {
284 page = "tree"; 284 page = "tree";
285 arg = "id"; 285 arg = "id";
286 } else if (obj->type == OBJ_TAG) { 286 } else if (obj->type == OBJ_TAG) {
287 page = "tag"; 287 page = "tag";
288 arg = "id"; 288 arg = "id";
289 } else { 289 } else {
290 page = "blob"; 290 page = "blob";
291 arg = "id"; 291 arg = "id";
292 } 292 }
293 293
294 url = cgit_pageurl(cgit_query_repo, page, 294 url = cgit_pageurl(cgit_query_repo, page,
295 fmt("%s=%s", arg, sha1_to_hex(obj->sha1))); 295 fmt("%s=%s", arg, sha1_to_hex(obj->sha1)));
296 html_link_open(url, NULL, NULL); 296 html_link_open(url, NULL, NULL);
297 htmlf("%s %s", typename(obj->type), 297 htmlf("%s %s", typename(obj->type),
298 sha1_to_hex(obj->sha1)); 298 sha1_to_hex(obj->sha1));
299 html_link_close(); 299 html_link_close();
300} 300}
301 301
302void cgit_print_date(time_t secs, char *format) 302void cgit_print_date(time_t secs, char *format)
303{ 303{
304 char buf[64]; 304 char buf[64];
305 struct tm *time; 305 struct tm *time;
306 306
307 time = gmtime(&secs); 307 time = gmtime(&secs);
308 strftime(buf, sizeof(buf)-1, format, time); 308 strftime(buf, sizeof(buf)-1, format, time);
309 html_txt(buf); 309 html_txt(buf);
310} 310}
311 311
312void cgit_print_age(time_t t, time_t max_relative, char *format) 312void cgit_print_age(time_t t, time_t max_relative, char *format)
313{ 313{
314 time_t now, secs; 314 time_t now, secs;
315 315
316 time(&now); 316 time(&now);
317 secs = now - t; 317 secs = now - t;
318 318
319 if (secs > max_relative && max_relative >= 0) { 319 if (secs > max_relative && max_relative >= 0) {
320 cgit_print_date(t, format); 320 cgit_print_date(t, format);
321 return; 321 return;
322 } 322 }
323 323
324 if (secs < TM_HOUR * 2) { 324 if (secs < TM_HOUR * 2) {
325 htmlf("<span class='age-mins'>%.0f min.</span>", 325 htmlf("<span class='age-mins'>%.0f min.</span>",
326 secs * 1.0 / TM_MIN); 326 secs * 1.0 / TM_MIN);
327 return; 327 return;
328 } 328 }
329 if (secs < TM_DAY * 2) { 329 if (secs < TM_DAY * 2) {
330 htmlf("<span class='age-hours'>%.0f hours</span>", 330 htmlf("<span class='age-hours'>%.0f hours</span>",
331 secs * 1.0 / TM_HOUR); 331 secs * 1.0 / TM_HOUR);
332 return; 332 return;
333 } 333 }
334 if (secs < TM_WEEK * 2) { 334 if (secs < TM_WEEK * 2) {
335 htmlf("<span class='age-days'>%.0f days</span>", 335 htmlf("<span class='age-days'>%.0f days</span>",
336 secs * 1.0 / TM_DAY); 336 secs * 1.0 / TM_DAY);
337 return; 337 return;
338 } 338 }
339 if (secs < TM_MONTH * 2) { 339 if (secs < TM_MONTH * 2) {
340 htmlf("<span class='age-weeks'>%.0f weeks</span>", 340 htmlf("<span class='age-weeks'>%.0f weeks</span>",
341 secs * 1.0 / TM_WEEK); 341 secs * 1.0 / TM_WEEK);
342 return; 342 return;
343 } 343 }
344 if (secs < TM_YEAR * 2) { 344 if (secs < TM_YEAR * 2) {
345 htmlf("<span class='age-months'>%.0f months</span>", 345 htmlf("<span class='age-months'>%.0f months</span>",
346 secs * 1.0 / TM_MONTH); 346 secs * 1.0 / TM_MONTH);
347 return; 347 return;
348 } 348 }
349 htmlf("<span class='age-years'>%.0f years</span>", 349 htmlf("<span class='age-years'>%.0f years</span>",
350 secs * 1.0 / TM_YEAR); 350 secs * 1.0 / TM_YEAR);
351} 351}
352 352
353void cgit_print_docstart(char *title, struct cacheitem *item) 353void cgit_print_docstart(char *title, struct cacheitem *item)
354{ 354{
355 html("Content-Type: text/html; charset=utf-8\n"); 355 html("Content-Type: text/html; charset=" PAGE_ENCODING "\n");
356 htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime)); 356 htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime));
357 htmlf("Expires: %s\n", http_date(item->st.st_mtime + 357 htmlf("Expires: %s\n", http_date(item->st.st_mtime +
358 ttl_seconds(item->ttl))); 358 ttl_seconds(item->ttl)));
359 html("\n"); 359 html("\n");
360 html(cgit_doctype); 360 html(cgit_doctype);
361 html("<html>\n"); 361 html("<html>\n");
362 html("<head>\n"); 362 html("<head>\n");
363 html("<title>"); 363 html("<title>");
364 html_txt(title); 364 html_txt(title);
365 html("</title>\n"); 365 html("</title>\n");
366 htmlf("<meta name='generator' content='cgit %s'/>\n", cgit_version); 366 htmlf("<meta name='generator' content='cgit %s'/>\n", cgit_version);
367 html("<link rel='stylesheet' type='text/css' href='"); 367 html("<link rel='stylesheet' type='text/css' href='");
368 html_attr(cgit_css); 368 html_attr(cgit_css);
369 html("'/>\n"); 369 html("'/>\n");
370 html("</head>\n"); 370 html("</head>\n");
371 html("<body>\n"); 371 html("<body>\n");
372} 372}
373 373
374void cgit_print_docend() 374void cgit_print_docend()
375{ 375{
376 html("</td>\n</tr>\n<table>\n</body>\n</html>\n"); 376 html("</td>\n</tr>\n<table>\n</body>\n</html>\n");
377} 377}
378 378
379int print_branch_option(const char *refname, const unsigned char *sha1, 379int print_branch_option(const char *refname, const unsigned char *sha1,
380 int flags, void *cb_data) 380 int flags, void *cb_data)
381{ 381{
382 char *name = (char *)refname; 382 char *name = (char *)refname;
383 html_option(name, name, cgit_query_head); 383 html_option(name, name, cgit_query_head);
384 return 0; 384 return 0;
385} 385}
386 386
387int print_archive_ref(const char *refname, const unsigned char *sha1, 387int print_archive_ref(const char *refname, const unsigned char *sha1,
388 int flags, void *cb_data) 388 int flags, void *cb_data)
389{ 389{
390 struct tag *tag; 390 struct tag *tag;
391 struct taginfo *info; 391 struct taginfo *info;
392 struct object *obj; 392 struct object *obj;
393 char buf[256], *url; 393 char buf[256], *url;
394 unsigned char fileid[20]; 394 unsigned char fileid[20];
395 int *header = (int *)cb_data; 395 int *header = (int *)cb_data;
396 396
397 if (prefixcmp(refname, "refs/archives")) 397 if (prefixcmp(refname, "refs/archives"))
398 return 0; 398 return 0;
399 strncpy(buf, refname+14, sizeof(buf)); 399 strncpy(buf, refname+14, sizeof(buf));
400 obj = parse_object(sha1); 400 obj = parse_object(sha1);
401 if (!obj) 401 if (!obj)
402 return 1; 402 return 1;
403 if (obj->type == OBJ_TAG) { 403 if (obj->type == OBJ_TAG) {
404 tag = lookup_tag(sha1); 404 tag = lookup_tag(sha1);
405 if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag))) 405 if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag)))
406 return 0; 406 return 0;
407 hashcpy(fileid, tag->tagged->sha1); 407 hashcpy(fileid, tag->tagged->sha1);
408 } else if (obj->type != OBJ_BLOB) { 408 } else if (obj->type != OBJ_BLOB) {
409 return 0; 409 return 0;
410 } else { 410 } else {
411 hashcpy(fileid, sha1); 411 hashcpy(fileid, sha1);
412 } 412 }
413 if (!*header) { 413 if (!*header) {
414 html("<p><h1>download</h1>"); 414 html("<p><h1>download</h1>");
415 *header = 1; 415 *header = 1;
416 } 416 }
417 url = cgit_pageurl(cgit_query_repo, "blob", 417 url = cgit_pageurl(cgit_query_repo, "blob",
418 fmt("id=%s&amp;path=%s", sha1_to_hex(fileid), 418 fmt("id=%s&amp;path=%s", sha1_to_hex(fileid),
419 buf)); 419 buf));
420 html_link_open(url, NULL, "menu"); 420 html_link_open(url, NULL, "menu");
421 html_txt(strlpart(buf, 20)); 421 html_txt(strlpart(buf, 20));
422 html_link_close(); 422 html_link_close();
423 return 0; 423 return 0;
424} 424}
425 425
426void add_hidden_formfields(int incl_head, int incl_search, char *page) 426void add_hidden_formfields(int incl_head, int incl_search, char *page)
427{ 427{
428 char *url; 428 char *url;
429 429
430 if (!cgit_virtual_root) { 430 if (!cgit_virtual_root) {
431 url = fmt("%s/%s", cgit_query_repo, page); 431 url = fmt("%s/%s", cgit_query_repo, page);
432 if (cgit_query_path) 432 if (cgit_query_path)
433 url = fmt("%s/%s", url, cgit_query_path); 433 url = fmt("%s/%s", url, cgit_query_path);
434 html_hidden("url", url); 434 html_hidden("url", url);
435 } 435 }
436 436
437 if (incl_head && strcmp(cgit_query_head, cgit_repo->defbranch)) 437 if (incl_head && strcmp(cgit_query_head, cgit_repo->defbranch))
438 html_hidden("h", cgit_query_head); 438 html_hidden("h", cgit_query_head);
439 439
440 if (cgit_query_sha1) 440 if (cgit_query_sha1)
441 html_hidden("id", cgit_query_sha1); 441 html_hidden("id", cgit_query_sha1);
442 if (cgit_query_sha2) 442 if (cgit_query_sha2)
443 html_hidden("id2", cgit_query_sha2); 443 html_hidden("id2", cgit_query_sha2);
444 444
445 if (incl_search) { 445 if (incl_search) {
446 if (cgit_query_grep) 446 if (cgit_query_grep)
447 html_hidden("qt", cgit_query_grep); 447 html_hidden("qt", cgit_query_grep);
448 if (cgit_query_search) 448 if (cgit_query_search)
449 html_hidden("q", cgit_query_search); 449 html_hidden("q", cgit_query_search);
450 } 450 }
451} 451}
452 452
453void cgit_print_pageheader(char *title, int show_search) 453void cgit_print_pageheader(char *title, int show_search)
454{ 454{
455 static const char *default_info = "This is cgit, a fast webinterface for git repositories"; 455 static const char *default_info = "This is cgit, a fast webinterface for git repositories";
456 int header = 0; 456 int header = 0;
457 457
458 html("<div id='sidebar'>\n"); 458 html("<div id='sidebar'>\n");
459 html("<a href='"); 459 html("<a href='");
460 html_attr(cgit_rooturl()); 460 html_attr(cgit_rooturl());
461 htmlf("'><div id='logo'><img src='%s' alt='cgit'/></div></a>\n", 461 htmlf("'><div id='logo'><img src='%s' alt='cgit'/></div></a>\n",
462 cgit_logo); 462 cgit_logo);
463 html("<div class='infobox'>"); 463 html("<div class='infobox'>");
464 if (cgit_query_repo) { 464 if (cgit_query_repo) {
465 html("<h1>"); 465 html("<h1>");
466 html_txt(strrpart(cgit_repo->name, 20)); 466 html_txt(strrpart(cgit_repo->name, 20));
467 html("</h1>\n"); 467 html("</h1>\n");
468 html_txt(cgit_repo->desc); 468 html_txt(cgit_repo->desc);
469 if (cgit_repo->owner) { 469 if (cgit_repo->owner) {
470 html("<p>\n<h1>owner</h1>\n"); 470 html("<p>\n<h1>owner</h1>\n");
471 html_txt(cgit_repo->owner); 471 html_txt(cgit_repo->owner);
472 } 472 }
473 html("<p>\n<h1>navigate</h1>\n"); 473 html("<p>\n<h1>navigate</h1>\n");
474 reporevlink(NULL, "summary", NULL, "menu", cgit_query_head, 474 reporevlink(NULL, "summary", NULL, "menu", cgit_query_head,
475 NULL, NULL); 475 NULL, NULL);
476 cgit_log_link("log", NULL, "menu", cgit_query_head, NULL, NULL, 476 cgit_log_link("log", NULL, "menu", cgit_query_head, NULL, NULL,
477 0, NULL, NULL); 477 0, NULL, NULL);
478 cgit_tree_link("tree", NULL, "menu", cgit_query_head, 478 cgit_tree_link("tree", NULL, "menu", cgit_query_head,
479 cgit_query_sha1, NULL); 479 cgit_query_sha1, NULL);
480 cgit_commit_link("commit", NULL, "menu", cgit_query_head, 480 cgit_commit_link("commit", NULL, "menu", cgit_query_head,
481 cgit_query_sha1); 481 cgit_query_sha1);
482 cgit_diff_link("diff", NULL, "menu", cgit_query_head, 482 cgit_diff_link("diff", NULL, "menu", cgit_query_head,
483 cgit_query_sha1, cgit_query_sha2, NULL); 483 cgit_query_sha1, cgit_query_sha2, NULL);
484 484
485 for_each_ref(print_archive_ref, &header); 485 for_each_ref(print_archive_ref, &header);
486 486
487 html("<p>\n<h1>branch</h1>\n"); 487 html("<p>\n<h1>branch</h1>\n");
488 html("<form method='get' action=''>\n"); 488 html("<form method='get' action=''>\n");
489 add_hidden_formfields(0, 1, cgit_query_page); 489 add_hidden_formfields(0, 1, cgit_query_page);
490 html("<table class='grid'><tr><td id='branch-dropdown-cell'>"); 490 html("<table class='grid'><tr><td id='branch-dropdown-cell'>");
491 html("<select name='h' onchange='this.form.submit();'>\n"); 491 html("<select name='h' onchange='this.form.submit();'>\n");
492 for_each_branch_ref(print_branch_option, cgit_query_head); 492 for_each_branch_ref(print_branch_option, cgit_query_head);
493 html("</select>\n"); 493 html("</select>\n");
494 html("</td><td>"); 494 html("</td><td>");
495 html("<noscript><input type='submit' id='switch-btn' value='..'></noscript>\n"); 495 html("<noscript><input type='submit' id='switch-btn' value='..'></noscript>\n");
496 html("</td></tr></table>"); 496 html("</td></tr></table>");
497 html("</form>\n"); 497 html("</form>\n");
498 498
499 html("<p>\n<h1>search</h1>\n"); 499 html("<p>\n<h1>search</h1>\n");
500 html("<form method='get' action='"); 500 html("<form method='get' action='");
501 if (cgit_virtual_root) 501 if (cgit_virtual_root)
502 html_attr(cgit_fileurl(cgit_query_repo, "log", 502 html_attr(cgit_fileurl(cgit_query_repo, "log",
503 cgit_query_path, NULL)); 503 cgit_query_path, NULL));
504 html("'>\n"); 504 html("'>\n");
505 add_hidden_formfields(1, 0, "log"); 505 add_hidden_formfields(1, 0, "log");
506 html("<select name='qt'>\n"); 506 html("<select name='qt'>\n");
507 html_option("grep", "log msg", cgit_query_grep); 507 html_option("grep", "log msg", cgit_query_grep);
508 html_option("author", "author", cgit_query_grep); 508 html_option("author", "author", cgit_query_grep);
509 html_option("committer", "committer", cgit_query_grep); 509 html_option("committer", "committer", cgit_query_grep);
510 html("</select>\n"); 510 html("</select>\n");
511 html("<input class='txt' type='text' name='q' value='"); 511 html("<input class='txt' type='text' name='q' value='");
512 html_attr(cgit_query_search); 512 html_attr(cgit_query_search);
513 html("'/>\n"); 513 html("'/>\n");
514 html("</form>\n"); 514 html("</form>\n");
515 } else { 515 } else {
516 if (!cgit_index_info || html_include(cgit_index_info)) 516 if (!cgit_index_info || html_include(cgit_index_info))
517 html(default_info); 517 html(default_info);
518 } 518 }
519 519
520 html("</div>\n"); 520 html("</div>\n");
521 521
522 html("</div>\n<table class='grid'><tr><td id='content'>\n"); 522 html("</div>\n<table class='grid'><tr><td id='content'>\n");
523} 523}
524 524
525 525
526void cgit_print_snapshot_start(const char *mimetype, const char *filename, 526void cgit_print_snapshot_start(const char *mimetype, const char *filename,
527 struct cacheitem *item) 527 struct cacheitem *item)
528{ 528{
529 htmlf("Content-Type: %s\n", mimetype); 529 htmlf("Content-Type: %s\n", mimetype);
530 htmlf("Content-Disposition: inline; filename=\"%s\"\n", filename); 530 htmlf("Content-Disposition: inline; filename=\"%s\"\n", filename);
531 htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime)); 531 htmlf("Last-Modified: %s\n", http_date(item->st.st_mtime));
532 htmlf("Expires: %s\n", http_date(item->st.st_mtime + 532 htmlf("Expires: %s\n", http_date(item->st.st_mtime +
533 ttl_seconds(item->ttl))); 533 ttl_seconds(item->ttl)));
534 html("\n"); 534 html("\n");
535} 535}
536 536
537/* vim:set sw=8: */ 537/* vim:set sw=8: */