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