#include "git-compat-util.h"

#include "abspath.h"

#include "environment.h"

#include "gettext.h"

#include "path.h"

#include "repository.h"

#include "refs.h"

#include "setup.h"

#include "strbuf.h"

#include "worktree.h"

#include "dir.h"

#include "wt-status.h"

#include "config.h"

void free_worktree(struct worktree *worktree)

{

if (!worktree)

return;

free(worktree->path);

free(worktree->id);

free(worktree->head_ref);

free(worktree->lock_reason);

free(worktree->prune_reason);

free(worktree);

}

void free_worktrees(struct worktree **worktrees)

{

int i = 0;

for (i = 0; worktrees[i]; i++)

free_worktree(worktrees[i]);

free (worktrees);

}

/**

* Update head_oid, head_ref and is_detached of the given worktree

*/

static void add_head_info(struct worktree *wt)

{

int flags;

const char *target;

target = refs_resolve_ref_unsafe(get_worktree_ref_store(wt),

"HEAD",

0,

&wt->head_oid, &flags);

if (!target)

return;

if (flags & REF_ISSYMREF)

wt->head_ref = xstrdup(target);

else

wt->is_detached = 1;

}

/**

* get the main worktree

*/

static struct worktree *get_main_worktree(int skip_reading_head)

{

struct worktree *worktree = NULL;

struct strbuf worktree_path = STRBUF_INIT;

strbuf_add_real_path(&worktree_path, get_git_common_dir());

strbuf_strip_suffix(&worktree_path, "/.git");

CALLOC_ARRAY(worktree, 1);

worktree->repo = the_repository;

worktree->path = strbuf_detach(&worktree_path, NULL);

/*

* NEEDSWORK: If this function is called from a secondary worktree and

* config.worktree is present, is_bare_repository_cfg will reflect the

* contents of config.worktree, not the contents of the main worktree.

* This means that worktree->is_bare may be set to 0 even if the main

* worktree is configured to be bare.

*/

worktree->is_bare = (is_bare_repository_cfg == 1) ||

is_bare_repository();

if (!skip_reading_head)

add_head_info(worktree);

return worktree;

}

struct worktree *get_linked_worktree(const char *id,

int skip_reading_head)

{

struct worktree *worktree = NULL;

struct strbuf path = STRBUF_INIT;

struct strbuf worktree_path = STRBUF_INIT;

if (!id)

die("Missing linked worktree name");

strbuf_git_common_path(&path, the_repository, "worktrees/%s/gitdir", id);

if (strbuf_read_file(&worktree_path, path.buf, 0) <= 0)

/* invalid gitdir file */

goto done;

strbuf_rtrim(&worktree_path);

strbuf_strip_suffix(&worktree_path, "/.git");

CALLOC_ARRAY(worktree, 1);

worktree->repo = the_repository;

worktree->path = strbuf_detach(&worktree_path, NULL);

worktree->id = xstrdup(id);

if (!skip_reading_head)

add_head_info(worktree);

done:

strbuf_release(&path);

strbuf_release(&worktree_path);

return worktree;

}

static void mark_current_worktree(struct worktree **worktrees)

{

char *git_dir = absolute_pathdup(get_git_dir());

int i;

for (i = 0; worktrees[i]; i++) {

struct worktree *wt = worktrees[i];

const char *wt_git_dir = get_worktree_git_dir(wt);

if (!fspathcmp(git_dir, absolute_path(wt_git_dir))) {

wt->is_current = 1;

break;

}

}

free(git_dir);

}

/*

* NEEDSWORK: This function exists so that we can look up metadata of a

* worktree without trying to access any of its internals like the refdb. It

* would be preferable to instead have a corruption-tolerant function for

* retrieving worktree metadata that could be used when the worktree is known

* to not be in a healthy state, e.g. when creating or repairing it.

*/

static struct worktree **get_worktrees_internal(int skip_reading_head)

