#include <assert.h>

#include "checkout.h"

#include "git2/repository.h"

#include "git2/refs.h"

#include "git2/tree.h"

#include "git2/blob.h"

#include "git2/config.h"

#include "git2/diff.h"

#include "git2/submodule.h"

#include "refs.h"

#include "repository.h"

#include "filter.h"

#include "blob.h"

#include "diff.h"

#include "pathspec.h"

enum {

CHECKOUT_ACTION__NONE = 0,

CHECKOUT_ACTION__REMOVE = 1,

CHECKOUT_ACTION__UPDATE_BLOB = 2,

CHECKOUT_ACTION__UPDATE_SUBMODULE = 4,

CHECKOUT_ACTION__CONFLICT = 8,

CHECKOUT_ACTION__MAX = 8,

CHECKOUT_ACTION__DEFER_REMOVE = 16,

CHECKOUT_ACTION__REMOVE_AND_UPDATE =

(CHECKOUT_ACTION__UPDATE_BLOB | CHECKOUT_ACTION__REMOVE),

};

typedef struct {

git_repository *repo;

git_diff_list *diff;

git_checkout_opts opts;

bool opts_free_baseline;

char *pfx;

git_index *index;

git_pool pool;

git_vector removes;

git_buf path;

size_t workdir_len;

unsigned int strategy;

int can_symlink;

bool reload_submodules;

size_t total_steps;

size_t completed_steps;

} checkout_data;

static int checkout_notify(

const git_index_entry *wditem)

{

git_diff_file wdfile;

const git_diff_file *baseline = NULL, *target = NULL, *workdir = NULL;

if (!data->opts.notify_cb)

return 0;

if ((why & data->opts.notify_flags) == 0)

return 0;

if (wditem) {

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

git_oid_cpy(&wdfile.oid, &wditem->oid);

wdfile.path = wditem->path;

wdfile.size = wditem->file_size;

wdfile.flags = GIT_DIFF_FILE_VALID_OID;

wdfile.mode = wditem->mode;

workdir = &wdfile;

}

if (delta) {

switch (delta->status) {

case GIT_DELTA_UNMODIFIED:

case GIT_DELTA_MODIFIED:

case GIT_DELTA_TYPECHANGE:

default:

baseline = &delta->old_file;

target = &delta->new_file;

break;

case GIT_DELTA_ADDED:

case GIT_DELTA_IGNORED:

case GIT_DELTA_UNTRACKED:

target = &delta->new_file;

break;

case GIT_DELTA_DELETED:

baseline = &delta->old_file;

break;

}

}

return data->opts.notify_cb(

why, delta ? delta->old_file.path : wditem->path,

baseline, target, workdir, data->opts.notify_payload);

}

static bool checkout_is_workdir_modified(

checkout_data *data,

const git_diff_file *baseitem,

const git_index_entry *wditem)

