author | Lars Hjemli <hjemli@gmail.com> | 2008-10-11 17:05:50 (UTC) |
---|---|---|
committer | Lars Hjemli <hjemli@gmail.com> | 2008-10-11 17:05:50 (UTC) |
commit | 5632ba35d133ee29d46c031cdd4b4a37097b8ca1 (patch) (unidiff) | |
tree | 6e95881e8ec6bb812a82668fd45e4ca28b8d0f97 | |
parent | cb1cc0d82d764051d8376281fcb556153f074c1a (diff) | |
download | cgit-5632ba35d133ee29d46c031cdd4b4a37097b8ca1.zip cgit-5632ba35d133ee29d46c031cdd4b4a37097b8ca1.tar.gz cgit-5632ba35d133ee29d46c031cdd4b4a37097b8ca1.tar.bz2 |
Add cgit_query.nohead flag
This flag is set when no HEAD is specified in the querystring. Currently
it has no users, but it will be used by ui-snapshot to invoke a DWIM-mode
where the revision is extracted from the snapshot name.
Signed-off-by: Lars Hjemli <hjemli@gmail.com>
-rw-r--r-- | cgit.c | 1 | ||||
-rw-r--r-- | cgit.h | 1 |
2 files changed, 2 insertions, 0 deletions
@@ -129,256 +129,257 @@ static void querystring_cb(const char *name, const char *value) | |||
129 | ctx.qry.repo = xstrdup(value); | 129 | ctx.qry.repo = xstrdup(value); |
130 | ctx.repo = cgit_get_repoinfo(value); | 130 | ctx.repo = cgit_get_repoinfo(value); |
131 | } else if (!strcmp(name, "p")) { | 131 | } else if (!strcmp(name, "p")) { |
132 | ctx.qry.page = xstrdup(value); | 132 | ctx.qry.page = xstrdup(value); |
133 | } else if (!strcmp(name, "url")) { | 133 | } else if (!strcmp(name, "url")) { |
134 | ctx.qry.url = xstrdup(value); | 134 | ctx.qry.url = xstrdup(value); |
135 | cgit_parse_url(value); | 135 | cgit_parse_url(value); |
136 | } else if (!strcmp(name, "qt")) { | 136 | } else if (!strcmp(name, "qt")) { |
137 | ctx.qry.grep = xstrdup(value); | 137 | ctx.qry.grep = xstrdup(value); |
138 | } else if (!strcmp(name, "q")) { | 138 | } else if (!strcmp(name, "q")) { |
139 | ctx.qry.search = xstrdup(value); | 139 | ctx.qry.search = xstrdup(value); |
140 | } else if (!strcmp(name, "h")) { | 140 | } else if (!strcmp(name, "h")) { |
141 | ctx.qry.head = xstrdup(value); | 141 | ctx.qry.head = xstrdup(value); |
142 | ctx.qry.has_symref = 1; | 142 | ctx.qry.has_symref = 1; |
143 | } else if (!strcmp(name, "id")) { | 143 | } else if (!strcmp(name, "id")) { |
144 | ctx.qry.sha1 = xstrdup(value); | 144 | ctx.qry.sha1 = xstrdup(value); |
145 | ctx.qry.has_sha1 = 1; | 145 | ctx.qry.has_sha1 = 1; |
146 | } else if (!strcmp(name, "id2")) { | 146 | } else if (!strcmp(name, "id2")) { |
147 | ctx.qry.sha2 = xstrdup(value); | 147 | ctx.qry.sha2 = xstrdup(value); |
148 | ctx.qry.has_sha1 = 1; | 148 | ctx.qry.has_sha1 = 1; |
149 | } else if (!strcmp(name, "ofs")) { | 149 | } else if (!strcmp(name, "ofs")) { |
150 | ctx.qry.ofs = atoi(value); | 150 | ctx.qry.ofs = atoi(value); |
151 | } else if (!strcmp(name, "path")) { | 151 | } else if (!strcmp(name, "path")) { |
152 | ctx.qry.path = trim_end(value, '/'); | 152 | ctx.qry.path = trim_end(value, '/'); |
153 | } else if (!strcmp(name, "name")) { | 153 | } else if (!strcmp(name, "name")) { |
154 | ctx.qry.name = xstrdup(value); | 154 | ctx.qry.name = xstrdup(value); |
155 | } else if (!strcmp(name, "mimetype")) { | 155 | } else if (!strcmp(name, "mimetype")) { |
156 | ctx.qry.mimetype = xstrdup(value); | 156 | ctx.qry.mimetype = xstrdup(value); |
157 | } | 157 | } |
158 | } | 158 | } |
159 | 159 | ||
160 | static void prepare_context(struct cgit_context *ctx) | 160 | static void prepare_context(struct cgit_context *ctx) |
161 | { | 161 | { |
162 | memset(ctx, 0, sizeof(ctx)); | 162 | memset(ctx, 0, sizeof(ctx)); |
163 | ctx->cfg.agefile = "info/web/last-modified"; | 163 | ctx->cfg.agefile = "info/web/last-modified"; |
164 | ctx->cfg.nocache = 0; | 164 | ctx->cfg.nocache = 0; |
165 | ctx->cfg.cache_size = 0; | 165 | ctx->cfg.cache_size = 0; |
166 | ctx->cfg.cache_dynamic_ttl = 5; | 166 | ctx->cfg.cache_dynamic_ttl = 5; |
167 | ctx->cfg.cache_max_create_time = 5; | 167 | ctx->cfg.cache_max_create_time = 5; |
168 | ctx->cfg.cache_repo_ttl = 5; | 168 | ctx->cfg.cache_repo_ttl = 5; |
169 | ctx->cfg.cache_root = CGIT_CACHE_ROOT; | 169 | ctx->cfg.cache_root = CGIT_CACHE_ROOT; |
170 | ctx->cfg.cache_root_ttl = 5; | 170 | ctx->cfg.cache_root_ttl = 5; |
171 | ctx->cfg.cache_static_ttl = -1; | 171 | ctx->cfg.cache_static_ttl = -1; |
172 | ctx->cfg.css = "/cgit.css"; | 172 | ctx->cfg.css = "/cgit.css"; |
173 | ctx->cfg.logo = "/git-logo.png"; | 173 | ctx->cfg.logo = "/git-logo.png"; |
174 | ctx->cfg.local_time = 0; | 174 | ctx->cfg.local_time = 0; |
175 | ctx->cfg.max_repo_count = 50; | 175 | ctx->cfg.max_repo_count = 50; |
176 | ctx->cfg.max_commit_count = 50; | 176 | ctx->cfg.max_commit_count = 50; |
177 | ctx->cfg.max_lock_attempts = 5; | 177 | ctx->cfg.max_lock_attempts = 5; |
178 | ctx->cfg.max_msg_len = 80; | 178 | ctx->cfg.max_msg_len = 80; |
179 | ctx->cfg.max_repodesc_len = 80; | 179 | ctx->cfg.max_repodesc_len = 80; |
180 | ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s"; | 180 | ctx->cfg.module_link = "./?repo=%s&page=commit&id=%s"; |
181 | ctx->cfg.renamelimit = -1; | 181 | ctx->cfg.renamelimit = -1; |
182 | ctx->cfg.robots = "index, nofollow"; | 182 | ctx->cfg.robots = "index, nofollow"; |
183 | ctx->cfg.root_title = "Git repository browser"; | 183 | ctx->cfg.root_title = "Git repository browser"; |
184 | ctx->cfg.root_desc = "a fast webinterface for the git dscm"; | 184 | ctx->cfg.root_desc = "a fast webinterface for the git dscm"; |
185 | ctx->cfg.script_name = CGIT_SCRIPT_NAME; | 185 | ctx->cfg.script_name = CGIT_SCRIPT_NAME; |
186 | ctx->cfg.summary_branches = 10; | 186 | ctx->cfg.summary_branches = 10; |
187 | ctx->cfg.summary_log = 10; | 187 | ctx->cfg.summary_log = 10; |
188 | ctx->cfg.summary_tags = 10; | 188 | ctx->cfg.summary_tags = 10; |
189 | ctx->page.mimetype = "text/html"; | 189 | ctx->page.mimetype = "text/html"; |
190 | ctx->page.charset = PAGE_ENCODING; | 190 | ctx->page.charset = PAGE_ENCODING; |
191 | ctx->page.filename = NULL; | 191 | ctx->page.filename = NULL; |
192 | ctx->page.size = 0; | 192 | ctx->page.size = 0; |
193 | ctx->page.modified = time(NULL); | 193 | ctx->page.modified = time(NULL); |
194 | ctx->page.expires = ctx->page.modified; | 194 | ctx->page.expires = ctx->page.modified; |
195 | } | 195 | } |
196 | 196 | ||
197 | struct refmatch { | 197 | struct refmatch { |
198 | char *req_ref; | 198 | char *req_ref; |
199 | char *first_ref; | 199 | char *first_ref; |
200 | int match; | 200 | int match; |
201 | }; | 201 | }; |
202 | 202 | ||
203 | int find_current_ref(const char *refname, const unsigned char *sha1, | 203 | int find_current_ref(const char *refname, const unsigned char *sha1, |
204 | int flags, void *cb_data) | 204 | int flags, void *cb_data) |
205 | { | 205 | { |
206 | struct refmatch *info; | 206 | struct refmatch *info; |
207 | 207 | ||
208 | info = (struct refmatch *)cb_data; | 208 | info = (struct refmatch *)cb_data; |
209 | if (!strcmp(refname, info->req_ref)) | 209 | if (!strcmp(refname, info->req_ref)) |
210 | info->match = 1; | 210 | info->match = 1; |
211 | if (!info->first_ref) | 211 | if (!info->first_ref) |
212 | info->first_ref = xstrdup(refname); | 212 | info->first_ref = xstrdup(refname); |
213 | return info->match; | 213 | return info->match; |
214 | } | 214 | } |
215 | 215 | ||
216 | char *find_default_branch(struct cgit_repo *repo) | 216 | char *find_default_branch(struct cgit_repo *repo) |
217 | { | 217 | { |
218 | struct refmatch info; | 218 | struct refmatch info; |
219 | char *ref; | 219 | char *ref; |
220 | 220 | ||
221 | info.req_ref = repo->defbranch; | 221 | info.req_ref = repo->defbranch; |
222 | info.first_ref = NULL; | 222 | info.first_ref = NULL; |
223 | info.match = 0; | 223 | info.match = 0; |
224 | for_each_branch_ref(find_current_ref, &info); | 224 | for_each_branch_ref(find_current_ref, &info); |
225 | if (info.match) | 225 | if (info.match) |
226 | ref = info.req_ref; | 226 | ref = info.req_ref; |
227 | else | 227 | else |
228 | ref = info.first_ref; | 228 | ref = info.first_ref; |
229 | if (ref) | 229 | if (ref) |
230 | ref = xstrdup(ref); | 230 | ref = xstrdup(ref); |
231 | return ref; | 231 | return ref; |
232 | } | 232 | } |
233 | 233 | ||
234 | static int prepare_repo_cmd(struct cgit_context *ctx) | 234 | static int prepare_repo_cmd(struct cgit_context *ctx) |
235 | { | 235 | { |
236 | char *tmp; | 236 | char *tmp; |
237 | unsigned char sha1[20]; | 237 | unsigned char sha1[20]; |
238 | int nongit = 0; | 238 | int nongit = 0; |
239 | 239 | ||
240 | setenv("GIT_DIR", ctx->repo->path, 1); | 240 | setenv("GIT_DIR", ctx->repo->path, 1); |
241 | setup_git_directory_gently(&nongit); | 241 | setup_git_directory_gently(&nongit); |
242 | if (nongit) { | 242 | if (nongit) { |
243 | ctx->page.title = fmt("%s - %s", ctx->cfg.root_title, | 243 | ctx->page.title = fmt("%s - %s", ctx->cfg.root_title, |
244 | "config error"); | 244 | "config error"); |
245 | tmp = fmt("Not a git repository: '%s'", ctx->repo->path); | 245 | tmp = fmt("Not a git repository: '%s'", ctx->repo->path); |
246 | ctx->repo = NULL; | 246 | ctx->repo = NULL; |
247 | cgit_print_http_headers(ctx); | 247 | cgit_print_http_headers(ctx); |
248 | cgit_print_docstart(ctx); | 248 | cgit_print_docstart(ctx); |
249 | cgit_print_pageheader(ctx); | 249 | cgit_print_pageheader(ctx); |
250 | cgit_print_error(tmp); | 250 | cgit_print_error(tmp); |
251 | cgit_print_docend(); | 251 | cgit_print_docend(); |
252 | return 1; | 252 | return 1; |
253 | } | 253 | } |
254 | ctx->page.title = fmt("%s - %s", ctx->repo->name, ctx->repo->desc); | 254 | ctx->page.title = fmt("%s - %s", ctx->repo->name, ctx->repo->desc); |
255 | 255 | ||
256 | if (!ctx->qry.head) { | 256 | if (!ctx->qry.head) { |
257 | ctx->qry.nohead = 1; | ||
257 | ctx->qry.head = find_default_branch(ctx->repo); | 258 | ctx->qry.head = find_default_branch(ctx->repo); |
258 | ctx->repo->defbranch = ctx->qry.head; | 259 | ctx->repo->defbranch = ctx->qry.head; |
259 | } | 260 | } |
260 | 261 | ||
261 | if (!ctx->qry.head) { | 262 | if (!ctx->qry.head) { |
262 | cgit_print_http_headers(ctx); | 263 | cgit_print_http_headers(ctx); |
263 | cgit_print_docstart(ctx); | 264 | cgit_print_docstart(ctx); |
264 | cgit_print_pageheader(ctx); | 265 | cgit_print_pageheader(ctx); |
265 | cgit_print_error("Repository seems to be empty"); | 266 | cgit_print_error("Repository seems to be empty"); |
266 | cgit_print_docend(); | 267 | cgit_print_docend(); |
267 | return 1; | 268 | return 1; |
268 | } | 269 | } |
269 | 270 | ||
270 | if (get_sha1(ctx->qry.head, sha1)) { | 271 | if (get_sha1(ctx->qry.head, sha1)) { |
271 | tmp = xstrdup(ctx->qry.head); | 272 | tmp = xstrdup(ctx->qry.head); |
272 | ctx->qry.head = ctx->repo->defbranch; | 273 | ctx->qry.head = ctx->repo->defbranch; |
273 | cgit_print_http_headers(ctx); | 274 | cgit_print_http_headers(ctx); |
274 | cgit_print_docstart(ctx); | 275 | cgit_print_docstart(ctx); |
275 | cgit_print_pageheader(ctx); | 276 | cgit_print_pageheader(ctx); |
276 | cgit_print_error(fmt("Invalid branch: %s", tmp)); | 277 | cgit_print_error(fmt("Invalid branch: %s", tmp)); |
277 | cgit_print_docend(); | 278 | cgit_print_docend(); |
278 | return 1; | 279 | return 1; |
279 | } | 280 | } |
280 | return 0; | 281 | return 0; |
281 | } | 282 | } |
282 | 283 | ||
283 | static void process_request(void *cbdata) | 284 | static void process_request(void *cbdata) |
284 | { | 285 | { |
285 | struct cgit_context *ctx = cbdata; | 286 | struct cgit_context *ctx = cbdata; |
286 | struct cgit_cmd *cmd; | 287 | struct cgit_cmd *cmd; |
287 | 288 | ||
288 | cmd = cgit_get_cmd(ctx); | 289 | cmd = cgit_get_cmd(ctx); |
289 | if (!cmd) { | 290 | if (!cmd) { |
290 | ctx->page.title = "cgit error"; | 291 | ctx->page.title = "cgit error"; |
291 | ctx->repo = NULL; | 292 | ctx->repo = NULL; |
292 | cgit_print_http_headers(ctx); | 293 | cgit_print_http_headers(ctx); |
293 | cgit_print_docstart(ctx); | 294 | cgit_print_docstart(ctx); |
294 | cgit_print_pageheader(ctx); | 295 | cgit_print_pageheader(ctx); |
295 | cgit_print_error("Invalid request"); | 296 | cgit_print_error("Invalid request"); |
296 | cgit_print_docend(); | 297 | cgit_print_docend(); |
297 | return; | 298 | return; |
298 | } | 299 | } |
299 | 300 | ||
300 | if (cmd->want_repo && !ctx->repo) { | 301 | if (cmd->want_repo && !ctx->repo) { |
301 | cgit_print_http_headers(ctx); | 302 | cgit_print_http_headers(ctx); |
302 | cgit_print_docstart(ctx); | 303 | cgit_print_docstart(ctx); |
303 | cgit_print_pageheader(ctx); | 304 | cgit_print_pageheader(ctx); |
304 | cgit_print_error(fmt("No repository selected")); | 305 | cgit_print_error(fmt("No repository selected")); |
305 | cgit_print_docend(); | 306 | cgit_print_docend(); |
306 | return; | 307 | return; |
307 | } | 308 | } |
308 | 309 | ||
309 | if (ctx->repo && prepare_repo_cmd(ctx)) | 310 | if (ctx->repo && prepare_repo_cmd(ctx)) |
310 | return; | 311 | return; |
311 | 312 | ||
312 | if (cmd->want_layout) { | 313 | if (cmd->want_layout) { |
313 | cgit_print_http_headers(ctx); | 314 | cgit_print_http_headers(ctx); |
314 | cgit_print_docstart(ctx); | 315 | cgit_print_docstart(ctx); |
315 | cgit_print_pageheader(ctx); | 316 | cgit_print_pageheader(ctx); |
316 | } | 317 | } |
317 | 318 | ||
318 | cmd->fn(ctx); | 319 | cmd->fn(ctx); |
319 | 320 | ||
320 | if (cmd->want_layout) | 321 | if (cmd->want_layout) |
321 | cgit_print_docend(); | 322 | cgit_print_docend(); |
322 | } | 323 | } |
323 | 324 | ||
324 | int cmp_repos(const void *a, const void *b) | 325 | int cmp_repos(const void *a, const void *b) |
325 | { | 326 | { |
326 | const struct cgit_repo *ra = a, *rb = b; | 327 | const struct cgit_repo *ra = a, *rb = b; |
327 | return strcmp(ra->url, rb->url); | 328 | return strcmp(ra->url, rb->url); |
328 | } | 329 | } |
329 | 330 | ||
330 | void print_repo(struct cgit_repo *repo) | 331 | void print_repo(struct cgit_repo *repo) |
331 | { | 332 | { |
332 | printf("repo.url=%s\n", repo->url); | 333 | printf("repo.url=%s\n", repo->url); |
333 | printf("repo.name=%s\n", repo->name); | 334 | printf("repo.name=%s\n", repo->name); |
334 | printf("repo.path=%s\n", repo->path); | 335 | printf("repo.path=%s\n", repo->path); |
335 | if (repo->owner) | 336 | if (repo->owner) |
336 | printf("repo.owner=%s\n", repo->owner); | 337 | printf("repo.owner=%s\n", repo->owner); |
337 | if (repo->desc) | 338 | if (repo->desc) |
338 | printf("repo.desc=%s\n", repo->desc); | 339 | printf("repo.desc=%s\n", repo->desc); |
339 | if (repo->readme) | 340 | if (repo->readme) |
340 | printf("repo.readme=%s\n", repo->readme); | 341 | printf("repo.readme=%s\n", repo->readme); |
341 | printf("\n"); | 342 | printf("\n"); |
342 | } | 343 | } |
343 | 344 | ||
344 | void print_repolist(struct cgit_repolist *list) | 345 | void print_repolist(struct cgit_repolist *list) |
345 | { | 346 | { |
346 | int i; | 347 | int i; |
347 | 348 | ||
348 | for(i = 0; i < list->count; i++) | 349 | for(i = 0; i < list->count; i++) |
349 | print_repo(&list->repos[i]); | 350 | print_repo(&list->repos[i]); |
350 | } | 351 | } |
351 | 352 | ||
352 | 353 | ||
353 | static void cgit_parse_args(int argc, const char **argv) | 354 | static void cgit_parse_args(int argc, const char **argv) |
354 | { | 355 | { |
355 | int i; | 356 | int i; |
356 | int scan = 0; | 357 | int scan = 0; |
357 | 358 | ||
358 | for (i = 1; i < argc; i++) { | 359 | for (i = 1; i < argc; i++) { |
359 | if (!strncmp(argv[i], "--cache=", 8)) { | 360 | if (!strncmp(argv[i], "--cache=", 8)) { |
360 | ctx.cfg.cache_root = xstrdup(argv[i]+8); | 361 | ctx.cfg.cache_root = xstrdup(argv[i]+8); |
361 | } | 362 | } |
362 | if (!strcmp(argv[i], "--nocache")) { | 363 | if (!strcmp(argv[i], "--nocache")) { |
363 | ctx.cfg.nocache = 1; | 364 | ctx.cfg.nocache = 1; |
364 | } | 365 | } |
365 | if (!strncmp(argv[i], "--query=", 8)) { | 366 | if (!strncmp(argv[i], "--query=", 8)) { |
366 | ctx.qry.raw = xstrdup(argv[i]+8); | 367 | ctx.qry.raw = xstrdup(argv[i]+8); |
367 | } | 368 | } |
368 | if (!strncmp(argv[i], "--repo=", 7)) { | 369 | if (!strncmp(argv[i], "--repo=", 7)) { |
369 | ctx.qry.repo = xstrdup(argv[i]+7); | 370 | ctx.qry.repo = xstrdup(argv[i]+7); |
370 | } | 371 | } |
371 | if (!strncmp(argv[i], "--page=", 7)) { | 372 | if (!strncmp(argv[i], "--page=", 7)) { |
372 | ctx.qry.page = xstrdup(argv[i]+7); | 373 | ctx.qry.page = xstrdup(argv[i]+7); |
373 | } | 374 | } |
374 | if (!strncmp(argv[i], "--head=", 7)) { | 375 | if (!strncmp(argv[i], "--head=", 7)) { |
375 | ctx.qry.head = xstrdup(argv[i]+7); | 376 | ctx.qry.head = xstrdup(argv[i]+7); |
376 | ctx.qry.has_symref = 1; | 377 | ctx.qry.has_symref = 1; |
377 | } | 378 | } |
378 | if (!strncmp(argv[i], "--sha1=", 7)) { | 379 | if (!strncmp(argv[i], "--sha1=", 7)) { |
379 | ctx.qry.sha1 = xstrdup(argv[i]+7); | 380 | ctx.qry.sha1 = xstrdup(argv[i]+7); |
380 | ctx.qry.has_sha1 = 1; | 381 | ctx.qry.has_sha1 = 1; |
381 | } | 382 | } |
382 | if (!strncmp(argv[i], "--ofs=", 6)) { | 383 | if (!strncmp(argv[i], "--ofs=", 6)) { |
383 | ctx.qry.ofs = atoi(argv[i]+6); | 384 | ctx.qry.ofs = atoi(argv[i]+6); |
384 | } | 385 | } |
@@ -1,242 +1,243 @@ | |||
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 | #include <utf8.h> |
20 | 20 | ||
21 | 21 | ||
22 | /* | 22 | /* |
23 | * Dateformats used on misc. pages | 23 | * Dateformats used on misc. pages |
24 | */ | 24 | */ |
25 | #define FMT_LONGDATE "%Y-%m-%d %H:%M:%S (%Z)" | 25 | #define FMT_LONGDATE "%Y-%m-%d %H:%M:%S (%Z)" |
26 | #define FMT_SHORTDATE "%Y-%m-%d" | 26 | #define FMT_SHORTDATE "%Y-%m-%d" |
27 | #define FMT_ATOMDATE "%Y-%m-%dT%H:%M:%SZ" | 27 | #define FMT_ATOMDATE "%Y-%m-%dT%H:%M:%SZ" |
28 | 28 | ||
29 | 29 | ||
30 | /* | 30 | /* |
31 | * Limits used for relative dates | 31 | * Limits used for relative dates |
32 | */ | 32 | */ |
33 | #define TM_MIN 60 | 33 | #define TM_MIN 60 |
34 | #define TM_HOUR (TM_MIN * 60) | 34 | #define TM_HOUR (TM_MIN * 60) |
35 | #define TM_DAY (TM_HOUR * 24) | 35 | #define TM_DAY (TM_HOUR * 24) |
36 | #define TM_WEEK (TM_DAY * 7) | 36 | #define TM_WEEK (TM_DAY * 7) |
37 | #define TM_YEAR (TM_DAY * 365) | 37 | #define TM_YEAR (TM_DAY * 365) |
38 | #define TM_MONTH (TM_YEAR / 12.0) | 38 | #define TM_MONTH (TM_YEAR / 12.0) |
39 | 39 | ||
40 | 40 | ||
41 | /* | 41 | /* |
42 | * Default encoding | 42 | * Default encoding |
43 | */ | 43 | */ |
44 | #define PAGE_ENCODING "UTF-8" | 44 | #define PAGE_ENCODING "UTF-8" |
45 | 45 | ||
46 | typedef void (*configfn)(const char *name, const char *value); | 46 | typedef void (*configfn)(const char *name, const char *value); |
47 | typedef void (*filepair_fn)(struct diff_filepair *pair); | 47 | typedef void (*filepair_fn)(struct diff_filepair *pair); |
48 | typedef void (*linediff_fn)(char *line, int len); | 48 | typedef void (*linediff_fn)(char *line, int len); |
49 | 49 | ||
50 | struct cgit_repo { | 50 | struct cgit_repo { |
51 | char *url; | 51 | char *url; |
52 | char *name; | 52 | char *name; |
53 | char *path; | 53 | char *path; |
54 | char *desc; | 54 | char *desc; |
55 | char *owner; | 55 | char *owner; |
56 | char *defbranch; | 56 | char *defbranch; |
57 | char *group; | 57 | char *group; |
58 | char *module_link; | 58 | char *module_link; |
59 | char *readme; | 59 | char *readme; |
60 | char *clone_url; | 60 | char *clone_url; |
61 | int snapshots; | 61 | int snapshots; |
62 | int enable_log_filecount; | 62 | int enable_log_filecount; |
63 | int enable_log_linecount; | 63 | int enable_log_linecount; |
64 | }; | 64 | }; |
65 | 65 | ||
66 | struct cgit_repolist { | 66 | struct cgit_repolist { |
67 | int length; | 67 | int length; |
68 | int count; | 68 | int count; |
69 | struct cgit_repo *repos; | 69 | struct cgit_repo *repos; |
70 | }; | 70 | }; |
71 | 71 | ||
72 | struct commitinfo { | 72 | struct commitinfo { |
73 | struct commit *commit; | 73 | struct commit *commit; |
74 | char *author; | 74 | char *author; |
75 | char *author_email; | 75 | char *author_email; |
76 | unsigned long author_date; | 76 | unsigned long author_date; |
77 | char *committer; | 77 | char *committer; |
78 | char *committer_email; | 78 | char *committer_email; |
79 | unsigned long committer_date; | 79 | unsigned long committer_date; |
80 | char *subject; | 80 | char *subject; |
81 | char *msg; | 81 | char *msg; |
82 | char *msg_encoding; | 82 | char *msg_encoding; |
83 | }; | 83 | }; |
84 | 84 | ||
85 | struct taginfo { | 85 | struct taginfo { |
86 | char *tagger; | 86 | char *tagger; |
87 | char *tagger_email; | 87 | char *tagger_email; |
88 | unsigned long tagger_date; | 88 | unsigned long tagger_date; |
89 | char *msg; | 89 | char *msg; |
90 | }; | 90 | }; |
91 | 91 | ||
92 | struct refinfo { | 92 | struct refinfo { |
93 | const char *refname; | 93 | const char *refname; |
94 | struct object *object; | 94 | struct object *object; |
95 | union { | 95 | union { |
96 | struct taginfo *tag; | 96 | struct taginfo *tag; |
97 | struct commitinfo *commit; | 97 | struct commitinfo *commit; |
98 | }; | 98 | }; |
99 | }; | 99 | }; |
100 | 100 | ||
101 | struct reflist { | 101 | struct reflist { |
102 | struct refinfo **refs; | 102 | struct refinfo **refs; |
103 | int alloc; | 103 | int alloc; |
104 | int count; | 104 | int count; |
105 | }; | 105 | }; |
106 | 106 | ||
107 | struct cgit_query { | 107 | struct cgit_query { |
108 | int has_symref; | 108 | int has_symref; |
109 | int has_sha1; | 109 | int has_sha1; |
110 | char *raw; | 110 | char *raw; |
111 | char *repo; | 111 | char *repo; |
112 | char *page; | 112 | char *page; |
113 | char *search; | 113 | char *search; |
114 | char *grep; | 114 | char *grep; |
115 | char *head; | 115 | char *head; |
116 | char *sha1; | 116 | char *sha1; |
117 | char *sha2; | 117 | char *sha2; |
118 | char *path; | 118 | char *path; |
119 | char *name; | 119 | char *name; |
120 | char *mimetype; | 120 | char *mimetype; |
121 | char *url; | 121 | char *url; |
122 | int ofs; | 122 | int ofs; |
123 | int nohead; | ||
123 | }; | 124 | }; |
124 | 125 | ||
125 | struct cgit_config { | 126 | struct cgit_config { |
126 | char *agefile; | 127 | char *agefile; |
127 | char *cache_root; | 128 | char *cache_root; |
128 | char *clone_prefix; | 129 | char *clone_prefix; |
129 | char *css; | 130 | char *css; |
130 | char *favicon; | 131 | char *favicon; |
131 | char *footer; | 132 | char *footer; |
132 | char *index_header; | 133 | char *index_header; |
133 | char *index_info; | 134 | char *index_info; |
134 | char *logo; | 135 | char *logo; |
135 | char *logo_link; | 136 | char *logo_link; |
136 | char *module_link; | 137 | char *module_link; |
137 | char *repo_group; | 138 | char *repo_group; |
138 | char *robots; | 139 | char *robots; |
139 | char *root_title; | 140 | char *root_title; |
140 | char *root_desc; | 141 | char *root_desc; |
141 | char *root_readme; | 142 | char *root_readme; |
142 | char *script_name; | 143 | char *script_name; |
143 | char *virtual_root; | 144 | char *virtual_root; |
144 | int cache_size; | 145 | int cache_size; |
145 | int cache_dynamic_ttl; | 146 | int cache_dynamic_ttl; |
146 | int cache_max_create_time; | 147 | int cache_max_create_time; |
147 | int cache_repo_ttl; | 148 | int cache_repo_ttl; |
148 | int cache_root_ttl; | 149 | int cache_root_ttl; |
149 | int cache_static_ttl; | 150 | int cache_static_ttl; |
150 | int enable_index_links; | 151 | int enable_index_links; |
151 | int enable_log_filecount; | 152 | int enable_log_filecount; |
152 | int enable_log_linecount; | 153 | int enable_log_linecount; |
153 | int local_time; | 154 | int local_time; |
154 | int max_repo_count; | 155 | int max_repo_count; |
155 | int max_commit_count; | 156 | int max_commit_count; |
156 | int max_lock_attempts; | 157 | int max_lock_attempts; |
157 | int max_msg_len; | 158 | int max_msg_len; |
158 | int max_repodesc_len; | 159 | int max_repodesc_len; |
159 | int nocache; | 160 | int nocache; |
160 | int renamelimit; | 161 | int renamelimit; |
161 | int snapshots; | 162 | int snapshots; |
162 | int summary_branches; | 163 | int summary_branches; |
163 | int summary_log; | 164 | int summary_log; |
164 | int summary_tags; | 165 | int summary_tags; |
165 | }; | 166 | }; |
166 | 167 | ||
167 | struct cgit_page { | 168 | struct cgit_page { |
168 | time_t modified; | 169 | time_t modified; |
169 | time_t expires; | 170 | time_t expires; |
170 | size_t size; | 171 | size_t size; |
171 | char *mimetype; | 172 | char *mimetype; |
172 | char *charset; | 173 | char *charset; |
173 | char *filename; | 174 | char *filename; |
174 | char *title; | 175 | char *title; |
175 | }; | 176 | }; |
176 | 177 | ||
177 | struct cgit_context { | 178 | struct cgit_context { |
178 | struct cgit_query qry; | 179 | struct cgit_query qry; |
179 | struct cgit_config cfg; | 180 | struct cgit_config cfg; |
180 | struct cgit_repo *repo; | 181 | struct cgit_repo *repo; |
181 | struct cgit_page page; | 182 | struct cgit_page page; |
182 | }; | 183 | }; |
183 | 184 | ||
184 | struct cgit_snapshot_format { | 185 | struct cgit_snapshot_format { |
185 | const char *suffix; | 186 | const char *suffix; |
186 | const char *mimetype; | 187 | const char *mimetype; |
187 | write_archive_fn_t write_func; | 188 | write_archive_fn_t write_func; |
188 | int bit; | 189 | int bit; |
189 | }; | 190 | }; |
190 | 191 | ||
191 | extern const char *cgit_version; | 192 | extern const char *cgit_version; |
192 | 193 | ||
193 | extern struct cgit_repolist cgit_repolist; | 194 | extern struct cgit_repolist cgit_repolist; |
194 | extern struct cgit_context ctx; | 195 | extern struct cgit_context ctx; |
195 | extern const struct cgit_snapshot_format cgit_snapshot_formats[]; | 196 | extern const struct cgit_snapshot_format cgit_snapshot_formats[]; |
196 | 197 | ||
197 | extern struct cgit_repo *cgit_add_repo(const char *url); | 198 | extern struct cgit_repo *cgit_add_repo(const char *url); |
198 | extern struct cgit_repo *cgit_get_repoinfo(const char *url); | 199 | extern struct cgit_repo *cgit_get_repoinfo(const char *url); |
199 | extern void cgit_repo_config_cb(const char *name, const char *value); | 200 | extern void cgit_repo_config_cb(const char *name, const char *value); |
200 | 201 | ||
201 | extern int chk_zero(int result, char *msg); | 202 | extern int chk_zero(int result, char *msg); |
202 | extern int chk_positive(int result, char *msg); | 203 | extern int chk_positive(int result, char *msg); |
203 | extern int chk_non_negative(int result, char *msg); | 204 | extern int chk_non_negative(int result, char *msg); |
204 | 205 | ||
205 | extern char *trim_end(const char *str, char c); | 206 | extern char *trim_end(const char *str, char c); |
206 | extern char *strlpart(char *txt, int maxlen); | 207 | extern char *strlpart(char *txt, int maxlen); |
207 | extern char *strrpart(char *txt, int maxlen); | 208 | extern char *strrpart(char *txt, int maxlen); |
208 | 209 | ||
209 | extern void cgit_add_ref(struct reflist *list, struct refinfo *ref); | 210 | extern void cgit_add_ref(struct reflist *list, struct refinfo *ref); |
210 | extern int cgit_refs_cb(const char *refname, const unsigned char *sha1, | 211 | extern int cgit_refs_cb(const char *refname, const unsigned char *sha1, |
211 | int flags, void *cb_data); | 212 | int flags, void *cb_data); |
212 | 213 | ||
213 | extern void *cgit_free_commitinfo(struct commitinfo *info); | 214 | extern void *cgit_free_commitinfo(struct commitinfo *info); |
214 | 215 | ||
215 | extern int cgit_diff_files(const unsigned char *old_sha1, | 216 | extern int cgit_diff_files(const unsigned char *old_sha1, |
216 | const unsigned char *new_sha1, | 217 | const unsigned char *new_sha1, |
217 | linediff_fn fn); | 218 | linediff_fn fn); |
218 | 219 | ||
219 | extern void cgit_diff_tree(const unsigned char *old_sha1, | 220 | extern void cgit_diff_tree(const unsigned char *old_sha1, |
220 | const unsigned char *new_sha1, | 221 | const unsigned char *new_sha1, |
221 | filepair_fn fn, const char *prefix); | 222 | filepair_fn fn, const char *prefix); |
222 | 223 | ||
223 | extern void cgit_diff_commit(struct commit *commit, filepair_fn fn); | 224 | extern void cgit_diff_commit(struct commit *commit, filepair_fn fn); |
224 | 225 | ||
225 | extern char *fmt(const char *format,...); | 226 | extern char *fmt(const char *format,...); |
226 | 227 | ||
227 | extern struct commitinfo *cgit_parse_commit(struct commit *commit); | 228 | extern struct commitinfo *cgit_parse_commit(struct commit *commit); |
228 | extern struct taginfo *cgit_parse_tag(struct tag *tag); | 229 | extern struct taginfo *cgit_parse_tag(struct tag *tag); |
229 | extern void cgit_parse_url(const char *url); | 230 | extern void cgit_parse_url(const char *url); |
230 | 231 | ||
231 | extern const char *cgit_repobasename(const char *reponame); | 232 | extern const char *cgit_repobasename(const char *reponame); |
232 | 233 | ||
233 | extern int cgit_parse_snapshots_mask(const char *str); | 234 | extern int cgit_parse_snapshots_mask(const char *str); |
234 | 235 | ||
235 | /* libgit.a either links against or compiles its own implementation of | 236 | /* libgit.a either links against or compiles its own implementation of |
236 | * strcasestr(), and we'd like to reuse it. Simply re-declaring it | 237 | * strcasestr(), and we'd like to reuse it. Simply re-declaring it |
237 | * seems to do the trick. | 238 | * seems to do the trick. |
238 | */ | 239 | */ |
239 | extern char *strcasestr(const char *haystack, const char *needle); | 240 | extern char *strcasestr(const char *haystack, const char *needle); |
240 | 241 | ||
241 | 242 | ||
242 | #endif /* CGIT_H */ | 243 | #endif /* CGIT_H */ |