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