{

git_oid oid;

/* handle "modified" submodule */

if (wditem->mode == GIT_FILEMODE_COMMIT) {

git_submodule *sm;

unsigned int sm_status = 0;

const git_oid *sm_oid = NULL;

if (git_submodule_lookup(&sm, data->repo, wditem->path) < 0 ||

git_submodule_status(&sm_status, sm) < 0)

return true;

if (GIT_SUBMODULE_STATUS_IS_WD_DIRTY(sm_status))

return true;

sm_oid = git_submodule_wd_id(sm);

if (!sm_oid)

return false;

return (git_oid_cmp(&baseitem->oid, sm_oid) != 0);

}

/* depending on where base is coming from, we may or may not know

if (baseitem->size && wditem->file_size != baseitem->size)

return true;

if (git_diff__oid_for_file(

data->repo, wditem->path, wditem->mode,

wditem->file_size, &oid) < 0)

return false;

return (git_oid_cmp(&baseitem->oid, &oid) != 0);

}

#define CHECKOUT_ACTION_IF(FLAG,YES,NO) \

((data->strategy & GIT_CHECKOUT_##FLAG) ? CHECKOUT_ACTION__##YES : CHECKOUT_ACTION__##NO)

static int checkout_action_common(

const git_index_entry *wd)

{

git_checkout_notify_t notify = GIT_CHECKOUT_NOTIFY_NONE;

if (action <= 0)

return action;

if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0)

action = (action & ~CHECKOUT_ACTION__REMOVE);

if ((action & CHECKOUT_ACTION__UPDATE_BLOB) != 0) {

if (S_ISGITLINK(delta->new_file.mode))

action = (action & ~CHECKOUT_ACTION__UPDATE_BLOB) |

CHECKOUT_ACTION__UPDATE_SUBMODULE;

notify = GIT_CHECKOUT_NOTIFY_UPDATED;

}

if ((action & CHECKOUT_ACTION__CONFLICT) != 0)

notify = GIT_CHECKOUT_NOTIFY_CONFLICT;

if (notify != GIT_CHECKOUT_NOTIFY_NONE &&

checkout_notify(data, notify, delta, wd) != 0)

return GIT_EUSER;

return action;

}

static int checkout_action_no_wd(

checkout_data *data,

const git_diff_delta *delta)

{

int action = CHECKOUT_ACTION__NONE;

switch (delta->status) {

case GIT_DELTA_UNMODIFIED: /* case 12 */

if (checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, NULL))

return GIT_EUSER;

action = CHECKOUT_ACTION_IF(SAFE_CREATE, UPDATE_BLOB, NONE);

break;

case GIT_DELTA_ADDED: /* case 2 or 28 (and 5 but not really) */

case GIT_DELTA_MODIFIED: /* case 13 (and 35 but not really) */

action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);

break;

case GIT_DELTA_TYPECHANGE: /* case 21 (B->T) and 28 (T->B)*/

if (delta->new_file.mode == GIT_FILEMODE_TREE)

action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);

break;

case GIT_DELTA_DELETED: /* case 8 or 25 */

default: /* impossible */

break;

}

return checkout_action_common(data, action, delta, NULL);

}

static int checkout_action_wd_only(

git_vector *pathspec)

{

bool remove = false;

git_checkout_notify_t notify = GIT_CHECKOUT_NOTIFY_NONE;

if (!git_pathspec_match_path(

pathspec, wd->path,

(data->strategy & GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH) != 0,

git_iterator_ignore_case(workdir)))

return 0;

/* check if item is tracked in the index but not in the checkout diff */

if (data->index != NULL) {

if (wd->mode != GIT_FILEMODE_TREE) {

if (git_index_get_bypath(data->index, wd->path, 0) != NULL) {

notify = GIT_CHECKOUT_NOTIFY_DIRTY;

remove = ((data->strategy & GIT_CHECKOUT_FORCE) != 0);

}

} else {

/* for tree entries, we have to see if there are any index

size_t pos = git_index__prefix_position(data->index, wd->path);

const git_index_entry *e = git_index_get_byindex(data->index, pos);

if (e != NULL && data->diff->pfxcomp(e->path, wd->path) == 0) {

notify = GIT_CHECKOUT_NOTIFY_DIRTY;

remove = ((data->strategy & GIT_CHECKOUT_FORCE) != 0);

}

}

}

if (notify != GIT_CHECKOUT_NOTIFY_NONE)

/* found in index */;

else if (git_iterator_current_is_ignored(workdir)) {

notify = GIT_CHECKOUT_NOTIFY_IGNORED;

remove = ((data->strategy & GIT_CHECKOUT_REMOVE_IGNORED) != 0);

}

else {

notify = GIT_CHECKOUT_NOTIFY_UNTRACKED;

remove = ((data->strategy & GIT_CHECKOUT_REMOVE_UNTRACKED) != 0);

}

if (checkout_notify(data, notify, NULL, wd))

return GIT_EUSER;

if (remove) {

char *path = git_pool_strdup(&data->pool, wd->path);

GITERR_CHECK_ALLOC(path);

if (git_vector_insert(&data->removes, path) < 0)

return -1;

}

return 0;

}

static bool submodule_is_config_only(

checkout_data *data,

const char *path)

{

git_submodule *sm = NULL;

unsigned int sm_loc = 0;

if (git_submodule_lookup(&sm, data->repo, path) < 0 ||

git_submodule_location(&sm_loc, sm) < 0 ||

sm_loc == GIT_SUBMODULE_STATUS_IN_CONFIG)

return true;

return false;

}

static int checkout_action_with_wd(

checkout_data *data,

const git_diff_delta *delta,

const git_index_entry *wd)

{

int action = CHECKOUT_ACTION__NONE;

switch (delta->status) {

case GIT_DELTA_UNMODIFIED: /* case 14/15 or 33 */

if (checkout_is_workdir_modified(data, &delta->old_file, wd)) {

if (checkout_notify(

data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, wd))

return GIT_EUSER;

action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, NONE);

}

break;

case GIT_DELTA_ADDED: /* case 3, 4 or 6 */

action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, CONFLICT);

break;

case GIT_DELTA_DELETED: /* case 9 or 10 (or 26 but not really) */

if (checkout_is_workdir_modified(data, &delta->old_file, wd))

action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);

else

action = CHECKOUT_ACTION_IF(SAFE, REMOVE, NONE);

break;

case GIT_DELTA_MODIFIED: /* case 16, 17, 18 (or 36 but not really) */

if (checkout_is_workdir_modified(data, &delta->old_file, wd))

action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, CONFLICT);

