?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
portable: fix up log.c file location
[got-portable.git] / got / got.c
blob7afbff165a8d83cc740034cde9d4b97f2afeb3b4
1 /*
2 * Copyright (c) 2017 Martin Pieuchot <mpi@openbsd.org>
3 * Copyright (c) 2018, 2019, 2020 Stefan Sperling <stsp@openbsd.org>
4 * Copyright (c) 2020 Ori Bernstein <ori@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include "got_compat.h"
20
21 #include <sys/queue.h>
22 #include <sys/time.h>
23 #include <sys/types.h>
24 #include <sys/stat.h>
25 #include <sys/wait.h>
26
27 #include <err.h>
28 #include <errno.h>
29 #include <fcntl.h>
30 #include <limits.h>
31 #include <locale.h>
32 #include <ctype.h>
33 #include <signal.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <unistd.h>
38 #include <libgen.h>
39 #include <time.h>
40 #include <paths.h>
41 #include <regex.h>
42 #include <getopt.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_path.h"
50 #include "got_cancel.h"
51 #include "got_worktree.h"
52 #include "got_diff.h"
53 #include "got_commit_graph.h"
54 #include "got_fetch.h"
55 #include "got_send.h"
56 #include "got_blame.h"
57 #include "got_privsep.h"
58 #include "got_opentemp.h"
59 #include "got_gotconfig.h"
60 #include "got_dial.h"
61 #include "got_patch.h"
62 #include "got_sigs.h"
63 #include "got_date.h"
64 #include "got_keyword.h"
65
66 #ifndef nitems
67 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
68 #endif
69
70 #ifndef GOT_DEFAULT_EDITOR
71 #define GOT_DEFAULT_EDITOR "/usr/bin/vi"
72 #endif
73
74 static volatile sig_atomic_t sigint_received;
75 static volatile sig_atomic_t sigpipe_received;
76
77 static void
78 catch_sigint(int signo)
79 {
80 sigint_received = 1;
81 }
82
83 static void
84 catch_sigpipe(int signo)
85 {
86 sigpipe_received = 1;
87 }
88
89
90 struct got_cmd {
91 const char *cmd_name;
92 const struct got_error *(*cmd_main)(int, char *[]);
93 void (*cmd_usage)(void);
94 const char *cmd_alias;
95 };
96
97 __dead static void usage(int, int);
98 __dead static void usage_import(void);
99 __dead static void usage_clone(void);
100 __dead static void usage_fetch(void);
101 __dead static void usage_checkout(void);
102 __dead static void usage_update(void);
103 __dead static void usage_log(void);
104 __dead static void usage_diff(void);
105 __dead static void usage_blame(void);
106 __dead static void usage_tree(void);
107 __dead static void usage_status(void);
108 __dead static void usage_ref(void);
109 __dead static void usage_branch(void);
110 __dead static void usage_tag(void);
111 __dead static void usage_add(void);
112 __dead static void usage_remove(void);
113 __dead static void usage_patch(void);
114 __dead static void usage_revert(void);
115 __dead static void usage_commit(void);
116 __dead static void usage_send(void);
117 __dead static void usage_cherrypick(void);
118 __dead static void usage_backout(void);
119 __dead static void usage_rebase(void);
120 __dead static void usage_histedit(void);
121 __dead static void usage_integrate(void);
122 __dead static void usage_merge(void);
123 __dead static void usage_stage(void);
124 __dead static void usage_unstage(void);
125 __dead static void usage_cat(void);
126 __dead static void usage_info(void);
127
128 static const struct got_error* cmd_import(int, char *[]);
129 static const struct got_error* cmd_clone(int, char *[]);
130 static const struct got_error* cmd_fetch(int, char *[]);
131 static const struct got_error* cmd_checkout(int, char *[]);
132 static const struct got_error* cmd_update(int, char *[]);
133 static const struct got_error* cmd_log(int, char *[]);
134 static const struct got_error* cmd_diff(int, char *[]);
135 static const struct got_error* cmd_blame(int, char *[]);
136 static const struct got_error* cmd_tree(int, char *[]);
137 static const struct got_error* cmd_status(int, char *[]);
138 static const struct got_error* cmd_ref(int, char *[]);
139 static const struct got_error* cmd_branch(int, char *[]);
140 static const struct got_error* cmd_tag(int, char *[]);
141 static const struct got_error* cmd_add(int, char *[]);
142 static const struct got_error* cmd_remove(int, char *[]);
143 static const struct got_error* cmd_patch(int, char *[]);
144 static const struct got_error* cmd_revert(int, char *[]);
145 static const struct got_error* cmd_commit(int, char *[]);
146 static const struct got_error* cmd_send(int, char *[]);
147 static const struct got_error* cmd_cherrypick(int, char *[]);
148 static const struct got_error* cmd_backout(int, char *[]);
149 static const struct got_error* cmd_rebase(int, char *[]);
150 static const struct got_error* cmd_histedit(int, char *[]);
151 static const struct got_error* cmd_integrate(int, char *[]);
152 static const struct got_error* cmd_merge(int, char *[]);
153 static const struct got_error* cmd_stage(int, char *[]);
154 static const struct got_error* cmd_unstage(int, char *[]);
155 static const struct got_error* cmd_cat(int, char *[]);
156 static const struct got_error* cmd_info(int, char *[]);
157
158 static const struct got_cmd got_commands[] = {
159 { "import", cmd_import, usage_import, "im" },
160 { "clone", cmd_clone, usage_clone, "cl" },
161 { "fetch", cmd_fetch, usage_fetch, "fe" },
162 { "checkout", cmd_checkout, usage_checkout, "co" },
163 { "update", cmd_update, usage_update, "up" },
164 { "log", cmd_log, usage_log, "" },
165 { "diff", cmd_diff, usage_diff, "di" },
166 { "blame", cmd_blame, usage_blame, "bl" },
167 { "tree", cmd_tree, usage_tree, "tr" },
168 { "status", cmd_status, usage_status, "st" },
169 { "ref", cmd_ref, usage_ref, "" },
170 { "branch", cmd_branch, usage_branch, "br" },
171 { "tag", cmd_tag, usage_tag, "" },
172 { "add", cmd_add, usage_add, "" },
173 { "remove", cmd_remove, usage_remove, "rm" },
174 { "patch", cmd_patch, usage_patch, "pa" },
175 { "revert", cmd_revert, usage_revert, "rv" },
176 { "commit", cmd_commit, usage_commit, "ci" },
177 { "send", cmd_send, usage_send, "se" },
178 { "cherrypick", cmd_cherrypick, usage_cherrypick, "cy" },
179 { "backout", cmd_backout, usage_backout, "bo" },
180 { "rebase", cmd_rebase, usage_rebase, "rb" },
181 { "histedit", cmd_histedit, usage_histedit, "he" },
182 { "integrate", cmd_integrate, usage_integrate,"ig" },
183 { "merge", cmd_merge, usage_merge, "mg" },
184 { "stage", cmd_stage, usage_stage, "sg" },
185 { "unstage", cmd_unstage, usage_unstage, "ug" },
186 { "cat", cmd_cat, usage_cat, "" },
187 { "info", cmd_info, usage_info, "" },
188 };
189
190 static void
191 list_commands(FILE *fp)
192 {
193 size_t i;
194
195 fprintf(fp, "commands:");
196 for (i = 0; i < nitems(got_commands); i++) {
197 const struct got_cmd *cmd = &got_commands[i];
198 fprintf(fp, " %s", cmd->cmd_name);
199 }
200 fputc('\n', fp);
201 }
202
203 __dead static void
204 option_conflict(char a, char b)
205 {
206 errx(1, "-%c and -%c options are mutually exclusive", a, b);
207 }
208
209 int
210 main(int argc, char *argv[])
211 {
212 const struct got_cmd *cmd;
213 size_t i;
214 int ch;
215 int hflag = 0, Vflag = 0;
216 static const struct option longopts[] = {
217 { "version", no_argument, NULL, 'V' },
218 { NULL, 0, NULL, 0 }
219 };
220
221 setlocale(LC_CTYPE, "");
222
223 while ((ch = getopt_long(argc, argv, "+hV", longopts, NULL)) != -1) {
224 switch (ch) {
225 case 'h':
226 hflag = 1;
227 break;
228 case 'V':
229 Vflag = 1;
230 break;
231 default:
232 usage(hflag, 1);
233 /* NOTREACHED */
234 }
235 }
236
237 argc -= optind;
238 argv += optind;
239 optind = 1;
240 optreset = 1;
241
242 if (Vflag) {
243 got_version_print_str();
244 return 0;
245 }
246
247 if (argc <= 0)
248 usage(hflag, hflag ? 0 : 1);
249
250 signal(SIGINT, catch_sigint);
251 signal(SIGPIPE, catch_sigpipe);
252
253 for (i = 0; i < nitems(got_commands); i++) {
254 const struct got_error *error;
255
256 cmd = &got_commands[i];
257
258 if (strcmp(cmd->cmd_name, argv[0]) != 0 &&
259 strcmp(cmd->cmd_alias, argv[0]) != 0)
260 continue;
261
262 if (hflag)
263 cmd->cmd_usage();
264
265 error = cmd->cmd_main(argc, argv);
266 if (error && error->code != GOT_ERR_CANCELLED &&
267 error->code != GOT_ERR_PRIVSEP_EXIT &&
268 !(sigpipe_received &&
269 error->code == GOT_ERR_ERRNO && errno == EPIPE) &&
270 !(sigint_received &&
271 error->code == GOT_ERR_ERRNO && errno == EINTR)) {
272 fflush(stdout);
273 fprintf(stderr, "%s: %s\n", getprogname(), error->msg);
274 return 1;
275 }
276
277 return 0;
278 }
279
280 fprintf(stderr, "%s: unknown command '%s'\n", getprogname(), argv[0]);
281 list_commands(stderr);
282 return 1;
283 }
284
285 __dead static void
286 usage(int hflag, int status)
287 {
288 FILE *fp = (status == 0) ? stdout : stderr;
289
290 fprintf(fp, "usage: %s [-hV] command [arg ...]\n",
291 getprogname());
292 if (hflag)
293 list_commands(fp);
294 exit(status);
295 }
296
297 static const struct got_error *
298 get_editor(char **abspath)
299 {
300 const struct got_error *err = NULL;
301 const char *editor;
302
303 *abspath = NULL;
304
305 editor = getenv("VISUAL");
306 if (editor == NULL)
307 editor = getenv("EDITOR");
308
309 if (editor) {
310 err = got_path_find_prog(abspath, editor);
311 if (err)
312 return err;
313 }
314
315 if (*abspath == NULL) {
316 *abspath = strdup(GOT_DEFAULT_EDITOR);
317 if (*abspath == NULL)
318 return got_error_from_errno("strdup");
319 }
320
321 return NULL;
322 }
323
324 static const struct got_error *
325 apply_unveil(const char *repo_path, int repo_read_only,
326 const char *worktree_path)
327 {
328 const struct got_error *err;
329
330 #ifdef PROFILE
331 if (unveil("gmon.out", "rwc") != 0)
332 return got_error_from_errno2("unveil", "gmon.out");
333 #endif
334 if (repo_path && unveil(repo_path, repo_read_only ? "r" : "rwc") != 0)
335 return got_error_from_errno2("unveil", repo_path);
336
337 if (worktree_path && unveil(worktree_path, "rwc") != 0)
338 return got_error_from_errno2("unveil", worktree_path);
339
340 if (unveil(GOT_TMPDIR_STR, "rwc") != 0)
341 return got_error_from_errno2("unveil", GOT_TMPDIR_STR);
342
343 err = got_privsep_unveil_exec_helpers();
344 if (err != NULL)
345 return err;
346
347 if (unveil(NULL, NULL) != 0)
348 return got_error_from_errno("unveil");
349
350 return NULL;
351 }
352
353 __dead static void
354 usage_import(void)
355 {
356 fprintf(stderr, "usage: %s import [-b branch] [-I pattern] [-m message] "
357 "[-r repository-path] directory\n", getprogname());
358 exit(1);
359 }
360
361 static int
362 spawn_editor(const char *editor, const char *file)
363 {
364 pid_t pid;
365 sig_t sighup, sigint, sigquit;
366 int st = -1;
367
368 sighup = signal(SIGHUP, SIG_IGN);
369 sigint = signal(SIGINT, SIG_IGN);
370 sigquit = signal(SIGQUIT, SIG_IGN);
371
372 switch (pid = fork()) {
373 case -1:
374 goto doneediting;
375 case 0:
376 execl(editor, editor, file, (char *)NULL);
377 _exit(127);
378 }
379
380 while (waitpid(pid, &st, 0) == -1)
381 if (errno != EINTR)
382 break;
383
384 doneediting:
385 (void)signal(SIGHUP, sighup);
386 (void)signal(SIGINT, sigint);
387 (void)signal(SIGQUIT, sigquit);
388
389 if (!WIFEXITED(st)) {
390 errno = EINTR;
391 return -1;
392 }
393
394 return WEXITSTATUS(st);
395 }
396
397 static const struct got_error *
398 read_logmsg(char **logmsg, size_t *len, FILE *fp, size_t filesize)
399 {
400 const struct got_error *err = NULL;
401 char *line = NULL;
402 size_t linesize = 0;
403
404 *logmsg = NULL;
405 *len = 0;
406
407 if (fseeko(fp, 0L, SEEK_SET) == -1)
408 return got_error_from_errno("fseeko");
409
410 *logmsg = malloc(filesize + 1);
411 if (*logmsg == NULL)
412 return got_error_from_errno("malloc");
413 (*logmsg)[0] = '\0';
414
415 while (getline(&line, &linesize, fp) != -1) {
416 if (line[0] == '#' || (*len == 0 && line[0] == '\n'))
417 continue; /* remove comments and leading empty lines */
418 *len = strlcat(*logmsg, line, filesize + 1);
419 if (*len >= filesize + 1) {
420 err = got_error(GOT_ERR_NO_SPACE);
421 goto done;
422 }
423 }
424 if (ferror(fp)) {
425 err = got_ferror(fp, GOT_ERR_IO);
426 goto done;
427 }
428
429 while (*len > 0 && (*logmsg)[*len - 1] == '\n') {
430 (*logmsg)[*len - 1] = '\0';
431 (*len)--;
432 }
433 done:
434 free(line);
435 if (err) {
436 free(*logmsg);
437 *logmsg = NULL;
438 *len = 0;
439 }
440 return err;
441 }
442
443 static const struct got_error *
444 edit_logmsg(char **logmsg, const char *editor, const char *logmsg_path,
445 const char *initial_content, size_t initial_content_len,
446 int require_modification)
447 {
448 const struct got_error *err = NULL;
449 struct stat st, st2;
450 FILE *fp = NULL;
451 size_t logmsg_len;
452
453 *logmsg = NULL;
454
455 if (stat(logmsg_path, &st) == -1)
456 return got_error_from_errno2("stat", logmsg_path);
457
458 if (spawn_editor(editor, logmsg_path) == -1)
459 return got_error_from_errno("failed spawning editor");
460
461 if (require_modification) {
462 struct timespec timeout;
463
464 timeout.tv_sec = 0;
465 timeout.tv_nsec = 1;
466 nanosleep(&timeout, NULL);
467 }
468
469 if (stat(logmsg_path, &st2) == -1)
470 return got_error_from_errno2("stat", logmsg_path);
471
472 if (require_modification && st.st_size == st2.st_size &&
473 timespeccmp(&st.st_mtim, &st2.st_mtim, ==))
474 return got_error_msg(GOT_ERR_COMMIT_MSG_EMPTY,
475 "no changes made to commit message, aborting");
476
477 fp = fopen(logmsg_path, "re");
478 if (fp == NULL) {
479 err = got_error_from_errno("fopen");
480 goto done;
481 }
482
483 /* strip comments and leading/trailing newlines */
484 err = read_logmsg(logmsg, &logmsg_len, fp, st2.st_size);
485 if (err)
486 goto done;
487 if (logmsg_len == 0) {
488 err = got_error_msg(GOT_ERR_COMMIT_MSG_EMPTY,
489 "commit message cannot be empty, aborting");
490 goto done;
491 }
492 done:
493 if (fp && fclose(fp) == EOF && err == NULL)
494 err = got_error_from_errno("fclose");
495 if (err) {
496 free(*logmsg);
497 *logmsg = NULL;
498 }
499 return err;
500 }
501
502 static const struct got_error *
503 collect_import_msg(char **logmsg, char **logmsg_path, const char *editor,
504 const char *path_dir, const char *branch_name)
505 {
506 char *initial_content = NULL;
507 const struct got_error *err = NULL;
508 int initial_content_len;
509 int fd = -1;
510
511 initial_content_len = asprintf(&initial_content,
512 "\n# %s to be imported to branch %s\n", path_dir,
513 branch_name);
514 if (initial_content_len == -1)
515 return got_error_from_errno("asprintf");
516
517 err = got_opentemp_named_fd(logmsg_path, &fd,
518 GOT_TMPDIR_STR "/got-importmsg", "");
519 if (err)
520 goto done;
521
522 if (write(fd, initial_content, initial_content_len) == -1) {
523 err = got_error_from_errno2("write", *logmsg_path);
524 goto done;
525 }
526 if (close(fd) == -1) {
527 err = got_error_from_errno2("close", *logmsg_path);
528 goto done;
529 }
530 fd = -1;
531
532 err = edit_logmsg(logmsg, editor, *logmsg_path, initial_content,
533 initial_content_len, 1);
534 done:
535 if (fd != -1 && close(fd) == -1 && err == NULL)
536 err = got_error_from_errno2("close", *logmsg_path);
537 free(initial_content);
538 if (err) {
539 free(*logmsg_path);
540 *logmsg_path = NULL;
541 }
542 return err;
543 }
544
545 static const struct got_error *
546 import_progress(void *arg, const char *path)
547 {
548 printf("A %s\n", path);
549 return NULL;
550 }
551
552 static const struct got_error *
553 valid_author(const char *author)
554 {
555 const char *email = author;
556
557 /*
558 * Git' expects the author (or committer) to be in the form
559 * "name <email>", which are mostly free form (see the
560 * "committer" description in git-fast-import(1)). We're only
561 * doing this to avoid git's object parser breaking on commits
562 * we create.
563 */
564
565 while (*author && *author != '\n' && *author != '<' && *author != '>')
566 author++;
567 if (author != email && *author == '<' && *(author - 1) != ' ')
568 return got_error_fmt(GOT_ERR_COMMIT_BAD_AUTHOR, "%s: space "
569 "between author name and email required", email);
570 if (*author++ != '<')
571 return got_error_fmt(GOT_ERR_COMMIT_NO_EMAIL, "%s", email);
572 while (*author && *author != '\n' && *author != '<' && *author != '>')
573 author++;
574 if (strcmp(author, ">") != 0)
575 return got_error_fmt(GOT_ERR_COMMIT_NO_EMAIL, "%s", email);
576 return NULL;
577 }
578
579 static const struct got_error *
580 get_author(char **author, struct got_repository *repo,
581 struct got_worktree *worktree)
582 {
583 const struct got_error *err = NULL;
584 const char *got_author = NULL, *name, *email;
585 const struct got_gotconfig *worktree_conf = NULL, *repo_conf = NULL;
586
587 *author = NULL;
588
589 if (worktree)
590 worktree_conf = got_worktree_get_gotconfig(worktree);
591 repo_conf = got_repo_get_gotconfig(repo);
592
593 /*
594 * Priority of potential author information sources, from most
595 * significant to least significant:
596 * 1) work tree's .got/got.conf file
597 * 2) repository's got.conf file
598 * 3) repository's git config file
599 * 4) environment variables
600 * 5) global git config files (in user's home directory or /etc)
601 */
602
603 if (worktree_conf)
604 got_author = got_gotconfig_get_author(worktree_conf);
605 if (got_author == NULL)
606 got_author = got_gotconfig_get_author(repo_conf);
607 if (got_author == NULL) {
608 name = got_repo_get_gitconfig_author_name(repo);
609 email = got_repo_get_gitconfig_author_email(repo);
610 if (name && email) {
611 if (asprintf(author, "%s <%s>", name, email) == -1)
612 return got_error_from_errno("asprintf");
613 return NULL;
614 }
615
616 got_author = getenv("GOT_AUTHOR");
617 if (got_author == NULL) {
618 name = got_repo_get_global_gitconfig_author_name(repo);
619 email = got_repo_get_global_gitconfig_author_email(
620 repo);
621 if (name && email) {
622 if (asprintf(author, "%s <%s>", name, email)
623 == -1)
624 return got_error_from_errno("asprintf");
625 return NULL;
626 }
627 /* TODO: Look up user in password database? */
628 return got_error(GOT_ERR_COMMIT_NO_AUTHOR);
629 }
630 }
631
632 *author = strdup(got_author);
633 if (*author == NULL)
634 return got_error_from_errno("strdup");
635
636 err = valid_author(*author);
637 if (err) {
638 free(*author);
639 *author = NULL;
640 }
641 return err;
642 }
643
644 static const struct got_error *
645 get_allowed_signers(char **allowed_signers, struct got_repository *repo,
646 struct got_worktree *worktree)
647 {
648 const char *got_allowed_signers = NULL;
649 const struct got_gotconfig *worktree_conf = NULL, *repo_conf = NULL;
650
651 *allowed_signers = NULL;
652
653 if (worktree)
654 worktree_conf = got_worktree_get_gotconfig(worktree);
655 repo_conf = got_repo_get_gotconfig(repo);
656
657 /*
658 * Priority of potential author information sources, from most
659 * significant to least significant:
660 * 1) work tree's .got/got.conf file
661 * 2) repository's got.conf file
662 */
663
664 if (worktree_conf)
665 got_allowed_signers = got_gotconfig_get_allowed_signers_file(
666 worktree_conf);
667 if (got_allowed_signers == NULL)
668 got_allowed_signers = got_gotconfig_get_allowed_signers_file(
669 repo_conf);
670
671 if (got_allowed_signers) {
672 *allowed_signers = strdup(got_allowed_signers);
673 if (*allowed_signers == NULL)
674 return got_error_from_errno("strdup");
675 }
676 return NULL;
677 }
678
679 static const struct got_error *
680 get_revoked_signers(char **revoked_signers, struct got_repository *repo,
681 struct got_worktree *worktree)
682 {
683 const char *got_revoked_signers = NULL;
684 const struct got_gotconfig *worktree_conf = NULL, *repo_conf = NULL;
685
686 *revoked_signers = NULL;
687
688 if (worktree)
689 worktree_conf = got_worktree_get_gotconfig(worktree);
690 repo_conf = got_repo_get_gotconfig(repo);
691
692 /*
693 * Priority of potential author information sources, from most
694 * significant to least significant:
695 * 1) work tree's .got/got.conf file
696 * 2) repository's got.conf file
697 */
698
699 if (worktree_conf)
700 got_revoked_signers = got_gotconfig_get_revoked_signers_file(
701 worktree_conf);
702 if (got_revoked_signers == NULL)
703 got_revoked_signers = got_gotconfig_get_revoked_signers_file(
704 repo_conf);
705
706 if (got_revoked_signers) {
707 *revoked_signers = strdup(got_revoked_signers);
708 if (*revoked_signers == NULL)
709 return got_error_from_errno("strdup");
710 }
711 return NULL;
712 }
713
714 static const char *
715 get_signer_id(struct got_repository *repo, struct got_worktree *worktree)
716 {
717 const char *got_signer_id = NULL;
718 const struct got_gotconfig *worktree_conf = NULL, *repo_conf = NULL;
719
720 if (worktree)
721 worktree_conf = got_worktree_get_gotconfig(worktree);
722 repo_conf = got_repo_get_gotconfig(repo);
723
724 /*
725 * Priority of potential author information sources, from most
726 * significant to least significant:
727 * 1) work tree's .got/got.conf file
728 * 2) repository's got.conf file
729 */
730
731 if (worktree_conf)
732 got_signer_id = got_gotconfig_get_signer_id(worktree_conf);
733 if (got_signer_id == NULL)
734 got_signer_id = got_gotconfig_get_signer_id(repo_conf);
735
736 return got_signer_id;
737 }
738
739 static const struct got_error *
740 get_gitconfig_path(char **gitconfig_path)
741 {
742 const char *homedir = getenv("HOME");
743
744 *gitconfig_path = NULL;
745 if (homedir) {
746 if (asprintf(gitconfig_path, "%s/.gitconfig", homedir) == -1)
747 return got_error_from_errno("asprintf");
748
749 }
750 return NULL;
751 }
752
753 static const struct got_error *
754 cmd_import(int argc, char *argv[])
755 {
756 const struct got_error *error = NULL;
757 char *path_dir = NULL, *repo_path = NULL, *logmsg = NULL;
758 char *gitconfig_path = NULL, *editor = NULL, *author = NULL;
759 const char *branch_name = NULL;
760 char *id_str = NULL, *logmsg_path = NULL;
761 char refname[PATH_MAX] = "refs/heads/";
762 struct got_repository *repo = NULL;
763 struct got_reference *branch_ref = NULL, *head_ref = NULL;
764 struct got_object_id *new_commit_id = NULL;
765 int ch, n = 0;
766 struct got_pathlist_head ignores;
767 struct got_pathlist_entry *pe;
768 int preserve_logmsg = 0;
769 int *pack_fds = NULL;
770
771 TAILQ_INIT(&ignores);
772
773 #ifndef PROFILE
774 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
775 "unveil",
776 NULL) == -1)
777 err(1, "pledge");
778 #endif
779
780 while ((ch = getopt(argc, argv, "b:I:m:r:")) != -1) {
781 switch (ch) {
782 case 'b':
783 branch_name = optarg;
784 break;
785 case 'I':
786 if (optarg[0] == '\0')
787 break;
788 error = got_pathlist_insert(&pe, &ignores, optarg,
789 NULL);
790 if (error)
791 goto done;
792 break;
793 case 'm':
794 logmsg = strdup(optarg);
795 if (logmsg == NULL) {
796 error = got_error_from_errno("strdup");
797 goto done;
798 }
799 break;
800 case 'r':
801 repo_path = realpath(optarg, NULL);
802 if (repo_path == NULL) {
803 error = got_error_from_errno2("realpath",
804 optarg);
805 goto done;
806 }
807 break;
808 default:
809 usage_import();
810 /* NOTREACHED */
811 }
812 }
813
814 argc -= optind;
815 argv += optind;
816
817 if (argc != 1)
818 usage_import();
819
820 if (repo_path == NULL) {
821 repo_path = getcwd(NULL, 0);
822 if (repo_path == NULL)
823 return got_error_from_errno("getcwd");
824 }
825 got_path_strip_trailing_slashes(repo_path);
826 error = get_gitconfig_path(&gitconfig_path);
827 if (error)
828 goto done;
829 error = got_repo_pack_fds_open(&pack_fds);
830 if (error != NULL)
831 goto done;
832 error = got_repo_open(&repo, repo_path, gitconfig_path, pack_fds);
833 if (error)
834 goto done;
835
836 path_dir = realpath(argv[0], NULL);
837 if (path_dir == NULL) {
838 error = got_error_from_errno2("realpath", argv[0]);
839 goto done;
840 }
841 got_path_strip_trailing_slashes(path_dir);
842
843 error = get_editor(&editor);
844 if (error)
845 goto done;
846
847 if (unveil(path_dir, "r") != 0) {
848 error = got_error_from_errno2("unveil", path_dir);
849 goto done;
850 }
851 if (unveil(editor, "x") != 0) {
852 error = got_error_from_errno2("unveil", editor);
853 goto done;
854 }
855 error = apply_unveil(got_repo_get_path(repo), 0, NULL);
856 if (error)
857 goto done;
858
859 error = get_author(&author, repo, NULL);
860 if (error)
861 return error;
862
863 /*
864 * Don't let the user create a branch name with a leading '-'.
865 * While technically a valid reference name, this case is usually
866 * an unintended typo.
867 */
868 if (branch_name && branch_name[0] == '-')
869 return got_error_path(branch_name, GOT_ERR_REF_NAME_MINUS);
870
871 error = got_ref_open(&head_ref, repo, GOT_REF_HEAD, 0);
872 if (error && error->code != GOT_ERR_NOT_REF)
873 goto done;
874
875 if (branch_name)
876 n = strlcat(refname, branch_name, sizeof(refname));
877 else if (head_ref && got_ref_is_symbolic(head_ref))
878 n = strlcpy(refname, got_ref_get_symref_target(head_ref),
879 sizeof(refname));
880 else
881 n = strlcat(refname, "main", sizeof(refname));
882 if (n >= sizeof(refname)) {
883 error = got_error(GOT_ERR_NO_SPACE);
884 goto done;
885 }
886
887 error = got_ref_open(&branch_ref, repo, refname, 0);
888 if (error) {
889 if (error->code != GOT_ERR_NOT_REF)
890 goto done;
891 } else {
892 error = got_error_msg(GOT_ERR_BRANCH_EXISTS,
893 "import target branch already exists");
894 goto done;
895 }
896
897 if (logmsg == NULL || *logmsg == '\0') {
898 free(logmsg);
899 error = collect_import_msg(&logmsg, &logmsg_path, editor,
900 path_dir, refname);
901 if (error) {
902 if (error->code != GOT_ERR_COMMIT_MSG_EMPTY &&
903 logmsg_path != NULL)
904 preserve_logmsg = 1;
905 goto done;
906 }
907 }
908
909 error = got_repo_import(&new_commit_id, path_dir, logmsg,
910 author, &ignores, repo, import_progress, NULL);
911 if (error) {
912 if (logmsg_path)
913 preserve_logmsg = 1;
914 goto done;
915 }
916
917 error = got_ref_alloc(&branch_ref, refname, new_commit_id);
918 if (error) {
919 if (logmsg_path)
920 preserve_logmsg = 1;
921 goto done;
922 }
923
924 error = got_ref_write(branch_ref, repo);
925 if (error) {
926 if (logmsg_path)
927 preserve_logmsg = 1;
928 goto done;
929 }
930
931 error = got_object_id_str(&id_str, new_commit_id);
932 if (error) {
933 if (logmsg_path)
934 preserve_logmsg = 1;
935 goto done;
936 }
937
938 error = got_ref_open(&head_ref, repo, GOT_REF_HEAD, 0);
939 if (error) {
940 if (error->code != GOT_ERR_NOT_REF) {
941 if (logmsg_path)
942 preserve_logmsg = 1;
943 goto done;
944 }
945
946 error = got_ref_alloc_symref(&head_ref, GOT_REF_HEAD,
947 branch_ref);
948 if (error) {
949 if (logmsg_path)
950 preserve_logmsg = 1;
951 goto done;
952 }
953
954 error = got_ref_write(head_ref, repo);
955 if (error) {
956 if (logmsg_path)
957 preserve_logmsg = 1;
958 goto done;
959 }
960 }
961
962 printf("Created branch %s with commit %s\n",
963 got_ref_get_name(branch_ref), id_str);
964 done:
965 if (pack_fds) {
966 const struct got_error *pack_err =
967 got_repo_pack_fds_close(pack_fds);
968 if (error == NULL)
969 error = pack_err;
970 }
971 if (repo) {
972 const struct got_error *close_err = got_repo_close(repo);
973 if (error == NULL)
974 error = close_err;
975 }
976 if (preserve_logmsg) {
977 fprintf(stderr, "%s: log message preserved in %s\n",
978 getprogname(), logmsg_path);
979 } else if (logmsg_path && unlink(logmsg_path) == -1 && error == NULL)
980 error = got_error_from_errno2("unlink", logmsg_path);
981 free(logmsg);
982 free(logmsg_path);
983 free(repo_path);
984 free(editor);
985 free(new_commit_id);
986 free(id_str);
987 free(author);
988 free(gitconfig_path);
989 if (branch_ref)
990 got_ref_close(branch_ref);
991 if (head_ref)
992 got_ref_close(head_ref);
993 return error;
994 }
995
996 __dead static void
997 usage_clone(void)
998 {
999 fprintf(stderr, "usage: %s clone [-almqv] [-b branch] [-R reference] "
1000 "repository-URL [directory]\n", getprogname());
1001 exit(1);
1002 }
1003
1004 struct got_fetch_progress_arg {
1005 char last_scaled_size[FMT_SCALED_STRSIZE];
1006 int last_p_indexed;
1007 int last_p_resolved;
1008 int verbosity;
1009
1010 struct got_repository *repo;
1011
1012 int create_configs;
1013 int configs_created;
1014 struct {
1015 struct got_pathlist_head *symrefs;
1016 struct got_pathlist_head *wanted_branches;
1017 struct got_pathlist_head *wanted_refs;
1018 const char *proto;
1019 const char *host;
1020 const char *port;
1021 const char *remote_repo_path;
1022 const char *git_url;
1023 int fetch_all_branches;
1024 int mirror_references;
1025 } config_info;
1026 };
1027
1028 /* XXX forward declaration */
1029 static const struct got_error *
1030 create_config_files(const char *proto, const char *host, const char *port,
1031 const char *remote_repo_path, const char *git_url, int fetch_all_branches,
1032 int mirror_references, struct got_pathlist_head *symrefs,
1033 struct got_pathlist_head *wanted_branches,
1034 struct got_pathlist_head *wanted_refs, struct got_repository *repo);
1035
1036 static const struct got_error *
1037 fetch_progress(void *arg, const char *message, off_t packfile_size,
1038 int nobj_total, int nobj_indexed, int nobj_loose, int nobj_resolved)
1039 {
1040 const struct got_error *err = NULL;
1041 struct got_fetch_progress_arg *a = arg;
1042 char scaled_size[FMT_SCALED_STRSIZE];
1043 int p_indexed, p_resolved;
1044 int print_size = 0, print_indexed = 0, print_resolved = 0;
1045
1046 /*
1047 * In order to allow a failed clone to be resumed with 'got fetch'
1048 * we try to create configuration files as soon as possible.
1049 * Once the server has sent information about its default branch
1050 * we have all required information.
1051 */
1052 if (a->create_configs && !a->configs_created &&
1053 !TAILQ_EMPTY(a->config_info.symrefs)) {
1054 err = create_config_files(a->config_info.proto,
1055 a->config_info.host, a->config_info.port,
1056 a->config_info.remote_repo_path,
1057 a->config_info.git_url,
1058 a->config_info.fetch_all_branches,
1059 a->config_info.mirror_references,
1060 a->config_info.symrefs,
1061 a->config_info.wanted_branches,
1062 a->config_info.wanted_refs, a->repo);
1063 if (err)
1064 return err;
1065 a->configs_created = 1;
1066 }
1067
1068 if (a->verbosity < 0)
1069 return NULL;
1070
1071 if (message && message[0] != '\0') {
1072 printf("\rserver: %s", message);
1073 fflush(stdout);
1074 return NULL;
1075 }
1076
1077 if (packfile_size > 0 || nobj_indexed > 0) {
1078 if (fmt_scaled(packfile_size, scaled_size) == 0 &&
1079 (a->last_scaled_size[0] == '\0' ||
1080 strcmp(scaled_size, a->last_scaled_size)) != 0) {
1081 print_size = 1;
1082 if (strlcpy(a->last_scaled_size, scaled_size,
1083 FMT_SCALED_STRSIZE) >= FMT_SCALED_STRSIZE)
1084 return got_error(GOT_ERR_NO_SPACE);
1085 }
1086 if (nobj_indexed > 0) {
1087 p_indexed = (nobj_indexed * 100) / nobj_total;
1088 if (p_indexed != a->last_p_indexed) {
1089 a->last_p_indexed = p_indexed;
1090 print_indexed = 1;
1091 print_size = 1;
1092 }
1093 }
1094 if (nobj_resolved > 0) {
1095 p_resolved = (nobj_resolved * 100) /
1096 (nobj_total - nobj_loose);
1097 if (p_resolved != a->last_p_resolved) {
1098 a->last_p_resolved = p_resolved;
1099 print_resolved = 1;
1100 print_indexed = 1;
1101 print_size = 1;
1102 }
1103 }
1104
1105 }
1106 if (print_size || print_indexed || print_resolved)
1107 printf("\r");
1108 if (print_size)
1109 printf("%*s fetched", FMT_SCALED_STRSIZE - 2, scaled_size);
1110 if (print_indexed)
1111 printf("; indexing %d%%", p_indexed);
1112 if (print_resolved)
1113 printf("; resolving deltas %d%%", p_resolved);
1114 if (print_size || print_indexed || print_resolved)
1115 fflush(stdout);
1116
1117 return NULL;
1118 }
1119
1120 static const struct got_error *
1121 create_symref(const char *refname, struct got_reference *target_ref,
1122 int verbosity, struct got_repository *repo)
1123 {
1124 const struct got_error *err;
1125 struct got_reference *head_symref;
1126
1127 err = got_ref_alloc_symref(&head_symref, refname, target_ref);
1128 if (err)
1129 return err;
1130
1131 err = got_ref_write(head_symref, repo);
1132 if (err == NULL && verbosity > 0) {
1133 printf("Created reference %s: %s\n", GOT_REF_HEAD,
1134 got_ref_get_name(target_ref));
1135 }
1136 got_ref_close(head_symref);
1137 return err;
1138 }
1139
1140 static const struct got_error *
1141 list_remote_refs(struct got_pathlist_head *symrefs,
1142 struct got_pathlist_head *refs)
1143 {
1144 const struct got_error *err;
1145 struct got_pathlist_entry *pe;
1146
1147 TAILQ_FOREACH(pe, symrefs, entry) {
1148 const char *refname = pe->path;
1149 const char *targetref = pe->data;
1150
1151 printf("%s: %s\n", refname, targetref);
1152 }
1153
1154 TAILQ_FOREACH(pe, refs, entry) {
1155 const char *refname = pe->path;
1156 struct got_object_id *id = pe->data;
1157 char *id_str;
1158
1159 err = got_object_id_str(&id_str, id);
1160 if (err)
1161 return err;
1162 printf("%s: %s\n", refname, id_str);
1163 free(id_str);
1164 }
1165
1166 return NULL;
1167 }
1168
1169 static const struct got_error *
1170 create_ref(const char *refname, struct got_object_id *id,
1171 int verbosity, struct got_repository *repo)
1172 {
1173 const struct got_error *err = NULL;
1174 struct got_reference *ref;
1175 char *id_str;
1176
1177 err = got_object_id_str(&id_str, id);
1178 if (err)
1179 return err;
1180
1181 err = got_ref_alloc(&ref, refname, id);
1182 if (err)
1183 goto done;
1184
1185 err = got_ref_write(ref, repo);
1186 got_ref_close(ref);
1187
1188 if (err == NULL && verbosity >= 0)
1189 printf("Created reference %s: %s\n", refname, id_str);
1190 done:
1191 free(id_str);
1192 return err;
1193 }
1194
1195 static int
1196 match_wanted_ref(const char *refname, const char *wanted_ref)
1197 {
1198 if (strncmp(refname, "refs/", 5) != 0)
1199 return 0;
1200 refname += 5;
1201
1202 /*
1203 * Prevent fetching of references that won't make any
1204 * sense outside of the remote repository's context.
1205 */
1206 if (strncmp(refname, "got/", 4) == 0)
1207 return 0;
1208 if (strncmp(refname, "remotes/", 8) == 0)
1209 return 0;
1210
1211 if (strncmp(wanted_ref, "refs/", 5) == 0)
1212 wanted_ref += 5;
1213
1214 /* Allow prefix match. */
1215 if (got_path_is_child(refname, wanted_ref, strlen(wanted_ref)))
1216 return 1;
1217
1218 /* Allow exact match. */
1219 return (strcmp(refname, wanted_ref) == 0);
1220 }
1221
1222 static int
1223 is_wanted_ref(struct got_pathlist_head *wanted_refs, const char *refname)
1224 {
1225 struct got_pathlist_entry *pe;
1226
1227 TAILQ_FOREACH(pe, wanted_refs, entry) {
1228 if (match_wanted_ref(refname, pe->path))
1229 return 1;
1230 }
1231
1232 return 0;
1233 }
1234
1235 static const struct got_error *
1236 create_wanted_ref(const char *refname, struct got_object_id *id,
1237 const char *remote_repo_name, int verbosity, struct got_repository *repo)
1238 {
1239 const struct got_error *err;
1240 char *remote_refname;
1241
1242 if (strncmp("refs/", refname, 5) == 0)
1243 refname += 5;
1244
1245 if (asprintf(&remote_refname, "refs/remotes/%s/%s",
1246 remote_repo_name, refname) == -1)
1247 return got_error_from_errno("asprintf");
1248
1249 err = create_ref(remote_refname, id, verbosity, repo);
1250 free(remote_refname);
1251 return err;
1252 }
1253
1254 static const struct got_error *
1255 create_gotconfig(const char *proto, const char *host, const char *port,
1256 const char *remote_repo_path, const char *default_branch,
1257 int fetch_all_branches, struct got_pathlist_head *wanted_branches,
1258 struct got_pathlist_head *wanted_refs, int mirror_references,
1259 struct got_repository *repo)
1260 {
1261 const struct got_error *err = NULL;
1262 char *gotconfig_path = NULL;
1263 char *gotconfig = NULL;
1264 FILE *gotconfig_file = NULL;
1265 const char *branchname = NULL;
1266 char *branches = NULL, *refs = NULL;
1267 ssize_t n;
1268
1269 if (!fetch_all_branches && !TAILQ_EMPTY(wanted_branches)) {
1270 struct got_pathlist_entry *pe;
1271 TAILQ_FOREACH(pe, wanted_branches, entry) {
1272 char *s;
1273 branchname = pe->path;
1274 if (strncmp(branchname, "refs/heads/", 11) == 0)
1275 branchname += 11;
1276 if (asprintf(&s, "%s\"%s\" ",
1277 branches ? branches : "", branchname) == -1) {
1278 err = got_error_from_errno("asprintf");
1279 goto done;
1280 }
1281 free(branches);
1282 branches = s;
1283 }
1284 } else if (!fetch_all_branches && default_branch) {
1285 branchname = default_branch;
1286 if (strncmp(branchname, "refs/heads/", 11) == 0)
1287 branchname += 11;
1288 if (asprintf(&branches, "\"%s\" ", branchname) == -1) {
1289 err = got_error_from_errno("asprintf");
1290 goto done;
1291 }
1292 }
1293 if (!TAILQ_EMPTY(wanted_refs)) {
1294 struct got_pathlist_entry *pe;
1295 TAILQ_FOREACH(pe, wanted_refs, entry) {
1296 char *s;
1297 const char *refname = pe->path;
1298 if (strncmp(refname, "refs/", 5) == 0)
1299 branchname += 5;
1300 if (asprintf(&s, "%s\"%s\" ",
1301 refs ? refs : "", refname) == -1) {
1302 err = got_error_from_errno("asprintf");
1303 goto done;
1304 }
1305 free(refs);
1306 refs = s;
1307 }
1308 }
1309
1310 /* Create got.conf(5). */
1311 gotconfig_path = got_repo_get_path_gotconfig(repo);
1312 if (gotconfig_path == NULL) {
1313 err = got_error_from_errno("got_repo_get_path_gotconfig");
1314 goto done;
1315 }
1316 gotconfig_file = fopen(gotconfig_path, "ae");
1317 if (gotconfig_file == NULL) {
1318 err = got_error_from_errno2("fopen", gotconfig_path);
1319 goto done;
1320 }
1321 if (asprintf(&gotconfig,
1322 "remote \"%s\" {\n"
1323 "\tserver %s\n"
1324 "\tprotocol %s\n"
1325 "%s%s%s"
1326 "\trepository \"%s\"\n"
1327 "%s%s%s"
1328 "%s%s%s"
1329 "%s"
1330 "%s"
1331 "}\n",
1332 GOT_FETCH_DEFAULT_REMOTE_NAME, host, proto,
1333 port ? "\tport " : "", port ? port : "", port ? "\n" : "",
1334 remote_repo_path, branches ? "\tbranch { " : "",
1335 branches ? branches : "", branches ? "}\n" : "",
1336 refs ? "\treference { " : "", refs ? refs : "", refs ? "}\n" : "",
1337 mirror_references ? "\tmirror_references yes\n" : "",
1338 fetch_all_branches ? "\tfetch_all_branches yes\n" : "") == -1) {
1339 err = got_error_from_errno("asprintf");
1340 goto done;
1341 }
1342 n = fwrite(gotconfig, 1, strlen(gotconfig), gotconfig_file);
1343 if (n != strlen(gotconfig)) {
1344 err = got_ferror(gotconfig_file, GOT_ERR_IO);
1345 goto done;
1346 }
1347
1348 done:
1349 if (gotconfig_file && fclose(gotconfig_file) == EOF && err == NULL)
1350 err = got_error_from_errno2("fclose", gotconfig_path);
1351 free(gotconfig_path);
1352 free(branches);
1353 return err;
1354 }
1355
1356 static const struct got_error *
1357 create_gitconfig(const char *git_url, const char *default_branch,
1358 int fetch_all_branches, struct got_pathlist_head *wanted_branches,
1359 struct got_pathlist_head *wanted_refs, int mirror_references,
1360 struct got_repository *repo)
1361 {
1362 const struct got_error *err = NULL;
1363 char *gitconfig_path = NULL;
1364 char *gitconfig = NULL;
1365 FILE *gitconfig_file = NULL;
1366 char *branches = NULL, *refs = NULL;
1367 const char *branchname;
1368 ssize_t n;
1369
1370 /* Create a config file Git can understand. */
1371 gitconfig_path = got_repo_get_path_gitconfig(repo);
1372 if (gitconfig_path == NULL) {
1373 err = got_error_from_errno("got_repo_get_path_gitconfig");
1374 goto done;
1375 }
1376 gitconfig_file = fopen(gitconfig_path, "ae");
1377 if (gitconfig_file == NULL) {
1378 err = got_error_from_errno2("fopen", gitconfig_path);
1379 goto done;
1380 }
1381 if (fetch_all_branches) {
1382 if (mirror_references) {
1383 if (asprintf(&branches,
1384 "\tfetch = refs/heads/*:refs/heads/*\n") == -1) {
1385 err = got_error_from_errno("asprintf");
1386 goto done;
1387 }
1388 } else if (asprintf(&branches,
1389 "\tfetch = refs/heads/*:refs/remotes/%s/*\n",
1390 GOT_FETCH_DEFAULT_REMOTE_NAME) == -1) {
1391 err = got_error_from_errno("asprintf");
1392 goto done;
1393 }
1394 } else if (!TAILQ_EMPTY(wanted_branches)) {
1395 struct got_pathlist_entry *pe;
1396 TAILQ_FOREACH(pe, wanted_branches, entry) {
1397 char *s;
1398 branchname = pe->path;
1399 if (strncmp(branchname, "refs/heads/", 11) == 0)
1400 branchname += 11;
1401 if (mirror_references) {
1402 if (asprintf(&s,
1403 "%s\tfetch = refs/heads/%s:refs/heads/%s\n",
1404 branches ? branches : "",
1405 branchname, branchname) == -1) {
1406 err = got_error_from_errno("asprintf");
1407 goto done;
1408 }
1409 } else if (asprintf(&s,
1410 "%s\tfetch = refs/heads/%s:refs/remotes/%s/%s\n",
1411 branches ? branches : "",
1412 branchname, GOT_FETCH_DEFAULT_REMOTE_NAME,
1413 branchname) == -1) {
1414 err = got_error_from_errno("asprintf");
1415 goto done;
1416 }
1417 free(branches);
1418 branches = s;
1419 }
1420 } else {
1421 /*
1422 * If the server specified a default branch, use just that one.
1423 * Otherwise fall back to fetching all branches on next fetch.
1424 */
1425 if (default_branch) {
1426 branchname = default_branch;
1427 if (strncmp(branchname, "refs/heads/", 11) == 0)
1428 branchname += 11;
1429 } else
1430 branchname = "*"; /* fall back to all branches */
1431 if (mirror_references) {
1432 if (asprintf(&branches,
1433 "\tfetch = refs/heads/%s:refs/heads/%s\n",
1434 branchname, branchname) == -1) {
1435 err = got_error_from_errno("asprintf");
1436 goto done;
1437 }
1438 } else if (asprintf(&branches,
1439 "\tfetch = refs/heads/%s:refs/remotes/%s/%s\n",
1440 branchname, GOT_FETCH_DEFAULT_REMOTE_NAME,
1441 branchname) == -1) {
1442 err = got_error_from_errno("asprintf");
1443 goto done;
1444 }
1445 }
1446 if (!TAILQ_EMPTY(wanted_refs)) {
1447 struct got_pathlist_entry *pe;
1448 TAILQ_FOREACH(pe, wanted_refs, entry) {
1449 char *s;
1450 const char *refname = pe->path;
1451 if (strncmp(refname, "refs/", 5) == 0)
1452 refname += 5;
1453 if (mirror_references) {
1454 if (asprintf(&s,
1455 "%s\tfetch = refs/%s:refs/%s\n",
1456 refs ? refs : "", refname, refname) == -1) {
1457 err = got_error_from_errno("asprintf");
1458 goto done;
1459 }
1460 } else if (asprintf(&s,
1461 "%s\tfetch = refs/%s:refs/remotes/%s/%s\n",
1462 refs ? refs : "",
1463 refname, GOT_FETCH_DEFAULT_REMOTE_NAME,
1464 refname) == -1) {
1465 err = got_error_from_errno("asprintf");
1466 goto done;
1467 }
1468 free(refs);
1469 refs = s;
1470 }
1471 }
1472
1473 if (asprintf(&gitconfig,
1474 "[remote \"%s\"]\n"
1475 "\turl = %s\n"
1476 "%s"
1477 "%s"
1478 "\tfetch = refs/tags/*:refs/tags/*\n",
1479 GOT_FETCH_DEFAULT_REMOTE_NAME, git_url, branches ? branches : "",
1480 refs ? refs : "") == -1) {
1481 err = got_error_from_errno("asprintf");
1482 goto done;
1483 }
1484 n = fwrite(gitconfig, 1, strlen(gitconfig), gitconfig_file);
1485 if (n != strlen(gitconfig)) {
1486 err = got_ferror(gitconfig_file, GOT_ERR_IO);
1487 goto done;
1488 }
1489 done:
1490 if (gitconfig_file && fclose(gitconfig_file) == EOF && err == NULL)
1491 err = got_error_from_errno2("fclose", gitconfig_path);
1492 free(gitconfig_path);
1493 free(branches);
1494 return err;
1495 }
1496
1497 static const struct got_error *
1498 create_config_files(const char *proto, const char *host, const char *port,
1499 const char *remote_repo_path, const char *git_url, int fetch_all_branches,
1500 int mirror_references, struct got_pathlist_head *symrefs,
1501 struct got_pathlist_head *wanted_branches,
1502 struct got_pathlist_head *wanted_refs, struct got_repository *repo)
1503 {
1504 const struct got_error *err = NULL;
1505 const char *default_branch = NULL;
1506 struct got_pathlist_entry *pe;
1507
1508 /*
1509 * If we asked for a set of wanted branches then use the first
1510 * one of those.
1511 */
1512 if (!TAILQ_EMPTY(wanted_branches)) {
1513 pe = TAILQ_FIRST(wanted_branches);
1514 default_branch = pe->path;
1515 } else {
1516 /* First HEAD ref listed by server is the default branch. */
1517 TAILQ_FOREACH(pe, symrefs, entry) {
1518 const char *refname = pe->path;
1519 const char *target = pe->data;
1520
1521 if (strcmp(refname, GOT_REF_HEAD) != 0)
1522 continue;
1523
1524 default_branch = target;
1525 break;
1526 }
1527 }
1528
1529 /* Create got.conf(5). */
1530 err = create_gotconfig(proto, host, port, remote_repo_path,
1531 default_branch, fetch_all_branches, wanted_branches,
1532 wanted_refs, mirror_references, repo);
1533 if (err)
1534 return err;
1535
1536 /* Create a config file Git can understand. */
1537 return create_gitconfig(git_url, default_branch, fetch_all_branches,
1538 wanted_branches, wanted_refs, mirror_references, repo);
1539 }
1540
1541 static const struct got_error *
1542 cmd_clone(int argc, char *argv[])
1543 {
1544 const struct got_error *error = NULL;
1545 const char *uri, *dirname;
1546 char *proto, *host, *port, *repo_name, *server_path;
1547 char *default_destdir = NULL, *id_str = NULL;
1548 const char *repo_path;
1549 struct got_repository *repo = NULL;
1550 struct got_pathlist_head refs, symrefs, wanted_branches, wanted_refs;
1551 struct got_pathlist_entry *pe;
1552 struct got_object_id *pack_hash = NULL;
1553 int ch, fetchfd = -1, fetchstatus;
1554 pid_t fetchpid = -1;
1555 struct got_fetch_progress_arg fpa;
1556 char *git_url = NULL;
1557 int verbosity = 0, fetch_all_branches = 0, mirror_references = 0;
1558 int bflag = 0, list_refs_only = 0;
1559 int *pack_fds = NULL;
1560
1561 TAILQ_INIT(&refs);
1562 TAILQ_INIT(&symrefs);
1563 TAILQ_INIT(&wanted_branches);
1564 TAILQ_INIT(&wanted_refs);
1565
1566 while ((ch = getopt(argc, argv, "ab:lmqR:v")) != -1) {
1567 switch (ch) {
1568 case 'a':
1569 fetch_all_branches = 1;
1570 break;
1571 case 'b':
1572 error = got_pathlist_append(&wanted_branches,
1573 optarg, NULL);
1574 if (error)
1575 return error;
1576 bflag = 1;
1577 break;
1578 case 'l':
1579 list_refs_only = 1;
1580 break;
1581 case 'm':
1582 mirror_references = 1;
1583 break;
1584 case 'q':
1585 verbosity = -1;
1586 break;
1587 case 'R':
1588 error = got_pathlist_append(&wanted_refs,
1589 optarg, NULL);
1590 if (error)
1591 return error;
1592 break;
1593 case 'v':
1594 if (verbosity < 0)
1595 verbosity = 0;
1596 else if (verbosity < 3)
1597 verbosity++;
1598 break;
1599 default:
1600 usage_clone();
1601 break;
1602 }
1603 }
1604 argc -= optind;
1605 argv += optind;
1606
1607 if (fetch_all_branches && !TAILQ_EMPTY(&wanted_branches))
1608 option_conflict('a', 'b');
1609 if (list_refs_only) {
1610 if (!TAILQ_EMPTY(&wanted_branches))
1611 option_conflict('l', 'b');
1612 if (fetch_all_branches)
1613 option_conflict('l', 'a');
1614 if (mirror_references)
1615 option_conflict('l', 'm');
1616 if (!TAILQ_EMPTY(&wanted_refs))
1617 option_conflict('l', 'R');
1618 }
1619
1620 uri = argv[0];
1621
1622 if (argc == 1)
1623 dirname = NULL;
1624 else if (argc == 2)
1625 dirname = argv[1];
1626 else
1627 usage_clone();
1628
1629 error = got_dial_parse_uri(&proto, &host, &port, &server_path,
1630 &repo_name, uri);
1631 if (error)
1632 goto done;
1633
1634 if (asprintf(&git_url, "%s://%s%s%s%s%s", proto,
1635 host, port ? ":" : "", port ? port : "",
1636 server_path[0] != '/' ? "/" : "", server_path) == -1) {
1637 error = got_error_from_errno("asprintf");
1638 goto done;
1639 }
1640
1641 if (strcmp(proto, "git") == 0) {
1642 #ifndef PROFILE
1643 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
1644 "sendfd dns inet unveil", NULL) == -1)
1645 err(1, "pledge");
1646 #endif
1647 } else if (strcmp(proto, "git+ssh") == 0 ||
1648 strcmp(proto, "ssh") == 0 ||
1649 strcmp(proto, "git+http") == 0 ||
1650 strcmp(proto, "http") == 0 ||
1651 strcmp(proto, "git+https") == 0 ||
1652 strcmp(proto, "https") == 0) {
1653 #ifndef PROFILE
1654 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
1655 "sendfd unveil", NULL) == -1)
1656 err(1, "pledge");
1657 #endif
1658 } else {
1659 error = got_error_path(proto, GOT_ERR_BAD_PROTO);
1660 goto done;
1661 }
1662 if (dirname == NULL) {
1663 if (asprintf(&default_destdir, "%s.git", repo_name) == -1) {
1664 error = got_error_from_errno("asprintf");
1665 goto done;
1666 }
1667 repo_path = default_destdir;
1668 } else
1669 repo_path = dirname;
1670
1671 if (!list_refs_only) {
1672 error = got_path_mkdir(repo_path);
1673 if (error &&
1674 (!(error->code == GOT_ERR_ERRNO && errno == EISDIR) &&
1675 !(error->code == GOT_ERR_ERRNO && errno == EEXIST)))
1676 goto done;
1677 if (!got_path_dir_is_empty(repo_path)) {
1678 error = got_error_path(repo_path,
1679 GOT_ERR_DIR_NOT_EMPTY);
1680 goto done;
1681 }
1682 }
1683
1684 error = got_dial_apply_unveil(proto);
1685 if (error)
1686 goto done;
1687
1688 error = apply_unveil(repo_path, 0, NULL);
1689 if (error)
1690 goto done;
1691
1692 if (verbosity >= 0)
1693 printf("Connecting to %s\n", git_url);
1694
1695 error = got_fetch_connect(&fetchpid, &fetchfd, proto, host, port,
1696 server_path, verbosity);
1697 if (error)
1698 goto done;
1699
1700 #ifndef PROFILE
1701 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd",
1702 NULL) == -1)
1703 err(1, "pledge");
1704 #endif
1705 if (!list_refs_only) {
1706 error = got_repo_init(repo_path, NULL);
1707 if (error)
1708 goto done;
1709 error = got_repo_pack_fds_open(&pack_fds);
1710 if (error != NULL)
1711 goto done;
1712 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
1713 if (error)
1714 goto done;
1715 }
1716
1717 fpa.last_scaled_size[0] = '\0';
1718 fpa.last_p_indexed = -1;
1719 fpa.last_p_resolved = -1;
1720 fpa.verbosity = verbosity;
1721 fpa.create_configs = 1;
1722 fpa.configs_created = 0;
1723 fpa.repo = repo;
1724 fpa.config_info.symrefs = &symrefs;
1725 fpa.config_info.wanted_branches = &wanted_branches;
1726 fpa.config_info.wanted_refs = &wanted_refs;
1727 fpa.config_info.proto = proto;
1728 fpa.config_info.host = host;
1729 fpa.config_info.port = port;
1730 fpa.config_info.remote_repo_path = server_path;
1731 fpa.config_info.git_url = git_url;
1732 fpa.config_info.fetch_all_branches = fetch_all_branches;
1733 fpa.config_info.mirror_references = mirror_references;
1734 error = got_fetch_pack(&pack_hash, &refs, &symrefs,
1735 GOT_FETCH_DEFAULT_REMOTE_NAME, mirror_references,
1736 fetch_all_branches, &wanted_branches, &wanted_refs,
1737 list_refs_only, verbosity, fetchfd, repo, NULL, NULL, bflag,
1738 fetch_progress, &fpa);
1739 if (error)
1740 goto done;
1741
1742 if (list_refs_only) {
1743 error = list_remote_refs(&symrefs, &refs);
1744 goto done;
1745 }
1746
1747 if (pack_hash == NULL) {
1748 error = got_error_fmt(GOT_ERR_FETCH_FAILED, "%s",
1749 "server sent an empty pack file");
1750 goto done;
1751 }
1752 error = got_object_id_str(&id_str, pack_hash);
1753 if (error)
1754 goto done;
1755 if (verbosity >= 0)
1756 printf("\nFetched %s.pack\n", id_str);
1757 free(id_str);
1758
1759 /* Set up references provided with the pack file. */
1760 TAILQ_FOREACH(pe, &refs, entry) {
1761 const char *refname = pe->path;
1762 struct got_object_id *id = pe->data;
1763 char *remote_refname;
1764
1765 if (is_wanted_ref(&wanted_refs, refname) &&
1766 !mirror_references) {
1767 error = create_wanted_ref(refname, id,
1768 GOT_FETCH_DEFAULT_REMOTE_NAME,
1769 verbosity - 1, repo);
1770 if (error)
1771 goto done;
1772 continue;
1773 }
1774
1775 error = create_ref(refname, id, verbosity - 1, repo);
1776 if (error)
1777 goto done;
1778
1779 if (mirror_references)
1780 continue;
1781
1782 if (strncmp("refs/heads/", refname, 11) != 0)
1783 continue;
1784
1785 if (asprintf(&remote_refname,
1786 "refs/remotes/%s/%s", GOT_FETCH_DEFAULT_REMOTE_NAME,
1787 refname + 11) == -1) {
1788 error = got_error_from_errno("asprintf");
1789 goto done;
1790 }
1791 error = create_ref(remote_refname, id, verbosity - 1, repo);
1792 free(remote_refname);
1793 if (error)
1794 goto done;
1795 }
1796
1797 /* Set the HEAD reference if the server provided one. */
1798 TAILQ_FOREACH(pe, &symrefs, entry) {
1799 struct got_reference *target_ref;
1800 const char *refname = pe->path;
1801 const char *target = pe->data;
1802 char *remote_refname = NULL, *remote_target = NULL;
1803
1804 if (strcmp(refname, GOT_REF_HEAD) != 0)
1805 continue;
1806
1807 error = got_ref_open(&target_ref, repo, target, 0);
1808 if (error) {
1809 if (error->code == GOT_ERR_NOT_REF) {
1810 error = NULL;
1811 continue;
1812 }
1813 goto done;
1814 }
1815
1816 error = create_symref(refname, target_ref, verbosity, repo);
1817 got_ref_close(target_ref);
1818 if (error)
1819 goto done;
1820
1821 if (mirror_references)
1822 continue;
1823
1824 if (strncmp("refs/heads/", target, 11) != 0)
1825 continue;
1826
1827 if (asprintf(&remote_refname,
1828 "refs/remotes/%s/%s", GOT_FETCH_DEFAULT_REMOTE_NAME,
1829 refname) == -1) {
1830 error = got_error_from_errno("asprintf");
1831 goto done;
1832 }
1833 if (asprintf(&remote_target,
1834 "refs/remotes/%s/%s", GOT_FETCH_DEFAULT_REMOTE_NAME,
1835 target + 11) == -1) {
1836 error = got_error_from_errno("asprintf");
1837 free(remote_refname);
1838 goto done;
1839 }
1840 error = got_ref_open(&target_ref, repo, remote_target, 0);
1841 if (error) {
1842 free(remote_refname);
1843 free(remote_target);
1844 if (error->code == GOT_ERR_NOT_REF) {
1845 error = NULL;
1846 continue;
1847 }
1848 goto done;
1849 }
1850 error = create_symref(remote_refname, target_ref,
1851 verbosity - 1, repo);
1852 free(remote_refname);
1853 free(remote_target);
1854 got_ref_close(target_ref);
1855 if (error)
1856 goto done;
1857 }
1858 if (pe == NULL) {
1859 /*
1860 * We failed to set the HEAD reference. If we asked for
1861 * a set of wanted branches use the first of one of those
1862 * which could be fetched instead.
1863 */
1864 TAILQ_FOREACH(pe, &wanted_branches, entry) {
1865 const char *target = pe->path;
1866 struct got_reference *target_ref;
1867
1868 error = got_ref_open(&target_ref, repo, target, 0);
1869 if (error) {
1870 if (error->code == GOT_ERR_NOT_REF) {
1871 error = NULL;
1872 continue;
1873 }
1874 goto done;
1875 }
1876
1877 error = create_symref(GOT_REF_HEAD, target_ref,
1878 verbosity, repo);
1879 got_ref_close(target_ref);
1880 if (error)
1881 goto done;
1882 break;
1883 }
1884
1885 if (!fpa.configs_created && pe != NULL) {
1886 error = create_config_files(fpa.config_info.proto,
1887 fpa.config_info.host, fpa.config_info.port,
1888 fpa.config_info.remote_repo_path,
1889 fpa.config_info.git_url,
1890 fpa.config_info.fetch_all_branches,
1891 fpa.config_info.mirror_references,
1892 fpa.config_info.symrefs,
1893 fpa.config_info.wanted_branches,
1894 fpa.config_info.wanted_refs, fpa.repo);
1895 if (error)
1896 goto done;
1897 }
1898 }
1899
1900 if (verbosity >= 0)
1901 printf("Created %s repository '%s'\n",
1902 mirror_references ? "mirrored" : "cloned", repo_path);
1903 done:
1904 if (pack_fds) {
1905 const struct got_error *pack_err =
1906 got_repo_pack_fds_close(pack_fds);
1907 if (error == NULL)
1908 error = pack_err;
1909 }
1910 if (fetchpid > 0) {
1911 if (kill(fetchpid, SIGTERM) == -1)
1912 error = got_error_from_errno("kill");
1913 if (waitpid(fetchpid, &fetchstatus, 0) == -1 && error == NULL)
1914 error = got_error_from_errno("waitpid");
1915 }
1916 if (fetchfd != -1 && close(fetchfd) == -1 && error == NULL)
1917 error = got_error_from_errno("close");
1918 if (repo) {
1919 const struct got_error *close_err = got_repo_close(repo);
1920 if (error == NULL)
1921 error = close_err;
1922 }
1923 got_pathlist_free(&refs, GOT_PATHLIST_FREE_ALL);
1924 got_pathlist_free(&symrefs, GOT_PATHLIST_FREE_ALL);
1925 got_pathlist_free(&wanted_branches, GOT_PATHLIST_FREE_NONE);
1926 got_pathlist_free(&wanted_refs, GOT_PATHLIST_FREE_NONE);
1927 free(pack_hash);
1928 free(proto);
1929 free(host);
1930 free(port);
1931 free(server_path);
1932 free(repo_name);
1933 free(default_destdir);
1934 free(git_url);
1935 return error;
1936 }
1937
1938 static const struct got_error *
1939 update_ref(struct got_reference *ref, struct got_object_id *new_id,
1940 int replace_tags, int verbosity, struct got_repository *repo)
1941 {
1942 const struct got_error *err = NULL;
1943 char *new_id_str = NULL;
1944 struct got_object_id *old_id = NULL;
1945
1946 err = got_object_id_str(&new_id_str, new_id);
1947 if (err)
1948 goto done;
1949
1950 if (!replace_tags &&
1951 strncmp(got_ref_get_name(ref), "refs/tags/", 10) == 0) {
1952 err = got_ref_resolve(&old_id, repo, ref);
1953 if (err)
1954 goto done;
1955 if (got_object_id_cmp(old_id, new_id) == 0)
1956 goto done;
1957 if (verbosity >= 0) {
1958 printf("Rejecting update of existing tag %s: %s\n",
1959 got_ref_get_name(ref), new_id_str);
1960 }
1961 goto done;
1962 }
1963
1964 if (got_ref_is_symbolic(ref)) {
1965 if (verbosity >= 0) {
1966 printf("Replacing reference %s: %s\n",
1967 got_ref_get_name(ref),
1968 got_ref_get_symref_target(ref));
1969 }
1970 err = got_ref_change_symref_to_ref(ref, new_id);
1971 if (err)
1972 goto done;
1973 err = got_ref_write(ref, repo);
1974 if (err)
1975 goto done;
1976 } else {
1977 err = got_ref_resolve(&old_id, repo, ref);
1978 if (err)
1979 goto done;
1980 if (got_object_id_cmp(old_id, new_id) == 0)
1981 goto done;
1982
1983 err = got_ref_change_ref(ref, new_id);
1984 if (err)
1985 goto done;
1986 err = got_ref_write(ref, repo);
1987 if (err)
1988 goto done;
1989 }
1990
1991 if (verbosity >= 0)
1992 printf("Updated %s: %s\n", got_ref_get_name(ref),
1993 new_id_str);
1994 done:
1995 free(old_id);
1996 free(new_id_str);
1997 return err;
1998 }
1999
2000 static const struct got_error *
2001 update_symref(const char *refname, struct got_reference *target_ref,
2002 int verbosity, struct got_repository *repo)
2003 {
2004 const struct got_error *err = NULL, *unlock_err;
2005 struct got_reference *symref;
2006 int symref_is_locked = 0;
2007
2008 err = got_ref_open(&symref, repo, refname, 1);
2009 if (err) {
2010 if (err->code != GOT_ERR_NOT_REF)
2011 return err;
2012 err = got_ref_alloc_symref(&symref, refname, target_ref);
2013 if (err)
2014 goto done;
2015
2016 err = got_ref_write(symref, repo);
2017 if (err)
2018 goto done;
2019
2020 if (verbosity >= 0)
2021 printf("Created reference %s: %s\n",
2022 got_ref_get_name(symref),
2023 got_ref_get_symref_target(symref));
2024 } else {
2025 symref_is_locked = 1;
2026
2027 if (strcmp(got_ref_get_symref_target(symref),
2028 got_ref_get_name(target_ref)) == 0)
2029 goto done;
2030
2031 err = got_ref_change_symref(symref,
2032 got_ref_get_name(target_ref));
2033 if (err)
2034 goto done;
2035
2036 err = got_ref_write(symref, repo);
2037 if (err)
2038 goto done;
2039
2040 if (verbosity >= 0)
2041 printf("Updated %s: %s\n", got_ref_get_name(symref),
2042 got_ref_get_symref_target(symref));
2043
2044 }
2045 done:
2046 if (symref_is_locked) {
2047 unlock_err = got_ref_unlock(symref);
2048 if (unlock_err && err == NULL)
2049 err = unlock_err;
2050 }
2051 got_ref_close(symref);
2052 return err;
2053 }
2054
2055 __dead static void
2056 usage_fetch(void)
2057 {
2058 fprintf(stderr, "usage: %s fetch [-adlqtvX] [-b branch] "
2059 "[-R reference] [-r repository-path] [remote-repository]\n",
2060 getprogname());
2061 exit(1);
2062 }
2063
2064 static const struct got_error *
2065 delete_missing_ref(struct got_reference *ref,
2066 int verbosity, struct got_repository *repo)
2067 {
2068 const struct got_error *err = NULL;
2069 struct got_object_id *id = NULL;
2070 char *id_str = NULL;
2071
2072 if (got_ref_is_symbolic(ref)) {
2073 err = got_ref_delete(ref, repo);
2074 if (err)
2075 return err;
2076 if (verbosity >= 0) {
2077 printf("Deleted %s: %s\n",
2078 got_ref_get_name(ref),
2079 got_ref_get_symref_target(ref));
2080 }
2081 } else {
2082 err = got_ref_resolve(&id, repo, ref);
2083 if (err)
2084 return err;
2085 err = got_object_id_str(&id_str, id);
2086 if (err)
2087 goto done;
2088
2089 err = got_ref_delete(ref, repo);
2090 if (err)
2091 goto done;
2092 if (verbosity >= 0) {
2093 printf("Deleted %s: %s\n",
2094 got_ref_get_name(ref), id_str);
2095 }
2096 }
2097 done:
2098 free(id);
2099 free(id_str);
2100 return err;
2101 }
2102
2103 static const struct got_error *
2104 delete_missing_refs(struct got_pathlist_head *their_refs,
2105 struct got_pathlist_head *their_symrefs,
2106 const struct got_remote_repo *remote,
2107 int verbosity, struct got_repository *repo)
2108 {
2109 const struct got_error *err = NULL, *unlock_err;
2110 struct got_reflist_head my_refs;
2111 struct got_reflist_entry *re;
2112 struct got_pathlist_entry *pe;
2113 char *remote_namespace = NULL;
2114 char *local_refname = NULL;
2115
2116 TAILQ_INIT(&my_refs);
2117
2118 if (asprintf(&remote_namespace, "refs/remotes/%s/", remote->name)
2119 == -1)
2120 return got_error_from_errno("asprintf");
2121
2122 err = got_ref_list(&my_refs, repo, NULL, got_ref_cmp_by_name, NULL);
2123 if (err)
2124 goto done;
2125
2126 TAILQ_FOREACH(re, &my_refs, entry) {
2127 const char *refname = got_ref_get_name(re->ref);
2128 const char *their_refname;
2129
2130 if (remote->mirror_references) {
2131 their_refname = refname;
2132 } else {
2133 if (strncmp(refname, remote_namespace,
2134 strlen(remote_namespace)) == 0) {
2135 if (strcmp(refname + strlen(remote_namespace),
2136 GOT_REF_HEAD) == 0)
2137 continue;
2138 if (asprintf(&local_refname, "refs/heads/%s",
2139 refname + strlen(remote_namespace)) == -1) {
2140 err = got_error_from_errno("asprintf");
2141 goto done;
2142 }
2143 } else if (strncmp(refname, "refs/tags/", 10) != 0)
2144 continue;
2145
2146 their_refname = local_refname;
2147 }
2148
2149 TAILQ_FOREACH(pe, their_refs, entry) {
2150 if (strcmp(their_refname, pe->path) == 0)
2151 break;
2152 }
2153 if (pe != NULL)
2154 continue;
2155
2156 TAILQ_FOREACH(pe, their_symrefs, entry) {
2157 if (strcmp(their_refname, pe->path) == 0)
2158 break;
2159 }
2160 if (pe != NULL)
2161 continue;
2162
2163 err = delete_missing_ref(re->ref, verbosity, repo);
2164 if (err)
2165 break;
2166
2167 if (local_refname) {
2168 struct got_reference *ref;
2169 err = got_ref_open(&ref, repo, local_refname, 1);
2170 if (err) {
2171 if (err->code != GOT_ERR_NOT_REF)
2172 break;
2173 free(local_refname);
2174 local_refname = NULL;
2175 continue;
2176 }
2177 err = delete_missing_ref(ref, verbosity, repo);
2178 if (err)
2179 break;
2180 unlock_err = got_ref_unlock(ref);
2181 got_ref_close(ref);
2182 if (unlock_err && err == NULL) {
2183 err = unlock_err;
2184 break;
2185 }
2186
2187 free(local_refname);
2188 local_refname = NULL;
2189 }
2190 }
2191 done:
2192 got_ref_list_free(&my_refs);
2193 free(remote_namespace);
2194 free(local_refname);
2195 return err;
2196 }
2197
2198 static const struct got_error *
2199 update_wanted_ref(const char *refname, struct got_object_id *id,
2200 const char *remote_repo_name, int verbosity, struct got_repository *repo)
2201 {
2202 const struct got_error *err, *unlock_err;
2203 char *remote_refname;
2204 struct got_reference *ref;
2205
2206 if (strncmp("refs/", refname, 5) == 0)
2207 refname += 5;
2208
2209 if (asprintf(&remote_refname, "refs/remotes/%s/%s",
2210 remote_repo_name, refname) == -1)
2211 return got_error_from_errno("asprintf");
2212
2213 err = got_ref_open(&ref, repo, remote_refname, 1);
2214 if (err) {
2215 if (err->code != GOT_ERR_NOT_REF)
2216 goto done;
2217 err = create_ref(remote_refname, id, verbosity, repo);
2218 } else {
2219 err = update_ref(ref, id, 0, verbosity, repo);
2220 unlock_err = got_ref_unlock(ref);
2221 if (unlock_err && err == NULL)
2222 err = unlock_err;
2223 got_ref_close(ref);
2224 }
2225 done:
2226 free(remote_refname);
2227 return err;
2228 }
2229
2230 static const struct got_error *
2231 delete_ref(struct got_repository *repo, struct got_reference *ref)
2232 {
2233 const struct got_error *err = NULL;
2234 struct got_object_id *id = NULL;
2235 char *id_str = NULL;
2236 const char *target;
2237
2238 if (got_ref_is_symbolic(ref)) {
2239 target = got_ref_get_symref_target(ref);
2240 } else {
2241 err = got_ref_resolve(&id, repo, ref);
2242 if (err)
2243 goto done;
2244 err = got_object_id_str(&id_str, id);
2245 if (err)
2246 goto done;
2247 target = id_str;
2248 }
2249
2250 err = got_ref_delete(ref, repo);
2251 if (err)
2252 goto done;
2253
2254 printf("Deleted %s: %s\n", got_ref_get_name(ref), target);
2255 done:
2256 free(id);
2257 free(id_str);
2258 return err;
2259 }
2260
2261 static const struct got_error *
2262 delete_refs_for_remote(struct got_repository *repo, const char *remote_name)
2263 {
2264 const struct got_error *err = NULL;
2265 struct got_reflist_head refs;
2266 struct got_reflist_entry *re;
2267 char *prefix;
2268
2269 TAILQ_INIT(&refs);
2270
2271 if (asprintf(&prefix, "refs/remotes/%s", remote_name) == -1) {
2272 err = got_error_from_errno("asprintf");
2273 goto done;
2274 }
2275 err = got_ref_list(&refs, repo, prefix, got_ref_cmp_by_name, NULL);
2276 if (err)
2277 goto done;
2278
2279 TAILQ_FOREACH(re, &refs, entry)
2280 delete_ref(repo, re->ref);
2281 done:
2282 got_ref_list_free(&refs);
2283 return err;
2284 }
2285
2286 static const struct got_error *
2287 cmd_fetch(int argc, char *argv[])
2288 {
2289 const struct got_error *error = NULL, *unlock_err;
2290 char *cwd = NULL, *repo_path = NULL;
2291 const char *remote_name;
2292 char *proto = NULL, *host = NULL, *port = NULL;
2293 char *repo_name = NULL, *server_path = NULL;
2294 const struct got_remote_repo *remotes;
2295 struct got_remote_repo *remote = NULL;
2296 int nremotes;
2297 char *id_str = NULL;
2298 struct got_repository *repo = NULL;
2299 struct got_worktree *worktree = NULL;
2300 const struct got_gotconfig *repo_conf = NULL, *worktree_conf = NULL;
2301 struct got_pathlist_head refs, symrefs, wanted_branches, wanted_refs;
2302 char *head_refname = NULL;
2303 struct got_pathlist_entry *pe;
2304 struct got_reflist_head remote_refs;
2305 struct got_reflist_entry *re;
2306 struct got_object_id *pack_hash = NULL;
2307 int i, ch, fetchfd = -1, fetchstatus;
2308 pid_t fetchpid = -1;
2309 struct got_fetch_progress_arg fpa;
2310 int verbosity = 0, fetch_all_branches = 0, list_refs_only = 0;
2311 int delete_refs = 0, replace_tags = 0, delete_remote = 0;
2312 int *pack_fds = NULL, have_bflag = 0;
2313 const char *remote_head = NULL, *worktree_branch = NULL;
2314
2315 TAILQ_INIT(&refs);
2316 TAILQ_INIT(&symrefs);
2317 TAILQ_INIT(&remote_refs);
2318 TAILQ_INIT(&wanted_branches);
2319 TAILQ_INIT(&wanted_refs);
2320
2321 while ((ch = getopt(argc, argv, "ab:dlqR:r:tvX")) != -1) {
2322 switch (ch) {
2323 case 'a':
2324 fetch_all_branches = 1;
2325 break;
2326 case 'b':
2327 error = got_pathlist_append(&wanted_branches,
2328 optarg, NULL);
2329 if (error)
2330 return error;
2331 have_bflag = 1;
2332 break;
2333 case 'd':
2334 delete_refs = 1;
2335 break;
2336 case 'l':
2337 list_refs_only = 1;
2338 break;
2339 case 'q':
2340 verbosity = -1;
2341 break;
2342 case 'R':
2343 error = got_pathlist_append(&wanted_refs,
2344 optarg, NULL);
2345 if (error)
2346 return error;
2347 break;
2348 case 'r':
2349 repo_path = realpath(optarg, NULL);
2350 if (repo_path == NULL)
2351 return got_error_from_errno2("realpath",
2352 optarg);
2353 got_path_strip_trailing_slashes(repo_path);
2354 break;
2355 case 't':
2356 replace_tags = 1;
2357 break;
2358 case 'v':
2359 if (verbosity < 0)
2360 verbosity = 0;
2361 else if (verbosity < 3)
2362 verbosity++;
2363 break;
2364 case 'X':
2365 delete_remote = 1;
2366 break;
2367 default:
2368 usage_fetch();
2369 break;
2370 }
2371 }
2372 argc -= optind;
2373 argv += optind;
2374
2375 if (fetch_all_branches && !TAILQ_EMPTY(&wanted_branches))
2376 option_conflict('a', 'b');
2377 if (list_refs_only) {
2378 if (!TAILQ_EMPTY(&wanted_branches))
2379 option_conflict('l', 'b');
2380 if (fetch_all_branches)
2381 option_conflict('l', 'a');
2382 if (delete_refs)
2383 option_conflict('l', 'd');
2384 if (delete_remote)
2385 option_conflict('l', 'X');
2386 }
2387 if (delete_remote) {
2388 if (fetch_all_branches)
2389 option_conflict('X', 'a');
2390 if (!TAILQ_EMPTY(&wanted_branches))
2391 option_conflict('X', 'b');
2392 if (delete_refs)
2393 option_conflict('X', 'd');
2394 if (replace_tags)
2395 option_conflict('X', 't');
2396 if (!TAILQ_EMPTY(&wanted_refs))
2397 option_conflict('X', 'R');
2398 }
2399
2400 if (argc == 0) {
2401 if (delete_remote)
2402 errx(1, "-X option requires a remote name");
2403 remote_name = GOT_FETCH_DEFAULT_REMOTE_NAME;
2404 } else if (argc == 1)
2405 remote_name = argv[0];
2406 else
2407 usage_fetch();
2408
2409 cwd = getcwd(NULL, 0);
2410 if (cwd == NULL) {
2411 error = got_error_from_errno("getcwd");
2412 goto done;
2413 }
2414
2415 error = got_repo_pack_fds_open(&pack_fds);
2416 if (error != NULL)
2417 goto done;
2418
2419 if (repo_path == NULL) {
2420 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
2421 if (error && error->code != GOT_ERR_NOT_WORKTREE)
2422 goto done;
2423 else
2424 error = NULL;
2425 if (worktree) {
2426 repo_path =
2427 strdup(got_worktree_get_repo_path(worktree));
2428 if (repo_path == NULL)
2429 error = got_error_from_errno("strdup");
2430 if (error)
2431 goto done;
2432 } else {
2433 repo_path = strdup(cwd);
2434 if (repo_path == NULL) {
2435 error = got_error_from_errno("strdup");
2436 goto done;
2437 }
2438 }
2439 }
2440
2441 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
2442 if (error)
2443 goto done;
2444
2445 if (delete_remote) {
2446 error = delete_refs_for_remote(repo, remote_name);
2447 goto done; /* nothing else to do */
2448 }
2449
2450 if (worktree) {
2451 worktree_conf = got_worktree_get_gotconfig(worktree);
2452 if (worktree_conf) {
2453 got_gotconfig_get_remotes(&nremotes, &remotes,
2454 worktree_conf);
2455 for (i = 0; i < nremotes; i++) {
2456 if (strcmp(remotes[i].name, remote_name) == 0) {
2457 error = got_repo_remote_repo_dup(&remote,
2458 &remotes[i]);
2459 if (error)
2460 goto done;
2461 break;
2462 }
2463 }
2464 }
2465 }
2466 if (remote == NULL) {
2467 repo_conf = got_repo_get_gotconfig(repo);
2468 if (repo_conf) {
2469 got_gotconfig_get_remotes(&nremotes, &remotes,
2470 repo_conf);
2471 for (i = 0; i < nremotes; i++) {
2472 if (strcmp(remotes[i].name, remote_name) == 0) {
2473 error = got_repo_remote_repo_dup(&remote,
2474 &remotes[i]);
2475 if (error)
2476 goto done;
2477 break;
2478 }
2479 }
2480 }
2481 }
2482 if (remote == NULL) {
2483 got_repo_get_gitconfig_remotes(&nremotes, &remotes, repo);
2484 for (i = 0; i < nremotes; i++) {
2485 if (strcmp(remotes[i].name, remote_name) == 0) {
2486 error = got_repo_remote_repo_dup(&remote,
2487 &remotes[i]);
2488 if (error)
2489 goto done;
2490 break;
2491 }
2492 }
2493 }
2494 if (remote == NULL) {
2495 error = got_error_path(remote_name, GOT_ERR_NO_REMOTE);
2496 goto done;
2497 }
2498
2499 if (TAILQ_EMPTY(&wanted_branches)) {
2500 if (!fetch_all_branches)
2501 fetch_all_branches = remote->fetch_all_branches;
2502 for (i = 0; i < remote->nfetch_branches; i++) {
2503 error = got_pathlist_append(&wanted_branches,
2504 remote->fetch_branches[i], NULL);
2505 if (error)
2506 goto done;
2507 }
2508 }
2509 if (TAILQ_EMPTY(&wanted_refs)) {
2510 for (i = 0; i < remote->nfetch_refs; i++) {
2511 error = got_pathlist_append(&wanted_refs,
2512 remote->fetch_refs[i], NULL);
2513 if (error)
2514 goto done;
2515 }
2516 }
2517
2518 error = got_dial_parse_uri(&proto, &host, &port, &server_path,
2519 &repo_name, remote->fetch_url);
2520 if (error)
2521 goto done;
2522
2523 if (strcmp(proto, "git") == 0) {
2524 #ifndef PROFILE
2525 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
2526 "sendfd dns inet unveil", NULL) == -1)
2527 err(1, "pledge");
2528 #endif
2529 } else if (strcmp(proto, "git+ssh") == 0 ||
2530 strcmp(proto, "ssh") == 0 ||
2531 strcmp(proto, "git+http") == 0 ||
2532 strcmp(proto, "http") == 0 ||
2533 strcmp(proto, "git+https") == 0 ||
2534 strcmp(proto, "https") == 0) {
2535 #ifndef PROFILE
2536 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
2537 "sendfd unveil", NULL) == -1)
2538 err(1, "pledge");
2539 #endif
2540 } else {
2541 error = got_error_path(proto, GOT_ERR_BAD_PROTO);
2542 goto done;
2543 }
2544
2545 error = got_dial_apply_unveil(proto);
2546 if (error)
2547 goto done;
2548
2549 error = apply_unveil(got_repo_get_path(repo), 0, NULL);
2550 if (error)
2551 goto done;
2552
2553 if (worktree) {
2554 head_refname = strdup(got_worktree_get_head_ref_name(worktree));
2555 if (head_refname == NULL) {
2556 error = got_error_from_errno("strdup");
2557 goto done;
2558 }
2559
2560 /* Release work tree lock. */
2561 got_worktree_close(worktree);
2562 worktree = NULL;
2563 }
2564
2565 if (verbosity >= 0) {
2566 printf("Connecting to \"%s\" %s://%s%s%s%s%s\n",
2567 remote->name, proto, host,
2568 port ? ":" : "", port ? port : "",
2569 *server_path == '/' ? "" : "/", server_path);
2570 }
2571
2572 error = got_fetch_connect(&fetchpid, &fetchfd, proto, host, port,
2573 server_path, verbosity);
2574 if (error)
2575 goto done;
2576 #ifndef PROFILE
2577 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd",
2578 NULL) == -1)
2579 err(1, "pledge");
2580 #endif
2581 if (!have_bflag) {
2582 /*
2583 * If set, get this remote's HEAD ref target so
2584 * if it has changed on the server we can fetch it.
2585 */
2586 error = got_ref_list(&remote_refs, repo, "refs/remotes",
2587 got_ref_cmp_by_name, repo);
2588 if (error)
2589 goto done;
2590
2591 TAILQ_FOREACH(re, &remote_refs, entry) {
2592 const char *remote_refname, *remote_target;
2593 size_t remote_name_len;
2594
2595 if (!got_ref_is_symbolic(re->ref))
2596 continue;
2597
2598 remote_name_len = strlen(remote->name);
2599 remote_refname = got_ref_get_name(re->ref);
2600
2601 /* we only want refs/remotes/$remote->name/HEAD */
2602 if (strncmp(remote_refname + 13, remote->name,
2603 remote_name_len) != 0)
2604 continue;
2605
2606 if (strcmp(remote_refname + remote_name_len + 14,
2607 GOT_REF_HEAD) != 0)
2608 continue;
2609
2610 /*
2611 * Take the name itself because we already
2612 * only match with refs/heads/ in fetch_pack().
2613 */
2614 remote_target = got_ref_get_symref_target(re->ref);
2615 remote_head = remote_target + remote_name_len + 14;
2616 break;
2617 }
2618
2619 if (head_refname &&
2620 strncmp(head_refname, "refs/heads/", 11) == 0)
2621 worktree_branch = head_refname;
2622 }
2623
2624 fpa.last_scaled_size[0] = '\0';
2625 fpa.last_p_indexed = -1;
2626 fpa.last_p_resolved = -1;
2627 fpa.verbosity = verbosity;
2628 fpa.repo = repo;
2629 fpa.create_configs = 0;
2630 fpa.configs_created = 0;
2631 memset(&fpa.config_info, 0, sizeof(fpa.config_info));
2632
2633 error = got_fetch_pack(&pack_hash, &refs, &symrefs, remote->name,
2634 remote->mirror_references, fetch_all_branches, &wanted_branches,
2635 &wanted_refs, list_refs_only, verbosity, fetchfd, repo,
2636 worktree_branch, remote_head, have_bflag, fetch_progress, &fpa);
2637 if (error)
2638 goto done;
2639
2640 if (list_refs_only) {
2641 error = list_remote_refs(&symrefs, &refs);
2642 goto done;
2643 }
2644
2645 if (pack_hash == NULL) {
2646 if (verbosity >= 0)
2647 printf("Already up-to-date\n");
2648 } else if (verbosity >= 0) {
2649 error = got_object_id_str(&id_str, pack_hash);
2650 if (error)
2651 goto done;
2652 printf("\nFetched %s.pack\n", id_str);
2653 free(id_str);
2654 id_str = NULL;
2655 }
2656
2657 /* Update references provided with the pack file. */
2658 TAILQ_FOREACH(pe, &refs, entry) {
2659 const char *refname = pe->path;
2660 struct got_object_id *id = pe->data;
2661 struct got_reference *ref;
2662 char *remote_refname;
2663
2664 if (is_wanted_ref(&wanted_refs, refname) &&
2665 !remote->mirror_references) {
2666 error = update_wanted_ref(refname, id,
2667 remote->name, verbosity, repo);
2668 if (error)
2669 goto done;
2670 continue;
2671 }
2672
2673 if (remote->mirror_references ||
2674 strncmp("refs/tags/", refname, 10) == 0) {
2675 error = got_ref_open(&ref, repo, refname, 1);
2676 if (error) {
2677 if (error->code != GOT_ERR_NOT_REF)
2678 goto done;
2679 error = create_ref(refname, id, verbosity,
2680 repo);
2681 if (error)
2682 goto done;
2683 } else {
2684 error = update_ref(ref, id, replace_tags,
2685 verbosity, repo);
2686 unlock_err = got_ref_unlock(ref);
2687 if (unlock_err && error == NULL)
2688 error = unlock_err;
2689 got_ref_close(ref);
2690 if (error)
2691 goto done;
2692 }
2693 } else if (strncmp("refs/heads/", refname, 11) == 0) {
2694 if (asprintf(&remote_refname, "refs/remotes/%s/%s",
2695 remote_name, refname + 11) == -1) {
2696 error = got_error_from_errno("asprintf");
2697 goto done;
2698 }
2699
2700 error = got_ref_open(&ref, repo, remote_refname, 1);
2701 if (error) {
2702 if (error->code != GOT_ERR_NOT_REF)
2703 goto done;
2704 error = create_ref(remote_refname, id,
2705 verbosity, repo);
2706 if (error)
2707 goto done;
2708 } else {
2709 error = update_ref(ref, id, replace_tags,
2710 verbosity, repo);
2711 unlock_err = got_ref_unlock(ref);
2712 if (unlock_err && error == NULL)
2713 error = unlock_err;
2714 got_ref_close(ref);
2715 if (error)
2716 goto done;
2717 }
2718
2719 /* Also create a local branch if none exists yet. */
2720 error = got_ref_open(&ref, repo, refname, 1);
2721 if (error) {
2722 if (error->code != GOT_ERR_NOT_REF)
2723 goto done;
2724 error = create_ref(refname, id, verbosity,
2725 repo);
2726 if (error)
2727 goto done;
2728 } else {
2729 unlock_err = got_ref_unlock(ref);
2730 if (unlock_err && error == NULL)
2731 error = unlock_err;
2732 got_ref_close(ref);
2733 }
2734 }
2735 }
2736 if (delete_refs) {
2737 error = delete_missing_refs(&refs, &symrefs, remote,
2738 verbosity, repo);
2739 if (error)
2740 goto done;
2741 }
2742
2743 if (!remote->mirror_references) {
2744 /* Update remote HEAD reference if the server provided one. */
2745 TAILQ_FOREACH(pe, &symrefs, entry) {
2746 struct got_reference *target_ref;
2747 const char *refname = pe->path;
2748 const char *target = pe->data;
2749 char *remote_refname = NULL, *remote_target = NULL;
2750
2751 if (strcmp(refname, GOT_REF_HEAD) != 0)
2752 continue;
2753
2754 if (strncmp("refs/heads/", target, 11) != 0)
2755 continue;
2756
2757 if (asprintf(&remote_refname, "refs/remotes/%s/%s",
2758 remote->name, refname) == -1) {
2759 error = got_error_from_errno("asprintf");
2760 goto done;
2761 }
2762 if (asprintf(&remote_target, "refs/remotes/%s/%s",
2763 remote->name, target + 11) == -1) {
2764 error = got_error_from_errno("asprintf");
2765 free(remote_refname);
2766 goto done;
2767 }
2768
2769 error = got_ref_open(&target_ref, repo, remote_target,
2770 0);
2771 if (error) {
2772 free(remote_refname);
2773 free(remote_target);
2774 if (error->code == GOT_ERR_NOT_REF) {
2775 error = NULL;
2776 continue;
2777 }
2778 goto done;
2779 }
2780 error = update_symref(remote_refname, target_ref,
2781 verbosity, repo);
2782 free(remote_refname);
2783 free(remote_target);
2784 got_ref_close(target_ref);
2785 if (error)
2786 goto done;
2787 }
2788 }
2789 done:
2790 if (fetchpid > 0) {
2791 if (kill(fetchpid, SIGTERM) == -1)
2792 error = got_error_from_errno("kill");
2793 if (waitpid(fetchpid, &fetchstatus, 0) == -1 && error == NULL)
2794 error = got_error_from_errno("waitpid");
2795 }
2796 if (fetchfd != -1 && close(fetchfd) == -1 && error == NULL)
2797 error = got_error_from_errno("close");
2798 if (repo) {
2799 const struct got_error *close_err = got_repo_close(repo);
2800 if (error == NULL)
2801 error = close_err;
2802 }
2803 if (worktree)
2804 got_worktree_close(worktree);
2805 if (pack_fds) {
2806 const struct got_error *pack_err =
2807 got_repo_pack_fds_close(pack_fds);
2808 if (error == NULL)
2809 error = pack_err;
2810 }
2811 got_pathlist_free(&refs, GOT_PATHLIST_FREE_ALL);
2812 got_pathlist_free(&symrefs, GOT_PATHLIST_FREE_ALL);
2813 got_pathlist_free(&wanted_branches, GOT_PATHLIST_FREE_NONE);
2814 got_pathlist_free(&wanted_refs, GOT_PATHLIST_FREE_NONE);
2815 got_ref_list_free(&remote_refs);
2816 got_repo_free_remote_repo_data(remote);
2817 free(remote);
2818 free(head_refname);
2819 free(id_str);
2820 free(cwd);
2821 free(repo_path);
2822 free(pack_hash);
2823 free(proto);
2824 free(host);
2825 free(port);
2826 free(server_path);
2827 free(repo_name);
2828 return error;
2829 }
2830
2831
2832 __dead static void
2833 usage_checkout(void)
2834 {
2835 fprintf(stderr, "usage: %s checkout [-Eq] [-b branch] [-c commit] "
2836 "[-p path-prefix] repository-path [work-tree-path]\n",
2837 getprogname());
2838 exit(1);
2839 }
2840
2841 static void
2842 show_worktree_base_ref_warning(void)
2843 {
2844 fprintf(stderr, "%s: warning: could not create a reference "
2845 "to the work tree's base commit; the commit could be "
2846 "garbage-collected by Git or 'gotadmin cleanup'; making the "
2847 "repository writable and running 'got update' will prevent this\n",
2848 getprogname());
2849 }
2850
2851 struct got_checkout_progress_arg {
2852 const char *worktree_path;
2853 int had_base_commit_ref_error;
2854 int verbosity;
2855 };
2856
2857 static const struct got_error *
2858 checkout_progress(void *arg, unsigned char status, const char *path)
2859 {
2860 struct got_checkout_progress_arg *a = arg;
2861
2862 /* Base commit bump happens silently. */
2863 if (status == GOT_STATUS_BUMP_BASE)
2864 return NULL;
2865
2866 if (status == GOT_STATUS_BASE_REF_ERR) {
2867 a->had_base_commit_ref_error = 1;
2868 return NULL;
2869 }
2870
2871 while (path[0] == '/')
2872 path++;
2873
2874 if (a->verbosity >= 0)
2875 printf("%c %s/%s\n", status, a->worktree_path, path);
2876
2877 return NULL;
2878 }
2879
2880 static const struct got_error *
2881 check_cancelled(void *arg)
2882 {
2883 if (sigint_received || sigpipe_received)
2884 return got_error(GOT_ERR_CANCELLED);
2885 return NULL;
2886 }
2887
2888 static const struct got_error *
2889 check_linear_ancestry(struct got_object_id *commit_id,
2890 struct got_object_id *base_commit_id, int allow_forwards_in_time_only,
2891 struct got_repository *repo)
2892 {
2893 const struct got_error *err = NULL;
2894 struct got_object_id *yca_id;
2895
2896 err = got_commit_graph_find_youngest_common_ancestor(&yca_id,
2897 commit_id, base_commit_id, 1, 0, repo, check_cancelled, NULL);
2898 if (err)
2899 return err;
2900
2901 if (yca_id == NULL)
2902 return got_error(GOT_ERR_ANCESTRY);
2903
2904 /*
2905 * Require a straight line of history between the target commit
2906 * and the work tree's base commit.
2907 *
2908 * Non-linear situations such as this require a rebase:
2909 *
2910 * (commit) D F (base_commit)
2911 * \ /
2912 * C E
2913 * \ /
2914 * B (yca)
2915 * |
2916 * A
2917 *
2918 * 'got update' only handles linear cases:
2919 * Update forwards in time: A (base/yca) - B - C - D (commit)
2920 * Update backwards in time: D (base) - C - B - A (commit/yca)
2921 */
2922 if (allow_forwards_in_time_only) {
2923 if (got_object_id_cmp(base_commit_id, yca_id) != 0)
2924 return got_error(GOT_ERR_ANCESTRY);
2925 } else if (got_object_id_cmp(commit_id, yca_id) != 0 &&
2926 got_object_id_cmp(base_commit_id, yca_id) != 0)
2927 return got_error(GOT_ERR_ANCESTRY);
2928
2929 free(yca_id);
2930 return NULL;
2931 }
2932
2933 static const struct got_error *
2934 check_same_branch(struct got_object_id *commit_id,
2935 struct got_reference *head_ref, struct got_repository *repo)
2936 {
2937 const struct got_error *err = NULL;
2938 struct got_commit_graph *graph = NULL;
2939 struct got_object_id *head_commit_id = NULL;
2940
2941 err = got_ref_resolve(&head_commit_id, repo, head_ref);
2942 if (err)
2943 goto done;
2944
2945 if (got_object_id_cmp(head_commit_id, commit_id) == 0)
2946 goto done;
2947
2948 err = got_commit_graph_open(&graph, "/", 1);
2949 if (err)
2950 goto done;
2951
2952 err = got_commit_graph_bfsort(graph, head_commit_id, repo,
2953 check_cancelled, NULL);
2954 if (err)
2955 goto done;
2956
2957 for (;;) {
2958 struct got_object_id id;
2959
2960 err = got_commit_graph_iter_next(&id, graph, repo,
2961 check_cancelled, NULL);
2962 if (err) {
2963 if (err->code == GOT_ERR_ITER_COMPLETED)
2964 err = got_error(GOT_ERR_ANCESTRY);
2965 break;
2966 }
2967
2968 if (got_object_id_cmp(&id, commit_id) == 0)
2969 break;
2970 }
2971 done:
2972 if (graph)
2973 got_commit_graph_close(graph);
2974 free(head_commit_id);
2975 return err;
2976 }
2977
2978 static const struct got_error *
2979 checkout_ancestry_error(struct got_reference *ref, const char *commit_id_str)
2980 {
2981 static char msg[512];
2982 const char *branch_name;
2983
2984 if (got_ref_is_symbolic(ref))
2985 branch_name = got_ref_get_symref_target(ref);
2986 else
2987 branch_name = got_ref_get_name(ref);
2988
2989 if (strncmp("refs/heads/", branch_name, 11) == 0)
2990 branch_name += 11;
2991
2992 snprintf(msg, sizeof(msg),
2993 "target commit is not contained in branch '%s'; "
2994 "the branch to use must be specified with -b; "
2995 "if necessary a new branch can be created for "
2996 "this commit with 'got branch -c %s BRANCH_NAME'",
2997 branch_name, commit_id_str);
2998
2999 return got_error_msg(GOT_ERR_ANCESTRY, msg);
3000 }
3001
3002 static const struct got_error *
3003 cmd_checkout(int argc, char *argv[])
3004 {
3005 const struct got_error *close_err, *error = NULL;
3006 struct got_repository *repo = NULL;
3007 struct got_reference *head_ref = NULL, *ref = NULL;
3008 struct got_worktree *worktree = NULL;
3009 char *repo_path = NULL;
3010 char *worktree_path = NULL;
3011 const char *path_prefix = "";
3012 const char *branch_name = GOT_REF_HEAD, *refname = NULL;
3013 char *commit_id_str = NULL, *keyword_idstr = NULL;
3014 struct got_object_id *commit_id = NULL;
3015 char *cwd = NULL;
3016 int ch, same_path_prefix, allow_nonempty = 0, verbosity = 0;
3017 struct got_pathlist_head paths;
3018 struct got_checkout_progress_arg cpa;
3019 int *pack_fds = NULL;
3020
3021 TAILQ_INIT(&paths);
3022
3023 #ifndef PROFILE
3024 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
3025 "unveil", NULL) == -1)
3026 err(1, "pledge");
3027 #endif
3028
3029 while ((ch = getopt(argc, argv, "b:c:Ep:q")) != -1) {
3030 switch (ch) {
3031 case 'b':
3032 branch_name = optarg;
3033 break;
3034 case 'c':
3035 commit_id_str = strdup(optarg);
3036 if (commit_id_str == NULL)
3037 return got_error_from_errno("strdup");
3038 break;
3039 case 'E':
3040 allow_nonempty = 1;
3041 break;
3042 case 'p':
3043 path_prefix = optarg;
3044 break;
3045 case 'q':
3046 verbosity = -1;
3047 break;
3048 default:
3049 usage_checkout();
3050 /* NOTREACHED */
3051 }
3052 }
3053
3054 argc -= optind;
3055 argv += optind;
3056
3057 if (argc == 1) {
3058 char *base, *dotgit;
3059 const char *path;
3060 repo_path = realpath(argv[0], NULL);
3061 if (repo_path == NULL)
3062 return got_error_from_errno2("realpath", argv[0]);
3063 cwd = getcwd(NULL, 0);
3064 if (cwd == NULL) {
3065 error = got_error_from_errno("getcwd");
3066 goto done;
3067 }
3068 if (path_prefix[0])
3069 path = path_prefix;
3070 else
3071 path = repo_path;
3072 error = got_path_basename(&base, path);
3073 if (error)
3074 goto done;
3075 dotgit = strstr(base, ".git");
3076 if (dotgit)
3077 *dotgit = '\0';
3078 if (asprintf(&worktree_path, "%s/%s", cwd, base) == -1) {
3079 error = got_error_from_errno("asprintf");
3080 free(base);
3081 goto done;
3082 }
3083 free(base);
3084 } else if (argc == 2) {
3085 repo_path = realpath(argv[0], NULL);
3086 if (repo_path == NULL) {
3087 error = got_error_from_errno2("realpath", argv[0]);
3088 goto done;
3089 }
3090 worktree_path = realpath(argv[1], NULL);
3091 if (worktree_path == NULL) {
3092 if (errno != ENOENT) {
3093 error = got_error_from_errno2("realpath",
3094 argv[1]);
3095 goto done;
3096 }
3097 worktree_path = strdup(argv[1]);
3098 if (worktree_path == NULL) {
3099 error = got_error_from_errno("strdup");
3100 goto done;
3101 }
3102 }
3103 } else
3104 usage_checkout();
3105
3106 got_path_strip_trailing_slashes(repo_path);
3107 got_path_strip_trailing_slashes(worktree_path);
3108
3109 if (got_path_is_child(worktree_path, repo_path, strlen(repo_path)) ||
3110 got_path_is_child(repo_path, worktree_path,
3111 strlen(worktree_path))) {
3112 error = got_error_fmt(GOT_ERR_BAD_PATH,
3113 "work tree and repository paths may not overlap: %s",
3114 worktree_path);
3115 goto done;
3116 }
3117
3118 error = got_repo_pack_fds_open(&pack_fds);
3119 if (error != NULL)
3120 goto done;
3121
3122 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
3123 if (error != NULL)
3124 goto done;
3125
3126 /* Pre-create work tree path for unveil(2) */
3127 error = got_path_mkdir(worktree_path);
3128 if (error) {
3129 if (!(error->code == GOT_ERR_ERRNO && errno == EISDIR) &&
3130 !(error->code == GOT_ERR_ERRNO && errno == EEXIST))
3131 goto done;
3132 if (!allow_nonempty &&
3133 !got_path_dir_is_empty(worktree_path)) {
3134 error = got_error_path(worktree_path,
3135 GOT_ERR_DIR_NOT_EMPTY);
3136 goto done;
3137 }
3138 }
3139
3140 error = apply_unveil(got_repo_get_path(repo), 0, worktree_path);
3141 if (error)
3142 goto done;
3143
3144 error = got_ref_open(&head_ref, repo, branch_name, 0);
3145 if (error != NULL)
3146 goto done;
3147
3148 error = got_worktree_init(worktree_path, head_ref, path_prefix,
3149 GOT_WORKTREE_GOT_DIR, repo);
3150 if (error != NULL && !(error->code == GOT_ERR_ERRNO && errno == EEXIST))
3151 goto done;
3152
3153 error = got_worktree_open(&worktree, worktree_path,
3154 GOT_WORKTREE_GOT_DIR);
3155 if (error != NULL)
3156 goto done;
3157
3158 error = got_worktree_match_path_prefix(&same_path_prefix, worktree,
3159 path_prefix);
3160 if (error != NULL)
3161 goto done;
3162 if (!same_path_prefix) {
3163 error = got_error(GOT_ERR_PATH_PREFIX);
3164 goto done;
3165 }
3166
3167 if (commit_id_str) {
3168 struct got_reflist_head refs;
3169 TAILQ_INIT(&refs);
3170 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
3171 NULL);
3172 if (error)
3173 goto done;
3174
3175 error = got_keyword_to_idstr(&keyword_idstr, commit_id_str,
3176 repo, worktree);
3177 if (error != NULL)
3178 goto done;
3179 if (keyword_idstr != NULL) {
3180 free(commit_id_str);
3181 commit_id_str = keyword_idstr;
3182 }
3183
3184 error = got_repo_match_object_id(&commit_id, NULL,
3185 commit_id_str, GOT_OBJ_TYPE_COMMIT, &refs, repo);
3186 got_ref_list_free(&refs);
3187 if (error)
3188 goto done;
3189 error = check_linear_ancestry(commit_id,
3190 got_worktree_get_base_commit_id(worktree), 0, repo);
3191 if (error != NULL) {
3192 if (error->code == GOT_ERR_ANCESTRY) {
3193 error = checkout_ancestry_error(
3194 head_ref, commit_id_str);
3195 }
3196 goto done;
3197 }
3198 error = check_same_branch(commit_id, head_ref, repo);
3199 if (error) {
3200 if (error->code == GOT_ERR_ANCESTRY) {
3201 error = checkout_ancestry_error(
3202 head_ref, commit_id_str);
3203 }
3204 goto done;
3205 }
3206 error = got_worktree_set_base_commit_id(worktree, repo,
3207 commit_id);
3208 if (error)
3209 goto done;
3210 /* Expand potentially abbreviated commit ID string. */
3211 free(commit_id_str);
3212 error = got_object_id_str(&commit_id_str, commit_id);
3213 if (error)
3214 goto done;
3215 } else {
3216 commit_id = got_object_id_dup(
3217 got_worktree_get_base_commit_id(worktree));
3218 if (commit_id == NULL) {
3219 error = got_error_from_errno("got_object_id_dup");
3220 goto done;
3221 }
3222 error = got_object_id_str(&commit_id_str, commit_id);
3223 if (error)
3224 goto done;
3225 }
3226
3227 error = got_pathlist_append(&paths, "", NULL);
3228 if (error)
3229 goto done;
3230 cpa.worktree_path = worktree_path;
3231 cpa.had_base_commit_ref_error = 0;
3232 cpa.verbosity = verbosity;
3233 error = got_worktree_checkout_files(worktree, &paths, repo,
3234 checkout_progress, &cpa, check_cancelled, NULL);
3235 if (error != NULL)
3236 goto done;
3237
3238 if (got_ref_is_symbolic(head_ref)) {
3239 error = got_ref_resolve_symbolic(&ref, repo, head_ref);
3240 if (error)
3241 goto done;
3242 refname = got_ref_get_name(ref);
3243 } else
3244 refname = got_ref_get_name(head_ref);
3245 printf("Checked out %s: %s\n", refname, commit_id_str);
3246 printf("Now shut up and hack\n");
3247 if (cpa.had_base_commit_ref_error)
3248 show_worktree_base_ref_warning();
3249 done:
3250 if (pack_fds) {
3251 const struct got_error *pack_err =
3252 got_repo_pack_fds_close(pack_fds);
3253 if (error == NULL)
3254 error = pack_err;
3255 }
3256 if (head_ref)
3257 got_ref_close(head_ref);
3258 if (ref)
3259 got_ref_close(ref);
3260 if (repo) {
3261 close_err = got_repo_close(repo);
3262 if (error == NULL)
3263 error = close_err;
3264 }
3265 if (worktree != NULL) {
3266 close_err = got_worktree_close(worktree);
3267 if (error == NULL)
3268 error = close_err;
3269 }
3270 got_pathlist_free(&paths, GOT_PATHLIST_FREE_NONE);
3271 free(commit_id_str);
3272 free(commit_id);
3273 free(repo_path);
3274 free(worktree_path);
3275 free(cwd);
3276 return error;
3277 }
3278
3279 struct got_update_progress_arg {
3280 int did_something;
3281 int conflicts;
3282 int obstructed;
3283 int not_updated;
3284 int missing;
3285 int not_deleted;
3286 int unversioned;
3287 int verbosity;
3288 };
3289
3290 static void
3291 print_update_progress_stats(struct got_update_progress_arg *upa)
3292 {
3293 if (!upa->did_something)
3294 return;
3295
3296 if (upa->conflicts > 0)
3297 printf("Files with new merge conflicts: %d\n", upa->conflicts);
3298 if (upa->obstructed > 0)
3299 printf("File paths obstructed by a non-regular file: %d\n",
3300 upa->obstructed);
3301 if (upa->not_updated > 0)
3302 printf("Files not updated because of existing merge "
3303 "conflicts: %d\n", upa->not_updated);
3304 }
3305
3306 /*
3307 * The meaning of some status codes differs between merge-style operations and
3308 * update operations. For example, the ! status code means "file was missing"
3309 * if changes were merged into the work tree, and "missing file was restored"
3310 * if the work tree was updated. This function should be used by any operation
3311 * which merges changes into the work tree without updating the work tree.
3312 */
3313 static void
3314 print_merge_progress_stats(struct got_update_progress_arg *upa)
3315 {
3316 if (!upa->did_something)
3317 return;
3318
3319 if (upa->conflicts > 0)
3320 printf("Files with new merge conflicts: %d\n", upa->conflicts);
3321 if (upa->obstructed > 0)
3322 printf("File paths obstructed by a non-regular file: %d\n",
3323 upa->obstructed);
3324 if (upa->missing > 0)
3325 printf("Files which had incoming changes but could not be "
3326 "found in the work tree: %d\n", upa->missing);
3327 if (upa->not_deleted > 0)
3328 printf("Files not deleted due to differences in deleted "
3329 "content: %d\n", upa->not_deleted);
3330 if (upa->unversioned > 0)
3331 printf("Files not merged because an unversioned file was "
3332 "found in the work tree: %d\n", upa->unversioned);
3333 }
3334
3335 __dead static void
3336 usage_update(void)
3337 {
3338 fprintf(stderr, "usage: %s update [-q] [-b branch] [-c commit] "
3339 "[path ...]\n", getprogname());
3340 exit(1);
3341 }
3342
3343 static const struct got_error *
3344 update_progress(void *arg, unsigned char status, const char *path)
3345 {
3346 struct got_update_progress_arg *upa = arg;
3347
3348 if (status == GOT_STATUS_EXISTS ||
3349 status == GOT_STATUS_BASE_REF_ERR)
3350 return NULL;
3351
3352 upa->did_something = 1;
3353
3354 /* Base commit bump happens silently. */
3355 if (status == GOT_STATUS_BUMP_BASE)
3356 return NULL;
3357
3358 if (status == GOT_STATUS_CONFLICT)
3359 upa->conflicts++;
3360 if (status == GOT_STATUS_OBSTRUCTED)
3361 upa->obstructed++;
3362 if (status == GOT_STATUS_CANNOT_UPDATE)
3363 upa->not_updated++;
3364 if (status == GOT_STATUS_MISSING)
3365 upa->missing++;
3366 if (status == GOT_STATUS_CANNOT_DELETE)
3367 upa->not_deleted++;
3368 if (status == GOT_STATUS_UNVERSIONED)
3369 upa->unversioned++;
3370
3371 while (path[0] == '/')
3372 path++;
3373 if (upa->verbosity >= 0)
3374 printf("%c %s\n", status, path);
3375
3376 return NULL;
3377 }
3378
3379 static const struct got_error *
3380 switch_head_ref(struct got_reference *head_ref,
3381 struct got_object_id *commit_id, struct got_worktree *worktree,
3382 struct got_repository *repo)
3383 {
3384 const struct got_error *err = NULL;
3385 char *base_id_str;
3386 int ref_has_moved = 0;
3387
3388 /* Trivial case: switching between two different references. */
3389 if (strcmp(got_ref_get_name(head_ref),
3390 got_worktree_get_head_ref_name(worktree)) != 0) {
3391 printf("Switching work tree from %s to %s\n",
3392 got_worktree_get_head_ref_name(worktree),
3393 got_ref_get_name(head_ref));
3394 return got_worktree_set_head_ref(worktree, head_ref);
3395 }
3396
3397 err = check_linear_ancestry(commit_id,
3398 got_worktree_get_base_commit_id(worktree), 0, repo);
3399 if (err) {
3400 if (err->code != GOT_ERR_ANCESTRY)
3401 return err;
3402 ref_has_moved = 1;
3403 }
3404 if (!ref_has_moved)
3405 return NULL;
3406
3407 /* Switching to a rebased branch with the same reference name. */
3408 err = got_object_id_str(&base_id_str,
3409 got_worktree_get_base_commit_id(worktree));
3410 if (err)
3411 return err;
3412 printf("Reference %s now points at a different branch\n",
3413 got_worktree_get_head_ref_name(worktree));
3414 printf("Switching work tree from %s to %s\n", base_id_str,
3415 got_worktree_get_head_ref_name(worktree));
3416 return NULL;
3417 }
3418
3419 static const struct got_error *
3420 check_rebase_or_histedit_in_progress(struct got_worktree *worktree)
3421 {
3422 const struct got_error *err;
3423 int in_progress;
3424
3425 err = got_worktree_rebase_in_progress(&in_progress, worktree);
3426 if (err)
3427 return err;
3428 if (in_progress)
3429 return got_error(GOT_ERR_REBASING);
3430
3431 err = got_worktree_histedit_in_progress(&in_progress, worktree);
3432 if (err)
3433 return err;
3434 if (in_progress)
3435 return got_error(GOT_ERR_HISTEDIT_BUSY);
3436
3437 return NULL;
3438 }
3439
3440 static const struct got_error *
3441 check_merge_in_progress(struct got_worktree *worktree,
3442 struct got_repository *repo)
3443 {
3444 const struct got_error *err;
3445 int in_progress;
3446
3447 err = got_worktree_merge_in_progress(&in_progress, worktree, repo);
3448 if (err)
3449 return err;
3450 if (in_progress)
3451 return got_error(GOT_ERR_MERGE_BUSY);
3452
3453 return NULL;
3454 }
3455
3456 static const struct got_error *
3457 get_worktree_paths_from_argv(struct got_pathlist_head *paths, int argc,
3458 char *argv[], struct got_worktree *worktree)
3459 {
3460 const struct got_error *err = NULL;
3461 char *path;
3462 struct got_pathlist_entry *new;
3463 int i;
3464
3465 if (argc == 0) {
3466 path = strdup("");
3467 if (path == NULL)
3468 return got_error_from_errno("strdup");
3469 return got_pathlist_append(paths, path, NULL);
3470 }
3471
3472 for (i = 0; i < argc; i++) {
3473 err = got_worktree_resolve_path(&path, worktree, argv[i]);
3474 if (err)
3475 break;
3476 err = got_pathlist_insert(&new, paths, path, NULL);
3477 if (err || new == NULL /* duplicate */) {
3478 free(path);
3479 if (err)
3480 break;
3481 }
3482 }
3483
3484 return err;
3485 }
3486
3487 static const struct got_error *
3488 wrap_not_worktree_error(const struct got_error *orig_err,
3489 const char *cmdname, const char *path)
3490 {
3491 const struct got_error *err;
3492 struct got_repository *repo;
3493 static char msg[512];
3494 int *pack_fds = NULL;
3495
3496 err = got_repo_pack_fds_open(&pack_fds);
3497 if (err)
3498 return err;
3499
3500 err = got_repo_open(&repo, path, NULL, pack_fds);
3501 if (err)
3502 return orig_err;
3503
3504 snprintf(msg, sizeof(msg),
3505 "'got %s' needs a work tree in addition to a git repository\n"
3506 "Work trees can be checked out from this Git repository with "
3507 "'got checkout'.\n"
3508 "The got(1) manual page contains more information.", cmdname);
3509 err = got_error_msg(GOT_ERR_NOT_WORKTREE, msg);
3510 if (repo) {
3511 const struct got_error *close_err = got_repo_close(repo);
3512 if (err == NULL)
3513 err = close_err;
3514 }
3515 if (pack_fds) {
3516 const struct got_error *pack_err =
3517 got_repo_pack_fds_close(pack_fds);
3518 if (err == NULL)
3519 err = pack_err;
3520 }
3521 return err;
3522 }
3523
3524 static const struct got_error *
3525 cmd_update(int argc, char *argv[])
3526 {
3527 const struct got_error *close_err, *error = NULL;
3528 struct got_repository *repo = NULL;
3529 struct got_worktree *worktree = NULL;
3530 char *worktree_path = NULL;
3531 struct got_object_id *commit_id = NULL;
3532 char *commit_id_str = NULL;
3533 const char *branch_name = NULL;
3534 struct got_reference *head_ref = NULL;
3535 struct got_pathlist_head paths;
3536 struct got_pathlist_entry *pe;
3537 int ch, verbosity = 0;
3538 struct got_update_progress_arg upa;
3539 int *pack_fds = NULL;
3540
3541 TAILQ_INIT(&paths);
3542
3543 #ifndef PROFILE
3544 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
3545 "unveil", NULL) == -1)
3546 err(1, "pledge");
3547 #endif
3548
3549 while ((ch = getopt(argc, argv, "b:c:q")) != -1) {
3550 switch (ch) {
3551 case 'b':
3552 branch_name = optarg;
3553 break;
3554 case 'c':
3555 commit_id_str = strdup(optarg);
3556 if (commit_id_str == NULL)
3557 return got_error_from_errno("strdup");
3558 break;
3559 case 'q':
3560 verbosity = -1;
3561 break;
3562 default:
3563 usage_update();
3564 /* NOTREACHED */
3565 }
3566 }
3567
3568 argc -= optind;
3569 argv += optind;
3570
3571 worktree_path = getcwd(NULL, 0);
3572 if (worktree_path == NULL) {
3573 error = got_error_from_errno("getcwd");
3574 goto done;
3575 }
3576
3577 error = got_repo_pack_fds_open(&pack_fds);
3578 if (error != NULL)
3579 goto done;
3580
3581 error = got_worktree_open(&worktree, worktree_path,
3582 GOT_WORKTREE_GOT_DIR);
3583 if (error) {
3584 if (error->code == GOT_ERR_NOT_WORKTREE)
3585 error = wrap_not_worktree_error(error, "update",
3586 worktree_path);
3587 goto done;
3588 }
3589
3590 error = check_rebase_or_histedit_in_progress(worktree);
3591 if (error)
3592 goto done;
3593
3594 error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
3595 NULL, pack_fds);
3596 if (error != NULL)
3597 goto done;
3598
3599 error = apply_unveil(got_repo_get_path(repo), 0,
3600 got_worktree_get_root_path(worktree));
3601 if (error)
3602 goto done;
3603
3604 error = check_merge_in_progress(worktree, repo);
3605 if (error)
3606 goto done;
3607
3608 error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
3609 if (error)
3610 goto done;
3611
3612 error = got_ref_open(&head_ref, repo, branch_name ? branch_name :
3613 got_worktree_get_head_ref_name(worktree), 0);
3614 if (error != NULL)
3615 goto done;
3616 if (commit_id_str == NULL) {
3617 error = got_ref_resolve(&commit_id, repo, head_ref);
3618 if (error != NULL)
3619 goto done;
3620 error = got_object_id_str(&commit_id_str, commit_id);
3621 if (error != NULL)
3622 goto done;
3623 } else {
3624 struct got_reflist_head refs;
3625 char *keyword_idstr = NULL;
3626
3627 TAILQ_INIT(&refs);
3628
3629 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
3630 NULL);
3631 if (error)
3632 goto done;
3633
3634 error = got_keyword_to_idstr(&keyword_idstr, commit_id_str,
3635 repo, worktree);
3636 if (error != NULL)
3637 goto done;
3638 if (keyword_idstr != NULL) {
3639 free(commit_id_str);
3640 commit_id_str = keyword_idstr;
3641 }
3642
3643 error = got_repo_match_object_id(&commit_id, NULL,
3644 commit_id_str, GOT_OBJ_TYPE_COMMIT, &refs, repo);
3645 got_ref_list_free(&refs);
3646 free(commit_id_str);
3647 commit_id_str = NULL;
3648 if (error)
3649 goto done;
3650 error = got_object_id_str(&commit_id_str, commit_id);
3651 if (error)
3652 goto done;
3653 }
3654
3655 if (branch_name) {
3656 struct got_object_id *head_commit_id;
3657 TAILQ_FOREACH(pe, &paths, entry) {
3658 if (pe->path_len == 0)
3659 continue;
3660 error = got_error_msg(GOT_ERR_BAD_PATH,
3661 "switching between branches requires that "
3662 "the entire work tree gets updated");
3663 goto done;
3664 }
3665 error = got_ref_resolve(&head_commit_id, repo, head_ref);
3666 if (error)
3667 goto done;
3668 error = check_linear_ancestry(commit_id, head_commit_id, 0,
3669 repo);
3670 free(head_commit_id);
3671 if (error != NULL)
3672 goto done;
3673 error = check_same_branch(commit_id, head_ref, repo);
3674 if (error)
3675 goto done;
3676 error = switch_head_ref(head_ref, commit_id, worktree, repo);
3677 if (error)
3678 goto done;
3679 } else {
3680 error = check_linear_ancestry(commit_id,
3681 got_worktree_get_base_commit_id(worktree), 0, repo);
3682 if (error != NULL) {
3683 if (error->code == GOT_ERR_ANCESTRY)
3684 error = got_error(GOT_ERR_BRANCH_MOVED);
3685 goto done;
3686 }
3687 error = check_same_branch(commit_id, head_ref, repo);
3688 if (error)
3689 goto done;
3690 }
3691
3692 if (got_object_id_cmp(got_worktree_get_base_commit_id(worktree),
3693 commit_id) != 0) {
3694 error = got_worktree_set_base_commit_id(worktree, repo,
3695 commit_id);
3696 if (error)
3697 goto done;
3698 }
3699
3700 memset(&upa, 0, sizeof(upa));
3701 upa.verbosity = verbosity;
3702 error = got_worktree_checkout_files(worktree, &paths, repo,
3703 update_progress, &upa, check_cancelled, NULL);
3704 if (error != NULL)
3705 goto done;
3706
3707 if (upa.did_something) {
3708 printf("Updated to %s: %s\n",
3709 got_worktree_get_head_ref_name(worktree), commit_id_str);
3710 } else
3711 printf("Already up-to-date\n");
3712
3713 print_update_progress_stats(&upa);
3714 done:
3715 if (pack_fds) {
3716 const struct got_error *pack_err =
3717 got_repo_pack_fds_close(pack_fds);
3718 if (error == NULL)
3719 error = pack_err;
3720 }
3721 if (repo) {
3722 close_err = got_repo_close(repo);
3723 if (error == NULL)
3724 error = close_err;
3725 }
3726 if (worktree != NULL) {
3727 close_err = got_worktree_close(worktree);
3728 if (error == NULL)
3729 error = close_err;
3730 }
3731 if (head_ref != NULL)
3732 got_ref_close(head_ref);
3733 free(worktree_path);
3734 got_pathlist_free(&paths, GOT_PATHLIST_FREE_PATH);
3735 free(commit_id);
3736 free(commit_id_str);
3737 return error;
3738 }
3739
3740 static const struct got_error *
3741 diff_blobs(struct got_object_id *blob_id1, struct got_object_id *blob_id2,
3742 const char *path, int diff_context, int ignore_whitespace,
3743 int force_text_diff, struct got_diffstat_cb_arg *dsa,
3744 struct got_repository *repo, FILE *outfile)
3745 {
3746 const struct got_error *err = NULL;
3747 struct got_blob_object *blob1 = NULL, *blob2 = NULL;
3748 FILE *f1 = NULL, *f2 = NULL;
3749 int fd1 = -1, fd2 = -1;
3750
3751 fd1 = got_opentempfd();
3752 if (fd1 == -1)
3753 return got_error_from_errno("got_opentempfd");
3754 fd2 = got_opentempfd();
3755 if (fd2 == -1) {
3756 err = got_error_from_errno("got_opentempfd");
3757 goto done;
3758 }
3759
3760 if (blob_id1) {
3761 err = got_object_open_as_blob(&blob1, repo, blob_id1, 8192,
3762 fd1);
3763 if (err)
3764 goto done;
3765 }
3766
3767 err = got_object_open_as_blob(&blob2, repo, blob_id2, 8192, fd2);
3768 if (err)
3769 goto done;
3770
3771 f1 = got_opentemp();
3772 if (f1 == NULL) {
3773 err = got_error_from_errno("got_opentemp");
3774 goto done;
3775 }
3776 f2 = got_opentemp();
3777 if (f2 == NULL) {
3778 err = got_error_from_errno("got_opentemp");
3779 goto done;
3780 }
3781
3782 while (path[0] == '/')
3783 path++;
3784 err = got_diff_blob(NULL, NULL, blob1, blob2, f1, f2, path, path,
3785 GOT_DIFF_ALGORITHM_PATIENCE, diff_context, ignore_whitespace,
3786 force_text_diff, dsa, outfile);
3787 done:
3788 if (fd1 != -1 && close(fd1) == -1 && err == NULL)
3789 err = got_error_from_errno("close");
3790 if (blob1)
3791 got_object_blob_close(blob1);
3792 if (fd2 != -1 && close(fd2) == -1 && err == NULL)
3793 err = got_error_from_errno("close");
3794 if (blob2)
3795 got_object_blob_close(blob2);
3796 if (f1 && fclose(f1) == EOF && err == NULL)
3797 err = got_error_from_errno("fclose");
3798 if (f2 && fclose(f2) == EOF && err == NULL)
3799 err = got_error_from_errno("fclose");
3800 return err;
3801 }
3802
3803 static const struct got_error *
3804 diff_trees(struct got_object_id *tree_id1, struct got_object_id *tree_id2,
3805 const char *path, int diff_context, int ignore_whitespace,
3806 int force_text_diff, struct got_diffstat_cb_arg *dsa,
3807 struct got_repository *repo, FILE *outfile)
3808 {
3809 const struct got_error *err = NULL;
3810 struct got_tree_object *tree1 = NULL, *tree2 = NULL;
3811 struct got_diff_blob_output_unidiff_arg arg;
3812 FILE *f1 = NULL, *f2 = NULL;
3813 int fd1 = -1, fd2 = -1;
3814
3815 if (tree_id1) {
3816 err = got_object_open_as_tree(&tree1, repo, tree_id1);
3817 if (err)
3818 goto done;
3819 fd1 = got_opentempfd();
3820 if (fd1 == -1) {
3821 err = got_error_from_errno("got_opentempfd");
3822 goto done;
3823 }
3824 }
3825
3826 err = got_object_open_as_tree(&tree2, repo, tree_id2);
3827 if (err)
3828 goto done;
3829
3830 f1 = got_opentemp();
3831 if (f1 == NULL) {
3832 err = got_error_from_errno("got_opentemp");
3833 goto done;
3834 }
3835
3836 f2 = got_opentemp();
3837 if (f2 == NULL) {
3838 err = got_error_from_errno("got_opentemp");
3839 goto done;
3840 }
3841 fd2 = got_opentempfd();
3842 if (fd2 == -1) {
3843 err = got_error_from_errno("got_opentempfd");
3844 goto done;
3845 }
3846 arg.diff_context = diff_context;
3847 arg.ignore_whitespace = ignore_whitespace;
3848 arg.force_text_diff = force_text_diff;
3849 arg.diffstat = dsa;
3850 arg.diff_algo = GOT_DIFF_ALGORITHM_PATIENCE;
3851 arg.outfile = outfile;
3852 arg.lines = NULL;
3853 arg.nlines = 0;
3854 while (path[0] == '/')
3855 path++;
3856 err = got_diff_tree(tree1, tree2, f1, f2, fd1, fd2, path, path, repo,
3857 got_diff_blob_output_unidiff, &arg, 1);
3858 done:
3859 if (tree1)
3860 got_object_tree_close(tree1);
3861 if (tree2)
3862 got_object_tree_close(tree2);
3863 if (f1 && fclose(f1) == EOF && err == NULL)
3864 err = got_error_from_errno("fclose");
3865 if (f2 && fclose(f2) == EOF && err == NULL)
3866 err = got_error_from_errno("fclose");
3867 if (fd1 != -1 && close(fd1) == -1 && err == NULL)
3868 err = got_error_from_errno("close");
3869 if (fd2 != -1 && close(fd2) == -1 && err == NULL)
3870 err = got_error_from_errno("close");
3871 return err;
3872 }
3873
3874 static const struct got_error *
3875 get_changed_paths(struct got_pathlist_head *paths,
3876 struct got_commit_object *commit, struct got_repository *repo,
3877 struct got_diffstat_cb_arg *dsa)
3878 {
3879 const struct got_error *err = NULL;
3880 struct got_object_id *tree_id1 = NULL, *tree_id2 = NULL;
3881 struct got_tree_object *tree1 = NULL, *tree2 = NULL;
3882 struct got_object_qid *qid;
3883 got_diff_blob_cb cb = got_diff_tree_collect_changed_paths;
3884 FILE *f1 = NULL, *f2 = NULL;
3885 int fd1 = -1, fd2 = -1;
3886
3887 if (dsa) {
3888 cb = got_diff_tree_compute_diffstat;
3889
3890 f1 = got_opentemp();
3891 if (f1 == NULL) {
3892 err = got_error_from_errno("got_opentemp");
3893 goto done;
3894 }
3895 f2 = got_opentemp();
3896 if (f2 == NULL) {
3897 err = got_error_from_errno("got_opentemp");
3898 goto done;
3899 }
3900 fd1 = got_opentempfd();
3901 if (fd1 == -1) {
3902 err = got_error_from_errno("got_opentempfd");
3903 goto done;
3904 }
3905 fd2 = got_opentempfd();
3906 if (fd2 == -1) {
3907 err = got_error_from_errno("got_opentempfd");
3908 goto done;
3909 }
3910 }
3911
3912 qid = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
3913 if (qid != NULL) {
3914 struct got_commit_object *pcommit;
3915 err = got_object_open_as_commit(&pcommit, repo,
3916 &qid->id);
3917 if (err)
3918 return err;
3919
3920 tree_id1 = got_object_id_dup(
3921 got_object_commit_get_tree_id(pcommit));
3922 if (tree_id1 == NULL) {
3923 got_object_commit_close(pcommit);
3924 return got_error_from_errno("got_object_id_dup");
3925 }
3926 got_object_commit_close(pcommit);
3927
3928 }
3929
3930 if (tree_id1) {
3931 err = got_object_open_as_tree(&tree1, repo, tree_id1);
3932 if (err)
3933 goto done;
3934 }
3935
3936 tree_id2 = got_object_commit_get_tree_id(commit);
3937 err = got_object_open_as_tree(&tree2, repo, tree_id2);
3938 if (err)
3939 goto done;
3940
3941 err = got_diff_tree(tree1, tree2, f1, f2, fd1, fd2, "", "", repo,
3942 cb, dsa ? (void *)dsa : paths, dsa ? 1 : 0);
3943 done:
3944 if (tree1)
3945 got_object_tree_close(tree1);
3946 if (tree2)
3947 got_object_tree_close(tree2);
3948 if (fd1 != -1 && close(fd1) == -1 && err == NULL)
3949 err = got_error_from_errno("close");
3950 if (fd2 != -1 && close(fd2) == -1 && err == NULL)
3951 err = got_error_from_errno("close");
3952 if (f1 && fclose(f1) == EOF && err == NULL)
3953 err = got_error_from_errno("fclose");
3954 if (f2 && fclose(f2) == EOF && err == NULL)
3955 err = got_error_from_errno("fclose");
3956 free(tree_id1);
3957 return err;
3958 }
3959
3960 static const struct got_error *
3961 print_patch(struct got_commit_object *commit, struct got_object_id *id,
3962 const char *path, int diff_context, struct got_diffstat_cb_arg *dsa,
3963 struct got_repository *repo, FILE *outfile)
3964 {
3965 const struct got_error *err = NULL;
3966 struct got_commit_object *pcommit = NULL;
3967 char *id_str1 = NULL, *id_str2 = NULL;
3968 struct got_object_id *obj_id1 = NULL, *obj_id2 = NULL;
3969 struct got_object_qid *qid;
3970
3971 qid = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
3972 if (qid != NULL) {
3973 err = got_object_open_as_commit(&pcommit, repo,
3974 &qid->id);
3975 if (err)
3976 return err;
3977 err = got_object_id_str(&id_str1, &qid->id);
3978 if (err)
3979 goto done;
3980 }
3981
3982 err = got_object_id_str(&id_str2, id);
3983 if (err)
3984 goto done;
3985
3986 if (path && path[0] != '\0') {
3987 int obj_type;
3988 err = got_object_id_by_path(&obj_id2, repo, commit, path);
3989 if (err)
3990 goto done;
3991 if (pcommit) {
3992 err = got_object_id_by_path(&obj_id1, repo,
3993 pcommit, path);
3994 if (err) {
3995 if (err->code != GOT_ERR_NO_TREE_ENTRY) {
3996 free(obj_id2);
3997 goto done;
3998 }
3999 }
4000 }
4001 err = got_object_get_type(&obj_type, repo, obj_id2);
4002 if (err) {
4003 free(obj_id2);
4004 goto done;
4005 }
4006 fprintf(outfile,
4007 "diff %s %s\n", id_str1 ? id_str1 : "/dev/null", id_str2);
4008 fprintf(outfile, "commit - %s\n",
4009 id_str1 ? id_str1 : "/dev/null");
4010 fprintf(outfile, "commit + %s\n", id_str2);
4011 switch (obj_type) {
4012 case GOT_OBJ_TYPE_BLOB:
4013 err = diff_blobs(obj_id1, obj_id2, path, diff_context,
4014 0, 0, dsa, repo, outfile);
4015 break;
4016 case GOT_OBJ_TYPE_TREE:
4017 err = diff_trees(obj_id1, obj_id2, path, diff_context,
4018 0, 0, dsa, repo, outfile);
4019 break;
4020 default:
4021 err = got_error(GOT_ERR_OBJ_TYPE);
4022 break;
4023 }
4024 free(obj_id1);
4025 free(obj_id2);
4026 } else {
4027 obj_id2 = got_object_commit_get_tree_id(commit);
4028 if (pcommit)
4029 obj_id1 = got_object_commit_get_tree_id(pcommit);
4030 fprintf(outfile,
4031 "diff %s %s\n", id_str1 ? id_str1 : "/dev/null", id_str2);
4032 fprintf(outfile, "commit - %s\n",
4033 id_str1 ? id_str1 : "/dev/null");
4034 fprintf(outfile, "commit + %s\n", id_str2);
4035 err = diff_trees(obj_id1, obj_id2, "", diff_context, 0, 0,
4036 dsa, repo, outfile);
4037 }
4038 done:
4039 free(id_str1);
4040 free(id_str2);
4041 if (pcommit)
4042 got_object_commit_close(pcommit);
4043 return err;
4044 }
4045
4046 static char *
4047 get_datestr(time_t *time, char *datebuf)
4048 {
4049 struct tm mytm, *tm;
4050 char *p, *s;
4051
4052 tm = gmtime_r(time, &mytm);
4053 if (tm == NULL)
4054 return NULL;
4055 s = asctime_r(tm, datebuf);
4056 if (s == NULL)
4057 return NULL;
4058 p = strchr(s, '\n');
4059 if (p)
4060 *p = '\0';
4061 return s;
4062 }
4063
4064 static const struct got_error *
4065 match_commit(int *have_match, struct got_object_id *id,
4066 struct got_commit_object *commit, regex_t *regex)
4067 {
4068 const struct got_error *err = NULL;
4069 regmatch_t regmatch;
4070 char *id_str = NULL, *logmsg = NULL;
4071
4072 *have_match = 0;
4073
4074 err = got_object_id_str(&id_str, id);
4075 if (err)
4076 return err;
4077
4078 err = got_object_commit_get_logmsg(&logmsg, commit);
4079 if (err)
4080 goto done;
4081
4082 if (regexec(regex, got_object_commit_get_author(commit), 1,
4083 &regmatch, 0) == 0 ||
4084 regexec(regex, got_object_commit_get_committer(commit), 1,
4085 &regmatch, 0) == 0 ||
4086 regexec(regex, id_str, 1, &regmatch, 0) == 0 ||
4087 regexec(regex, logmsg, 1, &regmatch, 0) == 0)
4088 *have_match = 1;
4089 done:
4090 free(id_str);
4091 free(logmsg);
4092 return err;
4093 }
4094
4095 static void
4096 match_changed_paths(int *have_match, struct got_pathlist_head *changed_paths,
4097 regex_t *regex)
4098 {
4099 regmatch_t regmatch;
4100 struct got_pathlist_entry *pe;
4101
4102 *have_match = 0;
4103
4104 TAILQ_FOREACH(pe, changed_paths, entry) {
4105 if (regexec(regex, pe->path, 1, &regmatch, 0) == 0) {
4106 *have_match = 1;
4107 break;
4108 }
4109 }
4110 }
4111
4112 static const struct got_error *
4113 match_patch(int *have_match, struct got_commit_object *commit,
4114 struct got_object_id *id, const char *path, int diff_context,
4115 struct got_repository *repo, regex_t *regex, FILE *f)
4116 {
4117 const struct got_error *err = NULL;
4118 char *line = NULL;
4119 size_t linesize = 0;
4120 regmatch_t regmatch;
4121
4122 *have_match = 0;
4123
4124 err = got_opentemp_truncate(f);
4125 if (err)
4126 return err;
4127
4128 err = print_patch(commit, id, path, diff_context, NULL, repo, f);
4129 if (err)
4130 goto done;
4131
4132 if (fseeko(f, 0L, SEEK_SET) == -1) {
4133 err = got_error_from_errno("fseeko");
4134 goto done;
4135 }
4136
4137 while (getline(&line, &linesize, f) != -1) {
4138 if (regexec(regex, line, 1, &regmatch, 0) == 0) {
4139 *have_match = 1;
4140 break;
4141 }
4142 }
4143 done:
4144 free(line);
4145 return err;
4146 }
4147
4148 #define GOT_COMMIT_SEP_STR "-----------------------------------------------\n"
4149
4150 static const struct got_error*
4151 build_refs_str(char **refs_str, struct got_reflist_head *refs,
4152 struct got_object_id *id, struct got_repository *repo,
4153 int local_only)
4154 {
4155 static const struct got_error *err = NULL;
4156 struct got_reflist_entry *re;
4157 char *s;
4158 const char *name;
4159
4160 *refs_str = NULL;
4161
4162 TAILQ_FOREACH(re, refs, entry) {
4163 struct got_tag_object *tag = NULL;
4164 struct got_object_id *ref_id;
4165 int cmp;
4166
4167 name = got_ref_get_name(re->ref);
4168 if (strcmp(name, GOT_REF_HEAD) == 0)
4169 continue;
4170 if (strncmp(name, "refs/", 5) == 0)
4171 name += 5;
4172 if (strncmp(name, "got/", 4) == 0)
4173 continue;
4174 if (strncmp(name, "heads/", 6) == 0)
4175 name += 6;
4176 if (strncmp(name, "remotes/", 8) == 0) {
4177 if (local_only)
4178 continue;
4179 name += 8;
4180 s = strstr(name, "/" GOT_REF_HEAD);
4181 if (s != NULL && strcmp(s, "/" GOT_REF_HEAD) == 0)
4182 continue;
4183 }
4184 err = got_ref_resolve(&ref_id, repo, re->ref);
4185 if (err)
4186 break;
4187 if (strncmp(name, "tags/", 5) == 0) {
4188 err = got_object_open_as_tag(&tag, repo, ref_id);
4189 if (err) {
4190 if (err->code != GOT_ERR_OBJ_TYPE) {
4191 free(ref_id);
4192 break;
4193 }
4194 /* Ref points at something other than a tag. */
4195 err = NULL;
4196 tag = NULL;
4197 }
4198 }
4199 cmp = got_object_id_cmp(tag ?
4200 got_object_tag_get_object_id(tag) : ref_id, id);
4201 free(ref_id);
4202 if (tag)
4203 got_object_tag_close(tag);
4204 if (cmp != 0)
4205 continue;
4206 s = *refs_str;
4207 if (asprintf(refs_str, "%s%s%s", s ? s : "",
4208 s ? ", " : "", name) == -1) {
4209 err = got_error_from_errno("asprintf");
4210 free(s);
4211 *refs_str = NULL;
4212 break;
4213 }
4214 free(s);
4215 }
4216
4217 return err;
4218 }
4219
4220 static const struct got_error *
4221 print_commit_oneline(struct got_commit_object *commit, struct got_object_id *id,
4222 struct got_repository *repo, struct got_reflist_object_id_map *refs_idmap)
4223 {
4224 const struct got_error *err = NULL;
4225 char *ref_str = NULL, *id_str = NULL, *logmsg0 = NULL;
4226 char *comma, *s, *nl;
4227 struct got_reflist_head *refs;
4228 char datebuf[12]; /* YYYY-MM-DD + SPACE + NUL */
4229 struct tm tm;
4230 time_t committer_time;
4231
4232 refs = got_reflist_object_id_map_lookup(refs_idmap, id);
4233 if (refs) {
4234 err = build_refs_str(&ref_str, refs, id, repo, 1);
4235 if (err)
4236 return err;
4237
4238 /* Display the first matching ref only. */
4239 if (ref_str && (comma = strchr(ref_str, ',')) != NULL)
4240 *comma = '\0';
4241 }
4242
4243 if (ref_str == NULL) {
4244 err = got_object_id_str(&id_str, id);
4245 if (err)
4246 return err;
4247 }
4248
4249 committer_time = got_object_commit_get_committer_time(commit);
4250 if (gmtime_r(&committer_time, &tm) == NULL) {
4251 err = got_error_from_errno("gmtime_r");
4252 goto done;
4253 }
4254 if (strftime(datebuf, sizeof(datebuf), "%F ", &tm) == 0) {
4255 err = got_error(GOT_ERR_NO_SPACE);
4256 goto done;
4257 }
4258
4259 err = got_object_commit_get_logmsg(&logmsg0, commit);
4260 if (err)
4261 goto done;
4262
4263 s = logmsg0;
4264 while (isspace((unsigned char)s[0]))
4265 s++;
4266
4267 nl = strchr(s, '\n');
4268 if (nl) {
4269 *nl = '\0';
4270 }
4271
4272 if (ref_str)
4273 printf("%s%-7s %s\n", datebuf, ref_str, s);
4274 else
4275 printf("%s%.7s %s\n", datebuf, id_str, s);
4276
4277 if (fflush(stdout) != 0 && err == NULL)
4278 err = got_error_from_errno("fflush");
4279 done:
4280 free(id_str);
4281 free(ref_str);
4282 free(logmsg0);
4283 return err;
4284 }
4285
4286 static const struct got_error *
4287 print_diffstat(struct got_diffstat_cb_arg *dsa, const char *header)
4288 {
4289 struct got_pathlist_entry *pe;
4290
4291 if (header != NULL)
4292 printf("%s\n", header);
4293
4294 TAILQ_FOREACH(pe, dsa->paths, entry) {
4295 struct got_diff_changed_path *cp = pe->data;
4296 int pad = dsa->max_path_len - pe->path_len + 1;
4297
4298 printf(" %c %s%*c | %*d+ %*d-\n", cp->status, pe->path, pad,
4299 ' ', dsa->add_cols + 1, cp->add, dsa->rm_cols + 1, cp->rm);
4300 }
4301 printf("\n%d file%s changed, %d insertion%s(+), %d deletion%s(-)\n\n",
4302 dsa->nfiles, dsa->nfiles > 1 ? "s" : "", dsa->ins,
4303 dsa->ins != 1 ? "s" : "", dsa->del, dsa->del != 1 ? "s" : "");
4304
4305 if (fflush(stdout) != 0)
4306 return got_error_from_errno("fflush");
4307
4308 return NULL;
4309 }
4310
4311 static const struct got_error *
4312 printfile(FILE *f)
4313 {
4314 char buf[8192];
4315 size_t r;
4316
4317 if (fseeko(f, 0L, SEEK_SET) == -1)
4318 return got_error_from_errno("fseek");
4319
4320 for (;;) {
4321 r = fread(buf, 1, sizeof(buf), f);
4322 if (r == 0) {
4323 if (ferror(f))
4324 return got_error_from_errno("fread");
4325 if (feof(f))
4326 break;
4327 }
4328 if (fwrite(buf, 1, r, stdout) != r)
4329 return got_ferror(stdout, GOT_ERR_IO);
4330 }
4331
4332 return NULL;
4333 }
4334
4335 static const struct got_error *
4336 print_commit(struct got_commit_object *commit, struct got_object_id *id,
4337 struct got_repository *repo, const char *path,
4338 struct got_pathlist_head *changed_paths,
4339 struct got_diffstat_cb_arg *diffstat, int show_patch, int diff_context,
4340 struct got_reflist_object_id_map *refs_idmap, const char *custom_refs_str,
4341 const char *prefix)
4342 {
4343 const struct got_error *err = NULL;
4344 FILE *f = NULL;
4345 char *id_str, *datestr, *logmsg0, *logmsg, *line;
4346 char datebuf[26];
4347 time_t committer_time;
4348 const char *author, *committer;
4349 char *refs_str = NULL;
4350
4351 err = got_object_id_str(&id_str, id);
4352 if (err)
4353 return err;
4354
4355 if (custom_refs_str == NULL) {
4356 struct got_reflist_head *refs;
4357 refs = got_reflist_object_id_map_lookup(refs_idmap, id);
4358 if (refs) {
4359 err = build_refs_str(&refs_str, refs, id, repo, 0);
4360 if (err)
4361 goto done;
4362 }
4363 }
4364
4365 printf(GOT_COMMIT_SEP_STR);
4366 if (custom_refs_str)
4367 printf("%s %s (%s)\n", prefix ? prefix : "commit", id_str,
4368 custom_refs_str);
4369 else
4370 printf("%s %s%s%s%s\n", prefix ? prefix : "commit", id_str,
4371 refs_str ? " (" : "", refs_str ? refs_str : "",
4372 refs_str ? ")" : "");
4373 free(id_str);
4374 id_str = NULL;
4375 free(refs_str);
4376 refs_str = NULL;
4377 printf("from: %s\n", got_object_commit_get_author(commit));
4378 author = got_object_commit_get_author(commit);
4379 committer = got_object_commit_get_committer(commit);
4380 if (strcmp(author, committer) != 0)
4381 printf("via: %s\n", committer);
4382 committer_time = got_object_commit_get_committer_time(commit);
4383 datestr = get_datestr(&committer_time, datebuf);
4384 if (datestr)
4385 printf("date: %s UTC\n", datestr);
4386 if (got_object_commit_get_nparents(commit) > 1) {
4387 const struct got_object_id_queue *parent_ids;
4388 struct got_object_qid *qid;
4389 int n = 1;
4390 parent_ids = got_object_commit_get_parent_ids(commit);
4391 STAILQ_FOREACH(qid, parent_ids, entry) {
4392 err = got_object_id_str(&id_str, &qid->id);
4393 if (err)
4394 goto done;
4395 printf("parent %d: %s\n", n++, id_str);
4396 free(id_str);
4397 id_str = NULL;
4398 }
4399 }
4400
4401 err = got_object_commit_get_logmsg(&logmsg0, commit);
4402 if (err)
4403 goto done;
4404
4405 logmsg = logmsg0;
4406 do {
4407 line = strsep(&logmsg, "\n");
4408 if (line)
4409 printf(" %s\n", line);
4410 } while (line);
4411 free(logmsg0);
4412
4413 if (changed_paths && diffstat == NULL) {
4414 struct got_pathlist_entry *pe;
4415
4416 TAILQ_FOREACH(pe, changed_paths, entry) {
4417 struct got_diff_changed_path *cp = pe->data;
4418
4419 printf(" %c %s\n", cp->status, pe->path);
4420 }
4421 printf("\n");
4422 }
4423 if (show_patch) {
4424 if (diffstat) {
4425 f = got_opentemp();
4426 if (f == NULL) {
4427 err = got_error_from_errno("got_opentemp");
4428 goto done;
4429 }
4430 }
4431
4432 err = print_patch(commit, id, path, diff_context, diffstat,
4433 repo, diffstat == NULL ? stdout : f);
4434 if (err)
4435 goto done;
4436 }
4437 if (diffstat) {
4438 err = print_diffstat(diffstat, NULL);
4439 if (err)
4440 goto done;
4441 if (show_patch) {
4442 err = printfile(f);
4443 if (err)
4444 goto done;
4445 }
4446 }
4447 if (show_patch)
4448 printf("\n");
4449
4450 if (fflush(stdout) != 0 && err == NULL)
4451 err = got_error_from_errno("fflush");
4452 done:
4453 if (f && fclose(f) == EOF && err == NULL)
4454 err = got_error_from_errno("fclose");
4455 free(id_str);
4456 free(refs_str);
4457 return err;
4458 }
4459
4460 static const struct got_error *
4461 print_commits(struct got_object_id *root_id, struct got_object_id *end_id,
4462 struct got_repository *repo, const char *path, int show_changed_paths,
4463 int show_diffstat, int show_patch, const char *search_pattern,
4464 int diff_context, int limit, int log_branches, int reverse_display_order,
4465 struct got_reflist_object_id_map *refs_idmap, int one_line, int toposort,
4466 FILE *tmpfile)
4467 {
4468 const struct got_error *err;
4469 struct got_commit_graph *graph;
4470 regex_t regex;
4471 int have_match;
4472 struct got_object_id_queue reversed_commits;
4473 struct got_object_qid *qid;
4474 struct got_commit_object *commit;
4475 struct got_pathlist_head changed_paths;
4476
4477 STAILQ_INIT(&reversed_commits);
4478 TAILQ_INIT(&changed_paths);
4479
4480 if (search_pattern && regcomp(&regex, search_pattern,
4481 REG_EXTENDED | REG_NOSUB | REG_NEWLINE))
4482 return got_error_msg(GOT_ERR_REGEX, search_pattern);
4483
4484 err = got_commit_graph_open(&graph, path, !log_branches);
4485 if (err)
4486 return err;
4487 if (log_branches && toposort) {
4488 err = got_commit_graph_toposort(graph, root_id, repo,
4489 check_cancelled, NULL);
4490 } else {
4491 err = got_commit_graph_bfsort(graph, root_id, repo,
4492 check_cancelled, NULL);
4493 }
4494 if (err)
4495 goto done;
4496 for (;;) {
4497 struct got_object_id id;
4498 struct got_diffstat_cb_arg dsa = { 0, 0, 0, 0, 0, 0,
4499 &changed_paths, 0, 0, GOT_DIFF_ALGORITHM_PATIENCE };
4500
4501 if (sigint_received || sigpipe_received)
4502 break;
4503
4504 err = got_commit_graph_iter_next(&id, graph, repo,
4505 check_cancelled, NULL);
4506 if (err) {
4507 if (err->code == GOT_ERR_ITER_COMPLETED)
4508 err = NULL;
4509 break;
4510 }
4511
4512 err = got_object_open_as_commit(&commit, repo, &id);
4513 if (err)
4514 break;
4515
4516 if (((show_changed_paths && !show_diffstat) ||
4517 (show_diffstat && !show_patch))
4518 && !reverse_display_order) {
4519 err = get_changed_paths(&changed_paths, commit, repo,
4520 show_diffstat ? &dsa : NULL);
4521 if (err)
4522 break;
4523 }
4524
4525 if (search_pattern) {
4526 err = match_commit(&have_match, &id, commit, &regex);
4527 if (err) {
4528 got_object_commit_close(commit);
4529 break;
4530 }
4531 if (have_match == 0 && show_changed_paths)
4532 match_changed_paths(&have_match,
4533 &changed_paths, &regex);
4534 if (have_match == 0 && show_patch) {
4535 err = match_patch(&have_match, commit, &id,
4536 path, diff_context, repo, &regex, tmpfile);
4537 if (err)
4538 break;
4539 }
4540 if (have_match == 0) {
4541 got_object_commit_close(commit);
4542 got_pathlist_free(&changed_paths,
4543 GOT_PATHLIST_FREE_ALL);
4544 continue;
4545 }
4546 }
4547
4548 if (reverse_display_order) {
4549 err = got_object_qid_alloc(&qid, &id);
4550 if (err)
4551 break;
4552 STAILQ_INSERT_HEAD(&reversed_commits, qid, entry);
4553 got_object_commit_close(commit);
4554 } else {
4555 if (one_line)
4556 err = print_commit_oneline(commit, &id,
4557 repo, refs_idmap);
4558 else
4559 err = print_commit(commit, &id, repo, path,
4560 (show_changed_paths || show_diffstat) ?
4561 &changed_paths : NULL,
4562 show_diffstat ? &dsa : NULL, show_patch,
4563 diff_context, refs_idmap, NULL, NULL);
4564 got_object_commit_close(commit);
4565 if (err)
4566 break;
4567 }
4568 if ((limit && --limit == 0) ||
4569 (end_id && got_object_id_cmp(&id, end_id) == 0))
4570 break;
4571
4572 got_pathlist_free(&changed_paths, GOT_PATHLIST_FREE_ALL);
4573 }
4574 if (reverse_display_order) {
4575 STAILQ_FOREACH(qid, &reversed_commits, entry) {
4576 struct got_diffstat_cb_arg dsa = { 0, 0, 0, 0, 0, 0,
4577 &changed_paths, 0, 0, GOT_DIFF_ALGORITHM_PATIENCE };
4578
4579 err = got_object_open_as_commit(&commit, repo,
4580 &qid->id);
4581 if (err)
4582 break;
4583 if ((show_changed_paths && !show_diffstat) ||
4584 (show_diffstat && !show_patch)) {
4585 err = get_changed_paths(&changed_paths, commit,
4586 repo, show_diffstat ? &dsa : NULL);
4587 if (err)
4588 break;
4589 }
4590 if (one_line)
4591 err = print_commit_oneline(commit, &qid->id,
4592 repo, refs_idmap);
4593 else
4594 err = print_commit(commit, &qid->id, repo, path,
4595 (show_changed_paths || show_diffstat) ?
4596 &changed_paths : NULL,
4597 show_diffstat ? &dsa : NULL, show_patch,
4598 diff_context, refs_idmap, NULL, NULL);
4599 got_object_commit_close(commit);
4600 if (err)
4601 break;
4602 got_pathlist_free(&changed_paths, GOT_PATHLIST_FREE_ALL);
4603 }
4604 }
4605 done:
4606 while (!STAILQ_EMPTY(&reversed_commits)) {
4607 qid = STAILQ_FIRST(&reversed_commits);
4608 STAILQ_REMOVE_HEAD(&reversed_commits, entry);
4609 got_object_qid_free(qid);
4610 }
4611 got_pathlist_free(&changed_paths, GOT_PATHLIST_FREE_ALL);
4612 if (search_pattern)
4613 regfree(&regex);
4614 got_commit_graph_close(graph);
4615 return err;
4616 }
4617
4618 __dead static void
4619 usage_log(void)
4620 {
4621 fprintf(stderr, "usage: %s log [-bdPpRst] [-C number] [-c commit] "
4622 "[-l N] [-r repository-path] [-S search-pattern] [-x commit] "
4623 "[path]\n", getprogname());
4624 exit(1);
4625 }
4626
4627 static int
4628 get_default_log_limit(void)
4629 {
4630 const char *got_default_log_limit;
4631 long long n;
4632 const char *errstr;
4633
4634 got_default_log_limit = getenv("GOT_LOG_DEFAULT_LIMIT");
4635 if (got_default_log_limit == NULL)
4636 return 0;
4637 n = strtonum(got_default_log_limit, 0, INT_MAX, &errstr);
4638 if (errstr != NULL)
4639 return 0;
4640 return n;
4641 }
4642
4643 static const struct got_error *
4644 cmd_log(int argc, char *argv[])
4645 {
4646 const struct got_error *error;
4647 struct got_repository *repo = NULL;
4648 struct got_worktree *worktree = NULL;
4649 struct got_object_id *start_id = NULL, *end_id = NULL;
4650 char *repo_path = NULL, *path = NULL, *cwd = NULL, *in_repo_path = NULL;
4651 char *keyword_idstr = NULL;
4652 const char *start_commit = NULL, *end_commit = NULL;
4653 const char *search_pattern = NULL;
4654 int diff_context = -1, ch;
4655 int show_changed_paths = 0, show_patch = 0, limit = 0, log_branches = 0;
4656 int show_diffstat = 0, reverse_display_order = 0, one_line = 0;
4657 int toposort = 0;
4658 const char *errstr;
4659 struct got_reflist_head refs;
4660 struct got_reflist_object_id_map *refs_idmap = NULL;
4661 FILE *tmpfile = NULL;
4662 int *pack_fds = NULL;
4663
4664 TAILQ_INIT(&refs);
4665
4666 #ifndef PROFILE
4667 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
4668 NULL)
4669 == -1)
4670 err(1, "pledge");
4671 #endif
4672
4673 limit = get_default_log_limit();
4674
4675 while ((ch = getopt(argc, argv, "bC:c:dl:PpRr:S:stx:")) != -1) {
4676 switch (ch) {
4677 case 'b':
4678 log_branches = 1;
4679 break;
4680 case 'C':
4681 diff_context = strtonum(optarg, 0, GOT_DIFF_MAX_CONTEXT,
4682 &errstr);
4683 if (errstr != NULL)
4684 errx(1, "number of context lines is %s: %s",
4685 errstr, optarg);
4686 break;
4687 case 'c':
4688 start_commit = optarg;
4689 break;
4690 case 'd':
4691 show_diffstat = 1;
4692 break;
4693 case 'l':
4694 limit = strtonum(optarg, 0, INT_MAX, &errstr);
4695 if (errstr != NULL)
4696 errx(1, "number of commits is %s: %s",
4697 errstr, optarg);
4698 break;
4699 case 'P':
4700 show_changed_paths = 1;
4701 break;
4702 case 'p':
4703 show_patch = 1;
4704 break;
4705 case 'R':
4706 reverse_display_order = 1;
4707 break;
4708 case 'r':
4709 repo_path = realpath(optarg, NULL);
4710 if (repo_path == NULL)
4711 return got_error_from_errno2("realpath",
4712 optarg);
4713 got_path_strip_trailing_slashes(repo_path);
4714 break;
4715 case 'S':
4716 search_pattern = optarg;
4717 break;
4718 case 's':
4719 one_line = 1;
4720 break;
4721 case 't':
4722 toposort = 1;
4723 break;
4724 case 'x':
4725 end_commit = optarg;
4726 break;
4727 default:
4728 usage_log();
4729 /* NOTREACHED */
4730 }
4731 }
4732
4733 argc -= optind;
4734 argv += optind;
4735
4736 if (diff_context == -1)
4737 diff_context = 3;
4738 else if (!show_patch)
4739 errx(1, "-C requires -p");
4740
4741 if (one_line && (show_patch || show_changed_paths || show_diffstat))
4742 errx(1, "cannot use -s with -d, -p or -P");
4743
4744 cwd = getcwd(NULL, 0);
4745 if (cwd == NULL) {
4746 error = got_error_from_errno("getcwd");
4747 goto done;
4748 }
4749
4750 error = got_repo_pack_fds_open(&pack_fds);
4751 if (error != NULL)
4752 goto done;
4753
4754 if (repo_path == NULL) {
4755 error = got_worktree_open(&worktree, cwd,
4756 GOT_WORKTREE_GOT_DIR);
4757 if (error && error->code != GOT_ERR_NOT_WORKTREE)
4758 goto done;
4759 error = NULL;
4760 }
4761
4762 if (argc == 1) {
4763 if (worktree) {
4764 error = got_worktree_resolve_path(&path, worktree,
4765 argv[0]);
4766 if (error)
4767 goto done;
4768 } else {
4769 path = strdup(argv[0]);
4770 if (path == NULL) {
4771 error = got_error_from_errno("strdup");
4772 goto done;
4773 }
4774 }
4775 } else if (argc != 0)
4776 usage_log();
4777
4778 if (repo_path == NULL) {
4779 repo_path = worktree ?
4780 strdup(got_worktree_get_repo_path(worktree)) : strdup(cwd);
4781 }
4782 if (repo_path == NULL) {
4783 error = got_error_from_errno("strdup");
4784 goto done;
4785 }
4786
4787 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
4788 if (error != NULL)
4789 goto done;
4790
4791 error = apply_unveil(got_repo_get_path(repo), 1,
4792 worktree ? got_worktree_get_root_path(worktree) : NULL);
4793 if (error)
4794 goto done;
4795
4796 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
4797 if (error)
4798 goto done;
4799
4800 error = got_reflist_object_id_map_create(&refs_idmap, &refs, repo);
4801 if (error)
4802 goto done;
4803
4804 if (start_commit == NULL) {
4805 struct got_reference *head_ref;
4806 struct got_commit_object *commit = NULL;
4807 error = got_ref_open(&head_ref, repo,
4808 worktree ? got_worktree_get_head_ref_name(worktree)
4809 : GOT_REF_HEAD, 0);
4810 if (error != NULL)
4811 goto done;
4812 error = got_ref_resolve(&start_id, repo, head_ref);
4813 got_ref_close(head_ref);
4814 if (error != NULL)
4815 goto done;
4816 error = got_object_open_as_commit(&commit, repo,
4817 start_id);
4818 if (error != NULL)
4819 goto done;
4820 got_object_commit_close(commit);
4821 } else {
4822 error = got_keyword_to_idstr(&keyword_idstr, start_commit,
4823 repo, worktree);
4824 if (error != NULL)
4825 goto done;
4826 if (keyword_idstr != NULL)
4827 start_commit = keyword_idstr;
4828
4829 error = got_repo_match_object_id(&start_id, NULL,
4830 start_commit, GOT_OBJ_TYPE_COMMIT, &refs, repo);
4831 if (error != NULL)
4832 goto done;
4833 }
4834 if (end_commit != NULL) {
4835 error = got_keyword_to_idstr(&keyword_idstr, end_commit,
4836 repo, worktree);
4837 if (error != NULL)
4838 goto done;
4839 if (keyword_idstr != NULL)
4840 end_commit = keyword_idstr;
4841
4842 error = got_repo_match_object_id(&end_id, NULL,
4843 end_commit, GOT_OBJ_TYPE_COMMIT, &refs, repo);
4844 if (error != NULL)
4845 goto done;
4846 }
4847
4848 if (worktree) {
4849 /*
4850 * If a path was specified on the command line it was resolved
4851 * to a path in the work tree above. Prepend the work tree's
4852 * path prefix to obtain the corresponding in-repository path.
4853 */
4854 if (path) {
4855 const char *prefix;
4856 prefix = got_worktree_get_path_prefix(worktree);
4857 if (asprintf(&in_repo_path, "%s%s%s", prefix,
4858 (path[0] != '\0') ? "/" : "", path) == -1) {
4859 error = got_error_from_errno("asprintf");
4860 goto done;
4861 }
4862 }
4863 } else
4864 error = got_repo_map_path(&in_repo_path, repo,
4865 path ? path : "");
4866 if (error != NULL)
4867 goto done;
4868 if (in_repo_path) {
4869 free(path);
4870 path = in_repo_path;
4871 }
4872
4873 if (worktree) {
4874 /* Release work tree lock. */
4875 got_worktree_close(worktree);
4876 worktree = NULL;
4877 }
4878
4879 if (search_pattern && show_patch) {
4880 tmpfile = got_opentemp();
4881 if (tmpfile == NULL) {
4882 error = got_error_from_errno("got_opentemp");
4883 goto done;
4884 }
4885 }
4886
4887 error = print_commits(start_id, end_id, repo, path ? path : "",
4888 show_changed_paths, show_diffstat, show_patch, search_pattern,
4889 diff_context, limit, log_branches, reverse_display_order,
4890 refs_idmap, one_line, toposort, tmpfile);
4891 done:
4892 free(path);
4893 free(repo_path);
4894 free(cwd);
4895 free(start_id);
4896 free(end_id);
4897 free(keyword_idstr);
4898 if (worktree)
4899 got_worktree_close(worktree);
4900 if (repo) {
4901 const struct got_error *close_err = got_repo_close(repo);
4902 if (error == NULL)
4903 error = close_err;
4904 }
4905 if (pack_fds) {
4906 const struct got_error *pack_err =
4907 got_repo_pack_fds_close(pack_fds);
4908 if (error == NULL)
4909 error = pack_err;
4910 }
4911 if (refs_idmap)
4912 got_reflist_object_id_map_free(refs_idmap);
4913 if (tmpfile && fclose(tmpfile) == EOF && error == NULL)
4914 error = got_error_from_errno("fclose");
4915 got_ref_list_free(&refs);
4916 return error;
4917 }
4918
4919 __dead static void
4920 usage_diff(void)
4921 {
4922 fprintf(stderr, "usage: %s diff [-adPsw] [-C number] [-c commit] "
4923 "[-r repository-path] [object1 object2 | path ...]\n",
4924 getprogname());
4925 exit(1);
4926 }
4927
4928 struct print_diff_arg {
4929 struct got_repository *repo;
4930 struct got_worktree *worktree;
4931 struct got_diffstat_cb_arg *diffstat;
4932 int diff_context;
4933 const char *id_str;
4934 int header_shown;
4935 int diff_staged;
4936 enum got_diff_algorithm diff_algo;
4937 int ignore_whitespace;
4938 int force_text_diff;
4939 FILE *f1;
4940 FILE *f2;
4941 FILE *outfile;
4942 };
4943
4944 /*
4945 * Create a file which contains the target path of a symlink so we can feed
4946 * it as content to the diff engine.
4947 */
4948 static const struct got_error *
4949 get_symlink_target_file(int *fd, int dirfd, const char *de_name,
4950 const char *abspath)
4951 {
4952 const struct got_error *err = NULL;
4953 char target_path[PATH_MAX];
4954 ssize_t target_len, outlen;
4955
4956 *fd = -1;
4957
4958 if (dirfd != -1) {
4959 target_len = readlinkat(dirfd, de_name, target_path, PATH_MAX);
4960 if (target_len == -1)
4961 return got_error_from_errno2("readlinkat", abspath);
4962 } else {
4963 target_len = readlink(abspath, target_path, PATH_MAX);
4964 if (target_len == -1)
4965 return got_error_from_errno2("readlink", abspath);
4966 }
4967
4968 *fd = got_opentempfd();
4969 if (*fd == -1)
4970 return got_error_from_errno("got_opentempfd");
4971
4972 outlen = write(*fd, target_path, target_len);
4973 if (outlen == -1) {
4974 err = got_error_from_errno("got_opentempfd");
4975 goto done;
4976 }
4977
4978 if (lseek(*fd, 0, SEEK_SET) == -1) {
4979 err = got_error_from_errno2("lseek", abspath);
4980 goto done;
4981 }
4982 done:
4983 if (err) {
4984 close(*fd);
4985 *fd = -1;
4986 }
4987 return err;
4988 }
4989
4990 static const struct got_error *
4991 print_diff(void *arg, unsigned char status, unsigned char staged_status,
4992 const char *path, struct got_object_id *blob_id,
4993 struct got_object_id *staged_blob_id, struct got_object_id *commit_id,
4994 int dirfd, const char *de_name)
4995 {
4996 struct print_diff_arg *a = arg;
4997 const struct got_error *err = NULL;
4998 struct got_blob_object *blob1 = NULL;
4999 int fd = -1, fd1 = -1, fd2 = -1;
5000 FILE *f2 = NULL;
5001 char *abspath = NULL, *label1 = NULL;
5002 struct stat sb;
5003 off_t size1 = 0;
5004 int f2_exists = 0;
5005
5006 memset(&sb, 0, sizeof(sb));
5007
5008 if (a->diff_staged) {
5009 if (staged_status != GOT_STATUS_MODIFY &&
5010 staged_status != GOT_STATUS_ADD &&
5011 staged_status != GOT_STATUS_DELETE)
5012 return NULL;
5013 } else {
5014 if (staged_status == GOT_STATUS_DELETE)
5015 return NULL;
5016 if (status == GOT_STATUS_NONEXISTENT)
5017 return got_error_set_errno(ENOENT, path);
5018 if (status != GOT_STATUS_MODIFY &&
5019 status != GOT_STATUS_ADD &&
5020 status != GOT_STATUS_DELETE &&
5021 status != GOT_STATUS_CONFLICT)
5022 return NULL;
5023 }
5024
5025 err = got_opentemp_truncate(a->f1);
5026 if (err)
5027 return got_error_from_errno("got_opentemp_truncate");
5028 err = got_opentemp_truncate(a->f2);
5029 if (err)
5030 return got_error_from_errno("got_opentemp_truncate");
5031
5032 if (!a->header_shown) {
5033 if (fprintf(a->outfile, "diff %s%s\n",
5034 a->diff_staged ? "-s " : "",
5035 got_worktree_get_root_path(a->worktree)) < 0) {
5036 err = got_error_from_errno("fprintf");
5037 goto done;
5038 }
5039 if (fprintf(a->outfile, "commit - %s\n", a->id_str) < 0) {
5040 err = got_error_from_errno("fprintf");
5041 goto done;
5042 }
5043 if (fprintf(a->outfile, "path + %s%s\n",
5044 got_worktree_get_root_path(a->worktree),
5045 a->diff_staged ? " (staged changes)" : "") < 0) {
5046 err = got_error_from_errno("fprintf");
5047 goto done;
5048 }
5049 a->header_shown = 1;
5050 }
5051
5052 if (a->diff_staged) {
5053 const char *label1 = NULL, *label2 = NULL;
5054 switch (staged_status) {
5055 case GOT_STATUS_MODIFY:
5056 label1 = path;
5057 label2 = path;
5058 break;
5059 case GOT_STATUS_ADD:
5060 label2 = path;
5061 break;
5062 case GOT_STATUS_DELETE:
5063 label1 = path;
5064 break;
5065 default:
5066 return got_error(GOT_ERR_FILE_STATUS);
5067 }
5068 fd1 = got_opentempfd();
5069 if (fd1 == -1) {
5070 err = got_error_from_errno("got_opentempfd");
5071 goto done;
5072 }
5073 fd2 = got_opentempfd();
5074 if (fd2 == -1) {
5075 err = got_error_from_errno("got_opentempfd");
5076 goto done;
5077 }
5078 err = got_diff_objects_as_blobs(NULL, NULL, a->f1, a->f2,
5079 fd1, fd2, blob_id, staged_blob_id, label1, label2,
5080 a->diff_algo, a->diff_context, a->ignore_whitespace,
5081 a->force_text_diff, a->diffstat, a->repo, a->outfile);
5082 goto done;
5083 }
5084
5085 fd1 = got_opentempfd();
5086 if (fd1 == -1) {
5087 err = got_error_from_errno("got_opentempfd");
5088 goto done;
5089 }
5090
5091 if (staged_status == GOT_STATUS_ADD ||
5092 staged_status == GOT_STATUS_MODIFY) {
5093 char *id_str;
5094 err = got_object_open_as_blob(&blob1, a->repo, staged_blob_id,
5095 8192, fd1);
5096 if (err)
5097 goto done;
5098 err = got_object_id_str(&id_str, staged_blob_id);
5099 if (err)
5100 goto done;
5101 if (asprintf(&label1, "%s (staged)", id_str) == -1) {
5102 err = got_error_from_errno("asprintf");
5103 free(id_str);
5104 goto done;
5105 }
5106 free(id_str);
5107 } else if (status != GOT_STATUS_ADD) {
5108 err = got_object_open_as_blob(&blob1, a->repo, blob_id, 8192,
5109 fd1);
5110 if (err)
5111 goto done;
5112 }
5113
5114 if (status != GOT_STATUS_DELETE) {
5115 if (asprintf(&abspath, "%s/%s",
5116 got_worktree_get_root_path(a->worktree), path) == -1) {
5117 err = got_error_from_errno("asprintf");
5118 goto done;
5119 }
5120
5121 if (dirfd != -1) {
5122 fd = openat(dirfd, de_name,
5123 O_RDONLY | O_NOFOLLOW | O_CLOEXEC);
5124 if (fd == -1) {
5125 if (!got_err_open_nofollow_on_symlink()) {
5126 err = got_error_from_errno2("openat",
5127 abspath);
5128 goto done;
5129 }
5130 err = get_symlink_target_file(&fd, dirfd,
5131 de_name, abspath);
5132 if (err)
5133 goto done;
5134 }
5135 } else {
5136 fd = open(abspath, O_RDONLY | O_NOFOLLOW | O_CLOEXEC);
5137 if (fd == -1) {
5138 if (!got_err_open_nofollow_on_symlink()) {
5139 err = got_error_from_errno2("open",
5140 abspath);
5141 goto done;
5142 }
5143 err = get_symlink_target_file(&fd, dirfd,
5144 de_name, abspath);
5145 if (err)
5146 goto done;
5147 }
5148 }
5149 if (fstatat(fd, abspath, &sb, AT_SYMLINK_NOFOLLOW) == -1) {
5150 err = got_error_from_errno2("fstatat", abspath);
5151 goto done;
5152 }
5153 f2 = fdopen(fd, "r");
5154 if (f2 == NULL) {
5155 err = got_error_from_errno2("fdopen", abspath);
5156 goto done;
5157 }
5158 fd = -1;
5159 f2_exists = 1;
5160 }
5161
5162 if (blob1) {
5163 err = got_object_blob_dump_to_file(&size1, NULL, NULL,
5164 a->f1, blob1);
5165 if (err)
5166 goto done;
5167 }
5168
5169 err = got_diff_blob_file(blob1, a->f1, size1, label1, f2 ? f2 : a->f2,
5170 f2_exists, &sb, path, GOT_DIFF_ALGORITHM_PATIENCE, a->diff_context,
5171 a->ignore_whitespace, a->force_text_diff, a->diffstat, a->outfile);
5172 done:
5173 if (fd1 != -1 && close(fd1) == -1 && err == NULL)
5174 err = got_error_from_errno("close");
5175 if (fd2 != -1 && close(fd2) == -1 && err == NULL)
5176 err = got_error_from_errno("close");
5177 if (blob1)
5178 got_object_blob_close(blob1);
5179 if (fd != -1 && close(fd) == -1 && err == NULL)
5180 err = got_error_from_errno("close");
5181 if (f2 && fclose(f2) == EOF && err == NULL)
5182 err = got_error_from_errno("fclose");
5183 free(abspath);
5184 return err;
5185 }
5186
5187 static const struct got_error *
5188 cmd_diff(int argc, char *argv[])
5189 {
5190 const struct got_error *error;
5191 struct got_repository *repo = NULL;
5192 struct got_worktree *worktree = NULL;
5193 char *cwd = NULL, *repo_path = NULL;
5194 const char *commit_args[2] = { NULL, NULL };
5195 int ncommit_args = 0;
5196 struct got_object_id *ids[2] = { NULL, NULL };
5197 char *labels[2] = { NULL, NULL };
5198 int type1 = GOT_OBJ_TYPE_ANY, type2 = GOT_OBJ_TYPE_ANY;
5199 int diff_context = 3, diff_staged = 0, ignore_whitespace = 0, ch, i;
5200 int force_text_diff = 0, force_path = 0, rflag = 0, show_diffstat = 0;
5201 const char *errstr;
5202 struct got_reflist_head refs;
5203 struct got_pathlist_head diffstat_paths, paths;
5204 FILE *f1 = NULL, *f2 = NULL, *outfile = NULL;
5205 int fd1 = -1, fd2 = -1;
5206 int *pack_fds = NULL;
5207 struct got_diffstat_cb_arg dsa;
5208
5209 memset(&dsa, 0, sizeof(dsa));
5210
5211 TAILQ_INIT(&refs);
5212 TAILQ_INIT(&paths);
5213 TAILQ_INIT(&diffstat_paths);
5214
5215 #ifndef PROFILE
5216 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
5217 NULL) == -1)
5218 err(1, "pledge");
5219 #endif
5220
5221 while ((ch = getopt(argc, argv, "aC:c:dPr:sw")) != -1) {
5222 switch (ch) {
5223 case 'a':
5224 force_text_diff = 1;
5225 break;
5226 case 'C':
5227 diff_context = strtonum(optarg, 0, GOT_DIFF_MAX_CONTEXT,
5228 &errstr);
5229 if (errstr != NULL)
5230 errx(1, "number of context lines is %s: %s",
5231 errstr, optarg);
5232 break;
5233 case 'c':
5234 if (ncommit_args >= 2)
5235 errx(1, "too many -c options used");
5236 commit_args[ncommit_args++] = optarg;
5237 break;
5238 case 'd':
5239 show_diffstat = 1;
5240 break;
5241 case 'P':
5242 force_path = 1;
5243 break;
5244 case 'r':
5245 repo_path = realpath(optarg, NULL);
5246 if (repo_path == NULL)
5247 return got_error_from_errno2("realpath",
5248 optarg);
5249 got_path_strip_trailing_slashes(repo_path);
5250 rflag = 1;
5251 break;
5252 case 's':
5253 diff_staged = 1;
5254 break;
5255 case 'w':
5256 ignore_whitespace = 1;
5257 break;
5258 default:
5259 usage_diff();
5260 /* NOTREACHED */
5261 }
5262 }
5263
5264 argc -= optind;
5265 argv += optind;
5266
5267 cwd = getcwd(NULL, 0);
5268 if (cwd == NULL) {
5269 error = got_error_from_errno("getcwd");
5270 goto done;
5271 }
5272
5273 error = got_repo_pack_fds_open(&pack_fds);
5274 if (error != NULL)
5275 goto done;
5276
5277 if (repo_path == NULL) {
5278 error = got_worktree_open(&worktree, cwd,
5279 GOT_WORKTREE_GOT_DIR);
5280 if (error && error->code != GOT_ERR_NOT_WORKTREE)
5281 goto done;
5282 else
5283 error = NULL;
5284 if (worktree) {
5285 repo_path =
5286 strdup(got_worktree_get_repo_path(worktree));
5287 if (repo_path == NULL) {
5288 error = got_error_from_errno("strdup");
5289 goto done;
5290 }
5291 } else {
5292 repo_path = strdup(cwd);
5293 if (repo_path == NULL) {
5294 error = got_error_from_errno("strdup");
5295 goto done;
5296 }
5297 }
5298 }
5299
5300 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
5301 free(repo_path);
5302 if (error != NULL)
5303 goto done;
5304
5305 if (show_diffstat) {
5306 dsa.paths = &diffstat_paths;
5307 dsa.force_text = force_text_diff;
5308 dsa.ignore_ws = ignore_whitespace;
5309 dsa.diff_algo = GOT_DIFF_ALGORITHM_PATIENCE;
5310 }
5311
5312 if (rflag || worktree == NULL || ncommit_args > 0) {
5313 if (force_path) {
5314 error = got_error_msg(GOT_ERR_NOT_IMPL,
5315 "-P option can only be used when diffing "
5316 "a work tree");
5317 goto done;
5318 }
5319 if (diff_staged) {
5320 error = got_error_msg(GOT_ERR_NOT_IMPL,
5321 "-s option can only be used when diffing "
5322 "a work tree");
5323 goto done;
5324 }
5325 }
5326
5327 error = apply_unveil(got_repo_get_path(repo), 1,
5328 worktree ? got_worktree_get_root_path(worktree) : NULL);
5329 if (error)
5330 goto done;
5331
5332 if ((!force_path && argc == 2) || ncommit_args > 0) {
5333 int obj_type = (ncommit_args > 0 ?
5334 GOT_OBJ_TYPE_COMMIT : GOT_OBJ_TYPE_ANY);
5335 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
5336 NULL);
5337 if (error)
5338 goto done;
5339 for (i = 0; i < (ncommit_args > 0 ? ncommit_args : argc); i++) {
5340 const char *arg;
5341 char *keyword_idstr = NULL;
5342
5343 if (ncommit_args > 0)
5344 arg = commit_args[i];
5345 else
5346 arg = argv[i];
5347
5348 error = got_keyword_to_idstr(&keyword_idstr, arg,
5349 repo, worktree);
5350 if (error != NULL)
5351 goto done;
5352 if (keyword_idstr != NULL)
5353 arg = keyword_idstr;
5354
5355 error = got_repo_match_object_id(&ids[i], &labels[i],
5356 arg, obj_type, &refs, repo);
5357 free(keyword_idstr);
5358 if (error) {
5359 if (error->code != GOT_ERR_NOT_REF &&
5360 error->code != GOT_ERR_NO_OBJ)
5361 goto done;
5362 if (ncommit_args > 0)
5363 goto done;
5364 error = NULL;
5365 break;
5366 }
5367 }
5368 }
5369
5370 f1 = got_opentemp();
5371 if (f1 == NULL) {
5372 error = got_error_from_errno("got_opentemp");
5373 goto done;
5374 }
5375
5376 f2 = got_opentemp();
5377 if (f2 == NULL) {
5378 error = got_error_from_errno("got_opentemp");
5379 goto done;
5380 }
5381
5382 outfile = got_opentemp();
5383 if (outfile == NULL) {
5384 error = got_error_from_errno("got_opentemp");
5385 goto done;
5386 }
5387
5388 if (ncommit_args == 0 && (ids[0] == NULL || ids[1] == NULL)) {
5389 struct print_diff_arg arg;
5390 char *id_str;
5391
5392 if (worktree == NULL) {
5393 if (argc == 2 && ids[0] == NULL) {
5394 error = got_error_path(argv[0], GOT_ERR_NO_OBJ);
5395 goto done;
5396 } else if (argc == 2 && ids[1] == NULL) {
5397 error = got_error_path(argv[1], GOT_ERR_NO_OBJ);
5398 goto done;
5399 } else if (argc > 0) {
5400 error = got_error_fmt(GOT_ERR_NOT_WORKTREE,
5401 "%s", "specified paths cannot be resolved");
5402 goto done;
5403 } else {
5404 error = got_error(GOT_ERR_NOT_WORKTREE);
5405 goto done;
5406 }
5407 }
5408
5409 error = get_worktree_paths_from_argv(&paths, argc, argv,
5410 worktree);
5411 if (error)
5412 goto done;
5413
5414 error = got_object_id_str(&id_str,
5415 got_worktree_get_base_commit_id(worktree));
5416 if (error)
5417 goto done;
5418 arg.repo = repo;
5419 arg.worktree = worktree;
5420 arg.diff_algo = GOT_DIFF_ALGORITHM_PATIENCE;
5421 arg.diff_context = diff_context;
5422 arg.id_str = id_str;
5423 arg.header_shown = 0;
5424 arg.diff_staged = diff_staged;
5425 arg.ignore_whitespace = ignore_whitespace;
5426 arg.force_text_diff = force_text_diff;
5427 arg.diffstat = show_diffstat ? &dsa : NULL;
5428 arg.f1 = f1;
5429 arg.f2 = f2;
5430 arg.outfile = outfile;
5431
5432 error = got_worktree_status(worktree, &paths, repo, 0,
5433 print_diff, &arg, check_cancelled, NULL);
5434 free(id_str);
5435 if (error)
5436 goto done;
5437
5438 if (show_diffstat && dsa.nfiles > 0) {
5439 char *header;
5440
5441 if (asprintf(&header, "diffstat %s%s",
5442 diff_staged ? "-s " : "",
5443 got_worktree_get_root_path(worktree)) == -1) {
5444 error = got_error_from_errno("asprintf");
5445 goto done;
5446 }
5447
5448 error = print_diffstat(&dsa, header);
5449 free(header);
5450 if (error)
5451 goto done;
5452 }
5453
5454 error = printfile(outfile);
5455 goto done;
5456 }
5457
5458 if (ncommit_args == 1) {
5459 struct got_commit_object *commit;
5460 error = got_object_open_as_commit(&commit, repo, ids[0]);
5461 if (error)
5462 goto done;
5463
5464 labels[1] = labels[0];
5465 ids[1] = ids[0];
5466 if (got_object_commit_get_nparents(commit) > 0) {
5467 const struct got_object_id_queue *pids;
5468 struct got_object_qid *pid;
5469 pids = got_object_commit_get_parent_ids(commit);
5470 pid = STAILQ_FIRST(pids);
5471 ids[0] = got_object_id_dup(&pid->id);
5472 if (ids[0] == NULL) {
5473 error = got_error_from_errno(
5474 "got_object_id_dup");
5475 got_object_commit_close(commit);
5476 goto done;
5477 }
5478 error = got_object_id_str(&labels[0], ids[0]);
5479 if (error) {
5480 got_object_commit_close(commit);
5481 goto done;
5482 }
5483 } else {
5484 ids[0] = NULL;
5485 labels[0] = strdup("/dev/null");
5486 if (labels[0] == NULL) {
5487 error = got_error_from_errno("strdup");
5488 got_object_commit_close(commit);
5489 goto done;
5490 }
5491 }
5492
5493 got_object_commit_close(commit);
5494 }
5495
5496 if (ncommit_args == 0 && argc > 2) {
5497 error = got_error_msg(GOT_ERR_BAD_PATH,
5498 "path arguments cannot be used when diffing two objects");
5499 goto done;
5500 }
5501
5502 if (ids[0]) {
5503 error = got_object_get_type(&type1, repo, ids[0]);
5504 if (error)
5505 goto done;
5506 }
5507
5508 error = got_object_get_type(&type2, repo, ids[1]);
5509 if (error)
5510 goto done;
5511 if (type1 != GOT_OBJ_TYPE_ANY && type1 != type2) {
5512 error = got_error(GOT_ERR_OBJ_TYPE);
5513 goto done;
5514 }
5515 if (type1 == GOT_OBJ_TYPE_BLOB && argc > 2) {
5516 error = got_error_msg(GOT_ERR_OBJ_TYPE,
5517 "path arguments cannot be used when diffing blobs");
5518 goto done;
5519 }
5520
5521 for (i = 0; ncommit_args > 0 && i < argc; i++) {
5522 char *in_repo_path;
5523 struct got_pathlist_entry *new;
5524 if (worktree) {
5525 const char *prefix;
5526 char *p;
5527 error = got_worktree_resolve_path(&p, worktree,
5528 argv[i]);
5529 if (error)
5530 goto done;
5531 prefix = got_worktree_get_path_prefix(worktree);
5532 while (prefix[0] == '/')
5533 prefix++;
5534 if (asprintf(&in_repo_path, "%s%s%s", prefix,
5535 (p[0] != '\0' && prefix[0] != '\0') ? "/" : "",
5536 p) == -1) {
5537 error = got_error_from_errno("asprintf");
5538 free(p);
5539 goto done;
5540 }
5541 free(p);
5542 } else {
5543 char *mapped_path, *s;
5544 error = got_repo_map_path(&mapped_path, repo, argv[i]);
5545 if (error)
5546 goto done;
5547 s = mapped_path;
5548 while (s[0] == '/')
5549 s++;
5550 in_repo_path = strdup(s);
5551 if (in_repo_path == NULL) {
5552 error = got_error_from_errno("asprintf");
5553 free(mapped_path);
5554 goto done;
5555 }
5556 free(mapped_path);
5557
5558 }
5559 error = got_pathlist_insert(&new, &paths, in_repo_path, NULL);
5560 if (error || new == NULL /* duplicate */)
5561 free(in_repo_path);
5562 if (error)
5563 goto done;
5564 }
5565
5566 if (worktree) {
5567 /* Release work tree lock. */
5568 got_worktree_close(worktree);
5569 worktree = NULL;
5570 }
5571
5572 fd1 = got_opentempfd();
5573 if (fd1 == -1) {
5574 error = got_error_from_errno("got_opentempfd");
5575 goto done;
5576 }
5577
5578 fd2 = got_opentempfd();
5579 if (fd2 == -1) {
5580 error = got_error_from_errno("got_opentempfd");
5581 goto done;
5582 }
5583
5584 switch (type1 == GOT_OBJ_TYPE_ANY ? type2 : type1) {
5585 case GOT_OBJ_TYPE_BLOB:
5586 error = got_diff_objects_as_blobs(NULL, NULL, f1, f2,
5587 fd1, fd2, ids[0], ids[1], NULL, NULL,
5588 GOT_DIFF_ALGORITHM_PATIENCE, diff_context,
5589 ignore_whitespace, force_text_diff,
5590 show_diffstat ? &dsa : NULL, repo, outfile);
5591 break;
5592 case GOT_OBJ_TYPE_TREE:
5593 error = got_diff_objects_as_trees(NULL, NULL, f1, f2, fd1, fd2,
5594 ids[0], ids[1], &paths, "", "",
5595 GOT_DIFF_ALGORITHM_PATIENCE, diff_context,
5596 ignore_whitespace, force_text_diff,
5597 show_diffstat ? &dsa : NULL, repo, outfile);
5598 break;
5599 case GOT_OBJ_TYPE_COMMIT:
5600 fprintf(outfile, "diff %s %s\n", labels[0], labels[1]);
5601 error = got_diff_objects_as_commits(NULL, NULL, f1, f2,
5602 fd1, fd2, ids[0], ids[1], &paths,
5603 GOT_DIFF_ALGORITHM_PATIENCE, diff_context,
5604 ignore_whitespace, force_text_diff,
5605 show_diffstat ? &dsa : NULL, repo, outfile);
5606 break;
5607 default:
5608 error = got_error(GOT_ERR_OBJ_TYPE);
5609 }
5610 if (error)
5611 goto done;
5612
5613 if (show_diffstat && dsa.nfiles > 0) {
5614 char *header = NULL;
5615
5616 if (asprintf(&header, "diffstat %s %s",
5617 labels[0], labels[1]) == -1) {
5618 error = got_error_from_errno("asprintf");
5619 goto done;
5620 }
5621
5622 error = print_diffstat(&dsa, header);
5623 free(header);
5624 if (error)
5625 goto done;
5626 }
5627
5628 error = printfile(outfile);
5629
5630 done:
5631 free(labels[0]);
5632 free(labels[1]);
5633 free(ids[0]);
5634 free(ids[1]);
5635 if (worktree)
5636 got_worktree_close(worktree);
5637 if (repo) {
5638 const struct got_error *close_err = got_repo_close(repo);
5639 if (error == NULL)
5640 error = close_err;
5641 }
5642 if (pack_fds) {
5643 const struct got_error *pack_err =
5644 got_repo_pack_fds_close(pack_fds);
5645 if (error == NULL)
5646 error = pack_err;
5647 }
5648 got_pathlist_free(&paths, GOT_PATHLIST_FREE_PATH);
5649 got_pathlist_free(&diffstat_paths, GOT_PATHLIST_FREE_ALL);
5650 got_ref_list_free(&refs);
5651 if (outfile && fclose(outfile) == EOF && error == NULL)
5652 error = got_error_from_errno("fclose");
5653 if (f1 && fclose(f1) == EOF && error == NULL)
5654 error = got_error_from_errno("fclose");
5655 if (f2 && fclose(f2) == EOF && error == NULL)
5656 error = got_error_from_errno("fclose");
5657 if (fd1 != -1 && close(fd1) == -1 && error == NULL)
5658 error = got_error_from_errno("close");
5659 if (fd2 != -1 && close(fd2) == -1 && error == NULL)
5660 error = got_error_from_errno("close");
5661 return error;
5662 }
5663
5664 __dead static void
5665 usage_blame(void)
5666 {
5667 fprintf(stderr,
5668 "usage: %s blame [-c commit] [-r repository-path] path\n",
5669 getprogname());
5670 exit(1);
5671 }
5672
5673 struct blame_line {
5674 int annotated;
5675 char *id_str;
5676 char *committer;
5677 char datebuf[11]; /* YYYY-MM-DD + NUL */
5678 };
5679
5680 struct blame_cb_args {
5681 struct blame_line *lines;
5682 int nlines;
5683 int nlines_prec;
5684 int lineno_cur;
5685 off_t *line_offsets;
5686 FILE *f;
5687 struct got_repository *repo;
5688 };
5689
5690 static const struct got_error *
5691 blame_cb(void *arg, int nlines, int lineno,
5692 struct got_commit_object *commit, struct got_object_id *id)
5693 {
5694 const struct got_error *err = NULL;
5695 struct blame_cb_args *a = arg;
5696 struct blame_line *bline;
5697 char *line = NULL;
5698 size_t linesize = 0;
5699 off_t offset;
5700 struct tm tm;
5701 time_t committer_time;
5702
5703 if (nlines != a->nlines ||
5704 (lineno != -1 && lineno < 1) || lineno > a->nlines)
5705 return got_error(GOT_ERR_RANGE);
5706
5707 if (sigint_received)
5708 return got_error(GOT_ERR_ITER_COMPLETED);
5709
5710 if (lineno == -1)
5711 return NULL; /* no change in this commit */
5712
5713 /* Annotate this line. */
5714 bline = &a->lines[lineno - 1];
5715 if (bline->annotated)
5716 return NULL;
5717 err = got_object_id_str(&bline->id_str, id);
5718 if (err)
5719 return err;
5720
5721 bline->committer = strdup(got_object_commit_get_committer(commit));
5722 if (bline->committer == NULL) {
5723 err = got_error_from_errno("strdup");
5724 goto done;
5725 }
5726
5727 committer_time = got_object_commit_get_committer_time(commit);
5728 if (gmtime_r(&committer_time, &tm) == NULL)
5729 return got_error_from_errno("gmtime_r");
5730 if (strftime(bline->datebuf, sizeof(bline->datebuf), "%F", &tm) == 0) {
5731 err = got_error(GOT_ERR_NO_SPACE);
5732 goto done;
5733 }
5734 bline->annotated = 1;
5735
5736 /* Print lines annotated so far. */
5737 bline = &a->lines[a->lineno_cur - 1];
5738 if (!bline->annotated)
5739 goto done;
5740
5741 offset = a->line_offsets[a->lineno_cur - 1];
5742 if (fseeko(a->f, offset, SEEK_SET) == -1) {
5743 err = got_error_from_errno("fseeko");
5744 goto done;
5745 }
5746
5747 while (a->lineno_cur <= a->nlines && bline->annotated) {
5748 char *smallerthan, *at, *nl, *committer;
5749 size_t len;
5750
5751 if (getline(&line, &linesize, a->f) == -1) {
5752 if (ferror(a->f))
5753 err = got_error_from_errno("getline");
5754 break;
5755 }
5756
5757 committer = bline->committer;
5758 smallerthan = strchr(committer, '<');
5759 if (smallerthan && smallerthan[1] != '\0')
5760 committer = smallerthan + 1;
5761 at = strchr(committer, '@');
5762 if (at)
5763 *at = '\0';
5764 len = strlen(committer);
5765 if (len >= 9)
5766 committer[8] = '\0';
5767
5768 nl = strchr(line, '\n');
5769 if (nl)
5770 *nl = '\0';
5771 printf("%.*d) %.8s %s %-8s %s\n", a->nlines_prec, a->lineno_cur,
5772 bline->id_str, bline->datebuf, committer, line);
5773
5774 a->lineno_cur++;
5775 bline = &a->lines[a->lineno_cur - 1];
5776 }
5777 done:
5778 free(line);
5779 return err;
5780 }
5781
5782 static const struct got_error *
5783 cmd_blame(int argc, char *argv[])
5784 {
5785 const struct got_error *error;
5786 struct got_repository *repo = NULL;
5787 struct got_worktree *worktree = NULL;
5788 char *path, *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
5789 char *link_target = NULL;
5790 struct got_object_id *obj_id = NULL;
5791 struct got_object_id *commit_id = NULL;
5792 struct got_commit_object *commit = NULL;
5793 struct got_blob_object *blob = NULL;
5794 char *commit_id_str = NULL, *keyword_idstr = NULL;
5795 struct blame_cb_args bca;
5796 int ch, obj_type, i, fd1 = -1, fd2 = -1, fd3 = -1;
5797 off_t filesize;
5798 int *pack_fds = NULL;
5799 FILE *f1 = NULL, *f2 = NULL;
5800
5801 fd1 = got_opentempfd();
5802 if (fd1 == -1)
5803 return got_error_from_errno("got_opentempfd");
5804
5805 memset(&bca, 0, sizeof(bca));
5806
5807 #ifndef PROFILE
5808 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
5809 NULL) == -1)
5810 err(1, "pledge");
5811 #endif
5812
5813 while ((ch = getopt(argc, argv, "c:r:")) != -1) {
5814 switch (ch) {
5815 case 'c':
5816 commit_id_str = optarg;
5817 break;
5818 case 'r':
5819 repo_path = realpath(optarg, NULL);
5820 if (repo_path == NULL)
5821 return got_error_from_errno2("realpath",
5822 optarg);
5823 got_path_strip_trailing_slashes(repo_path);
5824 break;
5825 default:
5826 usage_blame();
5827 /* NOTREACHED */
5828 }
5829 }
5830
5831 argc -= optind;
5832 argv += optind;
5833
5834 if (argc == 1)
5835 path = argv[0];
5836 else
5837 usage_blame();
5838
5839 cwd = getcwd(NULL, 0);
5840 if (cwd == NULL) {
5841 error = got_error_from_errno("getcwd");
5842 goto done;
5843 }
5844
5845 error = got_repo_pack_fds_open(&pack_fds);
5846 if (error != NULL)
5847 goto done;
5848
5849 if (repo_path == NULL) {
5850 error = got_worktree_open(&worktree, cwd,
5851 GOT_WORKTREE_GOT_DIR);
5852 if (error && error->code != GOT_ERR_NOT_WORKTREE)
5853 goto done;
5854 else
5855 error = NULL;
5856 if (worktree) {
5857 repo_path =
5858 strdup(got_worktree_get_repo_path(worktree));
5859 if (repo_path == NULL) {
5860 error = got_error_from_errno("strdup");
5861 if (error)
5862 goto done;
5863 }
5864 } else {
5865 repo_path = strdup(cwd);
5866 if (repo_path == NULL) {
5867 error = got_error_from_errno("strdup");
5868 goto done;
5869 }
5870 }
5871 }
5872
5873 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
5874 if (error != NULL)
5875 goto done;
5876
5877 if (worktree) {
5878 const char *prefix = got_worktree_get_path_prefix(worktree);
5879 char *p;
5880
5881 error = got_worktree_resolve_path(&p, worktree, path);
5882 if (error)
5883 goto done;
5884 if (asprintf(&in_repo_path, "%s%s%s", prefix,
5885 (p[0] != '\0' && !got_path_is_root_dir(prefix)) ? "/" : "",
5886 p) == -1) {
5887 error = got_error_from_errno("asprintf");
5888 free(p);
5889 goto done;
5890 }
5891 free(p);
5892 error = apply_unveil(got_repo_get_path(repo), 1, NULL);
5893 } else {
5894 error = apply_unveil(got_repo_get_path(repo), 1, NULL);
5895 if (error)
5896 goto done;
5897 error = got_repo_map_path(&in_repo_path, repo, path);
5898 }
5899 if (error)
5900 goto done;
5901
5902 if (commit_id_str == NULL) {
5903 struct got_reference *head_ref;
5904 error = got_ref_open(&head_ref, repo, worktree ?
5905 got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD, 0);
5906 if (error != NULL)
5907 goto done;
5908 error = got_ref_resolve(&commit_id, repo, head_ref);
5909 got_ref_close(head_ref);
5910 if (error != NULL)
5911 goto done;
5912 } else {
5913 struct got_reflist_head refs;
5914
5915 TAILQ_INIT(&refs);
5916 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
5917 NULL);
5918 if (error)
5919 goto done;
5920
5921 error = got_keyword_to_idstr(&keyword_idstr, commit_id_str,
5922 repo, worktree);
5923 if (error != NULL)
5924 goto done;
5925 if (keyword_idstr != NULL)
5926 commit_id_str = keyword_idstr;
5927
5928 error = got_repo_match_object_id(&commit_id, NULL,
5929 commit_id_str, GOT_OBJ_TYPE_COMMIT, &refs, repo);
5930 got_ref_list_free(&refs);
5931 if (error)
5932 goto done;
5933 }
5934
5935 if (worktree) {
5936 /* Release work tree lock. */
5937 got_worktree_close(worktree);
5938 worktree = NULL;
5939 }
5940
5941 error = got_object_open_as_commit(&commit, repo, commit_id);
5942 if (error)
5943 goto done;
5944
5945 error = got_object_resolve_symlinks(&link_target, in_repo_path,
5946 commit, repo);
5947 if (error)
5948 goto done;
5949
5950 error = got_object_id_by_path(&obj_id, repo, commit,
5951 link_target ? link_target : in_repo_path);
5952 if (error)
5953 goto done;
5954
5955 error = got_object_get_type(&obj_type, repo, obj_id);
5956 if (error)
5957 goto done;
5958
5959 if (obj_type != GOT_OBJ_TYPE_BLOB) {
5960 error = got_error_path(link_target ? link_target : in_repo_path,
5961 GOT_ERR_OBJ_TYPE);
5962 goto done;
5963 }
5964
5965 error = got_object_open_as_blob(&blob, repo, obj_id, 8192, fd1);
5966 if (error)
5967 goto done;
5968 bca.f = got_opentemp();
5969 if (bca.f == NULL) {
5970 error = got_error_from_errno("got_opentemp");
5971 goto done;
5972 }
5973 error = got_object_blob_dump_to_file(&filesize, &bca.nlines,
5974 &bca.line_offsets, bca.f, blob);
5975 if (error || bca.nlines == 0)
5976 goto done;
5977
5978 /* Don't include \n at EOF in the blame line count. */
5979 if (bca.line_offsets[bca.nlines - 1] == filesize)
5980 bca.nlines--;
5981
5982 bca.lines = calloc(bca.nlines, sizeof(*bca.lines));
5983 if (bca.lines == NULL) {
5984 error = got_error_from_errno("calloc");
5985 goto done;
5986 }
5987 bca.lineno_cur = 1;
5988 bca.nlines_prec = 0;
5989 i = bca.nlines;
5990 while (i > 0) {
5991 i /= 10;
5992 bca.nlines_prec++;
5993 }
5994 bca.repo = repo;
5995
5996 fd2 = got_opentempfd();
5997 if (fd2 == -1) {
5998 error = got_error_from_errno("got_opentempfd");
5999 goto done;
6000 }
6001 fd3 = got_opentempfd();
6002 if (fd3 == -1) {
6003 error = got_error_from_errno("got_opentempfd");
6004 goto done;
6005 }
6006 f1 = got_opentemp();
6007 if (f1 == NULL) {
6008 error = got_error_from_errno("got_opentemp");
6009 goto done;
6010 }
6011 f2 = got_opentemp();
6012 if (f2 == NULL) {
6013 error = got_error_from_errno("got_opentemp");
6014 goto done;
6015 }
6016 error = got_blame(link_target ? link_target : in_repo_path, commit_id,
6017 repo, GOT_DIFF_ALGORITHM_PATIENCE, blame_cb, &bca,
6018 check_cancelled, NULL, fd2, fd3, f1, f2);
6019 done:
6020 free(keyword_idstr);
6021 free(in_repo_path);
6022 free(link_target);
6023 free(repo_path);
6024 free(cwd);
6025 free(commit_id);
6026 free(obj_id);
6027 if (commit)
6028 got_object_commit_close(commit);
6029
6030 if (fd1 != -1 && close(fd1) == -1 && error == NULL)
6031 error = got_error_from_errno("close");
6032 if (fd2 != -1 && close(fd2) == -1 && error == NULL)
6033 error = got_error_from_errno("close");
6034 if (fd3 != -1 && close(fd3) == -1 && error == NULL)
6035 error = got_error_from_errno("close");
6036 if (f1 && fclose(f1) == EOF && error == NULL)
6037 error = got_error_from_errno("fclose");
6038 if (f2 && fclose(f2) == EOF && error == NULL)
6039 error = got_error_from_errno("fclose");
6040
6041 if (blob)
6042 got_object_blob_close(blob);
6043 if (worktree)
6044 got_worktree_close(worktree);
6045 if (repo) {
6046 const struct got_error *close_err = got_repo_close(repo);
6047 if (error == NULL)
6048 error = close_err;
6049 }
6050 if (pack_fds) {
6051 const struct got_error *pack_err =
6052 got_repo_pack_fds_close(pack_fds);
6053 if (error == NULL)
6054 error = pack_err;
6055 }
6056 if (bca.lines) {
6057 for (i = 0; i < bca.nlines; i++) {
6058 struct blame_line *bline = &bca.lines[i];
6059 free(bline->id_str);
6060 free(bline->committer);
6061 }
6062 free(bca.lines);
6063 }
6064 free(bca.line_offsets);
6065 if (bca.f && fclose(bca.f) == EOF && error == NULL)
6066 error = got_error_from_errno("fclose");
6067 return error;
6068 }
6069
6070 __dead static void
6071 usage_tree(void)
6072 {
6073 fprintf(stderr, "usage: %s tree [-iR] [-c commit] [-r repository-path] "
6074 "[path]\n", getprogname());
6075 exit(1);
6076 }
6077
6078 static const struct got_error *
6079 print_entry(struct got_tree_entry *te, const char *id, const char *path,
6080 const char *root_path, struct got_repository *repo)
6081 {
6082 const struct got_error *err = NULL;
6083 int is_root_path = (strcmp(path, root_path) == 0);
6084 const char *modestr = "";
6085 mode_t mode = got_tree_entry_get_mode(te);
6086 char *link_target = NULL;
6087
6088 path += strlen(root_path);
6089 while (path[0] == '/')
6090 path++;
6091
6092 if (got_object_tree_entry_is_submodule(te))
6093 modestr = "$";
6094 else if (S_ISLNK(mode)) {
6095 int i;
6096
6097 err = got_tree_entry_get_symlink_target(&link_target, te, repo);
6098 if (err)
6099 return err;
6100 for (i = 0; link_target[i] != '\0'; i++) {
6101 if (!isprint((unsigned char)link_target[i]))
6102 link_target[i] = '?';
6103 }
6104
6105 modestr = "@";
6106 }
6107 else if (S_ISDIR(mode))
6108 modestr = "/";
6109 else if (mode & S_IXUSR)
6110 modestr = "*";
6111
6112 printf("%s%s%s%s%s%s%s\n", id ? id : "", path,
6113 is_root_path ? "" : "/", got_tree_entry_get_name(te), modestr,
6114 link_target ? " -> ": "", link_target ? link_target : "");
6115
6116 free(link_target);
6117 return NULL;
6118 }
6119
6120 static const struct got_error *
6121 print_tree(const char *path, struct got_commit_object *commit,
6122 int show_ids, int recurse, const char *root_path,
6123 struct got_repository *repo)
6124 {
6125 const struct got_error *err = NULL;
6126 struct got_object_id *tree_id = NULL;
6127 struct got_tree_object *tree = NULL;
6128 int nentries, i;
6129
6130 err = got_object_id_by_path(&tree_id, repo, commit, path);
6131 if (err)
6132 goto done;
6133
6134 err = got_object_open_as_tree(&tree, repo, tree_id);
6135 if (err)
6136 goto done;
6137 nentries = got_object_tree_get_nentries(tree);
6138 for (i = 0; i < nentries; i++) {
6139 struct got_tree_entry *te;
6140 char *id = NULL;
6141
6142 if (sigint_received || sigpipe_received)
6143 break;
6144
6145 te = got_object_tree_get_entry(tree, i);
6146 if (show_ids) {
6147 char *id_str;
6148 err = got_object_id_str(&id_str,
6149 got_tree_entry_get_id(te));
6150 if (err)
6151 goto done;
6152 if (asprintf(&id, "%s ", id_str) == -1) {
6153 err = got_error_from_errno("asprintf");
6154 free(id_str);
6155 goto done;
6156 }
6157 free(id_str);
6158 }
6159 err = print_entry(te, id, path, root_path, repo);
6160 free(id);
6161 if (err)
6162 goto done;
6163
6164 if (recurse && S_ISDIR(got_tree_entry_get_mode(te))) {
6165 char *child_path;
6166 if (asprintf(&child_path, "%s%s%s", path,
6167 path[0] == '/' && path[1] == '\0' ? "" : "/",
6168 got_tree_entry_get_name(te)) == -1) {
6169 err = got_error_from_errno("asprintf");
6170 goto done;
6171 }
6172 err = print_tree(child_path, commit, show_ids, 1,
6173 root_path, repo);
6174 free(child_path);
6175 if (err)
6176 goto done;
6177 }
6178 }
6179 done:
6180 if (tree)
6181 got_object_tree_close(tree);
6182 free(tree_id);
6183 return err;
6184 }
6185
6186 static const struct got_error *
6187 cmd_tree(int argc, char *argv[])
6188 {
6189 const struct got_error *error;
6190 struct got_repository *repo = NULL;
6191 struct got_worktree *worktree = NULL;
6192 const char *path, *refname = NULL;
6193 char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
6194 struct got_object_id *commit_id = NULL;
6195 struct got_commit_object *commit = NULL;
6196 char *commit_id_str = NULL, *keyword_idstr = NULL;
6197 int show_ids = 0, recurse = 0;
6198 int ch;
6199 int *pack_fds = NULL;
6200
6201 #ifndef PROFILE
6202 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
6203 NULL) == -1)
6204 err(1, "pledge");
6205 #endif
6206
6207 while ((ch = getopt(argc, argv, "c:iRr:")) != -1) {
6208 switch (ch) {
6209 case 'c':
6210 commit_id_str = optarg;
6211 break;
6212 case 'i':
6213 show_ids = 1;
6214 break;
6215 case 'R':
6216 recurse = 1;
6217 break;
6218 case 'r':
6219 repo_path = realpath(optarg, NULL);
6220 if (repo_path == NULL)
6221 return got_error_from_errno2("realpath",
6222 optarg);
6223 got_path_strip_trailing_slashes(repo_path);
6224 break;
6225 default:
6226 usage_tree();
6227 /* NOTREACHED */
6228 }
6229 }
6230
6231 argc -= optind;
6232 argv += optind;
6233
6234 if (argc == 1)
6235 path = argv[0];
6236 else if (argc > 1)
6237 usage_tree();
6238 else
6239 path = NULL;
6240
6241 cwd = getcwd(NULL, 0);
6242 if (cwd == NULL) {
6243 error = got_error_from_errno("getcwd");
6244 goto done;
6245 }
6246
6247 error = got_repo_pack_fds_open(&pack_fds);
6248 if (error != NULL)
6249 goto done;
6250
6251 if (repo_path == NULL) {
6252 error = got_worktree_open(&worktree, cwd,
6253 GOT_WORKTREE_GOT_DIR);
6254 if (error && error->code != GOT_ERR_NOT_WORKTREE)
6255 goto done;
6256 else
6257 error = NULL;
6258 if (worktree) {
6259 repo_path =
6260 strdup(got_worktree_get_repo_path(worktree));
6261 if (repo_path == NULL)
6262 error = got_error_from_errno("strdup");
6263 if (error)
6264 goto done;
6265 } else {
6266 repo_path = strdup(cwd);
6267 if (repo_path == NULL) {
6268 error = got_error_from_errno("strdup");
6269 goto done;
6270 }
6271 }
6272 }
6273
6274 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
6275 if (error != NULL)
6276 goto done;
6277
6278 if (worktree) {
6279 const char *prefix = got_worktree_get_path_prefix(worktree);
6280 char *p;
6281
6282 if (path == NULL || got_path_is_root_dir(path))
6283 path = "";
6284 error = got_worktree_resolve_path(&p, worktree, path);
6285 if (error)
6286 goto done;
6287 if (asprintf(&in_repo_path, "%s%s%s", prefix,
6288 (p[0] != '\0' && !got_path_is_root_dir(prefix)) ? "/" : "",
6289 p) == -1) {
6290 error = got_error_from_errno("asprintf");
6291 free(p);
6292 goto done;
6293 }
6294 free(p);
6295 error = apply_unveil(got_repo_get_path(repo), 1, NULL);
6296 if (error)
6297 goto done;
6298 } else {
6299 error = apply_unveil(got_repo_get_path(repo), 1, NULL);
6300 if (error)
6301 goto done;
6302 if (path == NULL)
6303 path = "/";
6304 error = got_repo_map_path(&in_repo_path, repo, path);
6305 if (error != NULL)
6306 goto done;
6307 }
6308
6309 if (commit_id_str == NULL) {
6310 struct got_reference *head_ref;
6311 if (worktree)
6312 refname = got_worktree_get_head_ref_name(worktree);
6313 else
6314 refname = GOT_REF_HEAD;
6315 error = got_ref_open(&head_ref, repo, refname, 0);
6316 if (error != NULL)
6317 goto done;
6318 error = got_ref_resolve(&commit_id, repo, head_ref);
6319 got_ref_close(head_ref);
6320 if (error != NULL)
6321 goto done;
6322 } else {
6323 struct got_reflist_head refs;
6324
6325 TAILQ_INIT(&refs);
6326 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
6327 NULL);
6328 if (error)
6329 goto done;
6330
6331 error = got_keyword_to_idstr(&keyword_idstr, commit_id_str,
6332 repo, worktree);
6333 if (error != NULL)
6334 goto done;
6335 if (keyword_idstr != NULL)
6336 commit_id_str = keyword_idstr;
6337
6338 error = got_repo_match_object_id(&commit_id, NULL,
6339 commit_id_str, GOT_OBJ_TYPE_COMMIT, &refs, repo);
6340 got_ref_list_free(&refs);
6341 if (error)
6342 goto done;
6343 }
6344
6345 if (worktree) {
6346 /* Release work tree lock. */
6347 got_worktree_close(worktree);
6348 worktree = NULL;
6349 }
6350
6351 error = got_object_open_as_commit(&commit, repo, commit_id);
6352 if (error)
6353 goto done;
6354
6355 error = print_tree(in_repo_path, commit, show_ids, recurse,
6356 in_repo_path, repo);
6357 done:
6358 free(keyword_idstr);
6359 free(in_repo_path);
6360 free(repo_path);
6361 free(cwd);
6362 free(commit_id);
6363 if (commit)
6364 got_object_commit_close(commit);
6365 if (worktree)
6366 got_worktree_close(worktree);
6367 if (repo) {
6368 const struct got_error *close_err = got_repo_close(repo);
6369 if (error == NULL)
6370 error = close_err;
6371 }
6372 if (pack_fds) {
6373 const struct got_error *pack_err =
6374 got_repo_pack_fds_close(pack_fds);
6375 if (error == NULL)
6376 error = pack_err;
6377 }
6378 return error;
6379 }
6380
6381 __dead static void
6382 usage_status(void)
6383 {
6384 fprintf(stderr, "usage: %s status [-I] [-S status-codes] "
6385 "[-s status-codes] [path ...]\n", getprogname());
6386 exit(1);
6387 }
6388
6389 struct got_status_arg {
6390 char *status_codes;
6391 int suppress;
6392 };
6393
6394 static const struct got_error *
6395 print_status(void *arg, unsigned char status, unsigned char staged_status,
6396 const char *path, struct got_object_id *blob_id,
6397 struct got_object_id *staged_blob_id, struct got_object_id *commit_id,
6398 int dirfd, const char *de_name)
6399 {
6400 struct got_status_arg *st = arg;
6401
6402 if (status == staged_status && (status == GOT_STATUS_DELETE))
6403 status = GOT_STATUS_NO_CHANGE;
6404 if (st != NULL && st->status_codes) {
6405 size_t ncodes = strlen(st->status_codes);
6406 int i, j = 0;
6407
6408 for (i = 0; i < ncodes ; i++) {
6409 if (st->suppress) {
6410 if (status == st->status_codes[i] ||
6411 staged_status == st->status_codes[i]) {
6412 j++;
6413 continue;
6414 }
6415 } else {
6416 if (status == st->status_codes[i] ||
6417 staged_status == st->status_codes[i])
6418 break;
6419 }
6420 }
6421
6422 if (st->suppress && j == 0)
6423 goto print;
6424
6425 if (i == ncodes)
6426 return NULL;
6427 }
6428 print:
6429 printf("%c%c %s\n", status, staged_status, path);
6430 return NULL;
6431 }
6432
6433 static const struct got_error *
6434 show_operation_in_progress(struct got_worktree *worktree,
6435 struct got_repository *repo)
6436 {
6437 const struct got_error *err;
6438 char *new_base_branch_name = NULL;
6439 char *branch_name = NULL;
6440 int rebase_in_progress, histedit_in_progress, merge_in_progress;
6441
6442 err = got_worktree_rebase_in_progress(&rebase_in_progress, worktree);
6443 if (err)
6444 return err;
6445 if (rebase_in_progress) {
6446 err = got_worktree_rebase_info(&new_base_branch_name,
6447 &branch_name, worktree, repo);
6448 if (err)
6449 return err;
6450 printf("Work tree is rebasing %s onto %s\n",
6451 branch_name, new_base_branch_name);
6452 }
6453
6454 err = got_worktree_histedit_in_progress(&histedit_in_progress,
6455 worktree);
6456 if (err)
6457 return err;
6458 if (histedit_in_progress) {
6459 err = got_worktree_histedit_info(&branch_name, worktree, repo);
6460 if (err)
6461 return err;
6462 printf("Work tree is editing the history of %s\n", branch_name);
6463 }
6464
6465 err = got_worktree_merge_in_progress(&merge_in_progress,
6466 worktree, repo);
6467 if (err)
6468 return err;
6469 if (merge_in_progress) {
6470 err = got_worktree_merge_info(&branch_name, worktree,
6471 repo);
6472 if (err)
6473 return err;
6474 printf("Work tree is merging %s into %s\n", branch_name,
6475 got_worktree_get_head_ref_name(worktree));
6476 }
6477
6478 free(new_base_branch_name);
6479 free(branch_name);
6480 return NULL;
6481 }
6482
6483 static const struct got_error *
6484 cmd_status(int argc, char *argv[])
6485 {
6486 const struct got_error *close_err, *error = NULL;
6487 struct got_repository *repo = NULL;
6488 struct got_worktree *worktree = NULL;
6489 struct got_status_arg st;
6490 char *cwd = NULL;
6491 struct got_pathlist_head paths;
6492 int ch, i, no_ignores = 0;
6493 int *pack_fds = NULL;
6494
6495 TAILQ_INIT(&paths);
6496
6497 memset(&st, 0, sizeof(st));
6498 st.status_codes = NULL;
6499 st.suppress = 0;
6500
6501 #ifndef PROFILE
6502 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
6503 NULL) == -1)
6504 err(1, "pledge");
6505 #endif
6506
6507 while ((ch = getopt(argc, argv, "IS:s:")) != -1) {
6508 switch (ch) {
6509 case 'I':
6510 no_ignores = 1;
6511 break;
6512 case 'S':
6513 if (st.status_codes != NULL && st.suppress == 0)
6514 option_conflict('S', 's');
6515 st.suppress = 1;
6516 /* fallthrough */
6517 case 's':
6518 for (i = 0; optarg[i] != '\0'; i++) {
6519 switch (optarg[i]) {
6520 case GOT_STATUS_MODIFY:
6521 case GOT_STATUS_ADD:
6522 case GOT_STATUS_DELETE:
6523 case GOT_STATUS_CONFLICT:
6524 case GOT_STATUS_MISSING:
6525 case GOT_STATUS_OBSTRUCTED:
6526 case GOT_STATUS_UNVERSIONED:
6527 case GOT_STATUS_MODE_CHANGE:
6528 case GOT_STATUS_NONEXISTENT:
6529 break;
6530 default:
6531 errx(1, "invalid status code '%c'",
6532 optarg[i]);
6533 }
6534 }
6535 if (ch == 's' && st.suppress)
6536 option_conflict('s', 'S');
6537 st.status_codes = optarg;
6538 break;
6539 default:
6540 usage_status();
6541 /* NOTREACHED */
6542 }
6543 }
6544
6545 argc -= optind;
6546 argv += optind;
6547
6548 cwd = getcwd(NULL, 0);
6549 if (cwd == NULL) {
6550 error = got_error_from_errno("getcwd");
6551 goto done;
6552 }
6553
6554 error = got_repo_pack_fds_open(&pack_fds);
6555 if (error != NULL)
6556 goto done;
6557
6558 error = got_worktree_open(&worktree, cwd,
6559 GOT_WORKTREE_GOT_DIR);
6560 if (error) {
6561 if (error->code == GOT_ERR_NOT_WORKTREE)
6562 error = wrap_not_worktree_error(error, "status", cwd);
6563 goto done;
6564 }
6565
6566 error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
6567 NULL, pack_fds);
6568 if (error != NULL)
6569 goto done;
6570
6571 error = apply_unveil(got_repo_get_path(repo), 1,
6572 got_worktree_get_root_path(worktree));
6573 if (error)
6574 goto done;
6575
6576 error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
6577 if (error)
6578 goto done;
6579
6580 error = got_worktree_status(worktree, &paths, repo, no_ignores,
6581 print_status, &st, check_cancelled, NULL);
6582 if (error)
6583 goto done;
6584
6585 error = show_operation_in_progress(worktree, repo);
6586 done:
6587 if (pack_fds) {
6588 const struct got_error *pack_err =
6589 got_repo_pack_fds_close(pack_fds);
6590 if (error == NULL)
6591 error = pack_err;
6592 }
6593 if (repo) {
6594 close_err = got_repo_close(repo);
6595 if (error == NULL)
6596 error = close_err;
6597 }
6598 if (worktree != NULL) {
6599 close_err = got_worktree_close(worktree);
6600 if (error == NULL)
6601 error = close_err;
6602 }
6603
6604 got_pathlist_free(&paths, GOT_PATHLIST_FREE_PATH);
6605 free(cwd);
6606 return error;
6607 }
6608
6609 __dead static void
6610 usage_ref(void)
6611 {
6612 fprintf(stderr, "usage: %s ref [-dlt] [-c object] [-r repository-path] "
6613 "[-s reference] [name]\n", getprogname());
6614 exit(1);
6615 }
6616
6617 static const struct got_error *
6618 list_refs(struct got_repository *repo, const char *refname, int sort_by_time)
6619 {
6620 static const struct got_error *err = NULL;
6621 struct got_reflist_head refs;
6622 struct got_reflist_entry *re;
6623
6624 TAILQ_INIT(&refs);
6625 err = got_ref_list(&refs, repo, refname, sort_by_time ?
6626 got_ref_cmp_by_commit_timestamp_descending : got_ref_cmp_by_name,
6627 repo);
6628 if (err)
6629 return err;
6630
6631 TAILQ_FOREACH(re, &refs, entry) {
6632 char *refstr;
6633 refstr = got_ref_to_str(re->ref);
6634 if (refstr == NULL) {
6635 err = got_error_from_errno("got_ref_to_str");
6636 break;
6637 }
6638 printf("%s: %s\n", got_ref_get_name(re->ref), refstr);
6639 free(refstr);
6640 }
6641
6642 got_ref_list_free(&refs);
6643 return err;
6644 }
6645
6646 static const struct got_error *
6647 delete_ref_by_name(struct got_repository *repo, const char *refname)
6648 {
6649 const struct got_error *err;
6650 struct got_reference *ref;
6651
6652 err = got_ref_open(&ref, repo, refname, 0);
6653 if (err)
6654 return err;
6655
6656 err = delete_ref(repo, ref);
6657 got_ref_close(ref);
6658 return err;
6659 }
6660
6661 static const struct got_error *
6662 add_ref(struct got_repository *repo, const char *refname, const char *target)
6663 {
6664 const struct got_error *err = NULL;
6665 struct got_object_id *id = NULL;
6666 struct got_reference *ref = NULL;
6667 struct got_reflist_head refs;
6668
6669 /*
6670 * Don't let the user create a reference name with a leading '-'.
6671 * While technically a valid reference name, this case is usually
6672 * an unintended typo.
6673 */
6674 if (refname[0] == '-')
6675 return got_error_path(refname, GOT_ERR_REF_NAME_MINUS);
6676
6677 TAILQ_INIT(&refs);
6678 err = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
6679 if (err)
6680 goto done;
6681 err = got_repo_match_object_id(&id, NULL, target, GOT_OBJ_TYPE_ANY,
6682 &refs, repo);
6683 got_ref_list_free(&refs);
6684 if (err)
6685 goto done;
6686
6687 err = got_ref_alloc(&ref, refname, id);
6688 if (err)
6689 goto done;
6690
6691 err = got_ref_write(ref, repo);
6692 done:
6693 if (ref)
6694 got_ref_close(ref);
6695 free(id);
6696 return err;
6697 }
6698
6699 static const struct got_error *
6700 add_symref(struct got_repository *repo, const char *refname, const char *target)
6701 {
6702 const struct got_error *err = NULL;
6703 struct got_reference *ref = NULL;
6704 struct got_reference *target_ref = NULL;
6705
6706 /*
6707 * Don't let the user create a reference name with a leading '-'.
6708 * While technically a valid reference name, this case is usually
6709 * an unintended typo.
6710 */
6711 if (refname[0] == '-')
6712 return got_error_path(refname, GOT_ERR_REF_NAME_MINUS);
6713
6714 err = got_ref_open(&target_ref, repo, target, 0);
6715 if (err)
6716 return err;
6717
6718 err = got_ref_alloc_symref(&ref, refname, target_ref);
6719 if (err)
6720 goto done;
6721
6722 err = got_ref_write(ref, repo);
6723 done:
6724 if (target_ref)
6725 got_ref_close(target_ref);
6726 if (ref)
6727 got_ref_close(ref);
6728 return err;
6729 }
6730
6731 static const struct got_error *
6732 cmd_ref(int argc, char *argv[])
6733 {
6734 const struct got_error *error = NULL;
6735 struct got_repository *repo = NULL;
6736 struct got_worktree *worktree = NULL;
6737 char *cwd = NULL, *repo_path = NULL;
6738 int ch, do_list = 0, do_delete = 0, sort_by_time = 0;
6739 const char *obj_arg = NULL, *symref_target= NULL;
6740 char *refname = NULL, *keyword_idstr = NULL;
6741 int *pack_fds = NULL;
6742
6743 #ifndef PROFILE
6744 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
6745 "sendfd unveil", NULL) == -1)
6746 err(1, "pledge");
6747 #endif
6748
6749 while ((ch = getopt(argc, argv, "c:dlr:s:t")) != -1) {
6750 switch (ch) {
6751 case 'c':
6752 obj_arg = optarg;
6753 break;
6754 case 'd':
6755 do_delete = 1;
6756 break;
6757 case 'l':
6758 do_list = 1;
6759 break;
6760 case 'r':
6761 repo_path = realpath(optarg, NULL);
6762 if (repo_path == NULL)
6763 return got_error_from_errno2("realpath",
6764 optarg);
6765 got_path_strip_trailing_slashes(repo_path);
6766 break;
6767 case 's':
6768 symref_target = optarg;
6769 break;
6770 case 't':
6771 sort_by_time = 1;
6772 break;
6773 default:
6774 usage_ref();
6775 /* NOTREACHED */
6776 }
6777 }
6778
6779 if (obj_arg && do_list)
6780 option_conflict('c', 'l');
6781 if (obj_arg && do_delete)
6782 option_conflict('c', 'd');
6783 if (obj_arg && symref_target)
6784 option_conflict('c', 's');
6785 if (symref_target && do_delete)
6786 option_conflict('s', 'd');
6787 if (symref_target && do_list)
6788 option_conflict('s', 'l');
6789 if (do_delete && do_list)
6790 option_conflict('d', 'l');
6791 if (sort_by_time && !do_list)
6792 errx(1, "-t option requires -l option");
6793
6794 argc -= optind;
6795 argv += optind;
6796
6797 if (do_list) {
6798 if (argc != 0 && argc != 1)
6799 usage_ref();
6800 if (argc == 1) {
6801 refname = strdup(argv[0]);
6802 if (refname == NULL) {
6803 error = got_error_from_errno("strdup");
6804 goto done;
6805 }
6806 }
6807 } else {
6808 if (argc != 1)
6809 usage_ref();
6810 refname = strdup(argv[0]);
6811 if (refname == NULL) {
6812 error = got_error_from_errno("strdup");
6813 goto done;
6814 }
6815 }
6816
6817 if (refname)
6818 got_path_strip_trailing_slashes(refname);
6819
6820 cwd = getcwd(NULL, 0);
6821 if (cwd == NULL) {
6822 error = got_error_from_errno("getcwd");
6823 goto done;
6824 }
6825
6826 error = got_repo_pack_fds_open(&pack_fds);
6827 if (error != NULL)
6828 goto done;
6829
6830 if (repo_path == NULL) {
6831 error = got_worktree_open(&worktree, cwd,
6832 GOT_WORKTREE_GOT_DIR);
6833 if (error && error->code != GOT_ERR_NOT_WORKTREE)
6834 goto done;
6835 else
6836 error = NULL;
6837 if (worktree) {
6838 repo_path =
6839 strdup(got_worktree_get_repo_path(worktree));
6840 if (repo_path == NULL)
6841 error = got_error_from_errno("strdup");
6842 if (error)
6843 goto done;
6844 } else {
6845 repo_path = strdup(cwd);
6846 if (repo_path == NULL) {
6847 error = got_error_from_errno("strdup");
6848 goto done;
6849 }
6850 }
6851 }
6852
6853 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
6854 if (error != NULL)
6855 goto done;
6856
6857 #ifndef PROFILE
6858 if (do_list) {
6859 /* Remove "cpath" promise. */
6860 if (pledge("stdio rpath wpath flock proc exec sendfd unveil",
6861 NULL) == -1)
6862 err(1, "pledge");
6863 }
6864 #endif
6865
6866 error = apply_unveil(got_repo_get_path(repo), do_list,
6867 worktree ? got_worktree_get_root_path(worktree) : NULL);
6868 if (error)
6869 goto done;
6870
6871 if (do_list)
6872 error = list_refs(repo, refname, sort_by_time);
6873 else if (do_delete)
6874 error = delete_ref_by_name(repo, refname);
6875 else if (symref_target)
6876 error = add_symref(repo, refname, symref_target);
6877 else {
6878 if (obj_arg == NULL)
6879 usage_ref();
6880
6881 error = got_keyword_to_idstr(&keyword_idstr, obj_arg,
6882 repo, worktree);
6883 if (error != NULL)
6884 goto done;
6885 if (keyword_idstr != NULL)
6886 obj_arg = keyword_idstr;
6887
6888 error = add_ref(repo, refname, obj_arg);
6889 }
6890 done:
6891 free(refname);
6892 if (repo) {
6893 const struct got_error *close_err = got_repo_close(repo);
6894 if (error == NULL)
6895 error = close_err;
6896 }
6897 if (worktree)
6898 got_worktree_close(worktree);
6899 if (pack_fds) {
6900 const struct got_error *pack_err =
6901 got_repo_pack_fds_close(pack_fds);
6902 if (error == NULL)
6903 error = pack_err;
6904 }
6905 free(cwd);
6906 free(repo_path);
6907 free(keyword_idstr);
6908 return error;
6909 }
6910
6911 __dead static void
6912 usage_branch(void)
6913 {
6914 fprintf(stderr, "usage: %s branch [-lnt] [-c commit] [-d name] "
6915 "[-r repository-path] [name]\n", getprogname());
6916 exit(1);
6917 }
6918
6919 static const struct got_error *
6920 list_branch(struct got_repository *repo, struct got_worktree *worktree,
6921 struct got_reference *ref)
6922 {
6923 const struct got_error *err = NULL;
6924 const char *refname;
6925 char *refstr;
6926 char marker = ' ';
6927
6928 refname = got_ref_get_name(ref);
6929 if (worktree && strcmp(refname,
6930 got_worktree_get_head_ref_name(worktree)) == 0) {
6931 err = got_worktree_get_state(&marker, repo, worktree,
6932 check_cancelled, NULL);
6933 if (err != NULL)
6934 return err;
6935 }
6936
6937 if (strncmp(refname, "refs/heads/", 11) == 0)
6938 refname += 11;
6939 if (strncmp(refname, "refs/got/worktree/", 18) == 0)
6940 refname += 18;
6941 if (strncmp(refname, "refs/remotes/", 13) == 0)
6942 refname += 13;
6943
6944 refstr = got_ref_to_str(ref);
6945 if (refstr == NULL)
6946 return got_error_from_errno("got_ref_to_str");
6947
6948 printf("%c %s: %s\n", marker, refname, refstr);
6949 free(refstr);
6950 return NULL;
6951 }
6952
6953 static const struct got_error *
6954 show_current_branch(struct got_repository *repo, struct got_worktree *worktree)
6955 {
6956 const char *refname;
6957
6958 if (worktree == NULL)
6959 return got_error(GOT_ERR_NOT_WORKTREE);
6960
6961 refname = got_worktree_get_head_ref_name(worktree);
6962
6963 if (strncmp(refname, "refs/heads/", 11) == 0)
6964 refname += 11;
6965 if (strncmp(refname, "refs/got/worktree/", 18) == 0)
6966 refname += 18;
6967
6968 printf("%s\n", refname);
6969
6970 return NULL;
6971 }
6972
6973 static const struct got_error *
6974 list_branches(struct got_repository *repo, struct got_worktree *worktree,
6975 int sort_by_time)
6976 {
6977 static const struct got_error *err = NULL;
6978 struct got_reflist_head refs;
6979 struct got_reflist_entry *re;
6980 struct got_reference *temp_ref = NULL;
6981 int rebase_in_progress, histedit_in_progress;
6982
6983 TAILQ_INIT(&refs);
6984
6985 if (worktree) {
6986 err = got_worktree_rebase_in_progress(&rebase_in_progress,
6987 worktree);
6988 if (err)
6989 return err;
6990
6991 err = got_worktree_histedit_in_progress(&histedit_in_progress,
6992 worktree);
6993 if (err)
6994 return err;
6995
6996 if (rebase_in_progress || histedit_in_progress) {
6997 err = got_ref_open(&temp_ref, repo,
6998 got_worktree_get_head_ref_name(worktree), 0);
6999 if (err)
7000 return err;
7001 list_branch(repo, worktree, temp_ref);
7002 got_ref_close(temp_ref);
7003 }
7004 }
7005
7006 err = got_ref_list(&refs, repo, "refs/heads", sort_by_time ?
7007 got_ref_cmp_by_commit_timestamp_descending : got_ref_cmp_by_name,
7008 repo);
7009 if (err)
7010 return err;
7011
7012 TAILQ_FOREACH(re, &refs, entry)
7013 list_branch(repo, worktree, re->ref);
7014
7015 got_ref_list_free(&refs);
7016
7017 err = got_ref_list(&refs, repo, "refs/remotes", sort_by_time ?
7018 got_ref_cmp_by_commit_timestamp_descending : got_ref_cmp_by_name,
7019 repo);
7020 if (err)
7021 return err;
7022
7023 TAILQ_FOREACH(re, &refs, entry)
7024 list_branch(repo, worktree, re->ref);
7025
7026 got_ref_list_free(&refs);
7027
7028 return NULL;
7029 }
7030
7031 static const struct got_error *
7032 delete_branch(struct got_repository *repo, struct got_worktree *worktree,
7033 const char *branch_name)
7034 {
7035 const struct got_error *err = NULL;
7036 struct got_reference *ref = NULL;
7037 char *refname, *remote_refname = NULL;
7038
7039 if (strncmp(branch_name, "refs/", 5) == 0)
7040 branch_name += 5;
7041 if (strncmp(branch_name, "heads/", 6) == 0)
7042 branch_name += 6;
7043 else if (strncmp(branch_name, "remotes/", 8) == 0)
7044 branch_name += 8;
7045
7046 if (asprintf(&refname, "refs/heads/%s", branch_name) == -1)
7047 return got_error_from_errno("asprintf");
7048
7049 if (asprintf(&remote_refname, "refs/remotes/%s",
7050 branch_name) == -1) {
7051 err = got_error_from_errno("asprintf");
7052 goto done;
7053 }
7054
7055 err = got_ref_open(&ref, repo, refname, 0);
7056 if (err) {
7057 const struct got_error *err2;
7058 if (err->code != GOT_ERR_NOT_REF)
7059 goto done;
7060 /*
7061 * Keep 'err' intact such that if neither branch exists
7062 * we report "refs/heads" rather than "refs/remotes" in
7063 * our error message.
7064 */
7065 err2 = got_ref_open(&ref, repo, remote_refname, 0);
7066 if (err2)
7067 goto done;
7068 err = NULL;
7069 }
7070
7071 if (worktree &&
7072 strcmp(got_worktree_get_head_ref_name(worktree),
7073 got_ref_get_name(ref)) == 0) {
7074 err = got_error_msg(GOT_ERR_SAME_BRANCH,
7075 "will not delete this work tree's current branch");
7076 goto done;
7077 }
7078
7079 err = delete_ref(repo, ref);
7080 done:
7081 if (ref)
7082 got_ref_close(ref);
7083 free(refname);
7084 free(remote_refname);
7085 return err;
7086 }
7087
7088 static const struct got_error *
7089 add_branch(struct got_repository *repo, const char *branch_name,
7090 struct got_object_id *base_commit_id)
7091 {
7092 const struct got_error *err = NULL;
7093 struct got_reference *ref = NULL;
7094 char *refname = NULL;
7095
7096 /*
7097 * Don't let the user create a branch name with a leading '-'.
7098 * While technically a valid reference name, this case is usually
7099 * an unintended typo.
7100 */
7101 if (branch_name[0] == '-')
7102 return got_error_path(branch_name, GOT_ERR_REF_NAME_MINUS);
7103
7104 if (strncmp(branch_name, "refs/heads/", 11) == 0)
7105 branch_name += 11;
7106
7107 if (asprintf(&refname, "refs/heads/%s", branch_name) == -1) {
7108 err = got_error_from_errno("asprintf");
7109 goto done;
7110 }
7111
7112 err = got_ref_open(&ref, repo, refname, 0);
7113 if (err == NULL) {
7114 err = got_error(GOT_ERR_BRANCH_EXISTS);
7115 goto done;
7116 } else if (err->code != GOT_ERR_NOT_REF)
7117 goto done;
7118
7119 err = got_ref_alloc(&ref, refname, base_commit_id);
7120 if (err)
7121 goto done;
7122
7123 err = got_ref_write(ref, repo);
7124 done:
7125 if (ref)
7126 got_ref_close(ref);
7127 free(refname);
7128 return err;
7129 }
7130
7131 static const struct got_error *
7132 cmd_branch(int argc, char *argv[])
7133 {
7134 const struct got_error *error = NULL;
7135 struct got_repository *repo = NULL;
7136 struct got_worktree *worktree = NULL;
7137 char *cwd = NULL, *repo_path = NULL;
7138 int ch, do_list = 0, do_show = 0, do_update = 1, sort_by_time = 0;
7139 const char *delref = NULL, *commit_id_arg = NULL;
7140 struct got_reference *ref = NULL;
7141 struct got_pathlist_head paths;
7142 struct got_object_id *commit_id = NULL;
7143 char *commit_id_str = NULL, *keyword_idstr = NULL;;
7144 int *pack_fds = NULL;
7145
7146 TAILQ_INIT(&paths);
7147
7148 #ifndef PROFILE
7149 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
7150 "sendfd unveil", NULL) == -1)
7151 err(1, "pledge");
7152 #endif
7153
7154 while ((ch = getopt(argc, argv, "c:d:lnr:t")) != -1) {
7155 switch (ch) {
7156 case 'c':
7157 commit_id_arg = optarg;
7158 break;
7159 case 'd':
7160 delref = optarg;
7161 break;
7162 case 'l':
7163 do_list = 1;
7164 break;
7165 case 'n':
7166 do_update = 0;
7167 break;
7168 case 'r':
7169 repo_path = realpath(optarg, NULL);
7170 if (repo_path == NULL)
7171 return got_error_from_errno2("realpath",
7172 optarg);
7173 got_path_strip_trailing_slashes(repo_path);
7174 break;
7175 case 't':
7176 sort_by_time = 1;
7177 break;
7178 default:
7179 usage_branch();
7180 /* NOTREACHED */
7181 }
7182 }
7183
7184 if (do_list && delref)
7185 option_conflict('l', 'd');
7186 if (sort_by_time && !do_list)
7187 errx(1, "-t option requires -l option");
7188
7189 argc -= optind;
7190 argv += optind;
7191
7192 if (!do_list && !delref && argc == 0)
7193 do_show = 1;
7194
7195 if ((do_list || delref || do_show) && commit_id_arg != NULL)
7196 errx(1, "-c option can only be used when creating a branch");
7197
7198 if (do_list || delref) {
7199 if (argc > 0)
7200 usage_branch();
7201 } else if (!do_show && argc != 1)
7202 usage_branch();
7203
7204 cwd = getcwd(NULL, 0);
7205 if (cwd == NULL) {
7206 error = got_error_from_errno("getcwd");
7207 goto done;
7208 }
7209
7210 error = got_repo_pack_fds_open(&pack_fds);
7211 if (error != NULL)
7212 goto done;
7213
7214 if (repo_path == NULL) {
7215 error = got_worktree_open(&worktree, cwd,
7216 GOT_WORKTREE_GOT_DIR);
7217 if (error && error->code != GOT_ERR_NOT_WORKTREE)
7218 goto done;
7219 else
7220 error = NULL;
7221 if (worktree) {
7222 repo_path =
7223 strdup(got_worktree_get_repo_path(worktree));
7224 if (repo_path == NULL)
7225 error = got_error_from_errno("strdup");
7226 if (error)
7227 goto done;
7228 } else {
7229 repo_path = strdup(cwd);
7230 if (repo_path == NULL) {
7231 error = got_error_from_errno("strdup");
7232 goto done;
7233 }
7234 }
7235 }
7236
7237 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
7238 if (error != NULL)
7239 goto done;
7240
7241 #ifndef PROFILE
7242 if (do_list || do_show) {
7243 /* Remove "cpath" promise. */
7244 if (pledge("stdio rpath wpath flock proc exec sendfd unveil",
7245 NULL) == -1)
7246 err(1, "pledge");
7247 }
7248 #endif
7249
7250 error = apply_unveil(got_repo_get_path(repo), do_list,
7251 worktree ? got_worktree_get_root_path(worktree) : NULL);
7252 if (error)
7253 goto done;
7254
7255 if (do_show)
7256 error = show_current_branch(repo, worktree);
7257 else if (do_list)
7258 error = list_branches(repo, worktree, sort_by_time);
7259 else if (delref)
7260 error = delete_branch(repo, worktree, delref);
7261 else {
7262 struct got_reflist_head refs;
7263 TAILQ_INIT(&refs);
7264 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
7265 NULL);
7266 if (error)
7267 goto done;
7268 if (commit_id_arg == NULL)
7269 commit_id_arg = worktree ?
7270 got_worktree_get_head_ref_name(worktree) :
7271 GOT_REF_HEAD;
7272 else {
7273 error = got_keyword_to_idstr(&keyword_idstr,
7274 commit_id_arg, repo, worktree);
7275 if (error != NULL)
7276 goto done;
7277 if (keyword_idstr != NULL)
7278 commit_id_arg = keyword_idstr;
7279 }
7280 error = got_repo_match_object_id(&commit_id, NULL,
7281 commit_id_arg, GOT_OBJ_TYPE_COMMIT, &refs, repo);
7282 got_ref_list_free(&refs);
7283 if (error)
7284 goto done;
7285 error = add_branch(repo, argv[0], commit_id);
7286 if (error)
7287 goto done;
7288 if (worktree && do_update) {
7289 struct got_update_progress_arg upa;
7290 char *branch_refname = NULL;
7291
7292 error = got_object_id_str(&commit_id_str, commit_id);
7293 if (error)
7294 goto done;
7295 error = get_worktree_paths_from_argv(&paths, 0, NULL,
7296 worktree);
7297 if (error)
7298 goto done;
7299 if (asprintf(&branch_refname, "refs/heads/%s", argv[0])
7300 == -1) {
7301 error = got_error_from_errno("asprintf");
7302 goto done;
7303 }
7304 error = got_ref_open(&ref, repo, branch_refname, 0);
7305 free(branch_refname);
7306 if (error)
7307 goto done;
7308 error = switch_head_ref(ref, commit_id, worktree,
7309 repo);
7310 if (error)
7311 goto done;
7312 error = got_worktree_set_base_commit_id(worktree, repo,
7313 commit_id);
7314 if (error)
7315 goto done;
7316 memset(&upa, 0, sizeof(upa));
7317 error = got_worktree_checkout_files(worktree, &paths,
7318 repo, update_progress, &upa, check_cancelled,
7319 NULL);
7320 if (error)
7321 goto done;
7322 if (upa.did_something) {
7323 printf("Updated to %s: %s\n",
7324 got_worktree_get_head_ref_name(worktree),
7325 commit_id_str);
7326 }
7327 print_update_progress_stats(&upa);
7328 }
7329 }
7330 done:
7331 free(keyword_idstr);
7332 if (ref)
7333 got_ref_close(ref);
7334 if (repo) {
7335 const struct got_error *close_err = got_repo_close(repo);
7336 if (error == NULL)
7337 error = close_err;
7338 }
7339 if (worktree)
7340 got_worktree_close(worktree);
7341 if (pack_fds) {
7342 const struct got_error *pack_err =
7343 got_repo_pack_fds_close(pack_fds);
7344 if (error == NULL)
7345 error = pack_err;
7346 }
7347 free(cwd);
7348 free(repo_path);
7349 free(commit_id);
7350 free(commit_id_str);
7351 got_pathlist_free(&paths, GOT_PATHLIST_FREE_PATH);
7352 return error;
7353 }
7354
7355
7356 __dead static void
7357 usage_tag(void)
7358 {
7359 fprintf(stderr, "usage: %s tag [-lVv] [-c commit] [-m message] "
7360 "[-r repository-path] [-s signer-id] name\n", getprogname());
7361 exit(1);
7362 }
7363
7364 #if 0
7365 static const struct got_error *
7366 sort_tags(struct got_reflist_head *sorted, struct got_reflist_head *tags)
7367 {
7368 const struct got_error *err = NULL;
7369 struct got_reflist_entry *re, *se, *new;
7370 struct got_object_id *re_id, *se_id;
7371 struct got_tag_object *re_tag, *se_tag;
7372 time_t re_time, se_time;
7373
7374 STAILQ_FOREACH(re, tags, entry) {
7375 se = STAILQ_FIRST(sorted);
7376 if (se == NULL) {
7377 err = got_reflist_entry_dup(&new, re);
7378 if (err)
7379 return err;
7380 STAILQ_INSERT_HEAD(sorted, new, entry);
7381 continue;
7382 } else {
7383 err = got_ref_resolve(&re_id, repo, re->ref);
7384 if (err)
7385 break;
7386 err = got_object_open_as_tag(&re_tag, repo, re_id);
7387 free(re_id);
7388 if (err)
7389 break;
7390 re_time = got_object_tag_get_tagger_time(re_tag);
7391 got_object_tag_close(re_tag);
7392 }
7393
7394 while (se) {
7395 err = got_ref_resolve(&se_id, repo, re->ref);
7396 if (err)
7397 break;
7398 err = got_object_open_as_tag(&se_tag, repo, se_id);
7399 free(se_id);
7400 if (err)
7401 break;
7402 se_time = got_object_tag_get_tagger_time(se_tag);
7403 got_object_tag_close(se_tag);
7404
7405 if (se_time > re_time) {
7406 err = got_reflist_entry_dup(&new, re);
7407 if (err)
7408 return err;
7409 STAILQ_INSERT_AFTER(sorted, se, new, entry);
7410 break;
7411 }
7412 se = STAILQ_NEXT(se, entry);
7413 continue;
7414 }
7415 }
7416 done:
7417 return err;
7418 }
7419 #endif
7420
7421 static const struct got_error *
7422 get_tag_refname(char **refname, const char *tag_name)
7423 {
7424 const struct got_error *err;
7425
7426 if (strncmp("refs/tags/", tag_name, 10) == 0) {
7427 *refname = strdup(tag_name);
7428 if (*refname == NULL)
7429 return got_error_from_errno("strdup");
7430 } else if (asprintf(refname, "refs/tags/%s", tag_name) == -1) {
7431 err = got_error_from_errno("asprintf");
7432 *refname = NULL;
7433 return err;
7434 }
7435
7436 return NULL;
7437 }
7438
7439 static const struct got_error *
7440 list_tags(struct got_repository *repo, const char *tag_name, int verify_tags,
7441 const char *allowed_signers, const char *revoked_signers, int verbosity)
7442 {
7443 static const struct got_error *err = NULL;
7444 struct got_reflist_head refs;
7445 struct got_reflist_entry *re;
7446 char *wanted_refname = NULL;
7447 int bad_sigs = 0;
7448
7449 TAILQ_INIT(&refs);
7450
7451 err = got_ref_list(&refs, repo, "refs/tags", got_ref_cmp_tags, repo);
7452 if (err)
7453 return err;
7454
7455 if (tag_name) {
7456 struct got_reference *ref;
7457 err = get_tag_refname(&wanted_refname, tag_name);
7458 if (err)
7459 goto done;
7460 /* Wanted tag reference should exist. */
7461 err = got_ref_open(&ref, repo, wanted_refname, 0);
7462 if (err)
7463 goto done;
7464 got_ref_close(ref);
7465 }
7466
7467 TAILQ_FOREACH(re, &refs, entry) {
7468 const char *refname;
7469 char *refstr, *tagmsg0, *tagmsg, *line, *id_str, *datestr;
7470 char datebuf[26];
7471 const char *tagger, *ssh_sig = NULL;
7472 char *sig_msg = NULL;
7473 time_t tagger_time;
7474 struct got_object_id *id;
7475 struct got_tag_object *tag;
7476 struct got_commit_object *commit = NULL;
7477
7478 refname = got_ref_get_name(re->ref);
7479 if (strncmp(refname, "refs/tags/", 10) != 0 ||
7480 (wanted_refname && strcmp(refname, wanted_refname) != 0))
7481 continue;
7482 refname += 10;
7483 refstr = got_ref_to_str(re->ref);
7484 if (refstr == NULL) {
7485 err = got_error_from_errno("got_ref_to_str");
7486 break;
7487 }
7488
7489 err = got_ref_resolve(&id, repo, re->ref);
7490 if (err)
7491 break;
7492 err = got_object_open_as_tag(&tag, repo, id);
7493 if (err) {
7494 if (err->code != GOT_ERR_OBJ_TYPE) {
7495 free(id);
7496 break;
7497 }
7498 /* "lightweight" tag */
7499 err = got_object_open_as_commit(&commit, repo, id);
7500 if (err) {
7501 free(id);
7502 break;
7503 }
7504 tagger = got_object_commit_get_committer(commit);
7505 tagger_time =
7506 got_object_commit_get_committer_time(commit);
7507 err = got_object_id_str(&id_str, id);
7508 free(id);
7509 if (err)
7510 break;
7511 } else {
7512 free(id);
7513 tagger = got_object_tag_get_tagger(tag);
7514 tagger_time = got_object_tag_get_tagger_time(tag);
7515 err = got_object_id_str(&id_str,
7516 got_object_tag_get_object_id(tag));
7517 if (err)
7518 break;
7519 }
7520
7521 if (tag && verify_tags) {
7522 ssh_sig = got_sigs_get_tagmsg_ssh_signature(
7523 got_object_tag_get_message(tag));
7524 if (ssh_sig && allowed_signers == NULL) {
7525 err = got_error_msg(
7526 GOT_ERR_VERIFY_TAG_SIGNATURE,
7527 "SSH signature verification requires "
7528 "setting allowed_signers in "
7529 "got.conf(5)");
7530 break;
7531 }
7532 }
7533
7534 printf("%stag %s %s\n", GOT_COMMIT_SEP_STR, refname, refstr);
7535 free(refstr);
7536 printf("from: %s\n", tagger);
7537 datestr = get_datestr(&tagger_time, datebuf);
7538 if (datestr)
7539 printf("date: %s UTC\n", datestr);
7540 if (commit)
7541 printf("object: %s %s\n", GOT_OBJ_LABEL_COMMIT, id_str);
7542 else {
7543 switch (got_object_tag_get_object_type(tag)) {
7544 case GOT_OBJ_TYPE_BLOB:
7545 printf("object: %s %s\n", GOT_OBJ_LABEL_BLOB,
7546 id_str);
7547 break;
7548 case GOT_OBJ_TYPE_TREE:
7549 printf("object: %s %s\n", GOT_OBJ_LABEL_TREE,
7550 id_str);
7551 break;
7552 case GOT_OBJ_TYPE_COMMIT:
7553 printf("object: %s %s\n", GOT_OBJ_LABEL_COMMIT,
7554 id_str);
7555 break;
7556 case GOT_OBJ_TYPE_TAG:
7557 printf("object: %s %s\n", GOT_OBJ_LABEL_TAG,
7558 id_str);
7559 break;
7560 default:
7561 break;
7562 }
7563 }
7564 free(id_str);
7565
7566 if (ssh_sig) {
7567 err = got_sigs_verify_tag_ssh(&sig_msg, tag, ssh_sig,
7568 allowed_signers, revoked_signers, verbosity);
7569 if (err && err->code == GOT_ERR_BAD_TAG_SIGNATURE)
7570 bad_sigs = 1;
7571 else if (err)
7572 break;
7573 printf("signature: %s", sig_msg);
7574 free(sig_msg);
7575 sig_msg = NULL;
7576 }
7577
7578 if (commit) {
7579 err = got_object_commit_get_logmsg(&tagmsg0, commit);
7580 if (err)
7581 break;
7582 got_object_commit_close(commit);
7583 } else {
7584 tagmsg0 = strdup(got_object_tag_get_message(tag));
7585 got_object_tag_close(tag);
7586 if (tagmsg0 == NULL) {
7587 err = got_error_from_errno("strdup");
7588 break;
7589 }
7590 }
7591
7592 tagmsg = tagmsg0;
7593 do {
7594 line = strsep(&tagmsg, "\n");
7595 if (line)
7596 printf(" %s\n", line);
7597 } while (line);
7598 free(tagmsg0);
7599 }
7600 done:
7601 got_ref_list_free(&refs);
7602 free(wanted_refname);
7603
7604 if (err == NULL && bad_sigs)
7605 err = got_error(GOT_ERR_BAD_TAG_SIGNATURE);
7606 return err;
7607 }
7608
7609 static const struct got_error *
7610 get_tag_message(char **tagmsg, char **tagmsg_path, const char *commit_id_str,
7611 const char *tag_name, const char *editor, const char *repo_path)
7612 {
7613 const struct got_error *err = NULL;
7614 char *template = NULL, *initial_content = NULL;
7615 int initial_content_len;
7616 int fd = -1;
7617
7618 if (asprintf(&template, GOT_TMPDIR_STR "/got-tagmsg") == -1) {
7619 err = got_error_from_errno("asprintf");
7620 goto done;
7621 }
7622
7623 initial_content_len = asprintf(&initial_content,
7624 "\n# tagging commit %s as %s\n",
7625 commit_id_str, tag_name);
7626 if (initial_content_len == -1) {
7627 err = got_error_from_errno("asprintf");
7628 goto done;
7629 }
7630
7631 err = got_opentemp_named_fd(tagmsg_path, &fd, template, "");
7632 if (err)
7633 goto done;
7634
7635 if (write(fd, initial_content, initial_content_len) == -1) {
7636 err = got_error_from_errno2("write", *tagmsg_path);
7637 goto done;
7638 }
7639 if (close(fd) == -1) {
7640 err = got_error_from_errno2("close", *tagmsg_path);
7641 goto done;
7642 }
7643 fd = -1;
7644
7645 err = edit_logmsg(tagmsg, editor, *tagmsg_path, initial_content,
7646 initial_content_len, 1);
7647 done:
7648 free(initial_content);
7649 free(template);
7650
7651 if (fd != -1 && close(fd) == -1 && err == NULL)
7652 err = got_error_from_errno2("close", *tagmsg_path);
7653
7654 if (err) {
7655 free(*tagmsg);
7656 *tagmsg = NULL;
7657 }
7658 return err;
7659 }
7660
7661 static const struct got_error *
7662 add_tag(struct got_repository *repo, const char *tagger,
7663 const char *tag_name, const char *commit_arg, const char *tagmsg_arg,
7664 const char *signer_id, const char *editor, int verbosity)
7665 {
7666 const struct got_error *err = NULL;
7667 struct got_object_id *commit_id = NULL, *tag_id = NULL;
7668 char *label = NULL, *commit_id_str = NULL;
7669 struct got_reference *ref = NULL;
7670 char *refname = NULL, *tagmsg = NULL;
7671 char *tagmsg_path = NULL, *tag_id_str = NULL;
7672 int preserve_tagmsg = 0;
7673 struct got_reflist_head refs;
7674
7675 TAILQ_INIT(&refs);
7676
7677 /*
7678 * Don't let the user create a tag name with a leading '-'.
7679 * While technically a valid reference name, this case is usually
7680 * an unintended typo.
7681 */
7682 if (tag_name[0] == '-')
7683 return got_error_path(tag_name, GOT_ERR_REF_NAME_MINUS);
7684
7685 err = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
7686 if (err)
7687 goto done;
7688
7689 err = got_repo_match_object_id(&commit_id, &label, commit_arg,
7690 GOT_OBJ_TYPE_COMMIT, &refs, repo);
7691 if (err)
7692 goto done;
7693
7694 err = got_object_id_str(&commit_id_str, commit_id);
7695 if (err)
7696 goto done;
7697
7698 err = get_tag_refname(&refname, tag_name);
7699 if (err)
7700 goto done;
7701 if (strncmp("refs/tags/", tag_name, 10) == 0)
7702 tag_name += 10;
7703
7704 err = got_ref_open(&ref, repo, refname, 0);
7705 if (err == NULL) {
7706 err = got_error(GOT_ERR_TAG_EXISTS);
7707 goto done;
7708 } else if (err->code != GOT_ERR_NOT_REF)
7709 goto done;
7710
7711 if (tagmsg_arg == NULL) {
7712 err = get_tag_message(&tagmsg, &tagmsg_path, commit_id_str,
7713 tag_name, editor, got_repo_get_path(repo));
7714 if (err) {
7715 if (err->code != GOT_ERR_COMMIT_MSG_EMPTY &&
7716 tagmsg_path != NULL)
7717 preserve_tagmsg = 1;
7718 goto done;
7719 }
7720 }
7721
7722 err = got_object_tag_create(&tag_id, tag_name, commit_id,
7723 tagger, time(NULL), tagmsg ? tagmsg : tagmsg_arg, signer_id, repo,
7724 verbosity);
7725 if (err) {
7726 if (tagmsg_path)
7727 preserve_tagmsg = 1;
7728 goto done;
7729 }
7730
7731 err = got_ref_alloc(&ref, refname, tag_id);
7732 if (err) {
7733 if (tagmsg_path)
7734 preserve_tagmsg = 1;
7735 goto done;
7736 }
7737
7738 err = got_ref_write(ref, repo);
7739 if (err) {
7740 if (tagmsg_path)
7741 preserve_tagmsg = 1;
7742 goto done;
7743 }
7744
7745 err = got_object_id_str(&tag_id_str, tag_id);
7746 if (err) {
7747 if (tagmsg_path)
7748 preserve_tagmsg = 1;
7749 goto done;
7750 }
7751 printf("Created tag %s\n", tag_id_str);
7752 done:
7753 if (preserve_tagmsg) {
7754 fprintf(stderr, "%s: tag message preserved in %s\n",
7755 getprogname(), tagmsg_path);
7756 } else if (tagmsg_path && unlink(tagmsg_path) == -1 && err == NULL)
7757 err = got_error_from_errno2("unlink", tagmsg_path);
7758 free(tag_id_str);
7759 if (ref)
7760 got_ref_close(ref);
7761 free(commit_id);
7762 free(commit_id_str);
7763 free(refname);
7764 free(tagmsg);
7765 free(tagmsg_path);
7766 got_ref_list_free(&refs);
7767 return err;
7768 }
7769
7770 static const struct got_error *
7771 cmd_tag(int argc, char *argv[])
7772 {
7773 const struct got_error *error = NULL;
7774 struct got_repository *repo = NULL;
7775 struct got_worktree *worktree = NULL;
7776 char *cwd = NULL, *repo_path = NULL, *commit_id_str = NULL;
7777 char *gitconfig_path = NULL, *tagger = NULL, *keyword_idstr = NULL;
7778 char *allowed_signers = NULL, *revoked_signers = NULL, *editor = NULL;
7779 const char *signer_id = NULL;
7780 const char *tag_name = NULL, *commit_id_arg = NULL, *tagmsg = NULL;
7781 int ch, do_list = 0, verify_tags = 0, verbosity = 0;
7782 int *pack_fds = NULL;
7783
7784 #ifndef PROFILE
7785 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
7786 "sendfd unveil", NULL) == -1)
7787 err(1, "pledge");
7788 #endif
7789
7790 while ((ch = getopt(argc, argv, "c:lm:r:s:Vv")) != -1) {
7791 switch (ch) {
7792 case 'c':
7793 commit_id_arg = optarg;
7794 break;
7795 case 'l':
7796 do_list = 1;
7797 break;
7798 case 'm':
7799 tagmsg = optarg;
7800 break;
7801 case 'r':
7802 repo_path = realpath(optarg, NULL);
7803 if (repo_path == NULL) {
7804 error = got_error_from_errno2("realpath",
7805 optarg);
7806 goto done;
7807 }
7808 got_path_strip_trailing_slashes(repo_path);
7809 break;
7810 case 's':
7811 signer_id = optarg;
7812 break;
7813 case 'V':
7814 verify_tags = 1;
7815 break;
7816 case 'v':
7817 if (verbosity < 0)
7818 verbosity = 0;
7819 else if (verbosity < 3)
7820 verbosity++;
7821 break;
7822 default:
7823 usage_tag();
7824 /* NOTREACHED */
7825 }
7826 }
7827
7828 argc -= optind;
7829 argv += optind;
7830
7831 if (do_list || verify_tags) {
7832 if (commit_id_arg != NULL)
7833 errx(1,
7834 "-c option can only be used when creating a tag");
7835 if (tagmsg) {
7836 if (do_list)
7837 option_conflict('l', 'm');
7838 else
7839 option_conflict('V', 'm');
7840 }
7841 if (signer_id) {
7842 if (do_list)
7843 option_conflict('l', 's');
7844 else
7845 option_conflict('V', 's');
7846 }
7847 if (argc > 1)
7848 usage_tag();
7849 } else if (argc != 1)
7850 usage_tag();
7851
7852 if (argc == 1)
7853 tag_name = argv[0];
7854
7855 cwd = getcwd(NULL, 0);
7856 if (cwd == NULL) {
7857 error = got_error_from_errno("getcwd");
7858 goto done;
7859 }
7860
7861 error = got_repo_pack_fds_open(&pack_fds);
7862 if (error != NULL)
7863 goto done;
7864
7865 if (repo_path == NULL) {
7866 error = got_worktree_open(&worktree, cwd,
7867 GOT_WORKTREE_GOT_DIR);
7868 if (error && error->code != GOT_ERR_NOT_WORKTREE)
7869 goto done;
7870 else
7871 error = NULL;
7872 if (worktree) {
7873 repo_path =
7874 strdup(got_worktree_get_repo_path(worktree));
7875 if (repo_path == NULL)
7876 error = got_error_from_errno("strdup");
7877 if (error)
7878 goto done;
7879 } else {
7880 repo_path = strdup(cwd);
7881 if (repo_path == NULL) {
7882 error = got_error_from_errno("strdup");
7883 goto done;
7884 }
7885 }
7886 }
7887
7888 if (do_list || verify_tags) {
7889 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
7890 if (error != NULL)
7891 goto done;
7892 error = get_allowed_signers(&allowed_signers, repo, worktree);
7893 if (error)
7894 goto done;
7895 error = get_revoked_signers(&revoked_signers, repo, worktree);
7896 if (error)
7897 goto done;
7898 if (worktree) {
7899 /* Release work tree lock. */
7900 got_worktree_close(worktree);
7901 worktree = NULL;
7902 }
7903
7904 /*
7905 * Remove "cpath" promise unless needed for signature tmpfile
7906 * creation.
7907 */
7908 if (verify_tags)
7909 got_sigs_apply_unveil();
7910 else {
7911 #ifndef PROFILE
7912 if (pledge("stdio rpath wpath flock proc exec sendfd "
7913 "unveil", NULL) == -1)
7914 err(1, "pledge");
7915 #endif
7916 }
7917 error = apply_unveil(got_repo_get_path(repo), 1, NULL);
7918 if (error)
7919 goto done;
7920 error = list_tags(repo, tag_name, verify_tags, allowed_signers,
7921 revoked_signers, verbosity);
7922 } else {
7923 error = get_gitconfig_path(&gitconfig_path);
7924 if (error)
7925 goto done;
7926 error = got_repo_open(&repo, repo_path, gitconfig_path,
7927 pack_fds);
7928 if (error != NULL)
7929 goto done;
7930
7931 error = get_author(&tagger, repo, worktree);
7932 if (error)
7933 goto done;
7934 if (signer_id == NULL)
7935 signer_id = get_signer_id(repo, worktree);
7936
7937 if (tagmsg == NULL) {
7938 error = get_editor(&editor);
7939 if (error)
7940 goto done;
7941 if (unveil(editor, "x") != 0) {
7942 error = got_error_from_errno2("unveil", editor);
7943 goto done;
7944 }
7945 }
7946 if (signer_id) {
7947 error = got_sigs_apply_unveil();
7948 if (error)
7949 goto done;
7950 }
7951 error = apply_unveil(got_repo_get_path(repo), 0, NULL);
7952 if (error)
7953 goto done;
7954
7955 if (commit_id_arg == NULL) {
7956 struct got_reference *head_ref;
7957 struct got_object_id *commit_id;
7958 error = got_ref_open(&head_ref, repo,
7959 worktree ? got_worktree_get_head_ref_name(worktree)
7960 : GOT_REF_HEAD, 0);
7961 if (error)
7962 goto done;
7963 error = got_ref_resolve(&commit_id, repo, head_ref);
7964 got_ref_close(head_ref);
7965 if (error)
7966 goto done;
7967 error = got_object_id_str(&commit_id_str, commit_id);
7968 free(commit_id);
7969 if (error)
7970 goto done;
7971 } else {
7972 error = got_keyword_to_idstr(&keyword_idstr,
7973 commit_id_arg, repo, worktree);
7974 if (error != NULL)
7975 goto done;
7976 commit_id_str = keyword_idstr;
7977 }
7978
7979 if (worktree) {
7980 /* Release work tree lock. */
7981 got_worktree_close(worktree);
7982 worktree = NULL;
7983 }
7984
7985 error = add_tag(repo, tagger, tag_name,
7986 commit_id_str ? commit_id_str : commit_id_arg, tagmsg,
7987 signer_id, editor, verbosity);
7988 }
7989 done:
7990 if (repo) {
7991 const struct got_error *close_err = got_repo_close(repo);
7992 if (error == NULL)
7993 error = close_err;
7994 }
7995 if (worktree)
7996 got_worktree_close(worktree);
7997 if (pack_fds) {
7998 const struct got_error *pack_err =
7999 got_repo_pack_fds_close(pack_fds);
8000 if (error == NULL)
8001 error = pack_err;
8002 }
8003 free(cwd);
8004 free(editor);
8005 free(repo_path);
8006 free(gitconfig_path);
8007 free(commit_id_str);
8008 free(tagger);
8009 free(allowed_signers);
8010 free(revoked_signers);
8011 return error;
8012 }
8013
8014 __dead static void
8015 usage_add(void)
8016 {
8017 fprintf(stderr, "usage: %s add [-IR] path ...\n", getprogname());
8018 exit(1);
8019 }
8020
8021 static const struct got_error *
8022 add_progress(void *arg, unsigned char status, const char *path)
8023 {
8024 while (path[0] == '/')
8025 path++;
8026 printf("%c %s\n", status, path);
8027 return NULL;
8028 }
8029
8030 static const struct got_error *
8031 cmd_add(int argc, char *argv[])
8032 {
8033 const struct got_error *error = NULL;
8034 struct got_repository *repo = NULL;
8035 struct got_worktree *worktree = NULL;
8036 char *cwd = NULL;
8037 struct got_pathlist_head paths;
8038 struct got_pathlist_entry *pe;
8039 int ch, can_recurse = 0, no_ignores = 0;
8040 int *pack_fds = NULL;
8041
8042 TAILQ_INIT(&paths);
8043
8044 #ifndef PROFILE
8045 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
8046 NULL) == -1)
8047 err(1, "pledge");
8048 #endif
8049
8050 while ((ch = getopt(argc, argv, "IR")) != -1) {
8051 switch (ch) {
8052 case 'I':
8053 no_ignores = 1;
8054 break;
8055 case 'R':
8056 can_recurse = 1;
8057 break;
8058 default:
8059 usage_add();
8060 /* NOTREACHED */
8061 }
8062 }
8063
8064 argc -= optind;
8065 argv += optind;
8066
8067 if (argc < 1)
8068 usage_add();
8069
8070 cwd = getcwd(NULL, 0);
8071 if (cwd == NULL) {
8072 error = got_error_from_errno("getcwd");
8073 goto done;
8074 }
8075
8076 error = got_repo_pack_fds_open(&pack_fds);
8077 if (error != NULL)
8078 goto done;
8079
8080 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
8081 if (error) {
8082 if (error->code == GOT_ERR_NOT_WORKTREE)
8083 error = wrap_not_worktree_error(error, "add", cwd);
8084 goto done;
8085 }
8086
8087 error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
8088 NULL, pack_fds);
8089 if (error != NULL)
8090 goto done;
8091
8092 error = apply_unveil(got_repo_get_path(repo), 1,
8093 got_worktree_get_root_path(worktree));
8094 if (error)
8095 goto done;
8096
8097 error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
8098 if (error)
8099 goto done;
8100
8101 if (!can_recurse) {
8102 char *ondisk_path;
8103 struct stat sb;
8104 TAILQ_FOREACH(pe, &paths, entry) {
8105 if (asprintf(&ondisk_path, "%s/%s",
8106 got_worktree_get_root_path(worktree),
8107 pe->path) == -1) {
8108 error = got_error_from_errno("asprintf");
8109 goto done;
8110 }
8111 if (lstat(ondisk_path, &sb) == -1) {
8112 if (errno == ENOENT) {
8113 free(ondisk_path);
8114 continue;
8115 }
8116 error = got_error_from_errno2("lstat",
8117 ondisk_path);
8118 free(ondisk_path);
8119 goto done;
8120 }
8121 free(ondisk_path);
8122 if (S_ISDIR(sb.st_mode)) {
8123 error = got_error_msg(GOT_ERR_BAD_PATH,
8124 "adding directories requires -R option");
8125 goto done;
8126 }
8127 }
8128 }
8129
8130 error = got_worktree_schedule_add(worktree, &paths, add_progress,
8131 NULL, repo, no_ignores);
8132 done:
8133 if (repo) {
8134 const struct got_error *close_err = got_repo_close(repo);
8135 if (error == NULL)
8136 error = close_err;
8137 }
8138 if (worktree)
8139 got_worktree_close(worktree);
8140 if (pack_fds) {
8141 const struct got_error *pack_err =
8142 got_repo_pack_fds_close(pack_fds);
8143 if (error == NULL)
8144 error = pack_err;
8145 }
8146 got_pathlist_free(&paths, GOT_PATHLIST_FREE_PATH);
8147 free(cwd);
8148 return error;
8149 }
8150
8151 __dead static void
8152 usage_remove(void)
8153 {
8154 fprintf(stderr, "usage: %s remove [-fkR] [-s status-codes] path ...\n",
8155 getprogname());
8156 exit(1);
8157 }
8158
8159 static const struct got_error *
8160 print_remove_status(void *arg, unsigned char status,
8161 unsigned char staged_status, const char *path)
8162 {
8163 while (path[0] == '/')
8164 path++;
8165 if (status == GOT_STATUS_NONEXISTENT)
8166 return NULL;
8167 if (status == staged_status && (status == GOT_STATUS_DELETE))
8168 status = GOT_STATUS_NO_CHANGE;
8169 printf("%c%c %s\n", status, staged_status, path);
8170 return NULL;
8171 }
8172
8173 static const struct got_error *
8174 cmd_remove(int argc, char *argv[])
8175 {
8176 const struct got_error *error = NULL;
8177 struct got_worktree *worktree = NULL;
8178 struct got_repository *repo = NULL;
8179 const char *status_codes = NULL;
8180 char *cwd = NULL;
8181 struct got_pathlist_head paths;
8182 struct got_pathlist_entry *pe;
8183 int ch, delete_local_mods = 0, can_recurse = 0, keep_on_disk = 0, i;
8184 int ignore_missing_paths = 0;
8185 int *pack_fds = NULL;
8186
8187 TAILQ_INIT(&paths);
8188
8189 #ifndef PROFILE
8190 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
8191 NULL) == -1)
8192 err(1, "pledge");
8193 #endif
8194
8195 while ((ch = getopt(argc, argv, "fkRs:")) != -1) {
8196 switch (ch) {
8197 case 'f':
8198 delete_local_mods = 1;
8199 ignore_missing_paths = 1;
8200 break;
8201 case 'k':
8202 keep_on_disk = 1;
8203 break;
8204 case 'R':
8205 can_recurse = 1;
8206 break;
8207 case 's':
8208 for (i = 0; optarg[i] != '\0'; i++) {
8209 switch (optarg[i]) {
8210 case GOT_STATUS_MODIFY:
8211 delete_local_mods = 1;
8212 break;
8213 case GOT_STATUS_MISSING:
8214 ignore_missing_paths = 1;
8215 break;
8216 default:
8217 errx(1, "invalid status code '%c'",
8218 optarg[i]);
8219 }
8220 }
8221 status_codes = optarg;
8222 break;
8223 default:
8224 usage_remove();
8225 /* NOTREACHED */
8226 }
8227 }
8228
8229 argc -= optind;
8230 argv += optind;
8231
8232 if (argc < 1)
8233 usage_remove();
8234
8235 cwd = getcwd(NULL, 0);
8236 if (cwd == NULL) {
8237 error = got_error_from_errno("getcwd");
8238 goto done;
8239 }
8240
8241 error = got_repo_pack_fds_open(&pack_fds);
8242 if (error != NULL)
8243 goto done;
8244
8245 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
8246 if (error) {
8247 if (error->code == GOT_ERR_NOT_WORKTREE)
8248 error = wrap_not_worktree_error(error, "remove", cwd);
8249 goto done;
8250 }
8251
8252 error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
8253 NULL, pack_fds);
8254 if (error)
8255 goto done;
8256
8257 error = apply_unveil(got_repo_get_path(repo), 1,
8258 got_worktree_get_root_path(worktree));
8259 if (error)
8260 goto done;
8261
8262 error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
8263 if (error)
8264 goto done;
8265
8266 if (!can_recurse) {
8267 char *ondisk_path;
8268 struct stat sb;
8269 TAILQ_FOREACH(pe, &paths, entry) {
8270 if (asprintf(&ondisk_path, "%s/%s",
8271 got_worktree_get_root_path(worktree),
8272 pe->path) == -1) {
8273 error = got_error_from_errno("asprintf");
8274 goto done;
8275 }
8276 if (lstat(ondisk_path, &sb) == -1) {
8277 if (errno == ENOENT) {
8278 free(ondisk_path);
8279 continue;
8280 }
8281 error = got_error_from_errno2("lstat",
8282 ondisk_path);
8283 free(ondisk_path);
8284 goto done;
8285 }
8286 free(ondisk_path);
8287 if (S_ISDIR(sb.st_mode)) {
8288 error = got_error_msg(GOT_ERR_BAD_PATH,
8289 "removing directories requires -R option");
8290 goto done;
8291 }
8292 }
8293 }
8294
8295 error = got_worktree_schedule_delete(worktree, &paths,
8296 delete_local_mods, status_codes, print_remove_status, NULL,
8297 repo, keep_on_disk, ignore_missing_paths);
8298 done:
8299 if (repo) {
8300 const struct got_error *close_err = got_repo_close(repo);
8301 if (error == NULL)
8302 error = close_err;
8303 }
8304 if (worktree)
8305 got_worktree_close(worktree);
8306 if (pack_fds) {
8307 const struct got_error *pack_err =
8308 got_repo_pack_fds_close(pack_fds);
8309 if (error == NULL)
8310 error = pack_err;
8311 }
8312 got_pathlist_free(&paths, GOT_PATHLIST_FREE_PATH);
8313 free(cwd);
8314 return error;
8315 }
8316
8317 __dead static void
8318 usage_patch(void)
8319 {
8320 fprintf(stderr, "usage: %s patch [-nR] [-c commit] [-p strip-count] "
8321 "[patchfile]\n", getprogname());
8322 exit(1);
8323 }
8324
8325 static const struct got_error *
8326 patch_from_stdin(int *patchfd)
8327 {
8328 const struct got_error *err = NULL;
8329 ssize_t r;
8330 char buf[BUFSIZ];
8331 sig_t sighup, sigint, sigquit;
8332
8333 *patchfd = got_opentempfd();
8334 if (*patchfd == -1)
8335 return got_error_from_errno("got_opentempfd");
8336
8337 sighup = signal(SIGHUP, SIG_DFL);
8338 sigint = signal(SIGINT, SIG_DFL);
8339 sigquit = signal(SIGQUIT, SIG_DFL);
8340
8341 for (;;) {
8342 r = read(0, buf, sizeof(buf));
8343 if (r == -1) {
8344 err = got_error_from_errno("read");
8345 break;
8346 }
8347 if (r == 0)
8348 break;
8349 if (write(*patchfd, buf, r) == -1) {
8350 err = got_error_from_errno("write");
8351 break;
8352 }
8353 }
8354
8355 signal(SIGHUP, sighup);
8356 signal(SIGINT, sigint);
8357 signal(SIGQUIT, sigquit);
8358
8359 if (err == NULL && lseek(*patchfd, 0, SEEK_SET) == -1)
8360 err = got_error_from_errno("lseek");
8361
8362 if (err != NULL) {
8363 close(*patchfd);
8364 *patchfd = -1;
8365 }
8366
8367 return err;
8368 }
8369
8370 struct got_patch_progress_arg {
8371 int did_something;
8372 int conflicts;
8373 int rejects;
8374 };
8375
8376 static const struct got_error *
8377 patch_progress(void *arg, const char *old, const char *new,
8378 unsigned char status, const struct got_error *error, int old_from,
8379 int old_lines, int new_from, int new_lines, int offset,
8380 int ws_mangled, const struct got_error *hunk_err)
8381 {
8382 const char *path = new == NULL ? old : new;
8383 struct got_patch_progress_arg *a = arg;
8384
8385 while (*path == '/')
8386 path++;
8387
8388 if (status != GOT_STATUS_NO_CHANGE &&
8389 status != 0 /* per-hunk progress */) {
8390 printf("%c %s\n", status, path);
8391 a->did_something = 1;
8392 }
8393
8394 if (hunk_err == NULL) {
8395 if (status == GOT_STATUS_CANNOT_UPDATE)
8396 a->rejects++;
8397 else if (status == GOT_STATUS_CONFLICT)
8398 a->conflicts++;
8399 }
8400
8401 if (error != NULL)
8402 fprintf(stderr, "%s: %s\n", getprogname(), error->msg);
8403
8404 if (offset != 0 || hunk_err != NULL || ws_mangled) {
8405 printf("@@ -%d,%d +%d,%d @@ ", old_from,
8406 old_lines, new_from, new_lines);
8407 if (hunk_err != NULL)
8408 printf("%s\n", hunk_err->msg);
8409 else if (offset != 0)
8410 printf("applied with offset %d\n", offset);
8411 else
8412 printf("hunk contains mangled whitespace\n");
8413 }
8414
8415 return NULL;
8416 }
8417
8418 static void
8419 print_patch_progress_stats(struct got_patch_progress_arg *ppa)
8420 {
8421 if (!ppa->did_something)
8422 return;
8423
8424 if (ppa->conflicts > 0)
8425 printf("Files with merge conflicts: %d\n", ppa->conflicts);
8426
8427 if (ppa->rejects > 0) {
8428 printf("Files where patch failed to apply: %d\n",
8429 ppa->rejects);
8430 }
8431 }
8432
8433 static const struct got_error *
8434 cmd_patch(int argc, char *argv[])
8435 {
8436 const struct got_error *error = NULL, *close_error = NULL;
8437 struct got_worktree *worktree = NULL;
8438 struct got_repository *repo = NULL;
8439 struct got_reflist_head refs;
8440 struct got_object_id *commit_id = NULL;
8441 const char *commit_id_str = NULL;
8442 struct stat sb;
8443 const char *errstr;
8444 char *cwd = NULL, *keyword_idstr = NULL;
8445 int ch, nop = 0, strip = -1, reverse = 0;
8446 int patchfd;
8447 int *pack_fds = NULL;
8448 struct got_patch_progress_arg ppa;
8449
8450 TAILQ_INIT(&refs);
8451
8452 #ifndef PROFILE
8453 if (pledge("stdio rpath wpath cpath fattr proc exec sendfd flock "
8454 "unveil", NULL) == -1)
8455 err(1, "pledge");
8456 #endif
8457
8458 while ((ch = getopt(argc, argv, "c:np:R")) != -1) {
8459 switch (ch) {
8460 case 'c':
8461 commit_id_str = optarg;
8462 break;
8463 case 'n':
8464 nop = 1;
8465 break;
8466 case 'p':
8467 strip = strtonum(optarg, 0, INT_MAX, &errstr);
8468 if (errstr != NULL)
8469 errx(1, "pathname strip count is %s: %s",
8470 errstr, optarg);
8471 break;
8472 case 'R':
8473 reverse = 1;
8474 break;
8475 default:
8476 usage_patch();
8477 /* NOTREACHED */
8478 }
8479 }
8480
8481 argc -= optind;
8482 argv += optind;
8483
8484 if (argc == 0) {
8485 error = patch_from_stdin(&patchfd);
8486 if (error)
8487 return error;
8488 } else if (argc == 1) {
8489 patchfd = open(argv[0], O_RDONLY);
8490 if (patchfd == -1) {
8491 error = got_error_from_errno2("open", argv[0]);
8492 return error;
8493 }
8494 if (fstat(patchfd, &sb) == -1) {
8495 error = got_error_from_errno2("fstat", argv[0]);
8496 goto done;
8497 }
8498 if (!S_ISREG(sb.st_mode)) {
8499 error = got_error_path(argv[0], GOT_ERR_BAD_FILETYPE);
8500 goto done;
8501 }
8502 } else
8503 usage_patch();
8504
8505 if ((cwd = getcwd(NULL, 0)) == NULL) {
8506 error = got_error_from_errno("getcwd");
8507 goto done;
8508 }
8509
8510 error = got_repo_pack_fds_open(&pack_fds);
8511 if (error != NULL)
8512 goto done;
8513
8514 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
8515 if (error != NULL)
8516 goto done;
8517
8518 const char *repo_path = got_worktree_get_repo_path(worktree);
8519 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
8520 if (error != NULL)
8521 goto done;
8522
8523 error = apply_unveil(got_repo_get_path(repo), 0,
8524 got_worktree_get_root_path(worktree));
8525 if (error != NULL)
8526 goto done;
8527
8528 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
8529 if (error)
8530 goto done;
8531
8532 if (commit_id_str != NULL) {
8533 error = got_keyword_to_idstr(&keyword_idstr, commit_id_str,
8534 repo, worktree);
8535 if (error != NULL)
8536 goto done;
8537
8538 error = got_repo_match_object_id(&commit_id, NULL,
8539 keyword_idstr != NULL ? keyword_idstr : commit_id_str,
8540 GOT_OBJ_TYPE_COMMIT, &refs, repo);
8541 if (error)
8542 goto done;
8543 }
8544
8545 memset(&ppa, 0, sizeof(ppa));
8546 error = got_patch(patchfd, worktree, repo, nop, strip, reverse,
8547 commit_id, patch_progress, &ppa, check_cancelled, NULL);
8548 print_patch_progress_stats(&ppa);
8549 done:
8550 got_ref_list_free(&refs);
8551 free(keyword_idstr);
8552 free(commit_id);
8553 if (repo) {
8554 close_error = got_repo_close(repo);
8555 if (error == NULL)
8556 error = close_error;
8557 }
8558 if (worktree != NULL) {
8559 close_error = got_worktree_close(worktree);
8560 if (error == NULL)
8561 error = close_error;
8562 }
8563 if (pack_fds) {
8564 const struct got_error *pack_err =
8565 got_repo_pack_fds_close(pack_fds);
8566 if (error == NULL)
8567 error = pack_err;
8568 }
8569 free(cwd);
8570 return error;
8571 }
8572
8573 __dead static void
8574 usage_revert(void)
8575 {
8576 fprintf(stderr, "usage: %s revert [-pR] [-F response-script] path ...\n",
8577 getprogname());
8578 exit(1);
8579 }
8580
8581 static const struct got_error *
8582 revert_progress(void *arg, unsigned char status, const char *path)
8583 {
8584 if (status == GOT_STATUS_UNVERSIONED)
8585 return NULL;
8586
8587 while (path[0] == '/')
8588 path++;
8589 printf("%c %s\n", status, path);
8590 return NULL;
8591 }
8592
8593 struct choose_patch_arg {
8594 FILE *patch_script_file;
8595 const char *action;
8596 };
8597
8598 static const struct got_error *
8599 show_change(unsigned char status, const char *path, FILE *patch_file, int n,
8600 int nchanges, const char *action)
8601 {
8602 const struct got_error *err;
8603 char *line = NULL;
8604 size_t linesize = 0;
8605 ssize_t linelen;
8606
8607 switch (status) {
8608 case GOT_STATUS_ADD:
8609 printf("A %s\n%s this addition? [y/n] ", path, action);
8610 break;
8611 case GOT_STATUS_DELETE:
8612 printf("D %s\n%s this deletion? [y/n] ", path, action);
8613 break;
8614 case GOT_STATUS_MODIFY:
8615 if (fseek(patch_file, 0L, SEEK_SET) == -1)
8616 return got_error_from_errno("fseek");
8617 printf(GOT_COMMIT_SEP_STR);
8618 while ((linelen = getline(&line, &linesize, patch_file)) != -1)
8619 printf("%s", line);
8620 if (linelen == -1 && ferror(patch_file)) {
8621 err = got_error_from_errno("getline");
8622 free(line);
8623 return err;
8624 }
8625 free(line);
8626 printf(GOT_COMMIT_SEP_STR);
8627 printf("M %s (change %d of %d)\n%s this change? [y/n/q] ",
8628 path, n, nchanges, action);
8629 break;
8630 default:
8631 return got_error_path(path, GOT_ERR_FILE_STATUS);
8632 }
8633
8634 fflush(stdout);
8635 return NULL;
8636 }
8637
8638 #define CHOOSE_PATCH_VALID_RESPONSES "ynq"
8639
8640 static const struct got_error *
8641 choose_patch(int *choice, void *arg, unsigned char status, const char *path,
8642 FILE *patch_file, int n, int nchanges)
8643 {
8644 const struct got_error *err = NULL;
8645 char *nl, *line = NULL;
8646 FILE *fp = stdin;
8647 size_t linesize = 0;
8648 ssize_t linelen;
8649 int interactive = 1;
8650 struct choose_patch_arg *a = arg;
8651
8652 *choice = GOT_PATCH_CHOICE_NONE;
8653
8654 if (a->patch_script_file) {
8655 interactive = 0;
8656 fp = a->patch_script_file;
8657 }
8658
8659 for (;;) {
8660 err = show_change(status, path, patch_file, n, nchanges,
8661 a->action);
8662 if (err)
8663 return err;
8664
8665 linelen = getline(&line, &linesize, fp);
8666 if (linelen == -1) {
8667 free(line);
8668 if (ferror(fp))
8669 return got_error_from_errno("getline");
8670 if (feof(fp))
8671 return got_error(GOT_ERR_EOF);
8672 return NULL;
8673 }
8674
8675 nl = strchr(line, '\n');
8676 if (nl)
8677 *nl = '\0';
8678 if (strlen(line) != 1 ||
8679 !strchr(CHOOSE_PATCH_VALID_RESPONSES, line[0])) {
8680 printf("invalid response '%s'\n", line);
8681 if (interactive)
8682 continue;
8683 }
8684
8685 /* ADD and DELETE do not accept 'q' response currently. */
8686 if (status != GOT_STATUS_MODIFY && line[0] == 'q') {
8687 printf("invalid response '%s'\n", line);
8688 continue;
8689 }
8690
8691 break;
8692 }
8693
8694 switch (line[0]) {
8695 case 'y':
8696 *choice = GOT_PATCH_CHOICE_YES;
8697 break;
8698 case 'n':
8699 *choice = GOT_PATCH_CHOICE_NO;
8700 break;
8701 case 'q':
8702 if (status == GOT_STATUS_MODIFY)
8703 *choice = GOT_PATCH_CHOICE_QUIT;
8704 break;
8705 default:
8706 printf("invalid response '%s'\n", line);
8707 free(line);
8708 return NULL;
8709 }
8710
8711 if (!interactive)
8712 printf("%c\n", line[0]);
8713
8714 free(line);
8715 return NULL;
8716 }
8717
8718 struct wt_commitable_path_arg {
8719 struct got_pathlist_head *commit_paths;
8720 int *has_changes;
8721 };
8722
8723 /*
8724 * Shortcut work tree status callback to determine if the set of paths scanned
8725 * has at least one versioned path that is being modified and, if not NULL, is
8726 * in the arg->commit_paths list. Set arg and return GOT_ERR_FILE_MODIFIED as
8727 * soon as a path is passed with a status that satisfies this criteria.
8728 */
8729 static const struct got_error *
8730 worktree_has_commitable_path(void *arg, unsigned char status,
8731 unsigned char staged_status, const char *path,
8732 struct got_object_id *blob_id, struct got_object_id *staged_blob_id,
8733 struct got_object_id *commit_id, int dirfd, const char *de_name)
8734 {
8735 struct wt_commitable_path_arg *a = arg;
8736
8737 if (status == staged_status && (status == GOT_STATUS_DELETE))
8738 status = GOT_STATUS_NO_CHANGE;
8739
8740 if (!(status == GOT_STATUS_NO_CHANGE ||
8741 status == GOT_STATUS_UNVERSIONED) ||
8742 staged_status != GOT_STATUS_NO_CHANGE) {
8743 if (a->commit_paths != NULL) {
8744 struct got_pathlist_entry *pe;
8745
8746 TAILQ_FOREACH(pe, a->commit_paths, entry) {
8747 if (strncmp(path, pe->path,
8748 pe->path_len) == 0) {
8749 *a->has_changes = 1;
8750 break;
8751 }
8752 }
8753 } else
8754 *a->has_changes = 1;
8755
8756 if (*a->has_changes)
8757 return got_error(GOT_ERR_FILE_MODIFIED);
8758 }
8759
8760 return NULL;
8761 }
8762
8763 /*
8764 * Check that the changeset of the commit identified by id is
8765 * comprised of at least one modified path that is being committed.
8766 */
8767 static const struct got_error *
8768 commit_path_changed_in_worktree(struct wt_commitable_path_arg *wcpa,
8769 struct got_object_id *id, struct got_worktree *worktree,
8770 struct got_repository *repo)
8771 {
8772 const struct got_error *err;
8773 struct got_pathlist_head paths;
8774 struct got_commit_object *commit = NULL, *pcommit = NULL;
8775 struct got_tree_object *tree = NULL, *ptree = NULL;
8776 struct got_object_qid *pid;
8777
8778 TAILQ_INIT(&paths);
8779
8780 err = got_object_open_as_commit(&commit, repo, id);
8781 if (err)
8782 goto done;
8783
8784 err = got_object_open_as_tree(&tree, repo,
8785 got_object_commit_get_tree_id(commit));
8786 if (err)
8787 goto done;
8788
8789 pid = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
8790 if (pid != NULL) {
8791 err = got_object_open_as_commit(&pcommit, repo, &pid->id);
8792 if (err)
8793 goto done;
8794
8795 err = got_object_open_as_tree(&ptree, repo,
8796 got_object_commit_get_tree_id(pcommit));
8797 if (err)
8798 goto done;
8799 }
8800
8801 err = got_diff_tree(ptree, tree, NULL, NULL, -1, -1, "", "", repo,
8802 got_diff_tree_collect_changed_paths, &paths, 0);
8803 if (err)
8804 goto done;
8805
8806 err = got_worktree_status(worktree, &paths, repo, 0,
8807 worktree_has_commitable_path, wcpa, check_cancelled, NULL);
8808 if (err && err->code == GOT_ERR_FILE_MODIFIED) {
8809 /*
8810 * At least one changed path in the referenced commit is
8811 * modified in the work tree, that's all we need to know!
8812 */
8813 err = NULL;
8814 }
8815
8816 done:
8817 got_pathlist_free(&paths, GOT_PATHLIST_FREE_ALL);
8818 if (commit)
8819 got_object_commit_close(commit);
8820 if (pcommit)
8821 got_object_commit_close(pcommit);
8822 if (tree)
8823 got_object_tree_close(tree);
8824 if (ptree)
8825 got_object_tree_close(ptree);
8826 return err;
8827 }
8828
8829 /*
8830 * Remove any "logmsg" reference comprised entirely of paths that have
8831 * been reverted in this work tree. If any path in the logmsg ref changeset
8832 * remains in a changed state in the worktree, do not remove the reference.
8833 */
8834 static const struct got_error *
8835 rm_logmsg_ref(struct got_worktree *worktree, struct got_repository *repo)
8836 {
8837 const struct got_error *err;
8838 struct got_reflist_head refs;
8839 struct got_reflist_entry *re;
8840 struct got_commit_object *commit = NULL;
8841 struct got_object_id *commit_id = NULL;
8842 struct wt_commitable_path_arg wcpa;
8843 char *uuidstr = NULL;
8844
8845 TAILQ_INIT(&refs);
8846
8847 err = got_worktree_get_uuid(&uuidstr, worktree);
8848 if (err)
8849 goto done;
8850
8851 err = got_ref_list(&refs, repo, "refs/got/worktree",
8852 got_ref_cmp_by_name, repo);
8853 if (err)
8854 goto done;
8855
8856 TAILQ_FOREACH(re, &refs, entry) {
8857 const char *refname;
8858 int has_changes = 0;
8859
8860 refname = got_ref_get_name(re->ref);
8861
8862 if (!strncmp(refname, GOT_WORKTREE_CHERRYPICK_REF_PREFIX,
8863 GOT_WORKTREE_CHERRYPICK_REF_PREFIX_LEN))
8864 refname += GOT_WORKTREE_CHERRYPICK_REF_PREFIX_LEN + 1;
8865 else if (!strncmp(refname, GOT_WORKTREE_BACKOUT_REF_PREFIX,
8866 GOT_WORKTREE_BACKOUT_REF_PREFIX_LEN))
8867 refname += GOT_WORKTREE_BACKOUT_REF_PREFIX_LEN + 1;
8868 else
8869 continue;
8870
8871 if (strncmp(refname, uuidstr, GOT_WORKTREE_UUID_STRLEN) == 0)
8872 refname += GOT_WORKTREE_UUID_STRLEN + 1; /* skip '-' */
8873 else
8874 continue;
8875
8876 err = got_repo_match_object_id(&commit_id, NULL, refname,
8877 GOT_OBJ_TYPE_COMMIT, NULL, repo);
8878 if (err)
8879 goto done;
8880
8881 err = got_object_open_as_commit(&commit, repo, commit_id);
8882 if (err)
8883 goto done;
8884
8885 wcpa.commit_paths = NULL;
8886 wcpa.has_changes = &has_changes;
8887
8888 err = commit_path_changed_in_worktree(&wcpa, commit_id,
8889 worktree, repo);
8890 if (err)
8891 goto done;
8892
8893 if (!has_changes) {
8894 err = got_ref_delete(re->ref, repo);
8895 if (err)
8896 goto done;
8897 }
8898
8899 got_object_commit_close(commit);
8900 commit = NULL;
8901 free(commit_id);
8902 commit_id = NULL;
8903 }
8904
8905 done:
8906 free(uuidstr);
8907 free(commit_id);
8908 got_ref_list_free(&refs);
8909 if (commit)
8910 got_object_commit_close(commit);
8911 return err;
8912 }
8913
8914 static const struct got_error *
8915 cmd_revert(int argc, char *argv[])
8916 {
8917 const struct got_error *error = NULL;
8918 struct got_worktree *worktree = NULL;
8919 struct got_repository *repo = NULL;
8920 char *cwd = NULL, *path = NULL;
8921 struct got_pathlist_head paths;
8922 struct got_pathlist_entry *pe;
8923 int ch, can_recurse = 0, pflag = 0;
8924 FILE *patch_script_file = NULL;
8925 const char *patch_script_path = NULL;
8926 struct choose_patch_arg cpa;
8927 int *pack_fds = NULL;
8928
8929 TAILQ_INIT(&paths);
8930
8931 #ifndef PROFILE
8932 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
8933 "unveil", NULL) == -1)
8934 err(1, "pledge");
8935 #endif
8936
8937 while ((ch = getopt(argc, argv, "F:pR")) != -1) {
8938 switch (ch) {
8939 case 'F':
8940 patch_script_path = optarg;
8941 break;
8942 case 'p':
8943 pflag = 1;
8944 break;
8945 case 'R':
8946 can_recurse = 1;
8947 break;
8948 default:
8949 usage_revert();
8950 /* NOTREACHED */
8951 }
8952 }
8953
8954 argc -= optind;
8955 argv += optind;
8956
8957 if (argc < 1)
8958 usage_revert();
8959 if (patch_script_path && !pflag)
8960 errx(1, "-F option can only be used together with -p option");
8961
8962 cwd = getcwd(NULL, 0);
8963 if (cwd == NULL) {
8964 error = got_error_from_errno("getcwd");
8965 goto done;
8966 }
8967
8968 error = got_repo_pack_fds_open(&pack_fds);
8969 if (error != NULL)
8970 goto done;
8971
8972 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
8973 if (error) {
8974 if (error->code == GOT_ERR_NOT_WORKTREE)
8975 error = wrap_not_worktree_error(error, "revert", cwd);
8976 goto done;
8977 }
8978
8979 error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
8980 NULL, pack_fds);
8981 if (error != NULL)
8982 goto done;
8983
8984 if (patch_script_path) {
8985 patch_script_file = fopen(patch_script_path, "re");
8986 if (patch_script_file == NULL) {
8987 error = got_error_from_errno2("fopen",
8988 patch_script_path);
8989 goto done;
8990 }
8991 }
8992
8993 /*
8994 * XXX "c" perm needed on repo dir to delete merge references.
8995 */
8996 error = apply_unveil(got_repo_get_path(repo), 0,
8997 got_worktree_get_root_path(worktree));
8998 if (error)
8999 goto done;
9000
9001 error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
9002 if (error)
9003 goto done;
9004
9005 if (!can_recurse) {
9006 char *ondisk_path;
9007 struct stat sb;
9008 TAILQ_FOREACH(pe, &paths, entry) {
9009 if (asprintf(&ondisk_path, "%s/%s",
9010 got_worktree_get_root_path(worktree),
9011 pe->path) == -1) {
9012 error = got_error_from_errno("asprintf");
9013 goto done;
9014 }
9015 if (lstat(ondisk_path, &sb) == -1) {
9016 if (errno == ENOENT) {
9017 free(ondisk_path);
9018 continue;
9019 }
9020 error = got_error_from_errno2("lstat",
9021 ondisk_path);
9022 free(ondisk_path);
9023 goto done;
9024 }
9025 free(ondisk_path);
9026 if (S_ISDIR(sb.st_mode)) {
9027 error = got_error_msg(GOT_ERR_BAD_PATH,
9028 "reverting directories requires -R option");
9029 goto done;
9030 }
9031 }
9032 }
9033
9034 cpa.patch_script_file = patch_script_file;
9035 cpa.action = "revert";
9036 error = got_worktree_revert(worktree, &paths, revert_progress, NULL,
9037 pflag ? choose_patch : NULL, &cpa, repo);
9038
9039 error = rm_logmsg_ref(worktree, repo);
9040 done:
9041 if (patch_script_file && fclose(patch_script_file) == EOF &&
9042 error == NULL)
9043 error = got_error_from_errno2("fclose", patch_script_path);
9044 if (repo) {
9045 const struct got_error *close_err = got_repo_close(repo);
9046 if (error == NULL)
9047 error = close_err;
9048 }
9049 if (worktree)
9050 got_worktree_close(worktree);
9051 if (pack_fds) {
9052 const struct got_error *pack_err =
9053 got_repo_pack_fds_close(pack_fds);
9054 if (error == NULL)
9055 error = pack_err;
9056 }
9057 got_pathlist_free(&paths, GOT_PATHLIST_FREE_PATH);
9058 free(path);
9059 free(cwd);
9060 return error;
9061 }
9062
9063 __dead static void
9064 usage_commit(void)
9065 {
9066 fprintf(stderr, "usage: %s commit [-CNnS] [-A author] [-F path] "
9067 "[-m message] [path ...]\n", getprogname());
9068 exit(1);
9069 }
9070
9071 struct collect_commit_logmsg_arg {
9072 const char *cmdline_log;
9073 const char *prepared_log;
9074 const char *merged_log;
9075 int non_interactive;
9076 const char *editor;
9077 const char *worktree_path;
9078 const char *branch_name;
9079 const char *repo_path;
9080 char *logmsg_path;
9081
9082 };
9083
9084 static const struct got_error *
9085 read_prepared_logmsg(char **logmsg, const char *path)
9086 {
9087 const struct got_error *err = NULL;
9088 FILE *f = NULL;
9089 struct stat sb;
9090 size_t r;
9091
9092 *logmsg = NULL;
9093 memset(&sb, 0, sizeof(sb));
9094
9095 f = fopen(path, "re");
9096 if (f == NULL)
9097 return got_error_from_errno2("fopen", path);
9098
9099 if (fstat(fileno(f), &sb) == -1) {
9100 err = got_error_from_errno2("fstat", path);
9101 goto done;
9102 }
9103 if (sb.st_size == 0) {
9104 err = got_error(GOT_ERR_COMMIT_MSG_EMPTY);
9105 goto done;
9106 }
9107
9108 *logmsg = malloc(sb.st_size + 1);
9109 if (*logmsg == NULL) {
9110 err = got_error_from_errno("malloc");
9111 goto done;
9112 }
9113
9114 r = fread(*logmsg, 1, sb.st_size, f);
9115 if (r != sb.st_size) {
9116 if (ferror(f))
9117 err = got_error_from_errno2("fread", path);
9118 else
9119 err = got_error(GOT_ERR_IO);
9120 goto done;
9121 }
9122 (*logmsg)[sb.st_size] = '\0';
9123 done:
9124 if (fclose(f) == EOF && err == NULL)
9125 err = got_error_from_errno2("fclose", path);
9126 if (err) {
9127 free(*logmsg);
9128 *logmsg = NULL;
9129 }
9130 return err;
9131 }
9132
9133 static const struct got_error *
9134 collect_commit_logmsg(struct got_pathlist_head *commitable_paths,
9135 const char *diff_path, char **logmsg, void *arg)
9136 {
9137 char *initial_content = NULL;
9138 struct got_pathlist_entry *pe;
9139 const struct got_error *err = NULL;
9140 char *template = NULL;
9141 char *prepared_msg = NULL, *merged_msg = NULL;
9142 struct collect_commit_logmsg_arg *a = arg;
9143 int initial_content_len;
9144 int fd = -1;
9145 size_t len;
9146
9147 /* if a message was specified on the command line, just use it */
9148 if (a->cmdline_log != NULL && *a->cmdline_log != '\0') {
9149 len = strlen(a->cmdline_log) + 1;
9150 *logmsg = malloc(len + 1);
9151 if (*logmsg == NULL)
9152 return got_error_from_errno("malloc");
9153 strlcpy(*logmsg, a->cmdline_log, len);
9154 return NULL;
9155 } else if (a->prepared_log != NULL && a->non_interactive)
9156 return read_prepared_logmsg(logmsg, a->prepared_log);
9157
9158 if (asprintf(&template, "%s/logmsg", a->worktree_path) == -1)
9159 return got_error_from_errno("asprintf");
9160
9161 err = got_opentemp_named_fd(&a->logmsg_path, &fd, template, "");
9162 if (err)
9163 goto done;
9164
9165 if (a->prepared_log) {
9166 err = read_prepared_logmsg(&prepared_msg, a->prepared_log);
9167 if (err)
9168 goto done;
9169 } else if (a->merged_log) {
9170 err = read_prepared_logmsg(&merged_msg, a->merged_log);
9171 if (err)
9172 goto done;
9173 }
9174
9175 initial_content_len = asprintf(&initial_content,
9176 "%s%s\n# changes to be committed on branch %s:\n",
9177 prepared_msg ? prepared_msg : "",
9178 merged_msg ? merged_msg : "", a->branch_name);
9179 if (initial_content_len == -1) {
9180 err = got_error_from_errno("asprintf");
9181 goto done;
9182 }
9183
9184 if (write(fd, initial_content, initial_content_len) == -1) {
9185 err = got_error_from_errno2("write", a->logmsg_path);
9186 goto done;
9187 }
9188
9189 TAILQ_FOREACH(pe, commitable_paths, entry) {
9190 struct got_commitable *ct = pe->data;
9191 dprintf(fd, "# %c %s\n",
9192 got_commitable_get_status(ct),
9193 got_commitable_get_path(ct));
9194 }
9195
9196 if (diff_path) {
9197 dprintf(fd, "# detailed changes can be viewed in %s\n",
9198 diff_path);
9199 }
9200
9201 if (close(fd) == -1) {
9202 err = got_error_from_errno2("close", a->logmsg_path);
9203 goto done;
9204 }
9205 fd = -1;
9206
9207 err = edit_logmsg(logmsg, a->editor, a->logmsg_path, initial_content,
9208 initial_content_len, a->prepared_log ? 0 : 1);
9209 done:
9210 free(initial_content);
9211 free(template);
9212 free(prepared_msg);
9213 free(merged_msg);
9214
9215 if (fd != -1 && close(fd) == -1 && err == NULL)
9216 err = got_error_from_errno2("close", a->logmsg_path);
9217 if (err) {
9218 free(*logmsg);
9219 *logmsg = NULL;
9220 }
9221 return err;
9222 }
9223
9224 static const struct got_error *
9225 cat_logmsg(FILE *f, struct got_commit_object *commit, const char *idstr,
9226 const char *type, int has_content)
9227 {
9228 const struct got_error *err = NULL;
9229 char *logmsg = NULL;
9230
9231 err = got_object_commit_get_logmsg(&logmsg, commit);
9232 if (err)
9233 return err;
9234
9235 if (fprintf(f, "%s# log message of %s commit %s:%s",
9236 has_content ? "\n" : "", type, idstr, logmsg) < 0)
9237 err = got_ferror(f, GOT_ERR_IO);
9238
9239 free(logmsg);
9240 return err;
9241 }
9242
9243 /*
9244 * Lookup "logmsg" references of backed-out and cherrypicked commits
9245 * belonging to the current work tree. If found, and the worktree has
9246 * at least one modified file that was changed in the referenced commit,
9247 * add its log message to a new temporary file at *logmsg_path.
9248 * Add all refs found to matched_refs to be scheduled for removal on
9249 * successful commit.
9250 */
9251 static const struct got_error *
9252 lookup_logmsg_ref(char **logmsg_path, struct got_pathlist_head *paths,
9253 struct got_reflist_head *matched_refs, struct got_worktree *worktree,
9254 struct got_repository *repo)
9255 {
9256 const struct got_error *err;
9257 struct got_commit_object *commit = NULL;
9258 struct got_object_id *id = NULL;
9259 struct got_reflist_head refs;
9260 struct got_reflist_entry *re, *re_match;
9261 FILE *f = NULL;
9262 char *uuidstr = NULL;
9263 int added_logmsg = 0;
9264
9265 TAILQ_INIT(&refs);
9266
9267 *logmsg_path = NULL;
9268
9269 err = got_worktree_get_uuid(&uuidstr, worktree);
9270 if (err)
9271 goto done;
9272
9273 err = got_ref_list(&refs, repo, "refs/got/worktree",
9274 got_ref_cmp_by_name, repo);
9275 if (err)
9276 goto done;
9277
9278 TAILQ_FOREACH(re, &refs, entry) {
9279 const char *refname, *type;
9280 struct wt_commitable_path_arg wcpa;
9281 int add_logmsg = 0;
9282
9283 refname = got_ref_get_name(re->ref);
9284
9285 if (strncmp(refname, GOT_WORKTREE_CHERRYPICK_REF_PREFIX,
9286 GOT_WORKTREE_CHERRYPICK_REF_PREFIX_LEN) == 0) {
9287 refname += GOT_WORKTREE_CHERRYPICK_REF_PREFIX_LEN + 1;
9288 type = "cherrypicked";
9289 } else if (strncmp(refname, GOT_WORKTREE_BACKOUT_REF_PREFIX,
9290 GOT_WORKTREE_BACKOUT_REF_PREFIX_LEN) == 0) {
9291 refname += GOT_WORKTREE_BACKOUT_REF_PREFIX_LEN + 1;
9292 type = "backed-out";
9293 } else
9294 continue;
9295
9296 if (strncmp(refname, uuidstr, GOT_WORKTREE_UUID_STRLEN) == 0)
9297 refname += GOT_WORKTREE_UUID_STRLEN + 1; /* skip '-' */
9298 else
9299 continue;
9300
9301 err = got_repo_match_object_id(&id, NULL, refname,
9302 GOT_OBJ_TYPE_COMMIT, NULL, repo);
9303 if (err)
9304 goto done;
9305
9306 err = got_object_open_as_commit(&commit, repo, id);
9307 if (err)
9308 goto done;
9309
9310 wcpa.commit_paths = paths;
9311 wcpa.has_changes = &add_logmsg;
9312
9313 err = commit_path_changed_in_worktree(&wcpa, id,
9314 worktree, repo);
9315 if (err)
9316 goto done;
9317
9318 if (add_logmsg) {
9319 if (f == NULL) {
9320 err = got_opentemp_named(logmsg_path, &f,
9321 "got-commit-logmsg", "");
9322 if (err)
9323 goto done;
9324 }
9325 err = cat_logmsg(f, commit, refname, type,
9326 added_logmsg);
9327 if (err)
9328 goto done;
9329 if (!added_logmsg)
9330 ++added_logmsg;
9331
9332 err = got_reflist_entry_dup(&re_match, re);
9333 if (err)
9334 goto done;
9335 TAILQ_INSERT_HEAD(matched_refs, re_match, entry);
9336 }
9337
9338 got_object_commit_close(commit);
9339 commit = NULL;
9340 free(id);
9341 id = NULL;
9342 }
9343
9344 done:
9345 free(id);
9346 free(uuidstr);
9347 got_ref_list_free(&refs);
9348 if (commit)
9349 got_object_commit_close(commit);
9350 if (f && fclose(f) == EOF && err == NULL)
9351 err = got_error_from_errno("fclose");
9352 if (!added_logmsg) {
9353 if (*logmsg_path && unlink(*logmsg_path) != 0 && err == NULL)
9354 err = got_error_from_errno2("unlink", *logmsg_path);
9355 *logmsg_path = NULL;
9356 }
9357 return err;
9358 }
9359
9360 static const struct got_error *
9361 cmd_commit(int argc, char *argv[])
9362 {
9363 const struct got_error *error = NULL;
9364 struct got_worktree *worktree = NULL;
9365 struct got_repository *repo = NULL;
9366 char *cwd = NULL, *id_str = NULL;
9367 struct got_object_id *id = NULL;
9368 const char *logmsg = NULL;
9369 char *prepared_logmsg = NULL, *merged_logmsg = NULL;
9370 struct collect_commit_logmsg_arg cl_arg;
9371 const char *author = NULL;
9372 char *gitconfig_path = NULL, *editor = NULL, *committer = NULL;
9373 int ch, rebase_in_progress, histedit_in_progress, preserve_logmsg = 0;
9374 int allow_bad_symlinks = 0, non_interactive = 0, merge_in_progress = 0;
9375 int show_diff = 1, commit_conflicts = 0;
9376 struct got_pathlist_head paths;
9377 struct got_reflist_head refs;
9378 struct got_reflist_entry *re;
9379 int *pack_fds = NULL;
9380
9381 TAILQ_INIT(&refs);
9382 TAILQ_INIT(&paths);
9383 cl_arg.logmsg_path = NULL;
9384
9385 #ifndef PROFILE
9386 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
9387 "unveil", NULL) == -1)
9388 err(1, "pledge");
9389 #endif
9390
9391 while ((ch = getopt(argc, argv, "A:CF:m:NnS")) != -1) {
9392 switch (ch) {
9393 case 'A':
9394 author = optarg;
9395 error = valid_author(author);
9396 if (error)
9397 return error;
9398 break;
9399 case 'C':
9400 commit_conflicts = 1;
9401 break;
9402 case 'F':
9403 if (logmsg != NULL)
9404 option_conflict('F', 'm');
9405 prepared_logmsg = realpath(optarg, NULL);
9406 if (prepared_logmsg == NULL)
9407 return got_error_from_errno2("realpath",
9408 optarg);
9409 break;
9410 case 'm':
9411 if (prepared_logmsg)
9412 option_conflict('m', 'F');
9413 logmsg = optarg;
9414 break;
9415 case 'N':
9416 non_interactive = 1;
9417 break;
9418 case 'n':
9419 show_diff = 0;
9420 break;
9421 case 'S':
9422 allow_bad_symlinks = 1;
9423 break;
9424 default:
9425 usage_commit();
9426 /* NOTREACHED */
9427 }
9428 }
9429
9430 argc -= optind;
9431 argv += optind;
9432
9433 cwd = getcwd(NULL, 0);
9434 if (cwd == NULL) {
9435 error = got_error_from_errno("getcwd");
9436 goto done;
9437 }
9438
9439 error = got_repo_pack_fds_open(&pack_fds);
9440 if (error != NULL)
9441 goto done;
9442
9443 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
9444 if (error) {
9445 if (error->code == GOT_ERR_NOT_WORKTREE)
9446 error = wrap_not_worktree_error(error, "commit", cwd);
9447 goto done;
9448 }
9449
9450 error = got_worktree_rebase_in_progress(&rebase_in_progress, worktree);
9451 if (error)
9452 goto done;
9453 if (rebase_in_progress) {
9454 error = got_error(GOT_ERR_REBASING);
9455 goto done;
9456 }
9457
9458 error = got_worktree_histedit_in_progress(&histedit_in_progress,
9459 worktree);
9460 if (error)
9461 goto done;
9462
9463 error = get_gitconfig_path(&gitconfig_path);
9464 if (error)
9465 goto done;
9466 error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
9467 gitconfig_path, pack_fds);
9468 if (error != NULL)
9469 goto done;
9470
9471 error = got_worktree_merge_in_progress(&merge_in_progress, worktree, repo);
9472 if (error)
9473 goto done;
9474 if (merge_in_progress) {
9475 error = got_error(GOT_ERR_MERGE_BUSY);
9476 goto done;
9477 }
9478
9479 error = get_author(&committer, repo, worktree);
9480 if (error)
9481 goto done;
9482
9483 if (author == NULL)
9484 author = committer;
9485
9486 if (logmsg == NULL || strlen(logmsg) == 0) {
9487 error = get_editor(&editor);
9488 if (error)
9489 goto done;
9490 if (unveil(editor, "x") != 0) {
9491 error = got_error_from_errno2("unveil", editor);
9492 goto done;
9493 }
9494 }
9495 if (prepared_logmsg) {
9496 if (unveil(prepared_logmsg, "r") != 0) {
9497 error = got_error_from_errno2("unveil",
9498 prepared_logmsg);
9499 goto done;
9500 }
9501 }
9502
9503 error = apply_unveil(got_repo_get_path(repo), 0,
9504 got_worktree_get_root_path(worktree));
9505 if (error)
9506 goto done;
9507
9508 error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
9509 if (error)
9510 goto done;
9511
9512 if (prepared_logmsg == NULL) {
9513 error = lookup_logmsg_ref(&merged_logmsg,
9514 argc > 0 ? &paths : NULL, &refs, worktree, repo);
9515 if (error)
9516 goto done;
9517 }
9518
9519 cl_arg.editor = editor;
9520 cl_arg.cmdline_log = logmsg;
9521 cl_arg.prepared_log = prepared_logmsg;
9522 cl_arg.merged_log = merged_logmsg;
9523 cl_arg.non_interactive = non_interactive;
9524 cl_arg.worktree_path = got_worktree_get_root_path(worktree);
9525 cl_arg.branch_name = got_worktree_get_head_ref_name(worktree);
9526 if (!histedit_in_progress) {
9527 if (strncmp(cl_arg.branch_name, "refs/heads/", 11) != 0) {
9528 error = got_error(GOT_ERR_COMMIT_BRANCH);
9529 goto done;
9530 }
9531 cl_arg.branch_name += 11;
9532 }
9533 cl_arg.repo_path = got_repo_get_path(repo);
9534 error = got_worktree_commit(&id, worktree, &paths, author, committer,
9535 allow_bad_symlinks, show_diff, commit_conflicts,
9536 collect_commit_logmsg, &cl_arg, print_status, NULL, repo);
9537 if (error) {
9538 if (error->code != GOT_ERR_COMMIT_MSG_EMPTY &&
9539 cl_arg.logmsg_path != NULL)
9540 preserve_logmsg = 1;
9541 goto done;
9542 }
9543
9544 error = got_object_id_str(&id_str, id);
9545 if (error)
9546 goto done;
9547 printf("Created commit %s\n", id_str);
9548
9549 TAILQ_FOREACH(re, &refs, entry) {
9550 error = got_ref_delete(re->ref, repo);
9551 if (error)
9552 goto done;
9553 }
9554
9555 done:
9556 if (preserve_logmsg) {
9557 fprintf(stderr, "%s: log message preserved in %s\n",
9558 getprogname(), cl_arg.logmsg_path);
9559 } else if (cl_arg.logmsg_path && unlink(cl_arg.logmsg_path) == -1 &&
9560 error == NULL)
9561 error = got_error_from_errno2("unlink", cl_arg.logmsg_path);
9562 free(cl_arg.logmsg_path);
9563 if (merged_logmsg && unlink(merged_logmsg) == -1 && error == NULL)
9564 error = got_error_from_errno2("unlink", merged_logmsg);
9565 free(merged_logmsg);
9566 if (repo) {
9567 const struct got_error *close_err = got_repo_close(repo);
9568 if (error == NULL)
9569 error = close_err;
9570 }
9571 if (worktree)
9572 got_worktree_close(worktree);
9573 if (pack_fds) {
9574 const struct got_error *pack_err =
9575 got_repo_pack_fds_close(pack_fds);
9576 if (error == NULL)
9577 error = pack_err;
9578 }
9579 got_ref_list_free(&refs);
9580 got_pathlist_free(&paths, GOT_PATHLIST_FREE_PATH);
9581 free(cwd);
9582 free(id_str);
9583 free(gitconfig_path);
9584 free(editor);
9585 free(committer);
9586 free(prepared_logmsg);
9587 return error;
9588 }
9589
9590 __dead static void
9591 usage_send(void)
9592 {
9593 fprintf(stderr, "usage: %s send [-afqTv] [-b branch] [-d branch] "
9594 "[-r repository-path] [-t tag] [remote-repository]\n",
9595 getprogname());
9596 exit(1);
9597 }
9598
9599 static void
9600 print_load_info(int print_colored, int print_found, int print_trees,
9601 int ncolored, int nfound, int ntrees)
9602 {
9603 if (print_colored) {
9604 printf("%d commit%s colored", ncolored,
9605 ncolored == 1 ? "" : "s");
9606 }
9607 if (print_found) {
9608 printf("%s%d object%s found",
9609 ncolored > 0 ? "; " : "",
9610 nfound, nfound == 1 ? "" : "s");
9611 }
9612 if (print_trees) {
9613 printf("; %d tree%s scanned", ntrees,
9614 ntrees == 1 ? "" : "s");
9615 }
9616 }
9617
9618 struct got_send_progress_arg {
9619 char last_scaled_packsize[FMT_SCALED_STRSIZE];
9620 int verbosity;
9621 int last_ncolored;
9622 int last_nfound;
9623 int last_ntrees;
9624 int loading_done;
9625 int last_ncommits;
9626 int last_nobj_total;
9627 int last_p_deltify;
9628 int last_p_written;
9629 int last_p_sent;
9630 int printed_something;
9631 int sent_something;
9632 struct got_pathlist_head *delete_branches;
9633 };
9634
9635 static const struct got_error *
9636 send_progress(void *arg, int ncolored, int nfound, int ntrees,
9637 off_t packfile_size, int ncommits, int nobj_total, int nobj_deltify,
9638 int nobj_written, off_t bytes_sent, const char *refname,
9639 const char *errmsg, int success)
9640 {
9641 struct got_send_progress_arg *a = arg;
9642 char scaled_packsize[FMT_SCALED_STRSIZE];
9643 char scaled_sent[FMT_SCALED_STRSIZE];
9644 int p_deltify = 0, p_written = 0, p_sent = 0;
9645 int print_colored = 0, print_found = 0, print_trees = 0;
9646 int print_searching = 0, print_total = 0;
9647 int print_deltify = 0, print_written = 0, print_sent = 0;
9648
9649 if (a->verbosity < 0)
9650 return NULL;
9651
9652 if (refname) {
9653 const char *status = success ? "accepted" : "rejected";
9654
9655 if (success) {
9656 struct got_pathlist_entry *pe;
9657 TAILQ_FOREACH(pe, a->delete_branches, entry) {
9658 const char *branchname = pe->path;
9659 if (got_path_cmp(branchname, refname,
9660 strlen(branchname), strlen(refname)) == 0) {
9661 status = "deleted";
9662 a->sent_something = 1;
9663 break;
9664 }
9665 }
9666 }
9667
9668 if (a->printed_something)
9669 putchar('\n');
9670 printf("Server has %s %s", status, refname);
9671 if (errmsg)
9672 printf(": %s", errmsg);
9673 a->printed_something = 1;
9674 return NULL;
9675 }
9676
9677 if (a->last_ncolored != ncolored) {
9678 print_colored = 1;
9679 a->last_ncolored = ncolored;
9680 }
9681
9682 if (a->last_nfound != nfound) {
9683 print_colored = 1;
9684 print_found = 1;
9685 a->last_nfound = nfound;
9686 }
9687
9688 if (a->last_ntrees != ntrees) {
9689 print_colored = 1;
9690 print_found = 1;
9691 print_trees = 1;
9692 a->last_ntrees = ntrees;
9693 }
9694
9695 if ((print_colored || print_found || print_trees) &&
9696 !a->loading_done) {
9697 printf("\r");
9698 print_load_info(print_colored, print_found, print_trees,
9699 ncolored, nfound, ntrees);
9700 a->printed_something = 1;
9701 fflush(stdout);
9702 return NULL;
9703 } else if (!a->loading_done) {
9704 printf("\r");
9705 print_load_info(1, 1, 1, ncolored, nfound, ntrees);
9706 printf("\n");
9707 a->loading_done = 1;
9708 }
9709
9710 if (fmt_scaled(packfile_size, scaled_packsize) == -1)
9711 return got_error_from_errno("fmt_scaled");
9712 if (fmt_scaled(bytes_sent, scaled_sent) == -1)
9713 return got_error_from_errno("fmt_scaled");
9714
9715 if (a->last_ncommits != ncommits) {
9716 print_searching = 1;
9717 a->last_ncommits = ncommits;
9718 }
9719
9720 if (a->last_nobj_total != nobj_total) {
9721 print_searching = 1;
9722 print_total = 1;
9723 a->last_nobj_total = nobj_total;
9724 }
9725
9726 if (packfile_size > 0 && (a->last_scaled_packsize[0] == '\0' ||
9727 strcmp(scaled_packsize, a->last_scaled_packsize)) != 0) {
9728 if (strlcpy(a->last_scaled_packsize, scaled_packsize,
9729 FMT_SCALED_STRSIZE) >= FMT_SCALED_STRSIZE)
9730 return got_error(GOT_ERR_NO_SPACE);
9731 }
9732
9733 if (nobj_deltify > 0 || nobj_written > 0) {
9734 if (nobj_deltify > 0) {
9735 p_deltify = (nobj_deltify * 100) / nobj_total;
9736 if (p_deltify != a->last_p_deltify) {
9737 a->last_p_deltify = p_deltify;
9738 print_searching = 1;
9739 print_total = 1;
9740 print_deltify = 1;
9741 }
9742 }
9743 if (nobj_written > 0) {
9744 p_written = (nobj_written * 100) / nobj_total;
9745 if (p_written != a->last_p_written) {
9746 a->last_p_written = p_written;
9747 print_searching = 1;
9748 print_total = 1;
9749 print_deltify = 1;
9750 print_written = 1;
9751 }
9752 }
9753 }
9754
9755 if (bytes_sent > 0) {
9756 p_sent = (bytes_sent * 100) / packfile_size;
9757 if (p_sent != a->last_p_sent) {
9758 a->last_p_sent = p_sent;
9759 print_searching = 1;
9760 print_total = 1;
9761 print_deltify = 1;
9762 print_written = 1;
9763 print_sent = 1;
9764 }
9765 a->sent_something = 1;
9766 }
9767
9768 if (print_searching || print_total || print_deltify || print_written ||
9769 print_sent)
9770 printf("\r");
9771 if (print_searching)
9772 printf("packing %d reference%s", ncommits,
9773 ncommits == 1 ? "" : "s");
9774 if (print_total)
9775 printf("; %d object%s", nobj_total,
9776 nobj_total == 1 ? "" : "s");
9777 if (print_deltify)
9778 printf("; deltify: %d%%", p_deltify);
9779 if (print_sent)
9780 printf("; uploading pack: %*s %d%%", FMT_SCALED_STRSIZE - 2,
9781 scaled_packsize, p_sent);
9782 else if (print_written)
9783 printf("; writing pack: %*s %d%%", FMT_SCALED_STRSIZE - 2,
9784 scaled_packsize, p_written);
9785 if (print_searching || print_total || print_deltify ||
9786 print_written || print_sent) {
9787 a->printed_something = 1;
9788 fflush(stdout);
9789 }
9790 return NULL;
9791 }
9792
9793 static const struct got_error *
9794 cmd_send(int argc, char *argv[])
9795 {
9796 const struct got_error *error = NULL;
9797 char *cwd = NULL, *repo_path = NULL;
9798 const char *remote_name;
9799 char *proto = NULL, *host = NULL, *port = NULL;
9800 char *repo_name = NULL, *server_path = NULL;
9801 const struct got_remote_repo *remotes;
9802 struct got_remote_repo *remote = NULL;
9803 int nremotes, nbranches = 0, ndelete_branches = 0;
9804 struct got_repository *repo = NULL;
9805 struct got_worktree *worktree = NULL;
9806 const struct got_gotconfig *repo_conf = NULL, *worktree_conf = NULL;
9807 struct got_pathlist_head branches;
9808 struct got_pathlist_head tags;
9809 struct got_reflist_head all_branches;
9810 struct got_reflist_head all_tags;
9811 struct got_pathlist_head delete_args;
9812 struct got_pathlist_head delete_branches;
9813 struct got_reflist_entry *re;
9814 struct got_pathlist_entry *pe;
9815 int i, ch, sendfd = -1, sendstatus;
9816 pid_t sendpid = -1;
9817 struct got_send_progress_arg spa;
9818 int verbosity = 0, overwrite_refs = 0;
9819 int send_all_branches = 0, send_all_tags = 0;
9820 struct got_reference *ref = NULL;
9821 int *pack_fds = NULL;
9822
9823 TAILQ_INIT(&branches);
9824 TAILQ_INIT(&tags);
9825 TAILQ_INIT(&all_branches);
9826 TAILQ_INIT(&all_tags);
9827 TAILQ_INIT(&delete_args);
9828 TAILQ_INIT(&delete_branches);
9829
9830 while ((ch = getopt(argc, argv, "ab:d:fqr:Tt:v")) != -1) {
9831 switch (ch) {
9832 case 'a':
9833 send_all_branches = 1;
9834 break;
9835 case 'b':
9836 error = got_pathlist_append(&branches, optarg, NULL);
9837 if (error)
9838 return error;
9839 nbranches++;
9840 break;
9841 case 'd':
9842 error = got_pathlist_append(&delete_args, optarg, NULL);
9843 if (error)
9844 return error;
9845 break;
9846 case 'f':
9847 overwrite_refs = 1;
9848 break;
9849 case 'q':
9850 verbosity = -1;
9851 break;
9852 case 'r':
9853 repo_path = realpath(optarg, NULL);
9854 if (repo_path == NULL)
9855 return got_error_from_errno2("realpath",
9856 optarg);
9857 got_path_strip_trailing_slashes(repo_path);
9858 break;
9859 case 'T':
9860 send_all_tags = 1;
9861 break;
9862 case 't':
9863 error = got_pathlist_append(&tags, optarg, NULL);
9864 if (error)
9865 return error;
9866 break;
9867 case 'v':
9868 if (verbosity < 0)
9869 verbosity = 0;
9870 else if (verbosity < 3)
9871 verbosity++;
9872 break;
9873 default:
9874 usage_send();
9875 /* NOTREACHED */
9876 }
9877 }
9878 argc -= optind;
9879 argv += optind;
9880
9881 if (send_all_branches && !TAILQ_EMPTY(&branches))
9882 option_conflict('a', 'b');
9883 if (send_all_tags && !TAILQ_EMPTY(&tags))
9884 option_conflict('T', 't');
9885
9886
9887 if (argc == 0)
9888 remote_name = GOT_SEND_DEFAULT_REMOTE_NAME;
9889 else if (argc == 1)
9890 remote_name = argv[0];
9891 else
9892 usage_send();
9893
9894 cwd = getcwd(NULL, 0);
9895 if (cwd == NULL) {
9896 error = got_error_from_errno("getcwd");
9897 goto done;
9898 }
9899
9900 error = got_repo_pack_fds_open(&pack_fds);
9901 if (error != NULL)
9902 goto done;
9903
9904 if (repo_path == NULL) {
9905 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
9906 if (error && error->code != GOT_ERR_NOT_WORKTREE)
9907 goto done;
9908 else
9909 error = NULL;
9910 if (worktree) {
9911 repo_path =
9912 strdup(got_worktree_get_repo_path(worktree));
9913 if (repo_path == NULL)
9914 error = got_error_from_errno("strdup");
9915 if (error)
9916 goto done;
9917 } else {
9918 repo_path = strdup(cwd);
9919 if (repo_path == NULL) {
9920 error = got_error_from_errno("strdup");
9921 goto done;
9922 }
9923 }
9924 }
9925
9926 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
9927 if (error)
9928 goto done;
9929
9930 if (worktree) {
9931 worktree_conf = got_worktree_get_gotconfig(worktree);
9932 if (worktree_conf) {
9933 got_gotconfig_get_remotes(&nremotes, &remotes,
9934 worktree_conf);
9935 for (i = 0; i < nremotes; i++) {
9936 if (strcmp(remotes[i].name, remote_name) == 0) {
9937 error = got_repo_remote_repo_dup(&remote,
9938 &remotes[i]);
9939 if (error)
9940 goto done;
9941 break;
9942 }
9943 }
9944 }
9945 }
9946 if (remote == NULL) {
9947 repo_conf = got_repo_get_gotconfig(repo);
9948 if (repo_conf) {
9949 got_gotconfig_get_remotes(&nremotes, &remotes,
9950 repo_conf);
9951 for (i = 0; i < nremotes; i++) {
9952 if (strcmp(remotes[i].name, remote_name) == 0) {
9953 error = got_repo_remote_repo_dup(&remote,
9954 &remotes[i]);
9955 if (error)
9956 goto done;
9957 break;
9958 }
9959 }
9960 }
9961 }
9962 if (remote == NULL) {
9963 got_repo_get_gitconfig_remotes(&nremotes, &remotes, repo);
9964 for (i = 0; i < nremotes; i++) {
9965 if (strcmp(remotes[i].name, remote_name) == 0) {
9966 error = got_repo_remote_repo_dup(&remote,
9967 &remotes[i]);
9968 if (error)
9969 goto done;
9970 break;
9971 }
9972 }
9973 }
9974 if (remote == NULL) {
9975 error = got_error_path(remote_name, GOT_ERR_NO_REMOTE);
9976 goto done;
9977 }
9978
9979 error = got_dial_parse_uri(&proto, &host, &port, &server_path,
9980 &repo_name, remote->send_url);
9981 if (error)
9982 goto done;
9983
9984 if (strcmp(proto, "git") == 0) {
9985 #ifndef PROFILE
9986 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
9987 "sendfd dns inet unveil", NULL) == -1)
9988 err(1, "pledge");
9989 #endif
9990 } else if (strcmp(proto, "git+ssh") == 0 ||
9991 strcmp(proto, "ssh") == 0) {
9992 #ifndef PROFILE
9993 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
9994 "sendfd unveil", NULL) == -1)
9995 err(1, "pledge");
9996 #endif
9997 } else if (strcmp(proto, "http") == 0 ||
9998 strcmp(proto, "git+http") == 0) {
9999 error = got_error_path(proto, GOT_ERR_NOT_IMPL);
10000 goto done;
10001 } else {
10002 error = got_error_path(proto, GOT_ERR_BAD_PROTO);
10003 goto done;
10004 }
10005
10006 error = got_dial_apply_unveil(proto);
10007 if (error)
10008 goto done;
10009
10010 error = apply_unveil(got_repo_get_path(repo), 0, NULL);
10011 if (error)
10012 goto done;
10013
10014 if (send_all_branches) {
10015 error = got_ref_list(&all_branches, repo, "refs/heads",
10016 got_ref_cmp_by_name, NULL);
10017 if (error)
10018 goto done;
10019 TAILQ_FOREACH(re, &all_branches, entry) {
10020 const char *branchname = got_ref_get_name(re->ref);
10021 error = got_pathlist_append(&branches,
10022 branchname, NULL);
10023 if (error)
10024 goto done;
10025 nbranches++;
10026 }
10027 } else if (nbranches == 0) {
10028 for (i = 0; i < remote->nsend_branches; i++) {
10029 error = got_pathlist_append(&branches,
10030 remote->send_branches[i], NULL);
10031 if (error)
10032 goto done;
10033 }
10034 }
10035
10036 if (send_all_tags) {
10037 error = got_ref_list(&all_tags, repo, "refs/tags",
10038 got_ref_cmp_by_name, NULL);
10039 if (error)
10040 goto done;
10041 TAILQ_FOREACH(re, &all_tags, entry) {
10042 const char *tagname = got_ref_get_name(re->ref);
10043 error = got_pathlist_append(&tags,
10044 tagname, NULL);
10045 if (error)
10046 goto done;
10047 }
10048 }
10049
10050 /*
10051 * To prevent accidents only branches in refs/heads/ can be deleted
10052 * with 'got send -d'.
10053 * Deleting anything else requires local repository access or Git.
10054 */
10055 TAILQ_FOREACH(pe, &delete_args, entry) {
10056 const char *branchname = pe->path;
10057 char *s;
10058 struct got_pathlist_entry *new;
10059 if (strncmp(branchname, "refs/heads/", 11) == 0) {
10060 s = strdup(branchname);
10061 if (s == NULL) {
10062 error = got_error_from_errno("strdup");
10063 goto done;
10064 }
10065 } else {
10066 if (asprintf(&s, "refs/heads/%s", branchname) == -1) {
10067 error = got_error_from_errno("asprintf");
10068 goto done;
10069 }
10070 }
10071 error = got_pathlist_insert(&new, &delete_branches, s, NULL);
10072 if (error || new == NULL /* duplicate */)
10073 free(s);
10074 if (error)
10075 goto done;
10076 ndelete_branches++;
10077 }
10078
10079 if (nbranches == 0 && ndelete_branches == 0) {
10080 struct got_reference *head_ref;
10081 if (worktree)
10082 error = got_ref_open(&head_ref, repo,
10083 got_worktree_get_head_ref_name(worktree), 0);
10084 else
10085 error = got_ref_open(&head_ref, repo, GOT_REF_HEAD, 0);
10086 if (error)
10087 goto done;
10088 if (got_ref_is_symbolic(head_ref)) {
10089 error = got_ref_resolve_symbolic(&ref, repo, head_ref);
10090 got_ref_close(head_ref);
10091 if (error)
10092 goto done;
10093 } else
10094 ref = head_ref;
10095 error = got_pathlist_append(&branches, got_ref_get_name(ref),
10096 NULL);
10097 if (error)
10098 goto done;
10099 nbranches++;
10100 }
10101
10102 if (worktree) {
10103 /* Release work tree lock. */
10104 got_worktree_close(worktree);
10105 worktree = NULL;
10106 }
10107
10108 if (verbosity >= 0) {
10109 printf("Connecting to \"%s\" %s://%s%s%s%s%s\n",
10110 remote->name, proto, host,
10111 port ? ":" : "", port ? port : "",
10112 *server_path == '/' ? "" : "/", server_path);
10113 }
10114
10115 error = got_send_connect(&sendpid, &sendfd, proto, host, port,
10116 server_path, verbosity);
10117 if (error)
10118 goto done;
10119
10120 memset(&spa, 0, sizeof(spa));
10121 spa.last_scaled_packsize[0] = '\0';
10122 spa.last_p_deltify = -1;
10123 spa.last_p_written = -1;
10124 spa.verbosity = verbosity;
10125 spa.delete_branches = &delete_branches;
10126 error = got_send_pack(remote_name, &branches, &tags, &delete_branches,
10127 verbosity, overwrite_refs, sendfd, repo, send_progress, &spa,
10128 check_cancelled, NULL);
10129 if (spa.printed_something)
10130 putchar('\n');
10131 if (error)
10132 goto done;
10133 if (!spa.sent_something && verbosity >= 0)
10134 printf("Already up-to-date\n");
10135 done:
10136 if (sendpid > 0) {
10137 if (kill(sendpid, SIGTERM) == -1)
10138 error = got_error_from_errno("kill");
10139 if (waitpid(sendpid, &sendstatus, 0) == -1 && error == NULL)
10140 error = got_error_from_errno("waitpid");
10141 }
10142 if (sendfd != -1 && close(sendfd) == -1 && error == NULL)
10143 error = got_error_from_errno("close");
10144 if (repo) {
10145 const struct got_error *close_err = got_repo_close(repo);
10146 if (error == NULL)
10147 error = close_err;
10148 }
10149 if (worktree)
10150 got_worktree_close(worktree);
10151 if (pack_fds) {
10152 const struct got_error *pack_err =
10153 got_repo_pack_fds_close(pack_fds);
10154 if (error == NULL)
10155 error = pack_err;
10156 }
10157 if (ref)
10158 got_ref_close(ref);
10159 got_repo_free_remote_repo_data(remote);
10160 free(remote);
10161 got_pathlist_free(&branches, GOT_PATHLIST_FREE_NONE);
10162 got_pathlist_free(&tags, GOT_PATHLIST_FREE_NONE);
10163 got_ref_list_free(&all_branches);
10164 got_ref_list_free(&all_tags);
10165 got_pathlist_free(&delete_args, GOT_PATHLIST_FREE_NONE);
10166 got_pathlist_free(&delete_branches, GOT_PATHLIST_FREE_PATH);
10167 free(cwd);
10168 free(repo_path);
10169 free(proto);
10170 free(host);
10171 free(port);
10172 free(server_path);
10173 free(repo_name);
10174 return error;
10175 }
10176
10177 /*
10178 * Print and if delete is set delete all ref_prefix references.
10179 * If wanted_ref is not NULL, only print or delete this reference.
10180 */
10181 static const struct got_error *
10182 process_logmsg_refs(const char *ref_prefix, size_t prefix_len,
10183 const char *wanted_ref, int delete, struct got_worktree *worktree,
10184 struct got_repository *repo)
10185 {
10186 const struct got_error *err;
10187 struct got_pathlist_head paths;
10188 struct got_reflist_head refs;
10189 struct got_reflist_entry *re;
10190 struct got_reflist_object_id_map *refs_idmap = NULL;
10191 struct got_commit_object *commit = NULL;
10192 struct got_object_id *id = NULL;
10193 const char *header_prefix;
10194 char *uuidstr = NULL;
10195 int found = 0;
10196
10197 TAILQ_INIT(&refs);
10198 TAILQ_INIT(&paths);
10199
10200 err = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, repo);
10201 if (err)
10202 goto done;
10203
10204 err = got_reflist_object_id_map_create(&refs_idmap, &refs, repo);
10205 if (err)
10206 goto done;
10207
10208 if (worktree != NULL) {
10209 err = got_worktree_get_uuid(&uuidstr, worktree);
10210 if (err)
10211 goto done;
10212 }
10213
10214 if (wanted_ref) {
10215 if (strncmp(wanted_ref, "refs/heads/", 11) == 0)
10216 wanted_ref += 11;
10217 }
10218
10219 if (strcmp(ref_prefix, GOT_WORKTREE_BACKOUT_REF_PREFIX) == 0)
10220 header_prefix = "backout";
10221 else
10222 header_prefix = "cherrypick";
10223
10224 TAILQ_FOREACH(re, &refs, entry) {
10225 const char *refname, *wt;
10226
10227 refname = got_ref_get_name(re->ref);
10228
10229 err = check_cancelled(NULL);
10230 if (err)
10231 goto done;
10232
10233 if (strncmp(refname, ref_prefix, prefix_len) == 0)
10234 refname += prefix_len + 1; /* skip '-' delimiter */
10235 else
10236 continue;
10237
10238 wt = refname;
10239
10240 if (worktree == NULL || strncmp(refname, uuidstr,
10241 GOT_WORKTREE_UUID_STRLEN) == 0)
10242 refname += GOT_WORKTREE_UUID_STRLEN + 1; /* skip '-' */
10243 else
10244 continue;
10245
10246 err = got_repo_match_object_id(&id, NULL, refname,
10247 GOT_OBJ_TYPE_COMMIT, NULL, repo);
10248 if (err)
10249 goto done;
10250
10251 err = got_object_open_as_commit(&commit, repo, id);
10252 if (err)
10253 goto done;
10254
10255 if (wanted_ref)
10256 found = strncmp(wanted_ref, refname,
10257 strlen(wanted_ref)) == 0;
10258 if (wanted_ref && !found) {
10259 struct got_reflist_head *ci_refs;
10260
10261 ci_refs = got_reflist_object_id_map_lookup(refs_idmap,
10262 id);
10263
10264 if (ci_refs) {
10265 char *refs_str = NULL;
10266 char const *r = NULL;
10267
10268 err = build_refs_str(&refs_str, ci_refs, id,
10269 repo, 1);
10270 if (err)
10271 goto done;
10272
10273 r = refs_str;
10274 while (r) {
10275 if (strncmp(r, wanted_ref,
10276 strlen(wanted_ref)) == 0) {
10277 found = 1;
10278 break;
10279 }
10280 r = strchr(r, ' ');
10281 if (r)
10282 ++r;
10283 }
10284 free(refs_str);
10285 }
10286 }
10287
10288 if (wanted_ref == NULL || found) {
10289 if (delete) {
10290 err = got_ref_delete(re->ref, repo);
10291 if (err)
10292 goto done;
10293 printf("Deleted: ");
10294 err = print_commit_oneline(commit, id, repo,
10295 refs_idmap);
10296 } else {
10297 /*
10298 * Print paths modified by commit to help
10299 * associate commits with worktree changes.
10300 */
10301 err = get_changed_paths(&paths, commit,
10302 repo, NULL);
10303 if (err)
10304 goto done;
10305
10306 err = print_commit(commit, id, repo, NULL,
10307 &paths, NULL, 0, 0, refs_idmap, NULL,
10308 header_prefix);
10309 got_pathlist_free(&paths,
10310 GOT_PATHLIST_FREE_ALL);
10311
10312 if (worktree == NULL)
10313 printf("work tree: %.*s\n\n",
10314 GOT_WORKTREE_UUID_STRLEN, wt);
10315 }
10316 if (err || found)
10317 goto done;
10318 }
10319
10320 got_object_commit_close(commit);
10321 commit = NULL;
10322 free(id);
10323 id = NULL;
10324 }
10325
10326 if (wanted_ref != NULL && !found)
10327 err = got_error_fmt(GOT_ERR_NOT_REF, "%s", wanted_ref);
10328
10329 done:
10330 free(id);
10331 free(uuidstr);
10332 got_ref_list_free(&refs);
10333 got_pathlist_free(&paths, GOT_PATHLIST_FREE_ALL);
10334 if (refs_idmap)
10335 got_reflist_object_id_map_free(refs_idmap);
10336 if (commit)
10337 got_object_commit_close(commit);
10338 return err;
10339 }
10340
10341 /*
10342 * Create new temp "logmsg" ref of the backed-out or cherrypicked commit
10343 * identified by id for log messages to prepopulate the editor on commit.
10344 */
10345 static const struct got_error *
10346 logmsg_ref(struct got_object_id *id, const char *prefix,
10347 struct got_worktree *worktree, struct got_repository *repo)
10348 {
10349 const struct got_error *err = NULL;
10350 char *idstr, *ref = NULL, *refname = NULL;
10351 int histedit_in_progress;
10352 int rebase_in_progress, merge_in_progress;
10353
10354 /*
10355 * Silenty refuse to create merge reference if any histedit, merge,
10356 * or rebase operation is in progress.
10357 */
10358 err = got_worktree_histedit_in_progress(&histedit_in_progress,
10359 worktree);
10360 if (err)
10361 return err;
10362 if (histedit_in_progress)
10363 return NULL;
10364
10365 err = got_worktree_rebase_in_progress(&rebase_in_progress, worktree);
10366 if (err)
10367 return err;
10368 if (rebase_in_progress)
10369 return NULL;
10370
10371 err = got_worktree_merge_in_progress(&merge_in_progress, worktree,
10372 repo);
10373 if (err)
10374 return err;
10375 if (merge_in_progress)
10376 return NULL;
10377
10378 err = got_object_id_str(&idstr, id);
10379 if (err)
10380 return err;
10381
10382 err = got_worktree_get_logmsg_ref_name(&refname, worktree, prefix);
10383 if (err)
10384 goto done;
10385
10386 if (asprintf(&ref, "%s-%s", refname, idstr) == -1) {
10387 err = got_error_from_errno("asprintf");
10388 goto done;
10389 }
10390
10391 err = create_ref(ref, got_worktree_get_base_commit_id(worktree),
10392 -1, repo);
10393 done:
10394 free(ref);
10395 free(idstr);
10396 free(refname);
10397 return err;
10398 }
10399
10400 __dead static void
10401 usage_cherrypick(void)
10402 {
10403 fprintf(stderr, "usage: %s cherrypick [-lX] [commit-id]\n",
10404 getprogname());
10405 exit(1);
10406 }
10407
10408 static const struct got_error *
10409 cmd_cherrypick(int argc, char *argv[])
10410 {
10411 const struct got_error *error = NULL;
10412 struct got_worktree *worktree = NULL;
10413 struct got_repository *repo = NULL;
10414 char *cwd = NULL, *commit_id_str = NULL, *keyword_idstr = NULL;
10415 struct got_object_id *commit_id = NULL;
10416 struct got_commit_object *commit = NULL;
10417 struct got_object_qid *pid;
10418 int ch, list_refs = 0, remove_refs = 0;
10419 struct got_update_progress_arg upa;
10420 int *pack_fds = NULL;
10421
10422 #ifndef PROFILE
10423 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
10424 "unveil", NULL) == -1)
10425 err(1, "pledge");
10426 #endif
10427
10428 while ((ch = getopt(argc, argv, "lX")) != -1) {
10429 switch (ch) {
10430 case 'l':
10431 list_refs = 1;
10432 break;
10433 case 'X':
10434 remove_refs = 1;
10435 break;
10436 default:
10437 usage_cherrypick();
10438 /* NOTREACHED */
10439 }
10440 }
10441
10442 argc -= optind;
10443 argv += optind;
10444
10445 if (list_refs || remove_refs) {
10446 if (argc != 0 && argc != 1)
10447 usage_cherrypick();
10448 } else if (argc != 1)
10449 usage_cherrypick();
10450 if (list_refs && remove_refs)
10451 option_conflict('l', 'X');
10452
10453 cwd = getcwd(NULL, 0);
10454 if (cwd == NULL) {
10455 error = got_error_from_errno("getcwd");
10456 goto done;
10457 }
10458
10459 error = got_repo_pack_fds_open(&pack_fds);
10460 if (error != NULL)
10461 goto done;
10462
10463 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
10464 if (error) {
10465 if (list_refs || remove_refs) {
10466 if (error->code != GOT_ERR_NOT_WORKTREE)
10467 goto done;
10468 } else {
10469 if (error->code == GOT_ERR_NOT_WORKTREE)
10470 error = wrap_not_worktree_error(error,
10471 "cherrypick", cwd);
10472 goto done;
10473 }
10474 }
10475
10476 error = got_repo_open(&repo,
10477 worktree ? got_worktree_get_repo_path(worktree) : cwd,
10478 NULL, pack_fds);
10479 if (error != NULL)
10480 goto done;
10481
10482 error = apply_unveil(got_repo_get_path(repo), 0,
10483 worktree ? got_worktree_get_root_path(worktree) : NULL);
10484 if (error)
10485 goto done;
10486
10487 if (list_refs || remove_refs) {
10488 error = process_logmsg_refs(GOT_WORKTREE_CHERRYPICK_REF_PREFIX,
10489 GOT_WORKTREE_CHERRYPICK_REF_PREFIX_LEN,
10490 argc == 1 ? argv[0] : NULL, remove_refs, worktree, repo);
10491 goto done;
10492 }
10493
10494 error = got_keyword_to_idstr(&keyword_idstr, argv[0], repo, worktree);
10495 if (error != NULL)
10496 goto done;
10497
10498 error = got_repo_match_object_id(&commit_id, NULL,
10499 keyword_idstr != NULL ? keyword_idstr : argv[0],
10500 GOT_OBJ_TYPE_COMMIT, NULL, repo);
10501 if (error)
10502 goto done;
10503 error = got_object_id_str(&commit_id_str, commit_id);
10504 if (error)
10505 goto done;
10506
10507 error = got_object_open_as_commit(&commit, repo, commit_id);
10508 if (error)
10509 goto done;
10510 pid = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
10511 memset(&upa, 0, sizeof(upa));
10512 error = got_worktree_merge_files(worktree, pid ? &pid->id : NULL,
10513 commit_id, repo, update_progress, &upa, check_cancelled,
10514 NULL);
10515 if (error != NULL)
10516 goto done;
10517
10518 if (upa.did_something) {
10519 error = logmsg_ref(commit_id,
10520 GOT_WORKTREE_CHERRYPICK_REF_PREFIX, worktree, repo);
10521 if (error)
10522 goto done;
10523 printf("Merged commit %s\n", commit_id_str);
10524 }
10525 print_merge_progress_stats(&upa);
10526 done:
10527 free(cwd);
10528 free(keyword_idstr);
10529 if (commit)
10530 got_object_commit_close(commit);
10531 free(commit_id_str);
10532 if (worktree)
10533 got_worktree_close(worktree);
10534 if (repo) {
10535 const struct got_error *close_err = got_repo_close(repo);
10536 if (error == NULL)
10537 error = close_err;
10538 }
10539 if (pack_fds) {
10540 const struct got_error *pack_err =
10541 got_repo_pack_fds_close(pack_fds);
10542 if (error == NULL)
10543 error = pack_err;
10544 }
10545
10546 return error;
10547 }
10548
10549 __dead static void
10550 usage_backout(void)
10551 {
10552 fprintf(stderr, "usage: %s backout [-lX] [commit-id]\n", getprogname());
10553 exit(1);
10554 }
10555
10556 static const struct got_error *
10557 cmd_backout(int argc, char *argv[])
10558 {
10559 const struct got_error *error = NULL;
10560 struct got_worktree *worktree = NULL;
10561 struct got_repository *repo = NULL;
10562 char *cwd = NULL, *commit_id_str = NULL, *keyword_idstr = NULL;
10563 struct got_object_id *commit_id = NULL;
10564 struct got_commit_object *commit = NULL;
10565 struct got_object_qid *pid;
10566 int ch, list_refs = 0, remove_refs = 0;
10567 struct got_update_progress_arg upa;
10568 int *pack_fds = NULL;
10569
10570 #ifndef PROFILE
10571 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
10572 "unveil", NULL) == -1)
10573 err(1, "pledge");
10574 #endif
10575
10576 while ((ch = getopt(argc, argv, "lX")) != -1) {
10577 switch (ch) {
10578 case 'l':
10579 list_refs = 1;
10580 break;
10581 case 'X':
10582 remove_refs = 1;
10583 break;
10584 default:
10585 usage_backout();
10586 /* NOTREACHED */
10587 }
10588 }
10589
10590 argc -= optind;
10591 argv += optind;
10592
10593 if (list_refs || remove_refs) {
10594 if (argc != 0 && argc != 1)
10595 usage_backout();
10596 } else if (argc != 1)
10597 usage_backout();
10598 if (list_refs && remove_refs)
10599 option_conflict('l', 'X');
10600
10601 cwd = getcwd(NULL, 0);
10602 if (cwd == NULL) {
10603 error = got_error_from_errno("getcwd");
10604 goto done;
10605 }
10606
10607 error = got_repo_pack_fds_open(&pack_fds);
10608 if (error != NULL)
10609 goto done;
10610
10611 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
10612 if (error) {
10613 if (list_refs || remove_refs) {
10614 if (error->code != GOT_ERR_NOT_WORKTREE)
10615 goto done;
10616 } else {
10617 if (error->code == GOT_ERR_NOT_WORKTREE)
10618 error = wrap_not_worktree_error(error,
10619 "backout", cwd);
10620 goto done;
10621 }
10622 }
10623
10624 error = got_repo_open(&repo,
10625 worktree ? got_worktree_get_repo_path(worktree) : cwd,
10626 NULL, pack_fds);
10627 if (error != NULL)
10628 goto done;
10629
10630 error = apply_unveil(got_repo_get_path(repo), 0,
10631 worktree ? got_worktree_get_root_path(worktree) : NULL);
10632 if (error)
10633 goto done;
10634
10635 if (list_refs || remove_refs) {
10636 error = process_logmsg_refs(GOT_WORKTREE_BACKOUT_REF_PREFIX,
10637 GOT_WORKTREE_BACKOUT_REF_PREFIX_LEN,
10638 argc == 1 ? argv[0] : NULL, remove_refs, worktree, repo);
10639 goto done;
10640 }
10641
10642 error = got_keyword_to_idstr(&keyword_idstr, argv[0], repo, worktree);
10643 if (error != NULL)
10644 goto done;
10645
10646 error = got_repo_match_object_id(&commit_id, NULL,
10647 keyword_idstr != NULL ? keyword_idstr : argv[0],
10648 GOT_OBJ_TYPE_COMMIT, NULL, repo);
10649 if (error)
10650 goto done;
10651 error = got_object_id_str(&commit_id_str, commit_id);
10652 if (error)
10653 goto done;
10654
10655 error = got_object_open_as_commit(&commit, repo, commit_id);
10656 if (error)
10657 goto done;
10658 pid = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
10659 if (pid == NULL) {
10660 error = got_error(GOT_ERR_ROOT_COMMIT);
10661 goto done;
10662 }
10663
10664 memset(&upa, 0, sizeof(upa));
10665 error = got_worktree_merge_files(worktree, commit_id, &pid->id,
10666 repo, update_progress, &upa, check_cancelled, NULL);
10667 if (error != NULL)
10668 goto done;
10669
10670 if (upa.did_something) {
10671 error = logmsg_ref(commit_id, GOT_WORKTREE_BACKOUT_REF_PREFIX,
10672 worktree, repo);
10673 if (error)
10674 goto done;
10675 printf("Backed out commit %s\n", commit_id_str);
10676 }
10677 print_merge_progress_stats(&upa);
10678 done:
10679 free(cwd);
10680 free(keyword_idstr);
10681 if (commit)
10682 got_object_commit_close(commit);
10683 free(commit_id_str);
10684 if (worktree)
10685 got_worktree_close(worktree);
10686 if (repo) {
10687 const struct got_error *close_err = got_repo_close(repo);
10688 if (error == NULL)
10689 error = close_err;
10690 }
10691 if (pack_fds) {
10692 const struct got_error *pack_err =
10693 got_repo_pack_fds_close(pack_fds);
10694 if (error == NULL)
10695 error = pack_err;
10696 }
10697 return error;
10698 }
10699
10700 __dead static void
10701 usage_rebase(void)
10702 {
10703 fprintf(stderr, "usage: %s rebase [-aCclX] [branch]\n", getprogname());
10704 exit(1);
10705 }
10706
10707 static void
10708 trim_logmsg(char *logmsg, int limit)
10709 {
10710 char *nl;
10711 size_t len;
10712
10713 len = strlen(logmsg);
10714 if (len > limit)
10715 len = limit;
10716 logmsg[len] = '\0';
10717 nl = strchr(logmsg, '\n');
10718 if (nl)
10719 *nl = '\0';
10720 }
10721
10722 static const struct got_error *
10723 get_short_logmsg(char **logmsg, int limit, struct got_commit_object *commit)
10724 {
10725 const struct got_error *err;
10726 char *logmsg0 = NULL;
10727 const char *s;
10728
10729 err = got_object_commit_get_logmsg(&logmsg0, commit);
10730 if (err)
10731 return err;
10732
10733 s = logmsg0;
10734 while (isspace((unsigned char)s[0]))
10735 s++;
10736
10737 *logmsg = strdup(s);
10738 if (*logmsg == NULL) {
10739 err = got_error_from_errno("strdup");
10740 goto done;
10741 }
10742
10743 trim_logmsg(*logmsg, limit);
10744 done:
10745 free(logmsg0);
10746 return err;
10747 }
10748
10749 static const struct got_error *
10750 show_rebase_merge_conflict(struct got_object_id *id,
10751 struct got_repository *repo)
10752 {
10753 const struct got_error *err;
10754 struct got_commit_object *commit = NULL;
10755 char *id_str = NULL, *logmsg = NULL;
10756
10757 err = got_object_open_as_commit(&commit, repo, id);
10758 if (err)
10759 return err;
10760
10761 err = got_object_id_str(&id_str, id);
10762 if (err)
10763 goto done;
10764
10765 id_str[12] = '\0';
10766
10767 err = get_short_logmsg(&logmsg, 42, commit);
10768 if (err)
10769 goto done;
10770
10771 printf("%s -> merge conflict: %s\n", id_str, logmsg);
10772 done:
10773 free(id_str);
10774 got_object_commit_close(commit);
10775 free(logmsg);
10776 return err;
10777 }
10778
10779 static const struct got_error *
10780 show_rebase_progress(struct got_commit_object *commit,
10781 struct got_object_id *old_id, struct got_object_id *new_id)
10782 {
10783 const struct got_error *err;
10784 char *old_id_str = NULL, *new_id_str = NULL, *logmsg = NULL;
10785
10786 err = got_object_id_str(&old_id_str, old_id);
10787 if (err)
10788 goto done;
10789
10790 if (new_id) {
10791 err = got_object_id_str(&new_id_str, new_id);
10792 if (err)
10793 goto done;
10794 }
10795
10796 old_id_str[12] = '\0';
10797 if (new_id_str)
10798 new_id_str[12] = '\0';
10799
10800 err = get_short_logmsg(&logmsg, 42, commit);
10801 if (err)
10802 goto done;
10803
10804 printf("%s -> %s: %s\n", old_id_str,
10805 new_id_str ? new_id_str : "no-op change", logmsg);
10806 done:
10807 free(old_id_str);
10808 free(new_id_str);
10809 free(logmsg);
10810 return err;
10811 }
10812
10813 static const struct got_error *
10814 rebase_complete(struct got_worktree *worktree, struct got_fileindex *fileindex,
10815 struct got_reference *branch, struct got_reference *tmp_branch,
10816 struct got_repository *repo, int create_backup)
10817 {
10818 printf("Switching work tree to %s\n", got_ref_get_name(branch));
10819 return got_worktree_rebase_complete(worktree, fileindex,
10820 tmp_branch, branch, repo, create_backup);
10821 }
10822
10823 static const struct got_error *
10824 rebase_commit(struct got_pathlist_head *merged_paths,
10825 struct got_worktree *worktree, struct got_fileindex *fileindex,
10826 struct got_reference *tmp_branch, const char *committer,
10827 struct got_object_id *commit_id, int allow_conflict,
10828 struct got_repository *repo)
10829 {
10830 const struct got_error *error;
10831 struct got_commit_object *commit;
10832 struct got_object_id *new_commit_id;
10833
10834 error = got_object_open_as_commit(&commit, repo, commit_id);
10835 if (error)
10836 return error;
10837
10838 error = got_worktree_rebase_commit(&new_commit_id, merged_paths,
10839 worktree, fileindex, tmp_branch, committer, commit, commit_id,
10840 allow_conflict, repo);
10841 if (error) {
10842 if (error->code != GOT_ERR_COMMIT_NO_CHANGES)
10843 goto done;
10844 error = show_rebase_progress(commit, commit_id, NULL);
10845 } else {
10846 error = show_rebase_progress(commit, commit_id, new_commit_id);
10847 free(new_commit_id);
10848 }
10849 done:
10850 got_object_commit_close(commit);
10851 return error;
10852 }
10853
10854 struct check_path_prefix_arg {
10855 const char *path_prefix;
10856 size_t len;
10857 int errcode;
10858 };
10859
10860 static const struct got_error *
10861 check_path_prefix_in_diff(void *arg, struct got_blob_object *blob1,
10862 struct got_blob_object *blob2, FILE *f1, FILE *f2,
10863 struct got_object_id *id1, struct got_object_id *id2,
10864 const char *path1, const char *path2,
10865 mode_t mode1, mode_t mode2, struct got_repository *repo)
10866 {
10867 struct check_path_prefix_arg *a = arg;
10868
10869 if ((path1 && !got_path_is_child(path1, a->path_prefix, a->len)) ||
10870 (path2 && !got_path_is_child(path2, a->path_prefix, a->len)))
10871 return got_error(a->errcode);
10872
10873 return NULL;
10874 }
10875
10876 static const struct got_error *
10877 check_path_prefix(struct got_object_id *parent_id,
10878 struct got_object_id *commit_id, const char *path_prefix,
10879 int errcode, struct got_repository *repo)
10880 {
10881 const struct got_error *err;
10882 struct got_tree_object *tree1 = NULL, *tree2 = NULL;
10883 struct got_commit_object *commit = NULL, *parent_commit = NULL;
10884 struct check_path_prefix_arg cpp_arg;
10885
10886 if (got_path_is_root_dir(path_prefix))
10887 return NULL;
10888
10889 err = got_object_open_as_commit(&commit, repo, commit_id);
10890 if (err)
10891 goto done;
10892
10893 err = got_object_open_as_commit(&parent_commit, repo, parent_id);
10894 if (err)
10895 goto done;
10896
10897 err = got_object_open_as_tree(&tree1, repo,
10898 got_object_commit_get_tree_id(parent_commit));
10899 if (err)
10900 goto done;
10901
10902 err = got_object_open_as_tree(&tree2, repo,
10903 got_object_commit_get_tree_id(commit));
10904 if (err)
10905 goto done;
10906
10907 cpp_arg.path_prefix = path_prefix;
10908 while (cpp_arg.path_prefix[0] == '/')
10909 cpp_arg.path_prefix++;
10910 cpp_arg.len = strlen(cpp_arg.path_prefix);
10911 cpp_arg.errcode = errcode;
10912 err = got_diff_tree(tree1, tree2, NULL, NULL, -1, -1, "", "", repo,
10913 check_path_prefix_in_diff, &cpp_arg, 0);
10914 done:
10915 if (tree1)
10916 got_object_tree_close(tree1);
10917 if (tree2)
10918 got_object_tree_close(tree2);
10919 if (commit)
10920 got_object_commit_close(commit);
10921 if (parent_commit)
10922 got_object_commit_close(parent_commit);
10923 return err;
10924 }
10925
10926 static const struct got_error *
10927 collect_commits(struct got_object_id_queue *commits,
10928 struct got_object_id *initial_commit_id,
10929 struct got_object_id *iter_start_id, struct got_object_id *iter_stop_id,
10930 const char *path_prefix, int path_prefix_errcode,
10931 struct got_repository *repo)
10932 {
10933 const struct got_error *err = NULL;
10934 struct got_commit_graph *graph = NULL;
10935 struct got_object_id parent_id, commit_id;
10936 struct got_object_qid *qid;
10937
10938 err = got_commit_graph_open(&graph, "/", 1);
10939 if (err)
10940 return err;
10941
10942 err = got_commit_graph_bfsort(graph, iter_start_id, repo,
10943 check_cancelled, NULL);
10944 if (err)
10945 goto done;
10946
10947 memcpy(&commit_id, initial_commit_id, sizeof(commit_id));
10948 while (got_object_id_cmp(&commit_id, iter_stop_id) != 0) {
10949 err = got_commit_graph_iter_next(&parent_id, graph, repo,
10950 check_cancelled, NULL);
10951 if (err) {
10952 if (err->code == GOT_ERR_ITER_COMPLETED) {
10953 err = got_error_msg(GOT_ERR_ANCESTRY,
10954 "ran out of commits to rebase before "
10955 "youngest common ancestor commit has "
10956 "been reached?!?");
10957 }
10958 goto done;
10959 } else {
10960 err = check_path_prefix(&parent_id, &commit_id,
10961 path_prefix, path_prefix_errcode, repo);
10962 if (err)
10963 goto done;
10964
10965 err = got_object_qid_alloc(&qid, &commit_id);
10966 if (err)
10967 goto done;
10968 STAILQ_INSERT_HEAD(commits, qid, entry);
10969
10970 memcpy(&commit_id, &parent_id, sizeof(commit_id));
10971 }
10972 }
10973 done:
10974 got_commit_graph_close(graph);
10975 return err;
10976 }
10977
10978 static const struct got_error *
10979 get_commit_brief_str(char **brief_str, struct got_commit_object *commit)
10980 {
10981 const struct got_error *err = NULL;
10982 time_t committer_time;
10983 struct tm tm;
10984 char datebuf[11]; /* YYYY-MM-DD + NUL */
10985 char *author0 = NULL, *author, *smallerthan;
10986 char *logmsg0 = NULL, *logmsg, *newline;
10987
10988 committer_time = got_object_commit_get_committer_time(commit);
10989 if (gmtime_r(&committer_time, &tm) == NULL)
10990 return got_error_from_errno("gmtime_r");
10991 if (strftime(datebuf, sizeof(datebuf), "%F", &tm) == 0)
10992 return got_error(GOT_ERR_NO_SPACE);
10993
10994 author0 = strdup(got_object_commit_get_author(commit));
10995 if (author0 == NULL)
10996 return got_error_from_errno("strdup");
10997 author = author0;
10998 smallerthan = strchr(author, '<');
10999 if (smallerthan && smallerthan[1] != '\0')
11000 author = smallerthan + 1;
11001 author[strcspn(author, "@>")] = '\0';
11002
11003 err = got_object_commit_get_logmsg(&logmsg0, commit);
11004 if (err)
11005 goto done;
11006 logmsg = logmsg0;
11007 while (*logmsg == '\n')
11008 logmsg++;
11009 newline = strchr(logmsg, '\n');
11010 if (newline)
11011 *newline = '\0';
11012
11013 if (asprintf(brief_str, "%s %s %s",
11014 datebuf, author, logmsg) == -1)
11015 err = got_error_from_errno("asprintf");
11016 done:
11017 free(author0);
11018 free(logmsg0);
11019 return err;
11020 }
11021
11022 static const struct got_error *
11023 delete_backup_ref(struct got_reference *ref, struct got_object_id *id,
11024 struct got_repository *repo)
11025 {
11026 const struct got_error *err;
11027 char *id_str;
11028
11029 err = got_object_id_str(&id_str, id);
11030 if (err)
11031 return err;
11032
11033 err = got_ref_delete(ref, repo);
11034 if (err)
11035 goto done;
11036
11037 printf("Deleted %s: %s\n", got_ref_get_name(ref), id_str);
11038 done:
11039 free(id_str);
11040 return err;
11041 }
11042
11043 static const struct got_error *
11044 print_backup_ref(const char *branch_name, const char *new_id_str,
11045 struct got_object_id *old_commit_id, struct got_commit_object *old_commit,
11046 struct got_reflist_object_id_map *refs_idmap,
11047 struct got_repository *repo)
11048 {
11049 const struct got_error *err = NULL;
11050 struct got_reflist_head *refs;
11051 char *refs_str = NULL;
11052 struct got_object_id *new_commit_id = NULL;
11053 struct got_commit_object *new_commit = NULL;
11054 char *new_commit_brief_str = NULL;
11055 struct got_object_id *yca_id = NULL;
11056 struct got_commit_object *yca_commit = NULL;
11057 char *yca_id_str = NULL, *yca_brief_str = NULL;
11058 char *custom_refs_str;
11059
11060 if (asprintf(&custom_refs_str, "formerly %s", branch_name) == -1)
11061 return got_error_from_errno("asprintf");
11062
11063 err = print_commit(old_commit, old_commit_id, repo, NULL, NULL, NULL,
11064 0, 0, refs_idmap, custom_refs_str, NULL);
11065 if (err)
11066 goto done;
11067
11068 err = got_object_resolve_id_str(&new_commit_id, repo, new_id_str);
11069 if (err)
11070 goto done;
11071
11072 refs = got_reflist_object_id_map_lookup(refs_idmap, new_commit_id);
11073 if (refs) {
11074 err = build_refs_str(&refs_str, refs, new_commit_id, repo, 0);
11075 if (err)
11076 goto done;
11077 }
11078
11079 err = got_object_open_as_commit(&new_commit, repo, new_commit_id);
11080 if (err)
11081 goto done;
11082
11083 err = get_commit_brief_str(&new_commit_brief_str, new_commit);
11084 if (err)
11085 goto done;
11086
11087 err = got_commit_graph_find_youngest_common_ancestor(&yca_id,
11088 old_commit_id, new_commit_id, 1, 0, repo, check_cancelled, NULL);
11089 if (err)
11090 goto done;
11091
11092 printf("has become commit %s%s%s%s\n %s\n", new_id_str,
11093 refs_str ? " (" : "", refs_str ? refs_str : "",
11094 refs_str ? ")" : "", new_commit_brief_str);
11095 if (yca_id && got_object_id_cmp(yca_id, new_commit_id) != 0 &&
11096 got_object_id_cmp(yca_id, old_commit_id) != 0) {
11097 free(refs_str);
11098 refs_str = NULL;
11099
11100 err = got_object_open_as_commit(&yca_commit, repo, yca_id);
11101 if (err)
11102 goto done;
11103
11104 err = get_commit_brief_str(&yca_brief_str, yca_commit);
11105 if (err)
11106 goto done;
11107
11108 err = got_object_id_str(&yca_id_str, yca_id);
11109 if (err)
11110 goto done;
11111
11112 refs = got_reflist_object_id_map_lookup(refs_idmap, yca_id);
11113 if (refs) {
11114 err = build_refs_str(&refs_str, refs, yca_id, repo, 0);
11115 if (err)
11116 goto done;
11117 }
11118 printf("history forked at %s%s%s%s\n %s\n",
11119 yca_id_str,
11120 refs_str ? " (" : "", refs_str ? refs_str : "",
11121 refs_str ? ")" : "", yca_brief_str);
11122 }
11123 done:
11124 free(custom_refs_str);
11125 free(new_commit_id);
11126 free(refs_str);
11127 free(yca_id);
11128 free(yca_id_str);
11129 free(yca_brief_str);
11130 if (new_commit)
11131 got_object_commit_close(new_commit);
11132 if (yca_commit)
11133 got_object_commit_close(yca_commit);
11134
11135 return err;
11136 }
11137
11138 static const struct got_error *
11139 worktree_has_logmsg_ref(const char *caller, struct got_worktree *worktree,
11140 struct got_repository *repo)
11141 {
11142 const struct got_error *err;
11143 struct got_reflist_head refs;
11144 struct got_reflist_entry *re;
11145 char *uuidstr = NULL;
11146 static char msg[160];
11147
11148 TAILQ_INIT(&refs);
11149
11150 err = got_worktree_get_uuid(&uuidstr, worktree);
11151 if (err)
11152 goto done;
11153
11154 err = got_ref_list(&refs, repo, "refs/got/worktree",
11155 got_ref_cmp_by_name, repo);
11156 if (err)
11157 goto done;
11158
11159 TAILQ_FOREACH(re, &refs, entry) {
11160 const char *cmd, *refname, *type;
11161
11162 refname = got_ref_get_name(re->ref);
11163
11164 if (strncmp(refname, GOT_WORKTREE_CHERRYPICK_REF_PREFIX,
11165 GOT_WORKTREE_CHERRYPICK_REF_PREFIX_LEN) == 0) {
11166 refname += GOT_WORKTREE_CHERRYPICK_REF_PREFIX_LEN + 1;
11167 cmd = "cherrypick";
11168 type = "cherrypicked";
11169 } else if (strncmp(refname, GOT_WORKTREE_BACKOUT_REF_PREFIX,
11170 GOT_WORKTREE_BACKOUT_REF_PREFIX_LEN) == 0) {
11171 refname += GOT_WORKTREE_BACKOUT_REF_PREFIX_LEN + 1;
11172 cmd = "backout";
11173 type = "backed-out";
11174 } else
11175 continue;
11176
11177 if (strncmp(refname, uuidstr, GOT_WORKTREE_UUID_STRLEN) != 0)
11178 continue;
11179
11180 snprintf(msg, sizeof(msg),
11181 "work tree has references created by %s commits which "
11182 "must be removed with 'got %s -X' before running the %s "
11183 "command", type, cmd, caller);
11184 err = got_error_msg(GOT_ERR_WORKTREE_META, msg);
11185 goto done;
11186 }
11187
11188 done:
11189 free(uuidstr);
11190 got_ref_list_free(&refs);
11191 return err;
11192 }
11193
11194 static const struct got_error *
11195 process_backup_refs(const char *backup_ref_prefix,
11196 const char *wanted_branch_name,
11197 int delete, struct got_repository *repo)
11198 {
11199 const struct got_error *err;
11200 struct got_reflist_head refs, backup_refs;
11201 struct got_reflist_entry *re;
11202 const size_t backup_ref_prefix_len = strlen(backup_ref_prefix);
11203 struct got_object_id *old_commit_id = NULL;
11204 char *branch_name = NULL;
11205 struct got_commit_object *old_commit = NULL;
11206 struct got_reflist_object_id_map *refs_idmap = NULL;
11207 int wanted_branch_found = 0;
11208
11209 TAILQ_INIT(&refs);
11210 TAILQ_INIT(&backup_refs);
11211
11212 err = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
11213 if (err)
11214 return err;
11215
11216 err = got_reflist_object_id_map_create(&refs_idmap, &refs, repo);
11217 if (err)
11218 goto done;
11219
11220 if (wanted_branch_name) {
11221 if (strncmp(wanted_branch_name, "refs/heads/", 11) == 0)
11222 wanted_branch_name += 11;
11223 }
11224
11225 err = got_ref_list(&backup_refs, repo, backup_ref_prefix,
11226 got_ref_cmp_by_commit_timestamp_descending, repo);
11227 if (err)
11228 goto done;
11229
11230 TAILQ_FOREACH(re, &backup_refs, entry) {
11231 const char *refname = got_ref_get_name(re->ref);
11232 char *slash;
11233
11234 err = check_cancelled(NULL);
11235 if (err)
11236 break;
11237
11238 err = got_ref_resolve(&old_commit_id, repo, re->ref);
11239 if (err)
11240 break;
11241
11242 err = got_object_open_as_commit(&old_commit, repo,
11243 old_commit_id);
11244 if (err)
11245 break;
11246
11247 if (strncmp(backup_ref_prefix, refname,
11248 backup_ref_prefix_len) == 0)
11249 refname += backup_ref_prefix_len;
11250
11251 while (refname[0] == '/')
11252 refname++;
11253
11254 branch_name = strdup(refname);
11255 if (branch_name == NULL) {
11256 err = got_error_from_errno("strdup");
11257 break;
11258 }
11259 slash = strrchr(branch_name, '/');
11260 if (slash) {
11261 *slash = '\0';
11262 refname += strlen(branch_name) + 1;
11263 }
11264
11265 if (wanted_branch_name == NULL ||
11266 strcmp(wanted_branch_name, branch_name) == 0) {
11267 wanted_branch_found = 1;
11268 if (delete) {
11269 err = delete_backup_ref(re->ref,
11270 old_commit_id, repo);
11271 } else {
11272 err = print_backup_ref(branch_name, refname,
11273 old_commit_id, old_commit, refs_idmap,
11274 repo);
11275 }
11276 if (err)
11277 break;
11278 }
11279
11280 free(old_commit_id);
11281 old_commit_id = NULL;
11282 free(branch_name);
11283 branch_name = NULL;
11284 got_object_commit_close(old_commit);
11285 old_commit = NULL;
11286 }
11287
11288 if (wanted_branch_name && !wanted_branch_found) {
11289 err = got_error_fmt(GOT_ERR_NOT_REF,
11290 "%s/%s/", backup_ref_prefix, wanted_branch_name);
11291 }
11292 done:
11293 if (refs_idmap)
11294 got_reflist_object_id_map_free(refs_idmap);
11295 got_ref_list_free(&refs);
11296 got_ref_list_free(&backup_refs);
11297 free(old_commit_id);
11298 free(branch_name);
11299 if (old_commit)
11300 got_object_commit_close(old_commit);
11301 return err;
11302 }
11303
11304 static const struct got_error *
11305 abort_progress(void *arg, unsigned char status, const char *path)
11306 {
11307 /*
11308 * Unversioned files should not clutter progress output when
11309 * an operation is aborted.
11310 */
11311 if (status == GOT_STATUS_UNVERSIONED)
11312 return NULL;
11313
11314 return update_progress(arg, status, path);
11315 }
11316
11317 static const struct got_error *
11318 find_merge_commit_yca(struct got_object_id **new_yca_id,
11319 struct got_object_id *branch_head_commit_id,
11320 struct got_object_id *yca_id,
11321 struct got_object_id *base_commit_id,
11322 struct got_repository *repo)
11323 {
11324 const struct got_error *err = NULL;
11325 struct got_commit_graph *graph = NULL;
11326 struct got_commit_object *commit = NULL;
11327
11328 *new_yca_id = NULL;
11329
11330 err = got_commit_graph_open(&graph, "/", 1);
11331 if (err)
11332 return err;
11333
11334 err = got_commit_graph_bfsort(graph, base_commit_id,
11335 repo, check_cancelled, NULL);
11336 if (err)
11337 goto done;
11338
11339 for (;;) {
11340 struct got_object_id id;
11341
11342 err = got_commit_graph_iter_next(&id, graph, repo,
11343 check_cancelled, NULL);
11344 if (err) {
11345 if (err->code == GOT_ERR_ITER_COMPLETED)
11346 err = NULL;
11347 break;
11348 }
11349
11350 err = got_object_open_as_commit(&commit, repo, &id);
11351 if (err)
11352 break;
11353
11354 if (got_object_commit_get_nparents(commit) > 1) {
11355 /* Search for a better YCA using toposort. */
11356 err = got_commit_graph_find_youngest_common_ancestor(
11357 new_yca_id, base_commit_id, branch_head_commit_id,
11358 0, 1, repo, check_cancelled, NULL);
11359 break;
11360 }
11361
11362 if (got_object_id_cmp(&id, yca_id) == 0)
11363 break;
11364 got_object_commit_close(commit);
11365 commit = NULL;
11366 }
11367 done:
11368 got_commit_graph_close(graph);
11369 if (commit)
11370 got_object_commit_close(commit);
11371 return err;
11372 }
11373
11374 static const struct got_error *
11375 cmd_rebase(int argc, char *argv[])
11376 {
11377 const struct got_error *error = NULL;
11378 struct got_worktree *worktree = NULL;
11379 struct got_repository *repo = NULL;
11380 struct got_fileindex *fileindex = NULL;
11381 char *cwd = NULL, *committer = NULL, *gitconfig_path = NULL;
11382 struct got_reference *branch = NULL;
11383 struct got_reference *new_base_branch = NULL, *tmp_branch = NULL;
11384 struct got_object_id *commit_id = NULL, *parent_id = NULL;
11385 struct got_object_id *resume_commit_id = NULL;
11386 struct got_object_id *branch_head_commit_id = NULL, *yca_id = NULL;
11387 struct got_object_id *head_commit_id = NULL;
11388 struct got_reference *head_ref = NULL;
11389 struct got_commit_object *commit = NULL;
11390 int ch, rebase_in_progress = 0, abort_rebase = 0, continue_rebase = 0;
11391 int histedit_in_progress = 0, merge_in_progress = 0;
11392 int create_backup = 1, list_backups = 0, delete_backups = 0;
11393 int allow_conflict = 0;
11394 struct got_object_id_queue commits;
11395 struct got_pathlist_head merged_paths;
11396 const struct got_object_id_queue *parent_ids;
11397 struct got_object_qid *qid, *pid;
11398 struct got_update_progress_arg upa;
11399 int *pack_fds = NULL;
11400
11401 STAILQ_INIT(&commits);
11402 TAILQ_INIT(&merged_paths);
11403 memset(&upa, 0, sizeof(upa));
11404
11405 #ifndef PROFILE
11406 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
11407 "unveil", NULL) == -1)
11408 err(1, "pledge");
11409 #endif
11410
11411 while ((ch = getopt(argc, argv, "aCclX")) != -1) {
11412 switch (ch) {
11413 case 'a':
11414 abort_rebase = 1;
11415 break;
11416 case 'C':
11417 allow_conflict = 1;
11418 break;
11419 case 'c':
11420 continue_rebase = 1;
11421 break;
11422 case 'l':
11423 list_backups = 1;
11424 break;
11425 case 'X':
11426 delete_backups = 1;
11427 break;
11428 default:
11429 usage_rebase();
11430 /* NOTREACHED */
11431 }
11432 }
11433
11434 argc -= optind;
11435 argv += optind;
11436
11437 if (list_backups) {
11438 if (abort_rebase)
11439 option_conflict('l', 'a');
11440 if (allow_conflict)
11441 option_conflict('l', 'C');
11442 if (continue_rebase)
11443 option_conflict('l', 'c');
11444 if (delete_backups)
11445 option_conflict('l', 'X');
11446 if (argc != 0 && argc != 1)
11447 usage_rebase();
11448 } else if (delete_backups) {
11449 if (abort_rebase)
11450 option_conflict('X', 'a');
11451 if (allow_conflict)
11452 option_conflict('X', 'C');
11453 if (continue_rebase)
11454 option_conflict('X', 'c');
11455 if (list_backups)
11456 option_conflict('l', 'X');
11457 if (argc != 0 && argc != 1)
11458 usage_rebase();
11459 } else if (allow_conflict) {
11460 if (abort_rebase)
11461 option_conflict('C', 'a');
11462 if (!continue_rebase)
11463 errx(1, "-C option requires -c");
11464 } else {
11465 if (abort_rebase && continue_rebase)
11466 usage_rebase();
11467 else if (abort_rebase || continue_rebase) {
11468 if (argc != 0)
11469 usage_rebase();
11470 } else if (argc != 1)
11471 usage_rebase();
11472 }
11473
11474 cwd = getcwd(NULL, 0);
11475 if (cwd == NULL) {
11476 error = got_error_from_errno("getcwd");
11477 goto done;
11478 }
11479
11480 error = got_repo_pack_fds_open(&pack_fds);
11481 if (error != NULL)
11482 goto done;
11483
11484 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
11485 if (error) {
11486 if (list_backups || delete_backups) {
11487 if (error->code != GOT_ERR_NOT_WORKTREE)
11488 goto done;
11489 } else {
11490 if (error->code == GOT_ERR_NOT_WORKTREE)
11491 error = wrap_not_worktree_error(error,
11492 "rebase", cwd);
11493 goto done;
11494 }
11495 }
11496
11497 error = get_gitconfig_path(&gitconfig_path);
11498 if (error)
11499 goto done;
11500 error = got_repo_open(&repo,
11501 worktree ? got_worktree_get_repo_path(worktree) : cwd,
11502 gitconfig_path, pack_fds);
11503 if (error != NULL)
11504 goto done;
11505
11506 if (worktree != NULL && !list_backups && !delete_backups) {
11507 error = worktree_has_logmsg_ref("rebase", worktree, repo);
11508 if (error)
11509 goto done;
11510 }
11511
11512 error = get_author(&committer, repo, worktree);
11513 if (error && error->code != GOT_ERR_COMMIT_NO_AUTHOR)
11514 goto done;
11515
11516 error = apply_unveil(got_repo_get_path(repo), 0,
11517 worktree ? got_worktree_get_root_path(worktree) : NULL);
11518 if (error)
11519 goto done;
11520
11521 if (list_backups || delete_backups) {
11522 error = process_backup_refs(
11523 GOT_WORKTREE_REBASE_BACKUP_REF_PREFIX,
11524 argc == 1 ? argv[0] : NULL, delete_backups, repo);
11525 goto done; /* nothing else to do */
11526 }
11527
11528 error = got_worktree_histedit_in_progress(&histedit_in_progress,
11529 worktree);
11530 if (error)
11531 goto done;
11532 if (histedit_in_progress) {
11533 error = got_error(GOT_ERR_HISTEDIT_BUSY);
11534 goto done;
11535 }
11536
11537 error = got_worktree_merge_in_progress(&merge_in_progress,
11538 worktree, repo);
11539 if (error)
11540 goto done;
11541 if (merge_in_progress) {
11542 error = got_error(GOT_ERR_MERGE_BUSY);
11543 goto done;
11544 }
11545
11546 error = got_worktree_rebase_in_progress(&rebase_in_progress, worktree);
11547 if (error)
11548 goto done;
11549
11550 if (abort_rebase) {
11551 if (!rebase_in_progress) {
11552 error = got_error(GOT_ERR_NOT_REBASING);
11553 goto done;
11554 }
11555 error = got_worktree_rebase_continue(&resume_commit_id,
11556 &new_base_branch, &tmp_branch, &branch, &fileindex,
11557 worktree, repo);
11558 if (error)
11559 goto done;
11560 printf("Switching work tree to %s\n",
11561 got_ref_get_symref_target(new_base_branch));
11562 error = got_worktree_rebase_abort(worktree, fileindex, repo,
11563 new_base_branch, abort_progress, &upa);
11564 if (error)
11565 goto done;
11566 printf("Rebase of %s aborted\n", got_ref_get_name(branch));
11567 print_merge_progress_stats(&upa);
11568 goto done; /* nothing else to do */
11569 }
11570
11571 if (continue_rebase) {
11572 if (!rebase_in_progress) {
11573 error = got_error(GOT_ERR_NOT_REBASING);
11574 goto done;
11575 }
11576 error = got_worktree_rebase_continue(&resume_commit_id,
11577 &new_base_branch, &tmp_branch, &branch, &fileindex,
11578 worktree, repo);
11579 if (error)
11580 goto done;
11581
11582 error = rebase_commit(NULL, worktree, fileindex, tmp_branch,
11583 committer, resume_commit_id, allow_conflict, repo);
11584 if (error)
11585 goto done;
11586
11587 yca_id = got_object_id_dup(resume_commit_id);
11588 if (yca_id == NULL) {
11589 error = got_error_from_errno("got_object_id_dup");
11590 goto done;
11591 }
11592 } else {
11593 error = got_ref_open(&branch, repo, argv[0], 0);
11594 if (error != NULL)
11595 goto done;
11596 if (strncmp(got_ref_get_name(branch), "refs/heads/", 11) != 0) {
11597 error = got_error_msg(GOT_ERR_COMMIT_BRANCH,
11598 "will not rebase a branch which lives outside "
11599 "the \"refs/heads/\" reference namespace");
11600 goto done;
11601 }
11602 }
11603
11604 error = got_ref_resolve(&branch_head_commit_id, repo, branch);
11605 if (error)
11606 goto done;
11607
11608 if (!continue_rebase) {
11609 struct got_object_id *base_commit_id;
11610
11611 error = got_ref_open(&head_ref, repo,
11612 got_worktree_get_head_ref_name(worktree), 0);
11613 if (error)
11614 goto done;
11615 error = got_ref_resolve(&head_commit_id, repo, head_ref);
11616 if (error)
11617 goto done;
11618 base_commit_id = got_worktree_get_base_commit_id(worktree);
11619 if (got_object_id_cmp(base_commit_id, head_commit_id) != 0) {
11620 error = got_error(GOT_ERR_REBASE_OUT_OF_DATE);
11621 goto done;
11622 }
11623
11624 error = got_commit_graph_find_youngest_common_ancestor(&yca_id,
11625 base_commit_id, branch_head_commit_id, 1, 0,
11626 repo, check_cancelled, NULL);
11627 if (error) {
11628 if (error->code == GOT_ERR_ANCESTRY) {
11629 error = got_error_msg(GOT_ERR_ANCESTRY,
11630 "specified branch shares no common "
11631 "ancestry with work tree's branch");
11632 }
11633 goto done;
11634 }
11635
11636 /*
11637 * If a merge commit appears between the new base branch tip
11638 * and a YCA found via first-parent traversal then we might
11639 * find a better YCA using topologically sorted commits.
11640 */
11641 if (got_object_id_cmp(base_commit_id, yca_id) != 0) {
11642 struct got_object_id *better_yca_id;
11643 error = find_merge_commit_yca(&better_yca_id,
11644 branch_head_commit_id, yca_id,
11645 base_commit_id, repo);
11646 if (error)
11647 goto done;
11648 if (better_yca_id) {
11649 free(yca_id);
11650 yca_id = better_yca_id;
11651 }
11652 }
11653
11654 if (got_object_id_cmp(base_commit_id, yca_id) == 0) {
11655 struct got_pathlist_head paths;
11656 const char *branch_name = got_ref_get_name(branch);
11657 const char *base =
11658 got_worktree_get_head_ref_name(worktree);
11659
11660 if (strcmp(branch_name, base) == 0) {
11661 error = got_error_fmt(GOT_ERR_WRONG_BRANCH,
11662 "cannot rebase %s onto itself",
11663 branch_name);
11664 goto done;
11665 } else {
11666 printf("%s is already based on %s\n",
11667 branch_name, base);
11668 }
11669 error = switch_head_ref(branch, branch_head_commit_id,
11670 worktree, repo);
11671 if (error)
11672 goto done;
11673 error = got_worktree_set_base_commit_id(worktree, repo,
11674 branch_head_commit_id);
11675 if (error)
11676 goto done;
11677 TAILQ_INIT(&paths);
11678 error = got_pathlist_append(&paths, "", NULL);
11679 if (error)
11680 goto done;
11681 error = got_worktree_checkout_files(worktree,
11682 &paths, repo, update_progress, &upa,
11683 check_cancelled, NULL);
11684 got_pathlist_free(&paths, GOT_PATHLIST_FREE_NONE);
11685 if (error)
11686 goto done;
11687 if (upa.did_something) {
11688 char *id_str;
11689 error = got_object_id_str(&id_str,
11690 branch_head_commit_id);
11691 if (error)
11692 goto done;
11693 printf("Updated to %s: %s\n",
11694 got_worktree_get_head_ref_name(worktree),
11695 id_str);
11696 free(id_str);
11697 } else
11698 printf("Already up-to-date\n");
11699 print_update_progress_stats(&upa);
11700 goto done;
11701 }
11702 }
11703
11704 commit_id = branch_head_commit_id;
11705 error = got_object_open_as_commit(&commit, repo, commit_id);
11706 if (error)
11707 goto done;
11708
11709 parent_ids = got_object_commit_get_parent_ids(commit);
11710 pid = STAILQ_FIRST(parent_ids);
11711 if (pid) {
11712 error = collect_commits(&commits, commit_id, &pid->id,
11713 yca_id, got_worktree_get_path_prefix(worktree),
11714 GOT_ERR_REBASE_PATH, repo);
11715 if (error)
11716 goto done;
11717 }
11718
11719 got_object_commit_close(commit);
11720 commit = NULL;
11721
11722 if (!continue_rebase) {
11723 error = got_worktree_rebase_prepare(&new_base_branch,
11724 &tmp_branch, &fileindex, worktree, branch, repo);
11725 if (error)
11726 goto done;
11727 }
11728
11729 if (STAILQ_EMPTY(&commits)) {
11730 if (continue_rebase) {
11731 error = rebase_complete(worktree, fileindex,
11732 branch, tmp_branch, repo, create_backup);
11733 goto done;
11734 } else {
11735 /* Fast-forward the reference of the branch. */
11736 struct got_object_id *new_head_commit_id;
11737 char *id_str;
11738 error = got_ref_resolve(&new_head_commit_id, repo,
11739 new_base_branch);
11740 if (error)
11741 goto done;
11742 error = got_object_id_str(&id_str, new_head_commit_id);
11743 if (error)
11744 goto done;
11745 printf("Forwarding %s to commit %s\n",
11746 got_ref_get_name(branch), id_str);
11747 free(id_str);
11748 error = got_ref_change_ref(branch,
11749 new_head_commit_id);
11750 if (error)
11751 goto done;
11752 /* No backup needed since objects did not change. */
11753 create_backup = 0;
11754 }
11755 }
11756
11757 pid = NULL;
11758 STAILQ_FOREACH(qid, &commits, entry) {
11759
11760 commit_id = &qid->id;
11761 parent_id = pid ? &pid->id : yca_id;
11762 pid = qid;
11763
11764 memset(&upa, 0, sizeof(upa));
11765 error = got_worktree_rebase_merge_files(&merged_paths,
11766 worktree, fileindex, parent_id, commit_id, repo,
11767 update_progress, &upa, check_cancelled, NULL);
11768 if (error)
11769 goto done;
11770
11771 print_merge_progress_stats(&upa);
11772 if (upa.conflicts > 0 || upa.missing > 0 ||
11773 upa.not_deleted > 0 || upa.unversioned > 0) {
11774 if (upa.conflicts > 0) {
11775 error = show_rebase_merge_conflict(&qid->id,
11776 repo);
11777 if (error)
11778 goto done;
11779 }
11780 got_pathlist_free(&merged_paths, GOT_PATHLIST_FREE_PATH);
11781 break;
11782 }
11783
11784 error = rebase_commit(&merged_paths, worktree, fileindex,
11785 tmp_branch, committer, commit_id, 0, repo);
11786 got_pathlist_free(&merged_paths, GOT_PATHLIST_FREE_PATH);
11787 if (error)
11788 goto done;
11789 }
11790
11791 if (upa.conflicts > 0 || upa.missing > 0 ||
11792 upa.not_deleted > 0 || upa.unversioned > 0) {
11793 error = got_worktree_rebase_postpone(worktree, fileindex);
11794 if (error)
11795 goto done;
11796 if (upa.conflicts > 0 && upa.missing == 0 &&
11797 upa.not_deleted == 0 && upa.unversioned == 0) {
11798 error = got_error_msg(GOT_ERR_CONFLICTS,
11799 "conflicts must be resolved before rebasing "
11800 "can continue");
11801 } else if (upa.conflicts > 0) {
11802 error = got_error_msg(GOT_ERR_CONFLICTS,
11803 "conflicts must be resolved before rebasing "
11804 "can continue; changes destined for some "
11805 "files were not yet merged and should be "
11806 "merged manually if required before the "
11807 "rebase operation is continued");
11808 } else {
11809 error = got_error_msg(GOT_ERR_CONFLICTS,
11810 "changes destined for some files were not "
11811 "yet merged and should be merged manually "
11812 "if required before the rebase operation "
11813 "is continued");
11814 }
11815 } else
11816 error = rebase_complete(worktree, fileindex, branch,
11817 tmp_branch, repo, create_backup);
11818 done:
11819 free(cwd);
11820 free(committer);
11821 free(gitconfig_path);
11822 got_object_id_queue_free(&commits);
11823 free(branch_head_commit_id);
11824 free(resume_commit_id);
11825 free(head_commit_id);
11826 free(yca_id);
11827 if (commit)
11828 got_object_commit_close(commit);
11829 if (branch)
11830 got_ref_close(branch);
11831 if (new_base_branch)
11832 got_ref_close(new_base_branch);
11833 if (tmp_branch)
11834 got_ref_close(tmp_branch);
11835 if (head_ref)
11836 got_ref_close(head_ref);
11837 if (worktree)
11838 got_worktree_close(worktree);
11839 if (repo) {
11840 const struct got_error *close_err = got_repo_close(repo);
11841 if (error == NULL)
11842 error = close_err;
11843 }
11844 if (pack_fds) {
11845 const struct got_error *pack_err =
11846 got_repo_pack_fds_close(pack_fds);
11847 if (error == NULL)
11848 error = pack_err;
11849 }
11850 return error;
11851 }
11852
11853 __dead static void
11854 usage_histedit(void)
11855 {
11856 fprintf(stderr, "usage: %s histedit [-aCcdeflmX] [-F histedit-script] "
11857 "[branch]\n", getprogname());
11858 exit(1);
11859 }
11860
11861 #define GOT_HISTEDIT_PICK 'p'
11862 #define GOT_HISTEDIT_EDIT 'e'
11863 #define GOT_HISTEDIT_FOLD 'f'
11864 #define GOT_HISTEDIT_DROP 'd'
11865 #define GOT_HISTEDIT_MESG 'm'
11866
11867 static const struct got_histedit_cmd {
11868 unsigned char code;
11869 const char *name;
11870 const char *desc;
11871 } got_histedit_cmds[] = {
11872 { GOT_HISTEDIT_PICK, "pick", "use commit" },
11873 { GOT_HISTEDIT_EDIT, "edit", "use commit but stop for amending" },
11874 { GOT_HISTEDIT_FOLD, "fold", "combine with next commit that will "
11875 "be used" },
11876 { GOT_HISTEDIT_DROP, "drop", "remove commit from history" },
11877 { GOT_HISTEDIT_MESG, "mesg", "open editor to edit the log message" },
11878 };
11879
11880 struct got_histedit_list_entry {
11881 TAILQ_ENTRY(got_histedit_list_entry) entry;
11882 struct got_object_id *commit_id;
11883 const struct got_histedit_cmd *cmd;
11884 char *logmsg;
11885 };
11886 TAILQ_HEAD(got_histedit_list, got_histedit_list_entry);
11887
11888 static const struct got_error *
11889 histedit_write_commit(struct got_object_id *commit_id, const char *cmdname,
11890 FILE *f, struct got_repository *repo)
11891 {
11892 const struct got_error *err = NULL;
11893 char *logmsg = NULL, *id_str = NULL;
11894 struct got_commit_object *commit = NULL;
11895 int n;
11896
11897 err = got_object_open_as_commit(&commit, repo, commit_id);
11898 if (err)
11899 goto done;
11900
11901 err = get_short_logmsg(&logmsg, 34, commit);
11902 if (err)
11903 goto done;
11904
11905 err = got_object_id_str(&id_str, commit_id);
11906 if (err)
11907 goto done;
11908
11909 n = fprintf(f, "%s %s %s\n", cmdname, id_str, logmsg);
11910 if (n < 0)
11911 err = got_ferror(f, GOT_ERR_IO);
11912 done:
11913 if (commit)
11914 got_object_commit_close(commit);
11915 free(id_str);
11916 free(logmsg);
11917 return err;
11918 }
11919
11920 static const struct got_error *
11921 histedit_write_commit_list(struct got_object_id_queue *commits,
11922 FILE *f, int edit_logmsg_only, int fold_only, int drop_only,
11923 int edit_only, struct got_repository *repo)
11924 {
11925 const struct got_error *err = NULL;
11926 struct got_object_qid *qid;
11927 const char *histedit_cmd = NULL;
11928
11929 if (STAILQ_EMPTY(commits))
11930 return got_error(GOT_ERR_EMPTY_HISTEDIT);
11931
11932 STAILQ_FOREACH(qid, commits, entry) {
11933 histedit_cmd = got_histedit_cmds[0].name;
11934 if (drop_only)
11935 histedit_cmd = "drop";
11936 else if (edit_only)
11937 histedit_cmd = "edit";
11938 else if (fold_only && STAILQ_NEXT(qid, entry) != NULL)
11939 histedit_cmd = "fold";
11940 else if (edit_logmsg_only)
11941 histedit_cmd = "mesg";
11942 err = histedit_write_commit(&qid->id, histedit_cmd, f, repo);
11943 if (err)
11944 break;
11945 }
11946
11947 return err;
11948 }
11949
11950 static const struct got_error *
11951 write_cmd_list(FILE *f, const char *branch_name,
11952 struct got_object_id_queue *commits)
11953 {
11954 const struct got_error *err = NULL;
11955 size_t i;
11956 int n;
11957 char *id_str;
11958 struct got_object_qid *qid;
11959
11960 qid = STAILQ_FIRST(commits);
11961 err = got_object_id_str(&id_str, &qid->id);
11962 if (err)
11963 return err;
11964
11965 n = fprintf(f,
11966 "# Editing the history of branch '%s' starting at\n"
11967 "# commit %s\n"
11968 "# Commits will be processed in order from top to "
11969 "bottom of this file.\n", branch_name, id_str);
11970 if (n < 0) {
11971 err = got_ferror(f, GOT_ERR_IO);
11972 goto done;
11973 }
11974
11975 n = fprintf(f, "# Available histedit commands:\n");
11976 if (n < 0) {
11977 err = got_ferror(f, GOT_ERR_IO);
11978 goto done;
11979 }
11980
11981 for (i = 0; i < nitems(got_histedit_cmds); i++) {
11982 const struct got_histedit_cmd *cmd = &got_histedit_cmds[i];
11983 n = fprintf(f, "# %s (%c): %s\n", cmd->name, cmd->code,
11984 cmd->desc);
11985 if (n < 0) {
11986 err = got_ferror(f, GOT_ERR_IO);
11987 break;
11988 }
11989 }
11990 done:
11991 free(id_str);
11992 return err;
11993 }
11994
11995 static const struct got_error *
11996 histedit_syntax_error(int lineno)
11997 {
11998 static char msg[42];
11999 int ret;
12000
12001 ret = snprintf(msg, sizeof(msg), "histedit syntax error on line %d",
12002 lineno);
12003 if (ret < 0 || (size_t)ret >= sizeof(msg))
12004 return got_error(GOT_ERR_HISTEDIT_SYNTAX);
12005
12006 return got_error_msg(GOT_ERR_HISTEDIT_SYNTAX, msg);
12007 }
12008
12009 static const struct got_error *
12010 append_folded_commit_msg(char **new_msg, struct got_histedit_list_entry *hle,
12011 char *logmsg, struct got_repository *repo)
12012 {
12013 const struct got_error *err;
12014 struct got_commit_object *folded_commit = NULL;
12015 char *id_str, *folded_logmsg = NULL;
12016
12017 err = got_object_id_str(&id_str, hle->commit_id);
12018 if (err)
12019 return err;
12020
12021 err = got_object_open_as_commit(&folded_commit, repo, hle->commit_id);
12022 if (err)
12023 goto done;
12024
12025 err = got_object_commit_get_logmsg(&folded_logmsg, folded_commit);
12026 if (err)
12027 goto done;
12028 if (asprintf(new_msg, "%s%s# log message of folded commit %s: %s",
12029 logmsg ? logmsg : "", logmsg ? "\n" : "", id_str,
12030 folded_logmsg) == -1) {
12031 err = got_error_from_errno("asprintf");
12032 }
12033 done:
12034 if (folded_commit)
12035 got_object_commit_close(folded_commit);
12036 free(id_str);
12037 free(folded_logmsg);
12038 return err;
12039 }
12040
12041 static struct got_histedit_list_entry *
12042 get_folded_commits(struct got_histedit_list_entry *hle)
12043 {
12044 struct got_histedit_list_entry *prev, *folded = NULL;
12045
12046 prev = TAILQ_PREV(hle, got_histedit_list, entry);
12047 while (prev && (prev->cmd->code == GOT_HISTEDIT_FOLD ||
12048 prev->cmd->code == GOT_HISTEDIT_DROP)) {
12049 if (prev->cmd->code == GOT_HISTEDIT_FOLD)
12050 folded = prev;
12051 prev = TAILQ_PREV(prev, got_histedit_list, entry);
12052 }
12053
12054 return folded;
12055 }
12056
12057 static const struct got_error *
12058 histedit_edit_logmsg(struct got_histedit_list_entry *hle,
12059 const char *editor, struct got_repository *repo)
12060 {
12061 char *logmsg_path = NULL, *id_str = NULL, *orig_logmsg = NULL;
12062 char *logmsg = NULL, *new_msg = NULL;
12063 const struct got_error *err = NULL;
12064 struct got_commit_object *commit = NULL;
12065 int logmsg_len;
12066 int fd = -1;
12067 struct got_histedit_list_entry *folded = NULL;
12068
12069 err = got_object_open_as_commit(&commit, repo, hle->commit_id);
12070 if (err)
12071 return err;
12072
12073 folded = get_folded_commits(hle);
12074 if (folded) {
12075 while (folded != hle) {
12076 if (folded->cmd->code == GOT_HISTEDIT_DROP) {
12077 folded = TAILQ_NEXT(folded, entry);
12078 continue;
12079 }
12080 err = append_folded_commit_msg(&new_msg, folded,
12081 logmsg, repo);
12082 if (err)
12083 goto done;
12084 free(logmsg);
12085 logmsg = new_msg;
12086 folded = TAILQ_NEXT(folded, entry);
12087 }
12088 }
12089
12090 err = got_object_id_str(&id_str, hle->commit_id);
12091 if (err)
12092 goto done;
12093 err = got_object_commit_get_logmsg(&orig_logmsg, commit);
12094 if (err)
12095 goto done;
12096 logmsg_len = asprintf(&new_msg,
12097 "%s\n# original log message of commit %s: %s",
12098 logmsg ? logmsg : "", id_str, orig_logmsg);
12099 if (logmsg_len == -1) {
12100 err = got_error_from_errno("asprintf");
12101 goto done;
12102 }
12103 free(logmsg);
12104 logmsg = new_msg;
12105
12106 err = got_object_id_str(&id_str, hle->commit_id);
12107 if (err)
12108 goto done;
12109
12110 err = got_opentemp_named_fd(&logmsg_path, &fd,
12111 GOT_TMPDIR_STR "/got-logmsg", "");
12112 if (err)
12113 goto done;
12114
12115 if (write(fd, logmsg, logmsg_len) == -1) {
12116 err = got_error_from_errno2("write", logmsg_path);
12117 goto done;
12118 }
12119 if (close(fd) == -1) {
12120 err = got_error_from_errno2("close", logmsg_path);
12121 goto done;
12122 }
12123 fd = -1;
12124
12125 err = edit_logmsg(&hle->logmsg, editor, logmsg_path, logmsg,
12126 logmsg_len, 0);
12127 if (err) {
12128 if (err->code != GOT_ERR_COMMIT_MSG_EMPTY)
12129 goto done;
12130 err = NULL;
12131 hle->logmsg = strdup(new_msg);
12132 if (hle->logmsg == NULL)
12133 err = got_error_from_errno("strdup");
12134 }
12135 done:
12136 if (fd != -1 && close(fd) == -1 && err == NULL)
12137 err = got_error_from_errno2("close", logmsg_path);
12138 if (logmsg_path && unlink(logmsg_path) != 0 && err == NULL)
12139 err = got_error_from_errno2("unlink", logmsg_path);
12140 free(logmsg_path);
12141 free(logmsg);
12142 free(orig_logmsg);
12143 if (commit)
12144 got_object_commit_close(commit);
12145 return err;
12146 }
12147
12148 static const struct got_error *
12149 histedit_parse_list(struct got_histedit_list *histedit_cmds,
12150 FILE *f, struct got_repository *repo)
12151 {
12152 const struct got_error *err = NULL;
12153 char *line = NULL, *p, *end;
12154 size_t i, linesize = 0;
12155 ssize_t linelen;
12156 int lineno = 0;
12157 const struct got_histedit_cmd *cmd;
12158 struct got_object_id *commit_id = NULL;
12159 struct got_histedit_list_entry *hle = NULL;
12160
12161 for (;;) {
12162 linelen = getline(&line, &linesize, f);
12163 if (linelen == -1) {
12164 const struct got_error *getline_err;
12165 if (feof(f))
12166 break;
12167 getline_err = got_error_from_errno("getline");
12168 err = got_ferror(f, getline_err->code);
12169 break;
12170 }
12171 lineno++;
12172 p = line;
12173 while (isspace((unsigned char)p[0]))
12174 p++;
12175 if (p[0] == '#' || p[0] == '\0')
12176 continue;
12177 cmd = NULL;
12178 for (i = 0; i < nitems(got_histedit_cmds); i++) {
12179 cmd = &got_histedit_cmds[i];
12180 if (strncmp(cmd->name, p, strlen(cmd->name)) == 0 &&
12181 isspace((unsigned char)p[strlen(cmd->name)])) {
12182 p += strlen(cmd->name);
12183 break;
12184 }
12185 if (p[0] == cmd->code && isspace((unsigned char)p[1])) {
12186 p++;
12187 break;
12188 }
12189 }
12190 if (i == nitems(got_histedit_cmds)) {
12191 err = histedit_syntax_error(lineno);
12192 break;
12193 }
12194 while (isspace((unsigned char)p[0]))
12195 p++;
12196 end = p;
12197 while (end[0] && !isspace((unsigned char)end[0]))
12198 end++;
12199 *end = '\0';
12200 err = got_object_resolve_id_str(&commit_id, repo, p);
12201 if (err) {
12202 /* override error code */
12203 err = histedit_syntax_error(lineno);
12204 break;
12205 }
12206 hle = malloc(sizeof(*hle));
12207 if (hle == NULL) {
12208 err = got_error_from_errno("malloc");
12209 break;
12210 }
12211 hle->cmd = cmd;
12212 hle->commit_id = commit_id;
12213 hle->logmsg = NULL;
12214 commit_id = NULL;
12215 TAILQ_INSERT_TAIL(histedit_cmds, hle, entry);
12216 }
12217
12218 free(line);
12219 free(commit_id);
12220 return err;
12221 }
12222
12223 static const struct got_error *
12224 histedit_check_script(struct got_histedit_list *histedit_cmds,
12225 struct got_object_id_queue *commits, struct got_repository *repo)
12226 {
12227 const struct got_error *err = NULL;
12228 struct got_object_qid *qid;
12229 struct got_histedit_list_entry *hle;
12230 static char msg[92];
12231 char *id_str;
12232
12233 if (TAILQ_EMPTY(histedit_cmds))
12234 return got_error_msg(GOT_ERR_EMPTY_HISTEDIT,
12235 "histedit script contains no commands");
12236 if (STAILQ_EMPTY(commits))
12237 return got_error(GOT_ERR_EMPTY_HISTEDIT);
12238
12239 TAILQ_FOREACH(hle, histedit_cmds, entry) {
12240 struct got_histedit_list_entry *hle2;
12241 TAILQ_FOREACH(hle2, histedit_cmds, entry) {
12242 if (hle == hle2)
12243 continue;
12244 if (got_object_id_cmp(hle->commit_id,
12245 hle2->commit_id) != 0)
12246 continue;
12247 err = got_object_id_str(&id_str, hle->commit_id);
12248 if (err)
12249 return err;
12250 snprintf(msg, sizeof(msg), "commit %s is listed "
12251 "more than once in histedit script", id_str);
12252 free(id_str);
12253 return got_error_msg(GOT_ERR_HISTEDIT_CMD, msg);
12254 }
12255 }
12256
12257 STAILQ_FOREACH(qid, commits, entry) {
12258 TAILQ_FOREACH(hle, histedit_cmds, entry) {
12259 if (got_object_id_cmp(&qid->id, hle->commit_id) == 0)
12260 break;
12261 }
12262 if (hle == NULL) {
12263 err = got_object_id_str(&id_str, &qid->id);
12264 if (err)
12265 return err;
12266 snprintf(msg, sizeof(msg),
12267 "commit %s missing from histedit script", id_str);
12268 free(id_str);
12269 return got_error_msg(GOT_ERR_HISTEDIT_CMD, msg);
12270 }
12271 }
12272
12273 hle = TAILQ_LAST(histedit_cmds, got_histedit_list);
12274 if (hle && hle->cmd->code == GOT_HISTEDIT_FOLD)
12275 return got_error_msg(GOT_ERR_HISTEDIT_CMD,
12276 "last commit in histedit script cannot be folded");
12277
12278 return NULL;
12279 }
12280
12281 static const struct got_error *
12282 histedit_run_editor(struct got_histedit_list *histedit_cmds,
12283 const char *editor, const char *path,
12284 struct got_object_id_queue *commits, struct got_repository *repo)
12285 {
12286 const struct got_error *err = NULL;
12287 struct stat st, st2;
12288 struct timespec timeout;
12289 FILE *f = NULL;
12290
12291 if (stat(path, &st) == -1) {
12292 err = got_error_from_errno2("stat", path);
12293 goto done;
12294 }
12295
12296 if (spawn_editor(editor, path) == -1) {
12297 err = got_error_from_errno("failed spawning editor");
12298 goto done;
12299 }
12300
12301 timeout.tv_sec = 0;
12302 timeout.tv_nsec = 1;
12303 nanosleep(&timeout, NULL);
12304
12305 if (stat(path, &st2) == -1) {
12306 err = got_error_from_errno2("stat", path);
12307 goto done;
12308 }
12309
12310 if (st.st_size == st2.st_size &&
12311 timespeccmp(&st.st_mtim, &st2.st_mtim, ==)) {
12312 err = got_error_msg(GOT_ERR_EMPTY_HISTEDIT,
12313 "no changes made to histedit script, aborting");
12314 goto done;
12315 }
12316
12317 f = fopen(path, "re");
12318 if (f == NULL) {
12319 err = got_error_from_errno("fopen");
12320 goto done;
12321 }
12322 err = histedit_parse_list(histedit_cmds, f, repo);
12323 if (err)
12324 goto done;
12325
12326 err = histedit_check_script(histedit_cmds, commits, repo);
12327 done:
12328 if (f && fclose(f) == EOF && err == NULL)
12329 err = got_error_from_errno("fclose");
12330 return err;
12331 }
12332
12333 static const struct got_error *
12334 histedit_edit_list_retry(struct got_histedit_list *, const struct got_error *,
12335 struct got_object_id_queue *, const char *, const char *, const char *,
12336 struct got_repository *);
12337
12338 static const struct got_error *
12339 histedit_edit_script(struct got_histedit_list *histedit_cmds,
12340 struct got_object_id_queue *commits, const char *branch_name,
12341 int edit_logmsg_only, int fold_only, int drop_only, int edit_only,
12342 const char *editor, struct got_repository *repo)
12343 {
12344 const struct got_error *err;
12345 FILE *f = NULL;
12346 char *path = NULL;
12347
12348 err = got_opentemp_named(&path, &f, "got-histedit", "");
12349 if (err)
12350 return err;
12351
12352 err = write_cmd_list(f, branch_name, commits);
12353 if (err)
12354 goto done;
12355
12356 err = histedit_write_commit_list(commits, f, edit_logmsg_only,
12357 fold_only, drop_only, edit_only, repo);
12358 if (err)
12359 goto done;
12360
12361 if (drop_only || edit_logmsg_only || fold_only || edit_only) {
12362 rewind(f);
12363 err = histedit_parse_list(histedit_cmds, f, repo);
12364 } else {
12365 if (fclose(f) == EOF) {
12366 err = got_error_from_errno("fclose");
12367 goto done;
12368 }
12369 f = NULL;
12370 err = histedit_run_editor(histedit_cmds, editor, path,
12371 commits, repo);
12372 if (err) {
12373 if (err->code != GOT_ERR_HISTEDIT_SYNTAX &&
12374 err->code != GOT_ERR_HISTEDIT_CMD)
12375 goto done;
12376 err = histedit_edit_list_retry(histedit_cmds, err,
12377 commits, editor, path, branch_name, repo);
12378 }
12379 }
12380 done:
12381 if (f && fclose(f) == EOF && err == NULL)
12382 err = got_error_from_errno("fclose");
12383 if (path && unlink(path) != 0 && err == NULL)
12384 err = got_error_from_errno2("unlink", path);
12385 free(path);
12386 return err;
12387 }
12388
12389 static const struct got_error *
12390 histedit_save_list(struct got_histedit_list *histedit_cmds,
12391 struct got_worktree *worktree, struct got_repository *repo)
12392 {
12393 const struct got_error *err = NULL;
12394 char *path = NULL;
12395 FILE *f = NULL;
12396 struct got_histedit_list_entry *hle;
12397
12398 err = got_worktree_get_histedit_script_path(&path, worktree);
12399 if (err)
12400 return err;
12401
12402 f = fopen(path, "we");
12403 if (f == NULL) {
12404 err = got_error_from_errno2("fopen", path);
12405 goto done;
12406 }
12407 TAILQ_FOREACH(hle, histedit_cmds, entry) {
12408 err = histedit_write_commit(hle->commit_id, hle->cmd->name, f,
12409 repo);
12410 if (err)
12411 break;
12412 }
12413 done:
12414 if (f && fclose(f) == EOF && err == NULL)
12415 err = got_error_from_errno("fclose");
12416 free(path);
12417 return err;
12418 }
12419
12420 static void
12421 histedit_free_list(struct got_histedit_list *histedit_cmds)
12422 {
12423 struct got_histedit_list_entry *hle;
12424
12425 while ((hle = TAILQ_FIRST(histedit_cmds))) {
12426 TAILQ_REMOVE(histedit_cmds, hle, entry);
12427 free(hle);
12428 }
12429 }
12430
12431 static const struct got_error *
12432 histedit_load_list(struct got_histedit_list *histedit_cmds,
12433 const char *path, struct got_repository *repo)
12434 {
12435 const struct got_error *err = NULL;
12436 FILE *f = NULL;
12437
12438 f = fopen(path, "re");
12439 if (f == NULL) {
12440 err = got_error_from_errno2("fopen", path);
12441 goto done;
12442 }
12443
12444 err = histedit_parse_list(histedit_cmds, f, repo);
12445 done:
12446 if (f && fclose(f) == EOF && err == NULL)
12447 err = got_error_from_errno("fclose");
12448 return err;
12449 }
12450
12451 static const struct got_error *
12452 histedit_edit_list_retry(struct got_histedit_list *histedit_cmds,
12453 const struct got_error *edit_err, struct got_object_id_queue *commits,
12454 const char *editor, const char *path, const char *branch_name,
12455 struct got_repository *repo)
12456 {
12457 const struct got_error *err = NULL, *prev_err = edit_err;
12458 int resp = ' ';
12459
12460 while (resp != 'c' && resp != 'r' && resp != 'a') {
12461 printf("%s: %s\n(c)ontinue editing, (r)estart editing, "
12462 "or (a)bort: ", getprogname(), prev_err->msg);
12463 resp = getchar();
12464 if (resp == '\n')
12465 resp = getchar();
12466 if (resp == 'c') {
12467 histedit_free_list(histedit_cmds);
12468 err = histedit_run_editor(histedit_cmds, editor, path,
12469 commits, repo);
12470 if (err) {
12471 if (err->code != GOT_ERR_HISTEDIT_SYNTAX &&
12472 err->code != GOT_ERR_HISTEDIT_CMD)
12473 break;
12474 prev_err = err;
12475 resp = ' ';
12476 continue;
12477 }
12478 break;
12479 } else if (resp == 'r') {
12480 histedit_free_list(histedit_cmds);
12481 err = histedit_edit_script(histedit_cmds,
12482 commits, branch_name, 0, 0, 0, 0, editor, repo);
12483 if (err) {
12484 if (err->code != GOT_ERR_HISTEDIT_SYNTAX &&
12485 err->code != GOT_ERR_HISTEDIT_CMD)
12486 break;
12487 prev_err = err;
12488 resp = ' ';
12489 continue;
12490 }
12491 break;
12492 } else if (resp == 'a') {
12493 err = got_error(GOT_ERR_HISTEDIT_CANCEL);
12494 break;
12495 } else
12496 printf("invalid response '%c'\n", resp);
12497 }
12498
12499 return err;
12500 }
12501
12502 static const struct got_error *
12503 histedit_complete(struct got_worktree *worktree,
12504 struct got_fileindex *fileindex, struct got_reference *tmp_branch,
12505 struct got_reference *branch, struct got_repository *repo)
12506 {
12507 printf("Switching work tree to %s\n",
12508 got_ref_get_symref_target(branch));
12509 return got_worktree_histedit_complete(worktree, fileindex, tmp_branch,
12510 branch, repo);
12511 }
12512
12513 static const struct got_error *
12514 show_histedit_progress(struct got_commit_object *commit,
12515 struct got_histedit_list_entry *hle, struct got_object_id *new_id)
12516 {
12517 const struct got_error *err;
12518 char *old_id_str = NULL, *new_id_str = NULL, *logmsg = NULL;
12519
12520 err = got_object_id_str(&old_id_str, hle->commit_id);
12521 if (err)
12522 goto done;
12523
12524 if (new_id) {
12525 err = got_object_id_str(&new_id_str, new_id);
12526 if (err)
12527 goto done;
12528 }
12529
12530 old_id_str[12] = '\0';
12531 if (new_id_str)
12532 new_id_str[12] = '\0';
12533
12534 if (hle->logmsg) {
12535 logmsg = strdup(hle->logmsg);
12536 if (logmsg == NULL) {
12537 err = got_error_from_errno("strdup");
12538 goto done;
12539 }
12540 trim_logmsg(logmsg, 42);
12541 } else {
12542 err = get_short_logmsg(&logmsg, 42, commit);
12543 if (err)
12544 goto done;
12545 }
12546
12547 switch (hle->cmd->code) {
12548 case GOT_HISTEDIT_PICK:
12549 case GOT_HISTEDIT_EDIT:
12550 case GOT_HISTEDIT_MESG:
12551 printf("%s -> %s: %s\n", old_id_str,
12552 new_id_str ? new_id_str : "no-op change", logmsg);
12553 break;
12554 case GOT_HISTEDIT_DROP:
12555 case GOT_HISTEDIT_FOLD:
12556 printf("%s -> %s commit: %s\n", old_id_str, hle->cmd->name,
12557 logmsg);
12558 break;
12559 default:
12560 break;
12561 }
12562 done:
12563 free(old_id_str);
12564 free(new_id_str);
12565 return err;
12566 }
12567
12568 static const struct got_error *
12569 histedit_commit(struct got_pathlist_head *merged_paths,
12570 struct got_worktree *worktree, struct got_fileindex *fileindex,
12571 struct got_reference *tmp_branch, struct got_histedit_list_entry *hle,
12572 const char *committer, int allow_conflict, const char *editor,
12573 struct got_repository *repo)
12574 {
12575 const struct got_error *err;
12576 struct got_commit_object *commit;
12577 struct got_object_id *new_commit_id;
12578
12579 if ((hle->cmd->code == GOT_HISTEDIT_EDIT || get_folded_commits(hle))
12580 && hle->logmsg == NULL) {
12581 err = histedit_edit_logmsg(hle, editor, repo);
12582 if (err)
12583 return err;
12584 }
12585
12586 err = got_object_open_as_commit(&commit, repo, hle->commit_id);
12587 if (err)
12588 return err;
12589
12590 err = got_worktree_histedit_commit(&new_commit_id, merged_paths,
12591 worktree, fileindex, tmp_branch, committer, commit, hle->commit_id,
12592 hle->logmsg, allow_conflict, repo);
12593 if (err) {
12594 if (err->code != GOT_ERR_COMMIT_NO_CHANGES)
12595 goto done;
12596 err = show_histedit_progress(commit, hle, NULL);
12597 } else {
12598 err = show_histedit_progress(commit, hle, new_commit_id);
12599 free(new_commit_id);
12600 }
12601 done:
12602 got_object_commit_close(commit);
12603 return err;
12604 }
12605
12606 static const struct got_error *
12607 histedit_skip_commit(struct got_histedit_list_entry *hle,
12608 struct got_worktree *worktree, struct got_repository *repo)
12609 {
12610 const struct got_error *error;
12611 struct got_commit_object *commit;
12612
12613 error = got_worktree_histedit_skip_commit(worktree, hle->commit_id,
12614 repo);
12615 if (error)
12616 return error;
12617
12618 error = got_object_open_as_commit(&commit, repo, hle->commit_id);
12619 if (error)
12620 return error;
12621
12622 error = show_histedit_progress(commit, hle, NULL);
12623 got_object_commit_close(commit);
12624 return error;
12625 }
12626
12627 static const struct got_error *
12628 check_local_changes(void *arg, unsigned char status,
12629 unsigned char staged_status, const char *path,
12630 struct got_object_id *blob_id, struct got_object_id *staged_blob_id,
12631 struct got_object_id *commit_id, int dirfd, const char *de_name)
12632 {
12633 int *have_local_changes = arg;
12634
12635 switch (status) {
12636 case GOT_STATUS_ADD:
12637 case GOT_STATUS_DELETE:
12638 case GOT_STATUS_MODIFY:
12639 case GOT_STATUS_CONFLICT:
12640 *have_local_changes = 1;
12641 return got_error(GOT_ERR_CANCELLED);
12642 default:
12643 break;
12644 }
12645
12646 switch (staged_status) {
12647 case GOT_STATUS_ADD:
12648 case GOT_STATUS_DELETE:
12649 case GOT_STATUS_MODIFY:
12650 *have_local_changes = 1;
12651 return got_error(GOT_ERR_CANCELLED);
12652 default:
12653 break;
12654 }
12655
12656 return NULL;
12657 }
12658
12659 static const struct got_error *
12660 cmd_histedit(int argc, char *argv[])
12661 {
12662 const struct got_error *error = NULL;
12663 struct got_worktree *worktree = NULL;
12664 struct got_fileindex *fileindex = NULL;
12665 struct got_repository *repo = NULL;
12666 char *cwd = NULL, *committer = NULL, *gitconfig_path = NULL;
12667 struct got_reference *branch = NULL;
12668 struct got_reference *tmp_branch = NULL;
12669 struct got_object_id *resume_commit_id = NULL;
12670 struct got_object_id *base_commit_id = NULL;
12671 struct got_object_id *head_commit_id = NULL;
12672 struct got_commit_object *commit = NULL;
12673 int ch, rebase_in_progress = 0, merge_in_progress = 0;
12674 struct got_update_progress_arg upa;
12675 int edit_in_progress = 0, abort_edit = 0, continue_edit = 0;
12676 int drop_only = 0, edit_logmsg_only = 0, fold_only = 0, edit_only = 0;
12677 int allow_conflict = 0, list_backups = 0, delete_backups = 0;
12678 const char *edit_script_path = NULL;
12679 char *editor = NULL;
12680 struct got_object_id_queue commits;
12681 struct got_pathlist_head merged_paths;
12682 const struct got_object_id_queue *parent_ids;
12683 struct got_object_qid *pid;
12684 struct got_histedit_list histedit_cmds;
12685 struct got_histedit_list_entry *hle;
12686 int *pack_fds = NULL;
12687
12688 STAILQ_INIT(&commits);
12689 TAILQ_INIT(&histedit_cmds);
12690 TAILQ_INIT(&merged_paths);
12691 memset(&upa, 0, sizeof(upa));
12692
12693 #ifndef PROFILE
12694 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
12695 "unveil", NULL) == -1)
12696 err(1, "pledge");
12697 #endif
12698
12699 while ((ch = getopt(argc, argv, "aCcdeF:flmX")) != -1) {
12700 switch (ch) {
12701 case 'a':
12702 abort_edit = 1;
12703 break;
12704 case 'C':
12705 allow_conflict = 1;
12706 break;
12707 case 'c':
12708 continue_edit = 1;
12709 break;
12710 case 'd':
12711 drop_only = 1;
12712 break;
12713 case 'e':
12714 edit_only = 1;
12715 break;
12716 case 'F':
12717 edit_script_path = optarg;
12718 break;
12719 case 'f':
12720 fold_only = 1;
12721 break;
12722 case 'l':
12723 list_backups = 1;
12724 break;
12725 case 'm':
12726 edit_logmsg_only = 1;
12727 break;
12728 case 'X':
12729 delete_backups = 1;
12730 break;
12731 default:
12732 usage_histedit();
12733 /* NOTREACHED */
12734 }
12735 }
12736
12737 argc -= optind;
12738 argv += optind;
12739
12740 if (abort_edit && allow_conflict)
12741 option_conflict('a', 'C');
12742 if (abort_edit && continue_edit)
12743 option_conflict('a', 'c');
12744 if (edit_script_path && allow_conflict)
12745 option_conflict('F', 'C');
12746 if (edit_script_path && edit_logmsg_only)
12747 option_conflict('F', 'm');
12748 if (abort_edit && edit_logmsg_only)
12749 option_conflict('a', 'm');
12750 if (edit_logmsg_only && allow_conflict)
12751 option_conflict('m', 'C');
12752 if (continue_edit && edit_logmsg_only)
12753 option_conflict('c', 'm');
12754 if (abort_edit && fold_only)
12755 option_conflict('a', 'f');
12756 if (fold_only && allow_conflict)
12757 option_conflict('f', 'C');
12758 if (continue_edit && fold_only)
12759 option_conflict('c', 'f');
12760 if (fold_only && edit_logmsg_only)
12761 option_conflict('f', 'm');
12762 if (edit_script_path && fold_only)
12763 option_conflict('F', 'f');
12764 if (abort_edit && edit_only)
12765 option_conflict('a', 'e');
12766 if (continue_edit && edit_only)
12767 option_conflict('c', 'e');
12768 if (edit_only && edit_logmsg_only)
12769 option_conflict('e', 'm');
12770 if (edit_script_path && edit_only)
12771 option_conflict('F', 'e');
12772 if (fold_only && edit_only)
12773 option_conflict('f', 'e');
12774 if (drop_only && abort_edit)
12775 option_conflict('d', 'a');
12776 if (drop_only && allow_conflict)
12777 option_conflict('d', 'C');
12778 if (drop_only && continue_edit)
12779 option_conflict('d', 'c');
12780 if (drop_only && edit_logmsg_only)
12781 option_conflict('d', 'm');
12782 if (drop_only && edit_only)
12783 option_conflict('d', 'e');
12784 if (drop_only && edit_script_path)
12785 option_conflict('d', 'F');
12786 if (drop_only && fold_only)
12787 option_conflict('d', 'f');
12788 if (list_backups) {
12789 if (abort_edit)
12790 option_conflict('l', 'a');
12791 if (allow_conflict)
12792 option_conflict('l', 'C');
12793 if (continue_edit)
12794 option_conflict('l', 'c');
12795 if (edit_script_path)
12796 option_conflict('l', 'F');
12797 if (edit_logmsg_only)
12798 option_conflict('l', 'm');
12799 if (drop_only)
12800 option_conflict('l', 'd');
12801 if (fold_only)
12802 option_conflict('l', 'f');
12803 if (edit_only)
12804 option_conflict('l', 'e');
12805 if (delete_backups)
12806 option_conflict('l', 'X');
12807 if (argc != 0 && argc != 1)
12808 usage_histedit();
12809 } else if (delete_backups) {
12810 if (abort_edit)
12811 option_conflict('X', 'a');
12812 if (allow_conflict)
12813 option_conflict('X', 'C');
12814 if (continue_edit)
12815 option_conflict('X', 'c');
12816 if (drop_only)
12817 option_conflict('X', 'd');
12818 if (edit_script_path)
12819 option_conflict('X', 'F');
12820 if (edit_logmsg_only)
12821 option_conflict('X', 'm');
12822 if (fold_only)
12823 option_conflict('X', 'f');
12824 if (edit_only)
12825 option_conflict('X', 'e');
12826 if (list_backups)
12827 option_conflict('X', 'l');
12828 if (argc != 0 && argc != 1)
12829 usage_histedit();
12830 } else if (allow_conflict && !continue_edit)
12831 errx(1, "-C option requires -c");
12832 else if (argc != 0)
12833 usage_histedit();
12834
12835 cwd = getcwd(NULL, 0);
12836 if (cwd == NULL) {
12837 error = got_error_from_errno("getcwd");
12838 goto done;
12839 }
12840
12841 error = got_repo_pack_fds_open(&pack_fds);
12842 if (error != NULL)
12843 goto done;
12844
12845 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
12846 if (error) {
12847 if (list_backups || delete_backups) {
12848 if (error->code != GOT_ERR_NOT_WORKTREE)
12849 goto done;
12850 } else {
12851 if (error->code == GOT_ERR_NOT_WORKTREE)
12852 error = wrap_not_worktree_error(error,
12853 "histedit", cwd);
12854 goto done;
12855 }
12856 }
12857
12858 if (list_backups || delete_backups) {
12859 error = got_repo_open(&repo,
12860 worktree ? got_worktree_get_repo_path(worktree) : cwd,
12861 NULL, pack_fds);
12862 if (error != NULL)
12863 goto done;
12864 error = apply_unveil(got_repo_get_path(repo), 0,
12865 worktree ? got_worktree_get_root_path(worktree) : NULL);
12866 if (error)
12867 goto done;
12868 error = process_backup_refs(
12869 GOT_WORKTREE_HISTEDIT_BACKUP_REF_PREFIX,
12870 argc == 1 ? argv[0] : NULL, delete_backups, repo);
12871 goto done; /* nothing else to do */
12872 } else {
12873 error = get_gitconfig_path(&gitconfig_path);
12874 if (error)
12875 goto done;
12876 error = got_repo_open(&repo,
12877 got_worktree_get_repo_path(worktree), gitconfig_path,
12878 pack_fds);
12879 if (error != NULL)
12880 goto done;
12881 error = get_editor(&editor);
12882 if (error)
12883 goto done;
12884 if (unveil(editor, "x") != 0) {
12885 error = got_error_from_errno2("unveil", editor);
12886 goto done;
12887 }
12888 if (edit_script_path) {
12889 if (unveil(edit_script_path, "r") != 0) {
12890 error = got_error_from_errno2("unveil",
12891 edit_script_path);
12892 goto done;
12893 }
12894 }
12895 error = apply_unveil(got_repo_get_path(repo), 0,
12896 got_worktree_get_root_path(worktree));
12897 if (error)
12898 goto done;
12899 }
12900
12901 if (worktree != NULL && !list_backups && !delete_backups) {
12902 error = worktree_has_logmsg_ref("histedit", worktree, repo);
12903 if (error)
12904 goto done;
12905 }
12906
12907 error = got_worktree_rebase_in_progress(&rebase_in_progress, worktree);
12908 if (error)
12909 goto done;
12910 if (rebase_in_progress) {
12911 error = got_error(GOT_ERR_REBASING);
12912 goto done;
12913 }
12914
12915 error = got_worktree_merge_in_progress(&merge_in_progress, worktree,
12916 repo);
12917 if (error)
12918 goto done;
12919 if (merge_in_progress) {
12920 error = got_error(GOT_ERR_MERGE_BUSY);
12921 goto done;
12922 }
12923
12924 error = got_worktree_histedit_in_progress(&edit_in_progress, worktree);
12925 if (error)
12926 goto done;
12927
12928 if (edit_in_progress && edit_logmsg_only) {
12929 error = got_error_msg(GOT_ERR_HISTEDIT_BUSY,
12930 "histedit operation is in progress in this "
12931 "work tree and must be continued or aborted "
12932 "before the -m option can be used");
12933 goto done;
12934 }
12935 if (edit_in_progress && drop_only) {
12936 error = got_error_msg(GOT_ERR_HISTEDIT_BUSY,
12937 "histedit operation is in progress in this "
12938 "work tree and must be continued or aborted "
12939 "before the -d option can be used");
12940 goto done;
12941 }
12942 if (edit_in_progress && fold_only) {
12943 error = got_error_msg(GOT_ERR_HISTEDIT_BUSY,
12944 "histedit operation is in progress in this "
12945 "work tree and must be continued or aborted "
12946 "before the -f option can be used");
12947 goto done;
12948 }
12949 if (edit_in_progress && edit_only) {
12950 error = got_error_msg(GOT_ERR_HISTEDIT_BUSY,
12951 "histedit operation is in progress in this "
12952 "work tree and must be continued or aborted "
12953 "before the -e option can be used");
12954 goto done;
12955 }
12956
12957 if (edit_in_progress && abort_edit) {
12958 error = got_worktree_histedit_continue(&resume_commit_id,
12959 &tmp_branch, &branch, &base_commit_id, &fileindex,
12960 worktree, repo);
12961 if (error)
12962 goto done;
12963 printf("Switching work tree to %s\n",
12964 got_ref_get_symref_target(branch));
12965 error = got_worktree_histedit_abort(worktree, fileindex, repo,
12966 branch, base_commit_id, abort_progress, &upa);
12967 if (error)
12968 goto done;
12969 printf("Histedit of %s aborted\n",
12970 got_ref_get_symref_target(branch));
12971 print_merge_progress_stats(&upa);
12972 goto done; /* nothing else to do */
12973 } else if (abort_edit) {
12974 error = got_error(GOT_ERR_NOT_HISTEDIT);
12975 goto done;
12976 }
12977
12978 error = get_author(&committer, repo, worktree);
12979 if (error)
12980 goto done;
12981
12982 if (continue_edit) {
12983 char *path;
12984
12985 if (!edit_in_progress) {
12986 error = got_error(GOT_ERR_NOT_HISTEDIT);
12987 goto done;
12988 }
12989
12990 error = got_worktree_get_histedit_script_path(&path, worktree);
12991 if (error)
12992 goto done;
12993
12994 error = histedit_load_list(&histedit_cmds, path, repo);
12995 free(path);
12996 if (error)
12997 goto done;
12998
12999 error = got_worktree_histedit_continue(&resume_commit_id,
13000 &tmp_branch, &branch, &base_commit_id, &fileindex,
13001 worktree, repo);
13002 if (error)
13003 goto done;
13004
13005 error = got_ref_resolve(&head_commit_id, repo, branch);
13006 if (error)
13007 goto done;
13008
13009 error = got_object_open_as_commit(&commit, repo,
13010 head_commit_id);
13011 if (error)
13012 goto done;
13013 parent_ids = got_object_commit_get_parent_ids(commit);
13014 pid = STAILQ_FIRST(parent_ids);
13015 if (pid == NULL) {
13016 error = got_error(GOT_ERR_EMPTY_HISTEDIT);
13017 goto done;
13018 }
13019 error = collect_commits(&commits, head_commit_id, &pid->id,
13020 base_commit_id, got_worktree_get_path_prefix(worktree),
13021 GOT_ERR_HISTEDIT_PATH, repo);
13022 got_object_commit_close(commit);
13023 commit = NULL;
13024 if (error)
13025 goto done;
13026 } else {
13027 if (edit_in_progress) {
13028 error = got_error(GOT_ERR_HISTEDIT_BUSY);
13029 goto done;
13030 }
13031
13032 error = got_ref_open(&branch, repo,
13033 got_worktree_get_head_ref_name(worktree), 0);
13034 if (error != NULL)
13035 goto done;
13036
13037 if (strncmp(got_ref_get_name(branch), "refs/heads/", 11) != 0) {
13038 error = got_error_msg(GOT_ERR_COMMIT_BRANCH,
13039 "will not edit commit history of a branch outside "
13040 "the \"refs/heads/\" reference namespace");
13041 goto done;
13042 }
13043
13044 error = got_ref_resolve(&head_commit_id, repo, branch);
13045 got_ref_close(branch);
13046 branch = NULL;
13047 if (error)
13048 goto done;
13049
13050 error = got_object_open_as_commit(&commit, repo,
13051 head_commit_id);
13052 if (error)
13053 goto done;
13054 parent_ids = got_object_commit_get_parent_ids(commit);
13055 pid = STAILQ_FIRST(parent_ids);
13056 if (pid == NULL) {
13057 error = got_error(GOT_ERR_EMPTY_HISTEDIT);
13058 goto done;
13059 }
13060 error = collect_commits(&commits, head_commit_id, &pid->id,
13061 got_worktree_get_base_commit_id(worktree),
13062 got_worktree_get_path_prefix(worktree),
13063 GOT_ERR_HISTEDIT_PATH, repo);
13064 got_object_commit_close(commit);
13065 commit = NULL;
13066 if (error)
13067 goto done;
13068
13069 if (STAILQ_EMPTY(&commits)) {
13070 error = got_error(GOT_ERR_EMPTY_HISTEDIT);
13071 goto done;
13072 }
13073
13074 error = got_worktree_histedit_prepare(&tmp_branch, &branch,
13075 &base_commit_id, &fileindex, worktree, repo);
13076 if (error)
13077 goto done;
13078
13079 if (edit_script_path) {
13080 error = histedit_load_list(&histedit_cmds,
13081 edit_script_path, repo);
13082 if (error) {
13083 got_worktree_histedit_abort(worktree, fileindex,
13084 repo, branch, base_commit_id,
13085 abort_progress, &upa);
13086 print_merge_progress_stats(&upa);
13087 goto done;
13088 }
13089 } else {
13090 const char *branch_name;
13091 branch_name = got_ref_get_symref_target(branch);
13092 if (strncmp(branch_name, "refs/heads/", 11) == 0)
13093 branch_name += 11;
13094 error = histedit_edit_script(&histedit_cmds, &commits,
13095 branch_name, edit_logmsg_only, fold_only,
13096 drop_only, edit_only, editor, repo);
13097 if (error) {
13098 got_worktree_histedit_abort(worktree, fileindex,
13099 repo, branch, base_commit_id,
13100 abort_progress, &upa);
13101 print_merge_progress_stats(&upa);
13102 goto done;
13103 }
13104
13105 }
13106
13107 error = histedit_save_list(&histedit_cmds, worktree,
13108 repo);
13109 if (error) {
13110 got_worktree_histedit_abort(worktree, fileindex,
13111 repo, branch, base_commit_id,
13112 abort_progress, &upa);
13113 print_merge_progress_stats(&upa);
13114 goto done;
13115 }
13116
13117 }
13118
13119 error = histedit_check_script(&histedit_cmds, &commits, repo);
13120 if (error)
13121 goto done;
13122
13123 TAILQ_FOREACH(hle, &histedit_cmds, entry) {
13124 if (resume_commit_id) {
13125 if (got_object_id_cmp(hle->commit_id,
13126 resume_commit_id) != 0)
13127 continue;
13128
13129 resume_commit_id = NULL;
13130 if (hle->cmd->code == GOT_HISTEDIT_DROP ||
13131 hle->cmd->code == GOT_HISTEDIT_FOLD) {
13132 error = histedit_skip_commit(hle, worktree,
13133 repo);
13134 if (error)
13135 goto done;
13136 } else {
13137 struct got_pathlist_head paths;
13138 int have_changes = 0;
13139
13140 TAILQ_INIT(&paths);
13141 error = got_pathlist_append(&paths, "", NULL);
13142 if (error)
13143 goto done;
13144 error = got_worktree_status(worktree, &paths,
13145 repo, 0, check_local_changes, &have_changes,
13146 check_cancelled, NULL);
13147 got_pathlist_free(&paths,
13148 GOT_PATHLIST_FREE_NONE);
13149 if (error) {
13150 if (error->code != GOT_ERR_CANCELLED)
13151 goto done;
13152 if (sigint_received || sigpipe_received)
13153 goto done;
13154 }
13155 if (have_changes) {
13156 error = histedit_commit(NULL, worktree,
13157 fileindex, tmp_branch, hle,
13158 committer, allow_conflict, editor,
13159 repo);
13160 if (error)
13161 goto done;
13162 } else {
13163 error = got_object_open_as_commit(
13164 &commit, repo, hle->commit_id);
13165 if (error)
13166 goto done;
13167 error = show_histedit_progress(commit,
13168 hle, NULL);
13169 got_object_commit_close(commit);
13170 commit = NULL;
13171 if (error)
13172 goto done;
13173 }
13174 }
13175 continue;
13176 }
13177
13178 if (hle->cmd->code == GOT_HISTEDIT_DROP) {
13179 error = histedit_skip_commit(hle, worktree, repo);
13180 if (error)
13181 goto done;
13182 continue;
13183 }
13184 error = got_object_open_as_commit(&commit, repo,
13185 hle->commit_id);
13186 if (error)
13187 goto done;
13188 parent_ids = got_object_commit_get_parent_ids(commit);
13189 pid = STAILQ_FIRST(parent_ids);
13190
13191 error = got_worktree_histedit_merge_files(&merged_paths,
13192 worktree, fileindex, &pid->id, hle->commit_id, repo,
13193 update_progress, &upa, check_cancelled, NULL);
13194 if (error)
13195 goto done;
13196 got_object_commit_close(commit);
13197 commit = NULL;
13198
13199 print_merge_progress_stats(&upa);
13200 if (upa.conflicts > 0 || upa.missing > 0 ||
13201 upa.not_deleted > 0 || upa.unversioned > 0) {
13202 if (upa.conflicts > 0) {
13203 error = show_rebase_merge_conflict(
13204 hle->commit_id, repo);
13205 if (error)
13206 goto done;
13207 }
13208 got_pathlist_free(&merged_paths, GOT_PATHLIST_FREE_PATH);
13209 break;
13210 }
13211
13212 if (hle->cmd->code == GOT_HISTEDIT_EDIT) {
13213 char *id_str;
13214 error = got_object_id_str(&id_str, hle->commit_id);
13215 if (error)
13216 goto done;
13217 printf("Stopping histedit for amending commit %s\n",
13218 id_str);
13219 free(id_str);
13220 got_pathlist_free(&merged_paths, GOT_PATHLIST_FREE_PATH);
13221 error = got_worktree_histedit_postpone(worktree,
13222 fileindex);
13223 goto done;
13224 } else if (hle->cmd->code == GOT_HISTEDIT_FOLD) {
13225 error = histedit_skip_commit(hle, worktree, repo);
13226 if (error)
13227 goto done;
13228 continue;
13229 } else if (hle->cmd->code == GOT_HISTEDIT_MESG) {
13230 error = histedit_edit_logmsg(hle, editor, repo);
13231 if (error)
13232 goto done;
13233 }
13234
13235 error = histedit_commit(&merged_paths, worktree, fileindex,
13236 tmp_branch, hle, committer, allow_conflict, editor, repo);
13237 got_pathlist_free(&merged_paths, GOT_PATHLIST_FREE_PATH);
13238 if (error)
13239 goto done;
13240 }
13241
13242 if (upa.conflicts > 0 || upa.missing > 0 ||
13243 upa.not_deleted > 0 || upa.unversioned > 0) {
13244 error = got_worktree_histedit_postpone(worktree, fileindex);
13245 if (error)
13246 goto done;
13247 if (upa.conflicts > 0 && upa.missing == 0 &&
13248 upa.not_deleted == 0 && upa.unversioned == 0) {
13249 error = got_error_msg(GOT_ERR_CONFLICTS,
13250 "conflicts must be resolved before histedit "
13251 "can continue");
13252 } else if (upa.conflicts > 0) {
13253 error = got_error_msg(GOT_ERR_CONFLICTS,
13254 "conflicts must be resolved before histedit "
13255 "can continue; changes destined for some "
13256 "files were not yet merged and should be "
13257 "merged manually if required before the "
13258 "histedit operation is continued");
13259 } else {
13260 error = got_error_msg(GOT_ERR_CONFLICTS,
13261 "changes destined for some files were not "
13262 "yet merged and should be merged manually "
13263 "if required before the histedit operation "
13264 "is continued");
13265 }
13266 } else
13267 error = histedit_complete(worktree, fileindex, tmp_branch,
13268 branch, repo);
13269 done:
13270 free(cwd);
13271 free(editor);
13272 free(committer);
13273 free(gitconfig_path);
13274 got_object_id_queue_free(&commits);
13275 histedit_free_list(&histedit_cmds);
13276 free(head_commit_id);
13277 free(base_commit_id);
13278 free(resume_commit_id);
13279 if (commit)
13280 got_object_commit_close(commit);
13281 if (branch)
13282 got_ref_close(branch);
13283 if (tmp_branch)
13284 got_ref_close(tmp_branch);
13285 if (worktree)
13286 got_worktree_close(worktree);
13287 if (repo) {
13288 const struct got_error *close_err = got_repo_close(repo);
13289 if (error == NULL)
13290 error = close_err;
13291 }
13292 if (pack_fds) {
13293 const struct got_error *pack_err =
13294 got_repo_pack_fds_close(pack_fds);
13295 if (error == NULL)
13296 error = pack_err;
13297 }
13298 return error;
13299 }
13300
13301 __dead static void
13302 usage_integrate(void)
13303 {
13304 fprintf(stderr, "usage: %s integrate branch\n", getprogname());
13305 exit(1);
13306 }
13307
13308 static const struct got_error *
13309 cmd_integrate(int argc, char *argv[])
13310 {
13311 const struct got_error *error = NULL;
13312 struct got_repository *repo = NULL;
13313 struct got_worktree *worktree = NULL;
13314 char *cwd = NULL, *refname = NULL, *base_refname = NULL;
13315 const char *branch_arg = NULL;
13316 struct got_reference *branch_ref = NULL, *base_branch_ref = NULL;
13317 struct got_fileindex *fileindex = NULL;
13318 struct got_object_id *commit_id = NULL, *base_commit_id = NULL;
13319 int ch;
13320 struct got_update_progress_arg upa;
13321 int *pack_fds = NULL;
13322
13323 #ifndef PROFILE
13324 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
13325 "unveil", NULL) == -1)
13326 err(1, "pledge");
13327 #endif
13328
13329 while ((ch = getopt(argc, argv, "")) != -1) {
13330 switch (ch) {
13331 default:
13332 usage_integrate();
13333 /* NOTREACHED */
13334 }
13335 }
13336
13337 argc -= optind;
13338 argv += optind;
13339
13340 if (argc != 1)
13341 usage_integrate();
13342 branch_arg = argv[0];
13343
13344 cwd = getcwd(NULL, 0);
13345 if (cwd == NULL) {
13346 error = got_error_from_errno("getcwd");
13347 goto done;
13348 }
13349
13350 error = got_repo_pack_fds_open(&pack_fds);
13351 if (error != NULL)
13352 goto done;
13353
13354 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
13355 if (error) {
13356 if (error->code == GOT_ERR_NOT_WORKTREE)
13357 error = wrap_not_worktree_error(error, "integrate",
13358 cwd);
13359 goto done;
13360 }
13361
13362 error = check_rebase_or_histedit_in_progress(worktree);
13363 if (error)
13364 goto done;
13365
13366 error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
13367 NULL, pack_fds);
13368 if (error != NULL)
13369 goto done;
13370
13371 error = apply_unveil(got_repo_get_path(repo), 0,
13372 got_worktree_get_root_path(worktree));
13373 if (error)
13374 goto done;
13375
13376 error = check_merge_in_progress(worktree, repo);
13377 if (error)
13378 goto done;
13379
13380 if (asprintf(&refname, "refs/heads/%s", branch_arg) == -1) {
13381 error = got_error_from_errno("asprintf");
13382 goto done;
13383 }
13384
13385 error = got_worktree_integrate_prepare(&fileindex, &branch_ref,
13386 &base_branch_ref, worktree, refname, repo);
13387 if (error)
13388 goto done;
13389
13390 refname = strdup(got_ref_get_name(branch_ref));
13391 if (refname == NULL) {
13392 error = got_error_from_errno("strdup");
13393 got_worktree_integrate_abort(worktree, fileindex, repo,
13394 branch_ref, base_branch_ref);
13395 goto done;
13396 }
13397 base_refname = strdup(got_ref_get_name(base_branch_ref));
13398 if (base_refname == NULL) {
13399 error = got_error_from_errno("strdup");
13400 got_worktree_integrate_abort(worktree, fileindex, repo,
13401 branch_ref, base_branch_ref);
13402 goto done;
13403 }
13404 if (strncmp(base_refname, "refs/heads/", 11) != 0) {
13405 error = got_error(GOT_ERR_INTEGRATE_BRANCH);
13406 got_worktree_integrate_abort(worktree, fileindex, repo,
13407 branch_ref, base_branch_ref);
13408 goto done;
13409 }
13410
13411 error = got_ref_resolve(&commit_id, repo, branch_ref);
13412 if (error)
13413 goto done;
13414
13415 error = got_ref_resolve(&base_commit_id, repo, base_branch_ref);
13416 if (error)
13417 goto done;
13418
13419 if (got_object_id_cmp(commit_id, base_commit_id) == 0) {
13420 error = got_error_msg(GOT_ERR_SAME_BRANCH,
13421 "specified branch has already been integrated");
13422 got_worktree_integrate_abort(worktree, fileindex, repo,
13423 branch_ref, base_branch_ref);
13424 goto done;
13425 }
13426
13427 error = check_linear_ancestry(commit_id, base_commit_id, 1, repo);
13428 if (error) {
13429 if (error->code == GOT_ERR_ANCESTRY)
13430 error = got_error(GOT_ERR_REBASE_REQUIRED);
13431 got_worktree_integrate_abort(worktree, fileindex, repo,
13432 branch_ref, base_branch_ref);
13433 goto done;
13434 }
13435
13436 memset(&upa, 0, sizeof(upa));
13437 error = got_worktree_integrate_continue(worktree, fileindex, repo,
13438 branch_ref, base_branch_ref, update_progress, &upa,
13439 check_cancelled, NULL);
13440 if (error)
13441 goto done;
13442
13443 printf("Integrated %s into %s\n", refname, base_refname);
13444 print_update_progress_stats(&upa);
13445 done:
13446 if (repo) {
13447 const struct got_error *close_err = got_repo_close(repo);
13448 if (error == NULL)
13449 error = close_err;
13450 }
13451 if (worktree)
13452 got_worktree_close(worktree);
13453 if (pack_fds) {
13454 const struct got_error *pack_err =
13455 got_repo_pack_fds_close(pack_fds);
13456 if (error == NULL)
13457 error = pack_err;
13458 }
13459 free(cwd);
13460 free(base_commit_id);
13461 free(commit_id);
13462 free(refname);
13463 free(base_refname);
13464 return error;
13465 }
13466
13467 __dead static void
13468 usage_merge(void)
13469 {
13470 fprintf(stderr, "usage: %s merge [-aCcn] [branch]\n", getprogname());
13471 exit(1);
13472 }
13473
13474 static const struct got_error *
13475 cmd_merge(int argc, char *argv[])
13476 {
13477 const struct got_error *error = NULL;
13478 struct got_worktree *worktree = NULL;
13479 struct got_repository *repo = NULL;
13480 struct got_fileindex *fileindex = NULL;
13481 char *cwd = NULL, *id_str = NULL, *author = NULL;
13482 char *gitconfig_path = NULL;
13483 struct got_reference *branch = NULL, *wt_branch = NULL;
13484 struct got_object_id *branch_tip = NULL, *yca_id = NULL;
13485 struct got_object_id *wt_branch_tip = NULL;
13486 int ch, merge_in_progress = 0, abort_merge = 0, continue_merge = 0;
13487 int allow_conflict = 0, prefer_fast_forward = 1, interrupt_merge = 0;
13488 struct got_update_progress_arg upa;
13489 struct got_object_id *merge_commit_id = NULL;
13490 char *branch_name = NULL;
13491 int *pack_fds = NULL;
13492
13493 memset(&upa, 0, sizeof(upa));
13494
13495 #ifndef PROFILE
13496 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
13497 "unveil", NULL) == -1)
13498 err(1, "pledge");
13499 #endif
13500
13501 while ((ch = getopt(argc, argv, "aCcMn")) != -1) {
13502 switch (ch) {
13503 case 'a':
13504 abort_merge = 1;
13505 break;
13506 case 'C':
13507 allow_conflict = 1;
13508 break;
13509 case 'c':
13510 continue_merge = 1;
13511 break;
13512 case 'M':
13513 prefer_fast_forward = 0;
13514 break;
13515 case 'n':
13516 interrupt_merge = 1;
13517 break;
13518 default:
13519 usage_merge();
13520 /* NOTREACHED */
13521 }
13522 }
13523
13524 argc -= optind;
13525 argv += optind;
13526
13527 if (abort_merge) {
13528 if (continue_merge)
13529 option_conflict('a', 'c');
13530 if (!prefer_fast_forward)
13531 option_conflict('a', 'M');
13532 if (interrupt_merge)
13533 option_conflict('a', 'n');
13534 } else if (continue_merge) {
13535 if (!prefer_fast_forward)
13536 option_conflict('c', 'M');
13537 if (interrupt_merge)
13538 option_conflict('c', 'n');
13539 }
13540 if (allow_conflict) {
13541 if (!continue_merge)
13542 errx(1, "-C option requires -c");
13543 }
13544 if (abort_merge || continue_merge) {
13545 if (argc != 0)
13546 usage_merge();
13547 } else if (argc != 1)
13548 usage_merge();
13549
13550 cwd = getcwd(NULL, 0);
13551 if (cwd == NULL) {
13552 error = got_error_from_errno("getcwd");
13553 goto done;
13554 }
13555
13556 error = got_repo_pack_fds_open(&pack_fds);
13557 if (error != NULL)
13558 goto done;
13559
13560 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
13561 if (error) {
13562 if (error->code == GOT_ERR_NOT_WORKTREE)
13563 error = wrap_not_worktree_error(error,
13564 "merge", cwd);
13565 goto done;
13566 }
13567
13568 error = get_gitconfig_path(&gitconfig_path);
13569 if (error)
13570 goto done;
13571 error = got_repo_open(&repo,
13572 worktree ? got_worktree_get_repo_path(worktree) : cwd,
13573 gitconfig_path, pack_fds);
13574 if (error != NULL)
13575 goto done;
13576
13577 if (worktree != NULL) {
13578 error = worktree_has_logmsg_ref("merge", worktree, repo);
13579 if (error)
13580 goto done;
13581 }
13582
13583 error = apply_unveil(got_repo_get_path(repo), 0,
13584 worktree ? got_worktree_get_root_path(worktree) : NULL);
13585 if (error)
13586 goto done;
13587
13588 error = check_rebase_or_histedit_in_progress(worktree);
13589 if (error)
13590 goto done;
13591
13592 error = got_worktree_merge_in_progress(&merge_in_progress, worktree,
13593 repo);
13594 if (error)
13595 goto done;
13596
13597 if (merge_in_progress && !(abort_merge || continue_merge)) {
13598 error = got_error(GOT_ERR_MERGE_BUSY);
13599 goto done;
13600 }
13601
13602 if (!merge_in_progress && (abort_merge || continue_merge)) {
13603 error = got_error(GOT_ERR_NOT_MERGING);
13604 goto done;
13605 }
13606
13607 if (abort_merge) {
13608 error = got_worktree_merge_continue(&branch_name,
13609 &branch_tip, &fileindex, worktree, repo);
13610 if (error)
13611 goto done;
13612 error = got_worktree_merge_abort(worktree, fileindex, repo,
13613 abort_progress, &upa);
13614 if (error)
13615 goto done;
13616 printf("Merge of %s aborted\n", branch_name);
13617 goto done; /* nothing else to do */
13618 }
13619
13620 if (strncmp(got_worktree_get_head_ref_name(worktree),
13621 "refs/heads/", 11) != 0) {
13622 error = got_error_fmt(GOT_ERR_COMMIT_BRANCH,
13623 "work tree's current branch %s is outside the "
13624 "\"refs/heads/\" reference namespace; "
13625 "update -b required",
13626 got_worktree_get_head_ref_name(worktree));
13627 goto done;
13628 }
13629
13630 error = get_author(&author, repo, worktree);
13631 if (error)
13632 goto done;
13633
13634 error = got_ref_open(&wt_branch, repo,
13635 got_worktree_get_head_ref_name(worktree), 0);
13636 if (error)
13637 goto done;
13638 error = got_ref_resolve(&wt_branch_tip, repo, wt_branch);
13639 if (error)
13640 goto done;
13641
13642 if (continue_merge) {
13643 struct got_object_id *base_commit_id;
13644 base_commit_id = got_worktree_get_base_commit_id(worktree);
13645 if (got_object_id_cmp(wt_branch_tip, base_commit_id) != 0) {
13646 error = got_error(GOT_ERR_MERGE_COMMIT_OUT_OF_DATE);
13647 goto done;
13648 }
13649 error = got_worktree_merge_continue(&branch_name,
13650 &branch_tip, &fileindex, worktree, repo);
13651 if (error)
13652 goto done;
13653 } else {
13654 error = got_ref_open(&branch, repo, argv[0], 0);
13655 if (error != NULL)
13656 goto done;
13657 branch_name = strdup(got_ref_get_name(branch));
13658 if (branch_name == NULL) {
13659 error = got_error_from_errno("strdup");
13660 goto done;
13661 }
13662 error = got_ref_resolve(&branch_tip, repo, branch);
13663 if (error)
13664 goto done;
13665 }
13666
13667 error = got_commit_graph_find_youngest_common_ancestor(&yca_id,
13668 wt_branch_tip, branch_tip, 0, 0, repo,
13669 check_cancelled, NULL);
13670 if (error && error->code != GOT_ERR_ANCESTRY)
13671 goto done;
13672
13673 if (!continue_merge) {
13674 error = check_path_prefix(wt_branch_tip, branch_tip,
13675 got_worktree_get_path_prefix(worktree),
13676 GOT_ERR_MERGE_PATH, repo);
13677 if (error)
13678 goto done;
13679 error = got_worktree_merge_prepare(&fileindex, worktree, repo);
13680 if (error)
13681 goto done;
13682 if (prefer_fast_forward && yca_id &&
13683 got_object_id_cmp(wt_branch_tip, yca_id) == 0) {
13684 struct got_pathlist_head paths;
13685 if (interrupt_merge) {
13686 error = got_error_fmt(GOT_ERR_BAD_OPTION,
13687 "there are no changes to merge since %s "
13688 "is already based on %s; merge cannot be "
13689 "interrupted for amending; -n",
13690 branch_name, got_ref_get_name(wt_branch));
13691 goto done;
13692 }
13693 printf("Forwarding %s to %s\n",
13694 got_ref_get_name(wt_branch), branch_name);
13695 error = got_ref_change_ref(wt_branch, branch_tip);
13696 if (error)
13697 goto done;
13698 error = got_ref_write(wt_branch, repo);
13699 if (error)
13700 goto done;
13701 error = got_worktree_set_base_commit_id(worktree, repo,
13702 branch_tip);
13703 if (error)
13704 goto done;
13705 TAILQ_INIT(&paths);
13706 error = got_pathlist_append(&paths, "", NULL);
13707 if (error)
13708 goto done;
13709 error = got_worktree_checkout_files(worktree,
13710 &paths, repo, update_progress, &upa,
13711 check_cancelled, NULL);
13712 got_pathlist_free(&paths, GOT_PATHLIST_FREE_NONE);
13713 if (error)
13714 goto done;
13715 if (upa.did_something) {
13716 char *id_str;
13717 error = got_object_id_str(&id_str, branch_tip);
13718 if (error)
13719 goto done;
13720 printf("Updated to commit %s\n", id_str);
13721 free(id_str);
13722 } else
13723 printf("Already up-to-date\n");
13724 print_update_progress_stats(&upa);
13725 goto done;
13726 }
13727 error = got_worktree_merge_write_refs(worktree, branch, repo);
13728 if (error)
13729 goto done;
13730
13731 error = got_worktree_merge_branch(worktree, fileindex,
13732 yca_id, branch_tip, repo, update_progress, &upa,
13733 check_cancelled, NULL);
13734 if (error)
13735 goto done;
13736 print_merge_progress_stats(&upa);
13737 if (!upa.did_something) {
13738 error = got_worktree_merge_abort(worktree, fileindex,
13739 repo, abort_progress, &upa);
13740 if (error)
13741 goto done;
13742 printf("Already up-to-date\n");
13743 goto done;
13744 }
13745 }
13746
13747 if (interrupt_merge) {
13748 error = got_worktree_merge_postpone(worktree, fileindex);
13749 if (error)
13750 goto done;
13751 printf("Merge of %s interrupted on request\n", branch_name);
13752 } else if (upa.conflicts > 0 || upa.missing > 0 ||
13753 upa.not_deleted > 0 || upa.unversioned > 0) {
13754 error = got_worktree_merge_postpone(worktree, fileindex);
13755 if (error)
13756 goto done;
13757 if (upa.conflicts > 0 && upa.missing == 0 &&
13758 upa.not_deleted == 0 && upa.unversioned == 0) {
13759 error = got_error_msg(GOT_ERR_CONFLICTS,
13760 "conflicts must be resolved before merging "
13761 "can continue");
13762 } else if (upa.conflicts > 0) {
13763 error = got_error_msg(GOT_ERR_CONFLICTS,
13764 "conflicts must be resolved before merging "
13765 "can continue; changes destined for some "
13766 "files were not yet merged and "
13767 "should be merged manually if required before the "
13768 "merge operation is continued");
13769 } else {
13770 error = got_error_msg(GOT_ERR_CONFLICTS,
13771 "changes destined for some "
13772 "files were not yet merged and should be "
13773 "merged manually if required before the "
13774 "merge operation is continued");
13775 }
13776 goto done;
13777 } else {
13778 error = got_worktree_merge_commit(&merge_commit_id, worktree,
13779 fileindex, author, NULL, 1, branch_tip, branch_name,
13780 allow_conflict, repo, continue_merge ? print_status : NULL,
13781 NULL);
13782 if (error)
13783 goto done;
13784 error = got_worktree_merge_complete(worktree, fileindex, repo);
13785 if (error)
13786 goto done;
13787 error = got_object_id_str(&id_str, merge_commit_id);
13788 if (error)
13789 goto done;
13790 printf("Merged %s into %s: %s\n", branch_name,
13791 got_worktree_get_head_ref_name(worktree),
13792 id_str);
13793
13794 }
13795 done:
13796 free(gitconfig_path);
13797 free(id_str);
13798 free(merge_commit_id);
13799 free(author);
13800 free(branch_tip);
13801 free(branch_name);
13802 free(yca_id);
13803 if (branch)
13804 got_ref_close(branch);
13805 if (wt_branch)
13806 got_ref_close(wt_branch);
13807 if (worktree)
13808 got_worktree_close(worktree);
13809 if (repo) {
13810 const struct got_error *close_err = got_repo_close(repo);
13811 if (error == NULL)
13812 error = close_err;
13813 }
13814 if (pack_fds) {
13815 const struct got_error *pack_err =
13816 got_repo_pack_fds_close(pack_fds);
13817 if (error == NULL)
13818 error = pack_err;
13819 }
13820 return error;
13821 }
13822
13823 __dead static void
13824 usage_stage(void)
13825 {
13826 fprintf(stderr, "usage: %s stage [-lpS] [-F response-script] "
13827 "[path ...]\n", getprogname());
13828 exit(1);
13829 }
13830
13831 static const struct got_error *
13832 print_stage(void *arg, unsigned char status, unsigned char staged_status,
13833 const char *path, struct got_object_id *blob_id,
13834 struct got_object_id *staged_blob_id, struct got_object_id *commit_id,
13835 int dirfd, const char *de_name)
13836 {
13837 const struct got_error *err = NULL;
13838 char *id_str = NULL;
13839
13840 if (staged_status != GOT_STATUS_ADD &&
13841 staged_status != GOT_STATUS_MODIFY &&
13842 staged_status != GOT_STATUS_DELETE)
13843 return NULL;
13844
13845 if (staged_status == GOT_STATUS_ADD ||
13846 staged_status == GOT_STATUS_MODIFY)
13847 err = got_object_id_str(&id_str, staged_blob_id);
13848 else
13849 err = got_object_id_str(&id_str, blob_id);
13850 if (err)
13851 return err;
13852
13853 printf("%s %c %s\n", id_str, staged_status, path);
13854 free(id_str);
13855 return NULL;
13856 }
13857
13858 static const struct got_error *
13859 cmd_stage(int argc, char *argv[])
13860 {
13861 const struct got_error *error = NULL;
13862 struct got_repository *repo = NULL;
13863 struct got_worktree *worktree = NULL;
13864 char *cwd = NULL;
13865 struct got_pathlist_head paths;
13866 int ch, list_stage = 0, pflag = 0, allow_bad_symlinks = 0;
13867 FILE *patch_script_file = NULL;
13868 const char *patch_script_path = NULL;
13869 struct choose_patch_arg cpa;
13870 int *pack_fds = NULL;
13871
13872 TAILQ_INIT(&paths);
13873
13874 #ifndef PROFILE
13875 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
13876 "unveil", NULL) == -1)
13877 err(1, "pledge");
13878 #endif
13879
13880 while ((ch = getopt(argc, argv, "F:lpS")) != -1) {
13881 switch (ch) {
13882 case 'F':
13883 patch_script_path = optarg;
13884 break;
13885 case 'l':
13886 list_stage = 1;
13887 break;
13888 case 'p':
13889 pflag = 1;
13890 break;
13891 case 'S':
13892 allow_bad_symlinks = 1;
13893 break;
13894 default:
13895 usage_stage();
13896 /* NOTREACHED */
13897 }
13898 }
13899
13900 argc -= optind;
13901 argv += optind;
13902
13903 if (list_stage && (pflag || patch_script_path))
13904 errx(1, "-l option cannot be used with other options");
13905 if (patch_script_path && !pflag)
13906 errx(1, "-F option can only be used together with -p option");
13907
13908 cwd = getcwd(NULL, 0);
13909 if (cwd == NULL) {
13910 error = got_error_from_errno("getcwd");
13911 goto done;
13912 }
13913
13914 error = got_repo_pack_fds_open(&pack_fds);
13915 if (error != NULL)
13916 goto done;
13917
13918 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
13919 if (error) {
13920 if (error->code == GOT_ERR_NOT_WORKTREE)
13921 error = wrap_not_worktree_error(error, "stage", cwd);
13922 goto done;
13923 }
13924
13925 error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
13926 NULL, pack_fds);
13927 if (error != NULL)
13928 goto done;
13929
13930 if (patch_script_path) {
13931 patch_script_file = fopen(patch_script_path, "re");
13932 if (patch_script_file == NULL) {
13933 error = got_error_from_errno2("fopen",
13934 patch_script_path);
13935 goto done;
13936 }
13937 }
13938 error = apply_unveil(got_repo_get_path(repo), 0,
13939 got_worktree_get_root_path(worktree));
13940 if (error)
13941 goto done;
13942
13943 error = check_merge_in_progress(worktree, repo);
13944 if (error)
13945 goto done;
13946
13947 error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
13948 if (error)
13949 goto done;
13950
13951 if (list_stage)
13952 error = got_worktree_status(worktree, &paths, repo, 0,
13953 print_stage, NULL, check_cancelled, NULL);
13954 else {
13955 cpa.patch_script_file = patch_script_file;
13956 cpa.action = "stage";
13957 error = got_worktree_stage(worktree, &paths,
13958 pflag ? NULL : print_status, NULL,
13959 pflag ? choose_patch : NULL, &cpa,
13960 allow_bad_symlinks, repo);
13961 }
13962 done:
13963 if (patch_script_file && fclose(patch_script_file) == EOF &&
13964 error == NULL)
13965 error = got_error_from_errno2("fclose", patch_script_path);
13966 if (repo) {
13967 const struct got_error *close_err = got_repo_close(repo);
13968 if (error == NULL)
13969 error = close_err;
13970 }
13971 if (worktree)
13972 got_worktree_close(worktree);
13973 if (pack_fds) {
13974 const struct got_error *pack_err =
13975 got_repo_pack_fds_close(pack_fds);
13976 if (error == NULL)
13977 error = pack_err;
13978 }
13979 got_pathlist_free(&paths, GOT_PATHLIST_FREE_PATH);
13980 free(cwd);
13981 return error;
13982 }
13983
13984 __dead static void
13985 usage_unstage(void)
13986 {
13987 fprintf(stderr, "usage: %s unstage [-p] [-F response-script] "
13988 "[path ...]\n", getprogname());
13989 exit(1);
13990 }
13991
13992
13993 static const struct got_error *
13994 cmd_unstage(int argc, char *argv[])
13995 {
13996 const struct got_error *error = NULL;
13997 struct got_repository *repo = NULL;
13998 struct got_worktree *worktree = NULL;
13999 char *cwd = NULL;
14000 struct got_pathlist_head paths;
14001 int ch, pflag = 0;
14002 struct got_update_progress_arg upa;
14003 FILE *patch_script_file = NULL;
14004 const char *patch_script_path = NULL;
14005 struct choose_patch_arg cpa;
14006 int *pack_fds = NULL;
14007
14008 TAILQ_INIT(&paths);
14009
14010 #ifndef PROFILE
14011 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
14012 "unveil", NULL) == -1)
14013 err(1, "pledge");
14014 #endif
14015
14016 while ((ch = getopt(argc, argv, "F:p")) != -1) {
14017 switch (ch) {
14018 case 'F':
14019 patch_script_path = optarg;
14020 break;
14021 case 'p':
14022 pflag = 1;
14023 break;
14024 default:
14025 usage_unstage();
14026 /* NOTREACHED */
14027 }
14028 }
14029
14030 argc -= optind;
14031 argv += optind;
14032
14033 if (patch_script_path && !pflag)
14034 errx(1, "-F option can only be used together with -p option");
14035
14036 cwd = getcwd(NULL, 0);
14037 if (cwd == NULL) {
14038 error = got_error_from_errno("getcwd");
14039 goto done;
14040 }
14041
14042 error = got_repo_pack_fds_open(&pack_fds);
14043 if (error != NULL)
14044 goto done;
14045
14046 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
14047 if (error) {
14048 if (error->code == GOT_ERR_NOT_WORKTREE)
14049 error = wrap_not_worktree_error(error, "unstage", cwd);
14050 goto done;
14051 }
14052
14053 error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
14054 NULL, pack_fds);
14055 if (error != NULL)
14056 goto done;
14057
14058 if (patch_script_path) {
14059 patch_script_file = fopen(patch_script_path, "re");
14060 if (patch_script_file == NULL) {
14061 error = got_error_from_errno2("fopen",
14062 patch_script_path);
14063 goto done;
14064 }
14065 }
14066
14067 error = apply_unveil(got_repo_get_path(repo), 0,
14068 got_worktree_get_root_path(worktree));
14069 if (error)
14070 goto done;
14071
14072 error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
14073 if (error)
14074 goto done;
14075
14076 cpa.patch_script_file = patch_script_file;
14077 cpa.action = "unstage";
14078 memset(&upa, 0, sizeof(upa));
14079 error = got_worktree_unstage(worktree, &paths, update_progress,
14080 &upa, pflag ? choose_patch : NULL, &cpa, repo);
14081 if (!error)
14082 print_merge_progress_stats(&upa);
14083 done:
14084 if (patch_script_file && fclose(patch_script_file) == EOF &&
14085 error == NULL)
14086 error = got_error_from_errno2("fclose", patch_script_path);
14087 if (repo) {
14088 const struct got_error *close_err = got_repo_close(repo);
14089 if (error == NULL)
14090 error = close_err;
14091 }
14092 if (worktree)
14093 got_worktree_close(worktree);
14094 if (pack_fds) {
14095 const struct got_error *pack_err =
14096 got_repo_pack_fds_close(pack_fds);
14097 if (error == NULL)
14098 error = pack_err;
14099 }
14100 got_pathlist_free(&paths, GOT_PATHLIST_FREE_PATH);
14101 free(cwd);
14102 return error;
14103 }
14104
14105 __dead static void
14106 usage_cat(void)
14107 {
14108 fprintf(stderr, "usage: %s cat [-P] [-c commit] [-r repository-path] "
14109 "arg ...\n", getprogname());
14110 exit(1);
14111 }
14112
14113 static const struct got_error *
14114 cat_blob(struct got_object_id *id, struct got_repository *repo, FILE *outfile)
14115 {
14116 const struct got_error *err;
14117 struct got_blob_object *blob;
14118 int fd = -1;
14119
14120 fd = got_opentempfd();
14121 if (fd == -1)
14122 return got_error_from_errno("got_opentempfd");
14123
14124 err = got_object_open_as_blob(&blob, repo, id, 8192, fd);
14125 if (err)
14126 goto done;
14127
14128 err = got_object_blob_dump_to_file(NULL, NULL, NULL, outfile, blob);
14129 done:
14130 if (fd != -1 && close(fd) == -1 && err == NULL)
14131 err = got_error_from_errno("close");
14132 if (blob)
14133 got_object_blob_close(blob);
14134 return err;
14135 }
14136
14137 static const struct got_error *
14138 cat_tree(struct got_object_id *id, struct got_repository *repo, FILE *outfile)
14139 {
14140 const struct got_error *err;
14141 struct got_tree_object *tree;
14142 int nentries, i;
14143
14144 err = got_object_open_as_tree(&tree, repo, id);
14145 if (err)
14146 return err;
14147
14148 nentries = got_object_tree_get_nentries(tree);
14149 for (i = 0; i < nentries; i++) {
14150 struct got_tree_entry *te;
14151 char *id_str;
14152 if (sigint_received || sigpipe_received)
14153 break;
14154 te = got_object_tree_get_entry(tree, i);
14155 err = got_object_id_str(&id_str, got_tree_entry_get_id(te));
14156 if (err)
14157 break;
14158 fprintf(outfile, "%s %.7o %s\n", id_str,
14159 got_tree_entry_get_mode(te),
14160 got_tree_entry_get_name(te));
14161 free(id_str);
14162 }
14163
14164 got_object_tree_close(tree);
14165 return err;
14166 }
14167
14168 static const struct got_error *
14169 cat_commit(struct got_object_id *id, struct got_repository *repo, FILE *outfile)
14170 {
14171 const struct got_error *err;
14172 struct got_commit_object *commit;
14173 const struct got_object_id_queue *parent_ids;
14174 struct got_object_qid *pid;
14175 char *id_str = NULL;
14176 const char *logmsg = NULL;
14177 char gmtoff[6];
14178
14179 err = got_object_open_as_commit(&commit, repo, id);
14180 if (err)
14181 return err;
14182
14183 err = got_object_id_str(&id_str, got_object_commit_get_tree_id(commit));
14184 if (err)
14185 goto done;
14186
14187 fprintf(outfile, "%s%s\n", GOT_COMMIT_LABEL_TREE, id_str);
14188 parent_ids = got_object_commit_get_parent_ids(commit);
14189 fprintf(outfile, "numparents %d\n",
14190 got_object_commit_get_nparents(commit));
14191 STAILQ_FOREACH(pid, parent_ids, entry) {
14192 char *pid_str;
14193 err = got_object_id_str(&pid_str, &pid->id);
14194 if (err)
14195 goto done;
14196 fprintf(outfile, "%s%s\n", GOT_COMMIT_LABEL_PARENT, pid_str);
14197 free(pid_str);
14198 }
14199 got_date_format_gmtoff(gmtoff, sizeof(gmtoff),
14200 got_object_commit_get_author_gmtoff(commit));
14201 fprintf(outfile, "%s%s %lld %s\n", GOT_COMMIT_LABEL_AUTHOR,
14202 got_object_commit_get_author(commit),
14203 (long long)got_object_commit_get_author_time(commit),
14204 gmtoff);
14205
14206 got_date_format_gmtoff(gmtoff, sizeof(gmtoff),
14207 got_object_commit_get_committer_gmtoff(commit));
14208 fprintf(outfile, "%s%s %lld %s\n", GOT_COMMIT_LABEL_COMMITTER,
14209 got_object_commit_get_committer(commit),
14210 (long long)got_object_commit_get_committer_time(commit),
14211 gmtoff);
14212
14213 logmsg = got_object_commit_get_logmsg_raw(commit);
14214 fprintf(outfile, "messagelen %zd\n", strlen(logmsg));
14215 fprintf(outfile, "%s", logmsg);
14216 done:
14217 free(id_str);
14218 got_object_commit_close(commit);
14219 return err;
14220 }
14221
14222 static const struct got_error *
14223 cat_tag(struct got_object_id *id, struct got_repository *repo, FILE *outfile)
14224 {
14225 const struct got_error *err;
14226 struct got_tag_object *tag;
14227 char *id_str = NULL;
14228 const char *tagmsg = NULL;
14229 char gmtoff[6];
14230
14231 err = got_object_open_as_tag(&tag, repo, id);
14232 if (err)
14233 return err;
14234
14235 err = got_object_id_str(&id_str, got_object_tag_get_object_id(tag));
14236 if (err)
14237 goto done;
14238
14239 fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_OBJECT, id_str);
14240
14241 switch (got_object_tag_get_object_type(tag)) {
14242 case GOT_OBJ_TYPE_BLOB:
14243 fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_TYPE,
14244 GOT_OBJ_LABEL_BLOB);
14245 break;
14246 case GOT_OBJ_TYPE_TREE:
14247 fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_TYPE,
14248 GOT_OBJ_LABEL_TREE);
14249 break;
14250 case GOT_OBJ_TYPE_COMMIT:
14251 fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_TYPE,
14252 GOT_OBJ_LABEL_COMMIT);
14253 break;
14254 case GOT_OBJ_TYPE_TAG:
14255 fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_TYPE,
14256 GOT_OBJ_LABEL_TAG);
14257 break;
14258 default:
14259 break;
14260 }
14261
14262 fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_TAG,
14263 got_object_tag_get_name(tag));
14264
14265 got_date_format_gmtoff(gmtoff, sizeof(gmtoff),
14266 got_object_tag_get_tagger_gmtoff(tag));
14267 fprintf(outfile, "%s%s %lld %s\n", GOT_TAG_LABEL_TAGGER,
14268 got_object_tag_get_tagger(tag),
14269 (long long)got_object_tag_get_tagger_time(tag),
14270 gmtoff);
14271
14272 tagmsg = got_object_tag_get_message(tag);
14273 fprintf(outfile, "messagelen %zd\n", strlen(tagmsg));
14274 fprintf(outfile, "%s", tagmsg);
14275 done:
14276 free(id_str);
14277 got_object_tag_close(tag);
14278 return err;
14279 }
14280
14281 static const struct got_error *
14282 cmd_cat(int argc, char *argv[])
14283 {
14284 const struct got_error *error;
14285 struct got_repository *repo = NULL;
14286 struct got_worktree *worktree = NULL;
14287 char *cwd = NULL, *repo_path = NULL, *label = NULL;
14288 char *keyword_idstr = NULL;
14289 const char *commit_id_str = NULL;
14290 struct got_object_id *id = NULL, *commit_id = NULL;
14291 struct got_commit_object *commit = NULL;
14292 int ch, obj_type, i, force_path = 0;
14293 struct got_reflist_head refs;
14294 int *pack_fds = NULL;
14295
14296 TAILQ_INIT(&refs);
14297
14298 #ifndef PROFILE
14299 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
14300 NULL) == -1)
14301 err(1, "pledge");
14302 #endif
14303
14304 while ((ch = getopt(argc, argv, "c:Pr:")) != -1) {
14305 switch (ch) {
14306 case 'c':
14307 commit_id_str = optarg;
14308 break;
14309 case 'P':
14310 force_path = 1;
14311 break;
14312 case 'r':
14313 repo_path = realpath(optarg, NULL);
14314 if (repo_path == NULL)
14315 return got_error_from_errno2("realpath",
14316 optarg);
14317 got_path_strip_trailing_slashes(repo_path);
14318 break;
14319 default:
14320 usage_cat();
14321 /* NOTREACHED */
14322 }
14323 }
14324
14325 argc -= optind;
14326 argv += optind;
14327
14328 cwd = getcwd(NULL, 0);
14329 if (cwd == NULL) {
14330 error = got_error_from_errno("getcwd");
14331 goto done;
14332 }
14333
14334 error = got_repo_pack_fds_open(&pack_fds);
14335 if (error != NULL)
14336 goto done;
14337
14338 if (repo_path == NULL) {
14339 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
14340 if (error && error->code != GOT_ERR_NOT_WORKTREE)
14341 goto done;
14342 if (worktree) {
14343 repo_path = strdup(
14344 got_worktree_get_repo_path(worktree));
14345 if (repo_path == NULL) {
14346 error = got_error_from_errno("strdup");
14347 goto done;
14348 }
14349
14350 if (commit_id_str == NULL) {
14351 /* Release work tree lock. */
14352 got_worktree_close(worktree);
14353 worktree = NULL;
14354 }
14355 }
14356 }
14357
14358 if (repo_path == NULL) {
14359 repo_path = strdup(cwd);
14360 if (repo_path == NULL)
14361 return got_error_from_errno("strdup");
14362 }
14363
14364 error = got_repo_open(&repo, repo_path, NULL, pack_fds);
14365 free(repo_path);
14366 if (error != NULL)
14367 goto done;
14368
14369 error = apply_unveil(got_repo_get_path(repo), 1, NULL);
14370 if (error)
14371 goto done;
14372
14373 error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
14374 if (error)
14375 goto done;
14376
14377 if (commit_id_str != NULL) {
14378 error = got_keyword_to_idstr(&keyword_idstr, commit_id_str,
14379 repo, worktree);
14380 if (error != NULL)
14381 goto done;
14382 if (keyword_idstr != NULL)
14383 commit_id_str = keyword_idstr;
14384 if (worktree != NULL) {
14385 got_worktree_close(worktree);
14386 worktree = NULL;
14387 }
14388 } else
14389 commit_id_str = GOT_REF_HEAD;
14390 error = got_repo_match_object_id(&commit_id, NULL,
14391 commit_id_str, GOT_OBJ_TYPE_COMMIT, &refs, repo);
14392 if (error)
14393 goto done;
14394
14395 error = got_object_open_as_commit(&commit, repo, commit_id);
14396 if (error)
14397 goto done;
14398
14399 for (i = 0; i < argc; i++) {
14400 if (force_path) {
14401 error = got_object_id_by_path(&id, repo, commit,
14402 argv[i]);
14403 if (error)
14404 break;
14405 } else {
14406 error = got_repo_match_object_id(&id, &label, argv[i],
14407 GOT_OBJ_TYPE_ANY, NULL /* do not resolve tags */,
14408 repo);
14409 if (error) {
14410 if (error->code != GOT_ERR_BAD_OBJ_ID_STR &&
14411 error->code != GOT_ERR_NOT_REF)
14412 break;
14413 error = got_object_id_by_path(&id, repo,
14414 commit, argv[i]);
14415 if (error)
14416 break;
14417 }
14418 }
14419
14420 error = got_object_get_type(&obj_type, repo, id);
14421 if (error)
14422 break;
14423
14424 switch (obj_type) {
14425 case GOT_OBJ_TYPE_BLOB:
14426 error = cat_blob(id, repo, stdout);
14427 break;
14428 case GOT_OBJ_TYPE_TREE:
14429 error = cat_tree(id, repo, stdout);
14430 break;
14431 case GOT_OBJ_TYPE_COMMIT:
14432 error = cat_commit(id, repo, stdout);
14433 break;
14434 case GOT_OBJ_TYPE_TAG:
14435 error = cat_tag(id, repo, stdout);
14436 break;
14437 default:
14438 error = got_error(GOT_ERR_OBJ_TYPE);
14439 break;
14440 }
14441 if (error)
14442 break;
14443 free(label);
14444 label = NULL;
14445 free(id);
14446 id = NULL;
14447 }
14448 done:
14449 free(label);
14450 free(id);
14451 free(commit_id);
14452 free(keyword_idstr);
14453 if (commit)
14454 got_object_commit_close(commit);
14455 if (worktree)
14456 got_worktree_close(worktree);
14457 if (repo) {
14458 const struct got_error *close_err = got_repo_close(repo);
14459 if (error == NULL)
14460 error = close_err;
14461 }
14462 if (pack_fds) {
14463 const struct got_error *pack_err =
14464 got_repo_pack_fds_close(pack_fds);
14465 if (error == NULL)
14466 error = pack_err;
14467 }
14468
14469 got_ref_list_free(&refs);
14470 return error;
14471 }
14472
14473 __dead static void
14474 usage_info(void)
14475 {
14476 fprintf(stderr, "usage: %s info [path ...]\n",
14477 getprogname());
14478 exit(1);
14479 }
14480
14481 static const struct got_error *
14482 print_path_info(void *arg, const char *path, mode_t mode, time_t mtime,
14483 struct got_object_id *blob_id, struct got_object_id *staged_blob_id,
14484 struct got_object_id *commit_id)
14485 {
14486 const struct got_error *err = NULL;
14487 char *id_str = NULL;
14488 char datebuf[128];
14489 struct tm mytm, *tm;
14490 struct got_pathlist_head *paths = arg;
14491 struct got_pathlist_entry *pe;
14492
14493 /*
14494 * Clear error indication from any of the path arguments which
14495 * would cause this file index entry to be displayed.
14496 */
14497 TAILQ_FOREACH(pe, paths, entry) {
14498 if (got_path_cmp(path, pe->path, strlen(path),
14499 pe->path_len) == 0 ||
14500 got_path_is_child(path, pe->path, pe->path_len))
14501 pe->data = NULL; /* no error */
14502 }
14503
14504 printf(GOT_COMMIT_SEP_STR);
14505 if (S_ISLNK(mode))
14506 printf("symlink: %s\n", path);
14507 else if (S_ISREG(mode)) {
14508 printf("file: %s\n", path);
14509 printf("mode: %o\n", mode & (S_IRWXU | S_IRWXG | S_IRWXO));
14510 } else if (S_ISDIR(mode))
14511 printf("directory: %s\n", path);
14512 else
14513 printf("something: %s\n", path);
14514
14515 tm = localtime_r(&mtime, &mytm);
14516 if (tm == NULL)
14517 return NULL;
14518 if (strftime(datebuf, sizeof(datebuf), "%c %Z", tm) == 0)
14519 return got_error(GOT_ERR_NO_SPACE);
14520 printf("timestamp: %s\n", datebuf);
14521
14522 if (blob_id) {
14523 err = got_object_id_str(&id_str, blob_id);
14524 if (err)
14525 return err;
14526 printf("based on blob: %s\n", id_str);
14527 free(id_str);
14528 }
14529
14530 if (staged_blob_id) {
14531 err = got_object_id_str(&id_str, staged_blob_id);
14532 if (err)
14533 return err;
14534 printf("based on staged blob: %s\n", id_str);
14535 free(id_str);
14536 }
14537
14538 if (commit_id) {
14539 err = got_object_id_str(&id_str, commit_id);
14540 if (err)
14541 return err;
14542 printf("based on commit: %s\n", id_str);
14543 free(id_str);
14544 }
14545
14546 return NULL;
14547 }
14548
14549 static const struct got_error *
14550 cmd_info(int argc, char *argv[])
14551 {
14552 const struct got_error *error = NULL;
14553 struct got_worktree *worktree = NULL;
14554 char *cwd = NULL, *id_str = NULL;
14555 struct got_pathlist_head paths;
14556 char *uuidstr = NULL;
14557 int ch, show_files = 0;
14558
14559 TAILQ_INIT(&paths);
14560
14561 #ifndef PROFILE
14562 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
14563 NULL) == -1)
14564 err(1, "pledge");
14565 #endif
14566
14567 while ((ch = getopt(argc, argv, "")) != -1) {
14568 switch (ch) {
14569 default:
14570 usage_info();
14571 /* NOTREACHED */
14572 }
14573 }
14574
14575 argc -= optind;
14576 argv += optind;
14577
14578 cwd = getcwd(NULL, 0);
14579 if (cwd == NULL) {
14580 error = got_error_from_errno("getcwd");
14581 goto done;
14582 }
14583
14584 error = got_worktree_open(&worktree, cwd, GOT_WORKTREE_GOT_DIR);
14585 if (error) {
14586 if (error->code == GOT_ERR_NOT_WORKTREE)
14587 error = wrap_not_worktree_error(error, "info", cwd);
14588 goto done;
14589 }
14590
14591 #ifndef PROFILE
14592 /* Remove "wpath cpath proc exec sendfd" promises. */
14593 if (pledge("stdio rpath flock unveil", NULL) == -1)
14594 err(1, "pledge");
14595 #endif
14596 error = apply_unveil(NULL, 0, got_worktree_get_root_path(worktree));
14597 if (error)
14598 goto done;
14599
14600 if (argc >= 1) {
14601 error = get_worktree_paths_from_argv(&paths, argc, argv,
14602 worktree);
14603 if (error)
14604 goto done;
14605 show_files = 1;
14606 }
14607
14608 error = got_object_id_str(&id_str,
14609 got_worktree_get_base_commit_id(worktree));
14610 if (error)
14611 goto done;
14612
14613 error = got_worktree_get_uuid(&uuidstr, worktree);
14614 if (error)
14615 goto done;
14616
14617 printf("work tree: %s\n", got_worktree_get_root_path(worktree));
14618 printf("work tree base commit: %s\n", id_str);
14619 printf("work tree path prefix: %s\n",
14620 got_worktree_get_path_prefix(worktree));
14621 printf("work tree branch reference: %s\n",
14622 got_worktree_get_head_ref_name(worktree));
14623 printf("work tree UUID: %s\n", uuidstr);
14624 printf("repository: %s\n", got_worktree_get_repo_path(worktree));
14625
14626 if (show_files) {
14627 struct got_pathlist_entry *pe;
14628 TAILQ_FOREACH(pe, &paths, entry) {
14629 if (pe->path_len == 0)
14630 continue;
14631 /*
14632 * Assume this path will fail. This will be corrected
14633 * in print_path_info() in case the path does suceeed.
14634 */
14635 pe->data = (void *)got_error(GOT_ERR_BAD_PATH);
14636 }
14637 error = got_worktree_path_info(worktree, &paths,
14638 print_path_info, &paths, check_cancelled, NULL);
14639 if (error)
14640 goto done;
14641 TAILQ_FOREACH(pe, &paths, entry) {
14642 if (pe->data != NULL) {
14643 const struct got_error *perr;
14644
14645 perr = pe->data;
14646 error = got_error_fmt(perr->code, "%s",
14647 pe->path);
14648 break;
14649 }
14650 }
14651 }
14652 done:
14653 if (worktree)
14654 got_worktree_close(worktree);
14655 got_pathlist_free(&paths, GOT_PATHLIST_FREE_PATH);
14656 free(cwd);
14657 free(id_str);
14658 free(uuidstr);
14659 return error;
14660 }
portable version of Game of Trees