?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gotwebd: templateify gotweb_render_navs
[got-portable.git] / gotweb / gotweb.c
blob0580992091e15b774b51ac00db28f4d691a4b1a0
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 }
portable version of Game of Trees