else

action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);

break;

case GIT_DELTA_TYPECHANGE: /* case 22, 23, 29, 30 */

if (delta->old_file.mode == GIT_FILEMODE_TREE) {

if (wd->mode == GIT_FILEMODE_TREE)

/* either deleting items in old tree will delete the wd dir,

action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);

else if (wd->mode == GIT_FILEMODE_COMMIT) {

/* workdir is possibly a "phantom" submodule - treat as a

if (submodule_is_config_only(data, wd->path))

action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);

else

action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);

} else

action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);

}

else if (checkout_is_workdir_modified(data, &delta->old_file, wd))

action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);

else

action = CHECKOUT_ACTION_IF(SAFE, REMOVE_AND_UPDATE, NONE);

/* don't update if the typechange is to a tree */

if (delta->new_file.mode == GIT_FILEMODE_TREE)

action = (action & ~CHECKOUT_ACTION__UPDATE_BLOB);

break;

default: /* impossible */

break;

}

return checkout_action_common(data, action, delta, wd);

}

static int checkout_action_with_wd_blocker(

checkout_data *data,

const git_diff_delta *delta,

const git_index_entry *wd)

{

int action = CHECKOUT_ACTION__NONE;

switch (delta->status) {

case GIT_DELTA_UNMODIFIED:

/* should show delta as dirty / deleted */

if (checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, wd))

return GIT_EUSER;

action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, NONE);

break;

case GIT_DELTA_ADDED:

case GIT_DELTA_MODIFIED:

action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);

break;

case GIT_DELTA_DELETED:

action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);

break;

case GIT_DELTA_TYPECHANGE:

/* not 100% certain about this... */

action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);

break;

default: /* impossible */

break;

}

return checkout_action_common(data, action, delta, wd);

}

static int checkout_action_with_wd_dir(

checkout_data *data,

const git_diff_delta *delta,

const git_index_entry *wd)

{

int action = CHECKOUT_ACTION__NONE;

switch (delta->status) {

case GIT_DELTA_UNMODIFIED: /* case 19 or 24 (or 34 but not really) */

if (checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, NULL) ||

checkout_notify(

data, GIT_CHECKOUT_NOTIFY_UNTRACKED, NULL, wd))

return GIT_EUSER;

break;

case GIT_DELTA_ADDED:/* case 4 (and 7 for dir) */

case GIT_DELTA_MODIFIED: /* case 20 (or 37 but not really) */

if (delta->old_file.mode == GIT_FILEMODE_COMMIT)

/* expected submodule (and maybe found one) */;

else if (delta->new_file.mode != GIT_FILEMODE_TREE)

action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);

