Merge branch 'dl/p4-encode-after-kw-expansion'
[git] / worktree.c
1 #include "cache.h"
2 #include "repository.h"
3 #include "refs.h"
4 #include "strbuf.h"
5 #include "worktree.h"
6 #include "dir.h"
7 #include "wt-status.h"
8
9 void free_worktrees(struct worktree **worktrees)
10 {
11         int i = 0;
12
13         for (i = 0; worktrees[i]; i++) {
14                 free(worktrees[i]->path);
15                 free(worktrees[i]->id);
16                 free(worktrees[i]->head_ref);
17                 free(worktrees[i]->lock_reason);
18                 free(worktrees[i]);
19         }
20         free (worktrees);
21 }
22
23 /**
24  * Update head_oid, head_ref and is_detached of the given worktree
25  */
26 static void add_head_info(struct worktree *wt)
27 {
28         int flags;
29         const char *target;
30
31         target = refs_resolve_ref_unsafe(get_worktree_ref_store(wt),
32                                          "HEAD",
33                                          0,
34                                          &wt->head_oid, &flags);
35         if (!target)
36                 return;
37
38         if (flags & REF_ISSYMREF)
39                 wt->head_ref = xstrdup(target);
40         else
41                 wt->is_detached = 1;
42 }
43
44 /**
45  * get the main worktree
46  */
47 static struct worktree *get_main_worktree(void)
48 {
49         struct worktree *worktree = NULL;
50         struct strbuf worktree_path = STRBUF_INIT;
51
52         strbuf_add_real_path(&worktree_path, get_git_common_dir());
53         strbuf_strip_suffix(&worktree_path, "/.git");
54
55         worktree = xcalloc(1, sizeof(*worktree));
56         worktree->path = strbuf_detach(&worktree_path, NULL);
57         /*
58          * NEEDSWORK: If this function is called from a secondary worktree and
59          * config.worktree is present, is_bare_repository_cfg will reflect the
60          * contents of config.worktree, not the contents of the main worktree.
61          * This means that worktree->is_bare may be set to 0 even if the main
62          * worktree is configured to be bare.
63          */
64         worktree->is_bare = (is_bare_repository_cfg == 1) ||
65                 is_bare_repository();
66         add_head_info(worktree);
67         return worktree;
68 }
69
70 static struct worktree *get_linked_worktree(const char *id)
71 {
72         struct worktree *worktree = NULL;
73         struct strbuf path = STRBUF_INIT;
74         struct strbuf worktree_path = STRBUF_INIT;
75
76         if (!id)
77                 die("Missing linked worktree name");
78
79         strbuf_git_common_path(&path, the_repository, "worktrees/%s/gitdir", id);
80         if (strbuf_read_file(&worktree_path, path.buf, 0) <= 0)
81                 /* invalid gitdir file */
82                 goto done;
83         strbuf_rtrim(&worktree_path);
84         strbuf_strip_suffix(&worktree_path, "/.git");
85
86         worktree = xcalloc(1, sizeof(*worktree));
87         worktree->path = strbuf_detach(&worktree_path, NULL);
88         worktree->id = xstrdup(id);
89         add_head_info(worktree);
90
91 done:
92         strbuf_release(&path);
93         strbuf_release(&worktree_path);
94         return worktree;
95 }
96
97 static void mark_current_worktree(struct worktree **worktrees)
98 {
99         char *git_dir = absolute_pathdup(get_git_dir());
100         int i;
101
102         for (i = 0; worktrees[i]; i++) {
103                 struct worktree *wt = worktrees[i];
104                 const char *wt_git_dir = get_worktree_git_dir(wt);
105
106                 if (!fspathcmp(git_dir, absolute_path(wt_git_dir))) {
107                         wt->is_current = 1;
108                         break;
109                 }
110         }
111         free(git_dir);
112 }
113
114 struct worktree **get_worktrees(void)
115 {
116         struct worktree **list = NULL;
117         struct strbuf path = STRBUF_INIT;
118         DIR *dir;
119         struct dirent *d;
120         int counter = 0, alloc = 2;
121
122         ALLOC_ARRAY(list, alloc);
123
124         list[counter++] = get_main_worktree();
125
126         strbuf_addf(&path, "%s/worktrees", get_git_common_dir());
127         dir = opendir(path.buf);
128         strbuf_release(&path);
129         if (dir) {
130                 while ((d = readdir(dir)) != NULL) {
131                         struct worktree *linked = NULL;
132                         if (is_dot_or_dotdot(d->d_name))
133                                 continue;
134
135                         if ((linked = get_linked_worktree(d->d_name))) {
136                                 ALLOC_GROW(list, counter + 1, alloc);
137                                 list[counter++] = linked;
138                         }
139                 }
140                 closedir(dir);
141         }
142         ALLOC_GROW(list, counter + 1, alloc);
143         list[counter] = NULL;
144
145         mark_current_worktree(list);
146         return list;
147 }
148
149 const char *get_worktree_git_dir(const struct worktree *wt)
150 {
151         if (!wt)
152                 return get_git_dir();
153         else if (!wt->id)
154                 return get_git_common_dir();
155         else
156                 return git_common_path("worktrees/%s", wt->id);
157 }
158
159 static struct worktree *find_worktree_by_suffix(struct worktree **list,
160                                                 const char *suffix)
161 {
162         struct worktree *found = NULL;
163         int nr_found = 0, suffixlen;
164
165         suffixlen = strlen(suffix);
166         if (!suffixlen)
167                 return NULL;
168
169         for (; *list && nr_found < 2; list++) {
170                 const char      *path    = (*list)->path;
171                 int              pathlen = strlen(path);
172                 int              start   = pathlen - suffixlen;
173
174                 /* suffix must start at directory boundary */
175                 if ((!start || (start > 0 && is_dir_sep(path[start - 1]))) &&
176                     !fspathcmp(suffix, path + start)) {
177                         found = *list;
178                         nr_found++;
179                 }
180         }
181         return nr_found == 1 ? found : NULL;
182 }
183
184 struct worktree *find_worktree(struct worktree **list,
185                                const char *prefix,
186                                const char *arg)
187 {
188         struct worktree *wt;
189         char *to_free = NULL;
190
191         if ((wt = find_worktree_by_suffix(list, arg)))
192                 return wt;
193
194         if (prefix)
195                 arg = to_free = prefix_filename(prefix, arg);
196         wt = find_worktree_by_path(list, arg);
197         free(to_free);
198         return wt;
199 }
200
201 struct worktree *find_worktree_by_path(struct worktree **list, const char *p)
202 {
203         struct strbuf wt_path = STRBUF_INIT;
204         char *path = real_pathdup(p, 0);
205
206         if (!path)
207                 return NULL;
208         for (; *list; list++) {
209                 if (!strbuf_realpath(&wt_path, (*list)->path, 0))
210                         continue;
211
212                 if (!fspathcmp(path, wt_path.buf))
213                         break;
214         }
215         free(path);
216         strbuf_release(&wt_path);
217         return *list;
218 }
219
220 int is_main_worktree(const struct worktree *wt)
221 {
222         return !wt->id;
223 }
224
225 const char *worktree_lock_reason(struct worktree *wt)
226 {
227         assert(!is_main_worktree(wt));
228
229         if (!wt->lock_reason_valid) {
230                 struct strbuf path = STRBUF_INIT;
231
232                 strbuf_addstr(&path, worktree_git_path(wt, "locked"));
233                 if (file_exists(path.buf)) {
234                         struct strbuf lock_reason = STRBUF_INIT;
235                         if (strbuf_read_file(&lock_reason, path.buf, 0) < 0)
236                                 die_errno(_("failed to read '%s'"), path.buf);
237                         strbuf_trim(&lock_reason);
238                         wt->lock_reason = strbuf_detach(&lock_reason, NULL);
239                 } else
240                         wt->lock_reason = NULL;
241                 wt->lock_reason_valid = 1;
242                 strbuf_release(&path);
243         }
244
245         return wt->lock_reason;
246 }
247
248 /* convenient wrapper to deal with NULL strbuf */
249 static void strbuf_addf_gently(struct strbuf *buf, const char *fmt, ...)
250 {
251         va_list params;
252
253         if (!buf)
254                 return;
255
256         va_start(params, fmt);
257         strbuf_vaddf(buf, fmt, params);
258         va_end(params);
259 }
260
261 int validate_worktree(const struct worktree *wt, struct strbuf *errmsg,
262                       unsigned flags)
263 {
264         struct strbuf wt_path = STRBUF_INIT;
265         struct strbuf realpath = STRBUF_INIT;
266         char *path = NULL;
267         int err, ret = -1;
268
269         strbuf_addf(&wt_path, "%s/.git", wt->path);
270
271         if (is_main_worktree(wt)) {
272                 if (is_directory(wt_path.buf)) {
273                         ret = 0;
274                         goto done;
275                 }
276                 /*
277                  * Main worktree using .git file to point to the
278                  * repository would make it impossible to know where
279                  * the actual worktree is if this function is executed
280                  * from another worktree. No .git file support for now.
281                  */
282                 strbuf_addf_gently(errmsg,
283                                    _("'%s' at main working tree is not the repository directory"),
284                                    wt_path.buf);
285                 goto done;
286         }
287
288         /*
289          * Make sure "gitdir" file points to a real .git file and that
290          * file points back here.
291          */
292         if (!is_absolute_path(wt->path)) {
293                 strbuf_addf_gently(errmsg,
294                                    _("'%s' file does not contain absolute path to the working tree location"),
295                                    git_common_path("worktrees/%s/gitdir", wt->id));
296                 goto done;
297         }
298
299         if (flags & WT_VALIDATE_WORKTREE_MISSING_OK &&
300             !file_exists(wt->path)) {
301                 ret = 0;
302                 goto done;
303         }
304
305         if (!file_exists(wt_path.buf)) {
306                 strbuf_addf_gently(errmsg, _("'%s' does not exist"), wt_path.buf);
307                 goto done;
308         }
309
310         path = xstrdup_or_null(read_gitfile_gently(wt_path.buf, &err));
311         if (!path) {
312                 strbuf_addf_gently(errmsg, _("'%s' is not a .git file, error code %d"),
313                                    wt_path.buf, err);
314                 goto done;
315         }
316
317         strbuf_realpath(&realpath, git_common_path("worktrees/%s", wt->id), 1);
318         ret = fspathcmp(path, realpath.buf);
319
320         if (ret)
321                 strbuf_addf_gently(errmsg, _("'%s' does not point back to '%s'"),
322                                    wt->path, git_common_path("worktrees/%s", wt->id));
323 done:
324         free(path);
325         strbuf_release(&wt_path);
326         strbuf_release(&realpath);
327         return ret;
328 }
329
330 void update_worktree_location(struct worktree *wt, const char *path_)
331 {
332         struct strbuf path = STRBUF_INIT;
333
334         if (is_main_worktree(wt))
335                 BUG("can't relocate main worktree");
336
337         strbuf_realpath(&path, path_, 1);
338         if (fspathcmp(wt->path, path.buf)) {
339                 write_file(git_common_path("worktrees/%s/gitdir", wt->id),
340                            "%s/.git", path.buf);
341                 free(wt->path);
342                 wt->path = strbuf_detach(&path, NULL);
343         }
344         strbuf_release(&path);
345 }
346
347 int is_worktree_being_rebased(const struct worktree *wt,
348                               const char *target)
349 {
350         struct wt_status_state state;
351         int found_rebase;
352
353         memset(&state, 0, sizeof(state));
354         found_rebase = wt_status_check_rebase(wt, &state) &&
355                        (state.rebase_in_progress ||
356                         state.rebase_interactive_in_progress) &&
357                        state.branch &&
358                        skip_prefix(target, "refs/heads/", &target) &&
359                        !strcmp(state.branch, target);
360         wt_status_state_free_buffers(&state);
361         return found_rebase;
362 }
363
364 int is_worktree_being_bisected(const struct worktree *wt,
365                                const char *target)
366 {
367         struct wt_status_state state;
368         int found_bisect;
369
370         memset(&state, 0, sizeof(state));
371         found_bisect = wt_status_check_bisect(wt, &state) &&
372                        state.branch &&
373                        skip_prefix(target, "refs/heads/", &target) &&
374                        !strcmp(state.branch, target);
375         wt_status_state_free_buffers(&state);
376         return found_bisect;
377 }
378
379 /*
380  * note: this function should be able to detect shared symref even if
381  * HEAD is temporarily detached (e.g. in the middle of rebase or
382  * bisect). New commands that do similar things should update this
383  * function as well.
384  */
385 const struct worktree *find_shared_symref(const char *symref,
386                                           const char *target)
387 {
388         const struct worktree *existing = NULL;
389         static struct worktree **worktrees;
390         int i = 0;
391
392         if (worktrees)
393                 free_worktrees(worktrees);
394         worktrees = get_worktrees();
395
396         for (i = 0; worktrees[i]; i++) {
397                 struct worktree *wt = worktrees[i];
398                 const char *symref_target;
399                 struct ref_store *refs;
400                 int flags;
401
402                 if (wt->is_bare)
403                         continue;
404
405                 if (wt->is_detached && !strcmp(symref, "HEAD")) {
406                         if (is_worktree_being_rebased(wt, target)) {
407                                 existing = wt;
408                                 break;
409                         }
410                         if (is_worktree_being_bisected(wt, target)) {
411                                 existing = wt;
412                                 break;
413                         }
414                 }
415
416                 refs = get_worktree_ref_store(wt);
417                 symref_target = refs_resolve_ref_unsafe(refs, symref, 0,
418                                                         NULL, &flags);
419                 if ((flags & REF_ISSYMREF) &&
420                     symref_target && !strcmp(symref_target, target)) {
421                         existing = wt;
422                         break;
423                 }
424         }
425
426         return existing;
427 }
428
429 int submodule_uses_worktrees(const char *path)
430 {
431         char *submodule_gitdir;
432         struct strbuf sb = STRBUF_INIT, err = STRBUF_INIT;
433         DIR *dir;
434         struct dirent *d;
435         int ret = 0;
436         struct repository_format format = REPOSITORY_FORMAT_INIT;
437
438         submodule_gitdir = git_pathdup_submodule(path, "%s", "");
439         if (!submodule_gitdir)
440                 return 0;
441
442         /* The env would be set for the superproject. */
443         get_common_dir_noenv(&sb, submodule_gitdir);
444         free(submodule_gitdir);
445
446         strbuf_addstr(&sb, "/config");
447         read_repository_format(&format, sb.buf);
448         if (verify_repository_format(&format, &err)) {
449                 strbuf_release(&err);
450                 strbuf_release(&sb);
451                 clear_repository_format(&format);
452                 return 1;
453         }
454         clear_repository_format(&format);
455         strbuf_release(&err);
456
457         /* Replace config by worktrees. */
458         strbuf_setlen(&sb, sb.len - strlen("config"));
459         strbuf_addstr(&sb, "worktrees");
460
461         /* See if there is any file inside the worktrees directory. */
462         dir = opendir(sb.buf);
463         strbuf_release(&sb);
464
465         if (!dir)
466                 return 0;
467
468         while ((d = readdir(dir)) != NULL) {
469                 if (is_dot_or_dotdot(d->d_name))
470                         continue;
471
472                 ret = 1;
473                 break;
474         }
475         closedir(dir);
476         return ret;
477 }
478
479 int parse_worktree_ref(const char *worktree_ref, const char **name,
480                        int *name_length, const char **ref)
481 {
482         if (skip_prefix(worktree_ref, "main-worktree/", &worktree_ref)) {
483                 if (!*worktree_ref)
484                         return -1;
485                 if (name)
486                         *name = NULL;
487                 if (name_length)
488                         *name_length = 0;
489                 if (ref)
490                         *ref = worktree_ref;
491                 return 0;
492         }
493         if (skip_prefix(worktree_ref, "worktrees/", &worktree_ref)) {
494                 const char *slash = strchr(worktree_ref, '/');
495
496                 if (!slash || slash == worktree_ref || !slash[1])
497                         return -1;
498                 if (name)
499                         *name = worktree_ref;
500                 if (name_length)
501                         *name_length = slash - worktree_ref;
502                 if (ref)
503                         *ref = slash + 1;
504                 return 0;
505         }
506         return -1;
507 }
508
509 void strbuf_worktree_ref(const struct worktree *wt,
510                          struct strbuf *sb,
511                          const char *refname)
512 {
513         switch (ref_type(refname)) {
514         case REF_TYPE_PSEUDOREF:
515         case REF_TYPE_PER_WORKTREE:
516                 if (wt && !wt->is_current) {
517                         if (is_main_worktree(wt))
518                                 strbuf_addstr(sb, "main-worktree/");
519                         else
520                                 strbuf_addf(sb, "worktrees/%s/", wt->id);
521                 }
522                 break;
523
524         case REF_TYPE_MAIN_PSEUDOREF:
525         case REF_TYPE_OTHER_PSEUDOREF:
526                 break;
527
528         case REF_TYPE_NORMAL:
529                 /*
530                  * For shared refs, don't prefix worktrees/ or
531                  * main-worktree/. It's not necessary and
532                  * files-backend.c can't handle it anyway.
533                  */
534                 break;
535         }
536         strbuf_addstr(sb, refname);
537 }
538
539 int other_head_refs(each_ref_fn fn, void *cb_data)
540 {
541         struct worktree **worktrees, **p;
542         struct strbuf refname = STRBUF_INIT;
543         int ret = 0;
544
545         worktrees = get_worktrees();
546         for (p = worktrees; *p; p++) {
547                 struct worktree *wt = *p;
548                 struct object_id oid;
549                 int flag;
550
551                 if (wt->is_current)
552                         continue;
553
554                 strbuf_reset(&refname);
555                 strbuf_worktree_ref(wt, &refname, "HEAD");
556                 if (!refs_read_ref_full(get_main_ref_store(the_repository),
557                                         refname.buf,
558                                         RESOLVE_REF_READING,
559                                         &oid, &flag))
560                         ret = fn(refname.buf, &oid, flag, cb_data);
561                 if (ret)
562                         break;
563         }
564         free_worktrees(worktrees);
565         strbuf_release(&refname);
566         return ret;
567 }
568
569 /*
570  * Repair worktree's /path/to/worktree/.git file if missing, corrupt, or not
571  * pointing at <repo>/worktrees/<id>.
572  */
573 static void repair_gitfile(struct worktree *wt,
574                            worktree_repair_fn fn, void *cb_data)
575 {
576         struct strbuf dotgit = STRBUF_INIT;
577         struct strbuf repo = STRBUF_INIT;
578         char *backlink;
579         const char *repair = NULL;
580         int err;
581
582         /* missing worktree can't be repaired */
583         if (!file_exists(wt->path))
584                 return;
585
586         if (!is_directory(wt->path)) {
587                 fn(1, wt->path, _("not a directory"), cb_data);
588                 return;
589         }
590
591         strbuf_realpath(&repo, git_common_path("worktrees/%s", wt->id), 1);
592         strbuf_addf(&dotgit, "%s/.git", wt->path);
593         backlink = xstrdup_or_null(read_gitfile_gently(dotgit.buf, &err));
594
595         if (err == READ_GITFILE_ERR_NOT_A_FILE)
596                 fn(1, wt->path, _(".git is not a file"), cb_data);
597         else if (err)
598                 repair = _(".git file broken");
599         else if (fspathcmp(backlink, repo.buf))
600                 repair = _(".git file incorrect");
601
602         if (repair) {
603                 fn(0, wt->path, repair, cb_data);
604                 write_file(dotgit.buf, "gitdir: %s", repo.buf);
605         }
606
607         free(backlink);
608         strbuf_release(&repo);
609         strbuf_release(&dotgit);
610 }
611
612 static void repair_noop(int iserr, const char *path, const char *msg,
613                         void *cb_data)
614 {
615         /* nothing */
616 }
617
618 void repair_worktrees(worktree_repair_fn fn, void *cb_data)
619 {
620         struct worktree **worktrees = get_worktrees();
621         struct worktree **wt = worktrees + 1; /* +1 skips main worktree */
622
623         if (!fn)
624                 fn = repair_noop;
625         for (; *wt; wt++)
626                 repair_gitfile(*wt, fn, cb_data);
627         free_worktrees(worktrees);
628 }
629
630 static int is_main_worktree_path(const char *path)
631 {
632         struct strbuf target = STRBUF_INIT;
633         struct strbuf maindir = STRBUF_INIT;
634         int cmp;
635
636         strbuf_add_real_path(&target, path);
637         strbuf_strip_suffix(&target, "/.git");
638         strbuf_add_real_path(&maindir, get_git_common_dir());
639         strbuf_strip_suffix(&maindir, "/.git");
640         cmp = fspathcmp(maindir.buf, target.buf);
641
642         strbuf_release(&maindir);
643         strbuf_release(&target);
644         return !cmp;
645 }
646
647 /*
648  * If both the main worktree and linked worktree have been moved, then the
649  * gitfile /path/to/worktree/.git won't point into the repository, thus we
650  * won't know which <repo>/worktrees/<id>/gitdir to repair. However, we may
651  * be able to infer the gitdir by manually reading /path/to/worktree/.git,
652  * extracting the <id>, and checking if <repo>/worktrees/<id> exists.
653  */
654 static char *infer_backlink(const char *gitfile)
655 {
656         struct strbuf actual = STRBUF_INIT;
657         struct strbuf inferred = STRBUF_INIT;
658         const char *id;
659
660         if (strbuf_read_file(&actual, gitfile, 0) < 0)
661                 goto error;
662         if (!starts_with(actual.buf, "gitdir:"))
663                 goto error;
664         if (!(id = find_last_dir_sep(actual.buf)))
665                 goto error;
666         strbuf_trim(&actual);
667         id++; /* advance past '/' to point at <id> */
668         if (!*id)
669                 goto error;
670         strbuf_git_common_path(&inferred, the_repository, "worktrees/%s", id);
671         if (!is_directory(inferred.buf))
672                 goto error;
673
674         strbuf_release(&actual);
675         return strbuf_detach(&inferred, NULL);
676
677 error:
678         strbuf_release(&actual);
679         strbuf_release(&inferred);
680         return NULL;
681 }
682
683 /*
684  * Repair <repo>/worktrees/<id>/gitdir if missing, corrupt, or not pointing at
685  * the worktree's path.
686  */
687 void repair_worktree_at_path(const char *path,
688                              worktree_repair_fn fn, void *cb_data)
689 {
690         struct strbuf dotgit = STRBUF_INIT;
691         struct strbuf realdotgit = STRBUF_INIT;
692         struct strbuf gitdir = STRBUF_INIT;
693         struct strbuf olddotgit = STRBUF_INIT;
694         char *backlink = NULL;
695         const char *repair = NULL;
696         int err;
697
698         if (!fn)
699                 fn = repair_noop;
700
701         if (is_main_worktree_path(path))
702                 goto done;
703
704         strbuf_addf(&dotgit, "%s/.git", path);
705         if (!strbuf_realpath(&realdotgit, dotgit.buf, 0)) {
706                 fn(1, path, _("not a valid path"), cb_data);
707                 goto done;
708         }
709
710         backlink = xstrdup_or_null(read_gitfile_gently(realdotgit.buf, &err));
711         if (err == READ_GITFILE_ERR_NOT_A_FILE) {
712                 fn(1, realdotgit.buf, _("unable to locate repository; .git is not a file"), cb_data);
713                 goto done;
714         } else if (err == READ_GITFILE_ERR_NOT_A_REPO) {
715                 if (!(backlink = infer_backlink(realdotgit.buf))) {
716                         fn(1, realdotgit.buf, _("unable to locate repository; .git file does not reference a repository"), cb_data);
717                         goto done;
718                 }
719         } else if (err) {
720                 fn(1, realdotgit.buf, _("unable to locate repository; .git file broken"), cb_data);
721                 goto done;
722         }
723
724         strbuf_addf(&gitdir, "%s/gitdir", backlink);
725         if (strbuf_read_file(&olddotgit, gitdir.buf, 0) < 0)
726                 repair = _("gitdir unreadable");
727         else {
728                 strbuf_rtrim(&olddotgit);
729                 if (fspathcmp(olddotgit.buf, realdotgit.buf))
730                         repair = _("gitdir incorrect");
731         }
732
733         if (repair) {
734                 fn(0, gitdir.buf, repair, cb_data);
735                 write_file(gitdir.buf, "%s", realdotgit.buf);
736         }
737 done:
738         free(backlink);
739         strbuf_release(&olddotgit);
740         strbuf_release(&gitdir);
741         strbuf_release(&realdotgit);
742         strbuf_release(&dotgit);
743 }