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