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>
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.
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.
19 #include <sys/types.h>
40 #include "got_compat.h"
42 #include "got_version.h"
43 #include "got_error.h"
44 #include "got_object.h"
45 #include "got_reference.h"
46 #include "got_repository.h"
48 #include "got_cancel.h"
49 #include "got_worktree.h"
51 #include "got_commit_graph.h"
52 #include "got_fetch.h"
54 #include "got_blame.h"
55 #include "got_privsep.h"
56 #include "got_opentemp.h"
57 #include "got_gotconfig.h"
61 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
64 static volatile sig_atomic_t sigint_received
;
65 static volatile sig_atomic_t sigpipe_received
;
68 catch_sigint(int signo
)
74 catch_sigpipe(int signo
)
82 const struct got_error
*(*cmd_main
)(int, char *[]);
83 void (*cmd_usage
)(void);
84 const char *cmd_alias
;
87 __dead
static void usage(int, int);
88 __dead
static void usage_init(void);
89 __dead
static void usage_import(void);
90 __dead
static void usage_clone(void);
91 __dead
static void usage_fetch(void);
92 __dead
static void usage_checkout(void);
93 __dead
static void usage_update(void);
94 __dead
static void usage_log(void);
95 __dead
static void usage_diff(void);
96 __dead
static void usage_blame(void);
97 __dead
static void usage_tree(void);
98 __dead
static void usage_status(void);
99 __dead
static void usage_ref(void);
100 __dead
static void usage_branch(void);
101 __dead
static void usage_tag(void);
102 __dead
static void usage_add(void);
103 __dead
static void usage_remove(void);
104 __dead
static void usage_revert(void);
105 __dead
static void usage_commit(void);
106 __dead
static void usage_send(void);
107 __dead
static void usage_cherrypick(void);
108 __dead
static void usage_backout(void);
109 __dead
static void usage_rebase(void);
110 __dead
static void usage_histedit(void);
111 __dead
static void usage_integrate(void);
112 __dead
static void usage_merge(void);
113 __dead
static void usage_stage(void);
114 __dead
static void usage_unstage(void);
115 __dead
static void usage_cat(void);
116 __dead
static void usage_info(void);
118 static const struct got_error
* cmd_init(int, char *[]);
119 static const struct got_error
* cmd_import(int, char *[]);
120 static const struct got_error
* cmd_clone(int, char *[]);
121 static const struct got_error
* cmd_fetch(int, char *[]);
122 static const struct got_error
* cmd_checkout(int, char *[]);
123 static const struct got_error
* cmd_update(int, char *[]);
124 static const struct got_error
* cmd_log(int, char *[]);
125 static const struct got_error
* cmd_diff(int, char *[]);
126 static const struct got_error
* cmd_blame(int, char *[]);
127 static const struct got_error
* cmd_tree(int, char *[]);
128 static const struct got_error
* cmd_status(int, char *[]);
129 static const struct got_error
* cmd_ref(int, char *[]);
130 static const struct got_error
* cmd_branch(int, char *[]);
131 static const struct got_error
* cmd_tag(int, char *[]);
132 static const struct got_error
* cmd_add(int, char *[]);
133 static const struct got_error
* cmd_remove(int, char *[]);
134 static const struct got_error
* cmd_revert(int, char *[]);
135 static const struct got_error
* cmd_commit(int, char *[]);
136 static const struct got_error
* cmd_send(int, char *[]);
137 static const struct got_error
* cmd_cherrypick(int, char *[]);
138 static const struct got_error
* cmd_backout(int, char *[]);
139 static const struct got_error
* cmd_rebase(int, char *[]);
140 static const struct got_error
* cmd_histedit(int, char *[]);
141 static const struct got_error
* cmd_integrate(int, char *[]);
142 static const struct got_error
* cmd_merge(int, char *[]);
143 static const struct got_error
* cmd_stage(int, char *[]);
144 static const struct got_error
* cmd_unstage(int, char *[]);
145 static const struct got_error
* cmd_cat(int, char *[]);
146 static const struct got_error
* cmd_info(int, char *[]);
148 static struct got_cmd got_commands
[] = {
149 { "init", cmd_init
, usage_init
, "" },
150 { "import", cmd_import
, usage_import
, "im" },
151 { "clone", cmd_clone
, usage_clone
, "cl" },
152 { "fetch", cmd_fetch
, usage_fetch
, "fe" },
153 { "checkout", cmd_checkout
, usage_checkout
, "co" },
154 { "update", cmd_update
, usage_update
, "up" },
155 { "log", cmd_log
, usage_log
, "" },
156 { "diff", cmd_diff
, usage_diff
, "di" },
157 { "blame", cmd_blame
, usage_blame
, "bl" },
158 { "tree", cmd_tree
, usage_tree
, "tr" },
159 { "status", cmd_status
, usage_status
, "st" },
160 { "ref", cmd_ref
, usage_ref
, "" },
161 { "branch", cmd_branch
, usage_branch
, "br" },
162 { "tag", cmd_tag
, usage_tag
, "" },
163 { "add", cmd_add
, usage_add
, "" },
164 { "remove", cmd_remove
, usage_remove
, "rm" },
165 { "revert", cmd_revert
, usage_revert
, "rv" },
166 { "commit", cmd_commit
, usage_commit
, "ci" },
167 { "send", cmd_send
, usage_send
, "se" },
168 { "cherrypick", cmd_cherrypick
, usage_cherrypick
, "cy" },
169 { "backout", cmd_backout
, usage_backout
, "bo" },
170 { "rebase", cmd_rebase
, usage_rebase
, "rb" },
171 { "histedit", cmd_histedit
, usage_histedit
, "he" },
172 { "integrate", cmd_integrate
, usage_integrate
,"ig" },
173 { "merge", cmd_merge
, usage_merge
, "mg" },
174 { "stage", cmd_stage
, usage_stage
, "sg" },
175 { "unstage", cmd_unstage
, usage_unstage
, "ug" },
176 { "cat", cmd_cat
, usage_cat
, "" },
177 { "info", cmd_info
, usage_info
, "" },
181 list_commands(FILE *fp
)
185 fprintf(fp
, "commands:");
186 for (i
= 0; i
< nitems(got_commands
); i
++) {
187 struct got_cmd
*cmd
= &got_commands
[i
];
188 fprintf(fp
, " %s", cmd
->cmd_name
);
194 option_conflict(char a
, char b
)
196 errx(1, "-%c and -%c options are mutually exclusive", a
, b
);
200 main(int argc
, char *argv
[])
205 int hflag
= 0, Vflag
= 0;
206 static struct option longopts
[] = {
207 { "version", no_argument
, NULL
, 'V' },
211 setlocale(LC_CTYPE
, "");
213 while ((ch
= getopt_long(argc
, argv
, "+hV", longopts
, NULL
)) != -1) {
233 got_version_print_str();
238 usage(hflag
, hflag
? 0 : 1);
240 signal(SIGINT
, catch_sigint
);
241 signal(SIGPIPE
, catch_sigpipe
);
243 for (i
= 0; i
< nitems(got_commands
); i
++) {
244 const struct got_error
*error
;
246 cmd
= &got_commands
[i
];
248 if (strcmp(cmd
->cmd_name
, argv
[0]) != 0 &&
249 strcmp(cmd
->cmd_alias
, argv
[0]) != 0)
253 got_commands
[i
].cmd_usage();
255 error
= got_commands
[i
].cmd_main(argc
, argv
);
256 if (error
&& error
->code
!= GOT_ERR_CANCELLED
&&
257 error
->code
!= GOT_ERR_PRIVSEP_EXIT
&&
258 !(sigpipe_received
&&
259 error
->code
== GOT_ERR_ERRNO
&& errno
== EPIPE
) &&
261 error
->code
== GOT_ERR_ERRNO
&& errno
== EINTR
)) {
262 fprintf(stderr
, "%s: %s\n", getprogname(), error
->msg
);
269 fprintf(stderr
, "%s: unknown command '%s'\n", getprogname(), argv
[0]);
270 list_commands(stderr
);
275 usage(int hflag
, int status
)
277 FILE *fp
= (status
== 0) ? stdout
: stderr
;
279 fprintf(fp
, "usage: %s [-h] [-V | --version] command [arg ...]\n",
286 static const struct got_error
*
287 get_editor(char **abspath
)
289 const struct got_error
*err
= NULL
;
294 editor
= getenv("VISUAL");
296 editor
= getenv("EDITOR");
299 err
= got_path_find_prog(abspath
, editor
);
304 if (*abspath
== NULL
) {
305 *abspath
= strdup("/bin/ed");
306 if (*abspath
== NULL
)
307 return got_error_from_errno("strdup");
313 static const struct got_error
*
314 apply_unveil(const char *repo_path
, int repo_read_only
,
315 const char *worktree_path
)
317 const struct got_error
*err
;
320 if (unveil("gmon.out", "rwc") != 0)
321 return got_error_from_errno2("unveil", "gmon.out");
323 if (repo_path
&& unveil(repo_path
, repo_read_only
? "r" : "rwc") != 0)
324 return got_error_from_errno2("unveil", repo_path
);
326 if (worktree_path
&& unveil(worktree_path
, "rwc") != 0)
327 return got_error_from_errno2("unveil", worktree_path
);
329 if (unveil(GOT_TMPDIR_STR
, "rwc") != 0)
330 return got_error_from_errno2("unveil", GOT_TMPDIR_STR
);
332 err
= got_privsep_unveil_exec_helpers();
336 if (unveil(NULL
, NULL
) != 0)
337 return got_error_from_errno("unveil");
345 fprintf(stderr
, "usage: %s init repository-path\n", getprogname());
349 static const struct got_error
*
350 cmd_init(int argc
, char *argv
[])
352 const struct got_error
*error
= NULL
;
353 char *repo_path
= NULL
;
356 while ((ch
= getopt(argc
, argv
, "")) != -1) {
368 if (pledge("stdio rpath wpath cpath unveil", NULL
) == -1)
374 repo_path
= strdup(argv
[0]);
375 if (repo_path
== NULL
)
376 return got_error_from_errno("strdup");
378 got_path_strip_trailing_slashes(repo_path
);
380 error
= got_path_mkdir(repo_path
);
382 !(error
->code
== GOT_ERR_ERRNO
&& errno
== EEXIST
))
385 error
= apply_unveil(repo_path
, 0, NULL
);
389 error
= got_repo_init(repo_path
);
398 fprintf(stderr
, "usage: %s import [-b branch] [-m message] "
399 "[-r repository-path] [-I pattern] path\n", getprogname());
404 spawn_editor(const char *editor
, const char *file
)
407 sig_t sighup
, sigint
, sigquit
;
410 sighup
= signal(SIGHUP
, SIG_IGN
);
411 sigint
= signal(SIGINT
, SIG_IGN
);
412 sigquit
= signal(SIGQUIT
, SIG_IGN
);
414 switch (pid
= fork()) {
418 execl(editor
, editor
, file
, (char *)NULL
);
422 while (waitpid(pid
, &st
, 0) == -1)
427 (void)signal(SIGHUP
, sighup
);
428 (void)signal(SIGINT
, sigint
);
429 (void)signal(SIGQUIT
, sigquit
);
431 if (!WIFEXITED(st
)) {
436 return WEXITSTATUS(st
);
439 static const struct got_error
*
440 edit_logmsg(char **logmsg
, const char *editor
, const char *logmsg_path
,
441 const char *initial_content
, size_t initial_content_len
,
442 int require_modification
)
444 const struct got_error
*err
= NULL
;
450 size_t len
, logmsg_len
;
451 char *initial_content_stripped
= NULL
, *buf
= NULL
, *s
;
455 if (stat(logmsg_path
, &st
) == -1)
456 return got_error_from_errno2("stat", logmsg_path
);
458 if (spawn_editor(editor
, logmsg_path
) == -1)
459 return got_error_from_errno("failed spawning editor");
461 if (stat(logmsg_path
, &st2
) == -1)
462 return got_error_from_errno("stat");
464 if (require_modification
&&
465 st
.st_mtime
== st2
.st_mtime
&& st
.st_size
== st2
.st_size
)
466 return got_error_msg(GOT_ERR_COMMIT_MSG_EMPTY
,
467 "no changes made to commit message, aborting");
470 * Set up a stripped version of the initial content without comments
471 * and blank lines. We need this in order to check if the message
472 * has in fact been edited.
474 initial_content_stripped
= malloc(initial_content_len
+ 1);
475 if (initial_content_stripped
== NULL
)
476 return got_error_from_errno("malloc");
477 initial_content_stripped
[0] = '\0';
479 buf
= strdup(initial_content
);
481 err
= got_error_from_errno("strdup");
486 while ((line
= strsep(&s
, "\n")) != NULL
) {
487 if ((line
[0] == '#' || (len
== 0 && line
[0] == '\n')))
488 continue; /* remove comments and leading empty lines */
489 len
= strlcat(initial_content_stripped
, line
,
490 initial_content_len
+ 1);
491 if (len
>= initial_content_len
+ 1) {
492 err
= got_error(GOT_ERR_NO_SPACE
);
496 while (len
> 0 && initial_content_stripped
[len
- 1] == '\n') {
497 initial_content_stripped
[len
- 1] = '\0';
501 logmsg_len
= st2
.st_size
;
502 *logmsg
= malloc(logmsg_len
+ 1);
504 return got_error_from_errno("malloc");
507 fp
= fopen(logmsg_path
, "r");
509 err
= got_error_from_errno("fopen");
514 while ((linelen
= getline(&line
, &linesize
, fp
)) != -1) {
515 if ((line
[0] == '#' || (len
== 0 && line
[0] == '\n')))
516 continue; /* remove comments and leading empty lines */
517 len
= strlcat(*logmsg
, line
, logmsg_len
+ 1);
518 if (len
>= logmsg_len
+ 1) {
519 err
= got_error(GOT_ERR_NO_SPACE
);
525 err
= got_ferror(fp
, GOT_ERR_IO
);
528 while (len
> 0 && (*logmsg
)[len
- 1] == '\n') {
529 (*logmsg
)[len
- 1] = '\0';
534 err
= got_error_msg(GOT_ERR_COMMIT_MSG_EMPTY
,
535 "commit message cannot be empty, aborting");
538 if (require_modification
&&
539 strcmp(*logmsg
, initial_content_stripped
) == 0)
540 err
= got_error_msg(GOT_ERR_COMMIT_MSG_EMPTY
,
541 "no changes made to commit message, aborting");
543 free(initial_content_stripped
);
545 if (fp
&& fclose(fp
) == EOF
&& err
== NULL
)
546 err
= got_error_from_errno("fclose");
554 static const struct got_error
*
555 collect_import_msg(char **logmsg
, char **logmsg_path
, const char *editor
,
556 const char *path_dir
, const char *branch_name
)
558 char *initial_content
= NULL
;
559 const struct got_error
*err
= NULL
;
560 int initial_content_len
;
563 initial_content_len
= asprintf(&initial_content
,
564 "\n# %s to be imported to branch %s\n", path_dir
,
566 if (initial_content_len
== -1)
567 return got_error_from_errno("asprintf");
569 err
= got_opentemp_named_fd(logmsg_path
, &fd
,
570 GOT_TMPDIR_STR
"/got-importmsg");
574 if (write(fd
, initial_content
, initial_content_len
) == -1) {
575 err
= got_error_from_errno2("write", *logmsg_path
);
579 err
= edit_logmsg(logmsg
, editor
, *logmsg_path
, initial_content
,
580 initial_content_len
, 1);
582 if (fd
!= -1 && close(fd
) == -1 && err
== NULL
)
583 err
= got_error_from_errno2("close", *logmsg_path
);
584 free(initial_content
);
592 static const struct got_error
*
593 import_progress(void *arg
, const char *path
)
595 printf("A %s\n", path
);
599 static const struct got_error
*
600 get_author(char **author
, struct got_repository
*repo
,
601 struct got_worktree
*worktree
)
603 const struct got_error
*err
= NULL
;
604 const char *got_author
= NULL
, *name
, *email
;
605 const struct got_gotconfig
*worktree_conf
= NULL
, *repo_conf
= NULL
;
610 worktree_conf
= got_worktree_get_gotconfig(worktree
);
611 repo_conf
= got_repo_get_gotconfig(repo
);
614 * Priority of potential author information sources, from most
615 * significant to least significant:
616 * 1) work tree's .got/got.conf file
617 * 2) repository's got.conf file
618 * 3) repository's git config file
619 * 4) environment variables
620 * 5) global git config files (in user's home directory or /etc)
624 got_author
= got_gotconfig_get_author(worktree_conf
);
625 if (got_author
== NULL
)
626 got_author
= got_gotconfig_get_author(repo_conf
);
627 if (got_author
== NULL
) {
628 name
= got_repo_get_gitconfig_author_name(repo
);
629 email
= got_repo_get_gitconfig_author_email(repo
);
631 if (asprintf(author
, "%s <%s>", name
, email
) == -1)
632 return got_error_from_errno("asprintf");
636 got_author
= getenv("GOT_AUTHOR");
637 if (got_author
== NULL
) {
638 name
= got_repo_get_global_gitconfig_author_name(repo
);
639 email
= got_repo_get_global_gitconfig_author_email(
642 if (asprintf(author
, "%s <%s>", name
, email
)
644 return got_error_from_errno("asprintf");
647 /* TODO: Look up user in password database? */
648 return got_error(GOT_ERR_COMMIT_NO_AUTHOR
);
652 *author
= strdup(got_author
);
654 return got_error_from_errno("strdup");
657 * Really dumb email address check; we're only doing this to
658 * avoid git's object parser breaking on commits we create.
660 while (*got_author
&& *got_author
!= '<')
662 if (*got_author
!= '<') {
663 err
= got_error(GOT_ERR_COMMIT_NO_EMAIL
);
666 while (*got_author
&& *got_author
!= '@')
668 if (*got_author
!= '@') {
669 err
= got_error(GOT_ERR_COMMIT_NO_EMAIL
);
672 while (*got_author
&& *got_author
!= '>')
674 if (*got_author
!= '>')
675 err
= got_error(GOT_ERR_COMMIT_NO_EMAIL
);
684 static const struct got_error
*
685 get_gitconfig_path(char **gitconfig_path
)
687 const char *homedir
= getenv("HOME");
689 *gitconfig_path
= NULL
;
691 if (asprintf(gitconfig_path
, "%s/.gitconfig", homedir
) == -1)
692 return got_error_from_errno("asprintf");
698 static const struct got_error
*
699 cmd_import(int argc
, char *argv
[])
701 const struct got_error
*error
= NULL
;
702 char *path_dir
= NULL
, *repo_path
= NULL
, *logmsg
= NULL
;
703 char *gitconfig_path
= NULL
, *editor
= NULL
, *author
= NULL
;
704 const char *branch_name
= "main";
705 char *refname
= NULL
, *id_str
= NULL
, *logmsg_path
= NULL
;
706 struct got_repository
*repo
= NULL
;
707 struct got_reference
*branch_ref
= NULL
, *head_ref
= NULL
;
708 struct got_object_id
*new_commit_id
= NULL
;
710 struct got_pathlist_head ignores
;
711 struct got_pathlist_entry
*pe
;
712 int preserve_logmsg
= 0;
714 TAILQ_INIT(&ignores
);
716 while ((ch
= getopt(argc
, argv
, "b:m:r:I:")) != -1) {
719 branch_name
= optarg
;
722 logmsg
= strdup(optarg
);
723 if (logmsg
== NULL
) {
724 error
= got_error_from_errno("strdup");
729 repo_path
= realpath(optarg
, NULL
);
730 if (repo_path
== NULL
) {
731 error
= got_error_from_errno2("realpath",
737 if (optarg
[0] == '\0')
739 error
= got_pathlist_insert(&pe
, &ignores
, optarg
,
754 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
762 if (repo_path
== NULL
) {
763 repo_path
= getcwd(NULL
, 0);
764 if (repo_path
== NULL
)
765 return got_error_from_errno("getcwd");
767 got_path_strip_trailing_slashes(repo_path
);
768 error
= get_gitconfig_path(&gitconfig_path
);
771 error
= got_repo_open(&repo
, repo_path
, gitconfig_path
);
775 error
= get_author(&author
, repo
, NULL
);
780 * Don't let the user create a branch name with a leading '-'.
781 * While technically a valid reference name, this case is usually
782 * an unintended typo.
784 if (branch_name
[0] == '-')
785 return got_error_path(branch_name
, GOT_ERR_REF_NAME_MINUS
);
787 if (asprintf(&refname
, "refs/heads/%s", branch_name
) == -1) {
788 error
= got_error_from_errno("asprintf");
792 error
= got_ref_open(&branch_ref
, repo
, refname
, 0);
794 if (error
->code
!= GOT_ERR_NOT_REF
)
797 error
= got_error_msg(GOT_ERR_BRANCH_EXISTS
,
798 "import target branch already exists");
802 path_dir
= realpath(argv
[0], NULL
);
803 if (path_dir
== NULL
) {
804 error
= got_error_from_errno2("realpath", argv
[0]);
807 got_path_strip_trailing_slashes(path_dir
);
810 * unveil(2) traverses exec(2); if an editor is used we have
811 * to apply unveil after the log message has been written.
813 if (logmsg
== NULL
|| strlen(logmsg
) == 0) {
814 error
= get_editor(&editor
);
818 error
= collect_import_msg(&logmsg
, &logmsg_path
, editor
,
821 if (error
->code
!= GOT_ERR_COMMIT_MSG_EMPTY
&&
828 if (unveil(path_dir
, "r") != 0) {
829 error
= got_error_from_errno2("unveil", path_dir
);
835 error
= apply_unveil(got_repo_get_path(repo
), 0, NULL
);
842 error
= got_repo_import(&new_commit_id
, path_dir
, logmsg
,
843 author
, &ignores
, repo
, import_progress
, NULL
);
850 error
= got_ref_alloc(&branch_ref
, refname
, new_commit_id
);
857 error
= got_ref_write(branch_ref
, repo
);
864 error
= got_object_id_str(&id_str
, new_commit_id
);
871 error
= got_ref_open(&head_ref
, repo
, GOT_REF_HEAD
, 0);
873 if (error
->code
!= GOT_ERR_NOT_REF
) {
879 error
= got_ref_alloc_symref(&head_ref
, GOT_REF_HEAD
,
887 error
= got_ref_write(head_ref
, repo
);
895 printf("Created branch %s with commit %s\n",
896 got_ref_get_name(branch_ref
), id_str
);
898 if (preserve_logmsg
) {
899 fprintf(stderr
, "%s: log message preserved in %s\n",
900 getprogname(), logmsg_path
);
901 } else if (logmsg_path
&& unlink(logmsg_path
) == -1 && error
== NULL
)
902 error
= got_error_from_errno2("unlink", logmsg_path
);
911 free(gitconfig_path
);
913 got_ref_close(branch_ref
);
915 got_ref_close(head_ref
);
922 fprintf(stderr
, "usage: %s clone [-a] [-b branch] [-l] [-m] [-q] [-v] "
923 "[-R reference] repository-url [directory]\n", getprogname());
927 struct got_fetch_progress_arg
{
928 char last_scaled_size
[FMT_SCALED_STRSIZE
];
933 struct got_repository
*repo
;
938 struct got_pathlist_head
*symrefs
;
939 struct got_pathlist_head
*wanted_branches
;
940 struct got_pathlist_head
*wanted_refs
;
944 const char *remote_repo_path
;
946 int fetch_all_branches
;
947 int mirror_references
;
951 /* XXX forward declaration */
952 static const struct got_error
*
953 create_config_files(const char *proto
, const char *host
, const char *port
,
954 const char *remote_repo_path
, const char *git_url
, int fetch_all_branches
,
955 int mirror_references
, struct got_pathlist_head
*symrefs
,
956 struct got_pathlist_head
*wanted_branches
,
957 struct got_pathlist_head
*wanted_refs
, struct got_repository
*repo
);
959 static const struct got_error
*
960 fetch_progress(void *arg
, const char *message
, off_t packfile_size
,
961 int nobj_total
, int nobj_indexed
, int nobj_loose
, int nobj_resolved
)
963 const struct got_error
*err
= NULL
;
964 struct got_fetch_progress_arg
*a
= arg
;
965 char scaled_size
[FMT_SCALED_STRSIZE
];
966 int p_indexed
, p_resolved
;
967 int print_size
= 0, print_indexed
= 0, print_resolved
= 0;
970 * In order to allow a failed clone to be resumed with 'got fetch'
971 * we try to create configuration files as soon as possible.
972 * Once the server has sent information about its default branch
973 * we have all required information.
975 if (a
->create_configs
&& !a
->configs_created
&&
976 !TAILQ_EMPTY(a
->config_info
.symrefs
)) {
977 err
= create_config_files(a
->config_info
.proto
,
978 a
->config_info
.host
, a
->config_info
.port
,
979 a
->config_info
.remote_repo_path
,
980 a
->config_info
.git_url
,
981 a
->config_info
.fetch_all_branches
,
982 a
->config_info
.mirror_references
,
983 a
->config_info
.symrefs
,
984 a
->config_info
.wanted_branches
,
985 a
->config_info
.wanted_refs
, a
->repo
);
988 a
->configs_created
= 1;
991 if (a
->verbosity
< 0)
994 if (message
&& message
[0] != '\0') {
995 printf("\rserver: %s", message
);
1000 if (packfile_size
> 0 || nobj_indexed
> 0) {
1001 if (fmt_scaled(packfile_size
, scaled_size
) == 0 &&
1002 (a
->last_scaled_size
[0] == '\0' ||
1003 strcmp(scaled_size
, a
->last_scaled_size
)) != 0) {
1005 if (strlcpy(a
->last_scaled_size
, scaled_size
,
1006 FMT_SCALED_STRSIZE
) >= FMT_SCALED_STRSIZE
)
1007 return got_error(GOT_ERR_NO_SPACE
);
1009 if (nobj_indexed
> 0) {
1010 p_indexed
= (nobj_indexed
* 100) / nobj_total
;
1011 if (p_indexed
!= a
->last_p_indexed
) {
1012 a
->last_p_indexed
= p_indexed
;
1017 if (nobj_resolved
> 0) {
1018 p_resolved
= (nobj_resolved
* 100) /
1019 (nobj_total
- nobj_loose
);
1020 if (p_resolved
!= a
->last_p_resolved
) {
1021 a
->last_p_resolved
= p_resolved
;
1029 if (print_size
|| print_indexed
|| print_resolved
)
1032 printf("%*s fetched", FMT_SCALED_STRSIZE
, scaled_size
);
1034 printf("; indexing %d%%", p_indexed
);
1036 printf("; resolving deltas %d%%", p_resolved
);
1037 if (print_size
|| print_indexed
|| print_resolved
)
1043 static const struct got_error
*
1044 create_symref(const char *refname
, struct got_reference
*target_ref
,
1045 int verbosity
, struct got_repository
*repo
)
1047 const struct got_error
*err
;
1048 struct got_reference
*head_symref
;
1050 err
= got_ref_alloc_symref(&head_symref
, refname
, target_ref
);
1054 err
= got_ref_write(head_symref
, repo
);
1055 if (err
== NULL
&& verbosity
> 0) {
1056 printf("Created reference %s: %s\n", GOT_REF_HEAD
,
1057 got_ref_get_name(target_ref
));
1059 got_ref_close(head_symref
);
1063 static const struct got_error
*
1064 list_remote_refs(struct got_pathlist_head
*symrefs
,
1065 struct got_pathlist_head
*refs
)
1067 const struct got_error
*err
;
1068 struct got_pathlist_entry
*pe
;
1070 TAILQ_FOREACH(pe
, symrefs
, entry
) {
1071 const char *refname
= pe
->path
;
1072 const char *targetref
= pe
->data
;
1074 printf("%s: %s\n", refname
, targetref
);
1077 TAILQ_FOREACH(pe
, refs
, entry
) {
1078 const char *refname
= pe
->path
;
1079 struct got_object_id
*id
= pe
->data
;
1082 err
= got_object_id_str(&id_str
, id
);
1085 printf("%s: %s\n", refname
, id_str
);
1092 static const struct got_error
*
1093 create_ref(const char *refname
, struct got_object_id
*id
,
1094 int verbosity
, struct got_repository
*repo
)
1096 const struct got_error
*err
= NULL
;
1097 struct got_reference
*ref
;
1100 err
= got_object_id_str(&id_str
, id
);
1104 err
= got_ref_alloc(&ref
, refname
, id
);
1108 err
= got_ref_write(ref
, repo
);
1111 if (err
== NULL
&& verbosity
>= 0)
1112 printf("Created reference %s: %s\n", refname
, id_str
);
1119 match_wanted_ref(const char *refname
, const char *wanted_ref
)
1121 if (strncmp(refname
, "refs/", 5) != 0)
1126 * Prevent fetching of references that won't make any
1127 * sense outside of the remote repository's context.
1129 if (strncmp(refname
, "got/", 4) == 0)
1131 if (strncmp(refname
, "remotes/", 8) == 0)
1134 if (strncmp(wanted_ref
, "refs/", 5) == 0)
1137 /* Allow prefix match. */
1138 if (got_path_is_child(refname
, wanted_ref
, strlen(wanted_ref
)))
1141 /* Allow exact match. */
1142 return (strcmp(refname
, wanted_ref
) == 0);
1146 is_wanted_ref(struct got_pathlist_head
*wanted_refs
, const char *refname
)
1148 struct got_pathlist_entry
*pe
;
1150 TAILQ_FOREACH(pe
, wanted_refs
, entry
) {
1151 if (match_wanted_ref(refname
, pe
->path
))
1158 static const struct got_error
*
1159 create_wanted_ref(const char *refname
, struct got_object_id
*id
,
1160 const char *remote_repo_name
, int verbosity
, struct got_repository
*repo
)
1162 const struct got_error
*err
;
1163 char *remote_refname
;
1165 if (strncmp("refs/", refname
, 5) == 0)
1168 if (asprintf(&remote_refname
, "refs/remotes/%s/%s",
1169 remote_repo_name
, refname
) == -1)
1170 return got_error_from_errno("asprintf");
1172 err
= create_ref(remote_refname
, id
, verbosity
, repo
);
1173 free(remote_refname
);
1177 static const struct got_error
*
1178 create_gotconfig(const char *proto
, const char *host
, const char *port
,
1179 const char *remote_repo_path
, const char *default_branch
,
1180 int fetch_all_branches
, struct got_pathlist_head
*wanted_branches
,
1181 struct got_pathlist_head
*wanted_refs
, int mirror_references
,
1182 struct got_repository
*repo
)
1184 const struct got_error
*err
= NULL
;
1185 char *gotconfig_path
= NULL
;
1186 char *gotconfig
= NULL
;
1187 FILE *gotconfig_file
= NULL
;
1188 const char *branchname
= NULL
;
1189 char *branches
= NULL
, *refs
= NULL
;
1192 if (!fetch_all_branches
&& !TAILQ_EMPTY(wanted_branches
)) {
1193 struct got_pathlist_entry
*pe
;
1194 TAILQ_FOREACH(pe
, wanted_branches
, entry
) {
1196 branchname
= pe
->path
;
1197 if (strncmp(branchname
, "refs/heads/", 11) == 0)
1199 if (asprintf(&s
, "%s\"%s\" ",
1200 branches
? branches
: "", branchname
) == -1) {
1201 err
= got_error_from_errno("asprintf");
1207 } else if (!fetch_all_branches
&& default_branch
) {
1208 branchname
= default_branch
;
1209 if (strncmp(branchname
, "refs/heads/", 11) == 0)
1211 if (asprintf(&branches
, "\"%s\" ", branchname
) == -1) {
1212 err
= got_error_from_errno("asprintf");
1216 if (!TAILQ_EMPTY(wanted_refs
)) {
1217 struct got_pathlist_entry
*pe
;
1218 TAILQ_FOREACH(pe
, wanted_refs
, entry
) {
1220 const char *refname
= pe
->path
;
1221 if (strncmp(refname
, "refs/", 5) == 0)
1223 if (asprintf(&s
, "%s\"%s\" ",
1224 refs
? refs
: "", refname
) == -1) {
1225 err
= got_error_from_errno("asprintf");
1233 /* Create got.conf(5). */
1234 gotconfig_path
= got_repo_get_path_gotconfig(repo
);
1235 if (gotconfig_path
== NULL
) {
1236 err
= got_error_from_errno("got_repo_get_path_gotconfig");
1239 gotconfig_file
= fopen(gotconfig_path
, "a");
1240 if (gotconfig_file
== NULL
) {
1241 err
= got_error_from_errno2("fopen", gotconfig_path
);
1244 if (asprintf(&gotconfig
,
1249 "\trepository \"%s\"\n"
1255 GOT_FETCH_DEFAULT_REMOTE_NAME
, host
, proto
,
1256 port
? "\tport " : "", port
? port
: "", port
? "\n" : "",
1257 remote_repo_path
, branches
? "\tbranch { " : "",
1258 branches
? branches
: "", branches
? "}\n" : "",
1259 refs
? "\treference { " : "", refs
? refs
: "", refs
? "}\n" : "",
1260 mirror_references
? "\tmirror-references yes\n" : "",
1261 fetch_all_branches
? "\tfetch-all-branches yes\n" : "") == -1) {
1262 err
= got_error_from_errno("asprintf");
1265 n
= fwrite(gotconfig
, 1, strlen(gotconfig
), gotconfig_file
);
1266 if (n
!= strlen(gotconfig
)) {
1267 err
= got_ferror(gotconfig_file
, GOT_ERR_IO
);
1272 if (gotconfig_file
&& fclose(gotconfig_file
) == EOF
&& err
== NULL
)
1273 err
= got_error_from_errno2("fclose", gotconfig_path
);
1274 free(gotconfig_path
);
1279 static const struct got_error
*
1280 create_gitconfig(const char *git_url
, const char *default_branch
,
1281 int fetch_all_branches
, struct got_pathlist_head
*wanted_branches
,
1282 struct got_pathlist_head
*wanted_refs
, int mirror_references
,
1283 struct got_repository
*repo
)
1285 const struct got_error
*err
= NULL
;
1286 char *gitconfig_path
= NULL
;
1287 char *gitconfig
= NULL
;
1288 FILE *gitconfig_file
= NULL
;
1289 char *branches
= NULL
, *refs
= NULL
;
1290 const char *branchname
;
1293 /* Create a config file Git can understand. */
1294 gitconfig_path
= got_repo_get_path_gitconfig(repo
);
1295 if (gitconfig_path
== NULL
) {
1296 err
= got_error_from_errno("got_repo_get_path_gitconfig");
1299 gitconfig_file
= fopen(gitconfig_path
, "a");
1300 if (gitconfig_file
== NULL
) {
1301 err
= got_error_from_errno2("fopen", gitconfig_path
);
1304 if (fetch_all_branches
) {
1305 if (mirror_references
) {
1306 if (asprintf(&branches
,
1307 "\tfetch = refs/heads/*:refs/heads/*\n") == -1) {
1308 err
= got_error_from_errno("asprintf");
1311 } else if (asprintf(&branches
,
1312 "\tfetch = refs/heads/*:refs/remotes/%s/*\n",
1313 GOT_FETCH_DEFAULT_REMOTE_NAME
) == -1) {
1314 err
= got_error_from_errno("asprintf");
1317 } else if (!TAILQ_EMPTY(wanted_branches
)) {
1318 struct got_pathlist_entry
*pe
;
1319 TAILQ_FOREACH(pe
, wanted_branches
, entry
) {
1321 branchname
= pe
->path
;
1322 if (strncmp(branchname
, "refs/heads/", 11) == 0)
1324 if (mirror_references
) {
1326 "%s\tfetch = refs/heads/%s:refs/heads/%s\n",
1327 branches
? branches
: "",
1328 branchname
, branchname
) == -1) {
1329 err
= got_error_from_errno("asprintf");
1332 } else if (asprintf(&s
,
1333 "%s\tfetch = refs/heads/%s:refs/remotes/%s/%s\n",
1334 branches
? branches
: "",
1335 branchname
, GOT_FETCH_DEFAULT_REMOTE_NAME
,
1336 branchname
) == -1) {
1337 err
= got_error_from_errno("asprintf");
1345 * If the server specified a default branch, use just that one.
1346 * Otherwise fall back to fetching all branches on next fetch.
1348 if (default_branch
) {
1349 branchname
= default_branch
;
1350 if (strncmp(branchname
, "refs/heads/", 11) == 0)
1353 branchname
= "*"; /* fall back to all branches */
1354 if (mirror_references
) {
1355 if (asprintf(&branches
,
1356 "\tfetch = refs/heads/%s:refs/heads/%s\n",
1357 branchname
, branchname
) == -1) {
1358 err
= got_error_from_errno("asprintf");
1361 } else if (asprintf(&branches
,
1362 "\tfetch = refs/heads/%s:refs/remotes/%s/%s\n",
1363 branchname
, GOT_FETCH_DEFAULT_REMOTE_NAME
,
1364 branchname
) == -1) {
1365 err
= got_error_from_errno("asprintf");
1369 if (!TAILQ_EMPTY(wanted_refs
)) {
1370 struct got_pathlist_entry
*pe
;
1371 TAILQ_FOREACH(pe
, wanted_refs
, entry
) {
1373 const char *refname
= pe
->path
;
1374 if (strncmp(refname
, "refs/", 5) == 0)
1376 if (mirror_references
) {
1378 "%s\tfetch = refs/%s:refs/%s\n",
1379 refs
? refs
: "", refname
, refname
) == -1) {
1380 err
= got_error_from_errno("asprintf");
1383 } else if (asprintf(&s
,
1384 "%s\tfetch = refs/%s:refs/remotes/%s/%s\n",
1386 refname
, GOT_FETCH_DEFAULT_REMOTE_NAME
,
1388 err
= got_error_from_errno("asprintf");
1396 if (asprintf(&gitconfig
,
1401 "\tfetch = refs/tags/*:refs/tags/*\n",
1402 GOT_FETCH_DEFAULT_REMOTE_NAME
, git_url
, branches
? branches
: "",
1403 refs
? refs
: "") == -1) {
1404 err
= got_error_from_errno("asprintf");
1407 n
= fwrite(gitconfig
, 1, strlen(gitconfig
), gitconfig_file
);
1408 if (n
!= strlen(gitconfig
)) {
1409 err
= got_ferror(gitconfig_file
, GOT_ERR_IO
);
1413 if (gitconfig_file
&& fclose(gitconfig_file
) == EOF
&& err
== NULL
)
1414 err
= got_error_from_errno2("fclose", gitconfig_path
);
1415 free(gitconfig_path
);
1420 static const struct got_error
*
1421 create_config_files(const char *proto
, const char *host
, const char *port
,
1422 const char *remote_repo_path
, const char *git_url
, int fetch_all_branches
,
1423 int mirror_references
, struct got_pathlist_head
*symrefs
,
1424 struct got_pathlist_head
*wanted_branches
,
1425 struct got_pathlist_head
*wanted_refs
, struct got_repository
*repo
)
1427 const struct got_error
*err
= NULL
;
1428 const char *default_branch
= NULL
;
1429 struct got_pathlist_entry
*pe
;
1432 * If we asked for a set of wanted branches then use the first
1435 if (!TAILQ_EMPTY(wanted_branches
)) {
1436 pe
= TAILQ_FIRST(wanted_branches
);
1437 default_branch
= pe
->path
;
1439 /* First HEAD ref listed by server is the default branch. */
1440 TAILQ_FOREACH(pe
, symrefs
, entry
) {
1441 const char *refname
= pe
->path
;
1442 const char *target
= pe
->data
;
1444 if (strcmp(refname
, GOT_REF_HEAD
) != 0)
1447 default_branch
= target
;
1452 /* Create got.conf(5). */
1453 err
= create_gotconfig(proto
, host
, port
, remote_repo_path
,
1454 default_branch
, fetch_all_branches
, wanted_branches
,
1455 wanted_refs
, mirror_references
, repo
);
1459 /* Create a config file Git can understand. */
1460 return create_gitconfig(git_url
, default_branch
, fetch_all_branches
,
1461 wanted_branches
, wanted_refs
, mirror_references
, repo
);
1464 static const struct got_error
*
1465 cmd_clone(int argc
, char *argv
[])
1467 const struct got_error
*error
= NULL
;
1468 const char *uri
, *dirname
;
1469 char *proto
, *host
, *port
, *repo_name
, *server_path
;
1470 char *default_destdir
= NULL
, *id_str
= NULL
;
1471 const char *repo_path
;
1472 struct got_repository
*repo
= NULL
;
1473 struct got_pathlist_head refs
, symrefs
, wanted_branches
, wanted_refs
;
1474 struct got_pathlist_entry
*pe
;
1475 struct got_object_id
*pack_hash
= NULL
;
1476 int ch
, fetchfd
= -1, fetchstatus
;
1477 pid_t fetchpid
= -1;
1478 struct got_fetch_progress_arg fpa
;
1479 char *git_url
= NULL
;
1480 int verbosity
= 0, fetch_all_branches
= 0, mirror_references
= 0;
1481 int list_refs_only
= 0;
1484 TAILQ_INIT(&symrefs
);
1485 TAILQ_INIT(&wanted_branches
);
1486 TAILQ_INIT(&wanted_refs
);
1488 while ((ch
= getopt(argc
, argv
, "ab:lmvqR:")) != -1) {
1491 fetch_all_branches
= 1;
1494 error
= got_pathlist_append(&wanted_branches
,
1503 mirror_references
= 1;
1508 else if (verbosity
< 3)
1515 error
= got_pathlist_append(&wanted_refs
,
1528 if (fetch_all_branches
&& !TAILQ_EMPTY(&wanted_branches
))
1529 option_conflict('a', 'b');
1530 if (list_refs_only
) {
1531 if (!TAILQ_EMPTY(&wanted_branches
))
1532 option_conflict('l', 'b');
1533 if (fetch_all_branches
)
1534 option_conflict('l', 'a');
1535 if (mirror_references
)
1536 option_conflict('l', 'm');
1537 if (!TAILQ_EMPTY(&wanted_refs
))
1538 option_conflict('l', 'R');
1550 error
= got_dial_parse_uri(&proto
, &host
, &port
, &server_path
,
1555 if (asprintf(&git_url
, "%s://%s%s%s%s%s", proto
,
1556 host
, port
? ":" : "", port
? port
: "",
1557 server_path
[0] != '/' ? "/" : "", server_path
) == -1) {
1558 error
= got_error_from_errno("asprintf");
1562 if (strcmp(proto
, "git") == 0) {
1564 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
1565 "sendfd dns inet unveil", NULL
) == -1)
1568 } else if (strcmp(proto
, "git+ssh") == 0 ||
1569 strcmp(proto
, "ssh") == 0) {
1571 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
1572 "sendfd unveil", NULL
) == -1)
1575 } else if (strcmp(proto
, "http") == 0 ||
1576 strcmp(proto
, "git+http") == 0) {
1577 error
= got_error_path(proto
, GOT_ERR_NOT_IMPL
);
1580 error
= got_error_path(proto
, GOT_ERR_BAD_PROTO
);
1583 if (dirname
== NULL
) {
1584 if (asprintf(&default_destdir
, "%s.git", repo_name
) == -1) {
1585 error
= got_error_from_errno("asprintf");
1588 repo_path
= default_destdir
;
1590 repo_path
= dirname
;
1592 if (!list_refs_only
) {
1593 error
= got_path_mkdir(repo_path
);
1595 (!(error
->code
== GOT_ERR_ERRNO
&& errno
== EISDIR
) &&
1596 !(error
->code
== GOT_ERR_ERRNO
&& errno
== EEXIST
)))
1598 if (!got_path_dir_is_empty(repo_path
)) {
1599 error
= got_error_path(repo_path
,
1600 GOT_ERR_DIR_NOT_EMPTY
);
1605 error
= got_dial_apply_unveil(proto
);
1609 error
= apply_unveil(repo_path
, 0, NULL
);
1614 printf("Connecting to %s%s%s\n", host
,
1615 port
? ":" : "", port
? port
: "");
1617 error
= got_fetch_connect(&fetchpid
, &fetchfd
, proto
, host
, port
,
1618 server_path
, verbosity
);
1622 if (!list_refs_only
) {
1623 error
= got_repo_init(repo_path
);
1626 error
= got_repo_open(&repo
, repo_path
, NULL
);
1631 fpa
.last_scaled_size
[0] = '\0';
1632 fpa
.last_p_indexed
= -1;
1633 fpa
.last_p_resolved
= -1;
1634 fpa
.verbosity
= verbosity
;
1635 fpa
.create_configs
= 1;
1636 fpa
.configs_created
= 0;
1638 fpa
.config_info
.symrefs
= &symrefs
;
1639 fpa
.config_info
.wanted_branches
= &wanted_branches
;
1640 fpa
.config_info
.wanted_refs
= &wanted_refs
;
1641 fpa
.config_info
.proto
= proto
;
1642 fpa
.config_info
.host
= host
;
1643 fpa
.config_info
.port
= port
;
1644 fpa
.config_info
.remote_repo_path
= server_path
;
1645 fpa
.config_info
.git_url
= git_url
;
1646 fpa
.config_info
.fetch_all_branches
= fetch_all_branches
;
1647 fpa
.config_info
.mirror_references
= mirror_references
;
1648 error
= got_fetch_pack(&pack_hash
, &refs
, &symrefs
,
1649 GOT_FETCH_DEFAULT_REMOTE_NAME
, mirror_references
,
1650 fetch_all_branches
, &wanted_branches
, &wanted_refs
,
1651 list_refs_only
, verbosity
, fetchfd
, repo
,
1652 fetch_progress
, &fpa
);
1656 if (list_refs_only
) {
1657 error
= list_remote_refs(&symrefs
, &refs
);
1661 error
= got_object_id_str(&id_str
, pack_hash
);
1665 printf("\nFetched %s.pack\n", id_str
);
1668 /* Set up references provided with the pack file. */
1669 TAILQ_FOREACH(pe
, &refs
, entry
) {
1670 const char *refname
= pe
->path
;
1671 struct got_object_id
*id
= pe
->data
;
1672 char *remote_refname
;
1674 if (is_wanted_ref(&wanted_refs
, refname
) &&
1675 !mirror_references
) {
1676 error
= create_wanted_ref(refname
, id
,
1677 GOT_FETCH_DEFAULT_REMOTE_NAME
,
1678 verbosity
- 1, repo
);
1684 error
= create_ref(refname
, id
, verbosity
- 1, repo
);
1688 if (mirror_references
)
1691 if (strncmp("refs/heads/", refname
, 11) != 0)
1694 if (asprintf(&remote_refname
,
1695 "refs/remotes/%s/%s", GOT_FETCH_DEFAULT_REMOTE_NAME
,
1696 refname
+ 11) == -1) {
1697 error
= got_error_from_errno("asprintf");
1700 error
= create_ref(remote_refname
, id
, verbosity
- 1, repo
);
1701 free(remote_refname
);
1706 /* Set the HEAD reference if the server provided one. */
1707 TAILQ_FOREACH(pe
, &symrefs
, entry
) {
1708 struct got_reference
*target_ref
;
1709 const char *refname
= pe
->path
;
1710 const char *target
= pe
->data
;
1711 char *remote_refname
= NULL
, *remote_target
= NULL
;
1713 if (strcmp(refname
, GOT_REF_HEAD
) != 0)
1716 error
= got_ref_open(&target_ref
, repo
, target
, 0);
1718 if (error
->code
== GOT_ERR_NOT_REF
) {
1725 error
= create_symref(refname
, target_ref
, verbosity
, repo
);
1726 got_ref_close(target_ref
);
1730 if (mirror_references
)
1733 if (strncmp("refs/heads/", target
, 11) != 0)
1736 if (asprintf(&remote_refname
,
1737 "refs/remotes/%s/%s", GOT_FETCH_DEFAULT_REMOTE_NAME
,
1739 error
= got_error_from_errno("asprintf");
1742 if (asprintf(&remote_target
,
1743 "refs/remotes/%s/%s", GOT_FETCH_DEFAULT_REMOTE_NAME
,
1744 target
+ 11) == -1) {
1745 error
= got_error_from_errno("asprintf");
1746 free(remote_refname
);
1749 error
= got_ref_open(&target_ref
, repo
, remote_target
, 0);
1751 free(remote_refname
);
1752 free(remote_target
);
1753 if (error
->code
== GOT_ERR_NOT_REF
) {
1759 error
= create_symref(remote_refname
, target_ref
,
1760 verbosity
- 1, repo
);
1761 free(remote_refname
);
1762 free(remote_target
);
1763 got_ref_close(target_ref
);
1769 * We failed to set the HEAD reference. If we asked for
1770 * a set of wanted branches use the first of one of those
1771 * which could be fetched instead.
1773 TAILQ_FOREACH(pe
, &wanted_branches
, entry
) {
1774 const char *target
= pe
->path
;
1775 struct got_reference
*target_ref
;
1777 error
= got_ref_open(&target_ref
, repo
, target
, 0);
1779 if (error
->code
== GOT_ERR_NOT_REF
) {
1786 error
= create_symref(GOT_REF_HEAD
, target_ref
,
1788 got_ref_close(target_ref
);
1796 printf("Created %s repository '%s'\n",
1797 mirror_references
? "mirrored" : "cloned", repo_path
);
1800 if (kill(fetchpid
, SIGTERM
) == -1)
1801 error
= got_error_from_errno("kill");
1802 if (waitpid(fetchpid
, &fetchstatus
, 0) == -1 && error
== NULL
)
1803 error
= got_error_from_errno("waitpid");
1805 if (fetchfd
!= -1 && close(fetchfd
) == -1 && error
== NULL
)
1806 error
= got_error_from_errno("close");
1808 const struct got_error
*close_err
= got_repo_close(repo
);
1812 TAILQ_FOREACH(pe
, &refs
, entry
) {
1813 free((void *)pe
->path
);
1816 got_pathlist_free(&refs
);
1817 TAILQ_FOREACH(pe
, &symrefs
, entry
) {
1818 free((void *)pe
->path
);
1821 got_pathlist_free(&symrefs
);
1822 got_pathlist_free(&wanted_branches
);
1823 got_pathlist_free(&wanted_refs
);
1830 free(default_destdir
);
1835 static const struct got_error
*
1836 update_ref(struct got_reference
*ref
, struct got_object_id
*new_id
,
1837 int replace_tags
, int verbosity
, struct got_repository
*repo
)
1839 const struct got_error
*err
= NULL
;
1840 char *new_id_str
= NULL
;
1841 struct got_object_id
*old_id
= NULL
;
1843 err
= got_object_id_str(&new_id_str
, new_id
);
1847 if (!replace_tags
&&
1848 strncmp(got_ref_get_name(ref
), "refs/tags/", 10) == 0) {
1849 err
= got_ref_resolve(&old_id
, repo
, ref
);
1852 if (got_object_id_cmp(old_id
, new_id
) == 0)
1854 if (verbosity
>= 0) {
1855 printf("Rejecting update of existing tag %s: %s\n",
1856 got_ref_get_name(ref
), new_id_str
);
1861 if (got_ref_is_symbolic(ref
)) {
1862 if (verbosity
>= 0) {
1863 printf("Replacing reference %s: %s\n",
1864 got_ref_get_name(ref
),
1865 got_ref_get_symref_target(ref
));
1867 err
= got_ref_change_symref_to_ref(ref
, new_id
);
1870 err
= got_ref_write(ref
, repo
);
1874 err
= got_ref_resolve(&old_id
, repo
, ref
);
1877 if (got_object_id_cmp(old_id
, new_id
) == 0)
1880 err
= got_ref_change_ref(ref
, new_id
);
1883 err
= got_ref_write(ref
, repo
);
1889 printf("Updated %s: %s\n", got_ref_get_name(ref
),
1897 static const struct got_error
*
1898 update_symref(const char *refname
, struct got_reference
*target_ref
,
1899 int verbosity
, struct got_repository
*repo
)
1901 const struct got_error
*err
= NULL
, *unlock_err
;
1902 struct got_reference
*symref
;
1903 int symref_is_locked
= 0;
1905 err
= got_ref_open(&symref
, repo
, refname
, 1);
1907 if (err
->code
!= GOT_ERR_NOT_REF
)
1909 err
= got_ref_alloc_symref(&symref
, refname
, target_ref
);
1913 err
= got_ref_write(symref
, repo
);
1918 printf("Created reference %s: %s\n",
1919 got_ref_get_name(symref
),
1920 got_ref_get_symref_target(symref
));
1922 symref_is_locked
= 1;
1924 if (strcmp(got_ref_get_symref_target(symref
),
1925 got_ref_get_name(target_ref
)) == 0)
1928 err
= got_ref_change_symref(symref
,
1929 got_ref_get_name(target_ref
));
1933 err
= got_ref_write(symref
, repo
);
1938 printf("Updated %s: %s\n", got_ref_get_name(symref
),
1939 got_ref_get_symref_target(symref
));
1943 if (symref_is_locked
) {
1944 unlock_err
= got_ref_unlock(symref
);
1945 if (unlock_err
&& err
== NULL
)
1948 got_ref_close(symref
);
1955 fprintf(stderr
, "usage: %s fetch [-a] [-b branch] [-d] [-l] "
1956 "[-r repository-path] [-t] [-q] [-v] [-R reference] [-X] "
1957 "[remote-repository-name]\n",
1962 static const struct got_error
*
1963 delete_missing_ref(struct got_reference
*ref
,
1964 int verbosity
, struct got_repository
*repo
)
1966 const struct got_error
*err
= NULL
;
1967 struct got_object_id
*id
= NULL
;
1968 char *id_str
= NULL
;
1970 if (got_ref_is_symbolic(ref
)) {
1971 err
= got_ref_delete(ref
, repo
);
1974 if (verbosity
>= 0) {
1975 printf("Deleted %s: %s\n",
1976 got_ref_get_name(ref
),
1977 got_ref_get_symref_target(ref
));
1980 err
= got_ref_resolve(&id
, repo
, ref
);
1983 err
= got_object_id_str(&id_str
, id
);
1987 err
= got_ref_delete(ref
, repo
);
1990 if (verbosity
>= 0) {
1991 printf("Deleted %s: %s\n",
1992 got_ref_get_name(ref
), id_str
);
2001 static const struct got_error
*
2002 delete_missing_refs(struct got_pathlist_head
*their_refs
,
2003 struct got_pathlist_head
*their_symrefs
,
2004 const struct got_remote_repo
*remote
,
2005 int verbosity
, struct got_repository
*repo
)
2007 const struct got_error
*err
= NULL
, *unlock_err
;
2008 struct got_reflist_head my_refs
;
2009 struct got_reflist_entry
*re
;
2010 struct got_pathlist_entry
*pe
;
2011 char *remote_namespace
= NULL
;
2012 char *local_refname
= NULL
;
2014 TAILQ_INIT(&my_refs
);
2016 if (asprintf(&remote_namespace
, "refs/remotes/%s/", remote
->name
)
2018 return got_error_from_errno("asprintf");
2020 err
= got_ref_list(&my_refs
, repo
, NULL
, got_ref_cmp_by_name
, NULL
);
2024 TAILQ_FOREACH(re
, &my_refs
, entry
) {
2025 const char *refname
= got_ref_get_name(re
->ref
);
2026 const char *their_refname
;
2028 if (remote
->mirror_references
) {
2029 their_refname
= refname
;
2031 if (strncmp(refname
, remote_namespace
,
2032 strlen(remote_namespace
)) == 0) {
2033 if (strcmp(refname
+ strlen(remote_namespace
),
2036 if (asprintf(&local_refname
, "refs/heads/%s",
2037 refname
+ strlen(remote_namespace
)) == -1) {
2038 err
= got_error_from_errno("asprintf");
2041 } else if (strncmp(refname
, "refs/tags/", 10) != 0)
2044 their_refname
= local_refname
;
2047 TAILQ_FOREACH(pe
, their_refs
, entry
) {
2048 if (strcmp(their_refname
, pe
->path
) == 0)
2054 TAILQ_FOREACH(pe
, their_symrefs
, entry
) {
2055 if (strcmp(their_refname
, pe
->path
) == 0)
2061 err
= delete_missing_ref(re
->ref
, verbosity
, repo
);
2065 if (local_refname
) {
2066 struct got_reference
*ref
;
2067 err
= got_ref_open(&ref
, repo
, local_refname
, 1);
2069 if (err
->code
!= GOT_ERR_NOT_REF
)
2071 free(local_refname
);
2072 local_refname
= NULL
;
2075 err
= delete_missing_ref(ref
, verbosity
, repo
);
2078 unlock_err
= got_ref_unlock(ref
);
2080 if (unlock_err
&& err
== NULL
) {
2085 free(local_refname
);
2086 local_refname
= NULL
;
2090 free(remote_namespace
);
2091 free(local_refname
);
2095 static const struct got_error
*
2096 update_wanted_ref(const char *refname
, struct got_object_id
*id
,
2097 const char *remote_repo_name
, int verbosity
, struct got_repository
*repo
)
2099 const struct got_error
*err
, *unlock_err
;
2100 char *remote_refname
;
2101 struct got_reference
*ref
;
2103 if (strncmp("refs/", refname
, 5) == 0)
2106 if (asprintf(&remote_refname
, "refs/remotes/%s/%s",
2107 remote_repo_name
, refname
) == -1)
2108 return got_error_from_errno("asprintf");
2110 err
= got_ref_open(&ref
, repo
, remote_refname
, 1);
2112 if (err
->code
!= GOT_ERR_NOT_REF
)
2114 err
= create_ref(remote_refname
, id
, verbosity
, repo
);
2116 err
= update_ref(ref
, id
, 0, verbosity
, repo
);
2117 unlock_err
= got_ref_unlock(ref
);
2118 if (unlock_err
&& err
== NULL
)
2123 free(remote_refname
);
2127 static const struct got_error
*
2128 delete_ref(struct got_repository
*repo
, struct got_reference
*ref
)
2130 const struct got_error
*err
= NULL
;
2131 struct got_object_id
*id
= NULL
;
2132 char *id_str
= NULL
;
2135 if (got_ref_is_symbolic(ref
)) {
2136 target
= got_ref_get_symref_target(ref
);
2138 err
= got_ref_resolve(&id
, repo
, ref
);
2141 err
= got_object_id_str(&id_str
, id
);
2147 err
= got_ref_delete(ref
, repo
);
2151 printf("Deleted %s: %s\n", got_ref_get_name(ref
), target
);
2158 static const struct got_error
*
2159 delete_refs_for_remote(struct got_repository
*repo
, const char *remote_name
)
2161 const struct got_error
*err
= NULL
;
2162 struct got_reflist_head refs
;
2163 struct got_reflist_entry
*re
;
2168 if (asprintf(&prefix
, "refs/remotes/%s", remote_name
) == -1) {
2169 err
= got_error_from_errno("asprintf");
2172 err
= got_ref_list(&refs
, repo
, prefix
, got_ref_cmp_by_name
, NULL
);
2176 TAILQ_FOREACH(re
, &refs
, entry
)
2177 delete_ref(repo
, re
->ref
);
2179 got_ref_list_free(&refs
);
2183 static const struct got_error
*
2184 cmd_fetch(int argc
, char *argv
[])
2186 const struct got_error
*error
= NULL
, *unlock_err
;
2187 char *cwd
= NULL
, *repo_path
= NULL
;
2188 const char *remote_name
;
2189 char *proto
= NULL
, *host
= NULL
, *port
= NULL
;
2190 char *repo_name
= NULL
, *server_path
= NULL
;
2191 const struct got_remote_repo
*remotes
, *remote
= NULL
;
2193 char *id_str
= NULL
;
2194 struct got_repository
*repo
= NULL
;
2195 struct got_worktree
*worktree
= NULL
;
2196 const struct got_gotconfig
*repo_conf
= NULL
, *worktree_conf
= NULL
;
2197 struct got_pathlist_head refs
, symrefs
, wanted_branches
, wanted_refs
;
2198 struct got_pathlist_entry
*pe
;
2199 struct got_object_id
*pack_hash
= NULL
;
2200 int i
, ch
, fetchfd
= -1, fetchstatus
;
2201 pid_t fetchpid
= -1;
2202 struct got_fetch_progress_arg fpa
;
2203 int verbosity
= 0, fetch_all_branches
= 0, list_refs_only
= 0;
2204 int delete_refs
= 0, replace_tags
= 0, delete_remote
= 0;
2207 TAILQ_INIT(&symrefs
);
2208 TAILQ_INIT(&wanted_branches
);
2209 TAILQ_INIT(&wanted_refs
);
2211 while ((ch
= getopt(argc
, argv
, "ab:dlr:tvqR:X")) != -1) {
2214 fetch_all_branches
= 1;
2217 error
= got_pathlist_append(&wanted_branches
,
2229 repo_path
= realpath(optarg
, NULL
);
2230 if (repo_path
== NULL
)
2231 return got_error_from_errno2("realpath",
2233 got_path_strip_trailing_slashes(repo_path
);
2241 else if (verbosity
< 3)
2248 error
= got_pathlist_append(&wanted_refs
,
2264 if (fetch_all_branches
&& !TAILQ_EMPTY(&wanted_branches
))
2265 option_conflict('a', 'b');
2266 if (list_refs_only
) {
2267 if (!TAILQ_EMPTY(&wanted_branches
))
2268 option_conflict('l', 'b');
2269 if (fetch_all_branches
)
2270 option_conflict('l', 'a');
2272 option_conflict('l', 'd');
2274 option_conflict('l', 'X');
2276 if (delete_remote
) {
2277 if (fetch_all_branches
)
2278 option_conflict('X', 'a');
2279 if (!TAILQ_EMPTY(&wanted_branches
))
2280 option_conflict('X', 'b');
2282 option_conflict('X', 'd');
2284 option_conflict('X', 't');
2285 if (!TAILQ_EMPTY(&wanted_refs
))
2286 option_conflict('X', 'R');
2291 errx(1, "-X option requires a remote name");
2292 remote_name
= GOT_FETCH_DEFAULT_REMOTE_NAME
;
2293 } else if (argc
== 1)
2294 remote_name
= argv
[0];
2298 cwd
= getcwd(NULL
, 0);
2300 error
= got_error_from_errno("getcwd");
2304 if (repo_path
== NULL
) {
2305 error
= got_worktree_open(&worktree
, cwd
);
2306 if (error
&& error
->code
!= GOT_ERR_NOT_WORKTREE
)
2312 strdup(got_worktree_get_repo_path(worktree
));
2313 if (repo_path
== NULL
)
2314 error
= got_error_from_errno("strdup");
2318 repo_path
= strdup(cwd
);
2319 if (repo_path
== NULL
) {
2320 error
= got_error_from_errno("strdup");
2326 error
= got_repo_open(&repo
, repo_path
, NULL
);
2330 if (delete_remote
) {
2331 error
= delete_refs_for_remote(repo
, remote_name
);
2332 goto done
; /* nothing else to do */
2336 worktree_conf
= got_worktree_get_gotconfig(worktree
);
2337 if (worktree_conf
) {
2338 got_gotconfig_get_remotes(&nremotes
, &remotes
,
2340 for (i
= 0; i
< nremotes
; i
++) {
2341 if (strcmp(remotes
[i
].name
, remote_name
) == 0) {
2342 remote
= &remotes
[i
];
2348 if (remote
== NULL
) {
2349 repo_conf
= got_repo_get_gotconfig(repo
);
2351 got_gotconfig_get_remotes(&nremotes
, &remotes
,
2353 for (i
= 0; i
< nremotes
; i
++) {
2354 if (strcmp(remotes
[i
].name
, remote_name
) == 0) {
2355 remote
= &remotes
[i
];
2361 if (remote
== NULL
) {
2362 got_repo_get_gitconfig_remotes(&nremotes
, &remotes
, repo
);
2363 for (i
= 0; i
< nremotes
; i
++) {
2364 if (strcmp(remotes
[i
].name
, remote_name
) == 0) {
2365 remote
= &remotes
[i
];
2370 if (remote
== NULL
) {
2371 error
= got_error_path(remote_name
, GOT_ERR_NO_REMOTE
);
2375 if (TAILQ_EMPTY(&wanted_branches
)) {
2376 if (!fetch_all_branches
)
2377 fetch_all_branches
= remote
->fetch_all_branches
;
2378 for (i
= 0; i
< remote
->nfetch_branches
; i
++) {
2379 got_pathlist_append(&wanted_branches
,
2380 remote
->fetch_branches
[i
], NULL
);
2383 if (TAILQ_EMPTY(&wanted_refs
)) {
2384 for (i
= 0; i
< remote
->nfetch_refs
; i
++) {
2385 got_pathlist_append(&wanted_refs
,
2386 remote
->fetch_refs
[i
], NULL
);
2390 error
= got_dial_parse_uri(&proto
, &host
, &port
, &server_path
,
2391 &repo_name
, remote
->fetch_url
);
2395 if (strcmp(proto
, "git") == 0) {
2397 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
2398 "sendfd dns inet unveil", NULL
) == -1)
2401 } else if (strcmp(proto
, "git+ssh") == 0 ||
2402 strcmp(proto
, "ssh") == 0) {
2404 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
2405 "sendfd unveil", NULL
) == -1)
2408 } else if (strcmp(proto
, "http") == 0 ||
2409 strcmp(proto
, "git+http") == 0) {
2410 error
= got_error_path(proto
, GOT_ERR_NOT_IMPL
);
2413 error
= got_error_path(proto
, GOT_ERR_BAD_PROTO
);
2417 error
= got_dial_apply_unveil(proto
);
2421 error
= apply_unveil(got_repo_get_path(repo
), 0, NULL
);
2426 printf("Connecting to \"%s\" %s%s%s\n", remote
->name
, host
,
2427 port
? ":" : "", port
? port
: "");
2429 error
= got_fetch_connect(&fetchpid
, &fetchfd
, proto
, host
, port
,
2430 server_path
, verbosity
);
2434 fpa
.last_scaled_size
[0] = '\0';
2435 fpa
.last_p_indexed
= -1;
2436 fpa
.last_p_resolved
= -1;
2437 fpa
.verbosity
= verbosity
;
2439 fpa
.create_configs
= 0;
2440 fpa
.configs_created
= 0;
2441 memset(&fpa
.config_info
, 0, sizeof(fpa
.config_info
));
2442 error
= got_fetch_pack(&pack_hash
, &refs
, &symrefs
, remote
->name
,
2443 remote
->mirror_references
, fetch_all_branches
, &wanted_branches
,
2444 &wanted_refs
, list_refs_only
, verbosity
, fetchfd
, repo
,
2445 fetch_progress
, &fpa
);
2449 if (list_refs_only
) {
2450 error
= list_remote_refs(&symrefs
, &refs
);
2454 if (pack_hash
== NULL
) {
2456 printf("Already up-to-date\n");
2457 } else if (verbosity
>= 0) {
2458 error
= got_object_id_str(&id_str
, pack_hash
);
2461 printf("\nFetched %s.pack\n", id_str
);
2466 /* Update references provided with the pack file. */
2467 TAILQ_FOREACH(pe
, &refs
, entry
) {
2468 const char *refname
= pe
->path
;
2469 struct got_object_id
*id
= pe
->data
;
2470 struct got_reference
*ref
;
2471 char *remote_refname
;
2473 if (is_wanted_ref(&wanted_refs
, refname
) &&
2474 !remote
->mirror_references
) {
2475 error
= update_wanted_ref(refname
, id
,
2476 remote
->name
, verbosity
, repo
);
2482 if (remote
->mirror_references
||
2483 strncmp("refs/tags/", refname
, 10) == 0) {
2484 error
= got_ref_open(&ref
, repo
, refname
, 1);
2486 if (error
->code
!= GOT_ERR_NOT_REF
)
2488 error
= create_ref(refname
, id
, verbosity
,
2493 error
= update_ref(ref
, id
, replace_tags
,
2495 unlock_err
= got_ref_unlock(ref
);
2496 if (unlock_err
&& error
== NULL
)
2502 } else if (strncmp("refs/heads/", refname
, 11) == 0) {
2503 if (asprintf(&remote_refname
, "refs/remotes/%s/%s",
2504 remote_name
, refname
+ 11) == -1) {
2505 error
= got_error_from_errno("asprintf");
2509 error
= got_ref_open(&ref
, repo
, remote_refname
, 1);
2511 if (error
->code
!= GOT_ERR_NOT_REF
)
2513 error
= create_ref(remote_refname
, id
,
2518 error
= update_ref(ref
, id
, replace_tags
,
2520 unlock_err
= got_ref_unlock(ref
);
2521 if (unlock_err
&& error
== NULL
)
2528 /* Also create a local branch if none exists yet. */
2529 error
= got_ref_open(&ref
, repo
, refname
, 1);
2531 if (error
->code
!= GOT_ERR_NOT_REF
)
2533 error
= create_ref(refname
, id
, verbosity
,
2538 unlock_err
= got_ref_unlock(ref
);
2539 if (unlock_err
&& error
== NULL
)
2546 error
= delete_missing_refs(&refs
, &symrefs
, remote
,
2552 if (!remote
->mirror_references
) {
2553 /* Update remote HEAD reference if the server provided one. */
2554 TAILQ_FOREACH(pe
, &symrefs
, entry
) {
2555 struct got_reference
*target_ref
;
2556 const char *refname
= pe
->path
;
2557 const char *target
= pe
->data
;
2558 char *remote_refname
= NULL
, *remote_target
= NULL
;
2560 if (strcmp(refname
, GOT_REF_HEAD
) != 0)
2563 if (strncmp("refs/heads/", target
, 11) != 0)
2566 if (asprintf(&remote_refname
, "refs/remotes/%s/%s",
2567 remote
->name
, refname
) == -1) {
2568 error
= got_error_from_errno("asprintf");
2571 if (asprintf(&remote_target
, "refs/remotes/%s/%s",
2572 remote
->name
, target
+ 11) == -1) {
2573 error
= got_error_from_errno("asprintf");
2574 free(remote_refname
);
2578 error
= got_ref_open(&target_ref
, repo
, remote_target
,
2581 free(remote_refname
);
2582 free(remote_target
);
2583 if (error
->code
== GOT_ERR_NOT_REF
) {
2589 error
= update_symref(remote_refname
, target_ref
,
2591 free(remote_refname
);
2592 free(remote_target
);
2593 got_ref_close(target_ref
);
2600 if (kill(fetchpid
, SIGTERM
) == -1)
2601 error
= got_error_from_errno("kill");
2602 if (waitpid(fetchpid
, &fetchstatus
, 0) == -1 && error
== NULL
)
2603 error
= got_error_from_errno("waitpid");
2605 if (fetchfd
!= -1 && close(fetchfd
) == -1 && error
== NULL
)
2606 error
= got_error_from_errno("close");
2608 const struct got_error
*close_err
= got_repo_close(repo
);
2613 got_worktree_close(worktree
);
2614 TAILQ_FOREACH(pe
, &refs
, entry
) {
2615 free((void *)pe
->path
);
2618 got_pathlist_free(&refs
);
2619 TAILQ_FOREACH(pe
, &symrefs
, entry
) {
2620 free((void *)pe
->path
);
2623 got_pathlist_free(&symrefs
);
2624 got_pathlist_free(&wanted_branches
);
2625 got_pathlist_free(&wanted_refs
);
2640 usage_checkout(void)
2642 fprintf(stderr
, "usage: %s checkout [-E] [-b branch] [-c commit] "
2643 "[-p prefix] [-q] repository-path [worktree-path]\n",
2649 show_worktree_base_ref_warning(void)
2651 fprintf(stderr
, "%s: warning: could not create a reference "
2652 "to the work tree's base commit; the commit could be "
2653 "garbage-collected by Git or 'gotadmin cleanup'; making the "
2654 "repository writable and running 'got update' will prevent this\n",
2658 struct got_checkout_progress_arg
{
2659 const char *worktree_path
;
2660 int had_base_commit_ref_error
;
2664 static const struct got_error
*
2665 checkout_progress(void *arg
, unsigned char status
, const char *path
)
2667 struct got_checkout_progress_arg
*a
= arg
;
2669 /* Base commit bump happens silently. */
2670 if (status
== GOT_STATUS_BUMP_BASE
)
2673 if (status
== GOT_STATUS_BASE_REF_ERR
) {
2674 a
->had_base_commit_ref_error
= 1;
2678 while (path
[0] == '/')
2681 if (a
->verbosity
>= 0)
2682 printf("%c %s/%s\n", status
, a
->worktree_path
, path
);
2687 static const struct got_error
*
2688 check_cancelled(void *arg
)
2690 if (sigint_received
|| sigpipe_received
)
2691 return got_error(GOT_ERR_CANCELLED
);
2695 static const struct got_error
*
2696 check_linear_ancestry(struct got_object_id
*commit_id
,
2697 struct got_object_id
*base_commit_id
, int allow_forwards_in_time_only
,
2698 struct got_repository
*repo
)
2700 const struct got_error
*err
= NULL
;
2701 struct got_object_id
*yca_id
;
2703 err
= got_commit_graph_find_youngest_common_ancestor(&yca_id
,
2704 commit_id
, base_commit_id
, repo
, check_cancelled
, NULL
);
2709 return got_error(GOT_ERR_ANCESTRY
);
2712 * Require a straight line of history between the target commit
2713 * and the work tree's base commit.
2715 * Non-linear situations such as this require a rebase:
2717 * (commit) D F (base_commit)
2725 * 'got update' only handles linear cases:
2726 * Update forwards in time: A (base/yca) - B - C - D (commit)
2727 * Update backwards in time: D (base) - C - B - A (commit/yca)
2729 if (allow_forwards_in_time_only
) {
2730 if (got_object_id_cmp(base_commit_id
, yca_id
) != 0)
2731 return got_error(GOT_ERR_ANCESTRY
);
2732 } else if (got_object_id_cmp(commit_id
, yca_id
) != 0 &&
2733 got_object_id_cmp(base_commit_id
, yca_id
) != 0)
2734 return got_error(GOT_ERR_ANCESTRY
);
2740 static const struct got_error
*
2741 check_same_branch(struct got_object_id
*commit_id
,
2742 struct got_reference
*head_ref
, struct got_object_id
*yca_id
,
2743 struct got_repository
*repo
)
2745 const struct got_error
*err
= NULL
;
2746 struct got_commit_graph
*graph
= NULL
;
2747 struct got_object_id
*head_commit_id
= NULL
;
2748 int is_same_branch
= 0;
2750 err
= got_ref_resolve(&head_commit_id
, repo
, head_ref
);
2754 if (got_object_id_cmp(head_commit_id
, commit_id
) == 0) {
2758 if (yca_id
&& got_object_id_cmp(commit_id
, yca_id
) == 0) {
2763 err
= got_commit_graph_open(&graph
, "/", 1);
2767 err
= got_commit_graph_iter_start(graph
, head_commit_id
, repo
,
2768 check_cancelled
, NULL
);
2773 struct got_object_id
*id
;
2774 err
= got_commit_graph_iter_next(&id
, graph
, repo
,
2775 check_cancelled
, NULL
);
2777 if (err
->code
== GOT_ERR_ITER_COMPLETED
)
2783 if (yca_id
&& got_object_id_cmp(id
, yca_id
) == 0)
2785 if (got_object_id_cmp(id
, commit_id
) == 0) {
2793 got_commit_graph_close(graph
);
2794 free(head_commit_id
);
2795 if (!err
&& !is_same_branch
)
2796 err
= got_error(GOT_ERR_ANCESTRY
);
2800 static const struct got_error
*
2801 checkout_ancestry_error(struct got_reference
*ref
, const char *commit_id_str
)
2803 static char msg
[512];
2804 const char *branch_name
;
2806 if (got_ref_is_symbolic(ref
))
2807 branch_name
= got_ref_get_symref_target(ref
);
2809 branch_name
= got_ref_get_name(ref
);
2811 if (strncmp("refs/heads/", branch_name
, 11) == 0)
2814 snprintf(msg
, sizeof(msg
),
2815 "target commit is not contained in branch '%s'; "
2816 "the branch to use must be specified with -b; "
2817 "if necessary a new branch can be created for "
2818 "this commit with 'got branch -c %s BRANCH_NAME'",
2819 branch_name
, commit_id_str
);
2821 return got_error_msg(GOT_ERR_ANCESTRY
, msg
);
2824 static const struct got_error
*
2825 cmd_checkout(int argc
, char *argv
[])
2827 const struct got_error
*error
= NULL
;
2828 struct got_repository
*repo
= NULL
;
2829 struct got_reference
*head_ref
= NULL
, *ref
= NULL
;
2830 struct got_worktree
*worktree
= NULL
;
2831 char *repo_path
= NULL
;
2832 char *worktree_path
= NULL
;
2833 const char *path_prefix
= "";
2834 const char *branch_name
= GOT_REF_HEAD
, *refname
= NULL
;
2835 char *commit_id_str
= NULL
;
2836 struct got_object_id
*commit_id
= NULL
;
2838 int ch
, same_path_prefix
, allow_nonempty
= 0, verbosity
= 0;
2839 struct got_pathlist_head paths
;
2840 struct got_checkout_progress_arg cpa
;
2844 while ((ch
= getopt(argc
, argv
, "b:c:Ep:q")) != -1) {
2847 branch_name
= optarg
;
2850 commit_id_str
= strdup(optarg
);
2851 if (commit_id_str
== NULL
)
2852 return got_error_from_errno("strdup");
2858 path_prefix
= optarg
;
2873 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
2874 "unveil", NULL
) == -1)
2878 char *base
, *dotgit
;
2880 repo_path
= realpath(argv
[0], NULL
);
2881 if (repo_path
== NULL
)
2882 return got_error_from_errno2("realpath", argv
[0]);
2883 cwd
= getcwd(NULL
, 0);
2885 error
= got_error_from_errno("getcwd");
2892 error
= got_path_basename(&base
, path
);
2895 dotgit
= strstr(base
, ".git");
2898 if (asprintf(&worktree_path
, "%s/%s", cwd
, base
) == -1) {
2899 error
= got_error_from_errno("asprintf");
2904 } else if (argc
== 2) {
2905 repo_path
= realpath(argv
[0], NULL
);
2906 if (repo_path
== NULL
) {
2907 error
= got_error_from_errno2("realpath", argv
[0]);
2910 worktree_path
= realpath(argv
[1], NULL
);
2911 if (worktree_path
== NULL
) {
2912 if (errno
!= ENOENT
) {
2913 error
= got_error_from_errno2("realpath",
2917 worktree_path
= strdup(argv
[1]);
2918 if (worktree_path
== NULL
) {
2919 error
= got_error_from_errno("strdup");
2926 got_path_strip_trailing_slashes(repo_path
);
2927 got_path_strip_trailing_slashes(worktree_path
);
2929 error
= got_repo_open(&repo
, repo_path
, NULL
);
2933 /* Pre-create work tree path for unveil(2) */
2934 error
= got_path_mkdir(worktree_path
);
2936 if (!(error
->code
== GOT_ERR_ERRNO
&& errno
== EISDIR
) &&
2937 !(error
->code
== GOT_ERR_ERRNO
&& errno
== EEXIST
))
2939 if (!allow_nonempty
&&
2940 !got_path_dir_is_empty(worktree_path
)) {
2941 error
= got_error_path(worktree_path
,
2942 GOT_ERR_DIR_NOT_EMPTY
);
2947 error
= apply_unveil(got_repo_get_path(repo
), 0, worktree_path
);
2951 error
= got_ref_open(&head_ref
, repo
, branch_name
, 0);
2955 error
= got_worktree_init(worktree_path
, head_ref
, path_prefix
, repo
);
2956 if (error
!= NULL
&& !(error
->code
== GOT_ERR_ERRNO
&& errno
== EEXIST
))
2959 error
= got_worktree_open(&worktree
, worktree_path
);
2963 error
= got_worktree_match_path_prefix(&same_path_prefix
, worktree
,
2967 if (!same_path_prefix
) {
2968 error
= got_error(GOT_ERR_PATH_PREFIX
);
2972 if (commit_id_str
) {
2973 struct got_reflist_head refs
;
2975 error
= got_ref_list(&refs
, repo
, NULL
, got_ref_cmp_by_name
,
2979 error
= got_repo_match_object_id(&commit_id
, NULL
,
2980 commit_id_str
, GOT_OBJ_TYPE_COMMIT
, &refs
, repo
);
2981 got_ref_list_free(&refs
);
2984 error
= check_linear_ancestry(commit_id
,
2985 got_worktree_get_base_commit_id(worktree
), 0, repo
);
2986 if (error
!= NULL
) {
2988 if (error
->code
== GOT_ERR_ANCESTRY
) {
2989 error
= checkout_ancestry_error(
2990 head_ref
, commit_id_str
);
2994 error
= check_same_branch(commit_id
, head_ref
, NULL
, repo
);
2996 if (error
->code
== GOT_ERR_ANCESTRY
) {
2997 error
= checkout_ancestry_error(
2998 head_ref
, commit_id_str
);
3002 error
= got_worktree_set_base_commit_id(worktree
, repo
,
3006 /* Expand potentially abbreviated commit ID string. */
3007 free(commit_id_str
);
3008 error
= got_object_id_str(&commit_id_str
, commit_id
);
3012 commit_id
= got_object_id_dup(
3013 got_worktree_get_base_commit_id(worktree
));
3014 if (commit_id
== NULL
) {
3015 error
= got_error_from_errno("got_object_id_dup");
3018 error
= got_object_id_str(&commit_id_str
, commit_id
);
3023 error
= got_pathlist_append(&paths
, "", NULL
);
3026 cpa
.worktree_path
= worktree_path
;
3027 cpa
.had_base_commit_ref_error
= 0;
3028 cpa
.verbosity
= verbosity
;
3029 error
= got_worktree_checkout_files(worktree
, &paths
, repo
,
3030 checkout_progress
, &cpa
, check_cancelled
, NULL
);
3034 if (got_ref_is_symbolic(head_ref
)) {
3035 error
= got_ref_resolve_symbolic(&ref
, repo
, head_ref
);
3038 refname
= got_ref_get_name(ref
);
3040 refname
= got_ref_get_name(head_ref
);
3041 printf("Checked out %s: %s\n", refname
, commit_id_str
);
3042 printf("Now shut up and hack\n");
3043 if (cpa
.had_base_commit_ref_error
)
3044 show_worktree_base_ref_warning();
3047 got_ref_close(head_ref
);
3050 got_pathlist_free(&paths
);
3051 free(commit_id_str
);
3054 free(worktree_path
);
3059 struct got_update_progress_arg
{
3069 print_update_progress_stats(struct got_update_progress_arg
*upa
)
3071 if (!upa
->did_something
)
3074 if (upa
->conflicts
> 0)
3075 printf("Files with new merge conflicts: %d\n", upa
->conflicts
);
3076 if (upa
->obstructed
> 0)
3077 printf("File paths obstructed by a non-regular file: %d\n",
3079 if (upa
->not_updated
> 0)
3080 printf("Files not updated because of existing merge "
3081 "conflicts: %d\n", upa
->not_updated
);
3087 fprintf(stderr
, "usage: %s update [-b branch] [-c commit] [-q] "
3093 static const struct got_error
*
3094 update_progress(void *arg
, unsigned char status
, const char *path
)
3096 struct got_update_progress_arg
*upa
= arg
;
3098 if (status
== GOT_STATUS_EXISTS
||
3099 status
== GOT_STATUS_BASE_REF_ERR
)
3102 upa
->did_something
= 1;
3104 /* Base commit bump happens silently. */
3105 if (status
== GOT_STATUS_BUMP_BASE
)
3108 if (status
== GOT_STATUS_CONFLICT
)
3110 if (status
== GOT_STATUS_OBSTRUCTED
)
3112 if (status
== GOT_STATUS_CANNOT_UPDATE
)
3114 if (status
== GOT_STATUS_MISSING
)
3117 while (path
[0] == '/')
3119 if (upa
->verbosity
>= 0)
3120 printf("%c %s\n", status
, path
);
3125 static const struct got_error
*
3126 switch_head_ref(struct got_reference
*head_ref
,
3127 struct got_object_id
*commit_id
, struct got_worktree
*worktree
,
3128 struct got_repository
*repo
)
3130 const struct got_error
*err
= NULL
;
3132 int ref_has_moved
= 0;
3134 /* Trivial case: switching between two different references. */
3135 if (strcmp(got_ref_get_name(head_ref
),
3136 got_worktree_get_head_ref_name(worktree
)) != 0) {
3137 printf("Switching work tree from %s to %s\n",
3138 got_worktree_get_head_ref_name(worktree
),
3139 got_ref_get_name(head_ref
));
3140 return got_worktree_set_head_ref(worktree
, head_ref
);
3143 err
= check_linear_ancestry(commit_id
,
3144 got_worktree_get_base_commit_id(worktree
), 0, repo
);
3146 if (err
->code
!= GOT_ERR_ANCESTRY
)
3153 /* Switching to a rebased branch with the same reference name. */
3154 err
= got_object_id_str(&base_id_str
,
3155 got_worktree_get_base_commit_id(worktree
));
3158 printf("Reference %s now points at a different branch\n",
3159 got_worktree_get_head_ref_name(worktree
));
3160 printf("Switching work tree from %s to %s\n", base_id_str
,
3161 got_worktree_get_head_ref_name(worktree
));
3165 static const struct got_error
*
3166 check_rebase_or_histedit_in_progress(struct got_worktree
*worktree
)
3168 const struct got_error
*err
;
3171 err
= got_worktree_rebase_in_progress(&in_progress
, worktree
);
3175 return got_error(GOT_ERR_REBASING
);
3177 err
= got_worktree_histedit_in_progress(&in_progress
, worktree
);
3181 return got_error(GOT_ERR_HISTEDIT_BUSY
);
3186 static const struct got_error
*
3187 check_merge_in_progress(struct got_worktree
*worktree
,
3188 struct got_repository
*repo
)
3190 const struct got_error
*err
;
3193 err
= got_worktree_merge_in_progress(&in_progress
, worktree
, repo
);
3197 return got_error(GOT_ERR_MERGE_BUSY
);
3202 static const struct got_error
*
3203 get_worktree_paths_from_argv(struct got_pathlist_head
*paths
, int argc
,
3204 char *argv
[], struct got_worktree
*worktree
)
3206 const struct got_error
*err
= NULL
;
3213 return got_error_from_errno("strdup");
3214 return got_pathlist_append(paths
, path
, NULL
);
3217 for (i
= 0; i
< argc
; i
++) {
3218 err
= got_worktree_resolve_path(&path
, worktree
, argv
[i
]);
3221 err
= got_pathlist_append(paths
, path
, NULL
);
3231 static const struct got_error
*
3232 wrap_not_worktree_error(const struct got_error
*orig_err
,
3233 const char *cmdname
, const char *path
)
3235 const struct got_error
*err
;
3236 struct got_repository
*repo
;
3237 static char msg
[512];
3239 err
= got_repo_open(&repo
, path
, NULL
);
3243 snprintf(msg
, sizeof(msg
),
3244 "'got %s' needs a work tree in addition to a git repository\n"
3245 "Work trees can be checked out from this Git repository with "
3247 "The got(1) manual page contains more information.", cmdname
);
3248 err
= got_error_msg(GOT_ERR_NOT_WORKTREE
, msg
);
3249 got_repo_close(repo
);
3253 static const struct got_error
*
3254 cmd_update(int argc
, char *argv
[])
3256 const struct got_error
*error
= NULL
;
3257 struct got_repository
*repo
= NULL
;
3258 struct got_worktree
*worktree
= NULL
;
3259 char *worktree_path
= NULL
;
3260 struct got_object_id
*commit_id
= NULL
;
3261 char *commit_id_str
= NULL
;
3262 const char *branch_name
= NULL
;
3263 struct got_reference
*head_ref
= NULL
;
3264 struct got_pathlist_head paths
;
3265 struct got_pathlist_entry
*pe
;
3266 int ch
, verbosity
= 0;
3267 struct got_update_progress_arg upa
;
3271 while ((ch
= getopt(argc
, argv
, "b:c:q")) != -1) {
3274 branch_name
= optarg
;
3277 commit_id_str
= strdup(optarg
);
3278 if (commit_id_str
== NULL
)
3279 return got_error_from_errno("strdup");
3294 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
3295 "unveil", NULL
) == -1)
3298 worktree_path
= getcwd(NULL
, 0);
3299 if (worktree_path
== NULL
) {
3300 error
= got_error_from_errno("getcwd");
3303 error
= got_worktree_open(&worktree
, worktree_path
);
3305 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
3306 error
= wrap_not_worktree_error(error
, "update",
3311 error
= check_rebase_or_histedit_in_progress(worktree
);
3315 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
3320 error
= apply_unveil(got_repo_get_path(repo
), 0,
3321 got_worktree_get_root_path(worktree
));
3325 error
= check_merge_in_progress(worktree
, repo
);
3329 error
= get_worktree_paths_from_argv(&paths
, argc
, argv
, worktree
);
3333 error
= got_ref_open(&head_ref
, repo
, branch_name
? branch_name
:
3334 got_worktree_get_head_ref_name(worktree
), 0);
3337 if (commit_id_str
== NULL
) {
3338 error
= got_ref_resolve(&commit_id
, repo
, head_ref
);
3341 error
= got_object_id_str(&commit_id_str
, commit_id
);
3345 struct got_reflist_head refs
;
3347 error
= got_ref_list(&refs
, repo
, NULL
, got_ref_cmp_by_name
,
3351 error
= got_repo_match_object_id(&commit_id
, NULL
,
3352 commit_id_str
, GOT_OBJ_TYPE_COMMIT
, &refs
, repo
);
3353 got_ref_list_free(&refs
);
3354 free(commit_id_str
);
3355 commit_id_str
= NULL
;
3358 error
= got_object_id_str(&commit_id_str
, commit_id
);
3364 struct got_object_id
*head_commit_id
;
3365 TAILQ_FOREACH(pe
, &paths
, entry
) {
3366 if (pe
->path_len
== 0)
3368 error
= got_error_msg(GOT_ERR_BAD_PATH
,
3369 "switching between branches requires that "
3370 "the entire work tree gets updated");
3373 error
= got_ref_resolve(&head_commit_id
, repo
, head_ref
);
3376 error
= check_linear_ancestry(commit_id
, head_commit_id
, 0,
3378 free(head_commit_id
);
3381 error
= check_same_branch(commit_id
, head_ref
, NULL
, repo
);
3384 error
= switch_head_ref(head_ref
, commit_id
, worktree
, repo
);
3388 error
= check_linear_ancestry(commit_id
,
3389 got_worktree_get_base_commit_id(worktree
), 0, repo
);
3390 if (error
!= NULL
) {
3391 if (error
->code
== GOT_ERR_ANCESTRY
)
3392 error
= got_error(GOT_ERR_BRANCH_MOVED
);
3395 error
= check_same_branch(commit_id
, head_ref
, NULL
, repo
);
3400 if (got_object_id_cmp(got_worktree_get_base_commit_id(worktree
),
3402 error
= got_worktree_set_base_commit_id(worktree
, repo
,
3408 memset(&upa
, 0, sizeof(upa
));
3409 upa
.verbosity
= verbosity
;
3410 error
= got_worktree_checkout_files(worktree
, &paths
, repo
,
3411 update_progress
, &upa
, check_cancelled
, NULL
);
3415 if (upa
.did_something
) {
3416 printf("Updated to %s: %s\n",
3417 got_worktree_get_head_ref_name(worktree
), commit_id_str
);
3419 printf("Already up-to-date\n");
3420 print_update_progress_stats(&upa
);
3422 free(worktree_path
);
3423 TAILQ_FOREACH(pe
, &paths
, entry
)
3424 free((char *)pe
->path
);
3425 got_pathlist_free(&paths
);
3427 free(commit_id_str
);
3431 static const struct got_error
*
3432 diff_blobs(struct got_object_id
*blob_id1
, struct got_object_id
*blob_id2
,
3433 const char *path
, int diff_context
, int ignore_whitespace
,
3434 int force_text_diff
, struct got_repository
*repo
)
3436 const struct got_error
*err
= NULL
;
3437 struct got_blob_object
*blob1
= NULL
, *blob2
= NULL
;
3440 err
= got_object_open_as_blob(&blob1
, repo
, blob_id1
, 8192);
3445 err
= got_object_open_as_blob(&blob2
, repo
, blob_id2
, 8192);
3449 while (path
[0] == '/')
3451 err
= got_diff_blob(NULL
, NULL
, blob1
, blob2
, path
, path
,
3452 diff_context
, ignore_whitespace
, force_text_diff
, stdout
);
3455 got_object_blob_close(blob1
);
3456 got_object_blob_close(blob2
);
3460 static const struct got_error
*
3461 diff_trees(struct got_object_id
*tree_id1
, struct got_object_id
*tree_id2
,
3462 const char *path
, int diff_context
, int ignore_whitespace
,
3463 int force_text_diff
, struct got_repository
*repo
)
3465 const struct got_error
*err
= NULL
;
3466 struct got_tree_object
*tree1
= NULL
, *tree2
= NULL
;
3467 struct got_diff_blob_output_unidiff_arg arg
;
3470 err
= got_object_open_as_tree(&tree1
, repo
, tree_id1
);
3475 err
= got_object_open_as_tree(&tree2
, repo
, tree_id2
);
3479 arg
.diff_context
= diff_context
;
3480 arg
.ignore_whitespace
= ignore_whitespace
;
3481 arg
.force_text_diff
= force_text_diff
;
3482 arg
.outfile
= stdout
;
3483 arg
.line_offsets
= NULL
;
3485 while (path
[0] == '/')
3487 err
= got_diff_tree(tree1
, tree2
, path
, path
, repo
,
3488 got_diff_blob_output_unidiff
, &arg
, 1);
3491 got_object_tree_close(tree1
);
3493 got_object_tree_close(tree2
);
3497 static const struct got_error
*
3498 get_changed_paths(struct got_pathlist_head
*paths
,
3499 struct got_commit_object
*commit
, struct got_repository
*repo
)
3501 const struct got_error
*err
= NULL
;
3502 struct got_object_id
*tree_id1
= NULL
, *tree_id2
= NULL
;
3503 struct got_tree_object
*tree1
= NULL
, *tree2
= NULL
;
3504 struct got_object_qid
*qid
;
3506 qid
= STAILQ_FIRST(got_object_commit_get_parent_ids(commit
));
3508 struct got_commit_object
*pcommit
;
3509 err
= got_object_open_as_commit(&pcommit
, repo
,
3514 tree_id1
= got_object_id_dup(
3515 got_object_commit_get_tree_id(pcommit
));
3516 if (tree_id1
== NULL
) {
3517 got_object_commit_close(pcommit
);
3518 return got_error_from_errno("got_object_id_dup");
3520 got_object_commit_close(pcommit
);
3525 err
= got_object_open_as_tree(&tree1
, repo
, tree_id1
);
3530 tree_id2
= got_object_commit_get_tree_id(commit
);
3531 err
= got_object_open_as_tree(&tree2
, repo
, tree_id2
);
3535 err
= got_diff_tree(tree1
, tree2
, "", "", repo
,
3536 got_diff_tree_collect_changed_paths
, paths
, 0);
3539 got_object_tree_close(tree1
);
3541 got_object_tree_close(tree2
);
3546 static const struct got_error
*
3547 print_patch(struct got_commit_object
*commit
, struct got_object_id
*id
,
3548 const char *path
, int diff_context
, struct got_repository
*repo
)
3550 const struct got_error
*err
= NULL
;
3551 struct got_commit_object
*pcommit
= NULL
;
3552 char *id_str1
= NULL
, *id_str2
= NULL
;
3553 struct got_object_id
*obj_id1
= NULL
, *obj_id2
= NULL
;
3554 struct got_object_qid
*qid
;
3556 qid
= STAILQ_FIRST(got_object_commit_get_parent_ids(commit
));
3558 err
= got_object_open_as_commit(&pcommit
, repo
,
3564 if (path
&& path
[0] != '\0') {
3566 err
= got_object_id_by_path(&obj_id2
, repo
, id
, path
);
3569 err
= got_object_id_str(&id_str2
, obj_id2
);
3575 err
= got_object_id_by_path(&obj_id1
, repo
,
3578 if (err
->code
!= GOT_ERR_NO_TREE_ENTRY
) {
3583 err
= got_object_id_str(&id_str1
, obj_id1
);
3590 err
= got_object_get_type(&obj_type
, repo
, obj_id2
);
3595 printf("diff %s %s\n", id_str1
? id_str1
: "/dev/null", id_str2
);
3597 case GOT_OBJ_TYPE_BLOB
:
3598 err
= diff_blobs(obj_id1
, obj_id2
, path
, diff_context
,
3601 case GOT_OBJ_TYPE_TREE
:
3602 err
= diff_trees(obj_id1
, obj_id2
, path
, diff_context
,
3606 err
= got_error(GOT_ERR_OBJ_TYPE
);
3612 obj_id2
= got_object_commit_get_tree_id(commit
);
3613 err
= got_object_id_str(&id_str2
, obj_id2
);
3617 obj_id1
= got_object_commit_get_tree_id(pcommit
);
3618 err
= got_object_id_str(&id_str1
, obj_id1
);
3622 printf("diff %s %s\n", id_str1
? id_str1
: "/dev/null",
3624 err
= diff_trees(obj_id1
, obj_id2
, "", diff_context
, 0, 0,
3631 got_object_commit_close(pcommit
);
3636 get_datestr(time_t *time
, char *datebuf
)
3638 struct tm mytm
, *tm
;
3641 tm
= gmtime_r(time
, &mytm
);
3644 s
= asctime_r(tm
, datebuf
);
3647 p
= strchr(s
, '\n');
3653 static const struct got_error
*
3654 match_logmsg(int *have_match
, struct got_object_id
*id
,
3655 struct got_commit_object
*commit
, regex_t
*regex
)
3657 const struct got_error
*err
= NULL
;
3658 regmatch_t regmatch
;
3659 char *id_str
= NULL
, *logmsg
= NULL
;
3663 err
= got_object_id_str(&id_str
, id
);
3667 err
= got_object_commit_get_logmsg(&logmsg
, commit
);
3671 if (regexec(regex
, logmsg
, 1, ®match
, 0) == 0)
3680 match_changed_paths(int *have_match
, struct got_pathlist_head
*changed_paths
,
3683 regmatch_t regmatch
;
3684 struct got_pathlist_entry
*pe
;
3688 TAILQ_FOREACH(pe
, changed_paths
, entry
) {
3689 if (regexec(regex
, pe
->path
, 1, ®match
, 0) == 0) {
3696 #define GOT_COMMIT_SEP_STR "-----------------------------------------------\n"
3698 static const struct got_error
*
3699 build_refs_str(char **refs_str
, struct got_reflist_head
*refs
,
3700 struct got_object_id
*id
, struct got_repository
*repo
)
3702 static const struct got_error
*err
= NULL
;
3703 struct got_reflist_entry
*re
;
3709 TAILQ_FOREACH(re
, refs
, entry
) {
3710 struct got_tag_object
*tag
= NULL
;
3711 struct got_object_id
*ref_id
;
3714 name
= got_ref_get_name(re
->ref
);
3715 if (strcmp(name
, GOT_REF_HEAD
) == 0)
3717 if (strncmp(name
, "refs/", 5) == 0)
3719 if (strncmp(name
, "got/", 4) == 0)
3721 if (strncmp(name
, "heads/", 6) == 0)
3723 if (strncmp(name
, "remotes/", 8) == 0) {
3725 s
= strstr(name
, "/" GOT_REF_HEAD
);
3726 if (s
!= NULL
&& s
[strlen(s
)] == '\0')
3729 err
= got_ref_resolve(&ref_id
, repo
, re
->ref
);
3732 if (strncmp(name
, "tags/", 5) == 0) {
3733 err
= got_object_open_as_tag(&tag
, repo
, ref_id
);
3735 if (err
->code
!= GOT_ERR_OBJ_TYPE
) {
3739 /* Ref points at something other than a tag. */
3744 cmp
= got_object_id_cmp(tag
?
3745 got_object_tag_get_object_id(tag
) : ref_id
, id
);
3748 got_object_tag_close(tag
);
3752 if (asprintf(refs_str
, "%s%s%s", s
? s
: "",
3753 s
? ", " : "", name
) == -1) {
3754 err
= got_error_from_errno("asprintf");
3765 static const struct got_error
*
3766 print_commit(struct got_commit_object
*commit
, struct got_object_id
*id
,
3767 struct got_repository
*repo
, const char *path
,
3768 struct got_pathlist_head
*changed_paths
, int show_patch
,
3769 int diff_context
, struct got_reflist_object_id_map
*refs_idmap
,
3770 const char *custom_refs_str
)
3772 const struct got_error
*err
= NULL
;
3773 char *id_str
, *datestr
, *logmsg0
, *logmsg
, *line
;
3775 time_t committer_time
;
3776 const char *author
, *committer
;
3777 char *refs_str
= NULL
;
3779 err
= got_object_id_str(&id_str
, id
);
3783 if (custom_refs_str
== NULL
) {
3784 struct got_reflist_head
*refs
;
3785 refs
= got_reflist_object_id_map_lookup(refs_idmap
, id
);
3787 err
= build_refs_str(&refs_str
, refs
, id
, repo
);
3793 printf(GOT_COMMIT_SEP_STR
);
3794 if (custom_refs_str
)
3795 printf("commit %s (%s)\n", id_str
, custom_refs_str
);
3797 printf("commit %s%s%s%s\n", id_str
, refs_str
? " (" : "",
3798 refs_str
? refs_str
: "", refs_str
? ")" : "");
3803 printf("from: %s\n", got_object_commit_get_author(commit
));
3804 committer_time
= got_object_commit_get_committer_time(commit
);
3805 datestr
= get_datestr(&committer_time
, datebuf
);
3807 printf("date: %s UTC\n", datestr
);
3808 author
= got_object_commit_get_author(commit
);
3809 committer
= got_object_commit_get_committer(commit
);
3810 if (strcmp(author
, committer
) != 0)
3811 printf("via: %s\n", committer
);
3812 if (got_object_commit_get_nparents(commit
) > 1) {
3813 const struct got_object_id_queue
*parent_ids
;
3814 struct got_object_qid
*qid
;
3816 parent_ids
= got_object_commit_get_parent_ids(commit
);
3817 STAILQ_FOREACH(qid
, parent_ids
, entry
) {
3818 err
= got_object_id_str(&id_str
, qid
->id
);
3821 printf("parent %d: %s\n", n
++, id_str
);
3827 err
= got_object_commit_get_logmsg(&logmsg0
, commit
);
3833 line
= strsep(&logmsg
, "\n");
3835 printf(" %s\n", line
);
3839 if (changed_paths
) {
3840 struct got_pathlist_entry
*pe
;
3841 TAILQ_FOREACH(pe
, changed_paths
, entry
) {
3842 struct got_diff_changed_path
*cp
= pe
->data
;
3843 printf(" %c %s\n", cp
->status
, pe
->path
);
3848 err
= print_patch(commit
, id
, path
, diff_context
, repo
);
3853 if (fflush(stdout
) != 0 && err
== NULL
)
3854 err
= got_error_from_errno("fflush");
3861 static const struct got_error
*
3862 print_commits(struct got_object_id
*root_id
, struct got_object_id
*end_id
,
3863 struct got_repository
*repo
, const char *path
, int show_changed_paths
,
3864 int show_patch
, const char *search_pattern
, int diff_context
, int limit
,
3865 int log_branches
, int reverse_display_order
,
3866 struct got_reflist_object_id_map
*refs_idmap
)
3868 const struct got_error
*err
;
3869 struct got_commit_graph
*graph
;
3872 struct got_object_id_queue reversed_commits
;
3873 struct got_object_qid
*qid
;
3874 struct got_commit_object
*commit
;
3875 struct got_pathlist_head changed_paths
;
3876 struct got_pathlist_entry
*pe
;
3878 STAILQ_INIT(&reversed_commits
);
3879 TAILQ_INIT(&changed_paths
);
3881 if (search_pattern
&& regcomp(®ex
, search_pattern
,
3882 REG_EXTENDED
| REG_NOSUB
| REG_NEWLINE
))
3883 return got_error_msg(GOT_ERR_REGEX
, search_pattern
);
3885 err
= got_commit_graph_open(&graph
, path
, !log_branches
);
3888 err
= got_commit_graph_iter_start(graph
, root_id
, repo
,
3889 check_cancelled
, NULL
);
3893 struct got_object_id
*id
;
3895 if (sigint_received
|| sigpipe_received
)
3898 err
= got_commit_graph_iter_next(&id
, graph
, repo
,
3899 check_cancelled
, NULL
);
3901 if (err
->code
== GOT_ERR_ITER_COMPLETED
)
3908 err
= got_object_open_as_commit(&commit
, repo
, id
);
3912 if (show_changed_paths
&& !reverse_display_order
) {
3913 err
= get_changed_paths(&changed_paths
, commit
, repo
);
3918 if (search_pattern
) {
3919 err
= match_logmsg(&have_match
, id
, commit
, ®ex
);
3921 got_object_commit_close(commit
);
3924 if (have_match
== 0 && show_changed_paths
)
3925 match_changed_paths(&have_match
,
3926 &changed_paths
, ®ex
);
3927 if (have_match
== 0) {
3928 got_object_commit_close(commit
);
3929 TAILQ_FOREACH(pe
, &changed_paths
, entry
) {
3930 free((char *)pe
->path
);
3933 got_pathlist_free(&changed_paths
);
3938 if (reverse_display_order
) {
3939 err
= got_object_qid_alloc(&qid
, id
);
3942 STAILQ_INSERT_HEAD(&reversed_commits
, qid
, entry
);
3943 got_object_commit_close(commit
);
3945 err
= print_commit(commit
, id
, repo
, path
,
3946 show_changed_paths
? &changed_paths
: NULL
,
3947 show_patch
, diff_context
, refs_idmap
, NULL
);
3948 got_object_commit_close(commit
);
3952 if ((limit
&& --limit
== 0) ||
3953 (end_id
&& got_object_id_cmp(id
, end_id
) == 0))
3956 TAILQ_FOREACH(pe
, &changed_paths
, entry
) {
3957 free((char *)pe
->path
);
3960 got_pathlist_free(&changed_paths
);
3962 if (reverse_display_order
) {
3963 STAILQ_FOREACH(qid
, &reversed_commits
, entry
) {
3964 err
= got_object_open_as_commit(&commit
, repo
, qid
->id
);
3967 if (show_changed_paths
) {
3968 err
= get_changed_paths(&changed_paths
,
3973 err
= print_commit(commit
, qid
->id
, repo
, path
,
3974 show_changed_paths
? &changed_paths
: NULL
,
3975 show_patch
, diff_context
, refs_idmap
, NULL
);
3976 got_object_commit_close(commit
);
3979 TAILQ_FOREACH(pe
, &changed_paths
, entry
) {
3980 free((char *)pe
->path
);
3983 got_pathlist_free(&changed_paths
);
3987 while (!STAILQ_EMPTY(&reversed_commits
)) {
3988 qid
= STAILQ_FIRST(&reversed_commits
);
3989 STAILQ_REMOVE_HEAD(&reversed_commits
, entry
);
3990 got_object_qid_free(qid
);
3992 TAILQ_FOREACH(pe
, &changed_paths
, entry
) {
3993 free((char *)pe
->path
);
3996 got_pathlist_free(&changed_paths
);
3999 got_commit_graph_close(graph
);
4006 fprintf(stderr
, "usage: %s log [-b] [-c commit] [-C number] [ -l N ] "
4007 "[-p] [-P] [-x commit] [-s search-pattern] [-r repository-path] "
4008 "[-R] [path]\n", getprogname());
4013 get_default_log_limit(void)
4015 const char *got_default_log_limit
;
4019 got_default_log_limit
= getenv("GOT_LOG_DEFAULT_LIMIT");
4020 if (got_default_log_limit
== NULL
)
4022 n
= strtonum(got_default_log_limit
, 0, INT_MAX
, &errstr
);
4028 static const struct got_error
*
4029 cmd_log(int argc
, char *argv
[])
4031 const struct got_error
*error
;
4032 struct got_repository
*repo
= NULL
;
4033 struct got_worktree
*worktree
= NULL
;
4034 struct got_object_id
*start_id
= NULL
, *end_id
= NULL
;
4035 char *repo_path
= NULL
, *path
= NULL
, *cwd
= NULL
, *in_repo_path
= NULL
;
4036 const char *start_commit
= NULL
, *end_commit
= NULL
;
4037 const char *search_pattern
= NULL
;
4038 int diff_context
= -1, ch
;
4039 int show_changed_paths
= 0, show_patch
= 0, limit
= 0, log_branches
= 0;
4040 int reverse_display_order
= 0;
4042 struct got_reflist_head refs
;
4043 struct got_reflist_object_id_map
*refs_idmap
= NULL
;
4048 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
4054 limit
= get_default_log_limit();
4056 while ((ch
= getopt(argc
, argv
, "bpPc:C:l:r:Rs:x:")) != -1) {
4062 show_changed_paths
= 1;
4065 start_commit
= optarg
;
4068 diff_context
= strtonum(optarg
, 0, GOT_DIFF_MAX_CONTEXT
,
4071 err(1, "-C option %s", errstr
);
4074 limit
= strtonum(optarg
, 0, INT_MAX
, &errstr
);
4076 err(1, "-l option %s", errstr
);
4082 repo_path
= realpath(optarg
, NULL
);
4083 if (repo_path
== NULL
)
4084 return got_error_from_errno2("realpath",
4086 got_path_strip_trailing_slashes(repo_path
);
4089 reverse_display_order
= 1;
4092 search_pattern
= optarg
;
4095 end_commit
= optarg
;
4106 if (diff_context
== -1)
4108 else if (!show_patch
)
4109 errx(1, "-C requires -p");
4111 cwd
= getcwd(NULL
, 0);
4113 error
= got_error_from_errno("getcwd");
4117 if (repo_path
== NULL
) {
4118 error
= got_worktree_open(&worktree
, cwd
);
4119 if (error
&& error
->code
!= GOT_ERR_NOT_WORKTREE
)
4126 error
= got_worktree_resolve_path(&path
, worktree
,
4131 path
= strdup(argv
[0]);
4133 error
= got_error_from_errno("strdup");
4137 } else if (argc
!= 0)
4140 if (repo_path
== NULL
) {
4141 repo_path
= worktree
?
4142 strdup(got_worktree_get_repo_path(worktree
)) : strdup(cwd
);
4144 if (repo_path
== NULL
) {
4145 error
= got_error_from_errno("strdup");
4149 error
= got_repo_open(&repo
, repo_path
, NULL
);
4153 error
= apply_unveil(got_repo_get_path(repo
), 1,
4154 worktree
? got_worktree_get_root_path(worktree
) : NULL
);
4158 error
= got_ref_list(&refs
, repo
, NULL
, got_ref_cmp_by_name
, NULL
);
4162 error
= got_reflist_object_id_map_create(&refs_idmap
, &refs
, repo
);
4166 if (start_commit
== NULL
) {
4167 struct got_reference
*head_ref
;
4168 struct got_commit_object
*commit
= NULL
;
4169 error
= got_ref_open(&head_ref
, repo
,
4170 worktree
? got_worktree_get_head_ref_name(worktree
)
4174 error
= got_ref_resolve(&start_id
, repo
, head_ref
);
4175 got_ref_close(head_ref
);
4178 error
= got_object_open_as_commit(&commit
, repo
,
4182 got_object_commit_close(commit
);
4184 error
= got_repo_match_object_id(&start_id
, NULL
,
4185 start_commit
, GOT_OBJ_TYPE_COMMIT
, &refs
, repo
);
4189 if (end_commit
!= NULL
) {
4190 error
= got_repo_match_object_id(&end_id
, NULL
,
4191 end_commit
, GOT_OBJ_TYPE_COMMIT
, &refs
, repo
);
4198 * If a path was specified on the command line it was resolved
4199 * to a path in the work tree above. Prepend the work tree's
4200 * path prefix to obtain the corresponding in-repository path.
4204 prefix
= got_worktree_get_path_prefix(worktree
);
4205 if (asprintf(&in_repo_path
, "%s%s%s", prefix
,
4206 (path
[0] != '\0') ? "/" : "", path
) == -1) {
4207 error
= got_error_from_errno("asprintf");
4212 error
= got_repo_map_path(&in_repo_path
, repo
,
4218 path
= in_repo_path
;
4221 error
= print_commits(start_id
, end_id
, repo
, path
? path
: "",
4222 show_changed_paths
, show_patch
, search_pattern
, diff_context
,
4223 limit
, log_branches
, reverse_display_order
, refs_idmap
);
4229 got_worktree_close(worktree
);
4231 const struct got_error
*close_err
= got_repo_close(repo
);
4236 got_reflist_object_id_map_free(refs_idmap
);
4237 got_ref_list_free(&refs
);
4244 fprintf(stderr
, "usage: %s diff [-a] [-C number] [-r repository-path] "
4245 "[-s] [-w] [object1 object2 | path]\n", getprogname());
4249 struct print_diff_arg
{
4250 struct got_repository
*repo
;
4251 struct got_worktree
*worktree
;
4256 int ignore_whitespace
;
4257 int force_text_diff
;
4261 * Create a file which contains the target path of a symlink so we can feed
4262 * it as content to the diff engine.
4264 static const struct got_error
*
4265 get_symlink_target_file(int *fd
, int dirfd
, const char *de_name
,
4266 const char *abspath
)
4268 const struct got_error
*err
= NULL
;
4269 char target_path
[PATH_MAX
];
4270 ssize_t target_len
, outlen
;
4275 target_len
= readlinkat(dirfd
, de_name
, target_path
, PATH_MAX
);
4276 if (target_len
== -1)
4277 return got_error_from_errno2("readlinkat", abspath
);
4279 target_len
= readlink(abspath
, target_path
, PATH_MAX
);
4280 if (target_len
== -1)
4281 return got_error_from_errno2("readlink", abspath
);
4284 *fd
= got_opentempfd();
4286 return got_error_from_errno("got_opentempfd");
4288 outlen
= write(*fd
, target_path
, target_len
);
4290 err
= got_error_from_errno("got_opentempfd");
4294 if (lseek(*fd
, 0, SEEK_SET
) == -1) {
4295 err
= got_error_from_errno2("lseek", abspath
);
4306 static const struct got_error
*
4307 print_diff(void *arg
, unsigned char status
, unsigned char staged_status
,
4308 const char *path
, struct got_object_id
*blob_id
,
4309 struct got_object_id
*staged_blob_id
, struct got_object_id
*commit_id
,
4310 int dirfd
, const char *de_name
)
4312 struct print_diff_arg
*a
= arg
;
4313 const struct got_error
*err
= NULL
;
4314 struct got_blob_object
*blob1
= NULL
;
4317 char *abspath
= NULL
, *label1
= NULL
;
4320 if (a
->diff_staged
) {
4321 if (staged_status
!= GOT_STATUS_MODIFY
&&
4322 staged_status
!= GOT_STATUS_ADD
&&
4323 staged_status
!= GOT_STATUS_DELETE
)
4326 if (staged_status
== GOT_STATUS_DELETE
)
4328 if (status
== GOT_STATUS_NONEXISTENT
)
4329 return got_error_set_errno(ENOENT
, path
);
4330 if (status
!= GOT_STATUS_MODIFY
&&
4331 status
!= GOT_STATUS_ADD
&&
4332 status
!= GOT_STATUS_DELETE
&&
4333 status
!= GOT_STATUS_CONFLICT
)
4337 if (!a
->header_shown
) {
4338 printf("diff %s %s%s\n", a
->id_str
,
4339 got_worktree_get_root_path(a
->worktree
),
4340 a
->diff_staged
? " (staged changes)" : "");
4341 a
->header_shown
= 1;
4344 if (a
->diff_staged
) {
4345 const char *label1
= NULL
, *label2
= NULL
;
4346 switch (staged_status
) {
4347 case GOT_STATUS_MODIFY
:
4351 case GOT_STATUS_ADD
:
4354 case GOT_STATUS_DELETE
:
4358 return got_error(GOT_ERR_FILE_STATUS
);
4360 return got_diff_objects_as_blobs(NULL
, NULL
, blob_id
,
4361 staged_blob_id
, label1
, label2
, a
->diff_context
,
4362 a
->ignore_whitespace
, a
->force_text_diff
, a
->repo
, stdout
);
4365 if (staged_status
== GOT_STATUS_ADD
||
4366 staged_status
== GOT_STATUS_MODIFY
) {
4368 err
= got_object_open_as_blob(&blob1
, a
->repo
, staged_blob_id
,
4372 err
= got_object_id_str(&id_str
, staged_blob_id
);
4375 if (asprintf(&label1
, "%s (staged)", id_str
) == -1) {
4376 err
= got_error_from_errno("asprintf");
4381 } else if (status
!= GOT_STATUS_ADD
) {
4382 err
= got_object_open_as_blob(&blob1
, a
->repo
, blob_id
, 8192);
4387 if (status
!= GOT_STATUS_DELETE
) {
4388 if (asprintf(&abspath
, "%s/%s",
4389 got_worktree_get_root_path(a
->worktree
), path
) == -1) {
4390 err
= got_error_from_errno("asprintf");
4395 fd
= openat(dirfd
, de_name
, O_RDONLY
| O_NOFOLLOW
);
4397 if (errno
!= ELOOP
) {
4398 err
= got_error_from_errno2("openat",
4402 err
= get_symlink_target_file(&fd
, dirfd
,
4408 fd
= open(abspath
, O_RDONLY
| O_NOFOLLOW
);
4410 if (errno
!= ELOOP
) {
4411 err
= got_error_from_errno2("open",
4415 err
= get_symlink_target_file(&fd
, dirfd
,
4421 if (fstat(fd
, &sb
) == -1) {
4422 err
= got_error_from_errno2("fstat", abspath
);
4425 f2
= fdopen(fd
, "r");
4427 err
= got_error_from_errno2("fdopen", abspath
);
4434 err
= got_diff_blob_file(blob1
, label1
, f2
, sb
.st_size
, path
,
4435 a
->diff_context
, a
->ignore_whitespace
, a
->force_text_diff
, stdout
);
4438 got_object_blob_close(blob1
);
4439 if (f2
&& fclose(f2
) == EOF
&& err
== NULL
)
4440 err
= got_error_from_errno("fclose");
4441 if (fd
!= -1 && close(fd
) == -1 && err
== NULL
)
4442 err
= got_error_from_errno("close");
4447 static const struct got_error
*
4448 cmd_diff(int argc
, char *argv
[])
4450 const struct got_error
*error
;
4451 struct got_repository
*repo
= NULL
;
4452 struct got_worktree
*worktree
= NULL
;
4453 char *cwd
= NULL
, *repo_path
= NULL
;
4454 struct got_object_id
*id1
= NULL
, *id2
= NULL
;
4455 const char *id_str1
= NULL
, *id_str2
= NULL
;
4456 char *label1
= NULL
, *label2
= NULL
;
4458 int diff_context
= 3, diff_staged
= 0, ignore_whitespace
= 0, ch
;
4459 int force_text_diff
= 0;
4462 struct got_reflist_head refs
;
4467 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
4472 while ((ch
= getopt(argc
, argv
, "aC:r:sw")) != -1) {
4475 force_text_diff
= 1;
4478 diff_context
= strtonum(optarg
, 0, GOT_DIFF_MAX_CONTEXT
,
4481 err(1, "-C option %s", errstr
);
4484 repo_path
= realpath(optarg
, NULL
);
4485 if (repo_path
== NULL
)
4486 return got_error_from_errno2("realpath",
4488 got_path_strip_trailing_slashes(repo_path
);
4494 ignore_whitespace
= 1;
4505 cwd
= getcwd(NULL
, 0);
4507 error
= got_error_from_errno("getcwd");
4513 "-r option can't be used when diffing a work tree");
4514 error
= got_worktree_open(&worktree
, cwd
);
4516 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
4517 error
= wrap_not_worktree_error(error
, "diff",
4521 repo_path
= strdup(got_worktree_get_repo_path(worktree
));
4522 if (repo_path
== NULL
) {
4523 error
= got_error_from_errno("strdup");
4527 error
= got_worktree_resolve_path(&path
, worktree
,
4534 error
= got_error_from_errno("strdup");
4538 } else if (argc
== 2) {
4540 errx(1, "-s option can't be used when diffing "
4541 "objects in repository");
4544 if (repo_path
== NULL
) {
4545 error
= got_worktree_open(&worktree
, cwd
);
4546 if (error
&& error
->code
!= GOT_ERR_NOT_WORKTREE
)
4548 repo_path
= strdup(worktree
?
4549 got_worktree_get_repo_path(worktree
) : cwd
);
4550 if (repo_path
== NULL
) {
4551 error
= got_error_from_errno("strdup");
4558 error
= got_repo_open(&repo
, repo_path
, NULL
);
4563 error
= apply_unveil(got_repo_get_path(repo
), 1,
4564 worktree
? got_worktree_get_root_path(worktree
) : NULL
);
4569 struct print_diff_arg arg
;
4570 struct got_pathlist_head paths
;
4575 error
= got_object_id_str(&id_str
,
4576 got_worktree_get_base_commit_id(worktree
));
4580 arg
.worktree
= worktree
;
4581 arg
.diff_context
= diff_context
;
4582 arg
.id_str
= id_str
;
4583 arg
.header_shown
= 0;
4584 arg
.diff_staged
= diff_staged
;
4585 arg
.ignore_whitespace
= ignore_whitespace
;
4586 arg
.force_text_diff
= force_text_diff
;
4588 error
= got_pathlist_append(&paths
, path
, NULL
);
4592 error
= got_worktree_status(worktree
, &paths
, repo
, 0,
4593 print_diff
, &arg
, check_cancelled
, NULL
);
4595 got_pathlist_free(&paths
);
4599 error
= got_ref_list(&refs
, repo
, NULL
, got_ref_cmp_by_name
, NULL
);
4603 error
= got_repo_match_object_id(&id1
, &label1
, id_str1
,
4604 GOT_OBJ_TYPE_ANY
, &refs
, repo
);
4608 error
= got_repo_match_object_id(&id2
, &label2
, id_str2
,
4609 GOT_OBJ_TYPE_ANY
, &refs
, repo
);
4613 error
= got_object_get_type(&type1
, repo
, id1
);
4617 error
= got_object_get_type(&type2
, repo
, id2
);
4621 if (type1
!= type2
) {
4622 error
= got_error(GOT_ERR_OBJ_TYPE
);
4627 case GOT_OBJ_TYPE_BLOB
:
4628 error
= got_diff_objects_as_blobs(NULL
, NULL
, id1
, id2
,
4629 NULL
, NULL
, diff_context
, ignore_whitespace
,
4630 force_text_diff
, repo
, stdout
);
4632 case GOT_OBJ_TYPE_TREE
:
4633 error
= got_diff_objects_as_trees(NULL
, NULL
, id1
, id2
,
4634 "", "", diff_context
, ignore_whitespace
, force_text_diff
,
4637 case GOT_OBJ_TYPE_COMMIT
:
4638 printf("diff %s %s\n", label1
, label2
);
4639 error
= got_diff_objects_as_commits(NULL
, NULL
, id1
, id2
,
4640 diff_context
, ignore_whitespace
, force_text_diff
, repo
,
4644 error
= got_error(GOT_ERR_OBJ_TYPE
);
4653 got_worktree_close(worktree
);
4655 const struct got_error
*close_err
= got_repo_close(repo
);
4659 got_ref_list_free(&refs
);
4667 "usage: %s blame [-c commit] [-r repository-path] path\n",
4676 char datebuf
[11]; /* YYYY-MM-DD + NUL */
4679 struct blame_cb_args
{
4680 struct blame_line
*lines
;
4684 off_t
*line_offsets
;
4686 struct got_repository
*repo
;
4689 static const struct got_error
*
4690 blame_cb(void *arg
, int nlines
, int lineno
, struct got_object_id
*id
)
4692 const struct got_error
*err
= NULL
;
4693 struct blame_cb_args
*a
= arg
;
4694 struct blame_line
*bline
;
4696 size_t linesize
= 0;
4697 struct got_commit_object
*commit
= NULL
;
4700 time_t committer_time
;
4702 if (nlines
!= a
->nlines
||
4703 (lineno
!= -1 && lineno
< 1) || lineno
> a
->nlines
)
4704 return got_error(GOT_ERR_RANGE
);
4706 if (sigint_received
)
4707 return got_error(GOT_ERR_ITER_COMPLETED
);
4710 return NULL
; /* no change in this commit */
4712 /* Annotate this line. */
4713 bline
= &a
->lines
[lineno
- 1];
4714 if (bline
->annotated
)
4716 err
= got_object_id_str(&bline
->id_str
, id
);
4720 err
= got_object_open_as_commit(&commit
, a
->repo
, id
);
4724 bline
->committer
= strdup(got_object_commit_get_committer(commit
));
4725 if (bline
->committer
== NULL
) {
4726 err
= got_error_from_errno("strdup");
4730 committer_time
= got_object_commit_get_committer_time(commit
);
4731 if (gmtime_r(&committer_time
, &tm
) == NULL
)
4732 return got_error_from_errno("gmtime_r");
4733 if (strftime(bline
->datebuf
, sizeof(bline
->datebuf
), "%G-%m-%d",
4735 err
= got_error(GOT_ERR_NO_SPACE
);
4738 bline
->annotated
= 1;
4740 /* Print lines annotated so far. */
4741 bline
= &a
->lines
[a
->lineno_cur
- 1];
4742 if (!bline
->annotated
)
4745 offset
= a
->line_offsets
[a
->lineno_cur
- 1];
4746 if (fseeko(a
->f
, offset
, SEEK_SET
) == -1) {
4747 err
= got_error_from_errno("fseeko");
4751 while (bline
->annotated
) {
4752 char *smallerthan
, *at
, *nl
, *committer
;
4755 if (getline(&line
, &linesize
, a
->f
) == -1) {
4757 err
= got_error_from_errno("getline");
4761 committer
= bline
->committer
;
4762 smallerthan
= strchr(committer
, '<');
4763 if (smallerthan
&& smallerthan
[1] != '\0')
4764 committer
= smallerthan
+ 1;
4765 at
= strchr(committer
, '@');
4768 len
= strlen(committer
);
4770 committer
[8] = '\0';
4772 nl
= strchr(line
, '\n');
4775 printf("%.*d) %.8s %s %-8s %s\n", a
->nlines_prec
, a
->lineno_cur
,
4776 bline
->id_str
, bline
->datebuf
, committer
, line
);
4779 bline
= &a
->lines
[a
->lineno_cur
- 1];
4783 got_object_commit_close(commit
);
4788 static const struct got_error
*
4789 cmd_blame(int argc
, char *argv
[])
4791 const struct got_error
*error
;
4792 struct got_repository
*repo
= NULL
;
4793 struct got_worktree
*worktree
= NULL
;
4794 char *path
, *cwd
= NULL
, *repo_path
= NULL
, *in_repo_path
= NULL
;
4795 char *link_target
= NULL
;
4796 struct got_object_id
*obj_id
= NULL
;
4797 struct got_object_id
*commit_id
= NULL
;
4798 struct got_blob_object
*blob
= NULL
;
4799 char *commit_id_str
= NULL
;
4800 struct blame_cb_args bca
;
4801 int ch
, obj_type
, i
;
4804 memset(&bca
, 0, sizeof(bca
));
4807 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
4812 while ((ch
= getopt(argc
, argv
, "c:r:")) != -1) {
4815 commit_id_str
= optarg
;
4818 repo_path
= realpath(optarg
, NULL
);
4819 if (repo_path
== NULL
)
4820 return got_error_from_errno2("realpath",
4822 got_path_strip_trailing_slashes(repo_path
);
4838 cwd
= getcwd(NULL
, 0);
4840 error
= got_error_from_errno("getcwd");
4843 if (repo_path
== NULL
) {
4844 error
= got_worktree_open(&worktree
, cwd
);
4845 if (error
&& error
->code
!= GOT_ERR_NOT_WORKTREE
)
4851 strdup(got_worktree_get_repo_path(worktree
));
4852 if (repo_path
== NULL
) {
4853 error
= got_error_from_errno("strdup");
4858 repo_path
= strdup(cwd
);
4859 if (repo_path
== NULL
) {
4860 error
= got_error_from_errno("strdup");
4866 error
= got_repo_open(&repo
, repo_path
, NULL
);
4871 const char *prefix
= got_worktree_get_path_prefix(worktree
);
4874 error
= got_worktree_resolve_path(&p
, worktree
, path
);
4877 if (asprintf(&in_repo_path
, "%s%s%s", prefix
,
4878 (p
[0] != '\0' && !got_path_is_root_dir(prefix
)) ? "/" : "",
4880 error
= got_error_from_errno("asprintf");
4885 error
= apply_unveil(got_repo_get_path(repo
), 1, NULL
);
4887 error
= apply_unveil(got_repo_get_path(repo
), 1, NULL
);
4890 error
= got_repo_map_path(&in_repo_path
, repo
, path
);
4895 if (commit_id_str
== NULL
) {
4896 struct got_reference
*head_ref
;
4897 error
= got_ref_open(&head_ref
, repo
, worktree
?
4898 got_worktree_get_head_ref_name(worktree
) : GOT_REF_HEAD
, 0);
4901 error
= got_ref_resolve(&commit_id
, repo
, head_ref
);
4902 got_ref_close(head_ref
);
4906 struct got_reflist_head refs
;
4908 error
= got_ref_list(&refs
, repo
, NULL
, got_ref_cmp_by_name
,
4912 error
= got_repo_match_object_id(&commit_id
, NULL
,
4913 commit_id_str
, GOT_OBJ_TYPE_COMMIT
, &refs
, repo
);
4914 got_ref_list_free(&refs
);
4919 error
= got_object_resolve_symlinks(&link_target
, in_repo_path
,
4924 error
= got_object_id_by_path(&obj_id
, repo
, commit_id
,
4925 link_target
? link_target
: in_repo_path
);
4929 error
= got_object_get_type(&obj_type
, repo
, obj_id
);
4933 if (obj_type
!= GOT_OBJ_TYPE_BLOB
) {
4934 error
= got_error_path(link_target
? link_target
: in_repo_path
,
4939 error
= got_object_open_as_blob(&blob
, repo
, obj_id
, 8192);
4942 bca
.f
= got_opentemp();
4943 if (bca
.f
== NULL
) {
4944 error
= got_error_from_errno("got_opentemp");
4947 error
= got_object_blob_dump_to_file(&filesize
, &bca
.nlines
,
4948 &bca
.line_offsets
, bca
.f
, blob
);
4949 if (error
|| bca
.nlines
== 0)
4952 /* Don't include \n at EOF in the blame line count. */
4953 if (bca
.line_offsets
[bca
.nlines
- 1] == filesize
)
4956 bca
.lines
= calloc(bca
.nlines
, sizeof(*bca
.lines
));
4957 if (bca
.lines
== NULL
) {
4958 error
= got_error_from_errno("calloc");
4962 bca
.nlines_prec
= 0;
4970 error
= got_blame(link_target
? link_target
: in_repo_path
, commit_id
,
4971 repo
, blame_cb
, &bca
, check_cancelled
, NULL
);
4980 got_object_blob_close(blob
);
4982 got_worktree_close(worktree
);
4984 const struct got_error
*close_err
= got_repo_close(repo
);
4989 for (i
= 0; i
< bca
.nlines
; i
++) {
4990 struct blame_line
*bline
= &bca
.lines
[i
];
4991 free(bline
->id_str
);
4992 free(bline
->committer
);
4996 free(bca
.line_offsets
);
4997 if (bca
.f
&& fclose(bca
.f
) == EOF
&& error
== NULL
)
4998 error
= got_error_from_errno("fclose");
5006 "usage: %s tree [-c commit] [-r repository-path] [-iR] [path]\n",
5011 static const struct got_error
*
5012 print_entry(struct got_tree_entry
*te
, const char *id
, const char *path
,
5013 const char *root_path
, struct got_repository
*repo
)
5015 const struct got_error
*err
= NULL
;
5016 int is_root_path
= (strcmp(path
, root_path
) == 0);
5017 const char *modestr
= "";
5018 mode_t mode
= got_tree_entry_get_mode(te
);
5019 char *link_target
= NULL
;
5021 path
+= strlen(root_path
);
5022 while (path
[0] == '/')
5025 if (got_object_tree_entry_is_submodule(te
))
5027 else if (S_ISLNK(mode
)) {
5030 err
= got_tree_entry_get_symlink_target(&link_target
, te
, repo
);
5033 for (i
= 0; i
< strlen(link_target
); i
++) {
5034 if (!isprint((unsigned char)link_target
[i
]))
5035 link_target
[i
] = '?';
5040 else if (S_ISDIR(mode
))
5042 else if (mode
& S_IXUSR
)
5045 printf("%s%s%s%s%s%s%s\n", id
? id
: "", path
,
5046 is_root_path
? "" : "/", got_tree_entry_get_name(te
), modestr
,
5047 link_target
? " -> ": "", link_target
? link_target
: "");
5053 static const struct got_error
*
5054 print_tree(const char *path
, struct got_object_id
*commit_id
,
5055 int show_ids
, int recurse
, const char *root_path
,
5056 struct got_repository
*repo
)
5058 const struct got_error
*err
= NULL
;
5059 struct got_object_id
*tree_id
= NULL
;
5060 struct got_tree_object
*tree
= NULL
;
5063 err
= got_object_id_by_path(&tree_id
, repo
, commit_id
, path
);
5067 err
= got_object_open_as_tree(&tree
, repo
, tree_id
);
5070 nentries
= got_object_tree_get_nentries(tree
);
5071 for (i
= 0; i
< nentries
; i
++) {
5072 struct got_tree_entry
*te
;
5075 if (sigint_received
|| sigpipe_received
)
5078 te
= got_object_tree_get_entry(tree
, i
);
5081 err
= got_object_id_str(&id_str
,
5082 got_tree_entry_get_id(te
));
5085 if (asprintf(&id
, "%s ", id_str
) == -1) {
5086 err
= got_error_from_errno("asprintf");
5092 err
= print_entry(te
, id
, path
, root_path
, repo
);
5097 if (recurse
&& S_ISDIR(got_tree_entry_get_mode(te
))) {
5099 if (asprintf(&child_path
, "%s%s%s", path
,
5100 path
[0] == '/' && path
[1] == '\0' ? "" : "/",
5101 got_tree_entry_get_name(te
)) == -1) {
5102 err
= got_error_from_errno("asprintf");
5105 err
= print_tree(child_path
, commit_id
, show_ids
, 1,
5114 got_object_tree_close(tree
);
5119 static const struct got_error
*
5120 cmd_tree(int argc
, char *argv
[])
5122 const struct got_error
*error
;
5123 struct got_repository
*repo
= NULL
;
5124 struct got_worktree
*worktree
= NULL
;
5125 const char *path
, *refname
= NULL
;
5126 char *cwd
= NULL
, *repo_path
= NULL
, *in_repo_path
= NULL
;
5127 struct got_object_id
*commit_id
= NULL
;
5128 char *commit_id_str
= NULL
;
5129 int show_ids
= 0, recurse
= 0;
5133 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
5138 while ((ch
= getopt(argc
, argv
, "c:r:iR")) != -1) {
5141 commit_id_str
= optarg
;
5144 repo_path
= realpath(optarg
, NULL
);
5145 if (repo_path
== NULL
)
5146 return got_error_from_errno2("realpath",
5148 got_path_strip_trailing_slashes(repo_path
);
5172 cwd
= getcwd(NULL
, 0);
5174 error
= got_error_from_errno("getcwd");
5177 if (repo_path
== NULL
) {
5178 error
= got_worktree_open(&worktree
, cwd
);
5179 if (error
&& error
->code
!= GOT_ERR_NOT_WORKTREE
)
5185 strdup(got_worktree_get_repo_path(worktree
));
5186 if (repo_path
== NULL
)
5187 error
= got_error_from_errno("strdup");
5191 repo_path
= strdup(cwd
);
5192 if (repo_path
== NULL
) {
5193 error
= got_error_from_errno("strdup");
5199 error
= got_repo_open(&repo
, repo_path
, NULL
);
5204 const char *prefix
= got_worktree_get_path_prefix(worktree
);
5209 error
= got_worktree_resolve_path(&p
, worktree
, path
);
5212 if (asprintf(&in_repo_path
, "%s%s%s", prefix
,
5213 (p
[0] != '\0' && !got_path_is_root_dir(prefix
)) ? "/" : "",
5215 error
= got_error_from_errno("asprintf");
5220 error
= apply_unveil(got_repo_get_path(repo
), 1, NULL
);
5224 error
= apply_unveil(got_repo_get_path(repo
), 1, NULL
);
5229 error
= got_repo_map_path(&in_repo_path
, repo
, path
);
5234 if (commit_id_str
== NULL
) {
5235 struct got_reference
*head_ref
;
5237 refname
= got_worktree_get_head_ref_name(worktree
);
5239 refname
= GOT_REF_HEAD
;
5240 error
= got_ref_open(&head_ref
, repo
, refname
, 0);
5243 error
= got_ref_resolve(&commit_id
, repo
, head_ref
);
5244 got_ref_close(head_ref
);
5248 struct got_reflist_head refs
;
5250 error
= got_ref_list(&refs
, repo
, NULL
, got_ref_cmp_by_name
,
5254 error
= got_repo_match_object_id(&commit_id
, NULL
,
5255 commit_id_str
, GOT_OBJ_TYPE_COMMIT
, &refs
, repo
);
5256 got_ref_list_free(&refs
);
5261 error
= print_tree(in_repo_path
, commit_id
, show_ids
, recurse
,
5262 in_repo_path
, repo
);
5269 got_worktree_close(worktree
);
5271 const struct got_error
*close_err
= got_repo_close(repo
);
5281 fprintf(stderr
, "usage: %s status [-I] [-s status-codes ] "
5282 "[-S status-codes] [path ...]\n", getprogname());
5286 struct got_status_arg
{
5291 static const struct got_error
*
5292 print_status(void *arg
, unsigned char status
, unsigned char staged_status
,
5293 const char *path
, struct got_object_id
*blob_id
,
5294 struct got_object_id
*staged_blob_id
, struct got_object_id
*commit_id
,
5295 int dirfd
, const char *de_name
)
5297 struct got_status_arg
*st
= arg
;
5299 if (status
== staged_status
&& (status
== GOT_STATUS_DELETE
))
5300 status
= GOT_STATUS_NO_CHANGE
;
5301 if (st
!= NULL
&& st
->status_codes
) {
5302 size_t ncodes
= strlen(st
->status_codes
);
5305 for (i
= 0; i
< ncodes
; i
++) {
5307 if (status
== st
->status_codes
[i
] ||
5308 staged_status
== st
->status_codes
[i
]) {
5313 if (status
== st
->status_codes
[i
] ||
5314 staged_status
== st
->status_codes
[i
])
5319 if (st
->suppress
&& j
== 0)
5326 printf("%c%c %s\n", status
, staged_status
, path
);
5330 static const struct got_error
*
5331 cmd_status(int argc
, char *argv
[])
5333 const struct got_error
*error
= NULL
;
5334 struct got_repository
*repo
= NULL
;
5335 struct got_worktree
*worktree
= NULL
;
5336 struct got_status_arg st
;
5338 struct got_pathlist_head paths
;
5339 struct got_pathlist_entry
*pe
;
5340 int ch
, i
, no_ignores
= 0;
5344 memset(&st
, 0, sizeof(st
));
5345 st
.status_codes
= NULL
;
5348 while ((ch
= getopt(argc
, argv
, "Is:S:")) != -1) {
5354 if (st
.status_codes
!= NULL
&& st
.suppress
== 0)
5355 option_conflict('S', 's');
5359 for (i
= 0; i
< strlen(optarg
); i
++) {
5360 switch (optarg
[i
]) {
5361 case GOT_STATUS_MODIFY
:
5362 case GOT_STATUS_ADD
:
5363 case GOT_STATUS_DELETE
:
5364 case GOT_STATUS_CONFLICT
:
5365 case GOT_STATUS_MISSING
:
5366 case GOT_STATUS_OBSTRUCTED
:
5367 case GOT_STATUS_UNVERSIONED
:
5368 case GOT_STATUS_MODE_CHANGE
:
5369 case GOT_STATUS_NONEXISTENT
:
5372 errx(1, "invalid status code '%c'",
5376 if (ch
== 's' && st
.suppress
)
5377 option_conflict('s', 'S');
5378 st
.status_codes
= optarg
;
5390 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
5394 cwd
= getcwd(NULL
, 0);
5396 error
= got_error_from_errno("getcwd");
5400 error
= got_worktree_open(&worktree
, cwd
);
5402 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
5403 error
= wrap_not_worktree_error(error
, "status", cwd
);
5407 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
5412 error
= apply_unveil(got_repo_get_path(repo
), 1,
5413 got_worktree_get_root_path(worktree
));
5417 error
= get_worktree_paths_from_argv(&paths
, argc
, argv
, worktree
);
5421 error
= got_worktree_status(worktree
, &paths
, repo
, no_ignores
,
5422 print_status
, &st
, check_cancelled
, NULL
);
5424 TAILQ_FOREACH(pe
, &paths
, entry
)
5425 free((char *)pe
->path
);
5426 got_pathlist_free(&paths
);
5435 "usage: %s ref [-r repository] [-l] [-c object] [-s reference] "
5441 static const struct got_error
*
5442 list_refs(struct got_repository
*repo
, const char *refname
)
5444 static const struct got_error
*err
= NULL
;
5445 struct got_reflist_head refs
;
5446 struct got_reflist_entry
*re
;
5449 err
= got_ref_list(&refs
, repo
, refname
, got_ref_cmp_by_name
, NULL
);
5453 TAILQ_FOREACH(re
, &refs
, entry
) {
5455 refstr
= got_ref_to_str(re
->ref
);
5457 return got_error_from_errno("got_ref_to_str");
5458 printf("%s: %s\n", got_ref_get_name(re
->ref
), refstr
);
5462 got_ref_list_free(&refs
);
5466 static const struct got_error
*
5467 delete_ref_by_name(struct got_repository
*repo
, const char *refname
)
5469 const struct got_error
*err
;
5470 struct got_reference
*ref
;
5472 err
= got_ref_open(&ref
, repo
, refname
, 0);
5476 err
= delete_ref(repo
, ref
);
5481 static const struct got_error
*
5482 add_ref(struct got_repository
*repo
, const char *refname
, const char *target
)
5484 const struct got_error
*err
= NULL
;
5485 struct got_object_id
*id
;
5486 struct got_reference
*ref
= NULL
;
5489 * Don't let the user create a reference name with a leading '-'.
5490 * While technically a valid reference name, this case is usually
5491 * an unintended typo.
5493 if (refname
[0] == '-')
5494 return got_error_path(refname
, GOT_ERR_REF_NAME_MINUS
);
5496 err
= got_repo_match_object_id_prefix(&id
, target
, GOT_OBJ_TYPE_ANY
,
5499 struct got_reference
*target_ref
;
5501 if (err
->code
!= GOT_ERR_BAD_OBJ_ID_STR
)
5503 err
= got_ref_open(&target_ref
, repo
, target
, 0);
5506 err
= got_ref_resolve(&id
, repo
, target_ref
);
5507 got_ref_close(target_ref
);
5512 err
= got_ref_alloc(&ref
, refname
, id
);
5516 err
= got_ref_write(ref
, repo
);
5524 static const struct got_error
*
5525 add_symref(struct got_repository
*repo
, const char *refname
, const char *target
)
5527 const struct got_error
*err
= NULL
;
5528 struct got_reference
*ref
= NULL
;
5529 struct got_reference
*target_ref
= NULL
;
5532 * Don't let the user create a reference name with a leading '-'.
5533 * While technically a valid reference name, this case is usually
5534 * an unintended typo.
5536 if (refname
[0] == '-')
5537 return got_error_path(refname
, GOT_ERR_REF_NAME_MINUS
);
5539 err
= got_ref_open(&target_ref
, repo
, target
, 0);
5543 err
= got_ref_alloc_symref(&ref
, refname
, target_ref
);
5547 err
= got_ref_write(ref
, repo
);
5550 got_ref_close(target_ref
);
5556 static const struct got_error
*
5557 cmd_ref(int argc
, char *argv
[])
5559 const struct got_error
*error
= NULL
;
5560 struct got_repository
*repo
= NULL
;
5561 struct got_worktree
*worktree
= NULL
;
5562 char *cwd
= NULL
, *repo_path
= NULL
;
5563 int ch
, do_list
= 0, do_delete
= 0;
5564 const char *obj_arg
= NULL
, *symref_target
= NULL
;
5565 char *refname
= NULL
;
5567 while ((ch
= getopt(argc
, argv
, "c:dr:ls:")) != -1) {
5576 repo_path
= realpath(optarg
, NULL
);
5577 if (repo_path
== NULL
)
5578 return got_error_from_errno2("realpath",
5580 got_path_strip_trailing_slashes(repo_path
);
5586 symref_target
= optarg
;
5594 if (obj_arg
&& do_list
)
5595 option_conflict('c', 'l');
5596 if (obj_arg
&& do_delete
)
5597 option_conflict('c', 'd');
5598 if (obj_arg
&& symref_target
)
5599 option_conflict('c', 's');
5600 if (symref_target
&& do_delete
)
5601 option_conflict('s', 'd');
5602 if (symref_target
&& do_list
)
5603 option_conflict('s', 'l');
5604 if (do_delete
&& do_list
)
5605 option_conflict('d', 'l');
5611 if (argc
!= 0 && argc
!= 1)
5614 refname
= strdup(argv
[0]);
5615 if (refname
== NULL
) {
5616 error
= got_error_from_errno("strdup");
5623 refname
= strdup(argv
[0]);
5624 if (refname
== NULL
) {
5625 error
= got_error_from_errno("strdup");
5631 got_path_strip_trailing_slashes(refname
);
5635 if (pledge("stdio rpath wpath flock proc exec sendfd unveil",
5639 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
5640 "sendfd unveil", NULL
) == -1)
5644 cwd
= getcwd(NULL
, 0);
5646 error
= got_error_from_errno("getcwd");
5650 if (repo_path
== NULL
) {
5651 error
= got_worktree_open(&worktree
, cwd
);
5652 if (error
&& error
->code
!= GOT_ERR_NOT_WORKTREE
)
5658 strdup(got_worktree_get_repo_path(worktree
));
5659 if (repo_path
== NULL
)
5660 error
= got_error_from_errno("strdup");
5664 repo_path
= strdup(cwd
);
5665 if (repo_path
== NULL
) {
5666 error
= got_error_from_errno("strdup");
5672 error
= got_repo_open(&repo
, repo_path
, NULL
);
5676 error
= apply_unveil(got_repo_get_path(repo
), do_list
,
5677 worktree
? got_worktree_get_root_path(worktree
) : NULL
);
5682 error
= list_refs(repo
, refname
);
5684 error
= delete_ref_by_name(repo
, refname
);
5685 else if (symref_target
)
5686 error
= add_symref(repo
, refname
, symref_target
);
5688 if (obj_arg
== NULL
)
5690 error
= add_ref(repo
, refname
, obj_arg
);
5695 const struct got_error
*close_err
= got_repo_close(repo
);
5700 got_worktree_close(worktree
);
5710 "usage: %s branch [-c commit] [-d] [-r repository] [-l] [-n] "
5711 "[name]\n", getprogname());
5715 static const struct got_error
*
5716 list_branch(struct got_repository
*repo
, struct got_worktree
*worktree
,
5717 struct got_reference
*ref
)
5719 const struct got_error
*err
= NULL
;
5720 const char *refname
, *marker
= " ";
5723 refname
= got_ref_get_name(ref
);
5724 if (worktree
&& strcmp(refname
,
5725 got_worktree_get_head_ref_name(worktree
)) == 0) {
5726 struct got_object_id
*id
= NULL
;
5728 err
= got_ref_resolve(&id
, repo
, ref
);
5731 if (got_object_id_cmp(id
,
5732 got_worktree_get_base_commit_id(worktree
)) == 0)
5739 if (strncmp(refname
, "refs/heads/", 11) == 0)
5741 if (strncmp(refname
, "refs/got/worktree/", 18) == 0)
5743 if (strncmp(refname
, "refs/remotes/", 13) == 0)
5746 refstr
= got_ref_to_str(ref
);
5748 return got_error_from_errno("got_ref_to_str");
5750 printf("%s%s: %s\n", marker
, refname
, refstr
);
5755 static const struct got_error
*
5756 show_current_branch(struct got_repository
*repo
, struct got_worktree
*worktree
)
5758 const char *refname
;
5760 if (worktree
== NULL
)
5761 return got_error(GOT_ERR_NOT_WORKTREE
);
5763 refname
= got_worktree_get_head_ref_name(worktree
);
5765 if (strncmp(refname
, "refs/heads/", 11) == 0)
5767 if (strncmp(refname
, "refs/got/worktree/", 18) == 0)
5770 printf("%s\n", refname
);
5775 static const struct got_error
*
5776 list_branches(struct got_repository
*repo
, struct got_worktree
*worktree
)
5778 static const struct got_error
*err
= NULL
;
5779 struct got_reflist_head refs
;
5780 struct got_reflist_entry
*re
;
5781 struct got_reference
*temp_ref
= NULL
;
5782 int rebase_in_progress
, histedit_in_progress
;
5787 err
= got_worktree_rebase_in_progress(&rebase_in_progress
,
5792 err
= got_worktree_histedit_in_progress(&histedit_in_progress
,
5797 if (rebase_in_progress
|| histedit_in_progress
) {
5798 err
= got_ref_open(&temp_ref
, repo
,
5799 got_worktree_get_head_ref_name(worktree
), 0);
5802 list_branch(repo
, worktree
, temp_ref
);
5803 got_ref_close(temp_ref
);
5807 err
= got_ref_list(&refs
, repo
, "refs/heads",
5808 got_ref_cmp_by_name
, NULL
);
5812 TAILQ_FOREACH(re
, &refs
, entry
)
5813 list_branch(repo
, worktree
, re
->ref
);
5815 got_ref_list_free(&refs
);
5817 err
= got_ref_list(&refs
, repo
, "refs/remotes",
5818 got_ref_cmp_by_name
, NULL
);
5822 TAILQ_FOREACH(re
, &refs
, entry
)
5823 list_branch(repo
, worktree
, re
->ref
);
5825 got_ref_list_free(&refs
);
5830 static const struct got_error
*
5831 delete_branch(struct got_repository
*repo
, struct got_worktree
*worktree
,
5832 const char *branch_name
)
5834 const struct got_error
*err
= NULL
;
5835 struct got_reference
*ref
= NULL
;
5836 char *refname
, *remote_refname
= NULL
;
5838 if (strncmp(branch_name
, "refs/", 5) == 0)
5840 if (strncmp(branch_name
, "heads/", 6) == 0)
5842 else if (strncmp(branch_name
, "remotes/", 8) == 0)
5845 if (asprintf(&refname
, "refs/heads/%s", branch_name
) == -1)
5846 return got_error_from_errno("asprintf");
5848 if (asprintf(&remote_refname
, "refs/remotes/%s",
5849 branch_name
) == -1) {
5850 err
= got_error_from_errno("asprintf");
5854 err
= got_ref_open(&ref
, repo
, refname
, 0);
5856 const struct got_error
*err2
;
5857 if (err
->code
!= GOT_ERR_NOT_REF
)
5860 * Keep 'err' intact such that if neither branch exists
5861 * we report "refs/heads" rather than "refs/remotes" in
5862 * our error message.
5864 err2
= got_ref_open(&ref
, repo
, remote_refname
, 0);
5871 strcmp(got_worktree_get_head_ref_name(worktree
),
5872 got_ref_get_name(ref
)) == 0) {
5873 err
= got_error_msg(GOT_ERR_SAME_BRANCH
,
5874 "will not delete this work tree's current branch");
5878 err
= delete_ref(repo
, ref
);
5883 free(remote_refname
);
5887 static const struct got_error
*
5888 add_branch(struct got_repository
*repo
, const char *branch_name
,
5889 struct got_object_id
*base_commit_id
)
5891 const struct got_error
*err
= NULL
;
5892 struct got_reference
*ref
= NULL
;
5893 char *base_refname
= NULL
, *refname
= NULL
;
5896 * Don't let the user create a branch name with a leading '-'.
5897 * While technically a valid reference name, this case is usually
5898 * an unintended typo.
5900 if (branch_name
[0] == '-')
5901 return got_error_path(branch_name
, GOT_ERR_REF_NAME_MINUS
);
5903 if (strncmp(branch_name
, "refs/heads/", 11) == 0)
5906 if (asprintf(&refname
, "refs/heads/%s", branch_name
) == -1) {
5907 err
= got_error_from_errno("asprintf");
5911 err
= got_ref_open(&ref
, repo
, refname
, 0);
5913 err
= got_error(GOT_ERR_BRANCH_EXISTS
);
5915 } else if (err
->code
!= GOT_ERR_NOT_REF
)
5918 err
= got_ref_alloc(&ref
, refname
, base_commit_id
);
5922 err
= got_ref_write(ref
, repo
);
5931 static const struct got_error
*
5932 cmd_branch(int argc
, char *argv
[])
5934 const struct got_error
*error
= NULL
;
5935 struct got_repository
*repo
= NULL
;
5936 struct got_worktree
*worktree
= NULL
;
5937 char *cwd
= NULL
, *repo_path
= NULL
;
5938 int ch
, do_list
= 0, do_show
= 0, do_update
= 1;
5939 const char *delref
= NULL
, *commit_id_arg
= NULL
;
5940 struct got_reference
*ref
= NULL
;
5941 struct got_pathlist_head paths
;
5942 struct got_pathlist_entry
*pe
;
5943 struct got_object_id
*commit_id
= NULL
;
5944 char *commit_id_str
= NULL
;
5948 while ((ch
= getopt(argc
, argv
, "c:d:r:ln")) != -1) {
5951 commit_id_arg
= optarg
;
5957 repo_path
= realpath(optarg
, NULL
);
5958 if (repo_path
== NULL
)
5959 return got_error_from_errno2("realpath",
5961 got_path_strip_trailing_slashes(repo_path
);
5975 if (do_list
&& delref
)
5976 option_conflict('l', 'd');
5981 if (!do_list
&& !delref
&& argc
== 0)
5984 if ((do_list
|| delref
|| do_show
) && commit_id_arg
!= NULL
)
5985 errx(1, "-c option can only be used when creating a branch");
5987 if (do_list
|| delref
) {
5990 } else if (!do_show
&& argc
!= 1)
5994 if (do_list
|| do_show
) {
5995 if (pledge("stdio rpath wpath flock proc exec sendfd unveil",
5999 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
6000 "sendfd unveil", NULL
) == -1)
6004 cwd
= getcwd(NULL
, 0);
6006 error
= got_error_from_errno("getcwd");
6010 if (repo_path
== NULL
) {
6011 error
= got_worktree_open(&worktree
, cwd
);
6012 if (error
&& error
->code
!= GOT_ERR_NOT_WORKTREE
)
6018 strdup(got_worktree_get_repo_path(worktree
));
6019 if (repo_path
== NULL
)
6020 error
= got_error_from_errno("strdup");
6024 repo_path
= strdup(cwd
);
6025 if (repo_path
== NULL
) {
6026 error
= got_error_from_errno("strdup");
6032 error
= got_repo_open(&repo
, repo_path
, NULL
);
6036 error
= apply_unveil(got_repo_get_path(repo
), do_list
,
6037 worktree
? got_worktree_get_root_path(worktree
) : NULL
);
6042 error
= show_current_branch(repo
, worktree
);
6044 error
= list_branches(repo
, worktree
);
6046 error
= delete_branch(repo
, worktree
, delref
);
6048 struct got_reflist_head refs
;
6050 error
= got_ref_list(&refs
, repo
, NULL
, got_ref_cmp_by_name
,
6054 if (commit_id_arg
== NULL
)
6055 commit_id_arg
= worktree
?
6056 got_worktree_get_head_ref_name(worktree
) :
6058 error
= got_repo_match_object_id(&commit_id
, NULL
,
6059 commit_id_arg
, GOT_OBJ_TYPE_COMMIT
, &refs
, repo
);
6060 got_ref_list_free(&refs
);
6063 error
= add_branch(repo
, argv
[0], commit_id
);
6066 if (worktree
&& do_update
) {
6067 struct got_update_progress_arg upa
;
6068 char *branch_refname
= NULL
;
6070 error
= got_object_id_str(&commit_id_str
, commit_id
);
6073 error
= get_worktree_paths_from_argv(&paths
, 0, NULL
,
6077 if (asprintf(&branch_refname
, "refs/heads/%s", argv
[0])
6079 error
= got_error_from_errno("asprintf");
6082 error
= got_ref_open(&ref
, repo
, branch_refname
, 0);
6083 free(branch_refname
);
6086 error
= switch_head_ref(ref
, commit_id
, worktree
,
6090 error
= got_worktree_set_base_commit_id(worktree
, repo
,
6094 memset(&upa
, 0, sizeof(upa
));
6095 error
= got_worktree_checkout_files(worktree
, &paths
,
6096 repo
, update_progress
, &upa
, check_cancelled
,
6100 if (upa
.did_something
) {
6101 printf("Updated to %s: %s\n",
6102 got_worktree_get_head_ref_name(worktree
),
6105 print_update_progress_stats(&upa
);
6112 const struct got_error
*close_err
= got_repo_close(repo
);
6117 got_worktree_close(worktree
);
6121 free(commit_id_str
);
6122 TAILQ_FOREACH(pe
, &paths
, entry
)
6123 free((char *)pe
->path
);
6124 got_pathlist_free(&paths
);
6133 "usage: %s tag [-c commit] [-r repository] [-l] "
6134 "[-m message] name\n", getprogname());
6139 static const struct got_error
*
6140 sort_tags(struct got_reflist_head
*sorted
, struct got_reflist_head
*tags
)
6142 const struct got_error
*err
= NULL
;
6143 struct got_reflist_entry
*re
, *se
, *new;
6144 struct got_object_id
*re_id
, *se_id
;
6145 struct got_tag_object
*re_tag
, *se_tag
;
6146 time_t re_time
, se_time
;
6148 STAILQ_FOREACH(re
, tags
, entry
) {
6149 se
= STAILQ_FIRST(sorted
);
6151 err
= got_reflist_entry_dup(&new, re
);
6154 STAILQ_INSERT_HEAD(sorted
, new, entry
);
6157 err
= got_ref_resolve(&re_id
, repo
, re
->ref
);
6160 err
= got_object_open_as_tag(&re_tag
, repo
, re_id
);
6164 re_time
= got_object_tag_get_tagger_time(re_tag
);
6165 got_object_tag_close(re_tag
);
6169 err
= got_ref_resolve(&se_id
, repo
, re
->ref
);
6172 err
= got_object_open_as_tag(&se_tag
, repo
, se_id
);
6176 se_time
= got_object_tag_get_tagger_time(se_tag
);
6177 got_object_tag_close(se_tag
);
6179 if (se_time
> re_time
) {
6180 err
= got_reflist_entry_dup(&new, re
);
6183 STAILQ_INSERT_AFTER(sorted
, se
, new, entry
);
6186 se
= STAILQ_NEXT(se
, entry
);
6195 static const struct got_error
*
6196 list_tags(struct got_repository
*repo
, struct got_worktree
*worktree
)
6198 static const struct got_error
*err
= NULL
;
6199 struct got_reflist_head refs
;
6200 struct got_reflist_entry
*re
;
6204 err
= got_ref_list(&refs
, repo
, "refs/tags", got_ref_cmp_tags
, repo
);
6208 TAILQ_FOREACH(re
, &refs
, entry
) {
6209 const char *refname
;
6210 char *refstr
, *tagmsg0
, *tagmsg
, *line
, *id_str
, *datestr
;
6214 struct got_object_id
*id
;
6215 struct got_tag_object
*tag
;
6216 struct got_commit_object
*commit
= NULL
;
6218 refname
= got_ref_get_name(re
->ref
);
6219 if (strncmp(refname
, "refs/tags/", 10) != 0)
6222 refstr
= got_ref_to_str(re
->ref
);
6223 if (refstr
== NULL
) {
6224 err
= got_error_from_errno("got_ref_to_str");
6227 printf("%stag %s %s\n", GOT_COMMIT_SEP_STR
, refname
, refstr
);
6230 err
= got_ref_resolve(&id
, repo
, re
->ref
);
6233 err
= got_object_open_as_tag(&tag
, repo
, id
);
6235 if (err
->code
!= GOT_ERR_OBJ_TYPE
) {
6239 /* "lightweight" tag */
6240 err
= got_object_open_as_commit(&commit
, repo
, id
);
6245 tagger
= got_object_commit_get_committer(commit
);
6247 got_object_commit_get_committer_time(commit
);
6248 err
= got_object_id_str(&id_str
, id
);
6254 tagger
= got_object_tag_get_tagger(tag
);
6255 tagger_time
= got_object_tag_get_tagger_time(tag
);
6256 err
= got_object_id_str(&id_str
,
6257 got_object_tag_get_object_id(tag
));
6261 printf("from: %s\n", tagger
);
6262 datestr
= get_datestr(&tagger_time
, datebuf
);
6264 printf("date: %s UTC\n", datestr
);
6266 printf("object: %s %s\n", GOT_OBJ_LABEL_COMMIT
, id_str
);
6268 switch (got_object_tag_get_object_type(tag
)) {
6269 case GOT_OBJ_TYPE_BLOB
:
6270 printf("object: %s %s\n", GOT_OBJ_LABEL_BLOB
,
6273 case GOT_OBJ_TYPE_TREE
:
6274 printf("object: %s %s\n", GOT_OBJ_LABEL_TREE
,
6277 case GOT_OBJ_TYPE_COMMIT
:
6278 printf("object: %s %s\n", GOT_OBJ_LABEL_COMMIT
,
6281 case GOT_OBJ_TYPE_TAG
:
6282 printf("object: %s %s\n", GOT_OBJ_LABEL_TAG
,
6291 err
= got_object_commit_get_logmsg(&tagmsg0
, commit
);
6294 got_object_commit_close(commit
);
6296 tagmsg0
= strdup(got_object_tag_get_message(tag
));
6297 got_object_tag_close(tag
);
6298 if (tagmsg0
== NULL
) {
6299 err
= got_error_from_errno("strdup");
6306 line
= strsep(&tagmsg
, "\n");
6308 printf(" %s\n", line
);
6313 got_ref_list_free(&refs
);
6317 static const struct got_error
*
6318 get_tag_message(char **tagmsg
, char **tagmsg_path
, const char *commit_id_str
,
6319 const char *tag_name
, const char *repo_path
)
6321 const struct got_error
*err
= NULL
;
6322 char *template = NULL
, *initial_content
= NULL
;
6323 char *editor
= NULL
;
6324 int initial_content_len
;
6327 if (asprintf(&template, GOT_TMPDIR_STR
"/got-tagmsg") == -1) {
6328 err
= got_error_from_errno("asprintf");
6332 initial_content_len
= asprintf(&initial_content
,
6333 "\n# tagging commit %s as %s\n",
6334 commit_id_str
, tag_name
);
6335 if (initial_content_len
== -1) {
6336 err
= got_error_from_errno("asprintf");
6340 err
= got_opentemp_named_fd(tagmsg_path
, &fd
, template);
6344 if (write(fd
, initial_content
, initial_content_len
) == -1) {
6345 err
= got_error_from_errno2("write", *tagmsg_path
);
6349 err
= get_editor(&editor
);
6352 err
= edit_logmsg(tagmsg
, editor
, *tagmsg_path
, initial_content
,
6353 initial_content_len
, 1);
6355 free(initial_content
);
6359 if (fd
!= -1 && close(fd
) == -1 && err
== NULL
)
6360 err
= got_error_from_errno2("close", *tagmsg_path
);
6362 /* Editor is done; we can now apply unveil(2) */
6364 err
= apply_unveil(repo_path
, 0, NULL
);
6372 static const struct got_error
*
6373 add_tag(struct got_repository
*repo
, struct got_worktree
*worktree
,
6374 const char *tag_name
, const char *commit_arg
, const char *tagmsg_arg
)
6376 const struct got_error
*err
= NULL
;
6377 struct got_object_id
*commit_id
= NULL
, *tag_id
= NULL
;
6378 char *label
= NULL
, *commit_id_str
= NULL
;
6379 struct got_reference
*ref
= NULL
;
6380 char *refname
= NULL
, *tagmsg
= NULL
, *tagger
= NULL
;
6381 char *tagmsg_path
= NULL
, *tag_id_str
= NULL
;
6382 int preserve_tagmsg
= 0;
6383 struct got_reflist_head refs
;
6388 * Don't let the user create a tag name with a leading '-'.
6389 * While technically a valid reference name, this case is usually
6390 * an unintended typo.
6392 if (tag_name
[0] == '-')
6393 return got_error_path(tag_name
, GOT_ERR_REF_NAME_MINUS
);
6395 err
= get_author(&tagger
, repo
, worktree
);
6399 err
= got_ref_list(&refs
, repo
, NULL
, got_ref_cmp_by_name
, NULL
);
6403 err
= got_repo_match_object_id(&commit_id
, &label
, commit_arg
,
6404 GOT_OBJ_TYPE_COMMIT
, &refs
, repo
);
6408 err
= got_object_id_str(&commit_id_str
, commit_id
);
6412 if (strncmp("refs/tags/", tag_name
, 10) == 0) {
6413 refname
= strdup(tag_name
);
6414 if (refname
== NULL
) {
6415 err
= got_error_from_errno("strdup");
6419 } else if (asprintf(&refname
, "refs/tags/%s", tag_name
) == -1) {
6420 err
= got_error_from_errno("asprintf");
6424 err
= got_ref_open(&ref
, repo
, refname
, 0);
6426 err
= got_error(GOT_ERR_TAG_EXISTS
);
6428 } else if (err
->code
!= GOT_ERR_NOT_REF
)
6431 if (tagmsg_arg
== NULL
) {
6432 err
= get_tag_message(&tagmsg
, &tagmsg_path
, commit_id_str
,
6433 tag_name
, got_repo_get_path(repo
));
6435 if (err
->code
!= GOT_ERR_COMMIT_MSG_EMPTY
&&
6436 tagmsg_path
!= NULL
)
6437 preserve_tagmsg
= 1;
6442 err
= got_object_tag_create(&tag_id
, tag_name
, commit_id
,
6443 tagger
, time(NULL
), tagmsg
? tagmsg
: tagmsg_arg
, repo
);
6446 preserve_tagmsg
= 1;
6450 err
= got_ref_alloc(&ref
, refname
, tag_id
);
6453 preserve_tagmsg
= 1;
6457 err
= got_ref_write(ref
, repo
);
6460 preserve_tagmsg
= 1;
6464 err
= got_object_id_str(&tag_id_str
, tag_id
);
6467 preserve_tagmsg
= 1;
6470 printf("Created tag %s\n", tag_id_str
);
6472 if (preserve_tagmsg
) {
6473 fprintf(stderr
, "%s: tag message preserved in %s\n",
6474 getprogname(), tagmsg_path
);
6475 } else if (tagmsg_path
&& unlink(tagmsg_path
) == -1 && err
== NULL
)
6476 err
= got_error_from_errno2("unlink", tagmsg_path
);
6481 free(commit_id_str
);
6486 got_ref_list_free(&refs
);
6490 static const struct got_error
*
6491 cmd_tag(int argc
, char *argv
[])
6493 const struct got_error
*error
= NULL
;
6494 struct got_repository
*repo
= NULL
;
6495 struct got_worktree
*worktree
= NULL
;
6496 char *cwd
= NULL
, *repo_path
= NULL
, *commit_id_str
= NULL
;
6497 char *gitconfig_path
= NULL
;
6498 const char *tag_name
, *commit_id_arg
= NULL
, *tagmsg
= NULL
;
6499 int ch
, do_list
= 0;
6501 while ((ch
= getopt(argc
, argv
, "c:m:r:l")) != -1) {
6504 commit_id_arg
= optarg
;
6510 repo_path
= realpath(optarg
, NULL
);
6511 if (repo_path
== NULL
)
6512 return got_error_from_errno2("realpath",
6514 got_path_strip_trailing_slashes(repo_path
);
6529 if (commit_id_arg
!= NULL
)
6531 "-c option can only be used when creating a tag");
6533 option_conflict('l', 'm');
6536 } else if (argc
!= 1)
6543 if (pledge("stdio rpath wpath flock proc exec sendfd unveil",
6547 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
6548 "sendfd unveil", NULL
) == -1)
6552 cwd
= getcwd(NULL
, 0);
6554 error
= got_error_from_errno("getcwd");
6558 if (repo_path
== NULL
) {
6559 error
= got_worktree_open(&worktree
, cwd
);
6560 if (error
&& error
->code
!= GOT_ERR_NOT_WORKTREE
)
6566 strdup(got_worktree_get_repo_path(worktree
));
6567 if (repo_path
== NULL
)
6568 error
= got_error_from_errno("strdup");
6572 repo_path
= strdup(cwd
);
6573 if (repo_path
== NULL
) {
6574 error
= got_error_from_errno("strdup");
6581 error
= got_repo_open(&repo
, repo_path
, NULL
);
6584 error
= apply_unveil(got_repo_get_path(repo
), 1, NULL
);
6587 error
= list_tags(repo
, worktree
);
6589 error
= get_gitconfig_path(&gitconfig_path
);
6592 error
= got_repo_open(&repo
, repo_path
, gitconfig_path
);
6597 error
= apply_unveil(got_repo_get_path(repo
), 0, NULL
);
6602 if (commit_id_arg
== NULL
) {
6603 struct got_reference
*head_ref
;
6604 struct got_object_id
*commit_id
;
6605 error
= got_ref_open(&head_ref
, repo
,
6606 worktree
? got_worktree_get_head_ref_name(worktree
)
6610 error
= got_ref_resolve(&commit_id
, repo
, head_ref
);
6611 got_ref_close(head_ref
);
6614 error
= got_object_id_str(&commit_id_str
, commit_id
);
6620 error
= add_tag(repo
, worktree
, tag_name
,
6621 commit_id_str
? commit_id_str
: commit_id_arg
, tagmsg
);
6625 const struct got_error
*close_err
= got_repo_close(repo
);
6630 got_worktree_close(worktree
);
6633 free(gitconfig_path
);
6634 free(commit_id_str
);
6641 fprintf(stderr
, "usage: %s add [-R] [-I] path ...\n",
6646 static const struct got_error
*
6647 add_progress(void *arg
, unsigned char status
, const char *path
)
6649 while (path
[0] == '/')
6651 printf("%c %s\n", status
, path
);
6655 static const struct got_error
*
6656 cmd_add(int argc
, char *argv
[])
6658 const struct got_error
*error
= NULL
;
6659 struct got_repository
*repo
= NULL
;
6660 struct got_worktree
*worktree
= NULL
;
6662 struct got_pathlist_head paths
;
6663 struct got_pathlist_entry
*pe
;
6664 int ch
, can_recurse
= 0, no_ignores
= 0;
6668 while ((ch
= getopt(argc
, argv
, "IR")) != -1) {
6686 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
6693 cwd
= getcwd(NULL
, 0);
6695 error
= got_error_from_errno("getcwd");
6699 error
= got_worktree_open(&worktree
, cwd
);
6701 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
6702 error
= wrap_not_worktree_error(error
, "add", cwd
);
6706 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
6711 error
= apply_unveil(got_repo_get_path(repo
), 1,
6712 got_worktree_get_root_path(worktree
));
6716 error
= get_worktree_paths_from_argv(&paths
, argc
, argv
, worktree
);
6723 TAILQ_FOREACH(pe
, &paths
, entry
) {
6724 if (asprintf(&ondisk_path
, "%s/%s",
6725 got_worktree_get_root_path(worktree
),
6727 error
= got_error_from_errno("asprintf");
6730 if (lstat(ondisk_path
, &sb
) == -1) {
6731 if (errno
== ENOENT
) {
6735 error
= got_error_from_errno2("lstat",
6741 if (S_ISDIR(sb
.st_mode
)) {
6742 error
= got_error_msg(GOT_ERR_BAD_PATH
,
6743 "adding directories requires -R option");
6749 error
= got_worktree_schedule_add(worktree
, &paths
, add_progress
,
6750 NULL
, repo
, no_ignores
);
6753 const struct got_error
*close_err
= got_repo_close(repo
);
6758 got_worktree_close(worktree
);
6759 TAILQ_FOREACH(pe
, &paths
, entry
)
6760 free((char *)pe
->path
);
6761 got_pathlist_free(&paths
);
6769 fprintf(stderr
, "usage: %s remove [-f] [-k] [-R] [-s status-codes] "
6770 "path ...\n", getprogname());
6774 static const struct got_error
*
6775 print_remove_status(void *arg
, unsigned char status
,
6776 unsigned char staged_status
, const char *path
)
6778 while (path
[0] == '/')
6780 if (status
== GOT_STATUS_NONEXISTENT
)
6782 if (status
== staged_status
&& (status
== GOT_STATUS_DELETE
))
6783 status
= GOT_STATUS_NO_CHANGE
;
6784 printf("%c%c %s\n", status
, staged_status
, path
);
6788 static const struct got_error
*
6789 cmd_remove(int argc
, char *argv
[])
6791 const struct got_error
*error
= NULL
;
6792 struct got_worktree
*worktree
= NULL
;
6793 struct got_repository
*repo
= NULL
;
6794 const char *status_codes
= NULL
;
6796 struct got_pathlist_head paths
;
6797 struct got_pathlist_entry
*pe
;
6798 int ch
, delete_local_mods
= 0, can_recurse
= 0, keep_on_disk
= 0, i
;
6802 while ((ch
= getopt(argc
, argv
, "fkRs:")) != -1) {
6805 delete_local_mods
= 1;
6814 for (i
= 0; i
< strlen(optarg
); i
++) {
6815 switch (optarg
[i
]) {
6816 case GOT_STATUS_MODIFY
:
6817 delete_local_mods
= 1;
6819 case GOT_STATUS_MISSING
:
6822 errx(1, "invalid status code '%c'",
6826 status_codes
= optarg
;
6838 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
6845 cwd
= getcwd(NULL
, 0);
6847 error
= got_error_from_errno("getcwd");
6850 error
= got_worktree_open(&worktree
, cwd
);
6852 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
6853 error
= wrap_not_worktree_error(error
, "remove", cwd
);
6857 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
6862 error
= apply_unveil(got_repo_get_path(repo
), 1,
6863 got_worktree_get_root_path(worktree
));
6867 error
= get_worktree_paths_from_argv(&paths
, argc
, argv
, worktree
);
6874 TAILQ_FOREACH(pe
, &paths
, entry
) {
6875 if (asprintf(&ondisk_path
, "%s/%s",
6876 got_worktree_get_root_path(worktree
),
6878 error
= got_error_from_errno("asprintf");
6881 if (lstat(ondisk_path
, &sb
) == -1) {
6882 if (errno
== ENOENT
) {
6886 error
= got_error_from_errno2("lstat",
6892 if (S_ISDIR(sb
.st_mode
)) {
6893 error
= got_error_msg(GOT_ERR_BAD_PATH
,
6894 "removing directories requires -R option");
6900 error
= got_worktree_schedule_delete(worktree
, &paths
,
6901 delete_local_mods
, status_codes
, print_remove_status
, NULL
,
6902 repo
, keep_on_disk
);
6905 const struct got_error
*close_err
= got_repo_close(repo
);
6910 got_worktree_close(worktree
);
6911 TAILQ_FOREACH(pe
, &paths
, entry
)
6912 free((char *)pe
->path
);
6913 got_pathlist_free(&paths
);
6921 fprintf(stderr
, "usage: %s revert [-p] [-F response-script] [-R] "
6922 "path ...\n", getprogname());
6926 static const struct got_error
*
6927 revert_progress(void *arg
, unsigned char status
, const char *path
)
6929 if (status
== GOT_STATUS_UNVERSIONED
)
6932 while (path
[0] == '/')
6934 printf("%c %s\n", status
, path
);
6938 struct choose_patch_arg
{
6939 FILE *patch_script_file
;
6943 static const struct got_error
*
6944 show_change(unsigned char status
, const char *path
, FILE *patch_file
, int n
,
6945 int nchanges
, const char *action
)
6948 size_t linesize
= 0;
6952 case GOT_STATUS_ADD
:
6953 printf("A %s\n%s this addition? [y/n] ", path
, action
);
6955 case GOT_STATUS_DELETE
:
6956 printf("D %s\n%s this deletion? [y/n] ", path
, action
);
6958 case GOT_STATUS_MODIFY
:
6959 if (fseek(patch_file
, 0L, SEEK_SET
) == -1)
6960 return got_error_from_errno("fseek");
6961 printf(GOT_COMMIT_SEP_STR
);
6962 while ((linelen
= getline(&line
, &linesize
, patch_file
)) != -1)
6964 if (ferror(patch_file
))
6965 return got_error_from_errno("getline");
6966 printf(GOT_COMMIT_SEP_STR
);
6967 printf("M %s (change %d of %d)\n%s this change? [y/n/q] ",
6968 path
, n
, nchanges
, action
);
6971 return got_error_path(path
, GOT_ERR_FILE_STATUS
);
6977 static const struct got_error
*
6978 choose_patch(int *choice
, void *arg
, unsigned char status
, const char *path
,
6979 FILE *patch_file
, int n
, int nchanges
)
6981 const struct got_error
*err
= NULL
;
6983 size_t linesize
= 0;
6986 struct choose_patch_arg
*a
= arg
;
6988 *choice
= GOT_PATCH_CHOICE_NONE
;
6990 if (a
->patch_script_file
) {
6992 err
= show_change(status
, path
, patch_file
, n
, nchanges
,
6996 linelen
= getline(&line
, &linesize
, a
->patch_script_file
);
6997 if (linelen
== -1) {
6998 if (ferror(a
->patch_script_file
))
6999 return got_error_from_errno("getline");
7002 nl
= strchr(line
, '\n');
7005 if (strcmp(line
, "y") == 0) {
7006 *choice
= GOT_PATCH_CHOICE_YES
;
7008 } else if (strcmp(line
, "n") == 0) {
7009 *choice
= GOT_PATCH_CHOICE_NO
;
7011 } else if (strcmp(line
, "q") == 0 &&
7012 status
== GOT_STATUS_MODIFY
) {
7013 *choice
= GOT_PATCH_CHOICE_QUIT
;
7016 printf("invalid response '%s'\n", line
);
7021 while (resp
!= 'y' && resp
!= 'n' && resp
!= 'q') {
7022 err
= show_change(status
, path
, patch_file
, n
, nchanges
,
7029 if (status
== GOT_STATUS_MODIFY
) {
7030 if (resp
!= 'y' && resp
!= 'n' && resp
!= 'q') {
7031 printf("invalid response '%c'\n", resp
);
7034 } else if (resp
!= 'y' && resp
!= 'n') {
7035 printf("invalid response '%c'\n", resp
);
7041 *choice
= GOT_PATCH_CHOICE_YES
;
7042 else if (resp
== 'n')
7043 *choice
= GOT_PATCH_CHOICE_NO
;
7044 else if (resp
== 'q' && status
== GOT_STATUS_MODIFY
)
7045 *choice
= GOT_PATCH_CHOICE_QUIT
;
7051 static const struct got_error
*
7052 cmd_revert(int argc
, char *argv
[])
7054 const struct got_error
*error
= NULL
;
7055 struct got_worktree
*worktree
= NULL
;
7056 struct got_repository
*repo
= NULL
;
7057 char *cwd
= NULL
, *path
= NULL
;
7058 struct got_pathlist_head paths
;
7059 struct got_pathlist_entry
*pe
;
7060 int ch
, can_recurse
= 0, pflag
= 0;
7061 FILE *patch_script_file
= NULL
;
7062 const char *patch_script_path
= NULL
;
7063 struct choose_patch_arg cpa
;
7067 while ((ch
= getopt(argc
, argv
, "pF:R")) != -1) {
7073 patch_script_path
= optarg
;
7088 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
7089 "unveil", NULL
) == -1)
7094 if (patch_script_path
&& !pflag
)
7095 errx(1, "-F option can only be used together with -p option");
7097 cwd
= getcwd(NULL
, 0);
7099 error
= got_error_from_errno("getcwd");
7102 error
= got_worktree_open(&worktree
, cwd
);
7104 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
7105 error
= wrap_not_worktree_error(error
, "revert", cwd
);
7109 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
7114 if (patch_script_path
) {
7115 patch_script_file
= fopen(patch_script_path
, "r");
7116 if (patch_script_file
== NULL
) {
7117 error
= got_error_from_errno2("fopen",
7122 error
= apply_unveil(got_repo_get_path(repo
), 1,
7123 got_worktree_get_root_path(worktree
));
7127 error
= get_worktree_paths_from_argv(&paths
, argc
, argv
, worktree
);
7134 TAILQ_FOREACH(pe
, &paths
, entry
) {
7135 if (asprintf(&ondisk_path
, "%s/%s",
7136 got_worktree_get_root_path(worktree
),
7138 error
= got_error_from_errno("asprintf");
7141 if (lstat(ondisk_path
, &sb
) == -1) {
7142 if (errno
== ENOENT
) {
7146 error
= got_error_from_errno2("lstat",
7152 if (S_ISDIR(sb
.st_mode
)) {
7153 error
= got_error_msg(GOT_ERR_BAD_PATH
,
7154 "reverting directories requires -R option");
7160 cpa
.patch_script_file
= patch_script_file
;
7161 cpa
.action
= "revert";
7162 error
= got_worktree_revert(worktree
, &paths
, revert_progress
, NULL
,
7163 pflag
? choose_patch
: NULL
, &cpa
, repo
);
7165 if (patch_script_file
&& fclose(patch_script_file
) == EOF
&&
7167 error
= got_error_from_errno2("fclose", patch_script_path
);
7169 const struct got_error
*close_err
= got_repo_close(repo
);
7174 got_worktree_close(worktree
);
7183 fprintf(stderr
, "usage: %s commit [-F path] [-m msg] [-N] [-S] "
7184 "[path ...]\n", getprogname());
7188 struct collect_commit_logmsg_arg
{
7189 const char *cmdline_log
;
7190 const char *prepared_log
;
7191 int non_interactive
;
7193 const char *worktree_path
;
7194 const char *branch_name
;
7195 const char *repo_path
;
7200 static const struct got_error
*
7201 read_prepared_logmsg(char **logmsg
, const char *path
)
7203 const struct got_error
*err
= NULL
;
7209 memset(&sb
, 0, sizeof(sb
));
7211 f
= fopen(path
, "r");
7213 return got_error_from_errno2("fopen", path
);
7215 if (fstat(fileno(f
), &sb
) == -1) {
7216 err
= got_error_from_errno2("fstat", path
);
7219 if (sb
.st_size
== 0) {
7220 err
= got_error(GOT_ERR_COMMIT_MSG_EMPTY
);
7224 *logmsg
= malloc(sb
.st_size
+ 1);
7225 if (*logmsg
== NULL
) {
7226 err
= got_error_from_errno("malloc");
7230 r
= fread(*logmsg
, 1, sb
.st_size
, f
);
7231 if (r
!= sb
.st_size
) {
7233 err
= got_error_from_errno2("fread", path
);
7235 err
= got_error(GOT_ERR_IO
);
7238 (*logmsg
)[sb
.st_size
] = '\0';
7240 if (fclose(f
) == EOF
&& err
== NULL
)
7241 err
= got_error_from_errno2("fclose", path
);
7250 static const struct got_error
*
7251 collect_commit_logmsg(struct got_pathlist_head
*commitable_paths
, char **logmsg
,
7254 char *initial_content
= NULL
;
7255 struct got_pathlist_entry
*pe
;
7256 const struct got_error
*err
= NULL
;
7257 char *template = NULL
;
7258 struct collect_commit_logmsg_arg
*a
= arg
;
7259 int initial_content_len
;
7263 /* if a message was specified on the command line, just use it */
7264 if (a
->cmdline_log
!= NULL
&& strlen(a
->cmdline_log
) != 0) {
7265 len
= strlen(a
->cmdline_log
) + 1;
7266 *logmsg
= malloc(len
+ 1);
7267 if (*logmsg
== NULL
)
7268 return got_error_from_errno("malloc");
7269 strlcpy(*logmsg
, a
->cmdline_log
, len
);
7271 } else if (a
->prepared_log
!= NULL
&& a
->non_interactive
)
7272 return read_prepared_logmsg(logmsg
, a
->prepared_log
);
7274 if (asprintf(&template, "%s/logmsg", a
->worktree_path
) == -1)
7275 return got_error_from_errno("asprintf");
7277 err
= got_opentemp_named_fd(&a
->logmsg_path
, &fd
, template);
7281 if (a
->prepared_log
) {
7283 err
= read_prepared_logmsg(&msg
, a
->prepared_log
);
7286 if (write(fd
, msg
, strlen(msg
)) == -1) {
7287 err
= got_error_from_errno2("write", a
->logmsg_path
);
7294 initial_content_len
= asprintf(&initial_content
,
7295 "\n# changes to be committed on branch %s:\n",
7297 if (initial_content_len
== -1) {
7298 err
= got_error_from_errno("asprintf");
7302 if (write(fd
, initial_content
, initial_content_len
) == -1) {
7303 err
= got_error_from_errno2("write", a
->logmsg_path
);
7307 TAILQ_FOREACH(pe
, commitable_paths
, entry
) {
7308 struct got_commitable
*ct
= pe
->data
;
7309 dprintf(fd
, "# %c %s\n",
7310 got_commitable_get_status(ct
),
7311 got_commitable_get_path(ct
));
7314 err
= edit_logmsg(logmsg
, a
->editor
, a
->logmsg_path
, initial_content
,
7315 initial_content_len
, a
->prepared_log
? 0 : 1);
7317 free(initial_content
);
7320 if (fd
!= -1 && close(fd
) == -1 && err
== NULL
)
7321 err
= got_error_from_errno2("close", a
->logmsg_path
);
7323 /* Editor is done; we can now apply unveil(2) */
7325 err
= apply_unveil(a
->repo_path
, 0, a
->worktree_path
);
7333 static const struct got_error
*
7334 cmd_commit(int argc
, char *argv
[])
7336 const struct got_error
*error
= NULL
;
7337 struct got_worktree
*worktree
= NULL
;
7338 struct got_repository
*repo
= NULL
;
7339 char *cwd
= NULL
, *id_str
= NULL
;
7340 struct got_object_id
*id
= NULL
;
7341 const char *logmsg
= NULL
;
7342 char *prepared_logmsg
= NULL
;
7343 struct collect_commit_logmsg_arg cl_arg
;
7344 char *gitconfig_path
= NULL
, *editor
= NULL
, *author
= NULL
;
7345 int ch
, rebase_in_progress
, histedit_in_progress
, preserve_logmsg
= 0;
7346 int allow_bad_symlinks
= 0, non_interactive
= 0, merge_in_progress
= 0;
7347 struct got_pathlist_head paths
;
7350 cl_arg
.logmsg_path
= NULL
;
7352 while ((ch
= getopt(argc
, argv
, "F:m:NS")) != -1) {
7356 option_conflict('F', 'm');
7357 prepared_logmsg
= realpath(optarg
, NULL
);
7358 if (prepared_logmsg
== NULL
)
7359 return got_error_from_errno2("realpath",
7363 if (prepared_logmsg
)
7364 option_conflict('m', 'F');
7368 non_interactive
= 1;
7371 allow_bad_symlinks
= 1;
7383 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
7384 "unveil", NULL
) == -1)
7387 cwd
= getcwd(NULL
, 0);
7389 error
= got_error_from_errno("getcwd");
7392 error
= got_worktree_open(&worktree
, cwd
);
7394 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
7395 error
= wrap_not_worktree_error(error
, "commit", cwd
);
7399 error
= got_worktree_rebase_in_progress(&rebase_in_progress
, worktree
);
7402 if (rebase_in_progress
) {
7403 error
= got_error(GOT_ERR_REBASING
);
7407 error
= got_worktree_histedit_in_progress(&histedit_in_progress
,
7412 error
= get_gitconfig_path(&gitconfig_path
);
7415 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
7420 error
= got_worktree_merge_in_progress(&merge_in_progress
, worktree
, repo
);
7423 if (merge_in_progress
) {
7424 error
= got_error(GOT_ERR_MERGE_BUSY
);
7428 error
= get_author(&author
, repo
, worktree
);
7433 * unveil(2) traverses exec(2); if an editor is used we have
7434 * to apply unveil after the log message has been written.
7436 if (logmsg
== NULL
|| strlen(logmsg
) == 0)
7437 error
= get_editor(&editor
);
7439 error
= apply_unveil(got_repo_get_path(repo
), 0,
7440 got_worktree_get_root_path(worktree
));
7444 error
= get_worktree_paths_from_argv(&paths
, argc
, argv
, worktree
);
7448 cl_arg
.editor
= editor
;
7449 cl_arg
.cmdline_log
= logmsg
;
7450 cl_arg
.prepared_log
= prepared_logmsg
;
7451 cl_arg
.non_interactive
= non_interactive
;
7452 cl_arg
.worktree_path
= got_worktree_get_root_path(worktree
);
7453 cl_arg
.branch_name
= got_worktree_get_head_ref_name(worktree
);
7454 if (!histedit_in_progress
) {
7455 if (strncmp(cl_arg
.branch_name
, "refs/heads/", 11) != 0) {
7456 error
= got_error(GOT_ERR_COMMIT_BRANCH
);
7459 cl_arg
.branch_name
+= 11;
7461 cl_arg
.repo_path
= got_repo_get_path(repo
);
7462 error
= got_worktree_commit(&id
, worktree
, &paths
, author
, NULL
,
7463 allow_bad_symlinks
, collect_commit_logmsg
, &cl_arg
,
7464 print_status
, NULL
, repo
);
7466 if (error
->code
!= GOT_ERR_COMMIT_MSG_EMPTY
&&
7467 cl_arg
.logmsg_path
!= NULL
)
7468 preserve_logmsg
= 1;
7472 error
= got_object_id_str(&id_str
, id
);
7475 printf("Created commit %s\n", id_str
);
7477 if (preserve_logmsg
) {
7478 fprintf(stderr
, "%s: log message preserved in %s\n",
7479 getprogname(), cl_arg
.logmsg_path
);
7480 } else if (cl_arg
.logmsg_path
&& unlink(cl_arg
.logmsg_path
) == -1 &&
7482 error
= got_error_from_errno2("unlink", cl_arg
.logmsg_path
);
7483 free(cl_arg
.logmsg_path
);
7485 const struct got_error
*close_err
= got_repo_close(repo
);
7490 got_worktree_close(worktree
);
7493 free(gitconfig_path
);
7496 free(prepared_logmsg
);
7503 fprintf(stderr
, "usage: %s send [-a] [-b branch] [-d branch] [-f] "
7504 "[-r repository-path] [-t tag] [-T] [-q] [-v] "
7505 "[remote-repository]\n", getprogname());
7509 struct got_send_progress_arg
{
7510 char last_scaled_packsize
[FMT_SCALED_STRSIZE
];
7513 int last_nobj_total
;
7517 int printed_something
;
7519 struct got_pathlist_head
*delete_branches
;
7522 static const struct got_error
*
7523 send_progress(void *arg
, off_t packfile_size
, int ncommits
, int nobj_total
,
7524 int nobj_deltify
, int nobj_written
, off_t bytes_sent
, const char *refname
,
7527 struct got_send_progress_arg
*a
= arg
;
7528 char scaled_packsize
[FMT_SCALED_STRSIZE
];
7529 char scaled_sent
[FMT_SCALED_STRSIZE
];
7530 int p_deltify
= 0, p_written
= 0, p_sent
= 0;
7531 int print_searching
= 0, print_total
= 0;
7532 int print_deltify
= 0, print_written
= 0, print_sent
= 0;
7534 if (a
->verbosity
< 0)
7538 const char *status
= success
? "accepted" : "rejected";
7541 struct got_pathlist_entry
*pe
;
7542 TAILQ_FOREACH(pe
, a
->delete_branches
, entry
) {
7543 const char *branchname
= pe
->path
;
7544 if (got_path_cmp(branchname
, refname
,
7545 strlen(branchname
), strlen(refname
)) == 0) {
7547 a
->sent_something
= 1;
7553 if (a
->printed_something
)
7555 printf("Server has %s %s", status
, refname
);
7556 a
->printed_something
= 1;
7560 if (fmt_scaled(packfile_size
, scaled_packsize
) == -1)
7561 return got_error_from_errno("fmt_scaled");
7562 if (fmt_scaled(bytes_sent
, scaled_sent
) == -1)
7563 return got_error_from_errno("fmt_scaled");
7565 if (a
->last_ncommits
!= ncommits
) {
7566 print_searching
= 1;
7567 a
->last_ncommits
= ncommits
;
7570 if (a
->last_nobj_total
!= nobj_total
) {
7571 print_searching
= 1;
7573 a
->last_nobj_total
= nobj_total
;
7576 if (packfile_size
> 0 && (a
->last_scaled_packsize
[0] == '\0' ||
7577 strcmp(scaled_packsize
, a
->last_scaled_packsize
)) != 0) {
7578 if (strlcpy(a
->last_scaled_packsize
, scaled_packsize
,
7579 FMT_SCALED_STRSIZE
) >= FMT_SCALED_STRSIZE
)
7580 return got_error(GOT_ERR_NO_SPACE
);
7583 if (nobj_deltify
> 0 || nobj_written
> 0) {
7584 if (nobj_deltify
> 0) {
7585 p_deltify
= (nobj_deltify
* 100) / nobj_total
;
7586 if (p_deltify
!= a
->last_p_deltify
) {
7587 a
->last_p_deltify
= p_deltify
;
7588 print_searching
= 1;
7593 if (nobj_written
> 0) {
7594 p_written
= (nobj_written
* 100) / nobj_total
;
7595 if (p_written
!= a
->last_p_written
) {
7596 a
->last_p_written
= p_written
;
7597 print_searching
= 1;
7605 if (bytes_sent
> 0) {
7606 p_sent
= (bytes_sent
* 100) / packfile_size
;
7607 if (p_sent
!= a
->last_p_sent
) {
7608 a
->last_p_sent
= p_sent
;
7609 print_searching
= 1;
7615 a
->sent_something
= 1;
7618 if (print_searching
|| print_total
|| print_deltify
|| print_written
||
7621 if (print_searching
)
7622 printf("packing %d reference%s", ncommits
,
7623 ncommits
== 1 ? "" : "s");
7625 printf("; %d object%s", nobj_total
,
7626 nobj_total
== 1 ? "" : "s");
7628 printf("; deltify: %d%%", p_deltify
);
7630 printf("; uploading pack: %*s %d%%", FMT_SCALED_STRSIZE
,
7631 scaled_packsize
, p_sent
);
7632 else if (print_written
)
7633 printf("; writing pack: %*s %d%%", FMT_SCALED_STRSIZE
,
7634 scaled_packsize
, p_written
);
7635 if (print_searching
|| print_total
|| print_deltify
||
7636 print_written
|| print_sent
) {
7637 a
->printed_something
= 1;
7643 static const struct got_error
*
7644 cmd_send(int argc
, char *argv
[])
7646 const struct got_error
*error
= NULL
;
7647 char *cwd
= NULL
, *repo_path
= NULL
;
7648 const char *remote_name
;
7649 char *proto
= NULL
, *host
= NULL
, *port
= NULL
;
7650 char *repo_name
= NULL
, *server_path
= NULL
;
7651 const struct got_remote_repo
*remotes
, *remote
= NULL
;
7652 int nremotes
, nbranches
= 0, ntags
= 0, ndelete_branches
= 0;
7653 struct got_repository
*repo
= NULL
;
7654 struct got_worktree
*worktree
= NULL
;
7655 const struct got_gotconfig
*repo_conf
= NULL
, *worktree_conf
= NULL
;
7656 struct got_pathlist_head branches
;
7657 struct got_pathlist_head tags
;
7658 struct got_reflist_head all_branches
;
7659 struct got_reflist_head all_tags
;
7660 struct got_pathlist_head delete_args
;
7661 struct got_pathlist_head delete_branches
;
7662 struct got_reflist_entry
*re
;
7663 struct got_pathlist_entry
*pe
;
7664 int i
, ch
, sendfd
= -1, sendstatus
;
7666 struct got_send_progress_arg spa
;
7667 int verbosity
= 0, overwrite_refs
= 0;
7668 int send_all_branches
= 0, send_all_tags
= 0;
7669 struct got_reference
*ref
= NULL
;
7671 TAILQ_INIT(&branches
);
7673 TAILQ_INIT(&all_branches
);
7674 TAILQ_INIT(&all_tags
);
7675 TAILQ_INIT(&delete_args
);
7676 TAILQ_INIT(&delete_branches
);
7678 while ((ch
= getopt(argc
, argv
, "ab:d:fr:t:Tvq")) != -1) {
7681 send_all_branches
= 1;
7684 error
= got_pathlist_append(&branches
, optarg
, NULL
);
7690 error
= got_pathlist_append(&delete_args
, optarg
, NULL
);
7698 repo_path
= realpath(optarg
, NULL
);
7699 if (repo_path
== NULL
)
7700 return got_error_from_errno2("realpath",
7702 got_path_strip_trailing_slashes(repo_path
);
7705 error
= got_pathlist_append(&tags
, optarg
, NULL
);
7716 else if (verbosity
< 3)
7730 if (send_all_branches
&& !TAILQ_EMPTY(&branches
))
7731 option_conflict('a', 'b');
7732 if (send_all_tags
&& !TAILQ_EMPTY(&tags
))
7733 option_conflict('T', 't');
7737 remote_name
= GOT_SEND_DEFAULT_REMOTE_NAME
;
7739 remote_name
= argv
[0];
7743 cwd
= getcwd(NULL
, 0);
7745 error
= got_error_from_errno("getcwd");
7749 if (repo_path
== NULL
) {
7750 error
= got_worktree_open(&worktree
, cwd
);
7751 if (error
&& error
->code
!= GOT_ERR_NOT_WORKTREE
)
7757 strdup(got_worktree_get_repo_path(worktree
));
7758 if (repo_path
== NULL
)
7759 error
= got_error_from_errno("strdup");
7763 repo_path
= strdup(cwd
);
7764 if (repo_path
== NULL
) {
7765 error
= got_error_from_errno("strdup");
7771 error
= got_repo_open(&repo
, repo_path
, NULL
);
7776 worktree_conf
= got_worktree_get_gotconfig(worktree
);
7777 if (worktree_conf
) {
7778 got_gotconfig_get_remotes(&nremotes
, &remotes
,
7780 for (i
= 0; i
< nremotes
; i
++) {
7781 if (strcmp(remotes
[i
].name
, remote_name
) == 0) {
7782 remote
= &remotes
[i
];
7788 if (remote
== NULL
) {
7789 repo_conf
= got_repo_get_gotconfig(repo
);
7791 got_gotconfig_get_remotes(&nremotes
, &remotes
,
7793 for (i
= 0; i
< nremotes
; i
++) {
7794 if (strcmp(remotes
[i
].name
, remote_name
) == 0) {
7795 remote
= &remotes
[i
];
7801 if (remote
== NULL
) {
7802 got_repo_get_gitconfig_remotes(&nremotes
, &remotes
, repo
);
7803 for (i
= 0; i
< nremotes
; i
++) {
7804 if (strcmp(remotes
[i
].name
, remote_name
) == 0) {
7805 remote
= &remotes
[i
];
7810 if (remote
== NULL
) {
7811 error
= got_error_path(remote_name
, GOT_ERR_NO_REMOTE
);
7815 error
= got_dial_parse_uri(&proto
, &host
, &port
, &server_path
,
7816 &repo_name
, remote
->send_url
);
7820 if (strcmp(proto
, "git") == 0) {
7822 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
7823 "sendfd dns inet unveil", NULL
) == -1)
7826 } else if (strcmp(proto
, "git+ssh") == 0 ||
7827 strcmp(proto
, "ssh") == 0) {
7829 if (pledge("stdio rpath wpath cpath fattr flock proc exec "
7830 "sendfd unveil", NULL
) == -1)
7833 } else if (strcmp(proto
, "http") == 0 ||
7834 strcmp(proto
, "git+http") == 0) {
7835 error
= got_error_path(proto
, GOT_ERR_NOT_IMPL
);
7838 error
= got_error_path(proto
, GOT_ERR_BAD_PROTO
);
7842 error
= got_dial_apply_unveil(proto
);
7846 error
= apply_unveil(got_repo_get_path(repo
), 0, NULL
);
7850 if (send_all_branches
) {
7851 error
= got_ref_list(&all_branches
, repo
, "refs/heads",
7852 got_ref_cmp_by_name
, NULL
);
7855 TAILQ_FOREACH(re
, &all_branches
, entry
) {
7856 const char *branchname
= got_ref_get_name(re
->ref
);
7857 error
= got_pathlist_append(&branches
,
7863 } else if (nbranches
== 0) {
7864 for (i
= 0; i
< remote
->nsend_branches
; i
++) {
7865 got_pathlist_append(&branches
,
7866 remote
->send_branches
[i
], NULL
);
7870 if (send_all_tags
) {
7871 error
= got_ref_list(&all_tags
, repo
, "refs/tags",
7872 got_ref_cmp_by_name
, NULL
);
7875 TAILQ_FOREACH(re
, &all_tags
, entry
) {
7876 const char *tagname
= got_ref_get_name(re
->ref
);
7877 error
= got_pathlist_append(&tags
,
7886 * To prevent accidents only branches in refs/heads/ can be deleted
7887 * with 'got send -d'.
7888 * Deleting anything else requires local repository access or Git.
7890 TAILQ_FOREACH(pe
, &delete_args
, entry
) {
7891 const char *branchname
= pe
->path
;
7893 struct got_pathlist_entry
*new;
7894 if (strncmp(branchname
, "refs/heads/", 11) == 0) {
7895 s
= strdup(branchname
);
7897 error
= got_error_from_errno("strdup");
7901 if (asprintf(&s
, "refs/heads/%s", branchname
) == -1) {
7902 error
= got_error_from_errno("asprintf");
7906 error
= got_pathlist_insert(&new, &delete_branches
, s
, NULL
);
7907 if (error
|| new == NULL
/* duplicate */)
7914 if (nbranches
== 0 && ndelete_branches
== 0) {
7915 struct got_reference
*head_ref
;
7917 error
= got_ref_open(&head_ref
, repo
,
7918 got_worktree_get_head_ref_name(worktree
), 0);
7920 error
= got_ref_open(&head_ref
, repo
, GOT_REF_HEAD
, 0);
7923 if (got_ref_is_symbolic(head_ref
)) {
7924 error
= got_ref_resolve_symbolic(&ref
, repo
, head_ref
);
7925 got_ref_close(head_ref
);
7930 error
= got_pathlist_append(&branches
, got_ref_get_name(ref
),
7938 printf("Connecting to \"%s\" %s%s%s\n", remote
->name
, host
,
7939 port
? ":" : "", port
? port
: "");
7941 error
= got_send_connect(&sendpid
, &sendfd
, proto
, host
, port
,
7942 server_path
, verbosity
);
7946 memset(&spa
, 0, sizeof(spa
));
7947 spa
.last_scaled_packsize
[0] = '\0';
7948 spa
.last_p_deltify
= -1;
7949 spa
.last_p_written
= -1;
7950 spa
.verbosity
= verbosity
;
7951 spa
.delete_branches
= &delete_branches
;
7952 error
= got_send_pack(remote_name
, &branches
, &tags
, &delete_branches
,
7953 verbosity
, overwrite_refs
, sendfd
, repo
, send_progress
, &spa
,
7954 check_cancelled
, NULL
);
7955 if (spa
.printed_something
)
7959 if (!spa
.sent_something
&& verbosity
>= 0)
7960 printf("Already up-to-date\n");
7963 if (kill(sendpid
, SIGTERM
) == -1)
7964 error
= got_error_from_errno("kill");
7965 if (waitpid(sendpid
, &sendstatus
, 0) == -1 && error
== NULL
)
7966 error
= got_error_from_errno("waitpid");
7968 if (sendfd
!= -1 && close(sendfd
) == -1 && error
== NULL
)
7969 error
= got_error_from_errno("close");
7971 const struct got_error
*close_err
= got_repo_close(repo
);
7976 got_worktree_close(worktree
);
7979 got_pathlist_free(&branches
);
7980 got_pathlist_free(&tags
);
7981 got_ref_list_free(&all_branches
);
7982 got_ref_list_free(&all_tags
);
7983 got_pathlist_free(&delete_args
);
7984 TAILQ_FOREACH(pe
, &delete_branches
, entry
)
7985 free((char *)pe
->path
);
7986 got_pathlist_free(&delete_branches
);
7998 usage_cherrypick(void)
8000 fprintf(stderr
, "usage: %s cherrypick commit-id\n", getprogname());
8004 static const struct got_error
*
8005 cmd_cherrypick(int argc
, char *argv
[])
8007 const struct got_error
*error
= NULL
;
8008 struct got_worktree
*worktree
= NULL
;
8009 struct got_repository
*repo
= NULL
;
8010 char *cwd
= NULL
, *commit_id_str
= NULL
;
8011 struct got_object_id
*commit_id
= NULL
;
8012 struct got_commit_object
*commit
= NULL
;
8013 struct got_object_qid
*pid
;
8015 struct got_update_progress_arg upa
;
8017 while ((ch
= getopt(argc
, argv
, "")) != -1) {
8029 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
8030 "unveil", NULL
) == -1)
8036 cwd
= getcwd(NULL
, 0);
8038 error
= got_error_from_errno("getcwd");
8041 error
= got_worktree_open(&worktree
, cwd
);
8043 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
8044 error
= wrap_not_worktree_error(error
, "cherrypick",
8049 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
8054 error
= apply_unveil(got_repo_get_path(repo
), 0,
8055 got_worktree_get_root_path(worktree
));
8059 error
= got_repo_match_object_id_prefix(&commit_id
, argv
[0],
8060 GOT_OBJ_TYPE_COMMIT
, repo
);
8061 if (error
!= NULL
) {
8062 struct got_reference
*ref
;
8063 if (error
->code
!= GOT_ERR_BAD_OBJ_ID_STR
)
8065 error
= got_ref_open(&ref
, repo
, argv
[0], 0);
8068 error
= got_ref_resolve(&commit_id
, repo
, ref
);
8073 error
= got_object_id_str(&commit_id_str
, commit_id
);
8077 error
= got_object_open_as_commit(&commit
, repo
, commit_id
);
8080 pid
= STAILQ_FIRST(got_object_commit_get_parent_ids(commit
));
8081 memset(&upa
, 0, sizeof(upa
));
8082 error
= got_worktree_merge_files(worktree
, pid
? pid
->id
: NULL
,
8083 commit_id
, repo
, update_progress
, &upa
, check_cancelled
,
8088 if (upa
.did_something
)
8089 printf("Merged commit %s\n", commit_id_str
);
8090 print_update_progress_stats(&upa
);
8093 got_object_commit_close(commit
);
8094 free(commit_id_str
);
8096 got_worktree_close(worktree
);
8098 const struct got_error
*close_err
= got_repo_close(repo
);
8108 fprintf(stderr
, "usage: %s backout commit-id\n", getprogname());
8112 static const struct got_error
*
8113 cmd_backout(int argc
, char *argv
[])
8115 const struct got_error
*error
= NULL
;
8116 struct got_worktree
*worktree
= NULL
;
8117 struct got_repository
*repo
= NULL
;
8118 char *cwd
= NULL
, *commit_id_str
= NULL
;
8119 struct got_object_id
*commit_id
= NULL
;
8120 struct got_commit_object
*commit
= NULL
;
8121 struct got_object_qid
*pid
;
8123 struct got_update_progress_arg upa
;
8125 while ((ch
= getopt(argc
, argv
, "")) != -1) {
8137 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
8138 "unveil", NULL
) == -1)
8144 cwd
= getcwd(NULL
, 0);
8146 error
= got_error_from_errno("getcwd");
8149 error
= got_worktree_open(&worktree
, cwd
);
8151 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
8152 error
= wrap_not_worktree_error(error
, "backout", cwd
);
8156 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
8161 error
= apply_unveil(got_repo_get_path(repo
), 0,
8162 got_worktree_get_root_path(worktree
));
8166 error
= got_repo_match_object_id_prefix(&commit_id
, argv
[0],
8167 GOT_OBJ_TYPE_COMMIT
, repo
);
8168 if (error
!= NULL
) {
8169 struct got_reference
*ref
;
8170 if (error
->code
!= GOT_ERR_BAD_OBJ_ID_STR
)
8172 error
= got_ref_open(&ref
, repo
, argv
[0], 0);
8175 error
= got_ref_resolve(&commit_id
, repo
, ref
);
8180 error
= got_object_id_str(&commit_id_str
, commit_id
);
8184 error
= got_object_open_as_commit(&commit
, repo
, commit_id
);
8187 pid
= STAILQ_FIRST(got_object_commit_get_parent_ids(commit
));
8189 error
= got_error(GOT_ERR_ROOT_COMMIT
);
8193 memset(&upa
, 0, sizeof(upa
));
8194 error
= got_worktree_merge_files(worktree
, commit_id
, pid
->id
,
8195 repo
, update_progress
, &upa
, check_cancelled
, NULL
);
8199 if (upa
.did_something
)
8200 printf("Backed out commit %s\n", commit_id_str
);
8201 print_update_progress_stats(&upa
);
8204 got_object_commit_close(commit
);
8205 free(commit_id_str
);
8207 got_worktree_close(worktree
);
8209 const struct got_error
*close_err
= got_repo_close(repo
);
8219 fprintf(stderr
, "usage: %s rebase [-a] [-c] [-l] [-X] [branch]\n",
8225 trim_logmsg(char *logmsg
, int limit
)
8230 len
= strlen(logmsg
);
8234 nl
= strchr(logmsg
, '\n');
8239 static const struct got_error
*
8240 get_short_logmsg(char **logmsg
, int limit
, struct got_commit_object
*commit
)
8242 const struct got_error
*err
;
8243 char *logmsg0
= NULL
;
8246 err
= got_object_commit_get_logmsg(&logmsg0
, commit
);
8251 while (isspace((unsigned char)s
[0]))
8254 *logmsg
= strdup(s
);
8255 if (*logmsg
== NULL
) {
8256 err
= got_error_from_errno("strdup");
8260 trim_logmsg(*logmsg
, limit
);
8266 static const struct got_error
*
8267 show_rebase_merge_conflict(struct got_object_id
*id
, struct got_repository
*repo
)
8269 const struct got_error
*err
;
8270 struct got_commit_object
*commit
= NULL
;
8271 char *id_str
= NULL
, *logmsg
= NULL
;
8273 err
= got_object_open_as_commit(&commit
, repo
, id
);
8277 err
= got_object_id_str(&id_str
, id
);
8283 err
= get_short_logmsg(&logmsg
, 42, commit
);
8287 printf("%s -> merge conflict: %s\n", id_str
, logmsg
);
8290 got_object_commit_close(commit
);
8295 static const struct got_error
*
8296 show_rebase_progress(struct got_commit_object
*commit
,
8297 struct got_object_id
*old_id
, struct got_object_id
*new_id
)
8299 const struct got_error
*err
;
8300 char *old_id_str
= NULL
, *new_id_str
= NULL
, *logmsg
= NULL
;
8302 err
= got_object_id_str(&old_id_str
, old_id
);
8307 err
= got_object_id_str(&new_id_str
, new_id
);
8312 old_id_str
[12] = '\0';
8314 new_id_str
[12] = '\0';
8316 err
= get_short_logmsg(&logmsg
, 42, commit
);
8320 printf("%s -> %s: %s\n", old_id_str
,
8321 new_id_str
? new_id_str
: "no-op change", logmsg
);
8329 static const struct got_error
*
8330 rebase_complete(struct got_worktree
*worktree
, struct got_fileindex
*fileindex
,
8331 struct got_reference
*branch
, struct got_reference
*new_base_branch
,
8332 struct got_reference
*tmp_branch
, struct got_repository
*repo
,
8335 printf("Switching work tree to %s\n", got_ref_get_name(branch
));
8336 return got_worktree_rebase_complete(worktree
, fileindex
,
8337 new_base_branch
, tmp_branch
, branch
, repo
, create_backup
);
8340 static const struct got_error
*
8341 rebase_commit(struct got_pathlist_head
*merged_paths
,
8342 struct got_worktree
*worktree
, struct got_fileindex
*fileindex
,
8343 struct got_reference
*tmp_branch
,
8344 struct got_object_id
*commit_id
, struct got_repository
*repo
)
8346 const struct got_error
*error
;
8347 struct got_commit_object
*commit
;
8348 struct got_object_id
*new_commit_id
;
8350 error
= got_object_open_as_commit(&commit
, repo
, commit_id
);
8354 error
= got_worktree_rebase_commit(&new_commit_id
, merged_paths
,
8355 worktree
, fileindex
, tmp_branch
, commit
, commit_id
, repo
);
8357 if (error
->code
!= GOT_ERR_COMMIT_NO_CHANGES
)
8359 error
= show_rebase_progress(commit
, commit_id
, NULL
);
8361 error
= show_rebase_progress(commit
, commit_id
, new_commit_id
);
8362 free(new_commit_id
);
8365 got_object_commit_close(commit
);
8369 struct check_path_prefix_arg
{
8370 const char *path_prefix
;
8375 static const struct got_error
*
8376 check_path_prefix_in_diff(void *arg
, struct got_blob_object
*blob1
,
8377 struct got_blob_object
*blob2
, struct got_object_id
*id1
,
8378 struct got_object_id
*id2
, const char *path1
, const char *path2
,
8379 mode_t mode1
, mode_t mode2
, struct got_repository
*repo
)
8381 struct check_path_prefix_arg
*a
= arg
;
8383 if ((path1
&& !got_path_is_child(path1
, a
->path_prefix
, a
->len
)) ||
8384 (path2
&& !got_path_is_child(path2
, a
->path_prefix
, a
->len
)))
8385 return got_error(a
->errcode
);
8390 static const struct got_error
*
8391 check_path_prefix(struct got_object_id
*parent_id
,
8392 struct got_object_id
*commit_id
, const char *path_prefix
,
8393 int errcode
, struct got_repository
*repo
)
8395 const struct got_error
*err
;
8396 struct got_tree_object
*tree1
= NULL
, *tree2
= NULL
;
8397 struct got_commit_object
*commit
= NULL
, *parent_commit
= NULL
;
8398 struct check_path_prefix_arg cpp_arg
;
8400 if (got_path_is_root_dir(path_prefix
))
8403 err
= got_object_open_as_commit(&commit
, repo
, commit_id
);
8407 err
= got_object_open_as_commit(&parent_commit
, repo
, parent_id
);
8411 err
= got_object_open_as_tree(&tree1
, repo
,
8412 got_object_commit_get_tree_id(parent_commit
));
8416 err
= got_object_open_as_tree(&tree2
, repo
,
8417 got_object_commit_get_tree_id(commit
));
8421 cpp_arg
.path_prefix
= path_prefix
;
8422 while (cpp_arg
.path_prefix
[0] == '/')
8423 cpp_arg
.path_prefix
++;
8424 cpp_arg
.len
= strlen(cpp_arg
.path_prefix
);
8425 cpp_arg
.errcode
= errcode
;
8426 err
= got_diff_tree(tree1
, tree2
, "", "", repo
,
8427 check_path_prefix_in_diff
, &cpp_arg
, 0);
8430 got_object_tree_close(tree1
);
8432 got_object_tree_close(tree2
);
8434 got_object_commit_close(commit
);
8436 got_object_commit_close(parent_commit
);
8440 static const struct got_error
*
8441 collect_commits(struct got_object_id_queue
*commits
,
8442 struct got_object_id
*initial_commit_id
,
8443 struct got_object_id
*iter_start_id
, struct got_object_id
*iter_stop_id
,
8444 const char *path_prefix
, int path_prefix_errcode
,
8445 struct got_repository
*repo
)
8447 const struct got_error
*err
= NULL
;
8448 struct got_commit_graph
*graph
= NULL
;
8449 struct got_object_id
*parent_id
= NULL
;
8450 struct got_object_qid
*qid
;
8451 struct got_object_id
*commit_id
= initial_commit_id
;
8453 err
= got_commit_graph_open(&graph
, "/", 1);
8457 err
= got_commit_graph_iter_start(graph
, iter_start_id
, repo
,
8458 check_cancelled
, NULL
);
8461 while (got_object_id_cmp(commit_id
, iter_stop_id
) != 0) {
8462 err
= got_commit_graph_iter_next(&parent_id
, graph
, repo
,
8463 check_cancelled
, NULL
);
8465 if (err
->code
== GOT_ERR_ITER_COMPLETED
) {
8466 err
= got_error_msg(GOT_ERR_ANCESTRY
,
8467 "ran out of commits to rebase before "
8468 "youngest common ancestor commit has "
8473 err
= check_path_prefix(parent_id
, commit_id
,
8474 path_prefix
, path_prefix_errcode
, repo
);
8478 err
= got_object_qid_alloc(&qid
, commit_id
);
8481 STAILQ_INSERT_HEAD(commits
, qid
, entry
);
8482 commit_id
= parent_id
;
8486 got_commit_graph_close(graph
);
8490 static const struct got_error
*
8491 get_commit_brief_str(char **brief_str
, struct got_commit_object
*commit
)
8493 const struct got_error
*err
= NULL
;
8494 time_t committer_time
;
8496 char datebuf
[11]; /* YYYY-MM-DD + NUL */
8497 char *author0
= NULL
, *author
, *smallerthan
;
8498 char *logmsg0
= NULL
, *logmsg
, *newline
;
8500 committer_time
= got_object_commit_get_committer_time(commit
);
8501 if (gmtime_r(&committer_time
, &tm
) == NULL
)
8502 return got_error_from_errno("gmtime_r");
8503 if (strftime(datebuf
, sizeof(datebuf
), "%G-%m-%d", &tm
) == 0)
8504 return got_error(GOT_ERR_NO_SPACE
);
8506 author0
= strdup(got_object_commit_get_author(commit
));
8507 if (author0
== NULL
)
8508 return got_error_from_errno("strdup");
8510 smallerthan
= strchr(author
, '<');
8511 if (smallerthan
&& smallerthan
[1] != '\0')
8512 author
= smallerthan
+ 1;
8513 author
[strcspn(author
, "@>")] = '\0';
8515 err
= got_object_commit_get_logmsg(&logmsg0
, commit
);
8519 while (*logmsg
== '\n')
8521 newline
= strchr(logmsg
, '\n');
8525 if (asprintf(brief_str
, "%s %s %s",
8526 datebuf
, author
, logmsg
) == -1)
8527 err
= got_error_from_errno("asprintf");
8534 static const struct got_error
*
8535 delete_backup_ref(struct got_reference
*ref
, struct got_object_id
*id
,
8536 struct got_repository
*repo
)
8538 const struct got_error
*err
;
8541 err
= got_object_id_str(&id_str
, id
);
8545 err
= got_ref_delete(ref
, repo
);
8549 printf("Deleted %s: %s\n", got_ref_get_name(ref
), id_str
);
8555 static const struct got_error
*
8556 print_backup_ref(const char *branch_name
, const char *new_id_str
,
8557 struct got_object_id
*old_commit_id
, struct got_commit_object
*old_commit
,
8558 struct got_reflist_object_id_map
*refs_idmap
,
8559 struct got_repository
*repo
)
8561 const struct got_error
*err
= NULL
;
8562 struct got_reflist_head
*refs
;
8563 char *refs_str
= NULL
;
8564 struct got_object_id
*new_commit_id
= NULL
;
8565 struct got_commit_object
*new_commit
= NULL
;
8566 char *new_commit_brief_str
= NULL
;
8567 struct got_object_id
*yca_id
= NULL
;
8568 struct got_commit_object
*yca_commit
= NULL
;
8569 char *yca_id_str
= NULL
, *yca_brief_str
= NULL
;
8570 char *custom_refs_str
;
8572 if (asprintf(&custom_refs_str
, "formerly %s", branch_name
) == -1)
8573 return got_error_from_errno("asprintf");
8575 err
= print_commit(old_commit
, old_commit_id
, repo
, NULL
, NULL
,
8576 0, 0, refs_idmap
, custom_refs_str
);
8580 err
= got_object_resolve_id_str(&new_commit_id
, repo
, new_id_str
);
8584 refs
= got_reflist_object_id_map_lookup(refs_idmap
, new_commit_id
);
8586 err
= build_refs_str(&refs_str
, refs
, new_commit_id
, repo
);
8591 err
= got_object_open_as_commit(&new_commit
, repo
, new_commit_id
);
8595 err
= get_commit_brief_str(&new_commit_brief_str
, new_commit
);
8599 err
= got_commit_graph_find_youngest_common_ancestor(&yca_id
,
8600 old_commit_id
, new_commit_id
, repo
, check_cancelled
, NULL
);
8604 printf("has become commit %s%s%s%s\n %s\n", new_id_str
,
8605 refs_str
? " (" : "", refs_str
? refs_str
: "",
8606 refs_str
? ")" : "", new_commit_brief_str
);
8607 if (yca_id
&& got_object_id_cmp(yca_id
, new_commit_id
) != 0 &&
8608 got_object_id_cmp(yca_id
, old_commit_id
) != 0) {
8612 err
= got_object_open_as_commit(&yca_commit
, repo
, yca_id
);
8616 err
= get_commit_brief_str(&yca_brief_str
, yca_commit
);
8620 err
= got_object_id_str(&yca_id_str
, yca_id
);
8624 refs
= got_reflist_object_id_map_lookup(refs_idmap
, yca_id
);
8626 err
= build_refs_str(&refs_str
, refs
, yca_id
, repo
);
8630 printf("history forked at %s%s%s%s\n %s\n",
8632 refs_str
? " (" : "", refs_str
? refs_str
: "",
8633 refs_str
? ")" : "", yca_brief_str
);
8636 free(custom_refs_str
);
8637 free(new_commit_id
);
8641 free(yca_brief_str
);
8643 got_object_commit_close(new_commit
);
8645 got_object_commit_close(yca_commit
);
8650 static const struct got_error
*
8651 process_backup_refs(const char *backup_ref_prefix
, const char *wanted_branch_name
,
8652 int delete, struct got_repository
*repo
)
8654 const struct got_error
*err
;
8655 struct got_reflist_head refs
, backup_refs
;
8656 struct got_reflist_entry
*re
;
8657 const size_t backup_ref_prefix_len
= strlen(backup_ref_prefix
);
8658 struct got_object_id
*old_commit_id
= NULL
;
8659 char *branch_name
= NULL
;
8660 struct got_commit_object
*old_commit
= NULL
;
8661 struct got_reflist_object_id_map
*refs_idmap
= NULL
;
8662 int wanted_branch_found
= 0;
8665 TAILQ_INIT(&backup_refs
);
8667 err
= got_ref_list(&refs
, repo
, NULL
, got_ref_cmp_by_name
, NULL
);
8671 err
= got_reflist_object_id_map_create(&refs_idmap
, &refs
, repo
);
8675 if (wanted_branch_name
) {
8676 if (strncmp(wanted_branch_name
, "refs/heads/", 11) == 0)
8677 wanted_branch_name
+= 11;
8680 err
= got_ref_list(&backup_refs
, repo
, backup_ref_prefix
,
8681 got_ref_cmp_by_commit_timestamp_descending
, repo
);
8685 TAILQ_FOREACH(re
, &backup_refs
, entry
) {
8686 const char *refname
= got_ref_get_name(re
->ref
);
8689 err
= check_cancelled(NULL
);
8693 err
= got_ref_resolve(&old_commit_id
, repo
, re
->ref
);
8697 err
= got_object_open_as_commit(&old_commit
, repo
,
8702 if (strncmp(backup_ref_prefix
, refname
,
8703 backup_ref_prefix_len
) == 0)
8704 refname
+= backup_ref_prefix_len
;
8706 while (refname
[0] == '/')
8709 branch_name
= strdup(refname
);
8710 if (branch_name
== NULL
) {
8711 err
= got_error_from_errno("strdup");
8714 slash
= strrchr(branch_name
, '/');
8717 refname
+= strlen(branch_name
) + 1;
8720 if (wanted_branch_name
== NULL
||
8721 strcmp(wanted_branch_name
, branch_name
) == 0) {
8722 wanted_branch_found
= 1;
8724 err
= delete_backup_ref(re
->ref
,
8725 old_commit_id
, repo
);
8727 err
= print_backup_ref(branch_name
, refname
,
8728 old_commit_id
, old_commit
, refs_idmap
,
8735 free(old_commit_id
);
8736 old_commit_id
= NULL
;
8739 got_object_commit_close(old_commit
);
8743 if (wanted_branch_name
&& !wanted_branch_found
) {
8744 err
= got_error_fmt(GOT_ERR_NOT_REF
,
8745 "%s/%s/", backup_ref_prefix
, wanted_branch_name
);
8749 got_reflist_object_id_map_free(refs_idmap
);
8750 got_ref_list_free(&refs
);
8751 got_ref_list_free(&backup_refs
);
8752 free(old_commit_id
);
8755 got_object_commit_close(old_commit
);
8759 static const struct got_error
*
8760 cmd_rebase(int argc
, char *argv
[])
8762 const struct got_error
*error
= NULL
;
8763 struct got_worktree
*worktree
= NULL
;
8764 struct got_repository
*repo
= NULL
;
8765 struct got_fileindex
*fileindex
= NULL
;
8767 struct got_reference
*branch
= NULL
;
8768 struct got_reference
*new_base_branch
= NULL
, *tmp_branch
= NULL
;
8769 struct got_object_id
*commit_id
= NULL
, *parent_id
= NULL
;
8770 struct got_object_id
*resume_commit_id
= NULL
;
8771 struct got_object_id
*branch_head_commit_id
= NULL
, *yca_id
= NULL
;
8772 struct got_commit_object
*commit
= NULL
;
8773 int ch
, rebase_in_progress
= 0, abort_rebase
= 0, continue_rebase
= 0;
8774 int histedit_in_progress
= 0, merge_in_progress
= 0;
8775 int create_backup
= 1, list_backups
= 0, delete_backups
= 0;
8776 unsigned char rebase_status
= GOT_STATUS_NO_CHANGE
;
8777 struct got_object_id_queue commits
;
8778 struct got_pathlist_head merged_paths
;
8779 const struct got_object_id_queue
*parent_ids
;
8780 struct got_object_qid
*qid
, *pid
;
8782 STAILQ_INIT(&commits
);
8783 TAILQ_INIT(&merged_paths
);
8785 while ((ch
= getopt(argc
, argv
, "aclX")) != -1) {
8791 continue_rebase
= 1;
8809 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
8810 "unveil", NULL
) == -1)
8815 option_conflict('l', 'a');
8816 if (continue_rebase
)
8817 option_conflict('l', 'c');
8819 option_conflict('l', 'X');
8820 if (argc
!= 0 && argc
!= 1)
8822 } else if (delete_backups
) {
8824 option_conflict('X', 'a');
8825 if (continue_rebase
)
8826 option_conflict('X', 'c');
8828 option_conflict('l', 'X');
8829 if (argc
!= 0 && argc
!= 1)
8832 if (abort_rebase
&& continue_rebase
)
8834 else if (abort_rebase
|| continue_rebase
) {
8837 } else if (argc
!= 1)
8841 cwd
= getcwd(NULL
, 0);
8843 error
= got_error_from_errno("getcwd");
8846 error
= got_worktree_open(&worktree
, cwd
);
8848 if (list_backups
|| delete_backups
) {
8849 if (error
->code
!= GOT_ERR_NOT_WORKTREE
)
8852 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
8853 error
= wrap_not_worktree_error(error
,
8859 error
= got_repo_open(&repo
,
8860 worktree
? got_worktree_get_repo_path(worktree
) : cwd
, NULL
);
8864 error
= apply_unveil(got_repo_get_path(repo
), 0,
8865 worktree
? got_worktree_get_root_path(worktree
) : NULL
);
8869 if (list_backups
|| delete_backups
) {
8870 error
= process_backup_refs(
8871 GOT_WORKTREE_REBASE_BACKUP_REF_PREFIX
,
8872 argc
== 1 ? argv
[0] : NULL
, delete_backups
, repo
);
8873 goto done
; /* nothing else to do */
8876 error
= got_worktree_histedit_in_progress(&histedit_in_progress
,
8880 if (histedit_in_progress
) {
8881 error
= got_error(GOT_ERR_HISTEDIT_BUSY
);
8885 error
= got_worktree_merge_in_progress(&merge_in_progress
,
8889 if (merge_in_progress
) {
8890 error
= got_error(GOT_ERR_MERGE_BUSY
);
8894 error
= got_worktree_rebase_in_progress(&rebase_in_progress
, worktree
);
8899 struct got_update_progress_arg upa
;
8900 if (!rebase_in_progress
) {
8901 error
= got_error(GOT_ERR_NOT_REBASING
);
8904 error
= got_worktree_rebase_continue(&resume_commit_id
,
8905 &new_base_branch
, &tmp_branch
, &branch
, &fileindex
,
8909 printf("Switching work tree to %s\n",
8910 got_ref_get_symref_target(new_base_branch
));
8911 memset(&upa
, 0, sizeof(upa
));
8912 error
= got_worktree_rebase_abort(worktree
, fileindex
, repo
,
8913 new_base_branch
, update_progress
, &upa
);
8916 printf("Rebase of %s aborted\n", got_ref_get_name(branch
));
8917 print_update_progress_stats(&upa
);
8918 goto done
; /* nothing else to do */
8921 if (continue_rebase
) {
8922 if (!rebase_in_progress
) {
8923 error
= got_error(GOT_ERR_NOT_REBASING
);
8926 error
= got_worktree_rebase_continue(&resume_commit_id
,
8927 &new_base_branch
, &tmp_branch
, &branch
, &fileindex
,
8932 error
= rebase_commit(NULL
, worktree
, fileindex
, tmp_branch
,
8933 resume_commit_id
, repo
);
8937 yca_id
= got_object_id_dup(resume_commit_id
);
8938 if (yca_id
== NULL
) {
8939 error
= got_error_from_errno("got_object_id_dup");
8943 error
= got_ref_open(&branch
, repo
, argv
[0], 0);
8948 error
= got_ref_resolve(&branch_head_commit_id
, repo
, branch
);
8952 if (!continue_rebase
) {
8953 struct got_object_id
*base_commit_id
;
8955 base_commit_id
= got_worktree_get_base_commit_id(worktree
);
8956 error
= got_commit_graph_find_youngest_common_ancestor(&yca_id
,
8957 base_commit_id
, branch_head_commit_id
, repo
,
8958 check_cancelled
, NULL
);
8961 if (yca_id
== NULL
) {
8962 error
= got_error_msg(GOT_ERR_ANCESTRY
,
8963 "specified branch shares no common ancestry "
8964 "with work tree's branch");
8968 error
= check_same_branch(base_commit_id
, branch
, yca_id
, repo
);
8970 if (error
->code
!= GOT_ERR_ANCESTRY
)
8974 static char msg
[128];
8975 snprintf(msg
, sizeof(msg
),
8976 "%s is already based on %s",
8977 got_ref_get_name(branch
),
8978 got_worktree_get_head_ref_name(worktree
));
8979 error
= got_error_msg(GOT_ERR_SAME_BRANCH
, msg
);
8982 error
= got_worktree_rebase_prepare(&new_base_branch
,
8983 &tmp_branch
, &fileindex
, worktree
, branch
, repo
);
8988 commit_id
= branch_head_commit_id
;
8989 error
= got_object_open_as_commit(&commit
, repo
, commit_id
);
8993 parent_ids
= got_object_commit_get_parent_ids(commit
);
8994 pid
= STAILQ_FIRST(parent_ids
);
8996 if (!continue_rebase
) {
8997 struct got_update_progress_arg upa
;
8998 memset(&upa
, 0, sizeof(upa
));
8999 error
= got_worktree_rebase_abort(worktree
, fileindex
,
9000 repo
, new_base_branch
, update_progress
, &upa
);
9003 printf("Rebase of %s aborted\n",
9004 got_ref_get_name(branch
));
9005 print_update_progress_stats(&upa
);
9008 error
= got_error(GOT_ERR_EMPTY_REBASE
);
9011 error
= collect_commits(&commits
, commit_id
, pid
->id
,
9012 yca_id
, got_worktree_get_path_prefix(worktree
),
9013 GOT_ERR_REBASE_PATH
, repo
);
9014 got_object_commit_close(commit
);
9019 if (STAILQ_EMPTY(&commits
)) {
9020 if (continue_rebase
) {
9021 error
= rebase_complete(worktree
, fileindex
,
9022 branch
, new_base_branch
, tmp_branch
, repo
,
9026 /* Fast-forward the reference of the branch. */
9027 struct got_object_id
*new_head_commit_id
;
9029 error
= got_ref_resolve(&new_head_commit_id
, repo
,
9033 error
= got_object_id_str(&id_str
, new_head_commit_id
);
9034 printf("Forwarding %s to commit %s\n",
9035 got_ref_get_name(branch
), id_str
);
9037 error
= got_ref_change_ref(branch
,
9038 new_head_commit_id
);
9041 /* No backup needed since objects did not change. */
9047 STAILQ_FOREACH(qid
, &commits
, entry
) {
9048 struct got_update_progress_arg upa
;
9050 commit_id
= qid
->id
;
9051 parent_id
= pid
? pid
->id
: yca_id
;
9054 memset(&upa
, 0, sizeof(upa
));
9055 error
= got_worktree_rebase_merge_files(&merged_paths
,
9056 worktree
, fileindex
, parent_id
, commit_id
, repo
,
9057 update_progress
, &upa
, check_cancelled
, NULL
);
9061 print_update_progress_stats(&upa
);
9062 if (upa
.conflicts
> 0)
9063 rebase_status
= GOT_STATUS_CONFLICT
;
9065 if (rebase_status
== GOT_STATUS_CONFLICT
) {
9066 error
= show_rebase_merge_conflict(qid
->id
, repo
);
9069 got_worktree_rebase_pathlist_free(&merged_paths
);
9073 error
= rebase_commit(&merged_paths
, worktree
, fileindex
,
9074 tmp_branch
, commit_id
, repo
);
9075 got_worktree_rebase_pathlist_free(&merged_paths
);
9080 if (rebase_status
== GOT_STATUS_CONFLICT
) {
9081 error
= got_worktree_rebase_postpone(worktree
, fileindex
);
9084 error
= got_error_msg(GOT_ERR_CONFLICTS
,
9085 "conflicts must be resolved before rebasing can continue");
9087 error
= rebase_complete(worktree
, fileindex
, branch
,
9088 new_base_branch
, tmp_branch
, repo
, create_backup
);
9090 got_object_id_queue_free(&commits
);
9091 free(branch_head_commit_id
);
9092 free(resume_commit_id
);
9095 got_object_commit_close(commit
);
9097 got_ref_close(branch
);
9098 if (new_base_branch
)
9099 got_ref_close(new_base_branch
);
9101 got_ref_close(tmp_branch
);
9103 got_worktree_close(worktree
);
9105 const struct got_error
*close_err
= got_repo_close(repo
);
9113 usage_histedit(void)
9115 fprintf(stderr
, "usage: %s histedit [-a] [-c] [-f] "
9116 "[-F histedit-script] [-m] [-l] [-X] [branch]\n",
9121 #define GOT_HISTEDIT_PICK 'p'
9122 #define GOT_HISTEDIT_EDIT 'e'
9123 #define GOT_HISTEDIT_FOLD 'f'
9124 #define GOT_HISTEDIT_DROP 'd'
9125 #define GOT_HISTEDIT_MESG 'm'
9127 static struct got_histedit_cmd
{
9131 } got_histedit_cmds
[] = {
9132 { GOT_HISTEDIT_PICK
, "pick", "use commit" },
9133 { GOT_HISTEDIT_EDIT
, "edit", "use commit but stop for amending" },
9134 { GOT_HISTEDIT_FOLD
, "fold", "combine with next commit that will "
9136 { GOT_HISTEDIT_DROP
, "drop", "remove commit from history" },
9137 { GOT_HISTEDIT_MESG
, "mesg",
9138 "single-line log message for commit above (open editor if empty)" },
9141 struct got_histedit_list_entry
{
9142 TAILQ_ENTRY(got_histedit_list_entry
) entry
;
9143 struct got_object_id
*commit_id
;
9144 const struct got_histedit_cmd
*cmd
;
9147 TAILQ_HEAD(got_histedit_list
, got_histedit_list_entry
);
9149 static const struct got_error
*
9150 histedit_write_commit(struct got_object_id
*commit_id
, const char *cmdname
,
9151 FILE *f
, struct got_repository
*repo
)
9153 const struct got_error
*err
= NULL
;
9154 char *logmsg
= NULL
, *id_str
= NULL
;
9155 struct got_commit_object
*commit
= NULL
;
9158 err
= got_object_open_as_commit(&commit
, repo
, commit_id
);
9162 err
= get_short_logmsg(&logmsg
, 34, commit
);
9166 err
= got_object_id_str(&id_str
, commit_id
);
9170 n
= fprintf(f
, "%s %s %s\n", cmdname
, id_str
, logmsg
);
9172 err
= got_ferror(f
, GOT_ERR_IO
);
9175 got_object_commit_close(commit
);
9181 static const struct got_error
*
9182 histedit_write_commit_list(struct got_object_id_queue
*commits
,
9183 FILE *f
, int edit_logmsg_only
, int fold_only
, struct got_repository
*repo
)
9185 const struct got_error
*err
= NULL
;
9186 struct got_object_qid
*qid
;
9187 const char *histedit_cmd
= NULL
;
9189 if (STAILQ_EMPTY(commits
))
9190 return got_error(GOT_ERR_EMPTY_HISTEDIT
);
9192 STAILQ_FOREACH(qid
, commits
, entry
) {
9193 histedit_cmd
= got_histedit_cmds
[0].name
;
9194 if (fold_only
&& STAILQ_NEXT(qid
, entry
) != NULL
)
9195 histedit_cmd
= "fold";
9196 err
= histedit_write_commit(qid
->id
, histedit_cmd
, f
, repo
);
9199 if (edit_logmsg_only
) {
9200 int n
= fprintf(f
, "%c\n", GOT_HISTEDIT_MESG
);
9202 err
= got_ferror(f
, GOT_ERR_IO
);
9211 static const struct got_error
*
9212 write_cmd_list(FILE *f
, const char *branch_name
,
9213 struct got_object_id_queue
*commits
)
9215 const struct got_error
*err
= NULL
;
9219 struct got_object_qid
*qid
;
9221 qid
= STAILQ_FIRST(commits
);
9222 err
= got_object_id_str(&id_str
, qid
->id
);
9227 "# Editing the history of branch '%s' starting at\n"
9229 "# Commits will be processed in order from top to "
9230 "bottom of this file.\n", branch_name
, id_str
);
9232 err
= got_ferror(f
, GOT_ERR_IO
);
9236 n
= fprintf(f
, "# Available histedit commands:\n");
9238 err
= got_ferror(f
, GOT_ERR_IO
);
9242 for (i
= 0; i
< nitems(got_histedit_cmds
); i
++) {
9243 struct got_histedit_cmd
*cmd
= &got_histedit_cmds
[i
];
9244 n
= fprintf(f
, "# %s (%c): %s\n", cmd
->name
, cmd
->code
,
9247 err
= got_ferror(f
, GOT_ERR_IO
);
9256 static const struct got_error
*
9257 histedit_syntax_error(int lineno
)
9259 static char msg
[42];
9262 ret
= snprintf(msg
, sizeof(msg
), "histedit syntax error on line %d",
9264 if (ret
== -1 || ret
>= sizeof(msg
))
9265 return got_error(GOT_ERR_HISTEDIT_SYNTAX
);
9267 return got_error_msg(GOT_ERR_HISTEDIT_SYNTAX
, msg
);
9270 static const struct got_error
*
9271 append_folded_commit_msg(char **new_msg
, struct got_histedit_list_entry
*hle
,
9272 char *logmsg
, struct got_repository
*repo
)
9274 const struct got_error
*err
;
9275 struct got_commit_object
*folded_commit
= NULL
;
9276 char *id_str
, *folded_logmsg
= NULL
;
9278 err
= got_object_id_str(&id_str
, hle
->commit_id
);
9282 err
= got_object_open_as_commit(&folded_commit
, repo
, hle
->commit_id
);
9286 err
= got_object_commit_get_logmsg(&folded_logmsg
, folded_commit
);
9289 if (asprintf(new_msg
, "%s%s# log message of folded commit %s: %s",
9290 logmsg
? logmsg
: "", logmsg
? "\n" : "", id_str
,
9291 folded_logmsg
) == -1) {
9292 err
= got_error_from_errno("asprintf");
9296 got_object_commit_close(folded_commit
);
9298 free(folded_logmsg
);
9302 static struct got_histedit_list_entry
*
9303 get_folded_commits(struct got_histedit_list_entry
*hle
)
9305 struct got_histedit_list_entry
*prev
, *folded
= NULL
;
9307 prev
= TAILQ_PREV(hle
, got_histedit_list
, entry
);
9308 while (prev
&& (prev
->cmd
->code
== GOT_HISTEDIT_FOLD
||
9309 prev
->cmd
->code
== GOT_HISTEDIT_DROP
)) {
9310 if (prev
->cmd
->code
== GOT_HISTEDIT_FOLD
)
9312 prev
= TAILQ_PREV(prev
, got_histedit_list
, entry
);
9318 static const struct got_error
*
9319 histedit_edit_logmsg(struct got_histedit_list_entry
*hle
,
9320 struct got_repository
*repo
)
9322 char *logmsg_path
= NULL
, *id_str
= NULL
, *orig_logmsg
= NULL
;
9323 char *logmsg
= NULL
, *new_msg
= NULL
, *editor
= NULL
;
9324 const struct got_error
*err
= NULL
;
9325 struct got_commit_object
*commit
= NULL
;
9328 struct got_histedit_list_entry
*folded
= NULL
;
9330 err
= got_object_open_as_commit(&commit
, repo
, hle
->commit_id
);
9334 folded
= get_folded_commits(hle
);
9336 while (folded
!= hle
) {
9337 if (folded
->cmd
->code
== GOT_HISTEDIT_DROP
) {
9338 folded
= TAILQ_NEXT(folded
, entry
);
9341 err
= append_folded_commit_msg(&new_msg
, folded
,
9347 folded
= TAILQ_NEXT(folded
, entry
);
9351 err
= got_object_id_str(&id_str
, hle
->commit_id
);
9354 err
= got_object_commit_get_logmsg(&orig_logmsg
, commit
);
9357 logmsg_len
= asprintf(&new_msg
,
9358 "%s\n# original log message of commit %s: %s",
9359 logmsg
? logmsg
: "", id_str
, orig_logmsg
);
9360 if (logmsg_len
== -1) {
9361 err
= got_error_from_errno("asprintf");
9367 err
= got_object_id_str(&id_str
, hle
->commit_id
);
9371 err
= got_opentemp_named_fd(&logmsg_path
, &fd
,
9372 GOT_TMPDIR_STR
"/got-logmsg");
9376 write(fd
, logmsg
, logmsg_len
);
9379 err
= get_editor(&editor
);
9383 err
= edit_logmsg(&hle
->logmsg
, editor
, logmsg_path
, logmsg
,
9386 if (err
->code
!= GOT_ERR_COMMIT_MSG_EMPTY
)
9389 hle
->logmsg
= strdup(new_msg
);
9390 if (hle
->logmsg
== NULL
)
9391 err
= got_error_from_errno("strdup");
9394 if (logmsg_path
&& unlink(logmsg_path
) != 0 && err
== NULL
)
9395 err
= got_error_from_errno2("unlink", logmsg_path
);
9401 got_object_commit_close(commit
);
9405 static const struct got_error
*
9406 histedit_parse_list(struct got_histedit_list
*histedit_cmds
,
9407 FILE *f
, struct got_repository
*repo
)
9409 const struct got_error
*err
= NULL
;
9410 char *line
= NULL
, *p
, *end
;
9414 const struct got_histedit_cmd
*cmd
;
9415 struct got_object_id
*commit_id
= NULL
;
9416 struct got_histedit_list_entry
*hle
= NULL
;
9419 len
= getline(&line
, &size
, f
);
9421 const struct got_error
*getline_err
;
9424 getline_err
= got_error_from_errno("getline");
9425 err
= got_ferror(f
, getline_err
->code
);
9430 while (isspace((unsigned char)p
[0]))
9432 if (p
[0] == '#' || p
[0] == '\0') {
9438 for (i
= 0; i
< nitems(got_histedit_cmds
); i
++) {
9439 cmd
= &got_histedit_cmds
[i
];
9440 if (strncmp(cmd
->name
, p
, strlen(cmd
->name
)) == 0 &&
9441 isspace((unsigned char)p
[strlen(cmd
->name
)])) {
9442 p
+= strlen(cmd
->name
);
9445 if (p
[0] == cmd
->code
&& isspace((unsigned char)p
[1])) {
9450 if (i
== nitems(got_histedit_cmds
)) {
9451 err
= histedit_syntax_error(lineno
);
9454 while (isspace((unsigned char)p
[0]))
9456 if (cmd
->code
== GOT_HISTEDIT_MESG
) {
9457 if (hle
== NULL
|| hle
->logmsg
!= NULL
) {
9458 err
= got_error(GOT_ERR_HISTEDIT_CMD
);
9462 err
= histedit_edit_logmsg(hle
, repo
);
9466 hle
->logmsg
= strdup(p
);
9467 if (hle
->logmsg
== NULL
) {
9468 err
= got_error_from_errno("strdup");
9477 while (end
[0] && !isspace((unsigned char)end
[0]))
9481 err
= got_object_resolve_id_str(&commit_id
, repo
, p
);
9483 /* override error code */
9484 err
= histedit_syntax_error(lineno
);
9488 hle
= malloc(sizeof(*hle
));
9490 err
= got_error_from_errno("malloc");
9494 hle
->commit_id
= commit_id
;
9499 TAILQ_INSERT_TAIL(histedit_cmds
, hle
, entry
);
9507 static const struct got_error
*
9508 histedit_check_script(struct got_histedit_list
*histedit_cmds
,
9509 struct got_object_id_queue
*commits
, struct got_repository
*repo
)
9511 const struct got_error
*err
= NULL
;
9512 struct got_object_qid
*qid
;
9513 struct got_histedit_list_entry
*hle
;
9514 static char msg
[92];
9517 if (TAILQ_EMPTY(histedit_cmds
))
9518 return got_error_msg(GOT_ERR_EMPTY_HISTEDIT
,
9519 "histedit script contains no commands");
9520 if (STAILQ_EMPTY(commits
))
9521 return got_error(GOT_ERR_EMPTY_HISTEDIT
);
9523 TAILQ_FOREACH(hle
, histedit_cmds
, entry
) {
9524 struct got_histedit_list_entry
*hle2
;
9525 TAILQ_FOREACH(hle2
, histedit_cmds
, entry
) {
9528 if (got_object_id_cmp(hle
->commit_id
,
9529 hle2
->commit_id
) != 0)
9531 err
= got_object_id_str(&id_str
, hle
->commit_id
);
9534 snprintf(msg
, sizeof(msg
), "commit %s is listed "
9535 "more than once in histedit script", id_str
);
9537 return got_error_msg(GOT_ERR_HISTEDIT_CMD
, msg
);
9541 STAILQ_FOREACH(qid
, commits
, entry
) {
9542 TAILQ_FOREACH(hle
, histedit_cmds
, entry
) {
9543 if (got_object_id_cmp(qid
->id
, hle
->commit_id
) == 0)
9547 err
= got_object_id_str(&id_str
, qid
->id
);
9550 snprintf(msg
, sizeof(msg
),
9551 "commit %s missing from histedit script", id_str
);
9553 return got_error_msg(GOT_ERR_HISTEDIT_CMD
, msg
);
9557 hle
= TAILQ_LAST(histedit_cmds
, got_histedit_list
);
9558 if (hle
&& hle
->cmd
->code
== GOT_HISTEDIT_FOLD
)
9559 return got_error_msg(GOT_ERR_HISTEDIT_CMD
,
9560 "last commit in histedit script cannot be folded");
9565 static const struct got_error
*
9566 histedit_run_editor(struct got_histedit_list
*histedit_cmds
,
9567 const char *path
, struct got_object_id_queue
*commits
,
9568 struct got_repository
*repo
)
9570 const struct got_error
*err
= NULL
;
9574 err
= get_editor(&editor
);
9578 if (spawn_editor(editor
, path
) == -1) {
9579 err
= got_error_from_errno("failed spawning editor");
9583 f
= fopen(path
, "r");
9585 err
= got_error_from_errno("fopen");
9588 err
= histedit_parse_list(histedit_cmds
, f
, repo
);
9592 err
= histedit_check_script(histedit_cmds
, commits
, repo
);
9594 if (f
&& fclose(f
) == EOF
&& err
== NULL
)
9595 err
= got_error_from_errno("fclose");
9600 static const struct got_error
*
9601 histedit_edit_list_retry(struct got_histedit_list
*, const struct got_error
*,
9602 struct got_object_id_queue
*, const char *, const char *,
9603 struct got_repository
*);
9605 static const struct got_error
*
9606 histedit_edit_script(struct got_histedit_list
*histedit_cmds
,
9607 struct got_object_id_queue
*commits
, const char *branch_name
,
9608 int edit_logmsg_only
, int fold_only
, struct got_repository
*repo
)
9610 const struct got_error
*err
;
9614 err
= got_opentemp_named(&path
, &f
, "got-histedit");
9618 err
= write_cmd_list(f
, branch_name
, commits
);
9622 err
= histedit_write_commit_list(commits
, f
, edit_logmsg_only
,
9627 if (edit_logmsg_only
|| fold_only
) {
9629 err
= histedit_parse_list(histedit_cmds
, f
, repo
);
9631 if (fclose(f
) == EOF
) {
9632 err
= got_error_from_errno("fclose");
9636 err
= histedit_run_editor(histedit_cmds
, path
, commits
, repo
);
9638 if (err
->code
!= GOT_ERR_HISTEDIT_SYNTAX
&&
9639 err
->code
!= GOT_ERR_HISTEDIT_CMD
)
9641 err
= histedit_edit_list_retry(histedit_cmds
, err
,
9642 commits
, path
, branch_name
, repo
);
9646 if (f
&& fclose(f
) == EOF
&& err
== NULL
)
9647 err
= got_error_from_errno("fclose");
9648 if (path
&& unlink(path
) != 0 && err
== NULL
)
9649 err
= got_error_from_errno2("unlink", path
);
9654 static const struct got_error
*
9655 histedit_save_list(struct got_histedit_list
*histedit_cmds
,
9656 struct got_worktree
*worktree
, struct got_repository
*repo
)
9658 const struct got_error
*err
= NULL
;
9661 struct got_histedit_list_entry
*hle
;
9662 struct got_commit_object
*commit
= NULL
;
9664 err
= got_worktree_get_histedit_script_path(&path
, worktree
);
9668 f
= fopen(path
, "w");
9670 err
= got_error_from_errno2("fopen", path
);
9673 TAILQ_FOREACH(hle
, histedit_cmds
, entry
) {
9674 err
= histedit_write_commit(hle
->commit_id
, hle
->cmd
->name
, f
,
9680 int n
= fprintf(f
, "%c %s\n",
9681 GOT_HISTEDIT_MESG
, hle
->logmsg
);
9683 err
= got_ferror(f
, GOT_ERR_IO
);
9689 if (f
&& fclose(f
) == EOF
&& err
== NULL
)
9690 err
= got_error_from_errno("fclose");
9693 got_object_commit_close(commit
);
9698 histedit_free_list(struct got_histedit_list
*histedit_cmds
)
9700 struct got_histedit_list_entry
*hle
;
9702 while ((hle
= TAILQ_FIRST(histedit_cmds
))) {
9703 TAILQ_REMOVE(histedit_cmds
, hle
, entry
);
9708 static const struct got_error
*
9709 histedit_load_list(struct got_histedit_list
*histedit_cmds
,
9710 const char *path
, struct got_repository
*repo
)
9712 const struct got_error
*err
= NULL
;
9715 f
= fopen(path
, "r");
9717 err
= got_error_from_errno2("fopen", path
);
9721 err
= histedit_parse_list(histedit_cmds
, f
, repo
);
9723 if (f
&& fclose(f
) == EOF
&& err
== NULL
)
9724 err
= got_error_from_errno("fclose");
9728 static const struct got_error
*
9729 histedit_edit_list_retry(struct got_histedit_list
*histedit_cmds
,
9730 const struct got_error
*edit_err
, struct got_object_id_queue
*commits
,
9731 const char *path
, const char *branch_name
, struct got_repository
*repo
)
9733 const struct got_error
*err
= NULL
, *prev_err
= edit_err
;
9736 while (resp
!= 'c' && resp
!= 'r' && resp
!= 'a') {
9737 printf("%s: %s\n(c)ontinue editing, (r)estart editing, "
9738 "or (a)bort: ", getprogname(), prev_err
->msg
);
9743 histedit_free_list(histedit_cmds
);
9744 err
= histedit_run_editor(histedit_cmds
, path
, commits
,
9747 if (err
->code
!= GOT_ERR_HISTEDIT_SYNTAX
&&
9748 err
->code
!= GOT_ERR_HISTEDIT_CMD
)
9755 } else if (resp
== 'r') {
9756 histedit_free_list(histedit_cmds
);
9757 err
= histedit_edit_script(histedit_cmds
,
9758 commits
, branch_name
, 0, 0, repo
);
9760 if (err
->code
!= GOT_ERR_HISTEDIT_SYNTAX
&&
9761 err
->code
!= GOT_ERR_HISTEDIT_CMD
)
9768 } else if (resp
== 'a') {
9769 err
= got_error(GOT_ERR_HISTEDIT_CANCEL
);
9772 printf("invalid response '%c'\n", resp
);
9778 static const struct got_error
*
9779 histedit_complete(struct got_worktree
*worktree
,
9780 struct got_fileindex
*fileindex
, struct got_reference
*tmp_branch
,
9781 struct got_reference
*branch
, struct got_repository
*repo
)
9783 printf("Switching work tree to %s\n",
9784 got_ref_get_symref_target(branch
));
9785 return got_worktree_histedit_complete(worktree
, fileindex
, tmp_branch
,
9789 static const struct got_error
*
9790 show_histedit_progress(struct got_commit_object
*commit
,
9791 struct got_histedit_list_entry
*hle
, struct got_object_id
*new_id
)
9793 const struct got_error
*err
;
9794 char *old_id_str
= NULL
, *new_id_str
= NULL
, *logmsg
= NULL
;
9796 err
= got_object_id_str(&old_id_str
, hle
->commit_id
);
9801 err
= got_object_id_str(&new_id_str
, new_id
);
9806 old_id_str
[12] = '\0';
9808 new_id_str
[12] = '\0';
9811 logmsg
= strdup(hle
->logmsg
);
9812 if (logmsg
== NULL
) {
9813 err
= got_error_from_errno("strdup");
9816 trim_logmsg(logmsg
, 42);
9818 err
= get_short_logmsg(&logmsg
, 42, commit
);
9823 switch (hle
->cmd
->code
) {
9824 case GOT_HISTEDIT_PICK
:
9825 case GOT_HISTEDIT_EDIT
:
9826 printf("%s -> %s: %s\n", old_id_str
,
9827 new_id_str
? new_id_str
: "no-op change", logmsg
);
9829 case GOT_HISTEDIT_DROP
:
9830 case GOT_HISTEDIT_FOLD
:
9831 printf("%s -> %s commit: %s\n", old_id_str
, hle
->cmd
->name
,
9843 static const struct got_error
*
9844 histedit_commit(struct got_pathlist_head
*merged_paths
,
9845 struct got_worktree
*worktree
, struct got_fileindex
*fileindex
,
9846 struct got_reference
*tmp_branch
, struct got_histedit_list_entry
*hle
,
9847 struct got_repository
*repo
)
9849 const struct got_error
*err
;
9850 struct got_commit_object
*commit
;
9851 struct got_object_id
*new_commit_id
;
9853 if ((hle
->cmd
->code
== GOT_HISTEDIT_EDIT
|| get_folded_commits(hle
))
9854 && hle
->logmsg
== NULL
) {
9855 err
= histedit_edit_logmsg(hle
, repo
);
9860 err
= got_object_open_as_commit(&commit
, repo
, hle
->commit_id
);
9864 err
= got_worktree_histedit_commit(&new_commit_id
, merged_paths
,
9865 worktree
, fileindex
, tmp_branch
, commit
, hle
->commit_id
,
9868 if (err
->code
!= GOT_ERR_COMMIT_NO_CHANGES
)
9870 err
= show_histedit_progress(commit
, hle
, NULL
);
9872 err
= show_histedit_progress(commit
, hle
, new_commit_id
);
9873 free(new_commit_id
);
9876 got_object_commit_close(commit
);
9880 static const struct got_error
*
9881 histedit_skip_commit(struct got_histedit_list_entry
*hle
,
9882 struct got_worktree
*worktree
, struct got_repository
*repo
)
9884 const struct got_error
*error
;
9885 struct got_commit_object
*commit
;
9887 error
= got_worktree_histedit_skip_commit(worktree
, hle
->commit_id
,
9892 error
= got_object_open_as_commit(&commit
, repo
, hle
->commit_id
);
9896 error
= show_histedit_progress(commit
, hle
, NULL
);
9897 got_object_commit_close(commit
);
9901 static const struct got_error
*
9902 check_local_changes(void *arg
, unsigned char status
,
9903 unsigned char staged_status
, const char *path
,
9904 struct got_object_id
*blob_id
, struct got_object_id
*staged_blob_id
,
9905 struct got_object_id
*commit_id
, int dirfd
, const char *de_name
)
9907 int *have_local_changes
= arg
;
9910 case GOT_STATUS_ADD
:
9911 case GOT_STATUS_DELETE
:
9912 case GOT_STATUS_MODIFY
:
9913 case GOT_STATUS_CONFLICT
:
9914 *have_local_changes
= 1;
9915 return got_error(GOT_ERR_CANCELLED
);
9920 switch (staged_status
) {
9921 case GOT_STATUS_ADD
:
9922 case GOT_STATUS_DELETE
:
9923 case GOT_STATUS_MODIFY
:
9924 *have_local_changes
= 1;
9925 return got_error(GOT_ERR_CANCELLED
);
9933 static const struct got_error
*
9934 cmd_histedit(int argc
, char *argv
[])
9936 const struct got_error
*error
= NULL
;
9937 struct got_worktree
*worktree
= NULL
;
9938 struct got_fileindex
*fileindex
= NULL
;
9939 struct got_repository
*repo
= NULL
;
9941 struct got_reference
*branch
= NULL
;
9942 struct got_reference
*tmp_branch
= NULL
;
9943 struct got_object_id
*resume_commit_id
= NULL
;
9944 struct got_object_id
*base_commit_id
= NULL
;
9945 struct got_object_id
*head_commit_id
= NULL
;
9946 struct got_commit_object
*commit
= NULL
;
9947 int ch
, rebase_in_progress
= 0, merge_in_progress
= 0;
9948 struct got_update_progress_arg upa
;
9949 int edit_in_progress
= 0, abort_edit
= 0, continue_edit
= 0;
9950 int edit_logmsg_only
= 0, fold_only
= 0;
9951 int list_backups
= 0, delete_backups
= 0;
9952 const char *edit_script_path
= NULL
;
9953 unsigned char rebase_status
= GOT_STATUS_NO_CHANGE
;
9954 struct got_object_id_queue commits
;
9955 struct got_pathlist_head merged_paths
;
9956 const struct got_object_id_queue
*parent_ids
;
9957 struct got_object_qid
*pid
;
9958 struct got_histedit_list histedit_cmds
;
9959 struct got_histedit_list_entry
*hle
;
9961 STAILQ_INIT(&commits
);
9962 TAILQ_INIT(&histedit_cmds
);
9963 TAILQ_INIT(&merged_paths
);
9964 memset(&upa
, 0, sizeof(upa
));
9966 while ((ch
= getopt(argc
, argv
, "acfF:mlX")) != -1) {
9978 edit_script_path
= optarg
;
9981 edit_logmsg_only
= 1;
9999 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
10000 "unveil", NULL
) == -1)
10003 if (abort_edit
&& continue_edit
)
10004 option_conflict('a', 'c');
10005 if (edit_script_path
&& edit_logmsg_only
)
10006 option_conflict('F', 'm');
10007 if (abort_edit
&& edit_logmsg_only
)
10008 option_conflict('a', 'm');
10009 if (continue_edit
&& edit_logmsg_only
)
10010 option_conflict('c', 'm');
10011 if (abort_edit
&& fold_only
)
10012 option_conflict('a', 'f');
10013 if (continue_edit
&& fold_only
)
10014 option_conflict('c', 'f');
10015 if (fold_only
&& edit_logmsg_only
)
10016 option_conflict('f', 'm');
10017 if (edit_script_path
&& fold_only
)
10018 option_conflict('F', 'f');
10019 if (list_backups
) {
10021 option_conflict('l', 'a');
10023 option_conflict('l', 'c');
10024 if (edit_script_path
)
10025 option_conflict('l', 'F');
10026 if (edit_logmsg_only
)
10027 option_conflict('l', 'm');
10029 option_conflict('l', 'f');
10030 if (delete_backups
)
10031 option_conflict('l', 'X');
10032 if (argc
!= 0 && argc
!= 1)
10034 } else if (delete_backups
) {
10036 option_conflict('X', 'a');
10038 option_conflict('X', 'c');
10039 if (edit_script_path
)
10040 option_conflict('X', 'F');
10041 if (edit_logmsg_only
)
10042 option_conflict('X', 'm');
10044 option_conflict('X', 'f');
10046 option_conflict('X', 'l');
10047 if (argc
!= 0 && argc
!= 1)
10049 } else if (argc
!= 0)
10053 * This command cannot apply unveil(2) in all cases because the
10054 * user may choose to run an editor to edit the histedit script
10055 * and to edit individual commit log messages.
10056 * unveil(2) traverses exec(2); if an editor is used we have to
10057 * apply unveil after edit script and log messages have been written.
10058 * XXX TODO: Make use of unveil(2) where possible.
10061 cwd
= getcwd(NULL
, 0);
10063 error
= got_error_from_errno("getcwd");
10066 error
= got_worktree_open(&worktree
, cwd
);
10068 if (list_backups
|| delete_backups
) {
10069 if (error
->code
!= GOT_ERR_NOT_WORKTREE
)
10072 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
10073 error
= wrap_not_worktree_error(error
,
10079 if (list_backups
|| delete_backups
) {
10080 error
= got_repo_open(&repo
,
10081 worktree
? got_worktree_get_repo_path(worktree
) : cwd
,
10085 error
= apply_unveil(got_repo_get_path(repo
), 0,
10086 worktree
? got_worktree_get_root_path(worktree
) : NULL
);
10089 error
= process_backup_refs(
10090 GOT_WORKTREE_HISTEDIT_BACKUP_REF_PREFIX
,
10091 argc
== 1 ? argv
[0] : NULL
, delete_backups
, repo
);
10092 goto done
; /* nothing else to do */
10095 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
10100 error
= got_worktree_rebase_in_progress(&rebase_in_progress
, worktree
);
10103 if (rebase_in_progress
) {
10104 error
= got_error(GOT_ERR_REBASING
);
10108 error
= got_worktree_merge_in_progress(&merge_in_progress
, worktree
,
10112 if (merge_in_progress
) {
10113 error
= got_error(GOT_ERR_MERGE_BUSY
);
10117 error
= got_worktree_histedit_in_progress(&edit_in_progress
, worktree
);
10121 if (edit_in_progress
&& edit_logmsg_only
) {
10122 error
= got_error_msg(GOT_ERR_HISTEDIT_BUSY
,
10123 "histedit operation is in progress in this "
10124 "work tree and must be continued or aborted "
10125 "before the -m option can be used");
10128 if (edit_in_progress
&& fold_only
) {
10129 error
= got_error_msg(GOT_ERR_HISTEDIT_BUSY
,
10130 "histedit operation is in progress in this "
10131 "work tree and must be continued or aborted "
10132 "before the -f option can be used");
10136 if (edit_in_progress
&& abort_edit
) {
10137 error
= got_worktree_histedit_continue(&resume_commit_id
,
10138 &tmp_branch
, &branch
, &base_commit_id
, &fileindex
,
10142 printf("Switching work tree to %s\n",
10143 got_ref_get_symref_target(branch
));
10144 error
= got_worktree_histedit_abort(worktree
, fileindex
, repo
,
10145 branch
, base_commit_id
, update_progress
, &upa
);
10148 printf("Histedit of %s aborted\n",
10149 got_ref_get_symref_target(branch
));
10150 print_update_progress_stats(&upa
);
10151 goto done
; /* nothing else to do */
10152 } else if (abort_edit
) {
10153 error
= got_error(GOT_ERR_NOT_HISTEDIT
);
10157 if (continue_edit
) {
10160 if (!edit_in_progress
) {
10161 error
= got_error(GOT_ERR_NOT_HISTEDIT
);
10165 error
= got_worktree_get_histedit_script_path(&path
, worktree
);
10169 error
= histedit_load_list(&histedit_cmds
, path
, repo
);
10174 error
= got_worktree_histedit_continue(&resume_commit_id
,
10175 &tmp_branch
, &branch
, &base_commit_id
, &fileindex
,
10180 error
= got_ref_resolve(&head_commit_id
, repo
, branch
);
10184 error
= got_object_open_as_commit(&commit
, repo
,
10188 parent_ids
= got_object_commit_get_parent_ids(commit
);
10189 pid
= STAILQ_FIRST(parent_ids
);
10191 error
= got_error(GOT_ERR_EMPTY_HISTEDIT
);
10194 error
= collect_commits(&commits
, head_commit_id
, pid
->id
,
10195 base_commit_id
, got_worktree_get_path_prefix(worktree
),
10196 GOT_ERR_HISTEDIT_PATH
, repo
);
10197 got_object_commit_close(commit
);
10202 if (edit_in_progress
) {
10203 error
= got_error(GOT_ERR_HISTEDIT_BUSY
);
10207 error
= got_ref_open(&branch
, repo
,
10208 got_worktree_get_head_ref_name(worktree
), 0);
10212 if (strncmp(got_ref_get_name(branch
), "refs/heads/", 11) != 0) {
10213 error
= got_error_msg(GOT_ERR_COMMIT_BRANCH
,
10214 "will not edit commit history of a branch outside "
10215 "the \"refs/heads/\" reference namespace");
10219 error
= got_ref_resolve(&head_commit_id
, repo
, branch
);
10220 got_ref_close(branch
);
10225 error
= got_object_open_as_commit(&commit
, repo
,
10229 parent_ids
= got_object_commit_get_parent_ids(commit
);
10230 pid
= STAILQ_FIRST(parent_ids
);
10232 error
= got_error(GOT_ERR_EMPTY_HISTEDIT
);
10235 error
= collect_commits(&commits
, head_commit_id
, pid
->id
,
10236 got_worktree_get_base_commit_id(worktree
),
10237 got_worktree_get_path_prefix(worktree
),
10238 GOT_ERR_HISTEDIT_PATH
, repo
);
10239 got_object_commit_close(commit
);
10244 if (STAILQ_EMPTY(&commits
)) {
10245 error
= got_error(GOT_ERR_EMPTY_HISTEDIT
);
10249 error
= got_worktree_histedit_prepare(&tmp_branch
, &branch
,
10250 &base_commit_id
, &fileindex
, worktree
, repo
);
10254 if (edit_script_path
) {
10255 error
= histedit_load_list(&histedit_cmds
,
10256 edit_script_path
, repo
);
10258 got_worktree_histedit_abort(worktree
, fileindex
,
10259 repo
, branch
, base_commit_id
,
10260 update_progress
, &upa
);
10261 print_update_progress_stats(&upa
);
10265 const char *branch_name
;
10266 branch_name
= got_ref_get_symref_target(branch
);
10267 if (strncmp(branch_name
, "refs/heads/", 11) == 0)
10269 error
= histedit_edit_script(&histedit_cmds
, &commits
,
10270 branch_name
, edit_logmsg_only
, fold_only
, repo
);
10272 got_worktree_histedit_abort(worktree
, fileindex
,
10273 repo
, branch
, base_commit_id
,
10274 update_progress
, &upa
);
10275 print_update_progress_stats(&upa
);
10281 error
= histedit_save_list(&histedit_cmds
, worktree
,
10284 got_worktree_histedit_abort(worktree
, fileindex
,
10285 repo
, branch
, base_commit_id
,
10286 update_progress
, &upa
);
10287 print_update_progress_stats(&upa
);
10293 error
= histedit_check_script(&histedit_cmds
, &commits
, repo
);
10297 TAILQ_FOREACH(hle
, &histedit_cmds
, entry
) {
10298 if (resume_commit_id
) {
10299 if (got_object_id_cmp(hle
->commit_id
,
10300 resume_commit_id
) != 0)
10303 resume_commit_id
= NULL
;
10304 if (hle
->cmd
->code
== GOT_HISTEDIT_DROP
||
10305 hle
->cmd
->code
== GOT_HISTEDIT_FOLD
) {
10306 error
= histedit_skip_commit(hle
, worktree
,
10311 struct got_pathlist_head paths
;
10312 int have_changes
= 0;
10314 TAILQ_INIT(&paths
);
10315 error
= got_pathlist_append(&paths
, "", NULL
);
10318 error
= got_worktree_status(worktree
, &paths
,
10319 repo
, 0, check_local_changes
, &have_changes
,
10320 check_cancelled
, NULL
);
10321 got_pathlist_free(&paths
);
10323 if (error
->code
!= GOT_ERR_CANCELLED
)
10325 if (sigint_received
|| sigpipe_received
)
10328 if (have_changes
) {
10329 error
= histedit_commit(NULL
, worktree
,
10330 fileindex
, tmp_branch
, hle
, repo
);
10334 error
= got_object_open_as_commit(
10335 &commit
, repo
, hle
->commit_id
);
10338 error
= show_histedit_progress(commit
,
10340 got_object_commit_close(commit
);
10349 if (hle
->cmd
->code
== GOT_HISTEDIT_DROP
) {
10350 error
= histedit_skip_commit(hle
, worktree
, repo
);
10356 error
= got_object_open_as_commit(&commit
, repo
,
10360 parent_ids
= got_object_commit_get_parent_ids(commit
);
10361 pid
= STAILQ_FIRST(parent_ids
);
10363 error
= got_worktree_histedit_merge_files(&merged_paths
,
10364 worktree
, fileindex
, pid
->id
, hle
->commit_id
, repo
,
10365 update_progress
, &upa
, check_cancelled
, NULL
);
10368 got_object_commit_close(commit
);
10371 print_update_progress_stats(&upa
);
10372 if (upa
.conflicts
> 0)
10373 rebase_status
= GOT_STATUS_CONFLICT
;
10375 if (rebase_status
== GOT_STATUS_CONFLICT
) {
10376 error
= show_rebase_merge_conflict(hle
->commit_id
,
10380 got_worktree_rebase_pathlist_free(&merged_paths
);
10384 if (hle
->cmd
->code
== GOT_HISTEDIT_EDIT
) {
10386 error
= got_object_id_str(&id_str
, hle
->commit_id
);
10389 printf("Stopping histedit for amending commit %s\n",
10392 got_worktree_rebase_pathlist_free(&merged_paths
);
10393 error
= got_worktree_histedit_postpone(worktree
,
10398 if (hle
->cmd
->code
== GOT_HISTEDIT_FOLD
) {
10399 error
= histedit_skip_commit(hle
, worktree
, repo
);
10405 error
= histedit_commit(&merged_paths
, worktree
, fileindex
,
10406 tmp_branch
, hle
, repo
);
10407 got_worktree_rebase_pathlist_free(&merged_paths
);
10412 if (rebase_status
== GOT_STATUS_CONFLICT
) {
10413 error
= got_worktree_histedit_postpone(worktree
, fileindex
);
10416 error
= got_error_msg(GOT_ERR_CONFLICTS
,
10417 "conflicts must be resolved before histedit can continue");
10419 error
= histedit_complete(worktree
, fileindex
, tmp_branch
,
10422 got_object_id_queue_free(&commits
);
10423 histedit_free_list(&histedit_cmds
);
10424 free(head_commit_id
);
10425 free(base_commit_id
);
10426 free(resume_commit_id
);
10428 got_object_commit_close(commit
);
10430 got_ref_close(branch
);
10432 got_ref_close(tmp_branch
);
10434 got_worktree_close(worktree
);
10436 const struct got_error
*close_err
= got_repo_close(repo
);
10444 usage_integrate(void)
10446 fprintf(stderr
, "usage: %s integrate branch\n", getprogname());
10450 static const struct got_error
*
10451 cmd_integrate(int argc
, char *argv
[])
10453 const struct got_error
*error
= NULL
;
10454 struct got_repository
*repo
= NULL
;
10455 struct got_worktree
*worktree
= NULL
;
10456 char *cwd
= NULL
, *refname
= NULL
, *base_refname
= NULL
;
10457 const char *branch_arg
= NULL
;
10458 struct got_reference
*branch_ref
= NULL
, *base_branch_ref
= NULL
;
10459 struct got_fileindex
*fileindex
= NULL
;
10460 struct got_object_id
*commit_id
= NULL
, *base_commit_id
= NULL
;
10462 struct got_update_progress_arg upa
;
10464 while ((ch
= getopt(argc
, argv
, "")) != -1) {
10477 branch_arg
= argv
[0];
10479 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
10480 "unveil", NULL
) == -1)
10483 cwd
= getcwd(NULL
, 0);
10485 error
= got_error_from_errno("getcwd");
10489 error
= got_worktree_open(&worktree
, cwd
);
10491 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
10492 error
= wrap_not_worktree_error(error
, "integrate",
10497 error
= check_rebase_or_histedit_in_progress(worktree
);
10501 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
10506 error
= apply_unveil(got_repo_get_path(repo
), 0,
10507 got_worktree_get_root_path(worktree
));
10511 error
= check_merge_in_progress(worktree
, repo
);
10515 if (asprintf(&refname
, "refs/heads/%s", branch_arg
) == -1) {
10516 error
= got_error_from_errno("asprintf");
10520 error
= got_worktree_integrate_prepare(&fileindex
, &branch_ref
,
10521 &base_branch_ref
, worktree
, refname
, repo
);
10525 refname
= strdup(got_ref_get_name(branch_ref
));
10526 if (refname
== NULL
) {
10527 error
= got_error_from_errno("strdup");
10528 got_worktree_integrate_abort(worktree
, fileindex
, repo
,
10529 branch_ref
, base_branch_ref
);
10532 base_refname
= strdup(got_ref_get_name(base_branch_ref
));
10533 if (base_refname
== NULL
) {
10534 error
= got_error_from_errno("strdup");
10535 got_worktree_integrate_abort(worktree
, fileindex
, repo
,
10536 branch_ref
, base_branch_ref
);
10540 error
= got_ref_resolve(&commit_id
, repo
, branch_ref
);
10544 error
= got_ref_resolve(&base_commit_id
, repo
, base_branch_ref
);
10548 if (got_object_id_cmp(commit_id
, base_commit_id
) == 0) {
10549 error
= got_error_msg(GOT_ERR_SAME_BRANCH
,
10550 "specified branch has already been integrated");
10551 got_worktree_integrate_abort(worktree
, fileindex
, repo
,
10552 branch_ref
, base_branch_ref
);
10556 error
= check_linear_ancestry(commit_id
, base_commit_id
, 1, repo
);
10558 if (error
->code
== GOT_ERR_ANCESTRY
)
10559 error
= got_error(GOT_ERR_REBASE_REQUIRED
);
10560 got_worktree_integrate_abort(worktree
, fileindex
, repo
,
10561 branch_ref
, base_branch_ref
);
10565 memset(&upa
, 0, sizeof(upa
));
10566 error
= got_worktree_integrate_continue(worktree
, fileindex
, repo
,
10567 branch_ref
, base_branch_ref
, update_progress
, &upa
,
10568 check_cancelled
, NULL
);
10572 printf("Integrated %s into %s\n", refname
, base_refname
);
10573 print_update_progress_stats(&upa
);
10576 const struct got_error
*close_err
= got_repo_close(repo
);
10581 got_worktree_close(worktree
);
10583 free(base_commit_id
);
10586 free(base_refname
);
10593 fprintf(stderr
, "usage: %s merge [-a] [-c] [branch]\n",
10598 static const struct got_error
*
10599 cmd_merge(int argc
, char *argv
[])
10601 const struct got_error
*error
= NULL
;
10602 struct got_worktree
*worktree
= NULL
;
10603 struct got_repository
*repo
= NULL
;
10604 struct got_fileindex
*fileindex
= NULL
;
10605 char *cwd
= NULL
, *id_str
= NULL
, *author
= NULL
;
10606 struct got_reference
*branch
= NULL
, *wt_branch
= NULL
;
10607 struct got_object_id
*branch_tip
= NULL
, *yca_id
= NULL
;
10608 struct got_object_id
*wt_branch_tip
= NULL
;
10609 int ch
, merge_in_progress
= 0, abort_merge
= 0, continue_merge
= 0;
10610 struct got_update_progress_arg upa
;
10611 struct got_object_id
*merge_commit_id
= NULL
;
10612 char *branch_name
= NULL
;
10614 memset(&upa
, 0, sizeof(upa
));
10616 while ((ch
= getopt(argc
, argv
, "ac")) != -1) {
10622 continue_merge
= 1;
10634 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
10635 "unveil", NULL
) == -1)
10639 if (abort_merge
&& continue_merge
)
10640 option_conflict('a', 'c');
10641 if (abort_merge
|| continue_merge
) {
10644 } else if (argc
!= 1)
10647 cwd
= getcwd(NULL
, 0);
10649 error
= got_error_from_errno("getcwd");
10653 error
= got_worktree_open(&worktree
, cwd
);
10655 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
10656 error
= wrap_not_worktree_error(error
,
10661 error
= got_repo_open(&repo
,
10662 worktree
? got_worktree_get_repo_path(worktree
) : cwd
, NULL
);
10666 error
= apply_unveil(got_repo_get_path(repo
), 0,
10667 worktree
? got_worktree_get_root_path(worktree
) : NULL
);
10671 error
= check_rebase_or_histedit_in_progress(worktree
);
10675 error
= got_worktree_merge_in_progress(&merge_in_progress
, worktree
,
10681 if (!merge_in_progress
) {
10682 error
= got_error(GOT_ERR_NOT_MERGING
);
10685 error
= got_worktree_merge_continue(&branch_name
,
10686 &branch_tip
, &fileindex
, worktree
, repo
);
10689 error
= got_worktree_merge_abort(worktree
, fileindex
, repo
,
10690 update_progress
, &upa
);
10693 printf("Merge of %s aborted\n", branch_name
);
10694 goto done
; /* nothing else to do */
10697 error
= get_author(&author
, repo
, worktree
);
10701 if (continue_merge
) {
10702 if (!merge_in_progress
) {
10703 error
= got_error(GOT_ERR_NOT_MERGING
);
10706 error
= got_worktree_merge_continue(&branch_name
,
10707 &branch_tip
, &fileindex
, worktree
, repo
);
10711 error
= got_ref_open(&branch
, repo
, argv
[0], 0);
10714 branch_name
= strdup(got_ref_get_name(branch
));
10715 if (branch_name
== NULL
) {
10716 error
= got_error_from_errno("strdup");
10719 error
= got_ref_resolve(&branch_tip
, repo
, branch
);
10724 error
= got_ref_open(&wt_branch
, repo
,
10725 got_worktree_get_head_ref_name(worktree
), 0);
10728 error
= got_ref_resolve(&wt_branch_tip
, repo
, wt_branch
);
10731 error
= got_commit_graph_find_youngest_common_ancestor(&yca_id
,
10732 wt_branch_tip
, branch_tip
, repo
,
10733 check_cancelled
, NULL
);
10736 if (yca_id
== NULL
) {
10737 error
= got_error_msg(GOT_ERR_ANCESTRY
,
10738 "specified branch shares no common ancestry "
10739 "with work tree's branch");
10743 if (!continue_merge
) {
10744 error
= check_path_prefix(wt_branch_tip
, branch_tip
,
10745 got_worktree_get_path_prefix(worktree
),
10746 GOT_ERR_MERGE_PATH
, repo
);
10749 error
= check_same_branch(wt_branch_tip
, branch
,
10752 if (error
->code
!= GOT_ERR_ANCESTRY
)
10756 static char msg
[512];
10757 snprintf(msg
, sizeof(msg
),
10758 "cannot create a merge commit because "
10759 "%s is based on %s; %s can be integrated "
10760 "with 'got integrate' instead", branch_name
,
10761 got_worktree_get_head_ref_name(worktree
),
10763 error
= got_error_msg(GOT_ERR_SAME_BRANCH
, msg
);
10766 error
= got_worktree_merge_prepare(&fileindex
, worktree
,
10771 error
= got_worktree_merge_branch(worktree
, fileindex
,
10772 yca_id
, branch_tip
, repo
, update_progress
, &upa
,
10773 check_cancelled
, NULL
);
10776 print_update_progress_stats(&upa
);
10779 if (upa
.conflicts
> 0 || upa
.missing
> 0) {
10780 error
= got_worktree_merge_postpone(worktree
, fileindex
);
10783 if (upa
.conflicts
> 0 && upa
.missing
== 0) {
10784 error
= got_error_msg(GOT_ERR_CONFLICTS
,
10785 "conflicts must be resolved before merging "
10787 } else if (upa
.conflicts
> 0) {
10788 error
= got_error_msg(GOT_ERR_CONFLICTS
,
10789 "conflicts must be resolved before merging "
10790 "can continue; changes destined for missing "
10791 "files were not yet merged and "
10792 "should be merged manually if required before the "
10793 "merge operation is continued");
10795 error
= got_error_msg(GOT_ERR_CONFLICTS
,
10796 "changes destined for missing "
10797 "files were not yet merged and should be "
10798 "merged manually if required before the "
10799 "merge operation is continued");
10803 error
= got_worktree_merge_commit(&merge_commit_id
, worktree
,
10804 fileindex
, author
, NULL
, 1, branch_tip
, branch_name
, repo
);
10807 error
= got_worktree_merge_complete(worktree
, fileindex
, repo
);
10810 error
= got_object_id_str(&id_str
, merge_commit_id
);
10813 printf("Merged %s into %s: %s\n", branch_name
,
10814 got_worktree_get_head_ref_name(worktree
),
10820 free(merge_commit_id
);
10826 got_ref_close(branch
);
10828 got_ref_close(wt_branch
);
10830 got_worktree_close(worktree
);
10832 const struct got_error
*close_err
= got_repo_close(repo
);
10842 fprintf(stderr
, "usage: %s stage [-l] | [-p] [-F response-script] "
10843 "[-S] [file-path ...]\n",
10848 static const struct got_error
*
10849 print_stage(void *arg
, unsigned char status
, unsigned char staged_status
,
10850 const char *path
, struct got_object_id
*blob_id
,
10851 struct got_object_id
*staged_blob_id
, struct got_object_id
*commit_id
,
10852 int dirfd
, const char *de_name
)
10854 const struct got_error
*err
= NULL
;
10855 char *id_str
= NULL
;
10857 if (staged_status
!= GOT_STATUS_ADD
&&
10858 staged_status
!= GOT_STATUS_MODIFY
&&
10859 staged_status
!= GOT_STATUS_DELETE
)
10862 if (staged_status
== GOT_STATUS_ADD
||
10863 staged_status
== GOT_STATUS_MODIFY
)
10864 err
= got_object_id_str(&id_str
, staged_blob_id
);
10866 err
= got_object_id_str(&id_str
, blob_id
);
10870 printf("%s %c %s\n", id_str
, staged_status
, path
);
10875 static const struct got_error
*
10876 cmd_stage(int argc
, char *argv
[])
10878 const struct got_error
*error
= NULL
;
10879 struct got_repository
*repo
= NULL
;
10880 struct got_worktree
*worktree
= NULL
;
10882 struct got_pathlist_head paths
;
10883 struct got_pathlist_entry
*pe
;
10884 int ch
, list_stage
= 0, pflag
= 0, allow_bad_symlinks
= 0;
10885 FILE *patch_script_file
= NULL
;
10886 const char *patch_script_path
= NULL
;
10887 struct choose_patch_arg cpa
;
10889 TAILQ_INIT(&paths
);
10891 while ((ch
= getopt(argc
, argv
, "lpF:S")) != -1) {
10900 patch_script_path
= optarg
;
10903 allow_bad_symlinks
= 1;
10915 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
10916 "unveil", NULL
) == -1)
10919 if (list_stage
&& (pflag
|| patch_script_path
))
10920 errx(1, "-l option cannot be used with other options");
10921 if (patch_script_path
&& !pflag
)
10922 errx(1, "-F option can only be used together with -p option");
10924 cwd
= getcwd(NULL
, 0);
10926 error
= got_error_from_errno("getcwd");
10930 error
= got_worktree_open(&worktree
, cwd
);
10932 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
10933 error
= wrap_not_worktree_error(error
, "stage", cwd
);
10937 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
10942 if (patch_script_path
) {
10943 patch_script_file
= fopen(patch_script_path
, "r");
10944 if (patch_script_file
== NULL
) {
10945 error
= got_error_from_errno2("fopen",
10946 patch_script_path
);
10950 error
= apply_unveil(got_repo_get_path(repo
), 0,
10951 got_worktree_get_root_path(worktree
));
10955 error
= check_merge_in_progress(worktree
, repo
);
10959 error
= get_worktree_paths_from_argv(&paths
, argc
, argv
, worktree
);
10964 error
= got_worktree_status(worktree
, &paths
, repo
, 0,
10965 print_stage
, NULL
, check_cancelled
, NULL
);
10967 cpa
.patch_script_file
= patch_script_file
;
10968 cpa
.action
= "stage";
10969 error
= got_worktree_stage(worktree
, &paths
,
10970 pflag
? NULL
: print_status
, NULL
,
10971 pflag
? choose_patch
: NULL
, &cpa
,
10972 allow_bad_symlinks
, repo
);
10975 if (patch_script_file
&& fclose(patch_script_file
) == EOF
&&
10977 error
= got_error_from_errno2("fclose", patch_script_path
);
10979 const struct got_error
*close_err
= got_repo_close(repo
);
10984 got_worktree_close(worktree
);
10985 TAILQ_FOREACH(pe
, &paths
, entry
)
10986 free((char *)pe
->path
);
10987 got_pathlist_free(&paths
);
10993 usage_unstage(void)
10995 fprintf(stderr
, "usage: %s unstage [-p] [-F response-script] "
10996 "[file-path ...]\n",
11002 static const struct got_error
*
11003 cmd_unstage(int argc
, char *argv
[])
11005 const struct got_error
*error
= NULL
;
11006 struct got_repository
*repo
= NULL
;
11007 struct got_worktree
*worktree
= NULL
;
11009 struct got_pathlist_head paths
;
11010 struct got_pathlist_entry
*pe
;
11012 struct got_update_progress_arg upa
;
11013 FILE *patch_script_file
= NULL
;
11014 const char *patch_script_path
= NULL
;
11015 struct choose_patch_arg cpa
;
11017 TAILQ_INIT(&paths
);
11019 while ((ch
= getopt(argc
, argv
, "pF:")) != -1) {
11025 patch_script_path
= optarg
;
11037 if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
11038 "unveil", NULL
) == -1)
11041 if (patch_script_path
&& !pflag
)
11042 errx(1, "-F option can only be used together with -p option");
11044 cwd
= getcwd(NULL
, 0);
11046 error
= got_error_from_errno("getcwd");
11050 error
= got_worktree_open(&worktree
, cwd
);
11052 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
11053 error
= wrap_not_worktree_error(error
, "unstage", cwd
);
11057 error
= got_repo_open(&repo
, got_worktree_get_repo_path(worktree
),
11062 if (patch_script_path
) {
11063 patch_script_file
= fopen(patch_script_path
, "r");
11064 if (patch_script_file
== NULL
) {
11065 error
= got_error_from_errno2("fopen",
11066 patch_script_path
);
11071 error
= apply_unveil(got_repo_get_path(repo
), 0,
11072 got_worktree_get_root_path(worktree
));
11076 error
= get_worktree_paths_from_argv(&paths
, argc
, argv
, worktree
);
11080 cpa
.patch_script_file
= patch_script_file
;
11081 cpa
.action
= "unstage";
11082 memset(&upa
, 0, sizeof(upa
));
11083 error
= got_worktree_unstage(worktree
, &paths
, update_progress
,
11084 &upa
, pflag
? choose_patch
: NULL
, &cpa
, repo
);
11086 print_update_progress_stats(&upa
);
11088 if (patch_script_file
&& fclose(patch_script_file
) == EOF
&&
11090 error
= got_error_from_errno2("fclose", patch_script_path
);
11092 const struct got_error
*close_err
= got_repo_close(repo
);
11097 got_worktree_close(worktree
);
11098 TAILQ_FOREACH(pe
, &paths
, entry
)
11099 free((char *)pe
->path
);
11100 got_pathlist_free(&paths
);
11108 fprintf(stderr
, "usage: %s cat [-r repository ] [ -c commit ] [ -P ] "
11109 "arg1 [arg2 ...]\n", getprogname());
11113 static const struct got_error
*
11114 cat_blob(struct got_object_id
*id
, struct got_repository
*repo
, FILE *outfile
)
11116 const struct got_error
*err
;
11117 struct got_blob_object
*blob
;
11119 err
= got_object_open_as_blob(&blob
, repo
, id
, 8192);
11123 err
= got_object_blob_dump_to_file(NULL
, NULL
, NULL
, outfile
, blob
);
11124 got_object_blob_close(blob
);
11128 static const struct got_error
*
11129 cat_tree(struct got_object_id
*id
, struct got_repository
*repo
, FILE *outfile
)
11131 const struct got_error
*err
;
11132 struct got_tree_object
*tree
;
11135 err
= got_object_open_as_tree(&tree
, repo
, id
);
11139 nentries
= got_object_tree_get_nentries(tree
);
11140 for (i
= 0; i
< nentries
; i
++) {
11141 struct got_tree_entry
*te
;
11143 if (sigint_received
|| sigpipe_received
)
11145 te
= got_object_tree_get_entry(tree
, i
);
11146 err
= got_object_id_str(&id_str
, got_tree_entry_get_id(te
));
11149 fprintf(outfile
, "%s %.7o %s\n", id_str
,
11150 got_tree_entry_get_mode(te
),
11151 got_tree_entry_get_name(te
));
11155 got_object_tree_close(tree
);
11159 static const struct got_error
*
11160 cat_commit(struct got_object_id
*id
, struct got_repository
*repo
, FILE *outfile
)
11162 const struct got_error
*err
;
11163 struct got_commit_object
*commit
;
11164 const struct got_object_id_queue
*parent_ids
;
11165 struct got_object_qid
*pid
;
11166 char *id_str
= NULL
;
11167 const char *logmsg
= NULL
;
11169 err
= got_object_open_as_commit(&commit
, repo
, id
);
11173 err
= got_object_id_str(&id_str
, got_object_commit_get_tree_id(commit
));
11177 fprintf(outfile
, "%s%s\n", GOT_COMMIT_LABEL_TREE
, id_str
);
11178 parent_ids
= got_object_commit_get_parent_ids(commit
);
11179 fprintf(outfile
, "numparents %d\n",
11180 got_object_commit_get_nparents(commit
));
11181 STAILQ_FOREACH(pid
, parent_ids
, entry
) {
11183 err
= got_object_id_str(&pid_str
, pid
->id
);
11186 fprintf(outfile
, "%s%s\n", GOT_COMMIT_LABEL_PARENT
, pid_str
);
11189 fprintf(outfile
, "%s%s %lld +0000\n", GOT_COMMIT_LABEL_AUTHOR
,
11190 got_object_commit_get_author(commit
),
11191 (long long)got_object_commit_get_author_time(commit
));
11193 fprintf(outfile
, "%s%s %lld +0000\n", GOT_COMMIT_LABEL_COMMITTER
,
11194 got_object_commit_get_author(commit
),
11195 (long long)got_object_commit_get_committer_time(commit
));
11197 logmsg
= got_object_commit_get_logmsg_raw(commit
);
11198 fprintf(outfile
, "messagelen %zd\n", strlen(logmsg
));
11199 fprintf(outfile
, "%s", logmsg
);
11202 got_object_commit_close(commit
);
11206 static const struct got_error
*
11207 cat_tag(struct got_object_id
*id
, struct got_repository
*repo
, FILE *outfile
)
11209 const struct got_error
*err
;
11210 struct got_tag_object
*tag
;
11211 char *id_str
= NULL
;
11212 const char *tagmsg
= NULL
;
11214 err
= got_object_open_as_tag(&tag
, repo
, id
);
11218 err
= got_object_id_str(&id_str
, got_object_tag_get_object_id(tag
));
11222 fprintf(outfile
, "%s%s\n", GOT_TAG_LABEL_OBJECT
, id_str
);
11224 switch (got_object_tag_get_object_type(tag
)) {
11225 case GOT_OBJ_TYPE_BLOB
:
11226 fprintf(outfile
, "%s%s\n", GOT_TAG_LABEL_TYPE
,
11227 GOT_OBJ_LABEL_BLOB
);
11229 case GOT_OBJ_TYPE_TREE
:
11230 fprintf(outfile
, "%s%s\n", GOT_TAG_LABEL_TYPE
,
11231 GOT_OBJ_LABEL_TREE
);
11233 case GOT_OBJ_TYPE_COMMIT
:
11234 fprintf(outfile
, "%s%s\n", GOT_TAG_LABEL_TYPE
,
11235 GOT_OBJ_LABEL_COMMIT
);
11237 case GOT_OBJ_TYPE_TAG
:
11238 fprintf(outfile
, "%s%s\n", GOT_TAG_LABEL_TYPE
,
11239 GOT_OBJ_LABEL_TAG
);
11245 fprintf(outfile
, "%s%s\n", GOT_TAG_LABEL_TAG
,
11246 got_object_tag_get_name(tag
));
11248 fprintf(outfile
, "%s%s %lld +0000\n", GOT_TAG_LABEL_TAGGER
,
11249 got_object_tag_get_tagger(tag
),
11250 (long long)got_object_tag_get_tagger_time(tag
));
11252 tagmsg
= got_object_tag_get_message(tag
);
11253 fprintf(outfile
, "messagelen %zd\n", strlen(tagmsg
));
11254 fprintf(outfile
, "%s", tagmsg
);
11257 got_object_tag_close(tag
);
11261 static const struct got_error
*
11262 cmd_cat(int argc
, char *argv
[])
11264 const struct got_error
*error
;
11265 struct got_repository
*repo
= NULL
;
11266 struct got_worktree
*worktree
= NULL
;
11267 char *cwd
= NULL
, *repo_path
= NULL
, *label
= NULL
;
11268 const char *commit_id_str
= NULL
;
11269 struct got_object_id
*id
= NULL
, *commit_id
= NULL
;
11270 int ch
, obj_type
, i
, force_path
= 0;
11271 struct got_reflist_head refs
;
11276 if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
11281 while ((ch
= getopt(argc
, argv
, "c:r:P")) != -1) {
11284 commit_id_str
= optarg
;
11287 repo_path
= realpath(optarg
, NULL
);
11288 if (repo_path
== NULL
)
11289 return got_error_from_errno2("realpath",
11291 got_path_strip_trailing_slashes(repo_path
);
11305 cwd
= getcwd(NULL
, 0);
11307 error
= got_error_from_errno("getcwd");
11310 error
= got_worktree_open(&worktree
, cwd
);
11311 if (error
&& error
->code
!= GOT_ERR_NOT_WORKTREE
)
11314 if (repo_path
== NULL
) {
11315 repo_path
= strdup(
11316 got_worktree_get_repo_path(worktree
));
11317 if (repo_path
== NULL
) {
11318 error
= got_error_from_errno("strdup");
11324 if (repo_path
== NULL
) {
11325 repo_path
= getcwd(NULL
, 0);
11326 if (repo_path
== NULL
)
11327 return got_error_from_errno("getcwd");
11330 error
= got_repo_open(&repo
, repo_path
, NULL
);
11335 error
= apply_unveil(got_repo_get_path(repo
), 1, NULL
);
11339 error
= got_ref_list(&refs
, repo
, NULL
, got_ref_cmp_by_name
, NULL
);
11343 if (commit_id_str
== NULL
)
11344 commit_id_str
= GOT_REF_HEAD
;
11345 error
= got_repo_match_object_id(&commit_id
, NULL
,
11346 commit_id_str
, GOT_OBJ_TYPE_COMMIT
, &refs
, repo
);
11350 for (i
= 0; i
< argc
; i
++) {
11352 error
= got_object_id_by_path(&id
, repo
, commit_id
,
11357 error
= got_repo_match_object_id(&id
, &label
, argv
[i
],
11358 GOT_OBJ_TYPE_ANY
, NULL
/* do not resolve tags */,
11361 if (error
->code
!= GOT_ERR_BAD_OBJ_ID_STR
&&
11362 error
->code
!= GOT_ERR_NOT_REF
)
11364 error
= got_object_id_by_path(&id
, repo
,
11365 commit_id
, argv
[i
]);
11371 error
= got_object_get_type(&obj_type
, repo
, id
);
11375 switch (obj_type
) {
11376 case GOT_OBJ_TYPE_BLOB
:
11377 error
= cat_blob(id
, repo
, stdout
);
11379 case GOT_OBJ_TYPE_TREE
:
11380 error
= cat_tree(id
, repo
, stdout
);
11382 case GOT_OBJ_TYPE_COMMIT
:
11383 error
= cat_commit(id
, repo
, stdout
);
11385 case GOT_OBJ_TYPE_TAG
:
11386 error
= cat_tag(id
, repo
, stdout
);
11389 error
= got_error(GOT_ERR_OBJ_TYPE
);
11404 got_worktree_close(worktree
);
11406 const struct got_error
*close_err
= got_repo_close(repo
);
11410 got_ref_list_free(&refs
);
11417 fprintf(stderr
, "usage: %s info [path ...]\n",
11422 static const struct got_error
*
11423 print_path_info(void *arg
, const char *path
, mode_t mode
, time_t mtime
,
11424 struct got_object_id
*blob_id
, struct got_object_id
*staged_blob_id
,
11425 struct got_object_id
*commit_id
)
11427 const struct got_error
*err
= NULL
;
11428 char *id_str
= NULL
;
11430 struct tm mytm
, *tm
;
11431 struct got_pathlist_head
*paths
= arg
;
11432 struct got_pathlist_entry
*pe
;
11435 * Clear error indication from any of the path arguments which
11436 * would cause this file index entry to be displayed.
11438 TAILQ_FOREACH(pe
, paths
, entry
) {
11439 if (got_path_cmp(path
, pe
->path
, strlen(path
),
11440 pe
->path_len
) == 0 ||
11441 got_path_is_child(path
, pe
->path
, pe
->path_len
))
11442 pe
->data
= NULL
; /* no error */
11445 printf(GOT_COMMIT_SEP_STR
);
11447 printf("symlink: %s\n", path
);
11448 else if (S_ISREG(mode
)) {
11449 printf("file: %s\n", path
);
11450 printf("mode: %o\n", mode
& (S_IRWXU
| S_IRWXG
| S_IRWXO
));
11451 } else if (S_ISDIR(mode
))
11452 printf("directory: %s\n", path
);
11454 printf("something: %s\n", path
);
11456 tm
= localtime_r(&mtime
, &mytm
);
11459 if (strftime(datebuf
, sizeof(datebuf
), "%c %Z", tm
) == 0)
11460 return got_error(GOT_ERR_NO_SPACE
);
11461 printf("timestamp: %s\n", datebuf
);
11464 err
= got_object_id_str(&id_str
, blob_id
);
11467 printf("based on blob: %s\n", id_str
);
11471 if (staged_blob_id
) {
11472 err
= got_object_id_str(&id_str
, staged_blob_id
);
11475 printf("based on staged blob: %s\n", id_str
);
11480 err
= got_object_id_str(&id_str
, commit_id
);
11483 printf("based on commit: %s\n", id_str
);
11490 static const struct got_error
*
11491 cmd_info(int argc
, char *argv
[])
11493 const struct got_error
*error
= NULL
;
11494 struct got_worktree
*worktree
= NULL
;
11495 char *cwd
= NULL
, *id_str
= NULL
;
11496 struct got_pathlist_head paths
;
11497 struct got_pathlist_entry
*pe
;
11498 char *uuidstr
= NULL
;
11499 int ch
, show_files
= 0;
11501 TAILQ_INIT(&paths
);
11503 while ((ch
= getopt(argc
, argv
, "")) != -1) {
11515 if (pledge("stdio rpath wpath flock proc exec sendfd unveil",
11519 cwd
= getcwd(NULL
, 0);
11521 error
= got_error_from_errno("getcwd");
11525 error
= got_worktree_open(&worktree
, cwd
);
11527 if (error
->code
== GOT_ERR_NOT_WORKTREE
)
11528 error
= wrap_not_worktree_error(error
, "info", cwd
);
11532 error
= apply_unveil(NULL
, 0, got_worktree_get_root_path(worktree
));
11537 error
= get_worktree_paths_from_argv(&paths
, argc
, argv
,
11544 error
= got_object_id_str(&id_str
,
11545 got_worktree_get_base_commit_id(worktree
));
11549 error
= got_worktree_get_uuid(&uuidstr
, worktree
);
11553 printf("work tree: %s\n", got_worktree_get_root_path(worktree
));
11554 printf("work tree base commit: %s\n", id_str
);
11555 printf("work tree path prefix: %s\n",
11556 got_worktree_get_path_prefix(worktree
));
11557 printf("work tree branch reference: %s\n",
11558 got_worktree_get_head_ref_name(worktree
));
11559 printf("work tree UUID: %s\n", uuidstr
);
11560 printf("repository: %s\n", got_worktree_get_repo_path(worktree
));
11563 struct got_pathlist_entry
*pe
;
11564 TAILQ_FOREACH(pe
, &paths
, entry
) {
11565 if (pe
->path_len
== 0)
11568 * Assume this path will fail. This will be corrected
11569 * in print_path_info() in case the path does suceeed.
11571 pe
->data
= (void *)got_error_path(pe
->path
,
11574 error
= got_worktree_path_info(worktree
, &paths
,
11575 print_path_info
, &paths
, check_cancelled
, NULL
);
11578 TAILQ_FOREACH(pe
, &paths
, entry
) {
11579 if (pe
->data
!= NULL
) {
11580 error
= pe
->data
; /* bad path */
11586 TAILQ_FOREACH(pe
, &paths
, entry
)
11587 free((char *)pe
->path
);
11588 got_pathlist_free(&paths
);