{

struct worktree **list = NULL;

struct strbuf path = STRBUF_INIT;

DIR *dir;

struct dirent *d;

int counter = 0, alloc = 2;

ALLOC_ARRAY(list, alloc);

list[counter++] = get_main_worktree(skip_reading_head);

strbuf_addf(&path, "%s/worktrees", get_git_common_dir());

dir = opendir(path.buf);

strbuf_release(&path);

if (dir) {

while ((d = readdir_skip_dot_and_dotdot(dir)) != NULL) {

struct worktree *linked = NULL;

if ((linked = get_linked_worktree(d->d_name, skip_reading_head))) {

ALLOC_GROW(list, counter + 1, alloc);

list[counter++] = linked;

}

}

closedir(dir);

}

ALLOC_GROW(list, counter + 1, alloc);

list[counter] = NULL;

mark_current_worktree(list);

return list;

}

struct worktree **get_worktrees(void)

{

return get_worktrees_internal(0);

}

const char *get_worktree_git_dir(const struct worktree *wt)

{

if (!wt)

return get_git_dir();

else if (!wt->id)

return get_git_common_dir();

else

return git_common_path("worktrees/%s", wt->id);

}

static struct worktree *find_worktree_by_suffix(struct worktree **list,

const char *suffix)

{

struct worktree *found = NULL;

int nr_found = 0, suffixlen;

suffixlen = strlen(suffix);

if (!suffixlen)

return NULL;

for (; *list && nr_found < 2; list++) {

const char *path = (*list)->path;

int pathlen = strlen(path);

int start = pathlen - suffixlen;

/* suffix must start at directory boundary */

if ((!start || (start > 0 && is_dir_sep(path[start - 1]))) &&

!fspathcmp(suffix, path + start)) {

found = *list;

nr_found++;

}

}

return nr_found == 1 ? found : NULL;

}

struct worktree *find_worktree(struct worktree **list,

const char *prefix,

const char *arg)

{

struct worktree *wt;

char *to_free = NULL;

if ((wt = find_worktree_by_suffix(list, arg)))

return wt;

if (prefix)

arg = to_free = prefix_filename(prefix, arg);

wt = find_worktree_by_path(list, arg);

free(to_free);

return wt;

}

struct worktree *find_worktree_by_path(struct worktree **list, const char *p)

{

struct strbuf wt_path = STRBUF_INIT;

char *path = real_pathdup(p, 0);

if (!path)

return NULL;

for (; *list; list++) {

if (!strbuf_realpath(&wt_path, (*list)->path, 0))

continue;

if (!fspathcmp(path, wt_path.buf))

break;

}

free(path);

strbuf_release(&wt_path);

return *list;

}

int is_main_worktree(const struct worktree *wt)

{

return !wt->id;

}

const char *worktree_lock_reason(struct worktree *wt)

{

if (is_main_worktree(wt))

return NULL;

if (!wt->lock_reason_valid) {

struct strbuf path = STRBUF_INIT;

strbuf_addstr(&path, worktree_git_path(wt, "locked"));

if (file_exists(path.buf)) {

struct strbuf lock_reason = STRBUF_INIT;

if (strbuf_read_file(&lock_reason, path.buf, 0) < 0)

die_errno(_("failed to read '%s'"), path.buf);

strbuf_trim(&lock_reason);

wt->lock_reason = strbuf_detach(&lock_reason, NULL);

} else

wt->lock_reason = NULL;

wt->lock_reason_valid = 1;

strbuf_release(&path);

}

return wt->lock_reason;

}

const char *worktree_prune_reason(struct worktree *wt, timestamp_t expire)

{

struct strbuf reason = STRBUF_INIT;

char *path = NULL;

if (is_main_worktree(wt))

return NULL;

if (wt->prune_reason_valid)

return wt->prune_reason;

if (should_prune_worktree(wt->id, &reason, &path, expire))

wt->prune_reason = strbuf_detach(&reason, NULL);

wt->prune_reason_valid = 1;

strbuf_release(&reason);

free(path);

return wt->prune_reason;

}

/* convenient wrapper to deal with NULL strbuf */

__attribute__((format (printf, 2, 3)))

static void strbuf_addf_gently(struct strbuf *buf, const char *fmt, ...)

{

va_list params;

if (!buf)

return;

va_start(params, fmt);

strbuf_vaddf(buf, fmt, params);

va_end(params);

}

int validate_worktree(const struct worktree *wt, struct strbuf *errmsg,

unsigned flags)