break;

case GIT_DELTA_DELETED: /* case 11 (and 27 for dir) */

if (delta->old_file.mode != GIT_FILEMODE_TREE &&

checkout_notify(

data, GIT_CHECKOUT_NOTIFY_UNTRACKED, NULL, wd))

return GIT_EUSER;

break;

case GIT_DELTA_TYPECHANGE: /* case 24 or 31 */

if (delta->old_file.mode == GIT_FILEMODE_TREE) {

/* For typechange from dir, remove dir and add blob, but it is

action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);

if (action != CHECKOUT_ACTION__NONE)

action |= CHECKOUT_ACTION__DEFER_REMOVE;

}

else if (delta->new_file.mode != GIT_FILEMODE_TREE)

/* For typechange to dir, dir is already created so no action */

action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);

break;

default: /* impossible */

break;

}

return checkout_action_common(data, action, delta, wd);

}

static int checkout_action(

git_vector *pathspec)

{

const git_index_entry *wd = *wditem_ptr;

int cmp = -1, act;

int (*strcomp)(const char *, const char *) = data->diff->strcomp;

int (*pfxcomp)(const char *str, const char *pfx) = data->diff->pfxcomp;

/* move workdir iterator to follow along with deltas */

while (1) {

if (!wd)

return checkout_action_no_wd(data, delta);

cmp = strcomp(wd->path, delta->old_file.path);

/* 1. wd before delta ("a/a" before "a/b")

if (cmp < 0) {

cmp = pfxcomp(delta->old_file.path, wd->path);

if (cmp == 0) {

if (wd->mode == GIT_FILEMODE_TREE) {

/* case 2 - entry prefixed by workdir tree */

if (git_iterator_advance_into_directory(workdir, &wd) < 0)

goto fail;

continue;

}

/* case 3 maybe - wd contains non-dir where dir expected */

if (delta->old_file.path[strlen(wd->path)] == '/') {

act = checkout_action_with_wd_blocker(data, delta, wd);

*wditem_ptr =

git_iterator_advance(workdir, &wd) ? NULL : wd;

return act;

}

}

/* case 1 - handle wd item (if it matches pathspec) */

if (checkout_action_wd_only(data, workdir, wd, pathspec) < 0 ||

git_iterator_advance(workdir, &wd) < 0)

goto fail;

*wditem_ptr = wd;

continue;

}

if (cmp == 0) {

/* case 4 */

act = checkout_action_with_wd(data, delta, wd);

*wditem_ptr = git_iterator_advance(workdir, &wd) ? NULL : wd;

return act;

}

cmp = pfxcomp(wd->path, delta->old_file.path);

if (cmp == 0) { /* case 5 */

if (wd->path[strlen(delta->old_file.path)] != '/')

return checkout_action_no_wd(data, delta);

if (delta->status == GIT_DELTA_TYPECHANGE) {

if (delta->old_file.mode == GIT_FILEMODE_TREE) {

act = checkout_action_with_wd(data, delta, wd);

if (git_iterator_advance_into_directory(workdir, &wd) < 0)

wd = NULL;

*wditem_ptr = wd;

return act;

}

if (delta->new_file.mode == GIT_FILEMODE_TREE ||

delta->new_file.mode == GIT_FILEMODE_COMMIT ||

delta->old_file.mode == GIT_FILEMODE_COMMIT)

{

act = checkout_action_with_wd(data, delta, wd);

if (git_iterator_advance(workdir, &wd) < 0)

wd = NULL;

*wditem_ptr = wd;

return act;

}

}

return checkout_action_with_wd_dir(data, delta, wd);

}

/* case 6 - wd is after delta */

return checkout_action_no_wd(data, delta);

}

fail:

*wditem_ptr = NULL;

return -1;

}

static int checkout_remaining_wd_items(

git_vector *spec)

{

int error = 0;

while (wd && !error) {

if (!(error = checkout_action_wd_only(data, workdir, wd, spec)))

error = git_iterator_advance(workdir, &wd);

}

return error;

}

