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, 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 		struct got_object_id *ref_id;
1167 		int cmp;
1168 
1169 		name = got_ref_get_name(re->ref);
1170 		if (strcmp(name, GOT_REF_HEAD) == 0)
1171 			continue;
1172 		if (strncmp(name, "refs/", 5) == 0)
1173 			name += 5;
1174 		if (strncmp(name, "got/", 4) == 0)
1175 			continue;
1176 		if (strncmp(name, "heads/", 6) == 0)
1177 			name += 6;
1178 		if (strncmp(name, "remotes/", 8) == 0) {
1179 			name += 8;
1180 			s = strstr(name, "/" GOT_REF_HEAD);
1181 			if (s != NULL && s[strlen(s)] == '\0')
1182 				continue;
1183 		}
1184 		err = got_ref_resolve(&ref_id, repo, re->ref);
1185 		if (err)
1186 			break;
1187 		if (strncmp(name, "tags/", 5) == 0) {
1188 			err = got_object_open_as_tag(&tag, repo, ref_id);
1189 			if (err) {
1190 				if (err->code != GOT_ERR_OBJ_TYPE) {
1191 					free(ref_id);
1192 					break;
1193 				}
1194 				/* Ref points at something other than a tag. */
1195 				err = NULL;
1196 				tag = NULL;
1197 			}
1198 		}
1199 		cmp = got_object_id_cmp(tag ?
1200 		    got_object_tag_get_object_id(tag) : ref_id, id);
1201 		free(ref_id);
1202 		if (tag)
1203 			got_object_tag_close(tag);
1204 		if (cmp != 0)
1205 			continue;
1206 		s = *refs_str;
1207 		if (asprintf(refs_str, "%s%s%s", s ? s : "",
1208 		    s ? ", " : "", name) == -1) {
1209 			err = got_error_from_errno("asprintf");
1210 			free(s);
1211 			*refs_str = NULL;
1212 			break;
1213 		}
1214 		free(s);
1215 	}
1216 
1217 	return err;
1218 }
1219 
1220 static const struct got_error *
1221 format_author(wchar_t **wauthor, int *author_width, char *author, int limit,
1222     int col_tab_align)
1223 {
1224 	char *smallerthan, *at;
1225 
1226 	smallerthan = strchr(author, '<');
1227 	if (smallerthan && smallerthan[1] != '\0')
1228 		author = smallerthan + 1;
1229 	at = strchr(author, '@');
1230 	if (at)
1231 		*at = '\0';
1232 	return format_line(wauthor, author_width, author, limit, col_tab_align);
1233 }
1234 
1235 static const struct got_error *
1236 draw_commit(struct tog_view *view, struct got_commit_object *commit,
1237     struct got_object_id *id, struct got_reflist_head *refs,
1238     const size_t date_display_cols, int author_display_cols,
1239     struct tog_colors *colors)
1240 {
1241 	const struct got_error *err = NULL;
1242 	char datebuf[12]; /* YYYY-MM-DD + SPACE + NUL */
1243 	char *logmsg0 = NULL, *logmsg = NULL;
1244 	char *author = NULL;
1245 	wchar_t *wlogmsg = NULL, *wauthor = NULL;
1246 	int author_width, logmsg_width;
1247 	char *newline, *line = NULL;
1248 	int col, limit;
1249 	const int avail = view->ncols;
1250 	struct tm tm;
1251 	time_t committer_time;
1252 	struct tog_color *tc;
1253 
1254 	committer_time = got_object_commit_get_committer_time(commit);
1255 	if (localtime_r(&committer_time, &tm) == NULL)
1256 		return got_error_from_errno("localtime_r");
1257 	if (strftime(datebuf, sizeof(datebuf), "%G-%m-%d ", &tm)
1258 	    >= sizeof(datebuf))
1259 		return got_error(GOT_ERR_NO_SPACE);
1260 
1261 	if (avail <= date_display_cols)
1262 		limit = MIN(sizeof(datebuf) - 1, avail);
1263 	else
1264 		limit = MIN(date_display_cols, sizeof(datebuf) - 1);
1265 	tc = get_color(colors, TOG_COLOR_DATE);
1266 	if (tc)
1267 		wattr_on(view->window,
1268 		    COLOR_PAIR(tc->colorpair), NULL);
1269 	waddnstr(view->window, datebuf, limit);
1270 	if (tc)
1271 		wattr_off(view->window,
1272 		    COLOR_PAIR(tc->colorpair), NULL);
1273 	col = limit;
1274 	if (col > avail)
1275 		goto done;
1276 
1277 	if (avail >= 120) {
1278 		char *id_str;
1279 		err = got_object_id_str(&id_str, id);
1280 		if (err)
1281 			goto done;
1282 		tc = get_color(colors, TOG_COLOR_COMMIT);
1283 		if (tc)
1284 			wattr_on(view->window,
1285 			    COLOR_PAIR(tc->colorpair), NULL);
1286 		wprintw(view->window, "%.8s ", id_str);
1287 		if (tc)
1288 			wattr_off(view->window,
1289 			    COLOR_PAIR(tc->colorpair), NULL);
1290 		free(id_str);
1291 		col += 9;
1292 		if (col > avail)
1293 			goto done;
1294 	}
1295 
1296 	author = strdup(got_object_commit_get_author(commit));
1297 	if (author == NULL) {
1298 		err = got_error_from_errno("strdup");
1299 		goto done;
1300 	}
1301 	err = format_author(&wauthor, &author_width, author, avail - col, col);
1302 	if (err)
1303 		goto done;
1304 	tc = get_color(colors, TOG_COLOR_AUTHOR);
1305 	if (tc)
1306 		wattr_on(view->window,
1307 		    COLOR_PAIR(tc->colorpair), NULL);
1308 	waddwstr(view->window, wauthor);
1309 	if (tc)
1310 		wattr_off(view->window,
1311 		    COLOR_PAIR(tc->colorpair), NULL);
1312 	col += author_width;
1313 	while (col < avail && author_width < author_display_cols + 2) {
1314 		waddch(view->window, ' ');
1315 		col++;
1316 		author_width++;
1317 	}
1318 	if (col > avail)
1319 		goto done;
1320 
1321 	err = got_object_commit_get_logmsg(&logmsg0, commit);
1322 	if (err)
1323 		goto done;
1324 	logmsg = logmsg0;
1325 	while (*logmsg == '\n')
1326 		logmsg++;
1327 	newline = strchr(logmsg, '\n');
1328 	if (newline)
1329 		*newline = '\0';
1330 	limit = avail - col;
1331 	err = format_line(&wlogmsg, &logmsg_width, logmsg, limit, col);
1332 	if (err)
1333 		goto done;
1334 	waddwstr(view->window, wlogmsg);
1335 	col += logmsg_width;
1336 	while (col < avail) {
1337 		waddch(view->window, ' ');
1338 		col++;
1339 	}
1340 done:
1341 	free(logmsg0);
1342 	free(wlogmsg);
1343 	free(author);
1344 	free(wauthor);
1345 	free(line);
1346 	return err;
1347 }
1348 
1349 static struct commit_queue_entry *
1350 alloc_commit_queue_entry(struct got_commit_object *commit,
1351     struct got_object_id *id)
1352 {
1353 	struct commit_queue_entry *entry;
1354 
1355 	entry = calloc(1, sizeof(*entry));
1356 	if (entry == NULL)
1357 		return NULL;
1358 
1359 	entry->id = id;
1360 	entry->commit = commit;
1361 	return entry;
1362 }
1363 
1364 static void
1365 pop_commit(struct commit_queue *commits)
1366 {
1367 	struct commit_queue_entry *entry;
1368 
1369 	entry = TAILQ_FIRST(&commits->head);
1370 	TAILQ_REMOVE(&commits->head, entry, entry);
1371 	got_object_commit_close(entry->commit);
1372 	commits->ncommits--;
1373 	/* Don't free entry->id! It is owned by the commit graph. */
1374 	free(entry);
1375 }
1376 
1377 static void
1378 free_commits(struct commit_queue *commits)
1379 {
1380 	while (!TAILQ_EMPTY(&commits->head))
1381 		pop_commit(commits);
1382 }
1383 
1384 static const struct got_error *
1385 match_commit(int *have_match, struct got_object_id *id,
1386     struct got_commit_object *commit, regex_t *regex)
1387 {
1388 	const struct got_error *err = NULL;
1389 	regmatch_t regmatch;
1390 	char *id_str = NULL, *logmsg = NULL;
1391 
1392 	*have_match = 0;
1393 
1394 	err = got_object_id_str(&id_str, id);
1395 	if (err)
1396 		return err;
1397 
1398 	err = got_object_commit_get_logmsg(&logmsg, commit);
1399 	if (err)
1400 		goto done;
1401 
1402 	if (regexec(regex, got_object_commit_get_author(commit), 1,
1403 	    &regmatch, 0) == 0 ||
1404 	    regexec(regex, got_object_commit_get_committer(commit), 1,
1405 	    &regmatch, 0) == 0 ||
1406 	    regexec(regex, id_str, 1, &regmatch, 0) == 0 ||
1407 	    regexec(regex, logmsg, 1, &regmatch, 0) == 0)
1408 		*have_match = 1;
1409 done:
1410 	free(id_str);
1411 	free(logmsg);
1412 	return err;
1413 }
1414 
1415 static const struct got_error *
1416 queue_commits(struct got_commit_graph *graph, struct commit_queue *commits,
1417     int minqueue, struct got_repository *repo, const char *path,
1418     int *searching, int *search_next_done, regex_t *regex)
1419 {
1420 	const struct got_error *err = NULL;
1421 	int nqueued = 0;
1422 
1423 	/*
1424 	 * We keep all commits open throughout the lifetime of the log
1425 	 * view in order to avoid having to re-fetch commits from disk
1426 	 * while updating the display.
1427 	 */
1428 	while (nqueued < minqueue ||
1429 	    (*searching == TOG_SEARCH_FORWARD && !*search_next_done)) {
1430 		struct got_object_id *id;
1431 		struct got_commit_object *commit;
1432 		struct commit_queue_entry *entry;
1433 		int errcode;
1434 
1435 		err = got_commit_graph_iter_next(&id, graph, repo, NULL, NULL);
1436 		if (err || id == NULL)
1437 			break;
1438 
1439 		err = got_object_open_as_commit(&commit, repo, id);
1440 		if (err)
1441 			break;
1442 		entry = alloc_commit_queue_entry(commit, id);
1443 		if (entry == NULL) {
1444 			err = got_error_from_errno("alloc_commit_queue_entry");
1445 			break;
1446 		}
1447 
1448 		errcode = pthread_mutex_lock(&tog_mutex);
1449 		if (errcode) {
1450 			err = got_error_set_errno(errcode,
1451 			    "pthread_mutex_lock");
1452 			break;
1453 		}
1454 
1455 		entry->idx = commits->ncommits;
1456 		TAILQ_INSERT_TAIL(&commits->head, entry, entry);
1457 		nqueued++;
1458 		commits->ncommits++;
1459 
1460 		if (*searching == TOG_SEARCH_FORWARD && !*search_next_done) {
1461 			int have_match;
1462 			err = match_commit(&have_match, id, commit, regex);
1463 			if (err)
1464 				break;
1465 			if (have_match)
1466 				*search_next_done = TOG_SEARCH_HAVE_MORE;
1467 		}
1468 
1469 		errcode = pthread_mutex_unlock(&tog_mutex);
1470 		if (errcode && err == NULL)
1471 			err = got_error_set_errno(errcode,
1472 			    "pthread_mutex_unlock");
1473 		if (err)
1474 			break;
1475 	}
1476 
1477 	return err;
1478 }
1479 
1480 static const struct got_error *
1481 draw_commits(struct tog_view *view, struct commit_queue_entry **last,
1482     struct commit_queue_entry **selected, struct commit_queue_entry *first,
1483     struct commit_queue *commits, int selected_idx, int limit,
1484     struct got_reflist_head *refs, const char *path, int commits_needed,
1485     struct tog_colors *colors)
1486 {
1487 	const struct got_error *err = NULL;
1488 	struct tog_log_view_state *s = &view->state.log;
1489 	struct commit_queue_entry *entry;
1490 	int width;
1491 	int ncommits, author_cols = 4;
1492 	char *id_str = NULL, *header = NULL, *ncommits_str = NULL;
1493 	char *refs_str = NULL;
1494 	wchar_t *wline;
1495 	struct tog_color *tc;
1496 	static const size_t date_display_cols = 12;
1497 
1498 	entry = first;
1499 	ncommits = 0;
1500 	while (entry) {
1501 		if (ncommits == selected_idx) {
1502 			*selected = entry;
1503 			break;
1504 		}
1505 		entry = TAILQ_NEXT(entry, entry);
1506 		ncommits++;
1507 	}
1508 
1509 	if (*selected && !(view->searching && view->search_next_done == 0)) {
1510 		err = got_object_id_str(&id_str, (*selected)->id);
1511 		if (err)
1512 			return err;
1513 		if (refs) {
1514 			err = build_refs_str(&refs_str, refs, (*selected)->id,
1515 			    s->repo);
1516 			if (err)
1517 				goto done;
1518 		}
1519 	}
1520 
1521 	if (commits_needed == 0)
1522 		halfdelay(10); /* disable fast refresh */
1523 
1524 	if (commits_needed > 0) {
1525 		if (asprintf(&ncommits_str, " [%d/%d] %s",
1526 		    entry ? entry->idx + 1 : 0, commits->ncommits,
1527 		    (view->searching && !view->search_next_done) ?
1528 		    "searching..." : "loading...") == -1) {
1529 			err = got_error_from_errno("asprintf");
1530 			goto done;
1531 		}
1532 	} else {
1533 		const char *search_str = NULL;
1534 
1535 		if (view->searching) {
1536 			if (view->search_next_done == TOG_SEARCH_NO_MORE)
1537 				search_str = "no more matches";
1538 			else if (view->search_next_done == TOG_SEARCH_HAVE_NONE)
1539 				search_str = "no matches found";
1540 			else if (!view->search_next_done)
1541 				search_str = "searching...";
1542 		}
1543 
1544 		if (asprintf(&ncommits_str, " [%d/%d] %s",
1545 		    entry ? entry->idx + 1 : 0, commits->ncommits,
1546 		    search_str ? search_str :
1547 		    (refs_str ? refs_str : "")) == -1) {
1548 			err = got_error_from_errno("asprintf");
1549 			goto done;
1550 		}
1551 	}
1552 
1553 	if (path && strcmp(path, "/") != 0) {
1554 		if (asprintf(&header, "commit %s %s%s",
1555 		    id_str ? id_str : "........................................",
1556 		    path, ncommits_str) == -1) {
1557 			err = got_error_from_errno("asprintf");
1558 			header = NULL;
1559 			goto done;
1560 		}
1561 	} else if (asprintf(&header, "commit %s%s",
1562 	    id_str ? id_str : "........................................",
1563 	    ncommits_str) == -1) {
1564 		err = got_error_from_errno("asprintf");
1565 		header = NULL;
1566 		goto done;
1567 	}
1568 	err = format_line(&wline, &width, header, view->ncols, 0);
1569 	if (err)
1570 		goto done;
1571 
1572 	werase(view->window);
1573 
1574 	if (view_needs_focus_indication(view))
1575 		wstandout(view->window);
1576 	tc = get_color(colors, TOG_COLOR_COMMIT);
1577 	if (tc)
1578 		wattr_on(view->window,
1579 		    COLOR_PAIR(tc->colorpair), NULL);
1580 	waddwstr(view->window, wline);
1581 	if (tc)
1582 		wattr_off(view->window,
1583 		    COLOR_PAIR(tc->colorpair), NULL);
1584 	while (width < view->ncols) {
1585 		waddch(view->window, ' ');
1586 		width++;
1587 	}
1588 	if (view_needs_focus_indication(view))
1589 		wstandend(view->window);
1590 	free(wline);
1591 	if (limit <= 1)
1592 		goto done;
1593 
1594 	/* Grow author column size if necessary. */
1595 	entry = first;
1596 	ncommits = 0;
1597 	while (entry) {
1598 		char *author;
1599 		wchar_t *wauthor;
1600 		int width;
1601 		if (ncommits >= limit - 1)
1602 			break;
1603 		author = strdup(got_object_commit_get_author(entry->commit));
1604 		if (author == NULL) {
1605 			err = got_error_from_errno("strdup");
1606 			goto done;
1607 		}
1608 		err = format_author(&wauthor, &width, author, COLS,
1609 		    date_display_cols);
1610 		if (author_cols < width)
1611 			author_cols = width;
1612 		free(wauthor);
1613 		free(author);
1614 		ncommits++;
1615 		entry = TAILQ_NEXT(entry, entry);
1616 	}
1617 
1618 	entry = first;
1619 	*last = first;
1620 	ncommits = 0;
1621 	while (entry) {
1622 		if (ncommits >= limit - 1)
1623 			break;
1624 		if (ncommits == selected_idx)
1625 			wstandout(view->window);
1626 		err = draw_commit(view, entry->commit, entry->id, refs,
1627 		    date_display_cols, author_cols, colors);
1628 		if (ncommits == selected_idx)
1629 			wstandend(view->window);
1630 		if (err)
1631 			goto done;
1632 		ncommits++;
1633 		*last = entry;
1634 		entry = TAILQ_NEXT(entry, entry);
1635 	}
1636 
1637 	view_vborder(view);
1638 done:
1639 	free(id_str);
1640 	free(refs_str);
1641 	free(ncommits_str);
1642 	free(header);
1643 	return err;
1644 }
1645 
1646 static void
1647 scroll_up(struct tog_view *view,
1648     struct commit_queue_entry **first_displayed_entry, int maxscroll,
1649     struct commit_queue *commits)
1650 {
1651 	struct commit_queue_entry *entry;
1652 	int nscrolled = 0;
1653 
1654 	entry = TAILQ_FIRST(&commits->head);
1655 	if (*first_displayed_entry == entry)
1656 		return;
1657 
1658 	entry = *first_displayed_entry;
1659 	while (entry && nscrolled < maxscroll) {
1660 		entry = TAILQ_PREV(entry, commit_queue_head, entry);
1661 		if (entry) {
1662 			*first_displayed_entry = entry;
1663 			nscrolled++;
1664 		}
1665 	}
1666 }
1667 
1668 static const struct got_error *
1669 trigger_log_thread(struct tog_view *log_view, int wait,
1670     int *commits_needed, int *log_complete,
1671     pthread_cond_t *need_commits, pthread_cond_t *commit_loaded)
1672 {
1673 	int errcode;
1674 
1675 	halfdelay(1); /* fast refresh while loading commits */
1676 
1677 	while (*commits_needed > 0) {
1678 		if (*log_complete)
1679 			break;
1680 
1681 		/* Wake the log thread. */
1682 		errcode = pthread_cond_signal(need_commits);
1683 		if (errcode)
1684 			return got_error_set_errno(errcode,
1685 			    "pthread_cond_signal");
1686 
1687 		/*
1688 		 * The mutex will be released while the view loop waits
1689 		 * in wgetch(), at which time the log thread will run.
1690 		 */
1691 		if (!wait)
1692 			break;
1693 
1694 		/* Display progress update in log view. */
1695 		show_log_view(log_view);
1696 		update_panels();
1697 		doupdate();
1698 
1699 		/* Wait right here while next commit is being loaded. */
1700 		errcode = pthread_cond_wait(commit_loaded, &tog_mutex);
1701 		if (errcode)
1702 			return got_error_set_errno(errcode,
1703 			    "pthread_cond_wait");
1704 
1705 		/* Display progress update in log view. */
1706 		show_log_view(log_view);
1707 		update_panels();
1708 		doupdate();
1709 	}
1710 
1711 	return NULL;
1712 }
1713 
1714 static const struct got_error *
1715 scroll_down(struct tog_view *log_view,
1716     struct commit_queue_entry **first_displayed_entry, int maxscroll,
1717     struct commit_queue_entry **last_displayed_entry,
1718     struct commit_queue *commits, int *log_complete, int *commits_needed,
1719     pthread_cond_t *need_commits, pthread_cond_t *commit_loaded)
1720 {
1721 	const struct got_error *err = NULL;
1722 	struct commit_queue_entry *pentry;
1723 	int nscrolled = 0, ncommits_needed;
1724 
1725 	if (*last_displayed_entry == NULL)
1726 		return NULL;
1727 
1728 	ncommits_needed = (*last_displayed_entry)->idx + 1 + maxscroll;
1729 	if (commits->ncommits < ncommits_needed && !*log_complete) {
1730 		/*
1731 		 * Ask the log thread for required amount of commits.
1732 		 */
1733 		(*commits_needed) += maxscroll;
1734 		err = trigger_log_thread(log_view, 1, commits_needed,
1735 		    log_complete, need_commits, commit_loaded);
1736 		if (err)
1737 			return err;
1738 	}
1739 
1740 	do {
1741 		pentry = TAILQ_NEXT(*last_displayed_entry, entry);
1742 		if (pentry == NULL)
1743 			break;
1744 
1745 		*last_displayed_entry = pentry;
1746 
1747 		pentry = TAILQ_NEXT(*first_displayed_entry, entry);
1748 		if (pentry == NULL)
1749 			break;
1750 		*first_displayed_entry = pentry;
1751 	} while (++nscrolled < maxscroll);
1752 
1753 	return err;
1754 }
1755 
1756 static const struct got_error *
1757 open_diff_view_for_commit(struct tog_view **new_view, int begin_x,
1758     struct got_commit_object *commit, struct got_object_id *commit_id,
1759     struct tog_view *log_view, struct got_reflist_head *refs,
1760     struct got_repository *repo)
1761 {
1762 	const struct got_error *err;
1763 	struct got_object_qid *parent_id;
1764 	struct tog_view *diff_view;
1765 
1766 	diff_view = view_open(0, 0, 0, begin_x, TOG_VIEW_DIFF);
1767 	if (diff_view == NULL)
1768 		return got_error_from_errno("view_open");
1769 
1770 	parent_id = SIMPLEQ_FIRST(got_object_commit_get_parent_ids(commit));
1771 	err = open_diff_view(diff_view, parent_id ? parent_id->id : NULL,
1772 	    commit_id, log_view, refs, repo);
1773 	if (err == NULL)
1774 		*new_view = diff_view;
1775 	return err;
1776 }
1777 
1778 static const struct got_error *
1779 tree_view_visit_subtree(struct got_tree_object *subtree,
1780     struct tog_tree_view_state *s)
1781 {
1782 	struct tog_parent_tree *parent;
1783 
1784 	parent = calloc(1, sizeof(*parent));
1785 	if (parent == NULL)
1786 		return got_error_from_errno("calloc");
1787 
1788 	parent->tree = s->tree;
1789 	parent->first_displayed_entry = s->first_displayed_entry;
1790 	parent->selected_entry = s->selected_entry;
1791 	parent->selected = s->selected;
1792 	TAILQ_INSERT_HEAD(&s->parents, parent, entry);
1793 	s->tree = subtree;
1794 	s->selected = 0;
1795 	s->first_displayed_entry = NULL;
1796 	return NULL;
1797 }
1798 
1799 static const struct got_error *
1800 tree_view_walk_path(struct tog_tree_view_state *s,
1801     struct got_object_id *commit_id,
1802     const char *path, struct got_repository *repo)
1803 {
1804 	const struct got_error *err = NULL;
1805 	struct got_tree_object *tree = NULL;
1806 	const char *p;
1807 	char *slash, *subpath = NULL;
1808 
1809 	/* Walk the path and open corresponding tree objects. */
1810 	p = path;
1811 	while (*p) {
1812 		struct got_tree_entry *te;
1813 		struct got_object_id *tree_id;
1814 		char *te_name;
1815 
1816 		while (p[0] == '/')
1817 			p++;
1818 
1819 		/* Ensure the correct subtree entry is selected. */
1820 		slash = strchr(p, '/');
1821 		if (slash == NULL)
1822 			te_name = strdup(p);
1823 		else
1824 			te_name = strndup(p, slash - p);
1825 		if (te_name == NULL) {
1826 			err = got_error_from_errno("strndup");
1827 			break;
1828 		}
1829 		te = got_object_tree_find_entry(s->tree, te_name);
1830 		if (te == NULL) {
1831 			err = got_error_path(te_name, GOT_ERR_NO_TREE_ENTRY);
1832 			free(te_name);
1833 			break;
1834 		}
1835 		free(te_name);
1836 		s->selected_entry = te;
1837 		s->selected = got_tree_entry_get_index(te);
1838 		if (s->tree != s->root)
1839 			s->selected++; /* skip '..' */
1840 
1841 		if (!S_ISDIR(got_tree_entry_get_mode(s->selected_entry))) {
1842 			/* Jump to this file's entry. */
1843 			s->first_displayed_entry = s->selected_entry;
1844 			s->selected = 0;
1845 			break;
1846 		}
1847 
1848 		slash = strchr(p, '/');
1849 		if (slash)
1850 			subpath = strndup(path, slash - path);
1851 		else
1852 			subpath = strdup(path);
1853 		if (subpath == NULL) {
1854 			err = got_error_from_errno("strdup");
1855 			break;
1856 		}
1857 
1858 		err = got_object_id_by_path(&tree_id, repo, commit_id,
1859 		    subpath);
1860 		if (err)
1861 			break;
1862 
1863 		err = got_object_open_as_tree(&tree, repo, tree_id);
1864 		free(tree_id);
1865 		if (err)
1866 			break;
1867 
1868 		err = tree_view_visit_subtree(tree, s);
1869 		if (err) {
1870 			got_object_tree_close(tree);
1871 			break;
1872 		}
1873 		if (slash == NULL)
1874 			break;
1875 		free(subpath);
1876 		subpath = NULL;
1877 		p = slash;
1878 	}
1879 
1880 	free(subpath);
1881 	return err;
1882 }
1883 
1884 static const struct got_error *
1885 browse_commit_tree(struct tog_view **new_view, int begin_x,
1886     struct commit_queue_entry *entry, const char *path,
1887     struct got_reflist_head *refs, struct got_repository *repo)
1888 {
1889 	const struct got_error *err = NULL;
1890 	struct got_tree_object *tree;
1891 	struct tog_tree_view_state *s;
1892 	struct tog_view *tree_view;
1893 
1894 	err = got_object_open_as_tree(&tree, repo,
1895 	    got_object_commit_get_tree_id(entry->commit));
1896 	if (err)
1897 		return err;
1898 
1899 	tree_view = view_open(0, 0, 0, begin_x, TOG_VIEW_TREE);
1900 	if (tree_view == NULL)
1901 		return got_error_from_errno("view_open");
1902 
1903 	err = open_tree_view(tree_view, tree, entry->id, refs, repo);
1904 	if (err) {
1905 		got_object_tree_close(tree);
1906 		return err;
1907 	}
1908 	s = &tree_view->state.tree;
1909 
1910 	*new_view = tree_view;
1911 
1912 	if (got_path_is_root_dir(path))
1913 		return NULL;
1914 
1915 	return tree_view_walk_path(s, entry->id, path, repo);
1916 }
1917 
1918 static const struct got_error *
1919 block_signals_used_by_main_thread(void)
1920 {
1921 	sigset_t sigset;
1922 	int errcode;
1923 
1924 	if (sigemptyset(&sigset) == -1)
1925 		return got_error_from_errno("sigemptyset");
1926 
1927 	/* tog handles SIGWINCH and SIGCONT */
1928 	if (sigaddset(&sigset, SIGWINCH) == -1)
1929 		return got_error_from_errno("sigaddset");
1930 	if (sigaddset(&sigset, SIGCONT) == -1)
1931 		return got_error_from_errno("sigaddset");
1932 
1933 	/* ncurses handles SIGTSTP */
1934 	if (sigaddset(&sigset, SIGTSTP) == -1)
1935 		return got_error_from_errno("sigaddset");
1936 
1937 	errcode = pthread_sigmask(SIG_BLOCK, &sigset, NULL);
1938 	if (errcode)
1939 		return got_error_set_errno(errcode, "pthread_sigmask");
1940 
1941 	return NULL;
1942 }
1943 
1944 static void *
1945 log_thread(void *arg)
1946 {
1947 	const struct got_error *err = NULL;
1948 	int errcode = 0;
1949 	struct tog_log_thread_args *a = arg;
1950 	int done = 0;
1951 
1952 	err = block_signals_used_by_main_thread();
1953 	if (err)
1954 		return (void *)err;
1955 
1956 	while (!done && !err && !tog_sigpipe_received) {
1957 		err = queue_commits(a->graph, a->commits, 1, a->repo,
1958 		    a->in_repo_path, a->searching, a->search_next_done,
1959 		    a->regex);
1960 		if (err) {
1961 			if (err->code != GOT_ERR_ITER_COMPLETED)
1962 				return (void *)err;
1963 			err = NULL;
1964 			done = 1;
1965 		} else if (a->commits_needed > 0)
1966 			a->commits_needed--;
1967 
1968 		errcode = pthread_mutex_lock(&tog_mutex);
1969 		if (errcode) {
1970 			err = got_error_set_errno(errcode,
1971 			    "pthread_mutex_lock");
1972 			break;
1973 		} else if (*a->quit)
1974 			done = 1;
1975 		else if (*a->first_displayed_entry == NULL) {
1976 			*a->first_displayed_entry =
1977 			    TAILQ_FIRST(&a->commits->head);
1978 			*a->selected_entry = *a->first_displayed_entry;
1979 		}
1980 
1981 		errcode = pthread_cond_signal(&a->commit_loaded);
1982 		if (errcode) {
1983 			err = got_error_set_errno(errcode,
1984 			    "pthread_cond_signal");
1985 			pthread_mutex_unlock(&tog_mutex);
1986 			break;
1987 		}
1988 
1989 		if (done)
1990 			a->commits_needed = 0;
1991 		else {
1992 			if (a->commits_needed == 0) {
1993 				errcode = pthread_cond_wait(&a->need_commits,
1994 				    &tog_mutex);
1995 				if (errcode)
1996 					err = got_error_set_errno(errcode,
1997 					    "pthread_cond_wait");
1998 			}
1999 		}
2000 
2001 		errcode = pthread_mutex_unlock(&tog_mutex);
2002 		if (errcode && err == NULL)
2003 			err = got_error_set_errno(errcode,
2004 			    "pthread_mutex_unlock");
2005 	}
2006 	a->log_complete = 1;
2007 	return (void *)err;
2008 }
2009 
2010 static const struct got_error *
2011 stop_log_thread(struct tog_log_view_state *s)
2012 {
2013 	const struct got_error *err = NULL;
2014 	int errcode;
2015 
2016 	if (s->thread) {
2017 		s->quit = 1;
2018 		errcode = pthread_cond_signal(&s->thread_args.need_commits);
2019 		if (errcode)
2020 			return got_error_set_errno(errcode,
2021 			    "pthread_cond_signal");
2022 		errcode = pthread_mutex_unlock(&tog_mutex);
2023 		if (errcode)
2024 			return got_error_set_errno(errcode,
2025 			    "pthread_mutex_unlock");
2026 		errcode = pthread_join(s->thread, (void **)&err);
2027 		if (errcode)
2028 			return got_error_set_errno(errcode, "pthread_join");
2029 		errcode = pthread_mutex_lock(&tog_mutex);
2030 		if (errcode)
2031 			return got_error_set_errno(errcode,
2032 			    "pthread_mutex_lock");
2033 		s->thread = NULL;
2034 	}
2035 
2036 	errcode = pthread_cond_destroy(&s->thread_args.need_commits);
2037 	if (errcode && err == NULL)
2038 		err = got_error_set_errno(errcode, "pthread_cond_destroy");
2039 
2040 	if (s->thread_args.repo) {
2041 		got_repo_close(s->thread_args.repo);
2042 		s->thread_args.repo = NULL;
2043 	}
2044 
2045 	if (s->thread_args.graph) {
2046 		got_commit_graph_close(s->thread_args.graph);
2047 		s->thread_args.graph = NULL;
2048 	}
2049 
2050 	return err;
2051 }
2052 
2053 static const struct got_error *
2054 close_log_view(struct tog_view *view)
2055 {
2056 	const struct got_error *err = NULL;
2057 	struct tog_log_view_state *s = &view->state.log;
2058 
2059 	err = stop_log_thread(s);
2060 	free_commits(&s->commits);
2061 	free(s->in_repo_path);
2062 	s->in_repo_path = NULL;
2063 	free(s->start_id);
2064 	s->start_id = NULL;
2065 	return err;
2066 }
2067 
2068 static const struct got_error *
2069 search_start_log_view(struct tog_view *view)
2070 {
2071 	struct tog_log_view_state *s = &view->state.log;
2072 
2073 	s->matched_entry = NULL;
2074 	s->search_entry = NULL;
2075 	return NULL;
2076 }
2077 
2078 static const struct got_error *
2079 search_next_log_view(struct tog_view *view)
2080 {
2081 	const struct got_error *err = NULL;
2082 	struct tog_log_view_state *s = &view->state.log;
2083 	struct commit_queue_entry *entry;
2084 
2085 	/* Display progress update in log view. */
2086 	show_log_view(view);
2087 	update_panels();
2088 	doupdate();
2089 
2090 	if (s->search_entry) {
2091 		int errcode, ch;
2092 		errcode = pthread_mutex_unlock(&tog_mutex);
2093 		if (errcode)
2094 			return got_error_set_errno(errcode,
2095 			    "pthread_mutex_unlock");
2096 		ch = wgetch(view->window);
2097 		errcode = pthread_mutex_lock(&tog_mutex);
2098 		if (errcode)
2099 			return got_error_set_errno(errcode,
2100 			    "pthread_mutex_lock");
2101 		if (ch == KEY_BACKSPACE) {
2102 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
2103 			return NULL;
2104 		}
2105 		if (view->searching == TOG_SEARCH_FORWARD)
2106 			entry = TAILQ_NEXT(s->search_entry, entry);
2107 		else
2108 			entry = TAILQ_PREV(s->search_entry,
2109 			    commit_queue_head, entry);
2110 	} else if (s->matched_entry) {
2111 		if (view->searching == TOG_SEARCH_FORWARD)
2112 			entry = TAILQ_NEXT(s->matched_entry, entry);
2113 		else
2114 			entry = TAILQ_PREV(s->matched_entry,
2115 			    commit_queue_head, entry);
2116 	} else {
2117 		if (view->searching == TOG_SEARCH_FORWARD)
2118 			entry = TAILQ_FIRST(&s->commits.head);
2119 		else
2120 			entry = TAILQ_LAST(&s->commits.head, commit_queue_head);
2121 	}
2122 
2123 	while (1) {
2124 		int have_match = 0;
2125 
2126 		if (entry == NULL) {
2127 			if (s->thread_args.log_complete ||
2128 			    view->searching == TOG_SEARCH_BACKWARD) {
2129 				view->search_next_done =
2130 				    (s->matched_entry == NULL ?
2131 				    TOG_SEARCH_HAVE_NONE : TOG_SEARCH_NO_MORE);
2132 				s->search_entry = NULL;
2133 				return NULL;
2134 			}
2135 			/*
2136 			 * Poke the log thread for more commits and return,
2137 			 * allowing the main loop to make progress. Search
2138 			 * will resume at s->search_entry once we come back.
2139 			 */
2140 			s->thread_args.commits_needed++;
2141 			return trigger_log_thread(view, 0,
2142 			    &s->thread_args.commits_needed,
2143 			    &s->thread_args.log_complete,
2144 			    &s->thread_args.need_commits,
2145 			    &s->thread_args.commit_loaded);
2146 		}
2147 
2148 		err = match_commit(&have_match, entry->id, entry->commit,
2149 		    &view->regex);
2150 		if (err)
2151 			break;
2152 		if (have_match) {
2153 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
2154 			s->matched_entry = entry;
2155 			break;
2156 		}
2157 
2158 		s->search_entry = entry;
2159 		if (view->searching == TOG_SEARCH_FORWARD)
2160 			entry = TAILQ_NEXT(entry, entry);
2161 		else
2162 			entry = TAILQ_PREV(entry, commit_queue_head, entry);
2163 	}
2164 
2165 	if (s->matched_entry) {
2166 		int cur = s->selected_entry->idx;
2167 		while (cur < s->matched_entry->idx) {
2168 			err = input_log_view(NULL, NULL, NULL, view, KEY_DOWN);
2169 			if (err)
2170 				return err;
2171 			cur++;
2172 		}
2173 		while (cur > s->matched_entry->idx) {
2174 			err = input_log_view(NULL, NULL, NULL, view, KEY_UP);
2175 			if (err)
2176 				return err;
2177 			cur--;
2178 		}
2179 	}
2180 
2181 	s->search_entry = NULL;
2182 
2183 	return NULL;
2184 }
2185 
2186 static const struct got_error *
2187 open_log_view(struct tog_view *view, struct got_object_id *start_id,
2188     struct got_reflist_head *refs, struct got_repository *repo,
2189     const char *head_ref_name, const char *in_repo_path,
2190     int log_branches)
2191 {
2192 	const struct got_error *err = NULL;
2193 	struct tog_log_view_state *s = &view->state.log;
2194 	struct got_repository *thread_repo = NULL;
2195 	struct got_commit_graph *thread_graph = NULL;
2196 	int errcode;
2197 
2198 	if (in_repo_path != s->in_repo_path) {
2199 		free(s->in_repo_path);
2200 		s->in_repo_path = strdup(in_repo_path);
2201 		if (s->in_repo_path == NULL)
2202 			return got_error_from_errno("strdup");
2203 	}
2204 
2205 	/* The commit queue only contains commits being displayed. */
2206 	TAILQ_INIT(&s->commits.head);
2207 	s->commits.ncommits = 0;
2208 
2209 	s->refs = refs;
2210 	s->repo = repo;
2211 	s->head_ref_name = head_ref_name;
2212 	s->start_id = got_object_id_dup(start_id);
2213 	if (s->start_id == NULL) {
2214 		err = got_error_from_errno("got_object_id_dup");
2215 		goto done;
2216 	}
2217 	s->log_branches = log_branches;
2218 
2219 	SIMPLEQ_INIT(&s->colors);
2220 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
2221 		err = add_color(&s->colors, "^$", TOG_COLOR_COMMIT,
2222 		    get_color_value("TOG_COLOR_COMMIT"));
2223 		if (err)
2224 			goto done;
2225 		err = add_color(&s->colors, "^$", TOG_COLOR_AUTHOR,
2226 		    get_color_value("TOG_COLOR_AUTHOR"));
2227 		if (err) {
2228 			free_colors(&s->colors);
2229 			goto done;
2230 		}
2231 		err = add_color(&s->colors, "^$", TOG_COLOR_DATE,
2232 		    get_color_value("TOG_COLOR_DATE"));
2233 		if (err) {
2234 			free_colors(&s->colors);
2235 			goto done;
2236 		}
2237 	}
2238 
2239 	view->show = show_log_view;
2240 	view->input = input_log_view;
2241 	view->close = close_log_view;
2242 	view->search_start = search_start_log_view;
2243 	view->search_next = search_next_log_view;
2244 
2245 	err = got_repo_open(&thread_repo, got_repo_get_path(repo), NULL);
2246 	if (err)
2247 		goto done;
2248 	err = got_commit_graph_open(&thread_graph, s->in_repo_path,
2249 	    !s->log_branches);
2250 	if (err)
2251 		goto done;
2252 	err = got_commit_graph_iter_start(thread_graph, s->start_id,
2253 	    s->repo, NULL, NULL);
2254 	if (err)
2255 		goto done;
2256 
2257 	errcode = pthread_cond_init(&s->thread_args.need_commits, NULL);
2258 	if (errcode) {
2259 		err = got_error_set_errno(errcode, "pthread_cond_init");
2260 		goto done;
2261 	}
2262 	errcode = pthread_cond_init(&s->thread_args.commit_loaded, NULL);
2263 	if (errcode) {
2264 		err = got_error_set_errno(errcode, "pthread_cond_init");
2265 		goto done;
2266 	}
2267 
2268 	s->thread_args.commits_needed = view->nlines;
2269 	s->thread_args.graph = thread_graph;
2270 	s->thread_args.commits = &s->commits;
2271 	s->thread_args.in_repo_path = s->in_repo_path;
2272 	s->thread_args.start_id = s->start_id;
2273 	s->thread_args.repo = thread_repo;
2274 	s->thread_args.log_complete = 0;
2275 	s->thread_args.quit = &s->quit;
2276 	s->thread_args.first_displayed_entry = &s->first_displayed_entry;
2277 	s->thread_args.selected_entry = &s->selected_entry;
2278 	s->thread_args.searching = &view->searching;
2279 	s->thread_args.search_next_done = &view->search_next_done;
2280 	s->thread_args.regex = &view->regex;
2281 done:
2282 	if (err)
2283 		close_log_view(view);
2284 	return err;
2285 }
2286 
2287 static const struct got_error *
2288 show_log_view(struct tog_view *view)
2289 {
2290 	struct tog_log_view_state *s = &view->state.log;
2291 
2292 	if (s->thread == NULL) {
2293 		int errcode = pthread_create(&s->thread, NULL, log_thread,
2294 		    &s->thread_args);
2295 		if (errcode)
2296 			return got_error_set_errno(errcode, "pthread_create");
2297 	}
2298 
2299 	return draw_commits(view, &s->last_displayed_entry,
2300 	    &s->selected_entry, s->first_displayed_entry,
2301 	    &s->commits, s->selected, view->nlines, s->refs,
2302 	    s->in_repo_path, s->thread_args.commits_needed, &s->colors);
2303 }
2304 
2305 static const struct got_error *
2306 input_log_view(struct tog_view **new_view, struct tog_view **dead_view,
2307     struct tog_view **focus_view, struct tog_view *view, int ch)
2308 {
2309 	const struct got_error *err = NULL;
2310 	struct tog_log_view_state *s = &view->state.log;
2311 	char *parent_path, *in_repo_path = NULL;
2312 	struct tog_view *diff_view = NULL, *tree_view = NULL, *lv = NULL;
2313 	int begin_x = 0;
2314 	struct got_object_id *start_id;
2315 
2316 	switch (ch) {
2317 	case 'q':
2318 		s->quit = 1;
2319 		break;
2320 	case 'k':
2321 	case KEY_UP:
2322 	case '<':
2323 	case ',':
2324 		if (s->first_displayed_entry == NULL)
2325 			break;
2326 		if (s->selected > 0)
2327 			s->selected--;
2328 		else
2329 			scroll_up(view, &s->first_displayed_entry, 1,
2330 			    &s->commits);
2331 		break;
2332 	case KEY_PPAGE:
2333 	case CTRL('b'):
2334 		if (s->first_displayed_entry == NULL)
2335 			break;
2336 		if (TAILQ_FIRST(&s->commits.head) ==
2337 		    s->first_displayed_entry) {
2338 			s->selected = 0;
2339 			break;
2340 		}
2341 		scroll_up(view, &s->first_displayed_entry,
2342 		    view->nlines - 1, &s->commits);
2343 		break;
2344 	case 'j':
2345 	case KEY_DOWN:
2346 	case '>':
2347 	case '.':
2348 		if (s->first_displayed_entry == NULL)
2349 			break;
2350 		if (s->selected < MIN(view->nlines - 2,
2351 		    s->commits.ncommits - 1)) {
2352 			s->selected++;
2353 			break;
2354 		}
2355 		err = scroll_down(view, &s->first_displayed_entry, 1,
2356 		    &s->last_displayed_entry, &s->commits,
2357 		    &s->thread_args.log_complete,
2358 		    &s->thread_args.commits_needed,
2359 		    &s->thread_args.need_commits,
2360 		    &s->thread_args.commit_loaded);
2361 		break;
2362 	case KEY_NPAGE:
2363 	case CTRL('f'): {
2364 		struct commit_queue_entry *first;
2365 		first = s->first_displayed_entry;
2366 		if (first == NULL)
2367 			break;
2368 		err = scroll_down(view, &s->first_displayed_entry,
2369 		    view->nlines - 1, &s->last_displayed_entry,
2370 		    &s->commits, &s->thread_args.log_complete,
2371 		    &s->thread_args.commits_needed,
2372 		    &s->thread_args.need_commits,
2373 		    &s->thread_args.commit_loaded);
2374 		if (err)
2375 			break;
2376 		if (first == s->first_displayed_entry &&
2377 		    s->selected < MIN(view->nlines - 2,
2378 		    s->commits.ncommits - 1)) {
2379 			/* can't scroll further down */
2380 			s->selected = MIN(view->nlines - 2,
2381 			    s->commits.ncommits - 1);
2382 		}
2383 		err = NULL;
2384 		break;
2385 	}
2386 	case KEY_RESIZE:
2387 		if (s->selected > view->nlines - 2)
2388 			s->selected = view->nlines - 2;
2389 		if (s->selected > s->commits.ncommits - 1)
2390 			s->selected = s->commits.ncommits - 1;
2391 		break;
2392 	case KEY_ENTER:
2393 	case ' ':
2394 	case '\r':
2395 		if (s->selected_entry == NULL)
2396 			break;
2397 		if (view_is_parent_view(view))
2398 			begin_x = view_split_begin_x(view->begin_x);
2399 		err = open_diff_view_for_commit(&diff_view, begin_x,
2400 		    s->selected_entry->commit, s->selected_entry->id,
2401 		    view, s->refs, s->repo);
2402 		if (err)
2403 			break;
2404 		if (view_is_parent_view(view)) {
2405 			err = view_close_child(view);
2406 			if (err)
2407 				return err;
2408 			err = view_set_child(view, diff_view);
2409 			if (err) {
2410 				view_close(diff_view);
2411 				break;
2412 			}
2413 			*focus_view = diff_view;
2414 			view->child_focussed = 1;
2415 		} else
2416 			*new_view = diff_view;
2417 		break;
2418 	case 't':
2419 		if (s->selected_entry == NULL)
2420 			break;
2421 		if (view_is_parent_view(view))
2422 			begin_x = view_split_begin_x(view->begin_x);
2423 		err = browse_commit_tree(&tree_view, begin_x,
2424 		    s->selected_entry, s->in_repo_path, s->refs, s->repo);
2425 		if (err)
2426 			break;
2427 		if (view_is_parent_view(view)) {
2428 			err = view_close_child(view);
2429 			if (err)
2430 				return err;
2431 			err = view_set_child(view, tree_view);
2432 			if (err) {
2433 				view_close(tree_view);
2434 				break;
2435 			}
2436 			*focus_view = tree_view;
2437 			view->child_focussed = 1;
2438 		} else
2439 			*new_view = tree_view;
2440 		break;
2441 	case KEY_BACKSPACE:
2442 		if (got_path_cmp(s->in_repo_path, "/",
2443 		    strlen(s->in_repo_path), 1) == 0)
2444 			break;
2445 		err = got_path_dirname(&parent_path, s->in_repo_path);
2446 		if (err)
2447 			return err;
2448 		err = stop_log_thread(s);
2449 		if (err) {
2450 			free(parent_path);
2451 			return err;
2452 		}
2453 		lv = view_open(view->nlines, view->ncols,
2454 		    view->begin_y, view->begin_x, TOG_VIEW_LOG);
2455 		if (lv == NULL) {
2456 			free(parent_path);
2457 			return got_error_from_errno("view_open");
2458 		}
2459 		err = open_log_view(lv, s->start_id, s->refs,
2460 		    s->repo, s->head_ref_name, parent_path,
2461 		    s->log_branches);
2462 		free(parent_path);
2463 		if (err)
2464 			return err;;
2465 		if (view_is_parent_view(view))
2466 			*new_view = lv;
2467 		else {
2468 			view_set_child(view->parent, lv);
2469 			*focus_view = lv;
2470 		}
2471 		break;
2472 	case CTRL('l'):
2473 		err = stop_log_thread(s);
2474 		if (err)
2475 			return err;
2476 		lv = view_open(view->nlines, view->ncols,
2477 		    view->begin_y, view->begin_x, TOG_VIEW_LOG);
2478 		if (lv == NULL)
2479 			return got_error_from_errno("view_open");
2480 		err = got_repo_match_object_id(&start_id, NULL,
2481 		    s->head_ref_name ? s->head_ref_name : GOT_REF_HEAD,
2482 		    GOT_OBJ_TYPE_COMMIT, 1, s->repo);
2483 		if (err) {
2484 			view_close(lv);
2485 			return err;
2486 		}
2487 		in_repo_path = strdup(s->in_repo_path);
2488 		if (in_repo_path == NULL) {
2489 			free(start_id);
2490 			view_close(lv);
2491 			return got_error_from_errno("strdup");
2492 		}
2493 		got_ref_list_free(s->refs);
2494 		err = got_ref_list(s->refs, s->repo, NULL,
2495 		    got_ref_cmp_by_name, NULL);
2496 		if (err) {
2497 			free(start_id);
2498 			view_close(lv);
2499 			return err;
2500 		}
2501 		err = open_log_view(lv, start_id, s->refs, s->repo,
2502 		    s->head_ref_name, in_repo_path, s->log_branches);
2503 		if (err) {
2504 			free(start_id);
2505 			view_close(lv);
2506 			return err;;
2507 		}
2508 		*dead_view = view;
2509 		*new_view = lv;
2510 		break;
2511 	case 'B':
2512 		s->log_branches = !s->log_branches;
2513 		err = stop_log_thread(s);
2514 		if (err)
2515 			return err;
2516 		lv = view_open(view->nlines, view->ncols,
2517 		    view->begin_y, view->begin_x, TOG_VIEW_LOG);
2518 		if (lv == NULL)
2519 			return got_error_from_errno("view_open");
2520 		err = open_log_view(lv, s->start_id, s->refs, s->repo,
2521 		    s->head_ref_name, s->in_repo_path, s->log_branches);
2522 		if (err) {
2523 			view_close(lv);
2524 			return err;;
2525 		}
2526 		*dead_view = view;
2527 		*new_view = lv;
2528 		break;
2529 	default:
2530 		break;
2531 	}
2532 
2533 	return err;
2534 }
2535 
2536 static const struct got_error *
2537 apply_unveil(const char *repo_path, const char *worktree_path)
2538 {
2539 	const struct got_error *error;
2540 
2541 #ifdef PROFILE
2542 	if (unveil("gmon.out", "rwc") != 0)
2543 		return got_error_from_errno2("unveil", "gmon.out");
2544 #endif
2545 	if (repo_path && unveil(repo_path, "r") != 0)
2546 		return got_error_from_errno2("unveil", repo_path);
2547 
2548 	if (worktree_path && unveil(worktree_path, "rwc") != 0)
2549 		return got_error_from_errno2("unveil", worktree_path);
2550 
2551 	if (unveil(GOT_TMPDIR_STR, "rwc") != 0)
2552 		return got_error_from_errno2("unveil", GOT_TMPDIR_STR);
2553 
2554 	error = got_privsep_unveil_exec_helpers();
2555 	if (error != NULL)
2556 		return error;
2557 
2558 	if (unveil(NULL, NULL) != 0)
2559 		return got_error_from_errno("unveil");
2560 
2561 	return NULL;
2562 }
2563 
2564 static void
2565 init_curses(void)
2566 {
2567 	initscr();
2568 	cbreak();
2569 	halfdelay(1); /* Do fast refresh while initial view is loading. */
2570 	noecho();
2571 	nonl();
2572 	intrflush(stdscr, FALSE);
2573 	keypad(stdscr, TRUE);
2574 	curs_set(0);
2575 	if (getenv("TOG_COLORS") != NULL) {
2576 		start_color();
2577 		use_default_colors();
2578 	}
2579 	signal(SIGWINCH, tog_sigwinch);
2580 	signal(SIGPIPE, tog_sigpipe);
2581 	signal(SIGCONT, tog_sigcont);
2582 }
2583 
2584 static const struct got_error *
2585 get_in_repo_path_from_argv0(char **in_repo_path, int argc, char *argv[],
2586     struct got_repository *repo, struct got_worktree *worktree)
2587 {
2588 	const struct got_error *err = NULL;
2589 
2590 	if (argc == 0) {
2591 		*in_repo_path = strdup("/");
2592 		if (*in_repo_path == NULL)
2593 			return got_error_from_errno("strdup");
2594 		return NULL;
2595 	}
2596 
2597 	if (worktree) {
2598 		const char *prefix = got_worktree_get_path_prefix(worktree);
2599 		char *wt_path, *p;
2600 
2601 		err = got_worktree_resolve_path(&wt_path, worktree, argv[0]);
2602 		if (err)
2603 			return err;
2604 
2605 		if (asprintf(&p, "%s%s%s", prefix,
2606 		    (strcmp(prefix, "/") != 0) ? "/" : "", wt_path) == -1) {
2607 			err = got_error_from_errno("asprintf");
2608 			free(wt_path);
2609 			return err;
2610 		}
2611 		err = got_repo_map_path(in_repo_path, repo, p, 0);
2612 		free(p);
2613 		free(wt_path);
2614 	} else
2615 		err = got_repo_map_path(in_repo_path, repo, argv[0], 1);
2616 
2617 	return err;
2618 }
2619 
2620 static const struct got_error *
2621 cmd_log(int argc, char *argv[])
2622 {
2623 	const struct got_error *error;
2624 	struct got_repository *repo = NULL;
2625 	struct got_worktree *worktree = NULL;
2626 	struct got_reflist_head refs;
2627 	struct got_object_id *start_id = NULL;
2628 	char *in_repo_path = NULL, *repo_path = NULL, *cwd = NULL;
2629 	char *start_commit = NULL, *head_ref_name = NULL;
2630 	int ch, log_branches = 0;
2631 	struct tog_view *view;
2632 
2633 	SIMPLEQ_INIT(&refs);
2634 
2635 #ifndef PROFILE
2636 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
2637 	    NULL) == -1)
2638 		err(1, "pledge");
2639 #endif
2640 
2641 	while ((ch = getopt(argc, argv, "bc:r:")) != -1) {
2642 		switch (ch) {
2643 		case 'b':
2644 			log_branches = 1;
2645 			break;
2646 		case 'c':
2647 			start_commit = optarg;
2648 			break;
2649 		case 'r':
2650 			repo_path = realpath(optarg, NULL);
2651 			if (repo_path == NULL)
2652 				return got_error_from_errno2("realpath",
2653 				    optarg);
2654 			break;
2655 		default:
2656 			usage_log();
2657 			/* NOTREACHED */
2658 		}
2659 	}
2660 
2661 	argc -= optind;
2662 	argv += optind;
2663 
2664 	if (argc > 1)
2665 		usage_log();
2666 
2667 	cwd = getcwd(NULL, 0);
2668 	if (cwd == NULL)
2669 		return got_error_from_errno("getcwd");
2670 
2671 	error = got_worktree_open(&worktree, cwd);
2672 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
2673 		goto done;
2674 
2675 	if (repo_path == NULL) {
2676 		if (worktree)
2677 			repo_path =
2678 			    strdup(got_worktree_get_repo_path(worktree));
2679 		else
2680 			repo_path = strdup(cwd);
2681 	}
2682 	if (repo_path == NULL) {
2683 		error = got_error_from_errno("strdup");
2684 		goto done;
2685 	}
2686 
2687 	error = got_repo_open(&repo, repo_path, NULL);
2688 	if (error != NULL)
2689 		goto done;
2690 
2691 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
2692 	    repo, worktree);
2693 	if (error)
2694 		goto done;
2695 
2696 	init_curses();
2697 
2698 	error = apply_unveil(got_repo_get_path(repo),
2699 	    worktree ? got_worktree_get_root_path(worktree) : NULL);
2700 	if (error)
2701 		goto done;
2702 
2703 	if (start_commit == NULL)
2704 		error = got_repo_match_object_id(&start_id, NULL, worktree ?
2705 		    got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD,
2706 		    GOT_OBJ_TYPE_COMMIT, 1, repo);
2707 	else
2708 		error = got_repo_match_object_id(&start_id, NULL, start_commit,
2709 		    GOT_OBJ_TYPE_COMMIT, 1, repo);
2710 	if (error != NULL)
2711 		goto done;
2712 
2713 	error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
2714 	if (error)
2715 		goto done;
2716 
2717 	view = view_open(0, 0, 0, 0, TOG_VIEW_LOG);
2718 	if (view == NULL) {
2719 		error = got_error_from_errno("view_open");
2720 		goto done;
2721 	}
2722 	if (worktree) {
2723 		head_ref_name = strdup(
2724 		    got_worktree_get_head_ref_name(worktree));
2725 		if (head_ref_name == NULL) {
2726 			error = got_error_from_errno("strdup");
2727 			goto done;
2728 		}
2729 	}
2730 	error = open_log_view(view, start_id, &refs, repo, head_ref_name,
2731 	    in_repo_path, log_branches);
2732 	if (error)
2733 		goto done;
2734 	if (worktree) {
2735 		/* Release work tree lock. */
2736 		got_worktree_close(worktree);
2737 		worktree = NULL;
2738 	}
2739 	error = view_loop(view);
2740 done:
2741 	free(in_repo_path);
2742 	free(repo_path);
2743 	free(cwd);
2744 	free(start_id);
2745 	free(head_ref_name);
2746 	if (repo)
2747 		got_repo_close(repo);
2748 	if (worktree)
2749 		got_worktree_close(worktree);
2750 	got_ref_list_free(&refs);
2751 	return error;
2752 }
2753 
2754 __dead static void
2755 usage_diff(void)
2756 {
2757 	endwin();
2758 	fprintf(stderr, "usage: %s diff [-r repository-path] object1 object2\n",
2759 	    getprogname());
2760 	exit(1);
2761 }
2762 
2763 static char *
2764 parse_next_line(FILE *f, size_t *len)
2765 {
2766 	char *line;
2767 	size_t linelen;
2768 	size_t lineno;
2769 	const char delim[3] = { '\0', '\0', '\0'};
2770 
2771 	line = fparseln(f, &linelen, &lineno, delim, 0);
2772 	if (len)
2773 		*len = linelen;
2774 	return line;
2775 }
2776 
2777 static int
2778 match_line(const char *line, regex_t *regex)
2779 {
2780 	regmatch_t regmatch;
2781 
2782 	return regexec(regex, line, 1, &regmatch, 0) == 0;
2783 }
2784 
2785 struct tog_color *
2786 match_color(struct tog_colors *colors, const char *line)
2787 {
2788 	struct tog_color *tc = NULL;
2789 
2790 	SIMPLEQ_FOREACH(tc, colors, entry) {
2791 		if (match_line(line, &tc->regex))
2792 			return tc;
2793 	}
2794 
2795 	return NULL;
2796 }
2797 
2798 static const struct got_error *
2799 draw_file(struct tog_view *view, FILE *f, int *first_displayed_line, int nlines,
2800     int selected_line, int max_lines, int *last_displayed_line, int *eof,
2801     char *header, struct tog_colors *colors)
2802 {
2803 	const struct got_error *err;
2804 	int lineno = 0, nprinted = 0;
2805 	char *line;
2806 	struct tog_color *tc;
2807 	size_t len;
2808 	wchar_t *wline;
2809 	int width;
2810 
2811 	rewind(f);
2812 	werase(view->window);
2813 
2814 	if (header) {
2815 		err = format_line(&wline, &width, header, view->ncols, 0);
2816 		if (err) {
2817 			return err;
2818 		}
2819 
2820 		if (view_needs_focus_indication(view))
2821 			wstandout(view->window);
2822 		waddwstr(view->window, wline);
2823 		if (view_needs_focus_indication(view))
2824 			wstandend(view->window);
2825 		if (width <= view->ncols - 1)
2826 			waddch(view->window, '\n');
2827 
2828 		if (max_lines <= 1)
2829 			return NULL;
2830 		max_lines--;
2831 	}
2832 
2833 	*eof = 0;
2834 	while (nprinted < max_lines) {
2835 		line = parse_next_line(f, &len);
2836 		if (line == NULL) {
2837 			*eof = 1;
2838 			break;
2839 		}
2840 		if (++lineno < *first_displayed_line) {
2841 			free(line);
2842 			continue;
2843 		}
2844 
2845 		err = format_line(&wline, &width, line, view->ncols, 0);
2846 		if (err) {
2847 			free(line);
2848 			return err;
2849 		}
2850 
2851 		tc = match_color(colors, line);
2852 		if (tc)
2853 			wattr_on(view->window,
2854 			    COLOR_PAIR(tc->colorpair), NULL);
2855 		waddwstr(view->window, wline);
2856 		if (tc)
2857 			wattr_off(view->window,
2858 			    COLOR_PAIR(tc->colorpair), NULL);
2859 		if (width <= view->ncols - 1)
2860 			waddch(view->window, '\n');
2861 		if (++nprinted == 1)
2862 			*first_displayed_line = lineno;
2863 		free(line);
2864 		free(wline);
2865 		wline = NULL;
2866 	}
2867 	*last_displayed_line = lineno;
2868 
2869 	view_vborder(view);
2870 
2871 	if (*eof) {
2872 		while (nprinted < view->nlines) {
2873 			waddch(view->window, '\n');
2874 			nprinted++;
2875 		}
2876 
2877 		err = format_line(&wline, &width, TOG_EOF_STRING, view->ncols, 0);
2878 		if (err) {
2879 			return err;
2880 		}
2881 
2882 		wstandout(view->window);
2883 		waddwstr(view->window, wline);
2884 		wstandend(view->window);
2885 	}
2886 
2887 	return NULL;
2888 }
2889 
2890 static char *
2891 get_datestr(time_t *time, char *datebuf)
2892 {
2893 	struct tm mytm, *tm;
2894 	char *p, *s;
2895 
2896 	tm = gmtime_r(time, &mytm);
2897 	if (tm == NULL)
2898 		return NULL;
2899 	s = asctime_r(tm, datebuf);
2900 	if (s == NULL)
2901 		return NULL;
2902 	p = strchr(s, '\n');
2903 	if (p)
2904 		*p = '\0';
2905 	return s;
2906 }
2907 
2908 static const struct got_error *
2909 get_changed_paths(struct got_pathlist_head *paths,
2910     struct got_commit_object *commit, struct got_repository *repo)
2911 {
2912 	const struct got_error *err = NULL;
2913 	struct got_object_id *tree_id1 = NULL, *tree_id2 = NULL;
2914 	struct got_tree_object *tree1 = NULL, *tree2 = NULL;
2915 	struct got_object_qid *qid;
2916 
2917 	qid = SIMPLEQ_FIRST(got_object_commit_get_parent_ids(commit));
2918 	if (qid != NULL) {
2919 		struct got_commit_object *pcommit;
2920 		err = got_object_open_as_commit(&pcommit, repo,
2921 		    qid->id);
2922 		if (err)
2923 			return err;
2924 
2925 		tree_id1 = got_object_commit_get_tree_id(pcommit);
2926 		got_object_commit_close(pcommit);
2927 
2928 	}
2929 
2930 	if (tree_id1) {
2931 		err = got_object_open_as_tree(&tree1, repo, tree_id1);
2932 		if (err)
2933 			goto done;
2934 	}
2935 
2936 	tree_id2 = got_object_commit_get_tree_id(commit);
2937 	err = got_object_open_as_tree(&tree2, repo, tree_id2);
2938 	if (err)
2939 		goto done;
2940 
2941 	err = got_diff_tree(tree1, tree2, "", "", repo,
2942 	    got_diff_tree_collect_changed_paths, paths, 0);
2943 done:
2944 	if (tree1)
2945 		got_object_tree_close(tree1);
2946 	if (tree2)
2947 		got_object_tree_close(tree2);
2948 	return err;
2949 }
2950 
2951 static const struct got_error *
2952 write_commit_info(struct got_object_id *commit_id,
2953     struct got_reflist_head *refs, struct got_repository *repo, FILE *outfile)
2954 {
2955 	const struct got_error *err = NULL;
2956 	char datebuf[26], *datestr;
2957 	struct got_commit_object *commit;
2958 	char *id_str = NULL, *logmsg = NULL;
2959 	time_t committer_time;
2960 	const char *author, *committer;
2961 	char *refs_str = NULL;
2962 	struct got_pathlist_head changed_paths;
2963 	struct got_pathlist_entry *pe;
2964 
2965 	TAILQ_INIT(&changed_paths);
2966 
2967 	if (refs) {
2968 		err = build_refs_str(&refs_str, refs, commit_id, repo);
2969 		if (err)
2970 			return err;
2971 	}
2972 
2973 	err = got_object_open_as_commit(&commit, repo, commit_id);
2974 	if (err)
2975 		return err;
2976 
2977 	err = got_object_id_str(&id_str, commit_id);
2978 	if (err) {
2979 		err = got_error_from_errno("got_object_id_str");
2980 		goto done;
2981 	}
2982 
2983 	if (fprintf(outfile, "commit %s%s%s%s\n", id_str, refs_str ? " (" : "",
2984 	    refs_str ? refs_str : "", refs_str ? ")" : "") < 0) {
2985 		err = got_error_from_errno("fprintf");
2986 		goto done;
2987 	}
2988 	if (fprintf(outfile, "from: %s\n",
2989 	    got_object_commit_get_author(commit)) < 0) {
2990 		err = got_error_from_errno("fprintf");
2991 		goto done;
2992 	}
2993 	committer_time = got_object_commit_get_committer_time(commit);
2994 	datestr = get_datestr(&committer_time, datebuf);
2995 	if (datestr && fprintf(outfile, "date: %s UTC\n", datestr) < 0) {
2996 		err = got_error_from_errno("fprintf");
2997 		goto done;
2998 	}
2999 	author = got_object_commit_get_author(commit);
3000 	committer = got_object_commit_get_committer(commit);
3001 	if (strcmp(author, committer) != 0 &&
3002 	    fprintf(outfile, "via: %s\n", committer) < 0) {
3003 		err = got_error_from_errno("fprintf");
3004 		goto done;
3005 	}
3006 	err = got_object_commit_get_logmsg(&logmsg, commit);
3007 	if (err)
3008 		goto done;
3009 	if (fprintf(outfile, "%s\n", logmsg) < 0) {
3010 		err = got_error_from_errno("fprintf");
3011 		goto done;
3012 	}
3013 	err = get_changed_paths(&changed_paths, commit, repo);
3014 	if (err)
3015 		goto done;
3016 	TAILQ_FOREACH(pe, &changed_paths, entry) {
3017 		struct got_diff_changed_path *cp = pe->data;
3018 		fprintf(outfile, "%c  %s\n", cp->status, pe->path);
3019 		free((char *)pe->path);
3020 		free(pe->data);
3021 	}
3022 	fputc('\n', outfile);
3023 done:
3024 	got_pathlist_free(&changed_paths);
3025 	free(id_str);
3026 	free(logmsg);
3027 	free(refs_str);
3028 	got_object_commit_close(commit);
3029 	return err;
3030 }
3031 
3032 const struct got_error *
3033 get_filestream_info(size_t *filesize, int *nlines, off_t **line_offsets,
3034     FILE *infile)
3035 {
3036 	const struct got_error *err = NULL;
3037 	size_t len, remain;
3038 	char buf[32768];
3039 	int i;
3040 	size_t nalloc = 0;
3041 	off_t off = 0;
3042 
3043 	*line_offsets = NULL;
3044 	*filesize = 0;
3045 	*nlines = 0;
3046 
3047 	if (fseek(infile, 0, SEEK_END) == -1)
3048 		return got_error_from_errno("fseek");
3049 	len = ftell(infile) + 1;
3050 	if (ferror(infile))
3051 		return got_error_from_errno("ftell");
3052 	if (fseek(infile, 0, SEEK_SET) == -1)
3053 		return got_error_from_errno("fseek");
3054 
3055 	if (len == 0)
3056 		return NULL;
3057 
3058 	remain = len;
3059 	while (remain > 0) {
3060 		size_t r, n = MIN(remain, sizeof(buf));
3061 		r = fread(buf, 1, n, infile);
3062 		if (r == 0) {
3063 			if (ferror(infile)) {
3064 				err = got_error_from_errno("fread");
3065 				goto done;
3066 			}
3067 			break;
3068 		}
3069 		i = 0;
3070 		remain -= r;
3071 
3072 		if (*line_offsets == NULL) {
3073 			/* Have some data but perhaps no '\n'. */
3074 			*nlines = 1;
3075 			nalloc = len / 40; /* 40-char average line length */
3076 			*line_offsets = calloc(nalloc, sizeof(**line_offsets));
3077 			if (*line_offsets == NULL) {
3078 				err = got_error_from_errno("calloc");
3079 				goto done;
3080 			}
3081 				/* Skip forward over end of first line. */
3082 			while (i < len) {
3083 				if (buf[i] == '\n')
3084 					break;
3085 				i++;
3086 			}
3087 		}
3088 
3089 		/* Scan '\n' offsets in remaining chunk of data. */
3090 		while (i < r) {
3091 			if (buf[i] != '\n') {
3092 				i++;
3093 				continue;
3094 			}
3095 			(*nlines)++;
3096 			if (nalloc < *nlines) {
3097 				size_t nallocnew = *nlines + (remain / 40);
3098 				off_t *o = recallocarray(*line_offsets,
3099 				    nalloc, nallocnew, sizeof(**line_offsets));
3100 				if (o == NULL) {
3101 					err = got_error_from_errno(
3102 					    "recallocarray");
3103 					goto done;
3104 				}
3105 				*line_offsets = o;
3106 				nalloc = nallocnew;
3107 			}
3108 			off = i + 1;
3109 			(*line_offsets)[*nlines - 1] = off;
3110 			i++;
3111 		}
3112 	}
3113 
3114 	if (fflush(infile) != 0) {
3115 		err = got_error_from_errno("fflush");
3116 		goto done;
3117 	}
3118 	rewind(infile);
3119 
3120 	*filesize = len;
3121 done:
3122 	if (err) {
3123 		free(*line_offsets);
3124 		*line_offsets = NULL;
3125 		*filesize = 0;
3126 		*nlines = 0;
3127 	}
3128 	return NULL;
3129 }
3130 
3131 static const struct got_error *
3132 create_diff(struct tog_diff_view_state *s)
3133 {
3134 	const struct got_error *err = NULL;
3135 	FILE *f = NULL;
3136 	int obj_type;
3137 
3138 	f = got_opentemp();
3139 	if (f == NULL) {
3140 		err = got_error_from_errno("got_opentemp");
3141 		goto done;
3142 	}
3143 	if (s->f && fclose(s->f) != 0) {
3144 		err = got_error_from_errno("fclose");
3145 		goto done;
3146 	}
3147 	s->f = f;
3148 
3149 	if (s->id1)
3150 		err = got_object_get_type(&obj_type, s->repo, s->id1);
3151 	else
3152 		err = got_object_get_type(&obj_type, s->repo, s->id2);
3153 	if (err)
3154 		goto done;
3155 
3156 	switch (obj_type) {
3157 	case GOT_OBJ_TYPE_BLOB:
3158 		err = got_diff_objects_as_blobs(s->id1, s->id2, NULL, NULL,
3159 		    s->diff_context, 0, s->repo, s->f);
3160 		break;
3161 	case GOT_OBJ_TYPE_TREE:
3162 		err = got_diff_objects_as_trees(s->id1, s->id2, "", "",
3163 		    s->diff_context, 0, s->repo, s->f);
3164 		break;
3165 	case GOT_OBJ_TYPE_COMMIT: {
3166 		const struct got_object_id_queue *parent_ids;
3167 		struct got_object_qid *pid;
3168 		struct got_commit_object *commit2;
3169 
3170 		err = got_object_open_as_commit(&commit2, s->repo, s->id2);
3171 		if (err)
3172 			goto done;
3173 		/* Show commit info if we're diffing to a parent/root commit. */
3174 		if (s->id1 == NULL) {
3175 			err = write_commit_info(s->id2, s->refs, s->repo, s->f);
3176 			if (err)
3177 				goto done;
3178 		} else {
3179 			parent_ids = got_object_commit_get_parent_ids(commit2);
3180 			SIMPLEQ_FOREACH(pid, parent_ids, entry) {
3181 				if (got_object_id_cmp(s->id1, pid->id) == 0) {
3182 					err = write_commit_info(s->id2, s->refs,
3183 					    s->repo, s->f);
3184 					if (err)
3185 						goto done;
3186 					break;
3187 				}
3188 			}
3189 		}
3190 		got_object_commit_close(commit2);
3191 
3192 		err = got_diff_objects_as_commits(s->id1, s->id2,
3193 		    s->diff_context, 0, s->repo, s->f);
3194 		break;
3195 	}
3196 	default:
3197 		err = got_error(GOT_ERR_OBJ_TYPE);
3198 		break;
3199 	}
3200 	if (err)
3201 		goto done;
3202 	err = get_filestream_info(&s->filesize, &s->nlines, &s->line_offsets,
3203 	    s->f);
3204 done:
3205 	if (s->f && fflush(s->f) != 0 && err == NULL)
3206 		err = got_error_from_errno("fflush");
3207 	return err;
3208 }
3209 
3210 static void
3211 diff_view_indicate_progress(struct tog_view *view)
3212 {
3213 	mvwaddstr(view->window, 0, 0, "diffing...");
3214 	update_panels();
3215 	doupdate();
3216 }
3217 
3218 static const struct got_error *
3219 search_start_diff_view(struct tog_view *view)
3220 {
3221 	struct tog_diff_view_state *s = &view->state.diff;
3222 
3223 	s->matched_line = 0;
3224 	return NULL;
3225 }
3226 
3227 static const struct got_error *
3228 search_next_diff_view(struct tog_view *view)
3229 {
3230 	struct tog_diff_view_state *s = &view->state.diff;
3231 	int lineno;
3232 
3233 	if (!view->searching) {
3234 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
3235 		return NULL;
3236 	}
3237 
3238 	if (s->matched_line) {
3239 		if (view->searching == TOG_SEARCH_FORWARD)
3240 			lineno = s->matched_line + 1;
3241 		else
3242 			lineno = s->matched_line - 1;
3243 	} else {
3244 		if (view->searching == TOG_SEARCH_FORWARD)
3245 			lineno = 1;
3246 		else
3247 			lineno = s->nlines;
3248 	}
3249 
3250 	while (1) {
3251 		char *line = NULL;
3252 		off_t offset;
3253 		size_t len;
3254 
3255 		if (lineno <= 0 || lineno > s->nlines) {
3256 			if (s->matched_line == 0) {
3257 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
3258 				free(line);
3259 				break;
3260 			}
3261 
3262 			if (view->searching == TOG_SEARCH_FORWARD)
3263 				lineno = 1;
3264 			else
3265 				lineno = s->nlines;
3266 		}
3267 
3268 		offset = s->line_offsets[lineno - 1];
3269 		if (fseeko(s->f, offset, SEEK_SET) != 0) {
3270 			free(line);
3271 			return got_error_from_errno("fseeko");
3272 		}
3273 		free(line);
3274 		line = parse_next_line(s->f, &len);
3275 		if (line && match_line(line, &view->regex)) {
3276 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
3277 			s->matched_line = lineno;
3278 			free(line);
3279 			break;
3280 		}
3281 		free(line);
3282 		if (view->searching == TOG_SEARCH_FORWARD)
3283 			lineno++;
3284 		else
3285 			lineno--;
3286 	}
3287 
3288 	if (s->matched_line) {
3289 		s->first_displayed_line = s->matched_line;
3290 		s->selected_line = 1;
3291 	}
3292 
3293 	return NULL;
3294 }
3295 
3296 static const struct got_error *
3297 open_diff_view(struct tog_view *view, struct got_object_id *id1,
3298     struct got_object_id *id2, struct tog_view *log_view,
3299     struct got_reflist_head *refs, struct got_repository *repo)
3300 {
3301 	const struct got_error *err;
3302 	struct tog_diff_view_state *s = &view->state.diff;
3303 
3304 	if (id1 != NULL && id2 != NULL) {
3305 	    int type1, type2;
3306 	    err = got_object_get_type(&type1, repo, id1);
3307 	    if (err)
3308 		return err;
3309 	    err = got_object_get_type(&type2, repo, id2);
3310 	    if (err)
3311 		return err;
3312 
3313 	    if (type1 != type2)
3314 		return got_error(GOT_ERR_OBJ_TYPE);
3315 	}
3316 	s->first_displayed_line = 1;
3317 	s->last_displayed_line = view->nlines;
3318 	s->selected_line = 1;
3319 	s->repo = repo;
3320 	s->refs = refs;
3321 	s->id1 = id1;
3322 	s->id2 = id2;
3323 
3324 	if (id1) {
3325 		s->id1 = got_object_id_dup(id1);
3326 		if (s->id1 == NULL)
3327 			return got_error_from_errno("got_object_id_dup");
3328 	} else
3329 		s->id1 = NULL;
3330 
3331 	s->id2 = got_object_id_dup(id2);
3332 	if (s->id2 == NULL) {
3333 		free(s->id1);
3334 		s->id1 = NULL;
3335 		return got_error_from_errno("got_object_id_dup");
3336 	}
3337 	s->f = NULL;
3338 	s->first_displayed_line = 1;
3339 	s->last_displayed_line = view->nlines;
3340 	s->diff_context = 3;
3341 	s->log_view = log_view;
3342 	s->repo = repo;
3343 	s->refs = refs;
3344 
3345 	SIMPLEQ_INIT(&s->colors);
3346 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
3347 		err = add_color(&s->colors,
3348 		    "^-", TOG_COLOR_DIFF_MINUS,
3349 		    get_color_value("TOG_COLOR_DIFF_MINUS"));
3350 		if (err)
3351 			return err;
3352 		err = add_color(&s->colors, "^\\+",
3353 		    TOG_COLOR_DIFF_PLUS,
3354 		    get_color_value("TOG_COLOR_DIFF_PLUS"));
3355 		if (err) {
3356 			free_colors(&s->colors);
3357 			return err;
3358 		}
3359 		err = add_color(&s->colors,
3360 		    "^@@", TOG_COLOR_DIFF_CHUNK_HEADER,
3361 		    get_color_value("TOG_COLOR_DIFF_CHUNK_HEADER"));
3362 		if (err) {
3363 			free_colors(&s->colors);
3364 			return err;
3365 		}
3366 
3367 		err = add_color(&s->colors,
3368 		    "^(commit [0-9a-f]|(blob|file) [-+] |[MDmA]  [^ ])",
3369 		    TOG_COLOR_DIFF_META,
3370 		    get_color_value("TOG_COLOR_DIFF_META"));
3371 		if (err) {
3372 			free_colors(&s->colors);
3373 			return err;
3374 		}
3375 
3376 		err = add_color(&s->colors,
3377 		    "^(from|via): ", TOG_COLOR_AUTHOR,
3378 		    get_color_value("TOG_COLOR_AUTHOR"));
3379 		if (err) {
3380 			free_colors(&s->colors);
3381 			return err;
3382 		}
3383 
3384 		err = add_color(&s->colors,
3385 		    "^date: ", TOG_COLOR_DATE,
3386 		    get_color_value("TOG_COLOR_DATE"));
3387 		if (err) {
3388 			free_colors(&s->colors);
3389 			return err;
3390 		}
3391 	}
3392 
3393 	if (log_view && view_is_splitscreen(view))
3394 		show_log_view(log_view); /* draw vborder */
3395 	diff_view_indicate_progress(view);
3396 
3397 	err = create_diff(s);
3398 	if (err) {
3399 		free(s->id1);
3400 		s->id1 = NULL;
3401 		free(s->id2);
3402 		s->id2 = NULL;
3403 		return err;
3404 	}
3405 
3406 	view->show = show_diff_view;
3407 	view->input = input_diff_view;
3408 	view->close = close_diff_view;
3409 	view->search_start = search_start_diff_view;
3410 	view->search_next = search_next_diff_view;
3411 
3412 	return NULL;
3413 }
3414 
3415 static const struct got_error *
3416 close_diff_view(struct tog_view *view)
3417 {
3418 	const struct got_error *err = NULL;
3419 	struct tog_diff_view_state *s = &view->state.diff;
3420 
3421 	free(s->id1);
3422 	s->id1 = NULL;
3423 	free(s->id2);
3424 	s->id2 = NULL;
3425 	if (s->f && fclose(s->f) == EOF)
3426 		err = got_error_from_errno("fclose");
3427 	free_colors(&s->colors);
3428 	free(s->line_offsets);
3429 	return err;
3430 }
3431 
3432 static const struct got_error *
3433 show_diff_view(struct tog_view *view)
3434 {
3435 	const struct got_error *err;
3436 	struct tog_diff_view_state *s = &view->state.diff;
3437 	char *id_str1 = NULL, *id_str2, *header;
3438 
3439 	if (s->id1) {
3440 		err = got_object_id_str(&id_str1, s->id1);
3441 		if (err)
3442 			return err;
3443 	}
3444 	err = got_object_id_str(&id_str2, s->id2);
3445 	if (err)
3446 		return err;
3447 
3448 	if (asprintf(&header, "diff %s %s",
3449 	    id_str1 ? id_str1 : "/dev/null", id_str2) == -1) {
3450 		err = got_error_from_errno("asprintf");
3451 		free(id_str1);
3452 		free(id_str2);
3453 		return err;
3454 	}
3455 	free(id_str1);
3456 	free(id_str2);
3457 
3458 	return draw_file(view, s->f, &s->first_displayed_line, s->nlines,
3459 	    s->selected_line, view->nlines, &s->last_displayed_line, &s->eof,
3460 	    header, &s->colors);
3461 }
3462 
3463 static const struct got_error *
3464 set_selected_commit(struct tog_diff_view_state *s,
3465     struct commit_queue_entry *entry)
3466 {
3467 	const struct got_error *err;
3468 	const struct got_object_id_queue *parent_ids;
3469 	struct got_commit_object *selected_commit;
3470 	struct got_object_qid *pid;
3471 
3472 	free(s->id2);
3473 	s->id2 = got_object_id_dup(entry->id);
3474 	if (s->id2 == NULL)
3475 		return got_error_from_errno("got_object_id_dup");
3476 
3477 	err = got_object_open_as_commit(&selected_commit, s->repo, entry->id);
3478 	if (err)
3479 		return err;
3480 	parent_ids = got_object_commit_get_parent_ids(selected_commit);
3481 	free(s->id1);
3482 	pid = SIMPLEQ_FIRST(parent_ids);
3483 	s->id1 = pid ? got_object_id_dup(pid->id) : NULL;
3484 	got_object_commit_close(selected_commit);
3485 	return NULL;
3486 }
3487 
3488 static const struct got_error *
3489 input_diff_view(struct tog_view **new_view, struct tog_view **dead_view,
3490     struct tog_view **focus_view, struct tog_view *view, int ch)
3491 {
3492 	const struct got_error *err = NULL;
3493 	struct tog_diff_view_state *s = &view->state.diff;
3494 	struct tog_log_view_state *ls;
3495 	struct commit_queue_entry *entry;
3496 	int i;
3497 
3498 	switch (ch) {
3499 	case 'k':
3500 	case KEY_UP:
3501 		if (s->first_displayed_line > 1)
3502 			s->first_displayed_line--;
3503 		break;
3504 	case KEY_PPAGE:
3505 	case CTRL('b'):
3506 		if (s->first_displayed_line == 1)
3507 			break;
3508 		i = 0;
3509 		while (i++ < view->nlines - 1 &&
3510 		    s->first_displayed_line > 1)
3511 			s->first_displayed_line--;
3512 		break;
3513 	case 'j':
3514 	case KEY_DOWN:
3515 		if (!s->eof)
3516 			s->first_displayed_line++;
3517 		break;
3518 	case KEY_NPAGE:
3519 	case CTRL('f'):
3520 	case ' ':
3521 		if (s->eof)
3522 			break;
3523 		i = 0;
3524 		while (!s->eof && i++ < view->nlines - 1) {
3525 			char *line;
3526 			line = parse_next_line(s->f, NULL);
3527 			s->first_displayed_line++;
3528 			if (line == NULL)
3529 				break;
3530 		}
3531 		break;
3532 	case '[':
3533 		if (s->diff_context > 0) {
3534 			s->diff_context--;
3535 			diff_view_indicate_progress(view);
3536 			err = create_diff(s);
3537 		}
3538 		break;
3539 	case ']':
3540 		if (s->diff_context < GOT_DIFF_MAX_CONTEXT) {
3541 			s->diff_context++;
3542 			diff_view_indicate_progress(view);
3543 			err = create_diff(s);
3544 		}
3545 		break;
3546 	case '<':
3547 	case ',':
3548 		if (s->log_view == NULL)
3549 			break;
3550 		ls = &s->log_view->state.log;
3551 		entry = TAILQ_PREV(ls->selected_entry,
3552 		    commit_queue_head, entry);
3553 		if (entry == NULL)
3554 			break;
3555 
3556 		err = input_log_view(NULL, NULL, NULL, s->log_view,
3557 		    KEY_UP);
3558 		if (err)
3559 			break;
3560 
3561 		err = set_selected_commit(s, entry);
3562 		if (err)
3563 			break;
3564 
3565 		s->first_displayed_line = 1;
3566 		s->last_displayed_line = view->nlines;
3567 
3568 		diff_view_indicate_progress(view);
3569 		err = create_diff(s);
3570 		break;
3571 	case '>':
3572 	case '.':
3573 		if (s->log_view == NULL)
3574 			break;
3575 		ls = &s->log_view->state.log;
3576 
3577 		if (TAILQ_NEXT(ls->selected_entry, entry) == NULL) {
3578 			ls->thread_args.commits_needed++;
3579 			err = trigger_log_thread(s->log_view, 1,
3580 			    &ls->thread_args.commits_needed,
3581 			    &ls->thread_args.log_complete,
3582 			    &ls->thread_args.need_commits,
3583 			    &ls->thread_args.commit_loaded);
3584 			if (err)
3585 				break;
3586 		}
3587 		err = input_log_view(NULL, NULL, NULL, s->log_view,
3588 		    KEY_DOWN);
3589 		if (err)
3590 			break;
3591 
3592 		entry = TAILQ_NEXT(ls->selected_entry, entry);
3593 		if (entry == NULL)
3594 			break;
3595 
3596 		err = set_selected_commit(s, entry);
3597 		if (err)
3598 			break;
3599 
3600 		s->first_displayed_line = 1;
3601 		s->last_displayed_line = view->nlines;
3602 
3603 		diff_view_indicate_progress(view);
3604 		err = create_diff(s);
3605 		break;
3606 	default:
3607 		break;
3608 	}
3609 
3610 	return err;
3611 }
3612 
3613 static const struct got_error *
3614 cmd_diff(int argc, char *argv[])
3615 {
3616 	const struct got_error *error = NULL;
3617 	struct got_repository *repo = NULL;
3618 	struct got_worktree *worktree = NULL;
3619 	struct got_reflist_head refs;
3620 	struct got_object_id *id1 = NULL, *id2 = NULL;
3621 	char *repo_path = NULL, *cwd = NULL;
3622 	char *id_str1 = NULL, *id_str2 = NULL;
3623 	int ch;
3624 	struct tog_view *view;
3625 
3626 	SIMPLEQ_INIT(&refs);
3627 
3628 #ifndef PROFILE
3629 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
3630 	    NULL) == -1)
3631 		err(1, "pledge");
3632 #endif
3633 
3634 	while ((ch = getopt(argc, argv, "r:")) != -1) {
3635 		switch (ch) {
3636 		case 'r':
3637 			repo_path = realpath(optarg, NULL);
3638 			if (repo_path == NULL)
3639 				return got_error_from_errno2("realpath",
3640 				    optarg);
3641 			break;
3642 		default:
3643 			usage_diff();
3644 			/* NOTREACHED */
3645 		}
3646 	}
3647 
3648 	argc -= optind;
3649 	argv += optind;
3650 
3651 	if (argc == 0) {
3652 		usage_diff(); /* TODO show local worktree changes */
3653 	} else if (argc == 2) {
3654 		id_str1 = argv[0];
3655 		id_str2 = argv[1];
3656 	} else
3657 		usage_diff();
3658 
3659 	cwd = getcwd(NULL, 0);
3660 	if (cwd == NULL)
3661 		return got_error_from_errno("getcwd");
3662 
3663 	error = got_worktree_open(&worktree, cwd);
3664 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
3665 		goto done;
3666 
3667 	if (repo_path == NULL) {
3668 		if (worktree)
3669 			repo_path =
3670 			    strdup(got_worktree_get_repo_path(worktree));
3671 		else
3672 			repo_path = strdup(cwd);
3673 	}
3674 	if (repo_path == NULL) {
3675 		error = got_error_from_errno("strdup");
3676 		goto done;
3677 	}
3678 
3679 	error = got_repo_open(&repo, repo_path, NULL);
3680 	if (error)
3681 		goto done;
3682 
3683 	init_curses();
3684 
3685 	error = apply_unveil(got_repo_get_path(repo), NULL);
3686 	if (error)
3687 		goto done;
3688 
3689 	error = got_repo_match_object_id_prefix(&id1, id_str1,
3690 	    GOT_OBJ_TYPE_ANY, repo);
3691 	if (error)
3692 		goto done;
3693 
3694 	error = got_repo_match_object_id_prefix(&id2, id_str2,
3695 	    GOT_OBJ_TYPE_ANY, repo);
3696 	if (error)
3697 		goto done;
3698 
3699 	error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
3700 	if (error)
3701 		goto done;
3702 
3703 	view = view_open(0, 0, 0, 0, TOG_VIEW_DIFF);
3704 	if (view == NULL) {
3705 		error = got_error_from_errno("view_open");
3706 		goto done;
3707 	}
3708 	error = open_diff_view(view, id1, id2, NULL, &refs, repo);
3709 	if (error)
3710 		goto done;
3711 	error = view_loop(view);
3712 done:
3713 	free(repo_path);
3714 	free(cwd);
3715 	if (repo)
3716 		got_repo_close(repo);
3717 	if (worktree)
3718 		got_worktree_close(worktree);
3719 	got_ref_list_free(&refs);
3720 	return error;
3721 }
3722 
3723 __dead static void
3724 usage_blame(void)
3725 {
3726 	endwin();
3727 	fprintf(stderr, "usage: %s blame [-c commit] [-r repository-path] path\n",
3728 	    getprogname());
3729 	exit(1);
3730 }
3731 
3732 struct tog_blame_line {
3733 	int annotated;
3734 	struct got_object_id *id;
3735 };
3736 
3737 static const struct got_error *
3738 draw_blame(struct tog_view *view, struct got_object_id *id, FILE *f,
3739     const char *path, struct tog_blame_line *lines, int nlines,
3740     int blame_complete, int selected_line, int *first_displayed_line,
3741     int *last_displayed_line, int *eof, int max_lines,
3742     struct tog_colors *colors)
3743 {
3744 	const struct got_error *err;
3745 	int lineno = 0, nprinted = 0;
3746 	char *line;
3747 	size_t len;
3748 	wchar_t *wline;
3749 	int width;
3750 	struct tog_blame_line *blame_line;
3751 	struct got_object_id *prev_id = NULL;
3752 	char *id_str;
3753 	struct tog_color *tc;
3754 
3755 	err = got_object_id_str(&id_str, id);
3756 	if (err)
3757 		return err;
3758 
3759 	rewind(f);
3760 	werase(view->window);
3761 
3762 	if (asprintf(&line, "commit %s", id_str) == -1) {
3763 		err = got_error_from_errno("asprintf");
3764 		free(id_str);
3765 		return err;
3766 	}
3767 
3768 	err = format_line(&wline, &width, line, view->ncols, 0);
3769 	free(line);
3770 	line = NULL;
3771 	if (err)
3772 		return err;
3773 	if (view_needs_focus_indication(view))
3774 		wstandout(view->window);
3775 	tc = get_color(colors, TOG_COLOR_COMMIT);
3776 	if (tc)
3777 		wattr_on(view->window,
3778 		    COLOR_PAIR(tc->colorpair), NULL);
3779 	waddwstr(view->window, wline);
3780 	if (tc)
3781 		wattr_off(view->window,
3782 		    COLOR_PAIR(tc->colorpair), NULL);
3783 	if (view_needs_focus_indication(view))
3784 		wstandend(view->window);
3785 	free(wline);
3786 	wline = NULL;
3787 	if (width < view->ncols - 1)
3788 		waddch(view->window, '\n');
3789 
3790 	if (asprintf(&line, "[%d/%d] %s%s",
3791 	    *first_displayed_line - 1 + selected_line, nlines,
3792 	    blame_complete ? "" : "annotating... ", path) == -1) {
3793 		free(id_str);
3794 		return got_error_from_errno("asprintf");
3795 	}
3796 	free(id_str);
3797 	err = format_line(&wline, &width, line, view->ncols, 0);
3798 	free(line);
3799 	line = NULL;
3800 	if (err)
3801 		return err;
3802 	waddwstr(view->window, wline);
3803 	free(wline);
3804 	wline = NULL;
3805 	if (width < view->ncols - 1)
3806 		waddch(view->window, '\n');
3807 
3808 	*eof = 0;
3809 	while (nprinted < max_lines - 2) {
3810 		line = parse_next_line(f, &len);
3811 		if (line == NULL) {
3812 			*eof = 1;
3813 			break;
3814 		}
3815 		if (++lineno < *first_displayed_line) {
3816 			free(line);
3817 			continue;
3818 		}
3819 
3820 		if (view->ncols <= 9) {
3821 			width = 9;
3822 			wline = wcsdup(L"");
3823 			if (wline == NULL)
3824 				err = got_error_from_errno("wcsdup");
3825 		} else {
3826 			err = format_line(&wline, &width, line,
3827 			    view->ncols - 9, 9);
3828 			width += 9;
3829 		}
3830 		if (err) {
3831 			free(line);
3832 			return err;
3833 		}
3834 
3835 		if (view->focussed && nprinted == selected_line - 1)
3836 			wstandout(view->window);
3837 
3838 		if (nlines > 0) {
3839 			blame_line = &lines[lineno - 1];
3840 			if (blame_line->annotated && prev_id &&
3841 			    got_object_id_cmp(prev_id, blame_line->id) == 0 &&
3842 			    !(view->focussed &&
3843 			    nprinted == selected_line - 1)) {
3844 				waddstr(view->window, "        ");
3845 			} else if (blame_line->annotated) {
3846 				char *id_str;
3847 				err = got_object_id_str(&id_str, blame_line->id);
3848 				if (err) {
3849 					free(line);
3850 					free(wline);
3851 					return err;
3852 				}
3853 				tc = get_color(colors, TOG_COLOR_COMMIT);
3854 				if (tc)
3855 					wattr_on(view->window,
3856 					    COLOR_PAIR(tc->colorpair), NULL);
3857 				wprintw(view->window, "%.8s", id_str);
3858 				if (tc)
3859 					wattr_off(view->window,
3860 					    COLOR_PAIR(tc->colorpair), NULL);
3861 				free(id_str);
3862 				prev_id = blame_line->id;
3863 			} else {
3864 				waddstr(view->window, "........");
3865 				prev_id = NULL;
3866 			}
3867 		} else {
3868 			waddstr(view->window, "........");
3869 			prev_id = NULL;
3870 		}
3871 
3872 		if (view->focussed && nprinted == selected_line - 1)
3873 			wstandend(view->window);
3874 		waddstr(view->window, " ");
3875 
3876 		waddwstr(view->window, wline);
3877 		if (width <= view->ncols - 1)
3878 			waddch(view->window, '\n');
3879 		if (++nprinted == 1)
3880 			*first_displayed_line = lineno;
3881 		free(line);
3882 		free(wline);
3883 		wline = NULL;
3884 	}
3885 	*last_displayed_line = lineno;
3886 
3887 	view_vborder(view);
3888 
3889 	return NULL;
3890 }
3891 
3892 static const struct got_error *
3893 blame_cb(void *arg, int nlines, int lineno, struct got_object_id *id)
3894 {
3895 	const struct got_error *err = NULL;
3896 	struct tog_blame_cb_args *a = arg;
3897 	struct tog_blame_line *line;
3898 	int errcode;
3899 
3900 	if (nlines != a->nlines ||
3901 	    (lineno != -1 && lineno < 1) || lineno > a->nlines)
3902 		return got_error(GOT_ERR_RANGE);
3903 
3904 	errcode = pthread_mutex_lock(&tog_mutex);
3905 	if (errcode)
3906 		return got_error_set_errno(errcode, "pthread_mutex_lock");
3907 
3908 	if (*a->quit) {	/* user has quit the blame view */
3909 		err = got_error(GOT_ERR_ITER_COMPLETED);
3910 		goto done;
3911 	}
3912 
3913 	if (lineno == -1)
3914 		goto done; /* no change in this commit */
3915 
3916 	line = &a->lines[lineno - 1];
3917 	if (line->annotated)
3918 		goto done;
3919 
3920 	line->id = got_object_id_dup(id);
3921 	if (line->id == NULL) {
3922 		err = got_error_from_errno("got_object_id_dup");
3923 		goto done;
3924 	}
3925 	line->annotated = 1;
3926 done:
3927 	errcode = pthread_mutex_unlock(&tog_mutex);
3928 	if (errcode)
3929 		err = got_error_set_errno(errcode, "pthread_mutex_unlock");
3930 	return err;
3931 }
3932 
3933 static void *
3934 blame_thread(void *arg)
3935 {
3936 	const struct got_error *err;
3937 	struct tog_blame_thread_args *ta = arg;
3938 	struct tog_blame_cb_args *a = ta->cb_args;
3939 	int errcode;
3940 
3941 	err = block_signals_used_by_main_thread();
3942 	if (err)
3943 		return (void *)err;
3944 
3945 	err = got_blame(ta->path, a->commit_id, ta->repo,
3946 	    blame_cb, ta->cb_args, ta->cancel_cb, ta->cancel_arg);
3947 	if (err && err->code == GOT_ERR_CANCELLED)
3948 		err = NULL;
3949 
3950 	errcode = pthread_mutex_lock(&tog_mutex);
3951 	if (errcode)
3952 		return (void *)got_error_set_errno(errcode,
3953 		    "pthread_mutex_lock");
3954 
3955 	got_repo_close(ta->repo);
3956 	ta->repo = NULL;
3957 	*ta->complete = 1;
3958 
3959 	errcode = pthread_mutex_unlock(&tog_mutex);
3960 	if (errcode && err == NULL)
3961 		err = got_error_set_errno(errcode, "pthread_mutex_unlock");
3962 
3963 	return (void *)err;
3964 }
3965 
3966 static struct got_object_id *
3967 get_selected_commit_id(struct tog_blame_line *lines, int nlines,
3968     int first_displayed_line, int selected_line)
3969 {
3970 	struct tog_blame_line *line;
3971 
3972 	if (nlines <= 0)
3973 		return NULL;
3974 
3975 	line = &lines[first_displayed_line - 1 + selected_line - 1];
3976 	if (!line->annotated)
3977 		return NULL;
3978 
3979 	return line->id;
3980 }
3981 
3982 static const struct got_error *
3983 stop_blame(struct tog_blame *blame)
3984 {
3985 	const struct got_error *err = NULL;
3986 	int i;
3987 
3988 	if (blame->thread) {
3989 		int errcode;
3990 		errcode = pthread_mutex_unlock(&tog_mutex);
3991 		if (errcode)
3992 			return got_error_set_errno(errcode,
3993 			    "pthread_mutex_unlock");
3994 		errcode = pthread_join(blame->thread, (void **)&err);
3995 		if (errcode)
3996 			return got_error_set_errno(errcode, "pthread_join");
3997 		errcode = pthread_mutex_lock(&tog_mutex);
3998 		if (errcode)
3999 			return got_error_set_errno(errcode,
4000 			    "pthread_mutex_lock");
4001 		if (err && err->code == GOT_ERR_ITER_COMPLETED)
4002 			err = NULL;
4003 		blame->thread = NULL;
4004 	}
4005 	if (blame->thread_args.repo) {
4006 		got_repo_close(blame->thread_args.repo);
4007 		blame->thread_args.repo = NULL;
4008 	}
4009 	if (blame->f) {
4010 		if (fclose(blame->f) != 0 && err == NULL)
4011 			err = got_error_from_errno("fclose");
4012 		blame->f = NULL;
4013 	}
4014 	if (blame->lines) {
4015 		for (i = 0; i < blame->nlines; i++)
4016 			free(blame->lines[i].id);
4017 		free(blame->lines);
4018 		blame->lines = NULL;
4019 	}
4020 	free(blame->cb_args.commit_id);
4021 	blame->cb_args.commit_id = NULL;
4022 
4023 	return err;
4024 }
4025 
4026 static const struct got_error *
4027 cancel_blame_view(void *arg)
4028 {
4029 	const struct got_error *err = NULL;
4030 	int *done = arg;
4031 	int errcode;
4032 
4033 	errcode = pthread_mutex_lock(&tog_mutex);
4034 	if (errcode)
4035 		return got_error_set_errno(errcode,
4036 		    "pthread_mutex_unlock");
4037 
4038 	if (*done)
4039 		err = got_error(GOT_ERR_CANCELLED);
4040 
4041 	errcode = pthread_mutex_unlock(&tog_mutex);
4042 	if (errcode)
4043 		return got_error_set_errno(errcode,
4044 		    "pthread_mutex_lock");
4045 
4046 	return err;
4047 }
4048 
4049 static const struct got_error *
4050 run_blame(struct tog_blame *blame, struct tog_view *view, int *blame_complete,
4051     int *first_displayed_line, int *last_displayed_line, int *selected_line,
4052     int *done, int *eof, const char *path, struct got_object_id *commit_id,
4053     struct got_repository *repo)
4054 {
4055 	const struct got_error *err = NULL;
4056 	struct got_blob_object *blob = NULL;
4057 	struct got_repository *thread_repo = NULL;
4058 	struct got_object_id *obj_id = NULL;
4059 	int obj_type;
4060 
4061 	err = got_object_id_by_path(&obj_id, repo, commit_id, path);
4062 	if (err)
4063 		return err;
4064 
4065 	err = got_object_get_type(&obj_type, repo, obj_id);
4066 	if (err)
4067 		goto done;
4068 
4069 	if (obj_type != GOT_OBJ_TYPE_BLOB) {
4070 		err = got_error(GOT_ERR_OBJ_TYPE);
4071 		goto done;
4072 	}
4073 
4074 	err = got_object_open_as_blob(&blob, repo, obj_id, 8192);
4075 	if (err)
4076 		goto done;
4077 	blame->f = got_opentemp();
4078 	if (blame->f == NULL) {
4079 		err = got_error_from_errno("got_opentemp");
4080 		goto done;
4081 	}
4082 	err = got_object_blob_dump_to_file(&blame->filesize, &blame->nlines,
4083 	    &blame->line_offsets, blame->f, blob);
4084 	if (err || blame->nlines == 0)
4085 		goto done;
4086 
4087 	/* Don't include \n at EOF in the blame line count. */
4088 	if (blame->line_offsets[blame->nlines - 1] == blame->filesize)
4089 		blame->nlines--;
4090 
4091 	blame->lines = calloc(blame->nlines, sizeof(*blame->lines));
4092 	if (blame->lines == NULL) {
4093 		err = got_error_from_errno("calloc");
4094 		goto done;
4095 	}
4096 
4097 	err = got_repo_open(&thread_repo, got_repo_get_path(repo), NULL);
4098 	if (err)
4099 		goto done;
4100 
4101 	blame->cb_args.view = view;
4102 	blame->cb_args.lines = blame->lines;
4103 	blame->cb_args.nlines = blame->nlines;
4104 	blame->cb_args.commit_id = got_object_id_dup(commit_id);
4105 	if (blame->cb_args.commit_id == NULL) {
4106 		err = got_error_from_errno("got_object_id_dup");
4107 		goto done;
4108 	}
4109 	blame->cb_args.quit = done;
4110 
4111 	blame->thread_args.path = path;
4112 	blame->thread_args.repo = thread_repo;
4113 	blame->thread_args.cb_args = &blame->cb_args;
4114 	blame->thread_args.complete = blame_complete;
4115 	blame->thread_args.cancel_cb = cancel_blame_view;
4116 	blame->thread_args.cancel_arg = done;
4117 	*blame_complete = 0;
4118 
4119 done:
4120 	if (blob)
4121 		got_object_blob_close(blob);
4122 	free(obj_id);
4123 	if (err)
4124 		stop_blame(blame);
4125 	return err;
4126 }
4127 
4128 static const struct got_error *
4129 open_blame_view(struct tog_view *view, char *path,
4130     struct got_object_id *commit_id, struct got_reflist_head *refs,
4131     struct got_repository *repo)
4132 {
4133 	const struct got_error *err = NULL;
4134 	struct tog_blame_view_state *s = &view->state.blame;
4135 
4136 	SIMPLEQ_INIT(&s->blamed_commits);
4137 
4138 	s->path = strdup(path);
4139 	if (s->path == NULL)
4140 		return got_error_from_errno("strdup");
4141 
4142 	err = got_object_qid_alloc(&s->blamed_commit, commit_id);
4143 	if (err) {
4144 		free(s->path);
4145 		return err;
4146 	}
4147 
4148 	SIMPLEQ_INSERT_HEAD(&s->blamed_commits, s->blamed_commit, entry);
4149 	s->first_displayed_line = 1;
4150 	s->last_displayed_line = view->nlines;
4151 	s->selected_line = 1;
4152 	s->blame_complete = 0;
4153 	s->repo = repo;
4154 	s->refs = refs;
4155 	s->commit_id = commit_id;
4156 	memset(&s->blame, 0, sizeof(s->blame));
4157 
4158 	SIMPLEQ_INIT(&s->colors);
4159 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
4160 		err = add_color(&s->colors, "^", TOG_COLOR_COMMIT,
4161 		    get_color_value("TOG_COLOR_COMMIT"));
4162 		if (err)
4163 			return err;
4164 	}
4165 
4166 	view->show = show_blame_view;
4167 	view->input = input_blame_view;
4168 	view->close = close_blame_view;
4169 	view->search_start = search_start_blame_view;
4170 	view->search_next = search_next_blame_view;
4171 
4172 	return run_blame(&s->blame, view, &s->blame_complete,
4173 	    &s->first_displayed_line, &s->last_displayed_line,
4174 	    &s->selected_line, &s->done, &s->eof, s->path,
4175 	    s->blamed_commit->id, s->repo);
4176 }
4177 
4178 static const struct got_error *
4179 close_blame_view(struct tog_view *view)
4180 {
4181 	const struct got_error *err = NULL;
4182 	struct tog_blame_view_state *s = &view->state.blame;
4183 
4184 	if (s->blame.thread)
4185 		err = stop_blame(&s->blame);
4186 
4187 	while (!SIMPLEQ_EMPTY(&s->blamed_commits)) {
4188 		struct got_object_qid *blamed_commit;
4189 		blamed_commit = SIMPLEQ_FIRST(&s->blamed_commits);
4190 		SIMPLEQ_REMOVE_HEAD(&s->blamed_commits, entry);
4191 		got_object_qid_free(blamed_commit);
4192 	}
4193 
4194 	free(s->path);
4195 	free_colors(&s->colors);
4196 
4197 	return err;
4198 }
4199 
4200 static const struct got_error *
4201 search_start_blame_view(struct tog_view *view)
4202 {
4203 	struct tog_blame_view_state *s = &view->state.blame;
4204 
4205 	s->matched_line = 0;
4206 	return NULL;
4207 }
4208 
4209 static const struct got_error *
4210 search_next_blame_view(struct tog_view *view)
4211 {
4212 	struct tog_blame_view_state *s = &view->state.blame;
4213 	int lineno;
4214 
4215 	if (!view->searching) {
4216 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
4217 		return NULL;
4218 	}
4219 
4220 	if (s->matched_line) {
4221 		if (view->searching == TOG_SEARCH_FORWARD)
4222 			lineno = s->matched_line + 1;
4223 		else
4224 			lineno = s->matched_line - 1;
4225 	} else {
4226 		if (view->searching == TOG_SEARCH_FORWARD)
4227 			lineno = 1;
4228 		else
4229 			lineno = s->blame.nlines;
4230 	}
4231 
4232 	while (1) {
4233 		char *line = NULL;
4234 		off_t offset;
4235 		size_t len;
4236 
4237 		if (lineno <= 0 || lineno > s->blame.nlines) {
4238 			if (s->matched_line == 0) {
4239 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
4240 				free(line);
4241 				break;
4242 			}
4243 
4244 			if (view->searching == TOG_SEARCH_FORWARD)
4245 				lineno = 1;
4246 			else
4247 				lineno = s->blame.nlines;
4248 		}
4249 
4250 		offset = s->blame.line_offsets[lineno - 1];
4251 		if (fseeko(s->blame.f, offset, SEEK_SET) != 0) {
4252 			free(line);
4253 			return got_error_from_errno("fseeko");
4254 		}
4255 		free(line);
4256 		line = parse_next_line(s->blame.f, &len);
4257 		if (line && match_line(line, &view->regex)) {
4258 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
4259 			s->matched_line = lineno;
4260 			free(line);
4261 			break;
4262 		}
4263 		free(line);
4264 		if (view->searching == TOG_SEARCH_FORWARD)
4265 			lineno++;
4266 		else
4267 			lineno--;
4268 	}
4269 
4270 	if (s->matched_line) {
4271 		s->first_displayed_line = s->matched_line;
4272 		s->selected_line = 1;
4273 	}
4274 
4275 	return NULL;
4276 }
4277 
4278 static const struct got_error *
4279 show_blame_view(struct tog_view *view)
4280 {
4281 	const struct got_error *err = NULL;
4282 	struct tog_blame_view_state *s = &view->state.blame;
4283 	int errcode;
4284 
4285 	if (s->blame.thread == NULL) {
4286 		errcode = pthread_create(&s->blame.thread, NULL, blame_thread,
4287 		    &s->blame.thread_args);
4288 		if (errcode)
4289 			return got_error_set_errno(errcode, "pthread_create");
4290 
4291 		halfdelay(1); /* fast refresh while annotating  */
4292 	}
4293 
4294 	if (s->blame_complete)
4295 		halfdelay(10); /* disable fast refresh */
4296 
4297 	err = draw_blame(view, s->blamed_commit->id, s->blame.f,
4298 	    s->path, s->blame.lines, s->blame.nlines, s->blame_complete,
4299 	    s->selected_line, &s->first_displayed_line,
4300 	    &s->last_displayed_line, &s->eof, view->nlines, &s->colors);
4301 
4302 	view_vborder(view);
4303 	return err;
4304 }
4305 
4306 static const struct got_error *
4307 input_blame_view(struct tog_view **new_view, struct tog_view **dead_view,
4308     struct tog_view **focus_view, struct tog_view *view, int ch)
4309 {
4310 	const struct got_error *err = NULL, *thread_err = NULL;
4311 	struct tog_view *diff_view;
4312 	struct tog_blame_view_state *s = &view->state.blame;
4313 	int begin_x = 0;
4314 
4315 	switch (ch) {
4316 	case 'q':
4317 		s->done = 1;
4318 		break;
4319 	case 'k':
4320 	case KEY_UP:
4321 		if (s->selected_line > 1)
4322 			s->selected_line--;
4323 		else if (s->selected_line == 1 &&
4324 		    s->first_displayed_line > 1)
4325 			s->first_displayed_line--;
4326 		break;
4327 	case KEY_PPAGE:
4328 	case CTRL('b'):
4329 		if (s->first_displayed_line == 1) {
4330 			s->selected_line = 1;
4331 			break;
4332 		}
4333 		if (s->first_displayed_line > view->nlines - 2)
4334 			s->first_displayed_line -=
4335 			    (view->nlines - 2);
4336 		else
4337 			s->first_displayed_line = 1;
4338 		break;
4339 	case 'j':
4340 	case KEY_DOWN:
4341 		if (s->selected_line < view->nlines - 2 &&
4342 		    s->first_displayed_line +
4343 		    s->selected_line <= s->blame.nlines)
4344 			s->selected_line++;
4345 		else if (s->last_displayed_line <
4346 		    s->blame.nlines)
4347 			s->first_displayed_line++;
4348 		break;
4349 	case 'b':
4350 	case 'p': {
4351 		struct got_object_id *id = NULL;
4352 		id = get_selected_commit_id(s->blame.lines, s->blame.nlines,
4353 		    s->first_displayed_line, s->selected_line);
4354 		if (id == NULL)
4355 			break;
4356 		if (ch == 'p') {
4357 			struct got_commit_object *commit;
4358 			struct got_object_qid *pid;
4359 			struct got_object_id *blob_id = NULL;
4360 			int obj_type;
4361 			err = got_object_open_as_commit(&commit,
4362 			    s->repo, id);
4363 			if (err)
4364 				break;
4365 			pid = SIMPLEQ_FIRST(
4366 			    got_object_commit_get_parent_ids(commit));
4367 			if (pid == NULL) {
4368 				got_object_commit_close(commit);
4369 				break;
4370 			}
4371 			/* Check if path history ends here. */
4372 			err = got_object_id_by_path(&blob_id, s->repo,
4373 			    pid->id, s->path);
4374 			if (err) {
4375 				if (err->code == GOT_ERR_NO_TREE_ENTRY)
4376 					err = NULL;
4377 				got_object_commit_close(commit);
4378 				break;
4379 			}
4380 			err = got_object_get_type(&obj_type, s->repo,
4381 			    blob_id);
4382 			free(blob_id);
4383 			/* Can't blame non-blob type objects. */
4384 			if (obj_type != GOT_OBJ_TYPE_BLOB) {
4385 				got_object_commit_close(commit);
4386 				break;
4387 			}
4388 			err = got_object_qid_alloc(&s->blamed_commit,
4389 			    pid->id);
4390 			got_object_commit_close(commit);
4391 		} else {
4392 			if (got_object_id_cmp(id,
4393 			    s->blamed_commit->id) == 0)
4394 				break;
4395 			err = got_object_qid_alloc(&s->blamed_commit,
4396 			    id);
4397 		}
4398 		if (err)
4399 			break;
4400 		s->done = 1;
4401 		thread_err = stop_blame(&s->blame);
4402 		s->done = 0;
4403 		if (thread_err)
4404 			break;
4405 		SIMPLEQ_INSERT_HEAD(&s->blamed_commits,
4406 		    s->blamed_commit, entry);
4407 		err = run_blame(&s->blame, view, &s->blame_complete,
4408 		    &s->first_displayed_line, &s->last_displayed_line,
4409 		    &s->selected_line, &s->done, &s->eof,
4410 		    s->path, s->blamed_commit->id, s->repo);
4411 		if (err)
4412 			break;
4413 		break;
4414 	}
4415 	case 'B': {
4416 		struct got_object_qid *first;
4417 		first = SIMPLEQ_FIRST(&s->blamed_commits);
4418 		if (!got_object_id_cmp(first->id, s->commit_id))
4419 			break;
4420 		s->done = 1;
4421 		thread_err = stop_blame(&s->blame);
4422 		s->done = 0;
4423 		if (thread_err)
4424 			break;
4425 		SIMPLEQ_REMOVE_HEAD(&s->blamed_commits, entry);
4426 		got_object_qid_free(s->blamed_commit);
4427 		s->blamed_commit =
4428 		    SIMPLEQ_FIRST(&s->blamed_commits);
4429 		err = run_blame(&s->blame, view, &s->blame_complete,
4430 		    &s->first_displayed_line, &s->last_displayed_line,
4431 		    &s->selected_line, &s->done, &s->eof, s->path,
4432 		    s->blamed_commit->id, s->repo);
4433 		if (err)
4434 			break;
4435 		break;
4436 	}
4437 	case KEY_ENTER:
4438 	case '\r': {
4439 		struct got_object_id *id = NULL;
4440 		struct got_object_qid *pid;
4441 		struct got_commit_object *commit = NULL;
4442 		id = get_selected_commit_id(s->blame.lines, s->blame.nlines,
4443 		    s->first_displayed_line, s->selected_line);
4444 		if (id == NULL)
4445 			break;
4446 		err = got_object_open_as_commit(&commit, s->repo, id);
4447 		if (err)
4448 			break;
4449 		pid = SIMPLEQ_FIRST(
4450 		    got_object_commit_get_parent_ids(commit));
4451 		if (view_is_parent_view(view))
4452 		    begin_x = view_split_begin_x(view->begin_x);
4453 		diff_view = view_open(0, 0, 0, begin_x, TOG_VIEW_DIFF);
4454 		if (diff_view == NULL) {
4455 			got_object_commit_close(commit);
4456 			err = got_error_from_errno("view_open");
4457 			break;
4458 		}
4459 		err = open_diff_view(diff_view, pid ? pid->id : NULL,
4460 		    id, NULL, s->refs, s->repo);
4461 		got_object_commit_close(commit);
4462 		if (err) {
4463 			view_close(diff_view);
4464 			break;
4465 		}
4466 		if (view_is_parent_view(view)) {
4467 			err = view_close_child(view);
4468 			if (err)
4469 				break;
4470 			err = view_set_child(view, diff_view);
4471 			if (err) {
4472 				view_close(diff_view);
4473 				break;
4474 			}
4475 			*focus_view = diff_view;
4476 			view->child_focussed = 1;
4477 		} else
4478 			*new_view = diff_view;
4479 		if (err)
4480 			break;
4481 		break;
4482 	}
4483 	case KEY_NPAGE:
4484 	case CTRL('f'):
4485 	case ' ':
4486 		if (s->last_displayed_line >= s->blame.nlines &&
4487 		    s->selected_line >= MIN(s->blame.nlines,
4488 		    view->nlines - 2)) {
4489 			break;
4490 		}
4491 		if (s->last_displayed_line >= s->blame.nlines &&
4492 		    s->selected_line < view->nlines - 2) {
4493 			s->selected_line = MIN(s->blame.nlines,
4494 			    view->nlines - 2);
4495 			break;
4496 		}
4497 		if (s->last_displayed_line + view->nlines - 2
4498 		    <= s->blame.nlines)
4499 			s->first_displayed_line +=
4500 			    view->nlines - 2;
4501 		else
4502 			s->first_displayed_line =
4503 			    s->blame.nlines -
4504 			    (view->nlines - 3);
4505 		break;
4506 	case KEY_RESIZE:
4507 		if (s->selected_line > view->nlines - 2) {
4508 			s->selected_line = MIN(s->blame.nlines,
4509 			    view->nlines - 2);
4510 		}
4511 		break;
4512 	default:
4513 		break;
4514 	}
4515 	return thread_err ? thread_err : err;
4516 }
4517 
4518 static const struct got_error *
4519 cmd_blame(int argc, char *argv[])
4520 {
4521 	const struct got_error *error;
4522 	struct got_repository *repo = NULL;
4523 	struct got_reflist_head refs;
4524 	struct got_worktree *worktree = NULL;
4525 	char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
4526 	char *link_target = NULL;
4527 	struct got_object_id *commit_id = NULL;
4528 	char *commit_id_str = NULL;
4529 	int ch;
4530 	struct tog_view *view;
4531 
4532 	SIMPLEQ_INIT(&refs);
4533 
4534 #ifndef PROFILE
4535 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
4536 	    NULL) == -1)
4537 		err(1, "pledge");
4538 #endif
4539 
4540 	while ((ch = getopt(argc, argv, "c:r:")) != -1) {
4541 		switch (ch) {
4542 		case 'c':
4543 			commit_id_str = optarg;
4544 			break;
4545 		case 'r':
4546 			repo_path = realpath(optarg, NULL);
4547 			if (repo_path == NULL)
4548 				return got_error_from_errno2("realpath",
4549 				    optarg);
4550 			break;
4551 		default:
4552 			usage_blame();
4553 			/* NOTREACHED */
4554 		}
4555 	}
4556 
4557 	argc -= optind;
4558 	argv += optind;
4559 
4560 	if (argc != 1)
4561 		usage_blame();
4562 
4563 	cwd = getcwd(NULL, 0);
4564 	if (cwd == NULL)
4565 		return got_error_from_errno("getcwd");
4566 
4567 	error = got_worktree_open(&worktree, cwd);
4568 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
4569 		goto done;
4570 
4571 	if (repo_path == NULL) {
4572 		if (worktree)
4573 			repo_path =
4574 			    strdup(got_worktree_get_repo_path(worktree));
4575 		else
4576 			repo_path = strdup(cwd);
4577 	}
4578 	if (repo_path == NULL) {
4579 		error = got_error_from_errno("strdup");
4580 		goto done;
4581 	}
4582 
4583 	error = got_repo_open(&repo, repo_path, NULL);
4584 	if (error != NULL)
4585 		goto done;
4586 
4587 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv, repo,
4588 	    worktree);
4589 	if (error)
4590 		goto done;
4591 
4592 	init_curses();
4593 
4594 	error = apply_unveil(got_repo_get_path(repo), NULL);
4595 	if (error)
4596 		goto done;
4597 
4598 	if (commit_id_str == NULL) {
4599 		struct got_reference *head_ref;
4600 		error = got_ref_open(&head_ref, repo, worktree ?
4601 		    got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD, 0);
4602 		if (error != NULL)
4603 			goto done;
4604 		error = got_ref_resolve(&commit_id, repo, head_ref);
4605 		got_ref_close(head_ref);
4606 	} else {
4607 		error = got_repo_match_object_id(&commit_id, NULL,
4608 		    commit_id_str, GOT_OBJ_TYPE_COMMIT, 1, repo);
4609 	}
4610 	if (error != NULL)
4611 		goto done;
4612 
4613 	error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
4614 	if (error)
4615 		goto done;
4616 
4617 	view = view_open(0, 0, 0, 0, TOG_VIEW_BLAME);
4618 	if (view == NULL) {
4619 		error = got_error_from_errno("view_open");
4620 		goto done;
4621 	}
4622 
4623 	error = got_object_resolve_symlinks(&link_target, in_repo_path,
4624 	    commit_id, repo);
4625 	if (error)
4626 		goto done;
4627 
4628 	error = open_blame_view(view, link_target ? link_target : in_repo_path,
4629 	    commit_id, &refs, repo);
4630 	if (error)
4631 		goto done;
4632 	if (worktree) {
4633 		/* Release work tree lock. */
4634 		got_worktree_close(worktree);
4635 		worktree = NULL;
4636 	}
4637 	error = view_loop(view);
4638 done:
4639 	free(repo_path);
4640 	free(in_repo_path);
4641 	free(link_target);
4642 	free(cwd);
4643 	free(commit_id);
4644 	if (worktree)
4645 		got_worktree_close(worktree);
4646 	if (repo)
4647 		got_repo_close(repo);
4648 	got_ref_list_free(&refs);
4649 	return error;
4650 }
4651 
4652 static const struct got_error *
4653 draw_tree_entries(struct tog_view *view,
4654     struct got_tree_entry **first_displayed_entry,
4655     struct got_tree_entry **last_displayed_entry,
4656     struct got_tree_entry **selected_entry, int *ndisplayed,
4657     const char *label, int show_ids, const char *parent_path,
4658     struct got_tree_object *tree, int selected, int limit,
4659     int isroot, struct tog_colors *colors, struct got_repository *repo)
4660 {
4661 	const struct got_error *err = NULL;
4662 	struct got_tree_entry *te;
4663 	wchar_t *wline;
4664 	struct tog_color *tc;
4665 	int width, n, i, nentries;
4666 
4667 	*ndisplayed = 0;
4668 
4669 	werase(view->window);
4670 
4671 	if (limit == 0)
4672 		return NULL;
4673 
4674 	err = format_line(&wline, &width, label, view->ncols, 0);
4675 	if (err)
4676 		return err;
4677 	if (view_needs_focus_indication(view))
4678 		wstandout(view->window);
4679 	tc = get_color(colors, TOG_COLOR_COMMIT);
4680 	if (tc)
4681 		wattr_on(view->window,
4682 		    COLOR_PAIR(tc->colorpair), NULL);
4683 	waddwstr(view->window, wline);
4684 	if (tc)
4685 		wattr_off(view->window,
4686 		    COLOR_PAIR(tc->colorpair), NULL);
4687 	if (view_needs_focus_indication(view))
4688 		wstandend(view->window);
4689 	free(wline);
4690 	wline = NULL;
4691 	if (width < view->ncols - 1)
4692 		waddch(view->window, '\n');
4693 	if (--limit <= 0)
4694 		return NULL;
4695 	err = format_line(&wline, &width, parent_path, view->ncols, 0);
4696 	if (err)
4697 		return err;
4698 	waddwstr(view->window, wline);
4699 	free(wline);
4700 	wline = NULL;
4701 	if (width < view->ncols - 1)
4702 		waddch(view->window, '\n');
4703 	if (--limit <= 0)
4704 		return NULL;
4705 	waddch(view->window, '\n');
4706 	if (--limit <= 0)
4707 		return NULL;
4708 
4709 	if (*first_displayed_entry == NULL) {
4710 		te = got_object_tree_get_first_entry(tree);
4711 		if (selected == 0) {
4712 			if (view->focussed)
4713 				wstandout(view->window);
4714 			*selected_entry = NULL;
4715 		}
4716 		waddstr(view->window, "  ..\n");	/* parent directory */
4717 		if (selected == 0 && view->focussed)
4718 			wstandend(view->window);
4719 		(*ndisplayed)++;
4720 		if (--limit <= 0)
4721 			return NULL;
4722 		n = 1;
4723 	} else {
4724 		n = 0;
4725 		te = *first_displayed_entry;
4726 	}
4727 
4728 	nentries = got_object_tree_get_nentries(tree);
4729 	for (i = got_tree_entry_get_index(te); i < nentries; i++) {
4730 		char *line = NULL, *id_str = NULL, *link_target = NULL;
4731 		const char *modestr = "";
4732 		mode_t mode;
4733 
4734 		te = got_object_tree_get_entry(tree, i);
4735 		mode = got_tree_entry_get_mode(te);
4736 
4737 		if (show_ids) {
4738 			err = got_object_id_str(&id_str,
4739 			    got_tree_entry_get_id(te));
4740 			if (err)
4741 				return got_error_from_errno(
4742 				    "got_object_id_str");
4743 		}
4744 		if (got_object_tree_entry_is_submodule(te))
4745 			modestr = "$";
4746 		else if (S_ISLNK(mode)) {
4747 			int i;
4748 
4749 			err = got_tree_entry_get_symlink_target(&link_target,
4750 			    te, repo);
4751 			if (err) {
4752 				free(id_str);
4753 				return err;
4754 			}
4755 			for (i = 0; i < strlen(link_target); i++) {
4756 				if (!isprint((unsigned char)link_target[i]))
4757 					link_target[i] = '?';
4758 			}
4759 			modestr = "@";
4760 		}
4761 		else if (S_ISDIR(mode))
4762 			modestr = "/";
4763 		else if (mode & S_IXUSR)
4764 			modestr = "*";
4765 		if (asprintf(&line, "%s  %s%s%s%s", id_str ? id_str : "",
4766 		    got_tree_entry_get_name(te), modestr,
4767 		    link_target ? " -> ": "",
4768 		    link_target ? link_target : "") == -1) {
4769 			free(id_str);
4770 			free(link_target);
4771 			return got_error_from_errno("asprintf");
4772 		}
4773 		free(id_str);
4774 		free(link_target);
4775 		err = format_line(&wline, &width, line, view->ncols, 0);
4776 		if (err) {
4777 			free(line);
4778 			break;
4779 		}
4780 		if (n == selected) {
4781 			if (view->focussed)
4782 				wstandout(view->window);
4783 			*selected_entry = te;
4784 		}
4785 		tc = match_color(colors, line);
4786 		if (tc)
4787 			wattr_on(view->window,
4788 			    COLOR_PAIR(tc->colorpair), NULL);
4789 		waddwstr(view->window, wline);
4790 		if (tc)
4791 			wattr_off(view->window,
4792 			    COLOR_PAIR(tc->colorpair), NULL);
4793 		if (width < view->ncols - 1)
4794 			waddch(view->window, '\n');
4795 		if (n == selected && view->focussed)
4796 			wstandend(view->window);
4797 		free(line);
4798 		free(wline);
4799 		wline = NULL;
4800 		n++;
4801 		(*ndisplayed)++;
4802 		*last_displayed_entry = te;
4803 		if (--limit <= 0)
4804 			break;
4805 	}
4806 
4807 	return err;
4808 }
4809 
4810 static void
4811 tree_scroll_up(struct tog_view *view,
4812     struct got_tree_entry **first_displayed_entry, int maxscroll,
4813     struct got_tree_object *tree, int isroot)
4814 {
4815 	struct got_tree_entry *te;
4816 	int i;
4817 
4818 	if (*first_displayed_entry == NULL)
4819 		return;
4820 
4821 	te = got_object_tree_get_entry(tree, 0);
4822 	if (*first_displayed_entry == te) {
4823 		if (!isroot)
4824 			*first_displayed_entry = NULL;
4825 		return;
4826 	}
4827 
4828 	i = 0;
4829 	while (*first_displayed_entry && i < maxscroll) {
4830 		*first_displayed_entry = got_tree_entry_get_prev(tree,
4831 		    *first_displayed_entry);
4832 		i++;
4833 	}
4834 	if (!isroot && te == got_object_tree_get_first_entry(tree) && i < maxscroll)
4835 		*first_displayed_entry = NULL;
4836 }
4837 
4838 static int
4839 tree_scroll_down(struct got_tree_entry **first_displayed_entry, int maxscroll,
4840 	struct got_tree_entry *last_displayed_entry,
4841 	struct got_tree_object *tree)
4842 {
4843 	struct got_tree_entry *next, *last;
4844 	int n = 0;
4845 
4846 	if (*first_displayed_entry)
4847 		next = got_tree_entry_get_next(tree, *first_displayed_entry);
4848 	else
4849 		next = got_object_tree_get_first_entry(tree);
4850 
4851 	last = last_displayed_entry;
4852 	while (next && last && n++ < maxscroll) {
4853 		last = got_tree_entry_get_next(tree, last);
4854 		if (last) {
4855 			*first_displayed_entry = next;
4856 			next = got_tree_entry_get_next(tree, next);
4857 		}
4858 	}
4859 	return n;
4860 }
4861 
4862 static const struct got_error *
4863 tree_entry_path(char **path, struct tog_parent_trees *parents,
4864     struct got_tree_entry *te)
4865 {
4866 	const struct got_error *err = NULL;
4867 	struct tog_parent_tree *pt;
4868 	size_t len = 2; /* for leading slash and NUL */
4869 
4870 	TAILQ_FOREACH(pt, parents, entry)
4871 		len += strlen(got_tree_entry_get_name(pt->selected_entry))
4872 		    + 1 /* slash */;
4873 	if (te)
4874 		len += strlen(got_tree_entry_get_name(te));
4875 
4876 	*path = calloc(1, len);
4877 	if (path == NULL)
4878 		return got_error_from_errno("calloc");
4879 
4880 	(*path)[0] = '/';
4881 	pt = TAILQ_LAST(parents, tog_parent_trees);
4882 	while (pt) {
4883 		const char *name = got_tree_entry_get_name(pt->selected_entry);
4884 		if (strlcat(*path, name, len) >= len) {
4885 			err = got_error(GOT_ERR_NO_SPACE);
4886 			goto done;
4887 		}
4888 		if (strlcat(*path, "/", len) >= len) {
4889 			err = got_error(GOT_ERR_NO_SPACE);
4890 			goto done;
4891 		}
4892 		pt = TAILQ_PREV(pt, tog_parent_trees, entry);
4893 	}
4894 	if (te) {
4895 		if (strlcat(*path, got_tree_entry_get_name(te), len) >= len) {
4896 			err = got_error(GOT_ERR_NO_SPACE);
4897 			goto done;
4898 		}
4899 	}
4900 done:
4901 	if (err) {
4902 		free(*path);
4903 		*path = NULL;
4904 	}
4905 	return err;
4906 }
4907 
4908 static const struct got_error *
4909 blame_tree_entry(struct tog_view **new_view, int begin_x,
4910     struct got_tree_entry *te, struct tog_parent_trees *parents,
4911     struct got_object_id *commit_id, struct got_reflist_head *refs,
4912     struct got_repository *repo)
4913 {
4914 	const struct got_error *err = NULL;
4915 	char *path;
4916 	struct tog_view *blame_view;
4917 
4918 	*new_view = NULL;
4919 
4920 	err = tree_entry_path(&path, parents, te);
4921 	if (err)
4922 		return err;
4923 
4924 	blame_view = view_open(0, 0, 0, begin_x, TOG_VIEW_BLAME);
4925 	if (blame_view == NULL) {
4926 		err = got_error_from_errno("view_open");
4927 		goto done;
4928 	}
4929 
4930 	err = open_blame_view(blame_view, path, commit_id, refs, repo);
4931 	if (err) {
4932 		if (err->code == GOT_ERR_CANCELLED)
4933 			err = NULL;
4934 		view_close(blame_view);
4935 	} else
4936 		*new_view = blame_view;
4937 done:
4938 	free(path);
4939 	return err;
4940 }
4941 
4942 static const struct got_error *
4943 log_tree_entry(struct tog_view **new_view, int begin_x,
4944     struct got_tree_entry *te, struct tog_parent_trees *parents,
4945     struct got_object_id *commit_id, struct got_reflist_head *refs,
4946     struct got_repository *repo)
4947 {
4948 	struct tog_view *log_view;
4949 	const struct got_error *err = NULL;
4950 	char *path;
4951 
4952 	*new_view = NULL;
4953 
4954 	log_view = view_open(0, 0, 0, begin_x, TOG_VIEW_LOG);
4955 	if (log_view == NULL)
4956 		return got_error_from_errno("view_open");
4957 
4958 	err = tree_entry_path(&path, parents, te);
4959 	if (err)
4960 		return err;
4961 
4962 	err = open_log_view(log_view, commit_id, refs, repo, NULL, path, 0);
4963 	if (err)
4964 		view_close(log_view);
4965 	else
4966 		*new_view = log_view;
4967 	free(path);
4968 	return err;
4969 }
4970 
4971 static const struct got_error *
4972 open_tree_view(struct tog_view *view, struct got_tree_object *root,
4973     struct got_object_id *commit_id, struct got_reflist_head *refs,
4974     struct got_repository *repo)
4975 {
4976 	const struct got_error *err = NULL;
4977 	char *commit_id_str = NULL;
4978 	struct tog_tree_view_state *s = &view->state.tree;
4979 
4980 	TAILQ_INIT(&s->parents);
4981 
4982 	err = got_object_id_str(&commit_id_str, commit_id);
4983 	if (err != NULL)
4984 		goto done;
4985 
4986 	if (asprintf(&s->tree_label, "commit %s", commit_id_str) == -1) {
4987 		err = got_error_from_errno("asprintf");
4988 		goto done;
4989 	}
4990 
4991 	s->root = s->tree = root;
4992 	s->first_displayed_entry = got_object_tree_get_entry(s->tree, 0);
4993 	s->selected_entry = got_object_tree_get_entry(s->tree, 0);
4994 	s->commit_id = got_object_id_dup(commit_id);
4995 	if (s->commit_id == NULL) {
4996 		err = got_error_from_errno("got_object_id_dup");
4997 		goto done;
4998 	}
4999 	s->refs = refs;
5000 	s->repo = repo;
5001 
5002 	SIMPLEQ_INIT(&s->colors);
5003 
5004 	if (has_colors() && getenv("TOG_COLORS") != NULL) {
5005 		err = add_color(&s->colors, "\\$$",
5006 		    TOG_COLOR_TREE_SUBMODULE,
5007 		    get_color_value("TOG_COLOR_TREE_SUBMODULE"));
5008 		if (err)
5009 			goto done;
5010 		err = add_color(&s->colors, "@$", TOG_COLOR_TREE_SYMLINK,
5011 		    get_color_value("TOG_COLOR_TREE_SYMLINK"));
5012 		if (err) {
5013 			free_colors(&s->colors);
5014 			goto done;
5015 		}
5016 		err = add_color(&s->colors, "/$",
5017 		    TOG_COLOR_TREE_DIRECTORY,
5018 		    get_color_value("TOG_COLOR_TREE_DIRECTORY"));
5019 		if (err) {
5020 			free_colors(&s->colors);
5021 			goto done;
5022 		}
5023 
5024 		err = add_color(&s->colors, "\\*$",
5025 		    TOG_COLOR_TREE_EXECUTABLE,
5026 		    get_color_value("TOG_COLOR_TREE_EXECUTABLE"));
5027 		if (err) {
5028 			free_colors(&s->colors);
5029 			goto done;
5030 		}
5031 
5032 		err = add_color(&s->colors, "^$", TOG_COLOR_COMMIT,
5033 		    get_color_value("TOG_COLOR_COMMIT"));
5034 		if (err) {
5035 			free_colors(&s->colors);
5036 			goto done;
5037 		}
5038 	}
5039 
5040 	view->show = show_tree_view;
5041 	view->input = input_tree_view;
5042 	view->close = close_tree_view;
5043 	view->search_start = search_start_tree_view;
5044 	view->search_next = search_next_tree_view;
5045 done:
5046 	free(commit_id_str);
5047 	if (err) {
5048 		free(s->tree_label);
5049 		s->tree_label = NULL;
5050 	}
5051 	return err;
5052 }
5053 
5054 static const struct got_error *
5055 close_tree_view(struct tog_view *view)
5056 {
5057 	struct tog_tree_view_state *s = &view->state.tree;
5058 
5059 	free_colors(&s->colors);
5060 	free(s->tree_label);
5061 	s->tree_label = NULL;
5062 	free(s->commit_id);
5063 	s->commit_id = NULL;
5064 	while (!TAILQ_EMPTY(&s->parents)) {
5065 		struct tog_parent_tree *parent;
5066 		parent = TAILQ_FIRST(&s->parents);
5067 		TAILQ_REMOVE(&s->parents, parent, entry);
5068 		free(parent);
5069 
5070 	}
5071 	if (s->tree != s->root)
5072 		got_object_tree_close(s->tree);
5073 	got_object_tree_close(s->root);
5074 
5075 	return NULL;
5076 }
5077 
5078 static const struct got_error *
5079 search_start_tree_view(struct tog_view *view)
5080 {
5081 	struct tog_tree_view_state *s = &view->state.tree;
5082 
5083 	s->matched_entry = NULL;
5084 	return NULL;
5085 }
5086 
5087 static int
5088 match_tree_entry(struct got_tree_entry *te, regex_t *regex)
5089 {
5090 	regmatch_t regmatch;
5091 
5092 	return regexec(regex, got_tree_entry_get_name(te), 1, &regmatch,
5093 	    0) == 0;
5094 }
5095 
5096 static const struct got_error *
5097 search_next_tree_view(struct tog_view *view)
5098 {
5099 	struct tog_tree_view_state *s = &view->state.tree;
5100 	struct got_tree_entry *te = NULL;
5101 
5102 	if (!view->searching) {
5103 		view->search_next_done = TOG_SEARCH_HAVE_MORE;
5104 		return NULL;
5105 	}
5106 
5107 	if (s->matched_entry) {
5108 		if (view->searching == TOG_SEARCH_FORWARD) {
5109 			if (s->selected_entry)
5110 				te = got_tree_entry_get_next(s->tree,
5111 				    s->selected_entry);
5112 			else
5113 				te = got_object_tree_get_first_entry(s->tree);
5114 		} else {
5115 			if (s->selected_entry == NULL)
5116 				te = got_object_tree_get_last_entry(s->tree);
5117 			else
5118 				te = got_tree_entry_get_prev(s->tree,
5119 				    s->selected_entry);
5120 		}
5121 	} else {
5122 		if (view->searching == TOG_SEARCH_FORWARD)
5123 			te = got_object_tree_get_first_entry(s->tree);
5124 		else
5125 			te = got_object_tree_get_last_entry(s->tree);
5126 	}
5127 
5128 	while (1) {
5129 		if (te == NULL) {
5130 			if (s->matched_entry == NULL) {
5131 				view->search_next_done = TOG_SEARCH_HAVE_MORE;
5132 				return NULL;
5133 			}
5134 			if (view->searching == TOG_SEARCH_FORWARD)
5135 				te = got_object_tree_get_first_entry(s->tree);
5136 			else
5137 				te = got_object_tree_get_last_entry(s->tree);
5138 		}
5139 
5140 		if (match_tree_entry(te, &view->regex)) {
5141 			view->search_next_done = TOG_SEARCH_HAVE_MORE;
5142 			s->matched_entry = te;
5143 			break;
5144 		}
5145 
5146 		if (view->searching == TOG_SEARCH_FORWARD)
5147 			te = got_tree_entry_get_next(s->tree, te);
5148 		else
5149 			te = got_tree_entry_get_prev(s->tree, te);
5150 	}
5151 
5152 	if (s->matched_entry) {
5153 		s->first_displayed_entry = s->matched_entry;
5154 		s->selected = 0;
5155 	}
5156 
5157 	return NULL;
5158 }
5159 
5160 static const struct got_error *
5161 show_tree_view(struct tog_view *view)
5162 {
5163 	const struct got_error *err = NULL;
5164 	struct tog_tree_view_state *s = &view->state.tree;
5165 	char *parent_path;
5166 
5167 	err = tree_entry_path(&parent_path, &s->parents, NULL);
5168 	if (err)
5169 		return err;
5170 
5171 	err = draw_tree_entries(view, &s->first_displayed_entry,
5172 	    &s->last_displayed_entry, &s->selected_entry,
5173 	    &s->ndisplayed, s->tree_label, s->show_ids, parent_path,
5174 	    s->tree, s->selected, view->nlines, s->tree == s->root,
5175 	    &s->colors, s->repo);
5176 	free(parent_path);
5177 
5178 	view_vborder(view);
5179 	return err;
5180 }
5181 
5182 static const struct got_error *
5183 input_tree_view(struct tog_view **new_view, struct tog_view **dead_view,
5184     struct tog_view **focus_view, struct tog_view *view, int ch)
5185 {
5186 	const struct got_error *err = NULL;
5187 	struct tog_tree_view_state *s = &view->state.tree;
5188 	struct tog_view *log_view;
5189 	int begin_x = 0, nscrolled;
5190 
5191 	switch (ch) {
5192 	case 'i':
5193 		s->show_ids = !s->show_ids;
5194 		break;
5195 	case 'l':
5196 		if (!s->selected_entry)
5197 			break;
5198 		if (view_is_parent_view(view))
5199 			begin_x = view_split_begin_x(view->begin_x);
5200 		err = log_tree_entry(&log_view, begin_x,
5201 		    s->selected_entry, &s->parents,
5202 		    s->commit_id, s->refs, s->repo);
5203 		if (view_is_parent_view(view)) {
5204 			err = view_close_child(view);
5205 			if (err)
5206 				return err;
5207 			err = view_set_child(view, log_view);
5208 			if (err) {
5209 				view_close(log_view);
5210 				break;
5211 			}
5212 			*focus_view = log_view;
5213 			view->child_focussed = 1;
5214 		} else
5215 			*new_view = log_view;
5216 		break;
5217 	case 'k':
5218 	case KEY_UP:
5219 		if (s->selected > 0) {
5220 			s->selected--;
5221 			if (s->selected == 0)
5222 				break;
5223 		}
5224 		if (s->selected > 0)
5225 			break;
5226 		tree_scroll_up(view, &s->first_displayed_entry, 1,
5227 		    s->tree, s->tree == s->root);
5228 		break;
5229 	case KEY_PPAGE:
5230 	case CTRL('b'):
5231 		tree_scroll_up(view, &s->first_displayed_entry,
5232 		    MAX(0, view->nlines - 4 - s->selected), s->tree,
5233 		    s->tree == s->root);
5234 		s->selected = 0;
5235 		if (got_object_tree_get_first_entry(s->tree) ==
5236 		    s->first_displayed_entry && s->tree != s->root)
5237 			s->first_displayed_entry = NULL;
5238 		break;
5239 	case 'j':
5240 	case KEY_DOWN:
5241 		if (s->selected < s->ndisplayed - 1) {
5242 			s->selected++;
5243 			break;
5244 		}
5245 		if (got_tree_entry_get_next(s->tree, s->last_displayed_entry)
5246 		    == NULL)
5247 			/* can't scroll any further */
5248 			break;
5249 		tree_scroll_down(&s->first_displayed_entry, 1,
5250 		    s->last_displayed_entry, s->tree);
5251 		break;
5252 	case KEY_NPAGE:
5253 	case CTRL('f'):
5254 		if (got_tree_entry_get_next(s->tree, s->last_displayed_entry)
5255 		    == NULL) {
5256 			/* can't scroll any further; move cursor down */
5257 			if (s->selected < s->ndisplayed - 1)
5258 				s->selected = s->ndisplayed - 1;
5259 			break;
5260 		}
5261 		nscrolled = tree_scroll_down(&s->first_displayed_entry,
5262 		    view->nlines, s->last_displayed_entry, s->tree);
5263 		if (nscrolled < view->nlines) {
5264 			int ndisplayed = 0;
5265 			struct got_tree_entry *te;
5266 			te = s->first_displayed_entry;
5267 			do {
5268 				ndisplayed++;
5269 				te = got_tree_entry_get_next(s->tree, te);
5270 			} while (te);
5271 			s->selected = ndisplayed - 1;
5272 		}
5273 		break;
5274 	case KEY_ENTER:
5275 	case '\r':
5276 	case KEY_BACKSPACE:
5277 		if (s->selected_entry == NULL || ch == KEY_BACKSPACE) {
5278 			struct tog_parent_tree *parent;
5279 			/* user selected '..' */
5280 			if (s->tree == s->root)
5281 				break;
5282 			parent = TAILQ_FIRST(&s->parents);
5283 			TAILQ_REMOVE(&s->parents, parent,
5284 			    entry);
5285 			got_object_tree_close(s->tree);
5286 			s->tree = parent->tree;
5287 			s->first_displayed_entry =
5288 			    parent->first_displayed_entry;
5289 			s->selected_entry =
5290 			    parent->selected_entry;
5291 			s->selected = parent->selected;
5292 			free(parent);
5293 		} else if (S_ISDIR(got_tree_entry_get_mode(
5294 		    s->selected_entry))) {
5295 			struct got_tree_object *subtree;
5296 			err = got_object_open_as_tree(&subtree, s->repo,
5297 			    got_tree_entry_get_id(s->selected_entry));
5298 			if (err)
5299 				break;
5300 			err = tree_view_visit_subtree(subtree, s);
5301 			if (err) {
5302 				got_object_tree_close(subtree);
5303 				break;
5304 			}
5305 		} else if (S_ISREG(got_tree_entry_get_mode(
5306 		    s->selected_entry))) {
5307 			struct tog_view *blame_view;
5308 			int begin_x = view_is_parent_view(view) ?
5309 			    view_split_begin_x(view->begin_x) : 0;
5310 
5311 			err = blame_tree_entry(&blame_view, begin_x,
5312 			    s->selected_entry, &s->parents,
5313 			    s->commit_id, s->refs, s->repo);
5314 			if (err)
5315 				break;
5316 			if (view_is_parent_view(view)) {
5317 				err = view_close_child(view);
5318 				if (err)
5319 					return err;
5320 				err = view_set_child(view, blame_view);
5321 				if (err) {
5322 					view_close(blame_view);
5323 					break;
5324 				}
5325 				*focus_view = blame_view;
5326 				view->child_focussed = 1;
5327 			} else
5328 				*new_view = blame_view;
5329 		}
5330 		break;
5331 	case KEY_RESIZE:
5332 		if (s->selected > view->nlines)
5333 			s->selected = s->ndisplayed - 1;
5334 		break;
5335 	default:
5336 		break;
5337 	}
5338 
5339 	return err;
5340 }
5341 
5342 __dead static void
5343 usage_tree(void)
5344 {
5345 	endwin();
5346 	fprintf(stderr, "usage: %s tree [-c commit] [-r repository-path] [path]\n",
5347 	    getprogname());
5348 	exit(1);
5349 }
5350 
5351 static const struct got_error *
5352 cmd_tree(int argc, char *argv[])
5353 {
5354 	const struct got_error *error;
5355 	struct got_repository *repo = NULL;
5356 	struct got_worktree *worktree = NULL;
5357 	struct got_reflist_head refs;
5358 	char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
5359 	struct got_object_id *commit_id = NULL;
5360 	char *commit_id_arg = NULL;
5361 	struct got_commit_object *commit = NULL;
5362 	struct got_tree_object *tree = NULL;
5363 	int ch;
5364 	struct tog_view *view;
5365 
5366 	SIMPLEQ_INIT(&refs);
5367 
5368 #ifndef PROFILE
5369 	if (pledge("stdio rpath wpath cpath flock proc tty exec sendfd unveil",
5370 	    NULL) == -1)
5371 		err(1, "pledge");
5372 #endif
5373 
5374 	while ((ch = getopt(argc, argv, "c:r:")) != -1) {
5375 		switch (ch) {
5376 		case 'c':
5377 			commit_id_arg = optarg;
5378 			break;
5379 		case 'r':
5380 			repo_path = realpath(optarg, NULL);
5381 			if (repo_path == NULL)
5382 				return got_error_from_errno2("realpath",
5383 				    optarg);
5384 			break;
5385 		default:
5386 			usage_tree();
5387 			/* NOTREACHED */
5388 		}
5389 	}
5390 
5391 	argc -= optind;
5392 	argv += optind;
5393 
5394 	if (argc > 1)
5395 		usage_tree();
5396 
5397 	cwd = getcwd(NULL, 0);
5398 	if (cwd == NULL)
5399 		return got_error_from_errno("getcwd");
5400 
5401 	error = got_worktree_open(&worktree, cwd);
5402 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
5403 		goto done;
5404 
5405 	if (repo_path == NULL) {
5406 		if (worktree)
5407 			repo_path =
5408 			    strdup(got_worktree_get_repo_path(worktree));
5409 		else
5410 			repo_path = strdup(cwd);
5411 	}
5412 	if (repo_path == NULL) {
5413 		error = got_error_from_errno("strdup");
5414 		goto done;
5415 	}
5416 
5417 	error = got_repo_open(&repo, repo_path, NULL);
5418 	if (error != NULL)
5419 		goto done;
5420 
5421 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
5422 	    repo, worktree);
5423 	if (error)
5424 		goto done;
5425 
5426 	init_curses();
5427 
5428 	error = apply_unveil(got_repo_get_path(repo), NULL);
5429 	if (error)
5430 		goto done;
5431 
5432 	error = got_repo_match_object_id(&commit_id, NULL,
5433 	    commit_id_arg ? commit_id_arg : GOT_REF_HEAD,
5434 	    GOT_OBJ_TYPE_COMMIT, 1, repo);
5435 	if (error)
5436 		goto done;
5437 
5438 	error = got_object_open_as_commit(&commit, repo, commit_id);
5439 	if (error)
5440 		goto done;
5441 
5442 	error = got_object_open_as_tree(&tree, repo,
5443 	    got_object_commit_get_tree_id(commit));
5444 	if (error)
5445 		goto done;
5446 
5447 	error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
5448 	if (error)
5449 		goto done;
5450 
5451 	view = view_open(0, 0, 0, 0, TOG_VIEW_TREE);
5452 	if (view == NULL) {
5453 		error = got_error_from_errno("view_open");
5454 		goto done;
5455 	}
5456 	error = open_tree_view(view, tree, commit_id, &refs, repo);
5457 	if (error)
5458 		goto done;
5459 	if (!got_path_is_root_dir(in_repo_path)) {
5460 		error = tree_view_walk_path(&view->state.tree, commit_id,
5461 		    in_repo_path, repo);
5462 		if (error)
5463 			goto done;
5464 	}
5465 
5466 	if (worktree) {
5467 		/* Release work tree lock. */
5468 		got_worktree_close(worktree);
5469 		worktree = NULL;
5470 	}
5471 	error = view_loop(view);
5472 done:
5473 	free(repo_path);
5474 	free(cwd);
5475 	free(commit_id);
5476 	if (commit)
5477 		got_object_commit_close(commit);
5478 	if (tree)
5479 		got_object_tree_close(tree);
5480 	if (repo)
5481 		got_repo_close(repo);
5482 	got_ref_list_free(&refs);
5483 	return error;
5484 }
5485 
5486 static void
5487 list_commands(FILE *fp)
5488 {
5489 	int i;
5490 
5491 	fprintf(fp, "commands:");
5492 	for (i = 0; i < nitems(tog_commands); i++) {
5493 		struct tog_cmd *cmd = &tog_commands[i];
5494 		fprintf(fp, " %s", cmd->name);
5495 	}
5496 	fputc('\n', fp);
5497 }
5498 
5499 __dead static void
5500 usage(int hflag, int status)
5501 {
5502 	FILE *fp = (status == 0) ? stdout : stderr;
5503 
5504 	fprintf(fp, "usage: %s [-h] [-V | --version] [command] [arg ...]\n",
5505 	    getprogname());
5506 	if (hflag) {
5507 		fprintf(fp, "lazy usage: %s path\n", getprogname());
5508 		list_commands(fp);
5509 	}
5510 	exit(status);
5511 }
5512 
5513 static char **
5514 make_argv(int argc, ...)
5515 {
5516 	va_list ap;
5517 	char **argv;
5518 	int i;
5519 
5520 	va_start(ap, argc);
5521 
5522 	argv = calloc(argc, sizeof(char *));
5523 	if (argv == NULL)
5524 		err(1, "calloc");
5525 	for (i = 0; i < argc; i++) {
5526 		argv[i] = strdup(va_arg(ap, char *));
5527 		if (argv[i] == NULL)
5528 			err(1, "strdup");
5529 	}
5530 
5531 	va_end(ap);
5532 	return argv;
5533 }
5534 
5535 /*
5536  * Try to convert 'tog path' into a 'tog log path' command.
5537  * The user could simply have mistyped the command rather than knowingly
5538  * provided a path. So check whether argv[0] can in fact be resolved
5539  * to a path in the HEAD commit and print a special error if not.
5540  * This hack is for mpi@ <3
5541  */
5542 static const struct got_error *
5543 tog_log_with_path(int argc, char *argv[])
5544 {
5545 	const struct got_error *error = NULL;
5546 	struct tog_cmd *cmd = NULL;
5547 	struct got_repository *repo = NULL;
5548 	struct got_worktree *worktree = NULL;
5549 	struct got_object_id *commit_id = NULL, *id = NULL;
5550 	char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
5551 	char *commit_id_str = NULL, **cmd_argv = NULL;
5552 
5553 	cwd = getcwd(NULL, 0);
5554 	if (cwd == NULL)
5555 		return got_error_from_errno("getcwd");
5556 
5557 	error = got_worktree_open(&worktree, cwd);
5558 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
5559 		goto done;
5560 
5561 	if (worktree)
5562 		repo_path = strdup(got_worktree_get_repo_path(worktree));
5563 	else
5564 		repo_path = strdup(cwd);
5565 	if (repo_path == NULL) {
5566 		error = got_error_from_errno("strdup");
5567 		goto done;
5568 	}
5569 
5570 	error = got_repo_open(&repo, repo_path, NULL);
5571 	if (error != NULL)
5572 		goto done;
5573 
5574 	error = get_in_repo_path_from_argv0(&in_repo_path, argc, argv,
5575 	    repo, worktree);
5576 	if (error)
5577 		goto done;
5578 
5579 	error = got_repo_match_object_id(&commit_id, NULL, worktree ?
5580 	    got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD,
5581 	    GOT_OBJ_TYPE_COMMIT, 1, repo);
5582 	if (error)
5583 		goto done;
5584 
5585 	if (worktree) {
5586 		got_worktree_close(worktree);
5587 		worktree = NULL;
5588 	}
5589 
5590 	error = got_object_id_by_path(&id, repo, commit_id, in_repo_path);
5591 	if (error) {
5592 		if (error->code != GOT_ERR_NO_TREE_ENTRY)
5593 			goto done;
5594 		fprintf(stderr, "%s: '%s' is no known command or path\n",
5595 		    getprogname(), argv[0]);
5596 		usage(1, 1);
5597 		/* not reached */
5598 	}
5599 
5600 	got_repo_close(repo);
5601 	repo = NULL;
5602 
5603 	error = got_object_id_str(&commit_id_str, commit_id);
5604 	if (error)
5605 		goto done;
5606 
5607 	cmd = &tog_commands[0]; /* log */
5608 	argc = 4;
5609 	cmd_argv = make_argv(argc, cmd->name, "-c", commit_id_str, argv[0]);
5610 	error = cmd->cmd_main(argc, cmd_argv);
5611 done:
5612 	if (repo)
5613 		got_repo_close(repo);
5614 	if (worktree)
5615 		got_worktree_close(worktree);
5616 	free(id);
5617 	free(commit_id_str);
5618 	free(commit_id);
5619 	free(cwd);
5620 	free(repo_path);
5621 	free(in_repo_path);
5622 	if (cmd_argv) {
5623 		int i;
5624 		for (i = 0; i < argc; i++)
5625 			free(cmd_argv[i]);
5626 		free(cmd_argv);
5627 	}
5628 	return error;
5629 }
5630 
5631 int
5632 main(int argc, char *argv[])
5633 {
5634 	const struct got_error *error = NULL;
5635 	struct tog_cmd *cmd = NULL;
5636 	int ch, hflag = 0, Vflag = 0;
5637 	char **cmd_argv = NULL;
5638 	static struct option longopts[] = {
5639 	    { "version", no_argument, NULL, 'V' },
5640 	    { NULL, 0, NULL, 0}
5641 	};
5642 
5643 	setlocale(LC_CTYPE, "");
5644 
5645 	while ((ch = getopt_long(argc, argv, "+hV", longopts, NULL)) != -1) {
5646 		switch (ch) {
5647 		case 'h':
5648 			hflag = 1;
5649 			break;
5650 		case 'V':
5651 			Vflag = 1;
5652 			break;
5653 		default:
5654 			usage(hflag, 1);
5655 			/* NOTREACHED */
5656 		}
5657 	}
5658 
5659 	argc -= optind;
5660 	argv += optind;
5661 	optind = 1;
5662 	optreset = 1;
5663 
5664 	if (Vflag) {
5665 		got_version_print_str();
5666 		return 0;
5667 	}
5668 
5669 	if (argc == 0) {
5670 		if (hflag)
5671 			usage(hflag, 0);
5672 		/* Build an argument vector which runs a default command. */
5673 		cmd = &tog_commands[0];
5674 		argc = 1;
5675 		cmd_argv = make_argv(argc, cmd->name);
5676 	} else {
5677 		int i;
5678 
5679 		/* Did the user specify a command? */
5680 		for (i = 0; i < nitems(tog_commands); i++) {
5681 			if (strncmp(tog_commands[i].name, argv[0],
5682 			    strlen(argv[0])) == 0) {
5683 				cmd = &tog_commands[i];
5684 				break;
5685 			}
5686 		}
5687 	}
5688 
5689 	if (cmd == NULL) {
5690 		if (argc != 1)
5691 			usage(0, 1);
5692 		/* No command specified; try log with a path */
5693 		error = tog_log_with_path(argc, argv);
5694 	} else {
5695 		if (hflag)
5696 			cmd->cmd_usage();
5697 		else
5698 			error = cmd->cmd_main(argc, cmd_argv ? cmd_argv : argv);
5699 	}
5700 
5701 	endwin();
5702 	putchar('\n');
5703 	if (cmd_argv) {
5704 		int i;
5705 		for (i = 0; i < argc; i++)
5706 			free(cmd_argv[i]);
5707 		free(cmd_argv);
5708 	}
5709 
5710 	if (error && error->code != GOT_ERR_CANCELLED)
5711 		fprintf(stderr, "%s: %s\n", getprogname(), error->msg);
5712 	return 0;
5713 }