summaryrefslogtreecommitdiffabout
Unidiff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--cgit.c75
-rw-r--r--cgit.h1
2 files changed, 75 insertions, 1 deletions
diff --git a/cgit.c b/cgit.c
index db96905..594b950 100644
--- a/cgit.c
+++ b/cgit.c
@@ -1,560 +1,633 @@
1/* cgit.c: cgi for the git scm 1/* cgit.c: cgi for the git scm
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#include "cache.h" 10#include "cache.h"
11#include "cmd.h" 11#include "cmd.h"
12#include "configfile.h" 12#include "configfile.h"
13#include "html.h" 13#include "html.h"
14#include "ui-shared.h" 14#include "ui-shared.h"
15#include "ui-stats.h" 15#include "ui-stats.h"
16#include "scan-tree.h" 16#include "scan-tree.h"
17 17
18const char *cgit_version = CGIT_VERSION; 18const char *cgit_version = CGIT_VERSION;
19 19
20void add_mimetype(const char *name, const char *value) 20void add_mimetype(const char *name, const char *value)
21{ 21{
22 struct string_list_item *item; 22 struct string_list_item *item;
23 23
24 item = string_list_insert(xstrdup(name), &ctx.cfg.mimetypes); 24 item = string_list_insert(xstrdup(name), &ctx.cfg.mimetypes);
25 item->util = xstrdup(value); 25 item->util = xstrdup(value);
26} 26}
27 27
28struct cgit_filter *new_filter(const char *cmd, int extra_args) 28struct cgit_filter *new_filter(const char *cmd, int extra_args)
29{ 29{
30 struct cgit_filter *f; 30 struct cgit_filter *f;
31 31
32 if (!cmd || !cmd[0]) 32 if (!cmd || !cmd[0])
33 return NULL; 33 return NULL;
34 34
35 f = xmalloc(sizeof(struct cgit_filter)); 35 f = xmalloc(sizeof(struct cgit_filter));
36 f->cmd = xstrdup(cmd); 36 f->cmd = xstrdup(cmd);
37 f->argv = xmalloc((2 + extra_args) * sizeof(char *)); 37 f->argv = xmalloc((2 + extra_args) * sizeof(char *));
38 f->argv[0] = f->cmd; 38 f->argv[0] = f->cmd;
39 f->argv[1] = NULL; 39 f->argv[1] = NULL;
40 return f; 40 return f;
41} 41}
42 42
43static void process_cached_repolist(const char *path);
44
43void config_cb(const char *name, const char *value) 45void config_cb(const char *name, const char *value)
44{ 46{
45 if (!strcmp(name, "root-title")) 47 if (!strcmp(name, "root-title"))
46 ctx.cfg.root_title = xstrdup(value); 48 ctx.cfg.root_title = xstrdup(value);
47 else if (!strcmp(name, "root-desc")) 49 else if (!strcmp(name, "root-desc"))
48 ctx.cfg.root_desc = xstrdup(value); 50 ctx.cfg.root_desc = xstrdup(value);
49 else if (!strcmp(name, "root-readme")) 51 else if (!strcmp(name, "root-readme"))
50 ctx.cfg.root_readme = xstrdup(value); 52 ctx.cfg.root_readme = xstrdup(value);
51 else if (!strcmp(name, "css")) 53 else if (!strcmp(name, "css"))
52 ctx.cfg.css = xstrdup(value); 54 ctx.cfg.css = xstrdup(value);
53 else if (!strcmp(name, "favicon")) 55 else if (!strcmp(name, "favicon"))
54 ctx.cfg.favicon = xstrdup(value); 56 ctx.cfg.favicon = xstrdup(value);
55 else if (!strcmp(name, "footer")) 57 else if (!strcmp(name, "footer"))
56 ctx.cfg.footer = xstrdup(value); 58 ctx.cfg.footer = xstrdup(value);
57 else if (!strcmp(name, "head-include")) 59 else if (!strcmp(name, "head-include"))
58 ctx.cfg.head_include = xstrdup(value); 60 ctx.cfg.head_include = xstrdup(value);
59 else if (!strcmp(name, "header")) 61 else if (!strcmp(name, "header"))
60 ctx.cfg.header = xstrdup(value); 62 ctx.cfg.header = xstrdup(value);
61 else if (!strcmp(name, "logo")) 63 else if (!strcmp(name, "logo"))
62 ctx.cfg.logo = xstrdup(value); 64 ctx.cfg.logo = xstrdup(value);
63 else if (!strcmp(name, "index-header")) 65 else if (!strcmp(name, "index-header"))
64 ctx.cfg.index_header = xstrdup(value); 66 ctx.cfg.index_header = xstrdup(value);
65 else if (!strcmp(name, "index-info")) 67 else if (!strcmp(name, "index-info"))
66 ctx.cfg.index_info = xstrdup(value); 68 ctx.cfg.index_info = xstrdup(value);
67 else if (!strcmp(name, "logo-link")) 69 else if (!strcmp(name, "logo-link"))
68 ctx.cfg.logo_link = xstrdup(value); 70 ctx.cfg.logo_link = xstrdup(value);
69 else if (!strcmp(name, "module-link")) 71 else if (!strcmp(name, "module-link"))
70 ctx.cfg.module_link = xstrdup(value); 72 ctx.cfg.module_link = xstrdup(value);
71 else if (!strcmp(name, "virtual-root")) { 73 else if (!strcmp(name, "virtual-root")) {
72 ctx.cfg.virtual_root = trim_end(value, '/'); 74 ctx.cfg.virtual_root = trim_end(value, '/');
73 if (!ctx.cfg.virtual_root && (!strcmp(value, "/"))) 75 if (!ctx.cfg.virtual_root && (!strcmp(value, "/")))
74 ctx.cfg.virtual_root = ""; 76 ctx.cfg.virtual_root = "";
75 } else if (!strcmp(name, "nocache")) 77 } else if (!strcmp(name, "nocache"))
76 ctx.cfg.nocache = atoi(value); 78 ctx.cfg.nocache = atoi(value);
77 else if (!strcmp(name, "noplainemail")) 79 else if (!strcmp(name, "noplainemail"))
78 ctx.cfg.noplainemail = atoi(value); 80 ctx.cfg.noplainemail = atoi(value);
79 else if (!strcmp(name, "noheader")) 81 else if (!strcmp(name, "noheader"))
80 ctx.cfg.noheader = atoi(value); 82 ctx.cfg.noheader = atoi(value);
81 else if (!strcmp(name, "snapshots")) 83 else if (!strcmp(name, "snapshots"))
82 ctx.cfg.snapshots = cgit_parse_snapshots_mask(value); 84 ctx.cfg.snapshots = cgit_parse_snapshots_mask(value);
83 else if (!strcmp(name, "enable-index-links")) 85 else if (!strcmp(name, "enable-index-links"))
84 ctx.cfg.enable_index_links = atoi(value); 86 ctx.cfg.enable_index_links = atoi(value);
85 else if (!strcmp(name, "enable-log-filecount")) 87 else if (!strcmp(name, "enable-log-filecount"))
86 ctx.cfg.enable_log_filecount = atoi(value); 88 ctx.cfg.enable_log_filecount = atoi(value);
87 else if (!strcmp(name, "enable-log-linecount")) 89 else if (!strcmp(name, "enable-log-linecount"))
88 ctx.cfg.enable_log_linecount = atoi(value); 90 ctx.cfg.enable_log_linecount = atoi(value);
89 else if (!strcmp(name, "max-stats")) 91 else if (!strcmp(name, "max-stats"))
90 ctx.cfg.max_stats = cgit_find_stats_period(value, NULL); 92 ctx.cfg.max_stats = cgit_find_stats_period(value, NULL);
91 else if (!strcmp(name, "cache-size")) 93 else if (!strcmp(name, "cache-size"))
92 ctx.cfg.cache_size = atoi(value); 94 ctx.cfg.cache_size = atoi(value);
93 else if (!strcmp(name, "cache-root")) 95 else if (!strcmp(name, "cache-root"))
94 ctx.cfg.cache_root = xstrdup(value); 96 ctx.cfg.cache_root = xstrdup(value);
95 else if (!strcmp(name, "cache-root-ttl")) 97 else if (!strcmp(name, "cache-root-ttl"))
96 ctx.cfg.cache_root_ttl = atoi(value); 98 ctx.cfg.cache_root_ttl = atoi(value);
97 else if (!strcmp(name, "cache-repo-ttl")) 99 else if (!strcmp(name, "cache-repo-ttl"))
98 ctx.cfg.cache_repo_ttl = atoi(value); 100 ctx.cfg.cache_repo_ttl = atoi(value);
101 else if (!strcmp(name, "cache-scanrc-ttl"))
102 ctx.cfg.cache_scanrc_ttl = atoi(value);
99 else if (!strcmp(name, "cache-static-ttl")) 103 else if (!strcmp(name, "cache-static-ttl"))
100 ctx.cfg.cache_static_ttl = atoi(value); 104 ctx.cfg.cache_static_ttl = atoi(value);
101 else if (!strcmp(name, "cache-dynamic-ttl")) 105 else if (!strcmp(name, "cache-dynamic-ttl"))
102 ctx.cfg.cache_dynamic_ttl = atoi(value); 106 ctx.cfg.cache_dynamic_ttl = atoi(value);
103 else if (!strcmp(name, "about-filter")) 107 else if (!strcmp(name, "about-filter"))
104 ctx.cfg.about_filter = new_filter(value, 0); 108 ctx.cfg.about_filter = new_filter(value, 0);
105 else if (!strcmp(name, "commit-filter")) 109 else if (!strcmp(name, "commit-filter"))
106 ctx.cfg.commit_filter = new_filter(value, 0); 110 ctx.cfg.commit_filter = new_filter(value, 0);
107 else if (!strcmp(name, "embedded")) 111 else if (!strcmp(name, "embedded"))
108 ctx.cfg.embedded = atoi(value); 112 ctx.cfg.embedded = atoi(value);
109 else if (!strcmp(name, "max-message-length")) 113 else if (!strcmp(name, "max-message-length"))
110 ctx.cfg.max_msg_len = atoi(value); 114 ctx.cfg.max_msg_len = atoi(value);
111 else if (!strcmp(name, "max-repodesc-length")) 115 else if (!strcmp(name, "max-repodesc-length"))
112 ctx.cfg.max_repodesc_len = atoi(value); 116 ctx.cfg.max_repodesc_len = atoi(value);
113 else if (!strcmp(name, "max-repo-count")) 117 else if (!strcmp(name, "max-repo-count"))
114 ctx.cfg.max_repo_count = atoi(value); 118 ctx.cfg.max_repo_count = atoi(value);
115 else if (!strcmp(name, "max-commit-count")) 119 else if (!strcmp(name, "max-commit-count"))
116 ctx.cfg.max_commit_count = atoi(value); 120 ctx.cfg.max_commit_count = atoi(value);
117 else if (!strcmp(name, "source-filter")) 121 else if (!strcmp(name, "source-filter"))
118 ctx.cfg.source_filter = new_filter(value, 1); 122 ctx.cfg.source_filter = new_filter(value, 1);
119 else if (!strcmp(name, "summary-log")) 123 else if (!strcmp(name, "summary-log"))
120 ctx.cfg.summary_log = atoi(value); 124 ctx.cfg.summary_log = atoi(value);
121 else if (!strcmp(name, "summary-branches")) 125 else if (!strcmp(name, "summary-branches"))
122 ctx.cfg.summary_branches = atoi(value); 126 ctx.cfg.summary_branches = atoi(value);
123 else if (!strcmp(name, "summary-tags")) 127 else if (!strcmp(name, "summary-tags"))
124 ctx.cfg.summary_tags = atoi(value); 128 ctx.cfg.summary_tags = atoi(value);
125 else if (!strcmp(name, "agefile")) 129 else if (!strcmp(name, "agefile"))
126 ctx.cfg.agefile = xstrdup(value); 130 ctx.cfg.agefile = xstrdup(value);
127 else if (!strcmp(name, "renamelimit")) 131 else if (!strcmp(name, "renamelimit"))
128 ctx.cfg.renamelimit = atoi(value); 132 ctx.cfg.renamelimit = atoi(value);
129 else if (!strcmp(name, "robots")) 133 else if (!strcmp(name, "robots"))
130 ctx.cfg.robots = xstrdup(value); 134 ctx.cfg.robots = xstrdup(value);
131 else if (!strcmp(name, "clone-prefix")) 135 else if (!strcmp(name, "clone-prefix"))
132 ctx.cfg.clone_prefix = xstrdup(value); 136 ctx.cfg.clone_prefix = xstrdup(value);
133 else if (!strcmp(name, "local-time")) 137 else if (!strcmp(name, "local-time"))
134 ctx.cfg.local_time = atoi(value); 138 ctx.cfg.local_time = atoi(value);
135 else if (!prefixcmp(name, "mimetype.")) 139 else if (!prefixcmp(name, "mimetype."))
136 add_mimetype(name + 9, value); 140 add_mimetype(name + 9, value);
137 else if (!strcmp(name, "repo.group")) 141 else if (!strcmp(name, "repo.group"))
138 ctx.cfg.repo_group = xstrdup(value); 142 ctx.cfg.repo_group = xstrdup(value);
139 else if (!strcmp(name, "repo.scan")) 143 else if (!strcmp(name, "repo.scan"))
140 scan_tree(value); 144 if (!ctx.cfg.nocache && ctx.cfg.cache_size)
145 process_cached_repolist(value);
146 else
147 scan_tree(value);
141 else if (!strcmp(name, "repo.url")) 148 else if (!strcmp(name, "repo.url"))
142 ctx.repo = cgit_add_repo(value); 149 ctx.repo = cgit_add_repo(value);
143 else if (!strcmp(name, "repo.name")) 150 else if (!strcmp(name, "repo.name"))
144 ctx.repo->name = xstrdup(value); 151 ctx.repo->name = xstrdup(value);
145 else if (ctx.repo && !strcmp(name, "repo.path")) 152 else if (ctx.repo && !strcmp(name, "repo.path"))
146 ctx.repo->path = trim_end(value, '/'); 153 ctx.repo->path = trim_end(value, '/');
147 else if (ctx.repo && !strcmp(name, "repo.clone-url")) 154 else if (ctx.repo && !strcmp(name, "repo.clone-url"))
148 ctx.repo->clone_url = xstrdup(value); 155 ctx.repo->clone_url = xstrdup(value);
149 else if (ctx.repo && !strcmp(name, "repo.desc")) 156 else if (ctx.repo && !strcmp(name, "repo.desc"))
150 ctx.repo->desc = xstrdup(value); 157 ctx.repo->desc = xstrdup(value);
151 else if (ctx.repo && !strcmp(name, "repo.owner")) 158 else if (ctx.repo && !strcmp(name, "repo.owner"))
152 ctx.repo->owner = xstrdup(value); 159 ctx.repo->owner = xstrdup(value);
153 else if (ctx.repo && !strcmp(name, "repo.defbranch")) 160 else if (ctx.repo && !strcmp(name, "repo.defbranch"))
154 ctx.repo->defbranch = xstrdup(value); 161 ctx.repo->defbranch = xstrdup(value);
155 else if (ctx.repo && !strcmp(name, "repo.snapshots")) 162 else if (ctx.repo && !strcmp(name, "repo.snapshots"))
156 ctx.repo->snapshots = ctx.cfg.snapshots & cgit_parse_snapshots_mask(value); /* XXX: &? */ 163 ctx.repo->snapshots = ctx.cfg.snapshots & cgit_parse_snapshots_mask(value); /* XXX: &? */
157 else if (ctx.repo && !strcmp(name, "repo.enable-log-filecount")) 164 else if (ctx.repo && !strcmp(name, "repo.enable-log-filecount"))
158 ctx.repo->enable_log_filecount = ctx.cfg.enable_log_filecount * atoi(value); 165 ctx.repo->enable_log_filecount = ctx.cfg.enable_log_filecount * atoi(value);
159 else if (ctx.repo && !strcmp(name, "repo.enable-log-linecount")) 166 else if (ctx.repo && !strcmp(name, "repo.enable-log-linecount"))
160 ctx.repo->enable_log_linecount = ctx.cfg.enable_log_linecount * atoi(value); 167 ctx.repo->enable_log_linecount = ctx.cfg.enable_log_linecount * atoi(value);
161 else if (ctx.repo && !strcmp(name, "repo.max-stats")) 168 else if (ctx.repo && !strcmp(name, "repo.max-stats"))
162 ctx.repo->max_stats = cgit_find_stats_period(value, NULL); 169 ctx.repo->max_stats = cgit_find_stats_period(value, NULL);
163 else if (ctx.repo && !strcmp(name, "repo.module-link")) 170 else if (ctx.repo && !strcmp(name, "repo.module-link"))
164 ctx.repo->module_link= xstrdup(value); 171 ctx.repo->module_link= xstrdup(value);
165 else if (ctx.repo && !strcmp(name, "repo.about-filter")) 172 else if (ctx.repo && !strcmp(name, "repo.about-filter"))
166 ctx.repo->about_filter = new_filter(value, 0); 173 ctx.repo->about_filter = new_filter(value, 0);
167 else if (ctx.repo && !strcmp(name, "repo.commit-filter")) 174 else if (ctx.repo && !strcmp(name, "repo.commit-filter"))
168 ctx.repo->commit_filter = new_filter(value, 0); 175 ctx.repo->commit_filter = new_filter(value, 0);
169 else if (ctx.repo && !strcmp(name, "repo.source-filter")) 176 else if (ctx.repo && !strcmp(name, "repo.source-filter"))
170 ctx.repo->source_filter = new_filter(value, 1); 177 ctx.repo->source_filter = new_filter(value, 1);
171 else if (ctx.repo && !strcmp(name, "repo.readme") && value != NULL) { 178 else if (ctx.repo && !strcmp(name, "repo.readme") && value != NULL) {
172 if (*value == '/') 179 if (*value == '/')
173 ctx.repo->readme = xstrdup(value); 180 ctx.repo->readme = xstrdup(value);
174 else 181 else
175 ctx.repo->readme = xstrdup(fmt("%s/%s", ctx.repo->path, value)); 182 ctx.repo->readme = xstrdup(fmt("%s/%s", ctx.repo->path, value));
176 } else if (!strcmp(name, "include")) 183 } else if (!strcmp(name, "include"))
177 parse_configfile(value, config_cb); 184 parse_configfile(value, config_cb);
178} 185}
179 186
180static void querystring_cb(const char *name, const char *value) 187static void querystring_cb(const char *name, const char *value)
181{ 188{
182 if (!value) 189 if (!value)
183 value = ""; 190 value = "";
184 191
185 if (!strcmp(name,"r")) { 192 if (!strcmp(name,"r")) {
186 ctx.qry.repo = xstrdup(value); 193 ctx.qry.repo = xstrdup(value);
187 ctx.repo = cgit_get_repoinfo(value); 194 ctx.repo = cgit_get_repoinfo(value);
188 } else if (!strcmp(name, "p")) { 195 } else if (!strcmp(name, "p")) {
189 ctx.qry.page = xstrdup(value); 196 ctx.qry.page = xstrdup(value);
190 } else if (!strcmp(name, "url")) { 197 } else if (!strcmp(name, "url")) {
191 ctx.qry.url = xstrdup(value); 198 ctx.qry.url = xstrdup(value);
192 cgit_parse_url(value); 199 cgit_parse_url(value);
193 } else if (!strcmp(name, "qt")) { 200 } else if (!strcmp(name, "qt")) {
194 ctx.qry.grep = xstrdup(value); 201 ctx.qry.grep = xstrdup(value);
195 } else if (!strcmp(name, "q")) { 202 } else if (!strcmp(name, "q")) {
196 ctx.qry.search = xstrdup(value); 203 ctx.qry.search = xstrdup(value);
197 } else if (!strcmp(name, "h")) { 204 } else if (!strcmp(name, "h")) {
198 ctx.qry.head = xstrdup(value); 205 ctx.qry.head = xstrdup(value);
199 ctx.qry.has_symref = 1; 206 ctx.qry.has_symref = 1;
200 } else if (!strcmp(name, "id")) { 207 } else if (!strcmp(name, "id")) {
201 ctx.qry.sha1 = xstrdup(value); 208 ctx.qry.sha1 = xstrdup(value);
202 ctx.qry.has_sha1 = 1; 209 ctx.qry.has_sha1 = 1;
203 } else if (!strcmp(name, "id2")) { 210 } else if (!strcmp(name, "id2")) {
204 ctx.qry.sha2 = xstrdup(value); 211 ctx.qry.sha2 = xstrdup(value);
205 ctx.qry.has_sha1 = 1; 212 ctx.qry.has_sha1 = 1;
206 } else if (!strcmp(name, "ofs")) { 213 } else if (!strcmp(name, "ofs")) {
207 ctx.qry.ofs = atoi(value); 214 ctx.qry.ofs = atoi(value);
208 } else if (!strcmp(name, "path")) { 215 } else if (!strcmp(name, "path")) {
209 ctx.qry.path = trim_end(value, '/'); 216 ctx.qry.path = trim_end(value, '/');
210 } else if (!strcmp(name, "name")) { 217 } else if (!strcmp(name, "name")) {
211 ctx.qry.name = xstrdup(value); 218 ctx.qry.name = xstrdup(value);
212 } else if (!strcmp(name, "mimetype")) { 219 } else if (!strcmp(name, "mimetype")) {
213 ctx.qry.mimetype = xstrdup(value); 220 ctx.qry.mimetype = xstrdup(value);
214 } else if (!strcmp(name, "s")){ 221 } else if (!strcmp(name, "s")){
215 ctx.qry.sort = xstrdup(value); 222 ctx.qry.sort = xstrdup(value);
216 } else if (!strcmp(name, "showmsg")) { 223 } else if (!strcmp(name, "showmsg")) {
217 ctx.qry.showmsg = atoi(value); 224 ctx.qry.showmsg = atoi(value);
218 } else if (!strcmp(name, "period")) { 225 } else if (!strcmp(name, "period")) {
219 ctx.qry.period = xstrdup(value); 226 ctx.qry.period = xstrdup(value);
220 } 227 }
221} 228}
222 229
223char *xstrdupn(const char *str) 230char *xstrdupn(const char *str)
224{ 231{
225 return (str ? xstrdup(str) : NULL); 232 return (str ? xstrdup(str) : NULL);
226} 233}
227 234
228static void prepare_context(struct cgit_context *ctx) 235static void prepare_context(struct cgit_context *ctx)
229{ 236{
230 memset(ctx, 0, sizeof(ctx)); 237 memset(ctx, 0, sizeof(ctx));
231 ctx->cfg.agefile = "info/web/last-modified"; 238 ctx->cfg.agefile = "info/web/last-modified";
232 ctx->cfg.nocache = 0; 239 ctx->cfg.nocache = 0;
233 ctx->cfg.cache_size = 0; 240 ctx->cfg.cache_size = 0;
234 ctx->cfg.cache_dynamic_ttl = 5; 241 ctx->cfg.cache_dynamic_ttl = 5;
235 ctx->cfg.cache_max_create_time = 5; 242 ctx->cfg.cache_max_create_time = 5;
236 ctx->cfg.cache_repo_ttl = 5; 243 ctx->cfg.cache_repo_ttl = 5;
237 ctx->cfg.cache_root = CGIT_CACHE_ROOT; 244 ctx->cfg.cache_root = CGIT_CACHE_ROOT;
238 ctx->cfg.cache_root_ttl = 5; 245 ctx->cfg.cache_root_ttl = 5;
246 ctx->cfg.cache_scanrc_ttl = 15;
239 ctx->cfg.cache_static_ttl = -1; 247 ctx->cfg.cache_static_ttl = -1;
240 ctx->cfg.css = "/cgit.css"; 248 ctx->cfg.css = "/cgit.css";
241 ctx->cfg.logo = "/cgit.png"; 249 ctx->cfg.logo = "/cgit.png";
242 ctx->cfg.local_time = 0; 250 ctx->cfg.local_time = 0;
243 ctx->cfg.max_repo_count = 50; 251 ctx->cfg.max_repo_count = 50;
244 ctx->cfg.max_commit_count = 50; 252 ctx->cfg.max_commit_count = 50;
245 ctx->cfg.max_lock_attempts = 5; 253 ctx->cfg.max_lock_attempts = 5;
246 ctx->cfg.max_msg_len = 80; 254 ctx->cfg.max_msg_len = 80;
247 ctx->cfg.max_repodesc_len = 80; 255 ctx->cfg.max_repodesc_len = 80;
248 ctx->cfg.max_stats = 0; 256 ctx->cfg.max_stats = 0;
249 ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s"; 257 ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s";
250 ctx->cfg.renamelimit = -1; 258 ctx->cfg.renamelimit = -1;
251 ctx->cfg.robots = "index, nofollow"; 259 ctx->cfg.robots = "index, nofollow";
252 ctx->cfg.root_title = "Git repository browser"; 260 ctx->cfg.root_title = "Git repository browser";
253 ctx->cfg.root_desc = "a fast webinterface for the git dscm"; 261 ctx->cfg.root_desc = "a fast webinterface for the git dscm";
254 ctx->cfg.script_name = CGIT_SCRIPT_NAME; 262 ctx->cfg.script_name = CGIT_SCRIPT_NAME;
255 ctx->cfg.summary_branches = 10; 263 ctx->cfg.summary_branches = 10;
256 ctx->cfg.summary_log = 10; 264 ctx->cfg.summary_log = 10;
257 ctx->cfg.summary_tags = 10; 265 ctx->cfg.summary_tags = 10;
258 ctx->env.cgit_config = xstrdupn(getenv("CGIT_CONFIG")); 266 ctx->env.cgit_config = xstrdupn(getenv("CGIT_CONFIG"));
259 ctx->env.http_host = xstrdupn(getenv("HTTP_HOST")); 267 ctx->env.http_host = xstrdupn(getenv("HTTP_HOST"));
260 ctx->env.https = xstrdupn(getenv("HTTPS")); 268 ctx->env.https = xstrdupn(getenv("HTTPS"));
261 ctx->env.no_http = xstrdupn(getenv("NO_HTTP")); 269 ctx->env.no_http = xstrdupn(getenv("NO_HTTP"));
262 ctx->env.path_info = xstrdupn(getenv("PATH_INFO")); 270 ctx->env.path_info = xstrdupn(getenv("PATH_INFO"));
263 ctx->env.query_string = xstrdupn(getenv("QUERY_STRING")); 271 ctx->env.query_string = xstrdupn(getenv("QUERY_STRING"));
264 ctx->env.request_method = xstrdupn(getenv("REQUEST_METHOD")); 272 ctx->env.request_method = xstrdupn(getenv("REQUEST_METHOD"));
265 ctx->env.script_name = xstrdupn(getenv("SCRIPT_NAME")); 273 ctx->env.script_name = xstrdupn(getenv("SCRIPT_NAME"));
266 ctx->env.server_name = xstrdupn(getenv("SERVER_NAME")); 274 ctx->env.server_name = xstrdupn(getenv("SERVER_NAME"));
267 ctx->env.server_port = xstrdupn(getenv("SERVER_PORT")); 275 ctx->env.server_port = xstrdupn(getenv("SERVER_PORT"));
268 ctx->page.mimetype = "text/html"; 276 ctx->page.mimetype = "text/html";
269 ctx->page.charset = PAGE_ENCODING; 277 ctx->page.charset = PAGE_ENCODING;
270 ctx->page.filename = NULL; 278 ctx->page.filename = NULL;
271 ctx->page.size = 0; 279 ctx->page.size = 0;
272 ctx->page.modified = time(NULL); 280 ctx->page.modified = time(NULL);
273 ctx->page.expires = ctx->page.modified; 281 ctx->page.expires = ctx->page.modified;
274 ctx->page.etag = NULL; 282 ctx->page.etag = NULL;
275 memset(&ctx->cfg.mimetypes, 0, sizeof(struct string_list)); 283 memset(&ctx->cfg.mimetypes, 0, sizeof(struct string_list));
276 if (ctx->env.script_name) 284 if (ctx->env.script_name)
277 ctx->cfg.script_name = ctx->env.script_name; 285 ctx->cfg.script_name = ctx->env.script_name;
278 if (ctx->env.query_string) 286 if (ctx->env.query_string)
279 ctx->qry.raw = ctx->env.query_string; 287 ctx->qry.raw = ctx->env.query_string;
280 if (!ctx->env.cgit_config) 288 if (!ctx->env.cgit_config)
281 ctx->env.cgit_config = CGIT_CONFIG; 289 ctx->env.cgit_config = CGIT_CONFIG;
282} 290}
283 291
284struct refmatch { 292struct refmatch {
285 char *req_ref; 293 char *req_ref;
286 char *first_ref; 294 char *first_ref;
287 int match; 295 int match;
288}; 296};
289 297
290int find_current_ref(const char *refname, const unsigned char *sha1, 298int find_current_ref(const char *refname, const unsigned char *sha1,
291 int flags, void *cb_data) 299 int flags, void *cb_data)
292{ 300{
293 struct refmatch *info; 301 struct refmatch *info;
294 302
295 info = (struct refmatch *)cb_data; 303 info = (struct refmatch *)cb_data;
296 if (!strcmp(refname, info->req_ref)) 304 if (!strcmp(refname, info->req_ref))
297 info->match = 1; 305 info->match = 1;
298 if (!info->first_ref) 306 if (!info->first_ref)
299 info->first_ref = xstrdup(refname); 307 info->first_ref = xstrdup(refname);
300 return info->match; 308 return info->match;
301} 309}
302 310
303char *find_default_branch(struct cgit_repo *repo) 311char *find_default_branch(struct cgit_repo *repo)
304{ 312{
305 struct refmatch info; 313 struct refmatch info;
306 char *ref; 314 char *ref;
307 315
308 info.req_ref = repo->defbranch; 316 info.req_ref = repo->defbranch;
309 info.first_ref = NULL; 317 info.first_ref = NULL;
310 info.match = 0; 318 info.match = 0;
311 for_each_branch_ref(find_current_ref, &info); 319 for_each_branch_ref(find_current_ref, &info);
312 if (info.match) 320 if (info.match)
313 ref = info.req_ref; 321 ref = info.req_ref;
314 else 322 else
315 ref = info.first_ref; 323 ref = info.first_ref;
316 if (ref) 324 if (ref)
317 ref = xstrdup(ref); 325 ref = xstrdup(ref);
318 return ref; 326 return ref;
319} 327}
320 328
321static int prepare_repo_cmd(struct cgit_context *ctx) 329static int prepare_repo_cmd(struct cgit_context *ctx)
322{ 330{
323 char *tmp; 331 char *tmp;
324 unsigned char sha1[20]; 332 unsigned char sha1[20];
325 int nongit = 0; 333 int nongit = 0;
326 334
327 setenv("GIT_DIR", ctx->repo->path, 1); 335 setenv("GIT_DIR", ctx->repo->path, 1);
328 setup_git_directory_gently(&nongit); 336 setup_git_directory_gently(&nongit);
329 if (nongit) { 337 if (nongit) {
330 ctx->page.title = fmt("%s - %s", ctx->cfg.root_title, 338 ctx->page.title = fmt("%s - %s", ctx->cfg.root_title,
331 "config error"); 339 "config error");
332 tmp = fmt("Not a git repository: '%s'", ctx->repo->path); 340 tmp = fmt("Not a git repository: '%s'", ctx->repo->path);
333 ctx->repo = NULL; 341 ctx->repo = NULL;
334 cgit_print_http_headers(ctx); 342 cgit_print_http_headers(ctx);
335 cgit_print_docstart(ctx); 343 cgit_print_docstart(ctx);
336 cgit_print_pageheader(ctx); 344 cgit_print_pageheader(ctx);
337 cgit_print_error(tmp); 345 cgit_print_error(tmp);
338 cgit_print_docend(); 346 cgit_print_docend();
339 return 1; 347 return 1;
340 } 348 }
341 ctx->page.title = fmt("%s - %s", ctx->repo->name, ctx->repo->desc); 349 ctx->page.title = fmt("%s - %s", ctx->repo->name, ctx->repo->desc);
342 350
343 if (!ctx->qry.head) { 351 if (!ctx->qry.head) {
344 ctx->qry.nohead = 1; 352 ctx->qry.nohead = 1;
345 ctx->qry.head = find_default_branch(ctx->repo); 353 ctx->qry.head = find_default_branch(ctx->repo);
346 ctx->repo->defbranch = ctx->qry.head; 354 ctx->repo->defbranch = ctx->qry.head;
347 } 355 }
348 356
349 if (!ctx->qry.head) { 357 if (!ctx->qry.head) {
350 cgit_print_http_headers(ctx); 358 cgit_print_http_headers(ctx);
351 cgit_print_docstart(ctx); 359 cgit_print_docstart(ctx);
352 cgit_print_pageheader(ctx); 360 cgit_print_pageheader(ctx);
353 cgit_print_error("Repository seems to be empty"); 361 cgit_print_error("Repository seems to be empty");
354 cgit_print_docend(); 362 cgit_print_docend();
355 return 1; 363 return 1;
356 } 364 }
357 365
358 if (get_sha1(ctx->qry.head, sha1)) { 366 if (get_sha1(ctx->qry.head, sha1)) {
359 tmp = xstrdup(ctx->qry.head); 367 tmp = xstrdup(ctx->qry.head);
360 ctx->qry.head = ctx->repo->defbranch; 368 ctx->qry.head = ctx->repo->defbranch;
361 ctx->page.status = 404; 369 ctx->page.status = 404;
362 ctx->page.statusmsg = "not found"; 370 ctx->page.statusmsg = "not found";
363 cgit_print_http_headers(ctx); 371 cgit_print_http_headers(ctx);
364 cgit_print_docstart(ctx); 372 cgit_print_docstart(ctx);
365 cgit_print_pageheader(ctx); 373 cgit_print_pageheader(ctx);
366 cgit_print_error(fmt("Invalid branch: %s", tmp)); 374 cgit_print_error(fmt("Invalid branch: %s", tmp));
367 cgit_print_docend(); 375 cgit_print_docend();
368 return 1; 376 return 1;
369 } 377 }
370 return 0; 378 return 0;
371} 379}
372 380
373static void process_request(void *cbdata) 381static void process_request(void *cbdata)
374{ 382{
375 struct cgit_context *ctx = cbdata; 383 struct cgit_context *ctx = cbdata;
376 struct cgit_cmd *cmd; 384 struct cgit_cmd *cmd;
377 385
378 cmd = cgit_get_cmd(ctx); 386 cmd = cgit_get_cmd(ctx);
379 if (!cmd) { 387 if (!cmd) {
380 ctx->page.title = "cgit error"; 388 ctx->page.title = "cgit error";
381 cgit_print_http_headers(ctx); 389 cgit_print_http_headers(ctx);
382 cgit_print_docstart(ctx); 390 cgit_print_docstart(ctx);
383 cgit_print_pageheader(ctx); 391 cgit_print_pageheader(ctx);
384 cgit_print_error("Invalid request"); 392 cgit_print_error("Invalid request");
385 cgit_print_docend(); 393 cgit_print_docend();
386 return; 394 return;
387 } 395 }
388 396
389 if (cmd->want_repo && !ctx->repo) { 397 if (cmd->want_repo && !ctx->repo) {
390 cgit_print_http_headers(ctx); 398 cgit_print_http_headers(ctx);
391 cgit_print_docstart(ctx); 399 cgit_print_docstart(ctx);
392 cgit_print_pageheader(ctx); 400 cgit_print_pageheader(ctx);
393 cgit_print_error(fmt("No repository selected")); 401 cgit_print_error(fmt("No repository selected"));
394 cgit_print_docend(); 402 cgit_print_docend();
395 return; 403 return;
396 } 404 }
397 405
398 if (ctx->repo && prepare_repo_cmd(ctx)) 406 if (ctx->repo && prepare_repo_cmd(ctx))
399 return; 407 return;
400 408
401 if (cmd->want_layout) { 409 if (cmd->want_layout) {
402 cgit_print_http_headers(ctx); 410 cgit_print_http_headers(ctx);
403 cgit_print_docstart(ctx); 411 cgit_print_docstart(ctx);
404 cgit_print_pageheader(ctx); 412 cgit_print_pageheader(ctx);
405 } 413 }
406 414
407 cmd->fn(ctx); 415 cmd->fn(ctx);
408 416
409 if (cmd->want_layout) 417 if (cmd->want_layout)
410 cgit_print_docend(); 418 cgit_print_docend();
411} 419}
412 420
413int cmp_repos(const void *a, const void *b) 421int cmp_repos(const void *a, const void *b)
414{ 422{
415 const struct cgit_repo *ra = a, *rb = b; 423 const struct cgit_repo *ra = a, *rb = b;
416 return strcmp(ra->url, rb->url); 424 return strcmp(ra->url, rb->url);
417} 425}
418 426
419void print_repo(FILE *f, struct cgit_repo *repo) 427void print_repo(FILE *f, struct cgit_repo *repo)
420{ 428{
421 fprintf(f, "repo.url=%s\n", repo->url); 429 fprintf(f, "repo.url=%s\n", repo->url);
422 fprintf(f, "repo.name=%s\n", repo->name); 430 fprintf(f, "repo.name=%s\n", repo->name);
423 fprintf(f, "repo.path=%s\n", repo->path); 431 fprintf(f, "repo.path=%s\n", repo->path);
424 if (repo->owner) 432 if (repo->owner)
425 fprintf(f, "repo.owner=%s\n", repo->owner); 433 fprintf(f, "repo.owner=%s\n", repo->owner);
426 if (repo->desc) 434 if (repo->desc)
427 fprintf(f, "repo.desc=%s\n", repo->desc); 435 fprintf(f, "repo.desc=%s\n", repo->desc);
428 if (repo->readme) 436 if (repo->readme)
429 fprintf(f, "repo.readme=%s\n", repo->readme); 437 fprintf(f, "repo.readme=%s\n", repo->readme);
430 fprintf(f, "\n"); 438 fprintf(f, "\n");
431} 439}
432 440
433void print_repolist(FILE *f, struct cgit_repolist *list, int start) 441void print_repolist(FILE *f, struct cgit_repolist *list, int start)
434{ 442{
435 int i; 443 int i;
436 444
437 for(i = start; i < list->count; i++) 445 for(i = start; i < list->count; i++)
438 print_repo(f, &list->repos[i]); 446 print_repo(f, &list->repos[i]);
439} 447}
440 448
449/* Scan 'path' for git repositories, save the resulting repolist in 'cached_rc'
450 * and return 0 on success.
451 */
452static int generate_cached_repolist(const char *path, const char *cached_rc)
453{
454 char *locked_rc;
455 int idx;
456 FILE *f;
457
458 locked_rc = xstrdup(fmt("%s.lock", cached_rc));
459 f = fopen(locked_rc, "wx");
460 if (!f) {
461 /* Inform about the error unless the lockfile already existed,
462 * since that only means we've got concurrent requests.
463 */
464 if (errno != EEXIST)
465 fprintf(stderr, "[cgit] Error opening %s: %s (%d)\n",
466 locked_rc, strerror(errno), errno);
467 return errno;
468 }
469 idx = cgit_repolist.count;
470 scan_tree(path);
471 print_repolist(f, &cgit_repolist, idx);
472 if (rename(locked_rc, cached_rc))
473 fprintf(stderr, "[cgit] Error renaming %s to %s: %s (%d)\n",
474 locked_rc, cached_rc, strerror(errno), errno);
475 fclose(f);
476 return 0;
477}
478
479static void process_cached_repolist(const char *path)
480{
481 struct stat st;
482 char *cached_rc;
483 time_t age;
484
485 cached_rc = xstrdup(fmt("%s/rc-%8x", ctx.cfg.cache_root,
486 hash_str(path)));
487
488 if (stat(cached_rc, &st)) {
489 /* Nothing is cached, we need to scan without forking. And
490 * if we fail to generate a cached repolist, we need to
491 * invoke scan_tree manually.
492 */
493 if (generate_cached_repolist(path, cached_rc))
494 scan_tree(path);
495 return;
496 }
497
498 parse_configfile(cached_rc, config_cb);
499
500 /* If the cached configfile hasn't expired, lets exit now */
501 age = time(NULL) - st.st_mtime;
502 if (age <= (ctx.cfg.cache_scanrc_ttl * 60))
503 return;
504
505 /* The cached repolist has been parsed, but it was old. So lets
506 * rescan the specified path and generate a new cached repolist
507 * in a child-process to avoid latency for the current request.
508 */
509 if (fork())
510 return;
511
512 exit(generate_cached_repolist(path, cached_rc));
513}
441 514
442static void cgit_parse_args(int argc, const char **argv) 515static void cgit_parse_args(int argc, const char **argv)
443{ 516{
444 int i; 517 int i;
445 int scan = 0; 518 int scan = 0;
446 519
447 for (i = 1; i < argc; i++) { 520 for (i = 1; i < argc; i++) {
448 if (!strncmp(argv[i], "--cache=", 8)) { 521 if (!strncmp(argv[i], "--cache=", 8)) {
449 ctx.cfg.cache_root = xstrdup(argv[i]+8); 522 ctx.cfg.cache_root = xstrdup(argv[i]+8);
450 } 523 }
451 if (!strcmp(argv[i], "--nocache")) { 524 if (!strcmp(argv[i], "--nocache")) {
452 ctx.cfg.nocache = 1; 525 ctx.cfg.nocache = 1;
453 } 526 }
454 if (!strcmp(argv[i], "--nohttp")) { 527 if (!strcmp(argv[i], "--nohttp")) {
455 ctx.env.no_http = "1"; 528 ctx.env.no_http = "1";
456 } 529 }
457 if (!strncmp(argv[i], "--query=", 8)) { 530 if (!strncmp(argv[i], "--query=", 8)) {
458 ctx.qry.raw = xstrdup(argv[i]+8); 531 ctx.qry.raw = xstrdup(argv[i]+8);
459 } 532 }
460 if (!strncmp(argv[i], "--repo=", 7)) { 533 if (!strncmp(argv[i], "--repo=", 7)) {
461 ctx.qry.repo = xstrdup(argv[i]+7); 534 ctx.qry.repo = xstrdup(argv[i]+7);
462 } 535 }
463 if (!strncmp(argv[i], "--page=", 7)) { 536 if (!strncmp(argv[i], "--page=", 7)) {
464 ctx.qry.page = xstrdup(argv[i]+7); 537 ctx.qry.page = xstrdup(argv[i]+7);
465 } 538 }
466 if (!strncmp(argv[i], "--head=", 7)) { 539 if (!strncmp(argv[i], "--head=", 7)) {
467 ctx.qry.head = xstrdup(argv[i]+7); 540 ctx.qry.head = xstrdup(argv[i]+7);
468 ctx.qry.has_symref = 1; 541 ctx.qry.has_symref = 1;
469 } 542 }
470 if (!strncmp(argv[i], "--sha1=", 7)) { 543 if (!strncmp(argv[i], "--sha1=", 7)) {
471 ctx.qry.sha1 = xstrdup(argv[i]+7); 544 ctx.qry.sha1 = xstrdup(argv[i]+7);
472 ctx.qry.has_sha1 = 1; 545 ctx.qry.has_sha1 = 1;
473 } 546 }
474 if (!strncmp(argv[i], "--ofs=", 6)) { 547 if (!strncmp(argv[i], "--ofs=", 6)) {
475 ctx.qry.ofs = atoi(argv[i]+6); 548 ctx.qry.ofs = atoi(argv[i]+6);
476 } 549 }
477 if (!strncmp(argv[i], "--scan-tree=", 12)) { 550 if (!strncmp(argv[i], "--scan-tree=", 12)) {
478 scan++; 551 scan++;
479 scan_tree(argv[i] + 12); 552 scan_tree(argv[i] + 12);
480 } 553 }
481 } 554 }
482 if (scan) { 555 if (scan) {
483 qsort(cgit_repolist.repos, cgit_repolist.count, 556 qsort(cgit_repolist.repos, cgit_repolist.count,
484 sizeof(struct cgit_repo), cmp_repos); 557 sizeof(struct cgit_repo), cmp_repos);
485 print_repolist(stdout, &cgit_repolist, 0); 558 print_repolist(stdout, &cgit_repolist, 0);
486 exit(0); 559 exit(0);
487 } 560 }
488} 561}
489 562
490static int calc_ttl() 563static int calc_ttl()
491{ 564{
492 if (!ctx.repo) 565 if (!ctx.repo)
493 return ctx.cfg.cache_root_ttl; 566 return ctx.cfg.cache_root_ttl;
494 567
495 if (!ctx.qry.page) 568 if (!ctx.qry.page)
496 return ctx.cfg.cache_repo_ttl; 569 return ctx.cfg.cache_repo_ttl;
497 570
498 if (ctx.qry.has_symref) 571 if (ctx.qry.has_symref)
499 return ctx.cfg.cache_dynamic_ttl; 572 return ctx.cfg.cache_dynamic_ttl;
500 573
501 if (ctx.qry.has_sha1) 574 if (ctx.qry.has_sha1)
502 return ctx.cfg.cache_static_ttl; 575 return ctx.cfg.cache_static_ttl;
503 576
504 return ctx.cfg.cache_repo_ttl; 577 return ctx.cfg.cache_repo_ttl;
505} 578}
506 579
507int main(int argc, const char **argv) 580int main(int argc, const char **argv)
508{ 581{
509 const char *path; 582 const char *path;
510 char *qry; 583 char *qry;
511 int err, ttl; 584 int err, ttl;
512 585
513 prepare_context(&ctx); 586 prepare_context(&ctx);
514 cgit_repolist.length = 0; 587 cgit_repolist.length = 0;
515 cgit_repolist.count = 0; 588 cgit_repolist.count = 0;
516 cgit_repolist.repos = NULL; 589 cgit_repolist.repos = NULL;
517 590
518 cgit_parse_args(argc, argv); 591 cgit_parse_args(argc, argv);
519 parse_configfile(ctx.env.cgit_config, config_cb); 592 parse_configfile(ctx.env.cgit_config, config_cb);
520 ctx.repo = NULL; 593 ctx.repo = NULL;
521 http_parse_querystring(ctx.qry.raw, querystring_cb); 594 http_parse_querystring(ctx.qry.raw, querystring_cb);
522 595
523 /* If virtual-root isn't specified in cgitrc, lets pretend 596 /* If virtual-root isn't specified in cgitrc, lets pretend
524 * that virtual-root equals SCRIPT_NAME. 597 * that virtual-root equals SCRIPT_NAME.
525 */ 598 */
526 if (!ctx.cfg.virtual_root) 599 if (!ctx.cfg.virtual_root)
527 ctx.cfg.virtual_root = ctx.cfg.script_name; 600 ctx.cfg.virtual_root = ctx.cfg.script_name;
528 601
529 /* If no url parameter is specified on the querystring, lets 602 /* If no url parameter is specified on the querystring, lets
530 * use PATH_INFO as url. This allows cgit to work with virtual 603 * use PATH_INFO as url. This allows cgit to work with virtual
531 * urls without the need for rewriterules in the webserver (as 604 * urls without the need for rewriterules in the webserver (as
532 * long as PATH_INFO is included in the cache lookup key). 605 * long as PATH_INFO is included in the cache lookup key).
533 */ 606 */
534 path = ctx.env.path_info; 607 path = ctx.env.path_info;
535 if (!ctx.qry.url && path) { 608 if (!ctx.qry.url && path) {
536 if (path[0] == '/') 609 if (path[0] == '/')
537 path++; 610 path++;
538 ctx.qry.url = xstrdup(path); 611 ctx.qry.url = xstrdup(path);
539 if (ctx.qry.raw) { 612 if (ctx.qry.raw) {
540 qry = ctx.qry.raw; 613 qry = ctx.qry.raw;
541 ctx.qry.raw = xstrdup(fmt("%s?%s", path, qry)); 614 ctx.qry.raw = xstrdup(fmt("%s?%s", path, qry));
542 free(qry); 615 free(qry);
543 } else 616 } else
544 ctx.qry.raw = xstrdup(ctx.qry.url); 617 ctx.qry.raw = xstrdup(ctx.qry.url);
545 cgit_parse_url(ctx.qry.url); 618 cgit_parse_url(ctx.qry.url);
546 } 619 }
547 620
548 ttl = calc_ttl(); 621 ttl = calc_ttl();
549 ctx.page.expires += ttl*60; 622 ctx.page.expires += ttl*60;
550 if (ctx.env.request_method && !strcmp(ctx.env.request_method, "HEAD")) 623 if (ctx.env.request_method && !strcmp(ctx.env.request_method, "HEAD"))
551 ctx.cfg.nocache = 1; 624 ctx.cfg.nocache = 1;
552 if (ctx.cfg.nocache) 625 if (ctx.cfg.nocache)
553 ctx.cfg.cache_size = 0; 626 ctx.cfg.cache_size = 0;
554 err = cache_process(ctx.cfg.cache_size, ctx.cfg.cache_root, 627 err = cache_process(ctx.cfg.cache_size, ctx.cfg.cache_root,
555 ctx.qry.raw, ttl, process_request, &ctx); 628 ctx.qry.raw, ttl, process_request, &ctx);
556 if (err) 629 if (err)
557 cgit_print_error(fmt("Error processing page: %s (%d)", 630 cgit_print_error(fmt("Error processing page: %s (%d)",
558 strerror(err), err)); 631 strerror(err), err));
559 return err; 632 return err;
560} 633}
diff --git a/cgit.h b/cgit.h
index adb8da4..5659580 100644
--- a/cgit.h
+++ b/cgit.h
@@ -1,288 +1,289 @@
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 <string-list.h> 18#include <string-list.h>
19#include <xdiff-interface.h> 19#include <xdiff-interface.h>
20#include <xdiff/xdiff.h> 20#include <xdiff/xdiff.h>
21#include <utf8.h> 21#include <utf8.h>
22 22
23 23
24/* 24/*
25 * Dateformats used on misc. pages 25 * Dateformats used on misc. pages
26 */ 26 */
27#define FMT_LONGDATE "%Y-%m-%d %H:%M:%S (%Z)" 27#define FMT_LONGDATE "%Y-%m-%d %H:%M:%S (%Z)"
28#define FMT_SHORTDATE "%Y-%m-%d" 28#define FMT_SHORTDATE "%Y-%m-%d"
29#define FMT_ATOMDATE "%Y-%m-%dT%H:%M:%SZ" 29#define FMT_ATOMDATE "%Y-%m-%dT%H:%M:%SZ"
30 30
31 31
32/* 32/*
33 * Limits used for relative dates 33 * Limits used for relative dates
34 */ 34 */
35#define TM_MIN 60 35#define TM_MIN 60
36#define TM_HOUR (TM_MIN * 60) 36#define TM_HOUR (TM_MIN * 60)
37#define TM_DAY (TM_HOUR * 24) 37#define TM_DAY (TM_HOUR * 24)
38#define TM_WEEK (TM_DAY * 7) 38#define TM_WEEK (TM_DAY * 7)
39#define TM_YEAR (TM_DAY * 365) 39#define TM_YEAR (TM_DAY * 365)
40#define TM_MONTH (TM_YEAR / 12.0) 40#define TM_MONTH (TM_YEAR / 12.0)
41 41
42 42
43/* 43/*
44 * Default encoding 44 * Default encoding
45 */ 45 */
46#define PAGE_ENCODING "UTF-8" 46#define PAGE_ENCODING "UTF-8"
47 47
48typedef void (*configfn)(const char *name, const char *value); 48typedef void (*configfn)(const char *name, const char *value);
49typedef void (*filepair_fn)(struct diff_filepair *pair); 49typedef void (*filepair_fn)(struct diff_filepair *pair);
50typedef void (*linediff_fn)(char *line, int len); 50typedef void (*linediff_fn)(char *line, int len);
51 51
52struct cgit_filter { 52struct cgit_filter {
53 char *cmd; 53 char *cmd;
54 char **argv; 54 char **argv;
55 int old_stdout; 55 int old_stdout;
56 int pipe_fh[2]; 56 int pipe_fh[2];
57 int pid; 57 int pid;
58 int exitstatus; 58 int exitstatus;
59}; 59};
60 60
61struct cgit_repo { 61struct cgit_repo {
62 char *url; 62 char *url;
63 char *name; 63 char *name;
64 char *path; 64 char *path;
65 char *desc; 65 char *desc;
66 char *owner; 66 char *owner;
67 char *defbranch; 67 char *defbranch;
68 char *group; 68 char *group;
69 char *module_link; 69 char *module_link;
70 char *readme; 70 char *readme;
71 char *clone_url; 71 char *clone_url;
72 int snapshots; 72 int snapshots;
73 int enable_log_filecount; 73 int enable_log_filecount;
74 int enable_log_linecount; 74 int enable_log_linecount;
75 int max_stats; 75 int max_stats;
76 time_t mtime; 76 time_t mtime;
77 struct cgit_filter *about_filter; 77 struct cgit_filter *about_filter;
78 struct cgit_filter *commit_filter; 78 struct cgit_filter *commit_filter;
79 struct cgit_filter *source_filter; 79 struct cgit_filter *source_filter;
80}; 80};
81 81
82struct cgit_repolist { 82struct cgit_repolist {
83 int length; 83 int length;
84 int count; 84 int count;
85 struct cgit_repo *repos; 85 struct cgit_repo *repos;
86}; 86};
87 87
88struct commitinfo { 88struct commitinfo {
89 struct commit *commit; 89 struct commit *commit;
90 char *author; 90 char *author;
91 char *author_email; 91 char *author_email;
92 unsigned long author_date; 92 unsigned long author_date;
93 char *committer; 93 char *committer;
94 char *committer_email; 94 char *committer_email;
95 unsigned long committer_date; 95 unsigned long committer_date;
96 char *subject; 96 char *subject;
97 char *msg; 97 char *msg;
98 char *msg_encoding; 98 char *msg_encoding;
99}; 99};
100 100
101struct taginfo { 101struct taginfo {
102 char *tagger; 102 char *tagger;
103 char *tagger_email; 103 char *tagger_email;
104 unsigned long tagger_date; 104 unsigned long tagger_date;
105 char *msg; 105 char *msg;
106}; 106};
107 107
108struct refinfo { 108struct refinfo {
109 const char *refname; 109 const char *refname;
110 struct object *object; 110 struct object *object;
111 union { 111 union {
112 struct taginfo *tag; 112 struct taginfo *tag;
113 struct commitinfo *commit; 113 struct commitinfo *commit;
114 }; 114 };
115}; 115};
116 116
117struct reflist { 117struct reflist {
118 struct refinfo **refs; 118 struct refinfo **refs;
119 int alloc; 119 int alloc;
120 int count; 120 int count;
121}; 121};
122 122
123struct cgit_query { 123struct cgit_query {
124 int has_symref; 124 int has_symref;
125 int has_sha1; 125 int has_sha1;
126 char *raw; 126 char *raw;
127 char *repo; 127 char *repo;
128 char *page; 128 char *page;
129 char *search; 129 char *search;
130 char *grep; 130 char *grep;
131 char *head; 131 char *head;
132 char *sha1; 132 char *sha1;
133 char *sha2; 133 char *sha2;
134 char *path; 134 char *path;
135 char *name; 135 char *name;
136 char *mimetype; 136 char *mimetype;
137 char *url; 137 char *url;
138 char *period; 138 char *period;
139 int ofs; 139 int ofs;
140 int nohead; 140 int nohead;
141 char *sort; 141 char *sort;
142 int showmsg; 142 int showmsg;
143}; 143};
144 144
145struct cgit_config { 145struct cgit_config {
146 char *agefile; 146 char *agefile;
147 char *cache_root; 147 char *cache_root;
148 char *clone_prefix; 148 char *clone_prefix;
149 char *css; 149 char *css;
150 char *favicon; 150 char *favicon;
151 char *footer; 151 char *footer;
152 char *head_include; 152 char *head_include;
153 char *header; 153 char *header;
154 char *index_header; 154 char *index_header;
155 char *index_info; 155 char *index_info;
156 char *logo; 156 char *logo;
157 char *logo_link; 157 char *logo_link;
158 char *module_link; 158 char *module_link;
159 char *repo_group; 159 char *repo_group;
160 char *robots; 160 char *robots;
161 char *root_title; 161 char *root_title;
162 char *root_desc; 162 char *root_desc;
163 char *root_readme; 163 char *root_readme;
164 char *script_name; 164 char *script_name;
165 char *virtual_root; 165 char *virtual_root;
166 int cache_size; 166 int cache_size;
167 int cache_dynamic_ttl; 167 int cache_dynamic_ttl;
168 int cache_max_create_time; 168 int cache_max_create_time;
169 int cache_repo_ttl; 169 int cache_repo_ttl;
170 int cache_root_ttl; 170 int cache_root_ttl;
171 int cache_scanrc_ttl;
171 int cache_static_ttl; 172 int cache_static_ttl;
172 int embedded; 173 int embedded;
173 int enable_index_links; 174 int enable_index_links;
174 int enable_log_filecount; 175 int enable_log_filecount;
175 int enable_log_linecount; 176 int enable_log_linecount;
176 int local_time; 177 int local_time;
177 int max_repo_count; 178 int max_repo_count;
178 int max_commit_count; 179 int max_commit_count;
179 int max_lock_attempts; 180 int max_lock_attempts;
180 int max_msg_len; 181 int max_msg_len;
181 int max_repodesc_len; 182 int max_repodesc_len;
182 int max_stats; 183 int max_stats;
183 int nocache; 184 int nocache;
184 int noplainemail; 185 int noplainemail;
185 int noheader; 186 int noheader;
186 int renamelimit; 187 int renamelimit;
187 int snapshots; 188 int snapshots;
188 int summary_branches; 189 int summary_branches;
189 int summary_log; 190 int summary_log;
190 int summary_tags; 191 int summary_tags;
191 struct string_list mimetypes; 192 struct string_list mimetypes;
192 struct cgit_filter *about_filter; 193 struct cgit_filter *about_filter;
193 struct cgit_filter *commit_filter; 194 struct cgit_filter *commit_filter;
194 struct cgit_filter *source_filter; 195 struct cgit_filter *source_filter;
195}; 196};
196 197
197struct cgit_page { 198struct cgit_page {
198 time_t modified; 199 time_t modified;
199 time_t expires; 200 time_t expires;
200 size_t size; 201 size_t size;
201 char *mimetype; 202 char *mimetype;
202 char *charset; 203 char *charset;
203 char *filename; 204 char *filename;
204 char *etag; 205 char *etag;
205 char *title; 206 char *title;
206 int status; 207 int status;
207 char *statusmsg; 208 char *statusmsg;
208}; 209};
209 210
210struct cgit_environment { 211struct cgit_environment {
211 char *cgit_config; 212 char *cgit_config;
212 char *http_host; 213 char *http_host;
213 char *https; 214 char *https;
214 char *no_http; 215 char *no_http;
215 char *path_info; 216 char *path_info;
216 char *query_string; 217 char *query_string;
217 char *request_method; 218 char *request_method;
218 char *script_name; 219 char *script_name;
219 char *server_name; 220 char *server_name;
220 char *server_port; 221 char *server_port;
221}; 222};
222 223
223struct cgit_context { 224struct cgit_context {
224 struct cgit_environment env; 225 struct cgit_environment env;
225 struct cgit_query qry; 226 struct cgit_query qry;
226 struct cgit_config cfg; 227 struct cgit_config cfg;
227 struct cgit_repo *repo; 228 struct cgit_repo *repo;
228 struct cgit_page page; 229 struct cgit_page page;
229}; 230};
230 231
231struct cgit_snapshot_format { 232struct cgit_snapshot_format {
232 const char *suffix; 233 const char *suffix;
233 const char *mimetype; 234 const char *mimetype;
234 write_archive_fn_t write_func; 235 write_archive_fn_t write_func;
235 int bit; 236 int bit;
236}; 237};
237 238
238extern const char *cgit_version; 239extern const char *cgit_version;
239 240
240extern struct cgit_repolist cgit_repolist; 241extern struct cgit_repolist cgit_repolist;
241extern struct cgit_context ctx; 242extern struct cgit_context ctx;
242extern const struct cgit_snapshot_format cgit_snapshot_formats[]; 243extern const struct cgit_snapshot_format cgit_snapshot_formats[];
243 244
244extern struct cgit_repo *cgit_add_repo(const char *url); 245extern struct cgit_repo *cgit_add_repo(const char *url);
245extern struct cgit_repo *cgit_get_repoinfo(const char *url); 246extern struct cgit_repo *cgit_get_repoinfo(const char *url);
246extern void cgit_repo_config_cb(const char *name, const char *value); 247extern void cgit_repo_config_cb(const char *name, const char *value);
247 248
248extern int chk_zero(int result, char *msg); 249extern int chk_zero(int result, char *msg);
249extern int chk_positive(int result, char *msg); 250extern int chk_positive(int result, char *msg);
250extern int chk_non_negative(int result, char *msg); 251extern int chk_non_negative(int result, char *msg);
251 252
252extern char *trim_end(const char *str, char c); 253extern char *trim_end(const char *str, char c);
253extern char *strlpart(char *txt, int maxlen); 254extern char *strlpart(char *txt, int maxlen);
254extern char *strrpart(char *txt, int maxlen); 255extern char *strrpart(char *txt, int maxlen);
255 256
256extern void cgit_add_ref(struct reflist *list, struct refinfo *ref); 257extern void cgit_add_ref(struct reflist *list, struct refinfo *ref);
257extern int cgit_refs_cb(const char *refname, const unsigned char *sha1, 258extern int cgit_refs_cb(const char *refname, const unsigned char *sha1,
258 int flags, void *cb_data); 259 int flags, void *cb_data);
259 260
260extern void *cgit_free_commitinfo(struct commitinfo *info); 261extern void *cgit_free_commitinfo(struct commitinfo *info);
261 262
262extern int cgit_diff_files(const unsigned char *old_sha1, 263extern int cgit_diff_files(const unsigned char *old_sha1,
263 const unsigned char *new_sha1, 264 const unsigned char *new_sha1,
264 unsigned long *old_size, unsigned long *new_size, 265 unsigned long *old_size, unsigned long *new_size,
265 int *binary, linediff_fn fn); 266 int *binary, linediff_fn fn);
266 267
267extern void cgit_diff_tree(const unsigned char *old_sha1, 268extern void cgit_diff_tree(const unsigned char *old_sha1,
268 const unsigned char *new_sha1, 269 const unsigned char *new_sha1,
269 filepair_fn fn, const char *prefix); 270 filepair_fn fn, const char *prefix);
270 271
271extern void cgit_diff_commit(struct commit *commit, filepair_fn fn); 272extern void cgit_diff_commit(struct commit *commit, filepair_fn fn);
272 273
273extern char *fmt(const char *format,...); 274extern char *fmt(const char *format,...);
274 275
275extern struct commitinfo *cgit_parse_commit(struct commit *commit); 276extern struct commitinfo *cgit_parse_commit(struct commit *commit);
276extern struct taginfo *cgit_parse_tag(struct tag *tag); 277extern struct taginfo *cgit_parse_tag(struct tag *tag);
277extern void cgit_parse_url(const char *url); 278extern void cgit_parse_url(const char *url);
278 279
279extern const char *cgit_repobasename(const char *reponame); 280extern const char *cgit_repobasename(const char *reponame);
280 281
281extern int cgit_parse_snapshots_mask(const char *str); 282extern int cgit_parse_snapshots_mask(const char *str);
282 283
283extern int cgit_open_filter(struct cgit_filter *filter); 284extern int cgit_open_filter(struct cgit_filter *filter);
284extern int cgit_close_filter(struct cgit_filter *filter); 285extern int cgit_close_filter(struct cgit_filter *filter);
285 286
286extern int readfile(const char *path, char **buf, size_t *size); 287extern int readfile(const char *path, char **buf, size_t *size);
287 288
288#endif /* CGIT_H */ 289#endif /* CGIT_H */