{

struct strbuf wt_path = STRBUF_INIT;

struct strbuf realpath = STRBUF_INIT;

char *path = NULL;

int err, ret = -1;

strbuf_addf(&wt_path, "%s/.git", wt->path);

if (is_main_worktree(wt)) {

if (is_directory(wt_path.buf)) {

ret = 0;

goto done;

}

/*

* Main worktree using .git file to point to the

* repository would make it impossible to know where

* the actual worktree is if this function is executed

* from another worktree. No .git file support for now.

*/

strbuf_addf_gently(errmsg,

_("'%s' at main working tree is not the repository directory"),

wt_path.buf);

goto done;

}

/*

* Make sure "gitdir" file points to a real .git file and that

* file points back here.

*/

if (!is_absolute_path(wt->path)) {

strbuf_addf_gently(errmsg,

_("'%s' file does not contain absolute path to the working tree location"),

git_common_path("worktrees/%s/gitdir", wt->id));

goto done;

}

if (flags & WT_VALIDATE_WORKTREE_MISSING_OK &&

!file_exists(wt->path)) {

ret = 0;

goto done;

}

if (!file_exists(wt_path.buf)) {

strbuf_addf_gently(errmsg, _("'%s' does not exist"), wt_path.buf);

goto done;

}

path = xstrdup_or_null(read_gitfile_gently(wt_path.buf, &err));

if (!path) {

strbuf_addf_gently(errmsg, _("'%s' is not a .git file, error code %d"),

wt_path.buf, err);

goto done;

}

strbuf_realpath(&realpath, git_common_path("worktrees/%s", wt->id), 1);

ret = fspathcmp(path, realpath.buf);

if (ret)

strbuf_addf_gently(errmsg, _("'%s' does not point back to '%s'"),

wt->path, git_common_path("worktrees/%s", wt->id));

done:

free(path);

strbuf_release(&wt_path);

strbuf_release(&realpath);

return ret;

}

void update_worktree_location(struct worktree *wt, const char *path_)

{

struct strbuf path = STRBUF_INIT;

if (is_main_worktree(wt))

BUG("can't relocate main worktree");

strbuf_realpath(&path, path_, 1);

if (fspathcmp(wt->path, path.buf)) {

write_file(git_common_path("worktrees/%s/gitdir", wt->id),

"%s/.git", path.buf);

free(wt->path);

wt->path = strbuf_detach(&path, NULL);

}

strbuf_release(&path);

}

int is_worktree_being_rebased(const struct worktree *wt,

const char *target)

{

struct wt_status_state state;

int found_rebase;

memset(&state, 0, sizeof(state));

found_rebase = wt_status_check_rebase(wt, &state) &&

(state.rebase_in_progress ||

state.rebase_interactive_in_progress) &&

state.branch &&

skip_prefix(target, "refs/heads/", &target) &&

!strcmp(state.branch, target);

wt_status_state_free_buffers(&state);

return found_rebase;

}

int is_worktree_being_bisected(const struct worktree *wt,

const char *target)

{

struct wt_status_state state;

int found_bisect;

memset(&state, 0, sizeof(state));

found_bisect = wt_status_check_bisect(wt, &state) &&

state.bisecting_from &&

skip_prefix(target, "refs/heads/", &target) &&

!strcmp(state.bisecting_from, target);

wt_status_state_free_buffers(&state);

return found_bisect;

}

/*

* note: this function should be able to detect shared symref even if

* HEAD is temporarily detached (e.g. in the middle of rebase or

* bisect). New commands that do similar things should update this

* function as well.

*/

int is_shared_symref(const struct worktree *wt, const char *symref,

const char *target)

{

const char *symref_target;

struct ref_store *refs;

int flags;

if (wt->is_bare)

return 0;

if (wt->is_detached && !strcmp(symref, "HEAD")) {

if (is_worktree_being_rebased(wt, target))

return 1;

if (is_worktree_being_bisected(wt, target))

return 1;

}

refs = get_worktree_ref_store(wt);

symref_target = refs_resolve_ref_unsafe(refs, symref, 0,

NULL, &flags);

if ((flags & REF_ISSYMREF) &&

symref_target && !strcmp(symref_target, target))

return 1;

return 0;

}

