2 f42b1b34 2018-03-12 stsp * Copyright (c) 2017 Martin Pieuchot <mpi@openbsd.org>
3 5aa81393 2020-01-06 stsp * Copyright (c) 2018, 2019, 2020 Stefan Sperling <stsp@openbsd.org>
4 93658fb9 2020-03-18 stsp * Copyright (c) 2020 Ori Bernstein <ori@openbsd.org>
6 5c860e29 2018-03-12 stsp * Permission to use, copy, modify, and distribute this software for any
7 5c860e29 2018-03-12 stsp * purpose with or without fee is hereby granted, provided that the above
8 5c860e29 2018-03-12 stsp * copyright notice and this permission notice appear in all copies.
10 5c860e29 2018-03-12 stsp * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 5c860e29 2018-03-12 stsp * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 5c860e29 2018-03-12 stsp * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 5c860e29 2018-03-12 stsp * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 5c860e29 2018-03-12 stsp * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 5c860e29 2018-03-12 stsp * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 5c860e29 2018-03-12 stsp * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 f42b1b34 2018-03-12 stsp #include <sys/queue.h>
20 c0768b0f 2018-06-10 stsp #include <sys/types.h>
21 5de5890b 2018-10-18 stsp #include <sys/stat.h>
22 33ad4cbe 2019-05-12 jcs #include <sys/wait.h>
24 5c860e29 2018-03-12 stsp #include <err.h>
25 5c860e29 2018-03-12 stsp #include <errno.h>
26 12463d8b 2019-12-13 stsp #include <fcntl.h>
27 12ce7a6c 2019-08-12 stsp #include <limits.h>
28 5c860e29 2018-03-12 stsp #include <locale.h>
29 818c7501 2019-07-11 stsp #include <ctype.h>
30 99437157 2018-11-11 stsp #include <signal.h>
31 5c860e29 2018-03-12 stsp #include <stdio.h>
32 5c860e29 2018-03-12 stsp #include <stdlib.h>
33 5c860e29 2018-03-12 stsp #include <string.h>
34 5c860e29 2018-03-12 stsp #include <unistd.h>
35 c09a553d 2018-03-12 stsp #include <libgen.h>
36 c0768b0f 2018-06-10 stsp #include <time.h>
37 33ad4cbe 2019-05-12 jcs #include <paths.h>
38 6841bf13 2019-11-29 kn #include <regex.h>
39 83cd27f8 2020-01-13 stsp #include <getopt.h>
40 d2cdc636 2020-03-18 stsp #include <util.h>
42 53ccebc2 2019-07-30 stsp #include "got_version.h"
43 f42b1b34 2018-03-12 stsp #include "got_error.h"
44 f42b1b34 2018-03-12 stsp #include "got_object.h"
45 5261c201 2018-04-01 stsp #include "got_reference.h"
46 f42b1b34 2018-03-12 stsp #include "got_repository.h"
47 1dd54920 2019-05-11 stsp #include "got_path.h"
48 e6209546 2019-08-22 stsp #include "got_cancel.h"
49 c09a553d 2018-03-12 stsp #include "got_worktree.h"
50 79109fed 2018-03-27 stsp #include "got_diff.h"
51 372ccdbb 2018-06-10 stsp #include "got_commit_graph.h"
52 6f23baec 2020-03-18 stsp #include "got_fetch.h"
53 f8a36e22 2021-08-26 stsp #include "got_send.h"
54 404c43c4 2018-06-21 stsp #include "got_blame.h"
55 63219cd2 2019-01-04 stsp #include "got_privsep.h"
56 793c30b5 2019-05-13 stsp #include "got_opentemp.h"
57 50b0790e 2020-09-11 stsp #include "got_gotconfig.h"
58 d65a88a2 2021-09-05 stsp #include "got_dial.h"
60 5c860e29 2018-03-12 stsp #ifndef nitems
61 5c860e29 2018-03-12 stsp #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
64 99437157 2018-11-11 stsp static volatile sig_atomic_t sigint_received;
65 99437157 2018-11-11 stsp static volatile sig_atomic_t sigpipe_received;
68 99437157 2018-11-11 stsp catch_sigint(int signo)
70 99437157 2018-11-11 stsp sigint_received = 1;
74 99437157 2018-11-11 stsp catch_sigpipe(int signo)
76 99437157 2018-11-11 stsp sigpipe_received = 1;
80 8cfb4057 2019-07-09 stsp struct got_cmd {
81 820059fa 2020-09-25 stsp const char *cmd_name;
82 d7d4f210 2018-03-12 stsp const struct got_error *(*cmd_main)(int, char *[]);
83 1b6b95a8 2018-03-12 stsp void (*cmd_usage)(void);
84 97b3a7be 2019-07-09 stsp const char *cmd_alias;
87 6879ba42 2020-10-01 naddy __dead static void usage(int, int);
88 2c7829a4 2019-06-17 stsp __dead static void usage_init(void);
89 3ce1b845 2019-07-15 stsp __dead static void usage_import(void);
90 93658fb9 2020-03-18 stsp __dead static void usage_clone(void);
91 7848a0e1 2020-03-19 stsp __dead static void usage_fetch(void);
92 2ab43947 2020-03-18 stsp __dead static void usage_checkout(void);
93 507dc3bb 2018-12-29 stsp __dead static void usage_update(void);
94 4ed7e80c 2018-05-20 stsp __dead static void usage_log(void);
95 4ed7e80c 2018-05-20 stsp __dead static void usage_diff(void);
96 404c43c4 2018-06-21 stsp __dead static void usage_blame(void);
97 5de5890b 2018-10-18 stsp __dead static void usage_tree(void);
98 6bad629b 2019-02-04 stsp __dead static void usage_status(void);
99 d0eebce4 2019-03-11 stsp __dead static void usage_ref(void);
100 4e759de4 2019-06-26 stsp __dead static void usage_branch(void);
101 8e7bd50a 2019-08-22 stsp __dead static void usage_tag(void);
102 d00136be 2019-03-26 stsp __dead static void usage_add(void);
103 648e4ef7 2019-07-09 stsp __dead static void usage_remove(void);
104 a129376b 2019-03-28 stsp __dead static void usage_revert(void);
105 c4296144 2019-05-09 stsp __dead static void usage_commit(void);
106 f8a36e22 2021-08-26 stsp __dead static void usage_send(void);
107 234035bc 2019-06-01 stsp __dead static void usage_cherrypick(void);
108 5ef14e63 2019-06-02 stsp __dead static void usage_backout(void);
109 818c7501 2019-07-11 stsp __dead static void usage_rebase(void);
110 0ebf8283 2019-07-24 stsp __dead static void usage_histedit(void);
111 2822a352 2019-10-15 stsp __dead static void usage_integrate(void);
112 f259c4c1 2021-09-24 stsp __dead static void usage_merge(void);
113 715dc77e 2019-08-03 stsp __dead static void usage_stage(void);
114 ad493afc 2019-08-03 stsp __dead static void usage_unstage(void);
115 01073a5d 2019-08-22 stsp __dead static void usage_cat(void);
116 b2118c49 2020-07-28 stsp __dead static void usage_info(void);
118 2c7829a4 2019-06-17 stsp static const struct got_error* cmd_init(int, char *[]);
119 3ce1b845 2019-07-15 stsp static const struct got_error* cmd_import(int, char *[]);
120 93658fb9 2020-03-18 stsp static const struct got_error* cmd_clone(int, char *[]);
121 7848a0e1 2020-03-19 stsp static const struct got_error* cmd_fetch(int, char *[]);
122 4ed7e80c 2018-05-20 stsp static const struct got_error* cmd_checkout(int, char *[]);
123 507dc3bb 2018-12-29 stsp static const struct got_error* cmd_update(int, char *[]);
124 4ed7e80c 2018-05-20 stsp static const struct got_error* cmd_log(int, char *[]);
125 4ed7e80c 2018-05-20 stsp static const struct got_error* cmd_diff(int, char *[]);
126 404c43c4 2018-06-21 stsp static const struct got_error* cmd_blame(int, char *[]);
127 5de5890b 2018-10-18 stsp static const struct got_error* cmd_tree(int, char *[]);
128 4ed7e80c 2018-05-20 stsp static const struct got_error* cmd_status(int, char *[]);
129 d0eebce4 2019-03-11 stsp static const struct got_error* cmd_ref(int, char *[]);
130 4e759de4 2019-06-26 stsp static const struct got_error* cmd_branch(int, char *[]);
131 8e7bd50a 2019-08-22 stsp static const struct got_error* cmd_tag(int, char *[]);
132 d00136be 2019-03-26 stsp static const struct got_error* cmd_add(int, char *[]);
133 648e4ef7 2019-07-09 stsp static const struct got_error* cmd_remove(int, char *[]);
134 a129376b 2019-03-28 stsp static const struct got_error* cmd_revert(int, char *[]);
135 c4296144 2019-05-09 stsp static const struct got_error* cmd_commit(int, char *[]);
136 f8a36e22 2021-08-26 stsp static const struct got_error* cmd_send(int, char *[]);
137 234035bc 2019-06-01 stsp static const struct got_error* cmd_cherrypick(int, char *[]);
138 5ef14e63 2019-06-02 stsp static const struct got_error* cmd_backout(int, char *[]);
139 818c7501 2019-07-11 stsp static const struct got_error* cmd_rebase(int, char *[]);
140 0ebf8283 2019-07-24 stsp static const struct got_error* cmd_histedit(int, char *[]);
141 2822a352 2019-10-15 stsp static const struct got_error* cmd_integrate(int, char *[]);
142 f259c4c1 2021-09-24 stsp static const struct got_error* cmd_merge(int, char *[]);
143 715dc77e 2019-08-03 stsp static const struct got_error* cmd_stage(int, char *[]);
144 ad493afc 2019-08-03 stsp static const struct got_error* cmd_unstage(int, char *[]);
145 01073a5d 2019-08-22 stsp static const struct got_error* cmd_cat(int, char *[]);
146 b2118c49 2020-07-28 stsp static const struct got_error* cmd_info(int, char *[]);
148 8cfb4057 2019-07-09 stsp static struct got_cmd got_commands[] = {
149 b2118c49 2020-07-28 stsp { "init", cmd_init, usage_init, "" },
150 bc26cce8 2019-08-04 stsp { "import", cmd_import, usage_import, "im" },
151 93658fb9 2020-03-18 stsp { "clone", cmd_clone, usage_clone, "cl" },
152 7848a0e1 2020-03-19 stsp { "fetch", cmd_fetch, usage_fetch, "fe" },
153 2ab43947 2020-03-18 stsp { "checkout", cmd_checkout, usage_checkout, "co" },
154 97b3a7be 2019-07-09 stsp { "update", cmd_update, usage_update, "up" },
155 97b3a7be 2019-07-09 stsp { "log", cmd_log, usage_log, "" },
156 bc26cce8 2019-08-04 stsp { "diff", cmd_diff, usage_diff, "di" },
157 bc26cce8 2019-08-04 stsp { "blame", cmd_blame, usage_blame, "bl" },
158 bc26cce8 2019-08-04 stsp { "tree", cmd_tree, usage_tree, "tr" },
159 97b3a7be 2019-07-09 stsp { "status", cmd_status, usage_status, "st" },
160 97b3a7be 2019-07-09 stsp { "ref", cmd_ref, usage_ref, "" },
161 97b3a7be 2019-07-09 stsp { "branch", cmd_branch, usage_branch, "br" },
162 8e7bd50a 2019-08-22 stsp { "tag", cmd_tag, usage_tag, "" },
163 97b3a7be 2019-07-09 stsp { "add", cmd_add, usage_add, "" },
164 648e4ef7 2019-07-09 stsp { "remove", cmd_remove, usage_remove, "rm" },
165 97b3a7be 2019-07-09 stsp { "revert", cmd_revert, usage_revert, "rv" },
166 97b3a7be 2019-07-09 stsp { "commit", cmd_commit, usage_commit, "ci" },
167 f8a36e22 2021-08-26 stsp { "send", cmd_send, usage_send, "se" },
168 016477fd 2019-07-09 stsp { "cherrypick", cmd_cherrypick, usage_cherrypick, "cy" },
169 97b3a7be 2019-07-09 stsp { "backout", cmd_backout, usage_backout, "bo" },
170 818c7501 2019-07-11 stsp { "rebase", cmd_rebase, usage_rebase, "rb" },
171 0ebf8283 2019-07-24 stsp { "histedit", cmd_histedit, usage_histedit, "he" },
172 2822a352 2019-10-15 stsp { "integrate", cmd_integrate, usage_integrate,"ig" },
173 f259c4c1 2021-09-24 stsp { "merge", cmd_merge, usage_merge, "mg" },
174 715dc77e 2019-08-03 stsp { "stage", cmd_stage, usage_stage, "sg" },
175 ad493afc 2019-08-03 stsp { "unstage", cmd_unstage, usage_unstage, "ug" },
176 01073a5d 2019-08-22 stsp { "cat", cmd_cat, usage_cat, "" },
177 b2118c49 2020-07-28 stsp { "info", cmd_info, usage_info, "" },
180 ce5b7c56 2019-07-09 stsp static void
181 6879ba42 2020-10-01 naddy list_commands(FILE *fp)
185 6879ba42 2020-10-01 naddy fprintf(fp, "commands:");
186 ce5b7c56 2019-07-09 stsp for (i = 0; i < nitems(got_commands); i++) {
187 ce5b7c56 2019-07-09 stsp struct got_cmd *cmd = &got_commands[i];
188 6879ba42 2020-10-01 naddy fprintf(fp, " %s", cmd->cmd_name);
190 6879ba42 2020-10-01 naddy fputc('\n', fp);
193 ff69268e 2020-12-13 stsp __dead static void
194 ff69268e 2020-12-13 stsp option_conflict(char a, char b)
196 ff69268e 2020-12-13 stsp errx(1, "-%c and -%c options are mutually exclusive", a, b);
200 5c860e29 2018-03-12 stsp main(int argc, char *argv[])
202 8cfb4057 2019-07-09 stsp struct got_cmd *cmd;
205 53ccebc2 2019-07-30 stsp int hflag = 0, Vflag = 0;
206 83cd27f8 2020-01-13 stsp static struct option longopts[] = {
207 62d463ca 2020-10-20 naddy { "version", no_argument, NULL, 'V' },
208 62d463ca 2020-10-20 naddy { NULL, 0, NULL, 0 }
211 289e3cbf 2019-02-04 stsp setlocale(LC_CTYPE, "");
213 6586ea88 2020-01-13 stsp while ((ch = getopt_long(argc, argv, "+hV", longopts, NULL)) != -1) {
214 5c860e29 2018-03-12 stsp switch (ch) {
222 6879ba42 2020-10-01 naddy usage(hflag, 1);
223 5c860e29 2018-03-12 stsp /* NOTREACHED */
227 5c860e29 2018-03-12 stsp argc -= optind;
228 5c860e29 2018-03-12 stsp argv += optind;
229 9814e6a3 2020-09-27 naddy optind = 1;
230 9814e6a3 2020-09-27 naddy optreset = 1;
232 53ccebc2 2019-07-30 stsp if (Vflag) {
233 53ccebc2 2019-07-30 stsp got_version_print_str();
237 5c860e29 2018-03-12 stsp if (argc <= 0)
238 6879ba42 2020-10-01 naddy usage(hflag, hflag ? 0 : 1);
240 99437157 2018-11-11 stsp signal(SIGINT, catch_sigint);
241 99437157 2018-11-11 stsp signal(SIGPIPE, catch_sigpipe);
243 5c860e29 2018-03-12 stsp for (i = 0; i < nitems(got_commands); i++) {
244 d7d4f210 2018-03-12 stsp const struct got_error *error;
246 5c860e29 2018-03-12 stsp cmd = &got_commands[i];
248 97b3a7be 2019-07-09 stsp if (strcmp(cmd->cmd_name, argv[0]) != 0 &&
249 97b3a7be 2019-07-09 stsp strcmp(cmd->cmd_alias, argv[0]) != 0)
253 1b6b95a8 2018-03-12 stsp got_commands[i].cmd_usage();
255 d7d4f210 2018-03-12 stsp error = got_commands[i].cmd_main(argc, argv);
256 f8afbdc8 2019-11-08 stsp if (error && error->code != GOT_ERR_CANCELLED &&
257 f8afbdc8 2019-11-08 stsp error->code != GOT_ERR_PRIVSEP_EXIT &&
258 f8afbdc8 2019-11-08 stsp !(sigpipe_received &&
259 70015d7a 2019-11-08 stsp error->code == GOT_ERR_ERRNO && errno == EPIPE) &&
260 70015d7a 2019-11-08 stsp !(sigint_received &&
261 70015d7a 2019-11-08 stsp error->code == GOT_ERR_ERRNO && errno == EINTR)) {
262 d7d4f210 2018-03-12 stsp fprintf(stderr, "%s: %s\n", getprogname(), error->msg);
269 20ecf764 2018-03-12 stsp fprintf(stderr, "%s: unknown command '%s'\n", getprogname(), argv[0]);
270 6879ba42 2020-10-01 naddy list_commands(stderr);
274 4ed7e80c 2018-05-20 stsp __dead static void
275 6879ba42 2020-10-01 naddy usage(int hflag, int status)
277 6879ba42 2020-10-01 naddy FILE *fp = (status == 0) ? stdout : stderr;
279 6879ba42 2020-10-01 naddy fprintf(fp, "usage: %s [-h] [-V | --version] command [arg ...]\n",
280 53ccebc2 2019-07-30 stsp getprogname());
282 6879ba42 2020-10-01 naddy list_commands(fp);
283 6879ba42 2020-10-01 naddy exit(status);
286 0266afb7 2019-01-04 stsp static const struct got_error *
287 0ee7065d 2019-05-13 stsp get_editor(char **abspath)
289 0ee7065d 2019-05-13 stsp const struct got_error *err = NULL;
290 e2ba3d07 2019-05-13 stsp const char *editor;
292 8920fa04 2019-08-18 stsp *abspath = NULL;
294 e2ba3d07 2019-05-13 stsp editor = getenv("VISUAL");
295 e2ba3d07 2019-05-13 stsp if (editor == NULL)
296 e2ba3d07 2019-05-13 stsp editor = getenv("EDITOR");
298 0ee7065d 2019-05-13 stsp if (editor) {
299 0ee7065d 2019-05-13 stsp err = got_path_find_prog(abspath, editor);
301 0ee7065d 2019-05-13 stsp return err;
304 0ee7065d 2019-05-13 stsp if (*abspath == NULL) {
305 0ee7065d 2019-05-13 stsp *abspath = strdup("/bin/ed");
306 0ee7065d 2019-05-13 stsp if (*abspath == NULL)
307 0ee7065d 2019-05-13 stsp return got_error_from_errno("strdup");
310 e2ba3d07 2019-05-13 stsp return NULL;
313 e2ba3d07 2019-05-13 stsp static const struct got_error *
314 d0eebce4 2019-03-11 stsp apply_unveil(const char *repo_path, int repo_read_only,
315 c530dc23 2019-07-23 stsp const char *worktree_path)
317 163ce85a 2019-05-13 stsp const struct got_error *err;
319 37c06ea4 2019-07-15 stsp #ifdef PROFILE
320 37c06ea4 2019-07-15 stsp if (unveil("gmon.out", "rwc") != 0)
321 37c06ea4 2019-07-15 stsp return got_error_from_errno2("unveil", "gmon.out");
323 d0eebce4 2019-03-11 stsp if (repo_path && unveil(repo_path, repo_read_only ? "r" : "rwc") != 0)
324 638f9024 2019-05-13 stsp return got_error_from_errno2("unveil", repo_path);
326 0266afb7 2019-01-04 stsp if (worktree_path && unveil(worktree_path, "rwc") != 0)
327 638f9024 2019-05-13 stsp return got_error_from_errno2("unveil", worktree_path);
329 bb63914a 2020-02-17 stsp if (unveil(GOT_TMPDIR_STR, "rwc") != 0)
330 bb63914a 2020-02-17 stsp return got_error_from_errno2("unveil", GOT_TMPDIR_STR);
332 163ce85a 2019-05-13 stsp err = got_privsep_unveil_exec_helpers();
333 163ce85a 2019-05-13 stsp if (err != NULL)
334 163ce85a 2019-05-13 stsp return err;
336 0266afb7 2019-01-04 stsp if (unveil(NULL, NULL) != 0)
337 638f9024 2019-05-13 stsp return got_error_from_errno("unveil");
339 0266afb7 2019-01-04 stsp return NULL;
342 2c7829a4 2019-06-17 stsp __dead static void
343 2c7829a4 2019-06-17 stsp usage_init(void)
345 09ea71ba 2019-07-27 stsp fprintf(stderr, "usage: %s init repository-path\n", getprogname());
349 2c7829a4 2019-06-17 stsp static const struct got_error *
350 2c7829a4 2019-06-17 stsp cmd_init(int argc, char *argv[])
352 2c7829a4 2019-06-17 stsp const struct got_error *error = NULL;
353 2c7829a4 2019-06-17 stsp char *repo_path = NULL;
356 2c7829a4 2019-06-17 stsp while ((ch = getopt(argc, argv, "")) != -1) {
357 2c7829a4 2019-06-17 stsp switch (ch) {
359 2c7829a4 2019-06-17 stsp usage_init();
360 2c7829a4 2019-06-17 stsp /* NOTREACHED */
364 2c7829a4 2019-06-17 stsp argc -= optind;
365 2c7829a4 2019-06-17 stsp argv += optind;
367 2c7829a4 2019-06-17 stsp #ifndef PROFILE
368 2c7829a4 2019-06-17 stsp if (pledge("stdio rpath wpath cpath unveil", NULL) == -1)
369 2c7829a4 2019-06-17 stsp err(1, "pledge");
371 2c7829a4 2019-06-17 stsp if (argc != 1)
372 bc20e173 2019-06-17 stsp usage_init();
374 2c7829a4 2019-06-17 stsp repo_path = strdup(argv[0]);
375 2c7829a4 2019-06-17 stsp if (repo_path == NULL)
376 2c7829a4 2019-06-17 stsp return got_error_from_errno("strdup");
378 2c7829a4 2019-06-17 stsp got_path_strip_trailing_slashes(repo_path);
380 2c7829a4 2019-06-17 stsp error = got_path_mkdir(repo_path);
381 2c7829a4 2019-06-17 stsp if (error &&
382 2c7829a4 2019-06-17 stsp !(error->code == GOT_ERR_ERRNO && errno == EEXIST))
385 c530dc23 2019-07-23 stsp error = apply_unveil(repo_path, 0, NULL);
389 2c7829a4 2019-06-17 stsp error = got_repo_init(repo_path);
391 3ce1b845 2019-07-15 stsp free(repo_path);
392 3ce1b845 2019-07-15 stsp return error;
395 3ce1b845 2019-07-15 stsp __dead static void
396 3ce1b845 2019-07-15 stsp usage_import(void)
398 3ce1b845 2019-07-15 stsp fprintf(stderr, "usage: %s import [-b branch] [-m message] "
399 3ce1b845 2019-07-15 stsp "[-r repository-path] [-I pattern] path\n", getprogname());
404 3ce1b845 2019-07-15 stsp spawn_editor(const char *editor, const char *file)
407 3ce1b845 2019-07-15 stsp sig_t sighup, sigint, sigquit;
408 3ce1b845 2019-07-15 stsp int st = -1;
410 3ce1b845 2019-07-15 stsp sighup = signal(SIGHUP, SIG_IGN);
411 3ce1b845 2019-07-15 stsp sigint = signal(SIGINT, SIG_IGN);
412 3ce1b845 2019-07-15 stsp sigquit = signal(SIGQUIT, SIG_IGN);
414 3ce1b845 2019-07-15 stsp switch (pid = fork()) {
416 3ce1b845 2019-07-15 stsp goto doneediting;
418 3ce1b845 2019-07-15 stsp execl(editor, editor, file, (char *)NULL);
419 3ce1b845 2019-07-15 stsp _exit(127);
422 3ce1b845 2019-07-15 stsp while (waitpid(pid, &st, 0) == -1)
423 3ce1b845 2019-07-15 stsp if (errno != EINTR)
426 3ce1b845 2019-07-15 stsp doneediting:
427 3ce1b845 2019-07-15 stsp (void)signal(SIGHUP, sighup);
428 3ce1b845 2019-07-15 stsp (void)signal(SIGINT, sigint);
429 3ce1b845 2019-07-15 stsp (void)signal(SIGQUIT, sigquit);
431 3ce1b845 2019-07-15 stsp if (!WIFEXITED(st)) {
432 3ce1b845 2019-07-15 stsp errno = EINTR;
436 3ce1b845 2019-07-15 stsp return WEXITSTATUS(st);
439 3ce1b845 2019-07-15 stsp static const struct got_error *
440 3ce1b845 2019-07-15 stsp edit_logmsg(char **logmsg, const char *editor, const char *logmsg_path,
441 28cf319f 2021-01-28 stsp const char *initial_content, size_t initial_content_len,
442 28cf319f 2021-01-28 stsp int require_modification)
444 3ce1b845 2019-07-15 stsp const struct got_error *err = NULL;
445 bfa12d5e 2020-09-26 stsp char *line = NULL;
446 bfa12d5e 2020-09-26 stsp size_t linesize = 0;
447 bfa12d5e 2020-09-26 stsp ssize_t linelen;
448 3ce1b845 2019-07-15 stsp struct stat st, st2;
449 bfa12d5e 2020-09-26 stsp FILE *fp = NULL;
450 bfa12d5e 2020-09-26 stsp size_t len, logmsg_len;
451 bfa12d5e 2020-09-26 stsp char *initial_content_stripped = NULL, *buf = NULL, *s;
453 3ce1b845 2019-07-15 stsp *logmsg = NULL;
455 3ce1b845 2019-07-15 stsp if (stat(logmsg_path, &st) == -1)
456 3ce1b845 2019-07-15 stsp return got_error_from_errno2("stat", logmsg_path);
458 3ce1b845 2019-07-15 stsp if (spawn_editor(editor, logmsg_path) == -1)
459 3ce1b845 2019-07-15 stsp return got_error_from_errno("failed spawning editor");
461 3ce1b845 2019-07-15 stsp if (stat(logmsg_path, &st2) == -1)
462 3ce1b845 2019-07-15 stsp return got_error_from_errno("stat");
464 28cf319f 2021-01-28 stsp if (require_modification &&
465 28cf319f 2021-01-28 stsp st.st_mtime == st2.st_mtime && st.st_size == st2.st_size)
466 3ce1b845 2019-07-15 stsp return got_error_msg(GOT_ERR_COMMIT_MSG_EMPTY,
467 3ce1b845 2019-07-15 stsp "no changes made to commit message, aborting");
470 bfa12d5e 2020-09-26 stsp * Set up a stripped version of the initial content without comments
471 bfa12d5e 2020-09-26 stsp * and blank lines. We need this in order to check if the message
472 bfa12d5e 2020-09-26 stsp * has in fact been edited.
474 bfa12d5e 2020-09-26 stsp initial_content_stripped = malloc(initial_content_len + 1);
475 bfa12d5e 2020-09-26 stsp if (initial_content_stripped == NULL)
476 bfa12d5e 2020-09-26 stsp return got_error_from_errno("malloc");
477 bfa12d5e 2020-09-26 stsp initial_content_stripped[0] = '\0';
479 bfa12d5e 2020-09-26 stsp buf = strdup(initial_content);
480 bfa12d5e 2020-09-26 stsp if (buf == NULL) {
481 bfa12d5e 2020-09-26 stsp err = got_error_from_errno("strdup");
486 bfa12d5e 2020-09-26 stsp while ((line = strsep(&s, "\n")) != NULL) {
487 bfa12d5e 2020-09-26 stsp if ((line[0] == '#' || (len == 0 && line[0] == '\n')))
488 bfa12d5e 2020-09-26 stsp continue; /* remove comments and leading empty lines */
489 bfa12d5e 2020-09-26 stsp len = strlcat(initial_content_stripped, line,
490 bfa12d5e 2020-09-26 stsp initial_content_len + 1);
491 bfa12d5e 2020-09-26 stsp if (len >= initial_content_len + 1) {
492 bfa12d5e 2020-09-26 stsp err = got_error(GOT_ERR_NO_SPACE);
496 bfa12d5e 2020-09-26 stsp while (len > 0 && initial_content_stripped[len - 1] == '\n') {
497 bfa12d5e 2020-09-26 stsp initial_content_stripped[len - 1] = '\0';
501 bfa12d5e 2020-09-26 stsp logmsg_len = st2.st_size;
502 bfa12d5e 2020-09-26 stsp *logmsg = malloc(logmsg_len + 1);
503 3ce1b845 2019-07-15 stsp if (*logmsg == NULL)
504 3ce1b845 2019-07-15 stsp return got_error_from_errno("malloc");
505 3ce1b845 2019-07-15 stsp (*logmsg)[0] = '\0';
507 00fe21f2 2021-12-31 stsp fp = fopen(logmsg_path, "re");
508 3ce1b845 2019-07-15 stsp if (fp == NULL) {
509 3ce1b845 2019-07-15 stsp err = got_error_from_errno("fopen");
514 bfa12d5e 2020-09-26 stsp while ((linelen = getline(&line, &linesize, fp)) != -1) {
515 bfa12d5e 2020-09-26 stsp if ((line[0] == '#' || (len == 0 && line[0] == '\n')))
516 3ce1b845 2019-07-15 stsp continue; /* remove comments and leading empty lines */
517 bfa12d5e 2020-09-26 stsp len = strlcat(*logmsg, line, logmsg_len + 1);
518 bfa12d5e 2020-09-26 stsp if (len >= logmsg_len + 1) {
519 bfa12d5e 2020-09-26 stsp err = got_error(GOT_ERR_NO_SPACE);
523 bfa12d5e 2020-09-26 stsp free(line);
524 bfa12d5e 2020-09-26 stsp if (ferror(fp)) {
525 bfa12d5e 2020-09-26 stsp err = got_ferror(fp, GOT_ERR_IO);
528 3ce1b845 2019-07-15 stsp while (len > 0 && (*logmsg)[len - 1] == '\n') {
529 3ce1b845 2019-07-15 stsp (*logmsg)[len - 1] = '\0';
533 bfa12d5e 2020-09-26 stsp if (len == 0) {
534 3ce1b845 2019-07-15 stsp err = got_error_msg(GOT_ERR_COMMIT_MSG_EMPTY,
535 3ce1b845 2019-07-15 stsp "commit message cannot be empty, aborting");
538 28cf319f 2021-01-28 stsp if (require_modification &&
539 28cf319f 2021-01-28 stsp strcmp(*logmsg, initial_content_stripped) == 0)
540 bfa12d5e 2020-09-26 stsp err = got_error_msg(GOT_ERR_COMMIT_MSG_EMPTY,
541 bfa12d5e 2020-09-26 stsp "no changes made to commit message, aborting");
543 bfa12d5e 2020-09-26 stsp free(initial_content_stripped);
545 bfa12d5e 2020-09-26 stsp if (fp && fclose(fp) == EOF && err == NULL)
546 bfa12d5e 2020-09-26 stsp err = got_error_from_errno("fclose");
548 3ce1b845 2019-07-15 stsp free(*logmsg);
549 3ce1b845 2019-07-15 stsp *logmsg = NULL;
551 3ce1b845 2019-07-15 stsp return err;
554 3ce1b845 2019-07-15 stsp static const struct got_error *
555 ef293bdd 2019-10-21 stsp collect_import_msg(char **logmsg, char **logmsg_path, const char *editor,
556 ef293bdd 2019-10-21 stsp const char *path_dir, const char *branch_name)
558 ef293bdd 2019-10-21 stsp char *initial_content = NULL;
559 3ce1b845 2019-07-15 stsp const struct got_error *err = NULL;
560 1601cb9f 2020-09-11 naddy int initial_content_len;
561 97972933 2020-09-11 stsp int fd = -1;
563 1601cb9f 2020-09-11 naddy initial_content_len = asprintf(&initial_content,
564 3ce1b845 2019-07-15 stsp "\n# %s to be imported to branch %s\n", path_dir,
565 1601cb9f 2020-09-11 naddy branch_name);
566 1601cb9f 2020-09-11 naddy if (initial_content_len == -1)
567 3ce1b845 2019-07-15 stsp return got_error_from_errno("asprintf");
569 bb63914a 2020-02-17 stsp err = got_opentemp_named_fd(logmsg_path, &fd,
570 bb63914a 2020-02-17 stsp GOT_TMPDIR_STR "/got-importmsg");
574 97972933 2020-09-11 stsp if (write(fd, initial_content, initial_content_len) == -1) {
575 97972933 2020-09-11 stsp err = got_error_from_errno2("write", *logmsg_path);
579 bfa12d5e 2020-09-26 stsp err = edit_logmsg(logmsg, editor, *logmsg_path, initial_content,
580 0d5bb276 2020-12-15 stsp initial_content_len, 1);
582 97972933 2020-09-11 stsp if (fd != -1 && close(fd) == -1 && err == NULL)
583 97972933 2020-09-11 stsp err = got_error_from_errno2("close", *logmsg_path);
584 3ce1b845 2019-07-15 stsp free(initial_content);
586 59f86c76 2020-09-11 stsp free(*logmsg_path);
587 59f86c76 2020-09-11 stsp *logmsg_path = NULL;
589 3ce1b845 2019-07-15 stsp return err;
592 3ce1b845 2019-07-15 stsp static const struct got_error *
593 3ce1b845 2019-07-15 stsp import_progress(void *arg, const char *path)
595 3ce1b845 2019-07-15 stsp printf("A %s\n", path);
596 3ce1b845 2019-07-15 stsp return NULL;
599 3ce1b845 2019-07-15 stsp static const struct got_error *
600 50b0790e 2020-09-11 stsp get_author(char **author, struct got_repository *repo,
601 50b0790e 2020-09-11 stsp struct got_worktree *worktree)
603 aba9c984 2019-09-08 stsp const struct got_error *err = NULL;
604 50b0790e 2020-09-11 stsp const char *got_author = NULL, *name, *email;
605 50b0790e 2020-09-11 stsp const struct got_gotconfig *worktree_conf = NULL, *repo_conf = NULL;
607 84792843 2019-08-09 stsp *author = NULL;
609 50b0790e 2020-09-11 stsp if (worktree)
610 50b0790e 2020-09-11 stsp worktree_conf = got_worktree_get_gotconfig(worktree);
611 50b0790e 2020-09-11 stsp repo_conf = got_repo_get_gotconfig(repo);
614 50b0790e 2020-09-11 stsp * Priority of potential author information sources, from most
615 50b0790e 2020-09-11 stsp * significant to least significant:
616 50b0790e 2020-09-11 stsp * 1) work tree's .got/got.conf file
617 50b0790e 2020-09-11 stsp * 2) repository's got.conf file
618 50b0790e 2020-09-11 stsp * 3) repository's git config file
619 50b0790e 2020-09-11 stsp * 4) environment variables
620 50b0790e 2020-09-11 stsp * 5) global git config files (in user's home directory or /etc)
623 50b0790e 2020-09-11 stsp if (worktree_conf)
624 50b0790e 2020-09-11 stsp got_author = got_gotconfig_get_author(worktree_conf);
625 50b0790e 2020-09-11 stsp if (got_author == NULL)
626 50b0790e 2020-09-11 stsp got_author = got_gotconfig_get_author(repo_conf);
627 84792843 2019-08-09 stsp if (got_author == NULL) {
628 257add31 2020-09-09 stsp name = got_repo_get_gitconfig_author_name(repo);
629 257add31 2020-09-09 stsp email = got_repo_get_gitconfig_author_email(repo);
630 c9956ddf 2019-09-08 stsp if (name && email) {
631 c9956ddf 2019-09-08 stsp if (asprintf(author, "%s <%s>", name, email) == -1)
632 c9956ddf 2019-09-08 stsp return got_error_from_errno("asprintf");
633 c9956ddf 2019-09-08 stsp return NULL;
636 257add31 2020-09-09 stsp got_author = getenv("GOT_AUTHOR");
637 257add31 2020-09-09 stsp if (got_author == NULL) {
638 257add31 2020-09-09 stsp name = got_repo_get_global_gitconfig_author_name(repo);
639 257add31 2020-09-09 stsp email = got_repo_get_global_gitconfig_author_email(
641 257add31 2020-09-09 stsp if (name && email) {
642 257add31 2020-09-09 stsp if (asprintf(author, "%s <%s>", name, email)
644 257add31 2020-09-09 stsp return got_error_from_errno("asprintf");
645 257add31 2020-09-09 stsp return NULL;
647 257add31 2020-09-09 stsp /* TODO: Look up user in password database? */
648 257add31 2020-09-09 stsp return got_error(GOT_ERR_COMMIT_NO_AUTHOR);
652 aba9c984 2019-09-08 stsp *author = strdup(got_author);
653 aba9c984 2019-09-08 stsp if (*author == NULL)
654 aba9c984 2019-09-08 stsp return got_error_from_errno("strdup");
657 84792843 2019-08-09 stsp * Really dumb email address check; we're only doing this to
658 84792843 2019-08-09 stsp * avoid git's object parser breaking on commits we create.
660 84792843 2019-08-09 stsp while (*got_author && *got_author != '<')
661 84792843 2019-08-09 stsp got_author++;
662 aba9c984 2019-09-08 stsp if (*got_author != '<') {
663 aba9c984 2019-09-08 stsp err = got_error(GOT_ERR_COMMIT_NO_EMAIL);
666 84792843 2019-08-09 stsp while (*got_author && *got_author != '@')
667 84792843 2019-08-09 stsp got_author++;
668 aba9c984 2019-09-08 stsp if (*got_author != '@') {
669 aba9c984 2019-09-08 stsp err = got_error(GOT_ERR_COMMIT_NO_EMAIL);
672 84792843 2019-08-09 stsp while (*got_author && *got_author != '>')
673 84792843 2019-08-09 stsp got_author++;
674 84792843 2019-08-09 stsp if (*got_author != '>')
675 aba9c984 2019-09-08 stsp err = got_error(GOT_ERR_COMMIT_NO_EMAIL);
678 aba9c984 2019-09-08 stsp free(*author);
679 aba9c984 2019-09-08 stsp *author = NULL;
681 aba9c984 2019-09-08 stsp return err;
684 c9956ddf 2019-09-08 stsp static const struct got_error *
685 c9956ddf 2019-09-08 stsp get_gitconfig_path(char **gitconfig_path)
687 c9956ddf 2019-09-08 stsp const char *homedir = getenv("HOME");
689 c9956ddf 2019-09-08 stsp *gitconfig_path = NULL;
690 c9956ddf 2019-09-08 stsp if (homedir) {
691 c9956ddf 2019-09-08 stsp if (asprintf(gitconfig_path, "%s/.gitconfig", homedir) == -1)
692 c9956ddf 2019-09-08 stsp return got_error_from_errno("asprintf");
695 c9956ddf 2019-09-08 stsp return NULL;
698 84792843 2019-08-09 stsp static const struct got_error *
699 3ce1b845 2019-07-15 stsp cmd_import(int argc, char *argv[])
701 3ce1b845 2019-07-15 stsp const struct got_error *error = NULL;
702 3ce1b845 2019-07-15 stsp char *path_dir = NULL, *repo_path = NULL, *logmsg = NULL;
703 c9956ddf 2019-09-08 stsp char *gitconfig_path = NULL, *editor = NULL, *author = NULL;
704 5d67f40d 2019-11-08 stsp const char *branch_name = "main";
705 ef293bdd 2019-10-21 stsp char *refname = NULL, *id_str = NULL, *logmsg_path = NULL;
706 3ce1b845 2019-07-15 stsp struct got_repository *repo = NULL;
707 3ce1b845 2019-07-15 stsp struct got_reference *branch_ref = NULL, *head_ref = NULL;
708 3ce1b845 2019-07-15 stsp struct got_object_id *new_commit_id = NULL;
710 3ce1b845 2019-07-15 stsp struct got_pathlist_head ignores;
711 3ce1b845 2019-07-15 stsp struct got_pathlist_entry *pe;
712 ef293bdd 2019-10-21 stsp int preserve_logmsg = 0;
714 3ce1b845 2019-07-15 stsp TAILQ_INIT(&ignores);
716 3ce1b845 2019-07-15 stsp while ((ch = getopt(argc, argv, "b:m:r:I:")) != -1) {
717 3ce1b845 2019-07-15 stsp switch (ch) {
719 3ce1b845 2019-07-15 stsp branch_name = optarg;
722 3ce1b845 2019-07-15 stsp logmsg = strdup(optarg);
723 3ce1b845 2019-07-15 stsp if (logmsg == NULL) {
724 3ce1b845 2019-07-15 stsp error = got_error_from_errno("strdup");
729 3ce1b845 2019-07-15 stsp repo_path = realpath(optarg, NULL);
730 3ce1b845 2019-07-15 stsp if (repo_path == NULL) {
731 9ba1d308 2019-10-21 stsp error = got_error_from_errno2("realpath",
737 3ce1b845 2019-07-15 stsp if (optarg[0] == '\0')
739 3ce1b845 2019-07-15 stsp error = got_pathlist_insert(&pe, &ignores, optarg,
745 b2b65d18 2019-08-22 stsp usage_import();
746 3ce1b845 2019-07-15 stsp /* NOTREACHED */
750 3ce1b845 2019-07-15 stsp argc -= optind;
751 3ce1b845 2019-07-15 stsp argv += optind;
753 3ce1b845 2019-07-15 stsp #ifndef PROFILE
754 aba9c984 2019-09-08 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
756 3ce1b845 2019-07-15 stsp NULL) == -1)
757 3ce1b845 2019-07-15 stsp err(1, "pledge");
759 3ce1b845 2019-07-15 stsp if (argc != 1)
760 3ce1b845 2019-07-15 stsp usage_import();
762 3ce1b845 2019-07-15 stsp if (repo_path == NULL) {
763 3ce1b845 2019-07-15 stsp repo_path = getcwd(NULL, 0);
764 3ce1b845 2019-07-15 stsp if (repo_path == NULL)
765 3ce1b845 2019-07-15 stsp return got_error_from_errno("getcwd");
767 3ce1b845 2019-07-15 stsp got_path_strip_trailing_slashes(repo_path);
768 c9956ddf 2019-09-08 stsp error = get_gitconfig_path(&gitconfig_path);
771 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, repo_path, gitconfig_path);
775 50b0790e 2020-09-11 stsp error = get_author(&author, repo, NULL);
777 aba9c984 2019-09-08 stsp return error;
780 bd5895f3 2019-11-28 stsp * Don't let the user create a branch name with a leading '-'.
781 e560b7e0 2019-11-28 stsp * While technically a valid reference name, this case is usually
782 e560b7e0 2019-11-28 stsp * an unintended typo.
784 bd5895f3 2019-11-28 stsp if (branch_name[0] == '-')
785 bd5895f3 2019-11-28 stsp return got_error_path(branch_name, GOT_ERR_REF_NAME_MINUS);
787 3ce1b845 2019-07-15 stsp if (asprintf(&refname, "refs/heads/%s", branch_name) == -1) {
788 3ce1b845 2019-07-15 stsp error = got_error_from_errno("asprintf");
792 3ce1b845 2019-07-15 stsp error = got_ref_open(&branch_ref, repo, refname, 0);
793 3ce1b845 2019-07-15 stsp if (error) {
794 3ce1b845 2019-07-15 stsp if (error->code != GOT_ERR_NOT_REF)
797 3ce1b845 2019-07-15 stsp error = got_error_msg(GOT_ERR_BRANCH_EXISTS,
798 3ce1b845 2019-07-15 stsp "import target branch already exists");
802 3ce1b845 2019-07-15 stsp path_dir = realpath(argv[0], NULL);
803 3ce1b845 2019-07-15 stsp if (path_dir == NULL) {
804 9ba1d308 2019-10-21 stsp error = got_error_from_errno2("realpath", argv[0]);
807 3ce1b845 2019-07-15 stsp got_path_strip_trailing_slashes(path_dir);
810 3ce1b845 2019-07-15 stsp * unveil(2) traverses exec(2); if an editor is used we have
811 3ce1b845 2019-07-15 stsp * to apply unveil after the log message has been written.
813 3ce1b845 2019-07-15 stsp if (logmsg == NULL || strlen(logmsg) == 0) {
814 3ce1b845 2019-07-15 stsp error = get_editor(&editor);
817 8e158b01 2019-09-22 stsp free(logmsg);
818 ef293bdd 2019-10-21 stsp error = collect_import_msg(&logmsg, &logmsg_path, editor,
819 ef293bdd 2019-10-21 stsp path_dir, refname);
820 ef293bdd 2019-10-21 stsp if (error) {
821 ef293bdd 2019-10-21 stsp if (error->code != GOT_ERR_COMMIT_MSG_EMPTY &&
822 ef293bdd 2019-10-21 stsp logmsg_path != NULL)
823 ef293bdd 2019-10-21 stsp preserve_logmsg = 1;
828 ef293bdd 2019-10-21 stsp if (unveil(path_dir, "r") != 0) {
829 ef293bdd 2019-10-21 stsp error = got_error_from_errno2("unveil", path_dir);
830 ef293bdd 2019-10-21 stsp if (logmsg_path)
831 ef293bdd 2019-10-21 stsp preserve_logmsg = 1;
835 ef293bdd 2019-10-21 stsp error = apply_unveil(got_repo_get_path(repo), 0, NULL);
836 ef293bdd 2019-10-21 stsp if (error) {
837 ef293bdd 2019-10-21 stsp if (logmsg_path)
838 ef293bdd 2019-10-21 stsp preserve_logmsg = 1;
842 3ce1b845 2019-07-15 stsp error = got_repo_import(&new_commit_id, path_dir, logmsg,
843 84792843 2019-08-09 stsp author, &ignores, repo, import_progress, NULL);
844 ef293bdd 2019-10-21 stsp if (error) {
845 ef293bdd 2019-10-21 stsp if (logmsg_path)
846 ef293bdd 2019-10-21 stsp preserve_logmsg = 1;
850 3ce1b845 2019-07-15 stsp error = got_ref_alloc(&branch_ref, refname, new_commit_id);
851 ef293bdd 2019-10-21 stsp if (error) {
852 ef293bdd 2019-10-21 stsp if (logmsg_path)
853 ef293bdd 2019-10-21 stsp preserve_logmsg = 1;
857 3ce1b845 2019-07-15 stsp error = got_ref_write(branch_ref, repo);
858 ef293bdd 2019-10-21 stsp if (error) {
859 ef293bdd 2019-10-21 stsp if (logmsg_path)
860 ef293bdd 2019-10-21 stsp preserve_logmsg = 1;
864 3ce1b845 2019-07-15 stsp error = got_object_id_str(&id_str, new_commit_id);
865 ef293bdd 2019-10-21 stsp if (error) {
866 ef293bdd 2019-10-21 stsp if (logmsg_path)
867 ef293bdd 2019-10-21 stsp preserve_logmsg = 1;
871 3ce1b845 2019-07-15 stsp error = got_ref_open(&head_ref, repo, GOT_REF_HEAD, 0);
872 3ce1b845 2019-07-15 stsp if (error) {
873 ef293bdd 2019-10-21 stsp if (error->code != GOT_ERR_NOT_REF) {
874 ef293bdd 2019-10-21 stsp if (logmsg_path)
875 ef293bdd 2019-10-21 stsp preserve_logmsg = 1;
879 3ce1b845 2019-07-15 stsp error = got_ref_alloc_symref(&head_ref, GOT_REF_HEAD,
880 3ce1b845 2019-07-15 stsp branch_ref);
881 ef293bdd 2019-10-21 stsp if (error) {
882 ef293bdd 2019-10-21 stsp if (logmsg_path)
883 ef293bdd 2019-10-21 stsp preserve_logmsg = 1;
887 3ce1b845 2019-07-15 stsp error = got_ref_write(head_ref, repo);
888 ef293bdd 2019-10-21 stsp if (error) {
889 ef293bdd 2019-10-21 stsp if (logmsg_path)
890 ef293bdd 2019-10-21 stsp preserve_logmsg = 1;
895 3ce1b845 2019-07-15 stsp printf("Created branch %s with commit %s\n",
896 3ce1b845 2019-07-15 stsp got_ref_get_name(branch_ref), id_str);
898 ef293bdd 2019-10-21 stsp if (preserve_logmsg) {
899 ef293bdd 2019-10-21 stsp fprintf(stderr, "%s: log message preserved in %s\n",
900 ef293bdd 2019-10-21 stsp getprogname(), logmsg_path);
901 ef293bdd 2019-10-21 stsp } else if (logmsg_path && unlink(logmsg_path) == -1 && error == NULL)
902 ef293bdd 2019-10-21 stsp error = got_error_from_errno2("unlink", logmsg_path);
903 8e158b01 2019-09-22 stsp free(logmsg);
904 ef293bdd 2019-10-21 stsp free(logmsg_path);
905 2c7829a4 2019-06-17 stsp free(repo_path);
906 3ce1b845 2019-07-15 stsp free(editor);
907 3ce1b845 2019-07-15 stsp free(refname);
908 3ce1b845 2019-07-15 stsp free(new_commit_id);
909 3ce1b845 2019-07-15 stsp free(id_str);
910 aba9c984 2019-09-08 stsp free(author);
911 c9956ddf 2019-09-08 stsp free(gitconfig_path);
912 3ce1b845 2019-07-15 stsp if (branch_ref)
913 3ce1b845 2019-07-15 stsp got_ref_close(branch_ref);
914 3ce1b845 2019-07-15 stsp if (head_ref)
915 3ce1b845 2019-07-15 stsp got_ref_close(head_ref);
916 2c7829a4 2019-06-17 stsp return error;
919 93658fb9 2020-03-18 stsp __dead static void
920 93658fb9 2020-03-18 stsp usage_clone(void)
922 13f12b09 2020-03-21 stsp fprintf(stderr, "usage: %s clone [-a] [-b branch] [-l] [-m] [-q] [-v] "
923 0e4002ca 2020-03-21 stsp "[-R reference] repository-url [directory]\n", getprogname());
927 892ac3b6 2020-03-18 stsp struct got_fetch_progress_arg {
928 892ac3b6 2020-03-18 stsp char last_scaled_size[FMT_SCALED_STRSIZE];
929 892ac3b6 2020-03-18 stsp int last_p_indexed;
930 892ac3b6 2020-03-18 stsp int last_p_resolved;
931 68999b92 2020-03-18 stsp int verbosity;
933 04d9a9ec 2020-09-24 stsp struct got_repository *repo;
935 04d9a9ec 2020-09-24 stsp int create_configs;
936 04d9a9ec 2020-09-24 stsp int configs_created;
938 04d9a9ec 2020-09-24 stsp struct got_pathlist_head *symrefs;
939 04d9a9ec 2020-09-24 stsp struct got_pathlist_head *wanted_branches;
940 99495ddb 2021-01-10 stsp struct got_pathlist_head *wanted_refs;
941 04d9a9ec 2020-09-24 stsp const char *proto;
942 04d9a9ec 2020-09-24 stsp const char *host;
943 04d9a9ec 2020-09-24 stsp const char *port;
944 04d9a9ec 2020-09-24 stsp const char *remote_repo_path;
945 04d9a9ec 2020-09-24 stsp const char *git_url;
946 04d9a9ec 2020-09-24 stsp int fetch_all_branches;
947 04d9a9ec 2020-09-24 stsp int mirror_references;
948 04d9a9ec 2020-09-24 stsp } config_info;
951 04d9a9ec 2020-09-24 stsp /* XXX forward declaration */
952 93658fb9 2020-03-18 stsp static const struct got_error *
953 04d9a9ec 2020-09-24 stsp create_config_files(const char *proto, const char *host, const char *port,
954 04d9a9ec 2020-09-24 stsp const char *remote_repo_path, const char *git_url, int fetch_all_branches,
955 04d9a9ec 2020-09-24 stsp int mirror_references, struct got_pathlist_head *symrefs,
956 99495ddb 2021-01-10 stsp struct got_pathlist_head *wanted_branches,
957 99495ddb 2021-01-10 stsp struct got_pathlist_head *wanted_refs, struct got_repository *repo);
959 04d9a9ec 2020-09-24 stsp static const struct got_error *
960 baa9fea0 2020-03-18 stsp fetch_progress(void *arg, const char *message, off_t packfile_size,
961 668a20f6 2020-03-18 stsp int nobj_total, int nobj_indexed, int nobj_loose, int nobj_resolved)
963 04d9a9ec 2020-09-24 stsp const struct got_error *err = NULL;
964 892ac3b6 2020-03-18 stsp struct got_fetch_progress_arg *a = arg;
965 892ac3b6 2020-03-18 stsp char scaled_size[FMT_SCALED_STRSIZE];
966 892ac3b6 2020-03-18 stsp int p_indexed, p_resolved;
967 892ac3b6 2020-03-18 stsp int print_size = 0, print_indexed = 0, print_resolved = 0;
970 04d9a9ec 2020-09-24 stsp * In order to allow a failed clone to be resumed with 'got fetch'
971 04d9a9ec 2020-09-24 stsp * we try to create configuration files as soon as possible.
972 04d9a9ec 2020-09-24 stsp * Once the server has sent information about its default branch
973 04d9a9ec 2020-09-24 stsp * we have all required information.
975 04d9a9ec 2020-09-24 stsp if (a->create_configs && !a->configs_created &&
976 04d9a9ec 2020-09-24 stsp !TAILQ_EMPTY(a->config_info.symrefs)) {
977 04d9a9ec 2020-09-24 stsp err = create_config_files(a->config_info.proto,
978 62d463ca 2020-10-20 naddy a->config_info.host, a->config_info.port,
979 62d463ca 2020-10-20 naddy a->config_info.remote_repo_path,
980 62d463ca 2020-10-20 naddy a->config_info.git_url,
981 62d463ca 2020-10-20 naddy a->config_info.fetch_all_branches,
982 62d463ca 2020-10-20 naddy a->config_info.mirror_references,
983 62d463ca 2020-10-20 naddy a->config_info.symrefs,
984 99495ddb 2021-01-10 stsp a->config_info.wanted_branches,
985 99495ddb 2021-01-10 stsp a->config_info.wanted_refs, a->repo);
987 04d9a9ec 2020-09-24 stsp return err;
988 04d9a9ec 2020-09-24 stsp a->configs_created = 1;
991 68999b92 2020-03-18 stsp if (a->verbosity < 0)
992 68999b92 2020-03-18 stsp return NULL;
994 fd843b58 2020-03-18 stsp if (message && message[0] != '\0') {
995 d2cdc636 2020-03-18 stsp printf("\rserver: %s", message);
996 892ac3b6 2020-03-18 stsp fflush(stdout);
997 12d1281e 2020-03-19 stsp return NULL;
1000 b2409d58 2020-03-18 stsp if (packfile_size > 0 || nobj_indexed > 0) {
1001 892ac3b6 2020-03-18 stsp if (fmt_scaled(packfile_size, scaled_size) == 0 &&
1002 892ac3b6 2020-03-18 stsp (a->last_scaled_size[0] == '\0' ||
1003 892ac3b6 2020-03-18 stsp strcmp(scaled_size, a->last_scaled_size)) != 0) {
1004 892ac3b6 2020-03-18 stsp print_size = 1;
1005 892ac3b6 2020-03-18 stsp if (strlcpy(a->last_scaled_size, scaled_size,
1006 892ac3b6 2020-03-18 stsp FMT_SCALED_STRSIZE) >= FMT_SCALED_STRSIZE)
1007 892ac3b6 2020-03-18 stsp return got_error(GOT_ERR_NO_SPACE);
1009 61cc1a7a 2020-03-18 stsp if (nobj_indexed > 0) {
1010 892ac3b6 2020-03-18 stsp p_indexed = (nobj_indexed * 100) / nobj_total;
1011 892ac3b6 2020-03-18 stsp if (p_indexed != a->last_p_indexed) {
1012 892ac3b6 2020-03-18 stsp a->last_p_indexed = p_indexed;
1013 892ac3b6 2020-03-18 stsp print_indexed = 1;
1014 892ac3b6 2020-03-18 stsp print_size = 1;
1017 61cc1a7a 2020-03-18 stsp if (nobj_resolved > 0) {
1018 892ac3b6 2020-03-18 stsp p_resolved = (nobj_resolved * 100) /
1019 892ac3b6 2020-03-18 stsp (nobj_total - nobj_loose);
1020 892ac3b6 2020-03-18 stsp if (p_resolved != a->last_p_resolved) {
1021 892ac3b6 2020-03-18 stsp a->last_p_resolved = p_resolved;
1022 892ac3b6 2020-03-18 stsp print_resolved = 1;
1023 892ac3b6 2020-03-18 stsp print_indexed = 1;
1024 892ac3b6 2020-03-18 stsp print_size = 1;
1029 892ac3b6 2020-03-18 stsp if (print_size || print_indexed || print_resolved)
1030 892ac3b6 2020-03-18 stsp printf("\r");
1031 892ac3b6 2020-03-18 stsp if (print_size)
1032 892ac3b6 2020-03-18 stsp printf("%*s fetched", FMT_SCALED_STRSIZE, scaled_size);
1033 d715f13e 2020-03-19 stsp if (print_indexed)
1034 892ac3b6 2020-03-18 stsp printf("; indexing %d%%", p_indexed);
1035 d715f13e 2020-03-19 stsp if (print_resolved)
1036 892ac3b6 2020-03-18 stsp printf("; resolving deltas %d%%", p_resolved);
1037 892ac3b6 2020-03-18 stsp if (print_size || print_indexed || print_resolved)
1038 892ac3b6 2020-03-18 stsp fflush(stdout);
1040 531c3985 2020-03-18 stsp return NULL;
1043 531c3985 2020-03-18 stsp static const struct got_error *
1044 04d9a9ec 2020-09-24 stsp create_symref(const char *refname, struct got_reference *target_ref,
1045 04d9a9ec 2020-09-24 stsp int verbosity, struct got_repository *repo)
1047 4ba14133 2020-03-20 stsp const struct got_error *err;
1048 04d9a9ec 2020-09-24 stsp struct got_reference *head_symref;
1050 04d9a9ec 2020-09-24 stsp err = got_ref_alloc_symref(&head_symref, refname, target_ref);
1052 4ba14133 2020-03-20 stsp return err;
1054 04d9a9ec 2020-09-24 stsp err = got_ref_write(head_symref, repo);
1055 6338a6a1 2020-03-21 stsp if (err == NULL && verbosity > 0) {
1056 6338a6a1 2020-03-21 stsp printf("Created reference %s: %s\n", GOT_REF_HEAD,
1057 6338a6a1 2020-03-21 stsp got_ref_get_name(target_ref));
1059 04d9a9ec 2020-09-24 stsp got_ref_close(head_symref);
1060 4ba14133 2020-03-20 stsp return err;
1063 4ba14133 2020-03-20 stsp static const struct got_error *
1064 41b0de12 2020-03-21 stsp list_remote_refs(struct got_pathlist_head *symrefs,
1065 41b0de12 2020-03-21 stsp struct got_pathlist_head *refs)
1067 41b0de12 2020-03-21 stsp const struct got_error *err;
1068 41b0de12 2020-03-21 stsp struct got_pathlist_entry *pe;
1070 41b0de12 2020-03-21 stsp TAILQ_FOREACH(pe, symrefs, entry) {
1071 41b0de12 2020-03-21 stsp const char *refname = pe->path;
1072 41b0de12 2020-03-21 stsp const char *targetref = pe->data;
1074 41b0de12 2020-03-21 stsp printf("%s: %s\n", refname, targetref);
1077 41b0de12 2020-03-21 stsp TAILQ_FOREACH(pe, refs, entry) {
1078 41b0de12 2020-03-21 stsp const char *refname = pe->path;
1079 41b0de12 2020-03-21 stsp struct got_object_id *id = pe->data;
1080 41b0de12 2020-03-21 stsp char *id_str;
1082 41b0de12 2020-03-21 stsp err = got_object_id_str(&id_str, id);
1084 41b0de12 2020-03-21 stsp return err;
1085 41b0de12 2020-03-21 stsp printf("%s: %s\n", refname, id_str);
1086 41b0de12 2020-03-21 stsp free(id_str);
1089 41b0de12 2020-03-21 stsp return NULL;
1092 6338a6a1 2020-03-21 stsp static const struct got_error *
1093 6338a6a1 2020-03-21 stsp create_ref(const char *refname, struct got_object_id *id,
1094 6338a6a1 2020-03-21 stsp int verbosity, struct got_repository *repo)
1096 6338a6a1 2020-03-21 stsp const struct got_error *err = NULL;
1097 6338a6a1 2020-03-21 stsp struct got_reference *ref;
1098 6338a6a1 2020-03-21 stsp char *id_str;
1100 6338a6a1 2020-03-21 stsp err = got_object_id_str(&id_str, id);
1102 6338a6a1 2020-03-21 stsp return err;
1104 6338a6a1 2020-03-21 stsp err = got_ref_alloc(&ref, refname, id);
1106 6338a6a1 2020-03-21 stsp goto done;
1108 6338a6a1 2020-03-21 stsp err = got_ref_write(ref, repo);
1109 6338a6a1 2020-03-21 stsp got_ref_close(ref);
1111 6338a6a1 2020-03-21 stsp if (err == NULL && verbosity >= 0)
1112 6338a6a1 2020-03-21 stsp printf("Created reference %s: %s\n", refname, id_str);
1114 6338a6a1 2020-03-21 stsp free(id_str);
1115 6338a6a1 2020-03-21 stsp return err;
1118 0e4002ca 2020-03-21 stsp static int
1119 0e4002ca 2020-03-21 stsp match_wanted_ref(const char *refname, const char *wanted_ref)
1121 0e4002ca 2020-03-21 stsp if (strncmp(refname, "refs/", 5) != 0)
1123 0e4002ca 2020-03-21 stsp refname += 5;
1126 0e4002ca 2020-03-21 stsp * Prevent fetching of references that won't make any
1127 0e4002ca 2020-03-21 stsp * sense outside of the remote repository's context.
1129 0e4002ca 2020-03-21 stsp if (strncmp(refname, "got/", 4) == 0)
1131 0e4002ca 2020-03-21 stsp if (strncmp(refname, "remotes/", 8) == 0)
1134 0e4002ca 2020-03-21 stsp if (strncmp(wanted_ref, "refs/", 5) == 0)
1135 0e4002ca 2020-03-21 stsp wanted_ref += 5;
1137 0e4002ca 2020-03-21 stsp /* Allow prefix match. */
1138 0e4002ca 2020-03-21 stsp if (got_path_is_child(refname, wanted_ref, strlen(wanted_ref)))
1141 0e4002ca 2020-03-21 stsp /* Allow exact match. */
1142 0e4002ca 2020-03-21 stsp return (strcmp(refname, wanted_ref) == 0);
1145 0e4002ca 2020-03-21 stsp static int
1146 0e4002ca 2020-03-21 stsp is_wanted_ref(struct got_pathlist_head *wanted_refs, const char *refname)
1148 0e4002ca 2020-03-21 stsp struct got_pathlist_entry *pe;
1150 0e4002ca 2020-03-21 stsp TAILQ_FOREACH(pe, wanted_refs, entry) {
1151 0e4002ca 2020-03-21 stsp if (match_wanted_ref(refname, pe->path))
1158 41b0de12 2020-03-21 stsp static const struct got_error *
1159 0e4002ca 2020-03-21 stsp create_wanted_ref(const char *refname, struct got_object_id *id,
1160 0e4002ca 2020-03-21 stsp const char *remote_repo_name, int verbosity, struct got_repository *repo)
1162 0e4002ca 2020-03-21 stsp const struct got_error *err;
1163 0e4002ca 2020-03-21 stsp char *remote_refname;
1165 0e4002ca 2020-03-21 stsp if (strncmp("refs/", refname, 5) == 0)
1166 0e4002ca 2020-03-21 stsp refname += 5;
1168 0e4002ca 2020-03-21 stsp if (asprintf(&remote_refname, "refs/remotes/%s/%s",
1169 0e4002ca 2020-03-21 stsp remote_repo_name, refname) == -1)
1170 0e4002ca 2020-03-21 stsp return got_error_from_errno("asprintf");
1172 0e4002ca 2020-03-21 stsp err = create_ref(remote_refname, id, verbosity, repo);
1173 0e4002ca 2020-03-21 stsp free(remote_refname);
1174 7c0b7f42 2020-09-24 stsp return err;
1177 7c0b7f42 2020-09-24 stsp static const struct got_error *
1178 7c0b7f42 2020-09-24 stsp create_gotconfig(const char *proto, const char *host, const char *port,
1179 15d3c221 2021-01-05 stsp const char *remote_repo_path, const char *default_branch,
1180 0c8b29c5 2021-01-05 stsp int fetch_all_branches, struct got_pathlist_head *wanted_branches,
1181 99495ddb 2021-01-10 stsp struct got_pathlist_head *wanted_refs, int mirror_references,
1182 99495ddb 2021-01-10 stsp struct got_repository *repo)
1184 7c0b7f42 2020-09-24 stsp const struct got_error *err = NULL;
1185 7c0b7f42 2020-09-24 stsp char *gotconfig_path = NULL;
1186 7c0b7f42 2020-09-24 stsp char *gotconfig = NULL;
1187 7c0b7f42 2020-09-24 stsp FILE *gotconfig_file = NULL;
1188 15d3c221 2021-01-05 stsp const char *branchname = NULL;
1189 99495ddb 2021-01-10 stsp char *branches = NULL, *refs = NULL;
1190 7c0b7f42 2020-09-24 stsp ssize_t n;
1192 0c8b29c5 2021-01-05 stsp if (!fetch_all_branches && !TAILQ_EMPTY(wanted_branches)) {
1193 132af4a5 2021-01-05 stsp struct got_pathlist_entry *pe;
1194 132af4a5 2021-01-05 stsp TAILQ_FOREACH(pe, wanted_branches, entry) {
1196 132af4a5 2021-01-05 stsp branchname = pe->path;
1197 132af4a5 2021-01-05 stsp if (strncmp(branchname, "refs/heads/", 11) == 0)
1198 132af4a5 2021-01-05 stsp branchname += 11;
1199 132af4a5 2021-01-05 stsp if (asprintf(&s, "%s\"%s\" ",
1200 132af4a5 2021-01-05 stsp branches ? branches : "", branchname) == -1) {
1201 132af4a5 2021-01-05 stsp err = got_error_from_errno("asprintf");
1202 132af4a5 2021-01-05 stsp goto done;
1204 132af4a5 2021-01-05 stsp free(branches);
1205 132af4a5 2021-01-05 stsp branches = s;
1207 0c8b29c5 2021-01-05 stsp } else if (!fetch_all_branches && default_branch) {
1208 15d3c221 2021-01-05 stsp branchname = default_branch;
1209 15d3c221 2021-01-05 stsp if (strncmp(branchname, "refs/heads/", 11) == 0)
1210 15d3c221 2021-01-05 stsp branchname += 11;
1211 132af4a5 2021-01-05 stsp if (asprintf(&branches, "\"%s\" ", branchname) == -1) {
1212 132af4a5 2021-01-05 stsp err = got_error_from_errno("asprintf");
1213 132af4a5 2021-01-05 stsp goto done;
1216 99495ddb 2021-01-10 stsp if (!TAILQ_EMPTY(wanted_refs)) {
1217 99495ddb 2021-01-10 stsp struct got_pathlist_entry *pe;
1218 99495ddb 2021-01-10 stsp TAILQ_FOREACH(pe, wanted_refs, entry) {
1220 99495ddb 2021-01-10 stsp const char *refname = pe->path;
1221 99495ddb 2021-01-10 stsp if (strncmp(refname, "refs/", 5) == 0)
1222 99495ddb 2021-01-10 stsp branchname += 5;
1223 99495ddb 2021-01-10 stsp if (asprintf(&s, "%s\"%s\" ",
1224 99495ddb 2021-01-10 stsp refs ? refs : "", refname) == -1) {
1225 99495ddb 2021-01-10 stsp err = got_error_from_errno("asprintf");
1226 99495ddb 2021-01-10 stsp goto done;
1228 99495ddb 2021-01-10 stsp free(refs);
1233 7c0b7f42 2020-09-24 stsp /* Create got.conf(5). */
1234 7c0b7f42 2020-09-24 stsp gotconfig_path = got_repo_get_path_gotconfig(repo);
1235 7c0b7f42 2020-09-24 stsp if (gotconfig_path == NULL) {
1236 7c0b7f42 2020-09-24 stsp err = got_error_from_errno("got_repo_get_path_gotconfig");
1237 7c0b7f42 2020-09-24 stsp goto done;
1239 00fe21f2 2021-12-31 stsp gotconfig_file = fopen(gotconfig_path, "ae");
1240 7c0b7f42 2020-09-24 stsp if (gotconfig_file == NULL) {
1241 7c0b7f42 2020-09-24 stsp err = got_error_from_errno2("fopen", gotconfig_path);
1242 7c0b7f42 2020-09-24 stsp goto done;
1244 7c0b7f42 2020-09-24 stsp if (asprintf(&gotconfig,
1245 7c0b7f42 2020-09-24 stsp "remote \"%s\" {\n"
1246 7c0b7f42 2020-09-24 stsp "\tserver %s\n"
1247 7c0b7f42 2020-09-24 stsp "\tprotocol %s\n"
1249 7c0b7f42 2020-09-24 stsp "\trepository \"%s\"\n"
1255 7c0b7f42 2020-09-24 stsp GOT_FETCH_DEFAULT_REMOTE_NAME, host, proto,
1256 7c0b7f42 2020-09-24 stsp port ? "\tport " : "", port ? port : "", port ? "\n" : "",
1257 132af4a5 2021-01-05 stsp remote_repo_path, branches ? "\tbranch { " : "",
1258 132af4a5 2021-01-05 stsp branches ? branches : "", branches ? "}\n" : "",
1259 99495ddb 2021-01-10 stsp refs ? "\treference { " : "", refs ? refs : "", refs ? "}\n" : "",
1260 0c8b29c5 2021-01-05 stsp mirror_references ? "\tmirror-references yes\n" : "",
1261 0c8b29c5 2021-01-05 stsp fetch_all_branches ? "\tfetch-all-branches yes\n" : "") == -1) {
1262 7c0b7f42 2020-09-24 stsp err = got_error_from_errno("asprintf");
1263 7c0b7f42 2020-09-24 stsp goto done;
1265 7c0b7f42 2020-09-24 stsp n = fwrite(gotconfig, 1, strlen(gotconfig), gotconfig_file);
1266 7c0b7f42 2020-09-24 stsp if (n != strlen(gotconfig)) {
1267 7c0b7f42 2020-09-24 stsp err = got_ferror(gotconfig_file, GOT_ERR_IO);
1268 7c0b7f42 2020-09-24 stsp goto done;
1272 7c0b7f42 2020-09-24 stsp if (gotconfig_file && fclose(gotconfig_file) == EOF && err == NULL)
1273 7c0b7f42 2020-09-24 stsp err = got_error_from_errno2("fclose", gotconfig_path);
1274 7c0b7f42 2020-09-24 stsp free(gotconfig_path);
1275 132af4a5 2021-01-05 stsp free(branches);
1276 7c0b7f42 2020-09-24 stsp return err;
1279 7c0b7f42 2020-09-24 stsp static const struct got_error *
1280 04d9a9ec 2020-09-24 stsp create_gitconfig(const char *git_url, const char *default_branch,
1281 132af4a5 2021-01-05 stsp int fetch_all_branches, struct got_pathlist_head *wanted_branches,
1282 99495ddb 2021-01-10 stsp struct got_pathlist_head *wanted_refs, int mirror_references,
1283 99495ddb 2021-01-10 stsp struct got_repository *repo)
1285 7c0b7f42 2020-09-24 stsp const struct got_error *err = NULL;
1286 7c0b7f42 2020-09-24 stsp char *gitconfig_path = NULL;
1287 7c0b7f42 2020-09-24 stsp char *gitconfig = NULL;
1288 7c0b7f42 2020-09-24 stsp FILE *gitconfig_file = NULL;
1289 99495ddb 2021-01-10 stsp char *branches = NULL, *refs = NULL;
1290 56d0a753 2021-01-20 stsp const char *branchname;
1291 7c0b7f42 2020-09-24 stsp ssize_t n;
1293 7c0b7f42 2020-09-24 stsp /* Create a config file Git can understand. */
1294 7c0b7f42 2020-09-24 stsp gitconfig_path = got_repo_get_path_gitconfig(repo);
1295 7c0b7f42 2020-09-24 stsp if (gitconfig_path == NULL) {
1296 7c0b7f42 2020-09-24 stsp err = got_error_from_errno("got_repo_get_path_gitconfig");
1297 7c0b7f42 2020-09-24 stsp goto done;
1299 00fe21f2 2021-12-31 stsp gitconfig_file = fopen(gitconfig_path, "ae");
1300 7c0b7f42 2020-09-24 stsp if (gitconfig_file == NULL) {
1301 7c0b7f42 2020-09-24 stsp err = got_error_from_errno2("fopen", gitconfig_path);
1302 7c0b7f42 2020-09-24 stsp goto done;
1304 56d0a753 2021-01-20 stsp if (fetch_all_branches) {
1305 56d0a753 2021-01-20 stsp if (mirror_references) {
1306 56d0a753 2021-01-20 stsp if (asprintf(&branches,
1307 56d0a753 2021-01-20 stsp "\tfetch = refs/heads/*:refs/heads/*\n") == -1) {
1308 56d0a753 2021-01-20 stsp err = got_error_from_errno("asprintf");
1309 56d0a753 2021-01-20 stsp goto done;
1311 56d0a753 2021-01-20 stsp } else if (asprintf(&branches,
1312 56d0a753 2021-01-20 stsp "\tfetch = refs/heads/*:refs/remotes/%s/*\n",
1313 7c0b7f42 2020-09-24 stsp GOT_FETCH_DEFAULT_REMOTE_NAME) == -1) {
1314 7c0b7f42 2020-09-24 stsp err = got_error_from_errno("asprintf");
1315 7c0b7f42 2020-09-24 stsp goto done;
1317 132af4a5 2021-01-05 stsp } else if (!TAILQ_EMPTY(wanted_branches)) {
1318 132af4a5 2021-01-05 stsp struct got_pathlist_entry *pe;
1319 132af4a5 2021-01-05 stsp TAILQ_FOREACH(pe, wanted_branches, entry) {
1321 132af4a5 2021-01-05 stsp branchname = pe->path;
1322 132af4a5 2021-01-05 stsp if (strncmp(branchname, "refs/heads/", 11) == 0)
1323 132af4a5 2021-01-05 stsp branchname += 11;
1324 56d0a753 2021-01-20 stsp if (mirror_references) {
1325 56d0a753 2021-01-20 stsp if (asprintf(&s,
1326 56d0a753 2021-01-20 stsp "%s\tfetch = refs/heads/%s:refs/heads/%s\n",
1327 56d0a753 2021-01-20 stsp branches ? branches : "",
1328 56d0a753 2021-01-20 stsp branchname, branchname) == -1) {
1329 56d0a753 2021-01-20 stsp err = got_error_from_errno("asprintf");
1330 56d0a753 2021-01-20 stsp goto done;
1332 56d0a753 2021-01-20 stsp } else if (asprintf(&s,
1333 56d0a753 2021-01-20 stsp "%s\tfetch = refs/heads/%s:refs/remotes/%s/%s\n",
1334 132af4a5 2021-01-05 stsp branches ? branches : "",
1335 132af4a5 2021-01-05 stsp branchname, GOT_FETCH_DEFAULT_REMOTE_NAME,
1336 132af4a5 2021-01-05 stsp branchname) == -1) {
1337 132af4a5 2021-01-05 stsp err = got_error_from_errno("asprintf");
1338 132af4a5 2021-01-05 stsp goto done;
1340 132af4a5 2021-01-05 stsp free(branches);
1341 132af4a5 2021-01-05 stsp branches = s;
1345 7c0b7f42 2020-09-24 stsp * If the server specified a default branch, use just that one.
1346 7c0b7f42 2020-09-24 stsp * Otherwise fall back to fetching all branches on next fetch.
1348 04d9a9ec 2020-09-24 stsp if (default_branch) {
1349 04d9a9ec 2020-09-24 stsp branchname = default_branch;
1350 7c0b7f42 2020-09-24 stsp if (strncmp(branchname, "refs/heads/", 11) == 0)
1351 7c0b7f42 2020-09-24 stsp branchname += 11;
1353 7c0b7f42 2020-09-24 stsp branchname = "*"; /* fall back to all branches */
1354 56d0a753 2021-01-20 stsp if (mirror_references) {
1355 56d0a753 2021-01-20 stsp if (asprintf(&branches,
1356 56d0a753 2021-01-20 stsp "\tfetch = refs/heads/%s:refs/heads/%s\n",
1357 56d0a753 2021-01-20 stsp branchname, branchname) == -1) {
1358 56d0a753 2021-01-20 stsp err = got_error_from_errno("asprintf");
1359 56d0a753 2021-01-20 stsp goto done;
1361 56d0a753 2021-01-20 stsp } else if (asprintf(&branches,
1362 56d0a753 2021-01-20 stsp "\tfetch = refs/heads/%s:refs/remotes/%s/%s\n",
1363 7c0b7f42 2020-09-24 stsp branchname, GOT_FETCH_DEFAULT_REMOTE_NAME,
1364 7c0b7f42 2020-09-24 stsp branchname) == -1) {
1365 7c0b7f42 2020-09-24 stsp err = got_error_from_errno("asprintf");
1366 7c0b7f42 2020-09-24 stsp goto done;
1369 56d0a753 2021-01-20 stsp if (!TAILQ_EMPTY(wanted_refs)) {
1370 99495ddb 2021-01-10 stsp struct got_pathlist_entry *pe;
1371 99495ddb 2021-01-10 stsp TAILQ_FOREACH(pe, wanted_refs, entry) {
1373 99495ddb 2021-01-10 stsp const char *refname = pe->path;
1374 99495ddb 2021-01-10 stsp if (strncmp(refname, "refs/", 5) == 0)
1375 99495ddb 2021-01-10 stsp refname += 5;
1376 56d0a753 2021-01-20 stsp if (mirror_references) {
1377 56d0a753 2021-01-20 stsp if (asprintf(&s,
1378 56d0a753 2021-01-20 stsp "%s\tfetch = refs/%s:refs/%s\n",
1379 56d0a753 2021-01-20 stsp refs ? refs : "", refname, refname) == -1) {
1380 56d0a753 2021-01-20 stsp err = got_error_from_errno("asprintf");
1381 56d0a753 2021-01-20 stsp goto done;
1383 56d0a753 2021-01-20 stsp } else if (asprintf(&s,
1384 56d0a753 2021-01-20 stsp "%s\tfetch = refs/%s:refs/remotes/%s/%s\n",
1385 99495ddb 2021-01-10 stsp refs ? refs : "",
1386 99495ddb 2021-01-10 stsp refname, GOT_FETCH_DEFAULT_REMOTE_NAME,
1387 99495ddb 2021-01-10 stsp refname) == -1) {
1388 99495ddb 2021-01-10 stsp err = got_error_from_errno("asprintf");
1389 99495ddb 2021-01-10 stsp goto done;
1391 99495ddb 2021-01-10 stsp free(refs);
1396 132af4a5 2021-01-05 stsp if (asprintf(&gitconfig,
1397 132af4a5 2021-01-05 stsp "[remote \"%s\"]\n"
1398 132af4a5 2021-01-05 stsp "\turl = %s\n"
1401 56d0a753 2021-01-20 stsp "\tfetch = refs/tags/*:refs/tags/*\n",
1402 132af4a5 2021-01-05 stsp GOT_FETCH_DEFAULT_REMOTE_NAME, git_url, branches ? branches : "",
1403 56d0a753 2021-01-20 stsp refs ? refs : "") == -1) {
1404 132af4a5 2021-01-05 stsp err = got_error_from_errno("asprintf");
1405 132af4a5 2021-01-05 stsp goto done;
1407 7c0b7f42 2020-09-24 stsp n = fwrite(gitconfig, 1, strlen(gitconfig), gitconfig_file);
1408 7c0b7f42 2020-09-24 stsp if (n != strlen(gitconfig)) {
1409 7c0b7f42 2020-09-24 stsp err = got_ferror(gitconfig_file, GOT_ERR_IO);
1410 7c0b7f42 2020-09-24 stsp goto done;
1413 7c0b7f42 2020-09-24 stsp if (gitconfig_file && fclose(gitconfig_file) == EOF && err == NULL)
1414 7c0b7f42 2020-09-24 stsp err = got_error_from_errno2("fclose", gitconfig_path);
1415 7c0b7f42 2020-09-24 stsp free(gitconfig_path);
1416 132af4a5 2021-01-05 stsp free(branches);
1417 0e4002ca 2020-03-21 stsp return err;
1420 0e4002ca 2020-03-21 stsp static const struct got_error *
1421 04d9a9ec 2020-09-24 stsp create_config_files(const char *proto, const char *host, const char *port,
1422 04d9a9ec 2020-09-24 stsp const char *remote_repo_path, const char *git_url, int fetch_all_branches,
1423 04d9a9ec 2020-09-24 stsp int mirror_references, struct got_pathlist_head *symrefs,
1424 99495ddb 2021-01-10 stsp struct got_pathlist_head *wanted_branches,
1425 99495ddb 2021-01-10 stsp struct got_pathlist_head *wanted_refs, struct got_repository *repo)
1427 04d9a9ec 2020-09-24 stsp const struct got_error *err = NULL;
1428 04d9a9ec 2020-09-24 stsp const char *default_branch = NULL;
1429 04d9a9ec 2020-09-24 stsp struct got_pathlist_entry *pe;
1432 04d9a9ec 2020-09-24 stsp * If we asked for a set of wanted branches then use the first
1433 04d9a9ec 2020-09-24 stsp * one of those.
1435 62d463ca 2020-10-20 naddy if (!TAILQ_EMPTY(wanted_branches)) {
1436 04d9a9ec 2020-09-24 stsp pe = TAILQ_FIRST(wanted_branches);
1437 04d9a9ec 2020-09-24 stsp default_branch = pe->path;
1439 04d9a9ec 2020-09-24 stsp /* First HEAD ref listed by server is the default branch. */
1440 04d9a9ec 2020-09-24 stsp TAILQ_FOREACH(pe, symrefs, entry) {
1441 04d9a9ec 2020-09-24 stsp const char *refname = pe->path;
1442 04d9a9ec 2020-09-24 stsp const char *target = pe->data;
1444 04d9a9ec 2020-09-24 stsp if (strcmp(refname, GOT_REF_HEAD) != 0)
1447 04d9a9ec 2020-09-24 stsp default_branch = target;
1452 04d9a9ec 2020-09-24 stsp /* Create got.conf(5). */
1453 04d9a9ec 2020-09-24 stsp err = create_gotconfig(proto, host, port, remote_repo_path,
1454 0c8b29c5 2021-01-05 stsp default_branch, fetch_all_branches, wanted_branches,
1455 99495ddb 2021-01-10 stsp wanted_refs, mirror_references, repo);
1457 04d9a9ec 2020-09-24 stsp return err;
1459 04d9a9ec 2020-09-24 stsp /* Create a config file Git can understand. */
1460 04d9a9ec 2020-09-24 stsp return create_gitconfig(git_url, default_branch, fetch_all_branches,
1461 99495ddb 2021-01-10 stsp wanted_branches, wanted_refs, mirror_references, repo);
1464 04d9a9ec 2020-09-24 stsp static const struct got_error *
1465 93658fb9 2020-03-18 stsp cmd_clone(int argc, char *argv[])
1467 39c64a6a 2020-03-18 stsp const struct got_error *error = NULL;
1468 9df6f38b 2020-03-18 stsp const char *uri, *dirname;
1469 09838ffc 2020-03-18 stsp char *proto, *host, *port, *repo_name, *server_path;
1470 d9b4d0c0 2020-03-18 stsp char *default_destdir = NULL, *id_str = NULL;
1471 a9c2d4c2 2020-09-24 stsp const char *repo_path;
1472 bb64b798 2020-03-18 stsp struct got_repository *repo = NULL;
1473 0e4002ca 2020-03-21 stsp struct got_pathlist_head refs, symrefs, wanted_branches, wanted_refs;
1474 d9b4d0c0 2020-03-18 stsp struct got_pathlist_entry *pe;
1475 d9b4d0c0 2020-03-18 stsp struct got_object_id *pack_hash = NULL;
1476 9c52365f 2020-03-21 stsp int ch, fetchfd = -1, fetchstatus;
1477 9c52365f 2020-03-21 stsp pid_t fetchpid = -1;
1478 892ac3b6 2020-03-18 stsp struct got_fetch_progress_arg fpa;
1479 b46f3e71 2020-03-18 stsp char *git_url = NULL;
1480 659e7fbd 2020-03-20 stsp int verbosity = 0, fetch_all_branches = 0, mirror_references = 0;
1481 41b0de12 2020-03-21 stsp int list_refs_only = 0;
1483 d9b4d0c0 2020-03-18 stsp TAILQ_INIT(&refs);
1484 d9b4d0c0 2020-03-18 stsp TAILQ_INIT(&symrefs);
1485 4ba14133 2020-03-20 stsp TAILQ_INIT(&wanted_branches);
1486 0e4002ca 2020-03-21 stsp TAILQ_INIT(&wanted_refs);
1488 0e4002ca 2020-03-21 stsp while ((ch = getopt(argc, argv, "ab:lmvqR:")) != -1) {
1489 93658fb9 2020-03-18 stsp switch (ch) {
1491 659e7fbd 2020-03-20 stsp fetch_all_branches = 1;
1494 4ba14133 2020-03-20 stsp error = got_pathlist_append(&wanted_branches,
1495 4ba14133 2020-03-20 stsp optarg, NULL);
1496 4ba14133 2020-03-20 stsp if (error)
1497 4ba14133 2020-03-20 stsp return error;
1500 41b0de12 2020-03-21 stsp list_refs_only = 1;
1503 469dd726 2020-03-20 stsp mirror_references = 1;
1506 68999b92 2020-03-18 stsp if (verbosity < 0)
1507 68999b92 2020-03-18 stsp verbosity = 0;
1508 68999b92 2020-03-18 stsp else if (verbosity < 3)
1509 68999b92 2020-03-18 stsp verbosity++;
1512 68999b92 2020-03-18 stsp verbosity = -1;
1515 0e4002ca 2020-03-21 stsp error = got_pathlist_append(&wanted_refs,
1516 0e4002ca 2020-03-21 stsp optarg, NULL);
1517 0e4002ca 2020-03-21 stsp if (error)
1518 0e4002ca 2020-03-21 stsp return error;
1521 93658fb9 2020-03-18 stsp usage_clone();
1525 93658fb9 2020-03-18 stsp argc -= optind;
1526 93658fb9 2020-03-18 stsp argv += optind;
1528 4ba14133 2020-03-20 stsp if (fetch_all_branches && !TAILQ_EMPTY(&wanted_branches))
1529 ff69268e 2020-12-13 stsp option_conflict('a', 'b');
1530 41b0de12 2020-03-21 stsp if (list_refs_only) {
1531 41b0de12 2020-03-21 stsp if (!TAILQ_EMPTY(&wanted_branches))
1532 ff69268e 2020-12-13 stsp option_conflict('l', 'b');
1533 41b0de12 2020-03-21 stsp if (fetch_all_branches)
1534 ff69268e 2020-12-13 stsp option_conflict('l', 'a');
1535 41b0de12 2020-03-21 stsp if (mirror_references)
1536 ff69268e 2020-12-13 stsp option_conflict('l', 'm');
1537 0e4002ca 2020-03-21 stsp if (!TAILQ_EMPTY(&wanted_refs))
1538 ff69268e 2020-12-13 stsp option_conflict('l', 'R');
1541 93658fb9 2020-03-18 stsp uri = argv[0];
1543 9df6f38b 2020-03-18 stsp if (argc == 1)
1544 93658fb9 2020-03-18 stsp dirname = NULL;
1545 9df6f38b 2020-03-18 stsp else if (argc == 2)
1546 93658fb9 2020-03-18 stsp dirname = argv[1];
1548 93658fb9 2020-03-18 stsp usage_clone();
1550 5e5da8c4 2021-09-05 stsp error = got_dial_parse_uri(&proto, &host, &port, &server_path,
1551 4dbec0a8 2020-08-27 stsp &repo_name, uri);
1552 39c64a6a 2020-03-18 stsp if (error)
1553 09f63084 2020-03-20 stsp goto done;
1555 09f63084 2020-03-20 stsp if (asprintf(&git_url, "%s://%s%s%s%s%s", proto,
1556 09f63084 2020-03-20 stsp host, port ? ":" : "", port ? port : "",
1557 09f63084 2020-03-20 stsp server_path[0] != '/' ? "/" : "", server_path) == -1) {
1558 09f63084 2020-03-20 stsp error = got_error_from_errno("asprintf");
1559 09838ffc 2020-03-18 stsp goto done;
1562 39c64a6a 2020-03-18 stsp if (strcmp(proto, "git") == 0) {
1563 b46f3e71 2020-03-18 stsp #ifndef PROFILE
1564 39c64a6a 2020-03-18 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec "
1565 39c64a6a 2020-03-18 stsp "sendfd dns inet unveil", NULL) == -1)
1566 39c64a6a 2020-03-18 stsp err(1, "pledge");
1568 39c64a6a 2020-03-18 stsp } else if (strcmp(proto, "git+ssh") == 0 ||
1569 39c64a6a 2020-03-18 stsp strcmp(proto, "ssh") == 0) {
1570 b46f3e71 2020-03-18 stsp #ifndef PROFILE
1571 39c64a6a 2020-03-18 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec "
1572 39c64a6a 2020-03-18 stsp "sendfd unveil", NULL) == -1)
1573 39c64a6a 2020-03-18 stsp err(1, "pledge");
1575 39c64a6a 2020-03-18 stsp } else if (strcmp(proto, "http") == 0 ||
1576 39c64a6a 2020-03-18 stsp strcmp(proto, "git+http") == 0) {
1577 39c64a6a 2020-03-18 stsp error = got_error_path(proto, GOT_ERR_NOT_IMPL);
1578 39c64a6a 2020-03-18 stsp goto done;
1580 39c64a6a 2020-03-18 stsp error = got_error_path(proto, GOT_ERR_BAD_PROTO);
1581 39c64a6a 2020-03-18 stsp goto done;
1583 bb64b798 2020-03-18 stsp if (dirname == NULL) {
1584 bb64b798 2020-03-18 stsp if (asprintf(&default_destdir, "%s.git", repo_name) == -1) {
1585 39c64a6a 2020-03-18 stsp error = got_error_from_errno("asprintf");
1586 bb64b798 2020-03-18 stsp goto done;
1588 bb64b798 2020-03-18 stsp repo_path = default_destdir;
1590 bb64b798 2020-03-18 stsp repo_path = dirname;
1592 41b0de12 2020-03-21 stsp if (!list_refs_only) {
1593 41b0de12 2020-03-21 stsp error = got_path_mkdir(repo_path);
1594 2751fe64 2020-09-24 stsp if (error &&
1595 2751fe64 2020-09-24 stsp (!(error->code == GOT_ERR_ERRNO && errno == EISDIR) &&
1596 2751fe64 2020-09-24 stsp !(error->code == GOT_ERR_ERRNO && errno == EEXIST)))
1597 41b0de12 2020-03-21 stsp goto done;
1598 2751fe64 2020-09-24 stsp if (!got_path_dir_is_empty(repo_path)) {
1599 2751fe64 2020-09-24 stsp error = got_error_path(repo_path,
1600 2751fe64 2020-09-24 stsp GOT_ERR_DIR_NOT_EMPTY);
1601 41b0de12 2020-03-21 stsp goto done;
1605 d65a88a2 2021-09-05 stsp error = got_dial_apply_unveil(proto);
1606 d65a88a2 2021-09-05 stsp if (error)
1607 d65a88a2 2021-09-05 stsp goto done;
1609 f535bcd4 2020-09-30 stsp error = apply_unveil(repo_path, 0, NULL);
1610 ee448f5f 2020-03-18 stsp if (error)
1611 ee448f5f 2020-03-18 stsp goto done;
1613 f79e6490 2020-04-19 stsp if (verbosity >= 0)
1614 f79e6490 2020-04-19 stsp printf("Connecting to %s%s%s\n", host,
1615 f79e6490 2020-04-19 stsp port ? ":" : "", port ? port : "");
1617 9c52365f 2020-03-21 stsp error = got_fetch_connect(&fetchpid, &fetchfd, proto, host, port,
1618 9c52365f 2020-03-21 stsp server_path, verbosity);
1619 39c64a6a 2020-03-18 stsp if (error)
1620 bb64b798 2020-03-18 stsp goto done;
1622 2751fe64 2020-09-24 stsp if (!list_refs_only) {
1623 2751fe64 2020-09-24 stsp error = got_repo_init(repo_path);
1624 2751fe64 2020-09-24 stsp if (error)
1625 2751fe64 2020-09-24 stsp goto done;
1626 2751fe64 2020-09-24 stsp error = got_repo_open(&repo, repo_path, NULL);
1627 2751fe64 2020-09-24 stsp if (error)
1628 2751fe64 2020-09-24 stsp goto done;
1631 892ac3b6 2020-03-18 stsp fpa.last_scaled_size[0] = '\0';
1632 892ac3b6 2020-03-18 stsp fpa.last_p_indexed = -1;
1633 892ac3b6 2020-03-18 stsp fpa.last_p_resolved = -1;
1634 68999b92 2020-03-18 stsp fpa.verbosity = verbosity;
1635 04d9a9ec 2020-09-24 stsp fpa.create_configs = 1;
1636 04d9a9ec 2020-09-24 stsp fpa.configs_created = 0;
1637 04d9a9ec 2020-09-24 stsp fpa.repo = repo;
1638 04d9a9ec 2020-09-24 stsp fpa.config_info.symrefs = &symrefs;
1639 04d9a9ec 2020-09-24 stsp fpa.config_info.wanted_branches = &wanted_branches;
1640 99495ddb 2021-01-10 stsp fpa.config_info.wanted_refs = &wanted_refs;
1641 04d9a9ec 2020-09-24 stsp fpa.config_info.proto = proto;
1642 04d9a9ec 2020-09-24 stsp fpa.config_info.host = host;
1643 04d9a9ec 2020-09-24 stsp fpa.config_info.port = port;
1644 04d9a9ec 2020-09-24 stsp fpa.config_info.remote_repo_path = server_path;
1645 04d9a9ec 2020-09-24 stsp fpa.config_info.git_url = git_url;
1646 04d9a9ec 2020-09-24 stsp fpa.config_info.fetch_all_branches = fetch_all_branches;
1647 04d9a9ec 2020-09-24 stsp fpa.config_info.mirror_references = mirror_references;
1648 7848a0e1 2020-03-19 stsp error = got_fetch_pack(&pack_hash, &refs, &symrefs,
1649 469dd726 2020-03-20 stsp GOT_FETCH_DEFAULT_REMOTE_NAME, mirror_references,
1650 0e4002ca 2020-03-21 stsp fetch_all_branches, &wanted_branches, &wanted_refs,
1651 0e4002ca 2020-03-21 stsp list_refs_only, verbosity, fetchfd, repo,
1652 0e4002ca 2020-03-21 stsp fetch_progress, &fpa);
1653 39c64a6a 2020-03-18 stsp if (error)
1654 d9b4d0c0 2020-03-18 stsp goto done;
1656 41b0de12 2020-03-21 stsp if (list_refs_only) {
1657 41b0de12 2020-03-21 stsp error = list_remote_refs(&symrefs, &refs);
1658 41b0de12 2020-03-21 stsp goto done;
1661 8a4f8535 2021-12-27 stsp if (pack_hash == NULL) {
1662 8a4f8535 2021-12-27 stsp error = got_error_fmt(GOT_ERR_FETCH_FAILED, "%s",
1663 8a4f8535 2021-12-27 stsp "server sent an empty pack file");
1664 8a4f8535 2021-12-27 stsp goto done;
1666 39c64a6a 2020-03-18 stsp error = got_object_id_str(&id_str, pack_hash);
1667 39c64a6a 2020-03-18 stsp if (error)
1668 d9b4d0c0 2020-03-18 stsp goto done;
1669 68999b92 2020-03-18 stsp if (verbosity >= 0)
1670 e69674d8 2020-03-19 stsp printf("\nFetched %s.pack\n", id_str);
1671 d9b4d0c0 2020-03-18 stsp free(id_str);
1673 d9b4d0c0 2020-03-18 stsp /* Set up references provided with the pack file. */
1674 d9b4d0c0 2020-03-18 stsp TAILQ_FOREACH(pe, &refs, entry) {
1675 d9b4d0c0 2020-03-18 stsp const char *refname = pe->path;
1676 d9b4d0c0 2020-03-18 stsp struct got_object_id *id = pe->data;
1677 7ebc0570 2020-03-18 stsp char *remote_refname;
1679 0e4002ca 2020-03-21 stsp if (is_wanted_ref(&wanted_refs, refname) &&
1680 0e4002ca 2020-03-21 stsp !mirror_references) {
1681 0e4002ca 2020-03-21 stsp error = create_wanted_ref(refname, id,
1682 0e4002ca 2020-03-21 stsp GOT_FETCH_DEFAULT_REMOTE_NAME,
1683 0e4002ca 2020-03-21 stsp verbosity - 1, repo);
1684 0e4002ca 2020-03-21 stsp if (error)
1685 0e4002ca 2020-03-21 stsp goto done;
1689 6338a6a1 2020-03-21 stsp error = create_ref(refname, id, verbosity - 1, repo);
1690 39c64a6a 2020-03-18 stsp if (error)
1691 d9b4d0c0 2020-03-18 stsp goto done;
1693 469dd726 2020-03-20 stsp if (mirror_references)
1696 7ebc0570 2020-03-18 stsp if (strncmp("refs/heads/", refname, 11) != 0)
1699 7ebc0570 2020-03-18 stsp if (asprintf(&remote_refname,
1700 7ebc0570 2020-03-18 stsp "refs/remotes/%s/%s", GOT_FETCH_DEFAULT_REMOTE_NAME,
1701 7ebc0570 2020-03-18 stsp refname + 11) == -1) {
1702 7ebc0570 2020-03-18 stsp error = got_error_from_errno("asprintf");
1703 7ebc0570 2020-03-18 stsp goto done;
1705 6338a6a1 2020-03-21 stsp error = create_ref(remote_refname, id, verbosity - 1, repo);
1706 f298ae0f 2020-03-25 stsp free(remote_refname);
1707 39c64a6a 2020-03-18 stsp if (error)
1708 d9b4d0c0 2020-03-18 stsp goto done;
1711 d9b4d0c0 2020-03-18 stsp /* Set the HEAD reference if the server provided one. */
1712 d9b4d0c0 2020-03-18 stsp TAILQ_FOREACH(pe, &symrefs, entry) {
1713 659e7fbd 2020-03-20 stsp struct got_reference *target_ref;
1714 d9b4d0c0 2020-03-18 stsp const char *refname = pe->path;
1715 d9b4d0c0 2020-03-18 stsp const char *target = pe->data;
1716 f298ae0f 2020-03-25 stsp char *remote_refname = NULL, *remote_target = NULL;
1718 d9b4d0c0 2020-03-18 stsp if (strcmp(refname, GOT_REF_HEAD) != 0)
1721 39c64a6a 2020-03-18 stsp error = got_ref_open(&target_ref, repo, target, 0);
1722 39c64a6a 2020-03-18 stsp if (error) {
1723 55330abe 2020-03-20 stsp if (error->code == GOT_ERR_NOT_REF) {
1724 55330abe 2020-03-20 stsp error = NULL;
1727 d9b4d0c0 2020-03-18 stsp goto done;
1730 04d9a9ec 2020-09-24 stsp error = create_symref(refname, target_ref, verbosity, repo);
1731 f298ae0f 2020-03-25 stsp got_ref_close(target_ref);
1732 f298ae0f 2020-03-25 stsp if (error)
1733 f298ae0f 2020-03-25 stsp goto done;
1735 f298ae0f 2020-03-25 stsp if (mirror_references)
1738 f298ae0f 2020-03-25 stsp if (strncmp("refs/heads/", target, 11) != 0)
1741 f298ae0f 2020-03-25 stsp if (asprintf(&remote_refname,
1742 f298ae0f 2020-03-25 stsp "refs/remotes/%s/%s", GOT_FETCH_DEFAULT_REMOTE_NAME,
1743 f298ae0f 2020-03-25 stsp refname) == -1) {
1744 f298ae0f 2020-03-25 stsp error = got_error_from_errno("asprintf");
1745 f298ae0f 2020-03-25 stsp goto done;
1747 f298ae0f 2020-03-25 stsp if (asprintf(&remote_target,
1748 f298ae0f 2020-03-25 stsp "refs/remotes/%s/%s", GOT_FETCH_DEFAULT_REMOTE_NAME,
1749 f298ae0f 2020-03-25 stsp target + 11) == -1) {
1750 f298ae0f 2020-03-25 stsp error = got_error_from_errno("asprintf");
1751 f298ae0f 2020-03-25 stsp free(remote_refname);
1752 f298ae0f 2020-03-25 stsp goto done;
1754 f298ae0f 2020-03-25 stsp error = got_ref_open(&target_ref, repo, remote_target, 0);
1755 f298ae0f 2020-03-25 stsp if (error) {
1756 f298ae0f 2020-03-25 stsp free(remote_refname);
1757 f298ae0f 2020-03-25 stsp free(remote_target);
1758 f298ae0f 2020-03-25 stsp if (error->code == GOT_ERR_NOT_REF) {
1759 f298ae0f 2020-03-25 stsp error = NULL;
1762 f298ae0f 2020-03-25 stsp goto done;
1764 04d9a9ec 2020-09-24 stsp error = create_symref(remote_refname, target_ref,
1765 04d9a9ec 2020-09-24 stsp verbosity - 1, repo);
1766 f298ae0f 2020-03-25 stsp free(remote_refname);
1767 f298ae0f 2020-03-25 stsp free(remote_target);
1768 d9b4d0c0 2020-03-18 stsp got_ref_close(target_ref);
1769 39c64a6a 2020-03-18 stsp if (error)
1770 d9b4d0c0 2020-03-18 stsp goto done;
1772 4ba14133 2020-03-20 stsp if (pe == NULL) {
1774 4ba14133 2020-03-20 stsp * We failed to set the HEAD reference. If we asked for
1775 4ba14133 2020-03-20 stsp * a set of wanted branches use the first of one of those
1776 4ba14133 2020-03-20 stsp * which could be fetched instead.
1778 62d463ca 2020-10-20 naddy TAILQ_FOREACH(pe, &wanted_branches, entry) {
1779 4ba14133 2020-03-20 stsp const char *target = pe->path;
1780 4ba14133 2020-03-20 stsp struct got_reference *target_ref;
1782 4ba14133 2020-03-20 stsp error = got_ref_open(&target_ref, repo, target, 0);
1783 4ba14133 2020-03-20 stsp if (error) {
1784 4ba14133 2020-03-20 stsp if (error->code == GOT_ERR_NOT_REF) {
1785 4ba14133 2020-03-20 stsp error = NULL;
1788 4ba14133 2020-03-20 stsp goto done;
1791 04d9a9ec 2020-09-24 stsp error = create_symref(GOT_REF_HEAD, target_ref,
1792 04d9a9ec 2020-09-24 stsp verbosity, repo);
1793 4ba14133 2020-03-20 stsp got_ref_close(target_ref);
1794 4ba14133 2020-03-20 stsp if (error)
1795 4ba14133 2020-03-20 stsp goto done;
1800 d715f13e 2020-03-19 stsp if (verbosity >= 0)
1801 469dd726 2020-03-20 stsp printf("Created %s repository '%s'\n",
1802 469dd726 2020-03-20 stsp mirror_references ? "mirrored" : "cloned", repo_path);
1804 9c52365f 2020-03-21 stsp if (fetchpid > 0) {
1805 9c52365f 2020-03-21 stsp if (kill(fetchpid, SIGTERM) == -1)
1806 9c52365f 2020-03-21 stsp error = got_error_from_errno("kill");
1807 9c52365f 2020-03-21 stsp if (waitpid(fetchpid, &fetchstatus, 0) == -1 && error == NULL)
1808 9c52365f 2020-03-21 stsp error = got_error_from_errno("waitpid");
1810 39c64a6a 2020-03-18 stsp if (fetchfd != -1 && close(fetchfd) == -1 && error == NULL)
1811 39c64a6a 2020-03-18 stsp error = got_error_from_errno("close");
1812 1d0f4054 2021-06-17 stsp if (repo) {
1813 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
1814 1d0f4054 2021-06-17 stsp if (error == NULL)
1815 1d0f4054 2021-06-17 stsp error = close_err;
1817 d9b4d0c0 2020-03-18 stsp TAILQ_FOREACH(pe, &refs, entry) {
1818 d9b4d0c0 2020-03-18 stsp free((void *)pe->path);
1819 d9b4d0c0 2020-03-18 stsp free(pe->data);
1821 d9b4d0c0 2020-03-18 stsp got_pathlist_free(&refs);
1822 d9b4d0c0 2020-03-18 stsp TAILQ_FOREACH(pe, &symrefs, entry) {
1823 d9b4d0c0 2020-03-18 stsp free((void *)pe->path);
1824 d9b4d0c0 2020-03-18 stsp free(pe->data);
1826 d9b4d0c0 2020-03-18 stsp got_pathlist_free(&symrefs);
1827 4ba14133 2020-03-20 stsp got_pathlist_free(&wanted_branches);
1828 0e4002ca 2020-03-21 stsp got_pathlist_free(&wanted_refs);
1829 d9b4d0c0 2020-03-18 stsp free(pack_hash);
1830 09838ffc 2020-03-18 stsp free(proto);
1831 09838ffc 2020-03-18 stsp free(host);
1832 09838ffc 2020-03-18 stsp free(port);
1833 09838ffc 2020-03-18 stsp free(server_path);
1834 09838ffc 2020-03-18 stsp free(repo_name);
1835 bb64b798 2020-03-18 stsp free(default_destdir);
1836 b46f3e71 2020-03-18 stsp free(git_url);
1837 39c64a6a 2020-03-18 stsp return error;
1840 7848a0e1 2020-03-19 stsp static const struct got_error *
1841 7848a0e1 2020-03-19 stsp update_ref(struct got_reference *ref, struct got_object_id *new_id,
1842 db6d8ad8 2020-03-21 stsp int replace_tags, int verbosity, struct got_repository *repo)
1844 7848a0e1 2020-03-19 stsp const struct got_error *err = NULL;
1845 7848a0e1 2020-03-19 stsp char *new_id_str = NULL;
1846 7848a0e1 2020-03-19 stsp struct got_object_id *old_id = NULL;
1848 7848a0e1 2020-03-19 stsp err = got_object_id_str(&new_id_str, new_id);
1850 7848a0e1 2020-03-19 stsp goto done;
1852 db6d8ad8 2020-03-21 stsp if (!replace_tags &&
1853 db6d8ad8 2020-03-21 stsp strncmp(got_ref_get_name(ref), "refs/tags/", 10) == 0) {
1854 88609724 2020-03-21 stsp err = got_ref_resolve(&old_id, repo, ref);
1856 88609724 2020-03-21 stsp goto done;
1857 88609724 2020-03-21 stsp if (got_object_id_cmp(old_id, new_id) == 0)
1858 88609724 2020-03-21 stsp goto done;
1859 db6d8ad8 2020-03-21 stsp if (verbosity >= 0) {
1860 db6d8ad8 2020-03-21 stsp printf("Rejecting update of existing tag %s: %s\n",
1861 db6d8ad8 2020-03-21 stsp got_ref_get_name(ref), new_id_str);
1863 db6d8ad8 2020-03-21 stsp goto done;
1866 7848a0e1 2020-03-19 stsp if (got_ref_is_symbolic(ref)) {
1867 688f11b3 2020-03-21 stsp if (verbosity >= 0) {
1868 e8a967e0 2020-03-21 stsp printf("Replacing reference %s: %s\n",
1869 6338a6a1 2020-03-21 stsp got_ref_get_name(ref),
1870 6338a6a1 2020-03-21 stsp got_ref_get_symref_target(ref));
1872 e8a967e0 2020-03-21 stsp err = got_ref_change_symref_to_ref(ref, new_id);
1874 7848a0e1 2020-03-19 stsp goto done;
1875 e8a967e0 2020-03-21 stsp err = got_ref_write(ref, repo);
1877 e8a967e0 2020-03-21 stsp goto done;
1879 7848a0e1 2020-03-19 stsp err = got_ref_resolve(&old_id, repo, ref);
1881 7848a0e1 2020-03-19 stsp goto done;
1882 6338a6a1 2020-03-21 stsp if (got_object_id_cmp(old_id, new_id) == 0)
1883 6338a6a1 2020-03-21 stsp goto done;
1885 6338a6a1 2020-03-21 stsp err = got_ref_change_ref(ref, new_id);
1887 6338a6a1 2020-03-21 stsp goto done;
1888 6338a6a1 2020-03-21 stsp err = got_ref_write(ref, repo);
1890 6338a6a1 2020-03-21 stsp goto done;
1893 6338a6a1 2020-03-21 stsp if (verbosity >= 0)
1894 f4d0e3fb 2020-05-15 stsp printf("Updated %s: %s\n", got_ref_get_name(ref),
1895 6338a6a1 2020-03-21 stsp new_id_str);
1897 7848a0e1 2020-03-19 stsp free(old_id);
1898 7848a0e1 2020-03-19 stsp free(new_id_str);
1899 7848a0e1 2020-03-19 stsp return err;
1902 f1bcca34 2020-03-25 stsp static const struct got_error *
1903 f1bcca34 2020-03-25 stsp update_symref(const char *refname, struct got_reference *target_ref,
1904 f1bcca34 2020-03-25 stsp int verbosity, struct got_repository *repo)
1906 f1bcca34 2020-03-25 stsp const struct got_error *err = NULL, *unlock_err;
1907 f1bcca34 2020-03-25 stsp struct got_reference *symref;
1908 bcf34b0e 2020-03-26 stsp int symref_is_locked = 0;
1910 f1bcca34 2020-03-25 stsp err = got_ref_open(&symref, repo, refname, 1);
1911 bcf34b0e 2020-03-26 stsp if (err) {
1912 bcf34b0e 2020-03-26 stsp if (err->code != GOT_ERR_NOT_REF)
1913 bcf34b0e 2020-03-26 stsp return err;
1914 bcf34b0e 2020-03-26 stsp err = got_ref_alloc_symref(&symref, refname, target_ref);
1916 bcf34b0e 2020-03-26 stsp goto done;
1918 bcf34b0e 2020-03-26 stsp err = got_ref_write(symref, repo);
1920 bcf34b0e 2020-03-26 stsp goto done;
1922 bcf34b0e 2020-03-26 stsp if (verbosity >= 0)
1923 bcf34b0e 2020-03-26 stsp printf("Created reference %s: %s\n",
1924 bcf34b0e 2020-03-26 stsp got_ref_get_name(symref),
1925 bcf34b0e 2020-03-26 stsp got_ref_get_symref_target(symref));
1927 bcf34b0e 2020-03-26 stsp symref_is_locked = 1;
1929 bcf34b0e 2020-03-26 stsp if (strcmp(got_ref_get_symref_target(symref),
1930 bcf34b0e 2020-03-26 stsp got_ref_get_name(target_ref)) == 0)
1931 bcf34b0e 2020-03-26 stsp goto done;
1933 bcf34b0e 2020-03-26 stsp err = got_ref_change_symref(symref,
1934 bcf34b0e 2020-03-26 stsp got_ref_get_name(target_ref));
1936 bcf34b0e 2020-03-26 stsp goto done;
1938 bcf34b0e 2020-03-26 stsp err = got_ref_write(symref, repo);
1940 bcf34b0e 2020-03-26 stsp goto done;
1942 bcf34b0e 2020-03-26 stsp if (verbosity >= 0)
1943 f4d0e3fb 2020-05-15 stsp printf("Updated %s: %s\n", got_ref_get_name(symref),
1944 bcf34b0e 2020-03-26 stsp got_ref_get_symref_target(symref));
1948 bcf34b0e 2020-03-26 stsp if (symref_is_locked) {
1949 bcf34b0e 2020-03-26 stsp unlock_err = got_ref_unlock(symref);
1950 bcf34b0e 2020-03-26 stsp if (unlock_err && err == NULL)
1951 bcf34b0e 2020-03-26 stsp err = unlock_err;
1953 f1bcca34 2020-03-25 stsp got_ref_close(symref);
1954 f1bcca34 2020-03-25 stsp return err;
1957 2ab43947 2020-03-18 stsp __dead static void
1958 7848a0e1 2020-03-19 stsp usage_fetch(void)
1960 f21ec2f0 2020-03-21 stsp fprintf(stderr, "usage: %s fetch [-a] [-b branch] [-d] [-l] "
1961 161728eb 2021-07-24 stsp "[-r repository-path] [-t] [-q] [-v] [-R reference] [-X] "
1962 0e4002ca 2020-03-21 stsp "[remote-repository-name]\n",
1963 13f12b09 2020-03-21 stsp getprogname());
1967 7848a0e1 2020-03-19 stsp static const struct got_error *
1968 3789fd73 2020-03-26 stsp delete_missing_ref(struct got_reference *ref,
1969 688f11b3 2020-03-21 stsp int verbosity, struct got_repository *repo)
1971 f21ec2f0 2020-03-21 stsp const struct got_error *err = NULL;
1972 3789fd73 2020-03-26 stsp struct got_object_id *id = NULL;
1973 3789fd73 2020-03-26 stsp char *id_str = NULL;
1975 3789fd73 2020-03-26 stsp if (got_ref_is_symbolic(ref)) {
1976 3789fd73 2020-03-26 stsp err = got_ref_delete(ref, repo);
1978 3789fd73 2020-03-26 stsp return err;
1979 3789fd73 2020-03-26 stsp if (verbosity >= 0) {
1980 f9d54ee6 2021-07-16 stsp printf("Deleted %s: %s\n",
1981 3789fd73 2020-03-26 stsp got_ref_get_name(ref),
1982 3789fd73 2020-03-26 stsp got_ref_get_symref_target(ref));
1985 3789fd73 2020-03-26 stsp err = got_ref_resolve(&id, repo, ref);
1987 3789fd73 2020-03-26 stsp return err;
1988 3789fd73 2020-03-26 stsp err = got_object_id_str(&id_str, id);
1990 3789fd73 2020-03-26 stsp goto done;
1992 3789fd73 2020-03-26 stsp err = got_ref_delete(ref, repo);
1994 3789fd73 2020-03-26 stsp goto done;
1995 3789fd73 2020-03-26 stsp if (verbosity >= 0) {
1996 f9d54ee6 2021-07-16 stsp printf("Deleted %s: %s\n",
1997 3789fd73 2020-03-26 stsp got_ref_get_name(ref), id_str);
2002 3789fd73 2020-03-26 stsp free(id_str);
2003 3789fd73 2020-03-26 stsp return NULL;
2006 3789fd73 2020-03-26 stsp static const struct got_error *
2007 3789fd73 2020-03-26 stsp delete_missing_refs(struct got_pathlist_head *their_refs,
2008 50b0790e 2020-09-11 stsp struct got_pathlist_head *their_symrefs,
2009 50b0790e 2020-09-11 stsp const struct got_remote_repo *remote,
2010 3789fd73 2020-03-26 stsp int verbosity, struct got_repository *repo)
2012 3789fd73 2020-03-26 stsp const struct got_error *err = NULL, *unlock_err;
2013 f21ec2f0 2020-03-21 stsp struct got_reflist_head my_refs;
2014 f21ec2f0 2020-03-21 stsp struct got_reflist_entry *re;
2015 f21ec2f0 2020-03-21 stsp struct got_pathlist_entry *pe;
2016 3789fd73 2020-03-26 stsp char *remote_namespace = NULL;
2017 3789fd73 2020-03-26 stsp char *local_refname = NULL;
2019 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&my_refs);
2021 3789fd73 2020-03-26 stsp if (asprintf(&remote_namespace, "refs/remotes/%s/", remote->name)
2023 3789fd73 2020-03-26 stsp return got_error_from_errno("asprintf");
2025 f21ec2f0 2020-03-21 stsp err = got_ref_list(&my_refs, repo, NULL, got_ref_cmp_by_name, NULL);
2027 3789fd73 2020-03-26 stsp goto done;
2029 d9dff0e5 2020-12-26 stsp TAILQ_FOREACH(re, &my_refs, entry) {
2030 f21ec2f0 2020-03-21 stsp const char *refname = got_ref_get_name(re->ref);
2031 1b796c3f 2021-09-11 stsp const char *their_refname;
2033 1b796c3f 2021-09-11 stsp if (remote->mirror_references) {
2034 1b796c3f 2021-09-11 stsp their_refname = refname;
2036 3789fd73 2020-03-26 stsp if (strncmp(refname, remote_namespace,
2037 3789fd73 2020-03-26 stsp strlen(remote_namespace)) == 0) {
2038 3789fd73 2020-03-26 stsp if (strcmp(refname + strlen(remote_namespace),
2039 3789fd73 2020-03-26 stsp GOT_REF_HEAD) == 0)
2041 3789fd73 2020-03-26 stsp if (asprintf(&local_refname, "refs/heads/%s",
2042 3789fd73 2020-03-26 stsp refname + strlen(remote_namespace)) == -1) {
2043 3789fd73 2020-03-26 stsp err = got_error_from_errno("asprintf");
2044 3789fd73 2020-03-26 stsp goto done;
2046 3789fd73 2020-03-26 stsp } else if (strncmp(refname, "refs/tags/", 10) != 0)
2049 1b796c3f 2021-09-11 stsp their_refname = local_refname;
2052 f21ec2f0 2020-03-21 stsp TAILQ_FOREACH(pe, their_refs, entry) {
2053 1b796c3f 2021-09-11 stsp if (strcmp(their_refname, pe->path) == 0)
2056 f21ec2f0 2020-03-21 stsp if (pe != NULL)
2059 3789fd73 2020-03-26 stsp TAILQ_FOREACH(pe, their_symrefs, entry) {
2060 1b796c3f 2021-09-11 stsp if (strcmp(their_refname, pe->path) == 0)
2063 3789fd73 2020-03-26 stsp if (pe != NULL)
2066 3789fd73 2020-03-26 stsp err = delete_missing_ref(re->ref, verbosity, repo);
2070 3789fd73 2020-03-26 stsp if (local_refname) {
2071 3789fd73 2020-03-26 stsp struct got_reference *ref;
2072 3789fd73 2020-03-26 stsp err = got_ref_open(&ref, repo, local_refname, 1);
2073 3789fd73 2020-03-26 stsp if (err) {
2074 3789fd73 2020-03-26 stsp if (err->code != GOT_ERR_NOT_REF)
2076 3789fd73 2020-03-26 stsp free(local_refname);
2077 3789fd73 2020-03-26 stsp local_refname = NULL;
2080 3789fd73 2020-03-26 stsp err = delete_missing_ref(ref, verbosity, repo);
2083 3789fd73 2020-03-26 stsp unlock_err = got_ref_unlock(ref);
2084 3789fd73 2020-03-26 stsp got_ref_close(ref);
2085 3789fd73 2020-03-26 stsp if (unlock_err && err == NULL) {
2086 3789fd73 2020-03-26 stsp err = unlock_err;
2090 3789fd73 2020-03-26 stsp free(local_refname);
2091 3789fd73 2020-03-26 stsp local_refname = NULL;
2095 3789fd73 2020-03-26 stsp free(remote_namespace);
2096 3789fd73 2020-03-26 stsp free(local_refname);
2097 0e4002ca 2020-03-21 stsp return err;
2100 0e4002ca 2020-03-21 stsp static const struct got_error *
2101 0e4002ca 2020-03-21 stsp update_wanted_ref(const char *refname, struct got_object_id *id,
2102 0e4002ca 2020-03-21 stsp const char *remote_repo_name, int verbosity, struct got_repository *repo)
2104 9f142382 2020-03-21 stsp const struct got_error *err, *unlock_err;
2105 0e4002ca 2020-03-21 stsp char *remote_refname;
2106 0e4002ca 2020-03-21 stsp struct got_reference *ref;
2108 0e4002ca 2020-03-21 stsp if (strncmp("refs/", refname, 5) == 0)
2109 0e4002ca 2020-03-21 stsp refname += 5;
2111 0e4002ca 2020-03-21 stsp if (asprintf(&remote_refname, "refs/remotes/%s/%s",
2112 0e4002ca 2020-03-21 stsp remote_repo_name, refname) == -1)
2113 0e4002ca 2020-03-21 stsp return got_error_from_errno("asprintf");
2115 9f142382 2020-03-21 stsp err = got_ref_open(&ref, repo, remote_refname, 1);
2116 0e4002ca 2020-03-21 stsp if (err) {
2117 0e4002ca 2020-03-21 stsp if (err->code != GOT_ERR_NOT_REF)
2118 0e4002ca 2020-03-21 stsp goto done;
2119 0e4002ca 2020-03-21 stsp err = create_ref(remote_refname, id, verbosity, repo);
2121 0e4002ca 2020-03-21 stsp err = update_ref(ref, id, 0, verbosity, repo);
2122 9f142382 2020-03-21 stsp unlock_err = got_ref_unlock(ref);
2123 9f142382 2020-03-21 stsp if (unlock_err && err == NULL)
2124 9f142382 2020-03-21 stsp err = unlock_err;
2125 0e4002ca 2020-03-21 stsp got_ref_close(ref);
2128 0e4002ca 2020-03-21 stsp free(remote_refname);
2129 161728eb 2021-07-24 stsp return err;
2132 161728eb 2021-07-24 stsp static const struct got_error *
2133 161728eb 2021-07-24 stsp delete_ref(struct got_repository *repo, struct got_reference *ref)
2135 161728eb 2021-07-24 stsp const struct got_error *err = NULL;
2136 161728eb 2021-07-24 stsp struct got_object_id *id = NULL;
2137 161728eb 2021-07-24 stsp char *id_str = NULL;
2138 161728eb 2021-07-24 stsp const char *target;
2140 161728eb 2021-07-24 stsp if (got_ref_is_symbolic(ref)) {
2141 161728eb 2021-07-24 stsp target = got_ref_get_symref_target(ref);
2143 161728eb 2021-07-24 stsp err = got_ref_resolve(&id, repo, ref);
2145 161728eb 2021-07-24 stsp goto done;
2146 161728eb 2021-07-24 stsp err = got_object_id_str(&id_str, id);
2148 161728eb 2021-07-24 stsp goto done;
2149 161728eb 2021-07-24 stsp target = id_str;
2152 161728eb 2021-07-24 stsp err = got_ref_delete(ref, repo);
2154 161728eb 2021-07-24 stsp goto done;
2156 161728eb 2021-07-24 stsp printf("Deleted %s: %s\n", got_ref_get_name(ref), target);
2159 161728eb 2021-07-24 stsp free(id_str);
2160 f21ec2f0 2020-03-21 stsp return err;
2163 f21ec2f0 2020-03-21 stsp static const struct got_error *
2164 161728eb 2021-07-24 stsp delete_refs_for_remote(struct got_repository *repo, const char *remote_name)
2166 161728eb 2021-07-24 stsp const struct got_error *err = NULL;
2167 161728eb 2021-07-24 stsp struct got_reflist_head refs;
2168 161728eb 2021-07-24 stsp struct got_reflist_entry *re;
2169 161728eb 2021-07-24 stsp char *prefix;
2171 161728eb 2021-07-24 stsp TAILQ_INIT(&refs);
2173 161728eb 2021-07-24 stsp if (asprintf(&prefix, "refs/remotes/%s", remote_name) == -1) {
2174 161728eb 2021-07-24 stsp err = got_error_from_errno("asprintf");
2175 161728eb 2021-07-24 stsp goto done;
2177 161728eb 2021-07-24 stsp err = got_ref_list(&refs, repo, prefix, got_ref_cmp_by_name, NULL);
2179 161728eb 2021-07-24 stsp goto done;
2181 161728eb 2021-07-24 stsp TAILQ_FOREACH(re, &refs, entry)
2182 161728eb 2021-07-24 stsp delete_ref(repo, re->ref);
2184 161728eb 2021-07-24 stsp got_ref_list_free(&refs);
2185 161728eb 2021-07-24 stsp return err;
2188 161728eb 2021-07-24 stsp static const struct got_error *
2189 7848a0e1 2020-03-19 stsp cmd_fetch(int argc, char *argv[])
2191 9f142382 2020-03-21 stsp const struct got_error *error = NULL, *unlock_err;
2192 7848a0e1 2020-03-19 stsp char *cwd = NULL, *repo_path = NULL;
2193 7848a0e1 2020-03-19 stsp const char *remote_name;
2194 7848a0e1 2020-03-19 stsp char *proto = NULL, *host = NULL, *port = NULL;
2195 7848a0e1 2020-03-19 stsp char *repo_name = NULL, *server_path = NULL;
2196 50b0790e 2020-09-11 stsp const struct got_remote_repo *remotes, *remote = NULL;
2197 7848a0e1 2020-03-19 stsp int nremotes;
2198 7848a0e1 2020-03-19 stsp char *id_str = NULL;
2199 7848a0e1 2020-03-19 stsp struct got_repository *repo = NULL;
2200 7848a0e1 2020-03-19 stsp struct got_worktree *worktree = NULL;
2201 50b0790e 2020-09-11 stsp const struct got_gotconfig *repo_conf = NULL, *worktree_conf = NULL;
2202 0e4002ca 2020-03-21 stsp struct got_pathlist_head refs, symrefs, wanted_branches, wanted_refs;
2203 7848a0e1 2020-03-19 stsp struct got_pathlist_entry *pe;
2204 7848a0e1 2020-03-19 stsp struct got_object_id *pack_hash = NULL;
2205 9c52365f 2020-03-21 stsp int i, ch, fetchfd = -1, fetchstatus;
2206 9c52365f 2020-03-21 stsp pid_t fetchpid = -1;
2207 7848a0e1 2020-03-19 stsp struct got_fetch_progress_arg fpa;
2208 41b0de12 2020-03-21 stsp int verbosity = 0, fetch_all_branches = 0, list_refs_only = 0;
2209 161728eb 2021-07-24 stsp int delete_refs = 0, replace_tags = 0, delete_remote = 0;
2211 7848a0e1 2020-03-19 stsp TAILQ_INIT(&refs);
2212 7848a0e1 2020-03-19 stsp TAILQ_INIT(&symrefs);
2213 4ba14133 2020-03-20 stsp TAILQ_INIT(&wanted_branches);
2214 0e4002ca 2020-03-21 stsp TAILQ_INIT(&wanted_refs);
2216 161728eb 2021-07-24 stsp while ((ch = getopt(argc, argv, "ab:dlr:tvqR:X")) != -1) {
2217 7848a0e1 2020-03-19 stsp switch (ch) {
2219 659e7fbd 2020-03-20 stsp fetch_all_branches = 1;
2222 4ba14133 2020-03-20 stsp error = got_pathlist_append(&wanted_branches,
2223 4ba14133 2020-03-20 stsp optarg, NULL);
2224 4ba14133 2020-03-20 stsp if (error)
2225 4ba14133 2020-03-20 stsp return error;
2228 f21ec2f0 2020-03-21 stsp delete_refs = 1;
2231 41b0de12 2020-03-21 stsp list_refs_only = 1;
2234 7848a0e1 2020-03-19 stsp repo_path = realpath(optarg, NULL);
2235 7848a0e1 2020-03-19 stsp if (repo_path == NULL)
2236 7848a0e1 2020-03-19 stsp return got_error_from_errno2("realpath",
2238 7848a0e1 2020-03-19 stsp got_path_strip_trailing_slashes(repo_path);
2241 db6d8ad8 2020-03-21 stsp replace_tags = 1;
2244 7848a0e1 2020-03-19 stsp if (verbosity < 0)
2245 7848a0e1 2020-03-19 stsp verbosity = 0;
2246 7848a0e1 2020-03-19 stsp else if (verbosity < 3)
2247 7848a0e1 2020-03-19 stsp verbosity++;
2250 7848a0e1 2020-03-19 stsp verbosity = -1;
2253 0e4002ca 2020-03-21 stsp error = got_pathlist_append(&wanted_refs,
2254 0e4002ca 2020-03-21 stsp optarg, NULL);
2255 0e4002ca 2020-03-21 stsp if (error)
2256 0e4002ca 2020-03-21 stsp return error;
2259 161728eb 2021-07-24 stsp delete_remote = 1;
2262 7848a0e1 2020-03-19 stsp usage_fetch();
2266 7848a0e1 2020-03-19 stsp argc -= optind;
2267 7848a0e1 2020-03-19 stsp argv += optind;
2269 4ba14133 2020-03-20 stsp if (fetch_all_branches && !TAILQ_EMPTY(&wanted_branches))
2270 ff69268e 2020-12-13 stsp option_conflict('a', 'b');
2271 41b0de12 2020-03-21 stsp if (list_refs_only) {
2272 41b0de12 2020-03-21 stsp if (!TAILQ_EMPTY(&wanted_branches))
2273 ff69268e 2020-12-13 stsp option_conflict('l', 'b');
2274 ff69268e 2020-12-13 stsp if (fetch_all_branches)
2275 ff69268e 2020-12-13 stsp option_conflict('l', 'a');
2276 f21ec2f0 2020-03-21 stsp if (delete_refs)
2277 ff69268e 2020-12-13 stsp option_conflict('l', 'd');
2278 161728eb 2021-07-24 stsp if (delete_remote)
2279 161728eb 2021-07-24 stsp option_conflict('l', 'X');
2281 161728eb 2021-07-24 stsp if (delete_remote) {
2282 161728eb 2021-07-24 stsp if (fetch_all_branches)
2283 161728eb 2021-07-24 stsp option_conflict('X', 'a');
2284 161728eb 2021-07-24 stsp if (!TAILQ_EMPTY(&wanted_branches))
2285 161728eb 2021-07-24 stsp option_conflict('X', 'b');
2286 161728eb 2021-07-24 stsp if (delete_refs)
2287 161728eb 2021-07-24 stsp option_conflict('X', 'd');
2288 161728eb 2021-07-24 stsp if (replace_tags)
2289 161728eb 2021-07-24 stsp option_conflict('X', 't');
2290 161728eb 2021-07-24 stsp if (!TAILQ_EMPTY(&wanted_refs))
2291 161728eb 2021-07-24 stsp option_conflict('X', 'R');
2294 161728eb 2021-07-24 stsp if (argc == 0) {
2295 161728eb 2021-07-24 stsp if (delete_remote)
2296 161728eb 2021-07-24 stsp errx(1, "-X option requires a remote name");
2297 7848a0e1 2020-03-19 stsp remote_name = GOT_FETCH_DEFAULT_REMOTE_NAME;
2298 161728eb 2021-07-24 stsp } else if (argc == 1)
2299 7848a0e1 2020-03-19 stsp remote_name = argv[0];
2301 7848a0e1 2020-03-19 stsp usage_fetch();
2303 7848a0e1 2020-03-19 stsp cwd = getcwd(NULL, 0);
2304 7848a0e1 2020-03-19 stsp if (cwd == NULL) {
2305 7848a0e1 2020-03-19 stsp error = got_error_from_errno("getcwd");
2306 7848a0e1 2020-03-19 stsp goto done;
2309 7848a0e1 2020-03-19 stsp if (repo_path == NULL) {
2310 7848a0e1 2020-03-19 stsp error = got_worktree_open(&worktree, cwd);
2311 7848a0e1 2020-03-19 stsp if (error && error->code != GOT_ERR_NOT_WORKTREE)
2312 7848a0e1 2020-03-19 stsp goto done;
2314 7848a0e1 2020-03-19 stsp error = NULL;
2315 7848a0e1 2020-03-19 stsp if (worktree) {
2316 7848a0e1 2020-03-19 stsp repo_path =
2317 7848a0e1 2020-03-19 stsp strdup(got_worktree_get_repo_path(worktree));
2318 7848a0e1 2020-03-19 stsp if (repo_path == NULL)
2319 7848a0e1 2020-03-19 stsp error = got_error_from_errno("strdup");
2320 7848a0e1 2020-03-19 stsp if (error)
2321 7848a0e1 2020-03-19 stsp goto done;
2323 7848a0e1 2020-03-19 stsp repo_path = strdup(cwd);
2324 7848a0e1 2020-03-19 stsp if (repo_path == NULL) {
2325 7848a0e1 2020-03-19 stsp error = got_error_from_errno("strdup");
2326 7848a0e1 2020-03-19 stsp goto done;
2331 7848a0e1 2020-03-19 stsp error = got_repo_open(&repo, repo_path, NULL);
2332 7848a0e1 2020-03-19 stsp if (error)
2333 7848a0e1 2020-03-19 stsp goto done;
2335 161728eb 2021-07-24 stsp if (delete_remote) {
2336 161728eb 2021-07-24 stsp error = delete_refs_for_remote(repo, remote_name);
2337 161728eb 2021-07-24 stsp goto done; /* nothing else to do */
2340 50b0790e 2020-09-11 stsp if (worktree) {
2341 50b0790e 2020-09-11 stsp worktree_conf = got_worktree_get_gotconfig(worktree);
2342 50b0790e 2020-09-11 stsp if (worktree_conf) {
2343 50b0790e 2020-09-11 stsp got_gotconfig_get_remotes(&nremotes, &remotes,
2344 50b0790e 2020-09-11 stsp worktree_conf);
2345 50b0790e 2020-09-11 stsp for (i = 0; i < nremotes; i++) {
2346 54eb00d5 2020-10-20 stsp if (strcmp(remotes[i].name, remote_name) == 0) {
2347 54eb00d5 2020-10-20 stsp remote = &remotes[i];
2353 50b0790e 2020-09-11 stsp if (remote == NULL) {
2354 50b0790e 2020-09-11 stsp repo_conf = got_repo_get_gotconfig(repo);
2355 50b0790e 2020-09-11 stsp if (repo_conf) {
2356 50b0790e 2020-09-11 stsp got_gotconfig_get_remotes(&nremotes, &remotes,
2357 50b0790e 2020-09-11 stsp repo_conf);
2358 50b0790e 2020-09-11 stsp for (i = 0; i < nremotes; i++) {
2359 54eb00d5 2020-10-20 stsp if (strcmp(remotes[i].name, remote_name) == 0) {
2360 54eb00d5 2020-10-20 stsp remote = &remotes[i];
2366 50b0790e 2020-09-11 stsp if (remote == NULL) {
2367 257add31 2020-09-09 stsp got_repo_get_gitconfig_remotes(&nremotes, &remotes, repo);
2368 257add31 2020-09-09 stsp for (i = 0; i < nremotes; i++) {
2369 54eb00d5 2020-10-20 stsp if (strcmp(remotes[i].name, remote_name) == 0) {
2370 54eb00d5 2020-10-20 stsp remote = &remotes[i];
2375 50b0790e 2020-09-11 stsp if (remote == NULL) {
2376 50b0790e 2020-09-11 stsp error = got_error_path(remote_name, GOT_ERR_NO_REMOTE);
2377 50b0790e 2020-09-11 stsp goto done;
2380 0c8b29c5 2021-01-05 stsp if (TAILQ_EMPTY(&wanted_branches)) {
2381 0c8b29c5 2021-01-05 stsp if (!fetch_all_branches)
2382 0c8b29c5 2021-01-05 stsp fetch_all_branches = remote->fetch_all_branches;
2383 6480c871 2021-08-30 stsp for (i = 0; i < remote->nfetch_branches; i++) {
2384 b8adfa55 2020-09-25 stsp got_pathlist_append(&wanted_branches,
2385 6480c871 2021-08-30 stsp remote->fetch_branches[i], NULL);
2388 99495ddb 2021-01-10 stsp if (TAILQ_EMPTY(&wanted_refs)) {
2389 6480c871 2021-08-30 stsp for (i = 0; i < remote->nfetch_refs; i++) {
2390 99495ddb 2021-01-10 stsp got_pathlist_append(&wanted_refs,
2391 6480c871 2021-08-30 stsp remote->fetch_refs[i], NULL);
2395 5e5da8c4 2021-09-05 stsp error = got_dial_parse_uri(&proto, &host, &port, &server_path,
2396 6480c871 2021-08-30 stsp &repo_name, remote->fetch_url);
2397 7848a0e1 2020-03-19 stsp if (error)
2398 7848a0e1 2020-03-19 stsp goto done;
2400 7848a0e1 2020-03-19 stsp if (strcmp(proto, "git") == 0) {
2401 7848a0e1 2020-03-19 stsp #ifndef PROFILE
2402 7848a0e1 2020-03-19 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec "
2403 7848a0e1 2020-03-19 stsp "sendfd dns inet unveil", NULL) == -1)
2404 7848a0e1 2020-03-19 stsp err(1, "pledge");
2406 7848a0e1 2020-03-19 stsp } else if (strcmp(proto, "git+ssh") == 0 ||
2407 7848a0e1 2020-03-19 stsp strcmp(proto, "ssh") == 0) {
2408 7848a0e1 2020-03-19 stsp #ifndef PROFILE
2409 7848a0e1 2020-03-19 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec "
2410 7848a0e1 2020-03-19 stsp "sendfd unveil", NULL) == -1)
2411 7848a0e1 2020-03-19 stsp err(1, "pledge");
2413 7848a0e1 2020-03-19 stsp } else if (strcmp(proto, "http") == 0 ||
2414 7848a0e1 2020-03-19 stsp strcmp(proto, "git+http") == 0) {
2415 7848a0e1 2020-03-19 stsp error = got_error_path(proto, GOT_ERR_NOT_IMPL);
2416 7848a0e1 2020-03-19 stsp goto done;
2418 7848a0e1 2020-03-19 stsp error = got_error_path(proto, GOT_ERR_BAD_PROTO);
2419 7848a0e1 2020-03-19 stsp goto done;
2422 d65a88a2 2021-09-05 stsp error = got_dial_apply_unveil(proto);
2423 d65a88a2 2021-09-05 stsp if (error)
2424 d65a88a2 2021-09-05 stsp goto done;
2426 7848a0e1 2020-03-19 stsp error = apply_unveil(got_repo_get_path(repo), 0, NULL);
2427 7848a0e1 2020-03-19 stsp if (error)
2428 7848a0e1 2020-03-19 stsp goto done;
2430 f79e6490 2020-04-19 stsp if (verbosity >= 0)
2431 f79e6490 2020-04-19 stsp printf("Connecting to \"%s\" %s%s%s\n", remote->name, host,
2432 f79e6490 2020-04-19 stsp port ? ":" : "", port ? port : "");
2434 9c52365f 2020-03-21 stsp error = got_fetch_connect(&fetchpid, &fetchfd, proto, host, port,
2435 9c52365f 2020-03-21 stsp server_path, verbosity);
2436 7848a0e1 2020-03-19 stsp if (error)
2437 7848a0e1 2020-03-19 stsp goto done;
2439 7848a0e1 2020-03-19 stsp fpa.last_scaled_size[0] = '\0';
2440 7848a0e1 2020-03-19 stsp fpa.last_p_indexed = -1;
2441 7848a0e1 2020-03-19 stsp fpa.last_p_resolved = -1;
2442 7848a0e1 2020-03-19 stsp fpa.verbosity = verbosity;
2443 04d9a9ec 2020-09-24 stsp fpa.repo = repo;
2444 04d9a9ec 2020-09-24 stsp fpa.create_configs = 0;
2445 04d9a9ec 2020-09-24 stsp fpa.configs_created = 0;
2446 04d9a9ec 2020-09-24 stsp memset(&fpa.config_info, 0, sizeof(fpa.config_info));
2447 7848a0e1 2020-03-19 stsp error = got_fetch_pack(&pack_hash, &refs, &symrefs, remote->name,
2448 4ba14133 2020-03-20 stsp remote->mirror_references, fetch_all_branches, &wanted_branches,
2449 0e4002ca 2020-03-21 stsp &wanted_refs, list_refs_only, verbosity, fetchfd, repo,
2450 0e4002ca 2020-03-21 stsp fetch_progress, &fpa);
2451 7848a0e1 2020-03-19 stsp if (error)
2452 7848a0e1 2020-03-19 stsp goto done;
2454 41b0de12 2020-03-21 stsp if (list_refs_only) {
2455 41b0de12 2020-03-21 stsp error = list_remote_refs(&symrefs, &refs);
2456 41b0de12 2020-03-21 stsp goto done;
2459 7848a0e1 2020-03-19 stsp if (pack_hash == NULL) {
2460 7848a0e1 2020-03-19 stsp if (verbosity >= 0)
2461 7848a0e1 2020-03-19 stsp printf("Already up-to-date\n");
2462 bcf34b0e 2020-03-26 stsp } else if (verbosity >= 0) {
2463 984065c8 2020-03-19 stsp error = got_object_id_str(&id_str, pack_hash);
2464 984065c8 2020-03-19 stsp if (error)
2465 984065c8 2020-03-19 stsp goto done;
2466 e69674d8 2020-03-19 stsp printf("\nFetched %s.pack\n", id_str);
2467 984065c8 2020-03-19 stsp free(id_str);
2468 984065c8 2020-03-19 stsp id_str = NULL;
2471 7848a0e1 2020-03-19 stsp /* Update references provided with the pack file. */
2472 7848a0e1 2020-03-19 stsp TAILQ_FOREACH(pe, &refs, entry) {
2473 7848a0e1 2020-03-19 stsp const char *refname = pe->path;
2474 7848a0e1 2020-03-19 stsp struct got_object_id *id = pe->data;
2475 7848a0e1 2020-03-19 stsp struct got_reference *ref;
2476 7848a0e1 2020-03-19 stsp char *remote_refname;
2478 0e4002ca 2020-03-21 stsp if (is_wanted_ref(&wanted_refs, refname) &&
2479 0e4002ca 2020-03-21 stsp !remote->mirror_references) {
2480 0e4002ca 2020-03-21 stsp error = update_wanted_ref(refname, id,
2481 0e4002ca 2020-03-21 stsp remote->name, verbosity, repo);
2482 0e4002ca 2020-03-21 stsp if (error)
2483 0e4002ca 2020-03-21 stsp goto done;
2487 1510c839 2020-03-20 stsp if (remote->mirror_references ||
2488 1510c839 2020-03-20 stsp strncmp("refs/tags/", refname, 10) == 0) {
2489 9f142382 2020-03-21 stsp error = got_ref_open(&ref, repo, refname, 1);
2490 7848a0e1 2020-03-19 stsp if (error) {
2491 7848a0e1 2020-03-19 stsp if (error->code != GOT_ERR_NOT_REF)
2492 7848a0e1 2020-03-19 stsp goto done;
2493 6338a6a1 2020-03-21 stsp error = create_ref(refname, id, verbosity,
2495 7848a0e1 2020-03-19 stsp if (error)
2496 7848a0e1 2020-03-19 stsp goto done;
2498 db6d8ad8 2020-03-21 stsp error = update_ref(ref, id, replace_tags,
2499 db6d8ad8 2020-03-21 stsp verbosity, repo);
2500 9f142382 2020-03-21 stsp unlock_err = got_ref_unlock(ref);
2501 9f142382 2020-03-21 stsp if (unlock_err && error == NULL)
2502 9f142382 2020-03-21 stsp error = unlock_err;
2503 7848a0e1 2020-03-19 stsp got_ref_close(ref);
2504 7848a0e1 2020-03-19 stsp if (error)
2505 7848a0e1 2020-03-19 stsp goto done;
2507 7848a0e1 2020-03-19 stsp } else if (strncmp("refs/heads/", refname, 11) == 0) {
2508 7848a0e1 2020-03-19 stsp if (asprintf(&remote_refname, "refs/remotes/%s/%s",
2509 7848a0e1 2020-03-19 stsp remote_name, refname + 11) == -1) {
2510 7848a0e1 2020-03-19 stsp error = got_error_from_errno("asprintf");
2511 7848a0e1 2020-03-19 stsp goto done;
2514 9f142382 2020-03-21 stsp error = got_ref_open(&ref, repo, remote_refname, 1);
2515 7848a0e1 2020-03-19 stsp if (error) {
2516 7848a0e1 2020-03-19 stsp if (error->code != GOT_ERR_NOT_REF)
2517 7848a0e1 2020-03-19 stsp goto done;
2518 6338a6a1 2020-03-21 stsp error = create_ref(remote_refname, id,
2519 688f11b3 2020-03-21 stsp verbosity, repo);
2520 7848a0e1 2020-03-19 stsp if (error)
2521 7848a0e1 2020-03-19 stsp goto done;
2523 db6d8ad8 2020-03-21 stsp error = update_ref(ref, id, replace_tags,
2524 db6d8ad8 2020-03-21 stsp verbosity, repo);
2525 9f142382 2020-03-21 stsp unlock_err = got_ref_unlock(ref);
2526 9f142382 2020-03-21 stsp if (unlock_err && error == NULL)
2527 9f142382 2020-03-21 stsp error = unlock_err;
2528 7848a0e1 2020-03-19 stsp got_ref_close(ref);
2529 7848a0e1 2020-03-19 stsp if (error)
2530 7848a0e1 2020-03-19 stsp goto done;
2533 2ec30c80 2020-03-20 stsp /* Also create a local branch if none exists yet. */
2534 9f142382 2020-03-21 stsp error = got_ref_open(&ref, repo, refname, 1);
2535 2ec30c80 2020-03-20 stsp if (error) {
2536 2ec30c80 2020-03-20 stsp if (error->code != GOT_ERR_NOT_REF)
2537 2ec30c80 2020-03-20 stsp goto done;
2538 6338a6a1 2020-03-21 stsp error = create_ref(refname, id, verbosity,
2540 2ec30c80 2020-03-20 stsp if (error)
2541 2ec30c80 2020-03-20 stsp goto done;
2543 9f142382 2020-03-21 stsp unlock_err = got_ref_unlock(ref);
2544 9f142382 2020-03-21 stsp if (unlock_err && error == NULL)
2545 9f142382 2020-03-21 stsp error = unlock_err;
2546 2ec30c80 2020-03-20 stsp got_ref_close(ref);
2550 f1bcca34 2020-03-25 stsp if (delete_refs) {
2551 3789fd73 2020-03-26 stsp error = delete_missing_refs(&refs, &symrefs, remote,
2552 3789fd73 2020-03-26 stsp verbosity, repo);
2553 f1bcca34 2020-03-25 stsp if (error)
2554 f1bcca34 2020-03-25 stsp goto done;
2557 f1bcca34 2020-03-25 stsp if (!remote->mirror_references) {
2558 f1bcca34 2020-03-25 stsp /* Update remote HEAD reference if the server provided one. */
2559 f1bcca34 2020-03-25 stsp TAILQ_FOREACH(pe, &symrefs, entry) {
2560 f1bcca34 2020-03-25 stsp struct got_reference *target_ref;
2561 f1bcca34 2020-03-25 stsp const char *refname = pe->path;
2562 f1bcca34 2020-03-25 stsp const char *target = pe->data;
2563 f1bcca34 2020-03-25 stsp char *remote_refname = NULL, *remote_target = NULL;
2565 f1bcca34 2020-03-25 stsp if (strcmp(refname, GOT_REF_HEAD) != 0)
2568 f1bcca34 2020-03-25 stsp if (strncmp("refs/heads/", target, 11) != 0)
2571 f1bcca34 2020-03-25 stsp if (asprintf(&remote_refname, "refs/remotes/%s/%s",
2572 f1bcca34 2020-03-25 stsp remote->name, refname) == -1) {
2573 f1bcca34 2020-03-25 stsp error = got_error_from_errno("asprintf");
2574 f1bcca34 2020-03-25 stsp goto done;
2576 f1bcca34 2020-03-25 stsp if (asprintf(&remote_target, "refs/remotes/%s/%s",
2577 f1bcca34 2020-03-25 stsp remote->name, target + 11) == -1) {
2578 f1bcca34 2020-03-25 stsp error = got_error_from_errno("asprintf");
2579 f1bcca34 2020-03-25 stsp free(remote_refname);
2580 f1bcca34 2020-03-25 stsp goto done;
2583 f1bcca34 2020-03-25 stsp error = got_ref_open(&target_ref, repo, remote_target,
2585 f1bcca34 2020-03-25 stsp if (error) {
2586 f1bcca34 2020-03-25 stsp free(remote_refname);
2587 f1bcca34 2020-03-25 stsp free(remote_target);
2588 f1bcca34 2020-03-25 stsp if (error->code == GOT_ERR_NOT_REF) {
2589 f1bcca34 2020-03-25 stsp error = NULL;
2592 f1bcca34 2020-03-25 stsp goto done;
2594 f1bcca34 2020-03-25 stsp error = update_symref(remote_refname, target_ref,
2595 f1bcca34 2020-03-25 stsp verbosity, repo);
2596 f1bcca34 2020-03-25 stsp free(remote_refname);
2597 f1bcca34 2020-03-25 stsp free(remote_target);
2598 f1bcca34 2020-03-25 stsp got_ref_close(target_ref);
2599 f1bcca34 2020-03-25 stsp if (error)
2600 f1bcca34 2020-03-25 stsp goto done;
2604 9c52365f 2020-03-21 stsp if (fetchpid > 0) {
2605 9c52365f 2020-03-21 stsp if (kill(fetchpid, SIGTERM) == -1)
2606 9c52365f 2020-03-21 stsp error = got_error_from_errno("kill");
2607 9c52365f 2020-03-21 stsp if (waitpid(fetchpid, &fetchstatus, 0) == -1 && error == NULL)
2608 9c52365f 2020-03-21 stsp error = got_error_from_errno("waitpid");
2610 7848a0e1 2020-03-19 stsp if (fetchfd != -1 && close(fetchfd) == -1 && error == NULL)
2611 7848a0e1 2020-03-19 stsp error = got_error_from_errno("close");
2612 1d0f4054 2021-06-17 stsp if (repo) {
2613 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
2614 1d0f4054 2021-06-17 stsp if (error == NULL)
2615 1d0f4054 2021-06-17 stsp error = close_err;
2617 7848a0e1 2020-03-19 stsp if (worktree)
2618 7848a0e1 2020-03-19 stsp got_worktree_close(worktree);
2619 7848a0e1 2020-03-19 stsp TAILQ_FOREACH(pe, &refs, entry) {
2620 7848a0e1 2020-03-19 stsp free((void *)pe->path);
2621 7848a0e1 2020-03-19 stsp free(pe->data);
2623 7848a0e1 2020-03-19 stsp got_pathlist_free(&refs);
2624 7848a0e1 2020-03-19 stsp TAILQ_FOREACH(pe, &symrefs, entry) {
2625 7848a0e1 2020-03-19 stsp free((void *)pe->path);
2626 7848a0e1 2020-03-19 stsp free(pe->data);
2628 7848a0e1 2020-03-19 stsp got_pathlist_free(&symrefs);
2629 4ba14133 2020-03-20 stsp got_pathlist_free(&wanted_branches);
2630 0e4002ca 2020-03-21 stsp got_pathlist_free(&wanted_refs);
2631 7848a0e1 2020-03-19 stsp free(id_str);
2632 7848a0e1 2020-03-19 stsp free(cwd);
2633 7848a0e1 2020-03-19 stsp free(repo_path);
2634 7848a0e1 2020-03-19 stsp free(pack_hash);
2635 7848a0e1 2020-03-19 stsp free(proto);
2636 7848a0e1 2020-03-19 stsp free(host);
2637 7848a0e1 2020-03-19 stsp free(port);
2638 7848a0e1 2020-03-19 stsp free(server_path);
2639 7848a0e1 2020-03-19 stsp free(repo_name);
2640 7848a0e1 2020-03-19 stsp return error;
2644 7848a0e1 2020-03-19 stsp __dead static void
2645 2ab43947 2020-03-18 stsp usage_checkout(void)
2647 2ab43947 2020-03-18 stsp fprintf(stderr, "usage: %s checkout [-E] [-b branch] [-c commit] "
2648 4ad4a1ec 2021-09-13 tracey "[-p prefix] [-q] repository-path [worktree-path]\n",
2649 4ad4a1ec 2021-09-13 tracey getprogname());
2653 2ab43947 2020-03-18 stsp static void
2654 2ab43947 2020-03-18 stsp show_worktree_base_ref_warning(void)
2656 2ab43947 2020-03-18 stsp fprintf(stderr, "%s: warning: could not create a reference "
2657 2ab43947 2020-03-18 stsp "to the work tree's base commit; the commit could be "
2658 e6786710 2021-07-03 stsp "garbage-collected by Git or 'gotadmin cleanup'; making the "
2659 e6786710 2021-07-03 stsp "repository writable and running 'got update' will prevent this\n",
2660 2ab43947 2020-03-18 stsp getprogname());
2663 2ab43947 2020-03-18 stsp struct got_checkout_progress_arg {
2664 2ab43947 2020-03-18 stsp const char *worktree_path;
2665 2ab43947 2020-03-18 stsp int had_base_commit_ref_error;
2666 4ad4a1ec 2021-09-13 tracey int verbosity;
2669 2ab43947 2020-03-18 stsp static const struct got_error *
2670 2ab43947 2020-03-18 stsp checkout_progress(void *arg, unsigned char status, const char *path)
2672 2ab43947 2020-03-18 stsp struct got_checkout_progress_arg *a = arg;
2674 2ab43947 2020-03-18 stsp /* Base commit bump happens silently. */
2675 2ab43947 2020-03-18 stsp if (status == GOT_STATUS_BUMP_BASE)
2676 2ab43947 2020-03-18 stsp return NULL;
2678 2ab43947 2020-03-18 stsp if (status == GOT_STATUS_BASE_REF_ERR) {
2679 2ab43947 2020-03-18 stsp a->had_base_commit_ref_error = 1;
2680 2ab43947 2020-03-18 stsp return NULL;
2683 2ab43947 2020-03-18 stsp while (path[0] == '/')
2686 4ad4a1ec 2021-09-13 tracey if (a->verbosity >= 0)
2687 4ad4a1ec 2021-09-13 tracey printf("%c %s/%s\n", status, a->worktree_path, path);
2689 2ab43947 2020-03-18 stsp return NULL;
2692 2ab43947 2020-03-18 stsp static const struct got_error *
2693 2ab43947 2020-03-18 stsp check_cancelled(void *arg)
2695 2ab43947 2020-03-18 stsp if (sigint_received || sigpipe_received)
2696 2ab43947 2020-03-18 stsp return got_error(GOT_ERR_CANCELLED);
2697 2ab43947 2020-03-18 stsp return NULL;
2700 2ab43947 2020-03-18 stsp static const struct got_error *
2701 2ab43947 2020-03-18 stsp check_linear_ancestry(struct got_object_id *commit_id,
2702 2ab43947 2020-03-18 stsp struct got_object_id *base_commit_id, int allow_forwards_in_time_only,
2703 2ab43947 2020-03-18 stsp struct got_repository *repo)
2705 2ab43947 2020-03-18 stsp const struct got_error *err = NULL;
2706 2ab43947 2020-03-18 stsp struct got_object_id *yca_id;
2708 2ab43947 2020-03-18 stsp err = got_commit_graph_find_youngest_common_ancestor(&yca_id,
2709 4e91ef15 2021-09-26 stsp commit_id, base_commit_id, 1, repo, check_cancelled, NULL);
2711 2ab43947 2020-03-18 stsp return err;
2713 2ab43947 2020-03-18 stsp if (yca_id == NULL)
2714 2ab43947 2020-03-18 stsp return got_error(GOT_ERR_ANCESTRY);
2717 2ab43947 2020-03-18 stsp * Require a straight line of history between the target commit
2718 2ab43947 2020-03-18 stsp * and the work tree's base commit.
2720 2ab43947 2020-03-18 stsp * Non-linear situations such as this require a rebase:
2722 2ab43947 2020-03-18 stsp * (commit) D F (base_commit)
2730 2ab43947 2020-03-18 stsp * 'got update' only handles linear cases:
2731 2ab43947 2020-03-18 stsp * Update forwards in time: A (base/yca) - B - C - D (commit)
2732 2ab43947 2020-03-18 stsp * Update backwards in time: D (base) - C - B - A (commit/yca)
2734 2ab43947 2020-03-18 stsp if (allow_forwards_in_time_only) {
2735 2ab43947 2020-03-18 stsp if (got_object_id_cmp(base_commit_id, yca_id) != 0)
2736 2ab43947 2020-03-18 stsp return got_error(GOT_ERR_ANCESTRY);
2737 2ab43947 2020-03-18 stsp } else if (got_object_id_cmp(commit_id, yca_id) != 0 &&
2738 2ab43947 2020-03-18 stsp got_object_id_cmp(base_commit_id, yca_id) != 0)
2739 2ab43947 2020-03-18 stsp return got_error(GOT_ERR_ANCESTRY);
2741 2ab43947 2020-03-18 stsp free(yca_id);
2742 2ab43947 2020-03-18 stsp return NULL;
2745 2ab43947 2020-03-18 stsp static const struct got_error *
2746 2ab43947 2020-03-18 stsp check_same_branch(struct got_object_id *commit_id,
2747 2ab43947 2020-03-18 stsp struct got_reference *head_ref, struct got_object_id *yca_id,
2748 2ab43947 2020-03-18 stsp struct got_repository *repo)
2750 2ab43947 2020-03-18 stsp const struct got_error *err = NULL;
2751 2ab43947 2020-03-18 stsp struct got_commit_graph *graph = NULL;
2752 2ab43947 2020-03-18 stsp struct got_object_id *head_commit_id = NULL;
2753 2ab43947 2020-03-18 stsp int is_same_branch = 0;
2755 2ab43947 2020-03-18 stsp err = got_ref_resolve(&head_commit_id, repo, head_ref);
2757 2ab43947 2020-03-18 stsp goto done;
2759 2ab43947 2020-03-18 stsp if (got_object_id_cmp(head_commit_id, commit_id) == 0) {
2760 2ab43947 2020-03-18 stsp is_same_branch = 1;
2761 2ab43947 2020-03-18 stsp goto done;
2763 2ab43947 2020-03-18 stsp if (yca_id && got_object_id_cmp(commit_id, yca_id) == 0) {
2764 2ab43947 2020-03-18 stsp is_same_branch = 1;
2765 2ab43947 2020-03-18 stsp goto done;
2768 2ab43947 2020-03-18 stsp err = got_commit_graph_open(&graph, "/", 1);
2770 2ab43947 2020-03-18 stsp goto done;
2772 2ab43947 2020-03-18 stsp err = got_commit_graph_iter_start(graph, head_commit_id, repo,
2773 2ab43947 2020-03-18 stsp check_cancelled, NULL);
2775 2ab43947 2020-03-18 stsp goto done;
2777 2ab43947 2020-03-18 stsp for (;;) {
2778 2ab43947 2020-03-18 stsp struct got_object_id *id;
2779 2ab43947 2020-03-18 stsp err = got_commit_graph_iter_next(&id, graph, repo,
2780 2ab43947 2020-03-18 stsp check_cancelled, NULL);
2781 2ab43947 2020-03-18 stsp if (err) {
2782 2ab43947 2020-03-18 stsp if (err->code == GOT_ERR_ITER_COMPLETED)
2783 2ab43947 2020-03-18 stsp err = NULL;
2788 2ab43947 2020-03-18 stsp if (yca_id && got_object_id_cmp(id, yca_id) == 0)
2790 2ab43947 2020-03-18 stsp if (got_object_id_cmp(id, commit_id) == 0) {
2791 2ab43947 2020-03-18 stsp is_same_branch = 1;
2797 2ab43947 2020-03-18 stsp if (graph)
2798 2ab43947 2020-03-18 stsp got_commit_graph_close(graph);
2799 2ab43947 2020-03-18 stsp free(head_commit_id);
2800 2ab43947 2020-03-18 stsp if (!err && !is_same_branch)
2801 2ab43947 2020-03-18 stsp err = got_error(GOT_ERR_ANCESTRY);
2802 2ab43947 2020-03-18 stsp return err;
2805 4ed7e80c 2018-05-20 stsp static const struct got_error *
2806 4b6c9460 2020-03-05 stsp checkout_ancestry_error(struct got_reference *ref, const char *commit_id_str)
2808 4b6c9460 2020-03-05 stsp static char msg[512];
2809 4b6c9460 2020-03-05 stsp const char *branch_name;
2811 4b6c9460 2020-03-05 stsp if (got_ref_is_symbolic(ref))
2812 4b6c9460 2020-03-05 stsp branch_name = got_ref_get_symref_target(ref);
2814 4b6c9460 2020-03-05 stsp branch_name = got_ref_get_name(ref);
2816 4b6c9460 2020-03-05 stsp if (strncmp("refs/heads/", branch_name, 11) == 0)
2817 4b6c9460 2020-03-05 stsp branch_name += 11;
2819 4b6c9460 2020-03-05 stsp snprintf(msg, sizeof(msg),
2820 4b6c9460 2020-03-05 stsp "target commit is not contained in branch '%s'; "
2821 4b6c9460 2020-03-05 stsp "the branch to use must be specified with -b; "
2822 4b6c9460 2020-03-05 stsp "if necessary a new branch can be created for "
2823 4b6c9460 2020-03-05 stsp "this commit with 'got branch -c %s BRANCH_NAME'",
2824 4b6c9460 2020-03-05 stsp branch_name, commit_id_str);
2826 4b6c9460 2020-03-05 stsp return got_error_msg(GOT_ERR_ANCESTRY, msg);
2829 4b6c9460 2020-03-05 stsp static const struct got_error *
2830 c09a553d 2018-03-12 stsp cmd_checkout(int argc, char *argv[])
2832 c09a553d 2018-03-12 stsp const struct got_error *error = NULL;
2833 c09a553d 2018-03-12 stsp struct got_repository *repo = NULL;
2834 08e5873e 2021-09-14 stsp struct got_reference *head_ref = NULL, *ref = NULL;
2835 c09a553d 2018-03-12 stsp struct got_worktree *worktree = NULL;
2836 c09a553d 2018-03-12 stsp char *repo_path = NULL;
2837 c09a553d 2018-03-12 stsp char *worktree_path = NULL;
2838 0bb8a95e 2018-03-12 stsp const char *path_prefix = "";
2839 08e5873e 2021-09-14 stsp const char *branch_name = GOT_REF_HEAD, *refname = NULL;
2840 8069f636 2019-01-12 stsp char *commit_id_str = NULL;
2841 08e5873e 2021-09-14 stsp struct got_object_id *commit_id = NULL;
2842 f0207f6a 2020-10-19 stsp char *cwd = NULL;
2843 4ad4a1ec 2021-09-13 tracey int ch, same_path_prefix, allow_nonempty = 0, verbosity = 0;
2844 f2ea84fa 2019-07-27 stsp struct got_pathlist_head paths;
2845 7f47418f 2019-12-20 stsp struct got_checkout_progress_arg cpa;
2847 f2ea84fa 2019-07-27 stsp TAILQ_INIT(&paths);
2849 4ad4a1ec 2021-09-13 tracey while ((ch = getopt(argc, argv, "b:c:Ep:q")) != -1) {
2850 0bb8a95e 2018-03-12 stsp switch (ch) {
2852 08573d5b 2019-05-14 stsp branch_name = optarg;
2855 8069f636 2019-01-12 stsp commit_id_str = strdup(optarg);
2856 8069f636 2019-01-12 stsp if (commit_id_str == NULL)
2857 638f9024 2019-05-13 stsp return got_error_from_errno("strdup");
2860 bb51a5b4 2020-01-13 stsp allow_nonempty = 1;
2863 0bb8a95e 2018-03-12 stsp path_prefix = optarg;
2865 4ad4a1ec 2021-09-13 tracey case 'q':
2866 4ad4a1ec 2021-09-13 tracey verbosity = -1;
2869 2deda0b9 2019-03-07 stsp usage_checkout();
2870 0bb8a95e 2018-03-12 stsp /* NOTREACHED */
2874 0bb8a95e 2018-03-12 stsp argc -= optind;
2875 0bb8a95e 2018-03-12 stsp argv += optind;
2877 6715a751 2018-03-16 stsp #ifndef PROFILE
2878 68ed9ba5 2019-02-10 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
2879 68ed9ba5 2019-02-10 stsp "unveil", NULL) == -1)
2880 c09a553d 2018-03-12 stsp err(1, "pledge");
2882 0bb8a95e 2018-03-12 stsp if (argc == 1) {
2883 c47340da 2020-09-20 stsp char *base, *dotgit;
2884 f0207f6a 2020-10-19 stsp const char *path;
2885 76089277 2018-04-01 stsp repo_path = realpath(argv[0], NULL);
2886 76089277 2018-04-01 stsp if (repo_path == NULL)
2887 638f9024 2019-05-13 stsp return got_error_from_errno2("realpath", argv[0]);
2888 c09a553d 2018-03-12 stsp cwd = getcwd(NULL, 0);
2889 76089277 2018-04-01 stsp if (cwd == NULL) {
2890 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
2891 76089277 2018-04-01 stsp goto done;
2893 c47340da 2020-09-20 stsp if (path_prefix[0])
2894 f0207f6a 2020-10-19 stsp path = path_prefix;
2896 f0207f6a 2020-10-19 stsp path = repo_path;
2897 f0207f6a 2020-10-19 stsp error = got_path_basename(&base, path);
2898 f0207f6a 2020-10-19 stsp if (error)
2899 c47340da 2020-09-20 stsp goto done;
2900 c09a553d 2018-03-12 stsp dotgit = strstr(base, ".git");
2901 c09a553d 2018-03-12 stsp if (dotgit)
2902 c09a553d 2018-03-12 stsp *dotgit = '\0';
2903 c09a553d 2018-03-12 stsp if (asprintf(&worktree_path, "%s/%s", cwd, base) == -1) {
2904 638f9024 2019-05-13 stsp error = got_error_from_errno("asprintf");
2905 f0207f6a 2020-10-19 stsp free(base);
2906 76089277 2018-04-01 stsp goto done;
2908 f0207f6a 2020-10-19 stsp free(base);
2909 0bb8a95e 2018-03-12 stsp } else if (argc == 2) {
2910 76089277 2018-04-01 stsp repo_path = realpath(argv[0], NULL);
2911 76089277 2018-04-01 stsp if (repo_path == NULL) {
2912 638f9024 2019-05-13 stsp error = got_error_from_errno2("realpath", argv[0]);
2913 76089277 2018-04-01 stsp goto done;
2915 f7b38925 2018-04-01 stsp worktree_path = realpath(argv[1], NULL);
2916 76089277 2018-04-01 stsp if (worktree_path == NULL) {
2917 b4b3a7dd 2019-07-22 stsp if (errno != ENOENT) {
2918 b4b3a7dd 2019-07-22 stsp error = got_error_from_errno2("realpath",
2920 b4b3a7dd 2019-07-22 stsp goto done;
2922 b4b3a7dd 2019-07-22 stsp worktree_path = strdup(argv[1]);
2923 b4b3a7dd 2019-07-22 stsp if (worktree_path == NULL) {
2924 b4b3a7dd 2019-07-22 stsp error = got_error_from_errno("strdup");
2925 b4b3a7dd 2019-07-22 stsp goto done;
2929 c09a553d 2018-03-12 stsp usage_checkout();
2931 7fbaa4f3 2019-05-11 stsp got_path_strip_trailing_slashes(repo_path);
2932 72151b04 2019-05-11 stsp got_path_strip_trailing_slashes(worktree_path);
2934 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, repo_path, NULL);
2935 c09a553d 2018-03-12 stsp if (error != NULL)
2936 c02c541e 2019-03-29 stsp goto done;
2938 c530dc23 2019-07-23 stsp /* Pre-create work tree path for unveil(2) */
2939 c530dc23 2019-07-23 stsp error = got_path_mkdir(worktree_path);
2940 c530dc23 2019-07-23 stsp if (error) {
2941 80c1b583 2019-08-07 stsp if (!(error->code == GOT_ERR_ERRNO && errno == EISDIR) &&
2942 80c1b583 2019-08-07 stsp !(error->code == GOT_ERR_ERRNO && errno == EEXIST))
2943 c530dc23 2019-07-23 stsp goto done;
2944 bb51a5b4 2020-01-13 stsp if (!allow_nonempty &&
2945 bb51a5b4 2020-01-13 stsp !got_path_dir_is_empty(worktree_path)) {
2946 c530dc23 2019-07-23 stsp error = got_error_path(worktree_path,
2947 c530dc23 2019-07-23 stsp GOT_ERR_DIR_NOT_EMPTY);
2948 c530dc23 2019-07-23 stsp goto done;
2952 c530dc23 2019-07-23 stsp error = apply_unveil(got_repo_get_path(repo), 0, worktree_path);
2953 c02c541e 2019-03-29 stsp if (error)
2954 c09a553d 2018-03-12 stsp goto done;
2956 08573d5b 2019-05-14 stsp error = got_ref_open(&head_ref, repo, branch_name, 0);
2957 c09a553d 2018-03-12 stsp if (error != NULL)
2958 c09a553d 2018-03-12 stsp goto done;
2960 0bb8a95e 2018-03-12 stsp error = got_worktree_init(worktree_path, head_ref, path_prefix, repo);
2961 d70b8e30 2018-12-27 stsp if (error != NULL && !(error->code == GOT_ERR_ERRNO && errno == EEXIST))
2962 c09a553d 2018-03-12 stsp goto done;
2964 c09a553d 2018-03-12 stsp error = got_worktree_open(&worktree, worktree_path);
2965 c09a553d 2018-03-12 stsp if (error != NULL)
2966 c09a553d 2018-03-12 stsp goto done;
2968 e5dc7198 2018-12-29 stsp error = got_worktree_match_path_prefix(&same_path_prefix, worktree,
2969 e5dc7198 2018-12-29 stsp path_prefix);
2970 e5dc7198 2018-12-29 stsp if (error != NULL)
2971 e5dc7198 2018-12-29 stsp goto done;
2972 e5dc7198 2018-12-29 stsp if (!same_path_prefix) {
2973 49520a32 2018-12-29 stsp error = got_error(GOT_ERR_PATH_PREFIX);
2974 49520a32 2018-12-29 stsp goto done;
2977 8069f636 2019-01-12 stsp if (commit_id_str) {
2978 84de9106 2020-12-26 stsp struct got_reflist_head refs;
2979 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
2980 84de9106 2020-12-26 stsp error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
2982 84de9106 2020-12-26 stsp if (error)
2983 84de9106 2020-12-26 stsp goto done;
2984 71a27632 2020-01-15 stsp error = got_repo_match_object_id(&commit_id, NULL,
2985 84de9106 2020-12-26 stsp commit_id_str, GOT_OBJ_TYPE_COMMIT, &refs, repo);
2986 84de9106 2020-12-26 stsp got_ref_list_free(&refs);
2987 30837e32 2019-07-25 stsp if (error)
2988 8069f636 2019-01-12 stsp goto done;
2989 024e9686 2019-05-14 stsp error = check_linear_ancestry(commit_id,
2990 3aef623b 2019-10-15 stsp got_worktree_get_base_commit_id(worktree), 0, repo);
2991 8069f636 2019-01-12 stsp if (error != NULL) {
2992 8069f636 2019-01-12 stsp free(commit_id);
2993 4b6c9460 2020-03-05 stsp if (error->code == GOT_ERR_ANCESTRY) {
2994 4b6c9460 2020-03-05 stsp error = checkout_ancestry_error(
2995 4b6c9460 2020-03-05 stsp head_ref, commit_id_str);
2997 8069f636 2019-01-12 stsp goto done;
2999 a51a74b3 2019-07-27 stsp error = check_same_branch(commit_id, head_ref, NULL, repo);
3000 4b6c9460 2020-03-05 stsp if (error) {
3001 4b6c9460 2020-03-05 stsp if (error->code == GOT_ERR_ANCESTRY) {
3002 4b6c9460 2020-03-05 stsp error = checkout_ancestry_error(
3003 4b6c9460 2020-03-05 stsp head_ref, commit_id_str);
3005 45d344f6 2019-05-14 stsp goto done;
3007 8069f636 2019-01-12 stsp error = got_worktree_set_base_commit_id(worktree, repo,
3008 8069f636 2019-01-12 stsp commit_id);
3009 8069f636 2019-01-12 stsp if (error)
3010 8069f636 2019-01-12 stsp goto done;
3011 08e5873e 2021-09-14 stsp /* Expand potentially abbreviated commit ID string. */
3012 08e5873e 2021-09-14 stsp free(commit_id_str);
3013 08e5873e 2021-09-14 stsp error = got_object_id_str(&commit_id_str, commit_id);
3014 08e5873e 2021-09-14 stsp if (error)
3015 08e5873e 2021-09-14 stsp goto done;
3017 08e5873e 2021-09-14 stsp commit_id = got_object_id_dup(
3018 08e5873e 2021-09-14 stsp got_worktree_get_base_commit_id(worktree));
3019 08e5873e 2021-09-14 stsp if (commit_id == NULL) {
3020 08e5873e 2021-09-14 stsp error = got_error_from_errno("got_object_id_dup");
3021 08e5873e 2021-09-14 stsp goto done;
3023 08e5873e 2021-09-14 stsp error = got_object_id_str(&commit_id_str, commit_id);
3024 08e5873e 2021-09-14 stsp if (error)
3025 08e5873e 2021-09-14 stsp goto done;
3028 adc19d55 2019-07-28 stsp error = got_pathlist_append(&paths, "", NULL);
3029 f2ea84fa 2019-07-27 stsp if (error)
3030 f2ea84fa 2019-07-27 stsp goto done;
3031 7f47418f 2019-12-20 stsp cpa.worktree_path = worktree_path;
3032 7f47418f 2019-12-20 stsp cpa.had_base_commit_ref_error = 0;
3033 4ad4a1ec 2021-09-13 tracey cpa.verbosity = verbosity;
3034 f2ea84fa 2019-07-27 stsp error = got_worktree_checkout_files(worktree, &paths, repo,
3035 7f47418f 2019-12-20 stsp checkout_progress, &cpa, check_cancelled, NULL);
3036 c09a553d 2018-03-12 stsp if (error != NULL)
3037 c09a553d 2018-03-12 stsp goto done;
3039 08e5873e 2021-09-14 stsp if (got_ref_is_symbolic(head_ref)) {
3040 08e5873e 2021-09-14 stsp error = got_ref_resolve_symbolic(&ref, repo, head_ref);
3041 08e5873e 2021-09-14 stsp if (error)
3042 08e5873e 2021-09-14 stsp goto done;
3043 08e5873e 2021-09-14 stsp refname = got_ref_get_name(ref);
3045 08e5873e 2021-09-14 stsp refname = got_ref_get_name(head_ref);
3046 08e5873e 2021-09-14 stsp printf("Checked out %s: %s\n", refname, commit_id_str);
3047 b65ae19a 2018-04-24 stsp printf("Now shut up and hack\n");
3048 7f47418f 2019-12-20 stsp if (cpa.had_base_commit_ref_error)
3049 7f47418f 2019-12-20 stsp show_worktree_base_ref_warning();
3051 08e5873e 2021-09-14 stsp if (head_ref)
3052 08e5873e 2021-09-14 stsp got_ref_close(head_ref);
3054 08e5873e 2021-09-14 stsp got_ref_close(ref);
3055 f2ea84fa 2019-07-27 stsp got_pathlist_free(&paths);
3056 8069f636 2019-01-12 stsp free(commit_id_str);
3057 08e5873e 2021-09-14 stsp free(commit_id);
3058 76089277 2018-04-01 stsp free(repo_path);
3059 507dc3bb 2018-12-29 stsp free(worktree_path);
3060 c47340da 2020-09-20 stsp free(cwd);
3061 507dc3bb 2018-12-29 stsp return error;
3064 9627c110 2020-04-18 stsp struct got_update_progress_arg {
3065 9627c110 2020-04-18 stsp int did_something;
3066 9627c110 2020-04-18 stsp int conflicts;
3067 9627c110 2020-04-18 stsp int obstructed;
3068 9627c110 2020-04-18 stsp int not_updated;
3069 f259c4c1 2021-09-24 stsp int missing;
3070 35ca1db7 2021-09-28 stsp int not_deleted;
3071 35ca1db7 2021-09-28 stsp int unversioned;
3072 4ad4a1ec 2021-09-13 tracey int verbosity;
3076 9627c110 2020-04-18 stsp print_update_progress_stats(struct got_update_progress_arg *upa)
3078 9627c110 2020-04-18 stsp if (!upa->did_something)
3081 9627c110 2020-04-18 stsp if (upa->conflicts > 0)
3082 9627c110 2020-04-18 stsp printf("Files with new merge conflicts: %d\n", upa->conflicts);
3083 9627c110 2020-04-18 stsp if (upa->obstructed > 0)
3084 9627c110 2020-04-18 stsp printf("File paths obstructed by a non-regular file: %d\n",
3085 9627c110 2020-04-18 stsp upa->obstructed);
3086 9627c110 2020-04-18 stsp if (upa->not_updated > 0)
3087 9627c110 2020-04-18 stsp printf("Files not updated because of existing merge "
3088 9627c110 2020-04-18 stsp "conflicts: %d\n", upa->not_updated);
3092 35ca1db7 2021-09-28 stsp * The meaning of some status codes differs between merge-style operations and
3093 35ca1db7 2021-09-28 stsp * update operations. For example, the ! status code means "file was missing"
3094 35ca1db7 2021-09-28 stsp * if changes were merged into the work tree, and "missing file was restored"
3095 35ca1db7 2021-09-28 stsp * if the work tree was updated. This function should be used by any operation
3096 35ca1db7 2021-09-28 stsp * which merges changes into the work tree without updating the work tree.
3099 35ca1db7 2021-09-28 stsp print_merge_progress_stats(struct got_update_progress_arg *upa)
3101 35ca1db7 2021-09-28 stsp if (!upa->did_something)
3104 35ca1db7 2021-09-28 stsp if (upa->conflicts > 0)
3105 35ca1db7 2021-09-28 stsp printf("Files with new merge conflicts: %d\n", upa->conflicts);
3106 35ca1db7 2021-09-28 stsp if (upa->obstructed > 0)
3107 35ca1db7 2021-09-28 stsp printf("File paths obstructed by a non-regular file: %d\n",
3108 35ca1db7 2021-09-28 stsp upa->obstructed);
3109 35ca1db7 2021-09-28 stsp if (upa->missing > 0)
3110 35ca1db7 2021-09-28 stsp printf("Files which had incoming changes but could not be "
3111 35ca1db7 2021-09-28 stsp "found in the work tree: %d\n", upa->missing);
3112 35ca1db7 2021-09-28 stsp if (upa->not_deleted > 0)
3113 35ca1db7 2021-09-28 stsp printf("Files not deleted due to differences in deleted "
3114 35ca1db7 2021-09-28 stsp "content: %d\n", upa->not_deleted);
3115 35ca1db7 2021-09-28 stsp if (upa->unversioned > 0)
3116 35ca1db7 2021-09-28 stsp printf("Files not merged because an unversioned file was "
3117 35ca1db7 2021-09-28 stsp "found in the work tree: %d\n", upa->unversioned);
3120 507dc3bb 2018-12-29 stsp __dead static void
3121 507dc3bb 2018-12-29 stsp usage_update(void)
3123 4ad4a1ec 2021-09-13 tracey fprintf(stderr, "usage: %s update [-b branch] [-c commit] [-q] "
3124 4ad4a1ec 2021-09-13 tracey "[path ...]\n",
3125 507dc3bb 2018-12-29 stsp getprogname());
3129 1ee397ad 2019-07-12 stsp static const struct got_error *
3130 507dc3bb 2018-12-29 stsp update_progress(void *arg, unsigned char status, const char *path)
3132 9627c110 2020-04-18 stsp struct got_update_progress_arg *upa = arg;
3134 7f47418f 2019-12-20 stsp if (status == GOT_STATUS_EXISTS ||
3135 7f47418f 2019-12-20 stsp status == GOT_STATUS_BASE_REF_ERR)
3136 1ee397ad 2019-07-12 stsp return NULL;
3138 9627c110 2020-04-18 stsp upa->did_something = 1;
3140 a484d721 2019-06-10 stsp /* Base commit bump happens silently. */
3141 a484d721 2019-06-10 stsp if (status == GOT_STATUS_BUMP_BASE)
3142 1ee397ad 2019-07-12 stsp return NULL;
3144 9627c110 2020-04-18 stsp if (status == GOT_STATUS_CONFLICT)
3145 9627c110 2020-04-18 stsp upa->conflicts++;
3146 9627c110 2020-04-18 stsp if (status == GOT_STATUS_OBSTRUCTED)
3147 9627c110 2020-04-18 stsp upa->obstructed++;
3148 9627c110 2020-04-18 stsp if (status == GOT_STATUS_CANNOT_UPDATE)
3149 9627c110 2020-04-18 stsp upa->not_updated++;
3150 f259c4c1 2021-09-24 stsp if (status == GOT_STATUS_MISSING)
3151 f259c4c1 2021-09-24 stsp upa->missing++;
3152 35ca1db7 2021-09-28 stsp if (status == GOT_STATUS_CANNOT_DELETE)
3153 35ca1db7 2021-09-28 stsp upa->not_deleted++;
3154 35ca1db7 2021-09-28 stsp if (status == GOT_STATUS_UNVERSIONED)
3155 35ca1db7 2021-09-28 stsp upa->unversioned++;
3157 507dc3bb 2018-12-29 stsp while (path[0] == '/')
3159 4ad4a1ec 2021-09-13 tracey if (upa->verbosity >= 0)
3160 4ad4a1ec 2021-09-13 tracey printf("%c %s\n", status, path);
3162 1ee397ad 2019-07-12 stsp return NULL;
3165 be7061eb 2018-12-30 stsp static const struct got_error *
3166 a1fb16d8 2019-05-24 stsp switch_head_ref(struct got_reference *head_ref,
3167 a1fb16d8 2019-05-24 stsp struct got_object_id *commit_id, struct got_worktree *worktree,
3168 a1fb16d8 2019-05-24 stsp struct got_repository *repo)
3170 a1fb16d8 2019-05-24 stsp const struct got_error *err = NULL;
3171 a1fb16d8 2019-05-24 stsp char *base_id_str;
3172 a1fb16d8 2019-05-24 stsp int ref_has_moved = 0;
3174 a1fb16d8 2019-05-24 stsp /* Trivial case: switching between two different references. */
3175 a1fb16d8 2019-05-24 stsp if (strcmp(got_ref_get_name(head_ref),
3176 a1fb16d8 2019-05-24 stsp got_worktree_get_head_ref_name(worktree)) != 0) {
3177 a1fb16d8 2019-05-24 stsp printf("Switching work tree from %s to %s\n",
3178 a1fb16d8 2019-05-24 stsp got_worktree_get_head_ref_name(worktree),
3179 a1fb16d8 2019-05-24 stsp got_ref_get_name(head_ref));
3180 a1fb16d8 2019-05-24 stsp return got_worktree_set_head_ref(worktree, head_ref);
3183 a1fb16d8 2019-05-24 stsp err = check_linear_ancestry(commit_id,
3184 3aef623b 2019-10-15 stsp got_worktree_get_base_commit_id(worktree), 0, repo);
3185 a1fb16d8 2019-05-24 stsp if (err) {
3186 a1fb16d8 2019-05-24 stsp if (err->code != GOT_ERR_ANCESTRY)
3187 a1fb16d8 2019-05-24 stsp return err;
3188 a1fb16d8 2019-05-24 stsp ref_has_moved = 1;
3190 a1fb16d8 2019-05-24 stsp if (!ref_has_moved)
3191 a1fb16d8 2019-05-24 stsp return NULL;
3193 a1fb16d8 2019-05-24 stsp /* Switching to a rebased branch with the same reference name. */
3194 a1fb16d8 2019-05-24 stsp err = got_object_id_str(&base_id_str,
3195 a1fb16d8 2019-05-24 stsp got_worktree_get_base_commit_id(worktree));
3197 a1fb16d8 2019-05-24 stsp return err;
3198 a1fb16d8 2019-05-24 stsp printf("Reference %s now points at a different branch\n",
3199 a1fb16d8 2019-05-24 stsp got_worktree_get_head_ref_name(worktree));
3200 a1fb16d8 2019-05-24 stsp printf("Switching work tree from %s to %s\n", base_id_str,
3201 a1fb16d8 2019-05-24 stsp got_worktree_get_head_ref_name(worktree));
3202 0ebf8283 2019-07-24 stsp return NULL;
3205 0ebf8283 2019-07-24 stsp static const struct got_error *
3206 0ebf8283 2019-07-24 stsp check_rebase_or_histedit_in_progress(struct got_worktree *worktree)
3208 0ebf8283 2019-07-24 stsp const struct got_error *err;
3209 0ebf8283 2019-07-24 stsp int in_progress;
3211 0ebf8283 2019-07-24 stsp err = got_worktree_rebase_in_progress(&in_progress, worktree);
3213 0ebf8283 2019-07-24 stsp return err;
3214 0ebf8283 2019-07-24 stsp if (in_progress)
3215 0ebf8283 2019-07-24 stsp return got_error(GOT_ERR_REBASING);
3217 0ebf8283 2019-07-24 stsp err = got_worktree_histedit_in_progress(&in_progress, worktree);
3219 0ebf8283 2019-07-24 stsp return err;
3220 0ebf8283 2019-07-24 stsp if (in_progress)
3221 0ebf8283 2019-07-24 stsp return got_error(GOT_ERR_HISTEDIT_BUSY);
3223 f259c4c1 2021-09-24 stsp return NULL;
3226 f259c4c1 2021-09-24 stsp static const struct got_error *
3227 f259c4c1 2021-09-24 stsp check_merge_in_progress(struct got_worktree *worktree,
3228 f259c4c1 2021-09-24 stsp struct got_repository *repo)
3230 f259c4c1 2021-09-24 stsp const struct got_error *err;
3231 f259c4c1 2021-09-24 stsp int in_progress;
3233 f259c4c1 2021-09-24 stsp err = got_worktree_merge_in_progress(&in_progress, worktree, repo);
3235 f259c4c1 2021-09-24 stsp return err;
3236 f259c4c1 2021-09-24 stsp if (in_progress)
3237 f259c4c1 2021-09-24 stsp return got_error(GOT_ERR_MERGE_BUSY);
3239 a1fb16d8 2019-05-24 stsp return NULL;
3242 a5edda0a 2019-07-27 stsp static const struct got_error *
3243 a5edda0a 2019-07-27 stsp get_worktree_paths_from_argv(struct got_pathlist_head *paths, int argc,
3244 a5edda0a 2019-07-27 stsp char *argv[], struct got_worktree *worktree)
3246 a0de39f3 2019-08-09 stsp const struct got_error *err = NULL;
3247 a5edda0a 2019-07-27 stsp char *path;
3248 10a623df 2021-10-11 stsp struct got_pathlist_entry *new;
3251 a5edda0a 2019-07-27 stsp if (argc == 0) {
3252 a5edda0a 2019-07-27 stsp path = strdup("");
3253 a5edda0a 2019-07-27 stsp if (path == NULL)
3254 a5edda0a 2019-07-27 stsp return got_error_from_errno("strdup");
3255 adc19d55 2019-07-28 stsp return got_pathlist_append(paths, path, NULL);
3258 a5edda0a 2019-07-27 stsp for (i = 0; i < argc; i++) {
3259 a5edda0a 2019-07-27 stsp err = got_worktree_resolve_path(&path, worktree, argv[i]);
3262 10a623df 2021-10-11 stsp err = got_pathlist_insert(&new, paths, path, NULL);
3263 10a623df 2021-10-11 stsp if (err || new == NULL /* duplicate */) {
3264 a5edda0a 2019-07-27 stsp free(path);
3270 a5edda0a 2019-07-27 stsp return err;
3273 a1fb16d8 2019-05-24 stsp static const struct got_error *
3274 fa51e947 2020-03-27 stsp wrap_not_worktree_error(const struct got_error *orig_err,
3275 fa51e947 2020-03-27 stsp const char *cmdname, const char *path)
3277 fa51e947 2020-03-27 stsp const struct got_error *err;
3278 fa51e947 2020-03-27 stsp struct got_repository *repo;
3279 fa51e947 2020-03-27 stsp static char msg[512];
3281 fa51e947 2020-03-27 stsp err = got_repo_open(&repo, path, NULL);
3283 fa51e947 2020-03-27 stsp return orig_err;
3285 fa51e947 2020-03-27 stsp snprintf(msg, sizeof(msg),
3286 fa51e947 2020-03-27 stsp "'got %s' needs a work tree in addition to a git repository\n"
3287 fa51e947 2020-03-27 stsp "Work trees can be checked out from this Git repository with "
3288 fa51e947 2020-03-27 stsp "'got checkout'.\n"
3289 fa51e947 2020-03-27 stsp "The got(1) manual page contains more information.", cmdname);
3290 fa51e947 2020-03-27 stsp err = got_error_msg(GOT_ERR_NOT_WORKTREE, msg);
3291 fa51e947 2020-03-27 stsp got_repo_close(repo);
3292 fa51e947 2020-03-27 stsp return err;
3295 fa51e947 2020-03-27 stsp static const struct got_error *
3296 507dc3bb 2018-12-29 stsp cmd_update(int argc, char *argv[])
3298 507dc3bb 2018-12-29 stsp const struct got_error *error = NULL;
3299 507dc3bb 2018-12-29 stsp struct got_repository *repo = NULL;
3300 507dc3bb 2018-12-29 stsp struct got_worktree *worktree = NULL;
3301 f2ea84fa 2019-07-27 stsp char *worktree_path = NULL;
3302 507dc3bb 2018-12-29 stsp struct got_object_id *commit_id = NULL;
3303 9c4b8182 2019-01-02 stsp char *commit_id_str = NULL;
3304 024e9686 2019-05-14 stsp const char *branch_name = NULL;
3305 024e9686 2019-05-14 stsp struct got_reference *head_ref = NULL;
3306 f2ea84fa 2019-07-27 stsp struct got_pathlist_head paths;
3307 f2ea84fa 2019-07-27 stsp struct got_pathlist_entry *pe;
3308 4ad4a1ec 2021-09-13 tracey int ch, verbosity = 0;
3309 9627c110 2020-04-18 stsp struct got_update_progress_arg upa;
3311 f2ea84fa 2019-07-27 stsp TAILQ_INIT(&paths);
3313 4ad4a1ec 2021-09-13 tracey while ((ch = getopt(argc, argv, "b:c:q")) != -1) {
3314 507dc3bb 2018-12-29 stsp switch (ch) {
3316 024e9686 2019-05-14 stsp branch_name = optarg;
3319 9c4b8182 2019-01-02 stsp commit_id_str = strdup(optarg);
3320 9c4b8182 2019-01-02 stsp if (commit_id_str == NULL)
3321 638f9024 2019-05-13 stsp return got_error_from_errno("strdup");
3323 4ad4a1ec 2021-09-13 tracey case 'q':
3324 4ad4a1ec 2021-09-13 tracey verbosity = -1;
3327 2deda0b9 2019-03-07 stsp usage_update();
3328 507dc3bb 2018-12-29 stsp /* NOTREACHED */
3332 507dc3bb 2018-12-29 stsp argc -= optind;
3333 507dc3bb 2018-12-29 stsp argv += optind;
3335 507dc3bb 2018-12-29 stsp #ifndef PROFILE
3336 68ed9ba5 2019-02-10 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
3337 68ed9ba5 2019-02-10 stsp "unveil", NULL) == -1)
3338 507dc3bb 2018-12-29 stsp err(1, "pledge");
3340 c4cdcb68 2019-04-03 stsp worktree_path = getcwd(NULL, 0);
3341 c4cdcb68 2019-04-03 stsp if (worktree_path == NULL) {
3342 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
3343 c4cdcb68 2019-04-03 stsp goto done;
3345 c4cdcb68 2019-04-03 stsp error = got_worktree_open(&worktree, worktree_path);
3346 fa51e947 2020-03-27 stsp if (error) {
3347 fa51e947 2020-03-27 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
3348 fa51e947 2020-03-27 stsp error = wrap_not_worktree_error(error, "update",
3349 fa51e947 2020-03-27 stsp worktree_path);
3350 7d5807f4 2019-07-11 stsp goto done;
3353 0ebf8283 2019-07-24 stsp error = check_rebase_or_histedit_in_progress(worktree);
3354 f2ea84fa 2019-07-27 stsp if (error)
3355 f2ea84fa 2019-07-27 stsp goto done;
3357 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
3359 507dc3bb 2018-12-29 stsp if (error != NULL)
3360 507dc3bb 2018-12-29 stsp goto done;
3362 97430839 2019-03-11 stsp error = apply_unveil(got_repo_get_path(repo), 0,
3363 c530dc23 2019-07-23 stsp got_worktree_get_root_path(worktree));
3364 087fb88c 2019-08-04 stsp if (error)
3365 087fb88c 2019-08-04 stsp goto done;
3367 f259c4c1 2021-09-24 stsp error = check_merge_in_progress(worktree, repo);
3368 f259c4c1 2021-09-24 stsp if (error)
3369 f259c4c1 2021-09-24 stsp goto done;
3371 087fb88c 2019-08-04 stsp error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
3372 0266afb7 2019-01-04 stsp if (error)
3373 0266afb7 2019-01-04 stsp goto done;
3375 a1fb16d8 2019-05-24 stsp error = got_ref_open(&head_ref, repo, branch_name ? branch_name :
3376 a1fb16d8 2019-05-24 stsp got_worktree_get_head_ref_name(worktree), 0);
3377 024e9686 2019-05-14 stsp if (error != NULL)
3378 024e9686 2019-05-14 stsp goto done;
3379 507dc3bb 2018-12-29 stsp if (commit_id_str == NULL) {
3380 507dc3bb 2018-12-29 stsp error = got_ref_resolve(&commit_id, repo, head_ref);
3381 9c4b8182 2019-01-02 stsp if (error != NULL)
3382 9c4b8182 2019-01-02 stsp goto done;
3383 9c4b8182 2019-01-02 stsp error = got_object_id_str(&commit_id_str, commit_id);
3384 507dc3bb 2018-12-29 stsp if (error != NULL)
3385 507dc3bb 2018-12-29 stsp goto done;
3387 84de9106 2020-12-26 stsp struct got_reflist_head refs;
3388 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
3389 84de9106 2020-12-26 stsp error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
3391 84de9106 2020-12-26 stsp if (error)
3392 84de9106 2020-12-26 stsp goto done;
3393 71a27632 2020-01-15 stsp error = got_repo_match_object_id(&commit_id, NULL,
3394 84de9106 2020-12-26 stsp commit_id_str, GOT_OBJ_TYPE_COMMIT, &refs, repo);
3395 84de9106 2020-12-26 stsp got_ref_list_free(&refs);
3396 04f57cb3 2019-07-25 stsp free(commit_id_str);
3397 bb787f09 2019-07-25 stsp commit_id_str = NULL;
3398 30837e32 2019-07-25 stsp if (error)
3399 a297e751 2019-07-11 stsp goto done;
3400 a297e751 2019-07-11 stsp error = got_object_id_str(&commit_id_str, commit_id);
3401 a297e751 2019-07-11 stsp if (error)
3402 507dc3bb 2018-12-29 stsp goto done;
3405 a1fb16d8 2019-05-24 stsp if (branch_name) {
3406 024e9686 2019-05-14 stsp struct got_object_id *head_commit_id;
3407 f2ea84fa 2019-07-27 stsp TAILQ_FOREACH(pe, &paths, entry) {
3408 f2b16ada 2019-08-02 stsp if (pe->path_len == 0)
3410 f2ea84fa 2019-07-27 stsp error = got_error_msg(GOT_ERR_BAD_PATH,
3411 f2ea84fa 2019-07-27 stsp "switching between branches requires that "
3412 f2ea84fa 2019-07-27 stsp "the entire work tree gets updated");
3413 024e9686 2019-05-14 stsp goto done;
3415 024e9686 2019-05-14 stsp error = got_ref_resolve(&head_commit_id, repo, head_ref);
3416 024e9686 2019-05-14 stsp if (error)
3417 024e9686 2019-05-14 stsp goto done;
3418 3aef623b 2019-10-15 stsp error = check_linear_ancestry(commit_id, head_commit_id, 0,
3420 a367ff0f 2019-05-14 stsp free(head_commit_id);
3421 024e9686 2019-05-14 stsp if (error != NULL)
3422 024e9686 2019-05-14 stsp goto done;
3423 a51a74b3 2019-07-27 stsp error = check_same_branch(commit_id, head_ref, NULL, repo);
3424 a367ff0f 2019-05-14 stsp if (error)
3425 a367ff0f 2019-05-14 stsp goto done;
3426 a1fb16d8 2019-05-24 stsp error = switch_head_ref(head_ref, commit_id, worktree, repo);
3427 024e9686 2019-05-14 stsp if (error)
3428 024e9686 2019-05-14 stsp goto done;
3430 024e9686 2019-05-14 stsp error = check_linear_ancestry(commit_id,
3431 3aef623b 2019-10-15 stsp got_worktree_get_base_commit_id(worktree), 0, repo);
3432 a367ff0f 2019-05-14 stsp if (error != NULL) {
3433 a367ff0f 2019-05-14 stsp if (error->code == GOT_ERR_ANCESTRY)
3434 a367ff0f 2019-05-14 stsp error = got_error(GOT_ERR_BRANCH_MOVED);
3435 024e9686 2019-05-14 stsp goto done;
3437 a51a74b3 2019-07-27 stsp error = check_same_branch(commit_id, head_ref, NULL, repo);
3438 a367ff0f 2019-05-14 stsp if (error)
3439 a367ff0f 2019-05-14 stsp goto done;
3442 507dc3bb 2018-12-29 stsp if (got_object_id_cmp(got_worktree_get_base_commit_id(worktree),
3443 507dc3bb 2018-12-29 stsp commit_id) != 0) {
3444 507dc3bb 2018-12-29 stsp error = got_worktree_set_base_commit_id(worktree, repo,
3445 507dc3bb 2018-12-29 stsp commit_id);
3446 507dc3bb 2018-12-29 stsp if (error)
3447 507dc3bb 2018-12-29 stsp goto done;
3450 9627c110 2020-04-18 stsp memset(&upa, 0, sizeof(upa));
3451 4ad4a1ec 2021-09-13 tracey upa.verbosity = verbosity;
3452 f2ea84fa 2019-07-27 stsp error = got_worktree_checkout_files(worktree, &paths, repo,
3453 9627c110 2020-04-18 stsp update_progress, &upa, check_cancelled, NULL);
3454 507dc3bb 2018-12-29 stsp if (error != NULL)
3455 507dc3bb 2018-12-29 stsp goto done;
3457 4f3c844b 2021-09-14 stsp if (upa.did_something) {
3458 4f3c844b 2021-09-14 stsp printf("Updated to %s: %s\n",
3459 4f3c844b 2021-09-14 stsp got_worktree_get_head_ref_name(worktree), commit_id_str);
3461 784955db 2019-01-12 stsp printf("Already up-to-date\n");
3462 9627c110 2020-04-18 stsp print_update_progress_stats(&upa);
3464 c09a553d 2018-03-12 stsp free(worktree_path);
3465 f2ea84fa 2019-07-27 stsp TAILQ_FOREACH(pe, &paths, entry)
3466 f2ea84fa 2019-07-27 stsp free((char *)pe->path);
3467 f2ea84fa 2019-07-27 stsp got_pathlist_free(&paths);
3468 507dc3bb 2018-12-29 stsp free(commit_id);
3469 9c4b8182 2019-01-02 stsp free(commit_id_str);
3470 c09a553d 2018-03-12 stsp return error;
3473 f42b1b34 2018-03-12 stsp static const struct got_error *
3474 44392932 2019-08-25 stsp diff_blobs(struct got_object_id *blob_id1, struct got_object_id *blob_id2,
3475 63035f9f 2019-10-06 stsp const char *path, int diff_context, int ignore_whitespace,
3476 64453f7e 2020-11-21 stsp int force_text_diff, struct got_repository *repo)
3478 f42b1b34 2018-03-12 stsp const struct got_error *err = NULL;
3479 44392932 2019-08-25 stsp struct got_blob_object *blob1 = NULL, *blob2 = NULL;
3481 44392932 2019-08-25 stsp if (blob_id1) {
3482 44392932 2019-08-25 stsp err = got_object_open_as_blob(&blob1, repo, blob_id1, 8192);
3484 44392932 2019-08-25 stsp goto done;
3487 44392932 2019-08-25 stsp err = got_object_open_as_blob(&blob2, repo, blob_id2, 8192);
3489 44392932 2019-08-25 stsp goto done;
3491 44392932 2019-08-25 stsp while (path[0] == '/')
3493 fe621944 2020-11-10 stsp err = got_diff_blob(NULL, NULL, blob1, blob2, path, path,
3494 64453f7e 2020-11-21 stsp diff_context, ignore_whitespace, force_text_diff, stdout);
3496 44392932 2019-08-25 stsp if (blob1)
3497 44392932 2019-08-25 stsp got_object_blob_close(blob1);
3498 44392932 2019-08-25 stsp got_object_blob_close(blob2);
3499 44392932 2019-08-25 stsp return err;
3502 44392932 2019-08-25 stsp static const struct got_error *
3503 44392932 2019-08-25 stsp diff_trees(struct got_object_id *tree_id1, struct got_object_id *tree_id2,
3504 63035f9f 2019-10-06 stsp const char *path, int diff_context, int ignore_whitespace,
3505 64453f7e 2020-11-21 stsp int force_text_diff, struct got_repository *repo)
3507 44392932 2019-08-25 stsp const struct got_error *err = NULL;
3508 44392932 2019-08-25 stsp struct got_tree_object *tree1 = NULL, *tree2 = NULL;
3509 44392932 2019-08-25 stsp struct got_diff_blob_output_unidiff_arg arg;
3511 44392932 2019-08-25 stsp if (tree_id1) {
3512 44392932 2019-08-25 stsp err = got_object_open_as_tree(&tree1, repo, tree_id1);
3514 44392932 2019-08-25 stsp goto done;
3517 44392932 2019-08-25 stsp err = got_object_open_as_tree(&tree2, repo, tree_id2);
3519 0f2b3dca 2018-12-22 stsp goto done;
3521 aaa13589 2019-06-01 stsp arg.diff_context = diff_context;
3522 63035f9f 2019-10-06 stsp arg.ignore_whitespace = ignore_whitespace;
3523 64453f7e 2020-11-21 stsp arg.force_text_diff = force_text_diff;
3524 aaa13589 2019-06-01 stsp arg.outfile = stdout;
3525 fe621944 2020-11-10 stsp arg.line_offsets = NULL;
3526 fe621944 2020-11-10 stsp arg.nlines = 0;
3527 44392932 2019-08-25 stsp while (path[0] == '/')
3529 44392932 2019-08-25 stsp err = got_diff_tree(tree1, tree2, path, path, repo,
3530 31b4484f 2019-07-27 stsp got_diff_blob_output_unidiff, &arg, 1);
3532 79109fed 2018-03-27 stsp if (tree1)
3533 79109fed 2018-03-27 stsp got_object_tree_close(tree1);
3534 366e0a5f 2019-10-10 stsp if (tree2)
3535 366e0a5f 2019-10-10 stsp got_object_tree_close(tree2);
3536 44392932 2019-08-25 stsp return err;
3539 44392932 2019-08-25 stsp static const struct got_error *
3540 0208f208 2020-05-05 stsp get_changed_paths(struct got_pathlist_head *paths,
3541 0208f208 2020-05-05 stsp struct got_commit_object *commit, struct got_repository *repo)
3543 0208f208 2020-05-05 stsp const struct got_error *err = NULL;
3544 0208f208 2020-05-05 stsp struct got_object_id *tree_id1 = NULL, *tree_id2 = NULL;
3545 0208f208 2020-05-05 stsp struct got_tree_object *tree1 = NULL, *tree2 = NULL;
3546 0208f208 2020-05-05 stsp struct got_object_qid *qid;
3548 dbdddfee 2021-06-23 naddy qid = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
3549 0208f208 2020-05-05 stsp if (qid != NULL) {
3550 0208f208 2020-05-05 stsp struct got_commit_object *pcommit;
3551 0208f208 2020-05-05 stsp err = got_object_open_as_commit(&pcommit, repo,
3554 0208f208 2020-05-05 stsp return err;
3556 aa8b5dd0 2021-08-01 stsp tree_id1 = got_object_id_dup(
3557 aa8b5dd0 2021-08-01 stsp got_object_commit_get_tree_id(pcommit));
3558 aa8b5dd0 2021-08-01 stsp if (tree_id1 == NULL) {
3559 aa8b5dd0 2021-08-01 stsp got_object_commit_close(pcommit);
3560 aa8b5dd0 2021-08-01 stsp return got_error_from_errno("got_object_id_dup");
3562 0208f208 2020-05-05 stsp got_object_commit_close(pcommit);
3566 0208f208 2020-05-05 stsp if (tree_id1) {
3567 0208f208 2020-05-05 stsp err = got_object_open_as_tree(&tree1, repo, tree_id1);
3569 0208f208 2020-05-05 stsp goto done;
3572 0208f208 2020-05-05 stsp tree_id2 = got_object_commit_get_tree_id(commit);
3573 0208f208 2020-05-05 stsp err = got_object_open_as_tree(&tree2, repo, tree_id2);
3575 0208f208 2020-05-05 stsp goto done;
3577 0208f208 2020-05-05 stsp err = got_diff_tree(tree1, tree2, "", "", repo,
3578 0208f208 2020-05-05 stsp got_diff_tree_collect_changed_paths, paths, 0);
3580 0208f208 2020-05-05 stsp if (tree1)
3581 0208f208 2020-05-05 stsp got_object_tree_close(tree1);
3582 0208f208 2020-05-05 stsp if (tree2)
3583 0208f208 2020-05-05 stsp got_object_tree_close(tree2);
3584 aa8b5dd0 2021-08-01 stsp free(tree_id1);
3585 0208f208 2020-05-05 stsp return err;
3588 0208f208 2020-05-05 stsp static const struct got_error *
3589 44392932 2019-08-25 stsp print_patch(struct got_commit_object *commit, struct got_object_id *id,
3590 44392932 2019-08-25 stsp const char *path, int diff_context, struct got_repository *repo)
3592 44392932 2019-08-25 stsp const struct got_error *err = NULL;
3593 44392932 2019-08-25 stsp struct got_commit_object *pcommit = NULL;
3594 44392932 2019-08-25 stsp char *id_str1 = NULL, *id_str2 = NULL;
3595 44392932 2019-08-25 stsp struct got_object_id *obj_id1 = NULL, *obj_id2 = NULL;
3596 44392932 2019-08-25 stsp struct got_object_qid *qid;
3598 dbdddfee 2021-06-23 naddy qid = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
3599 44392932 2019-08-25 stsp if (qid != NULL) {
3600 44392932 2019-08-25 stsp err = got_object_open_as_commit(&pcommit, repo,
3603 44392932 2019-08-25 stsp return err;
3606 44392932 2019-08-25 stsp if (path && path[0] != '\0') {
3607 44392932 2019-08-25 stsp int obj_type;
3608 44392932 2019-08-25 stsp err = got_object_id_by_path(&obj_id2, repo, id, path);
3610 44392932 2019-08-25 stsp goto done;
3611 44392932 2019-08-25 stsp err = got_object_id_str(&id_str2, obj_id2);
3612 44392932 2019-08-25 stsp if (err) {
3613 44392932 2019-08-25 stsp free(obj_id2);
3614 44392932 2019-08-25 stsp goto done;
3616 44392932 2019-08-25 stsp if (pcommit) {
3617 44392932 2019-08-25 stsp err = got_object_id_by_path(&obj_id1, repo,
3618 44392932 2019-08-25 stsp qid->id, path);
3619 44392932 2019-08-25 stsp if (err) {
3620 2e8c69d1 2020-05-04 stsp if (err->code != GOT_ERR_NO_TREE_ENTRY) {
3621 2e8c69d1 2020-05-04 stsp free(obj_id2);
3622 2e8c69d1 2020-05-04 stsp goto done;
3625 2e8c69d1 2020-05-04 stsp err = got_object_id_str(&id_str1, obj_id1);
3626 2e8c69d1 2020-05-04 stsp if (err) {
3627 2e8c69d1 2020-05-04 stsp free(obj_id2);
3628 2e8c69d1 2020-05-04 stsp goto done;
3632 44392932 2019-08-25 stsp err = got_object_get_type(&obj_type, repo, obj_id2);
3633 44392932 2019-08-25 stsp if (err) {
3634 44392932 2019-08-25 stsp free(obj_id2);
3635 44392932 2019-08-25 stsp goto done;
3637 44392932 2019-08-25 stsp printf("diff %s %s\n", id_str1 ? id_str1 : "/dev/null", id_str2);
3638 44392932 2019-08-25 stsp switch (obj_type) {
3639 44392932 2019-08-25 stsp case GOT_OBJ_TYPE_BLOB:
3640 44392932 2019-08-25 stsp err = diff_blobs(obj_id1, obj_id2, path, diff_context,
3641 64453f7e 2020-11-21 stsp 0, 0, repo);
3643 44392932 2019-08-25 stsp case GOT_OBJ_TYPE_TREE:
3644 44392932 2019-08-25 stsp err = diff_trees(obj_id1, obj_id2, path, diff_context,
3645 64453f7e 2020-11-21 stsp 0, 0, repo);
3648 44392932 2019-08-25 stsp err = got_error(GOT_ERR_OBJ_TYPE);
3651 44392932 2019-08-25 stsp free(obj_id1);
3652 44392932 2019-08-25 stsp free(obj_id2);
3654 44392932 2019-08-25 stsp obj_id2 = got_object_commit_get_tree_id(commit);
3655 44392932 2019-08-25 stsp err = got_object_id_str(&id_str2, obj_id2);
3657 44392932 2019-08-25 stsp goto done;
3658 579bd556 2020-10-24 stsp if (pcommit) {
3659 579bd556 2020-10-24 stsp obj_id1 = got_object_commit_get_tree_id(pcommit);
3660 579bd556 2020-10-24 stsp err = got_object_id_str(&id_str1, obj_id1);
3662 579bd556 2020-10-24 stsp goto done;
3664 64453f7e 2020-11-21 stsp printf("diff %s %s\n", id_str1 ? id_str1 : "/dev/null",
3666 64453f7e 2020-11-21 stsp err = diff_trees(obj_id1, obj_id2, "", diff_context, 0, 0,
3670 0f2b3dca 2018-12-22 stsp free(id_str1);
3671 0f2b3dca 2018-12-22 stsp free(id_str2);
3672 44392932 2019-08-25 stsp if (pcommit)
3673 44392932 2019-08-25 stsp got_object_commit_close(pcommit);
3674 79109fed 2018-03-27 stsp return err;
3677 4bb494d5 2018-06-16 stsp static char *
3678 6c281f94 2018-06-11 stsp get_datestr(time_t *time, char *datebuf)
3680 09867e48 2019-08-13 stsp struct tm mytm, *tm;
3681 09867e48 2019-08-13 stsp char *p, *s;
3683 09867e48 2019-08-13 stsp tm = gmtime_r(time, &mytm);
3684 09867e48 2019-08-13 stsp if (tm == NULL)
3685 09867e48 2019-08-13 stsp return NULL;
3686 09867e48 2019-08-13 stsp s = asctime_r(tm, datebuf);
3687 09867e48 2019-08-13 stsp if (s == NULL)
3688 09867e48 2019-08-13 stsp return NULL;
3689 6c281f94 2018-06-11 stsp p = strchr(s, '\n');
3691 6c281f94 2018-06-11 stsp *p = '\0';
3695 6841bf13 2019-11-29 kn static const struct got_error *
3696 6841bf13 2019-11-29 kn match_logmsg(int *have_match, struct got_object_id *id,
3697 6841bf13 2019-11-29 kn struct got_commit_object *commit, regex_t *regex)
3699 6841bf13 2019-11-29 kn const struct got_error *err = NULL;
3700 6841bf13 2019-11-29 kn regmatch_t regmatch;
3701 6841bf13 2019-11-29 kn char *id_str = NULL, *logmsg = NULL;
3703 6841bf13 2019-11-29 kn *have_match = 0;
3705 6841bf13 2019-11-29 kn err = got_object_id_str(&id_str, id);
3709 6841bf13 2019-11-29 kn err = got_object_commit_get_logmsg(&logmsg, commit);
3713 6841bf13 2019-11-29 kn if (regexec(regex, logmsg, 1, ®match, 0) == 0)
3714 6841bf13 2019-11-29 kn *have_match = 1;
3716 6841bf13 2019-11-29 kn free(id_str);
3717 6841bf13 2019-11-29 kn free(logmsg);
3721 0208f208 2020-05-05 stsp static void
3722 0208f208 2020-05-05 stsp match_changed_paths(int *have_match, struct got_pathlist_head *changed_paths,
3723 0208f208 2020-05-05 stsp regex_t *regex)
3725 0208f208 2020-05-05 stsp regmatch_t regmatch;
3726 0208f208 2020-05-05 stsp struct got_pathlist_entry *pe;
3728 0208f208 2020-05-05 stsp *have_match = 0;
3730 0208f208 2020-05-05 stsp TAILQ_FOREACH(pe, changed_paths, entry) {
3731 0208f208 2020-05-05 stsp if (regexec(regex, pe->path, 1, ®match, 0) == 0) {
3732 0208f208 2020-05-05 stsp *have_match = 1;
3738 dc424a06 2019-08-07 stsp #define GOT_COMMIT_SEP_STR "-----------------------------------------------\n"
3740 888b7d99 2020-12-26 stsp static const struct got_error*
3741 888b7d99 2020-12-26 stsp build_refs_str(char **refs_str, struct got_reflist_head *refs,
3742 888b7d99 2020-12-26 stsp struct got_object_id *id, struct got_repository *repo)
3744 888b7d99 2020-12-26 stsp static const struct got_error *err = NULL;
3745 199a4027 2019-02-02 stsp struct got_reflist_entry *re;
3747 888b7d99 2020-12-26 stsp const char *name;
3749 888b7d99 2020-12-26 stsp *refs_str = NULL;
3751 d9dff0e5 2020-12-26 stsp TAILQ_FOREACH(re, refs, entry) {
3752 a436ad14 2019-08-13 stsp struct got_tag_object *tag = NULL;
3753 48cae60d 2020-09-22 stsp struct got_object_id *ref_id;
3756 199a4027 2019-02-02 stsp name = got_ref_get_name(re->ref);
3757 d9498b20 2019-02-05 stsp if (strcmp(name, GOT_REF_HEAD) == 0)
3759 199a4027 2019-02-02 stsp if (strncmp(name, "refs/", 5) == 0)
3760 199a4027 2019-02-02 stsp name += 5;
3761 7143d404 2019-03-12 stsp if (strncmp(name, "got/", 4) == 0)
3763 e34f9ed6 2019-02-02 stsp if (strncmp(name, "heads/", 6) == 0)
3764 e34f9ed6 2019-02-02 stsp name += 6;
3765 4343a07f 2020-04-24 stsp if (strncmp(name, "remotes/", 8) == 0) {
3766 141c2bff 2019-02-04 stsp name += 8;
3767 4343a07f 2020-04-24 stsp s = strstr(name, "/" GOT_REF_HEAD);
3768 4343a07f 2020-04-24 stsp if (s != NULL && s[strlen(s)] == '\0')
3771 48cae60d 2020-09-22 stsp err = got_ref_resolve(&ref_id, repo, re->ref);
3774 a436ad14 2019-08-13 stsp if (strncmp(name, "tags/", 5) == 0) {
3775 48cae60d 2020-09-22 stsp err = got_object_open_as_tag(&tag, repo, ref_id);
3776 5d844a1e 2019-08-13 stsp if (err) {
3777 48cae60d 2020-09-22 stsp if (err->code != GOT_ERR_OBJ_TYPE) {
3778 48cae60d 2020-09-22 stsp free(ref_id);
3781 5d844a1e 2019-08-13 stsp /* Ref points at something other than a tag. */
3782 5d844a1e 2019-08-13 stsp err = NULL;
3783 5d844a1e 2019-08-13 stsp tag = NULL;
3786 a436ad14 2019-08-13 stsp cmp = got_object_id_cmp(tag ?
3787 48cae60d 2020-09-22 stsp got_object_tag_get_object_id(tag) : ref_id, id);
3788 48cae60d 2020-09-22 stsp free(ref_id);
3790 a436ad14 2019-08-13 stsp got_object_tag_close(tag);
3791 a436ad14 2019-08-13 stsp if (cmp != 0)
3793 888b7d99 2020-12-26 stsp s = *refs_str;
3794 888b7d99 2020-12-26 stsp if (asprintf(refs_str, "%s%s%s", s ? s : "",
3795 888b7d99 2020-12-26 stsp s ? ", " : "", name) == -1) {
3796 638f9024 2019-05-13 stsp err = got_error_from_errno("asprintf");
3798 888b7d99 2020-12-26 stsp *refs_str = NULL;
3804 888b7d99 2020-12-26 stsp return err;
3807 888b7d99 2020-12-26 stsp static const struct got_error *
3808 888b7d99 2020-12-26 stsp print_commit(struct got_commit_object *commit, struct got_object_id *id,
3809 888b7d99 2020-12-26 stsp struct got_repository *repo, const char *path,
3810 888b7d99 2020-12-26 stsp struct got_pathlist_head *changed_paths, int show_patch,
3811 e600f124 2021-03-21 stsp int diff_context, struct got_reflist_object_id_map *refs_idmap,
3812 e600f124 2021-03-21 stsp const char *custom_refs_str)
3814 888b7d99 2020-12-26 stsp const struct got_error *err = NULL;
3815 888b7d99 2020-12-26 stsp char *id_str, *datestr, *logmsg0, *logmsg, *line;
3816 888b7d99 2020-12-26 stsp char datebuf[26];
3817 888b7d99 2020-12-26 stsp time_t committer_time;
3818 888b7d99 2020-12-26 stsp const char *author, *committer;
3819 888b7d99 2020-12-26 stsp char *refs_str = NULL;
3821 832c249c 2018-06-10 stsp err = got_object_id_str(&id_str, id);
3823 8bf5b3c9 2018-03-17 stsp return err;
3825 e600f124 2021-03-21 stsp if (custom_refs_str == NULL) {
3826 e600f124 2021-03-21 stsp struct got_reflist_head *refs;
3827 e600f124 2021-03-21 stsp refs = got_reflist_object_id_map_lookup(refs_idmap, id);
3828 e600f124 2021-03-21 stsp if (refs) {
3829 e600f124 2021-03-21 stsp err = build_refs_str(&refs_str, refs, id, repo);
3831 e600f124 2021-03-21 stsp goto done;
3835 dc424a06 2019-08-07 stsp printf(GOT_COMMIT_SEP_STR);
3836 e600f124 2021-03-21 stsp if (custom_refs_str)
3837 e600f124 2021-03-21 stsp printf("commit %s (%s)\n", id_str, custom_refs_str);
3839 e600f124 2021-03-21 stsp printf("commit %s%s%s%s\n", id_str, refs_str ? " (" : "",
3840 e600f124 2021-03-21 stsp refs_str ? refs_str : "", refs_str ? ")" : "");
3841 832c249c 2018-06-10 stsp free(id_str);
3842 d3d493d7 2019-02-21 stsp id_str = NULL;
3843 d3d493d7 2019-02-21 stsp free(refs_str);
3844 d3d493d7 2019-02-21 stsp refs_str = NULL;
3845 45d799e2 2018-12-23 stsp printf("from: %s\n", got_object_commit_get_author(commit));
3846 45d799e2 2018-12-23 stsp committer_time = got_object_commit_get_committer_time(commit);
3847 45d799e2 2018-12-23 stsp datestr = get_datestr(&committer_time, datebuf);
3848 09867e48 2019-08-13 stsp if (datestr)
3849 09867e48 2019-08-13 stsp printf("date: %s UTC\n", datestr);
3850 45d799e2 2018-12-23 stsp author = got_object_commit_get_author(commit);
3851 45d799e2 2018-12-23 stsp committer = got_object_commit_get_committer(commit);
3852 45d799e2 2018-12-23 stsp if (strcmp(author, committer) != 0)
3853 45d799e2 2018-12-23 stsp printf("via: %s\n", committer);
3854 45d799e2 2018-12-23 stsp if (got_object_commit_get_nparents(commit) > 1) {
3855 45d799e2 2018-12-23 stsp const struct got_object_id_queue *parent_ids;
3856 79f35eb3 2018-06-11 stsp struct got_object_qid *qid;
3857 3fe1abad 2018-06-10 stsp int n = 1;
3858 45d799e2 2018-12-23 stsp parent_ids = got_object_commit_get_parent_ids(commit);
3859 dbdddfee 2021-06-23 naddy STAILQ_FOREACH(qid, parent_ids, entry) {
3860 79f35eb3 2018-06-11 stsp err = got_object_id_str(&id_str, qid->id);
3862 888b7d99 2020-12-26 stsp goto done;
3863 3fe1abad 2018-06-10 stsp printf("parent %d: %s\n", n++, id_str);
3864 a0603db2 2018-06-10 stsp free(id_str);
3865 888b7d99 2020-12-26 stsp id_str = NULL;
3869 5943eee2 2019-08-13 stsp err = got_object_commit_get_logmsg(&logmsg0, commit);
3871 888b7d99 2020-12-26 stsp goto done;
3873 621015ac 2018-07-23 stsp logmsg = logmsg0;
3875 832c249c 2018-06-10 stsp line = strsep(&logmsg, "\n");
3877 832c249c 2018-06-10 stsp printf(" %s\n", line);
3878 832c249c 2018-06-10 stsp } while (line);
3879 621015ac 2018-07-23 stsp free(logmsg0);
3881 0208f208 2020-05-05 stsp if (changed_paths) {
3882 0208f208 2020-05-05 stsp struct got_pathlist_entry *pe;
3883 0208f208 2020-05-05 stsp TAILQ_FOREACH(pe, changed_paths, entry) {
3884 0208f208 2020-05-05 stsp struct got_diff_changed_path *cp = pe->data;
3885 0208f208 2020-05-05 stsp printf(" %c %s\n", cp->status, pe->path);
3887 0208f208 2020-05-05 stsp printf("\n");
3889 971751ac 2018-03-27 stsp if (show_patch) {
3890 44392932 2019-08-25 stsp err = print_patch(commit, id, path, diff_context, repo);
3891 971751ac 2018-03-27 stsp if (err == 0)
3892 971751ac 2018-03-27 stsp printf("\n");
3895 cbe7f848 2019-02-11 stsp if (fflush(stdout) != 0 && err == NULL)
3896 638f9024 2019-05-13 stsp err = got_error_from_errno("fflush");
3898 888b7d99 2020-12-26 stsp free(id_str);
3899 888b7d99 2020-12-26 stsp free(refs_str);
3900 07862c20 2018-09-15 stsp return err;
3903 f42b1b34 2018-03-12 stsp static const struct got_error *
3904 d1fe46f9 2020-04-18 stsp print_commits(struct got_object_id *root_id, struct got_object_id *end_id,
3905 0208f208 2020-05-05 stsp struct got_repository *repo, const char *path, int show_changed_paths,
3906 0208f208 2020-05-05 stsp int show_patch, const char *search_pattern, int diff_context, int limit,
3907 888b7d99 2020-12-26 stsp int log_branches, int reverse_display_order,
3908 888b7d99 2020-12-26 stsp struct got_reflist_object_id_map *refs_idmap)
3910 f42b1b34 2018-03-12 stsp const struct got_error *err;
3911 372ccdbb 2018-06-10 stsp struct got_commit_graph *graph;
3912 6841bf13 2019-11-29 kn regex_t regex;
3913 6841bf13 2019-11-29 kn int have_match;
3914 dbec59df 2020-04-18 stsp struct got_object_id_queue reversed_commits;
3915 dbec59df 2020-04-18 stsp struct got_object_qid *qid;
3916 dbec59df 2020-04-18 stsp struct got_commit_object *commit;
3917 0208f208 2020-05-05 stsp struct got_pathlist_head changed_paths;
3918 0208f208 2020-05-05 stsp struct got_pathlist_entry *pe;
3920 dbdddfee 2021-06-23 naddy STAILQ_INIT(&reversed_commits);
3921 0208f208 2020-05-05 stsp TAILQ_INIT(&changed_paths);
3923 ccecc9fd 2020-04-18 stsp if (search_pattern && regcomp(®ex, search_pattern,
3924 ccecc9fd 2020-04-18 stsp REG_EXTENDED | REG_NOSUB | REG_NEWLINE))
3925 6841bf13 2019-11-29 kn return got_error_msg(GOT_ERR_REGEX, search_pattern);
3927 48c8c60d 2020-01-27 stsp err = got_commit_graph_open(&graph, path, !log_branches);
3929 f42b1b34 2018-03-12 stsp return err;
3930 6fb7cd11 2019-08-22 stsp err = got_commit_graph_iter_start(graph, root_id, repo,
3931 6fb7cd11 2019-08-22 stsp check_cancelled, NULL);
3933 fcc85cad 2018-07-22 stsp goto done;
3935 372ccdbb 2018-06-10 stsp struct got_object_id *id;
3937 84453469 2018-11-11 stsp if (sigint_received || sigpipe_received)
3940 ee780d5c 2020-01-04 stsp err = got_commit_graph_iter_next(&id, graph, repo,
3941 ee780d5c 2020-01-04 stsp check_cancelled, NULL);
3942 372ccdbb 2018-06-10 stsp if (err) {
3943 ee780d5c 2020-01-04 stsp if (err->code == GOT_ERR_ITER_COMPLETED)
3944 9ba79e04 2018-06-11 stsp err = NULL;
3947 b43fbaa0 2018-06-11 stsp if (id == NULL)
3950 f8e900f3 2018-06-11 stsp err = got_object_open_as_commit(&commit, repo, id);
3954 502b9684 2020-07-31 stsp if (show_changed_paths && !reverse_display_order) {
3955 0208f208 2020-05-05 stsp err = get_changed_paths(&changed_paths, commit, repo);
3960 6841bf13 2019-11-29 kn if (search_pattern) {
3961 6841bf13 2019-11-29 kn err = match_logmsg(&have_match, id, commit, ®ex);
3963 6841bf13 2019-11-29 kn got_object_commit_close(commit);
3966 0208f208 2020-05-05 stsp if (have_match == 0 && show_changed_paths)
3967 0208f208 2020-05-05 stsp match_changed_paths(&have_match,
3968 0208f208 2020-05-05 stsp &changed_paths, ®ex);
3969 6841bf13 2019-11-29 kn if (have_match == 0) {
3970 6841bf13 2019-11-29 kn got_object_commit_close(commit);
3971 0208f208 2020-05-05 stsp TAILQ_FOREACH(pe, &changed_paths, entry) {
3972 0208f208 2020-05-05 stsp free((char *)pe->path);
3973 0208f208 2020-05-05 stsp free(pe->data);
3975 0208f208 2020-05-05 stsp got_pathlist_free(&changed_paths);
3980 dbec59df 2020-04-18 stsp if (reverse_display_order) {
3981 dbec59df 2020-04-18 stsp err = got_object_qid_alloc(&qid, id);
3984 dbdddfee 2021-06-23 naddy STAILQ_INSERT_HEAD(&reversed_commits, qid, entry);
3985 dbec59df 2020-04-18 stsp got_object_commit_close(commit);
3987 0208f208 2020-05-05 stsp err = print_commit(commit, id, repo, path,
3988 0208f208 2020-05-05 stsp show_changed_paths ? &changed_paths : NULL,
3989 e600f124 2021-03-21 stsp show_patch, diff_context, refs_idmap, NULL);
3990 dbec59df 2020-04-18 stsp got_object_commit_close(commit);
3994 dbec59df 2020-04-18 stsp if ((limit && --limit == 0) ||
3995 dbec59df 2020-04-18 stsp (end_id && got_object_id_cmp(id, end_id) == 0))
3998 0208f208 2020-05-05 stsp TAILQ_FOREACH(pe, &changed_paths, entry) {
3999 0208f208 2020-05-05 stsp free((char *)pe->path);
4000 0208f208 2020-05-05 stsp free(pe->data);
4002 0208f208 2020-05-05 stsp got_pathlist_free(&changed_paths);
4004 dbec59df 2020-04-18 stsp if (reverse_display_order) {
4005 dbdddfee 2021-06-23 naddy STAILQ_FOREACH(qid, &reversed_commits, entry) {
4006 dbec59df 2020-04-18 stsp err = got_object_open_as_commit(&commit, repo, qid->id);
4009 502b9684 2020-07-31 stsp if (show_changed_paths) {
4010 502b9684 2020-07-31 stsp err = get_changed_paths(&changed_paths,
4011 502b9684 2020-07-31 stsp commit, repo);
4015 dbec59df 2020-04-18 stsp err = print_commit(commit, qid->id, repo, path,
4016 0208f208 2020-05-05 stsp show_changed_paths ? &changed_paths : NULL,
4017 e600f124 2021-03-21 stsp show_patch, diff_context, refs_idmap, NULL);
4018 dbec59df 2020-04-18 stsp got_object_commit_close(commit);
4021 502b9684 2020-07-31 stsp TAILQ_FOREACH(pe, &changed_paths, entry) {
4022 502b9684 2020-07-31 stsp free((char *)pe->path);
4023 502b9684 2020-07-31 stsp free(pe->data);
4025 502b9684 2020-07-31 stsp got_pathlist_free(&changed_paths);
4029 dbdddfee 2021-06-23 naddy while (!STAILQ_EMPTY(&reversed_commits)) {
4030 dbdddfee 2021-06-23 naddy qid = STAILQ_FIRST(&reversed_commits);
4031 dbdddfee 2021-06-23 naddy STAILQ_REMOVE_HEAD(&reversed_commits, entry);
4032 dbec59df 2020-04-18 stsp got_object_qid_free(qid);
4034 0208f208 2020-05-05 stsp TAILQ_FOREACH(pe, &changed_paths, entry) {
4035 0208f208 2020-05-05 stsp free((char *)pe->path);
4036 0208f208 2020-05-05 stsp free(pe->data);
4038 0208f208 2020-05-05 stsp got_pathlist_free(&changed_paths);
4039 6841bf13 2019-11-29 kn if (search_pattern)
4040 6841bf13 2019-11-29 kn regfree(®ex);
4041 372ccdbb 2018-06-10 stsp got_commit_graph_close(graph);
4042 f42b1b34 2018-03-12 stsp return err;
4045 4ed7e80c 2018-05-20 stsp __dead static void
4046 6f3d1eb0 2018-03-12 stsp usage_log(void)
4048 d1fe46f9 2020-04-18 stsp fprintf(stderr, "usage: %s log [-b] [-c commit] [-C number] [ -l N ] "
4049 0208f208 2020-05-05 stsp "[-p] [-P] [-x commit] [-s search-pattern] [-r repository-path] "
4050 0208f208 2020-05-05 stsp "[-R] [path]\n", getprogname());
4054 b1ebc001 2019-08-13 stsp static int
4055 b1ebc001 2019-08-13 stsp get_default_log_limit(void)
4057 b1ebc001 2019-08-13 stsp const char *got_default_log_limit;
4058 b1ebc001 2019-08-13 stsp long long n;
4059 b1ebc001 2019-08-13 stsp const char *errstr;
4061 b1ebc001 2019-08-13 stsp got_default_log_limit = getenv("GOT_LOG_DEFAULT_LIMIT");
4062 b1ebc001 2019-08-13 stsp if (got_default_log_limit == NULL)
4064 b1ebc001 2019-08-13 stsp n = strtonum(got_default_log_limit, 0, INT_MAX, &errstr);
4065 b1ebc001 2019-08-13 stsp if (errstr != NULL)
4070 4ed7e80c 2018-05-20 stsp static const struct got_error *
4071 f42b1b34 2018-03-12 stsp cmd_log(int argc, char *argv[])
4073 f42b1b34 2018-03-12 stsp const struct got_error *error;
4074 04ca23f4 2018-07-16 stsp struct got_repository *repo = NULL;
4075 cffc0aa4 2019-02-05 stsp struct got_worktree *worktree = NULL;
4076 d1fe46f9 2020-04-18 stsp struct got_object_id *start_id = NULL, *end_id = NULL;
4077 04ca23f4 2018-07-16 stsp char *repo_path = NULL, *path = NULL, *cwd = NULL, *in_repo_path = NULL;
4078 d1fe46f9 2020-04-18 stsp const char *start_commit = NULL, *end_commit = NULL;
4079 d1fe46f9 2020-04-18 stsp const char *search_pattern = NULL;
4080 dc1edbfa 2019-11-29 kn int diff_context = -1, ch;
4081 0208f208 2020-05-05 stsp int show_changed_paths = 0, show_patch = 0, limit = 0, log_branches = 0;
4082 dbec59df 2020-04-18 stsp int reverse_display_order = 0;
4083 64a96a6d 2018-04-01 stsp const char *errstr;
4084 199a4027 2019-02-02 stsp struct got_reflist_head refs;
4085 888b7d99 2020-12-26 stsp struct got_reflist_object_id_map *refs_idmap = NULL;
4087 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
4089 6715a751 2018-03-16 stsp #ifndef PROFILE
4090 6098196c 2019-01-04 stsp if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
4093 f42b1b34 2018-03-12 stsp err(1, "pledge");
4096 b1ebc001 2019-08-13 stsp limit = get_default_log_limit();
4098 0208f208 2020-05-05 stsp while ((ch = getopt(argc, argv, "bpPc:C:l:r:Rs:x:")) != -1) {
4099 79109fed 2018-03-27 stsp switch (ch) {
4101 79109fed 2018-03-27 stsp show_patch = 1;
4104 0208f208 2020-05-05 stsp show_changed_paths = 1;
4107 d142fc45 2018-04-01 stsp start_commit = optarg;
4110 4a8520aa 2018-10-18 stsp diff_context = strtonum(optarg, 0, GOT_DIFF_MAX_CONTEXT,
4112 c0cc5c62 2018-10-18 stsp if (errstr != NULL)
4113 c0cc5c62 2018-10-18 stsp err(1, "-C option %s", errstr);
4116 b1ebc001 2019-08-13 stsp limit = strtonum(optarg, 0, INT_MAX, &errstr);
4117 64a96a6d 2018-04-01 stsp if (errstr != NULL)
4118 64a96a6d 2018-04-01 stsp err(1, "-l option %s", errstr);
4121 48c8c60d 2020-01-27 stsp log_branches = 1;
4124 04ca23f4 2018-07-16 stsp repo_path = realpath(optarg, NULL);
4125 04ca23f4 2018-07-16 stsp if (repo_path == NULL)
4126 9ba1d308 2019-10-21 stsp return got_error_from_errno2("realpath",
4128 7fbaa4f3 2019-05-11 stsp got_path_strip_trailing_slashes(repo_path);
4131 dbec59df 2020-04-18 stsp reverse_display_order = 1;
4134 6841bf13 2019-11-29 kn search_pattern = optarg;
4137 d1fe46f9 2020-04-18 stsp end_commit = optarg;
4140 2deda0b9 2019-03-07 stsp usage_log();
4141 79109fed 2018-03-27 stsp /* NOTREACHED */
4145 79109fed 2018-03-27 stsp argc -= optind;
4146 79109fed 2018-03-27 stsp argv += optind;
4148 dc1edbfa 2019-11-29 kn if (diff_context == -1)
4149 dc1edbfa 2019-11-29 kn diff_context = 3;
4150 dc1edbfa 2019-11-29 kn else if (!show_patch)
4151 0429cd76 2020-09-15 naddy errx(1, "-C requires -p");
4153 04ca23f4 2018-07-16 stsp cwd = getcwd(NULL, 0);
4154 04ca23f4 2018-07-16 stsp if (cwd == NULL) {
4155 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
4156 04ca23f4 2018-07-16 stsp goto done;
4159 50f2fada 2020-04-24 stsp if (repo_path == NULL) {
4160 50f2fada 2020-04-24 stsp error = got_worktree_open(&worktree, cwd);
4161 50f2fada 2020-04-24 stsp if (error && error->code != GOT_ERR_NOT_WORKTREE)
4162 50f2fada 2020-04-24 stsp goto done;
4163 50f2fada 2020-04-24 stsp error = NULL;
4166 603cdeb0 2020-10-22 stsp if (argc == 1) {
4167 e7301579 2019-03-18 stsp if (worktree) {
4168 e7301579 2019-03-18 stsp error = got_worktree_resolve_path(&path, worktree,
4170 e7301579 2019-03-18 stsp if (error)
4171 e7301579 2019-03-18 stsp goto done;
4173 e7301579 2019-03-18 stsp path = strdup(argv[0]);
4174 e7301579 2019-03-18 stsp if (path == NULL) {
4175 638f9024 2019-05-13 stsp error = got_error_from_errno("strdup");
4176 e7301579 2019-03-18 stsp goto done;
4179 603cdeb0 2020-10-22 stsp } else if (argc != 0)
4180 cbd1af7a 2019-03-18 stsp usage_log();
4182 5486daa2 2019-05-11 stsp if (repo_path == NULL) {
4183 5486daa2 2019-05-11 stsp repo_path = worktree ?
4184 5486daa2 2019-05-11 stsp strdup(got_worktree_get_repo_path(worktree)) : strdup(cwd);
4186 04ca23f4 2018-07-16 stsp if (repo_path == NULL) {
4187 638f9024 2019-05-13 stsp error = got_error_from_errno("strdup");
4188 cffc0aa4 2019-02-05 stsp goto done;
4191 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, repo_path, NULL);
4192 d7d4f210 2018-03-12 stsp if (error != NULL)
4193 04ca23f4 2018-07-16 stsp goto done;
4195 c02c541e 2019-03-29 stsp error = apply_unveil(got_repo_get_path(repo), 1,
4196 c530dc23 2019-07-23 stsp worktree ? got_worktree_get_root_path(worktree) : NULL);
4197 c02c541e 2019-03-29 stsp if (error)
4198 c02c541e 2019-03-29 stsp goto done;
4200 84de9106 2020-12-26 stsp error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
4201 84de9106 2020-12-26 stsp if (error)
4202 84de9106 2020-12-26 stsp goto done;
4204 888b7d99 2020-12-26 stsp error = got_reflist_object_id_map_create(&refs_idmap, &refs, repo);
4205 888b7d99 2020-12-26 stsp if (error)
4206 888b7d99 2020-12-26 stsp goto done;
4208 d142fc45 2018-04-01 stsp if (start_commit == NULL) {
4209 3235492e 2018-04-01 stsp struct got_reference *head_ref;
4210 d1fe46f9 2020-04-18 stsp struct got_commit_object *commit = NULL;
4211 1cc14b9f 2019-05-14 stsp error = got_ref_open(&head_ref, repo,
4212 1cc14b9f 2019-05-14 stsp worktree ? got_worktree_get_head_ref_name(worktree)
4213 1cc14b9f 2019-05-14 stsp : GOT_REF_HEAD, 0);
4214 3235492e 2018-04-01 stsp if (error != NULL)
4215 d1fe46f9 2020-04-18 stsp goto done;
4216 d1fe46f9 2020-04-18 stsp error = got_ref_resolve(&start_id, repo, head_ref);
4217 3235492e 2018-04-01 stsp got_ref_close(head_ref);
4218 3235492e 2018-04-01 stsp if (error != NULL)
4219 d1fe46f9 2020-04-18 stsp goto done;
4220 d1fe46f9 2020-04-18 stsp error = got_object_open_as_commit(&commit, repo,
4221 d1fe46f9 2020-04-18 stsp start_id);
4222 d1fe46f9 2020-04-18 stsp if (error != NULL)
4223 d1fe46f9 2020-04-18 stsp goto done;
4224 d1fe46f9 2020-04-18 stsp got_object_commit_close(commit);
4226 7f9bfb31 2020-11-01 stsp error = got_repo_match_object_id(&start_id, NULL,
4227 84de9106 2020-12-26 stsp start_commit, GOT_OBJ_TYPE_COMMIT, &refs, repo);
4228 d1fe46f9 2020-04-18 stsp if (error != NULL)
4229 d1fe46f9 2020-04-18 stsp goto done;
4231 d1fe46f9 2020-04-18 stsp if (end_commit != NULL) {
4232 7f9bfb31 2020-11-01 stsp error = got_repo_match_object_id(&end_id, NULL,
4233 84de9106 2020-12-26 stsp end_commit, GOT_OBJ_TYPE_COMMIT, &refs, repo);
4234 d1fe46f9 2020-04-18 stsp if (error != NULL)
4235 d1fe46f9 2020-04-18 stsp goto done;
4238 deeabeae 2019-08-27 stsp if (worktree) {
4240 603cdeb0 2020-10-22 stsp * If a path was specified on the command line it was resolved
4241 603cdeb0 2020-10-22 stsp * to a path in the work tree above. Prepend the work tree's
4242 603cdeb0 2020-10-22 stsp * path prefix to obtain the corresponding in-repository path.
4244 603cdeb0 2020-10-22 stsp if (path) {
4245 603cdeb0 2020-10-22 stsp const char *prefix;
4246 603cdeb0 2020-10-22 stsp prefix = got_worktree_get_path_prefix(worktree);
4247 603cdeb0 2020-10-22 stsp if (asprintf(&in_repo_path, "%s%s%s", prefix,
4248 603cdeb0 2020-10-22 stsp (path[0] != '\0') ? "/" : "", path) == -1) {
4249 603cdeb0 2020-10-22 stsp error = got_error_from_errno("asprintf");
4250 603cdeb0 2020-10-22 stsp goto done;
4254 603cdeb0 2020-10-22 stsp error = got_repo_map_path(&in_repo_path, repo,
4255 8fa913ec 2020-11-14 stsp path ? path : "");
4256 04ca23f4 2018-07-16 stsp if (error != NULL)
4257 04ca23f4 2018-07-16 stsp goto done;
4258 04ca23f4 2018-07-16 stsp if (in_repo_path) {
4259 04ca23f4 2018-07-16 stsp free(path);
4260 04ca23f4 2018-07-16 stsp path = in_repo_path;
4263 603cdeb0 2020-10-22 stsp error = print_commits(start_id, end_id, repo, path ? path : "",
4264 603cdeb0 2020-10-22 stsp show_changed_paths, show_patch, search_pattern, diff_context,
4265 888b7d99 2020-12-26 stsp limit, log_branches, reverse_display_order, refs_idmap);
4267 04ca23f4 2018-07-16 stsp free(path);
4268 04ca23f4 2018-07-16 stsp free(repo_path);
4269 04ca23f4 2018-07-16 stsp free(cwd);
4270 cffc0aa4 2019-02-05 stsp if (worktree)
4271 cffc0aa4 2019-02-05 stsp got_worktree_close(worktree);
4272 ad242220 2018-09-08 stsp if (repo) {
4273 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
4274 ad242220 2018-09-08 stsp if (error == NULL)
4275 1d0f4054 2021-06-17 stsp error = close_err;
4277 888b7d99 2020-12-26 stsp if (refs_idmap)
4278 888b7d99 2020-12-26 stsp got_reflist_object_id_map_free(refs_idmap);
4279 e2e879a0 2019-03-11 stsp got_ref_list_free(&refs);
4280 8bf5b3c9 2018-03-17 stsp return error;
4283 4ed7e80c 2018-05-20 stsp __dead static void
4284 3f8b7d6a 2018-04-01 stsp usage_diff(void)
4286 51ed7429 2021-10-10 stsp fprintf(stderr, "usage: %s diff [-a] [-c commit] [-C number] "
4287 51ed7429 2021-10-10 stsp "[-r repository-path] [-s] [-w] [-P] "
4288 51ed7429 2021-10-10 stsp "[object1 object2 | path ...]\n", getprogname());
4292 b72f483a 2019-02-05 stsp struct print_diff_arg {
4293 b72f483a 2019-02-05 stsp struct got_repository *repo;
4294 b72f483a 2019-02-05 stsp struct got_worktree *worktree;
4295 b72f483a 2019-02-05 stsp int diff_context;
4296 3fc0c068 2019-02-10 stsp const char *id_str;
4297 3fc0c068 2019-02-10 stsp int header_shown;
4298 98eaaa12 2019-08-03 stsp int diff_staged;
4299 63035f9f 2019-10-06 stsp int ignore_whitespace;
4300 64453f7e 2020-11-21 stsp int force_text_diff;
4304 39449a05 2020-07-23 stsp * Create a file which contains the target path of a symlink so we can feed
4305 39449a05 2020-07-23 stsp * it as content to the diff engine.
4307 39449a05 2020-07-23 stsp static const struct got_error *
4308 39449a05 2020-07-23 stsp get_symlink_target_file(int *fd, int dirfd, const char *de_name,
4309 39449a05 2020-07-23 stsp const char *abspath)
4311 39449a05 2020-07-23 stsp const struct got_error *err = NULL;
4312 39449a05 2020-07-23 stsp char target_path[PATH_MAX];
4313 39449a05 2020-07-23 stsp ssize_t target_len, outlen;
4317 39449a05 2020-07-23 stsp if (dirfd != -1) {
4318 39449a05 2020-07-23 stsp target_len = readlinkat(dirfd, de_name, target_path, PATH_MAX);
4319 39449a05 2020-07-23 stsp if (target_len == -1)
4320 39449a05 2020-07-23 stsp return got_error_from_errno2("readlinkat", abspath);
4322 39449a05 2020-07-23 stsp target_len = readlink(abspath, target_path, PATH_MAX);
4323 39449a05 2020-07-23 stsp if (target_len == -1)
4324 39449a05 2020-07-23 stsp return got_error_from_errno2("readlink", abspath);
4327 39449a05 2020-07-23 stsp *fd = got_opentempfd();
4328 39449a05 2020-07-23 stsp if (*fd == -1)
4329 39449a05 2020-07-23 stsp return got_error_from_errno("got_opentempfd");
4331 39449a05 2020-07-23 stsp outlen = write(*fd, target_path, target_len);
4332 39449a05 2020-07-23 stsp if (outlen == -1) {
4333 39449a05 2020-07-23 stsp err = got_error_from_errno("got_opentempfd");
4334 39449a05 2020-07-23 stsp goto done;
4337 39449a05 2020-07-23 stsp if (lseek(*fd, 0, SEEK_SET) == -1) {
4338 39449a05 2020-07-23 stsp err = got_error_from_errno2("lseek", abspath);
4339 39449a05 2020-07-23 stsp goto done;
4342 39449a05 2020-07-23 stsp if (err) {
4343 39449a05 2020-07-23 stsp close(*fd);
4346 39449a05 2020-07-23 stsp return err;
4349 4ed7e80c 2018-05-20 stsp static const struct got_error *
4350 88d0e355 2019-08-03 stsp print_diff(void *arg, unsigned char status, unsigned char staged_status,
4351 88d0e355 2019-08-03 stsp const char *path, struct got_object_id *blob_id,
4352 12463d8b 2019-12-13 stsp struct got_object_id *staged_blob_id, struct got_object_id *commit_id,
4353 12463d8b 2019-12-13 stsp int dirfd, const char *de_name)
4355 b72f483a 2019-02-05 stsp struct print_diff_arg *a = arg;
4356 b72f483a 2019-02-05 stsp const struct got_error *err = NULL;
4357 b72f483a 2019-02-05 stsp struct got_blob_object *blob1 = NULL;
4358 12463d8b 2019-12-13 stsp int fd = -1;
4359 b72f483a 2019-02-05 stsp FILE *f2 = NULL;
4360 4ce46740 2019-08-08 stsp char *abspath = NULL, *label1 = NULL;
4361 b72f483a 2019-02-05 stsp struct stat sb;
4363 98eaaa12 2019-08-03 stsp if (a->diff_staged) {
4364 98eaaa12 2019-08-03 stsp if (staged_status != GOT_STATUS_MODIFY &&
4365 98eaaa12 2019-08-03 stsp staged_status != GOT_STATUS_ADD &&
4366 98eaaa12 2019-08-03 stsp staged_status != GOT_STATUS_DELETE)
4367 98eaaa12 2019-08-03 stsp return NULL;
4369 98eaaa12 2019-08-03 stsp if (staged_status == GOT_STATUS_DELETE)
4370 98eaaa12 2019-08-03 stsp return NULL;
4371 2a06fe5f 2019-08-24 stsp if (status == GOT_STATUS_NONEXISTENT)
4372 2a06fe5f 2019-08-24 stsp return got_error_set_errno(ENOENT, path);
4373 98eaaa12 2019-08-03 stsp if (status != GOT_STATUS_MODIFY &&
4374 98eaaa12 2019-08-03 stsp status != GOT_STATUS_ADD &&
4375 98eaaa12 2019-08-03 stsp status != GOT_STATUS_DELETE &&
4376 98eaaa12 2019-08-03 stsp status != GOT_STATUS_CONFLICT)
4377 98eaaa12 2019-08-03 stsp return NULL;
4380 3fc0c068 2019-02-10 stsp if (!a->header_shown) {
4381 98eaaa12 2019-08-03 stsp printf("diff %s %s%s\n", a->id_str,
4382 98eaaa12 2019-08-03 stsp got_worktree_get_root_path(a->worktree),
4383 98eaaa12 2019-08-03 stsp a->diff_staged ? " (staged changes)" : "");
4384 3fc0c068 2019-02-10 stsp a->header_shown = 1;
4387 98eaaa12 2019-08-03 stsp if (a->diff_staged) {
4388 98eaaa12 2019-08-03 stsp const char *label1 = NULL, *label2 = NULL;
4389 98eaaa12 2019-08-03 stsp switch (staged_status) {
4390 98eaaa12 2019-08-03 stsp case GOT_STATUS_MODIFY:
4391 98eaaa12 2019-08-03 stsp label1 = path;
4392 98eaaa12 2019-08-03 stsp label2 = path;
4394 98eaaa12 2019-08-03 stsp case GOT_STATUS_ADD:
4395 98eaaa12 2019-08-03 stsp label2 = path;
4397 98eaaa12 2019-08-03 stsp case GOT_STATUS_DELETE:
4398 98eaaa12 2019-08-03 stsp label1 = path;
4401 98eaaa12 2019-08-03 stsp return got_error(GOT_ERR_FILE_STATUS);
4403 fe621944 2020-11-10 stsp return got_diff_objects_as_blobs(NULL, NULL, blob_id,
4404 fe621944 2020-11-10 stsp staged_blob_id, label1, label2, a->diff_context,
4405 64453f7e 2020-11-21 stsp a->ignore_whitespace, a->force_text_diff, a->repo, stdout);
4408 408b4ebc 2019-08-03 stsp if (staged_status == GOT_STATUS_ADD ||
4409 4ce46740 2019-08-08 stsp staged_status == GOT_STATUS_MODIFY) {
4410 4ce46740 2019-08-08 stsp char *id_str;
4411 408b4ebc 2019-08-03 stsp err = got_object_open_as_blob(&blob1, a->repo, staged_blob_id,
4414 4ce46740 2019-08-08 stsp goto done;
4415 4ce46740 2019-08-08 stsp err = got_object_id_str(&id_str, staged_blob_id);
4417 4ce46740 2019-08-08 stsp goto done;
4418 4ce46740 2019-08-08 stsp if (asprintf(&label1, "%s (staged)", id_str) == -1) {
4419 4ce46740 2019-08-08 stsp err = got_error_from_errno("asprintf");
4420 4ce46740 2019-08-08 stsp free(id_str);
4421 4ce46740 2019-08-08 stsp goto done;
4423 4ce46740 2019-08-08 stsp free(id_str);
4424 4ce46740 2019-08-08 stsp } else if (status != GOT_STATUS_ADD) {
4425 016a88dd 2019-05-13 stsp err = got_object_open_as_blob(&blob1, a->repo, blob_id, 8192);
4427 4ce46740 2019-08-08 stsp goto done;
4430 7154f6ce 2019-03-27 stsp if (status != GOT_STATUS_DELETE) {
4431 2ec1f75b 2019-03-26 stsp if (asprintf(&abspath, "%s/%s",
4432 2ec1f75b 2019-03-26 stsp got_worktree_get_root_path(a->worktree), path) == -1) {
4433 638f9024 2019-05-13 stsp err = got_error_from_errno("asprintf");
4434 2ec1f75b 2019-03-26 stsp goto done;
4437 12463d8b 2019-12-13 stsp if (dirfd != -1) {
4438 e7ae0baf 2021-12-31 stsp fd = openat(dirfd, de_name,
4439 e7ae0baf 2021-12-31 stsp O_RDONLY | O_NOFOLLOW | O_CLOEXEC);
4440 12463d8b 2019-12-13 stsp if (fd == -1) {
4441 5c02d2a5 2021-09-26 stsp if (!got_err_open_nofollow_on_symlink()) {
4442 39449a05 2020-07-23 stsp err = got_error_from_errno2("openat",
4444 39449a05 2020-07-23 stsp goto done;
4446 39449a05 2020-07-23 stsp err = get_symlink_target_file(&fd, dirfd,
4447 39449a05 2020-07-23 stsp de_name, abspath);
4449 39449a05 2020-07-23 stsp goto done;
4452 8bd0cdad 2021-12-31 stsp fd = open(abspath, O_RDONLY | O_NOFOLLOW | O_CLOEXEC);
4453 12463d8b 2019-12-13 stsp if (fd == -1) {
4454 5c02d2a5 2021-09-26 stsp if (!got_err_open_nofollow_on_symlink()) {
4455 39449a05 2020-07-23 stsp err = got_error_from_errno2("open",
4457 39449a05 2020-07-23 stsp goto done;
4459 39449a05 2020-07-23 stsp err = get_symlink_target_file(&fd, dirfd,
4460 39449a05 2020-07-23 stsp de_name, abspath);
4462 39449a05 2020-07-23 stsp goto done;
4465 12463d8b 2019-12-13 stsp if (fstat(fd, &sb) == -1) {
4466 12463d8b 2019-12-13 stsp err = got_error_from_errno2("fstat", abspath);
4467 2ec1f75b 2019-03-26 stsp goto done;
4469 12463d8b 2019-12-13 stsp f2 = fdopen(fd, "r");
4470 12463d8b 2019-12-13 stsp if (f2 == NULL) {
4471 12463d8b 2019-12-13 stsp err = got_error_from_errno2("fdopen", abspath);
4472 2ec1f75b 2019-03-26 stsp goto done;
4476 2ec1f75b 2019-03-26 stsp sb.st_size = 0;
4478 4ce46740 2019-08-08 stsp err = got_diff_blob_file(blob1, label1, f2, sb.st_size, path,
4479 64453f7e 2020-11-21 stsp a->diff_context, a->ignore_whitespace, a->force_text_diff, stdout);
4481 b72f483a 2019-02-05 stsp if (blob1)
4482 b72f483a 2019-02-05 stsp got_object_blob_close(blob1);
4483 12463d8b 2019-12-13 stsp if (f2 && fclose(f2) == EOF && err == NULL)
4484 638f9024 2019-05-13 stsp err = got_error_from_errno("fclose");
4485 12463d8b 2019-12-13 stsp if (fd != -1 && close(fd) == -1 && err == NULL)
4486 12463d8b 2019-12-13 stsp err = got_error_from_errno("close");
4487 b72f483a 2019-02-05 stsp free(abspath);
4488 927df6b7 2019-02-10 stsp return err;
4491 927df6b7 2019-02-10 stsp static const struct got_error *
4492 b00d56cd 2018-04-01 stsp cmd_diff(int argc, char *argv[])
4494 b00d56cd 2018-04-01 stsp const struct got_error *error;
4495 b00d56cd 2018-04-01 stsp struct got_repository *repo = NULL;
4496 b72f483a 2019-02-05 stsp struct got_worktree *worktree = NULL;
4497 b72f483a 2019-02-05 stsp char *cwd = NULL, *repo_path = NULL;
4498 67b631c9 2021-10-10 stsp const char *commit_args[2] = { NULL, NULL };
4499 67b631c9 2021-10-10 stsp int ncommit_args = 0;
4500 e7ffb0b0 2021-10-07 stsp struct got_object_id *ids[2] = { NULL, NULL };
4501 e7ffb0b0 2021-10-07 stsp char *labels[2] = { NULL, NULL };
4502 67b631c9 2021-10-10 stsp int type1 = GOT_OBJ_TYPE_ANY, type2 = GOT_OBJ_TYPE_ANY;
4503 e7ffb0b0 2021-10-07 stsp int diff_context = 3, diff_staged = 0, ignore_whitespace = 0, ch, i;
4504 e7ffb0b0 2021-10-07 stsp int force_text_diff = 0, force_path = 0, rflag = 0;
4505 c0cc5c62 2018-10-18 stsp const char *errstr;
4506 84de9106 2020-12-26 stsp struct got_reflist_head refs;
4507 e7ffb0b0 2021-10-07 stsp struct got_pathlist_head paths;
4508 e7ffb0b0 2021-10-07 stsp struct got_pathlist_entry *pe;
4510 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
4511 e7ffb0b0 2021-10-07 stsp TAILQ_INIT(&paths);
4513 b00d56cd 2018-04-01 stsp #ifndef PROFILE
4514 25eccc22 2019-01-04 stsp if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
4515 25eccc22 2019-01-04 stsp NULL) == -1)
4516 b00d56cd 2018-04-01 stsp err(1, "pledge");
4519 67b631c9 2021-10-10 stsp while ((ch = getopt(argc, argv, "ac:C:r:swP")) != -1) {
4520 b00d56cd 2018-04-01 stsp switch (ch) {
4522 64453f7e 2020-11-21 stsp force_text_diff = 1;
4525 67b631c9 2021-10-10 stsp if (ncommit_args >= 2)
4526 67b631c9 2021-10-10 stsp errx(1, "too many -c options used");
4527 67b631c9 2021-10-10 stsp commit_args[ncommit_args++] = optarg;
4530 dfcab68b 2019-11-29 kn diff_context = strtonum(optarg, 0, GOT_DIFF_MAX_CONTEXT,
4532 c0cc5c62 2018-10-18 stsp if (errstr != NULL)
4533 c0cc5c62 2018-10-18 stsp err(1, "-C option %s", errstr);
4536 b72f483a 2019-02-05 stsp repo_path = realpath(optarg, NULL);
4537 b72f483a 2019-02-05 stsp if (repo_path == NULL)
4538 9ba1d308 2019-10-21 stsp return got_error_from_errno2("realpath",
4540 7fbaa4f3 2019-05-11 stsp got_path_strip_trailing_slashes(repo_path);
4541 e7ffb0b0 2021-10-07 stsp rflag = 1;
4544 98eaaa12 2019-08-03 stsp diff_staged = 1;
4547 63035f9f 2019-10-06 stsp ignore_whitespace = 1;
4550 e7ffb0b0 2021-10-07 stsp force_path = 1;
4553 2deda0b9 2019-03-07 stsp usage_diff();
4554 b00d56cd 2018-04-01 stsp /* NOTREACHED */
4558 b00d56cd 2018-04-01 stsp argc -= optind;
4559 b00d56cd 2018-04-01 stsp argv += optind;
4561 b72f483a 2019-02-05 stsp cwd = getcwd(NULL, 0);
4562 b72f483a 2019-02-05 stsp if (cwd == NULL) {
4563 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
4564 b72f483a 2019-02-05 stsp goto done;
4567 e7ffb0b0 2021-10-07 stsp if (repo_path == NULL) {
4568 1f03b8da 2020-03-20 stsp error = got_worktree_open(&worktree, cwd);
4569 e7ffb0b0 2021-10-07 stsp if (error && error->code != GOT_ERR_NOT_WORKTREE)
4570 1f03b8da 2020-03-20 stsp goto done;
4572 e7ffb0b0 2021-10-07 stsp error = NULL;
4573 e7ffb0b0 2021-10-07 stsp if (worktree) {
4574 e7ffb0b0 2021-10-07 stsp repo_path =
4575 e7ffb0b0 2021-10-07 stsp strdup(got_worktree_get_repo_path(worktree));
4576 e7ffb0b0 2021-10-07 stsp if (repo_path == NULL) {
4577 e7ffb0b0 2021-10-07 stsp error = got_error_from_errno("strdup");
4578 927df6b7 2019-02-10 stsp goto done;
4581 e7ffb0b0 2021-10-07 stsp repo_path = strdup(cwd);
4582 1a1242a9 2021-04-01 kn if (repo_path == NULL) {
4583 1a1242a9 2021-04-01 kn error = got_error_from_errno("strdup");
4589 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, repo_path, NULL);
4590 76089277 2018-04-01 stsp free(repo_path);
4591 b00d56cd 2018-04-01 stsp if (error != NULL)
4592 b00d56cd 2018-04-01 stsp goto done;
4594 67b631c9 2021-10-10 stsp if (rflag || worktree == NULL || ncommit_args > 0) {
4595 67b631c9 2021-10-10 stsp if (force_path) {
4596 67b631c9 2021-10-10 stsp error = got_error_msg(GOT_ERR_NOT_IMPL,
4597 67b631c9 2021-10-10 stsp "-P option can only be used when diffing "
4598 67b631c9 2021-10-10 stsp "a work tree");
4599 67b631c9 2021-10-10 stsp goto done;
4601 67b631c9 2021-10-10 stsp if (diff_staged) {
4602 67b631c9 2021-10-10 stsp error = got_error_msg(GOT_ERR_NOT_IMPL,
4603 67b631c9 2021-10-10 stsp "-s option can only be used when diffing "
4604 67b631c9 2021-10-10 stsp "a work tree");
4605 67b631c9 2021-10-10 stsp goto done;
4609 c02c541e 2019-03-29 stsp error = apply_unveil(got_repo_get_path(repo), 1,
4610 c530dc23 2019-07-23 stsp worktree ? got_worktree_get_root_path(worktree) : NULL);
4611 c02c541e 2019-03-29 stsp if (error)
4612 c02c541e 2019-03-29 stsp goto done;
4614 67b631c9 2021-10-10 stsp if ((!force_path && argc == 2) || ncommit_args > 0) {
4615 67b631c9 2021-10-10 stsp int obj_type = (ncommit_args > 0 ?
4616 67b631c9 2021-10-10 stsp GOT_OBJ_TYPE_COMMIT : GOT_OBJ_TYPE_ANY);
4617 e7ffb0b0 2021-10-07 stsp error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
4619 e7ffb0b0 2021-10-07 stsp if (error)
4620 e7ffb0b0 2021-10-07 stsp goto done;
4621 67b631c9 2021-10-10 stsp for (i = 0; i < (ncommit_args > 0 ? ncommit_args : argc); i++) {
4622 67b631c9 2021-10-10 stsp const char *arg;
4623 67b631c9 2021-10-10 stsp if (ncommit_args > 0)
4624 67b631c9 2021-10-10 stsp arg = commit_args[i];
4626 67b631c9 2021-10-10 stsp arg = argv[i];
4627 e7ffb0b0 2021-10-07 stsp error = got_repo_match_object_id(&ids[i], &labels[i],
4628 67b631c9 2021-10-10 stsp arg, obj_type, &refs, repo);
4629 e7ffb0b0 2021-10-07 stsp if (error) {
4630 e7ffb0b0 2021-10-07 stsp if (error->code != GOT_ERR_NOT_REF &&
4631 e7ffb0b0 2021-10-07 stsp error->code != GOT_ERR_NO_OBJ)
4632 e7ffb0b0 2021-10-07 stsp goto done;
4633 67b631c9 2021-10-10 stsp if (ncommit_args > 0)
4634 67b631c9 2021-10-10 stsp goto done;
4635 e7ffb0b0 2021-10-07 stsp error = NULL;
4641 67b631c9 2021-10-10 stsp if (ncommit_args == 0 && (ids[0] == NULL || ids[1] == NULL)) {
4642 b72f483a 2019-02-05 stsp struct print_diff_arg arg;
4643 b72f483a 2019-02-05 stsp char *id_str;
4645 67b631c9 2021-10-10 stsp if (worktree == NULL) {
4646 67b631c9 2021-10-10 stsp if (argc == 2 && ids[0] == NULL) {
4647 67b631c9 2021-10-10 stsp error = got_error_path(argv[0], GOT_ERR_NO_OBJ);
4648 67b631c9 2021-10-10 stsp goto done;
4649 67b631c9 2021-10-10 stsp } else if (argc == 2 && ids[1] == NULL) {
4650 67b631c9 2021-10-10 stsp error = got_error_path(argv[1], GOT_ERR_NO_OBJ);
4651 67b631c9 2021-10-10 stsp goto done;
4652 67b631c9 2021-10-10 stsp } else if (argc > 0) {
4653 67b631c9 2021-10-10 stsp error = got_error_fmt(GOT_ERR_NOT_WORKTREE,
4654 67b631c9 2021-10-10 stsp "%s", "specified paths cannot be resolved");
4655 67b631c9 2021-10-10 stsp goto done;
4657 67b631c9 2021-10-10 stsp error = got_error(GOT_ERR_NOT_WORKTREE);
4658 67b631c9 2021-10-10 stsp goto done;
4662 67b631c9 2021-10-10 stsp error = get_worktree_paths_from_argv(&paths, argc, argv,
4663 67b631c9 2021-10-10 stsp worktree);
4664 67b631c9 2021-10-10 stsp if (error)
4665 67b631c9 2021-10-10 stsp goto done;
4667 b72f483a 2019-02-05 stsp error = got_object_id_str(&id_str,
4668 b72f483a 2019-02-05 stsp got_worktree_get_base_commit_id(worktree));
4669 b72f483a 2019-02-05 stsp if (error)
4670 b72f483a 2019-02-05 stsp goto done;
4671 b72f483a 2019-02-05 stsp arg.repo = repo;
4672 b72f483a 2019-02-05 stsp arg.worktree = worktree;
4673 b72f483a 2019-02-05 stsp arg.diff_context = diff_context;
4674 3fc0c068 2019-02-10 stsp arg.id_str = id_str;
4675 3fc0c068 2019-02-10 stsp arg.header_shown = 0;
4676 98eaaa12 2019-08-03 stsp arg.diff_staged = diff_staged;
4677 63035f9f 2019-10-06 stsp arg.ignore_whitespace = ignore_whitespace;
4678 64453f7e 2020-11-21 stsp arg.force_text_diff = force_text_diff;
4680 f6343036 2021-06-22 stsp error = got_worktree_status(worktree, &paths, repo, 0,
4681 f6343036 2021-06-22 stsp print_diff, &arg, check_cancelled, NULL);
4682 b72f483a 2019-02-05 stsp free(id_str);
4683 b72f483a 2019-02-05 stsp goto done;
4686 67b631c9 2021-10-10 stsp if (ncommit_args == 1) {
4687 67b631c9 2021-10-10 stsp struct got_commit_object *commit;
4688 67b631c9 2021-10-10 stsp error = got_object_open_as_commit(&commit, repo, ids[0]);
4689 67b631c9 2021-10-10 stsp if (error)
4690 e7ffb0b0 2021-10-07 stsp goto done;
4692 67b631c9 2021-10-10 stsp labels[1] = labels[0];
4693 67b631c9 2021-10-10 stsp ids[1] = ids[0];
4694 67b631c9 2021-10-10 stsp if (got_object_commit_get_nparents(commit) > 0) {
4695 67b631c9 2021-10-10 stsp const struct got_object_id_queue *pids;
4696 67b631c9 2021-10-10 stsp struct got_object_qid *pid;
4697 67b631c9 2021-10-10 stsp pids = got_object_commit_get_parent_ids(commit);
4698 67b631c9 2021-10-10 stsp pid = STAILQ_FIRST(pids);
4699 67b631c9 2021-10-10 stsp ids[0] = got_object_id_dup(pid->id);
4700 67b631c9 2021-10-10 stsp if (ids[0] == NULL) {
4701 67b631c9 2021-10-10 stsp error = got_error_from_errno(
4702 67b631c9 2021-10-10 stsp "got_object_id_dup");
4703 67b631c9 2021-10-10 stsp got_object_commit_close(commit);
4704 67b631c9 2021-10-10 stsp goto done;
4706 67b631c9 2021-10-10 stsp error = got_object_id_str(&labels[0], ids[0]);
4707 67b631c9 2021-10-10 stsp if (error) {
4708 67b631c9 2021-10-10 stsp got_object_commit_close(commit);
4709 67b631c9 2021-10-10 stsp goto done;
4712 67b631c9 2021-10-10 stsp ids[0] = NULL;
4713 67b631c9 2021-10-10 stsp labels[0] = strdup("/dev/null");
4714 67b631c9 2021-10-10 stsp if (labels[0] == NULL) {
4715 67b631c9 2021-10-10 stsp error = got_error_from_errno("strdup");
4716 67b631c9 2021-10-10 stsp got_object_commit_close(commit);
4717 67b631c9 2021-10-10 stsp goto done;
4721 67b631c9 2021-10-10 stsp got_object_commit_close(commit);
4724 67b631c9 2021-10-10 stsp if (ncommit_args == 0 && argc > 2) {
4725 67b631c9 2021-10-10 stsp error = got_error_msg(GOT_ERR_BAD_PATH,
4726 67b631c9 2021-10-10 stsp "path arguments cannot be used when diffing two objects");
4727 0adb7196 2019-08-11 stsp goto done;
4730 67b631c9 2021-10-10 stsp if (ids[0]) {
4731 67b631c9 2021-10-10 stsp error = got_object_get_type(&type1, repo, ids[0]);
4732 67b631c9 2021-10-10 stsp if (error)
4733 67b631c9 2021-10-10 stsp goto done;
4736 e7ffb0b0 2021-10-07 stsp error = got_object_get_type(&type2, repo, ids[1]);
4737 15a94983 2018-12-23 stsp if (error)
4738 15a94983 2018-12-23 stsp goto done;
4739 67b631c9 2021-10-10 stsp if (type1 != GOT_OBJ_TYPE_ANY && type1 != type2) {
4740 b00d56cd 2018-04-01 stsp error = got_error(GOT_ERR_OBJ_TYPE);
4741 b00d56cd 2018-04-01 stsp goto done;
4743 67b631c9 2021-10-10 stsp if (type1 == GOT_OBJ_TYPE_BLOB && argc > 0) {
4744 67b631c9 2021-10-10 stsp error = got_error_msg(GOT_ERR_OBJ_TYPE,
4745 67b631c9 2021-10-10 stsp "path arguments cannot be used when diffing blobs");
4746 67b631c9 2021-10-10 stsp goto done;
4749 67b631c9 2021-10-10 stsp for (i = 0; ncommit_args > 0 && i < argc; i++) {
4750 67b631c9 2021-10-10 stsp char *in_repo_path;
4751 67b631c9 2021-10-10 stsp struct got_pathlist_entry *new;
4752 67b631c9 2021-10-10 stsp if (worktree) {
4753 67b631c9 2021-10-10 stsp const char *prefix;
4755 67b631c9 2021-10-10 stsp error = got_worktree_resolve_path(&p, worktree,
4757 67b631c9 2021-10-10 stsp if (error)
4758 67b631c9 2021-10-10 stsp goto done;
4759 67b631c9 2021-10-10 stsp prefix = got_worktree_get_path_prefix(worktree);
4760 67b631c9 2021-10-10 stsp while (prefix[0] == '/')
4762 67b631c9 2021-10-10 stsp if (asprintf(&in_repo_path, "%s%s%s", prefix,
4763 67b631c9 2021-10-10 stsp (p[0] != '\0' && prefix[0] != '\0') ? "/" : "",
4764 67b631c9 2021-10-10 stsp p) == -1) {
4765 67b631c9 2021-10-10 stsp error = got_error_from_errno("asprintf");
4767 67b631c9 2021-10-10 stsp goto done;
4771 67b631c9 2021-10-10 stsp char *mapped_path, *s;
4772 67b631c9 2021-10-10 stsp error = got_repo_map_path(&mapped_path, repo, argv[i]);
4773 67b631c9 2021-10-10 stsp if (error)
4774 67b631c9 2021-10-10 stsp goto done;
4775 67b631c9 2021-10-10 stsp s = mapped_path;
4776 67b631c9 2021-10-10 stsp while (s[0] == '/')
4778 67b631c9 2021-10-10 stsp in_repo_path = strdup(s);
4779 67b631c9 2021-10-10 stsp if (in_repo_path == NULL) {
4780 67b631c9 2021-10-10 stsp error = got_error_from_errno("asprintf");
4781 67b631c9 2021-10-10 stsp free(mapped_path);
4782 67b631c9 2021-10-10 stsp goto done;
4784 67b631c9 2021-10-10 stsp free(mapped_path);
4787 67b631c9 2021-10-10 stsp error = got_pathlist_insert(&new, &paths, in_repo_path, NULL);
4788 67b631c9 2021-10-10 stsp if (error || new == NULL /* duplicate */)
4789 67b631c9 2021-10-10 stsp free(in_repo_path);
4790 67b631c9 2021-10-10 stsp if (error)
4791 67b631c9 2021-10-10 stsp goto done;
4794 67b631c9 2021-10-10 stsp switch (type1 == GOT_OBJ_TYPE_ANY ? type2 : type1) {
4795 b00d56cd 2018-04-01 stsp case GOT_OBJ_TYPE_BLOB:
4796 e7ffb0b0 2021-10-07 stsp error = got_diff_objects_as_blobs(NULL, NULL, ids[0], ids[1],
4797 64453f7e 2020-11-21 stsp NULL, NULL, diff_context, ignore_whitespace,
4798 64453f7e 2020-11-21 stsp force_text_diff, repo, stdout);
4800 b00d56cd 2018-04-01 stsp case GOT_OBJ_TYPE_TREE:
4801 e7ffb0b0 2021-10-07 stsp error = got_diff_objects_as_trees(NULL, NULL, ids[0], ids[1],
4802 67b631c9 2021-10-10 stsp &paths, "", "", diff_context, ignore_whitespace,
4803 67b631c9 2021-10-10 stsp force_text_diff, repo, stdout);
4805 b00d56cd 2018-04-01 stsp case GOT_OBJ_TYPE_COMMIT:
4806 e7ffb0b0 2021-10-07 stsp printf("diff %s %s\n", labels[0], labels[1]);
4807 e7ffb0b0 2021-10-07 stsp error = got_diff_objects_as_commits(NULL, NULL, ids[0], ids[1],
4808 67b631c9 2021-10-10 stsp &paths, diff_context, ignore_whitespace, force_text_diff,
4809 67b631c9 2021-10-10 stsp repo, stdout);
4812 b00d56cd 2018-04-01 stsp error = got_error(GOT_ERR_OBJ_TYPE);
4815 e7ffb0b0 2021-10-07 stsp free(labels[0]);
4816 e7ffb0b0 2021-10-07 stsp free(labels[1]);
4817 e7ffb0b0 2021-10-07 stsp free(ids[0]);
4818 e7ffb0b0 2021-10-07 stsp free(ids[1]);
4819 b72f483a 2019-02-05 stsp if (worktree)
4820 b72f483a 2019-02-05 stsp got_worktree_close(worktree);
4821 ad242220 2018-09-08 stsp if (repo) {
4822 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
4823 ad242220 2018-09-08 stsp if (error == NULL)
4824 1d0f4054 2021-06-17 stsp error = close_err;
4826 e7ffb0b0 2021-10-07 stsp TAILQ_FOREACH(pe, &paths, entry)
4827 e7ffb0b0 2021-10-07 stsp free((char *)pe->path);
4828 e7ffb0b0 2021-10-07 stsp got_pathlist_free(&paths);
4829 84de9106 2020-12-26 stsp got_ref_list_free(&refs);
4830 b00d56cd 2018-04-01 stsp return error;
4833 404c43c4 2018-06-21 stsp __dead static void
4834 404c43c4 2018-06-21 stsp usage_blame(void)
4836 9270e621 2019-02-05 stsp fprintf(stderr,
4837 9270e621 2019-02-05 stsp "usage: %s blame [-c commit] [-r repository-path] path\n",
4838 404c43c4 2018-06-21 stsp getprogname());
4842 28315671 2019-08-14 stsp struct blame_line {
4843 28315671 2019-08-14 stsp int annotated;
4844 28315671 2019-08-14 stsp char *id_str;
4845 82f6abb8 2019-08-14 stsp char *committer;
4846 11db6024 2019-10-21 stsp char datebuf[11]; /* YYYY-MM-DD + NUL */
4849 28315671 2019-08-14 stsp struct blame_cb_args {
4850 28315671 2019-08-14 stsp struct blame_line *lines;
4851 28315671 2019-08-14 stsp int nlines;
4852 7ef28ff8 2019-08-14 stsp int nlines_prec;
4853 28315671 2019-08-14 stsp int lineno_cur;
4854 28315671 2019-08-14 stsp off_t *line_offsets;
4856 82f6abb8 2019-08-14 stsp struct got_repository *repo;
4859 404c43c4 2018-06-21 stsp static const struct got_error *
4860 28315671 2019-08-14 stsp blame_cb(void *arg, int nlines, int lineno, struct got_object_id *id)
4862 28315671 2019-08-14 stsp const struct got_error *err = NULL;
4863 28315671 2019-08-14 stsp struct blame_cb_args *a = arg;
4864 28315671 2019-08-14 stsp struct blame_line *bline;
4865 82f6abb8 2019-08-14 stsp char *line = NULL;
4866 28315671 2019-08-14 stsp size_t linesize = 0;
4867 82f6abb8 2019-08-14 stsp struct got_commit_object *commit = NULL;
4868 28315671 2019-08-14 stsp off_t offset;
4869 bcb49d15 2019-08-14 stsp struct tm tm;
4870 bcb49d15 2019-08-14 stsp time_t committer_time;
4872 28315671 2019-08-14 stsp if (nlines != a->nlines ||
4873 28315671 2019-08-14 stsp (lineno != -1 && lineno < 1) || lineno > a->nlines)
4874 28315671 2019-08-14 stsp return got_error(GOT_ERR_RANGE);
4876 28315671 2019-08-14 stsp if (sigint_received)
4877 28315671 2019-08-14 stsp return got_error(GOT_ERR_ITER_COMPLETED);
4879 2839f8b9 2019-08-18 stsp if (lineno == -1)
4880 2839f8b9 2019-08-18 stsp return NULL; /* no change in this commit */
4882 28315671 2019-08-14 stsp /* Annotate this line. */
4883 28315671 2019-08-14 stsp bline = &a->lines[lineno - 1];
4884 28315671 2019-08-14 stsp if (bline->annotated)
4885 28315671 2019-08-14 stsp return NULL;
4886 28315671 2019-08-14 stsp err = got_object_id_str(&bline->id_str, id);
4888 28315671 2019-08-14 stsp return err;
4890 82f6abb8 2019-08-14 stsp err = got_object_open_as_commit(&commit, a->repo, id);
4892 82f6abb8 2019-08-14 stsp goto done;
4894 82f6abb8 2019-08-14 stsp bline->committer = strdup(got_object_commit_get_committer(commit));
4895 82f6abb8 2019-08-14 stsp if (bline->committer == NULL) {
4896 82f6abb8 2019-08-14 stsp err = got_error_from_errno("strdup");
4897 bcb49d15 2019-08-14 stsp goto done;
4900 bcb49d15 2019-08-14 stsp committer_time = got_object_commit_get_committer_time(commit);
4901 e385fc42 2021-08-30 stsp if (gmtime_r(&committer_time, &tm) == NULL)
4902 e385fc42 2021-08-30 stsp return got_error_from_errno("gmtime_r");
4903 6db9f7f6 2019-12-10 stsp if (strftime(bline->datebuf, sizeof(bline->datebuf), "%G-%m-%d",
4904 ec6d1a36 2021-03-21 jrick &tm) == 0) {
4905 bcb49d15 2019-08-14 stsp err = got_error(GOT_ERR_NO_SPACE);
4906 82f6abb8 2019-08-14 stsp goto done;
4908 28315671 2019-08-14 stsp bline->annotated = 1;
4910 28315671 2019-08-14 stsp /* Print lines annotated so far. */
4911 28315671 2019-08-14 stsp bline = &a->lines[a->lineno_cur - 1];
4912 28315671 2019-08-14 stsp if (!bline->annotated)
4913 82f6abb8 2019-08-14 stsp goto done;
4915 28315671 2019-08-14 stsp offset = a->line_offsets[a->lineno_cur - 1];
4916 82f6abb8 2019-08-14 stsp if (fseeko(a->f, offset, SEEK_SET) == -1) {
4917 82f6abb8 2019-08-14 stsp err = got_error_from_errno("fseeko");
4918 82f6abb8 2019-08-14 stsp goto done;
4921 28315671 2019-08-14 stsp while (bline->annotated) {
4922 82f6abb8 2019-08-14 stsp char *smallerthan, *at, *nl, *committer;
4923 82f6abb8 2019-08-14 stsp size_t len;
4925 500467ff 2019-09-25 hiltjo if (getline(&line, &linesize, a->f) == -1) {
4926 28315671 2019-08-14 stsp if (ferror(a->f))
4927 28315671 2019-08-14 stsp err = got_error_from_errno("getline");
4931 82f6abb8 2019-08-14 stsp committer = bline->committer;
4932 82f6abb8 2019-08-14 stsp smallerthan = strchr(committer, '<');
4933 82f6abb8 2019-08-14 stsp if (smallerthan && smallerthan[1] != '\0')
4934 82f6abb8 2019-08-14 stsp committer = smallerthan + 1;
4935 82f6abb8 2019-08-14 stsp at = strchr(committer, '@');
4937 82f6abb8 2019-08-14 stsp *at = '\0';
4938 82f6abb8 2019-08-14 stsp len = strlen(committer);
4939 82f6abb8 2019-08-14 stsp if (len >= 9)
4940 82f6abb8 2019-08-14 stsp committer[8] = '\0';
4942 28315671 2019-08-14 stsp nl = strchr(line, '\n');
4944 28315671 2019-08-14 stsp *nl = '\0';
4945 bcb49d15 2019-08-14 stsp printf("%.*d) %.8s %s %-8s %s\n", a->nlines_prec, a->lineno_cur,
4946 bcb49d15 2019-08-14 stsp bline->id_str, bline->datebuf, committer, line);
4948 28315671 2019-08-14 stsp a->lineno_cur++;
4949 28315671 2019-08-14 stsp bline = &a->lines[a->lineno_cur - 1];
4952 82f6abb8 2019-08-14 stsp if (commit)
4953 82f6abb8 2019-08-14 stsp got_object_commit_close(commit);
4954 28315671 2019-08-14 stsp free(line);
4955 28315671 2019-08-14 stsp return err;
4958 28315671 2019-08-14 stsp static const struct got_error *
4959 404c43c4 2018-06-21 stsp cmd_blame(int argc, char *argv[])
4961 404c43c4 2018-06-21 stsp const struct got_error *error;
4962 404c43c4 2018-06-21 stsp struct got_repository *repo = NULL;
4963 0c06baac 2019-02-05 stsp struct got_worktree *worktree = NULL;
4964 66bea077 2018-08-02 stsp char *path, *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
4965 0587e10c 2020-07-23 stsp char *link_target = NULL;
4966 28315671 2019-08-14 stsp struct got_object_id *obj_id = NULL;
4967 404c43c4 2018-06-21 stsp struct got_object_id *commit_id = NULL;
4968 28315671 2019-08-14 stsp struct got_blob_object *blob = NULL;
4969 404c43c4 2018-06-21 stsp char *commit_id_str = NULL;
4970 28315671 2019-08-14 stsp struct blame_cb_args bca;
4971 28315671 2019-08-14 stsp int ch, obj_type, i;
4972 be659d10 2020-11-18 stsp off_t filesize;
4974 90f3c347 2019-08-19 stsp memset(&bca, 0, sizeof(bca));
4976 404c43c4 2018-06-21 stsp #ifndef PROFILE
4977 36e2fb66 2019-01-04 stsp if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
4978 36e2fb66 2019-01-04 stsp NULL) == -1)
4979 404c43c4 2018-06-21 stsp err(1, "pledge");
4982 66bea077 2018-08-02 stsp while ((ch = getopt(argc, argv, "c:r:")) != -1) {
4983 404c43c4 2018-06-21 stsp switch (ch) {
4985 404c43c4 2018-06-21 stsp commit_id_str = optarg;
4988 66bea077 2018-08-02 stsp repo_path = realpath(optarg, NULL);
4989 66bea077 2018-08-02 stsp if (repo_path == NULL)
4990 9ba1d308 2019-10-21 stsp return got_error_from_errno2("realpath",
4992 7fbaa4f3 2019-05-11 stsp got_path_strip_trailing_slashes(repo_path);
4995 2deda0b9 2019-03-07 stsp usage_blame();
4996 404c43c4 2018-06-21 stsp /* NOTREACHED */
5000 404c43c4 2018-06-21 stsp argc -= optind;
5001 404c43c4 2018-06-21 stsp argv += optind;
5003 a39318fd 2018-08-02 stsp if (argc == 1)
5004 404c43c4 2018-06-21 stsp path = argv[0];
5006 404c43c4 2018-06-21 stsp usage_blame();
5008 66bea077 2018-08-02 stsp cwd = getcwd(NULL, 0);
5009 66bea077 2018-08-02 stsp if (cwd == NULL) {
5010 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
5011 66bea077 2018-08-02 stsp goto done;
5013 66bea077 2018-08-02 stsp if (repo_path == NULL) {
5014 0c06baac 2019-02-05 stsp error = got_worktree_open(&worktree, cwd);
5015 0c06baac 2019-02-05 stsp if (error && error->code != GOT_ERR_NOT_WORKTREE)
5016 66bea077 2018-08-02 stsp goto done;
5018 0c06baac 2019-02-05 stsp error = NULL;
5019 0c06baac 2019-02-05 stsp if (worktree) {
5020 0c06baac 2019-02-05 stsp repo_path =
5021 0c06baac 2019-02-05 stsp strdup(got_worktree_get_repo_path(worktree));
5022 1f03b8da 2020-03-20 stsp if (repo_path == NULL) {
5023 638f9024 2019-05-13 stsp error = got_error_from_errno("strdup");
5024 1f03b8da 2020-03-20 stsp if (error)
5025 1f03b8da 2020-03-20 stsp goto done;
5028 0c06baac 2019-02-05 stsp repo_path = strdup(cwd);
5029 0c06baac 2019-02-05 stsp if (repo_path == NULL) {
5030 638f9024 2019-05-13 stsp error = got_error_from_errno("strdup");
5031 0c06baac 2019-02-05 stsp goto done;
5036 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, repo_path, NULL);
5037 c02c541e 2019-03-29 stsp if (error != NULL)
5038 404c43c4 2018-06-21 stsp goto done;
5040 0c06baac 2019-02-05 stsp if (worktree) {
5041 6efaaa2d 2019-02-05 stsp const char *prefix = got_worktree_get_path_prefix(worktree);
5044 01740607 2020-11-04 stsp error = got_worktree_resolve_path(&p, worktree, path);
5045 01740607 2020-11-04 stsp if (error)
5046 01740607 2020-11-04 stsp goto done;
5047 01740607 2020-11-04 stsp if (asprintf(&in_repo_path, "%s%s%s", prefix,
5048 01740607 2020-11-04 stsp (p[0] != '\0' && !got_path_is_root_dir(prefix)) ? "/" : "",
5049 01740607 2020-11-04 stsp p) == -1) {
5050 638f9024 2019-05-13 stsp error = got_error_from_errno("asprintf");
5052 0c06baac 2019-02-05 stsp goto done;
5055 01740607 2020-11-04 stsp error = apply_unveil(got_repo_get_path(repo), 1, NULL);
5057 01740607 2020-11-04 stsp error = apply_unveil(got_repo_get_path(repo), 1, NULL);
5058 01740607 2020-11-04 stsp if (error)
5059 01740607 2020-11-04 stsp goto done;
5060 8fa913ec 2020-11-14 stsp error = got_repo_map_path(&in_repo_path, repo, path);
5062 0c06baac 2019-02-05 stsp if (error)
5063 66bea077 2018-08-02 stsp goto done;
5065 404c43c4 2018-06-21 stsp if (commit_id_str == NULL) {
5066 404c43c4 2018-06-21 stsp struct got_reference *head_ref;
5067 a0975128 2020-02-07 stsp error = got_ref_open(&head_ref, repo, worktree ?
5068 a0975128 2020-02-07 stsp got_worktree_get_head_ref_name(worktree) : GOT_REF_HEAD, 0);
5069 404c43c4 2018-06-21 stsp if (error != NULL)
5070 66bea077 2018-08-02 stsp goto done;
5071 404c43c4 2018-06-21 stsp error = got_ref_resolve(&commit_id, repo, head_ref);
5072 404c43c4 2018-06-21 stsp got_ref_close(head_ref);
5073 404c43c4 2018-06-21 stsp if (error != NULL)
5074 66bea077 2018-08-02 stsp goto done;
5076 84de9106 2020-12-26 stsp struct got_reflist_head refs;
5077 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
5078 84de9106 2020-12-26 stsp error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
5080 84de9106 2020-12-26 stsp if (error)
5081 84de9106 2020-12-26 stsp goto done;
5082 71a27632 2020-01-15 stsp error = got_repo_match_object_id(&commit_id, NULL,
5083 84de9106 2020-12-26 stsp commit_id_str, GOT_OBJ_TYPE_COMMIT, &refs, repo);
5084 84de9106 2020-12-26 stsp got_ref_list_free(&refs);
5085 30837e32 2019-07-25 stsp if (error)
5086 66bea077 2018-08-02 stsp goto done;
5089 0587e10c 2020-07-23 stsp error = got_object_resolve_symlinks(&link_target, in_repo_path,
5090 0587e10c 2020-07-23 stsp commit_id, repo);
5091 0587e10c 2020-07-23 stsp if (error)
5092 0587e10c 2020-07-23 stsp goto done;
5094 0587e10c 2020-07-23 stsp error = got_object_id_by_path(&obj_id, repo, commit_id,
5095 0587e10c 2020-07-23 stsp link_target ? link_target : in_repo_path);
5096 28315671 2019-08-14 stsp if (error)
5097 28315671 2019-08-14 stsp goto done;
5099 28315671 2019-08-14 stsp error = got_object_get_type(&obj_type, repo, obj_id);
5100 28315671 2019-08-14 stsp if (error)
5101 28315671 2019-08-14 stsp goto done;
5103 28315671 2019-08-14 stsp if (obj_type != GOT_OBJ_TYPE_BLOB) {
5104 eb59b6d4 2020-07-23 stsp error = got_error_path(link_target ? link_target : in_repo_path,
5105 eb59b6d4 2020-07-23 stsp GOT_ERR_OBJ_TYPE);
5106 28315671 2019-08-14 stsp goto done;
5109 28315671 2019-08-14 stsp error = got_object_open_as_blob(&blob, repo, obj_id, 8192);
5110 28315671 2019-08-14 stsp if (error)
5111 28315671 2019-08-14 stsp goto done;
5112 28315671 2019-08-14 stsp bca.f = got_opentemp();
5113 28315671 2019-08-14 stsp if (bca.f == NULL) {
5114 28315671 2019-08-14 stsp error = got_error_from_errno("got_opentemp");
5115 28315671 2019-08-14 stsp goto done;
5117 b02560ec 2019-08-19 stsp error = got_object_blob_dump_to_file(&filesize, &bca.nlines,
5118 28315671 2019-08-14 stsp &bca.line_offsets, bca.f, blob);
5119 7ef28ff8 2019-08-14 stsp if (error || bca.nlines == 0)
5120 28315671 2019-08-14 stsp goto done;
5122 b02560ec 2019-08-19 stsp /* Don't include \n at EOF in the blame line count. */
5123 b02560ec 2019-08-19 stsp if (bca.line_offsets[bca.nlines - 1] == filesize)
5124 b02560ec 2019-08-19 stsp bca.nlines--;
5126 28315671 2019-08-14 stsp bca.lines = calloc(bca.nlines, sizeof(*bca.lines));
5127 28315671 2019-08-14 stsp if (bca.lines == NULL) {
5128 28315671 2019-08-14 stsp error = got_error_from_errno("calloc");
5129 28315671 2019-08-14 stsp goto done;
5131 28315671 2019-08-14 stsp bca.lineno_cur = 1;
5132 7ef28ff8 2019-08-14 stsp bca.nlines_prec = 0;
5133 7ef28ff8 2019-08-14 stsp i = bca.nlines;
5134 7ef28ff8 2019-08-14 stsp while (i > 0) {
5136 7ef28ff8 2019-08-14 stsp bca.nlines_prec++;
5138 82f6abb8 2019-08-14 stsp bca.repo = repo;
5140 0587e10c 2020-07-23 stsp error = got_blame(link_target ? link_target : in_repo_path, commit_id,
5141 0587e10c 2020-07-23 stsp repo, blame_cb, &bca, check_cancelled, NULL);
5143 66bea077 2018-08-02 stsp free(in_repo_path);
5144 0587e10c 2020-07-23 stsp free(link_target);
5145 66bea077 2018-08-02 stsp free(repo_path);
5146 66bea077 2018-08-02 stsp free(cwd);
5147 404c43c4 2018-06-21 stsp free(commit_id);
5148 28315671 2019-08-14 stsp free(obj_id);
5150 28315671 2019-08-14 stsp got_object_blob_close(blob);
5151 0c06baac 2019-02-05 stsp if (worktree)
5152 0c06baac 2019-02-05 stsp got_worktree_close(worktree);
5153 ad242220 2018-09-08 stsp if (repo) {
5154 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
5155 ad242220 2018-09-08 stsp if (error == NULL)
5156 1d0f4054 2021-06-17 stsp error = close_err;
5158 3affba96 2019-09-22 stsp if (bca.lines) {
5159 3affba96 2019-09-22 stsp for (i = 0; i < bca.nlines; i++) {
5160 3affba96 2019-09-22 stsp struct blame_line *bline = &bca.lines[i];
5161 3affba96 2019-09-22 stsp free(bline->id_str);
5162 3affba96 2019-09-22 stsp free(bline->committer);
5164 3affba96 2019-09-22 stsp free(bca.lines);
5166 28315671 2019-08-14 stsp free(bca.line_offsets);
5167 28315671 2019-08-14 stsp if (bca.f && fclose(bca.f) == EOF && error == NULL)
5168 28315671 2019-08-14 stsp error = got_error_from_errno("fclose");
5169 404c43c4 2018-06-21 stsp return error;
5172 5de5890b 2018-10-18 stsp __dead static void
5173 5de5890b 2018-10-18 stsp usage_tree(void)
5175 c1669e2e 2019-01-09 stsp fprintf(stderr,
5176 5d58be12 2020-05-17 stsp "usage: %s tree [-c commit] [-r repository-path] [-iR] [path]\n",
5177 5de5890b 2018-10-18 stsp getprogname());
5181 0d6c6ee3 2020-05-20 stsp static const struct got_error *
5182 c1669e2e 2019-01-09 stsp print_entry(struct got_tree_entry *te, const char *id, const char *path,
5183 0d6c6ee3 2020-05-20 stsp const char *root_path, struct got_repository *repo)
5185 0d6c6ee3 2020-05-20 stsp const struct got_error *err = NULL;
5186 c1669e2e 2019-01-09 stsp int is_root_path = (strcmp(path, root_path) == 0);
5187 848d6979 2019-08-12 stsp const char *modestr = "";
5188 56e0773d 2019-11-28 stsp mode_t mode = got_tree_entry_get_mode(te);
5189 0d6c6ee3 2020-05-20 stsp char *link_target = NULL;
5191 c1669e2e 2019-01-09 stsp path += strlen(root_path);
5192 c1669e2e 2019-01-09 stsp while (path[0] == '/')
5195 63c5ca5d 2019-08-24 stsp if (got_object_tree_entry_is_submodule(te))
5196 63c5ca5d 2019-08-24 stsp modestr = "$";
5197 0d6c6ee3 2020-05-20 stsp else if (S_ISLNK(mode)) {
5200 0d6c6ee3 2020-05-20 stsp err = got_tree_entry_get_symlink_target(&link_target, te, repo);
5202 0d6c6ee3 2020-05-20 stsp return err;
5203 0d6c6ee3 2020-05-20 stsp for (i = 0; i < strlen(link_target); i++) {
5204 0d6c6ee3 2020-05-20 stsp if (!isprint((unsigned char)link_target[i]))
5205 0d6c6ee3 2020-05-20 stsp link_target[i] = '?';
5208 848d6979 2019-08-12 stsp modestr = "@";
5210 56e0773d 2019-11-28 stsp else if (S_ISDIR(mode))
5211 848d6979 2019-08-12 stsp modestr = "/";
5212 56e0773d 2019-11-28 stsp else if (mode & S_IXUSR)
5213 848d6979 2019-08-12 stsp modestr = "*";
5215 0d6c6ee3 2020-05-20 stsp printf("%s%s%s%s%s%s%s\n", id ? id : "", path,
5216 0d6c6ee3 2020-05-20 stsp is_root_path ? "" : "/", got_tree_entry_get_name(te), modestr,
5217 0d6c6ee3 2020-05-20 stsp link_target ? " -> ": "", link_target ? link_target : "");
5219 0d6c6ee3 2020-05-20 stsp free(link_target);
5220 0d6c6ee3 2020-05-20 stsp return NULL;
5223 5de5890b 2018-10-18 stsp static const struct got_error *
5224 5de5890b 2018-10-18 stsp print_tree(const char *path, struct got_object_id *commit_id,
5225 c1669e2e 2019-01-09 stsp int show_ids, int recurse, const char *root_path,
5226 c1669e2e 2019-01-09 stsp struct got_repository *repo)
5228 5de5890b 2018-10-18 stsp const struct got_error *err = NULL;
5229 5de5890b 2018-10-18 stsp struct got_object_id *tree_id = NULL;
5230 5de5890b 2018-10-18 stsp struct got_tree_object *tree = NULL;
5231 56e0773d 2019-11-28 stsp int nentries, i;
5233 5de5890b 2018-10-18 stsp err = got_object_id_by_path(&tree_id, repo, commit_id, path);
5235 5de5890b 2018-10-18 stsp goto done;
5237 5de5890b 2018-10-18 stsp err = got_object_open_as_tree(&tree, repo, tree_id);
5239 5de5890b 2018-10-18 stsp goto done;
5240 56e0773d 2019-11-28 stsp nentries = got_object_tree_get_nentries(tree);
5241 56e0773d 2019-11-28 stsp for (i = 0; i < nentries; i++) {
5242 56e0773d 2019-11-28 stsp struct got_tree_entry *te;
5243 5de5890b 2018-10-18 stsp char *id = NULL;
5245 84453469 2018-11-11 stsp if (sigint_received || sigpipe_received)
5248 56e0773d 2019-11-28 stsp te = got_object_tree_get_entry(tree, i);
5249 5de5890b 2018-10-18 stsp if (show_ids) {
5250 5de5890b 2018-10-18 stsp char *id_str;
5251 56e0773d 2019-11-28 stsp err = got_object_id_str(&id_str,
5252 56e0773d 2019-11-28 stsp got_tree_entry_get_id(te));
5254 5de5890b 2018-10-18 stsp goto done;
5255 5de5890b 2018-10-18 stsp if (asprintf(&id, "%s ", id_str) == -1) {
5256 638f9024 2019-05-13 stsp err = got_error_from_errno("asprintf");
5257 5de5890b 2018-10-18 stsp free(id_str);
5258 5de5890b 2018-10-18 stsp goto done;
5260 5de5890b 2018-10-18 stsp free(id_str);
5262 0d6c6ee3 2020-05-20 stsp err = print_entry(te, id, path, root_path, repo);
5265 0d6c6ee3 2020-05-20 stsp goto done;
5267 56e0773d 2019-11-28 stsp if (recurse && S_ISDIR(got_tree_entry_get_mode(te))) {
5268 c1669e2e 2019-01-09 stsp char *child_path;
5269 c1669e2e 2019-01-09 stsp if (asprintf(&child_path, "%s%s%s", path,
5270 c1669e2e 2019-01-09 stsp path[0] == '/' && path[1] == '\0' ? "" : "/",
5271 56e0773d 2019-11-28 stsp got_tree_entry_get_name(te)) == -1) {
5272 638f9024 2019-05-13 stsp err = got_error_from_errno("asprintf");
5273 c1669e2e 2019-01-09 stsp goto done;
5275 c1669e2e 2019-01-09 stsp err = print_tree(child_path, commit_id, show_ids, 1,
5276 c1669e2e 2019-01-09 stsp root_path, repo);
5277 c1669e2e 2019-01-09 stsp free(child_path);
5279 c1669e2e 2019-01-09 stsp goto done;
5284 5de5890b 2018-10-18 stsp got_object_tree_close(tree);
5285 5de5890b 2018-10-18 stsp free(tree_id);
5286 5de5890b 2018-10-18 stsp return err;
5289 5de5890b 2018-10-18 stsp static const struct got_error *
5290 5de5890b 2018-10-18 stsp cmd_tree(int argc, char *argv[])
5292 5de5890b 2018-10-18 stsp const struct got_error *error;
5293 5de5890b 2018-10-18 stsp struct got_repository *repo = NULL;
5294 7a2c19d6 2019-02-05 stsp struct got_worktree *worktree = NULL;
5295 4e0a20a4 2020-03-23 tracey const char *path, *refname = NULL;
5296 7a2c19d6 2019-02-05 stsp char *cwd = NULL, *repo_path = NULL, *in_repo_path = NULL;
5297 5de5890b 2018-10-18 stsp struct got_object_id *commit_id = NULL;
5298 5de5890b 2018-10-18 stsp char *commit_id_str = NULL;
5299 c1669e2e 2019-01-09 stsp int show_ids = 0, recurse = 0;
5302 5de5890b 2018-10-18 stsp #ifndef PROFILE
5303 0f8d269b 2019-01-04 stsp if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
5304 0f8d269b 2019-01-04 stsp NULL) == -1)
5305 5de5890b 2018-10-18 stsp err(1, "pledge");
5308 c1669e2e 2019-01-09 stsp while ((ch = getopt(argc, argv, "c:r:iR")) != -1) {
5309 5de5890b 2018-10-18 stsp switch (ch) {
5311 5de5890b 2018-10-18 stsp commit_id_str = optarg;
5314 5de5890b 2018-10-18 stsp repo_path = realpath(optarg, NULL);
5315 5de5890b 2018-10-18 stsp if (repo_path == NULL)
5316 9ba1d308 2019-10-21 stsp return got_error_from_errno2("realpath",
5318 7fbaa4f3 2019-05-11 stsp got_path_strip_trailing_slashes(repo_path);
5321 5de5890b 2018-10-18 stsp show_ids = 1;
5324 c1669e2e 2019-01-09 stsp recurse = 1;
5327 2deda0b9 2019-03-07 stsp usage_tree();
5328 5de5890b 2018-10-18 stsp /* NOTREACHED */
5332 5de5890b 2018-10-18 stsp argc -= optind;
5333 5de5890b 2018-10-18 stsp argv += optind;
5335 5de5890b 2018-10-18 stsp if (argc == 1)
5336 5de5890b 2018-10-18 stsp path = argv[0];
5337 5de5890b 2018-10-18 stsp else if (argc > 1)
5338 5de5890b 2018-10-18 stsp usage_tree();
5340 7a2c19d6 2019-02-05 stsp path = NULL;
5342 9bf7a39b 2019-02-05 stsp cwd = getcwd(NULL, 0);
5343 9bf7a39b 2019-02-05 stsp if (cwd == NULL) {
5344 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
5345 9bf7a39b 2019-02-05 stsp goto done;
5347 5de5890b 2018-10-18 stsp if (repo_path == NULL) {
5348 7a2c19d6 2019-02-05 stsp error = got_worktree_open(&worktree, cwd);
5349 8994de28 2019-02-05 stsp if (error && error->code != GOT_ERR_NOT_WORKTREE)
5350 7a2c19d6 2019-02-05 stsp goto done;
5352 7a2c19d6 2019-02-05 stsp error = NULL;
5353 7a2c19d6 2019-02-05 stsp if (worktree) {
5354 7a2c19d6 2019-02-05 stsp repo_path =
5355 7a2c19d6 2019-02-05 stsp strdup(got_worktree_get_repo_path(worktree));
5356 7a2c19d6 2019-02-05 stsp if (repo_path == NULL)
5357 638f9024 2019-05-13 stsp error = got_error_from_errno("strdup");
5358 7a2c19d6 2019-02-05 stsp if (error)
5359 7a2c19d6 2019-02-05 stsp goto done;
5361 7a2c19d6 2019-02-05 stsp repo_path = strdup(cwd);
5362 7a2c19d6 2019-02-05 stsp if (repo_path == NULL) {
5363 638f9024 2019-05-13 stsp error = got_error_from_errno("strdup");
5364 7a2c19d6 2019-02-05 stsp goto done;
5369 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, repo_path, NULL);
5370 5de5890b 2018-10-18 stsp if (error != NULL)
5371 c02c541e 2019-03-29 stsp goto done;
5373 4fedbf4c 2020-11-07 stsp if (worktree) {
5374 4fedbf4c 2020-11-07 stsp const char *prefix = got_worktree_get_path_prefix(worktree);
5377 4fedbf4c 2020-11-07 stsp if (path == NULL)
5378 4fedbf4c 2020-11-07 stsp path = "";
5379 4fedbf4c 2020-11-07 stsp error = got_worktree_resolve_path(&p, worktree, path);
5380 4fedbf4c 2020-11-07 stsp if (error)
5381 4fedbf4c 2020-11-07 stsp goto done;
5382 4fedbf4c 2020-11-07 stsp if (asprintf(&in_repo_path, "%s%s%s", prefix,
5383 4fedbf4c 2020-11-07 stsp (p[0] != '\0' && !got_path_is_root_dir(prefix)) ? "/" : "",
5384 4fedbf4c 2020-11-07 stsp p) == -1) {
5385 4fedbf4c 2020-11-07 stsp error = got_error_from_errno("asprintf");
5387 4fedbf4c 2020-11-07 stsp goto done;
5390 4fedbf4c 2020-11-07 stsp error = apply_unveil(got_repo_get_path(repo), 1, NULL);
5391 4fedbf4c 2020-11-07 stsp if (error)
5392 4fedbf4c 2020-11-07 stsp goto done;
5394 4fedbf4c 2020-11-07 stsp error = apply_unveil(got_repo_get_path(repo), 1, NULL);
5395 4fedbf4c 2020-11-07 stsp if (error)
5396 4fedbf4c 2020-11-07 stsp goto done;
5397 4fedbf4c 2020-11-07 stsp if (path == NULL)
5398 9bf7a39b 2019-02-05 stsp path = "/";
5399 8fa913ec 2020-11-14 stsp error = got_repo_map_path(&in_repo_path, repo, path);
5400 9bf7a39b 2019-02-05 stsp if (error != NULL)
5401 9bf7a39b 2019-02-05 stsp goto done;
5404 5de5890b 2018-10-18 stsp if (commit_id_str == NULL) {
5405 5de5890b 2018-10-18 stsp struct got_reference *head_ref;
5406 4e0a20a4 2020-03-23 tracey if (worktree)
5407 4e0a20a4 2020-03-23 tracey refname = got_worktree_get_head_ref_name(worktree);
5409 4e0a20a4 2020-03-23 tracey refname = GOT_REF_HEAD;
5410 4e0a20a4 2020-03-23 tracey error = got_ref_open(&head_ref, repo, refname, 0);
5411 5de5890b 2018-10-18 stsp if (error != NULL)
5412 5de5890b 2018-10-18 stsp goto done;
5413 5de5890b 2018-10-18 stsp error = got_ref_resolve(&commit_id, repo, head_ref);
5414 5de5890b 2018-10-18 stsp got_ref_close(head_ref);
5415 5de5890b 2018-10-18 stsp if (error != NULL)
5416 5de5890b 2018-10-18 stsp goto done;
5418 84de9106 2020-12-26 stsp struct got_reflist_head refs;
5419 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
5420 84de9106 2020-12-26 stsp error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
5422 84de9106 2020-12-26 stsp if (error)
5423 84de9106 2020-12-26 stsp goto done;
5424 71a27632 2020-01-15 stsp error = got_repo_match_object_id(&commit_id, NULL,
5425 84de9106 2020-12-26 stsp commit_id_str, GOT_OBJ_TYPE_COMMIT, &refs, repo);
5426 84de9106 2020-12-26 stsp got_ref_list_free(&refs);
5427 30837e32 2019-07-25 stsp if (error)
5428 5de5890b 2018-10-18 stsp goto done;
5431 c1669e2e 2019-01-09 stsp error = print_tree(in_repo_path, commit_id, show_ids, recurse,
5432 c1669e2e 2019-01-09 stsp in_repo_path, repo);
5434 5de5890b 2018-10-18 stsp free(in_repo_path);
5435 5de5890b 2018-10-18 stsp free(repo_path);
5436 5de5890b 2018-10-18 stsp free(cwd);
5437 5de5890b 2018-10-18 stsp free(commit_id);
5438 7a2c19d6 2019-02-05 stsp if (worktree)
5439 7a2c19d6 2019-02-05 stsp got_worktree_close(worktree);
5440 5de5890b 2018-10-18 stsp if (repo) {
5441 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
5442 5de5890b 2018-10-18 stsp if (error == NULL)
5443 1d0f4054 2021-06-17 stsp error = close_err;
5445 5de5890b 2018-10-18 stsp return error;
5448 6bad629b 2019-02-04 stsp __dead static void
5449 6bad629b 2019-02-04 stsp usage_status(void)
5451 00357e4d 2021-09-14 tracey fprintf(stderr, "usage: %s status [-I] [-s status-codes ] "
5452 00357e4d 2021-09-14 tracey "[-S status-codes] [path ...]\n", getprogname());
5456 00357e4d 2021-09-14 tracey struct got_status_arg {
5457 00357e4d 2021-09-14 tracey char *status_codes;
5458 00357e4d 2021-09-14 tracey int suppress;
5461 b72f483a 2019-02-05 stsp static const struct got_error *
5462 88d0e355 2019-08-03 stsp print_status(void *arg, unsigned char status, unsigned char staged_status,
5463 88d0e355 2019-08-03 stsp const char *path, struct got_object_id *blob_id,
5464 12463d8b 2019-12-13 stsp struct got_object_id *staged_blob_id, struct got_object_id *commit_id,
5465 12463d8b 2019-12-13 stsp int dirfd, const char *de_name)
5467 00357e4d 2021-09-14 tracey struct got_status_arg *st = arg;
5469 244725f2 2019-08-03 stsp if (status == staged_status && (status == GOT_STATUS_DELETE))
5470 c363b2c1 2019-08-03 stsp status = GOT_STATUS_NO_CHANGE;
5471 00357e4d 2021-09-14 tracey if (st != NULL && st->status_codes) {
5472 00357e4d 2021-09-14 tracey size_t ncodes = strlen(st->status_codes);
5473 00357e4d 2021-09-14 tracey int i, j = 0;
5475 081470ac 2020-08-13 stsp for (i = 0; i < ncodes ; i++) {
5476 00357e4d 2021-09-14 tracey if (st->suppress) {
5477 00357e4d 2021-09-14 tracey if (status == st->status_codes[i] ||
5478 00357e4d 2021-09-14 tracey staged_status == st->status_codes[i]) {
5480 00357e4d 2021-09-14 tracey continue;
5482 00357e4d 2021-09-14 tracey } else {
5483 00357e4d 2021-09-14 tracey if (status == st->status_codes[i] ||
5484 00357e4d 2021-09-14 tracey staged_status == st->status_codes[i])
5489 00357e4d 2021-09-14 tracey if (st->suppress && j == 0)
5490 00357e4d 2021-09-14 tracey goto print;
5492 081470ac 2020-08-13 stsp if (i == ncodes)
5493 081470ac 2020-08-13 stsp return NULL;
5496 88d0e355 2019-08-03 stsp printf("%c%c %s\n", status, staged_status, path);
5497 b72f483a 2019-02-05 stsp return NULL;
5500 6bad629b 2019-02-04 stsp static const struct got_error *
5501 6bad629b 2019-02-04 stsp cmd_status(int argc, char *argv[])
5503 6bad629b 2019-02-04 stsp const struct got_error *error = NULL;
5504 6bad629b 2019-02-04 stsp struct got_repository *repo = NULL;
5505 6bad629b 2019-02-04 stsp struct got_worktree *worktree = NULL;
5506 00357e4d 2021-09-14 tracey struct got_status_arg st;
5507 00357e4d 2021-09-14 tracey char *cwd = NULL;
5508 72ea6654 2019-07-27 stsp struct got_pathlist_head paths;
5509 a5edda0a 2019-07-27 stsp struct got_pathlist_entry *pe;
5510 f6343036 2021-06-22 stsp int ch, i, no_ignores = 0;
5512 72ea6654 2019-07-27 stsp TAILQ_INIT(&paths);
5514 00357e4d 2021-09-14 tracey memset(&st, 0, sizeof(st));
5515 00357e4d 2021-09-14 tracey st.status_codes = NULL;
5516 00357e4d 2021-09-14 tracey st.suppress = 0;
5518 00357e4d 2021-09-14 tracey while ((ch = getopt(argc, argv, "Is:S:")) != -1) {
5519 6bad629b 2019-02-04 stsp switch (ch) {
5521 f6343036 2021-06-22 stsp no_ignores = 1;
5524 788d4a19 2021-09-14 stsp if (st.status_codes != NULL && st.suppress == 0)
5525 788d4a19 2021-09-14 stsp option_conflict('S', 's');
5526 788d4a19 2021-09-14 stsp st.suppress = 1;
5527 788d4a19 2021-09-14 stsp /* fallthrough */
5529 081470ac 2020-08-13 stsp for (i = 0; i < strlen(optarg); i++) {
5530 081470ac 2020-08-13 stsp switch (optarg[i]) {
5531 081470ac 2020-08-13 stsp case GOT_STATUS_MODIFY:
5532 081470ac 2020-08-13 stsp case GOT_STATUS_ADD:
5533 081470ac 2020-08-13 stsp case GOT_STATUS_DELETE:
5534 081470ac 2020-08-13 stsp case GOT_STATUS_CONFLICT:
5535 081470ac 2020-08-13 stsp case GOT_STATUS_MISSING:
5536 081470ac 2020-08-13 stsp case GOT_STATUS_OBSTRUCTED:
5537 081470ac 2020-08-13 stsp case GOT_STATUS_UNVERSIONED:
5538 081470ac 2020-08-13 stsp case GOT_STATUS_MODE_CHANGE:
5539 081470ac 2020-08-13 stsp case GOT_STATUS_NONEXISTENT:
5542 081470ac 2020-08-13 stsp errx(1, "invalid status code '%c'",
5543 081470ac 2020-08-13 stsp optarg[i]);
5546 788d4a19 2021-09-14 stsp if (ch == 's' && st.suppress)
5547 b043307b 2021-09-14 stsp option_conflict('s', 'S');
5548 00357e4d 2021-09-14 tracey st.status_codes = optarg;
5551 2deda0b9 2019-03-07 stsp usage_status();
5552 6bad629b 2019-02-04 stsp /* NOTREACHED */
5556 6bad629b 2019-02-04 stsp argc -= optind;
5557 6bad629b 2019-02-04 stsp argv += optind;
5559 6bad629b 2019-02-04 stsp #ifndef PROFILE
5560 6bad629b 2019-02-04 stsp if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
5561 6bad629b 2019-02-04 stsp NULL) == -1)
5562 6bad629b 2019-02-04 stsp err(1, "pledge");
5564 927df6b7 2019-02-10 stsp cwd = getcwd(NULL, 0);
5565 927df6b7 2019-02-10 stsp if (cwd == NULL) {
5566 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
5567 927df6b7 2019-02-10 stsp goto done;
5570 927df6b7 2019-02-10 stsp error = got_worktree_open(&worktree, cwd);
5571 fa51e947 2020-03-27 stsp if (error) {
5572 fa51e947 2020-03-27 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
5573 fa51e947 2020-03-27 stsp error = wrap_not_worktree_error(error, "status", cwd);
5574 a5edda0a 2019-07-27 stsp goto done;
5577 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
5579 6bad629b 2019-02-04 stsp if (error != NULL)
5580 6bad629b 2019-02-04 stsp goto done;
5582 d0eebce4 2019-03-11 stsp error = apply_unveil(got_repo_get_path(repo), 1,
5583 c530dc23 2019-07-23 stsp got_worktree_get_root_path(worktree));
5584 087fb88c 2019-08-04 stsp if (error)
5585 087fb88c 2019-08-04 stsp goto done;
5587 087fb88c 2019-08-04 stsp error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
5588 6bad629b 2019-02-04 stsp if (error)
5589 6bad629b 2019-02-04 stsp goto done;
5591 f6343036 2021-06-22 stsp error = got_worktree_status(worktree, &paths, repo, no_ignores,
5592 00357e4d 2021-09-14 tracey print_status, &st, check_cancelled, NULL);
5594 a5edda0a 2019-07-27 stsp TAILQ_FOREACH(pe, &paths, entry)
5595 a5edda0a 2019-07-27 stsp free((char *)pe->path);
5596 72ea6654 2019-07-27 stsp got_pathlist_free(&paths);
5597 927df6b7 2019-02-10 stsp free(cwd);
5598 d0eebce4 2019-03-11 stsp return error;
5601 d0eebce4 2019-03-11 stsp __dead static void
5602 d0eebce4 2019-03-11 stsp usage_ref(void)
5604 d0eebce4 2019-03-11 stsp fprintf(stderr,
5605 0f104432 2021-11-20 stsp "usage: %s ref [-r repository] [-l] [-t] [-c object] "
5606 0f104432 2021-11-20 stsp "[-s reference] [-d] [name]\n",
5607 d0eebce4 2019-03-11 stsp getprogname());
5611 d0eebce4 2019-03-11 stsp static const struct got_error *
5612 0f104432 2021-11-20 stsp list_refs(struct got_repository *repo, const char *refname, int sort_by_time)
5614 d0eebce4 2019-03-11 stsp static const struct got_error *err = NULL;
5615 d0eebce4 2019-03-11 stsp struct got_reflist_head refs;
5616 d0eebce4 2019-03-11 stsp struct got_reflist_entry *re;
5618 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
5619 0f104432 2021-11-20 stsp err = got_ref_list(&refs, repo, refname, sort_by_time ?
5620 0f104432 2021-11-20 stsp got_ref_cmp_by_commit_timestamp_descending : got_ref_cmp_by_name,
5623 d0eebce4 2019-03-11 stsp return err;
5625 d9dff0e5 2020-12-26 stsp TAILQ_FOREACH(re, &refs, entry) {
5626 d0eebce4 2019-03-11 stsp char *refstr;
5627 d0eebce4 2019-03-11 stsp refstr = got_ref_to_str(re->ref);
5628 d0eebce4 2019-03-11 stsp if (refstr == NULL)
5629 638f9024 2019-05-13 stsp return got_error_from_errno("got_ref_to_str");
5630 d0eebce4 2019-03-11 stsp printf("%s: %s\n", got_ref_get_name(re->ref), refstr);
5631 d0eebce4 2019-03-11 stsp free(refstr);
5634 e2e879a0 2019-03-11 stsp got_ref_list_free(&refs);
5635 d0eebce4 2019-03-11 stsp return NULL;
5638 d0eebce4 2019-03-11 stsp static const struct got_error *
5639 161728eb 2021-07-24 stsp delete_ref_by_name(struct got_repository *repo, const char *refname)
5641 161728eb 2021-07-24 stsp const struct got_error *err;
5642 d0eebce4 2019-03-11 stsp struct got_reference *ref;
5644 2f17228e 2019-05-12 stsp err = got_ref_open(&ref, repo, refname, 0);
5646 d0eebce4 2019-03-11 stsp return err;
5648 161728eb 2021-07-24 stsp err = delete_ref(repo, ref);
5649 d0eebce4 2019-03-11 stsp got_ref_close(ref);
5650 d0eebce4 2019-03-11 stsp return err;
5653 d0eebce4 2019-03-11 stsp static const struct got_error *
5654 d83d9d5c 2019-05-13 stsp add_ref(struct got_repository *repo, const char *refname, const char *target)
5656 d0eebce4 2019-03-11 stsp const struct got_error *err = NULL;
5657 d0eebce4 2019-03-11 stsp struct got_object_id *id;
5658 d0eebce4 2019-03-11 stsp struct got_reference *ref = NULL;
5661 bd5895f3 2019-11-28 stsp * Don't let the user create a reference name with a leading '-'.
5662 d1644381 2019-07-14 stsp * While technically a valid reference name, this case is usually
5663 d1644381 2019-07-14 stsp * an unintended typo.
5665 bd5895f3 2019-11-28 stsp if (refname[0] == '-')
5666 bd5895f3 2019-11-28 stsp return got_error_path(refname, GOT_ERR_REF_NAME_MINUS);
5668 dd88155e 2019-06-29 stsp err = got_repo_match_object_id_prefix(&id, target, GOT_OBJ_TYPE_ANY,
5670 d83d9d5c 2019-05-13 stsp if (err) {
5671 d83d9d5c 2019-05-13 stsp struct got_reference *target_ref;
5673 d83d9d5c 2019-05-13 stsp if (err->code != GOT_ERR_BAD_OBJ_ID_STR)
5674 d83d9d5c 2019-05-13 stsp return err;
5675 d83d9d5c 2019-05-13 stsp err = got_ref_open(&target_ref, repo, target, 0);
5677 d83d9d5c 2019-05-13 stsp return err;
5678 d83d9d5c 2019-05-13 stsp err = got_ref_resolve(&id, repo, target_ref);
5679 d83d9d5c 2019-05-13 stsp got_ref_close(target_ref);
5681 d83d9d5c 2019-05-13 stsp return err;
5684 d0eebce4 2019-03-11 stsp err = got_ref_alloc(&ref, refname, id);
5686 d0eebce4 2019-03-11 stsp goto done;
5688 d0eebce4 2019-03-11 stsp err = got_ref_write(ref, repo);
5691 d0eebce4 2019-03-11 stsp got_ref_close(ref);
5693 d1c1ae5f 2019-08-12 stsp return err;
5696 d1c1ae5f 2019-08-12 stsp static const struct got_error *
5697 d1c1ae5f 2019-08-12 stsp add_symref(struct got_repository *repo, const char *refname, const char *target)
5699 d1c1ae5f 2019-08-12 stsp const struct got_error *err = NULL;
5700 d1c1ae5f 2019-08-12 stsp struct got_reference *ref = NULL;
5701 d1c1ae5f 2019-08-12 stsp struct got_reference *target_ref = NULL;
5704 bd5895f3 2019-11-28 stsp * Don't let the user create a reference name with a leading '-'.
5705 d1c1ae5f 2019-08-12 stsp * While technically a valid reference name, this case is usually
5706 d1c1ae5f 2019-08-12 stsp * an unintended typo.
5708 bd5895f3 2019-11-28 stsp if (refname[0] == '-')
5709 bd5895f3 2019-11-28 stsp return got_error_path(refname, GOT_ERR_REF_NAME_MINUS);
5711 d1c1ae5f 2019-08-12 stsp err = got_ref_open(&target_ref, repo, target, 0);
5713 d1c1ae5f 2019-08-12 stsp return err;
5715 d1c1ae5f 2019-08-12 stsp err = got_ref_alloc_symref(&ref, refname, target_ref);
5717 d1c1ae5f 2019-08-12 stsp goto done;
5719 d1c1ae5f 2019-08-12 stsp err = got_ref_write(ref, repo);
5721 d1c1ae5f 2019-08-12 stsp if (target_ref)
5722 d1c1ae5f 2019-08-12 stsp got_ref_close(target_ref);
5724 d1c1ae5f 2019-08-12 stsp got_ref_close(ref);
5725 d0eebce4 2019-03-11 stsp return err;
5728 d0eebce4 2019-03-11 stsp static const struct got_error *
5729 d0eebce4 2019-03-11 stsp cmd_ref(int argc, char *argv[])
5731 d0eebce4 2019-03-11 stsp const struct got_error *error = NULL;
5732 d0eebce4 2019-03-11 stsp struct got_repository *repo = NULL;
5733 d0eebce4 2019-03-11 stsp struct got_worktree *worktree = NULL;
5734 d0eebce4 2019-03-11 stsp char *cwd = NULL, *repo_path = NULL;
5735 0f104432 2021-11-20 stsp int ch, do_list = 0, do_delete = 0, sort_by_time = 0;
5736 b2070a3f 2020-03-22 stsp const char *obj_arg = NULL, *symref_target= NULL;
5737 b2070a3f 2020-03-22 stsp char *refname = NULL;
5739 0f104432 2021-11-20 stsp while ((ch = getopt(argc, argv, "c:dr:ls:t")) != -1) {
5740 d0eebce4 2019-03-11 stsp switch (ch) {
5742 e31abbf2 2020-03-22 stsp obj_arg = optarg;
5745 e31abbf2 2020-03-22 stsp do_delete = 1;
5748 d0eebce4 2019-03-11 stsp repo_path = realpath(optarg, NULL);
5749 d0eebce4 2019-03-11 stsp if (repo_path == NULL)
5750 9ba1d308 2019-10-21 stsp return got_error_from_errno2("realpath",
5752 7fbaa4f3 2019-05-11 stsp got_path_strip_trailing_slashes(repo_path);
5755 d0eebce4 2019-03-11 stsp do_list = 1;
5758 e31abbf2 2020-03-22 stsp symref_target = optarg;
5761 0f104432 2021-11-20 stsp sort_by_time = 1;
5764 d0eebce4 2019-03-11 stsp usage_ref();
5765 d0eebce4 2019-03-11 stsp /* NOTREACHED */
5769 e31abbf2 2020-03-22 stsp if (obj_arg && do_list)
5770 ff69268e 2020-12-13 stsp option_conflict('c', 'l');
5771 ff69268e 2020-12-13 stsp if (obj_arg && do_delete)
5772 ff69268e 2020-12-13 stsp option_conflict('c', 'd');
5773 907f15e2 2020-03-22 stsp if (obj_arg && symref_target)
5774 ff69268e 2020-12-13 stsp option_conflict('c', 's');
5775 e31abbf2 2020-03-22 stsp if (symref_target && do_delete)
5776 ff69268e 2020-12-13 stsp option_conflict('s', 'd');
5777 e31abbf2 2020-03-22 stsp if (symref_target && do_list)
5778 ff69268e 2020-12-13 stsp option_conflict('s', 'l');
5779 e31abbf2 2020-03-22 stsp if (do_delete && do_list)
5780 ff69268e 2020-12-13 stsp option_conflict('d', 'l');
5781 0f104432 2021-11-20 stsp if (sort_by_time && !do_list)
5782 0f104432 2021-11-20 stsp errx(1, "-t option requires -l option");
5784 d0eebce4 2019-03-11 stsp argc -= optind;
5785 d0eebce4 2019-03-11 stsp argv += optind;
5787 e31abbf2 2020-03-22 stsp if (do_list) {
5788 b2070a3f 2020-03-22 stsp if (argc != 0 && argc != 1)
5789 d0eebce4 2019-03-11 stsp usage_ref();
5790 b2070a3f 2020-03-22 stsp if (argc == 1) {
5791 b2070a3f 2020-03-22 stsp refname = strdup(argv[0]);
5792 b2070a3f 2020-03-22 stsp if (refname == NULL) {
5793 b2070a3f 2020-03-22 stsp error = got_error_from_errno("strdup");
5794 b2070a3f 2020-03-22 stsp goto done;
5798 e31abbf2 2020-03-22 stsp if (argc != 1)
5799 e31abbf2 2020-03-22 stsp usage_ref();
5800 b2070a3f 2020-03-22 stsp refname = strdup(argv[0]);
5801 b2070a3f 2020-03-22 stsp if (refname == NULL) {
5802 b2070a3f 2020-03-22 stsp error = got_error_from_errno("strdup");
5803 b2070a3f 2020-03-22 stsp goto done;
5807 b2070a3f 2020-03-22 stsp if (refname)
5808 b2070a3f 2020-03-22 stsp got_path_strip_trailing_slashes(refname);
5810 d0eebce4 2019-03-11 stsp #ifndef PROFILE
5811 e0b57350 2019-03-12 stsp if (do_list) {
5812 e0b57350 2019-03-12 stsp if (pledge("stdio rpath wpath flock proc exec sendfd unveil",
5813 e0b57350 2019-03-12 stsp NULL) == -1)
5814 e0b57350 2019-03-12 stsp err(1, "pledge");
5816 e0b57350 2019-03-12 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec "
5817 e0b57350 2019-03-12 stsp "sendfd unveil", NULL) == -1)
5818 e0b57350 2019-03-12 stsp err(1, "pledge");
5821 d0eebce4 2019-03-11 stsp cwd = getcwd(NULL, 0);
5822 d0eebce4 2019-03-11 stsp if (cwd == NULL) {
5823 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
5824 d0eebce4 2019-03-11 stsp goto done;
5827 d0eebce4 2019-03-11 stsp if (repo_path == NULL) {
5828 d0eebce4 2019-03-11 stsp error = got_worktree_open(&worktree, cwd);
5829 d0eebce4 2019-03-11 stsp if (error && error->code != GOT_ERR_NOT_WORKTREE)
5830 d0eebce4 2019-03-11 stsp goto done;
5832 d0eebce4 2019-03-11 stsp error = NULL;
5833 d0eebce4 2019-03-11 stsp if (worktree) {
5834 d0eebce4 2019-03-11 stsp repo_path =
5835 d0eebce4 2019-03-11 stsp strdup(got_worktree_get_repo_path(worktree));
5836 d0eebce4 2019-03-11 stsp if (repo_path == NULL)
5837 638f9024 2019-05-13 stsp error = got_error_from_errno("strdup");
5838 d0eebce4 2019-03-11 stsp if (error)
5839 d0eebce4 2019-03-11 stsp goto done;
5841 d0eebce4 2019-03-11 stsp repo_path = strdup(cwd);
5842 d0eebce4 2019-03-11 stsp if (repo_path == NULL) {
5843 638f9024 2019-05-13 stsp error = got_error_from_errno("strdup");
5844 d0eebce4 2019-03-11 stsp goto done;
5849 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, repo_path, NULL);
5850 d0eebce4 2019-03-11 stsp if (error != NULL)
5851 d0eebce4 2019-03-11 stsp goto done;
5853 c02c541e 2019-03-29 stsp error = apply_unveil(got_repo_get_path(repo), do_list,
5854 c530dc23 2019-07-23 stsp worktree ? got_worktree_get_root_path(worktree) : NULL);
5855 c02c541e 2019-03-29 stsp if (error)
5856 c02c541e 2019-03-29 stsp goto done;
5858 d0eebce4 2019-03-11 stsp if (do_list)
5859 0f104432 2021-11-20 stsp error = list_refs(repo, refname, sort_by_time);
5860 e31abbf2 2020-03-22 stsp else if (do_delete)
5861 161728eb 2021-07-24 stsp error = delete_ref_by_name(repo, refname);
5862 e31abbf2 2020-03-22 stsp else if (symref_target)
5863 e31abbf2 2020-03-22 stsp error = add_symref(repo, refname, symref_target);
5865 e31abbf2 2020-03-22 stsp if (obj_arg == NULL)
5866 e31abbf2 2020-03-22 stsp usage_ref();
5867 e31abbf2 2020-03-22 stsp error = add_ref(repo, refname, obj_arg);
5870 b2070a3f 2020-03-22 stsp free(refname);
5871 1d0f4054 2021-06-17 stsp if (repo) {
5872 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
5873 1d0f4054 2021-06-17 stsp if (error == NULL)
5874 1d0f4054 2021-06-17 stsp error = close_err;
5876 4e759de4 2019-06-26 stsp if (worktree)
5877 4e759de4 2019-06-26 stsp got_worktree_close(worktree);
5878 4e759de4 2019-06-26 stsp free(cwd);
5879 4e759de4 2019-06-26 stsp free(repo_path);
5880 4e759de4 2019-06-26 stsp return error;
5883 4e759de4 2019-06-26 stsp __dead static void
5884 4e759de4 2019-06-26 stsp usage_branch(void)
5886 4e759de4 2019-06-26 stsp fprintf(stderr,
5887 f76670f0 2021-11-20 stsp "usage: %s branch [-c commit] [-d] [-r repository] [-l] [-t] "
5888 f76670f0 2021-11-20 stsp "[-n] [name]\n", getprogname());
5892 4e759de4 2019-06-26 stsp static const struct got_error *
5893 4e99b47e 2019-10-04 stsp list_branch(struct got_repository *repo, struct got_worktree *worktree,
5894 4e99b47e 2019-10-04 stsp struct got_reference *ref)
5896 4e99b47e 2019-10-04 stsp const struct got_error *err = NULL;
5897 4e99b47e 2019-10-04 stsp const char *refname, *marker = " ";
5898 4e99b47e 2019-10-04 stsp char *refstr;
5900 4e99b47e 2019-10-04 stsp refname = got_ref_get_name(ref);
5901 4e99b47e 2019-10-04 stsp if (worktree && strcmp(refname,
5902 4e99b47e 2019-10-04 stsp got_worktree_get_head_ref_name(worktree)) == 0) {
5903 4e99b47e 2019-10-04 stsp struct got_object_id *id = NULL;
5905 4e99b47e 2019-10-04 stsp err = got_ref_resolve(&id, repo, ref);
5907 4e99b47e 2019-10-04 stsp return err;
5908 4e99b47e 2019-10-04 stsp if (got_object_id_cmp(id,
5909 4e99b47e 2019-10-04 stsp got_worktree_get_base_commit_id(worktree)) == 0)
5910 4e99b47e 2019-10-04 stsp marker = "* ";
5912 4e99b47e 2019-10-04 stsp marker = "~ ";
5916 4e99b47e 2019-10-04 stsp if (strncmp(refname, "refs/heads/", 11) == 0)
5917 4e99b47e 2019-10-04 stsp refname += 11;
5918 4e99b47e 2019-10-04 stsp if (strncmp(refname, "refs/got/worktree/", 18) == 0)
5919 4e99b47e 2019-10-04 stsp refname += 18;
5920 34d4e04c 2021-02-08 stsp if (strncmp(refname, "refs/remotes/", 13) == 0)
5921 34d4e04c 2021-02-08 stsp refname += 13;
5923 4e99b47e 2019-10-04 stsp refstr = got_ref_to_str(ref);
5924 4e99b47e 2019-10-04 stsp if (refstr == NULL)
5925 4e99b47e 2019-10-04 stsp return got_error_from_errno("got_ref_to_str");
5927 4e99b47e 2019-10-04 stsp printf("%s%s: %s\n", marker, refname, refstr);
5928 4e99b47e 2019-10-04 stsp free(refstr);
5929 4e99b47e 2019-10-04 stsp return NULL;
5932 4e99b47e 2019-10-04 stsp static const struct got_error *
5933 ad89fa31 2019-10-04 stsp show_current_branch(struct got_repository *repo, struct got_worktree *worktree)
5935 ad89fa31 2019-10-04 stsp const char *refname;
5937 ad89fa31 2019-10-04 stsp if (worktree == NULL)
5938 ad89fa31 2019-10-04 stsp return got_error(GOT_ERR_NOT_WORKTREE);
5940 ad89fa31 2019-10-04 stsp refname = got_worktree_get_head_ref_name(worktree);
5942 ad89fa31 2019-10-04 stsp if (strncmp(refname, "refs/heads/", 11) == 0)
5943 ad89fa31 2019-10-04 stsp refname += 11;
5944 ad89fa31 2019-10-04 stsp if (strncmp(refname, "refs/got/worktree/", 18) == 0)
5945 ad89fa31 2019-10-04 stsp refname += 18;
5947 ad89fa31 2019-10-04 stsp printf("%s\n", refname);
5949 ad89fa31 2019-10-04 stsp return NULL;
5952 ad89fa31 2019-10-04 stsp static const struct got_error *
5953 f76670f0 2021-11-20 stsp list_branches(struct got_repository *repo, struct got_worktree *worktree,
5954 f76670f0 2021-11-20 stsp int sort_by_time)
5956 4e759de4 2019-06-26 stsp static const struct got_error *err = NULL;
5957 4e759de4 2019-06-26 stsp struct got_reflist_head refs;
5958 4e759de4 2019-06-26 stsp struct got_reflist_entry *re;
5959 4e99b47e 2019-10-04 stsp struct got_reference *temp_ref = NULL;
5960 4e99b47e 2019-10-04 stsp int rebase_in_progress, histedit_in_progress;
5962 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
5964 4e99b47e 2019-10-04 stsp if (worktree) {
5965 4e99b47e 2019-10-04 stsp err = got_worktree_rebase_in_progress(&rebase_in_progress,
5966 4e99b47e 2019-10-04 stsp worktree);
5968 4e99b47e 2019-10-04 stsp return err;
5970 4e99b47e 2019-10-04 stsp err = got_worktree_histedit_in_progress(&histedit_in_progress,
5971 4e99b47e 2019-10-04 stsp worktree);
5973 4e99b47e 2019-10-04 stsp return err;
5975 4e99b47e 2019-10-04 stsp if (rebase_in_progress || histedit_in_progress) {
5976 4e99b47e 2019-10-04 stsp err = got_ref_open(&temp_ref, repo,
5977 4e99b47e 2019-10-04 stsp got_worktree_get_head_ref_name(worktree), 0);
5979 4e99b47e 2019-10-04 stsp return err;
5980 4e99b47e 2019-10-04 stsp list_branch(repo, worktree, temp_ref);
5981 4e99b47e 2019-10-04 stsp got_ref_close(temp_ref);
5985 f76670f0 2021-11-20 stsp err = got_ref_list(&refs, repo, "refs/heads", sort_by_time ?
5986 f76670f0 2021-11-20 stsp got_ref_cmp_by_commit_timestamp_descending : got_ref_cmp_by_name,
5989 4e759de4 2019-06-26 stsp return err;
5991 d9dff0e5 2020-12-26 stsp TAILQ_FOREACH(re, &refs, entry)
5992 4e99b47e 2019-10-04 stsp list_branch(repo, worktree, re->ref);
5994 4e759de4 2019-06-26 stsp got_ref_list_free(&refs);
5996 f76670f0 2021-11-20 stsp err = got_ref_list(&refs, repo, "refs/remotes", sort_by_time ?
5997 f76670f0 2021-11-20 stsp got_ref_cmp_by_commit_timestamp_descending : got_ref_cmp_by_name,
6000 34d4e04c 2021-02-08 stsp return err;
6002 34d4e04c 2021-02-08 stsp TAILQ_FOREACH(re, &refs, entry)
6003 34d4e04c 2021-02-08 stsp list_branch(repo, worktree, re->ref);
6005 34d4e04c 2021-02-08 stsp got_ref_list_free(&refs);
6007 4e759de4 2019-06-26 stsp return NULL;
6010 4e759de4 2019-06-26 stsp static const struct got_error *
6011 45cd4e47 2019-08-25 stsp delete_branch(struct got_repository *repo, struct got_worktree *worktree,
6012 45cd4e47 2019-08-25 stsp const char *branch_name)
6014 4e759de4 2019-06-26 stsp const struct got_error *err = NULL;
6015 45cd4e47 2019-08-25 stsp struct got_reference *ref = NULL;
6016 2f1457c6 2021-08-27 stsp char *refname, *remote_refname = NULL;
6018 2f1457c6 2021-08-27 stsp if (strncmp(branch_name, "refs/", 5) == 0)
6019 2f1457c6 2021-08-27 stsp branch_name += 5;
6020 2f1457c6 2021-08-27 stsp if (strncmp(branch_name, "heads/", 6) == 0)
6021 2f1457c6 2021-08-27 stsp branch_name += 6;
6022 2f1457c6 2021-08-27 stsp else if (strncmp(branch_name, "remotes/", 8) == 0)
6023 2f1457c6 2021-08-27 stsp branch_name += 8;
6025 4e759de4 2019-06-26 stsp if (asprintf(&refname, "refs/heads/%s", branch_name) == -1)
6026 4e759de4 2019-06-26 stsp return got_error_from_errno("asprintf");
6028 2f1457c6 2021-08-27 stsp if (asprintf(&remote_refname, "refs/remotes/%s",
6029 2f1457c6 2021-08-27 stsp branch_name) == -1) {
6030 2f1457c6 2021-08-27 stsp err = got_error_from_errno("asprintf");
6031 4e759de4 2019-06-26 stsp goto done;
6034 2f1457c6 2021-08-27 stsp err = got_ref_open(&ref, repo, refname, 0);
6035 2f1457c6 2021-08-27 stsp if (err) {
6036 2f1457c6 2021-08-27 stsp const struct got_error *err2;
6037 2f1457c6 2021-08-27 stsp if (err->code != GOT_ERR_NOT_REF)
6038 2f1457c6 2021-08-27 stsp goto done;
6040 2f1457c6 2021-08-27 stsp * Keep 'err' intact such that if neither branch exists
6041 2f1457c6 2021-08-27 stsp * we report "refs/heads" rather than "refs/remotes" in
6042 2f1457c6 2021-08-27 stsp * our error message.
6044 2f1457c6 2021-08-27 stsp err2 = got_ref_open(&ref, repo, remote_refname, 0);
6046 2f1457c6 2021-08-27 stsp goto done;
6047 2f1457c6 2021-08-27 stsp err = NULL;
6050 45cd4e47 2019-08-25 stsp if (worktree &&
6051 45cd4e47 2019-08-25 stsp strcmp(got_worktree_get_head_ref_name(worktree),
6052 45cd4e47 2019-08-25 stsp got_ref_get_name(ref)) == 0) {
6053 45cd4e47 2019-08-25 stsp err = got_error_msg(GOT_ERR_SAME_BRANCH,
6054 45cd4e47 2019-08-25 stsp "will not delete this work tree's current branch");
6055 45cd4e47 2019-08-25 stsp goto done;
6058 978a28a1 2021-09-04 naddy err = delete_ref(repo, ref);
6061 45cd4e47 2019-08-25 stsp got_ref_close(ref);
6062 4e759de4 2019-06-26 stsp free(refname);
6063 2f1457c6 2021-08-27 stsp free(remote_refname);
6064 4e759de4 2019-06-26 stsp return err;
6067 4e759de4 2019-06-26 stsp static const struct got_error *
6068 4e759de4 2019-06-26 stsp add_branch(struct got_repository *repo, const char *branch_name,
6069 a74f7e83 2019-11-10 stsp struct got_object_id *base_commit_id)
6071 4e759de4 2019-06-26 stsp const struct got_error *err = NULL;
6072 4e759de4 2019-06-26 stsp struct got_reference *ref = NULL;
6073 4e759de4 2019-06-26 stsp char *base_refname = NULL, *refname = NULL;
6076 bd5895f3 2019-11-28 stsp * Don't let the user create a branch name with a leading '-'.
6077 d3f84d51 2019-07-11 stsp * While technically a valid reference name, this case is usually
6078 d3f84d51 2019-07-11 stsp * an unintended typo.
6080 bd5895f3 2019-11-28 stsp if (branch_name[0] == '-')
6081 bd5895f3 2019-11-28 stsp return got_error_path(branch_name, GOT_ERR_REF_NAME_MINUS);
6083 2f1457c6 2021-08-27 stsp if (strncmp(branch_name, "refs/heads/", 11) == 0)
6084 2f1457c6 2021-08-27 stsp branch_name += 11;
6086 4e759de4 2019-06-26 stsp if (asprintf(&refname, "refs/heads/%s", branch_name) == -1) {
6087 62d463ca 2020-10-20 naddy err = got_error_from_errno("asprintf");
6088 62d463ca 2020-10-20 naddy goto done;
6091 4e759de4 2019-06-26 stsp err = got_ref_open(&ref, repo, refname, 0);
6092 4e759de4 2019-06-26 stsp if (err == NULL) {
6093 4e759de4 2019-06-26 stsp err = got_error(GOT_ERR_BRANCH_EXISTS);
6094 4e759de4 2019-06-26 stsp goto done;
6095 4e759de4 2019-06-26 stsp } else if (err->code != GOT_ERR_NOT_REF)
6096 4e759de4 2019-06-26 stsp goto done;
6098 a74f7e83 2019-11-10 stsp err = got_ref_alloc(&ref, refname, base_commit_id);
6100 4e759de4 2019-06-26 stsp goto done;
6102 4e759de4 2019-06-26 stsp err = got_ref_write(ref, repo);
6105 4e759de4 2019-06-26 stsp got_ref_close(ref);
6106 4e759de4 2019-06-26 stsp free(base_refname);
6107 4e759de4 2019-06-26 stsp free(refname);
6108 4e759de4 2019-06-26 stsp return err;
6111 4e759de4 2019-06-26 stsp static const struct got_error *
6112 4e759de4 2019-06-26 stsp cmd_branch(int argc, char *argv[])
6114 4e759de4 2019-06-26 stsp const struct got_error *error = NULL;
6115 4e759de4 2019-06-26 stsp struct got_repository *repo = NULL;
6116 4e759de4 2019-06-26 stsp struct got_worktree *worktree = NULL;
6117 4e759de4 2019-06-26 stsp char *cwd = NULL, *repo_path = NULL;
6118 f76670f0 2021-11-20 stsp int ch, do_list = 0, do_show = 0, do_update = 1, sort_by_time = 0;
6119 a74f7e83 2019-11-10 stsp const char *delref = NULL, *commit_id_arg = NULL;
6120 da76fce2 2020-02-24 stsp struct got_reference *ref = NULL;
6121 da76fce2 2020-02-24 stsp struct got_pathlist_head paths;
6122 da76fce2 2020-02-24 stsp struct got_pathlist_entry *pe;
6123 da76fce2 2020-02-24 stsp struct got_object_id *commit_id = NULL;
6124 da76fce2 2020-02-24 stsp char *commit_id_str = NULL;
6126 da76fce2 2020-02-24 stsp TAILQ_INIT(&paths);
6128 f76670f0 2021-11-20 stsp while ((ch = getopt(argc, argv, "c:d:r:lnt")) != -1) {
6129 4e759de4 2019-06-26 stsp switch (ch) {
6131 a74f7e83 2019-11-10 stsp commit_id_arg = optarg;
6134 4e759de4 2019-06-26 stsp delref = optarg;
6137 4e759de4 2019-06-26 stsp repo_path = realpath(optarg, NULL);
6138 4e759de4 2019-06-26 stsp if (repo_path == NULL)
6139 9ba1d308 2019-10-21 stsp return got_error_from_errno2("realpath",
6141 4e759de4 2019-06-26 stsp got_path_strip_trailing_slashes(repo_path);
6144 4e759de4 2019-06-26 stsp do_list = 1;
6147 da76fce2 2020-02-24 stsp do_update = 0;
6150 f76670f0 2021-11-20 stsp sort_by_time = 1;
6153 4e759de4 2019-06-26 stsp usage_branch();
6154 4e759de4 2019-06-26 stsp /* NOTREACHED */
6158 4e759de4 2019-06-26 stsp if (do_list && delref)
6159 ff69268e 2020-12-13 stsp option_conflict('l', 'd');
6160 f76670f0 2021-11-20 stsp if (sort_by_time && !do_list)
6161 f76670f0 2021-11-20 stsp errx(1, "-t option requires -l option");
6163 4e759de4 2019-06-26 stsp argc -= optind;
6164 4e759de4 2019-06-26 stsp argv += optind;
6166 ad89fa31 2019-10-04 stsp if (!do_list && !delref && argc == 0)
6167 ad89fa31 2019-10-04 stsp do_show = 1;
6169 a74f7e83 2019-11-10 stsp if ((do_list || delref || do_show) && commit_id_arg != NULL)
6170 a74f7e83 2019-11-10 stsp errx(1, "-c option can only be used when creating a branch");
6172 4e759de4 2019-06-26 stsp if (do_list || delref) {
6173 4e759de4 2019-06-26 stsp if (argc > 0)
6174 4e759de4 2019-06-26 stsp usage_branch();
6175 a74f7e83 2019-11-10 stsp } else if (!do_show && argc != 1)
6176 4e759de4 2019-06-26 stsp usage_branch();
6178 4e759de4 2019-06-26 stsp #ifndef PROFILE
6179 ad89fa31 2019-10-04 stsp if (do_list || do_show) {
6180 4e759de4 2019-06-26 stsp if (pledge("stdio rpath wpath flock proc exec sendfd unveil",
6181 4e759de4 2019-06-26 stsp NULL) == -1)
6182 4e759de4 2019-06-26 stsp err(1, "pledge");
6184 4e759de4 2019-06-26 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec "
6185 4e759de4 2019-06-26 stsp "sendfd unveil", NULL) == -1)
6186 4e759de4 2019-06-26 stsp err(1, "pledge");
6189 4e759de4 2019-06-26 stsp cwd = getcwd(NULL, 0);
6190 4e759de4 2019-06-26 stsp if (cwd == NULL) {
6191 4e759de4 2019-06-26 stsp error = got_error_from_errno("getcwd");
6192 4e759de4 2019-06-26 stsp goto done;
6195 4e759de4 2019-06-26 stsp if (repo_path == NULL) {
6196 4e759de4 2019-06-26 stsp error = got_worktree_open(&worktree, cwd);
6197 4e759de4 2019-06-26 stsp if (error && error->code != GOT_ERR_NOT_WORKTREE)
6198 4e759de4 2019-06-26 stsp goto done;
6200 4e759de4 2019-06-26 stsp error = NULL;
6201 4e759de4 2019-06-26 stsp if (worktree) {
6202 4e759de4 2019-06-26 stsp repo_path =
6203 4e759de4 2019-06-26 stsp strdup(got_worktree_get_repo_path(worktree));
6204 4e759de4 2019-06-26 stsp if (repo_path == NULL)
6205 4e759de4 2019-06-26 stsp error = got_error_from_errno("strdup");
6206 4e759de4 2019-06-26 stsp if (error)
6207 4e759de4 2019-06-26 stsp goto done;
6209 4e759de4 2019-06-26 stsp repo_path = strdup(cwd);
6210 4e759de4 2019-06-26 stsp if (repo_path == NULL) {
6211 4e759de4 2019-06-26 stsp error = got_error_from_errno("strdup");
6212 4e759de4 2019-06-26 stsp goto done;
6217 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, repo_path, NULL);
6218 4e759de4 2019-06-26 stsp if (error != NULL)
6219 4e759de4 2019-06-26 stsp goto done;
6221 4e759de4 2019-06-26 stsp error = apply_unveil(got_repo_get_path(repo), do_list,
6222 c530dc23 2019-07-23 stsp worktree ? got_worktree_get_root_path(worktree) : NULL);
6223 4e759de4 2019-06-26 stsp if (error)
6224 4e759de4 2019-06-26 stsp goto done;
6226 ad89fa31 2019-10-04 stsp if (do_show)
6227 ad89fa31 2019-10-04 stsp error = show_current_branch(repo, worktree);
6228 ad89fa31 2019-10-04 stsp else if (do_list)
6229 f76670f0 2021-11-20 stsp error = list_branches(repo, worktree, sort_by_time);
6230 4e759de4 2019-06-26 stsp else if (delref)
6231 45cd4e47 2019-08-25 stsp error = delete_branch(repo, worktree, delref);
6233 84de9106 2020-12-26 stsp struct got_reflist_head refs;
6234 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
6235 84de9106 2020-12-26 stsp error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name,
6237 84de9106 2020-12-26 stsp if (error)
6238 84de9106 2020-12-26 stsp goto done;
6239 a74f7e83 2019-11-10 stsp if (commit_id_arg == NULL)
6240 a74f7e83 2019-11-10 stsp commit_id_arg = worktree ?
6241 4e759de4 2019-06-26 stsp got_worktree_get_head_ref_name(worktree) :
6242 4e759de4 2019-06-26 stsp GOT_REF_HEAD;
6243 71a27632 2020-01-15 stsp error = got_repo_match_object_id(&commit_id, NULL,
6244 84de9106 2020-12-26 stsp commit_id_arg, GOT_OBJ_TYPE_COMMIT, &refs, repo);
6245 84de9106 2020-12-26 stsp got_ref_list_free(&refs);
6246 a74f7e83 2019-11-10 stsp if (error)
6247 a74f7e83 2019-11-10 stsp goto done;
6248 a74f7e83 2019-11-10 stsp error = add_branch(repo, argv[0], commit_id);
6249 da76fce2 2020-02-24 stsp if (error)
6250 da76fce2 2020-02-24 stsp goto done;
6251 da76fce2 2020-02-24 stsp if (worktree && do_update) {
6252 9627c110 2020-04-18 stsp struct got_update_progress_arg upa;
6253 da76fce2 2020-02-24 stsp char *branch_refname = NULL;
6255 da76fce2 2020-02-24 stsp error = got_object_id_str(&commit_id_str, commit_id);
6256 da76fce2 2020-02-24 stsp if (error)
6257 da76fce2 2020-02-24 stsp goto done;
6258 da76fce2 2020-02-24 stsp error = get_worktree_paths_from_argv(&paths, 0, NULL,
6259 da76fce2 2020-02-24 stsp worktree);
6260 da76fce2 2020-02-24 stsp if (error)
6261 da76fce2 2020-02-24 stsp goto done;
6262 da76fce2 2020-02-24 stsp if (asprintf(&branch_refname, "refs/heads/%s", argv[0])
6264 da76fce2 2020-02-24 stsp error = got_error_from_errno("asprintf");
6265 da76fce2 2020-02-24 stsp goto done;
6267 da76fce2 2020-02-24 stsp error = got_ref_open(&ref, repo, branch_refname, 0);
6268 da76fce2 2020-02-24 stsp free(branch_refname);
6269 da76fce2 2020-02-24 stsp if (error)
6270 da76fce2 2020-02-24 stsp goto done;
6271 da76fce2 2020-02-24 stsp error = switch_head_ref(ref, commit_id, worktree,
6273 da76fce2 2020-02-24 stsp if (error)
6274 da76fce2 2020-02-24 stsp goto done;
6275 da76fce2 2020-02-24 stsp error = got_worktree_set_base_commit_id(worktree, repo,
6276 da76fce2 2020-02-24 stsp commit_id);
6277 da76fce2 2020-02-24 stsp if (error)
6278 da76fce2 2020-02-24 stsp goto done;
6279 9627c110 2020-04-18 stsp memset(&upa, 0, sizeof(upa));
6280 da76fce2 2020-02-24 stsp error = got_worktree_checkout_files(worktree, &paths,
6281 9627c110 2020-04-18 stsp repo, update_progress, &upa, check_cancelled,
6283 da76fce2 2020-02-24 stsp if (error)
6284 da76fce2 2020-02-24 stsp goto done;
6285 4f3c844b 2021-09-14 stsp if (upa.did_something) {
6286 4f3c844b 2021-09-14 stsp printf("Updated to %s: %s\n",
6287 4f3c844b 2021-09-14 stsp got_worktree_get_head_ref_name(worktree),
6288 4f3c844b 2021-09-14 stsp commit_id_str);
6290 9627c110 2020-04-18 stsp print_update_progress_stats(&upa);
6295 da76fce2 2020-02-24 stsp got_ref_close(ref);
6296 1d0f4054 2021-06-17 stsp if (repo) {
6297 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
6298 1d0f4054 2021-06-17 stsp if (error == NULL)
6299 1d0f4054 2021-06-17 stsp error = close_err;
6301 d0eebce4 2019-03-11 stsp if (worktree)
6302 d0eebce4 2019-03-11 stsp got_worktree_close(worktree);
6303 d0eebce4 2019-03-11 stsp free(cwd);
6304 d0eebce4 2019-03-11 stsp free(repo_path);
6305 da76fce2 2020-02-24 stsp free(commit_id);
6306 da76fce2 2020-02-24 stsp free(commit_id_str);
6307 da76fce2 2020-02-24 stsp TAILQ_FOREACH(pe, &paths, entry)
6308 da76fce2 2020-02-24 stsp free((char *)pe->path);
6309 da76fce2 2020-02-24 stsp got_pathlist_free(&paths);
6310 d00136be 2019-03-26 stsp return error;
6314 d00136be 2019-03-26 stsp __dead static void
6315 8e7bd50a 2019-08-22 stsp usage_tag(void)
6317 8e7bd50a 2019-08-22 stsp fprintf(stderr,
6318 80106605 2020-02-24 stsp "usage: %s tag [-c commit] [-r repository] [-l] "
6319 80106605 2020-02-24 stsp "[-m message] name\n", getprogname());
6324 b8bad2ba 2019-08-23 stsp static const struct got_error *
6325 b8bad2ba 2019-08-23 stsp sort_tags(struct got_reflist_head *sorted, struct got_reflist_head *tags)
6327 b8bad2ba 2019-08-23 stsp const struct got_error *err = NULL;
6328 b8bad2ba 2019-08-23 stsp struct got_reflist_entry *re, *se, *new;
6329 b8bad2ba 2019-08-23 stsp struct got_object_id *re_id, *se_id;
6330 b8bad2ba 2019-08-23 stsp struct got_tag_object *re_tag, *se_tag;
6331 b8bad2ba 2019-08-23 stsp time_t re_time, se_time;
6333 dbdddfee 2021-06-23 naddy STAILQ_FOREACH(re, tags, entry) {
6334 dbdddfee 2021-06-23 naddy se = STAILQ_FIRST(sorted);
6335 b8bad2ba 2019-08-23 stsp if (se == NULL) {
6336 b8bad2ba 2019-08-23 stsp err = got_reflist_entry_dup(&new, re);
6338 b8bad2ba 2019-08-23 stsp return err;
6339 dbdddfee 2021-06-23 naddy STAILQ_INSERT_HEAD(sorted, new, entry);
6342 b8bad2ba 2019-08-23 stsp err = got_ref_resolve(&re_id, repo, re->ref);
6345 b8bad2ba 2019-08-23 stsp err = got_object_open_as_tag(&re_tag, repo, re_id);
6346 b8bad2ba 2019-08-23 stsp free(re_id);
6349 b8bad2ba 2019-08-23 stsp re_time = got_object_tag_get_tagger_time(re_tag);
6350 b8bad2ba 2019-08-23 stsp got_object_tag_close(re_tag);
6353 b8bad2ba 2019-08-23 stsp while (se) {
6354 b8bad2ba 2019-08-23 stsp err = got_ref_resolve(&se_id, repo, re->ref);
6357 b8bad2ba 2019-08-23 stsp err = got_object_open_as_tag(&se_tag, repo, se_id);
6358 b8bad2ba 2019-08-23 stsp free(se_id);
6361 b8bad2ba 2019-08-23 stsp se_time = got_object_tag_get_tagger_time(se_tag);
6362 b8bad2ba 2019-08-23 stsp got_object_tag_close(se_tag);
6364 b8bad2ba 2019-08-23 stsp if (se_time > re_time) {
6365 b8bad2ba 2019-08-23 stsp err = got_reflist_entry_dup(&new, re);
6367 b8bad2ba 2019-08-23 stsp return err;
6368 dbdddfee 2021-06-23 naddy STAILQ_INSERT_AFTER(sorted, se, new, entry);
6371 dbdddfee 2021-06-23 naddy se = STAILQ_NEXT(se, entry);
6376 b8bad2ba 2019-08-23 stsp return err;
6380 b8bad2ba 2019-08-23 stsp static const struct got_error *
6381 8e7bd50a 2019-08-22 stsp list_tags(struct got_repository *repo, struct got_worktree *worktree)
6383 8e7bd50a 2019-08-22 stsp static const struct got_error *err = NULL;
6384 8e7bd50a 2019-08-22 stsp struct got_reflist_head refs;
6385 8e7bd50a 2019-08-22 stsp struct got_reflist_entry *re;
6387 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
6389 d1f16636 2020-01-15 stsp err = got_ref_list(&refs, repo, "refs/tags", got_ref_cmp_tags, repo);
6391 8e7bd50a 2019-08-22 stsp return err;
6393 d9dff0e5 2020-12-26 stsp TAILQ_FOREACH(re, &refs, entry) {
6394 8e7bd50a 2019-08-22 stsp const char *refname;
6395 8e7bd50a 2019-08-22 stsp char *refstr, *tagmsg0, *tagmsg, *line, *id_str, *datestr;
6396 8e7bd50a 2019-08-22 stsp char datebuf[26];
6397 d4efa91b 2020-01-14 stsp const char *tagger;
6398 8e7bd50a 2019-08-22 stsp time_t tagger_time;
6399 8e7bd50a 2019-08-22 stsp struct got_object_id *id;
6400 8e7bd50a 2019-08-22 stsp struct got_tag_object *tag;
6401 d4efa91b 2020-01-14 stsp struct got_commit_object *commit = NULL;
6403 8e7bd50a 2019-08-22 stsp refname = got_ref_get_name(re->ref);
6404 8e7bd50a 2019-08-22 stsp if (strncmp(refname, "refs/tags/", 10) != 0)
6406 8e7bd50a 2019-08-22 stsp refname += 10;
6407 8e7bd50a 2019-08-22 stsp refstr = got_ref_to_str(re->ref);
6408 8e7bd50a 2019-08-22 stsp if (refstr == NULL) {
6409 8e7bd50a 2019-08-22 stsp err = got_error_from_errno("got_ref_to_str");
6412 8e7bd50a 2019-08-22 stsp printf("%stag %s %s\n", GOT_COMMIT_SEP_STR, refname, refstr);
6413 8e7bd50a 2019-08-22 stsp free(refstr);
6415 8e7bd50a 2019-08-22 stsp err = got_ref_resolve(&id, repo, re->ref);
6418 8e7bd50a 2019-08-22 stsp err = got_object_open_as_tag(&tag, repo, id);
6419 d4efa91b 2020-01-14 stsp if (err) {
6420 d4efa91b 2020-01-14 stsp if (err->code != GOT_ERR_OBJ_TYPE) {
6424 d4efa91b 2020-01-14 stsp /* "lightweight" tag */
6425 d4efa91b 2020-01-14 stsp err = got_object_open_as_commit(&commit, repo, id);
6426 d4efa91b 2020-01-14 stsp if (err) {
6430 d4efa91b 2020-01-14 stsp tagger = got_object_commit_get_committer(commit);
6431 d4efa91b 2020-01-14 stsp tagger_time =
6432 d4efa91b 2020-01-14 stsp got_object_commit_get_committer_time(commit);
6433 d4efa91b 2020-01-14 stsp err = got_object_id_str(&id_str, id);
6439 d4efa91b 2020-01-14 stsp tagger = got_object_tag_get_tagger(tag);
6440 d4efa91b 2020-01-14 stsp tagger_time = got_object_tag_get_tagger_time(tag);
6441 d4efa91b 2020-01-14 stsp err = got_object_id_str(&id_str,
6442 d4efa91b 2020-01-14 stsp got_object_tag_get_object_id(tag));
6446 d4efa91b 2020-01-14 stsp printf("from: %s\n", tagger);
6447 2417344c 2019-08-23 stsp datestr = get_datestr(&tagger_time, datebuf);
6448 2417344c 2019-08-23 stsp if (datestr)
6449 2417344c 2019-08-23 stsp printf("date: %s UTC\n", datestr);
6450 d4efa91b 2020-01-14 stsp if (commit)
6451 2417344c 2019-08-23 stsp printf("object: %s %s\n", GOT_OBJ_LABEL_COMMIT, id_str);
6453 d4efa91b 2020-01-14 stsp switch (got_object_tag_get_object_type(tag)) {
6454 d4efa91b 2020-01-14 stsp case GOT_OBJ_TYPE_BLOB:
6455 d4efa91b 2020-01-14 stsp printf("object: %s %s\n", GOT_OBJ_LABEL_BLOB,
6458 d4efa91b 2020-01-14 stsp case GOT_OBJ_TYPE_TREE:
6459 d4efa91b 2020-01-14 stsp printf("object: %s %s\n", GOT_OBJ_LABEL_TREE,
6462 d4efa91b 2020-01-14 stsp case GOT_OBJ_TYPE_COMMIT:
6463 d4efa91b 2020-01-14 stsp printf("object: %s %s\n", GOT_OBJ_LABEL_COMMIT,
6466 d4efa91b 2020-01-14 stsp case GOT_OBJ_TYPE_TAG:
6467 d4efa91b 2020-01-14 stsp printf("object: %s %s\n", GOT_OBJ_LABEL_TAG,
6474 8e7bd50a 2019-08-22 stsp free(id_str);
6475 d4efa91b 2020-01-14 stsp if (commit) {
6476 d4efa91b 2020-01-14 stsp err = got_object_commit_get_logmsg(&tagmsg0, commit);
6479 d4efa91b 2020-01-14 stsp got_object_commit_close(commit);
6481 d4efa91b 2020-01-14 stsp tagmsg0 = strdup(got_object_tag_get_message(tag));
6482 d4efa91b 2020-01-14 stsp got_object_tag_close(tag);
6483 d4efa91b 2020-01-14 stsp if (tagmsg0 == NULL) {
6484 d4efa91b 2020-01-14 stsp err = got_error_from_errno("strdup");
6489 8e7bd50a 2019-08-22 stsp tagmsg = tagmsg0;
6491 8e7bd50a 2019-08-22 stsp line = strsep(&tagmsg, "\n");
6493 8e7bd50a 2019-08-22 stsp printf(" %s\n", line);
6494 8e7bd50a 2019-08-22 stsp } while (line);
6495 8e7bd50a 2019-08-22 stsp free(tagmsg0);
6498 8e7bd50a 2019-08-22 stsp got_ref_list_free(&refs);
6499 8e7bd50a 2019-08-22 stsp return NULL;
6502 8e7bd50a 2019-08-22 stsp static const struct got_error *
6503 f372d5cd 2019-10-21 stsp get_tag_message(char **tagmsg, char **tagmsg_path, const char *commit_id_str,
6504 62870f63 2019-08-22 stsp const char *tag_name, const char *repo_path)
6506 8e7bd50a 2019-08-22 stsp const struct got_error *err = NULL;
6507 8e7bd50a 2019-08-22 stsp char *template = NULL, *initial_content = NULL;
6508 f372d5cd 2019-10-21 stsp char *editor = NULL;
6509 1601cb9f 2020-09-11 naddy int initial_content_len;
6510 8e7bd50a 2019-08-22 stsp int fd = -1;
6512 bb63914a 2020-02-17 stsp if (asprintf(&template, GOT_TMPDIR_STR "/got-tagmsg") == -1) {
6513 8e7bd50a 2019-08-22 stsp err = got_error_from_errno("asprintf");
6514 8e7bd50a 2019-08-22 stsp goto done;
6517 1601cb9f 2020-09-11 naddy initial_content_len = asprintf(&initial_content,
6518 1601cb9f 2020-09-11 naddy "\n# tagging commit %s as %s\n",
6519 1601cb9f 2020-09-11 naddy commit_id_str, tag_name);
6520 1601cb9f 2020-09-11 naddy if (initial_content_len == -1) {
6521 8e7bd50a 2019-08-22 stsp err = got_error_from_errno("asprintf");
6522 8e7bd50a 2019-08-22 stsp goto done;
6525 f372d5cd 2019-10-21 stsp err = got_opentemp_named_fd(tagmsg_path, &fd, template);
6527 8e7bd50a 2019-08-22 stsp goto done;
6529 97972933 2020-09-11 stsp if (write(fd, initial_content, initial_content_len) == -1) {
6530 97972933 2020-09-11 stsp err = got_error_from_errno2("write", *tagmsg_path);
6531 97972933 2020-09-11 stsp goto done;
6534 8e7bd50a 2019-08-22 stsp err = get_editor(&editor);
6536 8e7bd50a 2019-08-22 stsp goto done;
6537 bfa12d5e 2020-09-26 stsp err = edit_logmsg(tagmsg, editor, *tagmsg_path, initial_content,
6538 0d5bb276 2020-12-15 stsp initial_content_len, 1);
6540 8e7bd50a 2019-08-22 stsp free(initial_content);
6541 8e7bd50a 2019-08-22 stsp free(template);
6542 8e7bd50a 2019-08-22 stsp free(editor);
6544 97972933 2020-09-11 stsp if (fd != -1 && close(fd) == -1 && err == NULL)
6545 97972933 2020-09-11 stsp err = got_error_from_errno2("close", *tagmsg_path);
6547 8e7bd50a 2019-08-22 stsp /* Editor is done; we can now apply unveil(2) */
6548 59f86c76 2020-09-11 stsp if (err == NULL)
6549 8e7bd50a 2019-08-22 stsp err = apply_unveil(repo_path, 0, NULL);
6550 59f86c76 2020-09-11 stsp if (err) {
6551 59f86c76 2020-09-11 stsp free(*tagmsg);
6552 59f86c76 2020-09-11 stsp *tagmsg = NULL;
6554 8e7bd50a 2019-08-22 stsp return err;
6557 8e7bd50a 2019-08-22 stsp static const struct got_error *
6558 50b0790e 2020-09-11 stsp add_tag(struct got_repository *repo, struct got_worktree *worktree,
6559 50b0790e 2020-09-11 stsp const char *tag_name, const char *commit_arg, const char *tagmsg_arg)
6561 8e7bd50a 2019-08-22 stsp const struct got_error *err = NULL;
6562 8e7bd50a 2019-08-22 stsp struct got_object_id *commit_id = NULL, *tag_id = NULL;
6563 8e7bd50a 2019-08-22 stsp char *label = NULL, *commit_id_str = NULL;
6564 8e7bd50a 2019-08-22 stsp struct got_reference *ref = NULL;
6565 aba9c984 2019-09-08 stsp char *refname = NULL, *tagmsg = NULL, *tagger = NULL;
6566 f372d5cd 2019-10-21 stsp char *tagmsg_path = NULL, *tag_id_str = NULL;
6567 f372d5cd 2019-10-21 stsp int preserve_tagmsg = 0;
6568 84de9106 2020-12-26 stsp struct got_reflist_head refs;
6570 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
6573 bd5895f3 2019-11-28 stsp * Don't let the user create a tag name with a leading '-'.
6574 8e7bd50a 2019-08-22 stsp * While technically a valid reference name, this case is usually
6575 8e7bd50a 2019-08-22 stsp * an unintended typo.
6577 bd5895f3 2019-11-28 stsp if (tag_name[0] == '-')
6578 bd5895f3 2019-11-28 stsp return got_error_path(tag_name, GOT_ERR_REF_NAME_MINUS);
6580 50b0790e 2020-09-11 stsp err = get_author(&tagger, repo, worktree);
6582 8e7bd50a 2019-08-22 stsp return err;
6584 84de9106 2020-12-26 stsp err = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
6586 84de9106 2020-12-26 stsp goto done;
6588 71a27632 2020-01-15 stsp err = got_repo_match_object_id(&commit_id, &label, commit_arg,
6589 84de9106 2020-12-26 stsp GOT_OBJ_TYPE_COMMIT, &refs, repo);
6591 8e7bd50a 2019-08-22 stsp goto done;
6593 8e7bd50a 2019-08-22 stsp err = got_object_id_str(&commit_id_str, commit_id);
6595 8e7bd50a 2019-08-22 stsp goto done;
6597 8e7bd50a 2019-08-22 stsp if (strncmp("refs/tags/", tag_name, 10) == 0) {
6598 8e7bd50a 2019-08-22 stsp refname = strdup(tag_name);
6599 8e7bd50a 2019-08-22 stsp if (refname == NULL) {
6600 62d463ca 2020-10-20 naddy err = got_error_from_errno("strdup");
6601 62d463ca 2020-10-20 naddy goto done;
6603 8e7bd50a 2019-08-22 stsp tag_name += 10;
6604 8e7bd50a 2019-08-22 stsp } else if (asprintf(&refname, "refs/tags/%s", tag_name) == -1) {
6605 62d463ca 2020-10-20 naddy err = got_error_from_errno("asprintf");
6606 62d463ca 2020-10-20 naddy goto done;
6609 8e7bd50a 2019-08-22 stsp err = got_ref_open(&ref, repo, refname, 0);
6610 8e7bd50a 2019-08-22 stsp if (err == NULL) {
6611 8e7bd50a 2019-08-22 stsp err = got_error(GOT_ERR_TAG_EXISTS);
6612 8e7bd50a 2019-08-22 stsp goto done;
6613 8e7bd50a 2019-08-22 stsp } else if (err->code != GOT_ERR_NOT_REF)
6614 8e7bd50a 2019-08-22 stsp goto done;
6616 8e7bd50a 2019-08-22 stsp if (tagmsg_arg == NULL) {
6617 f372d5cd 2019-10-21 stsp err = get_tag_message(&tagmsg, &tagmsg_path, commit_id_str,
6618 62870f63 2019-08-22 stsp tag_name, got_repo_get_path(repo));
6619 f372d5cd 2019-10-21 stsp if (err) {
6620 f372d5cd 2019-10-21 stsp if (err->code != GOT_ERR_COMMIT_MSG_EMPTY &&
6621 f372d5cd 2019-10-21 stsp tagmsg_path != NULL)
6622 f372d5cd 2019-10-21 stsp preserve_tagmsg = 1;
6623 8e7bd50a 2019-08-22 stsp goto done;
6627 8e7bd50a 2019-08-22 stsp err = got_object_tag_create(&tag_id, tag_name, commit_id,
6628 8e7bd50a 2019-08-22 stsp tagger, time(NULL), tagmsg ? tagmsg : tagmsg_arg, repo);
6629 f372d5cd 2019-10-21 stsp if (err) {
6630 f372d5cd 2019-10-21 stsp if (tagmsg_path)
6631 f372d5cd 2019-10-21 stsp preserve_tagmsg = 1;
6632 8e7bd50a 2019-08-22 stsp goto done;
6635 8e7bd50a 2019-08-22 stsp err = got_ref_alloc(&ref, refname, tag_id);
6636 f372d5cd 2019-10-21 stsp if (err) {
6637 f372d5cd 2019-10-21 stsp if (tagmsg_path)
6638 f372d5cd 2019-10-21 stsp preserve_tagmsg = 1;
6639 8e7bd50a 2019-08-22 stsp goto done;
6642 8e7bd50a 2019-08-22 stsp err = got_ref_write(ref, repo);
6643 f372d5cd 2019-10-21 stsp if (err) {
6644 f372d5cd 2019-10-21 stsp if (tagmsg_path)
6645 f372d5cd 2019-10-21 stsp preserve_tagmsg = 1;
6646 f372d5cd 2019-10-21 stsp goto done;
6649 f372d5cd 2019-10-21 stsp err = got_object_id_str(&tag_id_str, tag_id);
6650 f372d5cd 2019-10-21 stsp if (err) {
6651 f372d5cd 2019-10-21 stsp if (tagmsg_path)
6652 f372d5cd 2019-10-21 stsp preserve_tagmsg = 1;
6653 f372d5cd 2019-10-21 stsp goto done;
6655 f372d5cd 2019-10-21 stsp printf("Created tag %s\n", tag_id_str);
6657 f372d5cd 2019-10-21 stsp if (preserve_tagmsg) {
6658 f372d5cd 2019-10-21 stsp fprintf(stderr, "%s: tag message preserved in %s\n",
6659 f372d5cd 2019-10-21 stsp getprogname(), tagmsg_path);
6660 f372d5cd 2019-10-21 stsp } else if (tagmsg_path && unlink(tagmsg_path) == -1 && err == NULL)
6661 f372d5cd 2019-10-21 stsp err = got_error_from_errno2("unlink", tagmsg_path);
6662 f372d5cd 2019-10-21 stsp free(tag_id_str);
6664 8e7bd50a 2019-08-22 stsp got_ref_close(ref);
6665 8e7bd50a 2019-08-22 stsp free(commit_id);
6666 8e7bd50a 2019-08-22 stsp free(commit_id_str);
6667 8e7bd50a 2019-08-22 stsp free(refname);
6668 8e7bd50a 2019-08-22 stsp free(tagmsg);
6669 f372d5cd 2019-10-21 stsp free(tagmsg_path);
6670 aba9c984 2019-09-08 stsp free(tagger);
6671 84de9106 2020-12-26 stsp got_ref_list_free(&refs);
6672 8e7bd50a 2019-08-22 stsp return err;
6675 8e7bd50a 2019-08-22 stsp static const struct got_error *
6676 8e7bd50a 2019-08-22 stsp cmd_tag(int argc, char *argv[])
6678 8e7bd50a 2019-08-22 stsp const struct got_error *error = NULL;
6679 8e7bd50a 2019-08-22 stsp struct got_repository *repo = NULL;
6680 8e7bd50a 2019-08-22 stsp struct got_worktree *worktree = NULL;
6681 8e7bd50a 2019-08-22 stsp char *cwd = NULL, *repo_path = NULL, *commit_id_str = NULL;
6682 c9956ddf 2019-09-08 stsp char *gitconfig_path = NULL;
6683 8e7bd50a 2019-08-22 stsp const char *tag_name, *commit_id_arg = NULL, *tagmsg = NULL;
6684 8e7bd50a 2019-08-22 stsp int ch, do_list = 0;
6686 80106605 2020-02-24 stsp while ((ch = getopt(argc, argv, "c:m:r:l")) != -1) {
6687 8e7bd50a 2019-08-22 stsp switch (ch) {
6689 80106605 2020-02-24 stsp commit_id_arg = optarg;
6692 8e7bd50a 2019-08-22 stsp tagmsg = optarg;
6695 8e7bd50a 2019-08-22 stsp repo_path = realpath(optarg, NULL);
6696 8e7bd50a 2019-08-22 stsp if (repo_path == NULL)
6697 9ba1d308 2019-10-21 stsp return got_error_from_errno2("realpath",
6699 8e7bd50a 2019-08-22 stsp got_path_strip_trailing_slashes(repo_path);
6702 8e7bd50a 2019-08-22 stsp do_list = 1;
6705 8e7bd50a 2019-08-22 stsp usage_tag();
6706 8e7bd50a 2019-08-22 stsp /* NOTREACHED */
6710 8e7bd50a 2019-08-22 stsp argc -= optind;
6711 8e7bd50a 2019-08-22 stsp argv += optind;
6713 8e7bd50a 2019-08-22 stsp if (do_list) {
6714 80106605 2020-02-24 stsp if (commit_id_arg != NULL)
6716 775ce909 2020-03-22 stsp "-c option can only be used when creating a tag");
6717 8e7bd50a 2019-08-22 stsp if (tagmsg)
6718 ff69268e 2020-12-13 stsp option_conflict('l', 'm');
6719 8e7bd50a 2019-08-22 stsp if (argc > 0)
6720 8e7bd50a 2019-08-22 stsp usage_tag();
6721 80106605 2020-02-24 stsp } else if (argc != 1)
6722 8e7bd50a 2019-08-22 stsp usage_tag();
6724 a2887370 2019-08-23 stsp tag_name = argv[0];
6726 8e7bd50a 2019-08-22 stsp #ifndef PROFILE
6727 8e7bd50a 2019-08-22 stsp if (do_list) {
6728 8e7bd50a 2019-08-22 stsp if (pledge("stdio rpath wpath flock proc exec sendfd unveil",
6729 8e7bd50a 2019-08-22 stsp NULL) == -1)
6730 8e7bd50a 2019-08-22 stsp err(1, "pledge");
6732 8e7bd50a 2019-08-22 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec "
6733 8e7bd50a 2019-08-22 stsp "sendfd unveil", NULL) == -1)
6734 8e7bd50a 2019-08-22 stsp err(1, "pledge");
6737 8e7bd50a 2019-08-22 stsp cwd = getcwd(NULL, 0);
6738 8e7bd50a 2019-08-22 stsp if (cwd == NULL) {
6739 8e7bd50a 2019-08-22 stsp error = got_error_from_errno("getcwd");
6740 8e7bd50a 2019-08-22 stsp goto done;
6743 8e7bd50a 2019-08-22 stsp if (repo_path == NULL) {
6744 8e7bd50a 2019-08-22 stsp error = got_worktree_open(&worktree, cwd);
6745 8e7bd50a 2019-08-22 stsp if (error && error->code != GOT_ERR_NOT_WORKTREE)
6746 8e7bd50a 2019-08-22 stsp goto done;
6748 8e7bd50a 2019-08-22 stsp error = NULL;
6749 8e7bd50a 2019-08-22 stsp if (worktree) {
6750 8e7bd50a 2019-08-22 stsp repo_path =
6751 8e7bd50a 2019-08-22 stsp strdup(got_worktree_get_repo_path(worktree));
6752 8e7bd50a 2019-08-22 stsp if (repo_path == NULL)
6753 8e7bd50a 2019-08-22 stsp error = got_error_from_errno("strdup");
6754 8e7bd50a 2019-08-22 stsp if (error)
6755 8e7bd50a 2019-08-22 stsp goto done;
6757 8e7bd50a 2019-08-22 stsp repo_path = strdup(cwd);
6758 8e7bd50a 2019-08-22 stsp if (repo_path == NULL) {
6759 8e7bd50a 2019-08-22 stsp error = got_error_from_errno("strdup");
6760 8e7bd50a 2019-08-22 stsp goto done;
6765 8e7bd50a 2019-08-22 stsp if (do_list) {
6766 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, repo_path, NULL);
6767 c9956ddf 2019-09-08 stsp if (error != NULL)
6768 c9956ddf 2019-09-08 stsp goto done;
6769 8e7bd50a 2019-08-22 stsp error = apply_unveil(got_repo_get_path(repo), 1, NULL);
6770 8e7bd50a 2019-08-22 stsp if (error)
6771 8e7bd50a 2019-08-22 stsp goto done;
6772 8e7bd50a 2019-08-22 stsp error = list_tags(repo, worktree);
6774 c9956ddf 2019-09-08 stsp error = get_gitconfig_path(&gitconfig_path);
6775 c9956ddf 2019-09-08 stsp if (error)
6776 c9956ddf 2019-09-08 stsp goto done;
6777 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, repo_path, gitconfig_path);
6778 c9956ddf 2019-09-08 stsp if (error != NULL)
6779 c9956ddf 2019-09-08 stsp goto done;
6781 8e7bd50a 2019-08-22 stsp if (tagmsg) {
6782 42a285e2 2020-10-01 stsp error = apply_unveil(got_repo_get_path(repo), 0, NULL);
6783 8e7bd50a 2019-08-22 stsp if (error)
6784 8e7bd50a 2019-08-22 stsp goto done;
6787 8e7bd50a 2019-08-22 stsp if (commit_id_arg == NULL) {
6788 8e7bd50a 2019-08-22 stsp struct got_reference *head_ref;
6789 8e7bd50a 2019-08-22 stsp struct got_object_id *commit_id;
6790 8e7bd50a 2019-08-22 stsp error = got_ref_open(&head_ref, repo,
6791 8e7bd50a 2019-08-22 stsp worktree ? got_worktree_get_head_ref_name(worktree)
6792 8e7bd50a 2019-08-22 stsp : GOT_REF_HEAD, 0);
6793 8e7bd50a 2019-08-22 stsp if (error)
6794 8e7bd50a 2019-08-22 stsp goto done;
6795 8e7bd50a 2019-08-22 stsp error = got_ref_resolve(&commit_id, repo, head_ref);
6796 8e7bd50a 2019-08-22 stsp got_ref_close(head_ref);
6797 8e7bd50a 2019-08-22 stsp if (error)
6798 8e7bd50a 2019-08-22 stsp goto done;
6799 8e7bd50a 2019-08-22 stsp error = got_object_id_str(&commit_id_str, commit_id);
6800 8e7bd50a 2019-08-22 stsp free(commit_id);
6801 8e7bd50a 2019-08-22 stsp if (error)
6802 8e7bd50a 2019-08-22 stsp goto done;
6805 50b0790e 2020-09-11 stsp error = add_tag(repo, worktree, tag_name,
6806 8e7bd50a 2019-08-22 stsp commit_id_str ? commit_id_str : commit_id_arg, tagmsg);
6809 1d0f4054 2021-06-17 stsp if (repo) {
6810 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
6811 1d0f4054 2021-06-17 stsp if (error == NULL)
6812 1d0f4054 2021-06-17 stsp error = close_err;
6814 8e7bd50a 2019-08-22 stsp if (worktree)
6815 8e7bd50a 2019-08-22 stsp got_worktree_close(worktree);
6816 8e7bd50a 2019-08-22 stsp free(cwd);
6817 8e7bd50a 2019-08-22 stsp free(repo_path);
6818 c9956ddf 2019-09-08 stsp free(gitconfig_path);
6819 8e7bd50a 2019-08-22 stsp free(commit_id_str);
6820 8e7bd50a 2019-08-22 stsp return error;
6823 8e7bd50a 2019-08-22 stsp __dead static void
6824 d00136be 2019-03-26 stsp usage_add(void)
6826 c29c428a 2019-12-16 stsp fprintf(stderr, "usage: %s add [-R] [-I] path ...\n",
6827 022fae89 2019-12-06 tracey getprogname());
6831 d00136be 2019-03-26 stsp static const struct got_error *
6832 4e68cba3 2019-11-23 stsp add_progress(void *arg, unsigned char status, const char *path)
6834 4e68cba3 2019-11-23 stsp while (path[0] == '/')
6836 4e68cba3 2019-11-23 stsp printf("%c %s\n", status, path);
6837 4e68cba3 2019-11-23 stsp return NULL;
6840 4e68cba3 2019-11-23 stsp static const struct got_error *
6841 d00136be 2019-03-26 stsp cmd_add(int argc, char *argv[])
6843 d00136be 2019-03-26 stsp const struct got_error *error = NULL;
6844 031a5338 2019-03-26 stsp struct got_repository *repo = NULL;
6845 d00136be 2019-03-26 stsp struct got_worktree *worktree = NULL;
6846 1dd54920 2019-05-11 stsp char *cwd = NULL;
6847 1dd54920 2019-05-11 stsp struct got_pathlist_head paths;
6848 1dd54920 2019-05-11 stsp struct got_pathlist_entry *pe;
6849 022fae89 2019-12-06 tracey int ch, can_recurse = 0, no_ignores = 0;
6851 1dd54920 2019-05-11 stsp TAILQ_INIT(&paths);
6853 022fae89 2019-12-06 tracey while ((ch = getopt(argc, argv, "IR")) != -1) {
6854 d00136be 2019-03-26 stsp switch (ch) {
6855 022fae89 2019-12-06 tracey case 'I':
6856 022fae89 2019-12-06 tracey no_ignores = 1;
6859 4e68cba3 2019-11-23 stsp can_recurse = 1;
6862 d00136be 2019-03-26 stsp usage_add();
6863 d00136be 2019-03-26 stsp /* NOTREACHED */
6867 d00136be 2019-03-26 stsp argc -= optind;
6868 d00136be 2019-03-26 stsp argv += optind;
6870 43012d58 2019-07-14 stsp #ifndef PROFILE
6871 43012d58 2019-07-14 stsp if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
6872 43012d58 2019-07-14 stsp NULL) == -1)
6873 43012d58 2019-07-14 stsp err(1, "pledge");
6875 723c305c 2019-05-11 jcs if (argc < 1)
6876 d00136be 2019-03-26 stsp usage_add();
6878 d00136be 2019-03-26 stsp cwd = getcwd(NULL, 0);
6879 d00136be 2019-03-26 stsp if (cwd == NULL) {
6880 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
6881 d00136be 2019-03-26 stsp goto done;
6884 d00136be 2019-03-26 stsp error = got_worktree_open(&worktree, cwd);
6885 fa51e947 2020-03-27 stsp if (error) {
6886 fa51e947 2020-03-27 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
6887 fa51e947 2020-03-27 stsp error = wrap_not_worktree_error(error, "add", cwd);
6888 d00136be 2019-03-26 stsp goto done;
6891 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
6893 031a5338 2019-03-26 stsp if (error != NULL)
6894 031a5338 2019-03-26 stsp goto done;
6896 031a5338 2019-03-26 stsp error = apply_unveil(got_repo_get_path(repo), 1,
6897 c530dc23 2019-07-23 stsp got_worktree_get_root_path(worktree));
6898 d00136be 2019-03-26 stsp if (error)
6899 d00136be 2019-03-26 stsp goto done;
6901 6d022e97 2019-08-04 stsp error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
6902 6d022e97 2019-08-04 stsp if (error)
6903 022fae89 2019-12-06 tracey goto done;
6905 4e68cba3 2019-11-23 stsp if (!can_recurse) {
6906 4e68cba3 2019-11-23 stsp char *ondisk_path;
6907 4e68cba3 2019-11-23 stsp struct stat sb;
6908 4e68cba3 2019-11-23 stsp TAILQ_FOREACH(pe, &paths, entry) {
6909 4e68cba3 2019-11-23 stsp if (asprintf(&ondisk_path, "%s/%s",
6910 4e68cba3 2019-11-23 stsp got_worktree_get_root_path(worktree),
6911 62d463ca 2020-10-20 naddy pe->path) == -1) {
6912 4e68cba3 2019-11-23 stsp error = got_error_from_errno("asprintf");
6913 4e68cba3 2019-11-23 stsp goto done;
6915 4e68cba3 2019-11-23 stsp if (lstat(ondisk_path, &sb) == -1) {
6916 4e68cba3 2019-11-23 stsp if (errno == ENOENT) {
6917 4e68cba3 2019-11-23 stsp free(ondisk_path);
6920 4e68cba3 2019-11-23 stsp error = got_error_from_errno2("lstat",
6921 4e68cba3 2019-11-23 stsp ondisk_path);
6922 4e68cba3 2019-11-23 stsp free(ondisk_path);
6923 4e68cba3 2019-11-23 stsp goto done;
6925 4e68cba3 2019-11-23 stsp free(ondisk_path);
6926 4e68cba3 2019-11-23 stsp if (S_ISDIR(sb.st_mode)) {
6927 4e68cba3 2019-11-23 stsp error = got_error_msg(GOT_ERR_BAD_PATH,
6928 4e68cba3 2019-11-23 stsp "adding directories requires -R option");
6929 4e68cba3 2019-11-23 stsp goto done;
6934 4e68cba3 2019-11-23 stsp error = got_worktree_schedule_add(worktree, &paths, add_progress,
6935 022fae89 2019-12-06 tracey NULL, repo, no_ignores);
6937 1d0f4054 2021-06-17 stsp if (repo) {
6938 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
6939 1d0f4054 2021-06-17 stsp if (error == NULL)
6940 1d0f4054 2021-06-17 stsp error = close_err;
6942 d00136be 2019-03-26 stsp if (worktree)
6943 d00136be 2019-03-26 stsp got_worktree_close(worktree);
6944 1dd54920 2019-05-11 stsp TAILQ_FOREACH(pe, &paths, entry)
6945 1dd54920 2019-05-11 stsp free((char *)pe->path);
6946 1dd54920 2019-05-11 stsp got_pathlist_free(&paths);
6947 2ec1f75b 2019-03-26 stsp free(cwd);
6948 2ec1f75b 2019-03-26 stsp return error;
6951 2ec1f75b 2019-03-26 stsp __dead static void
6952 648e4ef7 2019-07-09 stsp usage_remove(void)
6954 766841c2 2020-08-13 stsp fprintf(stderr, "usage: %s remove [-f] [-k] [-R] [-s status-codes] "
6955 766841c2 2020-08-13 stsp "path ...\n", getprogname());
6959 2a06fe5f 2019-08-24 stsp static const struct got_error *
6960 2a06fe5f 2019-08-24 stsp print_remove_status(void *arg, unsigned char status,
6961 f2a9dc41 2019-12-13 tracey unsigned char staged_status, const char *path)
6963 f2a9dc41 2019-12-13 tracey while (path[0] == '/')
6965 2a06fe5f 2019-08-24 stsp if (status == GOT_STATUS_NONEXISTENT)
6966 2a06fe5f 2019-08-24 stsp return NULL;
6967 2a06fe5f 2019-08-24 stsp if (status == staged_status && (status == GOT_STATUS_DELETE))
6968 2a06fe5f 2019-08-24 stsp status = GOT_STATUS_NO_CHANGE;
6969 2a06fe5f 2019-08-24 stsp printf("%c%c %s\n", status, staged_status, path);
6970 2a06fe5f 2019-08-24 stsp return NULL;
6973 2ec1f75b 2019-03-26 stsp static const struct got_error *
6974 648e4ef7 2019-07-09 stsp cmd_remove(int argc, char *argv[])
6976 2ec1f75b 2019-03-26 stsp const struct got_error *error = NULL;
6977 2ec1f75b 2019-03-26 stsp struct got_worktree *worktree = NULL;
6978 2ec1f75b 2019-03-26 stsp struct got_repository *repo = NULL;
6979 766841c2 2020-08-13 stsp const char *status_codes = NULL;
6980 17ed4618 2019-06-02 stsp char *cwd = NULL;
6981 17ed4618 2019-06-02 stsp struct got_pathlist_head paths;
6982 17ed4618 2019-06-02 stsp struct got_pathlist_entry *pe;
6983 766841c2 2020-08-13 stsp int ch, delete_local_mods = 0, can_recurse = 0, keep_on_disk = 0, i;
6985 17ed4618 2019-06-02 stsp TAILQ_INIT(&paths);
6987 766841c2 2020-08-13 stsp while ((ch = getopt(argc, argv, "fkRs:")) != -1) {
6988 2ec1f75b 2019-03-26 stsp switch (ch) {
6990 2ec1f75b 2019-03-26 stsp delete_local_mods = 1;
6992 70e3e7f5 2019-12-13 tracey case 'k':
6993 70e3e7f5 2019-12-13 tracey keep_on_disk = 1;
6995 f2a9dc41 2019-12-13 tracey case 'R':
6996 f2a9dc41 2019-12-13 tracey can_recurse = 1;
6999 766841c2 2020-08-13 stsp for (i = 0; i < strlen(optarg); i++) {
7000 766841c2 2020-08-13 stsp switch (optarg[i]) {
7001 766841c2 2020-08-13 stsp case GOT_STATUS_MODIFY:
7002 766841c2 2020-08-13 stsp delete_local_mods = 1;
7004 766841c2 2020-08-13 stsp case GOT_STATUS_MISSING:
7007 766841c2 2020-08-13 stsp errx(1, "invalid status code '%c'",
7008 766841c2 2020-08-13 stsp optarg[i]);
7011 766841c2 2020-08-13 stsp status_codes = optarg;
7014 f2a9dc41 2019-12-13 tracey usage_remove();
7015 2ec1f75b 2019-03-26 stsp /* NOTREACHED */
7019 2ec1f75b 2019-03-26 stsp argc -= optind;
7020 2ec1f75b 2019-03-26 stsp argv += optind;
7022 43012d58 2019-07-14 stsp #ifndef PROFILE
7023 43012d58 2019-07-14 stsp if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
7024 43012d58 2019-07-14 stsp NULL) == -1)
7025 43012d58 2019-07-14 stsp err(1, "pledge");
7027 17ed4618 2019-06-02 stsp if (argc < 1)
7028 648e4ef7 2019-07-09 stsp usage_remove();
7030 2ec1f75b 2019-03-26 stsp cwd = getcwd(NULL, 0);
7031 2ec1f75b 2019-03-26 stsp if (cwd == NULL) {
7032 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
7033 2ec1f75b 2019-03-26 stsp goto done;
7035 2ec1f75b 2019-03-26 stsp error = got_worktree_open(&worktree, cwd);
7036 fa51e947 2020-03-27 stsp if (error) {
7037 fa51e947 2020-03-27 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
7038 fa51e947 2020-03-27 stsp error = wrap_not_worktree_error(error, "remove", cwd);
7039 2ec1f75b 2019-03-26 stsp goto done;
7042 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
7045 2ec1f75b 2019-03-26 stsp goto done;
7047 c2253644 2019-03-26 stsp error = apply_unveil(got_repo_get_path(repo), 1,
7048 c530dc23 2019-07-23 stsp got_worktree_get_root_path(worktree));
7049 2ec1f75b 2019-03-26 stsp if (error)
7050 2ec1f75b 2019-03-26 stsp goto done;
7052 6d022e97 2019-08-04 stsp error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
7053 6d022e97 2019-08-04 stsp if (error)
7054 6d022e97 2019-08-04 stsp goto done;
7056 f2a9dc41 2019-12-13 tracey if (!can_recurse) {
7057 f2a9dc41 2019-12-13 tracey char *ondisk_path;
7058 f2a9dc41 2019-12-13 tracey struct stat sb;
7059 f2a9dc41 2019-12-13 tracey TAILQ_FOREACH(pe, &paths, entry) {
7060 f2a9dc41 2019-12-13 tracey if (asprintf(&ondisk_path, "%s/%s",
7061 f2a9dc41 2019-12-13 tracey got_worktree_get_root_path(worktree),
7062 62d463ca 2020-10-20 naddy pe->path) == -1) {
7063 f2a9dc41 2019-12-13 tracey error = got_error_from_errno("asprintf");
7064 f2a9dc41 2019-12-13 tracey goto done;
7066 f2a9dc41 2019-12-13 tracey if (lstat(ondisk_path, &sb) == -1) {
7067 f2a9dc41 2019-12-13 tracey if (errno == ENOENT) {
7068 f2a9dc41 2019-12-13 tracey free(ondisk_path);
7069 f2a9dc41 2019-12-13 tracey continue;
7071 f2a9dc41 2019-12-13 tracey error = got_error_from_errno2("lstat",
7072 f2a9dc41 2019-12-13 tracey ondisk_path);
7073 f2a9dc41 2019-12-13 tracey free(ondisk_path);
7074 f2a9dc41 2019-12-13 tracey goto done;
7076 f2a9dc41 2019-12-13 tracey free(ondisk_path);
7077 f2a9dc41 2019-12-13 tracey if (S_ISDIR(sb.st_mode)) {
7078 f2a9dc41 2019-12-13 tracey error = got_error_msg(GOT_ERR_BAD_PATH,
7079 f2a9dc41 2019-12-13 tracey "removing directories requires -R option");
7080 f2a9dc41 2019-12-13 tracey goto done;
7085 17ed4618 2019-06-02 stsp error = got_worktree_schedule_delete(worktree, &paths,
7086 766841c2 2020-08-13 stsp delete_local_mods, status_codes, print_remove_status, NULL,
7087 766841c2 2020-08-13 stsp repo, keep_on_disk);
7089 1d0f4054 2021-06-17 stsp if (repo) {
7090 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
7091 1d0f4054 2021-06-17 stsp if (error == NULL)
7092 1d0f4054 2021-06-17 stsp error = close_err;
7094 a129376b 2019-03-28 stsp if (worktree)
7095 a129376b 2019-03-28 stsp got_worktree_close(worktree);
7096 17ed4618 2019-06-02 stsp TAILQ_FOREACH(pe, &paths, entry)
7097 17ed4618 2019-06-02 stsp free((char *)pe->path);
7098 17ed4618 2019-06-02 stsp got_pathlist_free(&paths);
7099 a129376b 2019-03-28 stsp free(cwd);
7100 a129376b 2019-03-28 stsp return error;
7103 a129376b 2019-03-28 stsp __dead static void
7104 a129376b 2019-03-28 stsp usage_revert(void)
7106 33aa809d 2019-08-08 stsp fprintf(stderr, "usage: %s revert [-p] [-F response-script] [-R] "
7107 33aa809d 2019-08-08 stsp "path ...\n", getprogname());
7111 1ee397ad 2019-07-12 stsp static const struct got_error *
7112 a129376b 2019-03-28 stsp revert_progress(void *arg, unsigned char status, const char *path)
7114 fb9704af 2020-01-27 stsp if (status == GOT_STATUS_UNVERSIONED)
7115 fb9704af 2020-01-27 stsp return NULL;
7117 a129376b 2019-03-28 stsp while (path[0] == '/')
7119 a129376b 2019-03-28 stsp printf("%c %s\n", status, path);
7120 33aa809d 2019-08-08 stsp return NULL;
7123 33aa809d 2019-08-08 stsp struct choose_patch_arg {
7124 33aa809d 2019-08-08 stsp FILE *patch_script_file;
7125 33aa809d 2019-08-08 stsp const char *action;
7128 33aa809d 2019-08-08 stsp static const struct got_error *
7129 33aa809d 2019-08-08 stsp show_change(unsigned char status, const char *path, FILE *patch_file, int n,
7130 33aa809d 2019-08-08 stsp int nchanges, const char *action)
7132 33aa809d 2019-08-08 stsp char *line = NULL;
7133 33aa809d 2019-08-08 stsp size_t linesize = 0;
7134 33aa809d 2019-08-08 stsp ssize_t linelen;
7136 33aa809d 2019-08-08 stsp switch (status) {
7137 33aa809d 2019-08-08 stsp case GOT_STATUS_ADD:
7138 33aa809d 2019-08-08 stsp printf("A %s\n%s this addition? [y/n] ", path, action);
7140 33aa809d 2019-08-08 stsp case GOT_STATUS_DELETE:
7141 33aa809d 2019-08-08 stsp printf("D %s\n%s this deletion? [y/n] ", path, action);
7143 33aa809d 2019-08-08 stsp case GOT_STATUS_MODIFY:
7144 33aa809d 2019-08-08 stsp if (fseek(patch_file, 0L, SEEK_SET) == -1)
7145 33aa809d 2019-08-08 stsp return got_error_from_errno("fseek");
7146 33aa809d 2019-08-08 stsp printf(GOT_COMMIT_SEP_STR);
7147 9516e7cb 2019-08-11 stsp while ((linelen = getline(&line, &linesize, patch_file)) != -1)
7148 33aa809d 2019-08-08 stsp printf("%s", line);
7149 33aa809d 2019-08-08 stsp if (ferror(patch_file))
7150 33aa809d 2019-08-08 stsp return got_error_from_errno("getline");
7151 33aa809d 2019-08-08 stsp printf(GOT_COMMIT_SEP_STR);
7152 33aa809d 2019-08-08 stsp printf("M %s (change %d of %d)\n%s this change? [y/n/q] ",
7153 33aa809d 2019-08-08 stsp path, n, nchanges, action);
7156 33aa809d 2019-08-08 stsp return got_error_path(path, GOT_ERR_FILE_STATUS);
7159 33aa809d 2019-08-08 stsp return NULL;
7162 33aa809d 2019-08-08 stsp static const struct got_error *
7163 33aa809d 2019-08-08 stsp choose_patch(int *choice, void *arg, unsigned char status, const char *path,
7164 33aa809d 2019-08-08 stsp FILE *patch_file, int n, int nchanges)
7166 33aa809d 2019-08-08 stsp const struct got_error *err = NULL;
7167 33aa809d 2019-08-08 stsp char *line = NULL;
7168 33aa809d 2019-08-08 stsp size_t linesize = 0;
7169 33aa809d 2019-08-08 stsp ssize_t linelen;
7170 33aa809d 2019-08-08 stsp int resp = ' ';
7171 33aa809d 2019-08-08 stsp struct choose_patch_arg *a = arg;
7173 33aa809d 2019-08-08 stsp *choice = GOT_PATCH_CHOICE_NONE;
7175 33aa809d 2019-08-08 stsp if (a->patch_script_file) {
7177 33aa809d 2019-08-08 stsp err = show_change(status, path, patch_file, n, nchanges,
7178 33aa809d 2019-08-08 stsp a->action);
7180 33aa809d 2019-08-08 stsp return err;
7181 33aa809d 2019-08-08 stsp linelen = getline(&line, &linesize, a->patch_script_file);
7182 33aa809d 2019-08-08 stsp if (linelen == -1) {
7183 33aa809d 2019-08-08 stsp if (ferror(a->patch_script_file))
7184 33aa809d 2019-08-08 stsp return got_error_from_errno("getline");
7185 33aa809d 2019-08-08 stsp return NULL;
7187 33aa809d 2019-08-08 stsp nl = strchr(line, '\n');
7189 33aa809d 2019-08-08 stsp *nl = '\0';
7190 33aa809d 2019-08-08 stsp if (strcmp(line, "y") == 0) {
7191 33aa809d 2019-08-08 stsp *choice = GOT_PATCH_CHOICE_YES;
7192 33aa809d 2019-08-08 stsp printf("y\n");
7193 33aa809d 2019-08-08 stsp } else if (strcmp(line, "n") == 0) {
7194 33aa809d 2019-08-08 stsp *choice = GOT_PATCH_CHOICE_NO;
7195 33aa809d 2019-08-08 stsp printf("n\n");
7196 33aa809d 2019-08-08 stsp } else if (strcmp(line, "q") == 0 &&
7197 33aa809d 2019-08-08 stsp status == GOT_STATUS_MODIFY) {
7198 33aa809d 2019-08-08 stsp *choice = GOT_PATCH_CHOICE_QUIT;
7199 33aa809d 2019-08-08 stsp printf("q\n");
7201 33aa809d 2019-08-08 stsp printf("invalid response '%s'\n", line);
7202 33aa809d 2019-08-08 stsp free(line);
7203 33aa809d 2019-08-08 stsp return NULL;
7206 33aa809d 2019-08-08 stsp while (resp != 'y' && resp != 'n' && resp != 'q') {
7207 33aa809d 2019-08-08 stsp err = show_change(status, path, patch_file, n, nchanges,
7208 33aa809d 2019-08-08 stsp a->action);
7210 33aa809d 2019-08-08 stsp return err;
7211 33aa809d 2019-08-08 stsp resp = getchar();
7212 33aa809d 2019-08-08 stsp if (resp == '\n')
7213 33aa809d 2019-08-08 stsp resp = getchar();
7214 33aa809d 2019-08-08 stsp if (status == GOT_STATUS_MODIFY) {
7215 33aa809d 2019-08-08 stsp if (resp != 'y' && resp != 'n' && resp != 'q') {
7216 33aa809d 2019-08-08 stsp printf("invalid response '%c'\n", resp);
7217 33aa809d 2019-08-08 stsp resp = ' ';
7219 33aa809d 2019-08-08 stsp } else if (resp != 'y' && resp != 'n') {
7220 33aa809d 2019-08-08 stsp printf("invalid response '%c'\n", resp);
7221 33aa809d 2019-08-08 stsp resp = ' ';
7225 33aa809d 2019-08-08 stsp if (resp == 'y')
7226 33aa809d 2019-08-08 stsp *choice = GOT_PATCH_CHOICE_YES;
7227 33aa809d 2019-08-08 stsp else if (resp == 'n')
7228 33aa809d 2019-08-08 stsp *choice = GOT_PATCH_CHOICE_NO;
7229 33aa809d 2019-08-08 stsp else if (resp == 'q' && status == GOT_STATUS_MODIFY)
7230 33aa809d 2019-08-08 stsp *choice = GOT_PATCH_CHOICE_QUIT;
7232 1ee397ad 2019-07-12 stsp return NULL;
7236 a129376b 2019-03-28 stsp static const struct got_error *
7237 a129376b 2019-03-28 stsp cmd_revert(int argc, char *argv[])
7239 a129376b 2019-03-28 stsp const struct got_error *error = NULL;
7240 a129376b 2019-03-28 stsp struct got_worktree *worktree = NULL;
7241 a129376b 2019-03-28 stsp struct got_repository *repo = NULL;
7242 a129376b 2019-03-28 stsp char *cwd = NULL, *path = NULL;
7243 e20a8b6f 2019-06-04 stsp struct got_pathlist_head paths;
7244 0f6d7415 2019-08-08 stsp struct got_pathlist_entry *pe;
7245 33aa809d 2019-08-08 stsp int ch, can_recurse = 0, pflag = 0;
7246 33aa809d 2019-08-08 stsp FILE *patch_script_file = NULL;
7247 33aa809d 2019-08-08 stsp const char *patch_script_path = NULL;
7248 33aa809d 2019-08-08 stsp struct choose_patch_arg cpa;
7250 e20a8b6f 2019-06-04 stsp TAILQ_INIT(&paths);
7252 33aa809d 2019-08-08 stsp while ((ch = getopt(argc, argv, "pF:R")) != -1) {
7253 a129376b 2019-03-28 stsp switch (ch) {
7255 33aa809d 2019-08-08 stsp pflag = 1;
7258 33aa809d 2019-08-08 stsp patch_script_path = optarg;
7261 0f6d7415 2019-08-08 stsp can_recurse = 1;
7264 a129376b 2019-03-28 stsp usage_revert();
7265 a129376b 2019-03-28 stsp /* NOTREACHED */
7269 a129376b 2019-03-28 stsp argc -= optind;
7270 a129376b 2019-03-28 stsp argv += optind;
7272 43012d58 2019-07-14 stsp #ifndef PROFILE
7273 43012d58 2019-07-14 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
7274 43012d58 2019-07-14 stsp "unveil", NULL) == -1)
7275 43012d58 2019-07-14 stsp err(1, "pledge");
7277 e20a8b6f 2019-06-04 stsp if (argc < 1)
7278 a129376b 2019-03-28 stsp usage_revert();
7279 33aa809d 2019-08-08 stsp if (patch_script_path && !pflag)
7280 33aa809d 2019-08-08 stsp errx(1, "-F option can only be used together with -p option");
7282 a129376b 2019-03-28 stsp cwd = getcwd(NULL, 0);
7283 a129376b 2019-03-28 stsp if (cwd == NULL) {
7284 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
7285 a129376b 2019-03-28 stsp goto done;
7287 a129376b 2019-03-28 stsp error = got_worktree_open(&worktree, cwd);
7288 fa51e947 2020-03-27 stsp if (error) {
7289 fa51e947 2020-03-27 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
7290 fa51e947 2020-03-27 stsp error = wrap_not_worktree_error(error, "revert", cwd);
7291 2ec1f75b 2019-03-26 stsp goto done;
7294 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
7296 a129376b 2019-03-28 stsp if (error != NULL)
7297 a129376b 2019-03-28 stsp goto done;
7299 33aa809d 2019-08-08 stsp if (patch_script_path) {
7300 00fe21f2 2021-12-31 stsp patch_script_file = fopen(patch_script_path, "re");
7301 33aa809d 2019-08-08 stsp if (patch_script_file == NULL) {
7302 33aa809d 2019-08-08 stsp error = got_error_from_errno2("fopen",
7303 33aa809d 2019-08-08 stsp patch_script_path);
7304 33aa809d 2019-08-08 stsp goto done;
7307 a129376b 2019-03-28 stsp error = apply_unveil(got_repo_get_path(repo), 1,
7308 c530dc23 2019-07-23 stsp got_worktree_get_root_path(worktree));
7309 a129376b 2019-03-28 stsp if (error)
7310 a129376b 2019-03-28 stsp goto done;
7312 6d022e97 2019-08-04 stsp error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
7313 6d022e97 2019-08-04 stsp if (error)
7314 6d022e97 2019-08-04 stsp goto done;
7316 0f6d7415 2019-08-08 stsp if (!can_recurse) {
7317 0f6d7415 2019-08-08 stsp char *ondisk_path;
7318 0f6d7415 2019-08-08 stsp struct stat sb;
7319 0f6d7415 2019-08-08 stsp TAILQ_FOREACH(pe, &paths, entry) {
7320 0f6d7415 2019-08-08 stsp if (asprintf(&ondisk_path, "%s/%s",
7321 0f6d7415 2019-08-08 stsp got_worktree_get_root_path(worktree),
7322 62d463ca 2020-10-20 naddy pe->path) == -1) {
7323 0f6d7415 2019-08-08 stsp error = got_error_from_errno("asprintf");
7324 0f6d7415 2019-08-08 stsp goto done;
7326 0f6d7415 2019-08-08 stsp if (lstat(ondisk_path, &sb) == -1) {
7327 0f6d7415 2019-08-08 stsp if (errno == ENOENT) {
7328 0f6d7415 2019-08-08 stsp free(ondisk_path);
7331 0f6d7415 2019-08-08 stsp error = got_error_from_errno2("lstat",
7332 0f6d7415 2019-08-08 stsp ondisk_path);
7333 0f6d7415 2019-08-08 stsp free(ondisk_path);
7334 0f6d7415 2019-08-08 stsp goto done;
7336 0f6d7415 2019-08-08 stsp free(ondisk_path);
7337 0f6d7415 2019-08-08 stsp if (S_ISDIR(sb.st_mode)) {
7338 0f6d7415 2019-08-08 stsp error = got_error_msg(GOT_ERR_BAD_PATH,
7339 0f6d7415 2019-08-08 stsp "reverting directories requires -R option");
7340 0f6d7415 2019-08-08 stsp goto done;
7345 33aa809d 2019-08-08 stsp cpa.patch_script_file = patch_script_file;
7346 33aa809d 2019-08-08 stsp cpa.action = "revert";
7347 33aa809d 2019-08-08 stsp error = got_worktree_revert(worktree, &paths, revert_progress, NULL,
7348 33aa809d 2019-08-08 stsp pflag ? choose_patch : NULL, &cpa, repo);
7350 33aa809d 2019-08-08 stsp if (patch_script_file && fclose(patch_script_file) == EOF &&
7351 33aa809d 2019-08-08 stsp error == NULL)
7352 33aa809d 2019-08-08 stsp error = got_error_from_errno2("fclose", patch_script_path);
7353 1d0f4054 2021-06-17 stsp if (repo) {
7354 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
7355 1d0f4054 2021-06-17 stsp if (error == NULL)
7356 1d0f4054 2021-06-17 stsp error = close_err;
7358 2ec1f75b 2019-03-26 stsp if (worktree)
7359 2ec1f75b 2019-03-26 stsp got_worktree_close(worktree);
7360 2ec1f75b 2019-03-26 stsp free(path);
7361 d00136be 2019-03-26 stsp free(cwd);
7362 6bad629b 2019-02-04 stsp return error;
7365 c4296144 2019-05-09 stsp __dead static void
7366 c4296144 2019-05-09 stsp usage_commit(void)
7368 28cf319f 2021-01-28 stsp fprintf(stderr, "usage: %s commit [-F path] [-m msg] [-N] [-S] "
7369 28cf319f 2021-01-28 stsp "[path ...]\n", getprogname());
7373 e2ba3d07 2019-05-13 stsp struct collect_commit_logmsg_arg {
7374 e2ba3d07 2019-05-13 stsp const char *cmdline_log;
7375 28cf319f 2021-01-28 stsp const char *prepared_log;
7376 28cf319f 2021-01-28 stsp int non_interactive;
7377 e2ba3d07 2019-05-13 stsp const char *editor;
7378 e0870e44 2019-05-13 stsp const char *worktree_path;
7379 76d98825 2019-06-03 stsp const char *branch_name;
7380 314a6357 2019-05-13 stsp const char *repo_path;
7381 e0870e44 2019-05-13 stsp char *logmsg_path;
7385 28cf319f 2021-01-28 stsp static const struct got_error *
7386 28cf319f 2021-01-28 stsp read_prepared_logmsg(char **logmsg, const char *path)
7388 28cf319f 2021-01-28 stsp const struct got_error *err = NULL;
7389 28cf319f 2021-01-28 stsp FILE *f = NULL;
7390 28cf319f 2021-01-28 stsp struct stat sb;
7393 28cf319f 2021-01-28 stsp *logmsg = NULL;
7394 28cf319f 2021-01-28 stsp memset(&sb, 0, sizeof(sb));
7396 00fe21f2 2021-12-31 stsp f = fopen(path, "re");
7397 28cf319f 2021-01-28 stsp if (f == NULL)
7398 28cf319f 2021-01-28 stsp return got_error_from_errno2("fopen", path);
7400 28cf319f 2021-01-28 stsp if (fstat(fileno(f), &sb) == -1) {
7401 28cf319f 2021-01-28 stsp err = got_error_from_errno2("fstat", path);
7402 28cf319f 2021-01-28 stsp goto done;
7404 28cf319f 2021-01-28 stsp if (sb.st_size == 0) {
7405 28cf319f 2021-01-28 stsp err = got_error(GOT_ERR_COMMIT_MSG_EMPTY);
7406 28cf319f 2021-01-28 stsp goto done;
7409 28cf319f 2021-01-28 stsp *logmsg = malloc(sb.st_size + 1);
7410 28cf319f 2021-01-28 stsp if (*logmsg == NULL) {
7411 28cf319f 2021-01-28 stsp err = got_error_from_errno("malloc");
7412 28cf319f 2021-01-28 stsp goto done;
7415 28cf319f 2021-01-28 stsp r = fread(*logmsg, 1, sb.st_size, f);
7416 28cf319f 2021-01-28 stsp if (r != sb.st_size) {
7417 28cf319f 2021-01-28 stsp if (ferror(f))
7418 28cf319f 2021-01-28 stsp err = got_error_from_errno2("fread", path);
7420 28cf319f 2021-01-28 stsp err = got_error(GOT_ERR_IO);
7421 28cf319f 2021-01-28 stsp goto done;
7423 28cf319f 2021-01-28 stsp (*logmsg)[sb.st_size] = '\0';
7425 28cf319f 2021-01-28 stsp if (fclose(f) == EOF && err == NULL)
7426 28cf319f 2021-01-28 stsp err = got_error_from_errno2("fclose", path);
7427 28cf319f 2021-01-28 stsp if (err) {
7428 28cf319f 2021-01-28 stsp free(*logmsg);
7429 28cf319f 2021-01-28 stsp *logmsg = NULL;
7431 28cf319f 2021-01-28 stsp return err;
7435 33ad4cbe 2019-05-12 jcs static const struct got_error *
7436 33ad4cbe 2019-05-12 jcs collect_commit_logmsg(struct got_pathlist_head *commitable_paths, char **logmsg,
7439 76d98825 2019-06-03 stsp char *initial_content = NULL;
7440 33ad4cbe 2019-05-12 jcs struct got_pathlist_entry *pe;
7441 33ad4cbe 2019-05-12 jcs const struct got_error *err = NULL;
7442 e0870e44 2019-05-13 stsp char *template = NULL;
7443 e2ba3d07 2019-05-13 stsp struct collect_commit_logmsg_arg *a = arg;
7444 1601cb9f 2020-09-11 naddy int initial_content_len;
7445 97972933 2020-09-11 stsp int fd = -1;
7446 33ad4cbe 2019-05-12 jcs size_t len;
7448 33ad4cbe 2019-05-12 jcs /* if a message was specified on the command line, just use it */
7449 e2ba3d07 2019-05-13 stsp if (a->cmdline_log != NULL && strlen(a->cmdline_log) != 0) {
7450 e2ba3d07 2019-05-13 stsp len = strlen(a->cmdline_log) + 1;
7451 33ad4cbe 2019-05-12 jcs *logmsg = malloc(len + 1);
7452 9f42ff69 2019-05-13 stsp if (*logmsg == NULL)
7453 638f9024 2019-05-13 stsp return got_error_from_errno("malloc");
7454 e2ba3d07 2019-05-13 stsp strlcpy(*logmsg, a->cmdline_log, len);
7455 33ad4cbe 2019-05-12 jcs return NULL;
7456 28cf319f 2021-01-28 stsp } else if (a->prepared_log != NULL && a->non_interactive)
7457 28cf319f 2021-01-28 stsp return read_prepared_logmsg(logmsg, a->prepared_log);
7459 e0870e44 2019-05-13 stsp if (asprintf(&template, "%s/logmsg", a->worktree_path) == -1)
7460 76d98825 2019-06-03 stsp return got_error_from_errno("asprintf");
7462 28cf319f 2021-01-28 stsp err = got_opentemp_named_fd(&a->logmsg_path, &fd, template);
7464 28cf319f 2021-01-28 stsp goto done;
7466 28cf319f 2021-01-28 stsp if (a->prepared_log) {
7467 28cf319f 2021-01-28 stsp char *msg;
7468 28cf319f 2021-01-28 stsp err = read_prepared_logmsg(&msg, a->prepared_log);
7470 28cf319f 2021-01-28 stsp goto done;
7471 28cf319f 2021-01-28 stsp if (write(fd, msg, strlen(msg)) == -1) {
7472 28cf319f 2021-01-28 stsp err = got_error_from_errno2("write", a->logmsg_path);
7473 28cf319f 2021-01-28 stsp free(msg);
7474 28cf319f 2021-01-28 stsp goto done;
7476 28cf319f 2021-01-28 stsp free(msg);
7479 1601cb9f 2020-09-11 naddy initial_content_len = asprintf(&initial_content,
7480 76d98825 2019-06-03 stsp "\n# changes to be committed on branch %s:\n",
7481 1601cb9f 2020-09-11 naddy a->branch_name);
7482 28cf319f 2021-01-28 stsp if (initial_content_len == -1) {
7483 28cf319f 2021-01-28 stsp err = got_error_from_errno("asprintf");
7484 e0870e44 2019-05-13 stsp goto done;
7487 97972933 2020-09-11 stsp if (write(fd, initial_content, initial_content_len) == -1) {
7488 97972933 2020-09-11 stsp err = got_error_from_errno2("write", a->logmsg_path);
7489 97972933 2020-09-11 stsp goto done;
7492 33ad4cbe 2019-05-12 jcs TAILQ_FOREACH(pe, commitable_paths, entry) {
7493 33ad4cbe 2019-05-12 jcs struct got_commitable *ct = pe->data;
7494 8656d6c4 2019-05-20 stsp dprintf(fd, "# %c %s\n",
7495 8656d6c4 2019-05-20 stsp got_commitable_get_status(ct),
7496 8656d6c4 2019-05-20 stsp got_commitable_get_path(ct));
7499 bfa12d5e 2020-09-26 stsp err = edit_logmsg(logmsg, a->editor, a->logmsg_path, initial_content,
7500 28cf319f 2021-01-28 stsp initial_content_len, a->prepared_log ? 0 : 1);
7502 76d98825 2019-06-03 stsp free(initial_content);
7503 e0870e44 2019-05-13 stsp free(template);
7505 97972933 2020-09-11 stsp if (fd != -1 && close(fd) == -1 && err == NULL)
7506 97972933 2020-09-11 stsp err = got_error_from_errno2("close", a->logmsg_path);
7508 314a6357 2019-05-13 stsp /* Editor is done; we can now apply unveil(2) */
7509 59f86c76 2020-09-11 stsp if (err == NULL)
7510 c530dc23 2019-07-23 stsp err = apply_unveil(a->repo_path, 0, a->worktree_path);
7511 59f86c76 2020-09-11 stsp if (err) {
7512 59f86c76 2020-09-11 stsp free(*logmsg);
7513 59f86c76 2020-09-11 stsp *logmsg = NULL;
7515 33ad4cbe 2019-05-12 jcs return err;
7518 c4296144 2019-05-09 stsp static const struct got_error *
7519 c4296144 2019-05-09 stsp cmd_commit(int argc, char *argv[])
7521 c4296144 2019-05-09 stsp const struct got_error *error = NULL;
7522 c4296144 2019-05-09 stsp struct got_worktree *worktree = NULL;
7523 c4296144 2019-05-09 stsp struct got_repository *repo = NULL;
7524 5c1e53bc 2019-07-28 stsp char *cwd = NULL, *id_str = NULL;
7525 c4296144 2019-05-09 stsp struct got_object_id *id = NULL;
7526 33ad4cbe 2019-05-12 jcs const char *logmsg = NULL;
7527 28cf319f 2021-01-28 stsp char *prepared_logmsg = NULL;
7528 aba9c984 2019-09-08 stsp struct collect_commit_logmsg_arg cl_arg;
7529 c9956ddf 2019-09-08 stsp char *gitconfig_path = NULL, *editor = NULL, *author = NULL;
7530 7266f21f 2019-10-21 stsp int ch, rebase_in_progress, histedit_in_progress, preserve_logmsg = 0;
7531 f259c4c1 2021-09-24 stsp int allow_bad_symlinks = 0, non_interactive = 0, merge_in_progress = 0;
7532 5c1e53bc 2019-07-28 stsp struct got_pathlist_head paths;
7534 5c1e53bc 2019-07-28 stsp TAILQ_INIT(&paths);
7535 6ac5a73c 2019-08-08 stsp cl_arg.logmsg_path = NULL;
7537 28cf319f 2021-01-28 stsp while ((ch = getopt(argc, argv, "F:m:NS")) != -1) {
7538 c4296144 2019-05-09 stsp switch (ch) {
7540 28cf319f 2021-01-28 stsp if (logmsg != NULL)
7541 28cf319f 2021-01-28 stsp option_conflict('F', 'm');
7542 28cf319f 2021-01-28 stsp prepared_logmsg = realpath(optarg, NULL);
7543 28cf319f 2021-01-28 stsp if (prepared_logmsg == NULL)
7544 28cf319f 2021-01-28 stsp return got_error_from_errno2("realpath",
7548 28cf319f 2021-01-28 stsp if (prepared_logmsg)
7549 28cf319f 2021-01-28 stsp option_conflict('m', 'F');
7550 c4296144 2019-05-09 stsp logmsg = optarg;
7553 28cf319f 2021-01-28 stsp non_interactive = 1;
7556 35213c7c 2020-07-23 stsp allow_bad_symlinks = 1;
7559 c4296144 2019-05-09 stsp usage_commit();
7560 c4296144 2019-05-09 stsp /* NOTREACHED */
7564 c4296144 2019-05-09 stsp argc -= optind;
7565 c4296144 2019-05-09 stsp argv += optind;
7567 43012d58 2019-07-14 stsp #ifndef PROFILE
7568 43012d58 2019-07-14 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
7569 43012d58 2019-07-14 stsp "unveil", NULL) == -1)
7570 43012d58 2019-07-14 stsp err(1, "pledge");
7572 c4296144 2019-05-09 stsp cwd = getcwd(NULL, 0);
7573 c4296144 2019-05-09 stsp if (cwd == NULL) {
7574 638f9024 2019-05-13 stsp error = got_error_from_errno("getcwd");
7575 c4296144 2019-05-09 stsp goto done;
7577 c4296144 2019-05-09 stsp error = got_worktree_open(&worktree, cwd);
7578 fa51e947 2020-03-27 stsp if (error) {
7579 fa51e947 2020-03-27 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
7580 fa51e947 2020-03-27 stsp error = wrap_not_worktree_error(error, "commit", cwd);
7581 7d5807f4 2019-07-11 stsp goto done;
7584 a698f62e 2019-07-25 stsp error = got_worktree_rebase_in_progress(&rebase_in_progress, worktree);
7585 c4296144 2019-05-09 stsp if (error)
7586 a698f62e 2019-07-25 stsp goto done;
7587 a698f62e 2019-07-25 stsp if (rebase_in_progress) {
7588 a698f62e 2019-07-25 stsp error = got_error(GOT_ERR_REBASING);
7589 c4296144 2019-05-09 stsp goto done;
7592 916f288c 2019-07-30 stsp error = got_worktree_histedit_in_progress(&histedit_in_progress,
7593 916f288c 2019-07-30 stsp worktree);
7594 5c1e53bc 2019-07-28 stsp if (error)
7595 5c1e53bc 2019-07-28 stsp goto done;
7597 c9956ddf 2019-09-08 stsp error = get_gitconfig_path(&gitconfig_path);
7598 c9956ddf 2019-09-08 stsp if (error)
7599 c9956ddf 2019-09-08 stsp goto done;
7600 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
7601 c9956ddf 2019-09-08 stsp gitconfig_path);
7602 c4296144 2019-05-09 stsp if (error != NULL)
7603 c4296144 2019-05-09 stsp goto done;
7605 f259c4c1 2021-09-24 stsp error = got_worktree_merge_in_progress(&merge_in_progress, worktree, repo);
7606 f259c4c1 2021-09-24 stsp if (error)
7607 f259c4c1 2021-09-24 stsp goto done;
7608 f259c4c1 2021-09-24 stsp if (merge_in_progress) {
7609 f259c4c1 2021-09-24 stsp error = got_error(GOT_ERR_MERGE_BUSY);
7610 f259c4c1 2021-09-24 stsp goto done;
7613 50b0790e 2020-09-11 stsp error = get_author(&author, repo, worktree);
7614 aba9c984 2019-09-08 stsp if (error)
7615 aba9c984 2019-09-08 stsp return error;
7618 314a6357 2019-05-13 stsp * unveil(2) traverses exec(2); if an editor is used we have
7619 314a6357 2019-05-13 stsp * to apply unveil after the log message has been written.
7621 314a6357 2019-05-13 stsp if (logmsg == NULL || strlen(logmsg) == 0)
7622 314a6357 2019-05-13 stsp error = get_editor(&editor);
7624 314a6357 2019-05-13 stsp error = apply_unveil(got_repo_get_path(repo), 0,
7625 c530dc23 2019-07-23 stsp got_worktree_get_root_path(worktree));
7626 c4296144 2019-05-09 stsp if (error)
7627 c4296144 2019-05-09 stsp goto done;
7629 087fb88c 2019-08-04 stsp error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
7630 087fb88c 2019-08-04 stsp if (error)
7631 087fb88c 2019-08-04 stsp goto done;
7633 e2ba3d07 2019-05-13 stsp cl_arg.editor = editor;
7634 e2ba3d07 2019-05-13 stsp cl_arg.cmdline_log = logmsg;
7635 28cf319f 2021-01-28 stsp cl_arg.prepared_log = prepared_logmsg;
7636 28cf319f 2021-01-28 stsp cl_arg.non_interactive = non_interactive;
7637 e0870e44 2019-05-13 stsp cl_arg.worktree_path = got_worktree_get_root_path(worktree);
7638 76d98825 2019-06-03 stsp cl_arg.branch_name = got_worktree_get_head_ref_name(worktree);
7639 916f288c 2019-07-30 stsp if (!histedit_in_progress) {
7640 916f288c 2019-07-30 stsp if (strncmp(cl_arg.branch_name, "refs/heads/", 11) != 0) {
7641 916f288c 2019-07-30 stsp error = got_error(GOT_ERR_COMMIT_BRANCH);
7642 916f288c 2019-07-30 stsp goto done;
7644 916f288c 2019-07-30 stsp cl_arg.branch_name += 11;
7646 314a6357 2019-05-13 stsp cl_arg.repo_path = got_repo_get_path(repo);
7647 84792843 2019-08-09 stsp error = got_worktree_commit(&id, worktree, &paths, author, NULL,
7648 35213c7c 2020-07-23 stsp allow_bad_symlinks, collect_commit_logmsg, &cl_arg,
7649 35213c7c 2020-07-23 stsp print_status, NULL, repo);
7650 e0870e44 2019-05-13 stsp if (error) {
7651 7266f21f 2019-10-21 stsp if (error->code != GOT_ERR_COMMIT_MSG_EMPTY &&
7652 7266f21f 2019-10-21 stsp cl_arg.logmsg_path != NULL)
7653 7266f21f 2019-10-21 stsp preserve_logmsg = 1;
7654 c4296144 2019-05-09 stsp goto done;
7657 c4296144 2019-05-09 stsp error = got_object_id_str(&id_str, id);
7658 c4296144 2019-05-09 stsp if (error)
7659 c4296144 2019-05-09 stsp goto done;
7660 a7648d7a 2019-06-02 stsp printf("Created commit %s\n", id_str);
7662 7266f21f 2019-10-21 stsp if (preserve_logmsg) {
7663 7266f21f 2019-10-21 stsp fprintf(stderr, "%s: log message preserved in %s\n",
7664 7266f21f 2019-10-21 stsp getprogname(), cl_arg.logmsg_path);
7665 7266f21f 2019-10-21 stsp } else if (cl_arg.logmsg_path && unlink(cl_arg.logmsg_path) == -1 &&
7666 7266f21f 2019-10-21 stsp error == NULL)
7667 7266f21f 2019-10-21 stsp error = got_error_from_errno2("unlink", cl_arg.logmsg_path);
7668 6ac5a73c 2019-08-08 stsp free(cl_arg.logmsg_path);
7669 1d0f4054 2021-06-17 stsp if (repo) {
7670 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
7671 1d0f4054 2021-06-17 stsp if (error == NULL)
7672 1d0f4054 2021-06-17 stsp error = close_err;
7674 c4296144 2019-05-09 stsp if (worktree)
7675 c4296144 2019-05-09 stsp got_worktree_close(worktree);
7676 c4296144 2019-05-09 stsp free(cwd);
7677 c4296144 2019-05-09 stsp free(id_str);
7678 c9956ddf 2019-09-08 stsp free(gitconfig_path);
7679 e2ba3d07 2019-05-13 stsp free(editor);
7680 aba9c984 2019-09-08 stsp free(author);
7681 28cf319f 2021-01-28 stsp free(prepared_logmsg);
7682 f8a36e22 2021-08-26 stsp return error;
7685 f8a36e22 2021-08-26 stsp __dead static void
7686 f8a36e22 2021-08-26 stsp usage_send(void)
7688 f8a36e22 2021-08-26 stsp fprintf(stderr, "usage: %s send [-a] [-b branch] [-d branch] [-f] "
7689 f8a36e22 2021-08-26 stsp "[-r repository-path] [-t tag] [-T] [-q] [-v] "
7690 f8a36e22 2021-08-26 stsp "[remote-repository]\n", getprogname());
7694 f8a36e22 2021-08-26 stsp struct got_send_progress_arg {
7695 f8a36e22 2021-08-26 stsp char last_scaled_packsize[FMT_SCALED_STRSIZE];
7696 f8a36e22 2021-08-26 stsp int verbosity;
7697 f8a36e22 2021-08-26 stsp int last_ncommits;
7698 f8a36e22 2021-08-26 stsp int last_nobj_total;
7699 f8a36e22 2021-08-26 stsp int last_p_deltify;
7700 f8a36e22 2021-08-26 stsp int last_p_written;
7701 f8a36e22 2021-08-26 stsp int last_p_sent;
7702 f8a36e22 2021-08-26 stsp int printed_something;
7703 f8a36e22 2021-08-26 stsp int sent_something;
7704 f8a36e22 2021-08-26 stsp struct got_pathlist_head *delete_branches;
7707 f8a36e22 2021-08-26 stsp static const struct got_error *
7708 f8a36e22 2021-08-26 stsp send_progress(void *arg, off_t packfile_size, int ncommits, int nobj_total,
7709 f8a36e22 2021-08-26 stsp int nobj_deltify, int nobj_written, off_t bytes_sent, const char *refname,
7710 f8a36e22 2021-08-26 stsp int success)
7712 f8a36e22 2021-08-26 stsp struct got_send_progress_arg *a = arg;
7713 f8a36e22 2021-08-26 stsp char scaled_packsize[FMT_SCALED_STRSIZE];
7714 f8a36e22 2021-08-26 stsp char scaled_sent[FMT_SCALED_STRSIZE];
7715 f8a36e22 2021-08-26 stsp int p_deltify = 0, p_written = 0, p_sent = 0;
7716 f8a36e22 2021-08-26 stsp int print_searching = 0, print_total = 0;
7717 f8a36e22 2021-08-26 stsp int print_deltify = 0, print_written = 0, print_sent = 0;
7719 f8a36e22 2021-08-26 stsp if (a->verbosity < 0)
7720 f8a36e22 2021-08-26 stsp return NULL;
7722 f8a36e22 2021-08-26 stsp if (refname) {
7723 f8a36e22 2021-08-26 stsp const char *status = success ? "accepted" : "rejected";
7725 f8a36e22 2021-08-26 stsp if (success) {
7726 f8a36e22 2021-08-26 stsp struct got_pathlist_entry *pe;
7727 f8a36e22 2021-08-26 stsp TAILQ_FOREACH(pe, a->delete_branches, entry) {
7728 f8a36e22 2021-08-26 stsp const char *branchname = pe->path;
7729 f8a36e22 2021-08-26 stsp if (got_path_cmp(branchname, refname,
7730 f8a36e22 2021-08-26 stsp strlen(branchname), strlen(refname)) == 0) {
7731 f8a36e22 2021-08-26 stsp status = "deleted";
7732 27b75514 2021-08-28 stsp a->sent_something = 1;
7738 27b75514 2021-08-28 stsp if (a->printed_something)
7739 27b75514 2021-08-28 stsp putchar('\n');
7740 27b75514 2021-08-28 stsp printf("Server has %s %s", status, refname);
7741 f8a36e22 2021-08-26 stsp a->printed_something = 1;
7742 f8a36e22 2021-08-26 stsp return NULL;
7745 f8a36e22 2021-08-26 stsp if (fmt_scaled(packfile_size, scaled_packsize) == -1)
7746 f8a36e22 2021-08-26 stsp return got_error_from_errno("fmt_scaled");
7747 f8a36e22 2021-08-26 stsp if (fmt_scaled(bytes_sent, scaled_sent) == -1)
7748 f8a36e22 2021-08-26 stsp return got_error_from_errno("fmt_scaled");
7750 f8a36e22 2021-08-26 stsp if (a->last_ncommits != ncommits) {
7751 f8a36e22 2021-08-26 stsp print_searching = 1;
7752 f8a36e22 2021-08-26 stsp a->last_ncommits = ncommits;
7755 f8a36e22 2021-08-26 stsp if (a->last_nobj_total != nobj_total) {
7756 f8a36e22 2021-08-26 stsp print_searching = 1;
7757 f8a36e22 2021-08-26 stsp print_total = 1;
7758 f8a36e22 2021-08-26 stsp a->last_nobj_total = nobj_total;
7761 f8a36e22 2021-08-26 stsp if (packfile_size > 0 && (a->last_scaled_packsize[0] == '\0' ||
7762 f8a36e22 2021-08-26 stsp strcmp(scaled_packsize, a->last_scaled_packsize)) != 0) {
7763 f8a36e22 2021-08-26 stsp if (strlcpy(a->last_scaled_packsize, scaled_packsize,
7764 f8a36e22 2021-08-26 stsp FMT_SCALED_STRSIZE) >= FMT_SCALED_STRSIZE)
7765 f8a36e22 2021-08-26 stsp return got_error(GOT_ERR_NO_SPACE);
7768 f8a36e22 2021-08-26 stsp if (nobj_deltify > 0 || nobj_written > 0) {
7769 f8a36e22 2021-08-26 stsp if (nobj_deltify > 0) {
7770 f8a36e22 2021-08-26 stsp p_deltify = (nobj_deltify * 100) / nobj_total;
7771 f8a36e22 2021-08-26 stsp if (p_deltify != a->last_p_deltify) {
7772 f8a36e22 2021-08-26 stsp a->last_p_deltify = p_deltify;
7773 f8a36e22 2021-08-26 stsp print_searching = 1;
7774 f8a36e22 2021-08-26 stsp print_total = 1;
7775 f8a36e22 2021-08-26 stsp print_deltify = 1;
7778 f8a36e22 2021-08-26 stsp if (nobj_written > 0) {
7779 f8a36e22 2021-08-26 stsp p_written = (nobj_written * 100) / nobj_total;
7780 f8a36e22 2021-08-26 stsp if (p_written != a->last_p_written) {
7781 f8a36e22 2021-08-26 stsp a->last_p_written = p_written;
7782 f8a36e22 2021-08-26 stsp print_searching = 1;
7783 f8a36e22 2021-08-26 stsp print_total = 1;
7784 f8a36e22 2021-08-26 stsp print_deltify = 1;
7785 f8a36e22 2021-08-26 stsp print_written = 1;
7790 f8a36e22 2021-08-26 stsp if (bytes_sent > 0) {
7791 f8a36e22 2021-08-26 stsp p_sent = (bytes_sent * 100) / packfile_size;
7792 f8a36e22 2021-08-26 stsp if (p_sent != a->last_p_sent) {
7793 f8a36e22 2021-08-26 stsp a->last_p_sent = p_sent;
7794 f8a36e22 2021-08-26 stsp print_searching = 1;
7795 f8a36e22 2021-08-26 stsp print_total = 1;
7796 f8a36e22 2021-08-26 stsp print_deltify = 1;
7797 f8a36e22 2021-08-26 stsp print_written = 1;
7798 f8a36e22 2021-08-26 stsp print_sent = 1;
7800 f8a36e22 2021-08-26 stsp a->sent_something = 1;
7803 f8a36e22 2021-08-26 stsp if (print_searching || print_total || print_deltify || print_written ||
7804 f8a36e22 2021-08-26 stsp print_sent)
7805 f8a36e22 2021-08-26 stsp printf("\r");
7806 f8a36e22 2021-08-26 stsp if (print_searching)
7807 f8a36e22 2021-08-26 stsp printf("packing %d reference%s", ncommits,
7808 f8a36e22 2021-08-26 stsp ncommits == 1 ? "" : "s");
7809 f8a36e22 2021-08-26 stsp if (print_total)
7810 f8a36e22 2021-08-26 stsp printf("; %d object%s", nobj_total,
7811 f8a36e22 2021-08-26 stsp nobj_total == 1 ? "" : "s");
7812 f8a36e22 2021-08-26 stsp if (print_deltify)
7813 f8a36e22 2021-08-26 stsp printf("; deltify: %d%%", p_deltify);
7814 f8a36e22 2021-08-26 stsp if (print_sent)
7815 f8a36e22 2021-08-26 stsp printf("; uploading pack: %*s %d%%", FMT_SCALED_STRSIZE,
7816 f8a36e22 2021-08-26 stsp scaled_packsize, p_sent);
7817 f8a36e22 2021-08-26 stsp else if (print_written)
7818 f8a36e22 2021-08-26 stsp printf("; writing pack: %*s %d%%", FMT_SCALED_STRSIZE,
7819 f8a36e22 2021-08-26 stsp scaled_packsize, p_written);
7820 f8a36e22 2021-08-26 stsp if (print_searching || print_total || print_deltify ||
7821 f8a36e22 2021-08-26 stsp print_written || print_sent) {
7822 f8a36e22 2021-08-26 stsp a->printed_something = 1;
7823 f8a36e22 2021-08-26 stsp fflush(stdout);
7825 f8a36e22 2021-08-26 stsp return NULL;
7828 f8a36e22 2021-08-26 stsp static const struct got_error *
7829 f8a36e22 2021-08-26 stsp cmd_send(int argc, char *argv[])
7831 f8a36e22 2021-08-26 stsp const struct got_error *error = NULL;
7832 f8a36e22 2021-08-26 stsp char *cwd = NULL, *repo_path = NULL;
7833 f8a36e22 2021-08-26 stsp const char *remote_name;
7834 f8a36e22 2021-08-26 stsp char *proto = NULL, *host = NULL, *port = NULL;
7835 f8a36e22 2021-08-26 stsp char *repo_name = NULL, *server_path = NULL;
7836 f8a36e22 2021-08-26 stsp const struct got_remote_repo *remotes, *remote = NULL;
7837 f8a36e22 2021-08-26 stsp int nremotes, nbranches = 0, ntags = 0, ndelete_branches = 0;
7838 f8a36e22 2021-08-26 stsp struct got_repository *repo = NULL;
7839 f8a36e22 2021-08-26 stsp struct got_worktree *worktree = NULL;
7840 f8a36e22 2021-08-26 stsp const struct got_gotconfig *repo_conf = NULL, *worktree_conf = NULL;
7841 f8a36e22 2021-08-26 stsp struct got_pathlist_head branches;
7842 f8a36e22 2021-08-26 stsp struct got_pathlist_head tags;
7843 f8a36e22 2021-08-26 stsp struct got_reflist_head all_branches;
7844 f8a36e22 2021-08-26 stsp struct got_reflist_head all_tags;
7845 f8a36e22 2021-08-26 stsp struct got_pathlist_head delete_args;
7846 f8a36e22 2021-08-26 stsp struct got_pathlist_head delete_branches;
7847 f8a36e22 2021-08-26 stsp struct got_reflist_entry *re;
7848 f8a36e22 2021-08-26 stsp struct got_pathlist_entry *pe;
7849 f8a36e22 2021-08-26 stsp int i, ch, sendfd = -1, sendstatus;
7850 f8a36e22 2021-08-26 stsp pid_t sendpid = -1;
7851 f8a36e22 2021-08-26 stsp struct got_send_progress_arg spa;
7852 f8a36e22 2021-08-26 stsp int verbosity = 0, overwrite_refs = 0;
7853 f8a36e22 2021-08-26 stsp int send_all_branches = 0, send_all_tags = 0;
7854 f8a36e22 2021-08-26 stsp struct got_reference *ref = NULL;
7856 f8a36e22 2021-08-26 stsp TAILQ_INIT(&branches);
7857 f8a36e22 2021-08-26 stsp TAILQ_INIT(&tags);
7858 f8a36e22 2021-08-26 stsp TAILQ_INIT(&all_branches);
7859 f8a36e22 2021-08-26 stsp TAILQ_INIT(&all_tags);
7860 f8a36e22 2021-08-26 stsp TAILQ_INIT(&delete_args);
7861 f8a36e22 2021-08-26 stsp TAILQ_INIT(&delete_branches);
7863 f8a36e22 2021-08-26 stsp while ((ch = getopt(argc, argv, "ab:d:fr:t:Tvq")) != -1) {
7864 f8a36e22 2021-08-26 stsp switch (ch) {
7866 f8a36e22 2021-08-26 stsp send_all_branches = 1;
7869 f8a36e22 2021-08-26 stsp error = got_pathlist_append(&branches, optarg, NULL);
7870 f8a36e22 2021-08-26 stsp if (error)
7871 f8a36e22 2021-08-26 stsp return error;
7872 f8a36e22 2021-08-26 stsp nbranches++;
7875 f8a36e22 2021-08-26 stsp error = got_pathlist_append(&delete_args, optarg, NULL);
7876 f8a36e22 2021-08-26 stsp if (error)
7877 f8a36e22 2021-08-26 stsp return error;
7880 f8a36e22 2021-08-26 stsp overwrite_refs = 1;
7883 f8a36e22 2021-08-26 stsp repo_path = realpath(optarg, NULL);
7884 f8a36e22 2021-08-26 stsp if (repo_path == NULL)
7885 f8a36e22 2021-08-26 stsp return got_error_from_errno2("realpath",
7887 f8a36e22 2021-08-26 stsp got_path_strip_trailing_slashes(repo_path);
7890 f8a36e22 2021-08-26 stsp error = got_pathlist_append(&tags, optarg, NULL);
7891 f8a36e22 2021-08-26 stsp if (error)
7892 f8a36e22 2021-08-26 stsp return error;
7896 f8a36e22 2021-08-26 stsp send_all_tags = 1;
7899 f8a36e22 2021-08-26 stsp if (verbosity < 0)
7900 f8a36e22 2021-08-26 stsp verbosity = 0;
7901 f8a36e22 2021-08-26 stsp else if (verbosity < 3)
7902 f8a36e22 2021-08-26 stsp verbosity++;
7905 f8a36e22 2021-08-26 stsp verbosity = -1;
7908 f8a36e22 2021-08-26 stsp usage_send();
7909 f8a36e22 2021-08-26 stsp /* NOTREACHED */
7912 f8a36e22 2021-08-26 stsp argc -= optind;
7913 f8a36e22 2021-08-26 stsp argv += optind;
7915 f8a36e22 2021-08-26 stsp if (send_all_branches && !TAILQ_EMPTY(&branches))
7916 f8a36e22 2021-08-26 stsp option_conflict('a', 'b');
7917 f8a36e22 2021-08-26 stsp if (send_all_tags && !TAILQ_EMPTY(&tags))
7918 f8a36e22 2021-08-26 stsp option_conflict('T', 't');
7921 f8a36e22 2021-08-26 stsp if (argc == 0)
7922 f8a36e22 2021-08-26 stsp remote_name = GOT_SEND_DEFAULT_REMOTE_NAME;
7923 f8a36e22 2021-08-26 stsp else if (argc == 1)
7924 f8a36e22 2021-08-26 stsp remote_name = argv[0];
7926 f8a36e22 2021-08-26 stsp usage_send();
7928 f8a36e22 2021-08-26 stsp cwd = getcwd(NULL, 0);
7929 f8a36e22 2021-08-26 stsp if (cwd == NULL) {
7930 f8a36e22 2021-08-26 stsp error = got_error_from_errno("getcwd");
7931 f8a36e22 2021-08-26 stsp goto done;
7934 f8a36e22 2021-08-26 stsp if (repo_path == NULL) {
7935 f8a36e22 2021-08-26 stsp error = got_worktree_open(&worktree, cwd);
7936 f8a36e22 2021-08-26 stsp if (error && error->code != GOT_ERR_NOT_WORKTREE)
7937 f8a36e22 2021-08-26 stsp goto done;
7939 f8a36e22 2021-08-26 stsp error = NULL;
7940 f8a36e22 2021-08-26 stsp if (worktree) {
7941 f8a36e22 2021-08-26 stsp repo_path =
7942 f8a36e22 2021-08-26 stsp strdup(got_worktree_get_repo_path(worktree));
7943 f8a36e22 2021-08-26 stsp if (repo_path == NULL)
7944 f8a36e22 2021-08-26 stsp error = got_error_from_errno("strdup");
7945 f8a36e22 2021-08-26 stsp if (error)
7946 f8a36e22 2021-08-26 stsp goto done;
7948 f8a36e22 2021-08-26 stsp repo_path = strdup(cwd);
7949 f8a36e22 2021-08-26 stsp if (repo_path == NULL) {
7950 f8a36e22 2021-08-26 stsp error = got_error_from_errno("strdup");
7951 f8a36e22 2021-08-26 stsp goto done;
7956 f8a36e22 2021-08-26 stsp error = got_repo_open(&repo, repo_path, NULL);
7957 f8a36e22 2021-08-26 stsp if (error)
7958 f8a36e22 2021-08-26 stsp goto done;
7960 f8a36e22 2021-08-26 stsp if (worktree) {
7961 f8a36e22 2021-08-26 stsp worktree_conf = got_worktree_get_gotconfig(worktree);
7962 f8a36e22 2021-08-26 stsp if (worktree_conf) {
7963 f8a36e22 2021-08-26 stsp got_gotconfig_get_remotes(&nremotes, &remotes,
7964 f8a36e22 2021-08-26 stsp worktree_conf);
7965 f8a36e22 2021-08-26 stsp for (i = 0; i < nremotes; i++) {
7966 f8a36e22 2021-08-26 stsp if (strcmp(remotes[i].name, remote_name) == 0) {
7967 f8a36e22 2021-08-26 stsp remote = &remotes[i];
7973 f8a36e22 2021-08-26 stsp if (remote == NULL) {
7974 f8a36e22 2021-08-26 stsp repo_conf = got_repo_get_gotconfig(repo);
7975 f8a36e22 2021-08-26 stsp if (repo_conf) {
7976 f8a36e22 2021-08-26 stsp got_gotconfig_get_remotes(&nremotes, &remotes,
7977 f8a36e22 2021-08-26 stsp repo_conf);
7978 f8a36e22 2021-08-26 stsp for (i = 0; i < nremotes; i++) {
7979 f8a36e22 2021-08-26 stsp if (strcmp(remotes[i].name, remote_name) == 0) {
7980 f8a36e22 2021-08-26 stsp remote = &remotes[i];
7986 f8a36e22 2021-08-26 stsp if (remote == NULL) {
7987 f8a36e22 2021-08-26 stsp got_repo_get_gitconfig_remotes(&nremotes, &remotes, repo);
7988 f8a36e22 2021-08-26 stsp for (i = 0; i < nremotes; i++) {
7989 f8a36e22 2021-08-26 stsp if (strcmp(remotes[i].name, remote_name) == 0) {
7990 f8a36e22 2021-08-26 stsp remote = &remotes[i];
7995 f8a36e22 2021-08-26 stsp if (remote == NULL) {
7996 f8a36e22 2021-08-26 stsp error = got_error_path(remote_name, GOT_ERR_NO_REMOTE);
7997 f8a36e22 2021-08-26 stsp goto done;
8000 5e5da8c4 2021-09-05 stsp error = got_dial_parse_uri(&proto, &host, &port, &server_path,
8001 6480c871 2021-08-30 stsp &repo_name, remote->send_url);
8002 f8a36e22 2021-08-26 stsp if (error)
8003 f8a36e22 2021-08-26 stsp goto done;
8005 f8a36e22 2021-08-26 stsp if (strcmp(proto, "git") == 0) {
8006 f8a36e22 2021-08-26 stsp #ifndef PROFILE
8007 f8a36e22 2021-08-26 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec "
8008 f8a36e22 2021-08-26 stsp "sendfd dns inet unveil", NULL) == -1)
8009 f8a36e22 2021-08-26 stsp err(1, "pledge");
8011 f8a36e22 2021-08-26 stsp } else if (strcmp(proto, "git+ssh") == 0 ||
8012 f8a36e22 2021-08-26 stsp strcmp(proto, "ssh") == 0) {
8013 f8a36e22 2021-08-26 stsp #ifndef PROFILE
8014 f8a36e22 2021-08-26 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec "
8015 f8a36e22 2021-08-26 stsp "sendfd unveil", NULL) == -1)
8016 f8a36e22 2021-08-26 stsp err(1, "pledge");
8018 f8a36e22 2021-08-26 stsp } else if (strcmp(proto, "http") == 0 ||
8019 f8a36e22 2021-08-26 stsp strcmp(proto, "git+http") == 0) {
8020 f8a36e22 2021-08-26 stsp error = got_error_path(proto, GOT_ERR_NOT_IMPL);
8021 f8a36e22 2021-08-26 stsp goto done;
8023 f8a36e22 2021-08-26 stsp error = got_error_path(proto, GOT_ERR_BAD_PROTO);
8024 f8a36e22 2021-08-26 stsp goto done;
8027 d65a88a2 2021-09-05 stsp error = got_dial_apply_unveil(proto);
8028 d65a88a2 2021-09-05 stsp if (error)
8029 d65a88a2 2021-09-05 stsp goto done;
8031 f8a36e22 2021-08-26 stsp error = apply_unveil(got_repo_get_path(repo), 0, NULL);
8032 f8a36e22 2021-08-26 stsp if (error)
8033 f8a36e22 2021-08-26 stsp goto done;
8035 f8a36e22 2021-08-26 stsp if (send_all_branches) {
8036 f8a36e22 2021-08-26 stsp error = got_ref_list(&all_branches, repo, "refs/heads",
8037 f8a36e22 2021-08-26 stsp got_ref_cmp_by_name, NULL);
8038 f8a36e22 2021-08-26 stsp if (error)
8039 f8a36e22 2021-08-26 stsp goto done;
8040 f8a36e22 2021-08-26 stsp TAILQ_FOREACH(re, &all_branches, entry) {
8041 f8a36e22 2021-08-26 stsp const char *branchname = got_ref_get_name(re->ref);
8042 f8a36e22 2021-08-26 stsp error = got_pathlist_append(&branches,
8043 f8a36e22 2021-08-26 stsp branchname, NULL);
8044 f8a36e22 2021-08-26 stsp if (error)
8045 f8a36e22 2021-08-26 stsp goto done;
8046 f8a36e22 2021-08-26 stsp nbranches++;
8048 eac1df47 2021-09-01 stsp } else if (nbranches == 0) {
8049 eac1df47 2021-09-01 stsp for (i = 0; i < remote->nsend_branches; i++) {
8050 eac1df47 2021-09-01 stsp got_pathlist_append(&branches,
8051 eac1df47 2021-09-01 stsp remote->send_branches[i], NULL);
8055 f8a36e22 2021-08-26 stsp if (send_all_tags) {
8056 f8a36e22 2021-08-26 stsp error = got_ref_list(&all_tags, repo, "refs/tags",
8057 f8a36e22 2021-08-26 stsp got_ref_cmp_by_name, NULL);
8058 f8a36e22 2021-08-26 stsp if (error)
8059 f8a36e22 2021-08-26 stsp goto done;
8060 f8a36e22 2021-08-26 stsp TAILQ_FOREACH(re, &all_tags, entry) {
8061 f8a36e22 2021-08-26 stsp const char *tagname = got_ref_get_name(re->ref);
8062 f8a36e22 2021-08-26 stsp error = got_pathlist_append(&tags,
8063 f8a36e22 2021-08-26 stsp tagname, NULL);
8064 f8a36e22 2021-08-26 stsp if (error)
8065 f8a36e22 2021-08-26 stsp goto done;
8071 f8a36e22 2021-08-26 stsp * To prevent accidents only branches in refs/heads/ can be deleted
8072 f8a36e22 2021-08-26 stsp * with 'got send -d'.
8073 f8a36e22 2021-08-26 stsp * Deleting anything else requires local repository access or Git.
8075 f8a36e22 2021-08-26 stsp TAILQ_FOREACH(pe, &delete_args, entry) {
8076 f8a36e22 2021-08-26 stsp const char *branchname = pe->path;
8078 f8a36e22 2021-08-26 stsp struct got_pathlist_entry *new;
8079 f8a36e22 2021-08-26 stsp if (strncmp(branchname, "refs/heads/", 11) == 0) {
8080 f8a36e22 2021-08-26 stsp s = strdup(branchname);
8081 f8a36e22 2021-08-26 stsp if (s == NULL) {
8082 f8a36e22 2021-08-26 stsp error = got_error_from_errno("strdup");
8083 f8a36e22 2021-08-26 stsp goto done;
8086 f8a36e22 2021-08-26 stsp if (asprintf(&s, "refs/heads/%s", branchname) == -1) {
8087 f8a36e22 2021-08-26 stsp error = got_error_from_errno("asprintf");
8088 f8a36e22 2021-08-26 stsp goto done;
8091 f8a36e22 2021-08-26 stsp error = got_pathlist_insert(&new, &delete_branches, s, NULL);
8092 f8a36e22 2021-08-26 stsp if (error || new == NULL /* duplicate */)
8094 f8a36e22 2021-08-26 stsp if (error)
8095 f8a36e22 2021-08-26 stsp goto done;
8096 f8a36e22 2021-08-26 stsp ndelete_branches++;
8099 f8a36e22 2021-08-26 stsp if (nbranches == 0 && ndelete_branches == 0) {
8100 f8a36e22 2021-08-26 stsp struct got_reference *head_ref;
8101 f8a36e22 2021-08-26 stsp if (worktree)
8102 f8a36e22 2021-08-26 stsp error = got_ref_open(&head_ref, repo,
8103 f8a36e22 2021-08-26 stsp got_worktree_get_head_ref_name(worktree), 0);
8105 f8a36e22 2021-08-26 stsp error = got_ref_open(&head_ref, repo, GOT_REF_HEAD, 0);
8106 f8a36e22 2021-08-26 stsp if (error)
8107 f8a36e22 2021-08-26 stsp goto done;
8108 f8a36e22 2021-08-26 stsp if (got_ref_is_symbolic(head_ref)) {
8109 f8a36e22 2021-08-26 stsp error = got_ref_resolve_symbolic(&ref, repo, head_ref);
8110 f8a36e22 2021-08-26 stsp got_ref_close(head_ref);
8111 f8a36e22 2021-08-26 stsp if (error)
8112 f8a36e22 2021-08-26 stsp goto done;
8114 f8a36e22 2021-08-26 stsp ref = head_ref;
8115 f8a36e22 2021-08-26 stsp error = got_pathlist_append(&branches, got_ref_get_name(ref),
8117 f8a36e22 2021-08-26 stsp if (error)
8118 f8a36e22 2021-08-26 stsp goto done;
8119 f8a36e22 2021-08-26 stsp nbranches++;
8122 f8a36e22 2021-08-26 stsp if (verbosity >= 0)
8123 f8a36e22 2021-08-26 stsp printf("Connecting to \"%s\" %s%s%s\n", remote->name, host,
8124 f8a36e22 2021-08-26 stsp port ? ":" : "", port ? port : "");
8126 f8a36e22 2021-08-26 stsp error = got_send_connect(&sendpid, &sendfd, proto, host, port,
8127 f8a36e22 2021-08-26 stsp server_path, verbosity);
8128 f8a36e22 2021-08-26 stsp if (error)
8129 f8a36e22 2021-08-26 stsp goto done;
8131 f8a36e22 2021-08-26 stsp memset(&spa, 0, sizeof(spa));
8132 f8a36e22 2021-08-26 stsp spa.last_scaled_packsize[0] = '\0';
8133 f8a36e22 2021-08-26 stsp spa.last_p_deltify = -1;
8134 f8a36e22 2021-08-26 stsp spa.last_p_written = -1;
8135 f8a36e22 2021-08-26 stsp spa.verbosity = verbosity;
8136 f8a36e22 2021-08-26 stsp spa.delete_branches = &delete_branches;
8137 f8a36e22 2021-08-26 stsp error = got_send_pack(remote_name, &branches, &tags, &delete_branches,
8138 f8a36e22 2021-08-26 stsp verbosity, overwrite_refs, sendfd, repo, send_progress, &spa,
8139 f8a36e22 2021-08-26 stsp check_cancelled, NULL);
8140 f8a36e22 2021-08-26 stsp if (spa.printed_something)
8141 f8a36e22 2021-08-26 stsp putchar('\n');
8142 f8a36e22 2021-08-26 stsp if (error)
8143 f8a36e22 2021-08-26 stsp goto done;
8144 f8a36e22 2021-08-26 stsp if (!spa.sent_something && verbosity >= 0)
8145 f8a36e22 2021-08-26 stsp printf("Already up-to-date\n");
8147 f8a36e22 2021-08-26 stsp if (sendpid > 0) {
8148 f8a36e22 2021-08-26 stsp if (kill(sendpid, SIGTERM) == -1)
8149 f8a36e22 2021-08-26 stsp error = got_error_from_errno("kill");
8150 f8a36e22 2021-08-26 stsp if (waitpid(sendpid, &sendstatus, 0) == -1 && error == NULL)
8151 f8a36e22 2021-08-26 stsp error = got_error_from_errno("waitpid");
8153 f8a36e22 2021-08-26 stsp if (sendfd != -1 && close(sendfd) == -1 && error == NULL)
8154 f8a36e22 2021-08-26 stsp error = got_error_from_errno("close");
8155 f8a36e22 2021-08-26 stsp if (repo) {
8156 f8a36e22 2021-08-26 stsp const struct got_error *close_err = got_repo_close(repo);
8157 f8a36e22 2021-08-26 stsp if (error == NULL)
8158 f8a36e22 2021-08-26 stsp error = close_err;
8160 f8a36e22 2021-08-26 stsp if (worktree)
8161 f8a36e22 2021-08-26 stsp got_worktree_close(worktree);
8163 f8a36e22 2021-08-26 stsp got_ref_close(ref);
8164 f8a36e22 2021-08-26 stsp got_pathlist_free(&branches);
8165 f8a36e22 2021-08-26 stsp got_pathlist_free(&tags);
8166 f8a36e22 2021-08-26 stsp got_ref_list_free(&all_branches);
8167 f8a36e22 2021-08-26 stsp got_ref_list_free(&all_tags);
8168 f8a36e22 2021-08-26 stsp got_pathlist_free(&delete_args);
8169 f8a36e22 2021-08-26 stsp TAILQ_FOREACH(pe, &delete_branches, entry)
8170 f8a36e22 2021-08-26 stsp free((char *)pe->path);
8171 f8a36e22 2021-08-26 stsp got_pathlist_free(&delete_branches);
8172 f8a36e22 2021-08-26 stsp free(cwd);
8173 f8a36e22 2021-08-26 stsp free(repo_path);
8174 f8a36e22 2021-08-26 stsp free(proto);
8175 f8a36e22 2021-08-26 stsp free(host);
8176 f8a36e22 2021-08-26 stsp free(port);
8177 f8a36e22 2021-08-26 stsp free(server_path);
8178 f8a36e22 2021-08-26 stsp free(repo_name);
8179 234035bc 2019-06-01 stsp return error;
8182 234035bc 2019-06-01 stsp __dead static void
8183 234035bc 2019-06-01 stsp usage_cherrypick(void)
8185 234035bc 2019-06-01 stsp fprintf(stderr, "usage: %s cherrypick commit-id\n", getprogname());
8189 234035bc 2019-06-01 stsp static const struct got_error *
8190 234035bc 2019-06-01 stsp cmd_cherrypick(int argc, char *argv[])
8192 234035bc 2019-06-01 stsp const struct got_error *error = NULL;
8193 234035bc 2019-06-01 stsp struct got_worktree *worktree = NULL;
8194 234035bc 2019-06-01 stsp struct got_repository *repo = NULL;
8195 234035bc 2019-06-01 stsp char *cwd = NULL, *commit_id_str = NULL;
8196 234035bc 2019-06-01 stsp struct got_object_id *commit_id = NULL;
8197 234035bc 2019-06-01 stsp struct got_commit_object *commit = NULL;
8198 234035bc 2019-06-01 stsp struct got_object_qid *pid;
8200 9627c110 2020-04-18 stsp struct got_update_progress_arg upa;
8202 234035bc 2019-06-01 stsp while ((ch = getopt(argc, argv, "")) != -1) {
8203 234035bc 2019-06-01 stsp switch (ch) {
8205 234035bc 2019-06-01 stsp usage_cherrypick();
8206 234035bc 2019-06-01 stsp /* NOTREACHED */
8210 234035bc 2019-06-01 stsp argc -= optind;
8211 234035bc 2019-06-01 stsp argv += optind;
8213 43012d58 2019-07-14 stsp #ifndef PROFILE
8214 43012d58 2019-07-14 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
8215 43012d58 2019-07-14 stsp "unveil", NULL) == -1)
8216 43012d58 2019-07-14 stsp err(1, "pledge");
8218 234035bc 2019-06-01 stsp if (argc != 1)
8219 234035bc 2019-06-01 stsp usage_cherrypick();
8221 234035bc 2019-06-01 stsp cwd = getcwd(NULL, 0);
8222 234035bc 2019-06-01 stsp if (cwd == NULL) {
8223 234035bc 2019-06-01 stsp error = got_error_from_errno("getcwd");
8224 234035bc 2019-06-01 stsp goto done;
8226 234035bc 2019-06-01 stsp error = got_worktree_open(&worktree, cwd);
8227 fa51e947 2020-03-27 stsp if (error) {
8228 fa51e947 2020-03-27 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
8229 fa51e947 2020-03-27 stsp error = wrap_not_worktree_error(error, "cherrypick",
8231 234035bc 2019-06-01 stsp goto done;
8234 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
8236 234035bc 2019-06-01 stsp if (error != NULL)
8237 234035bc 2019-06-01 stsp goto done;
8239 234035bc 2019-06-01 stsp error = apply_unveil(got_repo_get_path(repo), 0,
8240 c530dc23 2019-07-23 stsp got_worktree_get_root_path(worktree));
8241 234035bc 2019-06-01 stsp if (error)
8242 234035bc 2019-06-01 stsp goto done;
8244 dd88155e 2019-06-29 stsp error = got_repo_match_object_id_prefix(&commit_id, argv[0],
8245 dd88155e 2019-06-29 stsp GOT_OBJ_TYPE_COMMIT, repo);
8246 234035bc 2019-06-01 stsp if (error != NULL) {
8247 234035bc 2019-06-01 stsp struct got_reference *ref;
8248 234035bc 2019-06-01 stsp if (error->code != GOT_ERR_BAD_OBJ_ID_STR)
8249 234035bc 2019-06-01 stsp goto done;
8250 234035bc 2019-06-01 stsp error = got_ref_open(&ref, repo, argv[0], 0);
8251 234035bc 2019-06-01 stsp if (error != NULL)
8252 234035bc 2019-06-01 stsp goto done;
8253 234035bc 2019-06-01 stsp error = got_ref_resolve(&commit_id, repo, ref);
8254 234035bc 2019-06-01 stsp got_ref_close(ref);
8255 234035bc 2019-06-01 stsp if (error != NULL)
8256 234035bc 2019-06-01 stsp goto done;
8258 234035bc 2019-06-01 stsp error = got_object_id_str(&commit_id_str, commit_id);
8259 234035bc 2019-06-01 stsp if (error)
8260 234035bc 2019-06-01 stsp goto done;
8262 234035bc 2019-06-01 stsp error = got_object_open_as_commit(&commit, repo, commit_id);
8263 234035bc 2019-06-01 stsp if (error)
8264 234035bc 2019-06-01 stsp goto done;
8265 dbdddfee 2021-06-23 naddy pid = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
8266 9627c110 2020-04-18 stsp memset(&upa, 0, sizeof(upa));
8267 03415a1a 2019-06-02 stsp error = got_worktree_merge_files(worktree, pid ? pid->id : NULL,
8268 9627c110 2020-04-18 stsp commit_id, repo, update_progress, &upa, check_cancelled,
8270 234035bc 2019-06-01 stsp if (error != NULL)
8271 234035bc 2019-06-01 stsp goto done;
8273 9627c110 2020-04-18 stsp if (upa.did_something)
8274 a7648d7a 2019-06-02 stsp printf("Merged commit %s\n", commit_id_str);
8275 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
8277 234035bc 2019-06-01 stsp if (commit)
8278 234035bc 2019-06-01 stsp got_object_commit_close(commit);
8279 234035bc 2019-06-01 stsp free(commit_id_str);
8280 234035bc 2019-06-01 stsp if (worktree)
8281 234035bc 2019-06-01 stsp got_worktree_close(worktree);
8282 1d0f4054 2021-06-17 stsp if (repo) {
8283 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
8284 1d0f4054 2021-06-17 stsp if (error == NULL)
8285 1d0f4054 2021-06-17 stsp error = close_err;
8287 c4296144 2019-05-09 stsp return error;
8290 5ef14e63 2019-06-02 stsp __dead static void
8291 5ef14e63 2019-06-02 stsp usage_backout(void)
8293 5ef14e63 2019-06-02 stsp fprintf(stderr, "usage: %s backout commit-id\n", getprogname());
8297 5ef14e63 2019-06-02 stsp static const struct got_error *
8298 5ef14e63 2019-06-02 stsp cmd_backout(int argc, char *argv[])
8300 5ef14e63 2019-06-02 stsp const struct got_error *error = NULL;
8301 5ef14e63 2019-06-02 stsp struct got_worktree *worktree = NULL;
8302 5ef14e63 2019-06-02 stsp struct got_repository *repo = NULL;
8303 5ef14e63 2019-06-02 stsp char *cwd = NULL, *commit_id_str = NULL;
8304 5ef14e63 2019-06-02 stsp struct got_object_id *commit_id = NULL;
8305 5ef14e63 2019-06-02 stsp struct got_commit_object *commit = NULL;
8306 5ef14e63 2019-06-02 stsp struct got_object_qid *pid;
8308 9627c110 2020-04-18 stsp struct got_update_progress_arg upa;
8310 5ef14e63 2019-06-02 stsp while ((ch = getopt(argc, argv, "")) != -1) {
8311 5ef14e63 2019-06-02 stsp switch (ch) {
8313 5ef14e63 2019-06-02 stsp usage_backout();
8314 5ef14e63 2019-06-02 stsp /* NOTREACHED */
8318 5ef14e63 2019-06-02 stsp argc -= optind;
8319 5ef14e63 2019-06-02 stsp argv += optind;
8321 43012d58 2019-07-14 stsp #ifndef PROFILE
8322 43012d58 2019-07-14 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
8323 43012d58 2019-07-14 stsp "unveil", NULL) == -1)
8324 43012d58 2019-07-14 stsp err(1, "pledge");
8326 5ef14e63 2019-06-02 stsp if (argc != 1)
8327 5ef14e63 2019-06-02 stsp usage_backout();
8329 5ef14e63 2019-06-02 stsp cwd = getcwd(NULL, 0);
8330 5ef14e63 2019-06-02 stsp if (cwd == NULL) {
8331 5ef14e63 2019-06-02 stsp error = got_error_from_errno("getcwd");
8332 5ef14e63 2019-06-02 stsp goto done;
8334 5ef14e63 2019-06-02 stsp error = got_worktree_open(&worktree, cwd);
8335 fa51e947 2020-03-27 stsp if (error) {
8336 fa51e947 2020-03-27 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
8337 fa51e947 2020-03-27 stsp error = wrap_not_worktree_error(error, "backout", cwd);
8338 5ef14e63 2019-06-02 stsp goto done;
8341 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
8343 5ef14e63 2019-06-02 stsp if (error != NULL)
8344 5ef14e63 2019-06-02 stsp goto done;
8346 5ef14e63 2019-06-02 stsp error = apply_unveil(got_repo_get_path(repo), 0,
8347 c530dc23 2019-07-23 stsp got_worktree_get_root_path(worktree));
8348 5ef14e63 2019-06-02 stsp if (error)
8349 5ef14e63 2019-06-02 stsp goto done;
8351 dd88155e 2019-06-29 stsp error = got_repo_match_object_id_prefix(&commit_id, argv[0],
8352 dd88155e 2019-06-29 stsp GOT_OBJ_TYPE_COMMIT, repo);
8353 5ef14e63 2019-06-02 stsp if (error != NULL) {
8354 5ef14e63 2019-06-02 stsp struct got_reference *ref;
8355 5ef14e63 2019-06-02 stsp if (error->code != GOT_ERR_BAD_OBJ_ID_STR)
8356 5ef14e63 2019-06-02 stsp goto done;
8357 5ef14e63 2019-06-02 stsp error = got_ref_open(&ref, repo, argv[0], 0);
8358 5ef14e63 2019-06-02 stsp if (error != NULL)
8359 5ef14e63 2019-06-02 stsp goto done;
8360 5ef14e63 2019-06-02 stsp error = got_ref_resolve(&commit_id, repo, ref);
8361 5ef14e63 2019-06-02 stsp got_ref_close(ref);
8362 5ef14e63 2019-06-02 stsp if (error != NULL)
8363 5ef14e63 2019-06-02 stsp goto done;
8365 5ef14e63 2019-06-02 stsp error = got_object_id_str(&commit_id_str, commit_id);
8366 5ef14e63 2019-06-02 stsp if (error)
8367 5ef14e63 2019-06-02 stsp goto done;
8369 5ef14e63 2019-06-02 stsp error = got_object_open_as_commit(&commit, repo, commit_id);
8370 5ef14e63 2019-06-02 stsp if (error)
8371 5ef14e63 2019-06-02 stsp goto done;
8372 dbdddfee 2021-06-23 naddy pid = STAILQ_FIRST(got_object_commit_get_parent_ids(commit));
8373 5ef14e63 2019-06-02 stsp if (pid == NULL) {
8374 5ef14e63 2019-06-02 stsp error = got_error(GOT_ERR_ROOT_COMMIT);
8375 5ef14e63 2019-06-02 stsp goto done;
8378 9627c110 2020-04-18 stsp memset(&upa, 0, sizeof(upa));
8379 f259c4c1 2021-09-24 stsp error = got_worktree_merge_files(worktree, commit_id, pid->id,
8380 f259c4c1 2021-09-24 stsp repo, update_progress, &upa, check_cancelled, NULL);
8381 5ef14e63 2019-06-02 stsp if (error != NULL)
8382 5ef14e63 2019-06-02 stsp goto done;
8384 9627c110 2020-04-18 stsp if (upa.did_something)
8385 a7648d7a 2019-06-02 stsp printf("Backed out commit %s\n", commit_id_str);
8386 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
8388 5ef14e63 2019-06-02 stsp if (commit)
8389 5ef14e63 2019-06-02 stsp got_object_commit_close(commit);
8390 5ef14e63 2019-06-02 stsp free(commit_id_str);
8391 818c7501 2019-07-11 stsp if (worktree)
8392 818c7501 2019-07-11 stsp got_worktree_close(worktree);
8393 1d0f4054 2021-06-17 stsp if (repo) {
8394 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
8395 1d0f4054 2021-06-17 stsp if (error == NULL)
8396 1d0f4054 2021-06-17 stsp error = close_err;
8398 818c7501 2019-07-11 stsp return error;
8401 818c7501 2019-07-11 stsp __dead static void
8402 818c7501 2019-07-11 stsp usage_rebase(void)
8404 643b85bc 2021-07-16 stsp fprintf(stderr, "usage: %s rebase [-a] [-c] [-l] [-X] [branch]\n",
8405 af54c8f8 2019-07-11 stsp getprogname());
8410 0ebf8283 2019-07-24 stsp trim_logmsg(char *logmsg, int limit)
8413 0ebf8283 2019-07-24 stsp size_t len;
8415 0ebf8283 2019-07-24 stsp len = strlen(logmsg);
8416 0ebf8283 2019-07-24 stsp if (len > limit)
8417 0ebf8283 2019-07-24 stsp len = limit;
8418 0ebf8283 2019-07-24 stsp logmsg[len] = '\0';
8419 0ebf8283 2019-07-24 stsp nl = strchr(logmsg, '\n');
8421 0ebf8283 2019-07-24 stsp *nl = '\0';
8424 0ebf8283 2019-07-24 stsp static const struct got_error *
8425 0ebf8283 2019-07-24 stsp get_short_logmsg(char **logmsg, int limit, struct got_commit_object *commit)
8427 5943eee2 2019-08-13 stsp const struct got_error *err;
8428 5943eee2 2019-08-13 stsp char *logmsg0 = NULL;
8429 5943eee2 2019-08-13 stsp const char *s;
8431 5943eee2 2019-08-13 stsp err = got_object_commit_get_logmsg(&logmsg0, commit);
8433 5943eee2 2019-08-13 stsp return err;
8435 5943eee2 2019-08-13 stsp s = logmsg0;
8436 5943eee2 2019-08-13 stsp while (isspace((unsigned char)s[0]))
8439 5943eee2 2019-08-13 stsp *logmsg = strdup(s);
8440 5943eee2 2019-08-13 stsp if (*logmsg == NULL) {
8441 5943eee2 2019-08-13 stsp err = got_error_from_errno("strdup");
8442 5943eee2 2019-08-13 stsp goto done;
8445 0ebf8283 2019-07-24 stsp trim_logmsg(*logmsg, limit);
8447 5943eee2 2019-08-13 stsp free(logmsg0);
8448 a0ea4fc0 2020-02-28 stsp return err;
8451 a0ea4fc0 2020-02-28 stsp static const struct got_error *
8452 c0df5966 2021-12-31 stsp show_rebase_merge_conflict(struct got_object_id *id,
8453 c0df5966 2021-12-31 stsp struct got_repository *repo)
8455 a0ea4fc0 2020-02-28 stsp const struct got_error *err;
8456 a0ea4fc0 2020-02-28 stsp struct got_commit_object *commit = NULL;
8457 a0ea4fc0 2020-02-28 stsp char *id_str = NULL, *logmsg = NULL;
8459 a0ea4fc0 2020-02-28 stsp err = got_object_open_as_commit(&commit, repo, id);
8461 a0ea4fc0 2020-02-28 stsp return err;
8463 a0ea4fc0 2020-02-28 stsp err = got_object_id_str(&id_str, id);
8465 a0ea4fc0 2020-02-28 stsp goto done;
8467 a0ea4fc0 2020-02-28 stsp id_str[12] = '\0';
8469 a0ea4fc0 2020-02-28 stsp err = get_short_logmsg(&logmsg, 42, commit);
8471 a0ea4fc0 2020-02-28 stsp goto done;
8473 a0ea4fc0 2020-02-28 stsp printf("%s -> merge conflict: %s\n", id_str, logmsg);
8475 a0ea4fc0 2020-02-28 stsp free(id_str);
8476 a0ea4fc0 2020-02-28 stsp got_object_commit_close(commit);
8477 a0ea4fc0 2020-02-28 stsp free(logmsg);
8478 5943eee2 2019-08-13 stsp return err;
8481 818c7501 2019-07-11 stsp static const struct got_error *
8482 818c7501 2019-07-11 stsp show_rebase_progress(struct got_commit_object *commit,
8483 818c7501 2019-07-11 stsp struct got_object_id *old_id, struct got_object_id *new_id)
8485 818c7501 2019-07-11 stsp const struct got_error *err;
8486 0ebf8283 2019-07-24 stsp char *old_id_str = NULL, *new_id_str = NULL, *logmsg = NULL;
8488 818c7501 2019-07-11 stsp err = got_object_id_str(&old_id_str, old_id);
8490 818c7501 2019-07-11 stsp goto done;
8492 ff0d2220 2019-07-11 stsp if (new_id) {
8493 ff0d2220 2019-07-11 stsp err = got_object_id_str(&new_id_str, new_id);
8495 ff0d2220 2019-07-11 stsp goto done;
8498 818c7501 2019-07-11 stsp old_id_str[12] = '\0';
8499 ff0d2220 2019-07-11 stsp if (new_id_str)
8500 ff0d2220 2019-07-11 stsp new_id_str[12] = '\0';
8502 0ebf8283 2019-07-24 stsp err = get_short_logmsg(&logmsg, 42, commit);
8504 0ebf8283 2019-07-24 stsp goto done;
8506 ff0d2220 2019-07-11 stsp printf("%s -> %s: %s\n", old_id_str,
8507 ff0d2220 2019-07-11 stsp new_id_str ? new_id_str : "no-op change", logmsg);
8509 818c7501 2019-07-11 stsp free(old_id_str);
8510 818c7501 2019-07-11 stsp free(new_id_str);
8511 272a1371 2020-02-28 stsp free(logmsg);
8512 818c7501 2019-07-11 stsp return err;
8515 1ee397ad 2019-07-12 stsp static const struct got_error *
8516 3e3a69f1 2019-07-25 stsp rebase_complete(struct got_worktree *worktree, struct got_fileindex *fileindex,
8517 3e3a69f1 2019-07-25 stsp struct got_reference *branch, struct got_reference *new_base_branch,
8518 e600f124 2021-03-21 stsp struct got_reference *tmp_branch, struct got_repository *repo,
8519 e600f124 2021-03-21 stsp int create_backup)
8521 818c7501 2019-07-11 stsp printf("Switching work tree to %s\n", got_ref_get_name(branch));
8522 3e3a69f1 2019-07-25 stsp return got_worktree_rebase_complete(worktree, fileindex,
8523 e600f124 2021-03-21 stsp new_base_branch, tmp_branch, branch, repo, create_backup);
8526 818c7501 2019-07-11 stsp static const struct got_error *
8527 01757395 2019-07-12 stsp rebase_commit(struct got_pathlist_head *merged_paths,
8528 3e3a69f1 2019-07-25 stsp struct got_worktree *worktree, struct got_fileindex *fileindex,
8529 3e3a69f1 2019-07-25 stsp struct got_reference *tmp_branch,
8530 0ebf8283 2019-07-24 stsp struct got_object_id *commit_id, struct got_repository *repo)
8532 ff0d2220 2019-07-11 stsp const struct got_error *error;
8533 ff0d2220 2019-07-11 stsp struct got_commit_object *commit;
8534 ff0d2220 2019-07-11 stsp struct got_object_id *new_commit_id;
8536 ff0d2220 2019-07-11 stsp error = got_object_open_as_commit(&commit, repo, commit_id);
8537 ff0d2220 2019-07-11 stsp if (error)
8538 ff0d2220 2019-07-11 stsp return error;
8540 01757395 2019-07-12 stsp error = got_worktree_rebase_commit(&new_commit_id, merged_paths,
8541 3e3a69f1 2019-07-25 stsp worktree, fileindex, tmp_branch, commit, commit_id, repo);
8542 ff0d2220 2019-07-11 stsp if (error) {
8543 ff0d2220 2019-07-11 stsp if (error->code != GOT_ERR_COMMIT_NO_CHANGES)
8544 ff0d2220 2019-07-11 stsp goto done;
8545 ff0d2220 2019-07-11 stsp error = show_rebase_progress(commit, commit_id, NULL);
8547 ff0d2220 2019-07-11 stsp error = show_rebase_progress(commit, commit_id, new_commit_id);
8548 ff0d2220 2019-07-11 stsp free(new_commit_id);
8551 ff0d2220 2019-07-11 stsp got_object_commit_close(commit);
8552 ff0d2220 2019-07-11 stsp return error;
8555 64c6d990 2019-07-11 stsp struct check_path_prefix_arg {
8556 64c6d990 2019-07-11 stsp const char *path_prefix;
8557 64c6d990 2019-07-11 stsp size_t len;
8558 8ca9bd68 2019-07-25 stsp int errcode;
8561 64c6d990 2019-07-11 stsp static const struct got_error *
8562 8ca9bd68 2019-07-25 stsp check_path_prefix_in_diff(void *arg, struct got_blob_object *blob1,
8563 64c6d990 2019-07-11 stsp struct got_blob_object *blob2, struct got_object_id *id1,
8564 64c6d990 2019-07-11 stsp struct got_object_id *id2, const char *path1, const char *path2,
8565 46f68b20 2019-10-19 stsp mode_t mode1, mode_t mode2, struct got_repository *repo)
8567 64c6d990 2019-07-11 stsp struct check_path_prefix_arg *a = arg;
8569 64c6d990 2019-07-11 stsp if ((path1 && !got_path_is_child(path1, a->path_prefix, a->len)) ||
8570 64c6d990 2019-07-11 stsp (path2 && !got_path_is_child(path2, a->path_prefix, a->len)))
8571 8ca9bd68 2019-07-25 stsp return got_error(a->errcode);
8573 64c6d990 2019-07-11 stsp return NULL;
8576 64c6d990 2019-07-11 stsp static const struct got_error *
8577 8ca9bd68 2019-07-25 stsp check_path_prefix(struct got_object_id *parent_id,
8578 64c6d990 2019-07-11 stsp struct got_object_id *commit_id, const char *path_prefix,
8579 8ca9bd68 2019-07-25 stsp int errcode, struct got_repository *repo)
8581 64c6d990 2019-07-11 stsp const struct got_error *err;
8582 64c6d990 2019-07-11 stsp struct got_tree_object *tree1 = NULL, *tree2 = NULL;
8583 64c6d990 2019-07-11 stsp struct got_commit_object *commit = NULL, *parent_commit = NULL;
8584 64c6d990 2019-07-11 stsp struct check_path_prefix_arg cpp_arg;
8586 64c6d990 2019-07-11 stsp if (got_path_is_root_dir(path_prefix))
8587 64c6d990 2019-07-11 stsp return NULL;
8589 64c6d990 2019-07-11 stsp err = got_object_open_as_commit(&commit, repo, commit_id);
8591 64c6d990 2019-07-11 stsp goto done;
8593 64c6d990 2019-07-11 stsp err = got_object_open_as_commit(&parent_commit, repo, parent_id);
8595 64c6d990 2019-07-11 stsp goto done;
8597 64c6d990 2019-07-11 stsp err = got_object_open_as_tree(&tree1, repo,
8598 64c6d990 2019-07-11 stsp got_object_commit_get_tree_id(parent_commit));
8600 64c6d990 2019-07-11 stsp goto done;
8602 64c6d990 2019-07-11 stsp err = got_object_open_as_tree(&tree2, repo,
8603 64c6d990 2019-07-11 stsp got_object_commit_get_tree_id(commit));
8605 64c6d990 2019-07-11 stsp goto done;
8607 64c6d990 2019-07-11 stsp cpp_arg.path_prefix = path_prefix;
8608 d23ace97 2019-07-25 stsp while (cpp_arg.path_prefix[0] == '/')
8609 d23ace97 2019-07-25 stsp cpp_arg.path_prefix++;
8610 d23ace97 2019-07-25 stsp cpp_arg.len = strlen(cpp_arg.path_prefix);
8611 8ca9bd68 2019-07-25 stsp cpp_arg.errcode = errcode;
8612 8ca9bd68 2019-07-25 stsp err = got_diff_tree(tree1, tree2, "", "", repo,
8613 31b4484f 2019-07-27 stsp check_path_prefix_in_diff, &cpp_arg, 0);
8615 64c6d990 2019-07-11 stsp if (tree1)
8616 64c6d990 2019-07-11 stsp got_object_tree_close(tree1);
8617 64c6d990 2019-07-11 stsp if (tree2)
8618 64c6d990 2019-07-11 stsp got_object_tree_close(tree2);
8619 64c6d990 2019-07-11 stsp if (commit)
8620 64c6d990 2019-07-11 stsp got_object_commit_close(commit);
8621 64c6d990 2019-07-11 stsp if (parent_commit)
8622 64c6d990 2019-07-11 stsp got_object_commit_close(parent_commit);
8623 64c6d990 2019-07-11 stsp return err;
8626 ff0d2220 2019-07-11 stsp static const struct got_error *
8627 8ca9bd68 2019-07-25 stsp collect_commits(struct got_object_id_queue *commits,
8628 af61c510 2019-07-19 stsp struct got_object_id *initial_commit_id,
8629 af61c510 2019-07-19 stsp struct got_object_id *iter_start_id, struct got_object_id *iter_stop_id,
8630 8ca9bd68 2019-07-25 stsp const char *path_prefix, int path_prefix_errcode,
8631 8ca9bd68 2019-07-25 stsp struct got_repository *repo)
8633 af61c510 2019-07-19 stsp const struct got_error *err = NULL;
8634 af61c510 2019-07-19 stsp struct got_commit_graph *graph = NULL;
8635 af61c510 2019-07-19 stsp struct got_object_id *parent_id = NULL;
8636 af61c510 2019-07-19 stsp struct got_object_qid *qid;
8637 af61c510 2019-07-19 stsp struct got_object_id *commit_id = initial_commit_id;
8639 3d509237 2020-01-04 stsp err = got_commit_graph_open(&graph, "/", 1);
8641 af61c510 2019-07-19 stsp return err;
8643 6fb7cd11 2019-08-22 stsp err = got_commit_graph_iter_start(graph, iter_start_id, repo,
8644 6fb7cd11 2019-08-22 stsp check_cancelled, NULL);
8646 af61c510 2019-07-19 stsp goto done;
8647 af61c510 2019-07-19 stsp while (got_object_id_cmp(commit_id, iter_stop_id) != 0) {
8648 ee780d5c 2020-01-04 stsp err = got_commit_graph_iter_next(&parent_id, graph, repo,
8649 ee780d5c 2020-01-04 stsp check_cancelled, NULL);
8650 af61c510 2019-07-19 stsp if (err) {
8651 af61c510 2019-07-19 stsp if (err->code == GOT_ERR_ITER_COMPLETED) {
8652 af61c510 2019-07-19 stsp err = got_error_msg(GOT_ERR_ANCESTRY,
8653 af61c510 2019-07-19 stsp "ran out of commits to rebase before "
8654 af61c510 2019-07-19 stsp "youngest common ancestor commit has "
8655 af61c510 2019-07-19 stsp "been reached?!?");
8657 ee780d5c 2020-01-04 stsp goto done;
8659 8ca9bd68 2019-07-25 stsp err = check_path_prefix(parent_id, commit_id,
8660 8ca9bd68 2019-07-25 stsp path_prefix, path_prefix_errcode, repo);
8662 af61c510 2019-07-19 stsp goto done;
8664 af61c510 2019-07-19 stsp err = got_object_qid_alloc(&qid, commit_id);
8666 af61c510 2019-07-19 stsp goto done;
8667 dbdddfee 2021-06-23 naddy STAILQ_INSERT_HEAD(commits, qid, entry);
8668 af61c510 2019-07-19 stsp commit_id = parent_id;
8672 af61c510 2019-07-19 stsp got_commit_graph_close(graph);
8673 af61c510 2019-07-19 stsp return err;
8676 e600f124 2021-03-21 stsp static const struct got_error *
8677 e600f124 2021-03-21 stsp get_commit_brief_str(char **brief_str, struct got_commit_object *commit)
8679 e600f124 2021-03-21 stsp const struct got_error *err = NULL;
8680 e600f124 2021-03-21 stsp time_t committer_time;
8681 e600f124 2021-03-21 stsp struct tm tm;
8682 e600f124 2021-03-21 stsp char datebuf[11]; /* YYYY-MM-DD + NUL */
8683 e600f124 2021-03-21 stsp char *author0 = NULL, *author, *smallerthan;
8684 e600f124 2021-03-21 stsp char *logmsg0 = NULL, *logmsg, *newline;
8686 e600f124 2021-03-21 stsp committer_time = got_object_commit_get_committer_time(commit);
8687 e385fc42 2021-08-30 stsp if (gmtime_r(&committer_time, &tm) == NULL)
8688 e385fc42 2021-08-30 stsp return got_error_from_errno("gmtime_r");
8689 e3199de8 2021-03-21 stsp if (strftime(datebuf, sizeof(datebuf), "%G-%m-%d", &tm) == 0)
8690 e600f124 2021-03-21 stsp return got_error(GOT_ERR_NO_SPACE);
8692 e600f124 2021-03-21 stsp author0 = strdup(got_object_commit_get_author(commit));
8693 e600f124 2021-03-21 stsp if (author0 == NULL)
8694 e600f124 2021-03-21 stsp return got_error_from_errno("strdup");
8695 e600f124 2021-03-21 stsp author = author0;
8696 e600f124 2021-03-21 stsp smallerthan = strchr(author, '<');
8697 e600f124 2021-03-21 stsp if (smallerthan && smallerthan[1] != '\0')
8698 e600f124 2021-03-21 stsp author = smallerthan + 1;
8699 e600f124 2021-03-21 stsp author[strcspn(author, "@>")] = '\0';
8701 e600f124 2021-03-21 stsp err = got_object_commit_get_logmsg(&logmsg0, commit);
8703 e600f124 2021-03-21 stsp goto done;
8704 e600f124 2021-03-21 stsp logmsg = logmsg0;
8705 e600f124 2021-03-21 stsp while (*logmsg == '\n')
8707 e600f124 2021-03-21 stsp newline = strchr(logmsg, '\n');
8708 e600f124 2021-03-21 stsp if (newline)
8709 e600f124 2021-03-21 stsp *newline = '\0';
8711 e600f124 2021-03-21 stsp if (asprintf(brief_str, "%s %s %s",
8712 e600f124 2021-03-21 stsp datebuf, author, logmsg) == -1)
8713 e600f124 2021-03-21 stsp err = got_error_from_errno("asprintf");
8715 e600f124 2021-03-21 stsp free(author0);
8716 e600f124 2021-03-21 stsp free(logmsg0);
8717 643b85bc 2021-07-16 stsp return err;
8720 643b85bc 2021-07-16 stsp static const struct got_error *
8721 643b85bc 2021-07-16 stsp delete_backup_ref(struct got_reference *ref, struct got_object_id *id,
8722 643b85bc 2021-07-16 stsp struct got_repository *repo)
8724 643b85bc 2021-07-16 stsp const struct got_error *err;
8725 643b85bc 2021-07-16 stsp char *id_str;
8727 643b85bc 2021-07-16 stsp err = got_object_id_str(&id_str, id);
8729 643b85bc 2021-07-16 stsp return err;
8731 643b85bc 2021-07-16 stsp err = got_ref_delete(ref, repo);
8733 643b85bc 2021-07-16 stsp goto done;
8735 643b85bc 2021-07-16 stsp printf("Deleted %s: %s\n", got_ref_get_name(ref), id_str);
8737 643b85bc 2021-07-16 stsp free(id_str);
8738 e600f124 2021-03-21 stsp return err;
8741 e600f124 2021-03-21 stsp static const struct got_error *
8742 e600f124 2021-03-21 stsp print_backup_ref(const char *branch_name, const char *new_id_str,
8743 e600f124 2021-03-21 stsp struct got_object_id *old_commit_id, struct got_commit_object *old_commit,
8744 e600f124 2021-03-21 stsp struct got_reflist_object_id_map *refs_idmap,
8745 e600f124 2021-03-21 stsp struct got_repository *repo)
8747 e600f124 2021-03-21 stsp const struct got_error *err = NULL;
8748 e600f124 2021-03-21 stsp struct got_reflist_head *refs;
8749 e600f124 2021-03-21 stsp char *refs_str = NULL;
8750 e600f124 2021-03-21 stsp struct got_object_id *new_commit_id = NULL;
8751 e600f124 2021-03-21 stsp struct got_commit_object *new_commit = NULL;
8752 e600f124 2021-03-21 stsp char *new_commit_brief_str = NULL;
8753 e600f124 2021-03-21 stsp struct got_object_id *yca_id = NULL;
8754 e600f124 2021-03-21 stsp struct got_commit_object *yca_commit = NULL;
8755 e600f124 2021-03-21 stsp char *yca_id_str = NULL, *yca_brief_str = NULL;
8756 e600f124 2021-03-21 stsp char *custom_refs_str;
8758 e600f124 2021-03-21 stsp if (asprintf(&custom_refs_str, "formerly %s", branch_name) == -1)
8759 e600f124 2021-03-21 stsp return got_error_from_errno("asprintf");
8761 e600f124 2021-03-21 stsp err = print_commit(old_commit, old_commit_id, repo, NULL, NULL,
8762 e600f124 2021-03-21 stsp 0, 0, refs_idmap, custom_refs_str);
8764 e600f124 2021-03-21 stsp goto done;
8766 e600f124 2021-03-21 stsp err = got_object_resolve_id_str(&new_commit_id, repo, new_id_str);
8768 e600f124 2021-03-21 stsp goto done;
8770 e600f124 2021-03-21 stsp refs = got_reflist_object_id_map_lookup(refs_idmap, new_commit_id);
8771 e600f124 2021-03-21 stsp if (refs) {
8772 e600f124 2021-03-21 stsp err = build_refs_str(&refs_str, refs, new_commit_id, repo);
8774 e600f124 2021-03-21 stsp goto done;
8777 e600f124 2021-03-21 stsp err = got_object_open_as_commit(&new_commit, repo, new_commit_id);
8779 e600f124 2021-03-21 stsp goto done;
8781 e600f124 2021-03-21 stsp err = get_commit_brief_str(&new_commit_brief_str, new_commit);
8783 e600f124 2021-03-21 stsp goto done;
8785 e600f124 2021-03-21 stsp err = got_commit_graph_find_youngest_common_ancestor(&yca_id,
8786 4e91ef15 2021-09-26 stsp old_commit_id, new_commit_id, 1, repo, check_cancelled, NULL);
8788 e600f124 2021-03-21 stsp goto done;
8790 e600f124 2021-03-21 stsp printf("has become commit %s%s%s%s\n %s\n", new_id_str,
8791 e600f124 2021-03-21 stsp refs_str ? " (" : "", refs_str ? refs_str : "",
8792 e600f124 2021-03-21 stsp refs_str ? ")" : "", new_commit_brief_str);
8793 e600f124 2021-03-21 stsp if (yca_id && got_object_id_cmp(yca_id, new_commit_id) != 0 &&
8794 e600f124 2021-03-21 stsp got_object_id_cmp(yca_id, old_commit_id) != 0) {
8795 e600f124 2021-03-21 stsp free(refs_str);
8796 e600f124 2021-03-21 stsp refs_str = NULL;
8798 e600f124 2021-03-21 stsp err = got_object_open_as_commit(&yca_commit, repo, yca_id);
8800 e600f124 2021-03-21 stsp goto done;
8802 e600f124 2021-03-21 stsp err = get_commit_brief_str(&yca_brief_str, yca_commit);
8804 e600f124 2021-03-21 stsp goto done;
8806 e600f124 2021-03-21 stsp err = got_object_id_str(&yca_id_str, yca_id);
8808 e600f124 2021-03-21 stsp goto done;
8810 e600f124 2021-03-21 stsp refs = got_reflist_object_id_map_lookup(refs_idmap, yca_id);
8811 e600f124 2021-03-21 stsp if (refs) {
8812 e600f124 2021-03-21 stsp err = build_refs_str(&refs_str, refs, yca_id, repo);
8814 e600f124 2021-03-21 stsp goto done;
8816 e600f124 2021-03-21 stsp printf("history forked at %s%s%s%s\n %s\n",
8817 e600f124 2021-03-21 stsp yca_id_str,
8818 e600f124 2021-03-21 stsp refs_str ? " (" : "", refs_str ? refs_str : "",
8819 e600f124 2021-03-21 stsp refs_str ? ")" : "", yca_brief_str);
8822 e600f124 2021-03-21 stsp free(custom_refs_str);
8823 e600f124 2021-03-21 stsp free(new_commit_id);
8824 e600f124 2021-03-21 stsp free(refs_str);
8825 e600f124 2021-03-21 stsp free(yca_id);
8826 e600f124 2021-03-21 stsp free(yca_id_str);
8827 e600f124 2021-03-21 stsp free(yca_brief_str);
8828 e600f124 2021-03-21 stsp if (new_commit)
8829 e600f124 2021-03-21 stsp got_object_commit_close(new_commit);
8830 e600f124 2021-03-21 stsp if (yca_commit)
8831 e600f124 2021-03-21 stsp got_object_commit_close(yca_commit);
8833 e600f124 2021-03-21 stsp return NULL;
8836 af61c510 2019-07-19 stsp static const struct got_error *
8837 c0df5966 2021-12-31 stsp process_backup_refs(const char *backup_ref_prefix,
8838 c0df5966 2021-12-31 stsp const char *wanted_branch_name,
8839 643b85bc 2021-07-16 stsp int delete, struct got_repository *repo)
8841 e600f124 2021-03-21 stsp const struct got_error *err;
8842 e600f124 2021-03-21 stsp struct got_reflist_head refs, backup_refs;
8843 e600f124 2021-03-21 stsp struct got_reflist_entry *re;
8844 e600f124 2021-03-21 stsp const size_t backup_ref_prefix_len = strlen(backup_ref_prefix);
8845 e600f124 2021-03-21 stsp struct got_object_id *old_commit_id = NULL;
8846 e600f124 2021-03-21 stsp char *branch_name = NULL;
8847 e600f124 2021-03-21 stsp struct got_commit_object *old_commit = NULL;
8848 e600f124 2021-03-21 stsp struct got_reflist_object_id_map *refs_idmap = NULL;
8849 9e822917 2021-03-23 stsp int wanted_branch_found = 0;
8851 e600f124 2021-03-21 stsp TAILQ_INIT(&refs);
8852 e600f124 2021-03-21 stsp TAILQ_INIT(&backup_refs);
8854 e600f124 2021-03-21 stsp err = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
8856 e600f124 2021-03-21 stsp return err;
8858 e600f124 2021-03-21 stsp err = got_reflist_object_id_map_create(&refs_idmap, &refs, repo);
8860 e600f124 2021-03-21 stsp goto done;
8862 e600f124 2021-03-21 stsp if (wanted_branch_name) {
8863 e600f124 2021-03-21 stsp if (strncmp(wanted_branch_name, "refs/heads/", 11) == 0)
8864 e600f124 2021-03-21 stsp wanted_branch_name += 11;
8867 e600f124 2021-03-21 stsp err = got_ref_list(&backup_refs, repo, backup_ref_prefix,
8868 e600f124 2021-03-21 stsp got_ref_cmp_by_commit_timestamp_descending, repo);
8870 e600f124 2021-03-21 stsp goto done;
8872 e600f124 2021-03-21 stsp TAILQ_FOREACH(re, &backup_refs, entry) {
8873 e600f124 2021-03-21 stsp const char *refname = got_ref_get_name(re->ref);
8874 e600f124 2021-03-21 stsp char *slash;
8876 643b85bc 2021-07-16 stsp err = check_cancelled(NULL);
8880 e600f124 2021-03-21 stsp err = got_ref_resolve(&old_commit_id, repo, re->ref);
8884 e600f124 2021-03-21 stsp err = got_object_open_as_commit(&old_commit, repo,
8885 e600f124 2021-03-21 stsp old_commit_id);
8889 e600f124 2021-03-21 stsp if (strncmp(backup_ref_prefix, refname,
8890 e600f124 2021-03-21 stsp backup_ref_prefix_len) == 0)
8891 e600f124 2021-03-21 stsp refname += backup_ref_prefix_len;
8893 e600f124 2021-03-21 stsp while (refname[0] == '/')
8894 e600f124 2021-03-21 stsp refname++;
8896 e600f124 2021-03-21 stsp branch_name = strdup(refname);
8897 e600f124 2021-03-21 stsp if (branch_name == NULL) {
8898 e600f124 2021-03-21 stsp err = got_error_from_errno("strdup");
8901 e600f124 2021-03-21 stsp slash = strrchr(branch_name, '/');
8902 e600f124 2021-03-21 stsp if (slash) {
8903 e600f124 2021-03-21 stsp *slash = '\0';
8904 e600f124 2021-03-21 stsp refname += strlen(branch_name) + 1;
8907 e600f124 2021-03-21 stsp if (wanted_branch_name == NULL ||
8908 e600f124 2021-03-21 stsp strcmp(wanted_branch_name, branch_name) == 0) {
8909 9e822917 2021-03-23 stsp wanted_branch_found = 1;
8910 643b85bc 2021-07-16 stsp if (delete) {
8911 643b85bc 2021-07-16 stsp err = delete_backup_ref(re->ref,
8912 643b85bc 2021-07-16 stsp old_commit_id, repo);
8914 643b85bc 2021-07-16 stsp err = print_backup_ref(branch_name, refname,
8915 abc59930 2021-09-05 naddy old_commit_id, old_commit, refs_idmap,
8922 e600f124 2021-03-21 stsp free(old_commit_id);
8923 e600f124 2021-03-21 stsp old_commit_id = NULL;
8924 e600f124 2021-03-21 stsp free(branch_name);
8925 e600f124 2021-03-21 stsp branch_name = NULL;
8926 e600f124 2021-03-21 stsp got_object_commit_close(old_commit);
8927 e600f124 2021-03-21 stsp old_commit = NULL;
8930 9e822917 2021-03-23 stsp if (wanted_branch_name && !wanted_branch_found) {
8931 9e822917 2021-03-23 stsp err = got_error_fmt(GOT_ERR_NOT_REF,
8932 9e822917 2021-03-23 stsp "%s/%s/", backup_ref_prefix, wanted_branch_name);
8935 e600f124 2021-03-21 stsp if (refs_idmap)
8936 e600f124 2021-03-21 stsp got_reflist_object_id_map_free(refs_idmap);
8937 e600f124 2021-03-21 stsp got_ref_list_free(&refs);
8938 e600f124 2021-03-21 stsp got_ref_list_free(&backup_refs);
8939 e600f124 2021-03-21 stsp free(old_commit_id);
8940 e600f124 2021-03-21 stsp free(branch_name);
8941 e600f124 2021-03-21 stsp if (old_commit)
8942 e600f124 2021-03-21 stsp got_object_commit_close(old_commit);
8943 e600f124 2021-03-21 stsp return err;
8946 e600f124 2021-03-21 stsp static const struct got_error *
8947 41f061b2 2021-10-05 stsp abort_progress(void *arg, unsigned char status, const char *path)
8950 41f061b2 2021-10-05 stsp * Unversioned files should not clutter progress output when
8951 41f061b2 2021-10-05 stsp * an operation is aborted.
8953 41f061b2 2021-10-05 stsp if (status == GOT_STATUS_UNVERSIONED)
8954 41f061b2 2021-10-05 stsp return NULL;
8956 41f061b2 2021-10-05 stsp return update_progress(arg, status, path);
8959 41f061b2 2021-10-05 stsp static const struct got_error *
8960 818c7501 2019-07-11 stsp cmd_rebase(int argc, char *argv[])
8962 818c7501 2019-07-11 stsp const struct got_error *error = NULL;
8963 818c7501 2019-07-11 stsp struct got_worktree *worktree = NULL;
8964 818c7501 2019-07-11 stsp struct got_repository *repo = NULL;
8965 3e3a69f1 2019-07-25 stsp struct got_fileindex *fileindex = NULL;
8966 818c7501 2019-07-11 stsp char *cwd = NULL;
8967 818c7501 2019-07-11 stsp struct got_reference *branch = NULL;
8968 818c7501 2019-07-11 stsp struct got_reference *new_base_branch = NULL, *tmp_branch = NULL;
8969 818c7501 2019-07-11 stsp struct got_object_id *commit_id = NULL, *parent_id = NULL;
8970 818c7501 2019-07-11 stsp struct got_object_id *resume_commit_id = NULL;
8971 818c7501 2019-07-11 stsp struct got_object_id *branch_head_commit_id = NULL, *yca_id = NULL;
8972 818c7501 2019-07-11 stsp struct got_commit_object *commit = NULL;
8973 818c7501 2019-07-11 stsp int ch, rebase_in_progress = 0, abort_rebase = 0, continue_rebase = 0;
8974 f259c4c1 2021-09-24 stsp int histedit_in_progress = 0, merge_in_progress = 0;
8975 f259c4c1 2021-09-24 stsp int create_backup = 1, list_backups = 0, delete_backups = 0;
8976 818c7501 2019-07-11 stsp struct got_object_id_queue commits;
8977 01757395 2019-07-12 stsp struct got_pathlist_head merged_paths;
8978 818c7501 2019-07-11 stsp const struct got_object_id_queue *parent_ids;
8979 818c7501 2019-07-11 stsp struct got_object_qid *qid, *pid;
8980 1fa49072 2021-09-28 stsp struct got_update_progress_arg upa;
8982 dbdddfee 2021-06-23 naddy STAILQ_INIT(&commits);
8983 01757395 2019-07-12 stsp TAILQ_INIT(&merged_paths);
8984 1fa49072 2021-09-28 stsp memset(&upa, 0, sizeof(upa));
8986 643b85bc 2021-07-16 stsp while ((ch = getopt(argc, argv, "aclX")) != -1) {
8987 818c7501 2019-07-11 stsp switch (ch) {
8989 818c7501 2019-07-11 stsp abort_rebase = 1;
8992 818c7501 2019-07-11 stsp continue_rebase = 1;
8995 e600f124 2021-03-21 stsp list_backups = 1;
8998 643b85bc 2021-07-16 stsp delete_backups = 1;
9001 818c7501 2019-07-11 stsp usage_rebase();
9002 818c7501 2019-07-11 stsp /* NOTREACHED */
9006 818c7501 2019-07-11 stsp argc -= optind;
9007 818c7501 2019-07-11 stsp argv += optind;
9009 43012d58 2019-07-14 stsp #ifndef PROFILE
9010 43012d58 2019-07-14 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
9011 43012d58 2019-07-14 stsp "unveil", NULL) == -1)
9012 43012d58 2019-07-14 stsp err(1, "pledge");
9014 e600f124 2021-03-21 stsp if (list_backups) {
9015 e600f124 2021-03-21 stsp if (abort_rebase)
9016 e600f124 2021-03-21 stsp option_conflict('l', 'a');
9017 e600f124 2021-03-21 stsp if (continue_rebase)
9018 e600f124 2021-03-21 stsp option_conflict('l', 'c');
9019 643b85bc 2021-07-16 stsp if (delete_backups)
9020 643b85bc 2021-07-16 stsp option_conflict('l', 'X');
9021 643b85bc 2021-07-16 stsp if (argc != 0 && argc != 1)
9022 643b85bc 2021-07-16 stsp usage_rebase();
9023 643b85bc 2021-07-16 stsp } else if (delete_backups) {
9024 643b85bc 2021-07-16 stsp if (abort_rebase)
9025 643b85bc 2021-07-16 stsp option_conflict('X', 'a');
9026 643b85bc 2021-07-16 stsp if (continue_rebase)
9027 643b85bc 2021-07-16 stsp option_conflict('X', 'c');
9028 643b85bc 2021-07-16 stsp if (list_backups)
9029 643b85bc 2021-07-16 stsp option_conflict('l', 'X');
9030 e600f124 2021-03-21 stsp if (argc != 0 && argc != 1)
9031 818c7501 2019-07-11 stsp usage_rebase();
9033 e600f124 2021-03-21 stsp if (abort_rebase && continue_rebase)
9034 e600f124 2021-03-21 stsp usage_rebase();
9035 e600f124 2021-03-21 stsp else if (abort_rebase || continue_rebase) {
9036 e600f124 2021-03-21 stsp if (argc != 0)
9037 e600f124 2021-03-21 stsp usage_rebase();
9038 e600f124 2021-03-21 stsp } else if (argc != 1)
9039 e600f124 2021-03-21 stsp usage_rebase();
9042 818c7501 2019-07-11 stsp cwd = getcwd(NULL, 0);
9043 818c7501 2019-07-11 stsp if (cwd == NULL) {
9044 818c7501 2019-07-11 stsp error = got_error_from_errno("getcwd");
9045 818c7501 2019-07-11 stsp goto done;
9047 818c7501 2019-07-11 stsp error = got_worktree_open(&worktree, cwd);
9048 fa51e947 2020-03-27 stsp if (error) {
9049 643b85bc 2021-07-16 stsp if (list_backups || delete_backups) {
9050 e600f124 2021-03-21 stsp if (error->code != GOT_ERR_NOT_WORKTREE)
9051 e600f124 2021-03-21 stsp goto done;
9053 e600f124 2021-03-21 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
9054 e600f124 2021-03-21 stsp error = wrap_not_worktree_error(error,
9055 e600f124 2021-03-21 stsp "rebase", cwd);
9056 e600f124 2021-03-21 stsp goto done;
9060 e600f124 2021-03-21 stsp error = got_repo_open(&repo,
9061 e600f124 2021-03-21 stsp worktree ? got_worktree_get_repo_path(worktree) : cwd, NULL);
9062 818c7501 2019-07-11 stsp if (error != NULL)
9063 818c7501 2019-07-11 stsp goto done;
9065 818c7501 2019-07-11 stsp error = apply_unveil(got_repo_get_path(repo), 0,
9066 e600f124 2021-03-21 stsp worktree ? got_worktree_get_root_path(worktree) : NULL);
9067 7ef62c4e 2020-02-24 stsp if (error)
9068 7ef62c4e 2020-02-24 stsp goto done;
9070 643b85bc 2021-07-16 stsp if (list_backups || delete_backups) {
9071 643b85bc 2021-07-16 stsp error = process_backup_refs(
9072 643b85bc 2021-07-16 stsp GOT_WORKTREE_REBASE_BACKUP_REF_PREFIX,
9073 643b85bc 2021-07-16 stsp argc == 1 ? argv[0] : NULL, delete_backups, repo);
9074 e600f124 2021-03-21 stsp goto done; /* nothing else to do */
9077 7ef62c4e 2020-02-24 stsp error = got_worktree_histedit_in_progress(&histedit_in_progress,
9078 7ef62c4e 2020-02-24 stsp worktree);
9079 818c7501 2019-07-11 stsp if (error)
9080 7ef62c4e 2020-02-24 stsp goto done;
9081 7ef62c4e 2020-02-24 stsp if (histedit_in_progress) {
9082 7ef62c4e 2020-02-24 stsp error = got_error(GOT_ERR_HISTEDIT_BUSY);
9083 f259c4c1 2021-09-24 stsp goto done;
9086 f259c4c1 2021-09-24 stsp error = got_worktree_merge_in_progress(&merge_in_progress,
9087 f259c4c1 2021-09-24 stsp worktree, repo);
9088 f259c4c1 2021-09-24 stsp if (error)
9089 f259c4c1 2021-09-24 stsp goto done;
9090 f259c4c1 2021-09-24 stsp if (merge_in_progress) {
9091 f259c4c1 2021-09-24 stsp error = got_error(GOT_ERR_MERGE_BUSY);
9092 818c7501 2019-07-11 stsp goto done;
9095 818c7501 2019-07-11 stsp error = got_worktree_rebase_in_progress(&rebase_in_progress, worktree);
9096 818c7501 2019-07-11 stsp if (error)
9097 818c7501 2019-07-11 stsp goto done;
9099 f6794adc 2019-07-23 stsp if (abort_rebase) {
9100 f6794adc 2019-07-23 stsp if (!rebase_in_progress) {
9101 f6794adc 2019-07-23 stsp error = got_error(GOT_ERR_NOT_REBASING);
9102 f6794adc 2019-07-23 stsp goto done;
9104 818c7501 2019-07-11 stsp error = got_worktree_rebase_continue(&resume_commit_id,
9105 3e3a69f1 2019-07-25 stsp &new_base_branch, &tmp_branch, &branch, &fileindex,
9106 3e3a69f1 2019-07-25 stsp worktree, repo);
9107 818c7501 2019-07-11 stsp if (error)
9108 818c7501 2019-07-11 stsp goto done;
9109 818c7501 2019-07-11 stsp printf("Switching work tree to %s\n",
9110 818c7501 2019-07-11 stsp got_ref_get_symref_target(new_base_branch));
9111 3e3a69f1 2019-07-25 stsp error = got_worktree_rebase_abort(worktree, fileindex, repo,
9112 41f061b2 2021-10-05 stsp new_base_branch, abort_progress, &upa);
9113 818c7501 2019-07-11 stsp if (error)
9114 818c7501 2019-07-11 stsp goto done;
9115 818c7501 2019-07-11 stsp printf("Rebase of %s aborted\n", got_ref_get_name(branch));
9116 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
9117 818c7501 2019-07-11 stsp goto done; /* nothing else to do */
9120 818c7501 2019-07-11 stsp if (continue_rebase) {
9121 f6794adc 2019-07-23 stsp if (!rebase_in_progress) {
9122 f6794adc 2019-07-23 stsp error = got_error(GOT_ERR_NOT_REBASING);
9123 f6794adc 2019-07-23 stsp goto done;
9125 818c7501 2019-07-11 stsp error = got_worktree_rebase_continue(&resume_commit_id,
9126 3e3a69f1 2019-07-25 stsp &new_base_branch, &tmp_branch, &branch, &fileindex,
9127 3e3a69f1 2019-07-25 stsp worktree, repo);
9128 818c7501 2019-07-11 stsp if (error)
9129 818c7501 2019-07-11 stsp goto done;
9131 3e3a69f1 2019-07-25 stsp error = rebase_commit(NULL, worktree, fileindex, tmp_branch,
9132 01757395 2019-07-12 stsp resume_commit_id, repo);
9133 818c7501 2019-07-11 stsp if (error)
9134 818c7501 2019-07-11 stsp goto done;
9136 ff0d2220 2019-07-11 stsp yca_id = got_object_id_dup(resume_commit_id);
9137 ff0d2220 2019-07-11 stsp if (yca_id == NULL) {
9138 818c7501 2019-07-11 stsp error = got_error_from_errno("got_object_id_dup");
9139 818c7501 2019-07-11 stsp goto done;
9142 818c7501 2019-07-11 stsp error = got_ref_open(&branch, repo, argv[0], 0);
9143 818c7501 2019-07-11 stsp if (error != NULL)
9144 818c7501 2019-07-11 stsp goto done;
9147 ff0d2220 2019-07-11 stsp error = got_ref_resolve(&branch_head_commit_id, repo, branch);
9148 ff0d2220 2019-07-11 stsp if (error)
9149 ff0d2220 2019-07-11 stsp goto done;
9151 ff0d2220 2019-07-11 stsp if (!continue_rebase) {
9152 a51a74b3 2019-07-27 stsp struct got_object_id *base_commit_id;
9154 a51a74b3 2019-07-27 stsp base_commit_id = got_worktree_get_base_commit_id(worktree);
9155 818c7501 2019-07-11 stsp error = got_commit_graph_find_youngest_common_ancestor(&yca_id,
9156 4e91ef15 2021-09-26 stsp base_commit_id, branch_head_commit_id, 1, repo,
9157 6fb7cd11 2019-08-22 stsp check_cancelled, NULL);
9158 818c7501 2019-07-11 stsp if (error)
9159 818c7501 2019-07-11 stsp goto done;
9160 818c7501 2019-07-11 stsp if (yca_id == NULL) {
9161 818c7501 2019-07-11 stsp error = got_error_msg(GOT_ERR_ANCESTRY,
9162 818c7501 2019-07-11 stsp "specified branch shares no common ancestry "
9163 818c7501 2019-07-11 stsp "with work tree's branch");
9164 818c7501 2019-07-11 stsp goto done;
9167 a51a74b3 2019-07-27 stsp error = check_same_branch(base_commit_id, branch, yca_id, repo);
9168 a51a74b3 2019-07-27 stsp if (error) {
9169 a51a74b3 2019-07-27 stsp if (error->code != GOT_ERR_ANCESTRY)
9170 a51a74b3 2019-07-27 stsp goto done;
9171 a51a74b3 2019-07-27 stsp error = NULL;
9173 3d42b266 2021-11-03 jrick struct got_pathlist_head paths;
9174 3d42b266 2021-11-03 jrick printf("%s is already based on %s\n",
9175 df3ed485 2021-01-31 stsp got_ref_get_name(branch),
9176 df3ed485 2021-01-31 stsp got_worktree_get_head_ref_name(worktree));
9177 3d42b266 2021-11-03 jrick error = switch_head_ref(branch, branch_head_commit_id,
9178 3d42b266 2021-11-03 jrick worktree, repo);
9179 3d42b266 2021-11-03 jrick if (error)
9180 3d42b266 2021-11-03 jrick goto done;
9181 3d42b266 2021-11-03 jrick error = got_worktree_set_base_commit_id(worktree, repo,
9182 3d42b266 2021-11-03 jrick branch_head_commit_id);
9183 3d42b266 2021-11-03 jrick if (error)
9184 3d42b266 2021-11-03 jrick goto done;
9185 3d42b266 2021-11-03 jrick TAILQ_INIT(&paths);
9186 3d42b266 2021-11-03 jrick error = got_pathlist_append(&paths, "", NULL);
9187 3d42b266 2021-11-03 jrick if (error)
9188 3d42b266 2021-11-03 jrick goto done;
9189 3d42b266 2021-11-03 jrick error = got_worktree_checkout_files(worktree,
9190 3d42b266 2021-11-03 jrick &paths, repo, update_progress, &upa,
9191 3d42b266 2021-11-03 jrick check_cancelled, NULL);
9192 3d42b266 2021-11-03 jrick got_pathlist_free(&paths);
9193 3d42b266 2021-11-03 jrick if (error)
9194 3d42b266 2021-11-03 jrick goto done;
9195 3d42b266 2021-11-03 jrick if (upa.did_something) {
9196 3d42b266 2021-11-03 jrick char *id_str;
9197 3d42b266 2021-11-03 jrick error = got_object_id_str(&id_str,
9198 3d42b266 2021-11-03 jrick branch_head_commit_id);
9199 3d42b266 2021-11-03 jrick if (error)
9200 3d42b266 2021-11-03 jrick goto done;
9201 3d42b266 2021-11-03 jrick printf("Updated to %s: %s\n",
9202 3d42b266 2021-11-03 jrick got_worktree_get_head_ref_name(worktree),
9204 3d42b266 2021-11-03 jrick free(id_str);
9206 3d42b266 2021-11-03 jrick printf("Already up-to-date\n");
9207 3d42b266 2021-11-03 jrick print_update_progress_stats(&upa);
9208 a51a74b3 2019-07-27 stsp goto done;
9210 818c7501 2019-07-11 stsp error = got_worktree_rebase_prepare(&new_base_branch,
9211 3e3a69f1 2019-07-25 stsp &tmp_branch, &fileindex, worktree, branch, repo);
9212 818c7501 2019-07-11 stsp if (error)
9213 818c7501 2019-07-11 stsp goto done;
9216 ff0d2220 2019-07-11 stsp commit_id = branch_head_commit_id;
9217 818c7501 2019-07-11 stsp error = got_object_open_as_commit(&commit, repo, commit_id);
9218 818c7501 2019-07-11 stsp if (error)
9219 818c7501 2019-07-11 stsp goto done;
9221 818c7501 2019-07-11 stsp parent_ids = got_object_commit_get_parent_ids(commit);
9222 dbdddfee 2021-06-23 naddy pid = STAILQ_FIRST(parent_ids);
9223 fc66b545 2019-08-12 stsp if (pid == NULL) {
9224 fc66b545 2019-08-12 stsp if (!continue_rebase) {
9225 fc66b545 2019-08-12 stsp error = got_worktree_rebase_abort(worktree, fileindex,
9226 41f061b2 2021-10-05 stsp repo, new_base_branch, abort_progress, &upa);
9227 fc66b545 2019-08-12 stsp if (error)
9228 fc66b545 2019-08-12 stsp goto done;
9229 fc66b545 2019-08-12 stsp printf("Rebase of %s aborted\n",
9230 fc66b545 2019-08-12 stsp got_ref_get_name(branch));
9231 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
9234 fc66b545 2019-08-12 stsp error = got_error(GOT_ERR_EMPTY_REBASE);
9235 fc66b545 2019-08-12 stsp goto done;
9237 8ca9bd68 2019-07-25 stsp error = collect_commits(&commits, commit_id, pid->id,
9238 8ca9bd68 2019-07-25 stsp yca_id, got_worktree_get_path_prefix(worktree),
9239 8ca9bd68 2019-07-25 stsp GOT_ERR_REBASE_PATH, repo);
9240 818c7501 2019-07-11 stsp got_object_commit_close(commit);
9241 818c7501 2019-07-11 stsp commit = NULL;
9242 818c7501 2019-07-11 stsp if (error)
9243 818c7501 2019-07-11 stsp goto done;
9245 dbdddfee 2021-06-23 naddy if (STAILQ_EMPTY(&commits)) {
9246 38b0338b 2019-11-29 stsp if (continue_rebase) {
9247 3e3a69f1 2019-07-25 stsp error = rebase_complete(worktree, fileindex,
9248 e600f124 2021-03-21 stsp branch, new_base_branch, tmp_branch, repo,
9249 e600f124 2021-03-21 stsp create_backup);
9250 38b0338b 2019-11-29 stsp goto done;
9252 38b0338b 2019-11-29 stsp /* Fast-forward the reference of the branch. */
9253 38b0338b 2019-11-29 stsp struct got_object_id *new_head_commit_id;
9254 38b0338b 2019-11-29 stsp char *id_str;
9255 38b0338b 2019-11-29 stsp error = got_ref_resolve(&new_head_commit_id, repo,
9256 38b0338b 2019-11-29 stsp new_base_branch);
9257 38b0338b 2019-11-29 stsp if (error)
9258 38b0338b 2019-11-29 stsp goto done;
9259 38b0338b 2019-11-29 stsp error = got_object_id_str(&id_str, new_head_commit_id);
9260 38b0338b 2019-11-29 stsp printf("Forwarding %s to commit %s\n",
9261 38b0338b 2019-11-29 stsp got_ref_get_name(branch), id_str);
9262 38b0338b 2019-11-29 stsp free(id_str);
9263 38b0338b 2019-11-29 stsp error = got_ref_change_ref(branch,
9264 38b0338b 2019-11-29 stsp new_head_commit_id);
9265 38b0338b 2019-11-29 stsp if (error)
9266 38b0338b 2019-11-29 stsp goto done;
9267 e600f124 2021-03-21 stsp /* No backup needed since objects did not change. */
9268 e600f124 2021-03-21 stsp create_backup = 0;
9272 818c7501 2019-07-11 stsp pid = NULL;
9273 dbdddfee 2021-06-23 naddy STAILQ_FOREACH(qid, &commits, entry) {
9275 818c7501 2019-07-11 stsp commit_id = qid->id;
9276 818c7501 2019-07-11 stsp parent_id = pid ? pid->id : yca_id;
9277 818c7501 2019-07-11 stsp pid = qid;
9279 9627c110 2020-04-18 stsp memset(&upa, 0, sizeof(upa));
9280 01757395 2019-07-12 stsp error = got_worktree_rebase_merge_files(&merged_paths,
9281 3e3a69f1 2019-07-25 stsp worktree, fileindex, parent_id, commit_id, repo,
9282 9627c110 2020-04-18 stsp update_progress, &upa, check_cancelled, NULL);
9283 818c7501 2019-07-11 stsp if (error)
9284 818c7501 2019-07-11 stsp goto done;
9286 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
9287 1fa49072 2021-09-28 stsp if (upa.conflicts > 0 || upa.missing > 0 ||
9288 1fa49072 2021-09-28 stsp upa.not_deleted > 0 || upa.unversioned > 0) {
9289 1fa49072 2021-09-28 stsp if (upa.conflicts > 0) {
9290 1fa49072 2021-09-28 stsp error = show_rebase_merge_conflict(qid->id,
9292 1fa49072 2021-09-28 stsp if (error)
9293 1fa49072 2021-09-28 stsp goto done;
9295 01757395 2019-07-12 stsp got_worktree_rebase_pathlist_free(&merged_paths);
9299 3e3a69f1 2019-07-25 stsp error = rebase_commit(&merged_paths, worktree, fileindex,
9300 3e3a69f1 2019-07-25 stsp tmp_branch, commit_id, repo);
9301 01757395 2019-07-12 stsp got_worktree_rebase_pathlist_free(&merged_paths);
9302 818c7501 2019-07-11 stsp if (error)
9303 818c7501 2019-07-11 stsp goto done;
9306 1fa49072 2021-09-28 stsp if (upa.conflicts > 0 || upa.missing > 0 ||
9307 1fa49072 2021-09-28 stsp upa.not_deleted > 0 || upa.unversioned > 0) {
9308 3e3a69f1 2019-07-25 stsp error = got_worktree_rebase_postpone(worktree, fileindex);
9309 818c7501 2019-07-11 stsp if (error)
9310 818c7501 2019-07-11 stsp goto done;
9311 1fa49072 2021-09-28 stsp if (upa.conflicts > 0 && upa.missing == 0 &&
9312 1fa49072 2021-09-28 stsp upa.not_deleted == 0 && upa.unversioned == 0) {
9313 1fa49072 2021-09-28 stsp error = got_error_msg(GOT_ERR_CONFLICTS,
9314 1fa49072 2021-09-28 stsp "conflicts must be resolved before rebasing "
9315 1fa49072 2021-09-28 stsp "can continue");
9316 1fa49072 2021-09-28 stsp } else if (upa.conflicts > 0) {
9317 1fa49072 2021-09-28 stsp error = got_error_msg(GOT_ERR_CONFLICTS,
9318 1fa49072 2021-09-28 stsp "conflicts must be resolved before rebasing "
9319 1fa49072 2021-09-28 stsp "can continue; changes destined for some "
9320 1fa49072 2021-09-28 stsp "files were not yet merged and should be "
9321 1fa49072 2021-09-28 stsp "merged manually if required before the "
9322 1fa49072 2021-09-28 stsp "rebase operation is continued");
9324 1fa49072 2021-09-28 stsp error = got_error_msg(GOT_ERR_CONFLICTS,
9325 1fa49072 2021-09-28 stsp "changes destined for some files were not "
9326 1fa49072 2021-09-28 stsp "yet merged and should be merged manually "
9327 1fa49072 2021-09-28 stsp "if required before the rebase operation "
9328 1fa49072 2021-09-28 stsp "is continued");
9331 3e3a69f1 2019-07-25 stsp error = rebase_complete(worktree, fileindex, branch,
9332 e600f124 2021-03-21 stsp new_base_branch, tmp_branch, repo, create_backup);
9334 818c7501 2019-07-11 stsp got_object_id_queue_free(&commits);
9335 818c7501 2019-07-11 stsp free(branch_head_commit_id);
9336 818c7501 2019-07-11 stsp free(resume_commit_id);
9337 818c7501 2019-07-11 stsp free(yca_id);
9338 818c7501 2019-07-11 stsp if (commit)
9339 818c7501 2019-07-11 stsp got_object_commit_close(commit);
9340 818c7501 2019-07-11 stsp if (branch)
9341 818c7501 2019-07-11 stsp got_ref_close(branch);
9342 818c7501 2019-07-11 stsp if (new_base_branch)
9343 818c7501 2019-07-11 stsp got_ref_close(new_base_branch);
9344 818c7501 2019-07-11 stsp if (tmp_branch)
9345 818c7501 2019-07-11 stsp got_ref_close(tmp_branch);
9346 5ef14e63 2019-06-02 stsp if (worktree)
9347 5ef14e63 2019-06-02 stsp got_worktree_close(worktree);
9348 1d0f4054 2021-06-17 stsp if (repo) {
9349 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
9350 1d0f4054 2021-06-17 stsp if (error == NULL)
9351 1d0f4054 2021-06-17 stsp error = close_err;
9353 5ef14e63 2019-06-02 stsp return error;
9356 0ebf8283 2019-07-24 stsp __dead static void
9357 0ebf8283 2019-07-24 stsp usage_histedit(void)
9359 b93c7142 2021-10-01 stsp fprintf(stderr, "usage: %s histedit [-a] [-c] [-e] [-f] "
9360 643b85bc 2021-07-16 stsp "[-F histedit-script] [-m] [-l] [-X] [branch]\n",
9361 643b85bc 2021-07-16 stsp getprogname());
9365 0ebf8283 2019-07-24 stsp #define GOT_HISTEDIT_PICK 'p'
9366 0ebf8283 2019-07-24 stsp #define GOT_HISTEDIT_EDIT 'e'
9367 0ebf8283 2019-07-24 stsp #define GOT_HISTEDIT_FOLD 'f'
9368 0ebf8283 2019-07-24 stsp #define GOT_HISTEDIT_DROP 'd'
9369 0ebf8283 2019-07-24 stsp #define GOT_HISTEDIT_MESG 'm'
9371 0ebf8283 2019-07-24 stsp static struct got_histedit_cmd {
9372 0ebf8283 2019-07-24 stsp unsigned char code;
9373 0ebf8283 2019-07-24 stsp const char *name;
9374 0ebf8283 2019-07-24 stsp const char *desc;
9375 0ebf8283 2019-07-24 stsp } got_histedit_cmds[] = {
9376 0ebf8283 2019-07-24 stsp { GOT_HISTEDIT_PICK, "pick", "use commit" },
9377 0ebf8283 2019-07-24 stsp { GOT_HISTEDIT_EDIT, "edit", "use commit but stop for amending" },
9378 82997472 2020-01-29 stsp { GOT_HISTEDIT_FOLD, "fold", "combine with next commit that will "
9379 82997472 2020-01-29 stsp "be used" },
9380 0ebf8283 2019-07-24 stsp { GOT_HISTEDIT_DROP, "drop", "remove commit from history" },
9381 0ebf8283 2019-07-24 stsp { GOT_HISTEDIT_MESG, "mesg",
9382 0ebf8283 2019-07-24 stsp "single-line log message for commit above (open editor if empty)" },
9385 0ebf8283 2019-07-24 stsp struct got_histedit_list_entry {
9386 0ebf8283 2019-07-24 stsp TAILQ_ENTRY(got_histedit_list_entry) entry;
9387 0ebf8283 2019-07-24 stsp struct got_object_id *commit_id;
9388 0ebf8283 2019-07-24 stsp const struct got_histedit_cmd *cmd;
9389 0ebf8283 2019-07-24 stsp char *logmsg;
9391 0ebf8283 2019-07-24 stsp TAILQ_HEAD(got_histedit_list, got_histedit_list_entry);
9393 0ebf8283 2019-07-24 stsp static const struct got_error *
9394 0ebf8283 2019-07-24 stsp histedit_write_commit(struct got_object_id *commit_id, const char *cmdname,
9395 0ebf8283 2019-07-24 stsp FILE *f, struct got_repository *repo)
9397 0ebf8283 2019-07-24 stsp const struct got_error *err = NULL;
9398 0ebf8283 2019-07-24 stsp char *logmsg = NULL, *id_str = NULL;
9399 0ebf8283 2019-07-24 stsp struct got_commit_object *commit = NULL;
9402 0ebf8283 2019-07-24 stsp err = got_object_open_as_commit(&commit, repo, commit_id);
9404 0ebf8283 2019-07-24 stsp goto done;
9406 0ebf8283 2019-07-24 stsp err = get_short_logmsg(&logmsg, 34, commit);
9408 0ebf8283 2019-07-24 stsp goto done;
9410 0ebf8283 2019-07-24 stsp err = got_object_id_str(&id_str, commit_id);
9412 0ebf8283 2019-07-24 stsp goto done;
9414 0ebf8283 2019-07-24 stsp n = fprintf(f, "%s %s %s\n", cmdname, id_str, logmsg);
9415 0ebf8283 2019-07-24 stsp if (n < 0)
9416 0ebf8283 2019-07-24 stsp err = got_ferror(f, GOT_ERR_IO);
9418 0ebf8283 2019-07-24 stsp if (commit)
9419 0ebf8283 2019-07-24 stsp got_object_commit_close(commit);
9420 0ebf8283 2019-07-24 stsp free(id_str);
9421 0ebf8283 2019-07-24 stsp free(logmsg);
9422 0ebf8283 2019-07-24 stsp return err;
9425 0ebf8283 2019-07-24 stsp static const struct got_error *
9426 083957f4 2020-02-24 stsp histedit_write_commit_list(struct got_object_id_queue *commits,
9427 b93c7142 2021-10-01 stsp FILE *f, int edit_logmsg_only, int fold_only, int edit_only,
9428 b93c7142 2021-10-01 stsp struct got_repository *repo)
9430 0ebf8283 2019-07-24 stsp const struct got_error *err = NULL;
9431 0ebf8283 2019-07-24 stsp struct got_object_qid *qid;
9432 466785b9 2020-12-10 jrick const char *histedit_cmd = NULL;
9434 dbdddfee 2021-06-23 naddy if (STAILQ_EMPTY(commits))
9435 0ebf8283 2019-07-24 stsp return got_error(GOT_ERR_EMPTY_HISTEDIT);
9437 dbdddfee 2021-06-23 naddy STAILQ_FOREACH(qid, commits, entry) {
9438 466785b9 2020-12-10 jrick histedit_cmd = got_histedit_cmds[0].name;
9439 b93c7142 2021-10-01 stsp if (edit_only)
9440 b93c7142 2021-10-01 stsp histedit_cmd = "edit";
9441 b93c7142 2021-10-01 stsp else if (fold_only && STAILQ_NEXT(qid, entry) != NULL)
9442 466785b9 2020-12-10 jrick histedit_cmd = "fold";
9443 466785b9 2020-12-10 jrick err = histedit_write_commit(qid->id, histedit_cmd, f, repo);
9446 083957f4 2020-02-24 stsp if (edit_logmsg_only) {
9447 083957f4 2020-02-24 stsp int n = fprintf(f, "%c\n", GOT_HISTEDIT_MESG);
9448 083957f4 2020-02-24 stsp if (n < 0) {
9449 083957f4 2020-02-24 stsp err = got_ferror(f, GOT_ERR_IO);
9455 0ebf8283 2019-07-24 stsp return err;
9458 0ebf8283 2019-07-24 stsp static const struct got_error *
9459 514f2ffe 2020-01-29 stsp write_cmd_list(FILE *f, const char *branch_name,
9460 514f2ffe 2020-01-29 stsp struct got_object_id_queue *commits)
9462 0ebf8283 2019-07-24 stsp const struct got_error *err = NULL;
9465 514f2ffe 2020-01-29 stsp char *id_str;
9466 514f2ffe 2020-01-29 stsp struct got_object_qid *qid;
9468 dbdddfee 2021-06-23 naddy qid = STAILQ_FIRST(commits);
9469 514f2ffe 2020-01-29 stsp err = got_object_id_str(&id_str, qid->id);
9471 514f2ffe 2020-01-29 stsp return err;
9473 514f2ffe 2020-01-29 stsp n = fprintf(f,
9474 514f2ffe 2020-01-29 stsp "# Editing the history of branch '%s' starting at\n"
9475 514f2ffe 2020-01-29 stsp "# commit %s\n"
9476 514f2ffe 2020-01-29 stsp "# Commits will be processed in order from top to "
9477 514f2ffe 2020-01-29 stsp "bottom of this file.\n", branch_name, id_str);
9478 514f2ffe 2020-01-29 stsp if (n < 0) {
9479 514f2ffe 2020-01-29 stsp err = got_ferror(f, GOT_ERR_IO);
9480 514f2ffe 2020-01-29 stsp goto done;
9483 0ebf8283 2019-07-24 stsp n = fprintf(f, "# Available histedit commands:\n");
9484 514f2ffe 2020-01-29 stsp if (n < 0) {
9485 514f2ffe 2020-01-29 stsp err = got_ferror(f, GOT_ERR_IO);
9486 514f2ffe 2020-01-29 stsp goto done;
9489 0ebf8283 2019-07-24 stsp for (i = 0; i < nitems(got_histedit_cmds); i++) {
9490 0ebf8283 2019-07-24 stsp struct got_histedit_cmd *cmd = &got_histedit_cmds[i];
9491 0ebf8283 2019-07-24 stsp n = fprintf(f, "# %s (%c): %s\n", cmd->name, cmd->code,
9492 0ebf8283 2019-07-24 stsp cmd->desc);
9493 0ebf8283 2019-07-24 stsp if (n < 0) {
9494 0ebf8283 2019-07-24 stsp err = got_ferror(f, GOT_ERR_IO);
9499 514f2ffe 2020-01-29 stsp free(id_str);
9500 0ebf8283 2019-07-24 stsp return err;
9503 0ebf8283 2019-07-24 stsp static const struct got_error *
9504 0ebf8283 2019-07-24 stsp histedit_syntax_error(int lineno)
9506 0ebf8283 2019-07-24 stsp static char msg[42];
9509 0ebf8283 2019-07-24 stsp ret = snprintf(msg, sizeof(msg), "histedit syntax error on line %d",
9511 0ebf8283 2019-07-24 stsp if (ret == -1 || ret >= sizeof(msg))
9512 0ebf8283 2019-07-24 stsp return got_error(GOT_ERR_HISTEDIT_SYNTAX);
9514 0ebf8283 2019-07-24 stsp return got_error_msg(GOT_ERR_HISTEDIT_SYNTAX, msg);
9517 0ebf8283 2019-07-24 stsp static const struct got_error *
9518 0ebf8283 2019-07-24 stsp append_folded_commit_msg(char **new_msg, struct got_histedit_list_entry *hle,
9519 0ebf8283 2019-07-24 stsp char *logmsg, struct got_repository *repo)
9521 0ebf8283 2019-07-24 stsp const struct got_error *err;
9522 0ebf8283 2019-07-24 stsp struct got_commit_object *folded_commit = NULL;
9523 5943eee2 2019-08-13 stsp char *id_str, *folded_logmsg = NULL;
9525 0ebf8283 2019-07-24 stsp err = got_object_id_str(&id_str, hle->commit_id);
9527 0ebf8283 2019-07-24 stsp return err;
9529 0ebf8283 2019-07-24 stsp err = got_object_open_as_commit(&folded_commit, repo, hle->commit_id);
9531 0ebf8283 2019-07-24 stsp goto done;
9533 5943eee2 2019-08-13 stsp err = got_object_commit_get_logmsg(&folded_logmsg, folded_commit);
9535 5943eee2 2019-08-13 stsp goto done;
9536 0ebf8283 2019-07-24 stsp if (asprintf(new_msg, "%s%s# log message of folded commit %s: %s",
9537 0ebf8283 2019-07-24 stsp logmsg ? logmsg : "", logmsg ? "\n" : "", id_str,
9538 5943eee2 2019-08-13 stsp folded_logmsg) == -1) {
9539 0ebf8283 2019-07-24 stsp err = got_error_from_errno("asprintf");
9542 0ebf8283 2019-07-24 stsp if (folded_commit)
9543 0ebf8283 2019-07-24 stsp got_object_commit_close(folded_commit);
9544 0ebf8283 2019-07-24 stsp free(id_str);
9545 5943eee2 2019-08-13 stsp free(folded_logmsg);
9546 0ebf8283 2019-07-24 stsp return err;
9549 0ebf8283 2019-07-24 stsp static struct got_histedit_list_entry *
9550 0ebf8283 2019-07-24 stsp get_folded_commits(struct got_histedit_list_entry *hle)
9552 0ebf8283 2019-07-24 stsp struct got_histedit_list_entry *prev, *folded = NULL;
9554 0ebf8283 2019-07-24 stsp prev = TAILQ_PREV(hle, got_histedit_list, entry);
9555 3f9de99f 2019-07-24 stsp while (prev && (prev->cmd->code == GOT_HISTEDIT_FOLD ||
9556 3f9de99f 2019-07-24 stsp prev->cmd->code == GOT_HISTEDIT_DROP)) {
9557 3f9de99f 2019-07-24 stsp if (prev->cmd->code == GOT_HISTEDIT_FOLD)
9558 3f9de99f 2019-07-24 stsp folded = prev;
9559 0ebf8283 2019-07-24 stsp prev = TAILQ_PREV(prev, got_histedit_list, entry);
9562 0ebf8283 2019-07-24 stsp return folded;
9565 0ebf8283 2019-07-24 stsp static const struct got_error *
9566 0ebf8283 2019-07-24 stsp histedit_edit_logmsg(struct got_histedit_list_entry *hle,
9567 0ebf8283 2019-07-24 stsp struct got_repository *repo)
9569 5943eee2 2019-08-13 stsp char *logmsg_path = NULL, *id_str = NULL, *orig_logmsg = NULL;
9570 0ebf8283 2019-07-24 stsp char *logmsg = NULL, *new_msg = NULL, *editor = NULL;
9571 0ebf8283 2019-07-24 stsp const struct got_error *err = NULL;
9572 0ebf8283 2019-07-24 stsp struct got_commit_object *commit = NULL;
9573 1601cb9f 2020-09-11 naddy int logmsg_len;
9575 0ebf8283 2019-07-24 stsp struct got_histedit_list_entry *folded = NULL;
9577 0ebf8283 2019-07-24 stsp err = got_object_open_as_commit(&commit, repo, hle->commit_id);
9579 0ebf8283 2019-07-24 stsp return err;
9581 0ebf8283 2019-07-24 stsp folded = get_folded_commits(hle);
9582 0ebf8283 2019-07-24 stsp if (folded) {
9583 0ebf8283 2019-07-24 stsp while (folded != hle) {
9584 3f9de99f 2019-07-24 stsp if (folded->cmd->code == GOT_HISTEDIT_DROP) {
9585 3f9de99f 2019-07-24 stsp folded = TAILQ_NEXT(folded, entry);
9588 0ebf8283 2019-07-24 stsp err = append_folded_commit_msg(&new_msg, folded,
9589 0ebf8283 2019-07-24 stsp logmsg, repo);
9591 0ebf8283 2019-07-24 stsp goto done;
9592 0ebf8283 2019-07-24 stsp free(logmsg);
9593 0ebf8283 2019-07-24 stsp logmsg = new_msg;
9594 0ebf8283 2019-07-24 stsp folded = TAILQ_NEXT(folded, entry);
9598 0ebf8283 2019-07-24 stsp err = got_object_id_str(&id_str, hle->commit_id);
9600 0ebf8283 2019-07-24 stsp goto done;
9601 5943eee2 2019-08-13 stsp err = got_object_commit_get_logmsg(&orig_logmsg, commit);
9603 5943eee2 2019-08-13 stsp goto done;
9604 1601cb9f 2020-09-11 naddy logmsg_len = asprintf(&new_msg,
9605 0ebf8283 2019-07-24 stsp "%s\n# original log message of commit %s: %s",
9606 1601cb9f 2020-09-11 naddy logmsg ? logmsg : "", id_str, orig_logmsg);
9607 1601cb9f 2020-09-11 naddy if (logmsg_len == -1) {
9608 0ebf8283 2019-07-24 stsp err = got_error_from_errno("asprintf");
9609 0ebf8283 2019-07-24 stsp goto done;
9611 0ebf8283 2019-07-24 stsp free(logmsg);
9612 0ebf8283 2019-07-24 stsp logmsg = new_msg;
9614 0ebf8283 2019-07-24 stsp err = got_object_id_str(&id_str, hle->commit_id);
9616 0ebf8283 2019-07-24 stsp goto done;
9618 bb63914a 2020-02-17 stsp err = got_opentemp_named_fd(&logmsg_path, &fd,
9619 bb63914a 2020-02-17 stsp GOT_TMPDIR_STR "/got-logmsg");
9621 0ebf8283 2019-07-24 stsp goto done;
9623 1601cb9f 2020-09-11 naddy write(fd, logmsg, logmsg_len);
9624 0ebf8283 2019-07-24 stsp close(fd);
9626 0ebf8283 2019-07-24 stsp err = get_editor(&editor);
9628 0ebf8283 2019-07-24 stsp goto done;
9630 bfa12d5e 2020-09-26 stsp err = edit_logmsg(&hle->logmsg, editor, logmsg_path, logmsg,
9631 0d5bb276 2020-12-15 stsp logmsg_len, 0);
9632 0ebf8283 2019-07-24 stsp if (err) {
9633 0ebf8283 2019-07-24 stsp if (err->code != GOT_ERR_COMMIT_MSG_EMPTY)
9634 0ebf8283 2019-07-24 stsp goto done;
9635 71392a05 2020-12-13 stsp err = NULL;
9636 71392a05 2020-12-13 stsp hle->logmsg = strdup(new_msg);
9637 71392a05 2020-12-13 stsp if (hle->logmsg == NULL)
9638 71392a05 2020-12-13 stsp err = got_error_from_errno("strdup");
9641 0ebf8283 2019-07-24 stsp if (logmsg_path && unlink(logmsg_path) != 0 && err == NULL)
9642 0ebf8283 2019-07-24 stsp err = got_error_from_errno2("unlink", logmsg_path);
9643 0ebf8283 2019-07-24 stsp free(logmsg_path);
9644 0ebf8283 2019-07-24 stsp free(logmsg);
9645 5943eee2 2019-08-13 stsp free(orig_logmsg);
9646 0ebf8283 2019-07-24 stsp free(editor);
9647 0ebf8283 2019-07-24 stsp if (commit)
9648 0ebf8283 2019-07-24 stsp got_object_commit_close(commit);
9649 0ebf8283 2019-07-24 stsp return err;
9652 0ebf8283 2019-07-24 stsp static const struct got_error *
9653 0ebf8283 2019-07-24 stsp histedit_parse_list(struct got_histedit_list *histedit_cmds,
9654 0ebf8283 2019-07-24 stsp FILE *f, struct got_repository *repo)
9656 0ebf8283 2019-07-24 stsp const struct got_error *err = NULL;
9657 0ebf8283 2019-07-24 stsp char *line = NULL, *p, *end;
9658 6059809a 2020-12-17 stsp size_t i, size;
9659 0ebf8283 2019-07-24 stsp ssize_t len;
9660 6059809a 2020-12-17 stsp int lineno = 0;
9661 0ebf8283 2019-07-24 stsp const struct got_histedit_cmd *cmd;
9662 0ebf8283 2019-07-24 stsp struct got_object_id *commit_id = NULL;
9663 0ebf8283 2019-07-24 stsp struct got_histedit_list_entry *hle = NULL;
9665 0ebf8283 2019-07-24 stsp for (;;) {
9666 0ebf8283 2019-07-24 stsp len = getline(&line, &size, f);
9667 0ebf8283 2019-07-24 stsp if (len == -1) {
9668 0ebf8283 2019-07-24 stsp const struct got_error *getline_err;
9669 0ebf8283 2019-07-24 stsp if (feof(f))
9671 0ebf8283 2019-07-24 stsp getline_err = got_error_from_errno("getline");
9672 0ebf8283 2019-07-24 stsp err = got_ferror(f, getline_err->code);
9677 0ebf8283 2019-07-24 stsp while (isspace((unsigned char)p[0]))
9679 0ebf8283 2019-07-24 stsp if (p[0] == '#' || p[0] == '\0') {
9680 0ebf8283 2019-07-24 stsp free(line);
9681 0ebf8283 2019-07-24 stsp line = NULL;
9684 0ebf8283 2019-07-24 stsp cmd = NULL;
9685 0ebf8283 2019-07-24 stsp for (i = 0; i < nitems(got_histedit_cmds); i++) {
9686 0ebf8283 2019-07-24 stsp cmd = &got_histedit_cmds[i];
9687 0ebf8283 2019-07-24 stsp if (strncmp(cmd->name, p, strlen(cmd->name)) == 0 &&
9688 0ebf8283 2019-07-24 stsp isspace((unsigned char)p[strlen(cmd->name)])) {
9689 0ebf8283 2019-07-24 stsp p += strlen(cmd->name);
9692 0ebf8283 2019-07-24 stsp if (p[0] == cmd->code && isspace((unsigned char)p[1])) {
9697 6c1844f6 2019-07-25 stsp if (i == nitems(got_histedit_cmds)) {
9698 0ebf8283 2019-07-24 stsp err = histedit_syntax_error(lineno);
9701 0ebf8283 2019-07-24 stsp while (isspace((unsigned char)p[0]))
9703 0ebf8283 2019-07-24 stsp if (cmd->code == GOT_HISTEDIT_MESG) {
9704 0ebf8283 2019-07-24 stsp if (hle == NULL || hle->logmsg != NULL) {
9705 0ebf8283 2019-07-24 stsp err = got_error(GOT_ERR_HISTEDIT_CMD);
9708 0ebf8283 2019-07-24 stsp if (p[0] == '\0') {
9709 0ebf8283 2019-07-24 stsp err = histedit_edit_logmsg(hle, repo);
9713 0ebf8283 2019-07-24 stsp hle->logmsg = strdup(p);
9714 0ebf8283 2019-07-24 stsp if (hle->logmsg == NULL) {
9715 0ebf8283 2019-07-24 stsp err = got_error_from_errno("strdup");
9719 0ebf8283 2019-07-24 stsp free(line);
9720 0ebf8283 2019-07-24 stsp line = NULL;
9724 0ebf8283 2019-07-24 stsp while (end[0] && !isspace((unsigned char)end[0]))
9726 0ebf8283 2019-07-24 stsp *end = '\0';
9728 0ebf8283 2019-07-24 stsp err = got_object_resolve_id_str(&commit_id, repo, p);
9729 0ebf8283 2019-07-24 stsp if (err) {
9730 0ebf8283 2019-07-24 stsp /* override error code */
9731 0ebf8283 2019-07-24 stsp err = histedit_syntax_error(lineno);
9735 0ebf8283 2019-07-24 stsp hle = malloc(sizeof(*hle));
9736 0ebf8283 2019-07-24 stsp if (hle == NULL) {
9737 0ebf8283 2019-07-24 stsp err = got_error_from_errno("malloc");
9740 0ebf8283 2019-07-24 stsp hle->cmd = cmd;
9741 0ebf8283 2019-07-24 stsp hle->commit_id = commit_id;
9742 0ebf8283 2019-07-24 stsp hle->logmsg = NULL;
9743 0ebf8283 2019-07-24 stsp commit_id = NULL;
9744 0ebf8283 2019-07-24 stsp free(line);
9745 0ebf8283 2019-07-24 stsp line = NULL;
9746 0ebf8283 2019-07-24 stsp TAILQ_INSERT_TAIL(histedit_cmds, hle, entry);
9749 0ebf8283 2019-07-24 stsp free(line);
9750 0ebf8283 2019-07-24 stsp free(commit_id);
9751 0ebf8283 2019-07-24 stsp return err;
9754 0ebf8283 2019-07-24 stsp static const struct got_error *
9755 bfce7f83 2019-07-27 stsp histedit_check_script(struct got_histedit_list *histedit_cmds,
9756 bfce7f83 2019-07-27 stsp struct got_object_id_queue *commits, struct got_repository *repo)
9758 bfce7f83 2019-07-27 stsp const struct got_error *err = NULL;
9759 bfce7f83 2019-07-27 stsp struct got_object_qid *qid;
9760 bfce7f83 2019-07-27 stsp struct got_histedit_list_entry *hle;
9761 5b87815e 2020-03-05 stsp static char msg[92];
9762 bfce7f83 2019-07-27 stsp char *id_str;
9764 bfce7f83 2019-07-27 stsp if (TAILQ_EMPTY(histedit_cmds))
9765 bfce7f83 2019-07-27 stsp return got_error_msg(GOT_ERR_EMPTY_HISTEDIT,
9766 bfce7f83 2019-07-27 stsp "histedit script contains no commands");
9767 dbdddfee 2021-06-23 naddy if (STAILQ_EMPTY(commits))
9768 a0de39f3 2019-08-09 stsp return got_error(GOT_ERR_EMPTY_HISTEDIT);
9770 5b87815e 2020-03-05 stsp TAILQ_FOREACH(hle, histedit_cmds, entry) {
9771 5b87815e 2020-03-05 stsp struct got_histedit_list_entry *hle2;
9772 5b87815e 2020-03-05 stsp TAILQ_FOREACH(hle2, histedit_cmds, entry) {
9773 5b87815e 2020-03-05 stsp if (hle == hle2)
9775 5b87815e 2020-03-05 stsp if (got_object_id_cmp(hle->commit_id,
9776 5b87815e 2020-03-05 stsp hle2->commit_id) != 0)
9778 5b87815e 2020-03-05 stsp err = got_object_id_str(&id_str, hle->commit_id);
9780 5b87815e 2020-03-05 stsp return err;
9781 5b87815e 2020-03-05 stsp snprintf(msg, sizeof(msg), "commit %s is listed "
9782 5b87815e 2020-03-05 stsp "more than once in histedit script", id_str);
9783 5b87815e 2020-03-05 stsp free(id_str);
9784 5b87815e 2020-03-05 stsp return got_error_msg(GOT_ERR_HISTEDIT_CMD, msg);
9788 dbdddfee 2021-06-23 naddy STAILQ_FOREACH(qid, commits, entry) {
9789 bfce7f83 2019-07-27 stsp TAILQ_FOREACH(hle, histedit_cmds, entry) {
9790 bfce7f83 2019-07-27 stsp if (got_object_id_cmp(qid->id, hle->commit_id) == 0)
9793 bfce7f83 2019-07-27 stsp if (hle == NULL) {
9794 bfce7f83 2019-07-27 stsp err = got_object_id_str(&id_str, qid->id);
9796 bfce7f83 2019-07-27 stsp return err;
9797 bfce7f83 2019-07-27 stsp snprintf(msg, sizeof(msg),
9798 bfce7f83 2019-07-27 stsp "commit %s missing from histedit script", id_str);
9799 bfce7f83 2019-07-27 stsp free(id_str);
9800 bfce7f83 2019-07-27 stsp return got_error_msg(GOT_ERR_HISTEDIT_CMD, msg);
9804 0def28b1 2019-08-17 stsp hle = TAILQ_LAST(histedit_cmds, got_histedit_list);
9805 0def28b1 2019-08-17 stsp if (hle && hle->cmd->code == GOT_HISTEDIT_FOLD)
9806 bfce7f83 2019-07-27 stsp return got_error_msg(GOT_ERR_HISTEDIT_CMD,
9807 bfce7f83 2019-07-27 stsp "last commit in histedit script cannot be folded");
9809 bfce7f83 2019-07-27 stsp return NULL;
9812 bfce7f83 2019-07-27 stsp static const struct got_error *
9813 0ebf8283 2019-07-24 stsp histedit_run_editor(struct got_histedit_list *histedit_cmds,
9814 bfce7f83 2019-07-27 stsp const char *path, struct got_object_id_queue *commits,
9815 bfce7f83 2019-07-27 stsp struct got_repository *repo)
9817 0ebf8283 2019-07-24 stsp const struct got_error *err = NULL;
9818 0ebf8283 2019-07-24 stsp char *editor;
9819 0ebf8283 2019-07-24 stsp FILE *f = NULL;
9821 0ebf8283 2019-07-24 stsp err = get_editor(&editor);
9823 0ebf8283 2019-07-24 stsp return err;
9825 0ebf8283 2019-07-24 stsp if (spawn_editor(editor, path) == -1) {
9826 0ebf8283 2019-07-24 stsp err = got_error_from_errno("failed spawning editor");
9827 0ebf8283 2019-07-24 stsp goto done;
9830 00fe21f2 2021-12-31 stsp f = fopen(path, "re");
9831 0ebf8283 2019-07-24 stsp if (f == NULL) {
9832 0ebf8283 2019-07-24 stsp err = got_error_from_errno("fopen");
9833 0ebf8283 2019-07-24 stsp goto done;
9835 0ebf8283 2019-07-24 stsp err = histedit_parse_list(histedit_cmds, f, repo);
9837 bfce7f83 2019-07-27 stsp goto done;
9839 bfce7f83 2019-07-27 stsp err = histedit_check_script(histedit_cmds, commits, repo);
9841 56b63ca4 2021-01-22 stsp if (f && fclose(f) == EOF && err == NULL)
9842 0ebf8283 2019-07-24 stsp err = got_error_from_errno("fclose");
9843 0ebf8283 2019-07-24 stsp free(editor);
9844 0ebf8283 2019-07-24 stsp return err;
9847 0ebf8283 2019-07-24 stsp static const struct got_error *
9848 bfce7f83 2019-07-27 stsp histedit_edit_list_retry(struct got_histedit_list *, const struct got_error *,
9849 514f2ffe 2020-01-29 stsp struct got_object_id_queue *, const char *, const char *,
9850 514f2ffe 2020-01-29 stsp struct got_repository *);
9852 0ebf8283 2019-07-24 stsp static const struct got_error *
9853 0ebf8283 2019-07-24 stsp histedit_edit_script(struct got_histedit_list *histedit_cmds,
9854 514f2ffe 2020-01-29 stsp struct got_object_id_queue *commits, const char *branch_name,
9855 b93c7142 2021-10-01 stsp int edit_logmsg_only, int fold_only, int edit_only,
9856 b93c7142 2021-10-01 stsp struct got_repository *repo)
9858 0ebf8283 2019-07-24 stsp const struct got_error *err;
9859 0ebf8283 2019-07-24 stsp FILE *f = NULL;
9860 0ebf8283 2019-07-24 stsp char *path = NULL;
9862 0ebf8283 2019-07-24 stsp err = got_opentemp_named(&path, &f, "got-histedit");
9864 0ebf8283 2019-07-24 stsp return err;
9866 514f2ffe 2020-01-29 stsp err = write_cmd_list(f, branch_name, commits);
9868 0ebf8283 2019-07-24 stsp goto done;
9870 466785b9 2020-12-10 jrick err = histedit_write_commit_list(commits, f, edit_logmsg_only,
9871 b93c7142 2021-10-01 stsp fold_only, edit_only, repo);
9873 0ebf8283 2019-07-24 stsp goto done;
9875 b93c7142 2021-10-01 stsp if (edit_logmsg_only || fold_only || edit_only) {
9876 083957f4 2020-02-24 stsp rewind(f);
9877 083957f4 2020-02-24 stsp err = histedit_parse_list(histedit_cmds, f, repo);
9879 56b63ca4 2021-01-22 stsp if (fclose(f) == EOF) {
9880 083957f4 2020-02-24 stsp err = got_error_from_errno("fclose");
9881 0ebf8283 2019-07-24 stsp goto done;
9884 083957f4 2020-02-24 stsp err = histedit_run_editor(histedit_cmds, path, commits, repo);
9885 083957f4 2020-02-24 stsp if (err) {
9886 083957f4 2020-02-24 stsp if (err->code != GOT_ERR_HISTEDIT_SYNTAX &&
9887 083957f4 2020-02-24 stsp err->code != GOT_ERR_HISTEDIT_CMD)
9888 083957f4 2020-02-24 stsp goto done;
9889 083957f4 2020-02-24 stsp err = histedit_edit_list_retry(histedit_cmds, err,
9890 083957f4 2020-02-24 stsp commits, path, branch_name, repo);
9894 56b63ca4 2021-01-22 stsp if (f && fclose(f) == EOF && err == NULL)
9895 0ebf8283 2019-07-24 stsp err = got_error_from_errno("fclose");
9896 0ebf8283 2019-07-24 stsp if (path && unlink(path) != 0 && err == NULL)
9897 0ebf8283 2019-07-24 stsp err = got_error_from_errno2("unlink", path);
9898 0ebf8283 2019-07-24 stsp free(path);
9899 0ebf8283 2019-07-24 stsp return err;
9902 0ebf8283 2019-07-24 stsp static const struct got_error *
9903 0ebf8283 2019-07-24 stsp histedit_save_list(struct got_histedit_list *histedit_cmds,
9904 0ebf8283 2019-07-24 stsp struct got_worktree *worktree, struct got_repository *repo)
9906 0ebf8283 2019-07-24 stsp const struct got_error *err = NULL;
9907 0ebf8283 2019-07-24 stsp char *path = NULL;
9908 0ebf8283 2019-07-24 stsp FILE *f = NULL;
9909 0ebf8283 2019-07-24 stsp struct got_histedit_list_entry *hle;
9910 0ebf8283 2019-07-24 stsp struct got_commit_object *commit = NULL;
9912 c3022ba5 2019-07-27 stsp err = got_worktree_get_histedit_script_path(&path, worktree);
9914 0ebf8283 2019-07-24 stsp return err;
9916 00fe21f2 2021-12-31 stsp f = fopen(path, "we");
9917 0ebf8283 2019-07-24 stsp if (f == NULL) {
9918 0ebf8283 2019-07-24 stsp err = got_error_from_errno2("fopen", path);
9919 0ebf8283 2019-07-24 stsp goto done;
9921 0ebf8283 2019-07-24 stsp TAILQ_FOREACH(hle, histedit_cmds, entry) {
9922 0ebf8283 2019-07-24 stsp err = histedit_write_commit(hle->commit_id, hle->cmd->name, f,
9927 0ebf8283 2019-07-24 stsp if (hle->logmsg) {
9928 0ebf8283 2019-07-24 stsp int n = fprintf(f, "%c %s\n",
9929 0ebf8283 2019-07-24 stsp GOT_HISTEDIT_MESG, hle->logmsg);
9930 0ebf8283 2019-07-24 stsp if (n < 0) {
9931 0ebf8283 2019-07-24 stsp err = got_ferror(f, GOT_ERR_IO);
9937 56b63ca4 2021-01-22 stsp if (f && fclose(f) == EOF && err == NULL)
9938 0ebf8283 2019-07-24 stsp err = got_error_from_errno("fclose");
9939 0ebf8283 2019-07-24 stsp free(path);
9940 0ebf8283 2019-07-24 stsp if (commit)
9941 0ebf8283 2019-07-24 stsp got_object_commit_close(commit);
9942 0ebf8283 2019-07-24 stsp return err;
9946 bfce7f83 2019-07-27 stsp histedit_free_list(struct got_histedit_list *histedit_cmds)
9948 bfce7f83 2019-07-27 stsp struct got_histedit_list_entry *hle;
9950 bfce7f83 2019-07-27 stsp while ((hle = TAILQ_FIRST(histedit_cmds))) {
9951 bfce7f83 2019-07-27 stsp TAILQ_REMOVE(histedit_cmds, hle, entry);
9952 bfce7f83 2019-07-27 stsp free(hle);
9956 0ebf8283 2019-07-24 stsp static const struct got_error *
9957 0ebf8283 2019-07-24 stsp histedit_load_list(struct got_histedit_list *histedit_cmds,
9958 0ebf8283 2019-07-24 stsp const char *path, struct got_repository *repo)
9960 0ebf8283 2019-07-24 stsp const struct got_error *err = NULL;
9961 0ebf8283 2019-07-24 stsp FILE *f = NULL;
9963 00fe21f2 2021-12-31 stsp f = fopen(path, "re");
9964 0ebf8283 2019-07-24 stsp if (f == NULL) {
9965 0ebf8283 2019-07-24 stsp err = got_error_from_errno2("fopen", path);
9966 0ebf8283 2019-07-24 stsp goto done;
9969 0ebf8283 2019-07-24 stsp err = histedit_parse_list(histedit_cmds, f, repo);
9971 56b63ca4 2021-01-22 stsp if (f && fclose(f) == EOF && err == NULL)
9972 0ebf8283 2019-07-24 stsp err = got_error_from_errno("fclose");
9973 0ebf8283 2019-07-24 stsp return err;
9976 0ebf8283 2019-07-24 stsp static const struct got_error *
9977 0ebf8283 2019-07-24 stsp histedit_edit_list_retry(struct got_histedit_list *histedit_cmds,
9978 bfce7f83 2019-07-27 stsp const struct got_error *edit_err, struct got_object_id_queue *commits,
9979 514f2ffe 2020-01-29 stsp const char *path, const char *branch_name, struct got_repository *repo)
9981 bfce7f83 2019-07-27 stsp const struct got_error *err = NULL, *prev_err = edit_err;
9982 0ebf8283 2019-07-24 stsp int resp = ' ';
9984 b006047e 2019-07-25 stsp while (resp != 'c' && resp != 'r' && resp != 'a') {
9985 0ebf8283 2019-07-24 stsp printf("%s: %s\n(c)ontinue editing, (r)estart editing, "
9986 bfce7f83 2019-07-27 stsp "or (a)bort: ", getprogname(), prev_err->msg);
9987 0ebf8283 2019-07-24 stsp resp = getchar();
9988 a61a4414 2019-08-07 stsp if (resp == '\n')
9989 a61a4414 2019-08-07 stsp resp = getchar();
9990 426ebf2e 2019-07-25 stsp if (resp == 'c') {
9991 bfce7f83 2019-07-27 stsp histedit_free_list(histedit_cmds);
9992 bfce7f83 2019-07-27 stsp err = histedit_run_editor(histedit_cmds, path, commits,
9994 426ebf2e 2019-07-25 stsp if (err) {
9995 bfce7f83 2019-07-27 stsp if (err->code != GOT_ERR_HISTEDIT_SYNTAX &&
9996 bfce7f83 2019-07-27 stsp err->code != GOT_ERR_HISTEDIT_CMD)
9998 bfce7f83 2019-07-27 stsp prev_err = err;
9999 426ebf2e 2019-07-25 stsp resp = ' ';
10000 426ebf2e 2019-07-25 stsp continue;
10003 426ebf2e 2019-07-25 stsp } else if (resp == 'r') {
10004 bfce7f83 2019-07-27 stsp histedit_free_list(histedit_cmds);
10005 0ebf8283 2019-07-24 stsp err = histedit_edit_script(histedit_cmds,
10006 b93c7142 2021-10-01 stsp commits, branch_name, 0, 0, 0, repo);
10007 426ebf2e 2019-07-25 stsp if (err) {
10008 bfce7f83 2019-07-27 stsp if (err->code != GOT_ERR_HISTEDIT_SYNTAX &&
10009 bfce7f83 2019-07-27 stsp err->code != GOT_ERR_HISTEDIT_CMD)
10011 bfce7f83 2019-07-27 stsp prev_err = err;
10012 426ebf2e 2019-07-25 stsp resp = ' ';
10013 426ebf2e 2019-07-25 stsp continue;
10016 426ebf2e 2019-07-25 stsp } else if (resp == 'a') {
10017 0ebf8283 2019-07-24 stsp err = got_error(GOT_ERR_HISTEDIT_CANCEL);
10020 0ebf8283 2019-07-24 stsp printf("invalid response '%c'\n", resp);
10023 0ebf8283 2019-07-24 stsp return err;
10026 0ebf8283 2019-07-24 stsp static const struct got_error *
10027 0ebf8283 2019-07-24 stsp histedit_complete(struct got_worktree *worktree,
10028 3e3a69f1 2019-07-25 stsp struct got_fileindex *fileindex, struct got_reference *tmp_branch,
10029 3e3a69f1 2019-07-25 stsp struct got_reference *branch, struct got_repository *repo)
10031 0ebf8283 2019-07-24 stsp printf("Switching work tree to %s\n",
10032 0ebf8283 2019-07-24 stsp got_ref_get_symref_target(branch));
10033 3e3a69f1 2019-07-25 stsp return got_worktree_histedit_complete(worktree, fileindex, tmp_branch,
10034 3e3a69f1 2019-07-25 stsp branch, repo);
10037 0ebf8283 2019-07-24 stsp static const struct got_error *
10038 0ebf8283 2019-07-24 stsp show_histedit_progress(struct got_commit_object *commit,
10039 0ebf8283 2019-07-24 stsp struct got_histedit_list_entry *hle, struct got_object_id *new_id)
10041 0ebf8283 2019-07-24 stsp const struct got_error *err;
10042 0ebf8283 2019-07-24 stsp char *old_id_str = NULL, *new_id_str = NULL, *logmsg = NULL;
10044 0ebf8283 2019-07-24 stsp err = got_object_id_str(&old_id_str, hle->commit_id);
10046 0ebf8283 2019-07-24 stsp goto done;
10048 0ebf8283 2019-07-24 stsp if (new_id) {
10049 0ebf8283 2019-07-24 stsp err = got_object_id_str(&new_id_str, new_id);
10051 0ebf8283 2019-07-24 stsp goto done;
10054 0ebf8283 2019-07-24 stsp old_id_str[12] = '\0';
10055 0ebf8283 2019-07-24 stsp if (new_id_str)
10056 0ebf8283 2019-07-24 stsp new_id_str[12] = '\0';
10058 0ebf8283 2019-07-24 stsp if (hle->logmsg) {
10059 0ebf8283 2019-07-24 stsp logmsg = strdup(hle->logmsg);
10060 0ebf8283 2019-07-24 stsp if (logmsg == NULL) {
10061 0ebf8283 2019-07-24 stsp err = got_error_from_errno("strdup");
10062 0ebf8283 2019-07-24 stsp goto done;
10064 0ebf8283 2019-07-24 stsp trim_logmsg(logmsg, 42);
10066 0ebf8283 2019-07-24 stsp err = get_short_logmsg(&logmsg, 42, commit);
10068 0ebf8283 2019-07-24 stsp goto done;
10071 0ebf8283 2019-07-24 stsp switch (hle->cmd->code) {
10072 0ebf8283 2019-07-24 stsp case GOT_HISTEDIT_PICK:
10073 0ebf8283 2019-07-24 stsp case GOT_HISTEDIT_EDIT:
10074 0ebf8283 2019-07-24 stsp printf("%s -> %s: %s\n", old_id_str,
10075 0ebf8283 2019-07-24 stsp new_id_str ? new_id_str : "no-op change", logmsg);
10077 0ebf8283 2019-07-24 stsp case GOT_HISTEDIT_DROP:
10078 0ebf8283 2019-07-24 stsp case GOT_HISTEDIT_FOLD:
10079 0ebf8283 2019-07-24 stsp printf("%s -> %s commit: %s\n", old_id_str, hle->cmd->name,
10086 0ebf8283 2019-07-24 stsp free(old_id_str);
10087 0ebf8283 2019-07-24 stsp free(new_id_str);
10088 0ebf8283 2019-07-24 stsp return err;
10091 0ebf8283 2019-07-24 stsp static const struct got_error *
10092 0ebf8283 2019-07-24 stsp histedit_commit(struct got_pathlist_head *merged_paths,
10093 3e3a69f1 2019-07-25 stsp struct got_worktree *worktree, struct got_fileindex *fileindex,
10094 3e3a69f1 2019-07-25 stsp struct got_reference *tmp_branch, struct got_histedit_list_entry *hle,
10095 3e3a69f1 2019-07-25 stsp struct got_repository *repo)
10097 0ebf8283 2019-07-24 stsp const struct got_error *err;
10098 0ebf8283 2019-07-24 stsp struct got_commit_object *commit;
10099 0ebf8283 2019-07-24 stsp struct got_object_id *new_commit_id;
10101 0ebf8283 2019-07-24 stsp if ((hle->cmd->code == GOT_HISTEDIT_EDIT || get_folded_commits(hle))
10102 0ebf8283 2019-07-24 stsp && hle->logmsg == NULL) {
10103 0ebf8283 2019-07-24 stsp err = histedit_edit_logmsg(hle, repo);
10105 0ebf8283 2019-07-24 stsp return err;
10108 0ebf8283 2019-07-24 stsp err = got_object_open_as_commit(&commit, repo, hle->commit_id);
10110 0ebf8283 2019-07-24 stsp return err;
10112 0ebf8283 2019-07-24 stsp err = got_worktree_histedit_commit(&new_commit_id, merged_paths,
10113 3e3a69f1 2019-07-25 stsp worktree, fileindex, tmp_branch, commit, hle->commit_id,
10114 3e3a69f1 2019-07-25 stsp hle->logmsg, repo);
10115 0ebf8283 2019-07-24 stsp if (err) {
10116 0ebf8283 2019-07-24 stsp if (err->code != GOT_ERR_COMMIT_NO_CHANGES)
10117 0ebf8283 2019-07-24 stsp goto done;
10118 0ebf8283 2019-07-24 stsp err = show_histedit_progress(commit, hle, NULL);
10120 0ebf8283 2019-07-24 stsp err = show_histedit_progress(commit, hle, new_commit_id);
10121 0ebf8283 2019-07-24 stsp free(new_commit_id);
10124 0ebf8283 2019-07-24 stsp got_object_commit_close(commit);
10125 0ebf8283 2019-07-24 stsp return err;
10128 0ebf8283 2019-07-24 stsp static const struct got_error *
10129 0ebf8283 2019-07-24 stsp histedit_skip_commit(struct got_histedit_list_entry *hle,
10130 0ebf8283 2019-07-24 stsp struct got_worktree *worktree, struct got_repository *repo)
10132 0ebf8283 2019-07-24 stsp const struct got_error *error;
10133 0ebf8283 2019-07-24 stsp struct got_commit_object *commit;
10135 0ebf8283 2019-07-24 stsp error = got_worktree_histedit_skip_commit(worktree, hle->commit_id,
10137 0ebf8283 2019-07-24 stsp if (error)
10138 0ebf8283 2019-07-24 stsp return error;
10140 0ebf8283 2019-07-24 stsp error = got_object_open_as_commit(&commit, repo, hle->commit_id);
10141 0ebf8283 2019-07-24 stsp if (error)
10142 0ebf8283 2019-07-24 stsp return error;
10144 0ebf8283 2019-07-24 stsp error = show_histedit_progress(commit, hle, NULL);
10145 0ebf8283 2019-07-24 stsp got_object_commit_close(commit);
10146 0ebf8283 2019-07-24 stsp return error;
10149 ab20a43a 2020-01-29 stsp static const struct got_error *
10150 ab20a43a 2020-01-29 stsp check_local_changes(void *arg, unsigned char status,
10151 ab20a43a 2020-01-29 stsp unsigned char staged_status, const char *path,
10152 ab20a43a 2020-01-29 stsp struct got_object_id *blob_id, struct got_object_id *staged_blob_id,
10153 ab20a43a 2020-01-29 stsp struct got_object_id *commit_id, int dirfd, const char *de_name)
10155 ab20a43a 2020-01-29 stsp int *have_local_changes = arg;
10157 ab20a43a 2020-01-29 stsp switch (status) {
10158 ab20a43a 2020-01-29 stsp case GOT_STATUS_ADD:
10159 ab20a43a 2020-01-29 stsp case GOT_STATUS_DELETE:
10160 ab20a43a 2020-01-29 stsp case GOT_STATUS_MODIFY:
10161 ab20a43a 2020-01-29 stsp case GOT_STATUS_CONFLICT:
10162 ab20a43a 2020-01-29 stsp *have_local_changes = 1;
10163 ab20a43a 2020-01-29 stsp return got_error(GOT_ERR_CANCELLED);
10168 ab20a43a 2020-01-29 stsp switch (staged_status) {
10169 ab20a43a 2020-01-29 stsp case GOT_STATUS_ADD:
10170 ab20a43a 2020-01-29 stsp case GOT_STATUS_DELETE:
10171 ab20a43a 2020-01-29 stsp case GOT_STATUS_MODIFY:
10172 ab20a43a 2020-01-29 stsp *have_local_changes = 1;
10173 ab20a43a 2020-01-29 stsp return got_error(GOT_ERR_CANCELLED);
10178 ab20a43a 2020-01-29 stsp return NULL;
10181 0ebf8283 2019-07-24 stsp static const struct got_error *
10182 0ebf8283 2019-07-24 stsp cmd_histedit(int argc, char *argv[])
10184 0ebf8283 2019-07-24 stsp const struct got_error *error = NULL;
10185 0ebf8283 2019-07-24 stsp struct got_worktree *worktree = NULL;
10186 3e3a69f1 2019-07-25 stsp struct got_fileindex *fileindex = NULL;
10187 0ebf8283 2019-07-24 stsp struct got_repository *repo = NULL;
10188 0ebf8283 2019-07-24 stsp char *cwd = NULL;
10189 0ebf8283 2019-07-24 stsp struct got_reference *branch = NULL;
10190 0ebf8283 2019-07-24 stsp struct got_reference *tmp_branch = NULL;
10191 0ebf8283 2019-07-24 stsp struct got_object_id *resume_commit_id = NULL;
10192 0ebf8283 2019-07-24 stsp struct got_object_id *base_commit_id = NULL;
10193 0ebf8283 2019-07-24 stsp struct got_object_id *head_commit_id = NULL;
10194 0ebf8283 2019-07-24 stsp struct got_commit_object *commit = NULL;
10195 f259c4c1 2021-09-24 stsp int ch, rebase_in_progress = 0, merge_in_progress = 0;
10196 9627c110 2020-04-18 stsp struct got_update_progress_arg upa;
10197 0ebf8283 2019-07-24 stsp int edit_in_progress = 0, abort_edit = 0, continue_edit = 0;
10198 b93c7142 2021-10-01 stsp int edit_logmsg_only = 0, fold_only = 0, edit_only = 0;
10199 643b85bc 2021-07-16 stsp int list_backups = 0, delete_backups = 0;
10200 0ebf8283 2019-07-24 stsp const char *edit_script_path = NULL;
10201 0ebf8283 2019-07-24 stsp struct got_object_id_queue commits;
10202 0ebf8283 2019-07-24 stsp struct got_pathlist_head merged_paths;
10203 0ebf8283 2019-07-24 stsp const struct got_object_id_queue *parent_ids;
10204 0ebf8283 2019-07-24 stsp struct got_object_qid *pid;
10205 0ebf8283 2019-07-24 stsp struct got_histedit_list histedit_cmds;
10206 0ebf8283 2019-07-24 stsp struct got_histedit_list_entry *hle;
10208 dbdddfee 2021-06-23 naddy STAILQ_INIT(&commits);
10209 0ebf8283 2019-07-24 stsp TAILQ_INIT(&histedit_cmds);
10210 0ebf8283 2019-07-24 stsp TAILQ_INIT(&merged_paths);
10211 9627c110 2020-04-18 stsp memset(&upa, 0, sizeof(upa));
10213 b93c7142 2021-10-01 stsp while ((ch = getopt(argc, argv, "acefF:mlX")) != -1) {
10214 0ebf8283 2019-07-24 stsp switch (ch) {
10215 0ebf8283 2019-07-24 stsp case 'a':
10216 0ebf8283 2019-07-24 stsp abort_edit = 1;
10218 0ebf8283 2019-07-24 stsp case 'c':
10219 0ebf8283 2019-07-24 stsp continue_edit = 1;
10221 b93c7142 2021-10-01 stsp case 'e':
10222 b93c7142 2021-10-01 stsp edit_only = 1;
10224 466785b9 2020-12-10 jrick case 'f':
10225 466785b9 2020-12-10 jrick fold_only = 1;
10227 0ebf8283 2019-07-24 stsp case 'F':
10228 0ebf8283 2019-07-24 stsp edit_script_path = optarg;
10230 083957f4 2020-02-24 stsp case 'm':
10231 083957f4 2020-02-24 stsp edit_logmsg_only = 1;
10233 e600f124 2021-03-21 stsp case 'l':
10234 e600f124 2021-03-21 stsp list_backups = 1;
10236 643b85bc 2021-07-16 stsp case 'X':
10237 643b85bc 2021-07-16 stsp delete_backups = 1;
10240 0ebf8283 2019-07-24 stsp usage_histedit();
10241 0ebf8283 2019-07-24 stsp /* NOTREACHED */
10245 0ebf8283 2019-07-24 stsp argc -= optind;
10246 0ebf8283 2019-07-24 stsp argv += optind;
10248 0ebf8283 2019-07-24 stsp #ifndef PROFILE
10249 0ebf8283 2019-07-24 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
10250 0ebf8283 2019-07-24 stsp "unveil", NULL) == -1)
10251 0ebf8283 2019-07-24 stsp err(1, "pledge");
10253 0ebf8283 2019-07-24 stsp if (abort_edit && continue_edit)
10254 ff69268e 2020-12-13 stsp option_conflict('a', 'c');
10255 083957f4 2020-02-24 stsp if (edit_script_path && edit_logmsg_only)
10256 ff69268e 2020-12-13 stsp option_conflict('F', 'm');
10257 083957f4 2020-02-24 stsp if (abort_edit && edit_logmsg_only)
10258 ff69268e 2020-12-13 stsp option_conflict('a', 'm');
10259 083957f4 2020-02-24 stsp if (continue_edit && edit_logmsg_only)
10260 ff69268e 2020-12-13 stsp option_conflict('c', 'm');
10261 466785b9 2020-12-10 jrick if (abort_edit && fold_only)
10262 ff69268e 2020-12-13 stsp option_conflict('a', 'f');
10263 ff69268e 2020-12-13 stsp if (continue_edit && fold_only)
10264 ff69268e 2020-12-13 stsp option_conflict('c', 'f');
10265 466785b9 2020-12-10 jrick if (fold_only && edit_logmsg_only)
10266 ff69268e 2020-12-13 stsp option_conflict('f', 'm');
10267 b3805337 2020-12-13 stsp if (edit_script_path && fold_only)
10268 b3805337 2020-12-13 stsp option_conflict('F', 'f');
10269 b93c7142 2021-10-01 stsp if (abort_edit && edit_only)
10270 b93c7142 2021-10-01 stsp option_conflict('a', 'e');
10271 b93c7142 2021-10-01 stsp if (continue_edit && edit_only)
10272 b93c7142 2021-10-01 stsp option_conflict('c', 'e');
10273 b93c7142 2021-10-01 stsp if (edit_only && edit_logmsg_only)
10274 b93c7142 2021-10-01 stsp option_conflict('e', 'm');
10275 b93c7142 2021-10-01 stsp if (edit_script_path && edit_only)
10276 b93c7142 2021-10-01 stsp option_conflict('F', 'e');
10277 e600f124 2021-03-21 stsp if (list_backups) {
10278 e600f124 2021-03-21 stsp if (abort_edit)
10279 e600f124 2021-03-21 stsp option_conflict('l', 'a');
10280 e600f124 2021-03-21 stsp if (continue_edit)
10281 e600f124 2021-03-21 stsp option_conflict('l', 'c');
10282 e600f124 2021-03-21 stsp if (edit_script_path)
10283 e600f124 2021-03-21 stsp option_conflict('l', 'F');
10284 e600f124 2021-03-21 stsp if (edit_logmsg_only)
10285 e600f124 2021-03-21 stsp option_conflict('l', 'm');
10286 e600f124 2021-03-21 stsp if (fold_only)
10287 e600f124 2021-03-21 stsp option_conflict('l', 'f');
10288 b93c7142 2021-10-01 stsp if (edit_only)
10289 b93c7142 2021-10-01 stsp option_conflict('l', 'e');
10290 643b85bc 2021-07-16 stsp if (delete_backups)
10291 643b85bc 2021-07-16 stsp option_conflict('l', 'X');
10292 e600f124 2021-03-21 stsp if (argc != 0 && argc != 1)
10293 e600f124 2021-03-21 stsp usage_histedit();
10294 643b85bc 2021-07-16 stsp } else if (delete_backups) {
10295 643b85bc 2021-07-16 stsp if (abort_edit)
10296 643b85bc 2021-07-16 stsp option_conflict('X', 'a');
10297 643b85bc 2021-07-16 stsp if (continue_edit)
10298 643b85bc 2021-07-16 stsp option_conflict('X', 'c');
10299 643b85bc 2021-07-16 stsp if (edit_script_path)
10300 643b85bc 2021-07-16 stsp option_conflict('X', 'F');
10301 643b85bc 2021-07-16 stsp if (edit_logmsg_only)
10302 643b85bc 2021-07-16 stsp option_conflict('X', 'm');
10303 643b85bc 2021-07-16 stsp if (fold_only)
10304 643b85bc 2021-07-16 stsp option_conflict('X', 'f');
10305 b93c7142 2021-10-01 stsp if (edit_only)
10306 b93c7142 2021-10-01 stsp option_conflict('X', 'e');
10307 643b85bc 2021-07-16 stsp if (list_backups)
10308 643b85bc 2021-07-16 stsp option_conflict('X', 'l');
10309 643b85bc 2021-07-16 stsp if (argc != 0 && argc != 1)
10310 643b85bc 2021-07-16 stsp usage_histedit();
10311 e600f124 2021-03-21 stsp } else if (argc != 0)
10312 0ebf8283 2019-07-24 stsp usage_histedit();
10315 0ebf8283 2019-07-24 stsp * This command cannot apply unveil(2) in all cases because the
10316 0ebf8283 2019-07-24 stsp * user may choose to run an editor to edit the histedit script
10317 0ebf8283 2019-07-24 stsp * and to edit individual commit log messages.
10318 0ebf8283 2019-07-24 stsp * unveil(2) traverses exec(2); if an editor is used we have to
10319 0ebf8283 2019-07-24 stsp * apply unveil after edit script and log messages have been written.
10320 0ebf8283 2019-07-24 stsp * XXX TODO: Make use of unveil(2) where possible.
10323 0ebf8283 2019-07-24 stsp cwd = getcwd(NULL, 0);
10324 0ebf8283 2019-07-24 stsp if (cwd == NULL) {
10325 0ebf8283 2019-07-24 stsp error = got_error_from_errno("getcwd");
10326 0ebf8283 2019-07-24 stsp goto done;
10328 0ebf8283 2019-07-24 stsp error = got_worktree_open(&worktree, cwd);
10329 fa51e947 2020-03-27 stsp if (error) {
10330 643b85bc 2021-07-16 stsp if (list_backups || delete_backups) {
10331 e600f124 2021-03-21 stsp if (error->code != GOT_ERR_NOT_WORKTREE)
10332 e600f124 2021-03-21 stsp goto done;
10334 e600f124 2021-03-21 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
10335 e600f124 2021-03-21 stsp error = wrap_not_worktree_error(error,
10336 e600f124 2021-03-21 stsp "histedit", cwd);
10337 e600f124 2021-03-21 stsp goto done;
10341 643b85bc 2021-07-16 stsp if (list_backups || delete_backups) {
10342 e600f124 2021-03-21 stsp error = got_repo_open(&repo,
10343 e600f124 2021-03-21 stsp worktree ? got_worktree_get_repo_path(worktree) : cwd,
10345 e600f124 2021-03-21 stsp if (error != NULL)
10346 e600f124 2021-03-21 stsp goto done;
10347 e600f124 2021-03-21 stsp error = apply_unveil(got_repo_get_path(repo), 0,
10348 e600f124 2021-03-21 stsp worktree ? got_worktree_get_root_path(worktree) : NULL);
10349 e600f124 2021-03-21 stsp if (error)
10350 e600f124 2021-03-21 stsp goto done;
10351 643b85bc 2021-07-16 stsp error = process_backup_refs(
10352 e600f124 2021-03-21 stsp GOT_WORKTREE_HISTEDIT_BACKUP_REF_PREFIX,
10353 643b85bc 2021-07-16 stsp argc == 1 ? argv[0] : NULL, delete_backups, repo);
10354 e600f124 2021-03-21 stsp goto done; /* nothing else to do */
10357 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
10359 0ebf8283 2019-07-24 stsp if (error != NULL)
10360 0ebf8283 2019-07-24 stsp goto done;
10362 0ebf8283 2019-07-24 stsp error = got_worktree_rebase_in_progress(&rebase_in_progress, worktree);
10363 0ebf8283 2019-07-24 stsp if (error)
10364 0ebf8283 2019-07-24 stsp goto done;
10365 0ebf8283 2019-07-24 stsp if (rebase_in_progress) {
10366 0ebf8283 2019-07-24 stsp error = got_error(GOT_ERR_REBASING);
10367 f259c4c1 2021-09-24 stsp goto done;
10370 f259c4c1 2021-09-24 stsp error = got_worktree_merge_in_progress(&merge_in_progress, worktree,
10372 f259c4c1 2021-09-24 stsp if (error)
10373 f259c4c1 2021-09-24 stsp goto done;
10374 f259c4c1 2021-09-24 stsp if (merge_in_progress) {
10375 f259c4c1 2021-09-24 stsp error = got_error(GOT_ERR_MERGE_BUSY);
10376 0ebf8283 2019-07-24 stsp goto done;
10379 0ebf8283 2019-07-24 stsp error = got_worktree_histedit_in_progress(&edit_in_progress, worktree);
10380 0ebf8283 2019-07-24 stsp if (error)
10381 0ebf8283 2019-07-24 stsp goto done;
10383 083957f4 2020-02-24 stsp if (edit_in_progress && edit_logmsg_only) {
10384 083957f4 2020-02-24 stsp error = got_error_msg(GOT_ERR_HISTEDIT_BUSY,
10385 083957f4 2020-02-24 stsp "histedit operation is in progress in this "
10386 083957f4 2020-02-24 stsp "work tree and must be continued or aborted "
10387 083957f4 2020-02-24 stsp "before the -m option can be used");
10388 083957f4 2020-02-24 stsp goto done;
10390 466785b9 2020-12-10 jrick if (edit_in_progress && fold_only) {
10391 466785b9 2020-12-10 jrick error = got_error_msg(GOT_ERR_HISTEDIT_BUSY,
10392 466785b9 2020-12-10 jrick "histedit operation is in progress in this "
10393 466785b9 2020-12-10 jrick "work tree and must be continued or aborted "
10394 466785b9 2020-12-10 jrick "before the -f option can be used");
10395 466785b9 2020-12-10 jrick goto done;
10397 b93c7142 2021-10-01 stsp if (edit_in_progress && edit_only) {
10398 b93c7142 2021-10-01 stsp error = got_error_msg(GOT_ERR_HISTEDIT_BUSY,
10399 b93c7142 2021-10-01 stsp "histedit operation is in progress in this "
10400 b93c7142 2021-10-01 stsp "work tree and must be continued or aborted "
10401 b93c7142 2021-10-01 stsp "before the -e option can be used");
10402 b93c7142 2021-10-01 stsp goto done;
10405 0ebf8283 2019-07-24 stsp if (edit_in_progress && abort_edit) {
10406 0ebf8283 2019-07-24 stsp error = got_worktree_histedit_continue(&resume_commit_id,
10407 3e3a69f1 2019-07-25 stsp &tmp_branch, &branch, &base_commit_id, &fileindex,
10408 3e3a69f1 2019-07-25 stsp worktree, repo);
10409 0ebf8283 2019-07-24 stsp if (error)
10410 0ebf8283 2019-07-24 stsp goto done;
10411 0ebf8283 2019-07-24 stsp printf("Switching work tree to %s\n",
10412 0ebf8283 2019-07-24 stsp got_ref_get_symref_target(branch));
10413 3e3a69f1 2019-07-25 stsp error = got_worktree_histedit_abort(worktree, fileindex, repo,
10414 41f061b2 2021-10-05 stsp branch, base_commit_id, abort_progress, &upa);
10415 0ebf8283 2019-07-24 stsp if (error)
10416 0ebf8283 2019-07-24 stsp goto done;
10417 0ebf8283 2019-07-24 stsp printf("Histedit of %s aborted\n",
10418 0ebf8283 2019-07-24 stsp got_ref_get_symref_target(branch));
10419 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
10420 0ebf8283 2019-07-24 stsp goto done; /* nothing else to do */
10421 0ebf8283 2019-07-24 stsp } else if (abort_edit) {
10422 0ebf8283 2019-07-24 stsp error = got_error(GOT_ERR_NOT_HISTEDIT);
10423 0ebf8283 2019-07-24 stsp goto done;
10426 0ebf8283 2019-07-24 stsp if (continue_edit) {
10427 0ebf8283 2019-07-24 stsp char *path;
10429 0ebf8283 2019-07-24 stsp if (!edit_in_progress) {
10430 0ebf8283 2019-07-24 stsp error = got_error(GOT_ERR_NOT_HISTEDIT);
10431 0ebf8283 2019-07-24 stsp goto done;
10434 c3022ba5 2019-07-27 stsp error = got_worktree_get_histedit_script_path(&path, worktree);
10435 0ebf8283 2019-07-24 stsp if (error)
10436 0ebf8283 2019-07-24 stsp goto done;
10438 0ebf8283 2019-07-24 stsp error = histedit_load_list(&histedit_cmds, path, repo);
10439 0ebf8283 2019-07-24 stsp free(path);
10440 0ebf8283 2019-07-24 stsp if (error)
10441 0ebf8283 2019-07-24 stsp goto done;
10443 0ebf8283 2019-07-24 stsp error = got_worktree_histedit_continue(&resume_commit_id,
10444 3e3a69f1 2019-07-25 stsp &tmp_branch, &branch, &base_commit_id, &fileindex,
10445 3e3a69f1 2019-07-25 stsp worktree, repo);
10446 0ebf8283 2019-07-24 stsp if (error)
10447 0ebf8283 2019-07-24 stsp goto done;
10449 0ebf8283 2019-07-24 stsp error = got_ref_resolve(&head_commit_id, repo, branch);
10450 0ebf8283 2019-07-24 stsp if (error)
10451 0ebf8283 2019-07-24 stsp goto done;
10453 0ebf8283 2019-07-24 stsp error = got_object_open_as_commit(&commit, repo,
10454 0ebf8283 2019-07-24 stsp head_commit_id);
10455 0ebf8283 2019-07-24 stsp if (error)
10456 0ebf8283 2019-07-24 stsp goto done;
10457 0ebf8283 2019-07-24 stsp parent_ids = got_object_commit_get_parent_ids(commit);
10458 dbdddfee 2021-06-23 naddy pid = STAILQ_FIRST(parent_ids);
10459 3aac7cf7 2019-07-25 stsp if (pid == NULL) {
10460 3aac7cf7 2019-07-25 stsp error = got_error(GOT_ERR_EMPTY_HISTEDIT);
10461 3aac7cf7 2019-07-25 stsp goto done;
10463 8ca9bd68 2019-07-25 stsp error = collect_commits(&commits, head_commit_id, pid->id,
10464 8ca9bd68 2019-07-25 stsp base_commit_id, got_worktree_get_path_prefix(worktree),
10465 8ca9bd68 2019-07-25 stsp GOT_ERR_HISTEDIT_PATH, repo);
10466 0ebf8283 2019-07-24 stsp got_object_commit_close(commit);
10467 0ebf8283 2019-07-24 stsp commit = NULL;
10468 0ebf8283 2019-07-24 stsp if (error)
10469 0ebf8283 2019-07-24 stsp goto done;
10471 0ebf8283 2019-07-24 stsp if (edit_in_progress) {
10472 0ebf8283 2019-07-24 stsp error = got_error(GOT_ERR_HISTEDIT_BUSY);
10473 0ebf8283 2019-07-24 stsp goto done;
10476 0ebf8283 2019-07-24 stsp error = got_ref_open(&branch, repo,
10477 0ebf8283 2019-07-24 stsp got_worktree_get_head_ref_name(worktree), 0);
10478 0ebf8283 2019-07-24 stsp if (error != NULL)
10479 0ebf8283 2019-07-24 stsp goto done;
10481 c7d20a3f 2019-07-30 stsp if (strncmp(got_ref_get_name(branch), "refs/heads/", 11) != 0) {
10482 c7d20a3f 2019-07-30 stsp error = got_error_msg(GOT_ERR_COMMIT_BRANCH,
10483 c7d20a3f 2019-07-30 stsp "will not edit commit history of a branch outside "
10484 c7d20a3f 2019-07-30 stsp "the \"refs/heads/\" reference namespace");
10485 c7d20a3f 2019-07-30 stsp goto done;
10488 0ebf8283 2019-07-24 stsp error = got_ref_resolve(&head_commit_id, repo, branch);
10489 bfce7f83 2019-07-27 stsp got_ref_close(branch);
10490 bfce7f83 2019-07-27 stsp branch = NULL;
10491 0ebf8283 2019-07-24 stsp if (error)
10492 0ebf8283 2019-07-24 stsp goto done;
10494 0ebf8283 2019-07-24 stsp error = got_object_open_as_commit(&commit, repo,
10495 0ebf8283 2019-07-24 stsp head_commit_id);
10496 0ebf8283 2019-07-24 stsp if (error)
10497 0ebf8283 2019-07-24 stsp goto done;
10498 0ebf8283 2019-07-24 stsp parent_ids = got_object_commit_get_parent_ids(commit);
10499 dbdddfee 2021-06-23 naddy pid = STAILQ_FIRST(parent_ids);
10500 3aac7cf7 2019-07-25 stsp if (pid == NULL) {
10501 3aac7cf7 2019-07-25 stsp error = got_error(GOT_ERR_EMPTY_HISTEDIT);
10502 3aac7cf7 2019-07-25 stsp goto done;
10504 8ca9bd68 2019-07-25 stsp error = collect_commits(&commits, head_commit_id, pid->id,
10505 8ca9bd68 2019-07-25 stsp got_worktree_get_base_commit_id(worktree),
10506 8ca9bd68 2019-07-25 stsp got_worktree_get_path_prefix(worktree),
10507 8ca9bd68 2019-07-25 stsp GOT_ERR_HISTEDIT_PATH, repo);
10508 0ebf8283 2019-07-24 stsp got_object_commit_close(commit);
10509 0ebf8283 2019-07-24 stsp commit = NULL;
10510 0ebf8283 2019-07-24 stsp if (error)
10511 0ebf8283 2019-07-24 stsp goto done;
10513 dbdddfee 2021-06-23 naddy if (STAILQ_EMPTY(&commits)) {
10514 c5996fff 2020-01-29 stsp error = got_error(GOT_ERR_EMPTY_HISTEDIT);
10515 c5996fff 2020-01-29 stsp goto done;
10518 bfce7f83 2019-07-27 stsp error = got_worktree_histedit_prepare(&tmp_branch, &branch,
10519 bfce7f83 2019-07-27 stsp &base_commit_id, &fileindex, worktree, repo);
10520 bfce7f83 2019-07-27 stsp if (error)
10521 bfce7f83 2019-07-27 stsp goto done;
10523 0ebf8283 2019-07-24 stsp if (edit_script_path) {
10524 0ebf8283 2019-07-24 stsp error = histedit_load_list(&histedit_cmds,
10525 0ebf8283 2019-07-24 stsp edit_script_path, repo);
10526 6ba2bea2 2019-07-27 stsp if (error) {
10527 6ba2bea2 2019-07-27 stsp got_worktree_histedit_abort(worktree, fileindex,
10528 6ba2bea2 2019-07-27 stsp repo, branch, base_commit_id,
10529 41f061b2 2021-10-05 stsp abort_progress, &upa);
10530 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
10531 0ebf8283 2019-07-24 stsp goto done;
10534 514f2ffe 2020-01-29 stsp const char *branch_name;
10535 514f2ffe 2020-01-29 stsp branch_name = got_ref_get_symref_target(branch);
10536 514f2ffe 2020-01-29 stsp if (strncmp(branch_name, "refs/heads/", 11) == 0)
10537 514f2ffe 2020-01-29 stsp branch_name += 11;
10538 0ebf8283 2019-07-24 stsp error = histedit_edit_script(&histedit_cmds, &commits,
10539 b93c7142 2021-10-01 stsp branch_name, edit_logmsg_only, fold_only,
10540 b93c7142 2021-10-01 stsp edit_only, repo);
10541 6ba2bea2 2019-07-27 stsp if (error) {
10542 6ba2bea2 2019-07-27 stsp got_worktree_histedit_abort(worktree, fileindex,
10543 6ba2bea2 2019-07-27 stsp repo, branch, base_commit_id,
10544 41f061b2 2021-10-05 stsp abort_progress, &upa);
10545 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
10546 0ebf8283 2019-07-24 stsp goto done;
10551 0ebf8283 2019-07-24 stsp error = histedit_save_list(&histedit_cmds, worktree,
10553 6ba2bea2 2019-07-27 stsp if (error) {
10554 6ba2bea2 2019-07-27 stsp got_worktree_histedit_abort(worktree, fileindex,
10555 6ba2bea2 2019-07-27 stsp repo, branch, base_commit_id,
10556 41f061b2 2021-10-05 stsp abort_progress, &upa);
10557 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
10558 0ebf8283 2019-07-24 stsp goto done;
10563 4ec14e60 2019-08-28 hiltjo error = histedit_check_script(&histedit_cmds, &commits, repo);
10564 4ec14e60 2019-08-28 hiltjo if (error)
10565 0ebf8283 2019-07-24 stsp goto done;
10567 0ebf8283 2019-07-24 stsp TAILQ_FOREACH(hle, &histedit_cmds, entry) {
10568 0ebf8283 2019-07-24 stsp if (resume_commit_id) {
10569 0ebf8283 2019-07-24 stsp if (got_object_id_cmp(hle->commit_id,
10570 0ebf8283 2019-07-24 stsp resume_commit_id) != 0)
10571 0ebf8283 2019-07-24 stsp continue;
10573 0ebf8283 2019-07-24 stsp resume_commit_id = NULL;
10574 0ebf8283 2019-07-24 stsp if (hle->cmd->code == GOT_HISTEDIT_DROP ||
10575 0ebf8283 2019-07-24 stsp hle->cmd->code == GOT_HISTEDIT_FOLD) {
10576 0ebf8283 2019-07-24 stsp error = histedit_skip_commit(hle, worktree,
10578 ab20a43a 2020-01-29 stsp if (error)
10579 ab20a43a 2020-01-29 stsp goto done;
10581 ab20a43a 2020-01-29 stsp struct got_pathlist_head paths;
10582 ab20a43a 2020-01-29 stsp int have_changes = 0;
10584 ab20a43a 2020-01-29 stsp TAILQ_INIT(&paths);
10585 ab20a43a 2020-01-29 stsp error = got_pathlist_append(&paths, "", NULL);
10586 ab20a43a 2020-01-29 stsp if (error)
10587 ab20a43a 2020-01-29 stsp goto done;
10588 ab20a43a 2020-01-29 stsp error = got_worktree_status(worktree, &paths,
10589 f6343036 2021-06-22 stsp repo, 0, check_local_changes, &have_changes,
10590 ab20a43a 2020-01-29 stsp check_cancelled, NULL);
10591 ab20a43a 2020-01-29 stsp got_pathlist_free(&paths);
10592 ab20a43a 2020-01-29 stsp if (error) {
10593 ab20a43a 2020-01-29 stsp if (error->code != GOT_ERR_CANCELLED)
10594 ab20a43a 2020-01-29 stsp goto done;
10595 ab20a43a 2020-01-29 stsp if (sigint_received || sigpipe_received)
10596 ab20a43a 2020-01-29 stsp goto done;
10598 ab20a43a 2020-01-29 stsp if (have_changes) {
10599 ab20a43a 2020-01-29 stsp error = histedit_commit(NULL, worktree,
10600 ab20a43a 2020-01-29 stsp fileindex, tmp_branch, hle, repo);
10601 ab20a43a 2020-01-29 stsp if (error)
10602 ab20a43a 2020-01-29 stsp goto done;
10604 ab20a43a 2020-01-29 stsp error = got_object_open_as_commit(
10605 ab20a43a 2020-01-29 stsp &commit, repo, hle->commit_id);
10606 ab20a43a 2020-01-29 stsp if (error)
10607 ab20a43a 2020-01-29 stsp goto done;
10608 ab20a43a 2020-01-29 stsp error = show_histedit_progress(commit,
10609 ab20a43a 2020-01-29 stsp hle, NULL);
10610 ab20a43a 2020-01-29 stsp got_object_commit_close(commit);
10611 ab20a43a 2020-01-29 stsp commit = NULL;
10612 ab20a43a 2020-01-29 stsp if (error)
10613 ab20a43a 2020-01-29 stsp goto done;
10616 0ebf8283 2019-07-24 stsp continue;
10619 0ebf8283 2019-07-24 stsp if (hle->cmd->code == GOT_HISTEDIT_DROP) {
10620 0ebf8283 2019-07-24 stsp error = histedit_skip_commit(hle, worktree, repo);
10621 0ebf8283 2019-07-24 stsp if (error)
10622 0ebf8283 2019-07-24 stsp goto done;
10623 0ebf8283 2019-07-24 stsp continue;
10626 0ebf8283 2019-07-24 stsp error = got_object_open_as_commit(&commit, repo,
10627 0ebf8283 2019-07-24 stsp hle->commit_id);
10628 0ebf8283 2019-07-24 stsp if (error)
10629 0ebf8283 2019-07-24 stsp goto done;
10630 0ebf8283 2019-07-24 stsp parent_ids = got_object_commit_get_parent_ids(commit);
10631 dbdddfee 2021-06-23 naddy pid = STAILQ_FIRST(parent_ids);
10633 0ebf8283 2019-07-24 stsp error = got_worktree_histedit_merge_files(&merged_paths,
10634 3e3a69f1 2019-07-25 stsp worktree, fileindex, pid->id, hle->commit_id, repo,
10635 9627c110 2020-04-18 stsp update_progress, &upa, check_cancelled, NULL);
10636 0ebf8283 2019-07-24 stsp if (error)
10637 0ebf8283 2019-07-24 stsp goto done;
10638 0ebf8283 2019-07-24 stsp got_object_commit_close(commit);
10639 0ebf8283 2019-07-24 stsp commit = NULL;
10641 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
10642 cd33da48 2021-09-28 stsp if (upa.conflicts > 0 || upa.missing > 0 ||
10643 cd33da48 2021-09-28 stsp upa.not_deleted > 0 || upa.unversioned > 0) {
10644 cd33da48 2021-09-28 stsp if (upa.conflicts > 0) {
10645 cd33da48 2021-09-28 stsp error = show_rebase_merge_conflict(
10646 cd33da48 2021-09-28 stsp hle->commit_id, repo);
10647 cd33da48 2021-09-28 stsp if (error)
10648 cd33da48 2021-09-28 stsp goto done;
10650 0ebf8283 2019-07-24 stsp got_worktree_rebase_pathlist_free(&merged_paths);
10654 0ebf8283 2019-07-24 stsp if (hle->cmd->code == GOT_HISTEDIT_EDIT) {
10655 0ebf8283 2019-07-24 stsp char *id_str;
10656 0ebf8283 2019-07-24 stsp error = got_object_id_str(&id_str, hle->commit_id);
10657 0ebf8283 2019-07-24 stsp if (error)
10658 0ebf8283 2019-07-24 stsp goto done;
10659 0ebf8283 2019-07-24 stsp printf("Stopping histedit for amending commit %s\n",
10661 0ebf8283 2019-07-24 stsp free(id_str);
10662 0ebf8283 2019-07-24 stsp got_worktree_rebase_pathlist_free(&merged_paths);
10663 3e3a69f1 2019-07-25 stsp error = got_worktree_histedit_postpone(worktree,
10664 3e3a69f1 2019-07-25 stsp fileindex);
10665 0ebf8283 2019-07-24 stsp goto done;
10668 0ebf8283 2019-07-24 stsp if (hle->cmd->code == GOT_HISTEDIT_FOLD) {
10669 0ebf8283 2019-07-24 stsp error = histedit_skip_commit(hle, worktree, repo);
10670 0ebf8283 2019-07-24 stsp if (error)
10671 0ebf8283 2019-07-24 stsp goto done;
10672 0ebf8283 2019-07-24 stsp continue;
10675 3e3a69f1 2019-07-25 stsp error = histedit_commit(&merged_paths, worktree, fileindex,
10676 3e3a69f1 2019-07-25 stsp tmp_branch, hle, repo);
10677 0ebf8283 2019-07-24 stsp got_worktree_rebase_pathlist_free(&merged_paths);
10678 0ebf8283 2019-07-24 stsp if (error)
10679 0ebf8283 2019-07-24 stsp goto done;
10682 cd33da48 2021-09-28 stsp if (upa.conflicts > 0 || upa.missing > 0 ||
10683 cd33da48 2021-09-28 stsp upa.not_deleted > 0 || upa.unversioned > 0) {
10684 3e3a69f1 2019-07-25 stsp error = got_worktree_histedit_postpone(worktree, fileindex);
10685 0ebf8283 2019-07-24 stsp if (error)
10686 0ebf8283 2019-07-24 stsp goto done;
10687 cd33da48 2021-09-28 stsp if (upa.conflicts > 0 && upa.missing == 0 &&
10688 cd33da48 2021-09-28 stsp upa.not_deleted == 0 && upa.unversioned == 0) {
10689 cd33da48 2021-09-28 stsp error = got_error_msg(GOT_ERR_CONFLICTS,
10690 cd33da48 2021-09-28 stsp "conflicts must be resolved before histedit "
10691 cd33da48 2021-09-28 stsp "can continue");
10692 cd33da48 2021-09-28 stsp } else if (upa.conflicts > 0) {
10693 cd33da48 2021-09-28 stsp error = got_error_msg(GOT_ERR_CONFLICTS,
10694 cd33da48 2021-09-28 stsp "conflicts must be resolved before histedit "
10695 cd33da48 2021-09-28 stsp "can continue; changes destined for some "
10696 cd33da48 2021-09-28 stsp "files were not yet merged and should be "
10697 cd33da48 2021-09-28 stsp "merged manually if required before the "
10698 cd33da48 2021-09-28 stsp "histedit operation is continued");
10700 cd33da48 2021-09-28 stsp error = got_error_msg(GOT_ERR_CONFLICTS,
10701 cd33da48 2021-09-28 stsp "changes destined for some files were not "
10702 cd33da48 2021-09-28 stsp "yet merged and should be merged manually "
10703 cd33da48 2021-09-28 stsp "if required before the histedit operation "
10704 cd33da48 2021-09-28 stsp "is continued");
10707 3e3a69f1 2019-07-25 stsp error = histedit_complete(worktree, fileindex, tmp_branch,
10708 3e3a69f1 2019-07-25 stsp branch, repo);
10710 0ebf8283 2019-07-24 stsp got_object_id_queue_free(&commits);
10711 bfce7f83 2019-07-27 stsp histedit_free_list(&histedit_cmds);
10712 0ebf8283 2019-07-24 stsp free(head_commit_id);
10713 0ebf8283 2019-07-24 stsp free(base_commit_id);
10714 0ebf8283 2019-07-24 stsp free(resume_commit_id);
10715 0ebf8283 2019-07-24 stsp if (commit)
10716 0ebf8283 2019-07-24 stsp got_object_commit_close(commit);
10717 0ebf8283 2019-07-24 stsp if (branch)
10718 0ebf8283 2019-07-24 stsp got_ref_close(branch);
10719 0ebf8283 2019-07-24 stsp if (tmp_branch)
10720 0ebf8283 2019-07-24 stsp got_ref_close(tmp_branch);
10721 0ebf8283 2019-07-24 stsp if (worktree)
10722 0ebf8283 2019-07-24 stsp got_worktree_close(worktree);
10723 1d0f4054 2021-06-17 stsp if (repo) {
10724 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
10725 1d0f4054 2021-06-17 stsp if (error == NULL)
10726 1d0f4054 2021-06-17 stsp error = close_err;
10728 2822a352 2019-10-15 stsp return error;
10731 2822a352 2019-10-15 stsp __dead static void
10732 2822a352 2019-10-15 stsp usage_integrate(void)
10734 2822a352 2019-10-15 stsp fprintf(stderr, "usage: %s integrate branch\n", getprogname());
10738 2822a352 2019-10-15 stsp static const struct got_error *
10739 2822a352 2019-10-15 stsp cmd_integrate(int argc, char *argv[])
10741 2822a352 2019-10-15 stsp const struct got_error *error = NULL;
10742 2822a352 2019-10-15 stsp struct got_repository *repo = NULL;
10743 2822a352 2019-10-15 stsp struct got_worktree *worktree = NULL;
10744 2822a352 2019-10-15 stsp char *cwd = NULL, *refname = NULL, *base_refname = NULL;
10745 2822a352 2019-10-15 stsp const char *branch_arg = NULL;
10746 2822a352 2019-10-15 stsp struct got_reference *branch_ref = NULL, *base_branch_ref = NULL;
10747 2822a352 2019-10-15 stsp struct got_fileindex *fileindex = NULL;
10748 2822a352 2019-10-15 stsp struct got_object_id *commit_id = NULL, *base_commit_id = NULL;
10750 9627c110 2020-04-18 stsp struct got_update_progress_arg upa;
10752 2822a352 2019-10-15 stsp while ((ch = getopt(argc, argv, "")) != -1) {
10753 2822a352 2019-10-15 stsp switch (ch) {
10755 2822a352 2019-10-15 stsp usage_integrate();
10756 2822a352 2019-10-15 stsp /* NOTREACHED */
10760 2822a352 2019-10-15 stsp argc -= optind;
10761 2822a352 2019-10-15 stsp argv += optind;
10763 2822a352 2019-10-15 stsp if (argc != 1)
10764 2822a352 2019-10-15 stsp usage_integrate();
10765 2822a352 2019-10-15 stsp branch_arg = argv[0];
10766 b08a0ccd 2020-09-24 stsp #ifndef PROFILE
10767 2822a352 2019-10-15 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
10768 2822a352 2019-10-15 stsp "unveil", NULL) == -1)
10769 2822a352 2019-10-15 stsp err(1, "pledge");
10771 2822a352 2019-10-15 stsp cwd = getcwd(NULL, 0);
10772 2822a352 2019-10-15 stsp if (cwd == NULL) {
10773 2822a352 2019-10-15 stsp error = got_error_from_errno("getcwd");
10774 2822a352 2019-10-15 stsp goto done;
10777 2822a352 2019-10-15 stsp error = got_worktree_open(&worktree, cwd);
10778 fa51e947 2020-03-27 stsp if (error) {
10779 fa51e947 2020-03-27 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
10780 fa51e947 2020-03-27 stsp error = wrap_not_worktree_error(error, "integrate",
10782 2822a352 2019-10-15 stsp goto done;
10785 2822a352 2019-10-15 stsp error = check_rebase_or_histedit_in_progress(worktree);
10786 2822a352 2019-10-15 stsp if (error)
10787 2822a352 2019-10-15 stsp goto done;
10789 2822a352 2019-10-15 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
10791 2822a352 2019-10-15 stsp if (error != NULL)
10792 2822a352 2019-10-15 stsp goto done;
10794 2822a352 2019-10-15 stsp error = apply_unveil(got_repo_get_path(repo), 0,
10795 2822a352 2019-10-15 stsp got_worktree_get_root_path(worktree));
10796 2822a352 2019-10-15 stsp if (error)
10797 2822a352 2019-10-15 stsp goto done;
10799 f259c4c1 2021-09-24 stsp error = check_merge_in_progress(worktree, repo);
10800 f259c4c1 2021-09-24 stsp if (error)
10801 f259c4c1 2021-09-24 stsp goto done;
10803 2822a352 2019-10-15 stsp if (asprintf(&refname, "refs/heads/%s", branch_arg) == -1) {
10804 2822a352 2019-10-15 stsp error = got_error_from_errno("asprintf");
10805 2822a352 2019-10-15 stsp goto done;
10808 2822a352 2019-10-15 stsp error = got_worktree_integrate_prepare(&fileindex, &branch_ref,
10809 2822a352 2019-10-15 stsp &base_branch_ref, worktree, refname, repo);
10810 2822a352 2019-10-15 stsp if (error)
10811 2822a352 2019-10-15 stsp goto done;
10813 2822a352 2019-10-15 stsp refname = strdup(got_ref_get_name(branch_ref));
10814 2822a352 2019-10-15 stsp if (refname == NULL) {
10815 2822a352 2019-10-15 stsp error = got_error_from_errno("strdup");
10816 2822a352 2019-10-15 stsp got_worktree_integrate_abort(worktree, fileindex, repo,
10817 2822a352 2019-10-15 stsp branch_ref, base_branch_ref);
10818 2822a352 2019-10-15 stsp goto done;
10820 2822a352 2019-10-15 stsp base_refname = strdup(got_ref_get_name(base_branch_ref));
10821 2822a352 2019-10-15 stsp if (base_refname == NULL) {
10822 2822a352 2019-10-15 stsp error = got_error_from_errno("strdup");
10823 2822a352 2019-10-15 stsp got_worktree_integrate_abort(worktree, fileindex, repo,
10824 2822a352 2019-10-15 stsp branch_ref, base_branch_ref);
10825 2822a352 2019-10-15 stsp goto done;
10828 2822a352 2019-10-15 stsp error = got_ref_resolve(&commit_id, repo, branch_ref);
10829 2822a352 2019-10-15 stsp if (error)
10830 2822a352 2019-10-15 stsp goto done;
10832 2822a352 2019-10-15 stsp error = got_ref_resolve(&base_commit_id, repo, base_branch_ref);
10833 2822a352 2019-10-15 stsp if (error)
10834 2822a352 2019-10-15 stsp goto done;
10836 2822a352 2019-10-15 stsp if (got_object_id_cmp(commit_id, base_commit_id) == 0) {
10837 2822a352 2019-10-15 stsp error = got_error_msg(GOT_ERR_SAME_BRANCH,
10838 2822a352 2019-10-15 stsp "specified branch has already been integrated");
10839 2822a352 2019-10-15 stsp got_worktree_integrate_abort(worktree, fileindex, repo,
10840 2822a352 2019-10-15 stsp branch_ref, base_branch_ref);
10841 2822a352 2019-10-15 stsp goto done;
10844 3aef623b 2019-10-15 stsp error = check_linear_ancestry(commit_id, base_commit_id, 1, repo);
10845 2822a352 2019-10-15 stsp if (error) {
10846 2822a352 2019-10-15 stsp if (error->code == GOT_ERR_ANCESTRY)
10847 2822a352 2019-10-15 stsp error = got_error(GOT_ERR_REBASE_REQUIRED);
10848 2822a352 2019-10-15 stsp got_worktree_integrate_abort(worktree, fileindex, repo,
10849 2822a352 2019-10-15 stsp branch_ref, base_branch_ref);
10850 2822a352 2019-10-15 stsp goto done;
10853 9627c110 2020-04-18 stsp memset(&upa, 0, sizeof(upa));
10854 2822a352 2019-10-15 stsp error = got_worktree_integrate_continue(worktree, fileindex, repo,
10855 9627c110 2020-04-18 stsp branch_ref, base_branch_ref, update_progress, &upa,
10856 2822a352 2019-10-15 stsp check_cancelled, NULL);
10857 2822a352 2019-10-15 stsp if (error)
10858 2822a352 2019-10-15 stsp goto done;
10860 2822a352 2019-10-15 stsp printf("Integrated %s into %s\n", refname, base_refname);
10861 9627c110 2020-04-18 stsp print_update_progress_stats(&upa);
10863 1d0f4054 2021-06-17 stsp if (repo) {
10864 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
10865 1d0f4054 2021-06-17 stsp if (error == NULL)
10866 1d0f4054 2021-06-17 stsp error = close_err;
10868 2822a352 2019-10-15 stsp if (worktree)
10869 2822a352 2019-10-15 stsp got_worktree_close(worktree);
10870 2822a352 2019-10-15 stsp free(cwd);
10871 2822a352 2019-10-15 stsp free(base_commit_id);
10872 2822a352 2019-10-15 stsp free(commit_id);
10873 2822a352 2019-10-15 stsp free(refname);
10874 2822a352 2019-10-15 stsp free(base_refname);
10875 f259c4c1 2021-09-24 stsp return error;
10878 f259c4c1 2021-09-24 stsp __dead static void
10879 f259c4c1 2021-09-24 stsp usage_merge(void)
10881 088449d3 2021-09-26 stsp fprintf(stderr, "usage: %s merge [-a] [-c] [-n] [branch]\n",
10882 f259c4c1 2021-09-24 stsp getprogname());
10886 f259c4c1 2021-09-24 stsp static const struct got_error *
10887 f259c4c1 2021-09-24 stsp cmd_merge(int argc, char *argv[])
10889 f259c4c1 2021-09-24 stsp const struct got_error *error = NULL;
10890 f259c4c1 2021-09-24 stsp struct got_worktree *worktree = NULL;
10891 f259c4c1 2021-09-24 stsp struct got_repository *repo = NULL;
10892 f259c4c1 2021-09-24 stsp struct got_fileindex *fileindex = NULL;
10893 f259c4c1 2021-09-24 stsp char *cwd = NULL, *id_str = NULL, *author = NULL;
10894 f259c4c1 2021-09-24 stsp struct got_reference *branch = NULL, *wt_branch = NULL;
10895 f259c4c1 2021-09-24 stsp struct got_object_id *branch_tip = NULL, *yca_id = NULL;
10896 f259c4c1 2021-09-24 stsp struct got_object_id *wt_branch_tip = NULL;
10897 f259c4c1 2021-09-24 stsp int ch, merge_in_progress = 0, abort_merge = 0, continue_merge = 0;
10898 088449d3 2021-09-26 stsp int interrupt_merge = 0;
10899 f259c4c1 2021-09-24 stsp struct got_update_progress_arg upa;
10900 f259c4c1 2021-09-24 stsp struct got_object_id *merge_commit_id = NULL;
10901 f259c4c1 2021-09-24 stsp char *branch_name = NULL;
10903 f259c4c1 2021-09-24 stsp memset(&upa, 0, sizeof(upa));
10905 088449d3 2021-09-26 stsp while ((ch = getopt(argc, argv, "acn")) != -1) {
10906 f259c4c1 2021-09-24 stsp switch (ch) {
10907 f259c4c1 2021-09-24 stsp case 'a':
10908 f259c4c1 2021-09-24 stsp abort_merge = 1;
10910 f259c4c1 2021-09-24 stsp case 'c':
10911 f259c4c1 2021-09-24 stsp continue_merge = 1;
10913 088449d3 2021-09-26 stsp case 'n':
10914 088449d3 2021-09-26 stsp interrupt_merge = 1;
10917 f259c4c1 2021-09-24 stsp usage_rebase();
10918 f259c4c1 2021-09-24 stsp /* NOTREACHED */
10922 f259c4c1 2021-09-24 stsp argc -= optind;
10923 f259c4c1 2021-09-24 stsp argv += optind;
10925 f259c4c1 2021-09-24 stsp #ifndef PROFILE
10926 f259c4c1 2021-09-24 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
10927 f259c4c1 2021-09-24 stsp "unveil", NULL) == -1)
10928 f259c4c1 2021-09-24 stsp err(1, "pledge");
10931 f259c4c1 2021-09-24 stsp if (abort_merge && continue_merge)
10932 f259c4c1 2021-09-24 stsp option_conflict('a', 'c');
10933 f259c4c1 2021-09-24 stsp if (abort_merge || continue_merge) {
10934 f259c4c1 2021-09-24 stsp if (argc != 0)
10935 f259c4c1 2021-09-24 stsp usage_merge();
10936 f259c4c1 2021-09-24 stsp } else if (argc != 1)
10937 f259c4c1 2021-09-24 stsp usage_merge();
10939 f259c4c1 2021-09-24 stsp cwd = getcwd(NULL, 0);
10940 f259c4c1 2021-09-24 stsp if (cwd == NULL) {
10941 f259c4c1 2021-09-24 stsp error = got_error_from_errno("getcwd");
10942 f259c4c1 2021-09-24 stsp goto done;
10945 f259c4c1 2021-09-24 stsp error = got_worktree_open(&worktree, cwd);
10946 f259c4c1 2021-09-24 stsp if (error) {
10947 f259c4c1 2021-09-24 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
10948 f259c4c1 2021-09-24 stsp error = wrap_not_worktree_error(error,
10949 f259c4c1 2021-09-24 stsp "merge", cwd);
10950 f259c4c1 2021-09-24 stsp goto done;
10953 f259c4c1 2021-09-24 stsp error = got_repo_open(&repo,
10954 f259c4c1 2021-09-24 stsp worktree ? got_worktree_get_repo_path(worktree) : cwd, NULL);
10955 f259c4c1 2021-09-24 stsp if (error != NULL)
10956 f259c4c1 2021-09-24 stsp goto done;
10958 f259c4c1 2021-09-24 stsp error = apply_unveil(got_repo_get_path(repo), 0,
10959 f259c4c1 2021-09-24 stsp worktree ? got_worktree_get_root_path(worktree) : NULL);
10960 f259c4c1 2021-09-24 stsp if (error)
10961 f259c4c1 2021-09-24 stsp goto done;
10963 f259c4c1 2021-09-24 stsp error = check_rebase_or_histedit_in_progress(worktree);
10964 f259c4c1 2021-09-24 stsp if (error)
10965 f259c4c1 2021-09-24 stsp goto done;
10967 f259c4c1 2021-09-24 stsp error = got_worktree_merge_in_progress(&merge_in_progress, worktree,
10969 f259c4c1 2021-09-24 stsp if (error)
10970 f259c4c1 2021-09-24 stsp goto done;
10972 f259c4c1 2021-09-24 stsp if (abort_merge) {
10973 f259c4c1 2021-09-24 stsp if (!merge_in_progress) {
10974 f259c4c1 2021-09-24 stsp error = got_error(GOT_ERR_NOT_MERGING);
10975 f259c4c1 2021-09-24 stsp goto done;
10977 f259c4c1 2021-09-24 stsp error = got_worktree_merge_continue(&branch_name,
10978 f259c4c1 2021-09-24 stsp &branch_tip, &fileindex, worktree, repo);
10979 f259c4c1 2021-09-24 stsp if (error)
10980 f259c4c1 2021-09-24 stsp goto done;
10981 f259c4c1 2021-09-24 stsp error = got_worktree_merge_abort(worktree, fileindex, repo,
10982 41f061b2 2021-10-05 stsp abort_progress, &upa);
10983 f259c4c1 2021-09-24 stsp if (error)
10984 f259c4c1 2021-09-24 stsp goto done;
10985 f259c4c1 2021-09-24 stsp printf("Merge of %s aborted\n", branch_name);
10986 f259c4c1 2021-09-24 stsp goto done; /* nothing else to do */
10989 f259c4c1 2021-09-24 stsp error = get_author(&author, repo, worktree);
10990 f259c4c1 2021-09-24 stsp if (error)
10991 f259c4c1 2021-09-24 stsp goto done;
10993 f259c4c1 2021-09-24 stsp if (continue_merge) {
10994 f259c4c1 2021-09-24 stsp if (!merge_in_progress) {
10995 f259c4c1 2021-09-24 stsp error = got_error(GOT_ERR_NOT_MERGING);
10996 f259c4c1 2021-09-24 stsp goto done;
10998 f259c4c1 2021-09-24 stsp error = got_worktree_merge_continue(&branch_name,
10999 f259c4c1 2021-09-24 stsp &branch_tip, &fileindex, worktree, repo);
11000 f259c4c1 2021-09-24 stsp if (error)
11001 f259c4c1 2021-09-24 stsp goto done;
11003 f259c4c1 2021-09-24 stsp error = got_ref_open(&branch, repo, argv[0], 0);
11004 f259c4c1 2021-09-24 stsp if (error != NULL)
11005 f259c4c1 2021-09-24 stsp goto done;
11006 f259c4c1 2021-09-24 stsp branch_name = strdup(got_ref_get_name(branch));
11007 f259c4c1 2021-09-24 stsp if (branch_name == NULL) {
11008 f259c4c1 2021-09-24 stsp error = got_error_from_errno("strdup");
11009 f259c4c1 2021-09-24 stsp goto done;
11011 f259c4c1 2021-09-24 stsp error = got_ref_resolve(&branch_tip, repo, branch);
11012 f259c4c1 2021-09-24 stsp if (error)
11013 f259c4c1 2021-09-24 stsp goto done;
11016 f259c4c1 2021-09-24 stsp error = got_ref_open(&wt_branch, repo,
11017 f259c4c1 2021-09-24 stsp got_worktree_get_head_ref_name(worktree), 0);
11018 f259c4c1 2021-09-24 stsp if (error)
11019 f259c4c1 2021-09-24 stsp goto done;
11020 f259c4c1 2021-09-24 stsp error = got_ref_resolve(&wt_branch_tip, repo, wt_branch);
11021 f259c4c1 2021-09-24 stsp if (error)
11022 f259c4c1 2021-09-24 stsp goto done;
11023 f259c4c1 2021-09-24 stsp error = got_commit_graph_find_youngest_common_ancestor(&yca_id,
11024 4e91ef15 2021-09-26 stsp wt_branch_tip, branch_tip, 0, repo,
11025 f259c4c1 2021-09-24 stsp check_cancelled, NULL);
11026 4e91ef15 2021-09-26 stsp if (error && error->code != GOT_ERR_ANCESTRY)
11027 f259c4c1 2021-09-24 stsp goto done;
11029 f259c4c1 2021-09-24 stsp if (!continue_merge) {
11030 f259c4c1 2021-09-24 stsp error = check_path_prefix(wt_branch_tip, branch_tip,
11031 f259c4c1 2021-09-24 stsp got_worktree_get_path_prefix(worktree),
11032 f259c4c1 2021-09-24 stsp GOT_ERR_MERGE_PATH, repo);
11033 f259c4c1 2021-09-24 stsp if (error)
11034 f259c4c1 2021-09-24 stsp goto done;
11035 4e91ef15 2021-09-26 stsp if (yca_id) {
11036 4e91ef15 2021-09-26 stsp error = check_same_branch(wt_branch_tip, branch,
11037 4e91ef15 2021-09-26 stsp yca_id, repo);
11038 4e91ef15 2021-09-26 stsp if (error) {
11039 4e91ef15 2021-09-26 stsp if (error->code != GOT_ERR_ANCESTRY)
11040 4e91ef15 2021-09-26 stsp goto done;
11041 4e91ef15 2021-09-26 stsp error = NULL;
11043 4e91ef15 2021-09-26 stsp static char msg[512];
11044 4e91ef15 2021-09-26 stsp snprintf(msg, sizeof(msg),
11045 4e91ef15 2021-09-26 stsp "cannot create a merge commit because "
11046 4e91ef15 2021-09-26 stsp "%s is based on %s; %s can be integrated "
11047 4e91ef15 2021-09-26 stsp "with 'got integrate' instead", branch_name,
11048 4e91ef15 2021-09-26 stsp got_worktree_get_head_ref_name(worktree),
11049 4e91ef15 2021-09-26 stsp branch_name);
11050 4e91ef15 2021-09-26 stsp error = got_error_msg(GOT_ERR_SAME_BRANCH, msg);
11051 f259c4c1 2021-09-24 stsp goto done;
11054 f259c4c1 2021-09-24 stsp error = got_worktree_merge_prepare(&fileindex, worktree,
11055 f259c4c1 2021-09-24 stsp branch, repo);
11056 f259c4c1 2021-09-24 stsp if (error)
11057 f259c4c1 2021-09-24 stsp goto done;
11059 f259c4c1 2021-09-24 stsp error = got_worktree_merge_branch(worktree, fileindex,
11060 f259c4c1 2021-09-24 stsp yca_id, branch_tip, repo, update_progress, &upa,
11061 f259c4c1 2021-09-24 stsp check_cancelled, NULL);
11062 f259c4c1 2021-09-24 stsp if (error)
11063 f259c4c1 2021-09-24 stsp goto done;
11064 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
11065 4e91ef15 2021-09-26 stsp if (!upa.did_something) {
11066 4e91ef15 2021-09-26 stsp error = got_worktree_merge_abort(worktree, fileindex,
11067 41f061b2 2021-10-05 stsp repo, abort_progress, &upa);
11068 4e91ef15 2021-09-26 stsp if (error)
11069 4e91ef15 2021-09-26 stsp goto done;
11070 4e91ef15 2021-09-26 stsp printf("Already up-to-date\n");
11071 4e91ef15 2021-09-26 stsp goto done;
11075 088449d3 2021-09-26 stsp if (interrupt_merge) {
11076 f259c4c1 2021-09-24 stsp error = got_worktree_merge_postpone(worktree, fileindex);
11077 f259c4c1 2021-09-24 stsp if (error)
11078 f259c4c1 2021-09-24 stsp goto done;
11079 088449d3 2021-09-26 stsp printf("Merge of %s interrupted on request\n", branch_name);
11080 c1b05723 2021-09-28 stsp } else if (upa.conflicts > 0 || upa.missing > 0 ||
11081 c1b05723 2021-09-28 stsp upa.not_deleted > 0 || upa.unversioned > 0) {
11082 088449d3 2021-09-26 stsp error = got_worktree_merge_postpone(worktree, fileindex);
11083 088449d3 2021-09-26 stsp if (error)
11084 088449d3 2021-09-26 stsp goto done;
11085 c1b05723 2021-09-28 stsp if (upa.conflicts > 0 && upa.missing == 0 &&
11086 c1b05723 2021-09-28 stsp upa.not_deleted == 0 && upa.unversioned == 0) {
11087 f259c4c1 2021-09-24 stsp error = got_error_msg(GOT_ERR_CONFLICTS,
11088 f259c4c1 2021-09-24 stsp "conflicts must be resolved before merging "
11089 f259c4c1 2021-09-24 stsp "can continue");
11090 f259c4c1 2021-09-24 stsp } else if (upa.conflicts > 0) {
11091 f259c4c1 2021-09-24 stsp error = got_error_msg(GOT_ERR_CONFLICTS,
11092 f259c4c1 2021-09-24 stsp "conflicts must be resolved before merging "
11093 c1b05723 2021-09-28 stsp "can continue; changes destined for some "
11094 1acd48bc 2021-09-24 stsp "files were not yet merged and "
11095 f259c4c1 2021-09-24 stsp "should be merged manually if required before the "
11096 f259c4c1 2021-09-24 stsp "merge operation is continued");
11098 f259c4c1 2021-09-24 stsp error = got_error_msg(GOT_ERR_CONFLICTS,
11099 c1b05723 2021-09-28 stsp "changes destined for some "
11100 f259c4c1 2021-09-24 stsp "files were not yet merged and should be "
11101 f259c4c1 2021-09-24 stsp "merged manually if required before the "
11102 f259c4c1 2021-09-24 stsp "merge operation is continued");
11104 f259c4c1 2021-09-24 stsp goto done;
11106 f259c4c1 2021-09-24 stsp error = got_worktree_merge_commit(&merge_commit_id, worktree,
11107 0ff8d236 2021-09-28 stsp fileindex, author, NULL, 1, branch_tip, branch_name,
11108 0ff8d236 2021-09-28 stsp repo, continue_merge ? print_status : NULL, NULL);
11109 f259c4c1 2021-09-24 stsp if (error)
11110 f259c4c1 2021-09-24 stsp goto done;
11111 f259c4c1 2021-09-24 stsp error = got_worktree_merge_complete(worktree, fileindex, repo);
11112 f259c4c1 2021-09-24 stsp if (error)
11113 f259c4c1 2021-09-24 stsp goto done;
11114 f259c4c1 2021-09-24 stsp error = got_object_id_str(&id_str, merge_commit_id);
11115 f259c4c1 2021-09-24 stsp if (error)
11116 f259c4c1 2021-09-24 stsp goto done;
11117 f259c4c1 2021-09-24 stsp printf("Merged %s into %s: %s\n", branch_name,
11118 f259c4c1 2021-09-24 stsp got_worktree_get_head_ref_name(worktree),
11123 f259c4c1 2021-09-24 stsp free(id_str);
11124 f259c4c1 2021-09-24 stsp free(merge_commit_id);
11125 f259c4c1 2021-09-24 stsp free(author);
11126 f259c4c1 2021-09-24 stsp free(branch_tip);
11127 f259c4c1 2021-09-24 stsp free(branch_name);
11128 f259c4c1 2021-09-24 stsp free(yca_id);
11129 f259c4c1 2021-09-24 stsp if (branch)
11130 f259c4c1 2021-09-24 stsp got_ref_close(branch);
11131 f259c4c1 2021-09-24 stsp if (wt_branch)
11132 f259c4c1 2021-09-24 stsp got_ref_close(wt_branch);
11133 f259c4c1 2021-09-24 stsp if (worktree)
11134 f259c4c1 2021-09-24 stsp got_worktree_close(worktree);
11135 f259c4c1 2021-09-24 stsp if (repo) {
11136 f259c4c1 2021-09-24 stsp const struct got_error *close_err = got_repo_close(repo);
11137 f259c4c1 2021-09-24 stsp if (error == NULL)
11138 f259c4c1 2021-09-24 stsp error = close_err;
11140 715dc77e 2019-08-03 stsp return error;
11143 715dc77e 2019-08-03 stsp __dead static void
11144 715dc77e 2019-08-03 stsp usage_stage(void)
11146 f3055044 2019-08-07 stsp fprintf(stderr, "usage: %s stage [-l] | [-p] [-F response-script] "
11147 35213c7c 2020-07-23 stsp "[-S] [file-path ...]\n",
11148 715dc77e 2019-08-03 stsp getprogname());
11152 715dc77e 2019-08-03 stsp static const struct got_error *
11153 408b4ebc 2019-08-03 stsp print_stage(void *arg, unsigned char status, unsigned char staged_status,
11154 408b4ebc 2019-08-03 stsp const char *path, struct got_object_id *blob_id,
11155 12463d8b 2019-12-13 stsp struct got_object_id *staged_blob_id, struct got_object_id *commit_id,
11156 12463d8b 2019-12-13 stsp int dirfd, const char *de_name)
11158 408b4ebc 2019-08-03 stsp const struct got_error *err = NULL;
11159 408b4ebc 2019-08-03 stsp char *id_str = NULL;
11161 408b4ebc 2019-08-03 stsp if (staged_status != GOT_STATUS_ADD &&
11162 408b4ebc 2019-08-03 stsp staged_status != GOT_STATUS_MODIFY &&
11163 408b4ebc 2019-08-03 stsp staged_status != GOT_STATUS_DELETE)
11164 408b4ebc 2019-08-03 stsp return NULL;
11166 408b4ebc 2019-08-03 stsp if (staged_status == GOT_STATUS_ADD ||
11167 408b4ebc 2019-08-03 stsp staged_status == GOT_STATUS_MODIFY)
11168 408b4ebc 2019-08-03 stsp err = got_object_id_str(&id_str, staged_blob_id);
11170 408b4ebc 2019-08-03 stsp err = got_object_id_str(&id_str, blob_id);
11172 408b4ebc 2019-08-03 stsp return err;
11174 408b4ebc 2019-08-03 stsp printf("%s %c %s\n", id_str, staged_status, path);
11175 408b4ebc 2019-08-03 stsp free(id_str);
11176 dc424a06 2019-08-07 stsp return NULL;
11179 dc424a06 2019-08-07 stsp static const struct got_error *
11180 715dc77e 2019-08-03 stsp cmd_stage(int argc, char *argv[])
11182 715dc77e 2019-08-03 stsp const struct got_error *error = NULL;
11183 715dc77e 2019-08-03 stsp struct got_repository *repo = NULL;
11184 715dc77e 2019-08-03 stsp struct got_worktree *worktree = NULL;
11185 715dc77e 2019-08-03 stsp char *cwd = NULL;
11186 715dc77e 2019-08-03 stsp struct got_pathlist_head paths;
11187 715dc77e 2019-08-03 stsp struct got_pathlist_entry *pe;
11188 35213c7c 2020-07-23 stsp int ch, list_stage = 0, pflag = 0, allow_bad_symlinks = 0;
11189 dc424a06 2019-08-07 stsp FILE *patch_script_file = NULL;
11190 2e1f37b0 2019-08-08 stsp const char *patch_script_path = NULL;
11191 2e1f37b0 2019-08-08 stsp struct choose_patch_arg cpa;
11193 715dc77e 2019-08-03 stsp TAILQ_INIT(&paths);
11195 35213c7c 2020-07-23 stsp while ((ch = getopt(argc, argv, "lpF:S")) != -1) {
11196 715dc77e 2019-08-03 stsp switch (ch) {
11197 408b4ebc 2019-08-03 stsp case 'l':
11198 408b4ebc 2019-08-03 stsp list_stage = 1;
11200 dc424a06 2019-08-07 stsp case 'p':
11201 dc424a06 2019-08-07 stsp pflag = 1;
11203 dc424a06 2019-08-07 stsp case 'F':
11204 dc424a06 2019-08-07 stsp patch_script_path = optarg;
11206 35213c7c 2020-07-23 stsp case 'S':
11207 35213c7c 2020-07-23 stsp allow_bad_symlinks = 1;
11210 715dc77e 2019-08-03 stsp usage_stage();
11211 715dc77e 2019-08-03 stsp /* NOTREACHED */
11215 715dc77e 2019-08-03 stsp argc -= optind;
11216 715dc77e 2019-08-03 stsp argv += optind;
11218 715dc77e 2019-08-03 stsp #ifndef PROFILE
11219 715dc77e 2019-08-03 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
11220 715dc77e 2019-08-03 stsp "unveil", NULL) == -1)
11221 715dc77e 2019-08-03 stsp err(1, "pledge");
11223 2db2652d 2019-08-07 stsp if (list_stage && (pflag || patch_script_path))
11224 2db2652d 2019-08-07 stsp errx(1, "-l option cannot be used with other options");
11225 dc424a06 2019-08-07 stsp if (patch_script_path && !pflag)
11226 dc424a06 2019-08-07 stsp errx(1, "-F option can only be used together with -p option");
11228 715dc77e 2019-08-03 stsp cwd = getcwd(NULL, 0);
11229 715dc77e 2019-08-03 stsp if (cwd == NULL) {
11230 715dc77e 2019-08-03 stsp error = got_error_from_errno("getcwd");
11231 715dc77e 2019-08-03 stsp goto done;
11234 715dc77e 2019-08-03 stsp error = got_worktree_open(&worktree, cwd);
11235 fa51e947 2020-03-27 stsp if (error) {
11236 fa51e947 2020-03-27 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
11237 fa51e947 2020-03-27 stsp error = wrap_not_worktree_error(error, "stage", cwd);
11238 715dc77e 2019-08-03 stsp goto done;
11241 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
11243 715dc77e 2019-08-03 stsp if (error != NULL)
11244 715dc77e 2019-08-03 stsp goto done;
11246 dc424a06 2019-08-07 stsp if (patch_script_path) {
11247 00fe21f2 2021-12-31 stsp patch_script_file = fopen(patch_script_path, "re");
11248 dc424a06 2019-08-07 stsp if (patch_script_file == NULL) {
11249 dc424a06 2019-08-07 stsp error = got_error_from_errno2("fopen",
11250 dc424a06 2019-08-07 stsp patch_script_path);
11251 dc424a06 2019-08-07 stsp goto done;
11254 9fd7cd22 2019-08-30 stsp error = apply_unveil(got_repo_get_path(repo), 0,
11255 715dc77e 2019-08-03 stsp got_worktree_get_root_path(worktree));
11256 715dc77e 2019-08-03 stsp if (error)
11257 715dc77e 2019-08-03 stsp goto done;
11259 f259c4c1 2021-09-24 stsp error = check_merge_in_progress(worktree, repo);
11260 f259c4c1 2021-09-24 stsp if (error)
11261 f259c4c1 2021-09-24 stsp goto done;
11263 6d022e97 2019-08-04 stsp error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
11264 6d022e97 2019-08-04 stsp if (error)
11265 6d022e97 2019-08-04 stsp goto done;
11267 6d022e97 2019-08-04 stsp if (list_stage)
11268 f6343036 2021-06-22 stsp error = got_worktree_status(worktree, &paths, repo, 0,
11269 408b4ebc 2019-08-03 stsp print_stage, NULL, check_cancelled, NULL);
11271 2e1f37b0 2019-08-08 stsp cpa.patch_script_file = patch_script_file;
11272 2e1f37b0 2019-08-08 stsp cpa.action = "stage";
11273 dc424a06 2019-08-07 stsp error = got_worktree_stage(worktree, &paths,
11274 dc424a06 2019-08-07 stsp pflag ? NULL : print_status, NULL,
11275 35213c7c 2020-07-23 stsp pflag ? choose_patch : NULL, &cpa,
11276 35213c7c 2020-07-23 stsp allow_bad_symlinks, repo);
11279 2e1f37b0 2019-08-08 stsp if (patch_script_file && fclose(patch_script_file) == EOF &&
11280 2e1f37b0 2019-08-08 stsp error == NULL)
11281 2e1f37b0 2019-08-08 stsp error = got_error_from_errno2("fclose", patch_script_path);
11282 1d0f4054 2021-06-17 stsp if (repo) {
11283 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
11284 1d0f4054 2021-06-17 stsp if (error == NULL)
11285 1d0f4054 2021-06-17 stsp error = close_err;
11287 ad493afc 2019-08-03 stsp if (worktree)
11288 ad493afc 2019-08-03 stsp got_worktree_close(worktree);
11289 ad493afc 2019-08-03 stsp TAILQ_FOREACH(pe, &paths, entry)
11290 ad493afc 2019-08-03 stsp free((char *)pe->path);
11291 ad493afc 2019-08-03 stsp got_pathlist_free(&paths);
11292 ad493afc 2019-08-03 stsp free(cwd);
11293 ad493afc 2019-08-03 stsp return error;
11296 ad493afc 2019-08-03 stsp __dead static void
11297 ad493afc 2019-08-03 stsp usage_unstage(void)
11299 2e1f37b0 2019-08-08 stsp fprintf(stderr, "usage: %s unstage [-p] [-F response-script] "
11300 2e1f37b0 2019-08-08 stsp "[file-path ...]\n",
11301 ad493afc 2019-08-03 stsp getprogname());
11306 ad493afc 2019-08-03 stsp static const struct got_error *
11307 ad493afc 2019-08-03 stsp cmd_unstage(int argc, char *argv[])
11309 ad493afc 2019-08-03 stsp const struct got_error *error = NULL;
11310 ad493afc 2019-08-03 stsp struct got_repository *repo = NULL;
11311 ad493afc 2019-08-03 stsp struct got_worktree *worktree = NULL;
11312 ad493afc 2019-08-03 stsp char *cwd = NULL;
11313 ad493afc 2019-08-03 stsp struct got_pathlist_head paths;
11314 ad493afc 2019-08-03 stsp struct got_pathlist_entry *pe;
11315 9627c110 2020-04-18 stsp int ch, pflag = 0;
11316 9627c110 2020-04-18 stsp struct got_update_progress_arg upa;
11317 2e1f37b0 2019-08-08 stsp FILE *patch_script_file = NULL;
11318 2e1f37b0 2019-08-08 stsp const char *patch_script_path = NULL;
11319 2e1f37b0 2019-08-08 stsp struct choose_patch_arg cpa;
11321 ad493afc 2019-08-03 stsp TAILQ_INIT(&paths);
11323 2e1f37b0 2019-08-08 stsp while ((ch = getopt(argc, argv, "pF:")) != -1) {
11324 ad493afc 2019-08-03 stsp switch (ch) {
11325 2e1f37b0 2019-08-08 stsp case 'p':
11326 2e1f37b0 2019-08-08 stsp pflag = 1;
11328 2e1f37b0 2019-08-08 stsp case 'F':
11329 2e1f37b0 2019-08-08 stsp patch_script_path = optarg;
11332 ad493afc 2019-08-03 stsp usage_unstage();
11333 ad493afc 2019-08-03 stsp /* NOTREACHED */
11337 ad493afc 2019-08-03 stsp argc -= optind;
11338 ad493afc 2019-08-03 stsp argv += optind;
11340 ad493afc 2019-08-03 stsp #ifndef PROFILE
11341 ad493afc 2019-08-03 stsp if (pledge("stdio rpath wpath cpath fattr flock proc exec sendfd "
11342 ad493afc 2019-08-03 stsp "unveil", NULL) == -1)
11343 ad493afc 2019-08-03 stsp err(1, "pledge");
11345 2e1f37b0 2019-08-08 stsp if (patch_script_path && !pflag)
11346 2e1f37b0 2019-08-08 stsp errx(1, "-F option can only be used together with -p option");
11348 ad493afc 2019-08-03 stsp cwd = getcwd(NULL, 0);
11349 ad493afc 2019-08-03 stsp if (cwd == NULL) {
11350 ad493afc 2019-08-03 stsp error = got_error_from_errno("getcwd");
11351 ad493afc 2019-08-03 stsp goto done;
11354 ad493afc 2019-08-03 stsp error = got_worktree_open(&worktree, cwd);
11355 fa51e947 2020-03-27 stsp if (error) {
11356 fa51e947 2020-03-27 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
11357 fa51e947 2020-03-27 stsp error = wrap_not_worktree_error(error, "unstage", cwd);
11358 ad493afc 2019-08-03 stsp goto done;
11361 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, got_worktree_get_repo_path(worktree),
11363 ad493afc 2019-08-03 stsp if (error != NULL)
11364 ad493afc 2019-08-03 stsp goto done;
11366 2e1f37b0 2019-08-08 stsp if (patch_script_path) {
11367 00fe21f2 2021-12-31 stsp patch_script_file = fopen(patch_script_path, "re");
11368 2e1f37b0 2019-08-08 stsp if (patch_script_file == NULL) {
11369 2e1f37b0 2019-08-08 stsp error = got_error_from_errno2("fopen",
11370 2e1f37b0 2019-08-08 stsp patch_script_path);
11371 2e1f37b0 2019-08-08 stsp goto done;
11375 00f36e47 2019-09-06 stsp error = apply_unveil(got_repo_get_path(repo), 0,
11376 ad493afc 2019-08-03 stsp got_worktree_get_root_path(worktree));
11377 ad493afc 2019-08-03 stsp if (error)
11378 ad493afc 2019-08-03 stsp goto done;
11380 ad493afc 2019-08-03 stsp error = get_worktree_paths_from_argv(&paths, argc, argv, worktree);
11381 ad493afc 2019-08-03 stsp if (error)
11382 ad493afc 2019-08-03 stsp goto done;
11384 2e1f37b0 2019-08-08 stsp cpa.patch_script_file = patch_script_file;
11385 2e1f37b0 2019-08-08 stsp cpa.action = "unstage";
11386 9627c110 2020-04-18 stsp memset(&upa, 0, sizeof(upa));
11387 ad493afc 2019-08-03 stsp error = got_worktree_unstage(worktree, &paths, update_progress,
11388 9627c110 2020-04-18 stsp &upa, pflag ? choose_patch : NULL, &cpa, repo);
11389 9627c110 2020-04-18 stsp if (!error)
11390 35ca1db7 2021-09-28 stsp print_merge_progress_stats(&upa);
11392 2e1f37b0 2019-08-08 stsp if (patch_script_file && fclose(patch_script_file) == EOF &&
11393 2e1f37b0 2019-08-08 stsp error == NULL)
11394 2e1f37b0 2019-08-08 stsp error = got_error_from_errno2("fclose", patch_script_path);
11395 1d0f4054 2021-06-17 stsp if (repo) {
11396 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
11397 1d0f4054 2021-06-17 stsp if (error == NULL)
11398 1d0f4054 2021-06-17 stsp error = close_err;
11400 715dc77e 2019-08-03 stsp if (worktree)
11401 715dc77e 2019-08-03 stsp got_worktree_close(worktree);
11402 715dc77e 2019-08-03 stsp TAILQ_FOREACH(pe, &paths, entry)
11403 715dc77e 2019-08-03 stsp free((char *)pe->path);
11404 715dc77e 2019-08-03 stsp got_pathlist_free(&paths);
11405 715dc77e 2019-08-03 stsp free(cwd);
11406 01073a5d 2019-08-22 stsp return error;
11409 01073a5d 2019-08-22 stsp __dead static void
11410 01073a5d 2019-08-22 stsp usage_cat(void)
11412 896e9b6f 2019-08-26 stsp fprintf(stderr, "usage: %s cat [-r repository ] [ -c commit ] [ -P ] "
11413 896e9b6f 2019-08-26 stsp "arg1 [arg2 ...]\n", getprogname());
11417 01073a5d 2019-08-22 stsp static const struct got_error *
11418 01073a5d 2019-08-22 stsp cat_blob(struct got_object_id *id, struct got_repository *repo, FILE *outfile)
11420 01073a5d 2019-08-22 stsp const struct got_error *err;
11421 01073a5d 2019-08-22 stsp struct got_blob_object *blob;
11423 01073a5d 2019-08-22 stsp err = got_object_open_as_blob(&blob, repo, id, 8192);
11425 01073a5d 2019-08-22 stsp return err;
11427 01073a5d 2019-08-22 stsp err = got_object_blob_dump_to_file(NULL, NULL, NULL, outfile, blob);
11428 01073a5d 2019-08-22 stsp got_object_blob_close(blob);
11429 01073a5d 2019-08-22 stsp return err;
11432 01073a5d 2019-08-22 stsp static const struct got_error *
11433 01073a5d 2019-08-22 stsp cat_tree(struct got_object_id *id, struct got_repository *repo, FILE *outfile)
11435 01073a5d 2019-08-22 stsp const struct got_error *err;
11436 01073a5d 2019-08-22 stsp struct got_tree_object *tree;
11437 56e0773d 2019-11-28 stsp int nentries, i;
11439 01073a5d 2019-08-22 stsp err = got_object_open_as_tree(&tree, repo, id);
11441 01073a5d 2019-08-22 stsp return err;
11443 56e0773d 2019-11-28 stsp nentries = got_object_tree_get_nentries(tree);
11444 56e0773d 2019-11-28 stsp for (i = 0; i < nentries; i++) {
11445 56e0773d 2019-11-28 stsp struct got_tree_entry *te;
11446 01073a5d 2019-08-22 stsp char *id_str;
11447 01073a5d 2019-08-22 stsp if (sigint_received || sigpipe_received)
11449 56e0773d 2019-11-28 stsp te = got_object_tree_get_entry(tree, i);
11450 56e0773d 2019-11-28 stsp err = got_object_id_str(&id_str, got_tree_entry_get_id(te));
11453 56e0773d 2019-11-28 stsp fprintf(outfile, "%s %.7o %s\n", id_str,
11454 56e0773d 2019-11-28 stsp got_tree_entry_get_mode(te),
11455 56e0773d 2019-11-28 stsp got_tree_entry_get_name(te));
11456 01073a5d 2019-08-22 stsp free(id_str);
11459 01073a5d 2019-08-22 stsp got_object_tree_close(tree);
11460 01073a5d 2019-08-22 stsp return err;
11463 01073a5d 2019-08-22 stsp static const struct got_error *
11464 01073a5d 2019-08-22 stsp cat_commit(struct got_object_id *id, struct got_repository *repo, FILE *outfile)
11466 01073a5d 2019-08-22 stsp const struct got_error *err;
11467 01073a5d 2019-08-22 stsp struct got_commit_object *commit;
11468 01073a5d 2019-08-22 stsp const struct got_object_id_queue *parent_ids;
11469 01073a5d 2019-08-22 stsp struct got_object_qid *pid;
11470 01073a5d 2019-08-22 stsp char *id_str = NULL;
11471 24ea5512 2019-08-22 stsp const char *logmsg = NULL;
11473 01073a5d 2019-08-22 stsp err = got_object_open_as_commit(&commit, repo, id);
11475 01073a5d 2019-08-22 stsp return err;
11477 01073a5d 2019-08-22 stsp err = got_object_id_str(&id_str, got_object_commit_get_tree_id(commit));
11479 01073a5d 2019-08-22 stsp goto done;
11481 8aa93786 2019-08-22 stsp fprintf(outfile, "%s%s\n", GOT_COMMIT_LABEL_TREE, id_str);
11482 01073a5d 2019-08-22 stsp parent_ids = got_object_commit_get_parent_ids(commit);
11483 8aa93786 2019-08-22 stsp fprintf(outfile, "numparents %d\n",
11484 01073a5d 2019-08-22 stsp got_object_commit_get_nparents(commit));
11485 dbdddfee 2021-06-23 naddy STAILQ_FOREACH(pid, parent_ids, entry) {
11486 01073a5d 2019-08-22 stsp char *pid_str;
11487 01073a5d 2019-08-22 stsp err = got_object_id_str(&pid_str, pid->id);
11489 01073a5d 2019-08-22 stsp goto done;
11490 8aa93786 2019-08-22 stsp fprintf(outfile, "%s%s\n", GOT_COMMIT_LABEL_PARENT, pid_str);
11491 01073a5d 2019-08-22 stsp free(pid_str);
11493 8aa93786 2019-08-22 stsp fprintf(outfile, "%s%s %lld +0000\n", GOT_COMMIT_LABEL_AUTHOR,
11494 8aa93786 2019-08-22 stsp got_object_commit_get_author(commit),
11495 1367695b 2020-09-26 naddy (long long)got_object_commit_get_author_time(commit));
11497 8aa93786 2019-08-22 stsp fprintf(outfile, "%s%s %lld +0000\n", GOT_COMMIT_LABEL_COMMITTER,
11498 8aa93786 2019-08-22 stsp got_object_commit_get_author(commit),
11499 1367695b 2020-09-26 naddy (long long)got_object_commit_get_committer_time(commit));
11501 24ea5512 2019-08-22 stsp logmsg = got_object_commit_get_logmsg_raw(commit);
11502 8aa93786 2019-08-22 stsp fprintf(outfile, "messagelen %zd\n", strlen(logmsg));
11503 01073a5d 2019-08-22 stsp fprintf(outfile, "%s", logmsg);
11505 01073a5d 2019-08-22 stsp free(id_str);
11506 01073a5d 2019-08-22 stsp got_object_commit_close(commit);
11507 01073a5d 2019-08-22 stsp return err;
11510 01073a5d 2019-08-22 stsp static const struct got_error *
11511 01073a5d 2019-08-22 stsp cat_tag(struct got_object_id *id, struct got_repository *repo, FILE *outfile)
11513 01073a5d 2019-08-22 stsp const struct got_error *err;
11514 01073a5d 2019-08-22 stsp struct got_tag_object *tag;
11515 01073a5d 2019-08-22 stsp char *id_str = NULL;
11516 01073a5d 2019-08-22 stsp const char *tagmsg = NULL;
11518 01073a5d 2019-08-22 stsp err = got_object_open_as_tag(&tag, repo, id);
11520 01073a5d 2019-08-22 stsp return err;
11522 01073a5d 2019-08-22 stsp err = got_object_id_str(&id_str, got_object_tag_get_object_id(tag));
11524 01073a5d 2019-08-22 stsp goto done;
11526 e15d5241 2019-08-22 stsp fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_OBJECT, id_str);
11528 01073a5d 2019-08-22 stsp switch (got_object_tag_get_object_type(tag)) {
11529 01073a5d 2019-08-22 stsp case GOT_OBJ_TYPE_BLOB:
11530 8aa93786 2019-08-22 stsp fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_TYPE,
11531 8aa93786 2019-08-22 stsp GOT_OBJ_LABEL_BLOB);
11533 01073a5d 2019-08-22 stsp case GOT_OBJ_TYPE_TREE:
11534 8aa93786 2019-08-22 stsp fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_TYPE,
11535 8aa93786 2019-08-22 stsp GOT_OBJ_LABEL_TREE);
11537 01073a5d 2019-08-22 stsp case GOT_OBJ_TYPE_COMMIT:
11538 8aa93786 2019-08-22 stsp fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_TYPE,
11539 8aa93786 2019-08-22 stsp GOT_OBJ_LABEL_COMMIT);
11541 01073a5d 2019-08-22 stsp case GOT_OBJ_TYPE_TAG:
11542 8aa93786 2019-08-22 stsp fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_TYPE,
11543 8aa93786 2019-08-22 stsp GOT_OBJ_LABEL_TAG);
11549 e15d5241 2019-08-22 stsp fprintf(outfile, "%s%s\n", GOT_TAG_LABEL_TAG,
11550 e15d5241 2019-08-22 stsp got_object_tag_get_name(tag));
11552 8aa93786 2019-08-22 stsp fprintf(outfile, "%s%s %lld +0000\n", GOT_TAG_LABEL_TAGGER,
11553 8aa93786 2019-08-22 stsp got_object_tag_get_tagger(tag),
11554 1367695b 2020-09-26 naddy (long long)got_object_tag_get_tagger_time(tag));
11556 01073a5d 2019-08-22 stsp tagmsg = got_object_tag_get_message(tag);
11557 8aa93786 2019-08-22 stsp fprintf(outfile, "messagelen %zd\n", strlen(tagmsg));
11558 01073a5d 2019-08-22 stsp fprintf(outfile, "%s", tagmsg);
11560 01073a5d 2019-08-22 stsp free(id_str);
11561 01073a5d 2019-08-22 stsp got_object_tag_close(tag);
11562 01073a5d 2019-08-22 stsp return err;
11565 01073a5d 2019-08-22 stsp static const struct got_error *
11566 01073a5d 2019-08-22 stsp cmd_cat(int argc, char *argv[])
11568 01073a5d 2019-08-22 stsp const struct got_error *error;
11569 01073a5d 2019-08-22 stsp struct got_repository *repo = NULL;
11570 01073a5d 2019-08-22 stsp struct got_worktree *worktree = NULL;
11571 01073a5d 2019-08-22 stsp char *cwd = NULL, *repo_path = NULL, *label = NULL;
11572 896e9b6f 2019-08-26 stsp const char *commit_id_str = NULL;
11573 896e9b6f 2019-08-26 stsp struct got_object_id *id = NULL, *commit_id = NULL;
11574 896e9b6f 2019-08-26 stsp int ch, obj_type, i, force_path = 0;
11575 84de9106 2020-12-26 stsp struct got_reflist_head refs;
11577 d9dff0e5 2020-12-26 stsp TAILQ_INIT(&refs);
11579 01073a5d 2019-08-22 stsp #ifndef PROFILE
11580 01073a5d 2019-08-22 stsp if (pledge("stdio rpath wpath cpath flock proc exec sendfd unveil",
11581 01073a5d 2019-08-22 stsp NULL) == -1)
11582 01073a5d 2019-08-22 stsp err(1, "pledge");
11585 896e9b6f 2019-08-26 stsp while ((ch = getopt(argc, argv, "c:r:P")) != -1) {
11586 01073a5d 2019-08-22 stsp switch (ch) {
11587 896e9b6f 2019-08-26 stsp case 'c':
11588 896e9b6f 2019-08-26 stsp commit_id_str = optarg;
11590 01073a5d 2019-08-22 stsp case 'r':
11591 01073a5d 2019-08-22 stsp repo_path = realpath(optarg, NULL);
11592 01073a5d 2019-08-22 stsp if (repo_path == NULL)
11593 9ba1d308 2019-10-21 stsp return got_error_from_errno2("realpath",
11595 01073a5d 2019-08-22 stsp got_path_strip_trailing_slashes(repo_path);
11597 896e9b6f 2019-08-26 stsp case 'P':
11598 896e9b6f 2019-08-26 stsp force_path = 1;
11601 01073a5d 2019-08-22 stsp usage_cat();
11602 01073a5d 2019-08-22 stsp /* NOTREACHED */
11606 01073a5d 2019-08-22 stsp argc -= optind;
11607 01073a5d 2019-08-22 stsp argv += optind;
11609 01073a5d 2019-08-22 stsp cwd = getcwd(NULL, 0);
11610 01073a5d 2019-08-22 stsp if (cwd == NULL) {
11611 01073a5d 2019-08-22 stsp error = got_error_from_errno("getcwd");
11612 01073a5d 2019-08-22 stsp goto done;
11614 01073a5d 2019-08-22 stsp error = got_worktree_open(&worktree, cwd);
11615 01073a5d 2019-08-22 stsp if (error && error->code != GOT_ERR_NOT_WORKTREE)
11616 01073a5d 2019-08-22 stsp goto done;
11617 01073a5d 2019-08-22 stsp if (worktree) {
11618 01073a5d 2019-08-22 stsp if (repo_path == NULL) {
11619 01073a5d 2019-08-22 stsp repo_path = strdup(
11620 01073a5d 2019-08-22 stsp got_worktree_get_repo_path(worktree));
11621 01073a5d 2019-08-22 stsp if (repo_path == NULL) {
11622 01073a5d 2019-08-22 stsp error = got_error_from_errno("strdup");
11623 01073a5d 2019-08-22 stsp goto done;
11628 01073a5d 2019-08-22 stsp if (repo_path == NULL) {
11629 01073a5d 2019-08-22 stsp repo_path = getcwd(NULL, 0);
11630 01073a5d 2019-08-22 stsp if (repo_path == NULL)
11631 01073a5d 2019-08-22 stsp return got_error_from_errno("getcwd");
11634 c9956ddf 2019-09-08 stsp error = got_repo_open(&repo, repo_path, NULL);
11635 01073a5d 2019-08-22 stsp free(repo_path);
11636 01073a5d 2019-08-22 stsp if (error != NULL)
11637 01073a5d 2019-08-22 stsp goto done;
11639 01073a5d 2019-08-22 stsp error = apply_unveil(got_repo_get_path(repo), 1, NULL);
11640 896e9b6f 2019-08-26 stsp if (error)
11641 896e9b6f 2019-08-26 stsp goto done;
11643 84de9106 2020-12-26 stsp error = got_ref_list(&refs, repo, NULL, got_ref_cmp_by_name, NULL);
11644 84de9106 2020-12-26 stsp if (error)
11645 84de9106 2020-12-26 stsp goto done;
11647 896e9b6f 2019-08-26 stsp if (commit_id_str == NULL)
11648 896e9b6f 2019-08-26 stsp commit_id_str = GOT_REF_HEAD;
11649 71a27632 2020-01-15 stsp error = got_repo_match_object_id(&commit_id, NULL,
11650 84de9106 2020-12-26 stsp commit_id_str, GOT_OBJ_TYPE_COMMIT, &refs, repo);
11651 01073a5d 2019-08-22 stsp if (error)
11652 01073a5d 2019-08-22 stsp goto done;
11654 01073a5d 2019-08-22 stsp for (i = 0; i < argc; i++) {
11655 896e9b6f 2019-08-26 stsp if (force_path) {
11656 896e9b6f 2019-08-26 stsp error = got_object_id_by_path(&id, repo, commit_id,
11657 896e9b6f 2019-08-26 stsp argv[i]);
11658 896e9b6f 2019-08-26 stsp if (error)
11661 71a27632 2020-01-15 stsp error = got_repo_match_object_id(&id, &label, argv[i],
11662 84de9106 2020-12-26 stsp GOT_OBJ_TYPE_ANY, NULL /* do not resolve tags */,
11664 896e9b6f 2019-08-26 stsp if (error) {
11665 896e9b6f 2019-08-26 stsp if (error->code != GOT_ERR_BAD_OBJ_ID_STR &&
11666 896e9b6f 2019-08-26 stsp error->code != GOT_ERR_NOT_REF)
11668 896e9b6f 2019-08-26 stsp error = got_object_id_by_path(&id, repo,
11669 896e9b6f 2019-08-26 stsp commit_id, argv[i]);
11670 896e9b6f 2019-08-26 stsp if (error)
11675 01073a5d 2019-08-22 stsp error = got_object_get_type(&obj_type, repo, id);
11676 01073a5d 2019-08-22 stsp if (error)
11679 01073a5d 2019-08-22 stsp switch (obj_type) {
11680 01073a5d 2019-08-22 stsp case GOT_OBJ_TYPE_BLOB:
11681 01073a5d 2019-08-22 stsp error = cat_blob(id, repo, stdout);
11683 01073a5d 2019-08-22 stsp case GOT_OBJ_TYPE_TREE:
11684 01073a5d 2019-08-22 stsp error = cat_tree(id, repo, stdout);
11686 01073a5d 2019-08-22 stsp case GOT_OBJ_TYPE_COMMIT:
11687 01073a5d 2019-08-22 stsp error = cat_commit(id, repo, stdout);
11689 01073a5d 2019-08-22 stsp case GOT_OBJ_TYPE_TAG:
11690 01073a5d 2019-08-22 stsp error = cat_tag(id, repo, stdout);
11693 01073a5d 2019-08-22 stsp error = got_error(GOT_ERR_OBJ_TYPE);
11696 01073a5d 2019-08-22 stsp if (error)
11698 01073a5d 2019-08-22 stsp free(label);
11699 01073a5d 2019-08-22 stsp label = NULL;
11700 01073a5d 2019-08-22 stsp free(id);
11701 01073a5d 2019-08-22 stsp id = NULL;
11704 01073a5d 2019-08-22 stsp free(label);
11705 01073a5d 2019-08-22 stsp free(id);
11706 896e9b6f 2019-08-26 stsp free(commit_id);
11707 01073a5d 2019-08-22 stsp if (worktree)
11708 01073a5d 2019-08-22 stsp got_worktree_close(worktree);
11709 01073a5d 2019-08-22 stsp if (repo) {
11710 1d0f4054 2021-06-17 stsp const struct got_error *close_err = got_repo_close(repo);
11711 01073a5d 2019-08-22 stsp if (error == NULL)
11712 1d0f4054 2021-06-17 stsp error = close_err;
11714 84de9106 2020-12-26 stsp got_ref_list_free(&refs);
11715 b2118c49 2020-07-28 stsp return error;
11718 b2118c49 2020-07-28 stsp __dead static void
11719 b2118c49 2020-07-28 stsp usage_info(void)
11721 b2118c49 2020-07-28 stsp fprintf(stderr, "usage: %s info [path ...]\n",
11722 b2118c49 2020-07-28 stsp getprogname());
11726 b2118c49 2020-07-28 stsp static const struct got_error *
11727 b2118c49 2020-07-28 stsp print_path_info(void *arg, const char *path, mode_t mode, time_t mtime,
11728 b2118c49 2020-07-28 stsp struct got_object_id *blob_id, struct got_object_id *staged_blob_id,
11729 b2118c49 2020-07-28 stsp struct got_object_id *commit_id)
11731 b2118c49 2020-07-28 stsp const struct got_error *err = NULL;
11732 b2118c49 2020-07-28 stsp char *id_str = NULL;
11733 b2118c49 2020-07-28 stsp char datebuf[128];
11734 b2118c49 2020-07-28 stsp struct tm mytm, *tm;
11735 b2118c49 2020-07-28 stsp struct got_pathlist_head *paths = arg;
11736 b2118c49 2020-07-28 stsp struct got_pathlist_entry *pe;
11739 b2118c49 2020-07-28 stsp * Clear error indication from any of the path arguments which
11740 b2118c49 2020-07-28 stsp * would cause this file index entry to be displayed.
11742 b2118c49 2020-07-28 stsp TAILQ_FOREACH(pe, paths, entry) {
11743 b2118c49 2020-07-28 stsp if (got_path_cmp(path, pe->path, strlen(path),
11744 b2118c49 2020-07-28 stsp pe->path_len) == 0 ||
11745 b2118c49 2020-07-28 stsp got_path_is_child(path, pe->path, pe->path_len))
11746 b2118c49 2020-07-28 stsp pe->data = NULL; /* no error */
11749 b2118c49 2020-07-28 stsp printf(GOT_COMMIT_SEP_STR);
11750 b2118c49 2020-07-28 stsp if (S_ISLNK(mode))
11751 b2118c49 2020-07-28 stsp printf("symlink: %s\n", path);
11752 b2118c49 2020-07-28 stsp else if (S_ISREG(mode)) {
11753 b2118c49 2020-07-28 stsp printf("file: %s\n", path);
11754 b2118c49 2020-07-28 stsp printf("mode: %o\n", mode & (S_IRWXU | S_IRWXG | S_IRWXO));
11755 b2118c49 2020-07-28 stsp } else if (S_ISDIR(mode))
11756 b2118c49 2020-07-28 stsp printf("directory: %s\n", path);
11758 b2118c49 2020-07-28 stsp printf("something: %s\n", path);
11760 b2118c49 2020-07-28 stsp tm = localtime_r(&mtime, &mytm);
11761 b2118c49 2020-07-28 stsp if (tm == NULL)
11762 b2118c49 2020-07-28 stsp return NULL;
11763 ec6d1a36 2021-03-21 jrick if (strftime(datebuf, sizeof(datebuf), "%c %Z", tm) == 0)
11764 b2118c49 2020-07-28 stsp return got_error(GOT_ERR_NO_SPACE);
11765 b2118c49 2020-07-28 stsp printf("timestamp: %s\n", datebuf);
11767 b2118c49 2020-07-28 stsp if (blob_id) {
11768 b2118c49 2020-07-28 stsp err = got_object_id_str(&id_str, blob_id);
11770 b2118c49 2020-07-28 stsp return err;
11771 b2118c49 2020-07-28 stsp printf("based on blob: %s\n", id_str);
11772 b2118c49 2020-07-28 stsp free(id_str);
11775 b2118c49 2020-07-28 stsp if (staged_blob_id) {
11776 b2118c49 2020-07-28 stsp err = got_object_id_str(&id_str, staged_blob_id);
11778 b2118c49 2020-07-28 stsp return err;
11779 b2118c49 2020-07-28 stsp printf("based on staged blob: %s\n", id_str);
11780 b2118c49 2020-07-28 stsp free(id_str);
11783 b2118c49 2020-07-28 stsp if (commit_id) {
11784 b2118c49 2020-07-28 stsp err = got_object_id_str(&id_str, commit_id);
11786 b2118c49 2020-07-28 stsp return err;
11787 b2118c49 2020-07-28 stsp printf("based on commit: %s\n", id_str);
11788 b2118c49 2020-07-28 stsp free(id_str);
11791 b2118c49 2020-07-28 stsp return NULL;
11794 b2118c49 2020-07-28 stsp static const struct got_error *
11795 b2118c49 2020-07-28 stsp cmd_info(int argc, char *argv[])
11797 b2118c49 2020-07-28 stsp const struct got_error *error = NULL;
11798 b2118c49 2020-07-28 stsp struct got_worktree *worktree = NULL;
11799 b2118c49 2020-07-28 stsp char *cwd = NULL, *id_str = NULL;
11800 b2118c49 2020-07-28 stsp struct got_pathlist_head paths;
11801 b2118c49 2020-07-28 stsp struct got_pathlist_entry *pe;
11802 b2118c49 2020-07-28 stsp char *uuidstr = NULL;
11803 b2118c49 2020-07-28 stsp int ch, show_files = 0;
11805 b2118c49 2020-07-28 stsp TAILQ_INIT(&paths);
11807 b2118c49 2020-07-28 stsp while ((ch = getopt(argc, argv, "")) != -1) {
11808 b2118c49 2020-07-28 stsp switch (ch) {
11810 b2118c49 2020-07-28 stsp usage_info();
11811 b2118c49 2020-07-28 stsp /* NOTREACHED */
11815 b2118c49 2020-07-28 stsp argc -= optind;
11816 b2118c49 2020-07-28 stsp argv += optind;
11818 b2118c49 2020-07-28 stsp #ifndef PROFILE
11819 b2118c49 2020-07-28 stsp if (pledge("stdio rpath wpath flock proc exec sendfd unveil",
11820 b2118c49 2020-07-28 stsp NULL) == -1)
11821 b2118c49 2020-07-28 stsp err(1, "pledge");
11823 b2118c49 2020-07-28 stsp cwd = getcwd(NULL, 0);
11824 b2118c49 2020-07-28 stsp if (cwd == NULL) {
11825 b2118c49 2020-07-28 stsp error = got_error_from_errno("getcwd");
11826 b2118c49 2020-07-28 stsp goto done;
11829 b2118c49 2020-07-28 stsp error = got_worktree_open(&worktree, cwd);
11830 b2118c49 2020-07-28 stsp if (error) {
11831 b2118c49 2020-07-28 stsp if (error->code == GOT_ERR_NOT_WORKTREE)
11832 8ea5c997 2021-02-07 naddy error = wrap_not_worktree_error(error, "info", cwd);
11833 b2118c49 2020-07-28 stsp goto done;
11836 b2118c49 2020-07-28 stsp error = apply_unveil(NULL, 0, got_worktree_get_root_path(worktree));
11837 b2118c49 2020-07-28 stsp if (error)
11838 b2118c49 2020-07-28 stsp goto done;
11840 b2118c49 2020-07-28 stsp if (argc >= 1) {
11841 b2118c49 2020-07-28 stsp error = get_worktree_paths_from_argv(&paths, argc, argv,
11842 b2118c49 2020-07-28 stsp worktree);
11843 b2118c49 2020-07-28 stsp if (error)
11844 b2118c49 2020-07-28 stsp goto done;
11845 b2118c49 2020-07-28 stsp show_files = 1;
11848 b2118c49 2020-07-28 stsp error = got_object_id_str(&id_str,
11849 b2118c49 2020-07-28 stsp got_worktree_get_base_commit_id(worktree));
11850 b2118c49 2020-07-28 stsp if (error)
11851 b2118c49 2020-07-28 stsp goto done;
11853 b2118c49 2020-07-28 stsp error = got_worktree_get_uuid(&uuidstr, worktree);
11854 b2118c49 2020-07-28 stsp if (error)
11855 b2118c49 2020-07-28 stsp goto done;
11857 b2118c49 2020-07-28 stsp printf("work tree: %s\n", got_worktree_get_root_path(worktree));
11858 b2118c49 2020-07-28 stsp printf("work tree base commit: %s\n", id_str);
11859 b2118c49 2020-07-28 stsp printf("work tree path prefix: %s\n",
11860 b2118c49 2020-07-28 stsp got_worktree_get_path_prefix(worktree));
11861 b2118c49 2020-07-28 stsp printf("work tree branch reference: %s\n",
11862 b2118c49 2020-07-28 stsp got_worktree_get_head_ref_name(worktree));
11863 b2118c49 2020-07-28 stsp printf("work tree UUID: %s\n", uuidstr);
11864 b2118c49 2020-07-28 stsp printf("repository: %s\n", got_worktree_get_repo_path(worktree));
11866 b2118c49 2020-07-28 stsp if (show_files) {
11867 b2118c49 2020-07-28 stsp struct got_pathlist_entry *pe;
11868 b2118c49 2020-07-28 stsp TAILQ_FOREACH(pe, &paths, entry) {
11869 b2118c49 2020-07-28 stsp if (pe->path_len == 0)
11870 b2118c49 2020-07-28 stsp continue;
11872 b2118c49 2020-07-28 stsp * Assume this path will fail. This will be corrected
11873 b2118c49 2020-07-28 stsp * in print_path_info() in case the path does suceeed.
11875 b2118c49 2020-07-28 stsp pe->data = (void *)got_error_path(pe->path,
11876 b2118c49 2020-07-28 stsp GOT_ERR_BAD_PATH);
11878 b2118c49 2020-07-28 stsp error = got_worktree_path_info(worktree, &paths,
11879 b2118c49 2020-07-28 stsp print_path_info, &paths, check_cancelled, NULL);
11880 b2118c49 2020-07-28 stsp if (error)
11881 b2118c49 2020-07-28 stsp goto done;
11882 b2118c49 2020-07-28 stsp TAILQ_FOREACH(pe, &paths, entry) {
11883 b2118c49 2020-07-28 stsp if (pe->data != NULL) {
11884 b2118c49 2020-07-28 stsp error = pe->data; /* bad path */
11890 b2118c49 2020-07-28 stsp TAILQ_FOREACH(pe, &paths, entry)
11891 b2118c49 2020-07-28 stsp free((char *)pe->path);
11892 b2118c49 2020-07-28 stsp got_pathlist_free(&paths);
11893 b2118c49 2020-07-28 stsp free(cwd);
11894 b2118c49 2020-07-28 stsp free(id_str);
11895 b2118c49 2020-07-28 stsp free(uuidstr);
11896 0ebf8283 2019-07-24 stsp return error;
