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 <stdarg.h>
28 #include <stdint.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33 
34 #include <got_object.h>
35 #include <got_reference.h>
36 #include <got_repository.h>
37 #include <got_path.h>
38 #include <got_cancel.h>
39 #include <got_worktree.h>
40 #include <got_diff.h>
41 #include <got_commit_graph.h>
42 #include <got_blame.h>
43 #include <got_privsep.h>
44 #include <got_opentemp.h>
45 
46 #include <kcgi.h>
47 #include <kcgihtml.h>
48 
49 #include "buf.h"
50 #include "gotweb.h"
51 #include "gotweb_ui.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 gw_dir		*gw_dir;
61 	struct gotweb_conf	*gw_conf;
62 	struct ktemplate	*gw_tmpl;
63 	struct khtmlreq		*gw_html_req;
64 	struct kreq		*gw_req;
65 	char			*repo_name;
66 	char			*repo_path;
67 	char			*commit;
68 	char			*repo_file;
69 	char			*repo_folder;
70 	char			*action_name;
71 	char			*headref;
72 	unsigned int		 action;
73 	unsigned int		 page;
74 	unsigned int		 repos_total;
75 	enum kmime		 mime;
76 };
77 
78 struct gw_header {
79 	TAILQ_ENTRY(gw_header)		 entry;
80 	struct got_repository		*repo;
81 	struct got_reflist_head		 refs;
82 	struct got_commit_object	*commit;
83 	struct got_object_id		*id;
84 	char				*path;
85 
86 	char			*refs_str;
87 	char			*commit_id; /* id_str1 */
88 	char			*parent_id; /* id_str2 */
89 	char			*tree_id;
90 	char			*author;
91 	char			*committer;
92 	char			*commit_msg;
93 	time_t			 committer_time;
94 };
95 
96 struct gw_dir {
97 	TAILQ_ENTRY(gw_dir)	 entry;
98 	char			*name;
99 	char			*owner;
100 	char			*description;
101 	char			*url;
102 	char			*age;
103 	char			*path;
104 };
105 
106 enum gw_key {
107 	KEY_ACTION,
108 	KEY_COMMIT_ID,
109 	KEY_FILE,
110 	KEY_FOLDER,
111 	KEY_HEADREF,
112 	KEY_PAGE,
113 	KEY_PATH,
114 	KEY__ZMAX
115 };
116 
117 enum gw_tmpl {
118 	TEMPL_CONTENT,
119 	TEMPL_HEAD,
120 	TEMPL_HEADER,
121 	TEMPL_SEARCH,
122 	TEMPL_SITEPATH,
123 	TEMPL_SITEOWNER,
124 	TEMPL_TITLE,
125 	TEMPL__MAX
126 };
127 
128 enum gw_ref_tm {
129 	TM_DIFF,
130 	TM_LONG,
131 };
132 
133 enum gw_tags {
134 	TAGBRIEF,
135 	TAGFULL,
136 };
137 
138 static const char *const gw_templs[TEMPL__MAX] = {
139 	"content",
140 	"head",
141 	"header",
142 	"search",
143 	"sitepath",
144 	"siteowner",
145 	"title",
146 };
147 
148 static const struct kvalid gw_keys[KEY__ZMAX] = {
149 	{ kvalid_stringne,	"action" },
150 	{ kvalid_stringne,	"commit" },
151 	{ kvalid_stringne,	"file" },
152 	{ kvalid_stringne,	"folder" },
153 	{ kvalid_stringne,	"headref" },
154 	{ kvalid_int,		"page" },
155 	{ kvalid_stringne,	"path" },
156 };
157 
158 static struct gw_dir		*gw_init_gw_dir(char *);
159 static struct gw_header		*gw_init_header(void);
160 
161 static char			*gw_get_repo_description(struct gw_trans *,
162 				    char *);
163 static char			*gw_get_repo_owner(struct gw_trans *,
164 				    char *);
165 static char			*gw_get_time_str(time_t, int);
166 static const struct got_error	*gw_get_repo_age(char **, struct gw_trans *,
167 				    char *, char *, int);
168 static char			*gw_get_file_blame_blob(struct gw_trans *);
169 static char			*gw_get_repo_tree(struct gw_trans *);
170 static char			*gw_get_diff(struct gw_trans *,
171 				    struct gw_header *);
172 static char			*gw_get_repo_tags(struct gw_trans *,
173 				    struct gw_header *, int, int);
174 static char			*gw_get_repo_heads(struct gw_trans *);
175 static char			*gw_get_clone_url(struct gw_trans *, char *);
176 static char			*gw_get_got_link(struct gw_trans *);
177 static char			*gw_get_site_link(struct gw_trans *);
178 static char			*gw_html_escape(const char *);
179 static char			*gw_colordiff_line(char *);
180 
181 static char			*gw_gen_commit_header(char *, char*);
182 static char			*gw_gen_diff_header(char *, char*);
183 static char			*gw_gen_author_header(char *);
184 static char			*gw_gen_committer_header(char *);
185 static char			*gw_gen_age_header(char *);
186 static char			*gw_gen_commit_msg_header(char *);
187 static char			*gw_gen_tree_header(char *);
188 
189 static void			 gw_free_headers(struct gw_header *);
190 static const struct got_error*	 gw_display_open(struct gw_trans *, enum khttp,
191 				    enum kmime);
192 static const struct got_error*	 gw_display_index(struct gw_trans *);
193 static void			 gw_display_error(struct gw_trans *,
194 				    const struct got_error *);
195 
196 static int			 gw_template(size_t, void *);
197 
198 static const struct got_error*	 gw_get_header(struct gw_trans *,
199 				    struct gw_header *, int);
200 static const struct got_error*	 gw_get_commits(struct gw_trans *,
201 				    struct gw_header *, int);
202 static const struct got_error*	 gw_get_commit(struct gw_trans *,
203 				    struct gw_header *);
204 static const struct got_error*	 gw_apply_unveil(const char *, const char *);
205 static const struct got_error*	 gw_blame_cb(void *, int, int,
206 				    struct got_object_id *);
207 static const struct got_error*	 gw_load_got_paths(struct gw_trans *);
208 static const struct got_error*	 gw_load_got_path(struct gw_trans *,
209 				    struct gw_dir *);
210 static const struct got_error*	 gw_parse_querystring(struct gw_trans *);
211 
212 static const struct got_error*	 gw_blame(struct gw_trans *);
213 static const struct got_error*	 gw_blob(struct gw_trans *);
214 static const struct got_error*	 gw_diff(struct gw_trans *);
215 static const struct got_error*	 gw_index(struct gw_trans *);
216 static const struct got_error*	 gw_commits(struct gw_trans *);
217 static const struct got_error*	 gw_briefs(struct gw_trans *);
218 static const struct got_error*	 gw_summary(struct gw_trans *);
219 static const struct got_error*	 gw_tree(struct gw_trans *);
220 static const struct got_error*	 gw_tag(struct gw_trans *);
221 
222 struct gw_query_action {
223 	unsigned int		 func_id;
224 	const char		*func_name;
225 	const struct got_error	*(*func_main)(struct gw_trans *);
226 	char			*template;
227 };
228 
229 enum gw_query_actions {
230 	GW_BLAME,
231 	GW_BLOB,
232 	GW_BRIEFS,
233 	GW_COMMITS,
234 	GW_DIFF,
235 	GW_ERR,
236 	GW_INDEX,
237 	GW_SUMMARY,
238 	GW_TAG,
239 	GW_TREE,
240 };
241 
242 static struct gw_query_action gw_query_funcs[] = {
243 	{ GW_BLAME,	"blame",	gw_blame,	"gw_tmpl/blame.tmpl" },
244 	{ GW_BLOB,	"blob",		NULL,		NULL },
245 	{ GW_BRIEFS,	"briefs",	gw_briefs,	"gw_tmpl/briefs.tmpl" },
246 	{ GW_COMMITS,	"commits",	gw_commits,	"gw_tmpl/commit.tmpl" },
247 	{ GW_DIFF,	"diff",		gw_diff,	"gw_tmpl/diff.tmpl" },
248 	{ GW_ERR,	 NULL,		NULL,		"gw_tmpl/err.tmpl" },
249 	{ GW_INDEX,	"index",	gw_index,	"gw_tmpl/index.tmpl" },
250 	{ GW_SUMMARY,	"summary",	gw_summary,	"gw_tmpl/summry.tmpl" },
251 	{ GW_TAG,	"tag",		gw_tag,		"gw_tmpl/tag.tmpl" },
252 	{ GW_TREE,	"tree",		gw_tree,	"gw_tmpl/tree.tmpl" },
253 };
254 
255 static const struct got_error *
256 gw_kcgi_error(enum kcgi_err kerr)
257 {
258 	if (kerr == KCGI_OK)
259 		return NULL;
260 
261 	if (kerr == KCGI_EXIT || kerr == KCGI_HUP)
262 		return got_error(GOT_ERR_CANCELLED);
263 
264 	if (kerr == KCGI_ENOMEM)
265 		return got_error_set_errno(ENOMEM, kcgi_strerror(kerr));
266 
267 	if (kerr == KCGI_ENFILE)
268 		return got_error_set_errno(ENFILE, kcgi_strerror(kerr));
269 
270 	if (kerr == KCGI_EAGAIN)
271 		return got_error_set_errno(EAGAIN, kcgi_strerror(kerr));
272 
273 	if (kerr == KCGI_FORM)
274 		return got_error_msg(GOT_ERR_IO, kcgi_strerror(kerr));
275 
276 	return got_error_from_errno(kcgi_strerror(kerr));
277 }
278 
279 static const struct got_error *
280 gw_apply_unveil(const char *repo_path, const char *repo_file)
281 {
282 	const struct got_error *err;
283 
284 	if (repo_path && repo_file) {
285 		char *full_path;
286 		if (asprintf(&full_path, "%s/%s", repo_path, repo_file) == -1)
287 			return got_error_from_errno("asprintf unveil");
288 		if (unveil(full_path, "r") != 0)
289 			return got_error_from_errno2("unveil", full_path);
290 	}
291 
292 	if (repo_path && unveil(repo_path, "r") != 0)
293 		return got_error_from_errno2("unveil", repo_path);
294 
295 	if (unveil("/tmp", "rwc") != 0)
296 		return got_error_from_errno2("unveil", "/tmp");
297 
298 	err = got_privsep_unveil_exec_helpers();
299 	if (err != NULL)
300 		return err;
301 
302 	if (unveil(NULL, NULL) != 0)
303 		return got_error_from_errno("unveil");
304 
305 	return NULL;
306 }
307 
308 static const struct got_error *
309 gw_blame(struct gw_trans *gw_trans)
310 {
311 	const struct got_error *error = NULL;
312 	struct gw_header *header = NULL;
313 	char *blame = NULL, *blame_html = NULL, *blame_html_disp = NULL;
314 	enum kcgi_err kerr;
315 
316 	if (pledge("stdio rpath wpath cpath proc exec sendfd unveil",
317 	    NULL) == -1)
318 		return got_error_from_errno("pledge");
319 
320 	if ((header = gw_init_header()) == NULL)
321 		return got_error_from_errno("malloc");
322 
323 	error = gw_apply_unveil(gw_trans->gw_dir->path, NULL);
324 	if (error)
325 		goto done;
326 
327 	error = gw_get_header(gw_trans, header, 1);
328 	if (error)
329 		goto done;
330 
331 	blame_html = gw_get_file_blame_blob(gw_trans);
332 
333 	if (blame_html == NULL) {
334 		blame_html = strdup("");
335 		if (blame_html == NULL) {
336 			error = got_error_from_errno("strdup");
337 			goto done;
338 		}
339 	}
340 
341 	if (asprintf(&blame_html_disp, blame_header,
342 	    gw_gen_age_header(gw_get_time_str(header->committer_time, TM_LONG)),
343 	    gw_gen_commit_msg_header(gw_html_escape(header->commit_msg)),
344 	    blame_html) == -1) {
345 		error = got_error_from_errno("asprintf");
346 		goto done;
347 	}
348 
349 	if (asprintf(&blame, blame_wrapper, blame_html_disp) == -1) {
350 		error = got_error_from_errno("asprintf");
351 		goto done;
352 	}
353 
354 	kerr = khttp_puts(gw_trans->gw_req, blame);
355 	if (kerr != KCGI_OK)
356 		error = gw_kcgi_error(kerr);
357 done:
358 	got_ref_list_free(&header->refs);
359 	gw_free_headers(header);
360 	free(blame_html_disp);
361 	free(blame_html);
362 	free(blame);
363 	return error;
364 }
365 
366 static const struct got_error *
367 gw_blob(struct gw_trans *gw_trans)
368 {
369 	const struct got_error *error = NULL;
370 	struct gw_header *header = NULL;
371 	char *blob = NULL;
372 	enum kcgi_err kerr;
373 
374 	if (pledge("stdio rpath wpath cpath proc exec sendfd unveil",
375 	    NULL) == -1)
376 		return got_error_from_errno("pledge");
377 
378 	if ((header = gw_init_header()) == NULL)
379 		return got_error_from_errno("malloc");
380 
381 	error = gw_apply_unveil(gw_trans->gw_dir->path, NULL);
382 	if (error)
383 		goto done;
384 
385 	error = gw_get_header(gw_trans, header, 1);
386 	if (error)
387 		goto done;
388 
389 	blob = gw_get_file_blame_blob(gw_trans);
390 
391 	if (blob == NULL) {
392 		blob = strdup("");
393 		if (blob == NULL) {
394 			error = got_error_from_errno("strdup");
395 			goto done;
396 		}
397 	}
398 
399 	if (gw_trans->mime == KMIME_APP_OCTET_STREAM)
400 		goto done;
401 	else {
402 		kerr = khttp_puts(gw_trans->gw_req, blob);
403 		if (kerr != KCGI_OK)
404 			error = gw_kcgi_error(kerr);
405 	}
406 done:
407 	got_ref_list_free(&header->refs);
408 	gw_free_headers(header);
409 	free(blob);
410 	return error;
411 }
412 
413 static const struct got_error *
414 gw_diff(struct gw_trans *gw_trans)
415 {
416 	const struct got_error *error = NULL;
417 	struct gw_header *header = NULL;
418 	char *diff = NULL, *diff_html = NULL, *diff_html_disp = NULL;
419 	enum kcgi_err kerr;
420 
421 	if (pledge("stdio rpath wpath cpath proc exec sendfd unveil",
422 	    NULL) == -1)
423 		return got_error_from_errno("pledge");
424 
425 	if ((header = gw_init_header()) == NULL)
426 		return got_error_from_errno("malloc");
427 
428 	error = gw_apply_unveil(gw_trans->gw_dir->path, NULL);
429 	if (error)
430 		goto done;
431 
432 	error = gw_get_header(gw_trans, header, 1);
433 	if (error)
434 		goto done;
435 
436 	diff_html = gw_get_diff(gw_trans, header);
437 
438 	if (diff_html == NULL) {
439 		diff_html = strdup("");
440 		if (diff_html == NULL) {
441 			error = got_error_from_errno("strdup");
442 			goto done;
443 		}
444 	}
445 
446 	if (asprintf(&diff_html_disp, diff_header,
447 	    gw_gen_diff_header(header->parent_id, header->commit_id),
448 	    gw_gen_commit_header(header->commit_id, header->refs_str),
449 	    gw_gen_tree_header(header->tree_id),
450 	    gw_gen_author_header(header->author),
451 	    gw_gen_committer_header(header->committer),
452 	    gw_gen_age_header(gw_get_time_str(header->committer_time, TM_LONG)),
453 	    gw_gen_commit_msg_header(gw_html_escape(header->commit_msg)),
454 	    diff_html) == -1) {
455 		error = got_error_from_errno("asprintf");
456 		goto done;
457 	}
458 
459 	if (asprintf(&diff, diff_wrapper, diff_html_disp) == -1) {
460 		error = got_error_from_errno("asprintf");
461 		goto done;
462 	}
463 
464 	kerr = khttp_puts(gw_trans->gw_req, diff);
465 	if (kerr != KCGI_OK)
466 		error = gw_kcgi_error(kerr);
467 done:
468 	got_ref_list_free(&header->refs);
469 	gw_free_headers(header);
470 	free(diff_html_disp);
471 	free(diff_html);
472 	free(diff);
473 	return error;
474 }
475 
476 static const struct got_error *
477 gw_index(struct gw_trans *gw_trans)
478 {
479 	const struct got_error *error = NULL;
480 	struct gw_dir *gw_dir = NULL;
481 	char *html, *navs, *next, *prev;
482 	unsigned int prev_disp = 0, next_disp = 1, dir_c = 0;
483 	enum kcgi_err kerr;
484 
485 	if (pledge("stdio rpath proc exec sendfd unveil",
486 	    NULL) == -1) {
487 		error = got_error_from_errno("pledge");
488 		return error;
489 	}
490 
491 	error = gw_apply_unveil(gw_trans->gw_conf->got_repos_path, NULL);
492 	if (error)
493 		return error;
494 
495 	error = gw_load_got_paths(gw_trans);
496 	if (error)
497 		return error;
498 
499 	kerr = khttp_puts(gw_trans->gw_req, index_projects_header);
500 	if (kerr != KCGI_OK)
501 		return gw_kcgi_error(kerr);
502 
503 	if (TAILQ_EMPTY(&gw_trans->gw_dirs)) {
504 		if (asprintf(&html, index_projects_empty,
505 		    gw_trans->gw_conf->got_repos_path) == -1)
506 			return got_error_from_errno("asprintf");
507 		kerr = khttp_puts(gw_trans->gw_req, html);
508 		if (kerr != KCGI_OK)
509 			error = gw_kcgi_error(kerr);
510 		free(html);
511 		return error;
512 	}
513 
514 	TAILQ_FOREACH(gw_dir, &gw_trans->gw_dirs, entry)
515 		dir_c++;
516 
517 	TAILQ_FOREACH(gw_dir, &gw_trans->gw_dirs, entry) {
518 		if (gw_trans->page > 0 && (gw_trans->page *
519 		    gw_trans->gw_conf->got_max_repos_display) > prev_disp) {
520 			prev_disp++;
521 			continue;
522 		}
523 
524 		prev_disp++;
525 
526 		if (error)
527 			return error;
528 		if(asprintf(&navs, index_navs, gw_dir->name, gw_dir->name,
529 		    gw_dir->name, gw_dir->name) == -1)
530 			return got_error_from_errno("asprintf");
531 
532 		if (asprintf(&html, index_projects, gw_dir->name, gw_dir->name,
533 		    gw_dir->description, gw_dir->owner, gw_dir->age,
534 		    navs) == -1)
535 			return got_error_from_errno("asprintf");
536 
537 		kerr = khttp_puts(gw_trans->gw_req, html);
538 		free(navs);
539 		free(html);
540 		if (kerr != KCGI_OK)
541 			return gw_kcgi_error(kerr);
542 
543 		if (gw_trans->gw_conf->got_max_repos_display == 0)
544 			continue;
545 
546 		if (next_disp == gw_trans->gw_conf->got_max_repos_display) {
547 			kerr = khttp_puts(gw_trans->gw_req, np_wrapper_start);
548 			if (kerr != KCGI_OK)
549 				return gw_kcgi_error(kerr);
550 		} else if ((gw_trans->gw_conf->got_max_repos_display > 0) &&
551 		    (gw_trans->page > 0) &&
552 		    (next_disp == gw_trans->gw_conf->got_max_repos_display ||
553 		    prev_disp == gw_trans->repos_total)) {
554 			kerr = khttp_puts(gw_trans->gw_req, np_wrapper_start);
555 			if (kerr != KCGI_OK)
556 				return gw_kcgi_error(kerr);
557 		}
558 
559 		if ((gw_trans->gw_conf->got_max_repos_display > 0) &&
560 		    (gw_trans->page > 0) &&
561 		    (next_disp == gw_trans->gw_conf->got_max_repos_display ||
562 		    prev_disp == gw_trans->repos_total)) {
563 			if (asprintf(&prev, nav_prev, gw_trans->page - 1) == -1)
564 				return got_error_from_errno("asprintf");
565 			kerr = khttp_puts(gw_trans->gw_req, prev);
566 			free(prev);
567 			if (kerr != KCGI_OK)
568 				return gw_kcgi_error(kerr);
569 		}
570 
571 		kerr = khttp_puts(gw_trans->gw_req, div_end);
572 		if (kerr != KCGI_OK)
573 			return gw_kcgi_error(kerr);
574 
575 		if (gw_trans->gw_conf->got_max_repos_display > 0 &&
576 		    next_disp == gw_trans->gw_conf->got_max_repos_display &&
577 		    dir_c != (gw_trans->page + 1) *
578 		    gw_trans->gw_conf->got_max_repos_display) {
579 			if (asprintf(&next, nav_next, gw_trans->page + 1) == -1)
580 				return got_error_from_errno("calloc");
581 			kerr = khttp_puts(gw_trans->gw_req, next);
582 			free(next);
583 			if (kerr != KCGI_OK)
584 				return gw_kcgi_error(kerr);
585 			kerr = khttp_puts(gw_trans->gw_req, div_end);
586 			if (kerr != KCGI_OK)
587 				error = gw_kcgi_error(kerr);
588 			next_disp = 0;
589 			break;
590 		}
591 
592 		if ((gw_trans->gw_conf->got_max_repos_display > 0) &&
593 		    (gw_trans->page > 0) &&
594 		    (next_disp == gw_trans->gw_conf->got_max_repos_display ||
595 		    prev_disp == gw_trans->repos_total)) {
596 			kerr = khttp_puts(gw_trans->gw_req, div_end);
597 			if (kerr != KCGI_OK)
598 				return gw_kcgi_error(kerr);
599 		}
600 
601 		next_disp++;
602 	}
603 	return error;
604 }
605 
606 static const struct got_error *
607 gw_commits(struct gw_trans *gw_trans)
608 {
609 	const struct got_error *error = NULL;
610 	char *commits_html, *commits_navs_html;
611 	struct gw_header *header = NULL, *n_header = NULL;
612 	enum kcgi_err kerr;
613 
614 	if ((header = gw_init_header()) == NULL)
615 		return got_error_from_errno("malloc");
616 
617 	if (pledge("stdio rpath proc exec sendfd unveil",
618 	    NULL) == -1) {
619 		error = got_error_from_errno("pledge");
620 		goto done;
621 	}
622 
623 	error = gw_apply_unveil(gw_trans->gw_dir->path, NULL);
624 	if (error)
625 		goto done;
626 
627 	error = gw_get_header(gw_trans, header,
628 	    gw_trans->gw_conf->got_max_commits_display);
629 	if (error)
630 		goto done;
631 
632 	kerr = khttp_puts(gw_trans->gw_req, commits_wrapper);
633 	if (kerr != KCGI_OK) {
634 		error = gw_kcgi_error(kerr);
635 		goto done;
636 	}
637 	TAILQ_FOREACH(n_header, &gw_trans->gw_headers, entry) {
638 		if (asprintf(&commits_navs_html, commits_navs,
639 		    gw_trans->repo_name, n_header->commit_id,
640 		    gw_trans->repo_name, n_header->commit_id,
641 		    gw_trans->repo_name, n_header->commit_id) == -1) {
642 			error = got_error_from_errno("asprintf");
643 			goto done;
644 		}
645 
646 		if (asprintf(&commits_html, commits_line,
647 		    gw_gen_commit_header(n_header->commit_id,
648 		        n_header->refs_str),
649 		    gw_gen_author_header(n_header->author),
650 		    gw_gen_committer_header(n_header->committer),
651 		    gw_gen_age_header(gw_get_time_str(n_header->committer_time,
652 		        TM_LONG)), gw_html_escape(n_header->commit_msg),
653 		    commits_navs_html) == -1) {
654 			error = got_error_from_errno("asprintf");
655 			goto done;
656 		}
657 		kerr = khttp_puts(gw_trans->gw_req, commits_html);
658 		if (kerr != KCGI_OK) {
659 			error = gw_kcgi_error(kerr);
660 			goto done;
661 		}
662 	}
663 	kerr = khttp_puts(gw_trans->gw_req, div_end);
664 	if (kerr != KCGI_OK)
665 		error = gw_kcgi_error(kerr);
666 done:
667 	got_ref_list_free(&header->refs);
668 	gw_free_headers(header);
669 	TAILQ_FOREACH(n_header, &gw_trans->gw_headers, entry)
670 		gw_free_headers(n_header);
671 	return error;
672 }
673 
674 static const struct got_error *
675 gw_briefs(struct gw_trans *gw_trans)
676 {
677 	const struct got_error *error = NULL;
678 	char *briefs_html = NULL, *briefs_navs_html = NULL, *newline;
679 	struct gw_header *header = NULL, *n_header = NULL;
680 	enum kcgi_err kerr;
681 
682 	if ((header = gw_init_header()) == NULL)
683 		return got_error_from_errno("malloc");
684 
685 	if (pledge("stdio rpath proc exec sendfd unveil",
686 	    NULL) == -1) {
687 		error = got_error_from_errno("pledge");
688 		goto done;
689 	}
690 
691 	error = gw_apply_unveil(gw_trans->gw_dir->path, NULL);
692 	if (error)
693 		goto done;
694 
695 	if (gw_trans->action == GW_SUMMARY)
696 		error = gw_get_header(gw_trans, header, D_MAXSLCOMMDISP);
697 	else
698 		error = gw_get_header(gw_trans, header,
699 		    gw_trans->gw_conf->got_max_commits_display);
700 	if (error)
701 		goto done;
702 
703 	kerr = khttp_puts(gw_trans->gw_req, briefs_wrapper);
704 	if (kerr != KCGI_OK) {
705 		error = gw_kcgi_error(kerr);
706 		goto done;
707 	}
708 
709 	TAILQ_FOREACH(n_header, &gw_trans->gw_headers, entry) {
710 		if (asprintf(&briefs_navs_html, briefs_navs,
711 		    gw_trans->repo_name, n_header->commit_id,
712 		    gw_trans->repo_name, n_header->commit_id,
713 		    gw_trans->repo_name, n_header->commit_id) == -1) {
714 			error = got_error_from_errno("asprintf");
715 			goto done;
716 		}
717 		newline = strchr(n_header->commit_msg, '\n');
718 		if (newline)
719 			*newline = '\0';
720 		if (asprintf(&briefs_html, briefs_line,
721 		    gw_get_time_str(n_header->committer_time, TM_DIFF),
722 		    n_header->author, gw_html_escape(n_header->commit_msg),
723 		    briefs_navs_html) == -1) {
724 			error = got_error_from_errno("asprintf");
725 			goto done;
726 		}
727 		kerr = khttp_puts(gw_trans->gw_req, briefs_html);
728 		if (kerr != KCGI_OK) {
729 			error = gw_kcgi_error(kerr);
730 			goto done;
731 		}
732 	}
733 	kerr = khttp_puts(gw_trans->gw_req, div_end);
734 	if (kerr != KCGI_OK)
735 		error = gw_kcgi_error(kerr);
736 done:
737 	got_ref_list_free(&header->refs);
738 	gw_free_headers(header);
739 	TAILQ_FOREACH(n_header, &gw_trans->gw_headers, entry)
740 		gw_free_headers(n_header);
741 	return error;
742 }
743 
744 static const struct got_error *
745 gw_summary(struct gw_trans *gw_trans)
746 {
747 	const struct got_error *error = NULL;
748 	char *description_html = NULL, *repo_owner_html = NULL;
749 	char *age = NULL, *repo_age_html = NULL, *cloneurl_html = NULL;
750 	char *tags = NULL, *tags_html = NULL;
751 	char *heads = NULL, *heads_html = NULL;
752 	enum kcgi_err kerr;
753 
754 	if (pledge("stdio rpath proc exec sendfd unveil", NULL) == -1)
755 		return got_error_from_errno("pledge");
756 
757 	/* unveil is applied with gw_briefs below */
758 
759 	kerr = khttp_puts(gw_trans->gw_req, summary_wrapper);
760 	if (kerr != KCGI_OK)
761 		return gw_kcgi_error(kerr);
762 
763 	if (gw_trans->gw_conf->got_show_repo_description) {
764 		if (gw_trans->gw_dir->description != NULL &&
765 		    (strcmp(gw_trans->gw_dir->description, "") != 0)) {
766 			if (asprintf(&description_html, description,
767 			    gw_trans->gw_dir->description) == -1) {
768 				error = got_error_from_errno("asprintf");
769 				goto done;
770 			}
771 
772 			kerr = khttp_puts(gw_trans->gw_req, description_html);
773 			if (kerr != KCGI_OK) {
774 				error = gw_kcgi_error(kerr);
775 				goto done;
776 			}
777 		}
778 	}
779 
780 	if (gw_trans->gw_conf->got_show_repo_owner) {
781 		if (gw_trans->gw_dir->owner != NULL &&
782 		    (strcmp(gw_trans->gw_dir->owner, "") != 0)) {
783 			if (asprintf(&repo_owner_html, repo_owner,
784 			    gw_trans->gw_dir->owner) == -1) {
785 				error = got_error_from_errno("asprintf");
786 				goto done;
787 			}
788 
789 			kerr = khttp_puts(gw_trans->gw_req, repo_owner_html);
790 			if (kerr != KCGI_OK) {
791 				error = gw_kcgi_error(kerr);
792 				goto done;
793 			}
794 		}
795 	}
796 
797 	if (gw_trans->gw_conf->got_show_repo_age) {
798 		error = gw_get_repo_age(&age, gw_trans, gw_trans->gw_dir->path,
799 		    "refs/heads", TM_LONG);
800 		if (error)
801 			goto done;
802 		if (strcmp(age, "") != 0) {
803 			if (asprintf(&repo_age_html, last_change, age) == -1) {
804 				error = got_error_from_errno("asprintf");
805 				goto done;
806 			}
807 
808 			kerr = khttp_puts(gw_trans->gw_req, repo_age_html);
809 			if (kerr != KCGI_OK) {
810 				error = gw_kcgi_error(kerr);
811 				goto done;
812 			}
813 		}
814 	}
815 
816 	if (gw_trans->gw_conf->got_show_repo_cloneurl) {
817 		if (gw_trans->gw_dir->url != NULL &&
818 		    (strcmp(gw_trans->gw_dir->url, "") != 0)) {
819 			if (asprintf(&cloneurl_html, cloneurl,
820 			    gw_trans->gw_dir->url) == -1) {
821 				error = got_error_from_errno("asprintf");
822 				goto done;
823 			}
824 
825 			kerr = khttp_puts(gw_trans->gw_req, cloneurl_html);
826 			if (kerr != KCGI_OK) {
827 				error = gw_kcgi_error(kerr);
828 				goto done;
829 			}
830 		}
831 	}
832 	kerr = khttp_puts(gw_trans->gw_req, div_end);
833 	if (kerr != KCGI_OK) {
834 		error = gw_kcgi_error(kerr);
835 		goto done;
836 	}
837 
838 	error = gw_briefs(gw_trans);
839 	if (error)
840 		goto done;
841 
842 	tags = gw_get_repo_tags(gw_trans, NULL, D_MAXSLCOMMDISP, TAGBRIEF);
843 	heads = gw_get_repo_heads(gw_trans);
844 
845 	if (tags != NULL && strcmp(tags, "") != 0) {
846 		if (asprintf(&tags_html, summary_tags, tags) == -1) {
847 			error = got_error_from_errno("asprintf");
848 			goto done;
849 		}
850 		kerr = khttp_puts(gw_trans->gw_req, tags_html);
851 		if (kerr != KCGI_OK) {
852 			error = gw_kcgi_error(kerr);
853 			goto done;
854 		}
855 	}
856 
857 	if (heads != NULL && strcmp(heads, "") != 0) {
858 		if (asprintf(&heads_html, summary_heads, heads) == -1) {
859 			error = got_error_from_errno("asprintf");
860 			goto done;
861 		}
862 		kerr = khttp_puts(gw_trans->gw_req, heads_html);
863 		if (kerr != KCGI_OK) {
864 			error = gw_kcgi_error(kerr);
865 			goto done;
866 		}
867 	}
868 done:
869 	free(description_html);
870 	free(repo_owner_html);
871 	free(age);
872 	free(repo_age_html);
873 	free(cloneurl_html);
874 	free(tags);
875 	free(tags_html);
876 	free(heads);
877 	free(heads_html);
878 	return error;
879 }
880 
881 static const struct got_error *
882 gw_tree(struct gw_trans *gw_trans)
883 {
884 	const struct got_error *error = NULL;
885 	struct gw_header *header = NULL;
886 	char *tree = NULL, *tree_html = NULL, *tree_html_disp = NULL;
887 	enum kcgi_err kerr;
888 
889 	if (pledge("stdio rpath proc exec sendfd unveil", NULL) == -1)
890 		return got_error_from_errno("pledge");
891 
892 	if ((header = gw_init_header()) == NULL)
893 		return got_error_from_errno("malloc");
894 
895 	error = gw_apply_unveil(gw_trans->gw_dir->path, NULL);
896 	if (error)
897 		goto done;
898 
899 	error = gw_get_header(gw_trans, header, 1);
900 	if (error)
901 		goto done;
902 
903 	tree_html = gw_get_repo_tree(gw_trans);
904 
905 	if (tree_html == NULL) {
906 		tree_html = strdup("");
907 		if (tree_html == NULL) {
908 			error = got_error_from_errno("strdup");
909 			goto done;
910 		}
911 	}
912 
913 	if (asprintf(&tree_html_disp, tree_header,
914 	    gw_gen_age_header(gw_get_time_str(header->committer_time, TM_LONG)),
915 	    gw_gen_commit_msg_header(gw_html_escape(header->commit_msg)),
916 	    tree_html) == -1) {
917 		error = got_error_from_errno("asprintf");
918 		goto done;
919 	}
920 
921 	if (asprintf(&tree, tree_wrapper, tree_html_disp) == -1) {
922 		error = got_error_from_errno("asprintf");
923 		goto done;
924 	}
925 
926 	kerr = khttp_puts(gw_trans->gw_req, tree);
927 	if (kerr != KCGI_OK)
928 		error = gw_kcgi_error(kerr);
929 done:
930 	got_ref_list_free(&header->refs);
931 	gw_free_headers(header);
932 	free(tree_html_disp);
933 	free(tree_html);
934 	free(tree);
935 	return error;
936 }
937 
938 static const struct got_error *
939 gw_tag(struct gw_trans *gw_trans)
940 {
941 	const struct got_error *error = NULL;
942 	struct gw_header *header = NULL;
943 	char *tag = NULL, *tag_html = NULL, *tag_html_disp = NULL;
944 	enum kcgi_err kerr;
945 
946 	if (pledge("stdio rpath proc exec sendfd unveil", NULL) == -1)
947 		return got_error_from_errno("pledge");
948 
949 	if ((header = gw_init_header()) == NULL)
950 		return got_error_from_errno("malloc");
951 
952 	error = gw_apply_unveil(gw_trans->gw_dir->path, NULL);
953 	if (error)
954 		goto done;
955 
956 	error = gw_get_header(gw_trans, header, 1);
957 	if (error)
958 		goto done;
959 
960 	tag_html = gw_get_repo_tags(gw_trans, header, 1, TAGFULL);
961 	if (tag_html == NULL) {
962 		tag_html = strdup("");
963 		if (tag_html == NULL) {
964 			error = got_error_from_errno("strdup");
965 			goto done;
966 		}
967 	}
968 
969 	if (asprintf(&tag_html_disp, tag_header,
970 	    gw_gen_commit_header(header->commit_id, header->refs_str),
971 	    gw_gen_commit_msg_header(gw_html_escape(header->commit_msg)),
972 	    tag_html) == -1) {
973 		error = got_error_from_errno("asprintf");
974 		goto done;
975 	}
976 
977 	if (asprintf(&tag, tag_wrapper, tag_html_disp) == -1) {
978 		error = got_error_from_errno("asprintf");
979 		goto done;
980 	}
981 
982 	kerr = khttp_puts(gw_trans->gw_req, tag);
983 	if (kerr != KCGI_OK)
984 		error = gw_kcgi_error(kerr);
985 done:
986 	got_ref_list_free(&header->refs);
987 	gw_free_headers(header);
988 	free(tag_html_disp);
989 	free(tag_html);
990 	free(tag);
991 	return error;
992 }
993 
994 static const struct got_error *
995 gw_load_got_path(struct gw_trans *gw_trans, struct gw_dir *gw_dir)
996 {
997 	const struct got_error *error = NULL;
998 	DIR *dt;
999 	char *dir_test;
1000 	int opened = 0;
1001 
1002 	if (asprintf(&dir_test, "%s/%s/%s",
1003 	    gw_trans->gw_conf->got_repos_path, gw_dir->name,
1004 	    GOTWEB_GIT_DIR) == -1)
1005 		return got_error_from_errno("asprintf");
1006 
1007 	dt = opendir(dir_test);
1008 	if (dt == NULL) {
1009 		free(dir_test);
1010 	} else {
1011 		gw_dir->path = strdup(dir_test);
1012 		opened = 1;
1013 		goto done;
1014 	}
1015 
1016 	if (asprintf(&dir_test, "%s/%s/%s",
1017 	    gw_trans->gw_conf->got_repos_path, gw_dir->name,
1018 	    GOTWEB_GOT_DIR) == -1)
1019 		return got_error_from_errno("asprintf");
1020 
1021 	dt = opendir(dir_test);
1022 	if (dt == NULL)
1023 		free(dir_test);
1024 	else {
1025 		opened = 1;
1026 		error = got_error(GOT_ERR_NOT_GIT_REPO);
1027 		goto errored;
1028 	}
1029 
1030 	if (asprintf(&dir_test, "%s/%s",
1031 	    gw_trans->gw_conf->got_repos_path, gw_dir->name) == -1)
1032 		return got_error_from_errno("asprintf");
1033 
1034 	gw_dir->path = strdup(dir_test);
1035 
1036 done:
1037 	gw_dir->description = gw_get_repo_description(gw_trans,
1038 	    gw_dir->path);
1039 	gw_dir->owner = gw_get_repo_owner(gw_trans, gw_dir->path);
1040 	error = gw_get_repo_age(&gw_dir->age, gw_trans, gw_dir->path,
1041 	    "refs/heads", TM_DIFF);
1042 	if (error)
1043 		goto errored;
1044 	gw_dir->url = gw_get_clone_url(gw_trans, gw_dir->path);
1045 
1046 errored:
1047 	free(dir_test);
1048 	if (opened)
1049 		closedir(dt);
1050 	return error;
1051 }
1052 
1053 static const struct got_error *
1054 gw_load_got_paths(struct gw_trans *gw_trans)
1055 {
1056 	const struct got_error *error = NULL;
1057 	DIR *d;
1058 	struct dirent **sd_dent;
1059 	struct gw_dir *gw_dir;
1060 	struct stat st;
1061 	unsigned int d_cnt, d_i;
1062 
1063 	d = opendir(gw_trans->gw_conf->got_repos_path);
1064 	if (d == NULL) {
1065 		error = got_error_from_errno2("opendir",
1066 		    gw_trans->gw_conf->got_repos_path);
1067 		return error;
1068 	}
1069 
1070 	d_cnt = scandir(gw_trans->gw_conf->got_repos_path, &sd_dent, NULL,
1071 	    alphasort);
1072 	if (d_cnt == -1) {
1073 		error = got_error_from_errno2("scandir",
1074 		    gw_trans->gw_conf->got_repos_path);
1075 		return error;
1076 	}
1077 
1078 	for (d_i = 0; d_i < d_cnt; d_i++) {
1079 		if (gw_trans->gw_conf->got_max_repos > 0 &&
1080 		    (d_i - 2) == gw_trans->gw_conf->got_max_repos)
1081 			break; /* account for parent and self */
1082 
1083 		if (strcmp(sd_dent[d_i]->d_name, ".") == 0 ||
1084 		    strcmp(sd_dent[d_i]->d_name, "..") == 0)
1085 			continue;
1086 
1087 		if ((gw_dir = gw_init_gw_dir(sd_dent[d_i]->d_name)) == NULL)
1088 			return got_error_from_errno("gw_dir malloc");
1089 
1090 		error = gw_load_got_path(gw_trans, gw_dir);
1091 		if (error && error->code == GOT_ERR_NOT_GIT_REPO)
1092 			continue;
1093 		else if (error)
1094 			return error;
1095 
1096 		if (lstat(gw_dir->path, &st) == 0 && S_ISDIR(st.st_mode) &&
1097 		    !got_path_dir_is_empty(gw_dir->path)) {
1098 			TAILQ_INSERT_TAIL(&gw_trans->gw_dirs, gw_dir,
1099 			    entry);
1100 			gw_trans->repos_total++;
1101 		}
1102 	}
1103 
1104 	closedir(d);
1105 	return error;
1106 }
1107 
1108 static const struct got_error *
1109 gw_parse_querystring(struct gw_trans *gw_trans)
1110 {
1111 	const struct got_error *error = NULL;
1112 	struct kpair *p;
1113 	struct gw_query_action *action = NULL;
1114 	unsigned int i;
1115 
1116 	if (gw_trans->gw_req->fieldnmap[0]) {
1117 		error = got_error_from_errno("bad parse");
1118 		return error;
1119 	} else if ((p = gw_trans->gw_req->fieldmap[KEY_PATH])) {
1120 		/* define gw_trans->repo_path */
1121 		if (asprintf(&gw_trans->repo_name, "%s", p->parsed.s) == -1)
1122 			return got_error_from_errno("asprintf");
1123 
1124 		if (asprintf(&gw_trans->repo_path, "%s/%s",
1125 		    gw_trans->gw_conf->got_repos_path, p->parsed.s) == -1)
1126 			return got_error_from_errno("asprintf");
1127 
1128 		/* get action and set function */
1129 		if ((p = gw_trans->gw_req->fieldmap[KEY_ACTION]))
1130 			for (i = 0; i < nitems(gw_query_funcs); i++) {
1131 				action = &gw_query_funcs[i];
1132 				if (action->func_name == NULL)
1133 					continue;
1134 
1135 				if (strcmp(action->func_name,
1136 				    p->parsed.s) == 0) {
1137 					gw_trans->action = i;
1138 					if (asprintf(&gw_trans->action_name,
1139 					    "%s", action->func_name) == -1)
1140 						return
1141 						    got_error_from_errno(
1142 						    "asprintf");
1143 
1144 					break;
1145 				}
1146 
1147 				action = NULL;
1148 			}
1149 
1150  		if ((p = gw_trans->gw_req->fieldmap[KEY_COMMIT_ID]))
1151 			if (asprintf(&gw_trans->commit, "%s",
1152 			    p->parsed.s) == -1)
1153 				return got_error_from_errno("asprintf");
1154 
1155 		if ((p = gw_trans->gw_req->fieldmap[KEY_FILE]))
1156 			if (asprintf(&gw_trans->repo_file, "%s",
1157 			    p->parsed.s) == -1)
1158 				return got_error_from_errno("asprintf");
1159 
1160 		if ((p = gw_trans->gw_req->fieldmap[KEY_FOLDER]))
1161 			if (asprintf(&gw_trans->repo_folder, "%s",
1162 			    p->parsed.s) == -1)
1163 				return got_error_from_errno("asprintf");
1164 
1165 		if ((p = gw_trans->gw_req->fieldmap[KEY_HEADREF]))
1166 			if (asprintf(&gw_trans->headref, "%s",
1167 			    p->parsed.s) == -1)
1168 				return got_error_from_errno("asprintf");
1169 
1170 		if (action == NULL) {
1171 			error = got_error_from_errno("invalid action");
1172 			return error;
1173 		}
1174 		if ((gw_trans->gw_dir =
1175 		    gw_init_gw_dir(gw_trans->repo_name)) == NULL)
1176 			return got_error_from_errno("gw_dir malloc");
1177 
1178 		error = gw_load_got_path(gw_trans, gw_trans->gw_dir);
1179 		if (error)
1180 			return error;
1181 	} else
1182 		gw_trans->action = GW_INDEX;
1183 
1184 	if ((p = gw_trans->gw_req->fieldmap[KEY_PAGE]))
1185 		gw_trans->page = p->parsed.i;
1186 
1187 	return error;
1188 }
1189 
1190 static struct gw_dir *
1191 gw_init_gw_dir(char *dir)
1192 {
1193 	struct gw_dir *gw_dir;
1194 
1195 	if ((gw_dir = malloc(sizeof(*gw_dir))) == NULL)
1196 		return NULL;
1197 
1198 	if (asprintf(&gw_dir->name, "%s", dir) == -1)
1199 		return NULL;
1200 
1201 	return gw_dir;
1202 }
1203 
1204 static const struct got_error *
1205 gw_display_open(struct gw_trans *gw_trans, enum khttp code, enum kmime mime)
1206 {
1207 	enum kcgi_err kerr;
1208 
1209 	kerr = khttp_head(gw_trans->gw_req, kresps[KRESP_ALLOW], "GET");
1210 	if (kerr != KCGI_OK)
1211 		return gw_kcgi_error(kerr);
1212 	kerr = khttp_head(gw_trans->gw_req, kresps[KRESP_STATUS], "%s",
1213 	    khttps[code]);
1214 	if (kerr != KCGI_OK)
1215 		return gw_kcgi_error(kerr);
1216 	kerr = khttp_head(gw_trans->gw_req, kresps[KRESP_CONTENT_TYPE], "%s",
1217 	    kmimetypes[mime]);
1218 	if (kerr != KCGI_OK)
1219 		return gw_kcgi_error(kerr);
1220 	kerr = khttp_head(gw_trans->gw_req, "X-Content-Type-Options",
1221 	    "nosniff");
1222 	if (kerr != KCGI_OK)
1223 		return gw_kcgi_error(kerr);
1224 	kerr = khttp_head(gw_trans->gw_req, "X-Frame-Options", "DENY");
1225 	if (kerr != KCGI_OK)
1226 		return gw_kcgi_error(kerr);
1227 	kerr = khttp_head(gw_trans->gw_req, "X-XSS-Protection",
1228 	    "1; mode=block");
1229 	if (kerr != KCGI_OK)
1230 		return gw_kcgi_error(kerr);
1231 
1232 	if (gw_trans->mime == KMIME_APP_OCTET_STREAM) {
1233 		kerr = khttp_head(gw_trans->gw_req,
1234 		    kresps[KRESP_CONTENT_DISPOSITION],
1235 		    "attachment; filename=%s", gw_trans->repo_file);
1236 		if (kerr != KCGI_OK)
1237 			return gw_kcgi_error(kerr);
1238 	}
1239 
1240 	kerr = khttp_body(gw_trans->gw_req);
1241 	return gw_kcgi_error(kerr);
1242 }
1243 
1244 static const struct got_error *
1245 gw_display_index(struct gw_trans *gw_trans)
1246 {
1247 	const struct got_error *error;
1248 	enum kcgi_err kerr;
1249 
1250 	error = gw_display_open(gw_trans, KHTTP_200, gw_trans->mime);
1251 	if (error)
1252 		return error;
1253 
1254 	kerr = khtml_open(gw_trans->gw_html_req, gw_trans->gw_req, 0);
1255 	if (kerr)
1256 		return gw_kcgi_error(kerr);
1257 
1258 	if (gw_trans->action != GW_BLOB) {
1259 		kerr = khttp_template(gw_trans->gw_req, gw_trans->gw_tmpl,
1260 		    gw_query_funcs[gw_trans->action].template);
1261 		if (kerr != KCGI_OK) {
1262 			khtml_close(gw_trans->gw_html_req);
1263 			return gw_kcgi_error(kerr);
1264 		}
1265 	}
1266 
1267 	return gw_kcgi_error(khtml_close(gw_trans->gw_html_req));
1268 }
1269 
1270 static void
1271 gw_display_error(struct gw_trans *gw_trans, const struct got_error *err)
1272 {
1273 	if (gw_display_open(gw_trans, KHTTP_200, gw_trans->mime) != NULL)
1274 		return;
1275 
1276 	if (khtml_open(gw_trans->gw_html_req, gw_trans->gw_req, 0) != KCGI_OK)
1277 		return;
1278 
1279 	khttp_puts(gw_trans->gw_req, err->msg);
1280 	khtml_close(gw_trans->gw_html_req);
1281 }
1282 
1283 static int
1284 gw_template(size_t key, void *arg)
1285 {
1286 	const struct got_error *error = NULL;
1287 	struct gw_trans *gw_trans = arg;
1288 	char *gw_got_link, *gw_site_link;
1289 	char *site_owner_name, *site_owner_name_h;
1290 
1291 	switch (key) {
1292 	case (TEMPL_HEAD):
1293 		khttp_puts(gw_trans->gw_req, head);
1294 		break;
1295 	case(TEMPL_HEADER):
1296 		gw_got_link = gw_get_got_link(gw_trans);
1297 		if (gw_got_link != NULL)
1298 			khttp_puts(gw_trans->gw_req, gw_got_link);
1299 
1300 		free(gw_got_link);
1301 		break;
1302 	case (TEMPL_SITEPATH):
1303 		gw_site_link = gw_get_site_link(gw_trans);
1304 		if (gw_site_link != NULL)
1305 			khttp_puts(gw_trans->gw_req, gw_site_link);
1306 
1307 		free(gw_site_link);
1308 		break;
1309 	case(TEMPL_TITLE):
1310 		if (gw_trans->gw_conf->got_site_name != NULL)
1311 			khtml_puts(gw_trans->gw_html_req,
1312 			    gw_trans->gw_conf->got_site_name);
1313 
1314 		break;
1315 	case (TEMPL_SEARCH):
1316 		khttp_puts(gw_trans->gw_req, search);
1317 		break;
1318 	case(TEMPL_SITEOWNER):
1319 		if (gw_trans->gw_conf->got_site_owner != NULL &&
1320 		    gw_trans->gw_conf->got_show_site_owner) {
1321 			site_owner_name =
1322 			    gw_html_escape(gw_trans->gw_conf->got_site_owner);
1323 			if (asprintf(&site_owner_name_h, site_owner,
1324 			    site_owner_name) == -1)
1325 				return 0;
1326 
1327 			khttp_puts(gw_trans->gw_req, site_owner_name_h);
1328 			free(site_owner_name);
1329 			free(site_owner_name_h);
1330 		}
1331 		break;
1332 	case(TEMPL_CONTENT):
1333 		error = gw_query_funcs[gw_trans->action].func_main(gw_trans);
1334 		if (error)
1335 			khttp_puts(gw_trans->gw_req, error->msg);
1336 		break;
1337 	default:
1338 		return 0;
1339 	}
1340 	return 1;
1341 }
1342 
1343 static char *
1344 gw_gen_commit_header(char *str1, char *str2)
1345 {
1346 	char *return_html = NULL, *ref_str = NULL;
1347 
1348 	if (strcmp(str2, "") != 0) {
1349 		if (asprintf(&ref_str, "(%s)", str2) == -1) {
1350 			return_html = strdup("");
1351 			return return_html;
1352 		}
1353 	} else
1354 		ref_str = strdup("");
1355 
1356 
1357 	if (asprintf(&return_html, header_commit_html, str1, ref_str) == -1)
1358 		return_html = strdup("");
1359 
1360 	free(ref_str);
1361 	return return_html;
1362 }
1363 
1364 static char *
1365 gw_gen_diff_header(char *str1, char *str2)
1366 {
1367 	char *return_html = NULL;
1368 
1369 	if (asprintf(&return_html, header_diff_html, str1, str2) == -1)
1370 		return_html = strdup("");
1371 
1372 	return return_html;
1373 }
1374 
1375 static char *
1376 gw_gen_author_header(char *str)
1377 {
1378 	char *return_html = NULL;
1379 
1380 	if (asprintf(&return_html, header_author_html, str) == -1)
1381 		return_html = strdup("");
1382 
1383 	return return_html;
1384 }
1385 
1386 static char *
1387 gw_gen_committer_header(char *str)
1388 {
1389 	char *return_html = NULL;
1390 
1391 	if (asprintf(&return_html, header_committer_html, str) == -1)
1392 		return_html = strdup("");
1393 
1394 	return return_html;
1395 }
1396 
1397 static char *
1398 gw_gen_age_header(char *str)
1399 {
1400 	char *return_html = NULL;
1401 
1402 	if (asprintf(&return_html, header_age_html, str) == -1)
1403 		return_html = strdup("");
1404 
1405 	return return_html;
1406 }
1407 
1408 static char *
1409 gw_gen_commit_msg_header(char *str)
1410 {
1411 	char *return_html = NULL;
1412 
1413 	if (asprintf(&return_html, header_commit_msg_html, str) == -1)
1414 		return_html = strdup("");
1415 
1416 	return return_html;
1417 }
1418 
1419 static char *
1420 gw_gen_tree_header(char *str)
1421 {
1422 	char *return_html = NULL;
1423 
1424 	if (asprintf(&return_html, header_tree_html, str) == -1)
1425 		return_html = strdup("");
1426 
1427 	return return_html;
1428 }
1429 
1430 static char *
1431 gw_get_repo_description(struct gw_trans *gw_trans, char *dir)
1432 {
1433 	FILE *f;
1434 	char *description = NULL, *d_file = NULL;
1435 	unsigned int len;
1436 
1437 	if (gw_trans->gw_conf->got_show_repo_description == 0)
1438 		goto err;
1439 
1440 	if (asprintf(&d_file, "%s/description", dir) == -1)
1441 		goto err;
1442 
1443 	if ((f = fopen(d_file, "r")) == NULL)
1444 		goto err;
1445 
1446 	fseek(f, 0, SEEK_END);
1447 	len = ftell(f) + 1;
1448 	fseek(f, 0, SEEK_SET);
1449 	if ((description = calloc(len, sizeof(char *))) == NULL)
1450 		goto err;
1451 
1452 	fread(description, 1, len, f);
1453 	fclose(f);
1454 	free(d_file);
1455 	return description;
1456 err:
1457 	return strdup("");
1458 }
1459 
1460 static char *
1461 gw_get_time_str(time_t committer_time, int ref_tm)
1462 {
1463 	struct tm tm;
1464 	time_t diff_time;
1465 	char *years = "years ago", *months = "months ago";
1466 	char *weeks = "weeks ago", *days = "days ago", *hours = "hours ago";
1467 	char *minutes = "minutes ago", *seconds = "seconds ago";
1468 	char *now = "right now";
1469 	char *repo_age, *s;
1470 	char datebuf[29];
1471 
1472 	switch (ref_tm) {
1473 	case TM_DIFF:
1474 		diff_time = time(NULL) - committer_time;
1475 		if (diff_time > 60 * 60 * 24 * 365 * 2) {
1476 			if (asprintf(&repo_age, "%lld %s",
1477 			    (diff_time / 60 / 60 / 24 / 365), years) == -1)
1478 				return NULL;
1479 		} else if (diff_time > 60 * 60 * 24 * (365 / 12) * 2) {
1480 			if (asprintf(&repo_age, "%lld %s",
1481 			    (diff_time / 60 / 60 / 24 / (365 / 12)),
1482 			    months) == -1)
1483 				return NULL;
1484 		} else if (diff_time > 60 * 60 * 24 * 7 * 2) {
1485 			if (asprintf(&repo_age, "%lld %s",
1486 			    (diff_time / 60 / 60 / 24 / 7), weeks) == -1)
1487 				return NULL;
1488 		} else if (diff_time > 60 * 60 * 24 * 2) {
1489 			if (asprintf(&repo_age, "%lld %s",
1490 			    (diff_time / 60 / 60 / 24), days) == -1)
1491 				return NULL;
1492 		} else if (diff_time > 60 * 60 * 2) {
1493 			if (asprintf(&repo_age, "%lld %s",
1494 			    (diff_time / 60 / 60), hours) == -1)
1495 				return NULL;
1496 		} else if (diff_time > 60 * 2) {
1497 			if (asprintf(&repo_age, "%lld %s", (diff_time / 60),
1498 			    minutes) == -1)
1499 				return NULL;
1500 		} else if (diff_time > 2) {
1501 			if (asprintf(&repo_age, "%lld %s", diff_time,
1502 			    seconds) == -1)
1503 				return NULL;
1504 		} else {
1505 			if (asprintf(&repo_age, "%s", now) == -1)
1506 				return NULL;
1507 		}
1508 		break;
1509 	case TM_LONG:
1510 		if (gmtime_r(&committer_time, &tm) == NULL)
1511 			return NULL;
1512 
1513 		s = asctime_r(&tm, datebuf);
1514 		if (s == NULL)
1515 			return NULL;
1516 
1517 		if (asprintf(&repo_age, "%s UTC", datebuf) == -1)
1518 			return NULL;
1519 		break;
1520 	}
1521 	return repo_age;
1522 }
1523 
1524 static const struct got_error *
1525 gw_get_repo_age(char **repo_age, struct gw_trans *gw_trans, char *dir,
1526     char *repo_ref, int ref_tm)
1527 {
1528 	const struct got_error *error = NULL;
1529 	struct got_object_id *id = NULL;
1530 	struct got_repository *repo = NULL;
1531 	struct got_commit_object *commit = NULL;
1532 	struct got_reflist_head refs;
1533 	struct got_reflist_entry *re;
1534 	struct got_reference *head_ref;
1535 	int is_head = 0;
1536 	time_t committer_time = 0, cmp_time = 0;
1537 	const char *refname;
1538 
1539 	*repo_age = NULL;
1540 	SIMPLEQ_INIT(&refs);
1541 
1542 	if (repo_ref == NULL)
1543 		return NULL;
1544 
1545 	if (strncmp(repo_ref, "refs/heads/", 11) == 0)
1546 		is_head = 1;
1547 
1548 	if (gw_trans->gw_conf->got_show_repo_age == 0) {
1549 		*repo_age = strdup("");
1550 		if (*repo_age == NULL)
1551 			return got_error_from_errno("strdup");
1552 		return NULL;
1553 	}
1554 
1555 	error = got_repo_open(&repo, dir, NULL);
1556 	if (error)
1557 		goto done;
1558 
1559 	if (is_head)
1560 		error = got_ref_list(&refs, repo, "refs/heads",
1561 		    got_ref_cmp_by_name, NULL);
1562 	else
1563 		error = got_ref_list(&refs, repo, repo_ref,
1564 		    got_ref_cmp_by_name, NULL);
1565 	if (error)
1566 		goto done;
1567 
1568 	SIMPLEQ_FOREACH(re, &refs, entry) {
1569 		if (is_head)
1570 			refname = strdup(repo_ref);
1571 		else
1572 			refname = got_ref_get_name(re->ref);
1573 		error = got_ref_open(&head_ref, repo, refname, 0);
1574 		if (error)
1575 			goto done;
1576 
1577 		error = got_ref_resolve(&id, repo, head_ref);
1578 		got_ref_close(head_ref);
1579 		if (error)
1580 			goto done;
1581 
1582 		error = got_object_open_as_commit(&commit, repo, id);
1583 		if (error)
1584 			goto done;
1585 
1586 		committer_time =
1587 		    got_object_commit_get_committer_time(commit);
1588 
1589 		if (cmp_time < committer_time)
1590 			cmp_time = committer_time;
1591 	}
1592 
1593 	if (cmp_time != 0) {
1594 		committer_time = cmp_time;
1595 		*repo_age = gw_get_time_str(committer_time, ref_tm);
1596 	} else {
1597 		*repo_age = strdup("");
1598 		if (*repo_age == NULL)
1599 			error = got_error_from_errno("strdup");
1600 	}
1601 done:
1602 	got_ref_list_free(&refs);
1603 	free(id);
1604 	return error;
1605 }
1606 
1607 static char *
1608 gw_get_diff(struct gw_trans *gw_trans, struct gw_header *header)
1609 {
1610 	const struct got_error *error;
1611 	FILE *f = NULL;
1612 	struct got_object_id *id1 = NULL, *id2 = NULL;
1613 	struct buf *diffbuf = NULL;
1614 	char *label1 = NULL, *label2 = NULL, *diff_html = NULL, *buf = NULL;
1615 	char *buf_color = NULL, *n_buf = NULL, *newline = NULL;
1616 	int obj_type;
1617 	size_t newsize;
1618 
1619 	f = got_opentemp();
1620 	if (f == NULL)
1621 		return NULL;
1622 
1623 	error = buf_alloc(&diffbuf, 0);
1624 	if (error)
1625 		return NULL;
1626 
1627 	error = got_repo_open(&header->repo, gw_trans->repo_path, NULL);
1628 	if (error)
1629 		goto done;
1630 
1631 	if (strncmp(header->parent_id, "/dev/null", 9) != 0) {
1632 		error = got_repo_match_object_id(&id1, &label1,
1633 			header->parent_id, GOT_OBJ_TYPE_ANY, 1, header->repo);
1634 		if (error)
1635 			goto done;
1636 	}
1637 
1638 	error = got_repo_match_object_id(&id2, &label2,
1639 	    header->commit_id, GOT_OBJ_TYPE_ANY, 1, header->repo);
1640 	if (error)
1641 		goto done;
1642 
1643 	error = got_object_get_type(&obj_type, header->repo, id2);
1644 	if (error)
1645 		goto done;
1646 	switch (obj_type) {
1647 	case GOT_OBJ_TYPE_BLOB:
1648 		error = got_diff_objects_as_blobs(id1, id2, NULL, NULL, 3, 0,
1649 		    header->repo, f);
1650 		break;
1651 	case GOT_OBJ_TYPE_TREE:
1652 		error = got_diff_objects_as_trees(id1, id2, "", "", 3, 0,
1653 		    header->repo, f);
1654 		break;
1655 	case GOT_OBJ_TYPE_COMMIT:
1656 		error = got_diff_objects_as_commits(id1, id2, 3, 0,
1657 		    header->repo, f);
1658 		break;
1659 	default:
1660 		error = got_error(GOT_ERR_OBJ_TYPE);
1661 	}
1662 
1663 	if ((buf = calloc(128, sizeof(char *))) == NULL)
1664 		goto done;
1665 
1666 	fseek(f, 0, SEEK_SET);
1667 
1668 	while ((fgets(buf, 2048, f)) != NULL) {
1669 		n_buf = buf;
1670 		while (*n_buf == '\n')
1671 			n_buf++;
1672 		newline = strchr(n_buf, '\n');
1673 		if (newline)
1674 			*newline = ' ';
1675 
1676 		buf_color = gw_colordiff_line(gw_html_escape(n_buf));
1677 		if (buf_color == NULL)
1678 			continue;
1679 
1680 		error = buf_puts(&newsize, diffbuf, buf_color);
1681 		if (error)
1682 			return NULL;
1683 
1684 		error = buf_puts(&newsize, diffbuf, div_end);
1685 		if (error)
1686 			return NULL;
1687 	}
1688 
1689 	if (buf_len(diffbuf) > 0) {
1690 		error = buf_putc(diffbuf, '\0');
1691 		diff_html = strdup(buf_get(diffbuf));
1692 	}
1693 done:
1694 	fclose(f);
1695 	free(buf_color);
1696 	free(buf);
1697 	free(diffbuf);
1698 	free(label1);
1699 	free(label2);
1700 	free(id1);
1701 	free(id2);
1702 
1703 	if (error)
1704 		return NULL;
1705 	else
1706 		return diff_html;
1707 }
1708 
1709 static char *
1710 gw_get_repo_owner(struct gw_trans *gw_trans, char *dir)
1711 {
1712 	FILE *f;
1713 	char *owner = NULL, *d_file = NULL;
1714 	char *gotweb = "[gotweb]", *gitweb = "[gitweb]", *gw_owner = "owner";
1715 	char *comp, *pos, *buf;
1716 	unsigned int i;
1717 
1718 	if (gw_trans->gw_conf->got_show_repo_owner == 0)
1719 		goto err;
1720 
1721 	if (asprintf(&d_file, "%s/config", dir) == -1)
1722 		goto err;
1723 
1724 	if ((f = fopen(d_file, "r")) == NULL)
1725 		goto err;
1726 
1727 	if ((buf = calloc(128, sizeof(char *))) == NULL)
1728 		goto err;
1729 
1730 	while ((fgets(buf, 128, f)) != NULL) {
1731 		if ((pos = strstr(buf, gotweb)) != NULL)
1732 			break;
1733 
1734 		if ((pos = strstr(buf, gitweb)) != NULL)
1735 			break;
1736 	}
1737 
1738 	if (pos == NULL)
1739 		goto err;
1740 
1741 	do {
1742 		fgets(buf, 128, f);
1743 	} while ((comp = strcasestr(buf, gw_owner)) == NULL);
1744 
1745 	if (comp == NULL)
1746 		goto err;
1747 
1748 	if (strncmp(gw_owner, comp, strlen(gw_owner)) != 0)
1749 		goto err;
1750 
1751 	for (i = 0; i < 2; i++) {
1752 		owner = strsep(&buf, "\"");
1753 	}
1754 
1755 	if (owner == NULL)
1756 		goto err;
1757 
1758 	fclose(f);
1759 	free(d_file);
1760 	return owner;
1761 err:
1762 	return strdup("");
1763 }
1764 
1765 static char *
1766 gw_get_clone_url(struct gw_trans *gw_trans, char *dir)
1767 {
1768 	FILE *f;
1769 	char *url = NULL, *d_file = NULL;
1770 	unsigned int len;
1771 
1772 	if (asprintf(&d_file, "%s/cloneurl", dir) == -1)
1773 		return NULL;
1774 
1775 	if ((f = fopen(d_file, "r")) == NULL)
1776 		return NULL;
1777 
1778 	fseek(f, 0, SEEK_END);
1779 	len = ftell(f) + 1;
1780 	fseek(f, 0, SEEK_SET);
1781 
1782 	if ((url = calloc(len, sizeof(char *))) == NULL)
1783 		return NULL;
1784 
1785 	fread(url, 1, len, f);
1786 	fclose(f);
1787 	free(d_file);
1788 	return url;
1789 }
1790 
1791 static char *
1792 gw_get_repo_tags(struct gw_trans *gw_trans, struct gw_header *header, int limit,
1793     int tag_type)
1794 {
1795 	const struct got_error *error = NULL;
1796 	struct got_repository *repo = NULL;
1797 	struct got_reflist_head refs;
1798 	struct got_reflist_entry *re;
1799 	char *tags = NULL, *tag_row = NULL, *tags_navs_disp = NULL;
1800 	char *age = NULL, *newline;
1801 	struct buf *diffbuf = NULL;
1802 	size_t newsize;
1803 
1804 	SIMPLEQ_INIT(&refs);
1805 
1806 	error = buf_alloc(&diffbuf, 0);
1807 	if (error)
1808 		return NULL;
1809 
1810 	error = got_repo_open(&repo, gw_trans->repo_path, NULL);
1811 	if (error)
1812 		goto done;
1813 
1814 	error = got_ref_list(&refs, repo, "refs/tags", got_ref_cmp_tags, repo);
1815 	if (error)
1816 		goto done;
1817 
1818 	SIMPLEQ_FOREACH(re, &refs, entry) {
1819 		const char *refname;
1820 		char *refstr, *tag_commit0, *tag_commit, *id_str;
1821 		const char *tagger;
1822 		time_t tagger_time;
1823 		struct got_object_id *id;
1824 		struct got_tag_object *tag;
1825 
1826 		refname = got_ref_get_name(re->ref);
1827 		if (strncmp(refname, "refs/tags/", 10) != 0)
1828 			continue;
1829 		refname += 10;
1830 		refstr = got_ref_to_str(re->ref);
1831 		if (refstr == NULL) {
1832 			error = got_error_from_errno("got_ref_to_str");
1833 			goto done;
1834 		}
1835 
1836 		error = got_ref_resolve(&id, repo, re->ref);
1837 		if (error)
1838 			goto done;
1839 		error = got_object_open_as_tag(&tag, repo, id);
1840 		free(id);
1841 		if (error)
1842 			goto done;
1843 
1844 		tagger = got_object_tag_get_tagger(tag);
1845 		tagger_time = got_object_tag_get_tagger_time(tag);
1846 
1847 		error = got_object_id_str(&id_str,
1848 		    got_object_tag_get_object_id(tag));
1849 		if (error)
1850 			goto done;
1851 
1852 		tag_commit0 = strdup(got_object_tag_get_message(tag));
1853 
1854 		if (tag_commit0 == NULL) {
1855 			error = got_error_from_errno("strdup");
1856 			goto done;
1857 		}
1858 
1859 		tag_commit = tag_commit0;
1860 		while (*tag_commit == '\n')
1861 			tag_commit++;
1862 
1863 		switch (tag_type) {
1864 		case TAGBRIEF:
1865 			newline = strchr(tag_commit, '\n');
1866 			if (newline)
1867 				*newline = '\0';
1868 
1869 			if (asprintf(&age, "%s", gw_get_time_str(tagger_time,
1870 			    TM_DIFF)) == -1) {
1871 				error = got_error_from_errno("asprintf");
1872 				goto done;
1873 			}
1874 
1875 			if (asprintf(&tags_navs_disp, tags_navs,
1876 			    gw_trans->repo_name, id_str, gw_trans->repo_name,
1877 			    id_str, gw_trans->repo_name, id_str,
1878 			    gw_trans->repo_name, id_str) == -1) {
1879 				error = got_error_from_errno("asprintf");
1880 				goto done;
1881 			}
1882 
1883 			if (asprintf(&tag_row, tags_row, age, refname,
1884 			    tag_commit, tags_navs_disp) == -1) {
1885 				error = got_error_from_errno("asprintf");
1886 				goto done;
1887 			}
1888 
1889 			free(tags_navs_disp);
1890 			break;
1891 		case TAGFULL:
1892 			if (asprintf(&age, "%s", gw_get_time_str(tagger_time,
1893 			    TM_LONG)) == -1) {
1894 				error = got_error_from_errno("asprintf");
1895 				goto done;
1896 			}
1897 			if (asprintf(&tag_row, tag_info, age,
1898 			    gw_html_escape(tagger),
1899 			    gw_html_escape(tag_commit)) == -1) {
1900 				error = got_error_from_errno("asprintf");
1901 				goto done;
1902 			}
1903 			break;
1904 		default:
1905 			break;
1906 		}
1907 
1908 		got_object_tag_close(tag);
1909 
1910 		error = buf_puts(&newsize, diffbuf, tag_row);
1911 
1912 		free(id_str);
1913 		free(refstr);
1914 		free(age);
1915 		free(tag_commit0);
1916 		free(tag_row);
1917 
1918 		if (error || (limit && --limit == 0))
1919 			break;
1920 	}
1921 
1922 	if (buf_len(diffbuf) > 0) {
1923 		error = buf_putc(diffbuf, '\0');
1924 		tags = strdup(buf_get(diffbuf));
1925 	}
1926 done:
1927 	buf_free(diffbuf);
1928 	got_ref_list_free(&refs);
1929 	if (repo)
1930 		got_repo_close(repo);
1931 	if (error)
1932 		return NULL;
1933 	else
1934 		return tags;
1935 }
1936 
1937 static void
1938 gw_free_headers(struct gw_header *header)
1939 {
1940 	free(header->id);
1941 	free(header->path);
1942 	if (header->commit != NULL)
1943 		got_object_commit_close(header->commit);
1944 	if (header->repo)
1945 		got_repo_close(header->repo);
1946 	free(header->refs_str);
1947 	free(header->commit_id);
1948 	free(header->parent_id);
1949 	free(header->tree_id);
1950 	free(header->author);
1951 	free(header->committer);
1952 	free(header->commit_msg);
1953 }
1954 
1955 static struct gw_header *
1956 gw_init_header()
1957 {
1958 	struct gw_header *header;
1959 
1960 	header = malloc(sizeof(*header));
1961 	if (header == NULL)
1962 		return NULL;
1963 
1964 	header->repo = NULL;
1965 	header->commit = NULL;
1966 	header->id = NULL;
1967 	header->path = NULL;
1968 	SIMPLEQ_INIT(&header->refs);
1969 
1970 	return header;
1971 }
1972 
1973 static const struct got_error *
1974 gw_get_commits(struct gw_trans * gw_trans, struct gw_header *header,
1975     int limit)
1976 {
1977 	const struct got_error *error = NULL;
1978 	struct got_commit_graph *graph = NULL;
1979 
1980 	error = got_commit_graph_open(&graph, header->path, 0);
1981 	if (error)
1982 		goto done;
1983 
1984 	error = got_commit_graph_iter_start(graph, header->id, header->repo,
1985 	    NULL, NULL);
1986 	if (error)
1987 		goto done;
1988 
1989 	for (;;) {
1990 		error = got_commit_graph_iter_next(&header->id, graph,
1991 		    header->repo, NULL, NULL);
1992 		if (error) {
1993 			if (error->code == GOT_ERR_ITER_COMPLETED)
1994 				error = NULL;
1995 			goto done;
1996 		}
1997 		if (header->id == NULL)
1998 			goto done;
1999 
2000 		error = got_object_open_as_commit(&header->commit, header->repo,
2001 		    header->id);
2002 		if (error)
2003 			goto done;
2004 
2005 		error = gw_get_commit(gw_trans, header);
2006 		if (limit > 1) {
2007 			struct gw_header *n_header = NULL;
2008 			if ((n_header = gw_init_header()) == NULL) {
2009 				error = got_error_from_errno("malloc");
2010 				goto done;
2011 			}
2012 
2013 			n_header->refs_str = strdup(header->refs_str);
2014 			n_header->commit_id = strdup(header->commit_id);
2015 			n_header->parent_id = strdup(header->parent_id);
2016 			n_header->tree_id = strdup(header->tree_id);
2017 			n_header->author = strdup(header->author);
2018 			n_header->committer = strdup(header->committer);
2019 			n_header->commit_msg = strdup(header->commit_msg);
2020 			n_header->committer_time = header->committer_time;
2021 			TAILQ_INSERT_TAIL(&gw_trans->gw_headers, n_header,
2022 			    entry);
2023 		}
2024 		if (error || (limit && --limit == 0))
2025 			break;
2026 	}
2027 done:
2028 	if (graph)
2029 		got_commit_graph_close(graph);
2030 	return error;
2031 }
2032 
2033 static const struct got_error *
2034 gw_get_commit(struct gw_trans *gw_trans, struct gw_header *header)
2035 {
2036 	const struct got_error *error = NULL;
2037 	struct got_reflist_entry *re;
2038 	struct got_object_id *id2 = NULL;
2039 	struct got_object_qid *parent_id;
2040 	char *refs_str = NULL, *commit_msg = NULL, *commit_msg0;
2041 
2042 	/*print commit*/
2043 	SIMPLEQ_FOREACH(re, &header->refs, entry) {
2044 		char *s;
2045 		const char *name;
2046 		struct got_tag_object *tag = NULL;
2047 		int cmp;
2048 
2049 		name = got_ref_get_name(re->ref);
2050 		if (strcmp(name, GOT_REF_HEAD) == 0)
2051 			continue;
2052 		if (strncmp(name, "refs/", 5) == 0)
2053 			name += 5;
2054 		if (strncmp(name, "got/", 4) == 0)
2055 			continue;
2056 		if (strncmp(name, "heads/", 6) == 0)
2057 			name += 6;
2058 		if (strncmp(name, "remotes/", 8) == 0)
2059 			name += 8;
2060 		if (strncmp(name, "tags/", 5) == 0) {
2061 			error = got_object_open_as_tag(&tag, header->repo,
2062 			    re->id);
2063 			if (error) {
2064 				if (error->code != GOT_ERR_OBJ_TYPE)
2065 					continue;
2066 				/*
2067 				 * Ref points at something other
2068 				 * than a tag.
2069 				 */
2070 				error = NULL;
2071 				tag = NULL;
2072 			}
2073 		}
2074 		cmp = got_object_id_cmp(tag ?
2075 		    got_object_tag_get_object_id(tag) : re->id, header->id);
2076 		if (tag)
2077 			got_object_tag_close(tag);
2078 		if (cmp != 0)
2079 			continue;
2080 		s = refs_str;
2081 		if (asprintf(&refs_str, "%s%s%s", s ? s : "",
2082 		    s ? ", " : "", name) == -1) {
2083 			error = got_error_from_errno("asprintf");
2084 			free(s);
2085 			return error;
2086 		}
2087 		header->refs_str = strdup(refs_str);
2088 		free(s);
2089 	}
2090 
2091 	if (refs_str == NULL)
2092 		header->refs_str = strdup("");
2093 	free(refs_str);
2094 
2095 	error = got_object_id_str(&header->commit_id, header->id);
2096 	if (error)
2097 		return error;
2098 
2099 	error = got_object_id_str(&header->tree_id,
2100 	    got_object_commit_get_tree_id(header->commit));
2101 	if (error)
2102 		return error;
2103 
2104 	if (gw_trans->action == GW_DIFF) {
2105 		parent_id = SIMPLEQ_FIRST(
2106 		    got_object_commit_get_parent_ids(header->commit));
2107 		if (parent_id != NULL) {
2108 			id2 = got_object_id_dup(parent_id->id);
2109 			free (parent_id);
2110 			error = got_object_id_str(&header->parent_id, id2);
2111 			if (error)
2112 				return error;
2113 			free(id2);
2114 		} else
2115 			header->parent_id = strdup("/dev/null");
2116 	} else
2117 		header->parent_id = strdup("");
2118 
2119 	header->committer_time =
2120 	    got_object_commit_get_committer_time(header->commit);
2121 
2122 	if (gw_trans->action != GW_BRIEFS && gw_trans->action != GW_SUMMARY) {
2123 		header->author = strdup(
2124 	 	    gw_html_escape(got_object_commit_get_author(header->commit))
2125 		);
2126 	} else {
2127 		header->author = strdup(
2128 		    got_object_commit_get_author(header->commit)
2129 		);
2130 	}
2131 
2132 	header->committer = strdup(
2133 		gw_html_escape(got_object_commit_get_committer(header->commit))
2134 	);
2135 
2136 	error = got_object_commit_get_logmsg(&commit_msg0, header->commit);
2137 	if (error)
2138 		return error;
2139 
2140 	commit_msg = commit_msg0;
2141 	while (*commit_msg == '\n')
2142 		commit_msg++;
2143 
2144 	header->commit_msg = strdup(commit_msg);
2145 	free(commit_msg0);
2146 	return error;
2147 }
2148 
2149 static const struct got_error *
2150 gw_get_header(struct gw_trans *gw_trans, struct gw_header *header, int limit)
2151 {
2152 	const struct got_error *error = NULL;
2153 	char *in_repo_path = NULL;
2154 
2155 	error = got_repo_open(&header->repo, gw_trans->repo_path, NULL);
2156 	if (error)
2157 		return error;
2158 
2159 	if (gw_trans->commit == NULL) {
2160 		struct got_reference *head_ref;
2161 		error = got_ref_open(&head_ref, header->repo,
2162 		    gw_trans->headref, 0);
2163 		if (error)
2164 			return error;
2165 
2166 		error = got_ref_resolve(&header->id, header->repo, head_ref);
2167 		got_ref_close(head_ref);
2168 		if (error)
2169 			return error;
2170 
2171 		error = got_object_open_as_commit(&header->commit,
2172 		    header->repo, header->id);
2173 	} else {
2174 		struct got_reference *ref;
2175 		error = got_ref_open(&ref, header->repo, gw_trans->commit, 0);
2176 		if (error == NULL) {
2177 			int obj_type;
2178 			error = got_ref_resolve(&header->id, header->repo, ref);
2179 			got_ref_close(ref);
2180 			if (error)
2181 				return error;
2182 			error = got_object_get_type(&obj_type, header->repo,
2183 			    header->id);
2184 			if (error)
2185 				return error;
2186 			if (obj_type == GOT_OBJ_TYPE_TAG) {
2187 				struct got_tag_object *tag;
2188 				error = got_object_open_as_tag(&tag,
2189 				    header->repo, header->id);
2190 				if (error)
2191 					return error;
2192 				if (got_object_tag_get_object_type(tag) !=
2193 				    GOT_OBJ_TYPE_COMMIT) {
2194 					got_object_tag_close(tag);
2195 					error = got_error(GOT_ERR_OBJ_TYPE);
2196 					return error;
2197 				}
2198 				free(header->id);
2199 				header->id = got_object_id_dup(
2200 				    got_object_tag_get_object_id(tag));
2201 				if (header->id == NULL)
2202 					error = got_error_from_errno(
2203 					    "got_object_id_dup");
2204 				got_object_tag_close(tag);
2205 				if (error)
2206 					return error;
2207 			} else if (obj_type != GOT_OBJ_TYPE_COMMIT) {
2208 				error = got_error(GOT_ERR_OBJ_TYPE);
2209 				return error;
2210 			}
2211 			error = got_object_open_as_commit(&header->commit,
2212 			    header->repo, header->id);
2213 			if (error)
2214 				return error;
2215 		}
2216 		if (header->commit == NULL) {
2217 			error = got_repo_match_object_id_prefix(&header->id,
2218 			    gw_trans->commit, GOT_OBJ_TYPE_COMMIT,
2219 			    header->repo);
2220 			if (error)
2221 				return error;
2222 		}
2223 		error = got_repo_match_object_id_prefix(&header->id,
2224 			    gw_trans->commit, GOT_OBJ_TYPE_COMMIT,
2225 			    header->repo);
2226 	}
2227 
2228 	error = got_repo_map_path(&in_repo_path, header->repo,
2229 	    gw_trans->repo_path, 1);
2230 	if (error)
2231 		return error;
2232 
2233 	if (in_repo_path) {
2234 		header->path = strdup(in_repo_path);
2235 	}
2236 	free(in_repo_path);
2237 
2238 	error = got_ref_list(&header->refs, header->repo, NULL,
2239 	    got_ref_cmp_by_name, NULL);
2240 	if (error)
2241 		return error;
2242 
2243 	error = gw_get_commits(gw_trans, header, limit);
2244 	return error;
2245 }
2246 
2247 struct blame_line {
2248 	int annotated;
2249 	char *id_str;
2250 	char *committer;
2251 	char datebuf[11]; /* YYYY-MM-DD + NUL */
2252 };
2253 
2254 struct gw_blame_cb_args {
2255 	struct blame_line *lines;
2256 	int nlines;
2257 	int nlines_prec;
2258 	int lineno_cur;
2259 	off_t *line_offsets;
2260 	FILE *f;
2261 	struct got_repository *repo;
2262 	struct gw_trans *gw_trans;
2263 	struct buf *blamebuf;
2264 };
2265 
2266 static const struct got_error *
2267 gw_blame_cb(void *arg, int nlines, int lineno, struct got_object_id *id)
2268 {
2269 	const struct got_error *err = NULL;
2270 	struct gw_blame_cb_args *a = arg;
2271 	struct blame_line *bline;
2272 	char *line = NULL;
2273 	size_t linesize = 0, newsize;
2274 	struct got_commit_object *commit = NULL;
2275 	off_t offset;
2276 	struct tm tm;
2277 	time_t committer_time;
2278 
2279 	if (nlines != a->nlines ||
2280 	    (lineno != -1 && lineno < 1) || lineno > a->nlines)
2281 		return got_error(GOT_ERR_RANGE);
2282 
2283 	if (lineno == -1)
2284 		return NULL; /* no change in this commit */
2285 
2286 	/* Annotate this line. */
2287 	bline = &a->lines[lineno - 1];
2288 	if (bline->annotated)
2289 		return NULL;
2290 	err = got_object_id_str(&bline->id_str, id);
2291 	if (err)
2292 		return err;
2293 
2294 	err = got_object_open_as_commit(&commit, a->repo, id);
2295 	if (err)
2296 		goto done;
2297 
2298 	bline->committer = strdup(got_object_commit_get_committer(commit));
2299 	if (bline->committer == NULL) {
2300 		err = got_error_from_errno("strdup");
2301 		goto done;
2302 	}
2303 
2304 	committer_time = got_object_commit_get_committer_time(commit);
2305 	if (localtime_r(&committer_time, &tm) == NULL)
2306 		return got_error_from_errno("localtime_r");
2307 	if (strftime(bline->datebuf, sizeof(bline->datebuf), "%G-%m-%d",
2308 	    &tm) >= sizeof(bline->datebuf)) {
2309 		err = got_error(GOT_ERR_NO_SPACE);
2310 		goto done;
2311 	}
2312 	bline->annotated = 1;
2313 
2314 	/* Print lines annotated so far. */
2315 	bline = &a->lines[a->lineno_cur - 1];
2316 	if (!bline->annotated)
2317 		goto done;
2318 
2319 	offset = a->line_offsets[a->lineno_cur - 1];
2320 	if (fseeko(a->f, offset, SEEK_SET) == -1) {
2321 		err = got_error_from_errno("fseeko");
2322 		goto done;
2323 	}
2324 
2325 	while (bline->annotated) {
2326 		char *smallerthan, *at, *nl, *committer, *blame_row = NULL,
2327 		     *line_escape = NULL;
2328 		size_t len;
2329 
2330 		if (getline(&line, &linesize, a->f) == -1) {
2331 			if (ferror(a->f))
2332 				err = got_error_from_errno("getline");
2333 			break;
2334 		}
2335 
2336 		committer = bline->committer;
2337 		smallerthan = strchr(committer, '<');
2338 		if (smallerthan && smallerthan[1] != '\0')
2339 			committer = smallerthan + 1;
2340 		at = strchr(committer, '@');
2341 		if (at)
2342 			*at = '\0';
2343 		len = strlen(committer);
2344 		if (len >= 9)
2345 			committer[8] = '\0';
2346 
2347 		nl = strchr(line, '\n');
2348 		if (nl)
2349 			*nl = '\0';
2350 
2351 		if (strcmp(line, "") != 0)
2352 			line_escape = strdup(gw_html_escape(line));
2353 		else
2354 			line_escape = strdup("");
2355 
2356 		asprintf(&blame_row, blame_line, a->nlines_prec,
2357 		    a->lineno_cur, bline->id_str, bline->datebuf, committer,
2358 		    line_escape);
2359 		a->lineno_cur++;
2360 		err = buf_puts(&newsize, a->blamebuf, blame_row);
2361 		if (err)
2362 			return err;
2363 
2364 		bline = &a->lines[a->lineno_cur - 1];
2365 		free(line_escape);
2366 		free(blame_row);
2367 	}
2368 done:
2369 	if (commit)
2370 		got_object_commit_close(commit);
2371 	free(line);
2372 	return err;
2373 }
2374 
2375 static char*
2376 gw_get_file_blame_blob(struct gw_trans *gw_trans)
2377 {
2378 	const struct got_error *error = NULL;
2379 	struct got_repository *repo = NULL;
2380 	struct got_object_id *obj_id = NULL;
2381 	struct got_object_id *commit_id = NULL;
2382 	struct got_blob_object *blob = NULL;
2383 	char *blame_html = NULL, *path = NULL, *in_repo_path = NULL;
2384 	char *folder = NULL;
2385 	struct gw_blame_cb_args bca;
2386 	int i, obj_type;
2387 	size_t filesize;
2388 	enum kcgi_err kerr;
2389 
2390 	error = got_repo_open(&repo, gw_trans->repo_path, NULL);
2391 	if (error)
2392 		goto done;
2393 
2394 	if (gw_trans->repo_folder != NULL) {
2395 		if (asprintf(&folder, "%s/", gw_trans->repo_folder) == -1) {
2396 			error = got_error_from_errno("asprintf");
2397 			goto done;
2398 		}
2399 	} else
2400 		folder = strdup("");
2401 
2402 	if (asprintf(&path, "%s%s", folder, gw_trans->repo_file) == -1) {
2403 		error = got_error_from_errno("asprintf");
2404 		goto done;
2405 	}
2406 	free(folder);
2407 
2408 	error = got_repo_map_path(&in_repo_path, repo, path, 1);
2409 	if (error)
2410 		goto done;
2411 
2412 	error = got_repo_match_object_id(&commit_id, NULL, gw_trans->commit,
2413 	    GOT_OBJ_TYPE_COMMIT, 1, repo);
2414 	if (error)
2415 		goto done;
2416 
2417 	error = got_object_id_by_path(&obj_id, repo, commit_id, in_repo_path);
2418 	if (error)
2419 		goto done;
2420 
2421 	if (obj_id == NULL) {
2422 		error = got_error(GOT_ERR_NO_OBJ);
2423 		goto done;
2424 	}
2425 
2426 	error = got_object_get_type(&obj_type, repo, obj_id);
2427 	if (error)
2428 		goto done;
2429 
2430 	if (obj_type != GOT_OBJ_TYPE_BLOB) {
2431 		error = got_error(GOT_ERR_OBJ_TYPE);
2432 		goto done;
2433 	}
2434 
2435 	error = got_object_open_as_blob(&blob, repo, obj_id, 8192);
2436 	if (error)
2437 		goto done;
2438 
2439 	error = buf_alloc(&bca.blamebuf, 0);
2440 	if (error)
2441 		goto done;
2442 
2443 	bca.f = got_opentemp();
2444 	if (bca.f == NULL) {
2445 		error = got_error_from_errno("got_opentemp");
2446 		goto done;
2447 	}
2448 	error = got_object_blob_dump_to_file(&filesize, &bca.nlines,
2449 	    &bca.line_offsets, bca.f, blob);
2450 	if (error || bca.nlines == 0)
2451 		goto done;
2452 
2453 	if (gw_trans->action == GW_BLOB) {
2454 		int len, p, p_check, t = 0, t_check = 50;
2455 
2456 		fseek(bca.f, 0, SEEK_END);
2457 		p_check = len = ftell(bca.f) + 1;
2458 		fseek(bca.f, 0, SEEK_SET);
2459 
2460 		if ((blame_html = calloc(len, sizeof(char *))) == NULL)
2461 			goto done;
2462 
2463 		fread(blame_html, 1, len, bca.f);
2464 
2465 		for (p = 0; p < p_check; p++) {
2466 			if (isprint(blame_html[p]) == 0)
2467 				if (iscntrl(blame_html[p]) == 0)
2468 					t++;
2469 		}
2470 
2471 		/*
2472 		 * Anything over zero is most likely not plain text,
2473 		 * but let's be sure. Perhaps there's a better way to
2474 		 * check in the future.
2475 		 */
2476 
2477 		if (t > t_check)
2478 			gw_trans->mime = KMIME_APP_OCTET_STREAM;
2479 		else
2480 			gw_trans->mime = KMIME_TEXT_PLAIN;
2481 
2482 		error = gw_display_index(gw_trans);
2483 
2484 		if (gw_trans->mime == KMIME_APP_OCTET_STREAM) {
2485 			kerr = khttp_write(gw_trans->gw_req, blame_html, len);
2486 			if (kerr != KCGI_OK)
2487 				error = gw_kcgi_error(kerr);
2488 		}
2489 		goto done;
2490 	}
2491 
2492 	/* Don't include \n at EOF in the blame line count. */
2493 	if (bca.line_offsets[bca.nlines - 1] == filesize)
2494 		bca.nlines--;
2495 
2496 	bca.lines = calloc(bca.nlines, sizeof(*bca.lines));
2497 	if (bca.lines == NULL) {
2498 		error = got_error_from_errno("calloc");
2499 		goto done;
2500 	}
2501 	bca.lineno_cur = 1;
2502 	bca.nlines_prec = 0;
2503 	i = bca.nlines;
2504 	while (i > 0) {
2505 		i /= 10;
2506 		bca.nlines_prec++;
2507 	}
2508 	bca.repo = repo;
2509 	bca.gw_trans = gw_trans;
2510 
2511 	error = got_blame(in_repo_path, commit_id, repo, gw_blame_cb, &bca,
2512 	    NULL, NULL);
2513 	if (error)
2514 		goto done;
2515 	if (buf_len(bca.blamebuf) > 0) {
2516 		error = buf_putc(bca.blamebuf, '\0');
2517 		blame_html = strdup(buf_get(bca.blamebuf));
2518 	}
2519 done:
2520 	free(bca.line_offsets);
2521 	free(bca.blamebuf);
2522 	free(in_repo_path);
2523 	free(commit_id);
2524 	free(obj_id);
2525 	free(path);
2526 
2527 	if (gw_trans->action != GW_BLOB && bca.lines) {
2528 		for (i = 0; i < bca.nlines; i++) {
2529 			struct blame_line *bline = &bca.lines[i];
2530 			free(bline->id_str);
2531 			free(bline->committer);
2532 		}
2533 		free(bca.lines);
2534 	}
2535 	if (error)
2536 		return NULL;
2537 	if (bca.f && fclose(bca.f) == EOF && error == NULL)
2538 		return NULL;
2539 	if (blob)
2540 		error = got_object_blob_close(blob);
2541 	if (error)
2542 		return NULL;
2543 	if (repo)
2544 		error = got_repo_close(repo);
2545 	if (error)
2546 		return NULL;
2547 	else
2548 		return blame_html;
2549 }
2550 
2551 static char*
2552 gw_get_repo_tree(struct gw_trans *gw_trans)
2553 {
2554 	const struct got_error *error = NULL;
2555 	struct got_repository *repo = NULL;
2556 	struct got_object_id *tree_id = NULL, *commit_id = NULL;
2557 	struct got_tree_object *tree = NULL;
2558 	struct buf *diffbuf = NULL;
2559 	size_t newsize;
2560 	char *tree_html = NULL, *path = NULL, *in_repo_path = NULL,
2561 	    *tree_row = NULL, *id_str, *class = NULL;
2562 	int nentries, i, class_flip = 0;
2563 
2564 	error = buf_alloc(&diffbuf, 0);
2565 	if (error)
2566 		return NULL;
2567 
2568 	error = got_repo_open(&repo, gw_trans->repo_path, NULL);
2569 	if (error)
2570 		goto done;
2571 
2572 	error = got_repo_map_path(&in_repo_path, repo, gw_trans->repo_path, 1);
2573 	if (error)
2574 		goto done;
2575 
2576 	if (gw_trans->repo_folder != NULL)
2577 		path = strdup(gw_trans->repo_folder);
2578 	else if (in_repo_path) {
2579 		free(path);
2580 		path = in_repo_path;
2581 	}
2582 
2583 	if (gw_trans->commit == NULL) {
2584 		struct got_reference *head_ref;
2585 		error = got_ref_open(&head_ref, repo, gw_trans->headref, 0);
2586 		if (error)
2587 			goto done;
2588 
2589 		error = got_ref_resolve(&commit_id, repo, head_ref);
2590 		got_ref_close(head_ref);
2591 
2592 	} else
2593 		error = got_repo_match_object_id(&commit_id, NULL,
2594 		    gw_trans->commit, GOT_OBJ_TYPE_COMMIT, 1, repo);
2595 	if (error)
2596 		goto done;
2597 
2598 	error = got_object_id_str(&gw_trans->commit, commit_id);
2599 	if (error)
2600 		goto done;
2601 
2602 	error = got_object_id_by_path(&tree_id, repo, commit_id, path);
2603 	if (error)
2604 		goto done;
2605 
2606 	error = got_object_open_as_tree(&tree, repo, tree_id);
2607 	if (error)
2608 		goto done;
2609 
2610 	nentries = got_object_tree_get_nentries(tree);
2611 
2612 	for (i = 0; i < nentries; i++) {
2613 		struct got_tree_entry *te;
2614 		const char *modestr = "";
2615 		char *id = NULL, *url_html = NULL;
2616 
2617 		te = got_object_tree_get_entry(tree, i);
2618 
2619 		error = got_object_id_str(&id_str, got_tree_entry_get_id(te));
2620 		if (error)
2621 			goto done;
2622 
2623 		if (asprintf(&id, "%s", id_str) == -1) {
2624 			error = got_error_from_errno("asprintf");
2625 			free(id_str);
2626 			goto done;
2627 		}
2628 
2629 		mode_t mode = got_tree_entry_get_mode(te);
2630 
2631 		if (got_object_tree_entry_is_submodule(te))
2632 			modestr = "$";
2633 		else if (S_ISLNK(mode))
2634 			modestr = "@";
2635 		else if (S_ISDIR(mode))
2636 			modestr = "/";
2637 		else if (mode & S_IXUSR)
2638 			modestr = "*";
2639 
2640 		if (class_flip == 0) {
2641 			class = strdup("back_lightgray");
2642 			class_flip = 1;
2643 		} else {
2644 			class = strdup("back_white");
2645 			class_flip = 0;
2646 		}
2647 
2648 		char *build_folder = NULL;
2649 		if (S_ISDIR(got_tree_entry_get_mode(te))) {
2650 			if (gw_trans->repo_folder != NULL) {
2651 				if (asprintf(&build_folder, "%s/%s",
2652 				    gw_trans->repo_folder,
2653 				    got_tree_entry_get_name(te)) == -1) {
2654 					error =
2655 					    got_error_from_errno("asprintf");
2656 					goto done;
2657 				}
2658 			} else {
2659 				if (asprintf(&build_folder, "%s",
2660 				    got_tree_entry_get_name(te)) == -1)
2661 					goto done;
2662 			}
2663 
2664 			if (asprintf(&url_html, folder_html,
2665 			    gw_trans->repo_name, gw_trans->action_name,
2666 			    gw_trans->commit, build_folder,
2667 			    got_tree_entry_get_name(te), modestr) == -1) {
2668 				error = got_error_from_errno("asprintf");
2669 				goto done;
2670 			}
2671 
2672 		if (asprintf(&tree_row, tree_line, class, url_html,
2673 			class) == -1) {
2674 			error = got_error_from_errno("asprintf");
2675 			goto done;
2676 		}
2677 
2678 		} else {
2679 			if (gw_trans->repo_folder != NULL) {
2680 				if (asprintf(&build_folder, "%s",
2681 				    gw_trans->repo_folder) == -1) {
2682 					error =
2683 					    got_error_from_errno("asprintf");
2684 					goto done;
2685 				}
2686 			} else
2687 				build_folder = strdup("");
2688 
2689 			if (asprintf(&url_html, file_html, gw_trans->repo_name,
2690 			    "blob", gw_trans->commit,
2691 			    got_tree_entry_get_name(te), build_folder,
2692 			    got_tree_entry_get_name(te), modestr) == -1) {
2693 				error = got_error_from_errno("asprintf");
2694 				goto done;
2695 			}
2696 
2697 			if (asprintf(&tree_row, tree_line_with_navs, class,
2698 				url_html, class, gw_trans->repo_name, "blob",
2699 				gw_trans->commit, got_tree_entry_get_name(te),
2700 				build_folder, "blob", gw_trans->repo_name,
2701 				"blame", gw_trans->commit,
2702 				got_tree_entry_get_name(te), build_folder,
2703 				"blame") == -1) {
2704 				error = got_error_from_errno("asprintf");
2705 				goto done;
2706 			}
2707 		}
2708 		free(build_folder);
2709 
2710 		if (error)
2711 			goto done;
2712 
2713 		error = buf_puts(&newsize, diffbuf, tree_row);
2714 		if (error)
2715 			goto done;
2716 
2717 		free(id);
2718 		free(id_str);
2719 		free(url_html);
2720 		free(tree_row);
2721 	}
2722 
2723 	if (buf_len(diffbuf) > 0) {
2724 		error = buf_putc(diffbuf, '\0');
2725 		tree_html = strdup(buf_get(diffbuf));
2726 	}
2727 done:
2728 	if (tree)
2729 		got_object_tree_close(tree);
2730 	if (repo)
2731 		got_repo_close(repo);
2732 
2733 	free(in_repo_path);
2734 	free(tree_id);
2735 	free(diffbuf);
2736 	if (error)
2737 		return NULL;
2738 	else
2739 		return tree_html;
2740 }
2741 
2742 static char *
2743 gw_get_repo_heads(struct gw_trans *gw_trans)
2744 {
2745 	const struct got_error *error = NULL;
2746 	struct got_repository *repo = NULL;
2747 	struct got_reflist_head refs;
2748 	struct got_reflist_entry *re;
2749 	char *heads, *head_row = NULL, *head_navs_disp = NULL, *age = NULL;
2750 	struct buf *diffbuf = NULL;
2751 	size_t newsize;
2752 
2753 	SIMPLEQ_INIT(&refs);
2754 
2755 	error = buf_alloc(&diffbuf, 0);
2756 	if (error)
2757 		return NULL;
2758 
2759 	error = got_repo_open(&repo, gw_trans->repo_path, NULL);
2760 	if (error)
2761 		goto done;
2762 
2763 	error = got_ref_list(&refs, repo, "refs/heads", got_ref_cmp_by_name,
2764 	    NULL);
2765 	if (error)
2766 		goto done;
2767 
2768 	SIMPLEQ_FOREACH(re, &refs, entry) {
2769 		char *refname;
2770 
2771 		refname = strdup(got_ref_get_name(re->ref));
2772 		if (refname == NULL) {
2773 			error = got_error_from_errno("got_ref_to_str");
2774 			goto done;
2775 		}
2776 
2777 		if (strncmp(refname, "refs/heads/", 11) != 0) {
2778 			free(refname);
2779 			continue;
2780 		}
2781 
2782 		error = gw_get_repo_age(&age, gw_trans, gw_trans->gw_dir->path,
2783 		    refname, TM_DIFF);
2784 		if (error)
2785 			goto done;
2786 
2787 		if (asprintf(&head_navs_disp, heads_navs, gw_trans->repo_name,
2788 		    refname, gw_trans->repo_name, refname,
2789 		    gw_trans->repo_name, refname, gw_trans->repo_name,
2790 		    refname) == -1) {
2791 			error = got_error_from_errno("asprintf");
2792 			goto done;
2793 		}
2794 
2795 		if (strncmp(refname, "refs/heads/", 11) == 0)
2796 			refname += 11;
2797 
2798 		if (asprintf(&head_row, heads_row, age, refname,
2799 		    head_navs_disp) == -1) {
2800 			error = got_error_from_errno("asprintf");
2801 			goto done;
2802 		}
2803 
2804 		error = buf_puts(&newsize, diffbuf, head_row);
2805 
2806 		free(head_navs_disp);
2807 		free(head_row);
2808 	}
2809 
2810 	if (buf_len(diffbuf) > 0) {
2811 		error = buf_putc(diffbuf, '\0');
2812 		heads = strdup(buf_get(diffbuf));
2813 	}
2814 done:
2815 	buf_free(diffbuf);
2816 	got_ref_list_free(&refs);
2817 	if (repo)
2818 		got_repo_close(repo);
2819 	if (error)
2820 		return NULL;
2821 	else
2822 		return heads;
2823 }
2824 
2825 static char *
2826 gw_get_got_link(struct gw_trans *gw_trans)
2827 {
2828 	char *link;
2829 
2830 	if (asprintf(&link, got_link, gw_trans->gw_conf->got_logo_url,
2831 	    gw_trans->gw_conf->got_logo) == -1)
2832 		return NULL;
2833 
2834 	return link;
2835 }
2836 
2837 static char *
2838 gw_get_site_link(struct gw_trans *gw_trans)
2839 {
2840 	char *link, *repo = "", *action = "";
2841 
2842 	if (gw_trans->repo_name != NULL)
2843 		if (asprintf(&repo, " / <a href='?path=%s&action=summary'>%s" \
2844 		    "</a>", gw_trans->repo_name, gw_trans->repo_name) == -1)
2845 			return NULL;
2846 
2847 	if (gw_trans->action_name != NULL)
2848 		if (asprintf(&action, " / %s", gw_trans->action_name) == -1)
2849 			return NULL;
2850 
2851 	if (asprintf(&link, site_link, GOTWEB,
2852 	    gw_trans->gw_conf->got_site_link, repo, action) == -1)
2853 		return NULL;
2854 
2855 	return link;
2856 }
2857 
2858 static char *
2859 gw_colordiff_line(char *buf)
2860 {
2861 	const struct got_error *error = NULL;
2862 	char *colorized_line = NULL, *div_diff_line_div = NULL, *color = NULL;
2863 	struct buf *diffbuf = NULL;
2864 	size_t newsize;
2865 
2866 	error = buf_alloc(&diffbuf, 0);
2867 	if (error)
2868 		return NULL;
2869 
2870 	if (buf == NULL)
2871 		return NULL;
2872 	if (strncmp(buf, "-", 1) == 0)
2873 		color = "diff_minus";
2874 	if (strncmp(buf, "+", 1) == 0)
2875 		color = "diff_plus";
2876 	if (strncmp(buf, "@@", 2) == 0)
2877 		color = "diff_chunk_header";
2878 	if (strncmp(buf, "@@", 2) == 0)
2879 		color = "diff_chunk_header";
2880 	if (strncmp(buf, "commit +", 8) == 0)
2881 		color = "diff_meta";
2882 	if (strncmp(buf, "commit -", 8) == 0)
2883 		color = "diff_meta";
2884 	if (strncmp(buf, "blob +", 6) == 0)
2885 		color = "diff_meta";
2886 	if (strncmp(buf, "blob -", 6) == 0)
2887 		color = "diff_meta";
2888 	if (strncmp(buf, "file +", 6) == 0)
2889 		color = "diff_meta";
2890 	if (strncmp(buf, "file -", 6) == 0)
2891 		color = "diff_meta";
2892 	if (strncmp(buf, "from:", 5) == 0)
2893 		color = "diff_author";
2894 	if (strncmp(buf, "via:", 4) == 0)
2895 		color = "diff_author";
2896 	if (strncmp(buf, "date:", 5) == 0)
2897 		color = "diff_date";
2898 
2899 	if (asprintf(&div_diff_line_div, div_diff_line, color) == -1)
2900 		return NULL;
2901 
2902 	error = buf_puts(&newsize, diffbuf, div_diff_line_div);
2903 	if (error)
2904 		return NULL;
2905 
2906 	error = buf_puts(&newsize, diffbuf, buf);
2907 	if (error)
2908 		return NULL;
2909 
2910 	if (buf_len(diffbuf) > 0) {
2911 		error = buf_putc(diffbuf, '\0');
2912 		colorized_line = strdup(buf_get(diffbuf));
2913 	}
2914 
2915 	free(diffbuf);
2916 	free(div_diff_line_div);
2917 	return colorized_line;
2918 }
2919 
2920 static char *
2921 gw_html_escape(const char *html)
2922 {
2923 	char *escaped_str = NULL, *buf;
2924 	char c[1];
2925 	size_t sz, i, buff_sz = 2048;
2926 
2927 	if ((buf = calloc(buff_sz, sizeof(char *))) == NULL)
2928 		return NULL;
2929 
2930 	if (html == NULL)
2931 		return NULL;
2932 	else
2933 		if ((sz = strlen(html)) == 0)
2934 			return NULL;
2935 
2936 	/* only work with buff_sz */
2937 	if (buff_sz < sz)
2938 		sz = buff_sz;
2939 
2940 	for (i = 0; i < sz; i++) {
2941 		c[0] = html[i];
2942 		switch (c[0]) {
2943 		case ('>'):
2944 			strcat(buf, "&gt;");
2945 			break;
2946 		case ('&'):
2947 			strcat(buf, "&amp;");
2948 			break;
2949 		case ('<'):
2950 			strcat(buf, "&lt;");
2951 			break;
2952 		case ('"'):
2953 			strcat(buf, "&quot;");
2954 			break;
2955 		case ('\''):
2956 			strcat(buf, "&apos;");
2957 			break;
2958 		case ('\n'):
2959 			strcat(buf, "<br />");
2960 		default:
2961 			strcat(buf, &c[0]);
2962 			break;
2963 		}
2964 	}
2965 	asprintf(&escaped_str, "%s", buf);
2966 	free(buf);
2967 	return escaped_str;
2968 }
2969 
2970 int
2971 main(int argc, char *argv[])
2972 {
2973 	const struct got_error *error = NULL;
2974 	struct gw_trans *gw_trans;
2975 	struct gw_dir *dir = NULL, *tdir;
2976 	const char *page = "index";
2977 	int gw_malloc = 1;
2978 	enum kcgi_err kerr;
2979 
2980 	if ((gw_trans = malloc(sizeof(struct gw_trans))) == NULL)
2981 		errx(1, "malloc");
2982 
2983 	if ((gw_trans->gw_req = malloc(sizeof(struct kreq))) == NULL)
2984 		errx(1, "malloc");
2985 
2986 	if ((gw_trans->gw_html_req = malloc(sizeof(struct khtmlreq))) == NULL)
2987 		errx(1, "malloc");
2988 
2989 	if ((gw_trans->gw_tmpl = malloc(sizeof(struct ktemplate))) == NULL)
2990 		errx(1, "malloc");
2991 
2992 	kerr = khttp_parse(gw_trans->gw_req, gw_keys, KEY__ZMAX, &page, 1, 0);
2993 	if (kerr != KCGI_OK) {
2994 		error = gw_kcgi_error(kerr);
2995 		goto done;
2996 	}
2997 
2998 	if ((gw_trans->gw_conf =
2999 	    malloc(sizeof(struct gotweb_conf))) == NULL) {
3000 		gw_malloc = 0;
3001 		error = got_error_from_errno("malloc");
3002 		goto done;
3003 	}
3004 
3005 	TAILQ_INIT(&gw_trans->gw_dirs);
3006 	TAILQ_INIT(&gw_trans->gw_headers);
3007 
3008 	gw_trans->page = 0;
3009 	gw_trans->repos_total = 0;
3010 	gw_trans->repo_path = NULL;
3011 	gw_trans->commit = NULL;
3012 	gw_trans->headref = strdup(GOT_REF_HEAD);
3013 	gw_trans->mime = KMIME_TEXT_HTML;
3014 	gw_trans->gw_tmpl->key = gw_templs;
3015 	gw_trans->gw_tmpl->keysz = TEMPL__MAX;
3016 	gw_trans->gw_tmpl->arg = gw_trans;
3017 	gw_trans->gw_tmpl->cb = gw_template;
3018 	error = parse_conf(GOTWEB_CONF, gw_trans->gw_conf);
3019 	if (error)
3020 		goto done;
3021 
3022 	error = gw_parse_querystring(gw_trans);
3023 	if (error)
3024 		goto done;
3025 
3026 	if (gw_trans->action == GW_BLOB)
3027 		error = gw_blob(gw_trans);
3028 	else
3029 		error = gw_display_index(gw_trans);
3030 done:
3031 	if (error) {
3032 		gw_trans->mime = KMIME_TEXT_PLAIN;
3033 		gw_trans->action = GW_ERR;
3034 		gw_display_error(gw_trans, error);
3035 	}
3036 	if (gw_malloc) {
3037 		free(gw_trans->gw_conf->got_repos_path);
3038 		free(gw_trans->gw_conf->got_site_name);
3039 		free(gw_trans->gw_conf->got_site_owner);
3040 		free(gw_trans->gw_conf->got_site_link);
3041 		free(gw_trans->gw_conf->got_logo);
3042 		free(gw_trans->gw_conf->got_logo_url);
3043 		free(gw_trans->gw_conf);
3044 		free(gw_trans->commit);
3045 		free(gw_trans->repo_path);
3046 		free(gw_trans->repo_name);
3047 		free(gw_trans->repo_file);
3048 		free(gw_trans->action_name);
3049 		free(gw_trans->headref);
3050 
3051 		TAILQ_FOREACH_SAFE(dir, &gw_trans->gw_dirs, entry, tdir) {
3052 			free(dir->name);
3053 			free(dir->description);
3054 			free(dir->age);
3055 			free(dir->url);
3056 			free(dir->path);
3057 			free(dir);
3058 		}
3059 
3060 	}
3061 
3062 	khttp_free(gw_trans->gw_req);
3063 	return 0;
3064 }