static int checkout_get_actions(

git_iterator *workdir)

{

int error = 0;

const git_index_entry *wditem;

git_vector pathspec = GIT_VECTOR_INIT, *deltas;

git_pool pathpool = GIT_POOL_INIT_STRINGPOOL;

git_diff_delta *delta;

size_t i, *counts = NULL;

uint32_t *actions = NULL;

if (data->opts.paths.count > 0 &&

git_pathspec_init(&pathspec, &data->opts.paths, &pathpool) < 0)

return -1;

if ((error = git_iterator_current(workdir, &wditem)) < 0)

goto fail;

deltas = &data->diff->deltas;

*counts_ptr = counts = git__calloc(CHECKOUT_ACTION__MAX+1, sizeof(size_t));

*actions_ptr = actions = git__calloc(

deltas->length ? deltas->length : 1, sizeof(uint32_t));

if (!counts || !actions) {

error = -1;

goto fail;

}

git_vector_foreach(deltas, i, delta) {

int act = checkout_action(data, delta, workdir, &wditem, &pathspec);

if (act < 0) {

error = act;

goto fail;

}

actions[i] = act;

if (act & CHECKOUT_ACTION__REMOVE)

counts[CHECKOUT_ACTION__REMOVE]++;

if (act & CHECKOUT_ACTION__UPDATE_BLOB)

counts[CHECKOUT_ACTION__UPDATE_BLOB]++;

if (act & CHECKOUT_ACTION__UPDATE_SUBMODULE)

counts[CHECKOUT_ACTION__UPDATE_SUBMODULE]++;

if (act & CHECKOUT_ACTION__CONFLICT)

counts[CHECKOUT_ACTION__CONFLICT]++;

}

error = checkout_remaining_wd_items(data, workdir, wditem, &pathspec);

if (error < 0)

goto fail;

counts[CHECKOUT_ACTION__REMOVE] += data->removes.length;

if (counts[CHECKOUT_ACTION__CONFLICT] > 0 &&

(data->strategy & GIT_CHECKOUT_ALLOW_CONFLICTS) == 0)

{

giterr_set(GITERR_CHECKOUT, "%d conflicts prevent checkout",

(int)counts[CHECKOUT_ACTION__CONFLICT]);

error = GIT_EMERGECONFLICT;

goto fail;

}

git_pathspec_free(&pathspec);

git_pool_clear(&pathpool);

return 0;

fail:

*counts_ptr = NULL;

git__free(counts);

*actions_ptr = NULL;

git__free(actions);

git_pathspec_free(&pathspec);

git_pool_clear(&pathpool);

return error;

}

static int buffer_to_file(

mode_t file_mode)

{

int fd, error;

if ((error = git_futils_mkpath2file(path, dir_mode)) < 0)

return error;

if ((fd = p_open(path, file_open_flags, file_mode)) < 0) {

giterr_set(GITERR_OS, "Could not open '%s' for writing", path);

return fd;

}

if ((error = p_write(fd, git_buf_cstr(buffer), git_buf_len(buffer))) < 0) {

giterr_set(GITERR_OS, "Could not write to '%s'", path);

(void)p_close(fd);

} else {

if ((error = p_fstat(fd, st)) < 0)

giterr_set(GITERR_OS, "Error while statting '%s'", path);

if ((error = p_close(fd)) < 0)

giterr_set(GITERR_OS, "Error while closing '%s'", path);

}

if (!error &&

(file_mode & 0100) != 0 &&

(error = p_chmod(path, file_mode)) < 0)

giterr_set(GITERR_OS, "Failed to set permissions on '%s'", path);

return error;

}

static int blob_content_to_file(

git_checkout_opts *opts)

