1 /*
2  * Copyright (c) 2017 Martin Pieuchot <mpi@openbsd.org>
3  * Copyright (c) 2018, 2019 Stefan Sperling <stsp@openbsd.org>
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #include <sys/queue.h>
19 #include <sys/limits.h>
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 
23 #include <err.h>
24 #include <errno.h>
25 #include <locale.h>
26 #include <signal.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <unistd.h>
31 #include <libgen.h>
32 #include <time.h>
33 
34 #include "got_error.h"
35 #include "got_object.h"
36 #include "got_reference.h"
37 #include "got_repository.h"
38 #include "got_worktree.h"
39 #include "got_diff.h"
40 #include "got_commit_graph.h"
41 #include "got_blame.h"
42 #include "got_privsep.h"
43 
44 #ifndef nitems
45 #define nitems(_a)	(sizeof((_a)) / sizeof((_a)[0]))
46 #endif
47 
48 static volatile sig_atomic_t sigint_received;
49 static volatile sig_atomic_t sigpipe_received;
50 
51 static void
52 catch_sigint(int signo)
53 {
54 	sigint_received = 1;
55 }
56 
57 static void
58 catch_sigpipe(int signo)
59 {
60 	sigpipe_received = 1;
61 }
62 
63 
64 struct cmd {
65 	const char	 *cmd_name;
66 	const struct got_error *(*cmd_main)(int, char *[]);
67 	void		(*cmd_usage)(void);
68 	const char	 *cmd_descr;
69 };
70 
71 __dead static void	usage(void);
72 __dead static void	usage_checkout(void);
73 __dead static void	usage_update(void);
74 __dead static void	usage_log(void);
75 __dead static void	usage_diff(void);
76 __dead static void	usage_blame(void);
77 __dead static void	usage_tree(void);
78 __dead static void	usage_status(void);
79 __dead static void	usage_ref(void);
80 
81 static const struct got_error*		cmd_checkout(int, char *[]);
82 static const struct got_error*		cmd_update(int, char *[]);
83 static const struct got_error*		cmd_log(int, char *[]);
84 static const struct got_error*		cmd_diff(int, char *[]);
85 static const struct got_error*		cmd_blame(int, char *[]);
86 static const struct got_error*		cmd_tree(int, char *[]);
87 static const struct got_error*		cmd_status(int, char *[]);
88 static const struct got_error*		cmd_ref(int, char *[]);
89 
90 static struct cmd got_commands[] = {
91 	{ "checkout",	cmd_checkout,	usage_checkout,
92 	    "check out a new work tree from a repository" },
93 	{ "update",	cmd_update,	usage_update,
94 	    "update a work tree to a different commit" },
95 	{ "log",	cmd_log,	usage_log,
96 	    "show repository history" },
97 	{ "diff",	cmd_diff,	usage_diff,
98 	    "compare files and directories" },
99 	{ "blame",	cmd_blame,	usage_blame,
100 	    " show when lines in a file were changed" },
101 	{ "tree",	cmd_tree,	usage_tree,
102 	    " list files and directories in repository" },
103 	{ "status",	cmd_status,	usage_status,
104 	    "show modification status of files" },
105 	{ "ref",	cmd_ref,	usage_ref,
106 	    "manage references in repository" },
107 };
108 
109 int
110 main(int argc, char *argv[])
111 {
112 	struct cmd *cmd;
113 	unsigned int i;
114 	int ch;
115 	int hflag = 0;
116 
117 	setlocale(LC_CTYPE, "");
118 
119 	while ((ch = getopt(argc, argv, "h")) != -1) {
120 		switch (ch) {
121 		case 'h':
122 			hflag = 1;
123 			break;
124 		default:
125 			usage();
126 			/* NOTREACHED */
127 		}
128 	}
129 
130 	argc -= optind;
131 	argv += optind;
132 	optind = 0;
133 
134 	if (argc <= 0)
135 		usage();
136 
137 	signal(SIGINT, catch_sigint);
138 	signal(SIGPIPE, catch_sigpipe);
139 
140 	for (i = 0; i < nitems(got_commands); i++) {
141 		const struct got_error *error;
142 
143 		cmd = &got_commands[i];
144 
145 		if (strncmp(cmd->cmd_name, argv[0], strlen(argv[0])))
146 			continue;
147 
148 		if (hflag)
149 			got_commands[i].cmd_usage();
150 
151 		error = got_commands[i].cmd_main(argc, argv);
152 		if (error && !(sigint_received || sigpipe_received)) {
153 			fprintf(stderr, "%s: %s\n", getprogname(), error->msg);
154 			return 1;
155 		}
156 
157 		return 0;
158 	}
159 
160 	fprintf(stderr, "%s: unknown command '%s'\n", getprogname(), argv[0]);
161 	return 1;
162 }
163 
164 __dead static void
165 usage(void)
166 {
167 	int i;
168 
169 	fprintf(stderr, "usage: %s [-h] command [arg ...]\n\n"
170 	    "Available commands:\n", getprogname());
171 	for (i = 0; i < nitems(got_commands); i++) {
172 		struct cmd *cmd = &got_commands[i];
173 		fprintf(stderr, "    %s: %s\n", cmd->cmd_name, cmd->cmd_descr);
174 	}
175 	exit(1);
176 }
177 
178 static const struct got_error *
179 apply_unveil(const char *repo_path, int repo_read_only,
180     const char *worktree_path)
181 {
182 	const struct got_error *error;
183 
184 	if (repo_path && unveil(repo_path, repo_read_only ? "r" : "rwc") != 0)
185 		return got_error_from_errno();
186 
187 	if (worktree_path && unveil(worktree_path, "rwc") != 0)
188 		return got_error_from_errno();
189 
190 	if (unveil("/tmp", "rwc") != 0)
191 		return got_error_from_errno();
192 
193 	error = got_privsep_unveil_exec_helpers();
194 	if (error != NULL)
195 		return error;
196 
197 	if (unveil(NULL, NULL) != 0)
198 		return got_error_from_errno();
199 
200 	return NULL;
201 }
202 
203 __dead static void
204 usage_checkout(void)
205 {
206 	fprintf(stderr, "usage: %s checkout [-p prefix] repository-path "
207 	    "[worktree-path]\n", getprogname());
208 	exit(1);
209 }
210 
211 static void
212 checkout_progress(void *arg, unsigned char status, const char *path)
213 {
214 	char *worktree_path = arg;
215 
216 	while (path[0] == '/')
217 		path++;
218 
219 	printf("%c  %s/%s\n", status, worktree_path, path);
220 }
221 
222 static const struct got_error *
223 check_cancelled(void *arg)
224 {
225 	if (sigint_received || sigpipe_received)
226 		return got_error(GOT_ERR_CANCELLED);
227 	return NULL;
228 }
229 
230 static const struct got_error *
231 check_ancestry(struct got_worktree *worktree, struct got_object_id *commit_id,
232     struct got_repository *repo)
233 {
234 	const struct got_error *err;
235 	struct got_reference *head_ref = NULL;
236 	struct got_object_id *head_commit_id = NULL;
237 	struct got_commit_graph *graph = NULL;
238 
239 	head_ref = got_worktree_get_head_ref(worktree);
240 	if (head_ref == NULL)
241 		return got_error_from_errno();
242 
243 	/* TODO: Check the reflog. The head ref may have been rebased. */
244 	err = got_ref_resolve(&head_commit_id, repo, head_ref);
245 	if (err)
246 		goto done;
247 
248 	err = got_commit_graph_open(&graph, head_commit_id, "/", 1, repo);
249 	if (err)
250 		goto done;
251 
252 	err = got_commit_graph_iter_start(graph, head_commit_id, repo);
253 	if (err)
254 		goto done;
255 	while (1) {
256 		struct got_object_id *id;
257 
258 		if (sigint_received || sigpipe_received)
259 			break;
260 
261 		err = got_commit_graph_iter_next(&id, graph);
262 		if (err) {
263 			if (err->code == GOT_ERR_ITER_COMPLETED) {
264 				err = got_error(GOT_ERR_ANCESTRY);
265 				break;
266 			}
267 			if (err->code != GOT_ERR_ITER_NEED_MORE)
268 				break;
269 			err = got_commit_graph_fetch_commits(graph, 1, repo);
270 			if (err)
271 				break;
272 			else
273 				continue;
274 		}
275 		if (id == NULL)
276 			break;
277 		if (got_object_id_cmp(id, commit_id) == 0)
278 			break;
279 	}
280 done:
281 	if (head_ref)
282 		got_ref_close(head_ref);
283 	if (graph)
284 		got_commit_graph_close(graph);
285 	return err;
286 }
287 
288 
289 static const struct got_error *
290 cmd_checkout(int argc, char *argv[])
291 {
292 	const struct got_error *error = NULL;
293 	struct got_repository *repo = NULL;
294 	struct got_reference *head_ref = NULL;
295 	struct got_worktree *worktree = NULL;
296 	char *repo_path = NULL;
297 	char *worktree_path = NULL;
298 	const char *path_prefix = "";
299 	char *commit_id_str = NULL;
300 	int ch, same_path_prefix;
301 
302 	while ((ch = getopt(argc, argv, "c:p:")) != -1) {
303 		switch (ch) {
304 		case 'c':
305 			commit_id_str = strdup(optarg);
306 			if (commit_id_str == NULL)
307 				return got_error_from_errno();
308 			break;
309 		case 'p':
310 			path_prefix = optarg;
311 			break;
312 		default:
313 			usage_checkout();
314 			/* NOTREACHED */
315 		}
316 	}
317 
318 	argc -= optind;
319 	argv += optind;
320 
321 #ifndef PROFILE
322 	if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
323 	    "unveil", NULL) == -1)
324 		err(1, "pledge");
325 #endif
326 	if (argc == 1) {
327 		char *cwd, *base, *dotgit;
328 		repo_path = realpath(argv[0], NULL);
329 		if (repo_path == NULL)
330 			return got_error_from_errno();
331 		cwd = getcwd(NULL, 0);
332 		if (cwd == NULL) {
333 			error = got_error_from_errno();
334 			goto done;
335 		}
336 		if (path_prefix[0])
337 			base = basename(path_prefix);
338 		else
339 			base = basename(repo_path);
340 		if (base == NULL) {
341 			error = got_error_from_errno();
342 			goto done;
343 		}
344 		dotgit = strstr(base, ".git");
345 		if (dotgit)
346 			*dotgit = '\0';
347 		if (asprintf(&worktree_path, "%s/%s", cwd, base) == -1) {
348 			error = got_error_from_errno();
349 			free(cwd);
350 			goto done;
351 		}
352 		free(cwd);
353 	} else if (argc == 2) {
354 		repo_path = realpath(argv[0], NULL);
355 		if (repo_path == NULL) {
356 			error = got_error_from_errno();
357 			goto done;
358 		}
359 		worktree_path = realpath(argv[1], NULL);
360 		if (worktree_path == NULL) {
361 			error = got_error_from_errno();
362 			goto done;
363 		}
364 	} else
365 		usage_checkout();
366 
367 	error = apply_unveil(repo_path, 1, worktree_path);
368 	if (error)
369 		goto done;
370 
371 	error = got_repo_open(&repo, repo_path);
372 	if (error != NULL)
373 		goto done;
374 
375 	error = got_ref_open(&head_ref, repo, GOT_REF_HEAD);
376 	if (error != NULL)
377 		goto done;
378 
379 	error = got_worktree_init(worktree_path, head_ref, path_prefix, repo);
380 	if (error != NULL && !(error->code == GOT_ERR_ERRNO && errno == EEXIST))
381 		goto done;
382 
383 	error = got_worktree_open(&worktree, worktree_path);
384 	if (error != NULL)
385 		goto done;
386 
387 	error = got_worktree_match_path_prefix(&same_path_prefix, worktree,
388 	    path_prefix);
389 	if (error != NULL)
390 		goto done;
391 	if (!same_path_prefix) {
392 		error = got_error(GOT_ERR_PATH_PREFIX);
393 		goto done;
394 	}
395 
396 	if (commit_id_str) {
397 		struct got_object_id *commit_id;
398 		error = got_object_resolve_id_str(&commit_id, repo,
399 		    commit_id_str);
400 		if (error != NULL)
401 			goto done;
402 		error = check_ancestry(worktree, commit_id, repo);
403 		if (error != NULL) {
404 			free(commit_id);
405 			goto done;
406 		}
407 		error = got_worktree_set_base_commit_id(worktree, repo,
408 		    commit_id);
409 		free(commit_id);
410 		if (error)
411 			goto done;
412 	}
413 
414 	error = got_worktree_checkout_files(worktree, repo,
415 	    checkout_progress, worktree_path, check_cancelled, NULL);
416 	if (error != NULL)
417 		goto done;
418 
419 	printf("Now shut up and hack\n");
420 
421 done:
422 	free(commit_id_str);
423 	free(repo_path);
424 	free(worktree_path);
425 	return error;
426 }
427 
428 __dead static void
429 usage_update(void)
430 {
431 	fprintf(stderr, "usage: %s update [-c commit] [worktree-path]\n",
432 	    getprogname());
433 	exit(1);
434 }
435 
436 static void
437 update_progress(void *arg, unsigned char status, const char *path)
438 {
439 	int *did_something = arg;
440 
441 	if (status == GOT_STATUS_EXISTS)
442 		return;
443 
444 	*did_something = 1;
445 	while (path[0] == '/')
446 		path++;
447 	printf("%c  %s\n", status, path);
448 }
449 
450 static const struct got_error *
451 cmd_update(int argc, char *argv[])
452 {
453 	const struct got_error *error = NULL;
454 	struct got_repository *repo = NULL;
455 	struct got_worktree *worktree = NULL;
456 	char *worktree_path = NULL;
457 	struct got_object_id *commit_id = NULL;
458 	char *commit_id_str = NULL;
459 	int ch, did_something = 0;
460 
461 	while ((ch = getopt(argc, argv, "c:")) != -1) {
462 		switch (ch) {
463 		case 'c':
464 			commit_id_str = strdup(optarg);
465 			if (commit_id_str == NULL)
466 				return got_error_from_errno();
467 			break;
468 		default:
469 			usage_update();
470 			/* NOTREACHED */
471 		}
472 	}
473 
474 	argc -= optind;
475 	argv += optind;
476 
477 #ifndef PROFILE
478 	if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
479 	    "unveil", NULL) == -1)
480 		err(1, "pledge");
481 #endif
482 	if (argc == 0) {
483 		worktree_path = getcwd(NULL, 0);
484 		if (worktree_path == NULL) {
485 			error = got_error_from_errno();
486 			goto done;
487 		}
488 	} else if (argc == 1) {
489 		worktree_path = realpath(argv[0], NULL);
490 		if (worktree_path == NULL) {
491 			error = got_error_from_errno();
492 			goto done;
493 		}
494 	} else
495 		usage_update();
496 
497 	error = got_worktree_open(&worktree, worktree_path);
498 	if (error != NULL)
499 		goto done;
500 
501 	error = got_repo_open(&repo, got_worktree_get_repo_path(worktree));
502 	if (error != NULL)
503 		goto done;
504 
505 	error = apply_unveil(got_repo_get_path(repo), 1,
506 	    got_worktree_get_root_path(worktree));
507 	if (error)
508 		goto done;
509 
510 	if (commit_id_str == NULL) {
511 		struct got_reference *head_ref;
512 		error = got_ref_open(&head_ref, repo, GOT_REF_HEAD);
513 		if (error != NULL)
514 			goto done;
515 		error = got_ref_resolve(&commit_id, repo, head_ref);
516 		if (error != NULL)
517 			goto done;
518 		error = got_object_id_str(&commit_id_str, commit_id);
519 		if (error != NULL)
520 			goto done;
521 	} else {
522 		error = got_object_resolve_id_str(&commit_id, repo,
523 		    commit_id_str);
524 		if (error != NULL)
525 			goto done;
526 	}
527 
528 	error = check_ancestry(worktree, commit_id, repo);
529 	if (error != NULL)
530 		goto done;
531 
532 	if (got_object_id_cmp(got_worktree_get_base_commit_id(worktree),
533 	    commit_id) != 0) {
534 		error = got_worktree_set_base_commit_id(worktree, repo,
535 		    commit_id);
536 		if (error)
537 			goto done;
538 	}
539 
540 	error = got_worktree_checkout_files(worktree, repo,
541 	    update_progress, &did_something, check_cancelled, NULL);
542 	if (error != NULL)
543 		goto done;
544 
545 	if (did_something)
546 		printf("Updated to commit %s\n", commit_id_str);
547 	else
548 		printf("Already up-to-date\n");
549 done:
550 	free(worktree_path);
551 	free(commit_id);
552 	free(commit_id_str);
553 	return error;
554 }
555 
556 static const struct got_error *
557 print_patch(struct got_commit_object *commit, struct got_object_id *id,
558     int diff_context, struct got_repository *repo)
559 {
560 	const struct got_error *err = NULL;
561 	struct got_tree_object *tree1 = NULL, *tree2;
562 	struct got_object_qid *qid;
563 	char *id_str1 = NULL, *id_str2;
564 
565 	err = got_object_open_as_tree(&tree2, repo,
566 	    got_object_commit_get_tree_id(commit));
567 	if (err)
568 		return err;
569 
570 	qid = SIMPLEQ_FIRST(got_object_commit_get_parent_ids(commit));
571 	if (qid != NULL) {
572 		struct got_commit_object *pcommit;
573 
574 		err = got_object_open_as_commit(&pcommit, repo, qid->id);
575 		if (err)
576 			return err;
577 
578 		err = got_object_open_as_tree(&tree1, repo,
579 		    got_object_commit_get_tree_id(pcommit));
580 		got_object_commit_close(pcommit);
581 		if (err)
582 			return err;
583 
584 		err = got_object_id_str(&id_str1, qid->id);
585 		if (err)
586 			return err;
587 	}
588 
589 	err = got_object_id_str(&id_str2, id);
590 	if (err)
591 		goto done;
592 
593 	printf("diff %s %s\n", id_str1 ? id_str1 : "/dev/null", id_str2);
594 	err = got_diff_tree(tree1, tree2, "", "", diff_context, repo, stdout);
595 done:
596 	if (tree1)
597 		got_object_tree_close(tree1);
598 	got_object_tree_close(tree2);
599 	free(id_str1);
600 	free(id_str2);
601 	return err;
602 }
603 
604 static char *
605 get_datestr(time_t *time, char *datebuf)
606 {
607 	char *p, *s = ctime_r(time, datebuf);
608 	p = strchr(s, '\n');
609 	if (p)
610 		*p = '\0';
611 	return s;
612 }
613 
614 static const struct got_error *
615 print_commit(struct got_commit_object *commit, struct got_object_id *id,
616     struct got_repository *repo, int show_patch, int diff_context,
617     struct got_reflist_head *refs)
618 {
619 	const struct got_error *err = NULL;
620 	char *id_str, *datestr, *logmsg0, *logmsg, *line;
621 	char datebuf[26];
622 	time_t committer_time;
623 	const char *author, *committer;
624 	char *refs_str = NULL;
625 	struct got_reflist_entry *re;
626 
627 	SIMPLEQ_FOREACH(re, refs, entry) {
628 		char *s;
629 		const char *name;
630 		if (got_object_id_cmp(re->id, id) != 0)
631 			continue;
632 		name = got_ref_get_name(re->ref);
633 		if (strcmp(name, GOT_REF_HEAD) == 0)
634 			continue;
635 		if (strncmp(name, "refs/", 5) == 0)
636 			name += 5;
637 		if (strncmp(name, "heads/", 6) == 0)
638 			name += 6;
639 		if (strncmp(name, "remotes/", 8) == 0)
640 			name += 8;
641 		s = refs_str;
642 		if (asprintf(&refs_str, "%s%s%s", s ? s : "", s ? ", " : "",
643 		    name) == -1) {
644 			err = got_error_from_errno();
645 			free(s);
646 			break;
647 		}
648 		free(s);
649 	}
650 	err = got_object_id_str(&id_str, id);
651 	if (err)
652 		return err;
653 
654 	printf("-----------------------------------------------\n");
655 	printf("commit %s%s%s%s\n", id_str, refs_str ? " (" : "",
656 	    refs_str ? refs_str : "", refs_str ? ")" : "");
657 	free(id_str);
658 	id_str = NULL;
659 	free(refs_str);
660 	refs_str = NULL;
661 	printf("from: %s\n", got_object_commit_get_author(commit));
662 	committer_time = got_object_commit_get_committer_time(commit);
663 	datestr = get_datestr(&committer_time, datebuf);
664 	printf("date: %s UTC\n", datestr);
665 	author = got_object_commit_get_author(commit);
666 	committer = got_object_commit_get_committer(commit);
667 	if (strcmp(author, committer) != 0)
668 		printf("via: %s\n", committer);
669 	if (got_object_commit_get_nparents(commit) > 1) {
670 		const struct got_object_id_queue *parent_ids;
671 		struct got_object_qid *qid;
672 		int n = 1;
673 		parent_ids = got_object_commit_get_parent_ids(commit);
674 		SIMPLEQ_FOREACH(qid, parent_ids, entry) {
675 			err = got_object_id_str(&id_str, qid->id);
676 			if (err)
677 				return err;
678 			printf("parent %d: %s\n", n++, id_str);
679 			free(id_str);
680 		}
681 	}
682 
683 	logmsg0 = strdup(got_object_commit_get_logmsg(commit));
684 	if (logmsg0 == NULL)
685 		return got_error_from_errno();
686 
687 	logmsg = logmsg0;
688 	do {
689 		line = strsep(&logmsg, "\n");
690 		if (line)
691 			printf(" %s\n", line);
692 	} while (line);
693 	free(logmsg0);
694 
695 	if (show_patch) {
696 		err = print_patch(commit, id, diff_context, repo);
697 		if (err == 0)
698 			printf("\n");
699 	}
700 
701 	if (fflush(stdout) != 0 && err == NULL)
702 		err = got_error_from_errno();
703 	return err;
704 }
705 
706 static const struct got_error *
707 print_commits(struct got_object_id *root_id, struct got_repository *repo,
708     char *path, int show_patch, int diff_context, int limit,
709     int first_parent_traversal, struct got_reflist_head *refs)
710 {
711 	const struct got_error *err;
712 	struct got_commit_graph *graph;
713 
714 	err = got_commit_graph_open(&graph, root_id, path,
715 	    first_parent_traversal, repo);
716 	if (err)
717 		return err;
718 	err = got_commit_graph_iter_start(graph, root_id, repo);
719 	if (err)
720 		goto done;
721 	while (1) {
722 		struct got_commit_object *commit;
723 		struct got_object_id *id;
724 
725 		if (sigint_received || sigpipe_received)
726 			break;
727 
728 		err = got_commit_graph_iter_next(&id, graph);
729 		if (err) {
730 			if (err->code == GOT_ERR_ITER_COMPLETED) {
731 				err = NULL;
732 				break;
733 			}
734 			if (err->code != GOT_ERR_ITER_NEED_MORE)
735 				break;
736 			err = got_commit_graph_fetch_commits(graph, 1, repo);
737 			if (err)
738 				break;
739 			else
740 				continue;
741 		}
742 		if (id == NULL)
743 			break;
744 
745 		err = got_object_open_as_commit(&commit, repo, id);
746 		if (err)
747 			break;
748 		err = print_commit(commit, id, repo, show_patch, diff_context,
749 		    refs);
750 		got_object_commit_close(commit);
751 		if (err || (limit && --limit == 0))
752 			break;
753 	}
754 done:
755 	got_commit_graph_close(graph);
756 	return err;
757 }
758 
759 __dead static void
760 usage_log(void)
761 {
762 	fprintf(stderr, "usage: %s log [-c commit] [-C number] [-f] [ -l N ] [-p] "
763 	    "[-r repository-path] [path]\n", getprogname());
764 	exit(1);
765 }
766 
767 static const struct got_error *
768 cmd_log(int argc, char *argv[])
769 {
770 	const struct got_error *error;
771 	struct got_repository *repo = NULL;
772 	struct got_worktree *worktree = NULL;
773 	struct got_commit_object *commit = NULL;
774 	struct got_object_id *id = NULL;
775 	char *repo_path = NULL, *path = NULL, *cwd = NULL, *in_repo_path = NULL;
776 	char *start_commit = NULL;
777 	int diff_context = 3, ch;
778 	int show_patch = 0, limit = 0, first_parent_traversal = 0;
779 	const char *errstr;
780 	struct got_reflist_head refs;
781 
782 #ifndef PROFILE
783 	if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
784 	    NULL)
785 	    == -1)
786 		err(1, "pledge");
787 #endif
788 
789 	while ((ch = getopt(argc, argv, "pc:C:l:fr:")) != -1) {
790 		switch (ch) {
791 		case 'p':
792 			show_patch = 1;
793 			break;
794 		case 'c':
795 			start_commit = optarg;
796 			break;
797 		case 'C':
798 			diff_context = strtonum(optarg, 0, GOT_DIFF_MAX_CONTEXT,
799 			    &errstr);
800 			if (errstr != NULL)
801 				err(1, "-C option %s", errstr);
802 			break;
803 		case 'l':
804 			limit = strtonum(optarg, 1, INT_MAX, &errstr);
805 			if (errstr != NULL)
806 				err(1, "-l option %s", errstr);
807 			break;
808 		case 'f':
809 			first_parent_traversal = 1;
810 			break;
811 		case 'r':
812 			repo_path = realpath(optarg, NULL);
813 			if (repo_path == NULL)
814 				err(1, "-r option");
815 			break;
816 		default:
817 			usage_log();
818 			/* NOTREACHED */
819 		}
820 	}
821 
822 	argc -= optind;
823 	argv += optind;
824 
825 	if (argc == 0)
826 		path = strdup("");
827 	else if (argc == 1)
828 		path = strdup(argv[0]);
829 	else
830 		usage_log();
831 	if (path == NULL)
832 		return got_error_from_errno();
833 
834 	cwd = getcwd(NULL, 0);
835 	if (cwd == NULL) {
836 		error = got_error_from_errno();
837 		goto done;
838 	}
839 
840 	error = got_worktree_open(&worktree, cwd);
841 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
842 		goto done;
843 	error = NULL;
844 
845 	repo_path = worktree ?
846 	    strdup(got_worktree_get_repo_path(worktree)) : strdup(cwd);
847 	if (repo_path == NULL) {
848 		error = got_error_from_errno();
849 		goto done;
850 	}
851 
852 	error = apply_unveil(repo_path, 1,
853 	    worktree ? got_worktree_get_root_path(worktree) : NULL);
854 	if (error)
855 		goto done;
856 
857 	error = got_repo_open(&repo, repo_path);
858 	if (error != NULL)
859 		goto done;
860 
861 	if (start_commit == NULL) {
862 		struct got_reference *head_ref;
863 		error = got_ref_open(&head_ref, repo, GOT_REF_HEAD);
864 		if (error != NULL)
865 			return error;
866 		error = got_ref_resolve(&id, repo, head_ref);
867 		got_ref_close(head_ref);
868 		if (error != NULL)
869 			return error;
870 		error = got_object_open_as_commit(&commit, repo, id);
871 	} else {
872 		struct got_reference *ref;
873 		error = got_ref_open(&ref, repo, start_commit);
874 		if (error == NULL) {
875 			int obj_type;
876 			error = got_ref_resolve(&id, repo, ref);
877 			got_ref_close(ref);
878 			if (error != NULL)
879 				goto done;
880 			error = got_object_get_type(&obj_type, repo, id);
881 			if (error != NULL)
882 				goto done;
883 			if (obj_type == GOT_OBJ_TYPE_TAG) {
884 				struct got_tag_object *tag;
885 				error = got_object_open_as_tag(&tag, repo, id);
886 				if (error != NULL)
887 					goto done;
888 				if (got_object_tag_get_object_type(tag) !=
889 				    GOT_OBJ_TYPE_COMMIT) {
890 					got_object_tag_close(tag);
891 					error = got_error(GOT_ERR_OBJ_TYPE);
892 					goto done;
893 				}
894 				free(id);
895 				id = got_object_id_dup(
896 				    got_object_tag_get_object_id(tag));
897 				if (id == NULL)
898 					error = got_error_from_errno();
899 				got_object_tag_close(tag);
900 				if (error)
901 					goto done;
902 			} else if (obj_type != GOT_OBJ_TYPE_COMMIT) {
903 				error = got_error(GOT_ERR_OBJ_TYPE);
904 				goto done;
905 			}
906 			error = got_object_open_as_commit(&commit, repo, id);
907 			if (error != NULL)
908 				goto done;
909 		}
910 		if (commit == NULL) {
911 			error = got_object_resolve_id_str(&id, repo,
912 			    start_commit);
913 			if (error != NULL)
914 				return error;
915 		}
916 	}
917 	if (error != NULL)
918 		goto done;
919 
920 	error = got_repo_map_path(&in_repo_path, repo, path, 1);
921 	if (error != NULL)
922 		goto done;
923 	if (in_repo_path) {
924 		free(path);
925 		path = in_repo_path;
926 	}
927 
928 	SIMPLEQ_INIT(&refs);
929 	error = got_ref_list(&refs, repo);
930 	if (error)
931 		goto done;
932 
933 	error = print_commits(id, repo, path, show_patch,
934 	    diff_context, limit, first_parent_traversal, &refs);
935 done:
936 	free(path);
937 	free(repo_path);
938 	free(cwd);
939 	free(id);
940 	if (worktree)
941 		got_worktree_close(worktree);
942 	if (repo) {
943 		const struct got_error *repo_error;
944 		repo_error = got_repo_close(repo);
945 		if (error == NULL)
946 			error = repo_error;
947 	}
948 	return error;
949 }
950 
951 __dead static void
952 usage_diff(void)
953 {
954 	fprintf(stderr, "usage: %s diff [-C number] [-r repository-path] "
955 	    "[object1 object2 | path]\n", getprogname());
956 	exit(1);
957 }
958 
959 struct print_diff_arg {
960 	struct got_repository *repo;
961 	struct got_worktree *worktree;
962 	int diff_context;
963 	const char *id_str;
964 	int header_shown;
965 };
966 
967 static const struct got_error *
968 print_diff(void *arg, unsigned char status, const char *path,
969     struct got_object_id *id)
970 {
971 	struct print_diff_arg *a = arg;
972 	const struct got_error *err = NULL;
973 	struct got_blob_object *blob1 = NULL;
974 	FILE *f2 = NULL;
975 	char *abspath = NULL;
976 	struct stat sb;
977 
978 	if (status != GOT_STATUS_MODIFY)
979 		return NULL;
980 
981 	if (!a->header_shown) {
982 		printf("diff %s %s\n", a->id_str,
983 		    got_worktree_get_root_path(a->worktree));
984 		a->header_shown = 1;
985 	}
986 
987 	err = got_object_open_as_blob(&blob1, a->repo, id, 8192);
988 	if (err)
989 		goto done;
990 
991 	if (asprintf(&abspath, "%s/%s",
992 	    got_worktree_get_root_path(a->worktree), path) == -1) {
993 		err = got_error_from_errno();
994 		goto done;
995 	}
996 
997 	f2 = fopen(abspath, "r");
998 	if (f2 == NULL) {
999 		err = got_error_from_errno();
1000 		goto done;
1001 	}
1002 	if (lstat(abspath, &sb) == -1) {
1003 		err = got_error_from_errno();
1004 		goto done;
1005 	}
1006 
1007 	err = got_diff_blob_file(blob1, f2, sb.st_size, path, a->diff_context,
1008 	    stdout);
1009 done:
1010 	if (blob1)
1011 		got_object_blob_close(blob1);
1012 	if (f2 && fclose(f2) != 0 && err == NULL)
1013 		err = got_error_from_errno();
1014 	free(abspath);
1015 	return err;
1016 }
1017 
1018 static const struct got_error *
1019 get_status_path(char **status_path, struct got_worktree *worktree,
1020     const char *arg)
1021 {
1022 	const struct got_error *err = NULL;
1023 	char *resolved, *path = NULL;
1024 	size_t len;
1025 
1026 	*status_path = NULL;
1027 
1028 	resolved = realpath(arg, NULL);
1029 	if (resolved == NULL)
1030 		return got_error_from_errno();
1031 
1032 	if (strncmp(got_worktree_get_root_path(worktree), resolved,
1033 	    strlen(got_worktree_get_root_path(worktree)))) {
1034 		err = got_error(GOT_ERR_BAD_PATH);
1035 		goto done;
1036 	}
1037 
1038 	path = strdup(resolved + strlen(got_worktree_get_root_path(worktree)));
1039 	if (path == NULL) {
1040 		err = got_error_from_errno();
1041 		goto done;
1042 	}
1043 
1044 	/* XXX status walk can't deal with trailing slash! */
1045 	len = strlen(path);
1046 	while (path[len - 1] == '/') {
1047 		path[len - 1] = '\0';
1048 		len--;
1049 	}
1050 done:
1051 	free(resolved);
1052 	if (err == NULL)
1053 		*status_path = path;
1054 	else
1055 		free(path);
1056 	return err;
1057 }
1058 
1059 static const struct got_error *
1060 cmd_diff(int argc, char *argv[])
1061 {
1062 	const struct got_error *error;
1063 	struct got_repository *repo = NULL;
1064 	struct got_worktree *worktree = NULL;
1065 	char *cwd = NULL, *repo_path = NULL;
1066 	struct got_object_id *id1 = NULL, *id2 = NULL;
1067 	char *id_str1 = NULL, *id_str2 = NULL;
1068 	int type1, type2;
1069 	int diff_context = 3, ch;
1070 	const char *errstr;
1071 	char *path = NULL;
1072 
1073 #ifndef PROFILE
1074 	if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
1075 	    NULL) == -1)
1076 		err(1, "pledge");
1077 #endif
1078 
1079 	while ((ch = getopt(argc, argv, "C:r:")) != -1) {
1080 		switch (ch) {
1081 		case 'C':
1082 			diff_context = strtonum(optarg, 1, INT_MAX, &errstr);
1083 			if (errstr != NULL)
1084 				err(1, "-C option %s", errstr);
1085 			break;
1086 		case 'r':
1087 			repo_path = realpath(optarg, NULL);
1088 			if (repo_path == NULL)
1089 				err(1, "-r option");
1090 			break;
1091 		default:
1092 			usage_diff();
1093 			/* NOTREACHED */
1094 		}
1095 	}
1096 
1097 	argc -= optind;
1098 	argv += optind;
1099 
1100 	cwd = getcwd(NULL, 0);
1101 	if (cwd == NULL) {
1102 		error = got_error_from_errno();
1103 		goto done;
1104 	}
1105 	error = got_worktree_open(&worktree, cwd);
1106 	if (error && error->code != GOT_ERR_NOT_WORKTREE)
1107 		goto done;
1108 	if (argc <= 1) {
1109 		if (worktree == NULL) {
1110 			error = got_error(GOT_ERR_NOT_WORKTREE);
1111 			goto done;
1112 		}
1113 		if (repo_path)
1114 			errx(1,
1115 			    "-r option can't be used when diffing a work tree");
1116 		repo_path = strdup(got_worktree_get_repo_path(worktree));
1117 		if (repo_path == NULL) {
1118 			error = got_error_from_errno();
1119 			goto done;
1120 		}
1121 		if (argc == 1) {
1122 			error = get_status_path(&path, worktree, argv[0]);
1123 			if (error)
1124 				goto done;
1125 		} else {
1126 			path = strdup("");
1127 			if (path == NULL) {
1128 				error = got_error_from_errno();
1129 				goto done;
1130 			}
1131 		}
1132 	} else if (argc == 2) {
1133 		id_str1 = argv[0];
1134 		id_str2 = argv[1];
1135 	} else
1136 		usage_diff();
1137 
1138 	if (repo_path == NULL) {
1139 		repo_path = getcwd(NULL, 0);
1140 		if (repo_path == NULL)
1141 			return got_error_from_errno();
1142 	}
1143 
1144 	error = apply_unveil(repo_path, 1,
1145 	    worktree ? got_worktree_get_root_path(worktree) : NULL);
1146 	if (error)
1147 		goto done;
1148 
1149 	error = got_repo_open(&repo, repo_path);
1150 	free(repo_path);
1151 	if (error != NULL)
1152 		goto done;
1153 
1154 	if (worktree) {
1155 		struct print_diff_arg arg;
1156 		char *id_str;
1157 		error = got_object_id_str(&id_str,
1158 		    got_worktree_get_base_commit_id(worktree));
1159 		if (error)
1160 			goto done;
1161 		arg.repo = repo;
1162 		arg.worktree = worktree;
1163 		arg.diff_context = diff_context;
1164 		arg.id_str = id_str;
1165 		arg.header_shown = 0;
1166 
1167 		error = got_worktree_status(worktree, path, repo, print_diff,
1168 		    &arg, check_cancelled, NULL);
1169 		free(id_str);
1170 		goto done;
1171 	}
1172 
1173 	error = got_object_resolve_id_str(&id1, repo, id_str1);
1174 	if (error)
1175 		goto done;
1176 
1177 	error = got_object_resolve_id_str(&id2, repo, id_str2);
1178 	if (error)
1179 		goto done;
1180 
1181 	error = got_object_get_type(&type1, repo, id1);
1182 	if (error)
1183 		goto done;
1184 
1185 	error = got_object_get_type(&type2, repo, id2);
1186 	if (error)
1187 		goto done;
1188 
1189 	if (type1 != type2) {
1190 		error = got_error(GOT_ERR_OBJ_TYPE);
1191 		goto done;
1192 	}
1193 
1194 	switch (type1) {
1195 	case GOT_OBJ_TYPE_BLOB:
1196 		error = got_diff_objects_as_blobs(id1, id2, NULL, NULL,
1197 		    diff_context, repo, stdout);
1198 		break;
1199 	case GOT_OBJ_TYPE_TREE:
1200 		error = got_diff_objects_as_trees(id1, id2, "", "",
1201 		    diff_context, repo, stdout);
1202 		break;
1203 	case GOT_OBJ_TYPE_COMMIT:
1204 		printf("diff %s %s\n", id_str1 ? id_str1 : "/dev/null",
1205 		    id_str2);
1206 		error = got_diff_objects_as_commits(id1, id2, diff_context,
1207 		    repo, stdout);
1208 		break;
1209 	default:
1210 		error = got_error(GOT_ERR_OBJ_TYPE);
1211 	}
1212 
1213 done:
1214 	free(id1);
1215 	free(id2);
1216 	free(path);
1217 	if (worktree)
1218 		got_worktree_close(worktree);
1219 	if (repo) {
1220 		const struct got_error *repo_error;
1221 		repo_error = got_repo_close(repo);
1222 		if (error == NULL)
1223 			error = repo_error;
1224 	}
1225 	return error;
1226 }
1227 
1228 __dead static void
1229 usage_blame(void)
1230 {
1231 	fprintf(stderr,
1232 	    "usage: %s blame [-c commit] [-r repository-path] path\n",
1233 	    getprogname());
1234 	exit(1);
1235 }
1236 
1237 static const struct got_error *
1238 cmd_blame(int argc, char *argv[])
1239 {
1240 	const struct got_error *error;
1241 	struct got_repository *repo = NULL;
1242 	struct got_worktree *worktree = NULL;
1243 	char *path, *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
1244 	struct got_object_id *commit_id = NULL;
1245 	char *commit_id_str = NULL;
1246 	int ch;
1247 
1248 #ifndef PROFILE
1249 	if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
1250 	    NULL) == -1)
1251 		err(1, "pledge");
1252 #endif
1253 
1254 	while ((ch = getopt(argc, argv, "c:r:")) != -1) {
1255 		switch (ch) {
1256 		case 'c':
1257 			commit_id_str = optarg;
1258 			break;
1259 		case 'r':
1260 			repo_path = realpath(optarg, NULL);
1261 			if (repo_path == NULL)
1262 				err(1, "-r option");
1263 			break;
1264 		default:
1265 			usage_blame();
1266 			/* NOTREACHED */
1267 		}
1268 	}
1269 
1270 	argc -= optind;
1271 	argv += optind;
1272 
1273 	if (argc == 1)
1274 		path = argv[0];
1275 	else
1276 		usage_blame();
1277 
1278 	cwd = getcwd(NULL, 0);
1279 	if (cwd == NULL) {
1280 		error = got_error_from_errno();
1281 		goto done;
1282 	}
1283 	if (repo_path == NULL) {
1284 		error = got_worktree_open(&worktree, cwd);
1285 		if (error && error->code != GOT_ERR_NOT_WORKTREE)
1286 			goto done;
1287 		else
1288 			error = NULL;
1289 		if (worktree) {
1290 			repo_path =
1291 			    strdup(got_worktree_get_repo_path(worktree));
1292 			if (repo_path == NULL)
1293 				error = got_error_from_errno();
1294 			if (error)
1295 				goto done;
1296 		} else {
1297 			repo_path = strdup(cwd);
1298 			if (repo_path == NULL) {
1299 				error = got_error_from_errno();
1300 				goto done;
1301 			}
1302 		}
1303 	}
1304 
1305 	error = apply_unveil(repo_path, 1, NULL);
1306 	if (error)
1307 		goto done;
1308 
1309 	error = got_repo_open(&repo, repo_path);
1310 	if (error != NULL)
1311 		goto done;
1312 
1313 	if (worktree) {
1314 		const char *prefix = got_worktree_get_path_prefix(worktree);
1315 		char *p, *worktree_subdir = cwd +
1316 		    strlen(got_worktree_get_root_path(worktree));
1317 		if (asprintf(&p, "%s%s%s%s%s",
1318 		    prefix, (strcmp(prefix, "/") != 0) ? "/" : "",
1319 		    worktree_subdir, worktree_subdir[0] ? "/" : "",
1320 		    path) == -1) {
1321 			error = got_error_from_errno();
1322 			goto done;
1323 		}
1324 		error = got_repo_map_path(&in_repo_path, repo, p, 0);
1325 		free(p);
1326 	} else {
1327 		error = got_repo_map_path(&in_repo_path, repo, path, 1);
1328 	}
1329 	if (error)
1330 		goto done;
1331 
1332 	if (commit_id_str == NULL) {
1333 		struct got_reference *head_ref;
1334 		error = got_ref_open(&head_ref, repo, GOT_REF_HEAD);
1335 		if (error != NULL)
1336 			goto done;
1337 		error = got_ref_resolve(&commit_id, repo, head_ref);
1338 		got_ref_close(head_ref);
1339 		if (error != NULL)
1340 			goto done;
1341 	} else {
1342 		error = got_object_resolve_id_str(&commit_id, repo,
1343 		    commit_id_str);
1344 		if (error != NULL)
1345 			goto done;
1346 	}
1347 
1348 	error = got_blame(in_repo_path, commit_id, repo, stdout);
1349 done:
1350 	free(in_repo_path);
1351 	free(repo_path);
1352 	free(cwd);
1353 	free(commit_id);
1354 	if (worktree)
1355 		got_worktree_close(worktree);
1356 	if (repo) {
1357 		const struct got_error *repo_error;
1358 		repo_error = got_repo_close(repo);
1359 		if (error == NULL)
1360 			error = repo_error;
1361 	}
1362 	return error;
1363 }
1364 
1365 __dead static void
1366 usage_tree(void)
1367 {
1368 	fprintf(stderr,
1369 	    "usage: %s tree [-c commit] [-r repository-path] [-iR] path\n",
1370 	    getprogname());
1371 	exit(1);
1372 }
1373 
1374 static void
1375 print_entry(struct got_tree_entry *te, const char *id, const char *path,
1376     const char *root_path)
1377 {
1378 	int is_root_path = (strcmp(path, root_path) == 0);
1379 
1380 	path += strlen(root_path);
1381 	while (path[0] == '/')
1382 		path++;
1383 
1384 	printf("%s%s%s%s%s\n", id ? id : "", path,
1385 	    is_root_path ? "" : "/", te->name,
1386 	    S_ISDIR(te->mode) ? "/" : ((te->mode & S_IXUSR) ? "*" : ""));
1387 }
1388 
1389 static const struct got_error *
1390 print_tree(const char *path, struct got_object_id *commit_id,
1391     int show_ids, int recurse, const char *root_path,
1392     struct got_repository *repo)
1393 {
1394 	const struct got_error *err = NULL;
1395 	struct got_object_id *tree_id = NULL;
1396 	struct got_tree_object *tree = NULL;
1397 	const struct got_tree_entries *entries;
1398 	struct got_tree_entry *te;
1399 
1400 	err = got_object_id_by_path(&tree_id, repo, commit_id, path);
1401 	if (err)
1402 		goto done;
1403 
1404 	err = got_object_open_as_tree(&tree, repo, tree_id);
1405 	if (err)
1406 		goto done;
1407 	entries = got_object_tree_get_entries(tree);
1408 	te = SIMPLEQ_FIRST(&entries->head);
1409 	while (te) {
1410 		char *id = NULL;
1411 
1412 		if (sigint_received || sigpipe_received)
1413 			break;
1414 
1415 		if (show_ids) {
1416 			char *id_str;
1417 			err = got_object_id_str(&id_str, te->id);
1418 			if (err)
1419 				goto done;
1420 			if (asprintf(&id, "%s ", id_str) == -1) {
1421 				err = got_error_from_errno();
1422 				free(id_str);
1423 				goto done;
1424 			}
1425 			free(id_str);
1426 		}
1427 		print_entry(te, id, path, root_path);
1428 		free(id);
1429 
1430 		if (recurse && S_ISDIR(te->mode)) {
1431 			char *child_path;
1432 			if (asprintf(&child_path, "%s%s%s", path,
1433 			    path[0] == '/' && path[1] == '\0' ? "" : "/",
1434 			    te->name) == -1) {
1435 				err = got_error_from_errno();
1436 				goto done;
1437 			}
1438 			err = print_tree(child_path, commit_id, show_ids, 1,
1439 			    root_path, repo);
1440 			free(child_path);
1441 			if (err)
1442 				goto done;
1443 		}
1444 
1445 		te = SIMPLEQ_NEXT(te, entry);
1446 	}
1447 done:
1448 	if (tree)
1449 		got_object_tree_close(tree);
1450 	free(tree_id);
1451 	return err;
1452 }
1453 
1454 static const struct got_error *
1455 cmd_tree(int argc, char *argv[])
1456 {
1457 	const struct got_error *error;
1458 	struct got_repository *repo = NULL;
1459 	struct got_worktree *worktree = NULL;
1460 	const char *path;
1461 	char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
1462 	struct got_object_id *commit_id = NULL;
1463 	char *commit_id_str = NULL;
1464 	int show_ids = 0, recurse = 0;
1465 	int ch;
1466 
1467 #ifndef PROFILE
1468 	if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
1469 	    NULL) == -1)
1470 		err(1, "pledge");
1471 #endif
1472 
1473 	while ((ch = getopt(argc, argv, "c:r:iR")) != -1) {
1474 		switch (ch) {
1475 		case 'c':
1476 			commit_id_str = optarg;
1477 			break;
1478 		case 'r':
1479 			repo_path = realpath(optarg, NULL);
1480 			if (repo_path == NULL)
1481 				err(1, "-r option");
1482 			break;
1483 		case 'i':
1484 			show_ids = 1;
1485 			break;
1486 		case 'R':
1487 			recurse = 1;
1488 			break;
1489 		default:
1490 			usage_tree();
1491 			/* NOTREACHED */
1492 		}
1493 	}
1494 
1495 	argc -= optind;
1496 	argv += optind;
1497 
1498 	if (argc == 1)
1499 		path = argv[0];
1500 	else if (argc > 1)
1501 		usage_tree();
1502 	else
1503 		path = NULL;
1504 
1505 	cwd = getcwd(NULL, 0);
1506 	if (cwd == NULL) {
1507 		error = got_error_from_errno();
1508 		goto done;
1509 	}
1510 	if (repo_path == NULL) {
1511 		error = got_worktree_open(&worktree, cwd);
1512 		if (error && error->code != GOT_ERR_NOT_WORKTREE)
1513 			goto done;
1514 		else
1515 			error = NULL;
1516 		if (worktree) {
1517 			repo_path =
1518 			    strdup(got_worktree_get_repo_path(worktree));
1519 			if (repo_path == NULL)
1520 				error = got_error_from_errno();
1521 			if (error)
1522 				goto done;
1523 		} else {
1524 			repo_path = strdup(cwd);
1525 			if (repo_path == NULL) {
1526 				error = got_error_from_errno();
1527 				goto done;
1528 			}
1529 		}
1530 	}
1531 
1532 	error = apply_unveil(repo_path, 1, NULL);
1533 	if (error)
1534 		goto done;
1535 
1536 	error = got_repo_open(&repo, repo_path);
1537 	if (error != NULL)
1538 		goto done;
1539 
1540 	if (path == NULL) {
1541 		if (worktree) {
1542 			char *p, *worktree_subdir = cwd +
1543 			    strlen(got_worktree_get_root_path(worktree));
1544 			if (asprintf(&p, "%s/%s",
1545 			    got_worktree_get_path_prefix(worktree),
1546 			    worktree_subdir) == -1) {
1547 				error = got_error_from_errno();
1548 				goto done;
1549 			}
1550 			error = got_repo_map_path(&in_repo_path, repo, p, 1);
1551 			free(p);
1552 			if (error)
1553 				goto done;
1554 		} else
1555 			path = "/";
1556 	}
1557 	if (in_repo_path == NULL) {
1558 		error = got_repo_map_path(&in_repo_path, repo, path, 1);
1559 		if (error != NULL)
1560 			goto done;
1561 	}
1562 
1563 	if (commit_id_str == NULL) {
1564 		struct got_reference *head_ref;
1565 		error = got_ref_open(&head_ref, repo, GOT_REF_HEAD);
1566 		if (error != NULL)
1567 			goto done;
1568 		error = got_ref_resolve(&commit_id, repo, head_ref);
1569 		got_ref_close(head_ref);
1570 		if (error != NULL)
1571 			goto done;
1572 	} else {
1573 		error = got_object_resolve_id_str(&commit_id, repo,
1574 		    commit_id_str);
1575 		if (error != NULL)
1576 			goto done;
1577 	}
1578 
1579 	error = print_tree(in_repo_path, commit_id, show_ids, recurse,
1580 	    in_repo_path, repo);
1581 done:
1582 	free(in_repo_path);
1583 	free(repo_path);
1584 	free(cwd);
1585 	free(commit_id);
1586 	if (worktree)
1587 		got_worktree_close(worktree);
1588 	if (repo) {
1589 		const struct got_error *repo_error;
1590 		repo_error = got_repo_close(repo);
1591 		if (error == NULL)
1592 			error = repo_error;
1593 	}
1594 	return error;
1595 }
1596 
1597 __dead static void
1598 usage_status(void)
1599 {
1600 	fprintf(stderr, "usage: %s status [path]\n", getprogname());
1601 	exit(1);
1602 }
1603 
1604 static const struct got_error *
1605 print_status(void *arg, unsigned char status, const char *path,
1606     struct got_object_id *id)
1607 {
1608 	printf("%c  %s\n", status, path);
1609 	return NULL;
1610 }
1611 
1612 static const struct got_error *
1613 cmd_status(int argc, char *argv[])
1614 {
1615 	const struct got_error *error = NULL;
1616 	struct got_repository *repo = NULL;
1617 	struct got_worktree *worktree = NULL;
1618 	char *cwd = NULL, *path = NULL;
1619 	int ch;
1620 
1621 	while ((ch = getopt(argc, argv, "")) != -1) {
1622 		switch (ch) {
1623 		default:
1624 			usage_status();
1625 			/* NOTREACHED */
1626 		}
1627 	}
1628 
1629 	argc -= optind;
1630 	argv += optind;
1631 
1632 #ifndef PROFILE
1633 	if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
1634 	    NULL) == -1)
1635 		err(1, "pledge");
1636 #endif
1637 	cwd = getcwd(NULL, 0);
1638 	if (cwd == NULL) {
1639 		error = got_error_from_errno();
1640 		goto done;
1641 	}
1642 
1643 	error = got_worktree_open(&worktree, cwd);
1644 	if (error != NULL)
1645 		goto done;
1646 
1647 	if (argc == 0) {
1648 		path = strdup("");
1649 		if (path == NULL) {
1650 			error = got_error_from_errno();
1651 			goto done;
1652 		}
1653 	} else if (argc == 1) {
1654 		error = get_status_path(&path, worktree, argv[0]);
1655 		if (error)
1656 			goto done;
1657 	} else
1658 		usage_status();
1659 
1660 	error = got_repo_open(&repo, got_worktree_get_repo_path(worktree));
1661 	if (error != NULL)
1662 		goto done;
1663 
1664 	error = apply_unveil(got_repo_get_path(repo), 1,
1665 	    got_worktree_get_root_path(worktree));
1666 	if (error)
1667 		goto done;
1668 
1669 	error = got_worktree_status(worktree, path, repo, print_status, NULL,
1670 	    check_cancelled, NULL);
1671 done:
1672 	free(cwd);
1673 	free(path);
1674 	return error;
1675 }
1676 
1677 __dead static void
1678 usage_ref(void)
1679 {
1680 	fprintf(stderr,
1681 	    "usage: %s ref [-r repository] -l | -d name | name object\n",
1682 	    getprogname());
1683 	exit(1);
1684 }
1685 
1686 static const struct got_error *
1687 list_refs(struct got_repository *repo)
1688 {
1689 	static const struct got_error *err = NULL;
1690 	struct got_reflist_head refs;
1691 	struct got_reflist_entry *re;
1692 
1693 	SIMPLEQ_INIT(&refs);
1694 	err = got_ref_list(&refs, repo);
1695 	if (err)
1696 		return err;
1697 
1698 	SIMPLEQ_FOREACH(re, &refs, entry) {
1699 		char *refstr;
1700 		refstr = got_ref_to_str(re->ref);
1701 		if (refstr == NULL)
1702 			return got_error_from_errno();
1703 		printf("%s: %s\n", got_ref_get_name(re->ref), refstr);
1704 		free(refstr);
1705 	}
1706 
1707 	return NULL;
1708 }
1709 
1710 static const struct got_error *
1711 delete_ref(struct got_repository *repo, const char *refname)
1712 {
1713 	const struct got_error *err = NULL;
1714 	struct got_reference *ref;
1715 
1716 	err = got_ref_open(&ref, repo, refname);
1717 	if (err)
1718 		return err;
1719 
1720 	err = got_ref_delete(ref, repo);
1721 	got_ref_close(ref);
1722 	return err;
1723 }
1724 
1725 static const struct got_error *
1726 add_ref(struct got_repository *repo, const char *refname, const char *id_str)
1727 {
1728 	const struct got_error *err = NULL;
1729 	struct got_object_id *id;
1730 	struct got_reference *ref = NULL;
1731 
1732 	err = got_object_resolve_id_str(&id, repo, id_str);
1733 	if (err)
1734 		return err;
1735 
1736 	err = got_ref_alloc(&ref, refname, id);
1737 	if (err)
1738 		goto done;
1739 
1740 	err = got_ref_write(ref, repo);
1741 done:
1742 	if (ref)
1743 		got_ref_close(ref);
1744 	free(id);
1745 	return err;
1746 }
1747 
1748 static const struct got_error *
1749 cmd_ref(int argc, char *argv[])
1750 {
1751 	const struct got_error *error = NULL;
1752 	struct got_repository *repo = NULL;
1753 	struct got_worktree *worktree = NULL;
1754 	char *cwd = NULL, *repo_path = NULL;
1755 	int ch, do_list = 0;
1756 	const char *delref = NULL;
1757 
1758 	/* TODO: Add -s option for adding symbolic references. */
1759 	while ((ch = getopt(argc, argv, "d:r:l")) != -1) {
1760 		switch (ch) {
1761 		case 'd':
1762 			delref = optarg;
1763 			break;
1764 		case 'r':
1765 			repo_path = realpath(optarg, NULL);
1766 			if (repo_path == NULL)
1767 				err(1, "-r option");
1768 			break;
1769 		case 'l':
1770 			do_list = 1;
1771 			break;
1772 		default:
1773 			usage_ref();
1774 			/* NOTREACHED */
1775 		}
1776 	}
1777 
1778 	if (do_list && delref)
1779 		errx(1, "-l and -d options are mutually exclusive\n");
1780 
1781 	argc -= optind;
1782 	argv += optind;
1783 
1784 	if (do_list || delref) {
1785 		if (argc > 0)
1786 			usage_ref();
1787 	} else if (argc != 2)
1788 		usage_ref();
1789 
1790 #ifndef PROFILE
1791 	if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
1792 	    "unveil", NULL) == -1)
1793 		err(1, "pledge");
1794 #endif
1795 	cwd = getcwd(NULL, 0);
1796 	if (cwd == NULL) {
1797 		error = got_error_from_errno();
1798 		goto done;
1799 	}
1800 
1801 	if (repo_path == NULL) {
1802 		error = got_worktree_open(&worktree, cwd);
1803 		if (error && error->code != GOT_ERR_NOT_WORKTREE)
1804 			goto done;
1805 		else
1806 			error = NULL;
1807 		if (worktree) {
1808 			repo_path =
1809 			    strdup(got_worktree_get_repo_path(worktree));
1810 			if (repo_path == NULL)
1811 				error = got_error_from_errno();
1812 			if (error)
1813 				goto done;
1814 		} else {
1815 			repo_path = strdup(cwd);
1816 			if (repo_path == NULL) {
1817 				error = got_error_from_errno();
1818 				goto done;
1819 			}
1820 		}
1821 	}
1822 
1823 	error = apply_unveil(repo_path, do_list,
1824 	    worktree ? got_worktree_get_root_path(worktree) : NULL);
1825 	if (error)
1826 		goto done;
1827 
1828 	error = got_repo_open(&repo, repo_path);
1829 	if (error != NULL)
1830 		goto done;
1831 
1832 	if (do_list)
1833 		error = list_refs(repo);
1834 	else if (delref)
1835 		error = delete_ref(repo, delref);
1836 	else
1837 		error = add_ref(repo, argv[0], argv[1]);
1838 done:
1839 	if (repo)
1840 		got_repo_close(repo);
1841 	if (worktree)
1842 		got_worktree_close(worktree);
1843 	free(cwd);
1844 	free(repo_path);
1845 	return error;
1846 }