const struct worktree *find_shared_symref(struct worktree **worktrees,

const char *symref,

const char *target)

{

for (int i = 0; worktrees[i]; i++)

if (is_shared_symref(worktrees[i], symref, target))

return worktrees[i];

return NULL;

}

int submodule_uses_worktrees(const char *path)

{

char *submodule_gitdir;

struct strbuf sb = STRBUF_INIT, err = STRBUF_INIT;

DIR *dir;

struct dirent *d;

int ret = 0;

struct repository_format format = REPOSITORY_FORMAT_INIT;

submodule_gitdir = git_pathdup_submodule(path, "%s", "");

if (!submodule_gitdir)

return 0;

/* The env would be set for the superproject. */

get_common_dir_noenv(&sb, submodule_gitdir);

free(submodule_gitdir);

strbuf_addstr(&sb, "/config");

read_repository_format(&format, sb.buf);

if (verify_repository_format(&format, &err)) {

strbuf_release(&err);

strbuf_release(&sb);

clear_repository_format(&format);

return 1;

}

clear_repository_format(&format);

strbuf_release(&err);

/* Replace config by worktrees. */

strbuf_setlen(&sb, sb.len - strlen("config"));

strbuf_addstr(&sb, "worktrees");

/* See if there is any file inside the worktrees directory. */

dir = opendir(sb.buf);

strbuf_release(&sb);

if (!dir)

return 0;

d = readdir_skip_dot_and_dotdot(dir);

if (d)

ret = 1;

closedir(dir);

return ret;

}

void strbuf_worktree_ref(const struct worktree *wt,

struct strbuf *sb,

const char *refname)

{

if (parse_worktree_ref(refname, NULL, NULL, NULL) ==

REF_WORKTREE_CURRENT &&

wt && !wt->is_current) {

if (is_main_worktree(wt))

strbuf_addstr(sb, "main-worktree/");

else

strbuf_addf(sb, "worktrees/%s/", wt->id);

}

strbuf_addstr(sb, refname);

}

int other_head_refs(each_ref_fn fn, void *cb_data)

{

struct worktree **worktrees, **p;

struct strbuf refname = STRBUF_INIT;

int ret = 0;

worktrees = get_worktrees();

for (p = worktrees; *p; p++) {

struct worktree *wt = *p;

struct object_id oid;

int flag;

if (wt->is_current)

continue;

strbuf_reset(&refname);

strbuf_worktree_ref(wt, &refname, "HEAD");

if (refs_resolve_ref_unsafe(get_main_ref_store(the_repository),

refname.buf,

RESOLVE_REF_READING,

&oid, &flag))

ret = fn(refname.buf, &oid, flag, cb_data);

if (ret)

break;

}

free_worktrees(worktrees);

strbuf_release(&refname);

return ret;

}

/*

* Repair worktree's /path/to/worktree/.git file if missing, corrupt, or not

* pointing at <repo>/worktrees/<id>.

*/

static void repair_gitfile(struct worktree *wt,

worktree_repair_fn fn, void *cb_data)

{

struct strbuf dotgit = STRBUF_INIT;

struct strbuf repo = STRBUF_INIT;

char *backlink;

const char *repair = NULL;

int err;

/* missing worktree can't be repaired */

if (!file_exists(wt->path))

return;

if (!is_directory(wt->path)) {

fn(1, wt->path, _("not a directory"), cb_data);

return;

}

strbuf_realpath(&repo, git_common_path("worktrees/%s", wt->id), 1);

strbuf_addf(&dotgit, "%s/.git", wt->path);

backlink = xstrdup_or_null(read_gitfile_gently(dotgit.buf, &err));

if (err == READ_GITFILE_ERR_NOT_A_FILE)

fn(1, wt->path, _(".git is not a file"), cb_data);

else if (err)

repair = _(".git file broken");

else if (fspathcmp(backlink, repo.buf))

repair = _(".git file incorrect");

if (repair) {

fn(0, wt->path, repair, cb_data);

write_file(dotgit.buf, "gitdir: %s", repo.buf);

}

free(backlink);

strbuf_release(&repo);

strbuf_release(&dotgit);

}

static void repair_noop(int iserr UNUSED,

const char *path UNUSED,

const char *msg UNUSED,

void *cb_data UNUSED)

