Blob


1 /*
2 * Copyright (c) 2019, 2020 Tracey Emery <tracey@traceyemery.net>
3 * Copyright (c) 2018, 2019 Stefan Sperling <stsp@openbsd.org>
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
18 #include <sys/queue.h>
19 #include <sys/stat.h>
20 #include <sys/types.h>
22 #include <ctype.h>
23 #include <dirent.h>
24 #include <err.h>
25 #include <errno.h>
26 #include <regex.h>
27 #include <stdarg.h>
28 #include <stdint.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
34 #include <got_error.h>
35 #include <got_object.h>
36 #include <got_reference.h>
37 #include <got_repository.h>
38 #include <got_path.h>
39 #include <got_cancel.h>
40 #include <got_worktree.h>
41 #include <got_diff.h>
42 #include <got_commit_graph.h>
43 #include <got_blame.h>
44 #include <got_privsep.h>
45 #include <got_opentemp.h>
47 #include <kcgi.h>
48 #include <kcgihtml.h>
50 #include "gotweb.h"
52 #ifndef nitems
53 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
54 #endif
56 struct gw_trans {
57 TAILQ_HEAD(headers, gw_header) gw_headers;
58 TAILQ_HEAD(dirs, gw_dir) gw_dirs;
59 struct got_repository *repo;
60 struct gw_dir *gw_dir;
61 struct gotweb_config *gw_conf;
62 struct ktemplate *gw_tmpl;
63 struct khtmlreq *gw_html_req;
64 struct kreq *gw_req;
65 const struct got_error *error;
66 const char *repo_name;
67 char *repo_path;
68 char *commit_id;
69 char *next_id;
70 char *prev_id;
71 const char *repo_file;
72 char *repo_folder;
73 const char *headref;
74 unsigned int action;
75 unsigned int page;
76 unsigned int repos_total;
77 enum kmime mime;
78 };
80 struct gw_header {
81 TAILQ_ENTRY(gw_header) entry;
82 struct got_reflist_head refs;
83 char *path;
85 char *refs_str;
86 char *commit_id; /* id_str1 */
87 char *parent_id; /* id_str2 */
88 char *tree_id;
89 char *author;
90 char *committer;
91 char *commit_msg;
92 time_t committer_time;
93 };
95 struct gw_dir {
96 TAILQ_ENTRY(gw_dir) entry;
97 char *name;
98 char *owner;
99 char *description;
100 char *url;
101 char *age;
102 char *path;
103 };
105 enum gw_key {
106 KEY_ACTION,
107 KEY_COMMIT_ID,
108 KEY_FILE,
109 KEY_FOLDER,
110 KEY_HEADREF,
111 KEY_PAGE,
112 KEY_PATH,
113 KEY_PREV_ID,
114 KEY__ZMAX
115 };
117 enum gw_tmpl {
118 TEMPL_CONTENT,
119 TEMPL_HEAD,
120 TEMPL_HEADER,
121 TEMPL_SEARCH,
122 TEMPL_SITEPATH,
123 TEMPL_SITEOWNER,
124 TEMPL_TITLE,
125 TEMPL__MAX
126 };
128 enum gw_ref_tm {
129 TM_DIFF,
130 TM_LONG,
131 };
133 enum gw_tags_type {
134 TAGBRIEF,
135 TAGFULL,
136 };
138 static const char *const gw_templs[TEMPL__MAX] = {
139 "content",
140 "head",
141 "header",
142 "search",
143 "sitepath",
144 "siteowner",
145 "title",
146 };
148 static const struct kvalid gw_keys[KEY__ZMAX] = {
149 { kvalid_stringne, "action" },
150 { kvalid_stringne, "commit" },
151 { kvalid_stringne, "file" },
152 { kvalid_stringne, "folder" },
153 { kvalid_stringne, "headref" },
154 { kvalid_int, "page" },
155 { kvalid_stringne, "path" },
156 { kvalid_stringne, "prev" },
157 };
159 static struct gw_header *gw_init_header(void);
161 static void gw_free_header(struct gw_header *);
163 static int gw_template(size_t, void *);
165 static const struct got_error *gw_error(struct gw_trans *);
166 static const struct got_error *gw_init_gw_dir(struct gw_dir **, const char *);
167 static const struct got_error *gw_get_repo_description(char **,
168 struct gw_trans *, char *);
169 static const struct got_error *gw_get_repo_owner(char **, struct gw_trans *,
170 char *);
171 static const struct got_error *gw_get_time_str(char **, time_t, int);
172 static const struct got_error *gw_get_repo_age(char **, struct gw_trans *,
173 char *, const char *, int);
174 static const struct got_error *gw_output_file_blame(struct gw_trans *,
175 struct gw_header *);
176 static const struct got_error *gw_output_blob_buf(struct gw_trans *,
177 struct gw_header *);
178 static const struct got_error *gw_output_repo_tree(struct gw_trans *,
179 struct gw_header *);
180 static const struct got_error *gw_output_diff(struct gw_trans *,
181 struct gw_header *);
182 static const struct got_error *gw_output_repo_tags(struct gw_trans *,
183 struct gw_header *, int, int);
184 static const struct got_error *gw_output_repo_heads(struct gw_trans *);
185 static const struct got_error *gw_output_site_link(struct gw_trans *);
186 static const struct got_error *gw_get_clone_url(char **, struct gw_trans *,
187 char *);
188 static const struct got_error *gw_colordiff_line(struct gw_trans *, char *);
190 static const struct got_error *gw_gen_commit_header(struct gw_trans *, char *,
191 char*);
192 static const struct got_error *gw_gen_diff_header(struct gw_trans *, char *,
193 char*);
194 static const struct got_error *gw_gen_author_header(struct gw_trans *,
195 const char *);
196 static const struct got_error *gw_gen_age_header(struct gw_trans *,
197 const char *);
198 static const struct got_error *gw_gen_committer_header(struct gw_trans *,
199 const char *);
200 static const struct got_error *gw_gen_commit_msg_header(struct gw_trans*,
201 char *);
202 static const struct got_error *gw_gen_tree_header(struct gw_trans *, char *);
203 static const struct got_error *gw_display_open(struct gw_trans *, enum khttp,
204 enum kmime);
205 static const struct got_error *gw_display_index(struct gw_trans *);
206 static const struct got_error *gw_get_header(struct gw_trans *,
207 struct gw_header *, int);
208 static const struct got_error *gw_get_commits(struct gw_trans *,
209 struct gw_header *, int,
210 struct got_object_id *);
211 static const struct got_error *gw_get_commit(struct gw_trans *,
212 struct gw_header *,
213 struct got_commit_object *,
214 struct got_object_id *);
215 static const struct got_error *gw_apply_unveil(const char *);
216 static const struct got_error *gw_blame_cb(void *, int, int,
217 struct got_object_id *);
218 static const struct got_error *gw_load_got_paths(struct gw_trans *);
219 static const struct got_error *gw_load_got_path(struct gw_trans *,
220 struct gw_dir *);
221 static const struct got_error *gw_parse_querystring(struct gw_trans *);
222 static const struct got_error *gw_blame(struct gw_trans *);
223 static const struct got_error *gw_blob(struct gw_trans *);
224 static const struct got_error *gw_diff(struct gw_trans *);
225 static const struct got_error *gw_index(struct gw_trans *);
226 static const struct got_error *gw_commits(struct gw_trans *);
227 static const struct got_error *gw_briefs(struct gw_trans *);
228 static const struct got_error *gw_summary(struct gw_trans *);
229 static const struct got_error *gw_tree(struct gw_trans *);
230 static const struct got_error *gw_tag(struct gw_trans *);
231 static const struct got_error *gw_tags(struct gw_trans *);
233 struct gw_query_action {
234 unsigned int func_id;
235 const char *func_name;
236 const struct got_error *(*func_main)(struct gw_trans *);
237 char *template;
238 };
240 enum gw_query_actions {
241 GW_BLAME,
242 GW_BLOB,
243 GW_BRIEFS,
244 GW_COMMITS,
245 GW_DIFF,
246 GW_ERR,
247 GW_INDEX,
248 GW_SUMMARY,
249 GW_TAG,
250 GW_TAGS,
251 GW_TREE,
252 };
254 static const struct gw_query_action gw_query_funcs[] = {
255 { GW_BLAME, "blame", gw_blame, "gw_tmpl/blame.tmpl" },
256 { GW_BLOB, "blob", NULL, NULL },
257 { GW_BRIEFS, "briefs", gw_briefs, "gw_tmpl/briefs.tmpl" },
258 { GW_COMMITS, "commits", gw_commits, "gw_tmpl/commit.tmpl" },
259 { GW_DIFF, "diff", gw_diff, "gw_tmpl/diff.tmpl" },
260 { GW_ERR, "error", gw_error, "gw_tmpl/err.tmpl" },
261 { GW_INDEX, "index", gw_index, "gw_tmpl/index.tmpl" },
262 { GW_SUMMARY, "summary", gw_summary, "gw_tmpl/summry.tmpl" },
263 { GW_TAG, "tag", gw_tag, "gw_tmpl/tag.tmpl" },
264 { GW_TAGS, "tags", gw_tags, "gw_tmpl/tags.tmpl" },
265 { GW_TREE, "tree", gw_tree, "gw_tmpl/tree.tmpl" },
266 };
268 static const char *
269 gw_get_action_name(struct gw_trans *gw_trans)
271 return gw_query_funcs[gw_trans->action].func_name;
274 static const struct got_error *
275 gw_kcgi_error(enum kcgi_err kerr)
277 if (kerr == KCGI_OK)
278 return NULL;
280 if (kerr == KCGI_EXIT || kerr == KCGI_HUP)
281 return got_error(GOT_ERR_CANCELLED);
283 if (kerr == KCGI_ENOMEM)
284 return got_error_set_errno(ENOMEM,
285 kcgi_strerror(kerr));
287 if (kerr == KCGI_ENFILE)
288 return got_error_set_errno(ENFILE,
289 kcgi_strerror(kerr));
291 if (kerr == KCGI_EAGAIN)
292 return got_error_set_errno(EAGAIN,
293 kcgi_strerror(kerr));
295 if (kerr == KCGI_FORM)
296 return got_error_msg(GOT_ERR_IO,
297 kcgi_strerror(kerr));
299 return got_error_from_errno(kcgi_strerror(kerr));
302 static const struct got_error *
303 gw_apply_unveil(const char *repo_path)
305 const struct got_error *err;
307 #ifdef PROFILE
308 if (unveil("gmon.out", "rwc") != 0)
309 return got_error_from_errno2("unveil", "gmon.out");
310 #endif
311 if (repo_path && unveil(repo_path, "r") != 0)
312 return got_error_from_errno2("unveil", repo_path);
314 if (unveil(GOT_TMPDIR_STR, "rwc") != 0)
315 return got_error_from_errno2("unveil", GOT_TMPDIR_STR);
317 err = got_privsep_unveil_exec_helpers();
318 if (err != NULL)
319 return err;
321 if (unveil(NULL, NULL) != 0)
322 return got_error_from_errno("unveil");
324 return NULL;
327 static int
328 isbinary(const uint8_t *buf, size_t n)
330 size_t i;
332 for (i = 0; i < n; i++)
333 if (buf[i] == 0)
334 return 1;
335 return 0;
338 static const struct got_error *
339 gw_blame(struct gw_trans *gw_trans)
341 const struct got_error *error = NULL;
342 struct gw_header *header = NULL;
343 char *age = NULL;
344 enum kcgi_err kerr = KCGI_OK;
346 #ifndef PROFILE
347 if (pledge("stdio rpath wpath cpath proc exec sendfd unveil",
348 NULL) == -1)
349 return got_error_from_errno("pledge");
350 #endif
351 if ((header = gw_init_header()) == NULL)
352 return got_error_from_errno("malloc");
354 error = gw_apply_unveil(gw_trans->gw_dir->path);
355 if (error)
356 goto done;
358 /* check querystring */
359 if (gw_trans->repo_file == NULL) {
360 error = got_error_msg(GOT_ERR_QUERYSTRING,
361 "file required in querystring");
362 goto done;
364 if (gw_trans->commit_id == NULL) {
365 error = got_error_msg(GOT_ERR_QUERYSTRING,
366 "commit required in querystring");
367 goto done;
370 error = gw_get_header(gw_trans, header, 1);
371 if (error)
372 goto done;
373 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
374 "blame_header_wrapper", KATTR__MAX);
375 if (kerr != KCGI_OK)
376 goto done;
377 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
378 "blame_header", KATTR__MAX);
379 if (kerr != KCGI_OK)
380 goto done;
381 error = gw_get_time_str(&age, header->committer_time,
382 TM_LONG);
383 if (error)
384 goto done;
385 error = gw_gen_age_header(gw_trans, age ?age : "");
386 if (error)
387 goto done;
388 error = gw_gen_commit_msg_header(gw_trans, header->commit_msg);
389 if (error)
390 goto done;
391 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
392 if (kerr != KCGI_OK)
393 goto done;
394 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
395 "dotted_line", KATTR__MAX);
396 if (kerr != KCGI_OK)
397 goto done;
398 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
399 if (kerr != KCGI_OK)
400 goto done;
402 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
403 "blame", KATTR__MAX);
404 if (kerr != KCGI_OK)
405 goto done;
406 error = gw_output_file_blame(gw_trans, header);
407 if (error)
408 goto done;
409 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
410 done:
411 gw_free_header(header);
412 if (error == NULL && kerr != KCGI_OK)
413 error = gw_kcgi_error(kerr);
414 return error;
417 static const struct got_error *
418 gw_blob(struct gw_trans *gw_trans)
420 const struct got_error *error = NULL, *err = NULL;
421 struct gw_header *header = NULL;
422 enum kcgi_err kerr = KCGI_OK;
424 #ifndef PROFILE
425 if (pledge("stdio rpath wpath cpath proc exec sendfd unveil",
426 NULL) == -1)
427 return got_error_from_errno("pledge");
428 #endif
429 if ((header = gw_init_header()) == NULL)
430 return got_error_from_errno("malloc");
432 error = gw_apply_unveil(gw_trans->gw_dir->path);
433 if (error)
434 goto done;
436 /* check querystring */
437 if (gw_trans->repo_file == NULL) {
438 error = got_error_msg(GOT_ERR_QUERYSTRING,
439 "file required in querystring");
440 goto done;
442 if (gw_trans->commit_id == NULL) {
443 error = got_error_msg(GOT_ERR_QUERYSTRING,
444 "commit required in querystring");
445 goto done;
447 error = gw_get_header(gw_trans, header, 1);
448 if (error)
449 goto done;
451 error = gw_output_blob_buf(gw_trans, header);
452 done:
454 if (error) {
455 gw_trans->mime = KMIME_TEXT_PLAIN;
456 err = gw_display_index(gw_trans);
457 if (err) {
458 error = err;
459 goto errored;
461 kerr = khttp_puts(gw_trans->gw_req, error->msg);
463 errored:
464 gw_free_header(header);
465 if (error == NULL && kerr != KCGI_OK)
466 error = gw_kcgi_error(kerr);
467 return error;
470 static const struct got_error *
471 gw_diff(struct gw_trans *gw_trans)
473 const struct got_error *error = NULL;
474 struct gw_header *header = NULL;
475 char *age = NULL;
476 enum kcgi_err kerr = KCGI_OK;
478 #ifndef PROFILE
479 if (pledge("stdio rpath wpath cpath proc exec sendfd unveil",
480 NULL) == -1)
481 return got_error_from_errno("pledge");
482 #endif
483 if ((header = gw_init_header()) == NULL)
484 return got_error_from_errno("malloc");
486 error = gw_apply_unveil(gw_trans->gw_dir->path);
487 if (error)
488 goto done;
490 error = gw_get_header(gw_trans, header, 1);
491 if (error)
492 goto done;
494 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
495 "diff_header_wrapper", KATTR__MAX);
496 if (kerr != KCGI_OK)
497 goto done;
498 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
499 "diff_header", KATTR__MAX);
500 if (kerr != KCGI_OK)
501 goto done;
502 error = gw_gen_diff_header(gw_trans, header->parent_id,
503 header->commit_id);
504 if (error)
505 goto done;
506 error = gw_gen_commit_header(gw_trans, header->commit_id,
507 header->refs_str);
508 if (error)
509 goto done;
510 error = gw_gen_tree_header(gw_trans, header->tree_id);
511 if (error)
512 goto done;
513 error = gw_gen_author_header(gw_trans, header->author);
514 if (error)
515 goto done;
516 error = gw_gen_committer_header(gw_trans, header->author);
517 if (error)
518 goto done;
519 error = gw_get_time_str(&age, header->committer_time,
520 TM_LONG);
521 if (error)
522 goto done;
523 error = gw_gen_age_header(gw_trans, age ?age : "");
524 if (error)
525 goto done;
526 error = gw_gen_commit_msg_header(gw_trans, header->commit_msg);
527 if (error)
528 goto done;
529 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
530 if (kerr != KCGI_OK)
531 goto done;
532 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
533 "dotted_line", KATTR__MAX);
534 if (kerr != KCGI_OK)
535 goto done;
536 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
537 if (kerr != KCGI_OK)
538 goto done;
540 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
541 "diff", KATTR__MAX);
542 if (kerr != KCGI_OK)
543 goto done;
544 error = gw_output_diff(gw_trans, header);
545 if (error)
546 goto done;
548 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
549 done:
550 gw_free_header(header);
551 free(age);
552 if (error == NULL && kerr != KCGI_OK)
553 error = gw_kcgi_error(kerr);
554 return error;
557 static const struct got_error *
558 gw_index(struct gw_trans *gw_trans)
560 const struct got_error *error = NULL;
561 struct gw_dir *gw_dir = NULL;
562 char *href_next = NULL, *href_prev = NULL, *href_summary = NULL;
563 char *href_briefs = NULL, *href_commits = NULL, *href_tree = NULL;
564 char *href_tags = NULL;
565 unsigned int prev_disp = 0, next_disp = 1, dir_c = 0;
566 enum kcgi_err kerr = KCGI_OK;
568 #ifndef PROFILE
569 if (pledge("stdio rpath proc exec sendfd unveil",
570 NULL) == -1) {
571 error = got_error_from_errno("pledge");
572 return error;
574 #endif
575 error = gw_apply_unveil(gw_trans->gw_conf->got_repos_path);
576 if (error)
577 return error;
579 error = gw_load_got_paths(gw_trans);
580 if (error)
581 return error;
583 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
584 "index_header", KATTR__MAX);
585 if (kerr != KCGI_OK)
586 return gw_kcgi_error(kerr);
587 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
588 "index_header_project", KATTR__MAX);
589 if (kerr != KCGI_OK)
590 return gw_kcgi_error(kerr);
591 kerr = khtml_puts(gw_trans->gw_html_req, "Project");
592 if (kerr != KCGI_OK)
593 return gw_kcgi_error(kerr);
594 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
595 if (kerr != KCGI_OK)
596 return gw_kcgi_error(kerr);
598 if (gw_trans->gw_conf->got_show_repo_description) {
599 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
600 "index_header_description", KATTR__MAX);
601 if (kerr != KCGI_OK)
602 return gw_kcgi_error(kerr);
603 kerr = khtml_puts(gw_trans->gw_html_req, "Description");
604 if (kerr != KCGI_OK)
605 return gw_kcgi_error(kerr);
606 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
607 if (kerr != KCGI_OK)
608 return gw_kcgi_error(kerr);
611 if (gw_trans->gw_conf->got_show_repo_owner) {
612 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
613 "index_header_owner", KATTR__MAX);
614 if (kerr != KCGI_OK)
615 return gw_kcgi_error(kerr);
616 kerr = khtml_puts(gw_trans->gw_html_req, "Owner");
617 if (kerr != KCGI_OK)
618 return gw_kcgi_error(kerr);
619 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
620 if (kerr != KCGI_OK)
621 return gw_kcgi_error(kerr);
624 if (gw_trans->gw_conf->got_show_repo_age) {
625 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
626 "index_header_age", KATTR__MAX);
627 if (kerr != KCGI_OK)
628 return gw_kcgi_error(kerr);
629 kerr = khtml_puts(gw_trans->gw_html_req, "Last Change");
630 if (kerr != KCGI_OK)
631 return gw_kcgi_error(kerr);
632 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
633 if (kerr != KCGI_OK)
634 return gw_kcgi_error(kerr);
637 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
638 if (kerr != KCGI_OK)
639 return gw_kcgi_error(kerr);
641 if (TAILQ_EMPTY(&gw_trans->gw_dirs)) {
642 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
643 "index_wrapper", KATTR__MAX);
644 if (kerr != KCGI_OK)
645 return gw_kcgi_error(kerr);
646 kerr = khtml_printf(gw_trans->gw_html_req,
647 "No repositories found in %s",
648 gw_trans->gw_conf->got_repos_path);
649 if (kerr != KCGI_OK)
650 return gw_kcgi_error(kerr);
651 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
652 if (kerr != KCGI_OK)
653 return gw_kcgi_error(kerr);
654 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
655 "dotted_line", KATTR__MAX);
656 if (kerr != KCGI_OK)
657 return gw_kcgi_error(kerr);
658 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
659 if (kerr != KCGI_OK)
660 return gw_kcgi_error(kerr);
661 return error;
664 TAILQ_FOREACH(gw_dir, &gw_trans->gw_dirs, entry)
665 dir_c++;
667 TAILQ_FOREACH(gw_dir, &gw_trans->gw_dirs, entry) {
668 if (gw_trans->page > 0 && (gw_trans->page *
669 gw_trans->gw_conf->got_max_repos_display) > prev_disp) {
670 prev_disp++;
671 continue;
674 prev_disp++;
676 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
677 "index_wrapper", KATTR__MAX);
678 if (kerr != KCGI_OK)
679 goto done;
681 href_summary = khttp_urlpart(NULL, NULL, "gotweb", "path",
682 gw_dir->name, "action", "summary", NULL);
683 if (href_summary == NULL) {
684 error = got_error_from_errno("khttp_urlpart");
685 goto done;
687 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
688 "index_project", KATTR__MAX);
689 if (kerr != KCGI_OK)
690 goto done;
691 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF,
692 href_summary, KATTR__MAX);
693 if (kerr != KCGI_OK)
694 goto done;
695 kerr = khtml_puts(gw_trans->gw_html_req, gw_dir->name);
696 if (kerr != KCGI_OK)
697 goto done;
698 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
699 if (kerr != KCGI_OK)
700 goto done;
701 if (gw_trans->gw_conf->got_show_repo_description) {
702 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
703 KATTR_ID, "index_project_description", KATTR__MAX);
704 if (kerr != KCGI_OK)
705 goto done;
706 kerr = khtml_puts(gw_trans->gw_html_req,
707 gw_dir->description ? gw_dir->description : "");
708 if (kerr != KCGI_OK)
709 goto done;
710 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
711 if (kerr != KCGI_OK)
712 goto done;
714 if (gw_trans->gw_conf->got_show_repo_owner) {
715 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
716 KATTR_ID, "index_project_owner", KATTR__MAX);
717 if (kerr != KCGI_OK)
718 goto done;
719 kerr = khtml_puts(gw_trans->gw_html_req,
720 gw_dir->owner ? gw_dir->owner : "");
721 if (kerr != KCGI_OK)
722 goto done;
723 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
724 if (kerr != KCGI_OK)
725 goto done;
727 if (gw_trans->gw_conf->got_show_repo_age) {
728 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
729 KATTR_ID, "index_project_age", KATTR__MAX);
730 if (kerr != KCGI_OK)
731 goto done;
732 kerr = khtml_puts(gw_trans->gw_html_req,
733 gw_dir->age ? gw_dir->age : "");
734 if (kerr != KCGI_OK)
735 goto done;
736 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
737 if (kerr != KCGI_OK)
738 goto done;
741 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
742 "navs_wrapper", KATTR__MAX);
743 if (kerr != KCGI_OK)
744 goto done;
745 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
746 "navs", KATTR__MAX);
747 if (kerr != KCGI_OK)
748 goto done;
750 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF,
751 href_summary, KATTR__MAX);
752 if (kerr != KCGI_OK)
753 goto done;
754 kerr = khtml_puts(gw_trans->gw_html_req, "summary");
755 if (kerr != KCGI_OK)
756 goto done;
757 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
758 if (kerr != KCGI_OK)
759 goto done;
761 kerr = khtml_puts(gw_trans->gw_html_req, " | ");
762 if (kerr != KCGI_OK)
763 goto done;
765 href_briefs = khttp_urlpart(NULL, NULL, "gotweb", "path",
766 gw_dir->name, "action", "briefs", NULL);
767 if (href_briefs == NULL) {
768 error = got_error_from_errno("khttp_urlpart");
769 goto done;
771 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF,
772 href_briefs, KATTR__MAX);
773 if (kerr != KCGI_OK)
774 goto done;
775 kerr = khtml_puts(gw_trans->gw_html_req, "commit briefs");
776 if (kerr != KCGI_OK)
777 goto done;
778 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
779 if (kerr != KCGI_OK)
780 error = gw_kcgi_error(kerr);
782 kerr = khtml_puts(gw_trans->gw_html_req, " | ");
783 if (kerr != KCGI_OK)
784 goto done;
786 href_commits = khttp_urlpart(NULL, NULL, "gotweb", "path",
787 gw_dir->name, "action", "commits", NULL);
788 if (href_commits == NULL) {
789 error = got_error_from_errno("khttp_urlpart");
790 goto done;
792 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF,
793 href_commits, KATTR__MAX);
794 if (kerr != KCGI_OK)
795 goto done;
796 kerr = khtml_puts(gw_trans->gw_html_req, "commits");
797 if (kerr != KCGI_OK)
798 goto done;
799 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
800 if (kerr != KCGI_OK)
801 goto done;
803 kerr = khtml_puts(gw_trans->gw_html_req, " | ");
804 if (kerr != KCGI_OK)
805 goto done;
807 href_tags = khttp_urlpart(NULL, NULL, "gotweb", "path",
808 gw_dir->name, "action", "tags", NULL);
809 if (href_tags == NULL) {
810 error = got_error_from_errno("khttp_urlpart");
811 goto done;
813 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF,
814 href_tags, KATTR__MAX);
815 if (kerr != KCGI_OK)
816 goto done;
817 kerr = khtml_puts(gw_trans->gw_html_req, "tags");
818 if (kerr != KCGI_OK)
819 goto done;
820 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
821 if (kerr != KCGI_OK)
822 goto done;
824 kerr = khtml_puts(gw_trans->gw_html_req, " | ");
825 if (kerr != KCGI_OK)
826 goto done;
828 href_tree = khttp_urlpart(NULL, NULL, "gotweb", "path",
829 gw_dir->name, "action", "tree", NULL);
830 if (href_tree == NULL) {
831 error = got_error_from_errno("khttp_urlpart");
832 goto done;
834 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF,
835 href_tree, KATTR__MAX);
836 if (kerr != KCGI_OK)
837 goto done;
838 kerr = khtml_puts(gw_trans->gw_html_req, "tree");
839 if (kerr != KCGI_OK)
840 goto done;
842 kerr = khtml_closeelem(gw_trans->gw_html_req, 4);
843 if (kerr != KCGI_OK)
844 goto done;
845 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
846 "dotted_line", KATTR__MAX);
847 if (kerr != KCGI_OK)
848 goto done;
849 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
850 if (kerr != KCGI_OK)
851 goto done;
853 free(href_summary);
854 href_summary = NULL;
855 free(href_briefs);
856 href_briefs = NULL;
857 free(href_commits);
858 href_commits = NULL;
859 free(href_tags);
860 href_tags = NULL;
861 free(href_tree);
862 href_tree = NULL;
864 if (gw_trans->gw_conf->got_max_repos_display == 0)
865 continue;
867 if ((next_disp == gw_trans->gw_conf->got_max_repos_display) ||
868 ((gw_trans->gw_conf->got_max_repos_display > 0) &&
869 (gw_trans->page > 0) &&
870 (next_disp == gw_trans->gw_conf->got_max_repos_display ||
871 prev_disp == gw_trans->repos_total))) {
872 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
873 KATTR_ID, "np_wrapper", KATTR__MAX);
874 if (kerr != KCGI_OK)
875 goto done;
876 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
877 KATTR_ID, "nav_prev", KATTR__MAX);
878 if (kerr != KCGI_OK)
879 goto done;
882 if ((gw_trans->gw_conf->got_max_repos_display > 0) &&
883 (gw_trans->page > 0) &&
884 (next_disp == gw_trans->gw_conf->got_max_repos_display ||
885 prev_disp == gw_trans->repos_total)) {
886 href_prev = khttp_urlpartx(NULL, NULL, "gotweb", "page",
887 KATTRX_INT, (int64_t)(gw_trans->page - 1), NULL);
888 if (href_prev == NULL) {
889 error = got_error_from_errno("khttp_urlpartx");
890 goto done;
892 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
893 KATTR_HREF, href_prev, KATTR__MAX);
894 if (kerr != KCGI_OK)
895 goto done;
896 kerr = khtml_puts(gw_trans->gw_html_req, "Previous");
897 if (kerr != KCGI_OK)
898 goto done;
899 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
900 if (kerr != KCGI_OK)
901 goto done;
904 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
905 if (kerr != KCGI_OK)
906 return gw_kcgi_error(kerr);
908 if (gw_trans->gw_conf->got_max_repos_display > 0 &&
909 next_disp == gw_trans->gw_conf->got_max_repos_display &&
910 dir_c != (gw_trans->page + 1) *
911 gw_trans->gw_conf->got_max_repos_display) {
912 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
913 KATTR_ID, "nav_next", KATTR__MAX);
914 if (kerr != KCGI_OK)
915 goto done;
916 href_next = khttp_urlpartx(NULL, NULL, "gotweb", "page",
917 KATTRX_INT, (int64_t)(gw_trans->page + 1), NULL);
918 if (href_next == NULL) {
919 error = got_error_from_errno("khttp_urlpartx");
920 goto done;
922 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
923 KATTR_HREF, href_next, KATTR__MAX);
924 if (kerr != KCGI_OK)
925 goto done;
926 kerr = khtml_puts(gw_trans->gw_html_req, "Next");
927 if (kerr != KCGI_OK)
928 goto done;
929 kerr = khtml_closeelem(gw_trans->gw_html_req, 3);
930 if (kerr != KCGI_OK)
931 goto done;
932 next_disp = 0;
933 break;
936 if ((gw_trans->gw_conf->got_max_repos_display > 0) &&
937 (gw_trans->page > 0) &&
938 (next_disp == gw_trans->gw_conf->got_max_repos_display ||
939 prev_disp == gw_trans->repos_total)) {
940 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
941 if (kerr != KCGI_OK)
942 goto done;
944 next_disp++;
946 done:
947 free(href_prev);
948 free(href_next);
949 free(href_summary);
950 free(href_briefs);
951 free(href_commits);
952 free(href_tags);
953 free(href_tree);
954 if (error == NULL && kerr != KCGI_OK)
955 error = gw_kcgi_error(kerr);
956 return error;
959 static const struct got_error *
960 gw_commits(struct gw_trans *gw_trans)
962 const struct got_error *error = NULL;
963 struct gw_header *header = NULL, *n_header = NULL;
964 char *age = NULL, *href_diff = NULL, *href_tree = NULL;
965 char *href_prev = NULL, *href_next = NULL;
966 enum kcgi_err kerr = KCGI_OK;
967 int commit_found = 0;
969 if ((header = gw_init_header()) == NULL)
970 return got_error_from_errno("malloc");
972 #ifndef PROFILE
973 if (pledge("stdio rpath proc exec sendfd unveil",
974 NULL) == -1) {
975 error = got_error_from_errno("pledge");
976 goto done;
978 #endif
979 error = gw_apply_unveil(gw_trans->gw_dir->path);
980 if (error)
981 goto done;
983 error = gw_get_header(gw_trans, header,
984 gw_trans->gw_conf->got_max_commits_display);
985 if (error)
986 goto done;
988 TAILQ_FOREACH(n_header, &gw_trans->gw_headers, entry) {
989 if (commit_found == 0 && gw_trans->commit_id != NULL) {
990 if (strcmp(gw_trans->commit_id,
991 n_header->commit_id) != 0)
992 continue;
993 else
994 commit_found = 1;
996 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
997 "commits_line_wrapper", KATTR__MAX);
998 if (kerr != KCGI_OK)
999 goto done;
1000 error = gw_gen_commit_header(gw_trans, n_header->commit_id,
1001 n_header->refs_str);
1002 if (error)
1003 goto done;
1004 error = gw_gen_author_header(gw_trans, n_header->author);
1005 if (error)
1006 goto done;
1007 error = gw_gen_committer_header(gw_trans, n_header->author);
1008 if (error)
1009 goto done;
1010 error = gw_get_time_str(&age, n_header->committer_time,
1011 TM_LONG);
1012 if (error)
1013 goto done;
1014 error = gw_gen_age_header(gw_trans, age ?age : "");
1015 if (error)
1016 goto done;
1017 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
1018 if (kerr != KCGI_OK)
1019 goto done;
1021 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1022 "dotted_line", KATTR__MAX);
1023 if (kerr != KCGI_OK)
1024 goto done;
1025 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1026 if (kerr != KCGI_OK)
1027 goto done;
1029 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1030 "commit", KATTR__MAX);
1031 if (kerr != KCGI_OK)
1032 goto done;
1033 kerr = khttp_puts(gw_trans->gw_req, n_header->commit_msg);
1034 if (kerr != KCGI_OK)
1035 goto done;
1036 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1037 if (kerr != KCGI_OK)
1038 goto done;
1040 href_diff = khttp_urlpart(NULL, NULL, "gotweb", "path",
1041 gw_trans->repo_name, "action", "diff", "commit",
1042 n_header->commit_id, NULL);
1043 if (href_diff == NULL) {
1044 error = got_error_from_errno("khttp_urlpart");
1045 goto done;
1047 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1048 KATTR_ID, "navs_wrapper", KATTR__MAX);
1049 if (kerr != KCGI_OK)
1050 goto done;
1051 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1052 KATTR_ID, "navs", KATTR__MAX);
1053 if (kerr != KCGI_OK)
1054 goto done;
1055 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
1056 KATTR_HREF, href_diff, KATTR__MAX);
1057 if (kerr != KCGI_OK)
1058 goto done;
1059 kerr = khtml_puts(gw_trans->gw_html_req, "diff");
1060 if (kerr != KCGI_OK)
1061 goto done;
1062 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1063 if (kerr != KCGI_OK)
1064 goto done;
1066 kerr = khtml_puts(gw_trans->gw_html_req, " | ");
1067 if (kerr != KCGI_OK)
1068 goto done;
1070 href_tree = khttp_urlpart(NULL, NULL, "gotweb", "path",
1071 gw_trans->repo_name, "action", "tree", "commit",
1072 n_header->commit_id, NULL);
1073 if (href_tree == NULL) {
1074 error = got_error_from_errno("khttp_urlpart");
1075 goto done;
1077 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
1078 KATTR_HREF, href_tree, KATTR__MAX);
1079 if (kerr != KCGI_OK)
1080 goto done;
1081 khtml_puts(gw_trans->gw_html_req, "tree");
1082 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1083 if (kerr != KCGI_OK)
1084 goto done;
1085 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1086 if (kerr != KCGI_OK)
1087 goto done;
1089 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1090 "solid_line", KATTR__MAX);
1091 if (kerr != KCGI_OK)
1092 goto done;
1093 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
1094 if (kerr != KCGI_OK)
1095 goto done;
1097 free(age);
1098 age = NULL;
1101 if (gw_trans->next_id || gw_trans->prev_id) {
1102 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1103 KATTR_ID, "np_wrapper", KATTR__MAX);
1104 if (kerr != KCGI_OK)
1105 goto done;
1106 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1107 KATTR_ID, "nav_prev", KATTR__MAX);
1108 if (kerr != KCGI_OK)
1109 goto done;
1112 if (gw_trans->prev_id) {
1113 href_prev = khttp_urlpartx(NULL, NULL, "gotweb", "path",
1114 KATTRX_STRING, gw_trans->repo_name, "page",
1115 KATTRX_INT, (int64_t) (gw_trans->page - 1), "action",
1116 KATTRX_STRING, "commits", "commit", KATTRX_STRING,
1117 gw_trans->prev_id ? gw_trans->prev_id : "", NULL);
1118 if (href_prev == NULL) {
1119 error = got_error_from_errno("khttp_urlpartx");
1120 goto done;
1122 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
1123 KATTR_HREF, href_prev, KATTR__MAX);
1124 if (kerr != KCGI_OK)
1125 goto done;
1126 kerr = khtml_puts(gw_trans->gw_html_req, "Previous");
1127 if (kerr != KCGI_OK)
1128 goto done;
1129 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1130 if (kerr != KCGI_OK)
1131 goto done;
1134 if (gw_trans->next_id || gw_trans->page > 0) {
1135 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1136 if (kerr != KCGI_OK)
1137 return gw_kcgi_error(kerr);
1140 if (gw_trans->next_id) {
1141 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1142 KATTR_ID, "nav_next", KATTR__MAX);
1143 if (kerr != KCGI_OK)
1144 goto done;
1145 href_next = khttp_urlpartx(NULL, NULL, "gotweb", "path",
1146 KATTRX_STRING, gw_trans->repo_name, "page",
1147 KATTRX_INT, (int64_t) (gw_trans->page + 1), "action",
1148 KATTRX_STRING, "commits", "commit", KATTRX_STRING,
1149 gw_trans->next_id, NULL);
1150 if (href_next == NULL) {
1151 error = got_error_from_errno("khttp_urlpartx");
1152 goto done;
1154 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
1155 KATTR_HREF, href_next, KATTR__MAX);
1156 if (kerr != KCGI_OK)
1157 goto done;
1158 kerr = khtml_puts(gw_trans->gw_html_req, "Next");
1159 if (kerr != KCGI_OK)
1160 goto done;
1161 kerr = khtml_closeelem(gw_trans->gw_html_req, 3);
1162 if (kerr != KCGI_OK)
1163 goto done;
1166 if (gw_trans->next_id || gw_trans->page > 0) {
1167 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
1168 if (kerr != KCGI_OK)
1169 goto done;
1171 done:
1172 gw_free_header(header);
1173 TAILQ_FOREACH(n_header, &gw_trans->gw_headers, entry)
1174 gw_free_header(n_header);
1175 free(age);
1176 free(href_next);
1177 free(href_prev);
1178 free(href_diff);
1179 free(href_tree);
1180 if (error == NULL && kerr != KCGI_OK)
1181 error = gw_kcgi_error(kerr);
1182 return error;
1185 static const struct got_error *
1186 gw_briefs(struct gw_trans *gw_trans)
1188 const struct got_error *error = NULL;
1189 struct gw_header *header = NULL, *n_header = NULL;
1190 char *age = NULL, *href_diff = NULL, *href_tree = NULL;
1191 char *href_prev = NULL, *href_next = NULL;
1192 char *newline, *smallerthan;
1193 enum kcgi_err kerr = KCGI_OK;
1194 int commit_found = 0;
1196 if ((header = gw_init_header()) == NULL)
1197 return got_error_from_errno("malloc");
1199 #ifndef PROFILE
1200 if (pledge("stdio rpath proc exec sendfd unveil",
1201 NULL) == -1) {
1202 error = got_error_from_errno("pledge");
1203 goto done;
1205 #endif
1206 if (gw_trans->action != GW_SUMMARY) {
1207 error = gw_apply_unveil(gw_trans->gw_dir->path);
1208 if (error)
1209 goto done;
1212 if (gw_trans->action == GW_SUMMARY)
1213 error = gw_get_header(gw_trans, header, D_MAXSLCOMMDISP);
1214 else
1215 error = gw_get_header(gw_trans, header,
1216 gw_trans->gw_conf->got_max_commits_display);
1217 if (error)
1218 goto done;
1220 TAILQ_FOREACH(n_header, &gw_trans->gw_headers, entry) {
1221 if (commit_found == 0 && gw_trans->commit_id != NULL) {
1222 if (strcmp(gw_trans->commit_id,
1223 n_header->commit_id) != 0)
1224 continue;
1225 else
1226 commit_found = 1;
1228 error = gw_get_time_str(&age, n_header->committer_time,
1229 TM_DIFF);
1230 if (error)
1231 goto done;
1233 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1234 KATTR_ID, "briefs_wrapper", KATTR__MAX);
1235 if (kerr != KCGI_OK)
1236 goto done;
1238 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1239 KATTR_ID, "briefs_age", KATTR__MAX);
1240 if (kerr != KCGI_OK)
1241 goto done;
1242 kerr = khtml_puts(gw_trans->gw_html_req, age ? age : "");
1243 if (kerr != KCGI_OK)
1244 goto done;
1245 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1246 if (kerr != KCGI_OK)
1247 goto done;
1249 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1250 KATTR_ID, "briefs_author", KATTR__MAX);
1251 if (kerr != KCGI_OK)
1252 goto done;
1253 smallerthan = strchr(n_header->author, '<');
1254 if (smallerthan)
1255 *smallerthan = '\0';
1256 kerr = khtml_puts(gw_trans->gw_html_req, n_header->author);
1257 if (kerr != KCGI_OK)
1258 goto done;
1259 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1260 if (kerr != KCGI_OK)
1261 goto done;
1263 href_diff = khttp_urlpart(NULL, NULL, "gotweb", "path",
1264 gw_trans->repo_name, "action", "diff", "commit",
1265 n_header->commit_id, NULL);
1266 if (href_diff == NULL) {
1267 error = got_error_from_errno("khttp_urlpart");
1268 goto done;
1270 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1271 KATTR_ID, "briefs_log", KATTR__MAX);
1272 if (kerr != KCGI_OK)
1273 goto done;
1274 newline = strchr(n_header->commit_msg, '\n');
1275 if (newline)
1276 *newline = '\0';
1277 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
1278 KATTR_HREF, href_diff, KATTR__MAX);
1279 if (kerr != KCGI_OK)
1280 goto done;
1281 kerr = khtml_puts(gw_trans->gw_html_req, n_header->commit_msg);
1282 if (kerr != KCGI_OK)
1283 goto done;
1284 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1285 if (kerr != KCGI_OK)
1286 goto done;
1288 if (n_header->refs_str) {
1289 kerr = khtml_puts(gw_trans->gw_html_req, " ");
1290 if (kerr != KCGI_OK)
1291 goto done;
1292 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_SPAN,
1293 KATTR_ID, "refs_str", KATTR__MAX);
1294 if (kerr != KCGI_OK)
1295 goto done;
1296 kerr = khtml_printf(gw_trans->gw_html_req, "(%s)",
1297 n_header->refs_str);
1298 if (kerr != KCGI_OK)
1299 goto done;
1300 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1301 if (kerr != KCGI_OK)
1302 goto done;
1305 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1306 if (kerr != KCGI_OK)
1307 goto done;
1309 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1310 KATTR_ID, "navs_wrapper", KATTR__MAX);
1311 if (kerr != KCGI_OK)
1312 goto done;
1313 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1314 KATTR_ID, "navs", KATTR__MAX);
1315 if (kerr != KCGI_OK)
1316 goto done;
1317 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
1318 KATTR_HREF, href_diff, KATTR__MAX);
1319 if (kerr != KCGI_OK)
1320 goto done;
1321 kerr = khtml_puts(gw_trans->gw_html_req, "diff");
1322 if (kerr != KCGI_OK)
1323 goto done;
1324 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1325 if (kerr != KCGI_OK)
1326 goto done;
1328 kerr = khtml_puts(gw_trans->gw_html_req, " | ");
1329 if (kerr != KCGI_OK)
1330 goto done;
1332 href_tree = khttp_urlpart(NULL, NULL, "gotweb", "path",
1333 gw_trans->repo_name, "action", "tree", "commit",
1334 n_header->commit_id, NULL);
1335 if (href_tree == NULL) {
1336 error = got_error_from_errno("khttp_urlpart");
1337 goto done;
1339 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
1340 KATTR_HREF, href_tree, KATTR__MAX);
1341 if (kerr != KCGI_OK)
1342 goto done;
1343 khtml_puts(gw_trans->gw_html_req, "tree");
1344 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1345 if (kerr != KCGI_OK)
1346 goto done;
1347 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1348 if (kerr != KCGI_OK)
1349 goto done;
1351 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1352 KATTR_ID, "dotted_line", KATTR__MAX);
1353 if (kerr != KCGI_OK)
1354 goto done;
1355 kerr = khtml_closeelem(gw_trans->gw_html_req, 3);
1356 if (kerr != KCGI_OK)
1357 goto done;
1359 free(age);
1360 age = NULL;
1361 free(href_diff);
1362 href_diff = NULL;
1363 free(href_tree);
1364 href_tree = NULL;
1367 if (gw_trans->next_id || gw_trans->prev_id) {
1368 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1369 KATTR_ID, "np_wrapper", KATTR__MAX);
1370 if (kerr != KCGI_OK)
1371 goto done;
1372 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1373 KATTR_ID, "nav_prev", KATTR__MAX);
1374 if (kerr != KCGI_OK)
1375 goto done;
1378 if (gw_trans->prev_id) {
1379 href_prev = khttp_urlpartx(NULL, NULL, "gotweb", "path",
1380 KATTRX_STRING, gw_trans->repo_name, "page",
1381 KATTRX_INT, (int64_t) (gw_trans->page - 1), "action",
1382 KATTRX_STRING, "briefs", "commit", KATTRX_STRING,
1383 gw_trans->prev_id ? gw_trans->prev_id : "", NULL);
1384 if (href_prev == NULL) {
1385 error = got_error_from_errno("khttp_urlpartx");
1386 goto done;
1388 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
1389 KATTR_HREF, href_prev, KATTR__MAX);
1390 if (kerr != KCGI_OK)
1391 goto done;
1392 kerr = khtml_puts(gw_trans->gw_html_req, "Previous");
1393 if (kerr != KCGI_OK)
1394 goto done;
1395 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1396 if (kerr != KCGI_OK)
1397 goto done;
1400 if (gw_trans->next_id || gw_trans->page > 0) {
1401 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1402 if (kerr != KCGI_OK)
1403 return gw_kcgi_error(kerr);
1406 if (gw_trans->next_id) {
1407 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1408 KATTR_ID, "nav_next", KATTR__MAX);
1409 if (kerr != KCGI_OK)
1410 goto done;
1412 href_next = khttp_urlpartx(NULL, NULL, "gotweb", "path",
1413 KATTRX_STRING, gw_trans->repo_name, "page",
1414 KATTRX_INT, (int64_t) (gw_trans->page + 1), "action",
1415 KATTRX_STRING, "briefs", "commit", KATTRX_STRING,
1416 gw_trans->next_id, NULL);
1417 if (href_next == NULL) {
1418 error = got_error_from_errno("khttp_urlpartx");
1419 goto done;
1421 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
1422 KATTR_HREF, href_next, KATTR__MAX);
1423 if (kerr != KCGI_OK)
1424 goto done;
1425 kerr = khtml_puts(gw_trans->gw_html_req, "Next");
1426 if (kerr != KCGI_OK)
1427 goto done;
1428 kerr = khtml_closeelem(gw_trans->gw_html_req, 3);
1429 if (kerr != KCGI_OK)
1430 goto done;
1433 if (gw_trans->next_id || gw_trans->page > 0) {
1434 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
1435 if (kerr != KCGI_OK)
1436 goto done;
1438 done:
1439 gw_free_header(header);
1440 TAILQ_FOREACH(n_header, &gw_trans->gw_headers, entry)
1441 gw_free_header(n_header);
1442 free(age);
1443 free(href_next);
1444 free(href_prev);
1445 free(href_diff);
1446 free(href_tree);
1447 if (error == NULL && kerr != KCGI_OK)
1448 error = gw_kcgi_error(kerr);
1449 return error;
1452 static const struct got_error *
1453 gw_summary(struct gw_trans *gw_trans)
1455 const struct got_error *error = NULL;
1456 char *age = NULL;
1457 enum kcgi_err kerr = KCGI_OK;
1459 #ifndef PROFILE
1460 if (pledge("stdio rpath proc exec sendfd unveil", NULL) == -1)
1461 return got_error_from_errno("pledge");
1462 #endif
1463 error = gw_apply_unveil(gw_trans->gw_dir->path);
1464 if (error)
1465 goto done;
1467 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1468 "summary_wrapper", KATTR__MAX);
1469 if (kerr != KCGI_OK)
1470 return gw_kcgi_error(kerr);
1472 if (gw_trans->gw_conf->got_show_repo_description &&
1473 gw_trans->gw_dir->description != NULL &&
1474 (strcmp(gw_trans->gw_dir->description, "") != 0)) {
1475 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1476 KATTR_ID, "description_title", KATTR__MAX);
1477 if (kerr != KCGI_OK)
1478 goto done;
1479 kerr = khtml_puts(gw_trans->gw_html_req, "Description: ");
1480 if (kerr != KCGI_OK)
1481 goto done;
1482 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1483 if (kerr != KCGI_OK)
1484 goto done;
1485 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1486 KATTR_ID, "description", KATTR__MAX);
1487 if (kerr != KCGI_OK)
1488 goto done;
1489 kerr = khtml_puts(gw_trans->gw_html_req,
1490 gw_trans->gw_dir->description);
1491 if (kerr != KCGI_OK)
1492 goto done;
1493 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1494 if (kerr != KCGI_OK)
1495 goto done;
1498 if (gw_trans->gw_conf->got_show_repo_owner &&
1499 gw_trans->gw_dir->owner != NULL &&
1500 (strcmp(gw_trans->gw_dir->owner, "") != 0)) {
1501 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1502 KATTR_ID, "repo_owner_title", KATTR__MAX);
1503 if (kerr != KCGI_OK)
1504 goto done;
1505 kerr = khtml_puts(gw_trans->gw_html_req, "Owner: ");
1506 if (kerr != KCGI_OK)
1507 goto done;
1508 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1509 if (kerr != KCGI_OK)
1510 goto done;
1511 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1512 KATTR_ID, "repo_owner", KATTR__MAX);
1513 if (kerr != KCGI_OK)
1514 goto done;
1515 kerr = khtml_puts(gw_trans->gw_html_req,
1516 gw_trans->gw_dir->owner);
1517 if (kerr != KCGI_OK)
1518 goto done;
1519 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1520 if (kerr != KCGI_OK)
1521 goto done;
1524 if (gw_trans->gw_conf->got_show_repo_age) {
1525 error = gw_get_repo_age(&age, gw_trans, gw_trans->gw_dir->path,
1526 NULL, TM_LONG);
1527 if (error)
1528 goto done;
1529 if (age != NULL) {
1530 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1531 KATTR_ID, "last_change_title", KATTR__MAX);
1532 if (kerr != KCGI_OK)
1533 goto done;
1534 kerr = khtml_puts(gw_trans->gw_html_req,
1535 "Last Change: ");
1536 if (kerr != KCGI_OK)
1537 goto done;
1538 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1539 if (kerr != KCGI_OK)
1540 goto done;
1541 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1542 KATTR_ID, "last_change", KATTR__MAX);
1543 if (kerr != KCGI_OK)
1544 goto done;
1545 kerr = khtml_puts(gw_trans->gw_html_req, age);
1546 if (kerr != KCGI_OK)
1547 goto done;
1548 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1549 if (kerr != KCGI_OK)
1550 goto done;
1554 if (gw_trans->gw_conf->got_show_repo_cloneurl &&
1555 gw_trans->gw_dir->url != NULL &&
1556 (strcmp(gw_trans->gw_dir->url, "") != 0)) {
1557 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1558 KATTR_ID, "cloneurl_title", KATTR__MAX);
1559 if (kerr != KCGI_OK)
1560 goto done;
1561 kerr = khtml_puts(gw_trans->gw_html_req, "Clone URL: ");
1562 if (kerr != KCGI_OK)
1563 goto done;
1564 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1565 if (kerr != KCGI_OK)
1566 goto done;
1567 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1568 KATTR_ID, "cloneurl", KATTR__MAX);
1569 if (kerr != KCGI_OK)
1570 goto done;
1571 kerr = khtml_puts(gw_trans->gw_html_req, gw_trans->gw_dir->url);
1572 if (kerr != KCGI_OK)
1573 goto done;
1574 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1575 if (kerr != KCGI_OK)
1576 goto done;
1579 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1580 if (kerr != KCGI_OK)
1581 goto done;
1583 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1584 "briefs_title_wrapper", KATTR__MAX);
1585 if (kerr != KCGI_OK)
1586 goto done;
1587 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1588 "briefs_title", KATTR__MAX);
1589 if (kerr != KCGI_OK)
1590 goto done;
1591 kerr = khtml_puts(gw_trans->gw_html_req, "Commit Briefs");
1592 if (kerr != KCGI_OK)
1593 goto done;
1594 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
1595 if (kerr != KCGI_OK)
1596 goto done;
1597 error = gw_briefs(gw_trans);
1598 if (error)
1599 goto done;
1601 error = gw_tags(gw_trans);
1602 if (error)
1603 goto done;
1605 error = gw_output_repo_heads(gw_trans);
1606 done:
1607 free(age);
1608 if (error == NULL && kerr != KCGI_OK)
1609 error = gw_kcgi_error(kerr);
1610 return error;
1613 static const struct got_error *
1614 gw_tree(struct gw_trans *gw_trans)
1616 const struct got_error *error = NULL;
1617 struct gw_header *header = NULL;
1618 char *tree = NULL, *tree_html = NULL, *tree_html_disp = NULL;
1619 char *age = NULL;
1620 enum kcgi_err kerr = KCGI_OK;
1622 #ifndef PROFILE
1623 if (pledge("stdio rpath proc exec sendfd unveil", NULL) == -1)
1624 return got_error_from_errno("pledge");
1625 #endif
1626 if ((header = gw_init_header()) == NULL)
1627 return got_error_from_errno("malloc");
1629 error = gw_apply_unveil(gw_trans->gw_dir->path);
1630 if (error)
1631 goto done;
1633 error = gw_get_header(gw_trans, header, 1);
1634 if (error)
1635 goto done;
1637 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1638 "tree_header_wrapper", KATTR__MAX);
1639 if (kerr != KCGI_OK)
1640 goto done;
1641 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1642 "tree_header", KATTR__MAX);
1643 if (kerr != KCGI_OK)
1644 goto done;
1645 error = gw_gen_tree_header(gw_trans, header->tree_id);
1646 if (error)
1647 goto done;
1648 error = gw_get_time_str(&age, header->committer_time,
1649 TM_LONG);
1650 if (error)
1651 goto done;
1652 error = gw_gen_age_header(gw_trans, age ?age : "");
1653 if (error)
1654 goto done;
1655 error = gw_gen_commit_msg_header(gw_trans, header->commit_msg);
1656 if (error)
1657 goto done;
1658 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
1659 if (kerr != KCGI_OK)
1660 goto done;
1661 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1662 "dotted_line", KATTR__MAX);
1663 if (kerr != KCGI_OK)
1664 goto done;
1665 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1666 if (kerr != KCGI_OK)
1667 goto done;
1669 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1670 "tree", KATTR__MAX);
1671 if (kerr != KCGI_OK)
1672 goto done;
1673 error = gw_output_repo_tree(gw_trans, header);
1674 if (error)
1675 goto done;
1677 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1678 done:
1679 gw_free_header(header);
1680 free(tree_html_disp);
1681 free(tree_html);
1682 free(tree);
1683 free(age);
1684 if (error == NULL && kerr != KCGI_OK)
1685 error = gw_kcgi_error(kerr);
1686 return error;
1689 static const struct got_error *
1690 gw_tags(struct gw_trans *gw_trans)
1692 const struct got_error *error = NULL;
1693 struct gw_header *header = NULL;
1694 char *href_next = NULL, *href_prev = NULL;
1695 enum kcgi_err kerr = KCGI_OK;
1697 #ifndef PROFILE
1698 if (pledge("stdio rpath proc exec sendfd unveil", NULL) == -1)
1699 return got_error_from_errno("pledge");
1700 #endif
1701 if ((header = gw_init_header()) == NULL)
1702 return got_error_from_errno("malloc");
1704 if (gw_trans->action != GW_SUMMARY) {
1705 error = gw_apply_unveil(gw_trans->gw_dir->path);
1706 if (error)
1707 goto done;
1710 error = gw_get_header(gw_trans, header, 1);
1711 if (error)
1712 goto done;
1714 if (gw_trans->action == GW_SUMMARY) {
1715 gw_trans->next_id = NULL;
1716 error = gw_output_repo_tags(gw_trans, header,
1717 D_MAXSLCOMMDISP, TAGBRIEF);
1718 if (error)
1719 goto done;
1720 } else {
1721 error = gw_output_repo_tags(gw_trans, header,
1722 gw_trans->gw_conf->got_max_commits_display, TAGBRIEF);
1723 if (error)
1724 goto done;
1727 if (gw_trans->next_id || gw_trans->page > 0) {
1728 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1729 KATTR_ID, "np_wrapper", KATTR__MAX);
1730 if (kerr != KCGI_OK)
1731 goto done;
1732 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1733 KATTR_ID, "nav_prev", KATTR__MAX);
1734 if (kerr != KCGI_OK)
1735 goto done;
1738 if (gw_trans->prev_id) {
1739 href_prev = khttp_urlpartx(NULL, NULL, "gotweb", "path",
1740 KATTRX_STRING, gw_trans->repo_name, "page",
1741 KATTRX_INT, (int64_t) (gw_trans->page - 1), "action",
1742 KATTRX_STRING, "tags", "commit", KATTRX_STRING,
1743 gw_trans->prev_id ? gw_trans->prev_id : "", NULL);
1744 if (href_prev == NULL) {
1745 error = got_error_from_errno("khttp_urlpartx");
1746 goto done;
1748 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
1749 KATTR_HREF, href_prev, KATTR__MAX);
1750 if (kerr != KCGI_OK)
1751 goto done;
1752 kerr = khtml_puts(gw_trans->gw_html_req, "Previous");
1753 if (kerr != KCGI_OK)
1754 goto done;
1755 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1756 if (kerr != KCGI_OK)
1757 goto done;
1760 if (gw_trans->next_id || gw_trans->page > 0) {
1761 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1762 if (kerr != KCGI_OK)
1763 return gw_kcgi_error(kerr);
1766 if (gw_trans->next_id) {
1767 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
1768 KATTR_ID, "nav_next", KATTR__MAX);
1769 if (kerr != KCGI_OK)
1770 goto done;
1771 href_next = khttp_urlpartx(NULL, NULL, "gotweb", "path",
1772 KATTRX_STRING, gw_trans->repo_name, "page",
1773 KATTRX_INT, (int64_t) (gw_trans->page + 1), "action",
1774 KATTRX_STRING, "tags", "commit", KATTRX_STRING,
1775 gw_trans->next_id, NULL);
1776 if (href_next == NULL) {
1777 error = got_error_from_errno("khttp_urlpartx");
1778 goto done;
1780 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
1781 KATTR_HREF, href_next, KATTR__MAX);
1782 if (kerr != KCGI_OK)
1783 goto done;
1784 kerr = khtml_puts(gw_trans->gw_html_req, "Next");
1785 if (kerr != KCGI_OK)
1786 goto done;
1787 kerr = khtml_closeelem(gw_trans->gw_html_req, 3);
1788 if (kerr != KCGI_OK)
1789 goto done;
1792 if (gw_trans->next_id || gw_trans->page > 0) {
1793 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
1794 if (kerr != KCGI_OK)
1795 goto done;
1797 done:
1798 gw_free_header(header);
1799 free(href_next);
1800 free(href_prev);
1801 if (error == NULL && kerr != KCGI_OK)
1802 error = gw_kcgi_error(kerr);
1803 return error;
1806 static const struct got_error *
1807 gw_tag(struct gw_trans *gw_trans)
1809 const struct got_error *error = NULL;
1810 struct gw_header *header = NULL;
1811 enum kcgi_err kerr = KCGI_OK;
1813 #ifndef PROFILE
1814 if (pledge("stdio rpath proc exec sendfd unveil", NULL) == -1)
1815 return got_error_from_errno("pledge");
1816 #endif
1817 if ((header = gw_init_header()) == NULL)
1818 return got_error_from_errno("malloc");
1820 error = gw_apply_unveil(gw_trans->gw_dir->path);
1821 if (error)
1822 goto done;
1824 if (gw_trans->commit_id == NULL) {
1825 error = got_error_msg(GOT_ERR_QUERYSTRING,
1826 "commit required in querystring");
1827 goto done;
1830 error = gw_get_header(gw_trans, header, 1);
1831 if (error)
1832 goto done;
1834 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1835 "tag_header_wrapper", KATTR__MAX);
1836 if (kerr != KCGI_OK)
1837 goto done;
1838 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1839 "tag_header", KATTR__MAX);
1840 if (kerr != KCGI_OK)
1841 goto done;
1842 error = gw_gen_commit_header(gw_trans, header->commit_id,
1843 header->refs_str);
1844 if (error)
1845 goto done;
1846 error = gw_gen_commit_msg_header(gw_trans, header->commit_msg);
1847 if (error)
1848 goto done;
1849 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
1850 if (kerr != KCGI_OK)
1851 goto done;
1852 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1853 "dotted_line", KATTR__MAX);
1854 if (kerr != KCGI_OK)
1855 goto done;
1856 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1857 if (kerr != KCGI_OK)
1858 goto done;
1860 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
1861 "tree", KATTR__MAX);
1862 if (kerr != KCGI_OK)
1863 goto done;
1865 error = gw_output_repo_tags(gw_trans, header, 1, TAGFULL);
1866 if (error)
1867 goto done;
1869 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
1870 done:
1871 gw_free_header(header);
1872 if (error == NULL && kerr != KCGI_OK)
1873 error = gw_kcgi_error(kerr);
1874 return error;
1877 static const struct got_error *
1878 gw_load_got_path(struct gw_trans *gw_trans, struct gw_dir *gw_dir)
1880 const struct got_error *error = NULL;
1881 DIR *dt;
1882 char *dir_test;
1883 int opened = 0;
1885 if (asprintf(&dir_test, "%s/%s/%s",
1886 gw_trans->gw_conf->got_repos_path, gw_dir->name,
1887 GOTWEB_GIT_DIR) == -1)
1888 return got_error_from_errno("asprintf");
1890 dt = opendir(dir_test);
1891 if (dt == NULL) {
1892 free(dir_test);
1893 } else {
1894 gw_dir->path = strdup(dir_test);
1895 if (gw_dir->path == NULL) {
1896 opened = 1;
1897 error = got_error_from_errno("strdup");
1898 goto errored;
1900 opened = 1;
1901 goto done;
1904 if (asprintf(&dir_test, "%s/%s/%s",
1905 gw_trans->gw_conf->got_repos_path, gw_dir->name,
1906 GOTWEB_GOT_DIR) == -1) {
1907 dir_test = NULL;
1908 error = got_error_from_errno("asprintf");
1909 goto errored;
1912 dt = opendir(dir_test);
1913 if (dt == NULL)
1914 free(dir_test);
1915 else {
1916 opened = 1;
1917 error = got_error(GOT_ERR_NOT_GIT_REPO);
1918 goto errored;
1921 if (asprintf(&dir_test, "%s/%s",
1922 gw_trans->gw_conf->got_repos_path, gw_dir->name) == -1) {
1923 error = got_error_from_errno("asprintf");
1924 dir_test = NULL;
1925 goto errored;
1928 gw_dir->path = strdup(dir_test);
1929 if (gw_dir->path == NULL) {
1930 opened = 1;
1931 error = got_error_from_errno("strdup");
1932 goto errored;
1935 dt = opendir(dir_test);
1936 if (dt == NULL) {
1937 error = got_error_path(gw_dir->name, GOT_ERR_NOT_GIT_REPO);
1938 goto errored;
1939 } else
1940 opened = 1;
1941 done:
1942 error = gw_get_repo_description(&gw_dir->description, gw_trans,
1943 gw_dir->path);
1944 if (error)
1945 goto errored;
1946 error = gw_get_repo_owner(&gw_dir->owner, gw_trans, gw_dir->path);
1947 if (error)
1948 goto errored;
1949 error = gw_get_repo_age(&gw_dir->age, gw_trans, gw_dir->path,
1950 NULL, TM_DIFF);
1951 if (error)
1952 goto errored;
1953 error = gw_get_clone_url(&gw_dir->url, gw_trans, gw_dir->path);
1954 errored:
1955 free(dir_test);
1956 if (opened)
1957 if (dt && closedir(dt) == -1 && error == NULL)
1958 error = got_error_from_errno("closedir");
1959 return error;
1962 static const struct got_error *
1963 gw_load_got_paths(struct gw_trans *gw_trans)
1965 const struct got_error *error = NULL;
1966 DIR *d;
1967 struct dirent **sd_dent;
1968 struct gw_dir *gw_dir;
1969 struct stat st;
1970 unsigned int d_cnt, d_i;
1972 d = opendir(gw_trans->gw_conf->got_repos_path);
1973 if (d == NULL) {
1974 error = got_error_from_errno2("opendir",
1975 gw_trans->gw_conf->got_repos_path);
1976 return error;
1979 d_cnt = scandir(gw_trans->gw_conf->got_repos_path, &sd_dent, NULL,
1980 alphasort);
1981 if (d_cnt == -1) {
1982 error = got_error_from_errno2("scandir",
1983 gw_trans->gw_conf->got_repos_path);
1984 goto done;
1987 for (d_i = 0; d_i < d_cnt; d_i++) {
1988 if (gw_trans->gw_conf->got_max_repos > 0 &&
1989 (d_i - 2) == gw_trans->gw_conf->got_max_repos)
1990 break; /* account for parent and self */
1992 if (strcmp(sd_dent[d_i]->d_name, ".") == 0 ||
1993 strcmp(sd_dent[d_i]->d_name, "..") == 0)
1994 continue;
1996 error = gw_init_gw_dir(&gw_dir, sd_dent[d_i]->d_name);
1997 if (error)
1998 goto done;
2000 error = gw_load_got_path(gw_trans, gw_dir);
2001 if (error && error->code == GOT_ERR_NOT_GIT_REPO) {
2002 error = NULL;
2003 continue;
2004 } else if (error && error->code != GOT_ERR_LONELY_PACKIDX)
2005 goto done;
2007 if (lstat(gw_dir->path, &st) == 0 && S_ISDIR(st.st_mode) &&
2008 !got_path_dir_is_empty(gw_dir->path)) {
2009 TAILQ_INSERT_TAIL(&gw_trans->gw_dirs, gw_dir,
2010 entry);
2011 gw_trans->repos_total++;
2014 done:
2015 if (d && closedir(d) == -1 && error == NULL)
2016 error = got_error_from_errno("closedir");
2017 return error;
2020 static const struct got_error *
2021 gw_parse_querystring(struct gw_trans *gw_trans)
2023 const struct got_error *error = NULL;
2024 struct kpair *p;
2025 const struct gw_query_action *action = NULL;
2026 unsigned int i;
2028 if (gw_trans->gw_req->fieldnmap[0]) {
2029 return got_error(GOT_ERR_QUERYSTRING);
2030 } else if ((p = gw_trans->gw_req->fieldmap[KEY_PATH])) {
2031 /* define gw_trans->repo_path */
2032 gw_trans->repo_name = p->parsed.s;
2034 if (asprintf(&gw_trans->repo_path, "%s/%s",
2035 gw_trans->gw_conf->got_repos_path, p->parsed.s) == -1)
2036 return got_error_from_errno("asprintf");
2038 /* get action and set function */
2039 if ((p = gw_trans->gw_req->fieldmap[KEY_ACTION])) {
2040 for (i = 0; i < nitems(gw_query_funcs); i++) {
2041 action = &gw_query_funcs[i];
2042 if (action->func_name == NULL)
2043 continue;
2044 if (strcmp(action->func_name,
2045 p->parsed.s) == 0) {
2046 gw_trans->action = i;
2047 break;
2051 if (gw_trans->action == -1) {
2052 gw_trans->action = GW_ERR;
2053 gw_trans->error = got_error_msg(GOT_ERR_QUERYSTRING,
2054 p != NULL ? "bad action in querystring" :
2055 "no action in querystring");
2056 return error;
2059 if ((p = gw_trans->gw_req->fieldmap[KEY_COMMIT_ID])) {
2060 if (asprintf(&gw_trans->commit_id, "%s",
2061 p->parsed.s) == -1)
2062 return got_error_from_errno("asprintf");
2065 if ((p = gw_trans->gw_req->fieldmap[KEY_FILE]))
2066 gw_trans->repo_file = p->parsed.s;
2068 if ((p = gw_trans->gw_req->fieldmap[KEY_FOLDER])) {
2069 if (asprintf(&gw_trans->repo_folder, "%s",
2070 p->parsed.s) == -1)
2071 return got_error_from_errno("asprintf");
2074 if ((p = gw_trans->gw_req->fieldmap[KEY_PREV_ID])) {
2075 if (asprintf(&gw_trans->prev_id, "%s",
2076 p->parsed.s) == -1)
2077 return got_error_from_errno("asprintf");
2080 if ((p = gw_trans->gw_req->fieldmap[KEY_HEADREF]))
2081 gw_trans->headref = p->parsed.s;
2083 error = gw_init_gw_dir(&gw_trans->gw_dir, gw_trans->repo_name);
2084 if (error)
2085 return error;
2087 gw_trans->error = gw_load_got_path(gw_trans, gw_trans->gw_dir);
2088 } else
2089 gw_trans->action = GW_INDEX;
2091 if ((p = gw_trans->gw_req->fieldmap[KEY_PAGE]))
2092 gw_trans->page = p->parsed.i;
2094 return error;
2097 static const struct got_error *
2098 gw_init_gw_dir(struct gw_dir **gw_dir, const char *dir)
2100 const struct got_error *error;
2102 *gw_dir = malloc(sizeof(**gw_dir));
2103 if (*gw_dir == NULL)
2104 return got_error_from_errno("malloc");
2106 if (asprintf(&(*gw_dir)->name, "%s", dir) == -1) {
2107 error = got_error_from_errno("asprintf");
2108 free(*gw_dir);
2109 *gw_dir = NULL;
2110 return error;
2113 return NULL;
2116 static const struct got_error *
2117 gw_display_open(struct gw_trans *gw_trans, enum khttp code, enum kmime mime)
2119 enum kcgi_err kerr = KCGI_OK;
2121 kerr = khttp_head(gw_trans->gw_req, kresps[KRESP_ALLOW], "GET");
2122 if (kerr != KCGI_OK)
2123 return gw_kcgi_error(kerr);
2124 kerr = khttp_head(gw_trans->gw_req, kresps[KRESP_STATUS], "%s",
2125 khttps[code]);
2126 if (kerr != KCGI_OK)
2127 return gw_kcgi_error(kerr);
2128 kerr = khttp_head(gw_trans->gw_req, kresps[KRESP_CONTENT_TYPE], "%s",
2129 kmimetypes[mime]);
2130 if (kerr != KCGI_OK)
2131 return gw_kcgi_error(kerr);
2132 kerr = khttp_head(gw_trans->gw_req, "X-Content-Type-Options",
2133 "nosniff");
2134 if (kerr != KCGI_OK)
2135 return gw_kcgi_error(kerr);
2136 kerr = khttp_head(gw_trans->gw_req, "X-Frame-Options", "DENY");
2137 if (kerr != KCGI_OK)
2138 return gw_kcgi_error(kerr);
2139 kerr = khttp_head(gw_trans->gw_req, "X-XSS-Protection",
2140 "1; mode=block");
2141 if (kerr != KCGI_OK)
2142 return gw_kcgi_error(kerr);
2144 if (gw_trans->mime == KMIME_APP_OCTET_STREAM) {
2145 kerr = khttp_head(gw_trans->gw_req,
2146 kresps[KRESP_CONTENT_DISPOSITION],
2147 "attachment; filename=%s", gw_trans->repo_file);
2148 if (kerr != KCGI_OK)
2149 return gw_kcgi_error(kerr);
2152 kerr = khttp_body(gw_trans->gw_req);
2153 return gw_kcgi_error(kerr);
2156 static const struct got_error *
2157 gw_display_index(struct gw_trans *gw_trans)
2159 const struct got_error *error;
2160 enum kcgi_err kerr = KCGI_OK;
2162 /* catch early querystring errors */
2163 if (gw_trans->error)
2164 gw_trans->action = GW_ERR;
2166 error = gw_display_open(gw_trans, KHTTP_200, gw_trans->mime);
2167 if (error)
2168 return error;
2170 kerr = khtml_open(gw_trans->gw_html_req, gw_trans->gw_req, 0);
2171 if (kerr != KCGI_OK)
2172 return gw_kcgi_error(kerr);
2174 if (gw_trans->action != GW_BLOB) {
2175 kerr = khttp_template(gw_trans->gw_req, gw_trans->gw_tmpl,
2176 gw_query_funcs[gw_trans->action].template);
2177 if (kerr != KCGI_OK) {
2178 khtml_close(gw_trans->gw_html_req);
2179 return gw_kcgi_error(kerr);
2183 return gw_kcgi_error(khtml_close(gw_trans->gw_html_req));
2186 static const struct got_error *
2187 gw_error(struct gw_trans *gw_trans)
2189 enum kcgi_err kerr = KCGI_OK;
2191 kerr = khtml_puts(gw_trans->gw_html_req, gw_trans->error->msg);
2193 return gw_kcgi_error(kerr);
2196 static int
2197 gw_template(size_t key, void *arg)
2199 const struct got_error *error = NULL;
2200 enum kcgi_err kerr = KCGI_OK;
2201 struct gw_trans *gw_trans = arg;
2202 char *ati = NULL, *fic32 = NULL, *fic16 = NULL;
2203 char *swm = NULL, *spt = NULL, *css = NULL, *logo = NULL;
2205 if (asprintf(&ati, "%s%s", gw_trans->gw_conf->got_www_path,
2206 "/apple-touch-icon.png") == -1)
2207 goto err;
2208 if (asprintf(&fic32, "%s%s", gw_trans->gw_conf->got_www_path,
2209 "/favicon-32x32.png") == -1)
2210 goto err;
2211 if (asprintf(&fic16, "%s%s", gw_trans->gw_conf->got_www_path,
2212 "/favicon-16x16.png") == -1)
2213 goto err;
2214 if (asprintf(&swm, "%s%s", gw_trans->gw_conf->got_www_path,
2215 "/site.webmanifest") == -1)
2216 goto err;
2217 if (asprintf(&spt, "%s%s", gw_trans->gw_conf->got_www_path,
2218 "/safari-pinned-tab.svg") == -1)
2219 goto err;
2220 if (asprintf(&css, "%s%s", gw_trans->gw_conf->got_www_path,
2221 "/gotweb.css") == -1)
2222 goto err;
2223 if (asprintf(&logo, "%s%s%s", gw_trans->gw_conf->got_www_path,
2224 gw_trans->gw_conf->got_www_path ? "/" : "",
2225 gw_trans->gw_conf->got_logo) == -1)
2226 goto err;
2228 switch (key) {
2229 case (TEMPL_HEAD):
2230 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_META,
2231 KATTR_NAME, "viewport",
2232 KATTR_CONTENT, "initial-scale=.75, user-scalable=yes",
2233 KATTR__MAX);
2234 if (kerr != KCGI_OK)
2235 return 0;
2236 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2237 if (kerr != KCGI_OK)
2238 return 0;
2239 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_META,
2240 KATTR_CHARSET, "utf-8",
2241 KATTR__MAX);
2242 if (kerr != KCGI_OK)
2243 return 0;
2244 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2245 if (kerr != KCGI_OK)
2246 return 0;
2247 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_META,
2248 KATTR_NAME, "msapplication-TileColor",
2249 KATTR_CONTENT, "#da532c", KATTR__MAX);
2250 if (kerr != KCGI_OK)
2251 return 0;
2252 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2253 if (kerr != KCGI_OK)
2254 return 0;
2255 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_META,
2256 KATTR_NAME, "theme-color",
2257 KATTR_CONTENT, "#ffffff", KATTR__MAX);
2258 if (kerr != KCGI_OK)
2259 return 0;
2260 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2261 if (kerr != KCGI_OK)
2262 return 0;
2263 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_LINK,
2264 KATTR_REL, "apple-touch-icon", KATTR_SIZES, "180x180",
2265 KATTR_HREF, ati, KATTR__MAX);
2266 if (kerr != KCGI_OK)
2267 return 0;
2268 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2269 if (kerr != KCGI_OK)
2270 return 0;
2271 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_LINK,
2272 KATTR_REL, "icon", KATTR_TYPE, "image/png", KATTR_SIZES,
2273 "32x32", KATTR_HREF, fic32, KATTR__MAX);
2274 if (kerr != KCGI_OK)
2275 return 0;
2276 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2277 if (kerr != KCGI_OK)
2278 return 0;
2279 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_LINK,
2280 KATTR_REL, "icon", KATTR_TYPE, "image/png", KATTR_SIZES,
2281 "16x16", KATTR_HREF, fic16, KATTR__MAX);
2282 if (kerr != KCGI_OK)
2283 return 0;
2284 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2285 if (kerr != KCGI_OK)
2286 return 0;
2287 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_LINK,
2288 KATTR_REL, "manifest", KATTR_HREF, swm,
2289 KATTR__MAX);
2290 if (kerr != KCGI_OK)
2291 return 0;
2292 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2293 if (kerr != KCGI_OK)
2294 return 0;
2295 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_LINK,
2296 KATTR_REL, "mask-icon", KATTR_HREF,
2297 spt, KATTR__MAX);
2298 if (kerr != KCGI_OK)
2299 return 0;
2300 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2301 if (kerr != KCGI_OK)
2302 return 0;
2303 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_LINK,
2304 KATTR_REL, "stylesheet", KATTR_TYPE, "text/css",
2305 KATTR_HREF, css, KATTR__MAX);
2306 if (kerr != KCGI_OK)
2307 return 0;
2308 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2309 if (kerr != KCGI_OK)
2310 return 0;
2311 break;
2312 case(TEMPL_HEADER):
2313 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2314 KATTR_ID, "got_link", KATTR__MAX);
2315 if (kerr != KCGI_OK)
2316 return 0;
2317 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
2318 KATTR_HREF, gw_trans->gw_conf->got_logo_url,
2319 KATTR_TARGET, "_sotd", KATTR__MAX);
2320 if (kerr != KCGI_OK)
2321 return 0;
2322 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_IMG,
2323 KATTR_SRC, logo, KATTR__MAX);
2324 if (kerr != KCGI_OK)
2325 return 0;
2326 kerr = khtml_closeelem(gw_trans->gw_html_req, 3);
2327 if (kerr != KCGI_OK)
2328 return 0;
2329 break;
2330 case (TEMPL_SITEPATH):
2331 error = gw_output_site_link(gw_trans);
2332 if (error)
2333 return 0;
2334 break;
2335 case(TEMPL_TITLE):
2336 if (gw_trans->gw_conf->got_site_name != NULL) {
2337 kerr = khtml_puts(gw_trans->gw_html_req,
2338 gw_trans->gw_conf->got_site_name);
2339 if (kerr != KCGI_OK)
2340 return 0;
2342 break;
2343 case (TEMPL_SEARCH):
2344 break;
2345 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
2346 "search", KATTR__MAX);
2347 if (kerr != KCGI_OK)
2348 return 0;
2349 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_FORM,
2350 KATTR_METHOD, "POST", KATTR__MAX);
2351 if (kerr != KCGI_OK)
2352 return 0;
2353 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_INPUT, KATTR_ID,
2354 "got-search", KATTR_NAME, "got-search", KATTR_SIZE, "15",
2355 KATTR_MAXLENGTH, "50", KATTR__MAX);
2356 if (kerr != KCGI_OK)
2357 return 0;
2358 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_BUTTON,
2359 KATTR__MAX);
2360 if (kerr != KCGI_OK)
2361 return 0;
2362 kerr = khtml_puts(gw_trans->gw_html_req, "Search");
2363 if (kerr != KCGI_OK)
2364 return 0;
2365 kerr = khtml_closeelem(gw_trans->gw_html_req, 4);
2366 if (kerr != KCGI_OK)
2367 return 0;
2368 break;
2369 case(TEMPL_SITEOWNER):
2370 if (gw_trans->gw_conf->got_site_owner != NULL &&
2371 gw_trans->gw_conf->got_show_site_owner) {
2372 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2373 KATTR_ID, "site_owner_wrapper", KATTR__MAX);
2374 if (kerr != KCGI_OK)
2375 return 0;
2376 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2377 KATTR_ID, "site_owner", KATTR__MAX);
2378 if (kerr != KCGI_OK)
2379 return 0;
2380 kerr = khtml_puts(gw_trans->gw_html_req,
2381 gw_trans->gw_conf->got_site_owner);
2382 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
2383 if (kerr != KCGI_OK)
2384 return 0;
2386 break;
2387 case(TEMPL_CONTENT):
2388 error = gw_query_funcs[gw_trans->action].func_main(gw_trans);
2389 if (error) {
2390 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2391 KATTR_ID, "tmpl_err", KATTR__MAX);
2392 if (kerr != KCGI_OK)
2393 return 0;
2394 kerr = khttp_printf(gw_trans->gw_req, "Error: %s",
2395 error->msg);
2396 if (kerr != KCGI_OK)
2397 return 0;
2398 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2399 if (kerr != KCGI_OK)
2400 return 0;
2402 break;
2403 default:
2404 return 0;
2406 free(ati);
2407 free(fic32);
2408 free(fic16);
2409 free(swm);
2410 free(spt);
2411 free(css);
2412 free(logo);
2413 return 1;
2414 err:
2415 free(ati);
2416 free(fic32);
2417 free(fic16);
2418 free(swm);
2419 free(spt);
2420 free(css);
2421 free(logo);
2422 return 0;
2425 static const struct got_error *
2426 gw_gen_commit_header(struct gw_trans *gw_trans, char *str1, char *str2)
2428 const struct got_error *error = NULL;
2429 enum kcgi_err kerr = KCGI_OK;
2431 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2432 KATTR_ID, "header_commit_title", KATTR__MAX);
2433 if (kerr != KCGI_OK)
2434 goto done;
2435 kerr = khtml_puts(gw_trans->gw_html_req, "Commit: ");
2436 if (kerr != KCGI_OK)
2437 goto done;
2438 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2439 if (kerr != KCGI_OK)
2440 goto done;
2441 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2442 KATTR_ID, "header_commit", KATTR__MAX);
2443 if (kerr != KCGI_OK)
2444 goto done;
2445 kerr = khtml_printf(gw_trans->gw_html_req, "%s ", str1);
2446 if (kerr != KCGI_OK)
2447 goto done;
2448 if (str2 != NULL) {
2449 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_SPAN,
2450 KATTR_ID, "refs_str", KATTR__MAX);
2451 if (kerr != KCGI_OK)
2452 goto done;
2453 kerr = khtml_printf(gw_trans->gw_html_req, "(%s)", str2);
2454 if (kerr != KCGI_OK)
2455 goto done;
2456 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2457 if (kerr != KCGI_OK)
2458 goto done;
2460 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2461 done:
2462 if (error == NULL && kerr != KCGI_OK)
2463 error = gw_kcgi_error(kerr);
2464 return error;
2467 static const struct got_error *
2468 gw_gen_diff_header(struct gw_trans *gw_trans, char *str1, char *str2)
2470 const struct got_error *error = NULL;
2471 enum kcgi_err kerr = KCGI_OK;
2473 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2474 KATTR_ID, "header_diff_title", KATTR__MAX);
2475 if (kerr != KCGI_OK)
2476 goto done;
2477 kerr = khtml_puts(gw_trans->gw_html_req, "Diff: ");
2478 if (kerr != KCGI_OK)
2479 goto done;
2480 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2481 if (kerr != KCGI_OK)
2482 goto done;
2483 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2484 KATTR_ID, "header_diff", KATTR__MAX);
2485 if (kerr != KCGI_OK)
2486 goto done;
2487 if (str1 != NULL) {
2488 kerr = khtml_puts(gw_trans->gw_html_req, str1);
2489 if (kerr != KCGI_OK)
2490 goto done;
2492 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_BR, KATTR__MAX);
2493 if (kerr != KCGI_OK)
2494 goto done;
2495 kerr = khtml_puts(gw_trans->gw_html_req, str2);
2496 if (kerr != KCGI_OK)
2497 goto done;
2498 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2499 done:
2500 if (error == NULL && kerr != KCGI_OK)
2501 error = gw_kcgi_error(kerr);
2502 return error;
2505 static const struct got_error *
2506 gw_gen_age_header(struct gw_trans *gw_trans, const char *str)
2508 const struct got_error *error = NULL;
2509 enum kcgi_err kerr = KCGI_OK;
2511 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2512 KATTR_ID, "header_age_title", KATTR__MAX);
2513 if (kerr != KCGI_OK)
2514 goto done;
2515 kerr = khtml_puts(gw_trans->gw_html_req, "Date: ");
2516 if (kerr != KCGI_OK)
2517 goto done;
2518 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2519 if (kerr != KCGI_OK)
2520 goto done;
2521 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2522 KATTR_ID, "header_age", KATTR__MAX);
2523 if (kerr != KCGI_OK)
2524 goto done;
2525 kerr = khtml_puts(gw_trans->gw_html_req, str);
2526 if (kerr != KCGI_OK)
2527 goto done;
2528 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2529 done:
2530 if (error == NULL && kerr != KCGI_OK)
2531 error = gw_kcgi_error(kerr);
2532 return error;
2535 static const struct got_error *
2536 gw_gen_author_header(struct gw_trans *gw_trans, const char *str)
2538 const struct got_error *error = NULL;
2539 enum kcgi_err kerr = KCGI_OK;
2541 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2542 KATTR_ID, "header_author_title", KATTR__MAX);
2543 if (kerr != KCGI_OK)
2544 goto done;
2545 kerr = khtml_puts(gw_trans->gw_html_req, "Author: ");
2546 if (kerr != KCGI_OK)
2547 goto done;
2548 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2549 if (kerr != KCGI_OK)
2550 goto done;
2551 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2552 KATTR_ID, "header_author", KATTR__MAX);
2553 if (kerr != KCGI_OK)
2554 goto done;
2555 kerr = khtml_puts(gw_trans->gw_html_req, str);
2556 if (kerr != KCGI_OK)
2557 goto done;
2558 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2559 done:
2560 if (error == NULL && kerr != KCGI_OK)
2561 error = gw_kcgi_error(kerr);
2562 return error;
2565 static const struct got_error *
2566 gw_gen_committer_header(struct gw_trans *gw_trans, const char *str)
2568 const struct got_error *error = NULL;
2569 enum kcgi_err kerr = KCGI_OK;
2571 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2572 KATTR_ID, "header_committer_title", KATTR__MAX);
2573 if (kerr != KCGI_OK)
2574 goto done;
2575 kerr = khtml_puts(gw_trans->gw_html_req, "Committer: ");
2576 if (kerr != KCGI_OK)
2577 goto done;
2578 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2579 if (kerr != KCGI_OK)
2580 goto done;
2581 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2582 KATTR_ID, "header_committer", KATTR__MAX);
2583 if (kerr != KCGI_OK)
2584 goto done;
2585 kerr = khtml_puts(gw_trans->gw_html_req, str);
2586 if (kerr != KCGI_OK)
2587 goto done;
2588 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2589 done:
2590 if (error == NULL && kerr != KCGI_OK)
2591 error = gw_kcgi_error(kerr);
2592 return error;
2595 static const struct got_error *
2596 gw_gen_commit_msg_header(struct gw_trans *gw_trans, char *str)
2598 const struct got_error *error = NULL;
2599 enum kcgi_err kerr = KCGI_OK;
2601 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2602 KATTR_ID, "header_commit_msg_title", KATTR__MAX);
2603 if (kerr != KCGI_OK)
2604 goto done;
2605 kerr = khtml_puts(gw_trans->gw_html_req, "Message: ");
2606 if (kerr != KCGI_OK)
2607 goto done;
2608 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2609 if (kerr != KCGI_OK)
2610 goto done;
2611 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2612 KATTR_ID, "header_commit_msg", KATTR__MAX);
2613 if (kerr != KCGI_OK)
2614 goto done;
2615 kerr = khttp_puts(gw_trans->gw_req, str);
2616 if (kerr != KCGI_OK)
2617 goto done;
2618 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2619 done:
2620 if (error == NULL && kerr != KCGI_OK)
2621 error = gw_kcgi_error(kerr);
2622 return error;
2625 static const struct got_error *
2626 gw_gen_tree_header(struct gw_trans *gw_trans, char *str)
2628 const struct got_error *error = NULL;
2629 enum kcgi_err kerr = KCGI_OK;
2631 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2632 KATTR_ID, "header_tree_title", KATTR__MAX);
2633 if (kerr != KCGI_OK)
2634 goto done;
2635 kerr = khtml_puts(gw_trans->gw_html_req, "Tree: ");
2636 if (kerr != KCGI_OK)
2637 goto done;
2638 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2639 if (kerr != KCGI_OK)
2640 goto done;
2641 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
2642 KATTR_ID, "header_tree", KATTR__MAX);
2643 if (kerr != KCGI_OK)
2644 goto done;
2645 kerr = khtml_puts(gw_trans->gw_html_req, str);
2646 if (kerr != KCGI_OK)
2647 goto done;
2648 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2649 done:
2650 if (error == NULL && kerr != KCGI_OK)
2651 error = gw_kcgi_error(kerr);
2652 return error;
2655 static const struct got_error *
2656 gw_get_repo_description(char **description, struct gw_trans *gw_trans,
2657 char *dir)
2659 const struct got_error *error = NULL;
2660 FILE *f = NULL;
2661 char *d_file = NULL;
2662 unsigned int len;
2663 size_t n;
2665 *description = NULL;
2666 if (gw_trans->gw_conf->got_show_repo_description == 0)
2667 return NULL;
2669 if (asprintf(&d_file, "%s/description", dir) == -1)
2670 return got_error_from_errno("asprintf");
2672 f = fopen(d_file, "re");
2673 if (f == NULL) {
2674 if (errno == ENOENT || errno == EACCES)
2675 return NULL;
2676 error = got_error_from_errno2("fopen", d_file);
2677 goto done;
2680 if (fseek(f, 0, SEEK_END) == -1) {
2681 error = got_ferror(f, GOT_ERR_IO);
2682 goto done;
2684 len = ftell(f);
2685 if (len == -1) {
2686 error = got_ferror(f, GOT_ERR_IO);
2687 goto done;
2689 if (fseek(f, 0, SEEK_SET) == -1) {
2690 error = got_ferror(f, GOT_ERR_IO);
2691 goto done;
2693 *description = calloc(len + 1, sizeof(**description));
2694 if (*description == NULL) {
2695 error = got_error_from_errno("calloc");
2696 goto done;
2699 n = fread(*description, 1, len, f);
2700 if (n == 0 && ferror(f))
2701 error = got_ferror(f, GOT_ERR_IO);
2702 done:
2703 if (f != NULL && fclose(f) == EOF && error == NULL)
2704 error = got_error_from_errno("fclose");
2705 free(d_file);
2706 return error;
2709 static const struct got_error *
2710 gw_get_time_str(char **repo_age, time_t committer_time, int ref_tm)
2712 struct tm tm;
2713 time_t diff_time;
2714 char *years = "years ago", *months = "months ago";
2715 char *weeks = "weeks ago", *days = "days ago", *hours = "hours ago";
2716 char *minutes = "minutes ago", *seconds = "seconds ago";
2717 char *now = "right now";
2718 char *s;
2719 char datebuf[29];
2721 *repo_age = NULL;
2723 switch (ref_tm) {
2724 case TM_DIFF:
2725 diff_time = time(NULL) - committer_time;
2726 if (diff_time > 60 * 60 * 24 * 365 * 2) {
2727 if (asprintf(repo_age, "%lld %s",
2728 (diff_time / 60 / 60 / 24 / 365), years) == -1)
2729 return got_error_from_errno("asprintf");
2730 } else if (diff_time > 60 * 60 * 24 * (365 / 12) * 2) {
2731 if (asprintf(repo_age, "%lld %s",
2732 (diff_time / 60 / 60 / 24 / (365 / 12)),
2733 months) == -1)
2734 return got_error_from_errno("asprintf");
2735 } else if (diff_time > 60 * 60 * 24 * 7 * 2) {
2736 if (asprintf(repo_age, "%lld %s",
2737 (diff_time / 60 / 60 / 24 / 7), weeks) == -1)
2738 return got_error_from_errno("asprintf");
2739 } else if (diff_time > 60 * 60 * 24 * 2) {
2740 if (asprintf(repo_age, "%lld %s",
2741 (diff_time / 60 / 60 / 24), days) == -1)
2742 return got_error_from_errno("asprintf");
2743 } else if (diff_time > 60 * 60 * 2) {
2744 if (asprintf(repo_age, "%lld %s",
2745 (diff_time / 60 / 60), hours) == -1)
2746 return got_error_from_errno("asprintf");
2747 } else if (diff_time > 60 * 2) {
2748 if (asprintf(repo_age, "%lld %s", (diff_time / 60),
2749 minutes) == -1)
2750 return got_error_from_errno("asprintf");
2751 } else if (diff_time > 2) {
2752 if (asprintf(repo_age, "%lld %s", diff_time,
2753 seconds) == -1)
2754 return got_error_from_errno("asprintf");
2755 } else {
2756 if (asprintf(repo_age, "%s", now) == -1)
2757 return got_error_from_errno("asprintf");
2759 break;
2760 case TM_LONG:
2761 if (gmtime_r(&committer_time, &tm) == NULL)
2762 return got_error_from_errno("gmtime_r");
2764 s = asctime_r(&tm, datebuf);
2765 if (s == NULL)
2766 return got_error_from_errno("asctime_r");
2768 if (asprintf(repo_age, "%s UTC", datebuf) == -1)
2769 return got_error_from_errno("asprintf");
2770 break;
2772 return NULL;
2775 static const struct got_error *
2776 gw_get_repo_age(char **repo_age, struct gw_trans *gw_trans, char *dir,
2777 const char *refname, int ref_tm)
2779 const struct got_error *error = NULL;
2780 struct got_repository *repo = NULL;
2781 struct got_commit_object *commit = NULL;
2782 struct got_reflist_head refs;
2783 struct got_reflist_entry *re;
2784 time_t committer_time = 0, cmp_time = 0;
2786 *repo_age = NULL;
2787 TAILQ_INIT(&refs);
2789 if (gw_trans->gw_conf->got_show_repo_age == 0)
2790 return NULL;
2792 if (gw_trans->repo)
2793 repo = gw_trans->repo;
2794 else {
2795 error = got_repo_open(&repo, dir, NULL);
2796 if (error)
2797 return error;
2800 error = got_ref_list(&refs, repo, "refs/heads",
2801 got_ref_cmp_by_name, NULL);
2802 if (error)
2803 goto done;
2806 * Find the youngest branch tip in the repository, or the age of
2807 * the a specific branch tip if a name was provided by the caller.
2809 TAILQ_FOREACH(re, &refs, entry) {
2810 struct got_object_id *id = NULL;
2812 if (refname && strcmp(got_ref_get_name(re->ref), refname) != 0)
2813 continue;
2815 error = got_ref_resolve(&id, repo, re->ref);
2816 if (error)
2817 goto done;
2819 error = got_object_open_as_commit(&commit, repo, id);
2820 free(id);
2821 if (error)
2822 goto done;
2824 committer_time =
2825 got_object_commit_get_committer_time(commit);
2826 got_object_commit_close(commit);
2827 if (cmp_time < committer_time)
2828 cmp_time = committer_time;
2830 if (refname)
2831 break;
2834 if (cmp_time != 0) {
2835 committer_time = cmp_time;
2836 error = gw_get_time_str(repo_age, committer_time, ref_tm);
2838 done:
2839 got_ref_list_free(&refs);
2840 if (gw_trans->repo == NULL) {
2841 const struct got_error *close_err = got_repo_close(repo);
2842 if (error == NULL)
2843 error = close_err;
2845 return error;
2848 static const struct got_error *
2849 gw_output_diff(struct gw_trans *gw_trans, struct gw_header *header)
2851 const struct got_error *error;
2852 FILE *f = NULL;
2853 struct got_object_id *id1 = NULL, *id2 = NULL;
2854 char *label1 = NULL, *label2 = NULL, *line = NULL;
2855 int obj_type;
2856 size_t linesize = 0;
2857 ssize_t linelen;
2858 enum kcgi_err kerr = KCGI_OK;
2860 f = got_opentemp();
2861 if (f == NULL)
2862 return NULL;
2864 if (header->parent_id != NULL &&
2865 strncmp(header->parent_id, "/dev/null", 9) != 0) {
2866 error = got_repo_match_object_id(&id1, &label1,
2867 header->parent_id, GOT_OBJ_TYPE_ANY,
2868 &header->refs, gw_trans->repo);
2869 if (error)
2870 goto done;
2873 error = got_repo_match_object_id(&id2, &label2,
2874 header->commit_id, GOT_OBJ_TYPE_ANY, &header->refs,
2875 gw_trans->repo);
2876 if (error)
2877 goto done;
2879 error = got_object_get_type(&obj_type, gw_trans->repo, id2);
2880 if (error)
2881 goto done;
2882 switch (obj_type) {
2883 case GOT_OBJ_TYPE_BLOB:
2884 error = got_diff_objects_as_blobs(NULL, NULL, id1, id2,
2885 NULL, NULL, 3, 0, 0, gw_trans->repo, f);
2886 break;
2887 case GOT_OBJ_TYPE_TREE:
2888 error = got_diff_objects_as_trees(NULL, NULL, id1, id2,
2889 NULL, "", "", 3, 0, 0, gw_trans->repo, f);
2890 break;
2891 case GOT_OBJ_TYPE_COMMIT:
2892 error = got_diff_objects_as_commits(NULL, NULL, id1, id2,
2893 NULL, 3, 0, 0, gw_trans->repo, f);
2894 break;
2895 default:
2896 error = got_error(GOT_ERR_OBJ_TYPE);
2898 if (error)
2899 goto done;
2901 if (fseek(f, 0, SEEK_SET) == -1) {
2902 error = got_ferror(f, GOT_ERR_IO);
2903 goto done;
2906 while ((linelen = getline(&line, &linesize, f)) != -1) {
2907 error = gw_colordiff_line(gw_trans, line);
2908 if (error)
2909 goto done;
2910 /* XXX: KHTML_PRETTY breaks this */
2911 kerr = khtml_puts(gw_trans->gw_html_req, line);
2912 if (kerr != KCGI_OK)
2913 goto done;
2914 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
2915 if (kerr != KCGI_OK)
2916 goto done;
2918 if (linelen == -1 && ferror(f))
2919 error = got_error_from_errno("getline");
2920 done:
2921 if (f && fclose(f) == EOF && error == NULL)
2922 error = got_error_from_errno("fclose");
2923 free(line);
2924 free(label1);
2925 free(label2);
2926 free(id1);
2927 free(id2);
2929 if (error == NULL && kerr != KCGI_OK)
2930 error = gw_kcgi_error(kerr);
2931 return error;
2934 static const struct got_error *
2935 gw_get_repo_owner(char **owner, struct gw_trans *gw_trans, char *dir)
2937 const struct got_error *error = NULL, *close_err;
2938 struct got_repository *repo;
2939 const char *gitconfig_owner;
2941 *owner = NULL;
2943 if (gw_trans->gw_conf->got_show_repo_owner == 0)
2944 return NULL;
2946 error = got_repo_open(&repo, dir, NULL);
2947 if (error)
2948 return error;
2949 gitconfig_owner = got_repo_get_gitconfig_owner(repo);
2950 if (gitconfig_owner) {
2951 *owner = strdup(gitconfig_owner);
2952 if (*owner == NULL)
2953 error = got_error_from_errno("strdup");
2955 close_err = got_repo_close(repo);
2956 if (error == NULL)
2957 error = close_err;
2958 return error;
2961 static const struct got_error *
2962 gw_get_clone_url(char **url, struct gw_trans *gw_trans, char *dir)
2964 const struct got_error *error = NULL;
2965 FILE *f;
2966 char *d_file = NULL;
2967 unsigned int len;
2968 size_t n;
2970 *url = NULL;
2972 if (asprintf(&d_file, "%s/cloneurl", dir) == -1)
2973 return got_error_from_errno("asprintf");
2975 f = fopen(d_file, "re");
2976 if (f == NULL) {
2977 if (errno != ENOENT && errno != EACCES)
2978 error = got_error_from_errno2("fopen", d_file);
2979 goto done;
2982 if (fseek(f, 0, SEEK_END) == -1) {
2983 error = got_ferror(f, GOT_ERR_IO);
2984 goto done;
2986 len = ftell(f);
2987 if (len == -1) {
2988 error = got_ferror(f, GOT_ERR_IO);
2989 goto done;
2991 if (fseek(f, 0, SEEK_SET) == -1) {
2992 error = got_ferror(f, GOT_ERR_IO);
2993 goto done;
2996 *url = calloc(len + 1, sizeof(**url));
2997 if (*url == NULL) {
2998 error = got_error_from_errno("calloc");
2999 goto done;
3002 n = fread(*url, 1, len, f);
3003 if (n == 0 && ferror(f))
3004 error = got_ferror(f, GOT_ERR_IO);
3005 done:
3006 if (f && fclose(f) == EOF && error == NULL)
3007 error = got_error_from_errno("fclose");
3008 free(d_file);
3009 return NULL;
3012 static const struct got_error *
3013 gw_output_repo_tags(struct gw_trans *gw_trans, struct gw_header *header,
3014 int limit, int tag_type)
3016 const struct got_error *error = NULL;
3017 struct got_reflist_head refs;
3018 struct got_reflist_entry *re;
3019 char *age = NULL;
3020 char *id_str = NULL, *newline, *href_commits = NULL;
3021 char *tag_commit0 = NULL, *href_tag = NULL, *href_briefs = NULL;
3022 struct got_tag_object *tag = NULL;
3023 enum kcgi_err kerr = KCGI_OK;
3024 int summary_header_displayed = 0, chk_next = 0;
3025 int tag_count = 0, commit_found = 0, c_cnt = 0;
3027 TAILQ_INIT(&refs);
3029 error = got_ref_list(&refs, gw_trans->repo, "refs/tags",
3030 got_ref_cmp_tags, gw_trans->repo);
3031 if (error)
3032 goto done;
3034 TAILQ_FOREACH(re, &refs, entry) {
3035 const char *refname;
3036 const char *tagger;
3037 const char *tag_commit;
3038 time_t tagger_time;
3039 struct got_object_id *id;
3040 struct got_commit_object *commit = NULL;
3042 refname = got_ref_get_name(re->ref);
3043 if (strncmp(refname, "refs/tags/", 10) != 0)
3044 continue;
3045 refname += 10;
3047 error = got_ref_resolve(&id, gw_trans->repo, re->ref);
3048 if (error)
3049 goto done;
3051 error = got_object_open_as_tag(&tag, gw_trans->repo, id);
3052 if (error) {
3053 if (error->code != GOT_ERR_OBJ_TYPE) {
3054 free(id);
3055 goto done;
3057 /* "lightweight" tag */
3058 error = got_object_open_as_commit(&commit,
3059 gw_trans->repo, id);
3060 if (error) {
3061 free(id);
3062 goto done;
3064 tagger = got_object_commit_get_committer(commit);
3065 tagger_time =
3066 got_object_commit_get_committer_time(commit);
3067 error = got_object_id_str(&id_str, id);
3068 free(id);
3069 } else {
3070 free(id);
3071 tagger = got_object_tag_get_tagger(tag);
3072 tagger_time = got_object_tag_get_tagger_time(tag);
3073 error = got_object_id_str(&id_str,
3074 got_object_tag_get_object_id(tag));
3076 if (error)
3077 goto done;
3079 if (tag_type == TAGFULL && strncmp(id_str, header->commit_id,
3080 strlen(id_str)) != 0)
3081 continue;
3083 if (tag_type == TAGBRIEF && gw_trans->commit_id &&
3084 commit_found == 0 && strncmp(id_str, gw_trans->commit_id,
3085 strlen(id_str)) != 0)
3086 continue;
3087 else
3088 commit_found = 1;
3090 tag_count++;
3092 if (chk_next) {
3093 gw_trans->next_id = strdup(id_str);
3094 if (gw_trans->next_id == NULL)
3095 error = got_error_from_errno("strdup");
3096 goto prev;
3099 if (commit) {
3100 error = got_object_commit_get_logmsg(&tag_commit0,
3101 commit);
3102 if (error)
3103 goto done;
3104 got_object_commit_close(commit);
3105 } else {
3106 tag_commit0 = strdup(got_object_tag_get_message(tag));
3107 if (tag_commit0 == NULL) {
3108 error = got_error_from_errno("strdup");
3109 goto done;
3113 tag_commit = tag_commit0;
3114 while (*tag_commit == '\n')
3115 tag_commit++;
3117 switch (tag_type) {
3118 case TAGBRIEF:
3119 newline = strchr(tag_commit, '\n');
3120 if (newline)
3121 *newline = '\0';
3123 if (summary_header_displayed == 0) {
3124 kerr = khtml_attr(gw_trans->gw_html_req,
3125 KELEM_DIV, KATTR_ID,
3126 "summary_tags_title_wrapper", KATTR__MAX);
3127 if (kerr != KCGI_OK)
3128 goto done;
3129 kerr = khtml_attr(gw_trans->gw_html_req,
3130 KELEM_DIV, KATTR_ID,
3131 "summary_tags_title", KATTR__MAX);
3132 if (kerr != KCGI_OK)
3133 goto done;
3134 kerr = khtml_puts(gw_trans->gw_html_req,
3135 "Tags");
3136 if (kerr != KCGI_OK)
3137 goto done;
3138 kerr = khtml_closeelem(gw_trans->gw_html_req,
3139 2);
3140 if (kerr != KCGI_OK)
3141 goto done;
3142 kerr = khtml_attr(gw_trans->gw_html_req,
3143 KELEM_DIV, KATTR_ID,
3144 "summary_tags_content", KATTR__MAX);
3145 if (kerr != KCGI_OK)
3146 goto done;
3147 summary_header_displayed = 1;
3150 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3151 KATTR_ID, "tag_wrapper", KATTR__MAX);
3152 if (kerr != KCGI_OK)
3153 goto done;
3154 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3155 KATTR_ID, "tag_age", KATTR__MAX);
3156 if (kerr != KCGI_OK)
3157 goto done;
3158 error = gw_get_time_str(&age, tagger_time, TM_DIFF);
3159 if (error)
3160 goto done;
3161 kerr = khtml_puts(gw_trans->gw_html_req,
3162 age ? age : "");
3163 if (kerr != KCGI_OK)
3164 goto done;
3165 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
3166 if (kerr != KCGI_OK)
3167 goto done;
3168 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3169 KATTR_ID, "tag", KATTR__MAX);
3170 if (kerr != KCGI_OK)
3171 goto done;
3172 kerr = khtml_puts(gw_trans->gw_html_req, refname);
3173 if (kerr != KCGI_OK)
3174 goto done;
3175 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
3176 if (kerr != KCGI_OK)
3177 goto done;
3178 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3179 KATTR_ID, "tag_name", KATTR__MAX);
3180 if (kerr != KCGI_OK)
3181 goto done;
3183 href_tag = khttp_urlpart(NULL, NULL, "gotweb", "path",
3184 gw_trans->repo_name, "action", "tag", "commit",
3185 id_str, NULL);
3186 if (href_tag == NULL) {
3187 error = got_error_from_errno("khttp_urlpart");
3188 goto done;
3190 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
3191 KATTR_HREF, href_tag, KATTR__MAX);
3192 if (kerr != KCGI_OK)
3193 goto done;
3194 kerr = khtml_puts(gw_trans->gw_html_req, tag_commit);
3195 if (kerr != KCGI_OK)
3196 goto done;
3197 kerr = khtml_closeelem(gw_trans->gw_html_req, 3);
3198 if (kerr != KCGI_OK)
3199 goto done;
3201 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3202 KATTR_ID, "navs_wrapper", KATTR__MAX);
3203 if (kerr != KCGI_OK)
3204 goto done;
3205 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3206 KATTR_ID, "navs", KATTR__MAX);
3207 if (kerr != KCGI_OK)
3208 goto done;
3210 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
3211 KATTR_HREF, href_tag, KATTR__MAX);
3212 if (kerr != KCGI_OK)
3213 goto done;
3214 kerr = khtml_puts(gw_trans->gw_html_req, "tag");
3215 if (kerr != KCGI_OK)
3216 goto done;
3217 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
3218 if (kerr != KCGI_OK)
3219 goto done;
3221 kerr = khtml_puts(gw_trans->gw_html_req, " | ");
3222 if (kerr != KCGI_OK)
3223 goto done;
3225 href_briefs = khttp_urlpart(NULL, NULL, "gotweb",
3226 "path", gw_trans->repo_name, "action", "briefs",
3227 "commit", id_str, NULL);
3228 if (href_briefs == NULL) {
3229 error = got_error_from_errno("khttp_urlpart");
3230 goto done;
3232 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
3233 KATTR_HREF, href_briefs, KATTR__MAX);
3234 if (kerr != KCGI_OK)
3235 goto done;
3236 kerr = khtml_puts(gw_trans->gw_html_req,
3237 "commit briefs");
3238 if (kerr != KCGI_OK)
3239 goto done;
3240 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
3241 if (kerr != KCGI_OK)
3242 goto done;
3244 kerr = khtml_puts(gw_trans->gw_html_req, " | ");
3245 if (kerr != KCGI_OK)
3246 goto done;
3248 href_commits = khttp_urlpart(NULL, NULL, "gotweb",
3249 "path", gw_trans->repo_name, "action", "commits",
3250 "commit", id_str, NULL);
3251 if (href_commits == NULL) {
3252 error = got_error_from_errno("khttp_urlpart");
3253 goto done;
3255 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
3256 KATTR_HREF, href_commits, KATTR__MAX);
3257 if (kerr != KCGI_OK)
3258 goto done;
3259 kerr = khtml_puts(gw_trans->gw_html_req, "commits");
3260 if (kerr != KCGI_OK)
3261 goto done;
3262 kerr = khtml_closeelem(gw_trans->gw_html_req, 3);
3263 if (kerr != KCGI_OK)
3264 goto done;
3266 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3267 KATTR_ID, "dotted_line", KATTR__MAX);
3268 if (kerr != KCGI_OK)
3269 goto done;
3270 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
3271 if (kerr != KCGI_OK)
3272 goto done;
3273 break;
3274 case TAGFULL:
3275 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3276 KATTR_ID, "tag_info_date_title", KATTR__MAX);
3277 if (kerr != KCGI_OK)
3278 goto done;
3279 kerr = khtml_puts(gw_trans->gw_html_req, "Tag Date:");
3280 if (kerr != KCGI_OK)
3281 goto done;
3282 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
3283 if (kerr != KCGI_OK)
3284 goto done;
3285 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3286 KATTR_ID, "tag_info_date", KATTR__MAX);
3287 if (kerr != KCGI_OK)
3288 goto done;
3289 error = gw_get_time_str(&age, tagger_time, TM_LONG);
3290 if (error)
3291 goto done;
3292 kerr = khtml_puts(gw_trans->gw_html_req,
3293 age ? age : "");
3294 if (kerr != KCGI_OK)
3295 goto done;
3296 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
3297 if (kerr != KCGI_OK)
3298 goto done;
3300 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3301 KATTR_ID, "tag_info_tagger_title", KATTR__MAX);
3302 if (kerr != KCGI_OK)
3303 goto done;
3304 kerr = khtml_puts(gw_trans->gw_html_req, "Tagger:");
3305 if (kerr != KCGI_OK)
3306 goto done;
3307 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
3308 if (kerr != KCGI_OK)
3309 goto done;
3310 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3311 KATTR_ID, "tag_info_date", KATTR__MAX);
3312 if (kerr != KCGI_OK)
3313 goto done;
3314 kerr = khtml_puts(gw_trans->gw_html_req, tagger);
3315 if (kerr != KCGI_OK)
3316 goto done;
3317 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
3318 if (kerr != KCGI_OK)
3319 goto done;
3321 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
3322 KATTR_ID, "tag_info", KATTR__MAX);
3323 if (kerr != KCGI_OK)
3324 goto done;
3325 kerr = khttp_puts(gw_trans->gw_req, tag_commit);
3326 if (kerr != KCGI_OK)
3327 goto done;
3328 break;
3329 default:
3330 break;
3332 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
3333 if (kerr != KCGI_OK)
3334 goto done;
3336 if (limit && --limit == 0)
3337 chk_next = 1;
3339 if (tag)
3340 got_object_tag_close(tag);
3341 tag = NULL;
3342 free(id_str);
3343 id_str = NULL;
3344 free(age);
3345 age = NULL;
3346 free(tag_commit0);
3347 tag_commit0 = NULL;
3348 free(href_tag);
3349 href_tag = NULL;
3350 free(href_briefs);
3351 href_briefs = NULL;
3352 free(href_commits);
3353 href_commits = NULL;
3355 if (tag_count == 0) {
3356 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
3357 "summary_tags_title_wrapper", KATTR__MAX);
3358 if (kerr != KCGI_OK)
3359 goto done;
3360 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
3361 "summary_tags_title", KATTR__MAX);
3362 if (kerr != KCGI_OK)
3363 goto done;
3364 kerr = khtml_puts(gw_trans->gw_html_req, "Tags");
3365 if (kerr != KCGI_OK)
3366 goto done;
3367 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
3368 if (kerr != KCGI_OK)
3369 goto done;
3370 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
3371 "summary_tags_content", KATTR__MAX);
3372 if (kerr != KCGI_OK)
3373 goto done;
3374 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
3375 "tags_info", KATTR__MAX);
3376 if (kerr != KCGI_OK)
3377 goto done;
3378 kerr = khttp_puts(gw_trans->gw_req,
3379 "There are no tags for this repo.");
3380 if (kerr != KCGI_OK)
3381 goto done;
3382 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
3383 goto done;
3385 prev:
3386 commit_found = 0;
3387 TAILQ_FOREACH_REVERSE(re, &refs, got_reflist_head, entry) {
3388 const char *refname;
3389 struct got_object_id *id;
3390 struct got_commit_object *commit = NULL;
3392 refname = got_ref_get_name(re->ref);
3393 if (strncmp(refname, "refs/tags/", 10) != 0)
3394 continue;
3395 refname += 10;
3397 error = got_ref_resolve(&id, gw_trans->repo, re->ref);
3398 if (error)
3399 goto done;
3401 error = got_object_open_as_tag(&tag, gw_trans->repo, id);
3402 if (error) {
3403 if (error->code != GOT_ERR_OBJ_TYPE) {
3404 free(id);
3405 goto done;
3407 /* "lightweight" tag */
3408 error = got_object_open_as_commit(&commit,
3409 gw_trans->repo, id);
3410 if (error) {
3411 free(id);
3412 goto done;
3414 error = got_object_id_str(&id_str, id);
3415 free(id);
3416 } else {
3417 free(id);
3418 error = got_object_id_str(&id_str,
3419 got_object_tag_get_object_id(tag));
3421 if (error)
3422 goto done;
3424 if (tag_type == TAGFULL && strncmp(id_str, header->commit_id,
3425 strlen(id_str)) != 0)
3426 continue;
3428 if (commit_found == 0 && tag_type == TAGBRIEF &&
3429 gw_trans->commit_id != NULL &&
3430 strncmp(id_str, gw_trans->commit_id, strlen(id_str)) != 0)
3431 continue;
3432 else
3433 commit_found = 1;
3435 if (gw_trans->commit_id != NULL &&
3436 strcmp(id_str, gw_trans->commit_id) != 0 &&
3437 (re == TAILQ_FIRST(&refs) ||
3438 c_cnt == gw_trans->gw_conf->got_max_commits_display)) {
3439 gw_trans->prev_id = strdup(id_str);
3440 if (gw_trans->prev_id == NULL) {
3441 error = got_error_from_errno("strdup");
3442 goto done;
3444 break;
3446 c_cnt++;
3448 done:
3449 if (tag)
3450 got_object_tag_close(tag);
3451 free(id_str);
3452 free(age);
3453 free(tag_commit0);
3454 free(href_tag);
3455 free(href_briefs);
3456 free(href_commits);
3457 got_ref_list_free(&refs);
3458 if (error == NULL && kerr != KCGI_OK)
3459 error = gw_kcgi_error(kerr);
3460 return error;
3463 static void
3464 gw_free_header(struct gw_header *header)
3466 free(header->path);
3467 free(header->author);
3468 free(header->committer);
3469 free(header->refs_str);
3470 free(header->commit_id);
3471 free(header->parent_id);
3472 free(header->tree_id);
3473 free(header->commit_msg);
3476 static struct gw_header *
3477 gw_init_header()
3479 struct gw_header *header;
3481 header = malloc(sizeof(*header));
3482 if (header == NULL)
3483 return NULL;
3485 header->path = NULL;
3486 TAILQ_INIT(&header->refs);
3488 header->refs_str = NULL;
3489 header->commit_id = NULL;
3490 header->committer = NULL;
3491 header->author = NULL;
3492 header->parent_id = NULL;
3493 header->tree_id = NULL;
3494 header->commit_msg = NULL;
3496 return header;
3499 static const struct got_error *
3500 gw_get_commits(struct gw_trans * gw_trans, struct gw_header *header,
3501 int limit, struct got_object_id *id)
3503 const struct got_error *error = NULL;
3504 struct got_commit_graph *graph = NULL;
3505 struct got_commit_object *commit = NULL;
3506 int chk_next = 0, chk_multi = 0, c_cnt = 0, commit_found = 0;
3507 struct gw_header *t_header = NULL;
3509 error = got_commit_graph_open(&graph, header->path, 0);
3510 if (error)
3511 return error;
3513 error = got_commit_graph_iter_start(graph, id, gw_trans->repo, NULL,
3514 NULL);
3515 if (error)
3516 goto err;
3518 for (;;) {
3519 error = got_commit_graph_iter_next(&id, graph, gw_trans->repo,
3520 NULL, NULL);
3521 if (error) {
3522 if (error->code == GOT_ERR_ITER_COMPLETED)
3523 error = NULL;
3524 goto done;
3526 if (id == NULL)
3527 goto err;
3529 error = got_object_open_as_commit(&commit, gw_trans->repo, id);
3530 if (error)
3531 goto err;
3532 if (limit == 1 && chk_multi == 0 &&
3533 gw_trans->gw_conf->got_max_commits_display != 1) {
3534 error = gw_get_commit(gw_trans, header, commit, id);
3535 if (error)
3536 goto err;
3537 commit_found = 1;
3538 } else {
3539 chk_multi = 1;
3540 struct gw_header *n_header = NULL;
3541 if ((n_header = gw_init_header()) == NULL) {
3542 error = got_error_from_errno("malloc");
3543 goto err;
3545 TAILQ_INSERT_TAIL(&gw_trans->gw_headers, n_header,
3546 entry);
3547 error = got_ref_list(&n_header->refs, gw_trans->repo,
3548 NULL, got_ref_cmp_by_name, NULL);
3549 if (error)
3550 goto err;
3552 error = gw_get_commit(gw_trans, n_header, commit, id);
3553 if (error)
3554 goto err;
3555 got_ref_list_free(&n_header->refs);
3557 if (gw_trans->commit_id != NULL) {
3558 if (strcmp(gw_trans->commit_id,
3559 n_header->commit_id) == 0)
3560 commit_found = 1;
3561 } else
3562 commit_found = 1;
3565 * check for one more commit before breaking,
3566 * so we know whether to navicate through gw_briefs
3567 * gw_commits and gw_summary
3569 if (chk_next && (gw_trans->action == GW_BRIEFS ||
3570 gw_trans->action == GW_COMMITS ||
3571 gw_trans->action == GW_SUMMARY)) {
3572 gw_trans->next_id = strdup(n_header->commit_id);
3573 if (gw_trans->next_id == NULL)
3574 error = got_error_from_errno("strdup");
3575 TAILQ_REMOVE(&gw_trans->gw_headers, n_header,
3576 entry);
3577 goto done;
3581 if (commit_found == 1 && (error || (limit && --limit == 0))) {
3582 if (chk_multi == 0)
3583 break;
3584 chk_next = 1;
3587 done:
3588 if (gw_trans->prev_id == NULL && gw_trans->commit_id != NULL &&
3589 (gw_trans->action == GW_BRIEFS || gw_trans->action == GW_COMMITS)) {
3590 commit_found = 0;
3591 TAILQ_FOREACH_REVERSE(t_header, &gw_trans->gw_headers,
3592 headers, entry) {
3593 if (commit_found == 0 &&
3594 strcmp(gw_trans->commit_id,
3595 t_header->commit_id) != 0)
3596 continue;
3597 else
3598 commit_found = 1;
3599 if (gw_trans->commit_id != NULL &&
3600 strcmp(gw_trans->commit_id,
3601 t_header->commit_id) != 0 &&
3602 (c_cnt == gw_trans->gw_conf->got_max_commits_display
3603 || t_header ==
3604 TAILQ_FIRST(&gw_trans->gw_headers))) {
3605 gw_trans->prev_id = strdup(t_header->commit_id);
3606 if (gw_trans->prev_id == NULL)
3607 error = got_error_from_errno("strdup");
3608 break;
3610 c_cnt++;
3613 err:
3614 if (commit != NULL)
3615 got_object_commit_close(commit);
3616 if (graph)
3617 got_commit_graph_close(graph);
3618 return error;
3621 static const struct got_error *
3622 gw_get_commit(struct gw_trans *gw_trans, struct gw_header *header,
3623 struct got_commit_object *commit, struct got_object_id *id)
3625 const struct got_error *error = NULL;
3626 struct got_reflist_entry *re;
3627 struct got_object_id *id2 = NULL;
3628 struct got_object_qid *parent_id;
3629 char *commit_msg = NULL, *commit_msg0;
3631 /*print commit*/
3632 TAILQ_FOREACH(re, &header->refs, entry) {
3633 char *s;
3634 const char *name;
3635 struct got_tag_object *tag = NULL;
3636 struct got_object_id *ref_id;
3637 int cmp;
3639 if (got_ref_is_symbolic(re->ref))
3640 continue;
3642 name = got_ref_get_name(re->ref);
3643 if (strncmp(name, "refs/", 5) == 0)
3644 name += 5;
3645 if (strncmp(name, "got/", 4) == 0)
3646 continue;
3647 if (strncmp(name, "heads/", 6) == 0)
3648 name += 6;
3649 if (strncmp(name, "remotes/", 8) == 0) {
3650 name += 8;
3651 s = strstr(name, "/" GOT_REF_HEAD);
3652 if (s != NULL && s[strlen(s)] == '\0')
3653 continue;
3655 error = got_ref_resolve(&ref_id, gw_trans->repo, re->ref);
3656 if (error)
3657 return error;
3658 if (strncmp(name, "tags/", 5) == 0) {
3659 error = got_object_open_as_tag(&tag, gw_trans->repo,
3660 ref_id);
3661 if (error) {
3662 if (error->code != GOT_ERR_OBJ_TYPE) {
3663 free(ref_id);
3664 continue;
3667 * Ref points at something other
3668 * than a tag.
3670 error = NULL;
3671 tag = NULL;
3674 cmp = got_object_id_cmp(tag ?
3675 got_object_tag_get_object_id(tag) : ref_id, id);
3676 free(ref_id);
3677 if (tag)
3678 got_object_tag_close(tag);
3679 if (cmp != 0)
3680 continue;
3681 s = header->refs_str;
3682 if (asprintf(&header->refs_str, "%s%s%s", s ? s : "",
3683 s ? ", " : "", name) == -1) {
3684 error = got_error_from_errno("asprintf");
3685 free(s);
3686 header->refs_str = NULL;
3687 return error;
3689 free(s);
3692 error = got_object_id_str(&header->commit_id, id);
3693 if (error)
3694 return error;
3696 error = got_object_id_str(&header->tree_id,
3697 got_object_commit_get_tree_id(commit));
3698 if (error)
3699 return error;
3701 if (gw_trans->action == GW_DIFF) {
3702 parent_id = STAILQ_FIRST(
3703 got_object_commit_get_parent_ids(commit));
3704 if (parent_id != NULL) {
3705 id2 = got_object_id_dup(parent_id->id);
3706 free (parent_id);
3707 error = got_object_id_str(&header->parent_id, id2);
3708 if (error)
3709 return error;
3710 free(id2);
3711 } else {
3712 header->parent_id = strdup("/dev/null");
3713 if (header->parent_id == NULL) {
3714 error = got_error_from_errno("strdup");
3715 return error;
3720 header->committer_time =
3721 got_object_commit_get_committer_time(commit);
3723 header->author =
3724 strdup(got_object_commit_get_author(commit));
3725 if (header->author == NULL) {
3726 error = got_error_from_errno("strdup");
3727 return error;
3729 header->committer =
3730 strdup(got_object_commit_get_committer(commit));
3731 if (header->committer == NULL) {
3732 error = got_error_from_errno("strdup");
3733 return error;
3735 error = got_object_commit_get_logmsg(&commit_msg0, commit);
3736 if (error)
3737 return error;
3739 commit_msg = commit_msg0;
3740 while (*commit_msg == '\n')
3741 commit_msg++;
3743 header->commit_msg = strdup(commit_msg);
3744 if (header->commit_msg == NULL)
3745 error = got_error_from_errno("strdup");
3746 free(commit_msg0);
3747 return error;
3750 static const struct got_error *
3751 gw_get_header(struct gw_trans *gw_trans, struct gw_header *header, int limit)
3753 const struct got_error *error = NULL;
3754 char *in_repo_path = NULL;
3755 struct got_object_id *id = NULL;
3756 struct got_reference *ref;
3758 error = got_repo_open(&gw_trans->repo, gw_trans->repo_path, NULL);
3759 if (error)
3760 return error;
3762 if (gw_trans->commit_id == NULL || gw_trans->action == GW_COMMITS ||
3763 gw_trans->action == GW_BRIEFS || gw_trans->action == GW_SUMMARY ||
3764 gw_trans->action == GW_TAGS) {
3765 error = got_ref_open(&ref, gw_trans->repo,
3766 gw_trans->headref, 0);
3767 if (error)
3768 return error;
3770 error = got_ref_resolve(&id, gw_trans->repo, ref);
3771 got_ref_close(ref);
3772 if (error)
3773 return error;
3774 } else {
3775 error = got_ref_open(&ref, gw_trans->repo,
3776 gw_trans->commit_id, 0);
3777 if (error == NULL) {
3778 int obj_type;
3779 error = got_ref_resolve(&id, gw_trans->repo, ref);
3780 got_ref_close(ref);
3781 if (error)
3782 return error;
3783 error = got_object_get_type(&obj_type, gw_trans->repo,
3784 id);
3785 if (error)
3786 goto done;
3787 if (obj_type == GOT_OBJ_TYPE_TAG) {
3788 struct got_tag_object *tag;
3789 error = got_object_open_as_tag(&tag,
3790 gw_trans->repo, id);
3791 if (error)
3792 goto done;
3793 if (got_object_tag_get_object_type(tag) !=
3794 GOT_OBJ_TYPE_COMMIT) {
3795 got_object_tag_close(tag);
3796 error = got_error(GOT_ERR_OBJ_TYPE);
3797 goto done;
3799 free(id);
3800 id = got_object_id_dup(
3801 got_object_tag_get_object_id(tag));
3802 if (id == NULL)
3803 error = got_error_from_errno(
3804 "got_object_id_dup");
3805 got_object_tag_close(tag);
3806 if (error)
3807 goto done;
3808 } else if (obj_type != GOT_OBJ_TYPE_COMMIT) {
3809 error = got_error(GOT_ERR_OBJ_TYPE);
3810 goto done;
3813 error = got_repo_match_object_id_prefix(&id,
3814 gw_trans->commit_id, GOT_OBJ_TYPE_COMMIT,
3815 gw_trans->repo);
3816 if (error)
3817 goto done;
3820 error = got_repo_map_path(&in_repo_path, gw_trans->repo,
3821 gw_trans->repo_path);
3822 if (error)
3823 goto done;
3825 if (in_repo_path) {
3826 header->path = strdup(in_repo_path);
3827 if (header->path == NULL) {
3828 error = got_error_from_errno("strdup");
3829 goto done;
3833 error = got_ref_list(&header->refs, gw_trans->repo, NULL,
3834 got_ref_cmp_by_name, NULL);
3835 if (error)
3836 goto done;
3838 error = gw_get_commits(gw_trans, header, limit, id);
3839 done:
3840 got_ref_list_free(&header->refs);
3841 free(id);
3842 free(in_repo_path);
3843 return error;
3846 struct blame_line {
3847 int annotated;
3848 char *id_str;
3849 char *committer;
3850 char datebuf[11]; /* YYYY-MM-DD + NUL */
3853 struct gw_blame_cb_args {
3854 struct blame_line *lines;
3855 int nlines;
3856 int nlines_prec;
3857 int lineno_cur;
3858 off_t *line_offsets;
3859 FILE *f;
3860 struct got_repository *repo;
3861 struct gw_trans *gw_trans;
3864 static const struct got_error *
3865 gw_blame_cb(void *arg, int nlines, int lineno, struct got_object_id *id)
3867 const struct got_error *err = NULL;
3868 struct gw_blame_cb_args *a = arg;
3869 struct blame_line *bline;
3870 char *line = NULL;
3871 size_t linesize = 0;
3872 struct got_commit_object *commit = NULL;
3873 off_t offset;
3874 struct tm tm;
3875 time_t committer_time;
3876 enum kcgi_err kerr = KCGI_OK;
3878 if (nlines != a->nlines ||
3879 (lineno != -1 && lineno < 1) || lineno > a->nlines)
3880 return got_error(GOT_ERR_RANGE);
3882 if (lineno == -1)
3883 return NULL; /* no change in this commit */
3885 /* Annotate this line. */
3886 bline = &a->lines[lineno - 1];
3887 if (bline->annotated)
3888 return NULL;
3889 err = got_object_id_str(&bline->id_str, id);
3890 if (err)
3891 return err;
3893 err = got_object_open_as_commit(&commit, a->repo, id);
3894 if (err)
3895 goto done;
3897 bline->committer = strdup(got_object_commit_get_committer(commit));
3898 if (bline->committer == NULL) {
3899 err = got_error_from_errno("strdup");
3900 goto done;
3903 committer_time = got_object_commit_get_committer_time(commit);
3904 if (gmtime_r(&committer_time, &tm) == NULL)
3905 return got_error_from_errno("gmtime_r");
3906 if (strftime(bline->datebuf, sizeof(bline->datebuf), "%G-%m-%d",
3907 &tm) == 0) {
3908 err = got_error(GOT_ERR_NO_SPACE);
3909 goto done;
3911 bline->annotated = 1;
3913 /* Print lines annotated so far. */
3914 bline = &a->lines[a->lineno_cur - 1];
3915 if (!bline->annotated)
3916 goto done;
3918 offset = a->line_offsets[a->lineno_cur - 1];
3919 if (fseeko(a->f, offset, SEEK_SET) == -1) {
3920 err = got_error_from_errno("fseeko");
3921 goto done;
3924 while (bline->annotated) {
3925 char *smallerthan, *at, *nl, *committer;
3926 char *href_diff = NULL;
3927 size_t len;
3929 if (getline(&line, &linesize, a->f) == -1) {
3930 if (ferror(a->f))
3931 err = got_error_from_errno("getline");
3932 break;
3935 committer = bline->committer;
3936 smallerthan = strchr(committer, '<');
3937 if (smallerthan && smallerthan[1] != '\0')
3938 committer = smallerthan + 1;
3939 at = strchr(committer, '@');
3940 if (at)
3941 *at = '\0';
3942 len = strlen(committer);
3943 if (len >= 9)
3944 committer[8] = '\0';
3946 nl = strchr(line, '\n');
3947 if (nl)
3948 *nl = '\0';
3950 kerr = khtml_attr(a->gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
3951 "blame_wrapper", KATTR__MAX);
3952 if (kerr != KCGI_OK)
3953 goto err;
3954 kerr = khtml_attr(a->gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
3955 "blame_number", KATTR__MAX);
3956 if (kerr != KCGI_OK)
3957 goto err;
3958 kerr = khtml_printf(a->gw_trans->gw_html_req, "%.*d",
3959 a->nlines_prec, a->lineno_cur);
3960 if (kerr != KCGI_OK)
3961 goto err;
3962 kerr = khtml_closeelem(a->gw_trans->gw_html_req, 1);
3963 if (kerr != KCGI_OK)
3964 goto err;
3966 kerr = khtml_attr(a->gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
3967 "blame_hash", KATTR__MAX);
3968 if (kerr != KCGI_OK)
3969 goto err;
3971 href_diff = khttp_urlpart(NULL, NULL, "gotweb", "path",
3972 a->gw_trans->repo_name, "action", "diff", "commit",
3973 bline->id_str, NULL);
3974 if (href_diff == NULL) {
3975 err = got_error_from_errno("khttp_urlpart");
3976 goto done;
3978 kerr = khtml_attr(a->gw_trans->gw_html_req, KELEM_A,
3979 KATTR_HREF, href_diff, KATTR__MAX);
3980 if (kerr != KCGI_OK)
3981 goto done;
3982 kerr = khtml_printf(a->gw_trans->gw_html_req, "%.8s",
3983 bline->id_str);
3984 if (kerr != KCGI_OK)
3985 goto err;
3986 kerr = khtml_closeelem(a->gw_trans->gw_html_req, 2);
3987 if (kerr != KCGI_OK)
3988 goto err;
3990 kerr = khtml_attr(a->gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
3991 "blame_date", KATTR__MAX);
3992 if (kerr != KCGI_OK)
3993 goto err;
3994 kerr = khtml_puts(a->gw_trans->gw_html_req, bline->datebuf);
3995 if (kerr != KCGI_OK)
3996 goto err;
3997 kerr = khtml_closeelem(a->gw_trans->gw_html_req, 1);
3998 if (kerr != KCGI_OK)
3999 goto err;
4001 kerr = khtml_attr(a->gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
4002 "blame_author", KATTR__MAX);
4003 if (kerr != KCGI_OK)
4004 goto err;
4005 kerr = khtml_puts(a->gw_trans->gw_html_req, committer);
4006 if (kerr != KCGI_OK)
4007 goto err;
4008 kerr = khtml_closeelem(a->gw_trans->gw_html_req, 1);
4009 if (kerr != KCGI_OK)
4010 goto err;
4012 kerr = khtml_attr(a->gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
4013 "blame_code", KATTR__MAX);
4014 if (kerr != KCGI_OK)
4015 goto err;
4016 kerr = khtml_puts(a->gw_trans->gw_html_req, line);
4017 if (kerr != KCGI_OK)
4018 goto err;
4019 kerr = khtml_closeelem(a->gw_trans->gw_html_req, 1);
4020 if (kerr != KCGI_OK)
4021 goto err;
4023 kerr = khtml_closeelem(a->gw_trans->gw_html_req, 1);
4024 if (kerr != KCGI_OK)
4025 goto err;
4027 a->lineno_cur++;
4028 bline = &a->lines[a->lineno_cur - 1];
4029 err:
4030 free(href_diff);
4032 done:
4033 if (commit)
4034 got_object_commit_close(commit);
4035 free(line);
4036 if (err == NULL && kerr != KCGI_OK)
4037 err = gw_kcgi_error(kerr);
4038 return err;
4041 static const struct got_error *
4042 gw_output_file_blame(struct gw_trans *gw_trans, struct gw_header *header)
4044 const struct got_error *error = NULL;
4045 struct got_object_id *obj_id = NULL;
4046 struct got_object_id *commit_id = NULL;
4047 struct got_blob_object *blob = NULL;
4048 char *path = NULL, *in_repo_path = NULL;
4049 struct gw_blame_cb_args bca;
4050 int i, obj_type;
4051 off_t filesize;
4053 memset(&bca, 0, sizeof(bca));
4055 if (asprintf(&path, "%s%s%s",
4056 gw_trans->repo_folder ? gw_trans->repo_folder : "",
4057 gw_trans->repo_folder ? "/" : "",
4058 gw_trans->repo_file) == -1) {
4059 error = got_error_from_errno("asprintf");
4060 goto done;
4063 error = got_repo_map_path(&in_repo_path, gw_trans->repo, path);
4064 if (error)
4065 goto done;
4067 error = got_repo_match_object_id(&commit_id, NULL, gw_trans->commit_id,
4068 GOT_OBJ_TYPE_COMMIT, &header->refs, gw_trans->repo);
4069 if (error)
4070 goto done;
4072 error = got_object_id_by_path(&obj_id, gw_trans->repo, commit_id,
4073 in_repo_path);
4074 if (error)
4075 goto done;
4077 if (obj_id == NULL) {
4078 error = got_error(GOT_ERR_NO_OBJ);
4079 goto done;
4082 error = got_object_get_type(&obj_type, gw_trans->repo, obj_id);
4083 if (error)
4084 goto done;
4086 if (obj_type != GOT_OBJ_TYPE_BLOB) {
4087 error = got_error(GOT_ERR_OBJ_TYPE);
4088 goto done;
4091 error = got_object_open_as_blob(&blob, gw_trans->repo, obj_id, 8192);
4092 if (error)
4093 goto done;
4095 bca.f = got_opentemp();
4096 if (bca.f == NULL) {
4097 error = got_error_from_errno("got_opentemp");
4098 goto done;
4100 error = got_object_blob_dump_to_file(&filesize, &bca.nlines,
4101 &bca.line_offsets, bca.f, blob);
4102 if (error || bca.nlines == 0)
4103 goto done;
4105 /* Don't include \n at EOF in the blame line count. */
4106 if (bca.line_offsets[bca.nlines - 1] == filesize)
4107 bca.nlines--;
4109 bca.lines = calloc(bca.nlines, sizeof(*bca.lines));
4110 if (bca.lines == NULL) {
4111 error = got_error_from_errno("calloc");
4112 goto done;
4114 bca.lineno_cur = 1;
4115 bca.nlines_prec = 0;
4116 i = bca.nlines;
4117 while (i > 0) {
4118 i /= 10;
4119 bca.nlines_prec++;
4121 bca.repo = gw_trans->repo;
4122 bca.gw_trans = gw_trans;
4124 error = got_blame(in_repo_path, commit_id, gw_trans->repo, gw_blame_cb,
4125 &bca, NULL, NULL);
4126 done:
4127 free(in_repo_path);
4128 free(commit_id);
4129 free(obj_id);
4130 free(path);
4132 if (blob) {
4133 free(bca.line_offsets);
4134 for (i = 0; i < bca.nlines; i++) {
4135 struct blame_line *bline = &bca.lines[i];
4136 free(bline->id_str);
4137 free(bline->committer);
4139 free(bca.lines);
4140 if (bca.f && fclose(bca.f) == EOF && error == NULL)
4141 error = got_error_from_errno("fclose");
4143 if (blob)
4144 got_object_blob_close(blob);
4145 return error;
4148 static const struct got_error *
4149 gw_output_blob_buf(struct gw_trans *gw_trans, struct gw_header *header)
4151 const struct got_error *error = NULL;
4152 struct got_object_id *obj_id = NULL;
4153 struct got_object_id *commit_id = NULL;
4154 struct got_blob_object *blob = NULL;
4155 char *path = NULL, *in_repo_path = NULL;
4156 int obj_type, set_mime = 0;
4157 size_t len, hdrlen;
4158 const uint8_t *buf;
4159 enum kcgi_err kerr = KCGI_OK;
4161 if (asprintf(&path, "%s%s%s",
4162 gw_trans->repo_folder ? gw_trans->repo_folder : "",
4163 gw_trans->repo_folder ? "/" : "",
4164 gw_trans->repo_file) == -1) {
4165 error = got_error_from_errno("asprintf");
4166 goto done;
4169 error = got_repo_map_path(&in_repo_path, gw_trans->repo, path);
4170 if (error)
4171 goto done;
4173 error = got_repo_match_object_id(&commit_id, NULL, gw_trans->commit_id,
4174 GOT_OBJ_TYPE_COMMIT, &header->refs, gw_trans->repo);
4175 if (error)
4176 goto done;
4178 error = got_object_id_by_path(&obj_id, gw_trans->repo, commit_id,
4179 in_repo_path);
4180 if (error)
4181 goto done;
4183 if (obj_id == NULL) {
4184 error = got_error(GOT_ERR_NO_OBJ);
4185 goto done;
4188 error = got_object_get_type(&obj_type, gw_trans->repo, obj_id);
4189 if (error)
4190 goto done;
4192 if (obj_type != GOT_OBJ_TYPE_BLOB) {
4193 error = got_error(GOT_ERR_OBJ_TYPE);
4194 goto done;
4197 error = got_object_open_as_blob(&blob, gw_trans->repo, obj_id, 8192);
4198 if (error)
4199 goto done;
4201 hdrlen = got_object_blob_get_hdrlen(blob);
4202 do {
4203 error = got_object_blob_read_block(&len, blob);
4204 if (error)
4205 goto done;
4206 buf = got_object_blob_get_read_buf(blob);
4209 * Skip blob object header first time around,
4210 * which also contains a zero byte.
4212 buf += hdrlen;
4213 if (set_mime == 0) {
4214 if (isbinary(buf, len - hdrlen))
4215 gw_trans->mime = KMIME_APP_OCTET_STREAM;
4216 else
4217 gw_trans->mime = KMIME_TEXT_PLAIN;
4218 set_mime = 1;
4219 error = gw_display_index(gw_trans);
4220 if (error)
4221 goto done;
4223 kerr = khttp_write(gw_trans->gw_req, buf, len - hdrlen);
4224 if (kerr != KCGI_OK)
4225 goto done;
4226 hdrlen = 0;
4227 } while (len != 0);
4228 done:
4229 free(in_repo_path);
4230 free(commit_id);
4231 free(obj_id);
4232 free(path);
4233 if (blob)
4234 got_object_blob_close(blob);
4235 if (error == NULL && kerr != KCGI_OK)
4236 error = gw_kcgi_error(kerr);
4237 return error;
4240 static const struct got_error *
4241 gw_output_repo_tree(struct gw_trans *gw_trans, struct gw_header *header)
4243 const struct got_error *error = NULL;
4244 struct got_object_id *tree_id = NULL, *commit_id = NULL;
4245 struct got_tree_object *tree = NULL;
4246 char *path = NULL, *in_repo_path = NULL;
4247 char *id_str = NULL;
4248 char *build_folder = NULL;
4249 char *href_blob = NULL, *href_blame = NULL;
4250 const char *class = NULL;
4251 int nentries, i, class_flip = 0;
4252 enum kcgi_err kerr = KCGI_OK;
4254 if (gw_trans->repo_folder != NULL) {
4255 path = strdup(gw_trans->repo_folder);
4256 if (path == NULL) {
4257 error = got_error_from_errno("strdup");
4258 goto done;
4260 } else {
4261 error = got_repo_map_path(&in_repo_path, gw_trans->repo,
4262 gw_trans->repo_path);
4263 if (error)
4264 goto done;
4265 free(path);
4266 path = in_repo_path;
4269 if (gw_trans->commit_id == NULL) {
4270 struct got_reference *head_ref;
4271 error = got_ref_open(&head_ref, gw_trans->repo,
4272 gw_trans->headref, 0);
4273 if (error)
4274 goto done;
4275 error = got_ref_resolve(&commit_id, gw_trans->repo, head_ref);
4276 if (error)
4277 goto done;
4278 got_ref_close(head_ref);
4280 * gw_trans->commit_id was not parsed from the querystring
4281 * we hit this code path from gw_index, where we don't know the
4282 * commit values for the tree link yet, so set
4283 * gw_trans->commit_id here to continue further into the tree
4285 error = got_object_id_str(&gw_trans->commit_id, commit_id);
4286 if (error)
4287 goto done;
4289 } else {
4290 error = got_repo_match_object_id(&commit_id, NULL,
4291 gw_trans->commit_id, GOT_OBJ_TYPE_COMMIT, &header->refs,
4292 gw_trans->repo);
4293 if (error)
4294 goto done;
4297 error = got_object_id_by_path(&tree_id, gw_trans->repo, commit_id,
4298 path);
4299 if (error)
4300 goto done;
4302 error = got_object_open_as_tree(&tree, gw_trans->repo, tree_id);
4303 if (error)
4304 goto done;
4306 nentries = got_object_tree_get_nentries(tree);
4307 for (i = 0; i < nentries; i++) {
4308 struct got_tree_entry *te;
4309 const char *modestr = "";
4310 mode_t mode;
4312 te = got_object_tree_get_entry(tree, i);
4314 error = got_object_id_str(&id_str, got_tree_entry_get_id(te));
4315 if (error)
4316 goto done;
4318 mode = got_tree_entry_get_mode(te);
4319 if (got_object_tree_entry_is_submodule(te))
4320 modestr = "$";
4321 else if (S_ISLNK(mode))
4322 modestr = "@";
4323 else if (S_ISDIR(mode))
4324 modestr = "/";
4325 else if (mode & S_IXUSR)
4326 modestr = "*";
4328 if (class_flip == 0) {
4329 class = "back_lightgray";
4330 class_flip = 1;
4331 } else {
4332 class = "back_white";
4333 class_flip = 0;
4336 if (S_ISDIR(mode)) {
4337 if (asprintf(&build_folder, "%s/%s",
4338 gw_trans->repo_folder ? gw_trans->repo_folder : "",
4339 got_tree_entry_get_name(te)) == -1) {
4340 error = got_error_from_errno("asprintf");
4341 goto done;
4344 href_blob = khttp_urlpart(NULL, NULL, "gotweb", "path",
4345 gw_trans->repo_name, "action",
4346 gw_get_action_name(gw_trans), "commit",
4347 gw_trans->commit_id, "folder", build_folder, NULL);
4348 if (href_blob == NULL) {
4349 error = got_error_from_errno("khttp_urlpart");
4350 goto done;
4352 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4353 KATTR_ID, "tree_wrapper", KATTR__MAX);
4354 if (kerr != KCGI_OK)
4355 goto done;
4356 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4357 KATTR_ID, "tree_line", KATTR_CLASS, class,
4358 KATTR__MAX);
4359 if (kerr != KCGI_OK)
4360 goto done;
4361 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
4362 KATTR_HREF, href_blob, KATTR_CLASS,
4363 "diff_directory", KATTR__MAX);
4364 if (kerr != KCGI_OK)
4365 goto done;
4366 kerr = khtml_printf(gw_trans->gw_html_req, "%s%s",
4367 got_tree_entry_get_name(te), modestr);
4368 if (kerr != KCGI_OK)
4369 goto done;
4370 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
4371 if (kerr != KCGI_OK)
4372 goto done;
4373 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4374 KATTR_ID, "tree_line_blank", KATTR_CLASS, class,
4375 KATTR__MAX);
4376 if (kerr != KCGI_OK)
4377 goto done;
4378 kerr = khtml_entity(gw_trans->gw_html_req,
4379 KENTITY_nbsp);
4380 if (kerr != KCGI_OK)
4381 goto done;
4382 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
4383 if (kerr != KCGI_OK)
4384 goto done;
4385 } else {
4386 href_blob = khttp_urlpart(NULL, NULL, "gotweb", "path",
4387 gw_trans->repo_name, "action", "blob", "commit",
4388 gw_trans->commit_id, "file",
4389 got_tree_entry_get_name(te), "folder",
4390 gw_trans->repo_folder ? gw_trans->repo_folder : "",
4391 NULL);
4392 if (href_blob == NULL) {
4393 error = got_error_from_errno("khttp_urlpart");
4394 goto done;
4396 href_blame = khttp_urlpart(NULL, NULL, "gotweb", "path",
4397 gw_trans->repo_name, "action", "blame", "commit",
4398 gw_trans->commit_id, "file",
4399 got_tree_entry_get_name(te), "folder",
4400 gw_trans->repo_folder ? gw_trans->repo_folder : "",
4401 NULL);
4402 if (href_blame == NULL) {
4403 error = got_error_from_errno("khttp_urlpart");
4404 goto done;
4406 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4407 KATTR_ID, "tree_wrapper", KATTR__MAX);
4408 if (kerr != KCGI_OK)
4409 goto done;
4410 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4411 KATTR_ID, "tree_line", KATTR_CLASS, class,
4412 KATTR__MAX);
4413 if (kerr != KCGI_OK)
4414 goto done;
4415 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
4416 KATTR_HREF, href_blob, KATTR__MAX);
4417 if (kerr != KCGI_OK)
4418 goto done;
4419 kerr = khtml_printf(gw_trans->gw_html_req, "%s%s",
4420 got_tree_entry_get_name(te), modestr);
4421 if (kerr != KCGI_OK)
4422 goto done;
4423 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
4424 if (kerr != KCGI_OK)
4425 goto done;
4426 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4427 KATTR_ID, "tree_line_navs", KATTR_CLASS, class,
4428 KATTR__MAX);
4429 if (kerr != KCGI_OK)
4430 goto done;
4432 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
4433 KATTR_HREF, href_blob, KATTR__MAX);
4434 if (kerr != KCGI_OK)
4435 goto done;
4436 kerr = khtml_puts(gw_trans->gw_html_req, "blob");
4437 if (kerr != KCGI_OK)
4438 goto done;
4439 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
4440 if (kerr != KCGI_OK)
4441 goto done;
4443 kerr = khtml_puts(gw_trans->gw_html_req, " | ");
4444 if (kerr != KCGI_OK)
4445 goto done;
4447 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A,
4448 KATTR_HREF, href_blame, KATTR__MAX);
4449 if (kerr != KCGI_OK)
4450 goto done;
4451 kerr = khtml_puts(gw_trans->gw_html_req, "blame");
4452 if (kerr != KCGI_OK)
4453 goto done;
4455 kerr = khtml_closeelem(gw_trans->gw_html_req, 3);
4456 if (kerr != KCGI_OK)
4457 goto done;
4459 free(id_str);
4460 id_str = NULL;
4461 free(href_blob);
4462 href_blob = NULL;
4463 free(build_folder);
4464 build_folder = NULL;
4466 done:
4467 if (tree)
4468 got_object_tree_close(tree);
4469 free(id_str);
4470 free(href_blob);
4471 free(href_blame);
4472 free(in_repo_path);
4473 free(tree_id);
4474 free(build_folder);
4475 if (error == NULL && kerr != KCGI_OK)
4476 error = gw_kcgi_error(kerr);
4477 return error;
4480 static const struct got_error *
4481 gw_output_repo_heads(struct gw_trans *gw_trans)
4483 const struct got_error *error = NULL;
4484 struct got_reflist_head refs;
4485 struct got_reflist_entry *re;
4486 char *age = NULL, *href_summary = NULL, *href_briefs = NULL;
4487 char *href_commits = NULL;
4488 enum kcgi_err kerr = KCGI_OK;
4490 TAILQ_INIT(&refs);
4492 error = got_ref_list(&refs, gw_trans->repo, "refs/heads",
4493 got_ref_cmp_by_name, NULL);
4494 if (error)
4495 goto done;
4497 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4498 KATTR_ID, "summary_heads_title_wrapper", KATTR__MAX);
4499 if (kerr != KCGI_OK)
4500 goto done;
4501 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4502 KATTR_ID, "summary_heads_title", KATTR__MAX);
4503 if (kerr != KCGI_OK)
4504 goto done;
4505 kerr = khtml_puts(gw_trans->gw_html_req, "Heads");
4506 if (kerr != KCGI_OK)
4507 goto done;
4508 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
4509 if (kerr != KCGI_OK)
4510 goto done;
4511 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4512 KATTR_ID, "summary_heads_content", KATTR__MAX);
4513 if (kerr != KCGI_OK)
4514 goto done;
4516 TAILQ_FOREACH(re, &refs, entry) {
4517 const char *refname;
4519 if (got_ref_is_symbolic(re->ref))
4520 continue;
4522 refname = got_ref_get_name(re->ref);
4523 if (strncmp(refname, "refs/heads/", 11) != 0)
4524 continue;
4526 error = gw_get_repo_age(&age, gw_trans, gw_trans->gw_dir->path,
4527 refname, TM_DIFF);
4528 if (error)
4529 goto done;
4531 if (strncmp(refname, "refs/heads/", 11) == 0)
4532 refname += 11;
4534 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4535 KATTR_ID, "heads_wrapper", KATTR__MAX);
4536 if (kerr != KCGI_OK)
4537 goto done;
4538 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4539 KATTR_ID, "heads_age", KATTR__MAX);
4540 if (kerr != KCGI_OK)
4541 goto done;
4542 kerr = khtml_puts(gw_trans->gw_html_req, age ? age : "");
4543 if (kerr != KCGI_OK)
4544 goto done;
4545 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
4546 if (kerr != KCGI_OK)
4547 goto done;
4548 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4549 KATTR_ID, "heads_space", KATTR__MAX);
4550 if (kerr != KCGI_OK)
4551 goto done;
4552 kerr = khtml_entity(gw_trans->gw_html_req, KENTITY_nbsp);
4553 if (kerr != KCGI_OK)
4554 goto done;
4555 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
4556 if (kerr != KCGI_OK)
4557 goto done;
4558 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV,
4559 KATTR_ID, "head", KATTR__MAX);
4560 if (kerr != KCGI_OK)
4561 goto done;
4563 href_summary = khttp_urlpart(NULL, NULL, "gotweb", "path",
4564 gw_trans->repo_name, "action", "summary", "headref",
4565 refname, NULL);
4566 if (href_summary == NULL) {
4567 error = got_error_from_errno("khttp_urlpart");
4568 goto done;
4570 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF,
4571 href_summary, KATTR__MAX);
4572 kerr = khtml_puts(gw_trans->gw_html_req, refname);
4573 if (kerr != KCGI_OK)
4574 goto done;
4575 kerr = khtml_closeelem(gw_trans->gw_html_req, 3);
4576 if (kerr != KCGI_OK)
4577 goto done;
4579 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
4580 "navs_wrapper", KATTR__MAX);
4581 if (kerr != KCGI_OK)
4582 goto done;
4583 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
4584 "navs", KATTR__MAX);
4585 if (kerr != KCGI_OK)
4586 goto done;
4588 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF,
4589 href_summary, KATTR__MAX);
4590 if (kerr != KCGI_OK)
4591 goto done;
4592 kerr = khtml_puts(gw_trans->gw_html_req, "summary");
4593 if (kerr != KCGI_OK)
4594 goto done;
4595 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
4596 if (kerr != KCGI_OK)
4597 goto done;
4599 kerr = khtml_puts(gw_trans->gw_html_req, " | ");
4600 if (kerr != KCGI_OK)
4601 goto done;
4603 href_briefs = khttp_urlpart(NULL, NULL, "gotweb", "path",
4604 gw_trans->repo_name, "action", "briefs", "headref",
4605 refname, NULL);
4606 if (href_briefs == NULL) {
4607 error = got_error_from_errno("khttp_urlpart");
4608 goto done;
4610 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF,
4611 href_briefs, KATTR__MAX);
4612 if (kerr != KCGI_OK)
4613 goto done;
4614 kerr = khtml_puts(gw_trans->gw_html_req, "commit briefs");
4615 if (kerr != KCGI_OK)
4616 goto done;
4617 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
4618 if (kerr != KCGI_OK)
4619 goto done;
4621 kerr = khtml_puts(gw_trans->gw_html_req, " | ");
4622 if (kerr != KCGI_OK)
4623 goto done;
4625 href_commits = khttp_urlpart(NULL, NULL, "gotweb", "path",
4626 gw_trans->repo_name, "action", "commits", "headref",
4627 refname, NULL);
4628 if (href_commits == NULL) {
4629 error = got_error_from_errno("khttp_urlpart");
4630 goto done;
4632 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF,
4633 href_commits, KATTR__MAX);
4634 if (kerr != KCGI_OK)
4635 goto done;
4636 kerr = khtml_puts(gw_trans->gw_html_req, "commits");
4637 if (kerr != KCGI_OK)
4638 goto done;
4639 kerr = khtml_closeelem(gw_trans->gw_html_req, 3);
4640 if (kerr != KCGI_OK)
4641 goto done;
4643 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
4644 "dotted_line", KATTR__MAX);
4645 if (kerr != KCGI_OK)
4646 goto done;
4647 kerr = khtml_closeelem(gw_trans->gw_html_req, 2);
4648 if (kerr != KCGI_OK)
4649 goto done;
4650 free(href_summary);
4651 href_summary = NULL;
4652 free(href_briefs);
4653 href_briefs = NULL;
4654 free(href_commits);
4655 href_commits = NULL;
4657 done:
4658 got_ref_list_free(&refs);
4659 free(href_summary);
4660 free(href_briefs);
4661 free(href_commits);
4662 return error;
4665 static const struct got_error *
4666 gw_output_site_link(struct gw_trans *gw_trans)
4668 const struct got_error *error = NULL;
4669 char *href_summary = NULL;
4670 enum kcgi_err kerr = KCGI_OK;
4672 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
4673 "site_link", KATTR__MAX);
4674 if (kerr != KCGI_OK)
4675 goto done;
4676 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF, GOTWEB,
4677 KATTR__MAX);
4678 if (kerr != KCGI_OK)
4679 goto done;
4680 kerr = khtml_puts(gw_trans->gw_html_req,
4681 gw_trans->gw_conf->got_site_link);
4682 if (kerr != KCGI_OK)
4683 goto done;
4684 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
4685 if (kerr != KCGI_OK)
4686 goto done;
4688 if (gw_trans->repo_name != NULL) {
4689 kerr = khtml_puts(gw_trans->gw_html_req, " / ");
4690 if (kerr != KCGI_OK)
4691 goto done;
4693 href_summary = khttp_urlpart(NULL, NULL, "gotweb", "path",
4694 gw_trans->repo_name, "action", "summary", NULL);
4695 if (href_summary == NULL) {
4696 error = got_error_from_errno("khttp_urlpart");
4697 goto done;
4699 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_A, KATTR_HREF,
4700 href_summary, KATTR__MAX);
4701 if (kerr != KCGI_OK)
4702 goto done;
4703 kerr = khtml_puts(gw_trans->gw_html_req, gw_trans->repo_name);
4704 if (kerr != KCGI_OK)
4705 goto done;
4706 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
4707 if (kerr != KCGI_OK)
4708 goto done;
4709 kerr = khtml_printf(gw_trans->gw_html_req, " / %s",
4710 gw_get_action_name(gw_trans));
4711 if (kerr != KCGI_OK)
4712 goto done;
4715 kerr = khtml_closeelem(gw_trans->gw_html_req, 1);
4716 if (kerr != KCGI_OK)
4717 goto done;
4718 done:
4719 free(href_summary);
4720 if (error == NULL && kerr != KCGI_OK)
4721 error = gw_kcgi_error(kerr);
4722 return error;
4725 static const struct got_error *
4726 gw_colordiff_line(struct gw_trans *gw_trans, char *buf)
4728 const struct got_error *error = NULL;
4729 char *color = NULL;
4730 enum kcgi_err kerr = KCGI_OK;
4732 if (strncmp(buf, "-", 1) == 0)
4733 color = "diff_minus";
4734 else if (strncmp(buf, "+", 1) == 0)
4735 color = "diff_plus";
4736 else if (strncmp(buf, "@@", 2) == 0)
4737 color = "diff_chunk_header";
4738 else if (strncmp(buf, "@@", 2) == 0)
4739 color = "diff_chunk_header";
4740 else if (strncmp(buf, "commit +", 8) == 0)
4741 color = "diff_meta";
4742 else if (strncmp(buf, "commit -", 8) == 0)
4743 color = "diff_meta";
4744 else if (strncmp(buf, "blob +", 6) == 0)
4745 color = "diff_meta";
4746 else if (strncmp(buf, "blob -", 6) == 0)
4747 color = "diff_meta";
4748 else if (strncmp(buf, "file +", 6) == 0)
4749 color = "diff_meta";
4750 else if (strncmp(buf, "file -", 6) == 0)
4751 color = "diff_meta";
4752 else if (strncmp(buf, "from:", 5) == 0)
4753 color = "diff_author";
4754 else if (strncmp(buf, "via:", 4) == 0)
4755 color = "diff_author";
4756 else if (strncmp(buf, "date:", 5) == 0)
4757 color = "diff_date";
4758 kerr = khtml_attr(gw_trans->gw_html_req, KELEM_DIV, KATTR_ID,
4759 "diff_line", KATTR_CLASS, color ? color : "", KATTR__MAX);
4760 if (error == NULL && kerr != KCGI_OK)
4761 error = gw_kcgi_error(kerr);
4762 return error;
4765 int
4766 main(int argc, char *argv[])
4768 const struct got_error *error = NULL, *error2 = NULL;
4769 struct gw_trans *gw_trans;
4770 struct gw_dir *dir = NULL, *tdir;
4771 const char *page = "index";
4772 enum kcgi_err kerr = KCGI_OK;
4774 if ((gw_trans = malloc(sizeof(struct gw_trans))) == NULL)
4775 errx(1, "malloc");
4777 if ((gw_trans->gw_req = malloc(sizeof(struct kreq))) == NULL)
4778 errx(1, "malloc");
4780 if ((gw_trans->gw_html_req = malloc(sizeof(struct khtmlreq))) == NULL)
4781 errx(1, "malloc");
4783 if ((gw_trans->gw_tmpl = malloc(sizeof(struct ktemplate))) == NULL)
4784 errx(1, "malloc");
4786 kerr = khttp_parse(gw_trans->gw_req, gw_keys, KEY__ZMAX, &page, 1, 0);
4787 if (kerr != KCGI_OK) {
4788 error = gw_kcgi_error(kerr);
4789 goto done;
4792 TAILQ_INIT(&gw_trans->gw_dirs);
4793 TAILQ_INIT(&gw_trans->gw_headers);
4795 gw_trans->action = -1;
4796 gw_trans->page = 0;
4797 gw_trans->repos_total = 0;
4798 gw_trans->repo_path = NULL;
4799 gw_trans->commit_id = NULL;
4800 gw_trans->next_id = NULL;
4801 gw_trans->prev_id = NULL;
4802 gw_trans->headref = GOT_REF_HEAD;
4803 gw_trans->mime = KMIME_TEXT_HTML;
4804 gw_trans->gw_tmpl->key = gw_templs;
4805 gw_trans->gw_tmpl->keysz = TEMPL__MAX;
4806 gw_trans->gw_tmpl->arg = gw_trans;
4807 gw_trans->gw_tmpl->cb = gw_template;
4809 error = parse_gotweb_config(&gw_trans->gw_conf, GOTWEB_CONF);
4810 if (error)
4811 goto done;
4813 error = gw_parse_querystring(gw_trans);
4814 if (error)
4815 goto done;
4817 if (gw_trans->action == GW_BLOB)
4818 error = gw_blob(gw_trans);
4819 else
4820 error = gw_display_index(gw_trans);
4821 done:
4822 if (gw_trans->repo) {
4823 const struct got_error *close_err;
4824 close_err = got_repo_close(gw_trans->repo);
4825 if (error == NULL)
4826 error = close_err;
4828 if (error) {
4829 gw_trans->error = error;
4830 gw_trans->action = GW_ERR;
4831 error2 = gw_display_open(gw_trans, KHTTP_200, gw_trans->mime);
4832 if (error2)
4833 goto cleanup; /* we can't display an error page */
4834 kerr = khtml_open(gw_trans->gw_html_req, gw_trans->gw_req, 0);
4835 if (kerr != KCGI_OK)
4836 goto cleanup; /* we can't display an error page */
4837 kerr = khttp_template(gw_trans->gw_req, gw_trans->gw_tmpl,
4838 gw_query_funcs[gw_trans->action].template);
4839 if (kerr != KCGI_OK) {
4840 khtml_close(gw_trans->gw_html_req);
4841 goto cleanup; /* we can't display an error page */
4845 cleanup:
4846 free(gw_trans->gw_conf->got_repos_path);
4847 free(gw_trans->gw_conf->got_www_path);
4848 free(gw_trans->gw_conf->got_site_name);
4849 free(gw_trans->gw_conf->got_site_owner);
4850 free(gw_trans->gw_conf->got_site_link);
4851 free(gw_trans->gw_conf->got_logo);
4852 free(gw_trans->gw_conf->got_logo_url);
4853 free(gw_trans->gw_conf);
4854 free(gw_trans->commit_id);
4855 free(gw_trans->next_id);
4856 free(gw_trans->prev_id);
4857 free(gw_trans->repo_path);
4858 TAILQ_FOREACH_SAFE(dir, &gw_trans->gw_dirs, entry, tdir) {
4859 free(dir->name);
4860 free(dir->description);
4861 free(dir->age);
4862 free(dir->url);
4863 free(dir->path);
4864 free(dir);
4867 khttp_free(gw_trans->gw_req);
4868 return 0;