1 /*
2  * Copyright (c) 2018, 2019 Stefan Sperling <stsp@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <sys/queue.h>
18 #include <sys/stat.h>
19 #include <sys/ioctl.h>
20 
21 #include <errno.h>
22 #define _XOPEN_SOURCE_EXTENDED
23 #include <curses.h>
24 #undef _XOPEN_SOURCE_EXTENDED
25 #include <panel.h>
26 #include <locale.h>
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <getopt.h>
30 #include <string.h>
31 #include <err.h>
32 #include <unistd.h>
33 #include <util.h>
34 #include <limits.h>
35 #include <wchar.h>
36 #include <time.h>
37 #include <pthread.h>
38 #include <libgen.h>
39 #include <regex.h>
40 
41 #include "got_error.h"
42 #include "got_object.h"
43 #include "got_reference.h"
44 #include "got_repository.h"
45 #include "got_diff.h"
46 #include "got_opentemp.h"
47 #include "got_commit_graph.h"
48 #include "got_utf8.h"
49 #include "got_blame.h"
50 #include "got_privsep.h"
51 #include "got_path.h"
52 #include "got_worktree.h"
53 
54 #ifndef MIN
55 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
56 #endif
57 
58 #ifndef MAX
59 #define	MAX(_a,_b) ((_a) > (_b) ? (_a) : (_b))
60 #endif
61 
62 #define CTRL(x)		((x) & 0x1f)
63 
64 #ifndef nitems
65 #define nitems(_a)	(sizeof((_a)) / sizeof((_a)[0]))
66 #endif
67 
68 struct tog_cmd {
69 	const char *name;
70 	const struct got_error *(*cmd_main)(int, char *[]);
71 	void (*cmd_usage)(void);
72 };
73 
74 __dead static void	usage(int);
75 __dead static void	usage_log(void);
76 __dead static void	usage_diff(void);
77 __dead static void	usage_blame(void);
78 __dead static void	usage_tree(void);
79 
80 static const struct got_error*	cmd_log(int, char *[]);
81 static const struct got_error*	cmd_diff(int, char *[]);
82 static const struct got_error*	cmd_blame(int, char *[]);
83 static const struct got_error*	cmd_tree(int, char *[]);
84 
85 static struct tog_cmd tog_commands[] = {
86 	{ "log",	cmd_log,	usage_log },
87 	{ "diff",	cmd_diff,	usage_diff },
88 	{ "blame",	cmd_blame,	usage_blame },
89 	{ "tree",	cmd_tree,	usage_tree },
90 };
91 
92 enum tog_view_type {
93 	TOG_VIEW_DIFF,
94 	TOG_VIEW_LOG,
95 	TOG_VIEW_BLAME,
96 	TOG_VIEW_TREE
97 };
98 
99 #define TOG_EOF_STRING	"(END)"
100 
101 struct commit_queue_entry {
102 	TAILQ_ENTRY(commit_queue_entry) entry;
103 	struct got_object_id *id;
104 	struct got_commit_object *commit;
105 	int idx;
106 };
107 TAILQ_HEAD(commit_queue_head, commit_queue_entry);
108 struct commit_queue {
109 	int ncommits;
110 	struct commit_queue_head head;
111 };
112 
113 struct tog_diff_view_state {
114 	struct got_object_id *id1, *id2;
115 	FILE *f;
116 	int first_displayed_line;
117 	int last_displayed_line;
118 	int eof;
119 	int diff_context;
120 	struct got_repository *repo;
121 	struct got_reflist_head *refs;
122 
123 	/* passed from log view; may be NULL */
124 	struct tog_view *log_view;
125 };
126 
127 pthread_mutex_t tog_mutex = PTHREAD_MUTEX_INITIALIZER;
128 
129 struct tog_log_thread_args {
130 	pthread_cond_t need_commits;
131 	int commits_needed;
132 	struct got_commit_graph *graph;
133 	struct commit_queue *commits;
134 	const char *in_repo_path;
135 	struct got_object_id *start_id;
136 	struct got_repository *repo;
137 	int log_complete;
138 	sig_atomic_t *quit;
139 	struct tog_view *view;
140 	struct commit_queue_entry **first_displayed_entry;
141 	struct commit_queue_entry **selected_entry;
142 };
143 
144 struct tog_log_view_state {
145 	struct commit_queue commits;
146 	struct commit_queue_entry *first_displayed_entry;
147 	struct commit_queue_entry *last_displayed_entry;
148 	struct commit_queue_entry *selected_entry;
149 	int selected;
150 	char *in_repo_path;
151 	const char *head_ref_name;
152 	struct got_repository *repo;
153 	struct got_reflist_head *refs;
154 	struct got_object_id *start_id;
155 	sig_atomic_t quit;
156 	pthread_t thread;
157 	struct tog_log_thread_args thread_args;
158 	struct commit_queue_entry *matched_entry;
159 	struct commit_queue_entry *search_entry;
160 };
161 
162 struct tog_blame_cb_args {
163 	struct tog_blame_line *lines; /* one per line */
164 	int nlines;
165 
166 	struct tog_view *view;
167 	struct got_object_id *commit_id;
168 	int *quit;
169 };
170 
171 struct tog_blame_thread_args {
172 	const char *path;
173 	struct got_repository *repo;
174 	struct tog_blame_cb_args *cb_args;
175 	int *complete;
176 };
177 
178 struct tog_blame {
179 	FILE *f;
180 	size_t filesize;
181 	struct tog_blame_line *lines;
182 	int nlines;
183 	off_t *line_offsets;
184 	pthread_t thread;
185 	struct tog_blame_thread_args thread_args;
186 	struct tog_blame_cb_args cb_args;
187 	const char *path;
188 };
189 
190 struct tog_blame_view_state {
191 	int first_displayed_line;
192 	int last_displayed_line;
193 	int selected_line;
194 	int blame_complete;
195 	int eof;
196 	int done;
197 	struct got_object_id_queue blamed_commits;
198 	struct got_object_qid *blamed_commit;
199 	char *path;
200 	struct got_repository *repo;
201 	struct got_reflist_head *refs;
202 	struct got_object_id *commit_id;
203 	struct tog_blame blame;
204 	int matched_line;
205 };
206 
207 struct tog_parent_tree {
208 	TAILQ_ENTRY(tog_parent_tree) entry;
209 	struct got_tree_object *tree;
210 	struct got_tree_entry *first_displayed_entry;
211 	struct got_tree_entry *selected_entry;
212 	int selected;
213 };
214 
215 TAILQ_HEAD(tog_parent_trees, tog_parent_tree);
216 
217 struct tog_tree_view_state {
218 	char *tree_label;
219 	struct got_tree_object *root;
220 	struct got_tree_object *tree;
221 	const struct got_tree_entries *entries;
222 	struct got_tree_entry *first_displayed_entry;
223 	struct got_tree_entry *last_displayed_entry;
224 	struct got_tree_entry *selected_entry;
225 	int ndisplayed, selected, show_ids;
226 	struct tog_parent_trees parents;
227 	struct got_object_id *commit_id;
228 	struct got_repository *repo;
229 	struct got_reflist_head *refs;
230 	struct got_tree_entry *matched_entry;
231 };
232 
233 /*
234  * We implement two types of views: parent views and child views.
235  *
236  * The 'Tab' key switches between a parent view and its child view.
237  * Child views are shown side-by-side to their parent view, provided
238  * there is enough screen estate.
239  *
240  * When a new view is opened from within a parent view, this new view
241  * becomes a child view of the parent view, replacing any existing child.
242  *
243  * When a new view is opened from within a child view, this new view
244  * becomes a parent view which will obscure the views below until the
245  * user quits the new parent view by typing 'q'.
246  *
247  * This list of views contains parent views only.
248  * Child views are only pointed to by their parent view.
249  */
250 TAILQ_HEAD(tog_view_list_head, tog_view);
251 
252 struct tog_view {
253 	TAILQ_ENTRY(tog_view) entry;
254 	WINDOW *window;
255 	PANEL *panel;
256 	int nlines, ncols, begin_y, begin_x;
257 	int lines, cols; /* copies of LINES and COLS */
258 	int focussed;
259 	struct tog_view *parent;
260 	struct tog_view *child;
261 	int child_focussed;
262 
263 	/* type-specific state */
264 	enum tog_view_type type;
265 	union {
266 		struct tog_diff_view_state diff;
267 		struct tog_log_view_state log;
268 		struct tog_blame_view_state blame;
269 		struct tog_tree_view_state tree;
270 	} state;
271 
272 	const struct got_error *(*show)(struct tog_view *);
273 	const struct got_error *(*input)(struct tog_view **,
274 	    struct tog_view **, struct tog_view**, struct tog_view *, int);
275 	const struct got_error *(*close)(struct tog_view *);
276 
277 	const struct got_error *(*search_start)(struct tog_view *);
278 	const struct got_error *(*search_next)(struct tog_view *);
279 	int searching;
280 #define TOG_SEARCH_FORWARD	1
281 #define TOG_SEARCH_BACKWARD	2
282 	int search_next_done;
283 	regex_t regex;
284 };
285 
286 static const struct got_error *open_diff_view(struct tog_view *,
287     struct got_object_id *, struct got_object_id *, struct tog_view *,
288     struct got_reflist_head *, struct got_repository *);
289 static const struct got_error *show_diff_view(struct tog_view *);
290 static const struct got_error *input_diff_view(struct tog_view **,
291     struct tog_view **, struct tog_view **, struct tog_view *, int);
292 static const struct got_error* close_diff_view(struct tog_view *);
293 
294 static const struct got_error *open_log_view(struct tog_view *,
295     struct got_object_id *, struct got_reflist_head *,
296     struct got_repository *, const char *, const char *, int);
297 static const struct got_error * show_log_view(struct tog_view *);
298 static const struct got_error *input_log_view(struct tog_view **,
299     struct tog_view **, struct tog_view **, struct tog_view *, int);
300 static const struct got_error *close_log_view(struct tog_view *);
301 static const struct got_error *search_start_log_view(struct tog_view *);
302 static const struct got_error *search_next_log_view(struct tog_view *);
303 
304 static const struct got_error *open_blame_view(struct tog_view *, char *,
305     struct got_object_id *, struct got_reflist_head *, struct got_repository *);
306 static const struct got_error *show_blame_view(struct tog_view *);
307 static const struct got_error *input_blame_view(struct tog_view **,
308     struct tog_view **, struct tog_view **, struct tog_view *, int);
309 static const struct got_error *close_blame_view(struct tog_view *);
310 static const struct got_error *search_start_blame_view(struct tog_view *);
311 static const struct got_error *search_next_blame_view(struct tog_view *);
312 
313 static const struct got_error *open_tree_view(struct tog_view *,
314     struct got_tree_object *, struct got_object_id *,
315     struct got_reflist_head *, struct got_repository *);
316 static const struct got_error *show_tree_view(struct tog_view *);
317 static const struct got_error *input_tree_view(struct tog_view **,
318     struct tog_view **, struct tog_view **, struct tog_view *, int);
319 static const struct got_error *close_tree_view(struct tog_view *);
320 static const struct got_error *search_start_tree_view(struct tog_view *);
321 static const struct got_error *search_next_tree_view(struct tog_view *);
322 
323 static volatile sig_atomic_t tog_sigwinch_received;
324 
325 static void
326 tog_sigwinch(int signo)
327 {
328 	tog_sigwinch_received = 1;
329 }
330 
331 static const struct got_error *
332 view_close(struct tog_view *view)
333 {
334 	const struct got_error *err = NULL;
335 
336 	if (view->child) {
337 		view_close(view->child);
338 		view->child = NULL;
339 	}
340 	if (view->close)
341 		err = view->close(view);
342 	if (view->panel)
343 		del_panel(view->panel);
344 	if (view->window)
345 		delwin(view->window);
346 	free(view);
347 	return err;
348 }
349 
350 static struct tog_view *
351 view_open(int nlines, int ncols, int begin_y, int begin_x,
352     enum tog_view_type type)
353 {
354 	struct tog_view *view = calloc(1, sizeof(*view));
355 
356 	if (view == NULL)
357 		return NULL;
358 
359 	view->type = type;
360 	view->lines = LINES;
361 	view->cols = COLS;
362 	view->nlines = nlines ? nlines : LINES - begin_y;
363 	view->ncols = ncols ? ncols : COLS - begin_x;
364 	view->begin_y = begin_y;
365 	view->begin_x = begin_x;
366 	view->window = newwin(nlines, ncols, begin_y, begin_x);
367 	if (view->window == NULL) {
368 		view_close(view);
369 		return NULL;
370 	}
371 	view->panel = new_panel(view->window);
372 	if (view->panel == NULL ||
373 	    set_panel_userptr(view->panel, view) != OK) {
374 		view_close(view);
375 		return NULL;
376 	}
377 
378 	keypad(view->window, TRUE);
379 	return view;
380 }
381 
382 static int
383 view_split_begin_x(int begin_x)
384 {
385 	if (begin_x > 0 || COLS < 120)
386 		return 0;
387 	return (COLS - MAX(COLS / 2, 80));
388 }
389 
390 static const struct got_error *view_resize(struct tog_view *);
391 
392 static const struct got_error *
393 view_splitscreen(struct tog_view *view)
394 {
395 	const struct got_error *err = NULL;
396 
397 	view->begin_y = 0;
398 	view->begin_x = view_split_begin_x(0);
399 	view->nlines = LINES;
400 	view->ncols = COLS - view->begin_x;
401 	view->lines = LINES;
402 	view->cols = COLS;
403 	err = view_resize(view);
404 	if (err)
405 		return err;
406 
407 	if (mvwin(view->window, view->begin_y, view->begin_x) == ERR)
408 		return got_error_from_errno("mvwin");
409 
410 	return NULL;
411 }
412 
413 static const struct got_error *
414 view_fullscreen(struct tog_view *view)
415 {
416 	const struct got_error *err = NULL;
417 
418 	view->begin_x = 0;
419 	view->begin_y = 0;
420 	view->nlines = LINES;
421 	view->ncols = COLS;
422 	view->lines = LINES;
423 	view->cols = COLS;
424 	err = view_resize(view);
425 	if (err)
426 		return err;
427 
428 	if (mvwin(view->window, view->begin_y, view->begin_x) == ERR)
429 		return got_error_from_errno("mvwin");
430 
431 	return NULL;
432 }
433 
434 static int
435 view_is_parent_view(struct tog_view *view)
436 {
437 	return view->parent == NULL;
438 }
439 
440 static const struct got_error *
441 view_resize(struct tog_view *view)
442 {
443 	int nlines, ncols;
444 
445 	if (view->lines > LINES)
446 		nlines = view->nlines - (view->lines - LINES);
447 	else
448 		nlines = view->nlines + (LINES - view->lines);
449 
450 	if (view->cols > COLS)
451 		ncols = view->ncols - (view->cols - COLS);
452 	else
453 		ncols = view->ncols + (COLS - view->cols);
454 
455 	if (wresize(view->window, nlines, ncols) == ERR)
456 		return got_error_from_errno("wresize");
457 	if (replace_panel(view->panel, view->window) == ERR)
458 		return got_error_from_errno("replace_panel");
459 	wclear(view->window);
460 
461 	view->nlines = nlines;
462 	view->ncols = ncols;
463 	view->lines = LINES;
464 	view->cols = COLS;
465 
466 	if (view->child) {
467 		view->child->begin_x = view_split_begin_x(view->begin_x);
468 		if (view->child->begin_x == 0) {
469 			view_fullscreen(view->child);
470 			if (view->child->focussed)
471 				show_panel(view->child->panel);
472 			else
473 				show_panel(view->panel);
474 		} else {
475 			view_splitscreen(view->child);
476 			show_panel(view->child->panel);
477 		}
478 	}
479 
480 	return NULL;
481 }
482 
483 static const struct got_error *
484 view_close_child(struct tog_view *view)
485 {
486 	const struct got_error *err = NULL;
487 
488 	if (view->child == NULL)
489 		return NULL;
490 
491 	err = view_close(view->child);
492 	view->child = NULL;
493 	return err;
494 }
495 
496 static const struct got_error *
497 view_set_child(struct tog_view *view, struct tog_view *child)
498 {
499 	const struct got_error *err = NULL;
500 
501 	view->child = child;
502 	child->parent = view;
503 	return err;
504 }
505 
506 static int
507 view_is_splitscreen(struct tog_view *view)
508 {
509 	return view->begin_x > 0;
510 }
511 
512 static void
513 tog_resizeterm(void)
514 {
515 	int cols, lines;
516 	struct winsize size;
517 
518 	if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &size) < 0) {
519 		cols = 80;     /* Default */
520 		lines = 24;
521 	} else {
522 		cols = size.ws_col;
523 		lines = size.ws_row;
524 	}
525 	resize_term(lines, cols);
526 }
527 
528 static const struct got_error *
529 view_search_start(struct tog_view *view)
530 {
531 	const struct got_error *err = NULL;
532 	char pattern[1024];
533 	int ret;
534 
535 	if (view->nlines < 1)
536 		return NULL;
537 
538 	mvwaddstr(view->window, view->begin_y + view->nlines - 1,
539 	    view->begin_x, "/");
540 	wclrtoeol(view->window);
541 
542 	nocbreak();
543 	echo();
544 	ret = wgetnstr(view->window, pattern, sizeof(pattern));
545 	cbreak();
546 	noecho();
547 	if (ret == ERR)
548 		return NULL;
549 
550 	if (view->searching) {
551 		regfree(&view->regex);
552 		view->searching = 0;
553 	}
554 
555 	if (regcomp(&view->regex, pattern,
556 	    REG_EXTENDED | REG_NOSUB | REG_NEWLINE) == 0) {
557 		err = view->search_start(view);
558 		if (err) {
559 			regfree(&view->regex);
560 			return err;
561 		}
562 		view->searching = TOG_SEARCH_FORWARD;
563 		view->search_next_done = 0;
564 		view->search_next(view);
565 	}
566 
567 	return NULL;
568 }
569 
570 static const struct got_error *
571 view_input(struct tog_view **new, struct tog_view **dead,
572     struct tog_view **focus, int *done, struct tog_view *view,
573     struct tog_view_list_head *views)
574 {
575 	const struct got_error *err = NULL;
576 	struct tog_view *v;
577 	int ch, errcode;
578 
579 	*new = NULL;
580 	*dead = NULL;
581 	*focus = NULL;
582 
583 	if (view->searching && !view->search_next_done) {
584 		errcode = pthread_mutex_unlock(&tog_mutex);
585 		if (errcode)
586 			return got_error_set_errno(errcode,
587 			    "pthread_mutex_unlock");
588 		pthread_yield();
589 		errcode = pthread_mutex_lock(&tog_mutex);
590 		if (errcode)
591 			return got_error_set_errno(errcode,
592 			    "pthread_mutex_lock");
593 		view->search_next(view);
594 		return NULL;
595 	}
596 
597 	nodelay(stdscr, FALSE);
598 	/* Allow threads to make progress while we are waiting for input. */
599 	errcode = pthread_mutex_unlock(&tog_mutex);
600 	if (errcode)
601 		return got_error_set_errno(errcode, "pthread_mutex_unlock");
602 	ch = wgetch(view->window);
603 	errcode = pthread_mutex_lock(&tog_mutex);
604 	if (errcode)
605 		return got_error_set_errno(errcode, "pthread_mutex_lock");
606 	nodelay(stdscr, TRUE);
607 
608 	if (tog_sigwinch_received) {
609 		tog_resizeterm();
610 		tog_sigwinch_received = 0;
611 		TAILQ_FOREACH(v, views, entry) {
612 			err = view_resize(v);
613 			if (err)
614 				return err;
615 			err = v->input(new, dead, focus, v, KEY_RESIZE);
616 			if (err)
617 				return err;
618 		}
619 	}
620 
621 	switch (ch) {
622 	case ERR:
623 		break;
624 	case '\t':
625 		if (view->child) {
626 			*focus = view->child;
627 			view->child_focussed = 1;
628 		} else if (view->parent) {
629 			*focus = view->parent;
630 			view->parent->child_focussed = 0;
631 		}
632 		break;
633 	case 'q':
634 		err = view->input(new, dead, focus, view, ch);
635 		*dead = view;
636 		break;
637 	case 'Q':
638 		*done = 1;
639 		break;
640 	case 'f':
641 		if (view_is_parent_view(view)) {
642 			if (view->child == NULL)
643 				break;
644 			if (view_is_splitscreen(view->child)) {
645 				*focus = view->child;
646 				view->child_focussed = 1;
647 				err = view_fullscreen(view->child);
648 			} else
649 				err = view_splitscreen(view->child);
650 			if (err)
651 				break;
652 			err = view->child->input(new, dead, focus,
653 			    view->child, KEY_RESIZE);
654 		} else {
655 			if (view_is_splitscreen(view)) {
656 				*focus = view;
657 				view->parent->child_focussed = 1;
658 				err = view_fullscreen(view);
659 			} else {
660 				err = view_splitscreen(view);
661 			}
662 			if (err)
663 				break;
664 			err = view->input(new, dead, focus, view,
665 			    KEY_RESIZE);
666 		}
667 		break;
668 	case KEY_RESIZE:
669 		break;
670 	case '/':
671 		if (view->search_start)
672 			view_search_start(view);
673 		else
674 			err = view->input(new, dead, focus, view, ch);
675 		break;
676 	case 'N':
677 	case 'n':
678 		if (view->search_next && view->searching) {
679 			view->searching = (ch == 'n' ?
680 			    TOG_SEARCH_FORWARD : TOG_SEARCH_BACKWARD);
681 			view->search_next_done = 0;
682 			view->search_next(view);
683 		} else
684 			err = view->input(new, dead, focus, view, ch);
685 		break;
686 	default:
687 		err = view->input(new, dead, focus, view, ch);
688 		break;
689 	}
690 
691 	return err;
692 }
693 
694 void
695 view_vborder(struct tog_view *view)
696 {
697 	PANEL *panel;
698 	struct tog_view *view_above;
699 
700 	if (view->parent)
701 		return view_vborder(view->parent);
702 
703 	panel = panel_above(view->panel);
704 	if (panel == NULL)
705 		return;
706 
707 	view_above = panel_userptr(panel);
708 	mvwvline(view->window, view->begin_y, view_above->begin_x - 1,
709 	    got_locale_is_utf8() ? ACS_VLINE : '|', view->nlines);
710 }
711 
712 int
713 view_needs_focus_indication(struct tog_view *view)
714 {
715 	if (view_is_parent_view(view)) {
716 		if (view->child == NULL || view->child_focussed)
717 			return 0;
718 		if (!view_is_splitscreen(view->child))
719 			return 0;
720 	} else if (!view_is_splitscreen(view))
721 		return 0;
722 
723 	return view->focussed;
724 }
725 
726 static const struct got_error *
727 view_loop(struct tog_view *view)
728 {
729 	const struct got_error *err = NULL;
730 	struct tog_view_list_head views;
731 	struct tog_view *new_view, *dead_view, *focus_view, *main_view;
732 	int fast_refresh = 10;
733 	int done = 0, errcode;
734 
735 	errcode = pthread_mutex_lock(&tog_mutex);
736 	if (errcode)
737 		return got_error_set_errno(errcode, "pthread_mutex_lock");
738 
739 	TAILQ_INIT(&views);
740 	TAILQ_INSERT_HEAD(&views, view, entry);
741 
742 	main_view = view;
743 	view->focussed = 1;
744 	err = view->show(view);
745 	if (err)
746 		return err;
747 	update_panels();
748 	doupdate();
749 	while (!TAILQ_EMPTY(&views) && !done) {
750 		/* Refresh fast during initialization, then become slower. */
751 		if (fast_refresh && fast_refresh-- == 0)
752 			halfdelay(10); /* switch to once per second */
753 
754 		err = view_input(&new_view, &dead_view, &focus_view, &done,
755 		    view, &views);
756 		if (err)
757 			break;
758 		if (dead_view) {
759 			struct tog_view *prev = NULL;
760 
761 			if (view_is_parent_view(dead_view))
762 				prev = TAILQ_PREV(dead_view,
763 				    tog_view_list_head, entry);
764 			else if (view->parent != dead_view)
765 				prev = view->parent;
766 
767 			if (dead_view->parent)
768 				dead_view->parent->child = NULL;
769 			else
770 				TAILQ_REMOVE(&views, dead_view, entry);
771 
772 			err = view_close(dead_view);
773 			if (err || (dead_view == main_view && new_view == NULL))
774 				goto done;
775 
776 			if (view == dead_view) {
777 				if (focus_view)
778 					view = focus_view;
779 				else if (prev)
780 					view = prev;
781 				else if (!TAILQ_EMPTY(&views))
782 					view = TAILQ_LAST(&views,
783 					    tog_view_list_head);
784 				else
785 					view = NULL;
786 				if (view) {
787 					if (view->child && view->child_focussed)
788 						focus_view = view->child;
789 					else
790 						focus_view = view;
791 				}
792 			}
793 		}
794 		if (new_view) {
795 			struct tog_view *v, *t;
796 			/* Only allow one parent view per type. */
797 			TAILQ_FOREACH_SAFE(v, &views, entry, t) {
798 				if (v->type != new_view->type)
799 					continue;
800 				TAILQ_REMOVE(&views, v, entry);
801 				err = view_close(v);
802 				if (err)
803 					goto done;
804 				break;
805 			}
806 			TAILQ_INSERT_TAIL(&views, new_view, entry);
807 			view = new_view;
808 			if (focus_view == NULL)
809 				focus_view = new_view;
810 		}
811 		if (focus_view) {
812 			show_panel(focus_view->panel);
813 			if (view)
814 				view->focussed = 0;
815 			focus_view->focussed = 1;
816 			view = focus_view;
817 			if (new_view)
818 				show_panel(new_view->panel);
819 			if (view->child && view_is_splitscreen(view->child))
820 				show_panel(view->child->panel);
821 		}
822 		if (view) {
823 			if (focus_view == NULL) {
824 				view->focussed = 1;
825 				show_panel(view->panel);
826 				if (view->child && view_is_splitscreen(view->child))
827 					show_panel(view->child->panel);
828 				focus_view = view;
829 			}
830 			if (view->parent) {
831 				err = view->parent->show(view->parent);
832 				if (err)
833 					goto done;
834 			}
835 			err = view->show(view);
836 			if (err)
837 				goto done;
838 			if (view->child) {
839 				err = view->child->show(view->child);
840 				if (err)
841 					goto done;
842 			}
843 			update_panels();
844 			doupdate();
845 		}
846 	}
847 done:
848 	while (!TAILQ_EMPTY(&views)) {
849 		view = TAILQ_FIRST(&views);
850 		TAILQ_REMOVE(&views, view, entry);
851 		view_close(view);
852 	}
853 
854 	errcode = pthread_mutex_unlock(&tog_mutex);
855 	if (errcode)
856 		return got_error_set_errno(errcode, "pthread_mutex_unlock");
857 
858 	return err;
859 }
860 
861 __dead static void
862 usage_log(void)
863 {
864 	endwin();
865 	fprintf(stderr,
866 	    "usage: %s log [-c commit] [-r repository-path] [path]\n",
867 	    getprogname());
868 	exit(1);
869 }
870 
871 /* Create newly allocated wide-character string equivalent to a byte string. */
872 static const struct got_error *
873 mbs2ws(wchar_t **ws, size_t *wlen, const char *s)
874 {
875 	char *vis = NULL;
876 	const struct got_error *err = NULL;
877 
878 	*ws = NULL;
879 	*wlen = mbstowcs(NULL, s, 0);
880 	if (*wlen == (size_t)-1) {
881 		int vislen;
882 		if (errno != EILSEQ)
883 			return got_error_from_errno("mbstowcs");
884 
885 		/* byte string invalid in current encoding; try to "fix" it */
886 		err = got_mbsavis(&vis, &vislen, s);
887 		if (err)
888 			return err;
889 		*wlen = mbstowcs(NULL, vis, 0);
890 		if (*wlen == (size_t)-1) {
891 			err = got_error_from_errno("mbstowcs"); /* give up */
892 			goto done;
893 		}
894 	}
895 
896 	*ws = calloc(*wlen + 1, sizeof(*ws));
897 	if (*ws == NULL) {
898 		err = got_error_from_errno("calloc");
899 		goto done;
900 	}
901 
902 	if (mbstowcs(*ws, vis ? vis : s, *wlen) != *wlen)
903 		err = got_error_from_errno("mbstowcs");
904 done:
905 	free(vis);
906 	if (err) {
907 		free(*ws);
908 		*ws = NULL;
909 		*wlen = 0;
910 	}
911 	return err;
912 }
913 
914 /* Format a line for display, ensuring that it won't overflow a width limit. */
915 static const struct got_error *
916 format_line(wchar_t **wlinep, int *widthp, const char *line, int wlimit)
917 {
918 	const struct got_error *err = NULL;
919 	int cols = 0;
920 	wchar_t *wline = NULL;
921 	size_t wlen;
922 	int i;
923 
924 	*wlinep = NULL;
925 	*widthp = 0;
926 
927 	err = mbs2ws(&wline, &wlen, line);
928 	if (err)
929 		return err;
930 
931 	i = 0;
932 	while (i < wlen && cols < wlimit) {
933 		int width = wcwidth(wline[i]);
934 		switch (width) {
935 		case 0:
936 			i++;
937 			break;
938 		case 1:
939 		case 2:
940 			if (cols + width <= wlimit)
941 				cols += width;
942 			i++;
943 			break;
944 		case -1:
945 			if (wline[i] == L'\t')
946 				cols += TABSIZE - ((cols + 1) % TABSIZE);
947 			i++;
948 			break;
949 		default:
950 			err = got_error_from_errno("wcwidth");
951 			goto done;
952 		}
953 	}
954 	wline[i] = L'\0';
955 	if (widthp)
956 		*widthp = cols;
957 done:
958 	if (err)
959 		free(wline);
960 	else
961 		*wlinep = wline;
962 	return err;
963 }
964 
965 static const struct got_error*
966 build_refs_str(char **refs_str, struct got_reflist_head *refs,
967     struct got_object_id *id)
968 {
969 	static const struct got_error *err = NULL;
970 	struct got_reflist_entry *re;
971 	char *s;
972 	const char *name;
973 
974 	*refs_str = NULL;
975 
976 	SIMPLEQ_FOREACH(re, refs, entry) {
977 		if (got_object_id_cmp(re->id, id) != 0)
978 			continue;
979 		name = got_ref_get_name(re->ref);
980 		if (strcmp(name, GOT_REF_HEAD) == 0)
981 			continue;
982 		if (strncmp(name, "refs/", 5) == 0)
983 			name += 5;
984 		if (strncmp(name, "got/", 4) == 0)
985 			continue;
986 		if (strncmp(name, "heads/", 6) == 0)
987 			name += 6;
988 		if (strncmp(name, "remotes/", 8) == 0)
989 			name += 8;
990 		s = *refs_str;
991 		if (asprintf(refs_str, "%s%s%s", s ? s : "",
992 		    s ? ", " : "", name) == -1) {
993 			err = got_error_from_errno("asprintf");
994 			free(s);
995 			*refs_str = NULL;
996 			break;
997 		}
998 		free(s);
999 	}
1000 
1001 	return err;
1002 }
1003 
1004 static const struct got_error *
1005 format_author(wchar_t **wauthor, int *author_width, char *author, int limit)
1006 {
1007 	char *smallerthan, *at;
1008 
1009 	smallerthan = strchr(author, '<');
1010 	if (smallerthan && smallerthan[1] != '\0')
1011 		author = smallerthan + 1;
1012 	at = strchr(author, '@');
1013 	if (at)
1014 		*at = '\0';
1015 	return format_line(wauthor, author_width, author, limit);
1016 }
1017 
1018 static const struct got_error *
1019 draw_commit(struct tog_view *view, struct got_commit_object *commit,
1020     struct got_object_id *id, struct got_reflist_head *refs,
1021     int author_display_cols)
1022 {
1023 	const struct got_error *err = NULL;
1024 	char datebuf[10]; /* YY-MM-DD + SPACE + NUL */
1025 	char *logmsg0 = NULL, *logmsg = NULL;
1026 	char *author = NULL;
1027 	wchar_t *wlogmsg = NULL, *wauthor = NULL;
1028 	int author_width, logmsg_width;
1029 	char *newline, *line = NULL;
1030 	int col, limit;
1031 	static const size_t date_display_cols = 9;
1032 	const int avail = view->ncols;
1033 	struct tm tm;
1034 	time_t committer_time;
1035 
1036 	committer_time = got_object_commit_get_committer_time(commit);
1037 	if (localtime_r(&committer_time, &tm) == NULL)
1038 		return got_error_from_errno("localtime_r");
1039 	if (strftime(datebuf, sizeof(datebuf), "%g/%m/%d ", &tm)
1040 	    >= sizeof(datebuf))
1041 		return got_error(GOT_ERR_NO_SPACE);
1042 
1043 	if (avail < date_display_cols)
1044 		limit = MIN(sizeof(datebuf) - 1, avail);
1045 	else
1046 		limit = MIN(date_display_cols, sizeof(datebuf) - 1);
1047 	waddnstr(view->window, datebuf, limit);
1048 	col = limit + 1;
1049 	if (col > avail)
1050 		goto done;
1051 
1052 	author = strdup(got_object_commit_get_author(commit));
1053 	if (author == NULL) {
1054 		err = got_error_from_errno("strdup");
1055 		goto done;
1056 	}
1057 	err = format_author(&wauthor, &author_width, author, avail - col);
1058 	if (err)
1059 		goto done;
1060 	waddwstr(view->window, wauthor);
1061 	col += author_width;
1062 	while (col <= avail && author_width < author_display_cols + 2) {
1063 		waddch(view->window, ' ');
1064 		col++;
1065 		author_width++;
1066 	}
1067 	if (col > avail)
1068 		goto done;
1069 
1070 	logmsg0 = strdup(got_object_commit_get_logmsg(commit));
1071 	if (logmsg0 == NULL) {
1072 		err = got_error_from_errno("strdup");
1073 		goto done;
1074 	}
1075 	logmsg = logmsg0;
1076 	while (*logmsg == '\n')
1077 		logmsg++;
1078 	newline = strchr(logmsg, '\n');
1079 	if (newline)
1080 		*newline = '\0';
1081 	limit = avail - col;
1082 	err = format_line(&wlogmsg, &logmsg_width, logmsg, limit);
1083 	if (err)
1084 		goto done;
1085 	waddwstr(view->window, wlogmsg);
1086 	col += logmsg_width;
1087 	while (col <= avail) {
1088 		waddch(view->window, ' ');
1089 		col++;
1090 	}
1091 done:
1092 	free(logmsg0);
1093 	free(wlogmsg);
1094 	free(author);
1095 	free(wauthor);
1096 	free(line);
1097 	return err;
1098 }
1099 
1100 static struct commit_queue_entry *
1101 alloc_commit_queue_entry(struct got_commit_object *commit,
1102     struct got_object_id *id)
1103 {
1104 	struct commit_queue_entry *entry;
1105 
1106 	entry = calloc(1, sizeof(*entry));
1107 	if (entry == NULL)
1108 		return NULL;
1109 
1110 	entry->id = id;
1111 	entry->commit = commit;
1112 	return entry;
1113 }
1114 
1115 static void
1116 pop_commit(struct commit_queue *commits)
1117 {
1118 	struct commit_queue_entry *entry;
1119 
1120 	entry = TAILQ_FIRST(&commits->head);
1121 	TAILQ_REMOVE(&commits->head, entry, entry);
1122 	got_object_commit_close(entry->commit);
1123 	commits->ncommits--;
1124 	/* Don't free entry->id! It is owned by the commit graph. */
1125 	free(entry);
1126 }
1127 
1128 static void
1129 free_commits(struct commit_queue *commits)
1130 {
1131 	while (!TAILQ_EMPTY(&commits->head))
1132 		pop_commit(commits);
1133 }
1134 
1135 static const struct got_error *
1136 queue_commits(struct got_commit_graph *graph, struct commit_queue *commits,
1137     int minqueue, struct got_repository *repo, const char *path)
1138 {
1139 	const struct got_error *err = NULL;
1140 	int nqueued = 0;
1141 
1142 	/*
1143 	 * We keep all commits open throughout the lifetime of the log
1144 	 * view in order to avoid having to re-fetch commits from disk
1145 	 * while updating the display.
1146 	 */
1147 	while (nqueued < minqueue) {
1148 		struct got_object_id *id;
1149 		struct got_commit_object *commit;
1150 		struct commit_queue_entry *entry;
1151 		int errcode;
1152 
1153 		err = got_commit_graph_iter_next(&id, graph);
1154 		if (err) {
1155 			if (err->code != GOT_ERR_ITER_NEED_MORE)
1156 				break;
1157 			err = got_commit_graph_fetch_commits(graph,
1158 			    minqueue, repo);
1159 			if (err)
1160 				return err;
1161 			continue;
1162 		}
1163 
1164 		if (id == NULL)
1165 			break;
1166 
1167 		err = got_object_open_as_commit(&commit, repo, id);
1168 		if (err)
1169 			break;
1170 		entry = alloc_commit_queue_entry(commit, id);
1171 		if (entry == NULL) {
1172 			err = got_error_from_errno("alloc_commit_queue_entry");
1173 			break;
1174 		}
1175 
1176 		errcode = pthread_mutex_lock(&tog_mutex);
1177 		if (errcode) {
1178 			err = got_error_set_errno(errcode, "pthread_mutex_lock");
1179 			break;
1180 		}
1181 
1182 		entry->idx = commits->ncommits;
1183 		TAILQ_INSERT_TAIL(&commits->head, entry, entry);
1184 		nqueued++;
1185 		commits->ncommits++;
1186 
1187 		errcode = pthread_mutex_unlock(&tog_mutex);
1188 		if (errcode && err == NULL)
1189 			err = got_error_set_errno(errcode,
1190 			    "pthread_mutex_unlock");
1191 	}
1192 
1193 	return err;
1194 }
1195 
1196 static const struct got_error *
1197 get_head_commit_id(struct got_object_id **head_id, const char *branch_name,
1198     struct got_repository *repo)
1199 {
1200 	const struct got_error *err = NULL;
1201 	struct got_reference *head_ref;
1202 
1203 	*head_id = NULL;
1204 
1205 	err = got_ref_open(&head_ref, repo, branch_name, 0);
1206 	if (err)
1207 		return err;
1208 
1209 	err = got_ref_resolve(head_id, repo, head_ref);
1210 	got_ref_close(head_ref);
1211 	if (err) {
1212 		*head_id = NULL;
1213 		return err;
1214 	}
1215 
1216 	return NULL;
1217 }
1218 
1219 static const struct got_error *
1220 draw_commits(struct tog_view *view, struct commit_queue_entry **last,
1221     struct commit_queue_entry **selected, struct commit_queue_entry *first,
1222     struct commit_queue *commits, int selected_idx, int limit,
1223     struct got_reflist_head *refs, const char *path, int commits_needed)
1224 {
1225 	const struct got_error *err = NULL;
1226 	struct commit_queue_entry *entry;
1227 	int width;
1228 	int ncommits, author_cols = 10;
1229 	char *id_str = NULL, *header = NULL, *ncommits_str = NULL;
1230 	char *refs_str = NULL;
1231 	wchar_t *wline;
1232 
1233 	entry = first;
1234 	ncommits = 0;
1235 	while (entry) {
1236 		if (ncommits == selected_idx) {
1237 			*selected = entry;
1238 			break;
1239 		}
1240 		entry = TAILQ_NEXT(entry, entry);
1241 		ncommits++;
1242 	}
1243 
1244 	if (*selected && !(view->searching && view->search_next_done == 0)) {
1245 		err = got_object_id_str(&id_str, (*selected)->id);
1246 		if (err)
1247 			return err;
1248 		if (refs) {
1249 			err = build_refs_str(&refs_str, refs, (*selected)->id);
1250 			if (err)
1251 				goto done;
1252 		}
1253 	}
1254 
1255 	if (commits_needed == 0)
1256 		halfdelay(10); /* disable fast refresh */
1257 
1258 	if (asprintf(&ncommits_str, " [%d/%d] %s",
1259 	    entry ? entry->idx + 1 : 0, commits->ncommits,
1260 	    commits_needed > 0 ?
1261 	    (view->searching && view->search_next_done == 0
1262 	    ? "searching..." : "loading... ") :
1263 	    (refs_str ? refs_str : "")) == -1) {
1264 		err = got_error_from_errno("asprintf");
1265 		goto done;
1266 	}
1267 
1268 	if (path && strcmp(path, "/") != 0) {
1269 		if (asprintf(&header, "commit %s %s%s",
1270 		    id_str ? id_str : "........................................",
1271 		    path, ncommits_str) == -1) {
1272 			err = got_error_from_errno("asprintf");
1273 			header = NULL;
1274 			goto done;
1275 		}
1276 	} else if (asprintf(&header, "commit %s%s",
1277 	    id_str ? id_str : "........................................",
1278 	    ncommits_str) == -1) {
1279 		err = got_error_from_errno("asprintf");
1280 		header = NULL;
1281 		goto done;
1282 	}
1283 	err = format_line(&wline, &width, header, view->ncols);
1284 	if (err)
1285 		goto done;
1286 
1287 	werase(view->window);
1288 
1289 	if (view_needs_focus_indication(view))
1290 		wstandout(view->window);
1291 	waddwstr(view->window, wline);
1292 	while (width < view->ncols) {
1293 		waddch(view->window, ' ');
1294 		width++;
1295 	}
1296 	if (view_needs_focus_indication(view))
1297 		wstandend(view->window);
1298 	free(wline);
1299 	if (limit <= 1)
1300 		goto done;
1301 
1302 	/* Grow author column size if necessary. */
1303 	entry = first;
1304 	ncommits = 0;
1305 	while (entry) {
1306 		char *author;
1307 		wchar_t *wauthor;
1308 		int width;
1309 		if (ncommits >= limit - 1)
1310 			break;
1311 		author = strdup(got_object_commit_get_author(entry->commit));
1312 		if (author == NULL) {
1313 			err = got_error_from_errno("strdup");
1314 			goto done;
1315 		}
1316 		err = format_author(&wauthor, &width, author, COLS);
1317 		if (author_cols < width)
1318 			author_cols = width;
1319 		free(wauthor);
1320 		free(author);
1321 		entry = TAILQ_NEXT(entry, entry);
1322 	}
1323 
1324 	entry = first;
1325 	*last = first;
1326 	ncommits = 0;
1327 	while (entry) {
1328 		if (ncommits >= limit - 1)
1329 			break;
1330 		if (ncommits == selected_idx)
1331 			wstandout(view->window);
1332 		err = draw_commit(view, entry->commit, entry->id, refs,
1333 		    author_cols);
1334 		if (ncommits == selected_idx)
1335 			wstandend(view->window);
1336 		if (err)
1337 			goto done;
1338 		ncommits++;
1339 		*last = entry;
1340 		entry = TAILQ_NEXT(entry, entry);
1341 	}
1342 
1343 	view_vborder(view);
1344 done:
1345 	free(id_str);
1346 	free(refs_str);
1347 	free(ncommits_str);
1348 	free(header);
1349 	return err;
1350 }
1351 
1352 static void
1353 scroll_up(struct tog_view *view,
1354     struct commit_queue_entry **first_displayed_entry, int maxscroll,
1355     struct commit_queue *commits)
1356 {
1357 	struct commit_queue_entry *entry;
1358 	int nscrolled = 0;
1359 
1360 	entry = TAILQ_FIRST(&commits->head);
1361 	if (*first_displayed_entry == entry)
1362 		return;
1363 
1364 	entry = *first_displayed_entry;
1365 	while (entry && nscrolled < maxscroll) {
1366 		entry = TAILQ_PREV(entry, commit_queue_head, entry);
1367 		if (entry) {
1368 			*first_displayed_entry = entry;
1369 			nscrolled++;
1370 		}
1371 	}
1372 }
1373 
1374 static const struct got_error *
1375 trigger_log_thread(int load_all, int *commits_needed, int *log_complete,
1376     pthread_cond_t *need_commits)
1377 {
1378 	int errcode;
1379 	int max_wait = 20;
1380 
1381 	halfdelay(1); /* fast refresh while loading commits */
1382 
1383 	while (*commits_needed > 0) {
1384 		if (*log_complete)
1385 			break;
1386 
1387 		/* Wake the log thread. */
1388 		errcode = pthread_cond_signal(need_commits);
1389 		if (errcode)
1390 			return got_error_set_errno(errcode,
1391 			    "pthread_cond_signal");
1392 		errcode = pthread_mutex_unlock(&tog_mutex);
1393 		if (errcode)
1394 			return got_error_set_errno(errcode,
1395 			    "pthread_mutex_unlock");
1396 		pthread_yield();
1397 		errcode = pthread_mutex_lock(&tog_mutex);
1398 		if (errcode)
1399 			return got_error_set_errno(errcode,
1400 			    "pthread_mutex_lock");
1401 
1402 		if (*commits_needed > 0 && (!load_all || --max_wait <= 0)) {
1403 			/*
1404 			 * Thread is not done yet; lose a key press
1405 			 * and let the user retry... this way the GUI
1406 			 * remains interactive while logging deep paths
1407 			 * with few commits in history.
1408 			 */
1409 			return NULL;
1410 		}
1411 	}
1412 
1413 	return NULL;
1414 }
1415 
1416 static const struct got_error *
1417 scroll_down(struct tog_view *view,
1418     struct commit_queue_entry **first_displayed_entry, int maxscroll,
1419     struct commit_queue_entry **last_displayed_entry,
1420     struct commit_queue *commits, int *log_complete, int *commits_needed,
1421     pthread_cond_t *need_commits)
1422 {
1423 	const struct got_error *err = NULL;
1424 	struct commit_queue_entry *pentry;
1425 	int nscrolled = 0;
1426 
1427 	if (*last_displayed_entry == NULL)
1428 		return NULL;
1429 
1430 	pentry = TAILQ_NEXT(*last_displayed_entry, entry);
1431 	if (pentry == NULL && !*log_complete) {
1432 		/*
1433 		 * Ask the log thread for required amount of commits
1434 		 * plus some amount of pre-fetching.
1435 		 */
1436 		(*commits_needed) += maxscroll + 20;
1437 		err = trigger_log_thread(0, commits_needed, log_complete,
1438 		    need_commits);
1439 		if (err)
1440 			return err;
1441 	}
1442 
1443 	do {
1444 		pentry = TAILQ_NEXT(*last_displayed_entry, entry);
1445 		if (pentry == NULL)
1446 			break;
1447 
1448 		*last_displayed_entry = pentry;
1449 
1450 		pentry = TAILQ_NEXT(*first_displayed_entry, entry);
1451 		if (pentry == NULL)
1452 			break;
1453 		*first_displayed_entry = pentry;
1454 	} while (++nscrolled < maxscroll);
1455 
1456 	return err;
1457 }
1458 
1459 static const struct got_error *
1460 open_diff_view_for_commit(struct tog_view **new_view, int begin_x,
1461     struct got_commit_object *commit, struct got_object_id *commit_id,
1462     struct tog_view *log_view, struct got_reflist_head *refs,
1463     struct got_repository *repo)
1464 {
1465 	const struct got_error *err;
1466 	struct got_object_qid *parent_id;
1467 	struct tog_view *diff_view;
1468 
1469 	diff_view = view_open(0, 0, 0, begin_x, TOG_VIEW_DIFF);
1470 	if (diff_view == NULL)
1471 		return got_error_from_errno("view_open");
1472 
1473 	parent_id = SIMPLEQ_FIRST(got_object_commit_get_parent_ids(commit));
1474 	err = open_diff_view(diff_view, parent_id ? parent_id->id : NULL,
1475 	    commit_id, log_view, refs, repo);
1476 	if (err == NULL)
1477 		*new_view = diff_view;
1478 	return err;
1479 }
1480 
1481 static const struct got_error *
1482 tree_view_visit_subtree(struct got_tree_object *subtree,
1483     struct tog_tree_view_state *s)
1484 {
1485 	struct tog_parent_tree *parent;
1486 
1487 	parent = calloc(1, sizeof(*parent));
1488 	if (parent == NULL)
1489 		return got_error_from_errno("calloc");
1490 
1491 	parent->tree = s->tree;
1492 	parent->first_displayed_entry = s->first_displayed_entry;
1493 	parent->selected_entry = s->selected_entry;
1494 	parent->selected = s->selected;
1495 	TAILQ_INSERT_HEAD(&s->parents, parent, entry);
1496 	s->tree = subtree;
1497 	s->entries = got_object_tree_get_entries(s->tree);
1498 	s->selected = 0;
1499 	s->first_displayed_entry = NULL;
1500 	return NULL;
1501 }
1502 
1503 
1504 static const struct got_error *
1505 browse_commit_tree(struct tog_view **new_view, int begin_x,
1506     struct commit_queue_entry *entry, const char *path,
1507     struct got_reflist_head *refs, struct got_repository *repo)
1508 {
1509 	const struct got_error *err = NULL;
1510 	struct got_tree_object *tree;
1511 	struct got_tree_entry *te;
1512 	struct tog_tree_view_state *s;
1513 	struct tog_view *tree_view;
1514 	char *slash, *subpath = NULL;
1515 	const char *p;
1516 
1517 	err = got_object_open_as_tree(&tree, repo,
1518 	    got_object_commit_get_tree_id(entry->commit));
1519 	if (err)
1520 		return err;
1521 
1522 	tree_view = view_open(0, 0, 0, begin_x, TOG_VIEW_TREE);
1523 	if (tree_view == NULL)
1524 		return got_error_from_errno("view_open");
1525 
1526 	err = open_tree_view(tree_view, tree, entry->id, refs, repo);
1527 	if (err) {
1528 		got_object_tree_close(tree);
1529 		return err;
1530 	}
1531 	s = &tree_view->state.tree;
1532 
1533 	*new_view = tree_view;
1534 
1535 	/* Walk the path and open corresponding tree objects. */
1536 	p = path;
1537 	while (*p) {
1538 		struct got_object_id *tree_id;
1539 
1540 		while (p[0] == '/')
1541 			p++;
1542 
1543 		/* Ensure the correct subtree entry is selected. */
1544 		slash = strchr(p, '/');
1545 		if (slash == NULL)
1546 			slash = strchr(p, '\0');
1547 		SIMPLEQ_FOREACH(te, &s->entries->head, entry) {
1548 			if (strncmp(p, te->name, slash - p) == 0) {
1549 				s->selected_entry = te;
1550 				break;
1551 			}
1552 			s->selected++;
1553 		}
1554 		if (s->selected_entry == NULL) {
1555 			err = got_error(GOT_ERR_NO_TREE_ENTRY);
1556 			break;
1557 		}
1558 		if (s->tree != s->root)
1559 			s->selected++; /* skip '..' */
1560 
1561 		if (!S_ISDIR(s->selected_entry->mode)) {
1562 			/* Jump to this file's entry. */
1563 			s->first_displayed_entry = s->selected_entry;
1564 			s->selected = 0;
1565 			break;
1566 		}
1567 
1568 		slash = strchr(p, '/');
1569 		if (slash)
1570 			subpath = strndup(path, slash - path);
1571 		else
1572 			subpath = strdup(path);
1573 		if (subpath == NULL) {
1574 			err = got_error_from_errno("strdup");
1575 			break;
1576 		}
1577 
1578 		err = got_object_id_by_path(&tree_id, repo, entry->id,
1579 		    subpath);
1580 		if (err)
1581 			break;
1582 
1583 		err = got_object_open_as_tree(&tree, repo, tree_id);
1584 		free(tree_id);
1585 		if (err)
1586 			break;
1587 
1588 		err = tree_view_visit_subtree(tree, s);
1589 		if (err) {
1590 			got_object_tree_close(tree);
1591 			break;
1592 		}
1593 		if (slash == NULL)
1594 			break;
1595 		free(subpath);
1596 		subpath = NULL;
1597 		p = slash;
1598 	}
1599 
1600 	free(subpath);
1601 	return err;
1602 }
1603 
1604 static void *
1605 log_thread(void *arg)
1606 {
1607 	const struct got_error *err = NULL;
1608 	int errcode = 0;
1609 	struct tog_log_thread_args *a = arg;
1610 	int done = 0;
1611 
1612 	err = got_commit_graph_iter_start(a->graph, a->start_id, a->repo);
1613 	if (err)
1614 		return (void *)err;
1615 
1616 	while (!done && !err) {
1617 		err = queue_commits(a->graph, a->commits, 1, a->repo,
1618 		    a->in_repo_path);
1619 		if (err) {
1620 			if (err->code != GOT_ERR_ITER_COMPLETED)
1621 				return (void *)err;
1622 			err = NULL;
1623 			done = 1;
1624 		} else if (a->commits_needed > 0)
1625 			a->commits_needed--;
1626 
1627 		errcode = pthread_mutex_lock(&tog_mutex);
1628 		if (errcode) {
1629 			err = got_error_set_errno(errcode,
1630 			    "pthread_mutex_lock");
1631 			break;
1632 		} else if (*a->quit)
1633 			done = 1;
1634 		else if (*a->first_displayed_entry == NULL) {
1635 			*a->first_displayed_entry =
1636 			    TAILQ_FIRST(&a->commits->head);
1637 			*a->selected_entry = *a->first_displayed_entry;
1638 		}
1639 
1640 		if (done)
1641 			a->commits_needed = 0;
1642 		else if (a->commits_needed == 0) {
1643 			errcode = pthread_cond_wait(&a->need_commits,
1644 			    &tog_mutex);
1645 			if (errcode)
1646 				err = got_error_set_errno(errcode,
1647 				    "pthread_cond_wait");
1648 		}
1649 
1650 		errcode = pthread_mutex_unlock(&tog_mutex);
1651 		if (errcode && err == NULL)
1652 			err = got_error_set_errno(errcode,
1653 			    "pthread_mutex_unlock");
1654 	}
1655 	a->log_complete = 1;
1656 	return (void *)err;
1657 }
1658 
1659 static const struct got_error *
1660 stop_log_thread(struct tog_log_view_state *s)
1661 {
1662 	const struct got_error *err = NULL;
1663 	int errcode;
1664 
1665 	if (s->thread) {
1666 		s->quit = 1;
1667 		errcode = pthread_cond_signal(&s->thread_args.need_commits);
1668 		if (errcode)
1669 			return got_error_set_errno(errcode,
1670 			    "pthread_cond_signal");
1671 		errcode = pthread_mutex_unlock(&tog_mutex);
1672 		if (errcode)
1673 			return got_error_set_errno(errcode,
1674 			    "pthread_mutex_unlock");
1675 		errcode = pthread_join(s->thread, (void **)&err);
1676 		if (errcode)
1677 			return got_error_set_errno(errcode, "pthread_join");
1678 		errcode = pthread_mutex_lock(&tog_mutex);
1679 		if (errcode)
1680 			return got_error_set_errno(errcode,
1681 			    "pthread_mutex_lock");
1682 		s->thread = NULL;
1683 	}
1684 
1685 	errcode = pthread_cond_destroy(&s->thread_args.need_commits);
1686 	if (errcode && err == NULL)
1687 		err = got_error_set_errno(errcode, "pthread_cond_destroy");
1688 
1689 	if (s->thread_args.repo) {
1690 		got_repo_close(s->thread_args.repo);
1691 		s->thread_args.repo = NULL;
1692 	}
1693 
1694 	if (s->thread_args.graph) {
1695 		got_commit_graph_close(s->thread_args.graph);
1696 		s->thread_args.graph = NULL;
1697 	}
1698 
1699 	return err;
1700 }
1701 
1702 static const struct got_error *
1703 close_log_view(struct tog_view *view)
1704 {
1705 	const struct got_error *err = NULL;
1706 	struct tog_log_view_state *s = &view->state.log;
1707 
1708 	err = stop_log_thread(s);
1709 	free_commits(&s->commits);
1710 	free(s->in_repo_path);
1711 	s->in_repo_path = NULL;
1712 	free(s->start_id);
1713 	s->start_id = NULL;
1714 	return err;
1715 }
1716 
1717 static const struct got_error *
1718 search_start_log_view(struct tog_view *view)
1719 {
1720 	struct tog_log_view_state *s = &view->state.log;
1721 
1722 	s->matched_entry = NULL;
1723 	s->search_entry = NULL;
1724 	return NULL;
1725 }
1726 
1727 static int
1728 match_commit(struct got_commit_object *commit, const char *id_str,
1729     regex_t *regex)
1730 {
1731 	regmatch_t regmatch;
1732 
1733 	if (regexec(regex, got_object_commit_get_author(commit), 1,
1734 	    &regmatch, 0) == 0 ||
1735 	    regexec(regex, got_object_commit_get_committer(commit), 1,
1736 	    &regmatch, 0) == 0 ||
1737 	    regexec(regex, got_object_commit_get_logmsg(commit), 1,
1738 	    &regmatch, 0) == 0 ||
1739 	    regexec(regex, id_str, 1, &regmatch, 0) == 0)
1740 		return 1;
1741 
1742 	return 0;
1743 }
1744 
1745 static const struct got_error *
1746 search_next_log_view(struct tog_view *view)
1747 {
1748 	const struct got_error *err = NULL;
1749 	struct tog_log_view_state *s = &view->state.log;
1750 	struct commit_queue_entry *entry;
1751 
1752 	if (!view->searching) {
1753 		view->search_next_done = 1;
1754 		return NULL;
1755 	}
1756 
1757 	if (s->search_entry) {
1758 		if (view->searching == TOG_SEARCH_FORWARD)
1759 			entry = TAILQ_NEXT(s->search_entry, entry);
1760 		else
1761 			entry = TAILQ_PREV(s->search_entry,
1762 			    commit_queue_head, entry);
1763 	} else if (s->matched_entry) {
1764 		if (view->searching == TOG_SEARCH_FORWARD)
1765 			entry = TAILQ_NEXT(s->selected_entry, entry);
1766 		else
1767 			entry = TAILQ_PREV(s->selected_entry,
1768 			    commit_queue_head, entry);
1769 	} else {
1770 		if (view->searching == TOG_SEARCH_FORWARD)
1771 			entry = TAILQ_FIRST(&s->commits.head);
1772 		else
1773 			entry = TAILQ_LAST(&s->commits.head, commit_queue_head);
1774 	}
1775 
1776 	while (1) {
1777 		char *id_str;
1778 		if (entry == NULL) {
1779 			if (s->thread_args.log_complete ||
1780 			    view->searching == TOG_SEARCH_BACKWARD) {
1781 				view->search_next_done = 1;
1782 				return NULL;
1783 			}
1784 			/*
1785 			 * Poke the log thread for more commits and return,
1786 			 * allowing the main loop to make progress. Search
1787 			 * will resume at s->search_entry once we come back.
1788 			 */
1789 			s->thread_args.commits_needed++;
1790 			return trigger_log_thread(1,
1791 			    &s->thread_args.commits_needed,
1792 			    &s->thread_args.log_complete,
1793 			    &s->thread_args.need_commits);
1794 		}
1795 
1796 		err = got_object_id_str(&id_str, entry->id);
1797 		if (err)
1798 			return err;
1799 
1800 		if (match_commit(entry->commit, id_str, &view->regex)) {
1801 			view->search_next_done = 1;
1802 			s->matched_entry = entry;
1803 			free(id_str);
1804 			break;
1805 		}
1806 		free(id_str);
1807 		s->search_entry = entry;
1808 		if (view->searching == TOG_SEARCH_FORWARD)
1809 			entry = TAILQ_NEXT(entry, entry);
1810 		else
1811 			entry = TAILQ_PREV(entry, commit_queue_head, entry);
1812 	}
1813 
1814 	if (s->matched_entry) {
1815 		int cur = s->selected_entry->idx;
1816 		while (cur < s->matched_entry->idx) {
1817 			err = input_log_view(NULL, NULL, NULL, view, KEY_DOWN);
1818 			if (err)
1819 				return err;
1820 			cur++;
1821 		}
1822 		while (cur > s->matched_entry->idx) {
1823 			err = input_log_view(NULL, NULL, NULL, view, KEY_UP);
1824 			if (err)
1825 				return err;
1826 			cur--;
1827 		}
1828 	}
1829 
1830 	s->search_entry = NULL;
1831 
1832 	return NULL;
1833 }
1834 
1835 static const struct got_error *
1836 open_log_view(struct tog_view *view, struct got_object_id *start_id,
1837     struct got_reflist_head *refs, struct got_repository *repo,
1838     const char *head_ref_name, const char *path, int check_disk)
1839 {
1840 	const struct got_error *err = NULL;
1841 	struct tog_log_view_state *s = &view->state.log;
1842 	struct got_repository *thread_repo = NULL;
1843 	struct got_commit_graph *thread_graph = NULL;
1844 	int errcode;
1845 
1846 	err = got_repo_map_path(&s->in_repo_path, repo, path, check_disk);
1847 	if (err != NULL)
1848 		goto done;
1849 
1850 	/* The commit queue only contains commits being displayed. */
1851 	TAILQ_INIT(&s->commits.head);
1852 	s->commits.ncommits = 0;
1853 
1854 	s->refs = refs;
1855 	s->repo = repo;
1856 	s->head_ref_name = head_ref_name;
1857 	s->start_id = got_object_id_dup(start_id);
1858 	if (s->start_id == NULL) {
1859 		err = got_error_from_errno("got_object_id_dup");
1860 		goto done;
1861 	}
1862 
1863 	view->show = show_log_view;
1864 	view->input = input_log_view;
1865 	view->close = close_log_view;
1866 	view->search_start = search_start_log_view;
1867 	view->search_next = search_next_log_view;
1868 
1869 	err = got_repo_open(&thread_repo, got_repo_get_path(repo));
1870 	if (err)
1871 		goto done;
1872 	err = got_commit_graph_open(&thread_graph, start_id, s->in_repo_path,
1873 	    0, thread_repo);
1874 	if (err)
1875 		goto done;
1876 
1877 	errcode = pthread_cond_init(&s->thread_args.need_commits, NULL);
1878 	if (errcode) {
1879 		err = got_error_set_errno(errcode, "pthread_cond_init");
1880 		goto done;
1881 	}
1882 
1883 	s->thread_args.commits_needed = view->nlines;
1884 	s->thread_args.graph = thread_graph;
1885 	s->thread_args.commits = &s->commits;
1886 	s->thread_args.in_repo_path = s->in_repo_path;
1887 	s->thread_args.start_id = s->start_id;
1888 	s->thread_args.repo = thread_repo;
1889 	s->thread_args.log_complete = 0;
1890 	s->thread_args.quit = &s->quit;
1891 	s->thread_args.view = view;
1892 	s->thread_args.first_displayed_entry = &s->first_displayed_entry;
1893 	s->thread_args.selected_entry = &s->selected_entry;
1894 done:
1895 	if (err)
1896 		close_log_view(view);
1897 	return err;
1898 }
1899 
1900 static const struct got_error *
1901 show_log_view(struct tog_view *view)
1902 {
1903 	struct tog_log_view_state *s = &view->state.log;
1904 
1905 	if (s->thread == NULL) {
1906 		int errcode = pthread_create(&s->thread, NULL, log_thread,
1907 		    &s->thread_args);
1908 		if (errcode)
1909 			return got_error_set_errno(errcode, "pthread_create");
1910 	}
1911 
1912 	return draw_commits(view, &s->last_displayed_entry,
1913 	    &s->selected_entry, s->first_displayed_entry,
1914 	    &s->commits, s->selected, view->nlines, s->refs,
1915 	    s->in_repo_path, s->thread_args.commits_needed);
1916 }
1917 
1918 static const struct got_error *
1919 input_log_view(struct tog_view **new_view, struct tog_view **dead_view,
1920     struct tog_view **focus_view, struct tog_view *view, int ch)
1921 {
1922 	const struct got_error *err = NULL;
1923 	struct tog_log_view_state *s = &view->state.log;
1924 	char *parent_path, *in_repo_path = NULL;
1925 	struct tog_view *diff_view = NULL, *tree_view = NULL, *lv = NULL;
1926 	int begin_x = 0;
1927 	struct got_object_id *start_id;
1928 
1929 	switch (ch) {
1930 	case 'q':
1931 		s->quit = 1;
1932 		break;
1933 	case 'k':
1934 	case KEY_UP:
1935 	case '<':
1936 	case ',':
1937 		if (s->first_displayed_entry == NULL)
1938 			break;
1939 		if (s->selected > 0)
1940 			s->selected--;
1941 		else
1942 			scroll_up(view, &s->first_displayed_entry, 1,
1943 			    &s->commits);
1944 		break;
1945 	case KEY_PPAGE:
1946 	case CTRL('b'):
1947 		if (s->first_displayed_entry == NULL)
1948 			break;
1949 		if (TAILQ_FIRST(&s->commits.head) ==
1950 		    s->first_displayed_entry) {
1951 			s->selected = 0;
1952 			break;
1953 		}
1954 		scroll_up(view, &s->first_displayed_entry,
1955 		    view->nlines, &s->commits);
1956 		break;
1957 	case 'j':
1958 	case KEY_DOWN:
1959 	case '>':
1960 	case '.':
1961 		if (s->first_displayed_entry == NULL)
1962 			break;
1963 		if (s->selected < MIN(view->nlines - 2,
1964 		    s->commits.ncommits - 1)) {
1965 			s->selected++;
1966 			break;
1967 		}
1968 		err = scroll_down(view, &s->first_displayed_entry, 1,
1969 		    &s->last_displayed_entry, &s->commits,
1970 		    &s->thread_args.log_complete,
1971 		    &s->thread_args.commits_needed,
1972 		    &s->thread_args.need_commits);
1973 		break;
1974 	case KEY_NPAGE:
1975 	case CTRL('f'): {
1976 		struct commit_queue_entry *first;
1977 		first = s->first_displayed_entry;
1978 		if (first == NULL)
1979 			break;
1980 		err = scroll_down(view, &s->first_displayed_entry,
1981 		    view->nlines, &s->last_displayed_entry,
1982 		    &s->commits, &s->thread_args.log_complete,
1983 		    &s->thread_args.commits_needed,
1984 		    &s->thread_args.need_commits);
1985 		if (first == s->first_displayed_entry &&
1986 		    s->selected < MIN(view->nlines - 2,
1987 		    s->commits.ncommits - 1)) {
1988 			/* can't scroll further down */
1989 			s->selected = MIN(view->nlines - 2,
1990 			    s->commits.ncommits - 1);
1991 		}
1992 		err = NULL;
1993 		break;
1994 	}
1995 	case KEY_RESIZE:
1996 		if (s->selected > view->nlines - 2)
1997 			s->selected = view->nlines - 2;
1998 		if (s->selected > s->commits.ncommits - 1)
1999 			s->selected = s->commits.ncommits - 1;
2000 		break;
2001 	case KEY_ENTER:
2002 	case ' ':
2003 	case '\r':
2004 		if (s->selected_entry == NULL)
2005 			break;
2006 		if (view_is_parent_view(view))
2007 			begin_x = view_split_begin_x(view->begin_x);
2008 		err = open_diff_view_for_commit(&diff_view, begin_x,
2009 		    s->selected_entry->commit, s->selected_entry->id,
2010 		    view, s->refs, s->repo);
2011 		if (err)
2012 			break;
2013 		if (view_is_parent_view(view)) {
2014 			err = view_close_child(view);
2015 			if (err)
2016 				return err;
2017 			err = view_set_child(view, diff_view);
2018 			if (err) {
2019 				view_close(diff_view);
2020 				break;
2021 			}
2022 			*focus_view = diff_view;
2023 			view->child_focussed = 1;
2024 		} else
2025 			*new_view = diff_view;
2026 		break;
2027 	case 't':
2028 		if (s->selected_entry == NULL)
2029 			break;
2030 		if (view_is_parent_view(view))
2031 			begin_x = view_split_begin_x(view->begin_x);
2032 		err = browse_commit_tree(&tree_view, begin_x,
2033 		    s->selected_entry, s->in_repo_path, s->refs, s->repo);
2034 		if (err)
2035 			break;
2036 		if (view_is_parent_view(view)) {
2037 			err = view_close_child(view);
2038 			if (err)
2039 				return err;
2040 			err = view_set_child(view, tree_view);
2041 			if (err) {
2042 				view_close(tree_view);
2043 				break;
2044 			}
2045 			*focus_view = tree_view;
2046 			view->child_focussed = 1;
2047 		} else
2048 			*new_view = tree_view;
2049 		break;
2050 	case KEY_BACKSPACE:
2051 		if (strcmp(s->in_repo_path, "/") == 0)
2052 			break;
2053 		parent_path = dirname(s->in_repo_path);
2054 		if (parent_path && strcmp(parent_path, ".") != 0) {
2055 			err = stop_log_thread(s);
2056 			if (err)
2057 				return err;
2058 			lv = view_open(view->nlines, view->ncols,
2059 			    view->begin_y, view->begin_x, TOG_VIEW_LOG);
2060 			if (lv == NULL)
2061 				return got_error_from_errno(
2062 				    "view_open");
2063 			err = open_log_view(lv, s->start_id, s->refs,
2064 			    s->repo, s->head_ref_name, parent_path, 0);
2065 			if (err)
2066 				return err;;
2067 			if (view_is_parent_view(view))
2068 				*new_view = lv;
2069 			else {
2070 				view_set_child(view->parent, lv);
2071 				*focus_view = lv;
2072 			}
2073 			return NULL;
2074 		}
2075 		break;
2076 	case CTRL('l'):
2077 		err = stop_log_thread(s);
2078 		if (err)
2079 			return err;
2080 		lv = view_open(view->nlines, view->ncols,
2081 		    view->begin_y, view->begin_x, TOG_VIEW_LOG);
2082 		if (lv == NULL)
2083 			return got_error_from_errno("view_open");
2084 		err = get_head_commit_id(&start_id, s->head_ref_name ?
2085 		    s->head_ref_name : GOT_REF_HEAD, s->repo);
2086 		if (err)
2087 			return err;
2088 		in_repo_path = strdup(s->in_repo_path);
2089 		if (in_repo_path == NULL) {
2090 			free(start_id);
2091 			return got_error_from_errno("strdup");
2092 		}
2093 		err = open_log_view(lv, start_id, s->refs, s->repo,
2094 		    s->head_ref_name, in_repo_path, 0);
2095 		if (err)
2096 			return err;;
2097 		*dead_view = view;
2098 		*new_view = lv;
2099 		break;
2100 	default:
2101 		break;
2102 	}
2103 
2104 	return err;
2105 }
2106 
2107 static const struct got_error *
2108 apply_unveil(const char *repo_path, const char *worktree_path)
2109 {
2110 	const struct got_error *error;
2111 
2112 #ifdef PROFILE
2113 	if (unveil("gmon.out", "rwc") != 0)
2114 		return got_error_from_errno2("unveil", "gmon.out");
2115 #endif
2116 	if (repo_path && unveil(repo_path, "r") != 0)
2117 		return got_error_from_errno2("unveil", repo_path);
2118 
2119 	if (worktree_path && unveil(worktree_path, "rwc") != 0)
2120 		return got_error_from_errno2("unveil", worktree_path);
2121 
2122 	if (unveil("/tmp", "rwc") != 0)
2123 		return got_error_from_errno2("unveil", "/tmp");
2124 
2125 	error = got_privsep_unveil_exec_helpers();
2126 	if (error != NULL)
2127 		return error;
2128 
2129 	if (unveil(NULL, NULL) != 0)
2130 		return got_error_from_errno("unveil");
2131 
2132 	return NULL;
2133 }
2134 
2135 static void
2136 init_curses(void)
2137 {
2138 	initscr();
2139 	cbreak();
2140 	halfdelay(1); /* Do fast refresh while initial view is loading. */
2141 	noecho();
2142 	nonl();
2143 	intrflush(stdscr, FALSE);
2144 	keypad(stdscr, TRUE);
2145 	curs_set(0);
2146 	signal(SIGWINCH, tog_sigwinch);
2147 }
2148 
2149 static const struct got_error *
2150 cmd_log(int argc, char *argv[])
2151 {
2152 	const struct got_error *error;
2153 	struct got_repository *repo = NULL;
2154 	struct got_worktree *worktree = NULL;
2155 	struct got_reflist_head refs;
2156 	struct got_object_id *start_id = NULL;
2157 	char *path = NULL, *repo_path = NULL, *cwd = NULL;
2158 	char *start_commit = NULL;
2159 	int ch;
2160 	struct tog_view *view;
2161 
2162 	SIMPLEQ_INIT(&refs);
2163 
2164 #ifndef PROFILE
2165 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
2166 	    NULL) == -1)
2167 		err(1, "pledge");
2168 #endif
2169 
2170 	while ((ch = getopt(argc, argv, "c:r:")) != -1) {
2171 		switch (ch) {
2172 		case 'c':
2173 			start_commit = optarg;
2174 			break;
2175 		case 'r':
2176 			repo_path = realpath(optarg, NULL);
2177 			if (repo_path == NULL)
2178 				err(1, "-r option");
2179 			break;
2180 		default:
2181 			usage_log();
2182 			/* NOTREACHED */
2183 		}
2184 	}
2185 
2186 	argc -= optind;
2187 	argv += optind;
2188 
2189 	cwd = getcwd(NULL, 0);
2190 	if (cwd == NULL) {
2191 		error = got_error_from_errno("getcwd");
2192 		goto done;
2193 	}
2194 	error = got_worktree_open(&worktree, cwd);
2195 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
2196 		goto done;
2197 	error = NULL;
2198 
2199 	if (argc == 0) {
2200 		path = strdup("");
2201 		if (path == NULL) {
2202 			error = got_error_from_errno("strdup");
2203 			goto done;
2204 		}
2205 	} else if (argc == 1) {
2206 		if (worktree) {
2207 			error = got_worktree_resolve_path(&path, worktree,
2208 			    argv[0]);
2209 			if (error)
2210 				goto done;
2211 		} else {
2212 			path = strdup(argv[0]);
2213 			if (path == NULL) {
2214 				error = got_error_from_errno("strdup");
2215 				goto done;
2216 			}
2217 		}
2218 	} else
2219 		usage_log();
2220 
2221 	repo_path = worktree ?
2222 	    strdup(got_worktree_get_repo_path(worktree)) : strdup(cwd);
2223 	if (repo_path == NULL) {
2224 		error = got_error_from_errno("strdup");
2225 		goto done;
2226 	}
2227 
2228 	init_curses();
2229 
2230 	error = got_repo_open(&repo, repo_path);
2231 	if (error != NULL)
2232 		goto done;
2233 
2234 	error = apply_unveil(got_repo_get_path(repo),
2235 	    worktree ? got_worktree_get_root_path(worktree) : NULL);
2236 	if (error)
2237 		goto done;
2238 
2239 	if (start_commit == NULL)
2240 		error = get_head_commit_id(&start_id, worktree ?
2241 		    got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD,
2242 		    repo);
2243 	else {
2244 		error = get_head_commit_id(&start_id, start_commit, repo);
2245 		if (error) {
2246 			if (error->code != GOT_ERR_NOT_REF)
2247 				goto done;
2248 			error = got_repo_match_object_id_prefix(&start_id,
2249 			    start_commit, GOT_OBJ_TYPE_COMMIT, repo);
2250 		}
2251 	}
2252 	if (error != NULL)
2253 		goto done;
2254 
2255 	error = got_ref_list(&refs, repo);
2256 	if (error)
2257 		goto done;
2258 
2259 	view = view_open(0, 0, 0, 0, TOG_VIEW_LOG);
2260 	if (view == NULL) {
2261 		error = got_error_from_errno("view_open");
2262 		goto done;
2263 	}
2264 	error = open_log_view(view, start_id, &refs, repo, worktree ?
2265 	    got_worktree_get_head_ref_name(worktree) : NULL, path, 1);
2266 	if (error)
2267 		goto done;
2268 	error = view_loop(view);
2269 done:
2270 	free(repo_path);
2271 	free(cwd);
2272 	free(path);
2273 	free(start_id);
2274 	if (repo)
2275 		got_repo_close(repo);
2276 	if (worktree)
2277 		got_worktree_close(worktree);
2278 	got_ref_list_free(&refs);
2279 	return error;
2280 }
2281 
2282 __dead static void
2283 usage_diff(void)
2284 {
2285 	endwin();
2286 	fprintf(stderr, "usage: %s diff [repository-path] object1 object2\n",
2287 	    getprogname());
2288 	exit(1);
2289 }
2290 
2291 static char *
2292 parse_next_line(FILE *f, size_t *len)
2293 {
2294 	char *line;
2295 	size_t linelen;
2296 	size_t lineno;
2297 	const char delim[3] = { '\0', '\0', '\0'};
2298 
2299 	line = fparseln(f, &linelen, &lineno, delim, 0);
2300 	if (len)
2301 		*len = linelen;
2302 	return line;
2303 }
2304 
2305 static const struct got_error *
2306 draw_file(struct tog_view *view, FILE *f, int *first_displayed_line,
2307     int *last_displayed_line, int *eof, int max_lines,
2308     char *header)
2309 {
2310 	const struct got_error *err;
2311 	int nlines = 0, nprinted = 0;
2312 	char *line;
2313 	size_t len;
2314 	wchar_t *wline;
2315 	int width;
2316 
2317 	rewind(f);
2318 	werase(view->window);
2319 
2320 	if (header) {
2321 		err = format_line(&wline, &width, header, view->ncols);
2322 		if (err) {
2323 			return err;
2324 		}
2325 
2326 		if (view_needs_focus_indication(view))
2327 			wstandout(view->window);
2328 		waddwstr(view->window, wline);
2329 		if (view_needs_focus_indication(view))
2330 			wstandend(view->window);
2331 		if (width < view->ncols - 1)
2332 			waddch(view->window, '\n');
2333 
2334 		if (max_lines <= 1)
2335 			return NULL;
2336 		max_lines--;
2337 	}
2338 
2339 	*eof = 0;
2340 	while (nprinted < max_lines) {
2341 		line = parse_next_line(f, &len);
2342 		if (line == NULL) {
2343 			*eof = 1;
2344 			break;
2345 		}
2346 		if (++nlines < *first_displayed_line) {
2347 			free(line);
2348 			continue;
2349 		}
2350 
2351 		err = format_line(&wline, &width, line, view->ncols);
2352 		if (err) {
2353 			free(line);
2354 			return err;
2355 		}
2356 		waddwstr(view->window, wline);
2357 		if (width < view->ncols - 1)
2358 			waddch(view->window, '\n');
2359 		if (++nprinted == 1)
2360 			*first_displayed_line = nlines;
2361 		free(line);
2362 		free(wline);
2363 		wline = NULL;
2364 	}
2365 	*last_displayed_line = nlines;
2366 
2367 	view_vborder(view);
2368 
2369 	if (*eof) {
2370 		while (nprinted < view->nlines) {
2371 			waddch(view->window, '\n');
2372 			nprinted++;
2373 		}
2374 
2375 		err = format_line(&wline, &width, TOG_EOF_STRING, view->ncols);
2376 		if (err) {
2377 			return err;
2378 		}
2379 
2380 		wstandout(view->window);
2381 		waddwstr(view->window, wline);
2382 		wstandend(view->window);
2383 	}
2384 
2385 	return NULL;
2386 }
2387 
2388 static char *
2389 get_datestr(time_t *time, char *datebuf)
2390 {
2391 	char *p, *s = ctime_r(time, datebuf);
2392 	p = strchr(s, '\n');
2393 	if (p)
2394 		*p = '\0';
2395 	return s;
2396 }
2397 
2398 static const struct got_error *
2399 write_commit_info(struct got_object_id *commit_id,
2400     struct got_reflist_head *refs, struct got_repository *repo, FILE *outfile)
2401 {
2402 	const struct got_error *err = NULL;
2403 	char datebuf[26];
2404 	struct got_commit_object *commit;
2405 	char *id_str = NULL;
2406 	time_t committer_time;
2407 	const char *author, *committer;
2408 	char *refs_str = NULL;
2409 
2410 	if (refs) {
2411 		err = build_refs_str(&refs_str, refs, commit_id);
2412 		if (err)
2413 			return err;
2414 	}
2415 
2416 	err = got_object_open_as_commit(&commit, repo, commit_id);
2417 	if (err)
2418 		return err;
2419 
2420 	err = got_object_id_str(&id_str, commit_id);
2421 	if (err) {
2422 		err = got_error_from_errno("got_object_id_str");
2423 		goto done;
2424 	}
2425 
2426 	if (fprintf(outfile, "commit %s%s%s%s\n", id_str, refs_str ? " (" : "",
2427 	    refs_str ? refs_str : "", refs_str ? ")" : "") < 0) {
2428 		err = got_error_from_errno("fprintf");
2429 		goto done;
2430 	}
2431 	if (fprintf(outfile, "from: %s\n",
2432 	    got_object_commit_get_author(commit)) < 0) {
2433 		err = got_error_from_errno("fprintf");
2434 		goto done;
2435 	}
2436 	committer_time = got_object_commit_get_committer_time(commit);
2437 	if (fprintf(outfile, "date: %s UTC\n",
2438 	    get_datestr(&committer_time, datebuf)) < 0) {
2439 		err = got_error_from_errno("fprintf");
2440 		goto done;
2441 	}
2442 	author = got_object_commit_get_author(commit);
2443 	committer = got_object_commit_get_committer(commit);
2444 	if (strcmp(author, committer) != 0 &&
2445 	    fprintf(outfile, "via: %s\n", committer) < 0) {
2446 		err = got_error_from_errno("fprintf");
2447 		goto done;
2448 	}
2449 	if (fprintf(outfile, "%s\n",
2450 	    got_object_commit_get_logmsg(commit)) < 0) {
2451 		err = got_error_from_errno("fprintf");
2452 		goto done;
2453 	}
2454 done:
2455 	free(id_str);
2456 	free(refs_str);
2457 	got_object_commit_close(commit);
2458 	return err;
2459 }
2460 
2461 static const struct got_error *
2462 create_diff(struct tog_diff_view_state *s)
2463 {
2464 	const struct got_error *err = NULL;
2465 	FILE *f = NULL;
2466 	int obj_type;
2467 
2468 	f = got_opentemp();
2469 	if (f == NULL) {
2470 		err = got_error_from_errno("got_opentemp");
2471 		goto done;
2472 	}
2473 	if (s->f && fclose(s->f) != 0) {
2474 		err = got_error_from_errno("fclose");
2475 		goto done;
2476 	}
2477 	s->f = f;
2478 
2479 	if (s->id1)
2480 		err = got_object_get_type(&obj_type, s->repo, s->id1);
2481 	else
2482 		err = got_object_get_type(&obj_type, s->repo, s->id2);
2483 	if (err)
2484 		goto done;
2485 
2486 	switch (obj_type) {
2487 	case GOT_OBJ_TYPE_BLOB:
2488 		err = got_diff_objects_as_blobs(s->id1, s->id2, NULL, NULL,
2489 		    s->diff_context, s->repo, f);
2490 		break;
2491 	case GOT_OBJ_TYPE_TREE:
2492 		err = got_diff_objects_as_trees(s->id1, s->id2, "", "",
2493 		    s->diff_context, s->repo, f);
2494 		break;
2495 	case GOT_OBJ_TYPE_COMMIT: {
2496 		const struct got_object_id_queue *parent_ids;
2497 		struct got_object_qid *pid;
2498 		struct got_commit_object *commit2;
2499 
2500 		err = got_object_open_as_commit(&commit2, s->repo, s->id2);
2501 		if (err)
2502 			break;
2503 		/* Show commit info if we're diffing to a parent/root commit. */
2504 		if (s->id1 == NULL)
2505 			write_commit_info(s->id2, s->refs, s->repo, f);
2506 		else {
2507 			parent_ids = got_object_commit_get_parent_ids(commit2);
2508 			SIMPLEQ_FOREACH(pid, parent_ids, entry) {
2509 				if (got_object_id_cmp(s->id1, pid->id) == 0) {
2510 					write_commit_info(s->id2, s->refs,
2511 					    s->repo, f);
2512 					break;
2513 				}
2514 			}
2515 		}
2516 		got_object_commit_close(commit2);
2517 
2518 		err = got_diff_objects_as_commits(s->id1, s->id2,
2519 		    s->diff_context, s->repo, f);
2520 		break;
2521 	}
2522 	default:
2523 		err = got_error(GOT_ERR_OBJ_TYPE);
2524 		break;
2525 	}
2526 done:
2527 	if (f && fflush(f) != 0 && err == NULL)
2528 		err = got_error_from_errno("fflush");
2529 	return err;
2530 }
2531 
2532 static void
2533 diff_view_indicate_progress(struct tog_view *view)
2534 {
2535 	mvwaddstr(view->window, 0, 0, "diffing...");
2536 	update_panels();
2537 	doupdate();
2538 }
2539 
2540 static const struct got_error *
2541 open_diff_view(struct tog_view *view, struct got_object_id *id1,
2542     struct got_object_id *id2, struct tog_view *log_view,
2543     struct got_reflist_head *refs, struct got_repository *repo)
2544 {
2545 	const struct got_error *err;
2546 
2547 	if (id1 != NULL && id2 != NULL) {
2548 	    int type1, type2;
2549 	    err = got_object_get_type(&type1, repo, id1);
2550 	    if (err)
2551 		return err;
2552 	    err = got_object_get_type(&type2, repo, id2);
2553 	    if (err)
2554 		return err;
2555 
2556 	    if (type1 != type2)
2557 		return got_error(GOT_ERR_OBJ_TYPE);
2558 	}
2559 
2560 	if (id1) {
2561 		view->state.diff.id1 = got_object_id_dup(id1);
2562 		if (view->state.diff.id1 == NULL)
2563 			return got_error_from_errno("got_object_id_dup");
2564 	} else
2565 		view->state.diff.id1 = NULL;
2566 
2567 	view->state.diff.id2 = got_object_id_dup(id2);
2568 	if (view->state.diff.id2 == NULL) {
2569 		free(view->state.diff.id1);
2570 		view->state.diff.id1 = NULL;
2571 		return got_error_from_errno("got_object_id_dup");
2572 	}
2573 	view->state.diff.f = NULL;
2574 	view->state.diff.first_displayed_line = 1;
2575 	view->state.diff.last_displayed_line = view->nlines;
2576 	view->state.diff.diff_context = 3;
2577 	view->state.diff.log_view = log_view;
2578 	view->state.diff.repo = repo;
2579 	view->state.diff.refs = refs;
2580 
2581 	if (log_view && view_is_splitscreen(view))
2582 		show_log_view(log_view); /* draw vborder */
2583 	diff_view_indicate_progress(view);
2584 
2585 	err = create_diff(&view->state.diff);
2586 	if (err) {
2587 		free(view->state.diff.id1);
2588 		view->state.diff.id1 = NULL;
2589 		free(view->state.diff.id2);
2590 		view->state.diff.id2 = NULL;
2591 		return err;
2592 	}
2593 
2594 	view->show = show_diff_view;
2595 	view->input = input_diff_view;
2596 	view->close = close_diff_view;
2597 
2598 	return NULL;
2599 }
2600 
2601 static const struct got_error *
2602 close_diff_view(struct tog_view *view)
2603 {
2604 	const struct got_error *err = NULL;
2605 
2606 	free(view->state.diff.id1);
2607 	view->state.diff.id1 = NULL;
2608 	free(view->state.diff.id2);
2609 	view->state.diff.id2 = NULL;
2610 	if (view->state.diff.f && fclose(view->state.diff.f) == EOF)
2611 		err = got_error_from_errno("fclose");
2612 	return err;
2613 }
2614 
2615 static const struct got_error *
2616 show_diff_view(struct tog_view *view)
2617 {
2618 	const struct got_error *err;
2619 	struct tog_diff_view_state *s = &view->state.diff;
2620 	char *id_str1 = NULL, *id_str2, *header;
2621 
2622 	if (s->id1) {
2623 		err = got_object_id_str(&id_str1, s->id1);
2624 		if (err)
2625 			return err;
2626 	}
2627 	err = got_object_id_str(&id_str2, s->id2);
2628 	if (err)
2629 		return err;
2630 
2631 	if (asprintf(&header, "diff %s %s",
2632 	    id_str1 ? id_str1 : "/dev/null", id_str2) == -1) {
2633 		err = got_error_from_errno("asprintf");
2634 		free(id_str1);
2635 		free(id_str2);
2636 		return err;
2637 	}
2638 	free(id_str1);
2639 	free(id_str2);
2640 
2641 	return draw_file(view, s->f, &s->first_displayed_line,
2642 	    &s->last_displayed_line, &s->eof, view->nlines,
2643 	    header);
2644 }
2645 
2646 static const struct got_error *
2647 set_selected_commit(struct tog_diff_view_state *s,
2648     struct commit_queue_entry *entry)
2649 {
2650 	const struct got_error *err;
2651 	const struct got_object_id_queue *parent_ids;
2652 	struct got_commit_object *selected_commit;
2653 	struct got_object_qid *pid;
2654 
2655 	free(s->id2);
2656 	s->id2 = got_object_id_dup(entry->id);
2657 	if (s->id2 == NULL)
2658 		return got_error_from_errno("got_object_id_dup");
2659 
2660 	err = got_object_open_as_commit(&selected_commit, s->repo, entry->id);
2661 	if (err)
2662 		return err;
2663 	parent_ids = got_object_commit_get_parent_ids(selected_commit);
2664 	free(s->id1);
2665 	pid = SIMPLEQ_FIRST(parent_ids);
2666 	s->id1 = pid ? got_object_id_dup(pid->id) : NULL;
2667 	got_object_commit_close(selected_commit);
2668 	return NULL;
2669 }
2670 
2671 static const struct got_error *
2672 input_diff_view(struct tog_view **new_view, struct tog_view **dead_view,
2673     struct tog_view **focus_view, struct tog_view *view, int ch)
2674 {
2675 	const struct got_error *err = NULL;
2676 	struct tog_diff_view_state *s = &view->state.diff;
2677 	struct tog_log_view_state *ls;
2678 	struct commit_queue_entry *entry;
2679 	int i;
2680 
2681 	switch (ch) {
2682 	case 'k':
2683 	case KEY_UP:
2684 		if (s->first_displayed_line > 1)
2685 			s->first_displayed_line--;
2686 		break;
2687 	case KEY_PPAGE:
2688 	case CTRL('b'):
2689 		if (s->first_displayed_line == 1)
2690 			break;
2691 		i = 0;
2692 		while (i++ < view->nlines - 1 &&
2693 		    s->first_displayed_line > 1)
2694 			s->first_displayed_line--;
2695 		break;
2696 	case 'j':
2697 	case KEY_DOWN:
2698 		if (!s->eof)
2699 			s->first_displayed_line++;
2700 		break;
2701 	case KEY_NPAGE:
2702 	case CTRL('f'):
2703 	case ' ':
2704 		if (s->eof)
2705 			break;
2706 		i = 0;
2707 		while (!s->eof && i++ < view->nlines - 1) {
2708 			char *line;
2709 			line = parse_next_line(s->f, NULL);
2710 			s->first_displayed_line++;
2711 			if (line == NULL)
2712 				break;
2713 		}
2714 		break;
2715 	case '[':
2716 		if (s->diff_context > 0) {
2717 			s->diff_context--;
2718 			diff_view_indicate_progress(view);
2719 			err = create_diff(s);
2720 		}
2721 		break;
2722 	case ']':
2723 		if (s->diff_context < GOT_DIFF_MAX_CONTEXT) {
2724 			s->diff_context++;
2725 			diff_view_indicate_progress(view);
2726 			err = create_diff(s);
2727 		}
2728 		break;
2729 	case '<':
2730 	case ',':
2731 		if (s->log_view == NULL)
2732 			break;
2733 		ls = &s->log_view->state.log;
2734 		entry = TAILQ_PREV(ls->selected_entry,
2735 		    commit_queue_head, entry);
2736 		if (entry == NULL)
2737 			break;
2738 
2739 		err = input_log_view(NULL, NULL, NULL, s->log_view,
2740 		    KEY_UP);
2741 		if (err)
2742 			break;
2743 
2744 		err = set_selected_commit(s, entry);
2745 		if (err)
2746 			break;
2747 
2748 		s->first_displayed_line = 1;
2749 		s->last_displayed_line = view->nlines;
2750 
2751 		diff_view_indicate_progress(view);
2752 		err = create_diff(s);
2753 		break;
2754 	case '>':
2755 	case '.':
2756 		if (s->log_view == NULL)
2757 			break;
2758 		ls = &s->log_view->state.log;
2759 
2760 		if (TAILQ_NEXT(ls->selected_entry, entry) == NULL) {
2761 			ls->thread_args.commits_needed++;
2762 
2763 			/* Display "loading..." in log view. */
2764 			show_log_view(s->log_view);
2765 			update_panels();
2766 			doupdate();
2767 
2768 			err = trigger_log_thread(1 /* load_all */,
2769 			    &ls->thread_args.commits_needed,
2770 			    &ls->thread_args.log_complete,
2771 			    &ls->thread_args.need_commits);
2772 			if (err)
2773 				break;
2774 		}
2775 		err = input_log_view(NULL, NULL, NULL, s->log_view,
2776 		    KEY_DOWN);
2777 		if (err)
2778 			break;
2779 
2780 		entry = TAILQ_NEXT(ls->selected_entry, entry);
2781 		if (entry == NULL)
2782 			break;
2783 
2784 		err = set_selected_commit(s, entry);
2785 		if (err)
2786 			break;
2787 
2788 		s->first_displayed_line = 1;
2789 		s->last_displayed_line = view->nlines;
2790 
2791 		diff_view_indicate_progress(view);
2792 		err = create_diff(s);
2793 		break;
2794 	default:
2795 		break;
2796 	}
2797 
2798 	return err;
2799 }
2800 
2801 static const struct got_error *
2802 cmd_diff(int argc, char *argv[])
2803 {
2804 	const struct got_error *error = NULL;
2805 	struct got_repository *repo = NULL;
2806 	struct got_reflist_head refs;
2807 	struct got_object_id *id1 = NULL, *id2 = NULL;
2808 	char *repo_path = NULL;
2809 	char *id_str1 = NULL, *id_str2 = NULL;
2810 	int ch;
2811 	struct tog_view *view;
2812 
2813 	SIMPLEQ_INIT(&refs);
2814 
2815 #ifndef PROFILE
2816 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
2817 	    NULL) == -1)
2818 		err(1, "pledge");
2819 #endif
2820 
2821 	while ((ch = getopt(argc, argv, "")) != -1) {
2822 		switch (ch) {
2823 		default:
2824 			usage_diff();
2825 			/* NOTREACHED */
2826 		}
2827 	}
2828 
2829 	argc -= optind;
2830 	argv += optind;
2831 
2832 	if (argc == 0) {
2833 		usage_diff(); /* TODO show local worktree changes */
2834 	} else if (argc == 2) {
2835 		repo_path = getcwd(NULL, 0);
2836 		if (repo_path == NULL)
2837 			return got_error_from_errno("getcwd");
2838 		id_str1 = argv[0];
2839 		id_str2 = argv[1];
2840 	} else if (argc == 3) {
2841 		repo_path = realpath(argv[0], NULL);
2842 		if (repo_path == NULL)
2843 			return got_error_from_errno2("realpath", argv[0]);
2844 		id_str1 = argv[1];
2845 		id_str2 = argv[2];
2846 	} else
2847 		usage_diff();
2848 
2849 	init_curses();
2850 
2851 	error = got_repo_open(&repo, repo_path);
2852 	if (error)
2853 		goto done;
2854 
2855 	error = apply_unveil(got_repo_get_path(repo), NULL);
2856 	if (error)
2857 		goto done;
2858 
2859 	error = got_repo_match_object_id_prefix(&id1, id_str1,
2860 	    GOT_OBJ_TYPE_ANY, repo);
2861 	if (error)
2862 		goto done;
2863 
2864 	error = got_repo_match_object_id_prefix(&id2, id_str2,
2865 	    GOT_OBJ_TYPE_ANY, repo);
2866 	if (error)
2867 		goto done;
2868 
2869 	error = got_ref_list(&refs, repo);
2870 	if (error)
2871 		goto done;
2872 
2873 	view = view_open(0, 0, 0, 0, TOG_VIEW_DIFF);
2874 	if (view == NULL) {
2875 		error = got_error_from_errno("view_open");
2876 		goto done;
2877 	}
2878 	error = open_diff_view(view, id1, id2, NULL, &refs, repo);
2879 	if (error)
2880 		goto done;
2881 	error = view_loop(view);
2882 done:
2883 	free(repo_path);
2884 	if (repo)
2885 		got_repo_close(repo);
2886 	got_ref_list_free(&refs);
2887 	return error;
2888 }
2889 
2890 __dead static void
2891 usage_blame(void)
2892 {
2893 	endwin();
2894 	fprintf(stderr, "usage: %s blame [-c commit] [-r repository-path] path\n",
2895 	    getprogname());
2896 	exit(1);
2897 }
2898 
2899 struct tog_blame_line {
2900 	int annotated;
2901 	struct got_object_id *id;
2902 };
2903 
2904 static const struct got_error *
2905 draw_blame(struct tog_view *view, struct got_object_id *id, FILE *f,
2906     const char *path, struct tog_blame_line *lines, int nlines,
2907     int blame_complete, int selected_line, int *first_displayed_line,
2908     int *last_displayed_line, int *eof, int max_lines)
2909 {
2910 	const struct got_error *err;
2911 	int lineno = 0, nprinted = 0;
2912 	char *line;
2913 	size_t len;
2914 	wchar_t *wline;
2915 	int width, wlimit;
2916 	struct tog_blame_line *blame_line;
2917 	struct got_object_id *prev_id = NULL;
2918 	char *id_str;
2919 
2920 	err = got_object_id_str(&id_str, id);
2921 	if (err)
2922 		return err;
2923 
2924 	rewind(f);
2925 	werase(view->window);
2926 
2927 	if (asprintf(&line, "commit %s", id_str) == -1) {
2928 		err = got_error_from_errno("asprintf");
2929 		free(id_str);
2930 		return err;
2931 	}
2932 
2933 	err = format_line(&wline, &width, line, view->ncols);
2934 	free(line);
2935 	line = NULL;
2936 	if (view_needs_focus_indication(view))
2937 		wstandout(view->window);
2938 	waddwstr(view->window, wline);
2939 	if (view_needs_focus_indication(view))
2940 		wstandend(view->window);
2941 	free(wline);
2942 	wline = NULL;
2943 	if (width < view->ncols - 1)
2944 		waddch(view->window, '\n');
2945 
2946 	if (asprintf(&line, "[%d/%d] %s%s",
2947 	    *first_displayed_line - 1 + selected_line, nlines,
2948 	    blame_complete ? "" : "annotating... ", path) == -1) {
2949 		free(id_str);
2950 		return got_error_from_errno("asprintf");
2951 	}
2952 	free(id_str);
2953 	err = format_line(&wline, &width, line, view->ncols);
2954 	free(line);
2955 	line = NULL;
2956 	if (err)
2957 		return err;
2958 	waddwstr(view->window, wline);
2959 	free(wline);
2960 	wline = NULL;
2961 	if (width < view->ncols - 1)
2962 		waddch(view->window, '\n');
2963 
2964 	*eof = 0;
2965 	while (nprinted < max_lines - 2) {
2966 		line = parse_next_line(f, &len);
2967 		if (line == NULL) {
2968 			*eof = 1;
2969 			break;
2970 		}
2971 		if (++lineno < *first_displayed_line) {
2972 			free(line);
2973 			continue;
2974 		}
2975 
2976 		wlimit = view->ncols < 9 ? 0 : view->ncols - 9;
2977 		err = format_line(&wline, &width, line, wlimit);
2978 		if (err) {
2979 			free(line);
2980 			return err;
2981 		}
2982 
2983 		if (view->focussed && nprinted == selected_line - 1)
2984 			wstandout(view->window);
2985 
2986 		blame_line = &lines[lineno - 1];
2987 		if (blame_line->annotated && prev_id &&
2988 		    got_object_id_cmp(prev_id, blame_line->id) == 0)
2989 			waddstr(view->window, "         ");
2990 		else if (blame_line->annotated) {
2991 			char *id_str;
2992 			err = got_object_id_str(&id_str, blame_line->id);
2993 			if (err) {
2994 				free(line);
2995 				free(wline);
2996 				return err;
2997 			}
2998 			wprintw(view->window, "%.8s ", id_str);
2999 			free(id_str);
3000 			prev_id = blame_line->id;
3001 		} else {
3002 			waddstr(view->window, "........ ");
3003 			prev_id = NULL;
3004 		}
3005 
3006 		waddwstr(view->window, wline);
3007 		while (width < wlimit) {
3008 			waddch(view->window, ' ');
3009 			width++;
3010 		}
3011 		if (view->focussed && nprinted == selected_line - 1)
3012 			wstandend(view->window);
3013 		if (++nprinted == 1)
3014 			*first_displayed_line = lineno;
3015 		free(line);
3016 		free(wline);
3017 		wline = NULL;
3018 	}
3019 	*last_displayed_line = lineno;
3020 
3021 	view_vborder(view);
3022 
3023 	return NULL;
3024 }
3025 
3026 static const struct got_error *
3027 blame_cb(void *arg, int nlines, int lineno, struct got_object_id *id)
3028 {
3029 	const struct got_error *err = NULL;
3030 	struct tog_blame_cb_args *a = arg;
3031 	struct tog_blame_line *line;
3032 	int errcode;
3033 
3034 	if (nlines != a->nlines ||
3035 	    (lineno != -1 && lineno < 1) || lineno > a->nlines)
3036 		return got_error(GOT_ERR_RANGE);
3037 
3038 	errcode = pthread_mutex_lock(&tog_mutex);
3039 	if (errcode)
3040 		return got_error_set_errno(errcode, "pthread_mutex_lock");
3041 
3042 	if (*a->quit) {	/* user has quit the blame view */
3043 		err = got_error(GOT_ERR_ITER_COMPLETED);
3044 		goto done;
3045 	}
3046 
3047 	if (lineno == -1)
3048 		goto done; /* no change in this commit */
3049 
3050 	line = &a->lines[lineno - 1];
3051 	if (line->annotated)
3052 		goto done;
3053 
3054 	line->id = got_object_id_dup(id);
3055 	if (line->id == NULL) {
3056 		err = got_error_from_errno("got_object_id_dup");
3057 		goto done;
3058 	}
3059 	line->annotated = 1;
3060 done:
3061 	errcode = pthread_mutex_unlock(&tog_mutex);
3062 	if (errcode)
3063 		err = got_error_set_errno(errcode, "pthread_mutex_unlock");
3064 	return err;
3065 }
3066 
3067 static void *
3068 blame_thread(void *arg)
3069 {
3070 	const struct got_error *err;
3071 	struct tog_blame_thread_args *ta = arg;
3072 	struct tog_blame_cb_args *a = ta->cb_args;
3073 	int errcode;
3074 
3075 	err = got_blame_incremental(ta->path, a->commit_id, ta->repo,
3076 	    blame_cb, ta->cb_args);
3077 
3078 	errcode = pthread_mutex_lock(&tog_mutex);
3079 	if (errcode)
3080 		return (void *)got_error_set_errno(errcode,
3081 		    "pthread_mutex_lock");
3082 
3083 	got_repo_close(ta->repo);
3084 	ta->repo = NULL;
3085 	*ta->complete = 1;
3086 
3087 	errcode = pthread_mutex_unlock(&tog_mutex);
3088 	if (errcode && err == NULL)
3089 		err = got_error_set_errno(errcode, "pthread_mutex_unlock");
3090 
3091 	return (void *)err;
3092 }
3093 
3094 static struct got_object_id *
3095 get_selected_commit_id(struct tog_blame_line *lines, int first_displayed_line,
3096     int selected_line)
3097 {
3098 	struct tog_blame_line *line;
3099 
3100 	line = &lines[first_displayed_line - 1 + selected_line - 1];
3101 	if (!line->annotated)
3102 		return NULL;
3103 
3104 	return line->id;
3105 }
3106 
3107 static const struct got_error *
3108 stop_blame(struct tog_blame *blame)
3109 {
3110 	const struct got_error *err = NULL;
3111 	int i;
3112 
3113 	if (blame->thread) {
3114 		int errcode;
3115 		errcode = pthread_mutex_unlock(&tog_mutex);
3116 		if (errcode)
3117 			return got_error_set_errno(errcode,
3118 			    "pthread_mutex_unlock");
3119 		errcode = pthread_join(blame->thread, (void **)&err);
3120 		if (errcode)
3121 			return got_error_set_errno(errcode, "pthread_join");
3122 		errcode = pthread_mutex_lock(&tog_mutex);
3123 		if (errcode)
3124 			return got_error_set_errno(errcode,
3125 			    "pthread_mutex_lock");
3126 		if (err && err->code == GOT_ERR_ITER_COMPLETED)
3127 			err = NULL;
3128 		blame->thread = NULL;
3129 	}
3130 	if (blame->thread_args.repo) {
3131 		got_repo_close(blame->thread_args.repo);
3132 		blame->thread_args.repo = NULL;
3133 	}
3134 	if (blame->f) {
3135 		if (fclose(blame->f) != 0 && err == NULL)
3136 			err = got_error_from_errno("fclose");
3137 		blame->f = NULL;
3138 	}
3139 	if (blame->lines) {
3140 		for (i = 0; i < blame->nlines; i++)
3141 			free(blame->lines[i].id);
3142 		free(blame->lines);
3143 		blame->lines = NULL;
3144 	}
3145 	free(blame->cb_args.commit_id);
3146 	blame->cb_args.commit_id = NULL;
3147 
3148 	return err;
3149 }
3150 
3151 static const struct got_error *
3152 run_blame(struct tog_blame *blame, struct tog_view *view, int *blame_complete,
3153     int *first_displayed_line, int *last_displayed_line, int *selected_line,
3154     int *done, int *eof, const char *path, struct got_object_id *commit_id,
3155     struct got_repository *repo)
3156 {
3157 	const struct got_error *err = NULL;
3158 	struct got_blob_object *blob = NULL;
3159 	struct got_repository *thread_repo = NULL;
3160 	struct got_object_id *obj_id = NULL;
3161 	int obj_type;
3162 
3163 	err = got_object_id_by_path(&obj_id, repo, commit_id, path);
3164 	if (err)
3165 		return err;
3166 	if (obj_id == NULL)
3167 		return got_error(GOT_ERR_NO_OBJ);
3168 
3169 	err = got_object_get_type(&obj_type, repo, obj_id);
3170 	if (err)
3171 		goto done;
3172 
3173 	if (obj_type != GOT_OBJ_TYPE_BLOB) {
3174 		err = got_error(GOT_ERR_OBJ_TYPE);
3175 		goto done;
3176 	}
3177 
3178 	err = got_object_open_as_blob(&blob, repo, obj_id, 8192);
3179 	if (err)
3180 		goto done;
3181 	blame->f = got_opentemp();
3182 	if (blame->f == NULL) {
3183 		err = got_error_from_errno("got_opentemp");
3184 		goto done;
3185 	}
3186 	err = got_object_blob_dump_to_file(&blame->filesize, &blame->nlines,
3187 	    &blame->line_offsets, blame->f, blob);
3188 	if (err)
3189 		goto done;
3190 
3191 	blame->lines = calloc(blame->nlines, sizeof(*blame->lines));
3192 	if (blame->lines == NULL) {
3193 		err = got_error_from_errno("calloc");
3194 		goto done;
3195 	}
3196 
3197 	err = got_repo_open(&thread_repo, got_repo_get_path(repo));
3198 	if (err)
3199 		goto done;
3200 
3201 	blame->cb_args.view = view;
3202 	blame->cb_args.lines = blame->lines;
3203 	blame->cb_args.nlines = blame->nlines;
3204 	blame->cb_args.commit_id = got_object_id_dup(commit_id);
3205 	if (blame->cb_args.commit_id == NULL) {
3206 		err = got_error_from_errno("got_object_id_dup");
3207 		goto done;
3208 	}
3209 	blame->cb_args.quit = done;
3210 
3211 	blame->thread_args.path = path;
3212 	blame->thread_args.repo = thread_repo;
3213 	blame->thread_args.cb_args = &blame->cb_args;
3214 	blame->thread_args.complete = blame_complete;
3215 	*blame_complete = 0;
3216 
3217 done:
3218 	if (blob)
3219 		got_object_blob_close(blob);
3220 	free(obj_id);
3221 	if (err)
3222 		stop_blame(blame);
3223 	return err;
3224 }
3225 
3226 static const struct got_error *
3227 open_blame_view(struct tog_view *view, char *path,
3228     struct got_object_id *commit_id, struct got_reflist_head *refs,
3229     struct got_repository *repo)
3230 {
3231 	const struct got_error *err = NULL;
3232 	struct tog_blame_view_state *s = &view->state.blame;
3233 
3234 	SIMPLEQ_INIT(&s->blamed_commits);
3235 
3236 	err = got_object_qid_alloc(&s->blamed_commit, commit_id);
3237 	if (err)
3238 		return err;
3239 
3240 	SIMPLEQ_INSERT_HEAD(&s->blamed_commits, s->blamed_commit, entry);
3241 	s->first_displayed_line = 1;
3242 	s->last_displayed_line = view->nlines;
3243 	s->selected_line = 1;
3244 	s->blame_complete = 0;
3245 	s->path = path;
3246 	if (s->path == NULL)
3247 		return got_error_from_errno("open_blame_view");
3248 	s->repo = repo;
3249 	s->refs = refs;
3250 	s->commit_id = commit_id;
3251 	memset(&s->blame, 0, sizeof(s->blame));
3252 
3253 	view->show = show_blame_view;
3254 	view->input = input_blame_view;
3255 	view->close = close_blame_view;
3256 	view->search_start = search_start_blame_view;
3257 	view->search_next = search_next_blame_view;
3258 
3259 	return run_blame(&s->blame, view, &s->blame_complete,
3260 	    &s->first_displayed_line, &s->last_displayed_line,
3261 	    &s->selected_line, &s->done, &s->eof, s->path,
3262 	    s->blamed_commit->id, s->repo);
3263 }
3264 
3265 static const struct got_error *
3266 close_blame_view(struct tog_view *view)
3267 {
3268 	const struct got_error *err = NULL;
3269 	struct tog_blame_view_state *s = &view->state.blame;
3270 
3271 	if (s->blame.thread)
3272 		err = stop_blame(&s->blame);
3273 
3274 	while (!SIMPLEQ_EMPTY(&s->blamed_commits)) {
3275 		struct got_object_qid *blamed_commit;
3276 		blamed_commit = SIMPLEQ_FIRST(&s->blamed_commits);
3277 		SIMPLEQ_REMOVE_HEAD(&s->blamed_commits, entry);
3278 		got_object_qid_free(blamed_commit);
3279 	}
3280 
3281 	free(s->path);
3282 
3283 	return err;
3284 }
3285 
3286 static const struct got_error *
3287 search_start_blame_view(struct tog_view *view)
3288 {
3289 	struct tog_blame_view_state *s = &view->state.blame;
3290 
3291 	s->matched_line = 0;
3292 	return NULL;
3293 }
3294 
3295 static int
3296 match_line(const char *line, regex_t *regex)
3297 {
3298 	regmatch_t regmatch;
3299 
3300 	return regexec(regex, line, 1, &regmatch, 0) == 0;
3301 }
3302 
3303 
3304 static const struct got_error *
3305 search_next_blame_view(struct tog_view *view)
3306 {
3307 	struct tog_blame_view_state *s = &view->state.blame;
3308 	int lineno;
3309 
3310 	if (!view->searching) {
3311 		view->search_next_done = 1;
3312 		return NULL;
3313 	}
3314 
3315 	if (s->matched_line) {
3316 		if (view->searching == TOG_SEARCH_FORWARD)
3317 			lineno = s->matched_line + 1;
3318 		else
3319 			lineno = s->matched_line - 1;
3320 	} else {
3321 		if (view->searching == TOG_SEARCH_FORWARD)
3322 			lineno = 1;
3323 		else
3324 			lineno = s->blame.nlines;
3325 	}
3326 
3327 	while (1) {
3328 		char *line = NULL;
3329 		off_t offset;
3330 		size_t len;
3331 
3332 		if (lineno <= 0 || lineno > s->blame.nlines) {
3333 			if (s->matched_line == 0) {
3334 				view->search_next_done = 1;
3335 				free(line);
3336 				break;
3337 			}
3338 
3339 			if (view->searching == TOG_SEARCH_FORWARD)
3340 				lineno = 1;
3341 			else
3342 				lineno = s->blame.nlines;
3343 		}
3344 
3345 		offset = s->blame.line_offsets[lineno - 1];
3346 		if (fseeko(s->blame.f, offset, SEEK_SET) != 0) {
3347 			free(line);
3348 			return got_error_from_errno("fseeko");
3349 		}
3350 		free(line);
3351 		line = parse_next_line(s->blame.f, &len);
3352 		if (line && match_line(line, &view->regex)) {
3353 			view->search_next_done = 1;
3354 			s->matched_line = lineno;
3355 			free(line);
3356 			break;
3357 		}
3358 		free(line);
3359 		if (view->searching == TOG_SEARCH_FORWARD)
3360 			lineno++;
3361 		else
3362 			lineno--;
3363 	}
3364 
3365 	if (s->matched_line) {
3366 		s->first_displayed_line = s->matched_line;
3367 		s->selected_line = 1;
3368 	}
3369 
3370 	return NULL;
3371 }
3372 
3373 static const struct got_error *
3374 show_blame_view(struct tog_view *view)
3375 {
3376 	const struct got_error *err = NULL;
3377 	struct tog_blame_view_state *s = &view->state.blame;
3378 	int errcode;
3379 
3380 	if (s->blame.thread == NULL) {
3381 		errcode = pthread_create(&s->blame.thread, NULL, blame_thread,
3382 		    &s->blame.thread_args);
3383 		if (errcode)
3384 			return got_error_set_errno(errcode, "pthread_create");
3385 	}
3386 
3387 	err = draw_blame(view, s->blamed_commit->id, s->blame.f,
3388 	    s->path, s->blame.lines, s->blame.nlines, s->blame_complete,
3389 	    s->selected_line, &s->first_displayed_line,
3390 	    &s->last_displayed_line, &s->eof, view->nlines);
3391 
3392 	view_vborder(view);
3393 	return err;
3394 }
3395 
3396 static const struct got_error *
3397 input_blame_view(struct tog_view **new_view, struct tog_view **dead_view,
3398     struct tog_view **focus_view, struct tog_view *view, int ch)
3399 {
3400 	const struct got_error *err = NULL, *thread_err = NULL;
3401 	struct tog_view *diff_view;
3402 	struct tog_blame_view_state *s = &view->state.blame;
3403 	int begin_x = 0;
3404 
3405 	switch (ch) {
3406 	case 'q':
3407 		s->done = 1;
3408 		break;
3409 	case 'k':
3410 	case KEY_UP:
3411 		if (s->selected_line > 1)
3412 			s->selected_line--;
3413 		else if (s->selected_line == 1 &&
3414 		    s->first_displayed_line > 1)
3415 			s->first_displayed_line--;
3416 		break;
3417 	case KEY_PPAGE:
3418 		if (s->first_displayed_line == 1) {
3419 			s->selected_line = 1;
3420 			break;
3421 		}
3422 		if (s->first_displayed_line > view->nlines - 2)
3423 			s->first_displayed_line -=
3424 			    (view->nlines - 2);
3425 		else
3426 			s->first_displayed_line = 1;
3427 		break;
3428 	case 'j':
3429 	case KEY_DOWN:
3430 		if (s->selected_line < view->nlines - 2 &&
3431 		    s->first_displayed_line +
3432 		    s->selected_line <= s->blame.nlines)
3433 			s->selected_line++;
3434 		else if (s->last_displayed_line <
3435 		    s->blame.nlines)
3436 			s->first_displayed_line++;
3437 		break;
3438 	case 'b':
3439 	case 'p': {
3440 		struct got_object_id *id = NULL;
3441 		id = get_selected_commit_id(s->blame.lines,
3442 		    s->first_displayed_line, s->selected_line);
3443 		if (id == NULL)
3444 			break;
3445 		if (ch == 'p') {
3446 			struct got_commit_object *commit;
3447 			struct got_object_qid *pid;
3448 			struct got_object_id *blob_id = NULL;
3449 			int obj_type;
3450 			err = got_object_open_as_commit(&commit,
3451 			    s->repo, id);
3452 			if (err)
3453 				break;
3454 			pid = SIMPLEQ_FIRST(
3455 			    got_object_commit_get_parent_ids(commit));
3456 			if (pid == NULL) {
3457 				got_object_commit_close(commit);
3458 				break;
3459 			}
3460 			/* Check if path history ends here. */
3461 			err = got_object_id_by_path(&blob_id, s->repo,
3462 			    pid->id, s->path);
3463 			if (err) {
3464 				if (err->code == GOT_ERR_NO_TREE_ENTRY)
3465 					err = NULL;
3466 				got_object_commit_close(commit);
3467 				break;
3468 			}
3469 			err = got_object_get_type(&obj_type, s->repo,
3470 			    blob_id);
3471 			free(blob_id);
3472 			/* Can't blame non-blob type objects. */
3473 			if (obj_type != GOT_OBJ_TYPE_BLOB) {
3474 				got_object_commit_close(commit);
3475 				break;
3476 			}
3477 			err = got_object_qid_alloc(&s->blamed_commit,
3478 			    pid->id);
3479 			got_object_commit_close(commit);
3480 		} else {
3481 			if (got_object_id_cmp(id,
3482 			    s->blamed_commit->id) == 0)
3483 				break;
3484 			err = got_object_qid_alloc(&s->blamed_commit,
3485 			    id);
3486 		}
3487 		if (err)
3488 			break;
3489 		s->done = 1;
3490 		thread_err = stop_blame(&s->blame);
3491 		s->done = 0;
3492 		if (thread_err)
3493 			break;
3494 		SIMPLEQ_INSERT_HEAD(&s->blamed_commits,
3495 		    s->blamed_commit, entry);
3496 		err = run_blame(&s->blame, view, &s->blame_complete,
3497 		    &s->first_displayed_line, &s->last_displayed_line,
3498 		    &s->selected_line, &s->done, &s->eof,
3499 		    s->path, s->blamed_commit->id, s->repo);
3500 		if (err)
3501 			break;
3502 		break;
3503 	}
3504 	case 'B': {
3505 		struct got_object_qid *first;
3506 		first = SIMPLEQ_FIRST(&s->blamed_commits);
3507 		if (!got_object_id_cmp(first->id, s->commit_id))
3508 			break;
3509 		s->done = 1;
3510 		thread_err = stop_blame(&s->blame);
3511 		s->done = 0;
3512 		if (thread_err)
3513 			break;
3514 		SIMPLEQ_REMOVE_HEAD(&s->blamed_commits, entry);
3515 		got_object_qid_free(s->blamed_commit);
3516 		s->blamed_commit =
3517 		    SIMPLEQ_FIRST(&s->blamed_commits);
3518 		err = run_blame(&s->blame, view, &s->blame_complete,
3519 		    &s->first_displayed_line, &s->last_displayed_line,
3520 		    &s->selected_line, &s->done, &s->eof, s->path,
3521 		    s->blamed_commit->id, s->repo);
3522 		if (err)
3523 			break;
3524 		break;
3525 	}
3526 	case KEY_ENTER:
3527 	case '\r': {
3528 		struct got_object_id *id = NULL;
3529 		struct got_object_qid *pid;
3530 		struct got_commit_object *commit = NULL;
3531 		id = get_selected_commit_id(s->blame.lines,
3532 		    s->first_displayed_line, s->selected_line);
3533 		if (id == NULL)
3534 			break;
3535 		err = got_object_open_as_commit(&commit, s->repo, id);
3536 		if (err)
3537 			break;
3538 		pid = SIMPLEQ_FIRST(
3539 		    got_object_commit_get_parent_ids(commit));
3540 		if (view_is_parent_view(view))
3541 		    begin_x = view_split_begin_x(view->begin_x);
3542 		diff_view = view_open(0, 0, 0, begin_x, TOG_VIEW_DIFF);
3543 		if (diff_view == NULL) {
3544 			got_object_commit_close(commit);
3545 			err = got_error_from_errno("view_open");
3546 			break;
3547 		}
3548 		err = open_diff_view(diff_view, pid ? pid->id : NULL,
3549 		    id, NULL, s->refs, s->repo);
3550 		got_object_commit_close(commit);
3551 		if (err) {
3552 			view_close(diff_view);
3553 			break;
3554 		}
3555 		if (view_is_parent_view(view)) {
3556 			err = view_close_child(view);
3557 			if (err)
3558 				break;
3559 			err = view_set_child(view, diff_view);
3560 			if (err) {
3561 				view_close(diff_view);
3562 				break;
3563 			}
3564 			*focus_view = diff_view;
3565 			view->child_focussed = 1;
3566 		} else
3567 			*new_view = diff_view;
3568 		if (err)
3569 			break;
3570 		break;
3571 	}
3572 	case KEY_NPAGE:
3573 	case ' ':
3574 		if (s->last_displayed_line >= s->blame.nlines &&
3575 		    s->selected_line >= MIN(s->blame.nlines,
3576 		    view->nlines - 2)) {
3577 			break;
3578 		}
3579 		if (s->last_displayed_line >= s->blame.nlines &&
3580 		    s->selected_line < view->nlines - 2) {
3581 			s->selected_line = MIN(s->blame.nlines,
3582 			    view->nlines - 2);
3583 			break;
3584 		}
3585 		if (s->last_displayed_line + view->nlines - 2
3586 		    <= s->blame.nlines)
3587 			s->first_displayed_line +=
3588 			    view->nlines - 2;
3589 		else
3590 			s->first_displayed_line =
3591 			    s->blame.nlines -
3592 			    (view->nlines - 3);
3593 		break;
3594 	case KEY_RESIZE:
3595 		if (s->selected_line > view->nlines - 2) {
3596 			s->selected_line = MIN(s->blame.nlines,
3597 			    view->nlines - 2);
3598 		}
3599 		break;
3600 	default:
3601 		break;
3602 	}
3603 	return thread_err ? thread_err : err;
3604 }
3605 
3606 static const struct got_error *
3607 cmd_blame(int argc, char *argv[])
3608 {
3609 	const struct got_error *error;
3610 	struct got_repository *repo = NULL;
3611 	struct got_reflist_head refs;
3612 	struct got_worktree *worktree = NULL;
3613 	char *path, *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
3614 	struct got_object_id *commit_id = NULL;
3615 	char *commit_id_str = NULL;
3616 	int ch;
3617 	struct tog_view *view;
3618 
3619 	SIMPLEQ_INIT(&refs);
3620 
3621 #ifndef PROFILE
3622 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
3623 	    NULL) == -1)
3624 		err(1, "pledge");
3625 #endif
3626 
3627 	while ((ch = getopt(argc, argv, "c:r:")) != -1) {
3628 		switch (ch) {
3629 		case 'c':
3630 			commit_id_str = optarg;
3631 			break;
3632 		case 'r':
3633 			repo_path = realpath(optarg, NULL);
3634 			if (repo_path == NULL)
3635 				err(1, "-r option");
3636 			break;
3637 		default:
3638 			usage_blame();
3639 			/* NOTREACHED */
3640 		}
3641 	}
3642 
3643 	argc -= optind;
3644 	argv += optind;
3645 
3646 	if (argc == 1)
3647 		path = argv[0];
3648 	else
3649 		usage_blame();
3650 
3651 	cwd = getcwd(NULL, 0);
3652 	if (cwd == NULL) {
3653 		error = got_error_from_errno("getcwd");
3654 		goto done;
3655 	}
3656 	if (repo_path == NULL) {
3657 		error = got_worktree_open(&worktree, cwd);
3658 		if (error && error->code != GOT_ERR_NOT_WORKTREE)
3659 			goto done;
3660 		else
3661 			error = NULL;
3662 		if (worktree) {
3663 			repo_path =
3664 			    strdup(got_worktree_get_repo_path(worktree));
3665 			if (repo_path == NULL)
3666 				error = got_error_from_errno("strdup");
3667 			if (error)
3668 				goto done;
3669 		} else {
3670 			repo_path = strdup(cwd);
3671 			if (repo_path == NULL) {
3672 				error = got_error_from_errno("strdup");
3673 				goto done;
3674 			}
3675 		}
3676 	}
3677 
3678 	init_curses();
3679 
3680 	error = got_repo_open(&repo, repo_path);
3681 	if (error != NULL)
3682 		goto done;
3683 
3684 	error = apply_unveil(got_repo_get_path(repo), NULL);
3685 	if (error)
3686 		goto done;
3687 
3688 	if (worktree) {
3689 		const char *prefix = got_worktree_get_path_prefix(worktree);
3690 		char *p, *worktree_subdir = cwd +
3691 		    strlen(got_worktree_get_root_path(worktree));
3692 		if (asprintf(&p, "%s%s%s%s%s",
3693 		    prefix, (strcmp(prefix, "/") != 0) ? "/" : "",
3694 		    worktree_subdir, worktree_subdir[0] ? "/" : "",
3695 		    path) == -1) {
3696 			error = got_error_from_errno("asprintf");
3697 			goto done;
3698 		}
3699 		error = got_repo_map_path(&in_repo_path, repo, p, 0);
3700 		free(p);
3701 	} else {
3702 		error = got_repo_map_path(&in_repo_path, repo, path, 1);
3703 	}
3704 	if (error)
3705 		goto done;
3706 
3707 	if (commit_id_str == NULL) {
3708 		struct got_reference *head_ref;
3709 		error = got_ref_open(&head_ref, repo, GOT_REF_HEAD, 0);
3710 		if (error != NULL)
3711 			goto done;
3712 		error = got_ref_resolve(&commit_id, repo, head_ref);
3713 		got_ref_close(head_ref);
3714 	} else {
3715 		error = get_head_commit_id(&commit_id, commit_id_str, repo);
3716 		if (error) {
3717 			if (error->code != GOT_ERR_NOT_REF)
3718 				goto done;
3719 			error = got_repo_match_object_id_prefix(&commit_id,
3720 			    commit_id_str, GOT_OBJ_TYPE_COMMIT, repo);
3721 		}
3722 	}
3723 	if (error != NULL)
3724 		goto done;
3725 
3726 	error = got_ref_list(&refs, repo);
3727 	if (error)
3728 		goto done;
3729 
3730 	view = view_open(0, 0, 0, 0, TOG_VIEW_BLAME);
3731 	if (view == NULL) {
3732 		error = got_error_from_errno("view_open");
3733 		goto done;
3734 	}
3735 	error = open_blame_view(view, in_repo_path, commit_id, &refs, repo);
3736 	if (error)
3737 		goto done;
3738 	error = view_loop(view);
3739 done:
3740 	free(repo_path);
3741 	free(cwd);
3742 	free(commit_id);
3743 	if (worktree)
3744 		got_worktree_close(worktree);
3745 	if (repo)
3746 		got_repo_close(repo);
3747 	got_ref_list_free(&refs);
3748 	return error;
3749 }
3750 
3751 static const struct got_error *
3752 draw_tree_entries(struct tog_view *view,
3753     struct got_tree_entry **first_displayed_entry,
3754     struct got_tree_entry **last_displayed_entry,
3755     struct got_tree_entry **selected_entry, int *ndisplayed,
3756     const char *label, int show_ids, const char *parent_path,
3757     const struct got_tree_entries *entries, int selected, int limit, int isroot)
3758 {
3759 	const struct got_error *err = NULL;
3760 	struct got_tree_entry *te;
3761 	wchar_t *wline;
3762 	int width, n;
3763 
3764 	*ndisplayed = 0;
3765 
3766 	werase(view->window);
3767 
3768 	if (limit == 0)
3769 		return NULL;
3770 
3771 	err = format_line(&wline, &width, label, view->ncols);
3772 	if (err)
3773 		return err;
3774 	if (view_needs_focus_indication(view))
3775 		wstandout(view->window);
3776 	waddwstr(view->window, wline);
3777 	if (view_needs_focus_indication(view))
3778 		wstandend(view->window);
3779 	free(wline);
3780 	wline = NULL;
3781 	if (width < view->ncols - 1)
3782 		waddch(view->window, '\n');
3783 	if (--limit <= 0)
3784 		return NULL;
3785 	err = format_line(&wline, &width, parent_path, view->ncols);
3786 	if (err)
3787 		return err;
3788 	waddwstr(view->window, wline);
3789 	free(wline);
3790 	wline = NULL;
3791 	if (width < view->ncols - 1)
3792 		waddch(view->window, '\n');
3793 	if (--limit <= 0)
3794 		return NULL;
3795 	waddch(view->window, '\n');
3796 	if (--limit <= 0)
3797 		return NULL;
3798 
3799 	te = SIMPLEQ_FIRST(&entries->head);
3800 	if (*first_displayed_entry == NULL) {
3801 		if (selected == 0) {
3802 			if (view->focussed)
3803 				wstandout(view->window);
3804 			*selected_entry = NULL;
3805 		}
3806 		waddstr(view->window, "  ..\n");	/* parent directory */
3807 		if (selected == 0 && view->focussed)
3808 			wstandend(view->window);
3809 		(*ndisplayed)++;
3810 		if (--limit <= 0)
3811 			return NULL;
3812 		n = 1;
3813 	} else {
3814 		n = 0;
3815 		while (te != *first_displayed_entry)
3816 			te = SIMPLEQ_NEXT(te, entry);
3817 	}
3818 
3819 	while (te) {
3820 		char *line = NULL, *id_str = NULL;
3821 
3822 		if (show_ids) {
3823 			err = got_object_id_str(&id_str, te->id);
3824 			if (err)
3825 				return got_error_from_errno(
3826 				    "got_object_id_str");
3827 		}
3828 		if (asprintf(&line, "%s  %s%s", id_str ? id_str : "",
3829 		    te->name, S_ISDIR(te->mode) ? "/" :
3830 		    ((te->mode & S_IXUSR) ? "*" : "")) == -1) {
3831 			free(id_str);
3832 			return got_error_from_errno("asprintf");
3833 		}
3834 		free(id_str);
3835 		err = format_line(&wline, &width, line, view->ncols);
3836 		if (err) {
3837 			free(line);
3838 			break;
3839 		}
3840 		if (n == selected) {
3841 			if (view->focussed)
3842 				wstandout(view->window);
3843 			*selected_entry = te;
3844 		}
3845 		waddwstr(view->window, wline);
3846 		if (width < view->ncols - 1)
3847 			waddch(view->window, '\n');
3848 		if (n == selected && view->focussed)
3849 			wstandend(view->window);
3850 		free(line);
3851 		free(wline);
3852 		wline = NULL;
3853 		n++;
3854 		(*ndisplayed)++;
3855 		*last_displayed_entry = te;
3856 		if (--limit <= 0)
3857 			break;
3858 		te = SIMPLEQ_NEXT(te, entry);
3859 	}
3860 
3861 	return err;
3862 }
3863 
3864 static void
3865 tree_scroll_up(struct tog_view *view,
3866     struct got_tree_entry **first_displayed_entry, int maxscroll,
3867     const struct got_tree_entries *entries, int isroot)
3868 {
3869 	struct got_tree_entry *te, *prev;
3870 	int i;
3871 
3872 	if (*first_displayed_entry == NULL)
3873 		return;
3874 
3875 	te = SIMPLEQ_FIRST(&entries->head);
3876 	if (*first_displayed_entry == te) {
3877 		if (!isroot)
3878 			*first_displayed_entry = NULL;
3879 		return;
3880 	}
3881 
3882 	/* XXX this is stupid... switch to TAILQ? */
3883 	for (i = 0; i < maxscroll; i++) {
3884 		while (te != *first_displayed_entry) {
3885 			prev = te;
3886 			te = SIMPLEQ_NEXT(te, entry);
3887 		}
3888 		*first_displayed_entry = prev;
3889 		te = SIMPLEQ_FIRST(&entries->head);
3890 	}
3891 	if (!isroot && te == SIMPLEQ_FIRST(&entries->head) && i < maxscroll)
3892 		*first_displayed_entry = NULL;
3893 }
3894 
3895 static int
3896 tree_scroll_down(struct got_tree_entry **first_displayed_entry, int maxscroll,
3897 	struct got_tree_entry *last_displayed_entry,
3898 	const struct got_tree_entries *entries)
3899 {
3900 	struct got_tree_entry *next, *last;
3901 	int n = 0;
3902 
3903 	if (*first_displayed_entry)
3904 		next = SIMPLEQ_NEXT(*first_displayed_entry, entry);
3905 	else
3906 		next = SIMPLEQ_FIRST(&entries->head);
3907 	last = last_displayed_entry;
3908 	while (next && last && n++ < maxscroll) {
3909 		last = SIMPLEQ_NEXT(last, entry);
3910 		if (last) {
3911 			*first_displayed_entry = next;
3912 			next = SIMPLEQ_NEXT(next, entry);
3913 		}
3914 	}
3915 	return n;
3916 }
3917 
3918 static const struct got_error *
3919 tree_entry_path(char **path, struct tog_parent_trees *parents,
3920     struct got_tree_entry *te)
3921 {
3922 	const struct got_error *err = NULL;
3923 	struct tog_parent_tree *pt;
3924 	size_t len = 2; /* for leading slash and NUL */
3925 
3926 	TAILQ_FOREACH(pt, parents, entry)
3927 		len += strlen(pt->selected_entry->name) + 1 /* slash */;
3928 	if (te)
3929 		len += strlen(te->name);
3930 
3931 	*path = calloc(1, len);
3932 	if (path == NULL)
3933 		return got_error_from_errno("calloc");
3934 
3935 	(*path)[0] = '/';
3936 	pt = TAILQ_LAST(parents, tog_parent_trees);
3937 	while (pt) {
3938 		if (strlcat(*path, pt->selected_entry->name, len) >= len) {
3939 			err = got_error(GOT_ERR_NO_SPACE);
3940 			goto done;
3941 		}
3942 		if (strlcat(*path, "/", len) >= len) {
3943 			err = got_error(GOT_ERR_NO_SPACE);
3944 			goto done;
3945 		}
3946 		pt = TAILQ_PREV(pt, tog_parent_trees, entry);
3947 	}
3948 	if (te) {
3949 		if (strlcat(*path, te->name, len) >= len) {
3950 			err = got_error(GOT_ERR_NO_SPACE);
3951 			goto done;
3952 		}
3953 	}
3954 done:
3955 	if (err) {
3956 		free(*path);
3957 		*path = NULL;
3958 	}
3959 	return err;
3960 }
3961 
3962 static const struct got_error *
3963 blame_tree_entry(struct tog_view **new_view, int begin_x,
3964     struct got_tree_entry *te, struct tog_parent_trees *parents,
3965     struct got_object_id *commit_id, struct got_reflist_head *refs,
3966     struct got_repository *repo)
3967 {
3968 	const struct got_error *err = NULL;
3969 	char *path;
3970 	struct tog_view *blame_view;
3971 
3972 	err = tree_entry_path(&path, parents, te);
3973 	if (err)
3974 		return err;
3975 
3976 	blame_view = view_open(0, 0, 0, begin_x, TOG_VIEW_BLAME);
3977 	if (blame_view == NULL)
3978 		return got_error_from_errno("view_open");
3979 
3980 	err = open_blame_view(blame_view, path, commit_id, refs, repo);
3981 	if (err) {
3982 		view_close(blame_view);
3983 		free(path);
3984 	} else
3985 		*new_view = blame_view;
3986 	return err;
3987 }
3988 
3989 static const struct got_error *
3990 log_tree_entry(struct tog_view **new_view, int begin_x,
3991     struct got_tree_entry *te, struct tog_parent_trees *parents,
3992     struct got_object_id *commit_id, struct got_reflist_head *refs,
3993     struct got_repository *repo)
3994 {
3995 	struct tog_view *log_view;
3996 	const struct got_error *err = NULL;
3997 	char *path;
3998 
3999 	log_view = view_open(0, 0, 0, begin_x, TOG_VIEW_LOG);
4000 	if (log_view == NULL)
4001 		return got_error_from_errno("view_open");
4002 
4003 	err = tree_entry_path(&path, parents, te);
4004 	if (err)
4005 		return err;
4006 
4007 	err = open_log_view(log_view, commit_id, refs, repo, NULL, path, 0);
4008 	if (err)
4009 		view_close(log_view);
4010 	else
4011 		*new_view = log_view;
4012 	free(path);
4013 	return err;
4014 }
4015 
4016 static const struct got_error *
4017 open_tree_view(struct tog_view *view, struct got_tree_object *root,
4018     struct got_object_id *commit_id, struct got_reflist_head *refs,
4019     struct got_repository *repo)
4020 {
4021 	const struct got_error *err = NULL;
4022 	char *commit_id_str = NULL;
4023 	struct tog_tree_view_state *s = &view->state.tree;
4024 
4025 	TAILQ_INIT(&s->parents);
4026 
4027 	err = got_object_id_str(&commit_id_str, commit_id);
4028 	if (err != NULL)
4029 		goto done;
4030 
4031 	if (asprintf(&s->tree_label, "commit %s", commit_id_str) == -1) {
4032 		err = got_error_from_errno("asprintf");
4033 		goto done;
4034 	}
4035 
4036 	s->root = s->tree = root;
4037 	s->entries = got_object_tree_get_entries(root);
4038 	s->first_displayed_entry = SIMPLEQ_FIRST(&s->entries->head);
4039 	s->commit_id = got_object_id_dup(commit_id);
4040 	if (s->commit_id == NULL) {
4041 		err = got_error_from_errno("got_object_id_dup");
4042 		goto done;
4043 	}
4044 	s->refs = refs;
4045 	s->repo = repo;
4046 
4047 	view->show = show_tree_view;
4048 	view->input = input_tree_view;
4049 	view->close = close_tree_view;
4050 	view->search_start = search_start_tree_view;
4051 	view->search_next = search_next_tree_view;
4052 done:
4053 	free(commit_id_str);
4054 	if (err) {
4055 		free(s->tree_label);
4056 		s->tree_label = NULL;
4057 	}
4058 	return err;
4059 }
4060 
4061 static const struct got_error *
4062 close_tree_view(struct tog_view *view)
4063 {
4064 	struct tog_tree_view_state *s = &view->state.tree;
4065 
4066 	free(s->tree_label);
4067 	s->tree_label = NULL;
4068 	free(s->commit_id);
4069 	s->commit_id = NULL;
4070 	while (!TAILQ_EMPTY(&s->parents)) {
4071 		struct tog_parent_tree *parent;
4072 		parent = TAILQ_FIRST(&s->parents);
4073 		TAILQ_REMOVE(&s->parents, parent, entry);
4074 		free(parent);
4075 
4076 	}
4077 	if (s->tree != s->root)
4078 		got_object_tree_close(s->tree);
4079 	got_object_tree_close(s->root);
4080 
4081 	return NULL;
4082 }
4083 
4084 static const struct got_error *
4085 search_start_tree_view(struct tog_view *view)
4086 {
4087 	struct tog_tree_view_state *s = &view->state.tree;
4088 
4089 	s->matched_entry = NULL;
4090 	return NULL;
4091 }
4092 
4093 static int
4094 match_tree_entry(struct got_tree_entry *te, regex_t *regex)
4095 {
4096 	regmatch_t regmatch;
4097 
4098 	return regexec(regex, te->name, 1, &regmatch, 0) == 0;
4099 }
4100 
4101 static const struct got_error *
4102 search_next_tree_view(struct tog_view *view)
4103 {
4104 	struct tog_tree_view_state *s = &view->state.tree;
4105 	struct got_tree_entry *entry, *te;
4106 
4107 	if (!view->searching) {
4108 		view->search_next_done = 1;
4109 		return NULL;
4110 	}
4111 
4112 	if (s->matched_entry) {
4113 		if (view->searching == TOG_SEARCH_FORWARD) {
4114 			if (s->selected_entry)
4115 				entry = SIMPLEQ_NEXT(s->selected_entry, entry);
4116 			else
4117 				entry = SIMPLEQ_FIRST(&s->entries->head);
4118 		}
4119 		else {
4120 			if (s->selected_entry == NULL) {
4121 				SIMPLEQ_FOREACH(te, &s->entries->head, entry)
4122 					entry = te;
4123 			} else {
4124 				SIMPLEQ_FOREACH(te, &s->entries->head, entry) {
4125 					entry = te;
4126 					if (SIMPLEQ_NEXT(te, entry) ==
4127 					    s->selected_entry)
4128 						break;
4129 				}
4130 			}
4131 		}
4132 	} else {
4133 		if (view->searching == TOG_SEARCH_FORWARD)
4134 			entry = SIMPLEQ_FIRST(&s->entries->head);
4135 		else {
4136 			SIMPLEQ_FOREACH(te, &s->entries->head, entry)
4137 				entry = te;
4138 		}
4139 	}
4140 
4141 	while (1) {
4142 		if (entry == NULL) {
4143 			if (s->matched_entry == NULL) {
4144 				view->search_next_done = 1;
4145 				return NULL;
4146 			}
4147 			if (view->searching == TOG_SEARCH_FORWARD)
4148 				entry = SIMPLEQ_FIRST(&s->entries->head);
4149 			else {
4150 				SIMPLEQ_FOREACH(te, &s->entries->head, entry)
4151 					entry = te;
4152 			}
4153 		}
4154 
4155 		if (match_tree_entry(entry, &view->regex)) {
4156 			view->search_next_done = 1;
4157 			s->matched_entry = entry;
4158 			break;
4159 		}
4160 
4161 		if (view->searching == TOG_SEARCH_FORWARD)
4162 			entry = SIMPLEQ_NEXT(entry, entry);
4163 		else {
4164 			if (SIMPLEQ_FIRST(&s->entries->head) == entry)
4165 				entry = NULL;
4166 			else {
4167 				SIMPLEQ_FOREACH(te, &s->entries->head, entry) {
4168 					if (SIMPLEQ_NEXT(te, entry) == entry) {
4169 						entry = te;
4170 						break;
4171 					}
4172 				}
4173 			}
4174 		}
4175 	}
4176 
4177 	if (s->matched_entry) {
4178 		s->first_displayed_entry = s->matched_entry;
4179 		s->selected = 0;
4180 	}
4181 
4182 	return NULL;
4183 }
4184 
4185 static const struct got_error *
4186 show_tree_view(struct tog_view *view)
4187 {
4188 	const struct got_error *err = NULL;
4189 	struct tog_tree_view_state *s = &view->state.tree;
4190 	char *parent_path;
4191 
4192 	err = tree_entry_path(&parent_path, &s->parents, NULL);
4193 	if (err)
4194 		return err;
4195 
4196 	err = draw_tree_entries(view, &s->first_displayed_entry,
4197 	    &s->last_displayed_entry, &s->selected_entry,
4198 	    &s->ndisplayed, s->tree_label, s->show_ids, parent_path,
4199 	    s->entries, s->selected, view->nlines, s->tree == s->root);
4200 	free(parent_path);
4201 
4202 	view_vborder(view);
4203 	return err;
4204 }
4205 
4206 static const struct got_error *
4207 input_tree_view(struct tog_view **new_view, struct tog_view **dead_view,
4208     struct tog_view **focus_view, struct tog_view *view, int ch)
4209 {
4210 	const struct got_error *err = NULL;
4211 	struct tog_tree_view_state *s = &view->state.tree;
4212 	struct tog_view *log_view;
4213 	int begin_x = 0, nscrolled;
4214 
4215 	switch (ch) {
4216 	case 'i':
4217 		s->show_ids = !s->show_ids;
4218 		break;
4219 	case 'l':
4220 		if (!s->selected_entry)
4221 			break;
4222 		if (view_is_parent_view(view))
4223 			begin_x = view_split_begin_x(view->begin_x);
4224 		err = log_tree_entry(&log_view, begin_x,
4225 		    s->selected_entry, &s->parents,
4226 		    s->commit_id, s->refs, s->repo);
4227 		if (view_is_parent_view(view)) {
4228 			err = view_close_child(view);
4229 			if (err)
4230 				return err;
4231 			err = view_set_child(view, log_view);
4232 			if (err) {
4233 				view_close(log_view);
4234 				break;
4235 			}
4236 			*focus_view = log_view;
4237 			view->child_focussed = 1;
4238 		} else
4239 			*new_view = log_view;
4240 		break;
4241 	case 'k':
4242 	case KEY_UP:
4243 		if (s->selected > 0) {
4244 			s->selected--;
4245 			if (s->selected == 0)
4246 				break;
4247 		}
4248 		if (s->selected > 0)
4249 			break;
4250 		tree_scroll_up(view, &s->first_displayed_entry, 1,
4251 		    s->entries, s->tree == s->root);
4252 		break;
4253 	case KEY_PPAGE:
4254 		tree_scroll_up(view, &s->first_displayed_entry,
4255 		    MAX(0, view->nlines - 4 - s->selected), s->entries,
4256 		    s->tree == s->root);
4257 		s->selected = 0;
4258 		if (SIMPLEQ_FIRST(&s->entries->head) ==
4259 		    s->first_displayed_entry && s->tree != s->root)
4260 			s->first_displayed_entry = NULL;
4261 		break;
4262 	case 'j':
4263 	case KEY_DOWN:
4264 		if (s->selected < s->ndisplayed - 1) {
4265 			s->selected++;
4266 			break;
4267 		}
4268 		if (SIMPLEQ_NEXT(s->last_displayed_entry, entry) == NULL)
4269 			/* can't scroll any further */
4270 			break;
4271 		tree_scroll_down(&s->first_displayed_entry, 1,
4272 		    s->last_displayed_entry, s->entries);
4273 		break;
4274 	case KEY_NPAGE:
4275 		if (SIMPLEQ_NEXT(s->last_displayed_entry, entry)
4276 		    == NULL) {
4277 			/* can't scroll any further; move cursor down */
4278 			if (s->selected < s->ndisplayed - 1)
4279 				s->selected = s->ndisplayed - 1;
4280 			break;
4281 		}
4282 		nscrolled = tree_scroll_down(&s->first_displayed_entry,
4283 		    view->nlines, s->last_displayed_entry, s->entries);
4284 		if (nscrolled < view->nlines) {
4285 			int ndisplayed = 0;
4286 			struct got_tree_entry *te;
4287 			te = s->first_displayed_entry;
4288 			do {
4289 				ndisplayed++;
4290 				te = SIMPLEQ_NEXT(te, entry);
4291 			} while (te);
4292 			s->selected = ndisplayed - 1;
4293 		}
4294 		break;
4295 	case KEY_ENTER:
4296 	case '\r':
4297 	case KEY_BACKSPACE:
4298 		if (s->selected_entry == NULL || ch == KEY_BACKSPACE) {
4299 			struct tog_parent_tree *parent;
4300 			/* user selected '..' */
4301 			if (s->tree == s->root)
4302 				break;
4303 			parent = TAILQ_FIRST(&s->parents);
4304 			TAILQ_REMOVE(&s->parents, parent,
4305 			    entry);
4306 			got_object_tree_close(s->tree);
4307 			s->tree = parent->tree;
4308 			s->entries =
4309 			    got_object_tree_get_entries(s->tree);
4310 			s->first_displayed_entry =
4311 			    parent->first_displayed_entry;
4312 			s->selected_entry =
4313 			    parent->selected_entry;
4314 			s->selected = parent->selected;
4315 			free(parent);
4316 		} else if (S_ISDIR(s->selected_entry->mode)) {
4317 			struct got_tree_object *subtree;
4318 			err = got_object_open_as_tree(&subtree,
4319 			    s->repo, s->selected_entry->id);
4320 			if (err)
4321 				break;
4322 			err = tree_view_visit_subtree(subtree, s);
4323 			if (err) {
4324 				got_object_tree_close(subtree);
4325 				break;
4326 			}
4327 		} else if (S_ISREG(s->selected_entry->mode)) {
4328 			struct tog_view *blame_view;
4329 			int begin_x = view_is_parent_view(view) ?
4330 			    view_split_begin_x(view->begin_x) : 0;
4331 
4332 			err = blame_tree_entry(&blame_view, begin_x,
4333 			    s->selected_entry, &s->parents,
4334 			    s->commit_id, s->refs, s->repo);
4335 			if (err)
4336 				break;
4337 			if (view_is_parent_view(view)) {
4338 				err = view_close_child(view);
4339 				if (err)
4340 					return err;
4341 				err = view_set_child(view, blame_view);
4342 				if (err) {
4343 					view_close(blame_view);
4344 					break;
4345 				}
4346 				*focus_view = blame_view;
4347 				view->child_focussed = 1;
4348 			} else
4349 				*new_view = blame_view;
4350 		}
4351 		break;
4352 	case KEY_RESIZE:
4353 		if (s->selected > view->nlines)
4354 			s->selected = s->ndisplayed - 1;
4355 		break;
4356 	default:
4357 		break;
4358 	}
4359 
4360 	return err;
4361 }
4362 
4363 __dead static void
4364 usage_tree(void)
4365 {
4366 	endwin();
4367 	fprintf(stderr, "usage: %s tree [-c commit] [repository-path]\n",
4368 	    getprogname());
4369 	exit(1);
4370 }
4371 
4372 static const struct got_error *
4373 cmd_tree(int argc, char *argv[])
4374 {
4375 	const struct got_error *error;
4376 	struct got_repository *repo = NULL;
4377 	struct got_reflist_head refs;
4378 	char *repo_path = NULL;
4379 	struct got_object_id *commit_id = NULL;
4380 	char *commit_id_arg = NULL;
4381 	struct got_commit_object *commit = NULL;
4382 	struct got_tree_object *tree = NULL;
4383 	int ch;
4384 	struct tog_view *view;
4385 
4386 	SIMPLEQ_INIT(&refs);
4387 
4388 #ifndef PROFILE
4389 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
4390 	    NULL) == -1)
4391 		err(1, "pledge");
4392 #endif
4393 
4394 	while ((ch = getopt(argc, argv, "c:")) != -1) {
4395 		switch (ch) {
4396 		case 'c':
4397 			commit_id_arg = optarg;
4398 			break;
4399 		default:
4400 			usage_tree();
4401 			/* NOTREACHED */
4402 		}
4403 	}
4404 
4405 	argc -= optind;
4406 	argv += optind;
4407 
4408 	if (argc == 0) {
4409 		struct got_worktree *worktree;
4410 		char *cwd = getcwd(NULL, 0);
4411 		if (cwd == NULL)
4412 			return got_error_from_errno("getcwd");
4413 		error = got_worktree_open(&worktree, cwd);
4414 		if (error && error->code != GOT_ERR_NOT_WORKTREE)
4415 			goto done;
4416 		if (worktree) {
4417 			free(cwd);
4418 			repo_path =
4419 			    strdup(got_worktree_get_repo_path(worktree));
4420 			got_worktree_close(worktree);
4421 		} else
4422 			repo_path = cwd;
4423 		if (repo_path == NULL) {
4424 			error = got_error_from_errno("strdup");
4425 			goto done;
4426 		}
4427 	} else if (argc == 1) {
4428 		repo_path = realpath(argv[0], NULL);
4429 		if (repo_path == NULL)
4430 			return got_error_from_errno2("realpath", argv[0]);
4431 	} else
4432 		usage_log();
4433 
4434 	init_curses();
4435 
4436 	error = got_repo_open(&repo, repo_path);
4437 	if (error != NULL)
4438 		goto done;
4439 
4440 	error = apply_unveil(got_repo_get_path(repo), NULL);
4441 	if (error)
4442 		goto done;
4443 
4444 	if (commit_id_arg == NULL)
4445 		error = get_head_commit_id(&commit_id, GOT_REF_HEAD, repo);
4446 	else {
4447 		error = get_head_commit_id(&commit_id, commit_id_arg, repo);
4448 		if (error) {
4449 			if (error->code != GOT_ERR_NOT_REF)
4450 				goto done;
4451 			error = got_repo_match_object_id_prefix(&commit_id,
4452 			    commit_id_arg, GOT_OBJ_TYPE_COMMIT, repo);
4453 		}
4454 	}
4455 	if (error != NULL)
4456 		goto done;
4457 
4458 	error = got_object_open_as_commit(&commit, repo, commit_id);
4459 	if (error != NULL)
4460 		goto done;
4461 
4462 	error = got_object_open_as_tree(&tree, repo,
4463 	    got_object_commit_get_tree_id(commit));
4464 	if (error != NULL)
4465 		goto done;
4466 
4467 	error = got_ref_list(&refs, repo);
4468 	if (error)
4469 		goto done;
4470 
4471 	view = view_open(0, 0, 0, 0, TOG_VIEW_TREE);
4472 	if (view == NULL) {
4473 		error = got_error_from_errno("view_open");
4474 		goto done;
4475 	}
4476 	error = open_tree_view(view, tree, commit_id, &refs, repo);
4477 	if (error)
4478 		goto done;
4479 	error = view_loop(view);
4480 done:
4481 	free(repo_path);
4482 	free(commit_id);
4483 	if (commit)
4484 		got_object_commit_close(commit);
4485 	if (tree)
4486 		got_object_tree_close(tree);
4487 	if (repo)
4488 		got_repo_close(repo);
4489 	got_ref_list_free(&refs);
4490 	return error;
4491 }
4492 
4493 static void
4494 list_commands(void)
4495 {
4496 	int i;
4497 
4498 	fprintf(stderr, "commands:");
4499 	for (i = 0; i < nitems(tog_commands); i++) {
4500 		struct tog_cmd *cmd = &tog_commands[i];
4501 		fprintf(stderr, " %s", cmd->name);
4502 	}
4503 	fputc('\n', stderr);
4504 }
4505 
4506 __dead static void
4507 usage(int hflag)
4508 {
4509 	fprintf(stderr, "usage: %s [-h] [command] [arg ...]\n", getprogname());
4510 	if (hflag)
4511 		list_commands();
4512 	exit(1);
4513 }
4514 
4515 static char **
4516 make_argv(const char *arg0, const char *arg1)
4517 {
4518 	char **argv;
4519 	int argc = (arg1 == NULL ? 1 : 2);
4520 
4521 	argv = calloc(argc, sizeof(char *));
4522 	if (argv == NULL)
4523 		err(1, "calloc");
4524 	argv[0] = strdup(arg0);
4525 	if (argv[0] == NULL)
4526 		err(1, "calloc");
4527 	if (arg1) {
4528 		argv[1] = strdup(arg1);
4529 		if (argv[1] == NULL)
4530 			err(1, "calloc");
4531 	}
4532 
4533 	return argv;
4534 }
4535 
4536 int
4537 main(int argc, char *argv[])
4538 {
4539 	const struct got_error *error = NULL;
4540 	struct tog_cmd *cmd = NULL;
4541 	int ch, hflag = 0;
4542 	char **cmd_argv = NULL;
4543 
4544 	setlocale(LC_CTYPE, "");
4545 
4546 	while ((ch = getopt(argc, argv, "h")) != -1) {
4547 		switch (ch) {
4548 		case 'h':
4549 			hflag = 1;
4550 			break;
4551 		default:
4552 			usage(hflag);
4553 			/* NOTREACHED */
4554 		}
4555 	}
4556 
4557 	argc -= optind;
4558 	argv += optind;
4559 	optind = 0;
4560 	optreset = 1;
4561 
4562 	if (argc == 0) {
4563 		if (hflag)
4564 			usage(hflag);
4565 		/* Build an argument vector which runs a default command. */
4566 		cmd = &tog_commands[0];
4567 		cmd_argv = make_argv(cmd->name, NULL);
4568 		argc = 1;
4569 	} else {
4570 		int i;
4571 
4572 		/* Did the user specific a command? */
4573 		for (i = 0; i < nitems(tog_commands); i++) {
4574 			if (strncmp(tog_commands[i].name, argv[0],
4575 			    strlen(argv[0])) == 0) {
4576 				cmd = &tog_commands[i];
4577 				break;
4578 			}
4579 		}
4580 
4581 		if (cmd == NULL) {
4582 			fprintf(stderr, "%s: unknown command '%s'\n",
4583 			    getprogname(), argv[0]);
4584 			list_commands();
4585 			return 1;
4586 		}
4587 	}
4588 
4589 	if (hflag)
4590 		cmd->cmd_usage();
4591 	else
4592 		error = cmd->cmd_main(argc, cmd_argv ? cmd_argv : argv);
4593 
4594 	endwin();
4595 	free(cmd_argv);
4596 	if (error)
4597 		fprintf(stderr, "%s: %s\n", getprogname(), error->msg);
4598 	return 0;
4599 }