{

/* nothing */

}

void repair_worktrees(worktree_repair_fn fn, void *cb_data)

{

struct worktree **worktrees = get_worktrees_internal(1);

struct worktree **wt = worktrees + 1; /* +1 skips main worktree */

if (!fn)

fn = repair_noop;

for (; *wt; wt++)

repair_gitfile(*wt, fn, cb_data);

free_worktrees(worktrees);

}

static int is_main_worktree_path(const char *path)

{

struct strbuf target = STRBUF_INIT;

struct strbuf maindir = STRBUF_INIT;

int cmp;

strbuf_add_real_path(&target, path);

strbuf_strip_suffix(&target, "/.git");

strbuf_add_real_path(&maindir, get_git_common_dir());

strbuf_strip_suffix(&maindir, "/.git");

cmp = fspathcmp(maindir.buf, target.buf);

strbuf_release(&maindir);

strbuf_release(&target);

return !cmp;

}

/*

* If both the main worktree and linked worktree have been moved, then the

* gitfile /path/to/worktree/.git won't point into the repository, thus we

* won't know which <repo>/worktrees/<id>/gitdir to repair. However, we may

* be able to infer the gitdir by manually reading /path/to/worktree/.git,

* extracting the <id>, and checking if <repo>/worktrees/<id> exists.

*/

static char *infer_backlink(const char *gitfile)

{

struct strbuf actual = STRBUF_INIT;

struct strbuf inferred = STRBUF_INIT;

const char *id;

if (strbuf_read_file(&actual, gitfile, 0) < 0)

goto error;

if (!starts_with(actual.buf, "gitdir:"))

goto error;

if (!(id = find_last_dir_sep(actual.buf)))

goto error;

strbuf_trim(&actual);

id++; /* advance past '/' to point at <id> */

if (!*id)

goto error;

strbuf_git_common_path(&inferred, the_repository, "worktrees/%s", id);

if (!is_directory(inferred.buf))

goto error;

strbuf_release(&actual);

return strbuf_detach(&inferred, NULL);

error:

strbuf_release(&actual);

strbuf_release(&inferred);

return NULL;

}

/*

* Repair <repo>/worktrees/<id>/gitdir if missing, corrupt, or not pointing at

* the worktree's path.

*/

void repair_worktree_at_path(const char *path,

worktree_repair_fn fn, void *cb_data)

{

struct strbuf dotgit = STRBUF_INIT;

struct strbuf realdotgit = STRBUF_INIT;

struct strbuf gitdir = STRBUF_INIT;

struct strbuf olddotgit = STRBUF_INIT;

char *backlink = NULL;

const char *repair = NULL;

int err;

if (!fn)

fn = repair_noop;

if (is_main_worktree_path(path))

goto done;

strbuf_addf(&dotgit, "%s/.git", path);

if (!strbuf_realpath(&realdotgit, dotgit.buf, 0)) {

fn(1, path, _("not a valid path"), cb_data);

goto done;

}

backlink = xstrdup_or_null(read_gitfile_gently(realdotgit.buf, &err));

if (err == READ_GITFILE_ERR_NOT_A_FILE) {

fn(1, realdotgit.buf, _("unable to locate repository; .git is not a file"), cb_data);

goto done;

} else if (err == READ_GITFILE_ERR_NOT_A_REPO) {

if (!(backlink = infer_backlink(realdotgit.buf))) {

fn(1, realdotgit.buf, _("unable to locate repository; .git file does not reference a repository"), cb_data);

goto done;

}

} else if (err) {

fn(1, realdotgit.buf, _("unable to locate repository; .git file broken"), cb_data);

goto done;

}

strbuf_addf(&gitdir, "%s/gitdir", backlink);

if (strbuf_read_file(&olddotgit, gitdir.buf, 0) < 0)

repair = _("gitdir unreadable");

else {

strbuf_rtrim(&olddotgit);

if (fspathcmp(olddotgit.buf, realdotgit.buf))

repair = _("gitdir incorrect");

}

if (repair) {

fn(0, gitdir.buf, repair, cb_data);

write_file(gitdir.buf, "%s", realdotgit.buf);

}

done:

free(backlink);

strbuf_release(&olddotgit);

strbuf_release(&gitdir);

strbuf_release(&realdotgit);

strbuf_release(&dotgit);

}