{

int error = -1, nb_filters = 0;

mode_t file_mode = opts->file_mode;

bool dont_free_filtered = false;

git_buf unfiltered = GIT_BUF_INIT, filtered = GIT_BUF_INIT;

git_vector filters = GIT_VECTOR_INIT;

/* Create a fake git_buf from the blob raw data... */

filtered.ptr = blob->odb_object->raw.data;

filtered.size = blob->odb_object->raw.len;

/* ... and make sure it doesn't get unexpectedly freed */

dont_free_filtered = true;

if (!opts->disable_filters &&

!git_buf_text_is_binary(&filtered) &&

(nb_filters = git_filters_load(

&filters,

git_object_owner((git_object *)blob),

path,

GIT_FILTER_TO_WORKTREE)) > 0)

{

/* reset 'filtered' so it can be a filter target */

git_buf_init(&filtered, 0);

dont_free_filtered = false;

}

if (nb_filters < 0)

return nb_filters;

if (nb_filters > 0) {

if ((error = git_blob__getbuf(&unfiltered, blob)) < 0)

goto cleanup;

if ((error = git_filters_apply(&filtered, &unfiltered, &filters)) < 0)

goto cleanup;

}

/* Allow overriding of file mode */

if (!file_mode)

file_mode = entry_filemode;

error = buffer_to_file(

st, &filtered, path, opts->dir_mode, opts->file_open_flags, file_mode);

if (!error)

st->st_mode = entry_filemode;

cleanup:

git_filters_free(&filters);

git_buf_free(&unfiltered);

if (!dont_free_filtered)

git_buf_free(&filtered);

return error;

}

static int blob_content_to_link(

struct stat *st, git_blob *blob, const char *path, int can_symlink)

{

git_buf linktarget = GIT_BUF_INIT;

int error;

if ((error = git_blob__getbuf(&linktarget, blob)) < 0)

return error;

if (can_symlink) {

if ((error = p_symlink(git_buf_cstr(&linktarget), path)) < 0)

giterr_set(GITERR_CHECKOUT, "Could not create symlink %s\n", path);

} else {

error = git_futils_fake_symlink(git_buf_cstr(&linktarget), path);

}

if (!error) {

if ((error = p_lstat(path, st)) < 0)

giterr_set(GITERR_CHECKOUT, "Could not stat symlink %s", path);

st->st_mode = GIT_FILEMODE_LINK;

}

git_buf_free(&linktarget);

return error;

}

static int checkout_update_index(

checkout_data *data,

const git_diff_file *file,

struct stat *st)

{

git_index_entry entry;

if (!data->index)

return 0;

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

entry.path = (char *)file->path; /* cast to prevent warning */

git_index_entry__init_from_stat(&entry, st);

git_oid_cpy(&entry.oid, &file->oid);

return git_index_add(data->index, &entry);

}

static int checkout_submodule(

checkout_data *data,

const git_diff_file *file)

{

int error = 0;

git_submodule *sm;

/* Until submodules are supported, UPDATE_ONLY means do nothing here */

if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0)

return 0;

if ((error = git_futils_mkdir(

file->path, git_repository_workdir(data->repo),

data->opts.dir_mode, GIT_MKDIR_PATH)) < 0)

return error;

if ((error = git_submodule_lookup(&sm, data->repo, file->path)) < 0)

return error;

/* TODO: Support checkout_strategy options. Two circumstances:

/* update the index unless prevented */

if ((data->strategy & GIT_CHECKOUT_DONT_UPDATE_INDEX) == 0) {

struct stat st;

git_buf_truncate(&data->path, data->workdir_len);

if (git_buf_puts(&data->path, file->path) < 0)

return -1;

if ((error = p_stat(git_buf_cstr(&data->path), &st)) < 0) {

giterr_set(

GITERR_CHECKOUT, "Could not stat submodule %s\n", file->path);

return error;

}

st.st_mode = GIT_FILEMODE_COMMIT;

error = checkout_update_index(data, file, &st);

}

return error;

}

static void report_progress(

checkout_data *data,

const char *path)

{

if (data->opts.progress_cb)

data->opts.progress_cb(

path, data->completed_steps, data->total_steps,

data->opts.progress_payload);

}

static int checkout_safe_for_update_only(const char *path, mode_t expected_mode)

