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