int should_prune_worktree(const char *id, struct strbuf *reason, char **wtpath, timestamp_t expire)

{

struct stat st;

char *path;

int fd;

size_t len;

ssize_t read_result;

*wtpath = NULL;

if (!is_directory(git_path("worktrees/%s", id))) {

strbuf_addstr(reason, _("not a valid directory"));

return 1;

}

if (file_exists(git_path("worktrees/%s/locked", id)))

return 0;

if (stat(git_path("worktrees/%s/gitdir", id), &st)) {

strbuf_addstr(reason, _("gitdir file does not exist"));

return 1;

}

fd = open(git_path("worktrees/%s/gitdir", id), O_RDONLY);

if (fd < 0) {

strbuf_addf(reason, _("unable to read gitdir file (%s)"),

strerror(errno));

return 1;

}

len = xsize_t(st.st_size);

path = xmallocz(len);

read_result = read_in_full(fd, path, len);

if (read_result < 0) {

strbuf_addf(reason, _("unable to read gitdir file (%s)"),

strerror(errno));

close(fd);

free(path);

return 1;

}

close(fd);

if (read_result != len) {

strbuf_addf(reason,

_("short read (expected %"PRIuMAX" bytes, read %"PRIuMAX")"),

(uintmax_t)len, (uintmax_t)read_result);

free(path);

return 1;

}

while (len && (path[len - 1] == '\n' || path[len - 1] == '\r'))

len--;

if (!len) {

strbuf_addstr(reason, _("invalid gitdir file"));

free(path);

return 1;

}

path[len] = '\0';

if (!file_exists(path)) {

if (stat(git_path("worktrees/%s/index", id), &st) ||

st.st_mtime <= expire) {

strbuf_addstr(reason, _("gitdir file points to non-existent location"));

free(path);

return 1;

} else {

*wtpath = path;

return 0;

}

}

*wtpath = path;

return 0;

}

static int move_config_setting(const char *key, const char *value,

const char *from_file, const char *to_file)

{

if (git_config_set_in_file_gently(to_file, key, NULL, value))

return error(_("unable to set %s in '%s'"), key, to_file);

if (git_config_set_in_file_gently(from_file, key, NULL, NULL))

return error(_("unable to unset %s in '%s'"), key, from_file);

return 0;

}

int init_worktree_config(struct repository *r)

{

int res = 0;

int bare = 0;

struct config_set cs = { { 0 } };

const char *core_worktree;

char *common_config_file;

char *main_worktree_file;

/*

* If the extension is already enabled, then we can skip the

* upgrade process.

*/

if (r->repository_format_worktree_config)

return 0;

if ((res = git_config_set_gently("extensions.worktreeConfig", "true")))

return error(_("failed to set extensions.worktreeConfig setting"));

common_config_file = xstrfmt("%s/config", r->commondir);

main_worktree_file = xstrfmt("%s/config.worktree", r->commondir);

git_configset_init(&cs);

git_configset_add_file(&cs, common_config_file);

/*

* If core.bare is true in the common config file, then we need to

* move it to the main worktree's config file or it will break all

* worktrees. If it is false, then leave it in place because it

* _could_ be negating a global core.bare=true.

*/

if (!git_configset_get_bool(&cs, "core.bare", &bare) && bare) {

if ((res = move_config_setting("core.bare", "true",

common_config_file,

main_worktree_file)))

goto cleanup;

}

/*

* If core.worktree is set, then the main worktree is located

* somewhere different than the parent of the common Git dir.

* Relocate that value to avoid breaking all worktrees with this

* upgrade to worktree config.

*/

if (!git_configset_get_value(&cs, "core.worktree", &core_worktree, NULL)) {

if ((res = move_config_setting("core.worktree", core_worktree,

common_config_file,

main_worktree_file)))

goto cleanup;

}

/*

* Ensure that we use worktree config for the remaining lifetime

* of the current process.

*/

r->repository_format_worktree_config = 1;

cleanup:

git_configset_clear(&cs);

free(common_config_file);

free(main_worktree_file);

return res;

}