{

struct stat st;

if (p_lstat(path, &st) < 0) {

/* if doesn't exist, then no error and no update */

if (errno == ENOENT || errno == ENOTDIR)

return 0;

/* otherwise, stat error and no update */

giterr_set(GITERR_OS, "Failed to stat file '%s'", path);

return -1;

}

/* only safe for update if this is the same type of file */

if ((st.st_mode & ~0777) == (expected_mode & ~0777))

return 1;

return 0;

}

static int checkout_blob(

checkout_data *data,

const git_diff_file *file)

{

int error = 0;

git_blob *blob;

struct stat st;

git_buf_truncate(&data->path, data->workdir_len);

if (git_buf_puts(&data->path, file->path) < 0)

return -1;

if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0) {

int rval = checkout_safe_for_update_only(

git_buf_cstr(&data->path), file->mode);

if (rval <= 0)

return rval;

}

if ((error = git_blob_lookup(&blob, data->repo, &file->oid)) < 0)

return error;

if (S_ISLNK(file->mode))

error = blob_content_to_link(

&st, blob, git_buf_cstr(&data->path), data->can_symlink);

else

error = blob_content_to_file(

&st, blob, git_buf_cstr(&data->path), file->mode, &data->opts);

git_blob_free(blob);

/* if we try to create the blob and an existing directory blocks it from

if ((data->strategy & GIT_CHECKOUT_ALLOW_CONFLICTS) != 0 &&

(error == GIT_ENOTFOUND || error == GIT_EEXISTS))

{

giterr_clear();

error = 0;

}

/* update the index unless prevented */

if (!error && (data->strategy & GIT_CHECKOUT_DONT_UPDATE_INDEX) == 0)

error = checkout_update_index(data, file, &st);

/* update the submodule data if this was a new .gitmodules file */

if (!error && strcmp(file->path, ".gitmodules") == 0)

data->reload_submodules = true;

return error;

}

static int checkout_remove_the_old(

unsigned int *actions,

checkout_data *data)

{

int error = 0;

git_diff_delta *delta;

const char *str;

size_t i;

const char *workdir = git_buf_cstr(&data->path);

uint32_t flg = GIT_RMDIR_EMPTY_PARENTS |

GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS;

git_buf_truncate(&data->path, data->workdir_len);

git_vector_foreach(&data->diff->deltas, i, delta) {

if (actions[i] & CHECKOUT_ACTION__REMOVE) {

error = git_futils_rmdir_r(delta->old_file.path, workdir, flg);

if (error < 0)

return error;

data->completed_steps++;

report_progress(data, delta->old_file.path);

if ((actions[i] & CHECKOUT_ACTION__UPDATE_BLOB) == 0 &&

(data->strategy & GIT_CHECKOUT_DONT_UPDATE_INDEX) == 0 &&

data->index != NULL)

{

(void)git_index_remove(data->index, delta->old_file.path, 0);

}

}

}

git_vector_foreach(&data->removes, i, str) {

error = git_futils_rmdir_r(str, workdir, flg);

if (error < 0)

return error;

data->completed_steps++;

report_progress(data, str);

if ((data->strategy & GIT_CHECKOUT_DONT_UPDATE_INDEX) == 0 &&

data->index != NULL)

{

if (str[strlen(str) - 1] == '/')

(void)git_index_remove_directory(data->index, str, 0);

else

(void)git_index_remove(data->index, str, 0);

}

}

return 0;

}

static int checkout_deferred_remove(git_repository *repo, const char *path)

{

#if 0

int error = git_futils_rmdir_r(

path, git_repository_workdir(repo), GIT_RMDIR_EMPTY_PARENTS);

if (error == GIT_ENOTFOUND) {

error = 0;

giterr_clear();

}

return error;

GIT_UNUSED(repo);

GIT_UNUSED(path);

assert(false);

return 0;

}

static int checkout_create_the_new(

unsigned int *actions,

checkout_data *data)

{

int error = 0;

git_diff_delta *delta;

size_t i;

git_vector_foreach(&data->diff->deltas, i, delta) {