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