#include "common.h"

#include "diff.h"

#include "fileops.h"

#include "config.h"

#include "attr_file.h"

#include "filter.h"

#include "pathspec.h"

#include "index.h"

#include "odb.h"

#include "submodule.h"

#define DIFF_FLAG_IS_SET(DIFF,FLAG) (((DIFF)->opts.flags & (FLAG)) != 0)

#define DIFF_FLAG_ISNT_SET(DIFF,FLAG) (((DIFF)->opts.flags & (FLAG)) == 0)

#define DIFF_FLAG_SET(DIFF,FLAG,VAL) (DIFF)->opts.flags = \

(VAL) ? ((DIFF)->opts.flags | (FLAG)) : ((DIFF)->opts.flags & ~(VAL))

static git_diff_delta *diff_delta__alloc(

git_diff *diff,

git_delta_t status,

const char *path)

{

git_diff_delta *delta = git__calloc(1, sizeof(git_diff_delta));

if (!delta)

return NULL;

delta->old_file.path = git_pool_strdup(&diff->pool, path);

if (delta->old_file.path == NULL) {

git__free(delta);

return NULL;

}

delta->new_file.path = delta->old_file.path;

if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE)) {

switch (status) {

case GIT_DELTA_ADDED: status = GIT_DELTA_DELETED; break;

case GIT_DELTA_DELETED: status = GIT_DELTA_ADDED; break;

default: break; /* leave other status values alone */

}

}

delta->status = status;

return delta;

}

static int diff_insert_delta(

git_diff *diff, git_diff_delta *delta, const char *matched_pathspec)

{

int error = 0;

if (diff->opts.notify_cb) {

error = diff->opts.notify_cb(

diff, delta, matched_pathspec, diff->opts.notify_payload);

if (error) {

git__free(delta);

if (error > 0) /* positive value means to skip this delta */

return 0;

else /* negative value means to cancel diff */

return giterr_set_after_callback_function(error, "git_diff");

}

}

if ((error = git_vector_insert(&diff->deltas, delta)) < 0)

git__free(delta);

return error;

}

static int diff_delta__from_one(

git_diff *diff,

git_delta_t status,

const git_index_entry *entry)

{

git_diff_delta *delta;

const char *matched_pathspec;

if ((entry->flags & GIT_IDXENTRY_VALID) != 0)

return 0;

if (status == GIT_DELTA_IGNORED &&

DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_IGNORED))

return 0;

if (status == GIT_DELTA_UNTRACKED &&

DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_UNTRACKED))

return 0;

if (status == GIT_DELTA_UNREADABLE &&

DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_UNREADABLE))

return 0;

if (!git_pathspec__match(

&diff->pathspec, entry->path,

DIFF_FLAG_IS_SET(diff, GIT_DIFF_DISABLE_PATHSPEC_MATCH),

DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE),

&matched_pathspec, NULL))

return 0;

delta = diff_delta__alloc(diff, status, entry->path);

GITERR_CHECK_ALLOC(delta);

/* This fn is just for single-sided diffs */

assert(status != GIT_DELTA_MODIFIED);

delta->nfiles = 1;

if (delta->status == GIT_DELTA_DELETED) {

delta->old_file.mode = entry->mode;

delta->old_file.size = entry->file_size;

git_oid_cpy(&delta->old_file.id, &entry->id);

} else /* ADDED, IGNORED, UNTRACKED */ {

delta->new_file.mode = entry->mode;

delta->new_file.size = entry->file_size;

git_oid_cpy(&delta->new_file.id, &entry->id);

}

delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;

if (delta->status == GIT_DELTA_DELETED ||

!git_oid_iszero(&delta->new_file.id))

delta->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;

return diff_insert_delta(diff, delta, matched_pathspec);

}

static int diff_delta__from_two(

const char *matched_pathspec)

{

git_diff_delta *delta;

const char *canonical_path = old_entry->path;

if (status == GIT_DELTA_UNMODIFIED &&

DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_UNMODIFIED))

return 0;

if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE)) {

uint32_t temp_mode = old_mode;

const git_index_entry *temp_entry = old_entry;

old_entry = new_entry;

new_entry = temp_entry;

old_mode = new_mode;

new_mode = temp_mode;

}

delta = diff_delta__alloc(diff, status, canonical_path);

GITERR_CHECK_ALLOC(delta);

delta->nfiles = 2;

git_oid_cpy(&delta->old_file.id, &old_entry->id);

delta->old_file.size = old_entry->file_size;

delta->old_file.mode = old_mode;

delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;

git_oid_cpy(&delta->new_file.id, &new_entry->id);

delta->new_file.size = new_entry->file_size;

delta->new_file.mode = new_mode;

if (new_oid) {

if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE))

git_oid_cpy(&delta->old_file.id, new_oid);

else

git_oid_cpy(&delta->new_file.id, new_oid);

}

if (new_oid || !git_oid_iszero(&new_entry->id))

delta->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;

return diff_insert_delta(diff, delta, matched_pathspec);

}

static git_diff_delta *diff_delta__last_for_item(

git_diff *diff,

const git_index_entry *item)

{

git_diff_delta *delta = git_vector_last(&diff->deltas);

if (!delta)

return NULL;

switch (delta->status) {

case GIT_DELTA_UNMODIFIED:

case GIT_DELTA_DELETED:

if (git_oid__cmp(&delta->old_file.id, &item->id) == 0)

return delta;

break;

case GIT_DELTA_ADDED:

if (git_oid__cmp(&delta->new_file.id, &item->id) == 0)

return delta;

break;

case GIT_DELTA_UNREADABLE:

case GIT_DELTA_UNTRACKED:

if (diff->strcomp(delta->new_file.path, item->path) == 0 &&

git_oid__cmp(&delta->new_file.id, &item->id) == 0)

return delta;

break;

case GIT_DELTA_MODIFIED:

if (git_oid__cmp(&delta->old_file.id, &item->id) == 0 ||

git_oid__cmp(&delta->new_file.id, &item->id) == 0)

return delta;

break;

default:

break;

}

return NULL;

}

static char *diff_strdup_prefix(git_pool *pool, const char *prefix)

{

size_t len = strlen(prefix);

/* append '/' at end if needed */

if (len > 0 && prefix[len - 1] != '/')

return git_pool_strcat(pool, prefix, "/");

else

return git_pool_strndup(pool, prefix, len + 1);

}

GIT_INLINE(const char *) diff_delta__path(const git_diff_delta *delta)

{

const char *str = delta->old_file.path;

if (!str ||

delta->status == GIT_DELTA_ADDED ||

delta->status == GIT_DELTA_RENAMED ||

delta->status == GIT_DELTA_COPIED)

str = delta->new_file.path;

return str;

}

const char *git_diff_delta__path(const git_diff_delta *delta)

{

return diff_delta__path(delta);

}

int git_diff_delta__cmp(const void *a, const void *b)

{

const git_diff_delta *da = a, *db = b;

int val = strcmp(diff_delta__path(da), diff_delta__path(db));

return val ? val : ((int)da->status - (int)db->status);

}

int git_diff_delta__casecmp(const void *a, const void *b)

{

const git_diff_delta *da = a, *db = b;

int val = strcasecmp(diff_delta__path(da), diff_delta__path(db));

return val ? val : ((int)da->status - (int)db->status);

}

GIT_INLINE(const char *) diff_delta__i2w_path(const git_diff_delta *delta)

{

return delta->old_file.path ?

delta->old_file.path : delta->new_file.path;

}

int git_diff_delta__i2w_cmp(const void *a, const void *b)

{

const git_diff_delta *da = a, *db = b;

int val = strcmp(diff_delta__i2w_path(da), diff_delta__i2w_path(db));

return val ? val : ((int)da->status - (int)db->status);

}

int git_diff_delta__i2w_casecmp(const void *a, const void *b)

{

const git_diff_delta *da = a, *db = b;

int val = strcasecmp(diff_delta__i2w_path(da), diff_delta__i2w_path(db));

return val ? val : ((int)da->status - (int)db->status);

}

bool git_diff_delta__should_skip(

const git_diff_options *opts, const git_diff_delta *delta)

{

uint32_t flags = opts ? opts->flags : 0;

if (delta->status == GIT_DELTA_UNMODIFIED &&

(flags & GIT_DIFF_INCLUDE_UNMODIFIED) == 0)

return true;

if (delta->status == GIT_DELTA_IGNORED &&

(flags & GIT_DIFF_INCLUDE_IGNORED) == 0)

return true;

if (delta->status == GIT_DELTA_UNTRACKED &&

(flags & GIT_DIFF_INCLUDE_UNTRACKED) == 0)

return true;

if (delta->status == GIT_DELTA_UNREADABLE &&

(flags & GIT_DIFF_INCLUDE_UNREADABLE) == 0)

return true;

return false;

}

static const char *diff_mnemonic_prefix(

git_iterator_type_t type, bool left_side)

{

const char *pfx = "";

switch (type) {

case GIT_ITERATOR_TYPE_EMPTY: pfx = "c"; break;

case GIT_ITERATOR_TYPE_TREE: pfx = "c"; break;

case GIT_ITERATOR_TYPE_INDEX: pfx = "i"; break;

case GIT_ITERATOR_TYPE_WORKDIR: pfx = "w"; break;

case GIT_ITERATOR_TYPE_FS: pfx = left_side ? "1" : "2"; break;

default: break;

}

/* note: without a deeper look at pathspecs, there is no easy way

return pfx;

}

static void diff_set_ignore_case(git_diff *diff, bool ignore_case)

{

if (!ignore_case) {

diff->opts.flags &= ~GIT_DIFF_IGNORE_CASE;

diff->strcomp = git__strcmp;

diff->strncomp = git__strncmp;

diff->pfxcomp = git__prefixcmp;

diff->entrycomp = git_index_entry_cmp;

git_vector_set_cmp(&diff->deltas, git_diff_delta__cmp);

} else {

diff->opts.flags |= GIT_DIFF_IGNORE_CASE;

diff->strcomp = git__strcasecmp;

diff->strncomp = git__strncasecmp;

diff->pfxcomp = git__prefixcmp_icase;

diff->entrycomp = git_index_entry_icmp;

git_vector_set_cmp(&diff->deltas, git_diff_delta__casecmp);

}

git_vector_sort(&diff->deltas);

}

static git_diff *diff_list_alloc(

git_repository *repo,

git_iterator *old_iter,

git_iterator *new_iter)

{

git_diff_options dflt = GIT_DIFF_OPTIONS_INIT;

git_diff *diff = git__calloc(1, sizeof(git_diff));

if (!diff)

return NULL;

assert(repo && old_iter && new_iter);

GIT_REFCOUNT_INC(diff);

diff->repo = repo;

diff->old_src = old_iter->type;

diff->new_src = new_iter->type;

memcpy(&diff->opts, &dflt, sizeof(diff->opts));

if (git_vector_init(&diff->deltas, 0, git_diff_delta__cmp) < 0 ||

git_pool_init(&diff->pool, 1, 0) < 0) {

git_diff_free(diff);

return NULL;

}

/* Use case-insensitive compare if either iterator has

diff_set_ignore_case(

diff,

git_iterator_ignore_case(old_iter) ||

git_iterator_ignore_case(new_iter));

return diff;

}

static int diff_list_apply_options(

git_diff *diff,

const git_diff_options *opts)

{

git_config *cfg = NULL;

git_repository *repo = diff->repo;

git_pool *pool = &diff->pool;

int val;

if (opts) {

/* copy user options (except case sensitivity info from iterators) */

bool icase = DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE);

memcpy(&diff->opts, opts, sizeof(diff->opts));

DIFF_FLAG_SET(diff, GIT_DIFF_IGNORE_CASE, icase);

/* initialize pathspec from options */

if (git_pathspec__vinit(&diff->pathspec, &opts->pathspec, pool) < 0)

return -1;

}

/* flag INCLUDE_TYPECHANGE_TREES implies INCLUDE_TYPECHANGE */

if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_TYPECHANGE_TREES))

diff->opts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE;

/* flag INCLUDE_UNTRACKED_CONTENT implies INCLUDE_UNTRACKED */

if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_SHOW_UNTRACKED_CONTENT))

diff->opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED;

/* load config values that affect diff behavior */

if ((val = git_repository_config_snapshot(&cfg, repo)) < 0)

return val;

if (!git_config__cvar(&val, cfg, GIT_CVAR_SYMLINKS) && val)

diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_HAS_SYMLINKS;

if (!git_config__cvar(&val, cfg, GIT_CVAR_IGNORESTAT) && val)

diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_IGNORE_STAT;

if ((diff->opts.flags & GIT_DIFF_IGNORE_FILEMODE) == 0 &&

!git_config__cvar(&val, cfg, GIT_CVAR_FILEMODE) && val)

diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_TRUST_MODE_BITS;

if (!git_config__cvar(&val, cfg, GIT_CVAR_TRUSTCTIME) && val)

diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_TRUST_CTIME;

/* Don't set GIT_DIFFCAPS_USE_DEV - compile time option in core git */

/* Set GIT_DIFFCAPS_TRUST_NANOSECS on a platform basis */

diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_TRUST_NANOSECS;

/* If not given explicit `opts`, check `diff.xyz` configs */

if (!opts) {

int context = git_config__get_int_force(cfg, "diff.context", 3);

diff->opts.context_lines = context >= 0 ? (uint32_t)context : 3;

/* add other defaults here */

}

/* Reverse src info if diff is reversed */

if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE)) {

git_iterator_type_t tmp_src = diff->old_src;

diff->old_src = diff->new_src;

diff->new_src = tmp_src;

}

/* Unset UPDATE_INDEX unless diffing workdir and index */

if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_UPDATE_INDEX) &&

(!(diff->old_src == GIT_ITERATOR_TYPE_WORKDIR ||

diff->new_src == GIT_ITERATOR_TYPE_WORKDIR) ||

!(diff->old_src == GIT_ITERATOR_TYPE_INDEX ||

diff->new_src == GIT_ITERATOR_TYPE_INDEX)))

diff->opts.flags &= ~GIT_DIFF_UPDATE_INDEX;

/* if ignore_submodules not explicitly set, check diff config */

if (diff->opts.ignore_submodules <= 0) {

const git_config_entry *entry;

git_config__lookup_entry(&entry, cfg, "diff.ignoresubmodules", true);

if (entry && git_submodule_parse_ignore(

&diff->opts.ignore_submodules, entry->value) < 0)

giterr_clear();

}

/* if either prefix is not set, figure out appropriate value */

if (!diff->opts.old_prefix || !diff->opts.new_prefix) {

const char *use_old = DIFF_OLD_PREFIX_DEFAULT;

const char *use_new = DIFF_NEW_PREFIX_DEFAULT;

if (git_config__get_bool_force(cfg, "diff.noprefix", 0))

use_old = use_new = "";

else if (git_config__get_bool_force(cfg, "diff.mnemonicprefix", 0)) {

use_old = diff_mnemonic_prefix(diff->old_src, true);

use_new = diff_mnemonic_prefix(diff->new_src, false);

}

if (!diff->opts.old_prefix)

diff->opts.old_prefix = use_old;

if (!diff->opts.new_prefix)

diff->opts.new_prefix = use_new;

}

/* strdup prefix from pool so we're not dependent on external data */

diff->opts.old_prefix = diff_strdup_prefix(pool, diff->opts.old_prefix);

diff->opts.new_prefix = diff_strdup_prefix(pool, diff->opts.new_prefix);

if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE)) {

const char *tmp_prefix = diff->opts.old_prefix;

diff->opts.old_prefix = diff->opts.new_prefix;

diff->opts.new_prefix = tmp_prefix;

}

git_config_free(cfg);

/* check strdup results for error */

return (!diff->opts.old_prefix || !diff->opts.new_prefix) ? -1 : 0;

}

static void diff_list_free(git_diff *diff)

{

git_vector_free_deep(&diff->deltas);

git_pathspec__vfree(&diff->pathspec);

git_pool_clear(&diff->pool);

git__memzero(diff, sizeof(*diff));

git__free(diff);

}

void git_diff_free(git_diff *diff)

{

if (!diff)

return;

GIT_REFCOUNT_DEC(diff, diff_list_free);

}

void git_diff_addref(git_diff *diff)

{

GIT_REFCOUNT_INC(diff);

}

int git_diff__oid_for_file(

git_off_t size)

{

git_index_entry entry;

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

entry.mode = mode;

entry.file_size = size;

entry.path = (char *)path;

return git_diff__oid_for_entry(out, diff, &entry, NULL);

}

int git_diff__oid_for_entry(

const git_oid *update_match)

{

int error = 0;

git_buf full_path = GIT_BUF_INIT;

git_index_entry entry = *src;

git_filter_list *fl = NULL;

memset(out, 0, sizeof(*out));

if (git_buf_joinpath(

&full_path, git_repository_workdir(diff->repo), entry.path) < 0)

return -1;

if (!entry.mode) {

struct stat st;

diff->perf.stat_calls++;

if (p_stat(full_path.ptr, &st) < 0) {

error = git_path_set_error(errno, entry.path, "stat");

git_buf_free(&full_path);

return error;

}

git_index_entry__init_from_stat(

&entry, &st, (diff->diffcaps & GIT_DIFFCAPS_TRUST_MODE_BITS) != 0);

}

/* calculate OID for file if possible */

if (S_ISGITLINK(entry.mode)) {

git_submodule *sm;

if (!git_submodule_lookup(&sm, diff->repo, entry.path)) {

const git_oid *sm_oid = git_submodule_wd_id(sm);

if (sm_oid)

git_oid_cpy(out, sm_oid);

git_submodule_free(sm);

} else {

/* if submodule lookup failed probably just in an intermediate

giterr_clear();

}

} else if (S_ISLNK(entry.mode)) {

error = git_odb__hashlink(out, full_path.ptr);

diff->perf.oid_calculations++;

} else if (!git__is_sizet(entry.file_size)) {

giterr_set(GITERR_OS, "File size overflow (for 32-bits) on '%s'",

entry.path);

error = -1;

} else if (!(error = git_filter_list_load(

&fl, diff->repo, NULL, entry.path,

GIT_FILTER_TO_ODB, GIT_FILTER_OPT_ALLOW_UNSAFE)))

{

int fd = git_futils_open_ro(full_path.ptr);

if (fd < 0)

error = fd;

else {

error = git_odb__hashfd_filtered(

out, fd, (size_t)entry.file_size, GIT_OBJ_BLOB, fl);

p_close(fd);

diff->perf.oid_calculations++;

}

git_filter_list_free(fl);

}

/* update index for entry if requested */

if (!error && update_match && git_oid_equal(out, update_match)) {

git_index *idx;

if (!(error = git_repository_index(&idx, diff->repo))) {

memcpy(&entry.id, out, sizeof(entry.id));

error = git_index_add(idx, &entry);

git_index_free(idx);

}

}

git_buf_free(&full_path);

return error;

}

static bool diff_time_eq(

const git_index_time *a, const git_index_time *b, bool use_nanos)

{

return a->seconds == b->seconds &&

(!use_nanos || a->nanoseconds == b->nanoseconds);

}

typedef struct {

git_repository *repo;

git_iterator *old_iter;

git_iterator *new_iter;

const git_index_entry *oitem;

const git_index_entry *nitem;

} diff_in_progress;

#define MODE_BITS_MASK 0000777

static int maybe_modified_submodule(

diff_in_progress *info)

{

int error = 0;

git_submodule *sub;

unsigned int sm_status = 0;

git_submodule_ignore_t ign = diff->opts.ignore_submodules;

*status = GIT_DELTA_UNMODIFIED;

if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_SUBMODULES) ||

ign == GIT_SUBMODULE_IGNORE_ALL)

return 0;

if ((error = git_submodule_lookup(

&sub, diff->repo, info->nitem->path)) < 0) {

/* GIT_EEXISTS means dir with .git in it was found - ignore it */

if (error == GIT_EEXISTS) {

giterr_clear();

error = 0;

}

return error;

}

if (ign <= 0 && git_submodule_ignore(sub) == GIT_SUBMODULE_IGNORE_ALL)

/* ignore it */;

else if ((error = git_submodule__status(

&sm_status, NULL, NULL, found_oid, sub, ign)) < 0)

/* return error below */;

/* check IS_WD_UNMODIFIED because this case is only used

else if (!GIT_SUBMODULE_STATUS_IS_WD_UNMODIFIED(sm_status))

*status = GIT_DELTA_MODIFIED;

/* now that we have a HEAD OID, check if HEAD moved */

else if ((sm_status & GIT_SUBMODULE_STATUS_IN_WD) != 0 &&

!git_oid_equal(&info->oitem->id, found_oid))

*status = GIT_DELTA_MODIFIED;

git_submodule_free(sub);

return error;

}

static int maybe_modified(

git_diff *diff,

diff_in_progress *info)

{

git_oid noid;

git_delta_t status = GIT_DELTA_MODIFIED;

const git_index_entry *oitem = info->oitem;

const git_index_entry *nitem = info->nitem;

unsigned int omode = oitem->mode;

unsigned int nmode = nitem->mode;

bool new_is_workdir = (info->new_iter->type == GIT_ITERATOR_TYPE_WORKDIR);

bool modified_uncertain = false;

const char *matched_pathspec;

int error = 0;

if (!git_pathspec__match(

&diff->pathspec, oitem->path,

DIFF_FLAG_IS_SET(diff, GIT_DIFF_DISABLE_PATHSPEC_MATCH),

DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE),

&matched_pathspec, NULL))

return 0;

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

/* on platforms with no symlinks, preserve mode of existing symlinks */

if (S_ISLNK(omode) && S_ISREG(nmode) && new_is_workdir &&

!(diff->diffcaps & GIT_DIFFCAPS_HAS_SYMLINKS))

nmode = omode;

/* on platforms with no execmode, just preserve old mode */

if (!(diff->diffcaps & GIT_DIFFCAPS_TRUST_MODE_BITS) &&

(nmode & MODE_BITS_MASK) != (omode & MODE_BITS_MASK) &&

new_is_workdir)

nmode = (nmode & ~MODE_BITS_MASK) | (omode & MODE_BITS_MASK);

/* support "assume unchanged" (poorly, b/c we still stat everything) */

if ((oitem->flags & GIT_IDXENTRY_VALID) != 0)

status = GIT_DELTA_UNMODIFIED;

/* support "skip worktree" index bit */

else if ((oitem->flags_extended & GIT_IDXENTRY_SKIP_WORKTREE) != 0)

status = GIT_DELTA_UNMODIFIED;

/* if basic type of file changed, then split into delete and add */

else if (GIT_MODE_TYPE(omode) != GIT_MODE_TYPE(nmode)) {

if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_TYPECHANGE))

status = GIT_DELTA_TYPECHANGE;

else if (nmode == GIT_FILEMODE_UNREADABLE) {

if (!(error = diff_delta__from_one(diff, GIT_DELTA_DELETED, oitem)))

error = diff_delta__from_one(diff, GIT_DELTA_UNREADABLE, nitem);

return error;

}

else {

if (!(error = diff_delta__from_one(diff, GIT_DELTA_DELETED, oitem)))

error = diff_delta__from_one(diff, GIT_DELTA_ADDED, nitem);

return error;

}

}

/* if oids and modes match (and are valid), then file is unmodified */

else if (git_oid_equal(&oitem->id, &nitem->id) &&

omode == nmode &&

!git_oid_iszero(&oitem->id))

status = GIT_DELTA_UNMODIFIED;

/* if we have an unknown OID and a workdir iterator, then check some

else if (git_oid_iszero(&nitem->id) && new_is_workdir) {

bool use_ctime = ((diff->diffcaps & GIT_DIFFCAPS_TRUST_CTIME) != 0);

bool use_nanos = ((diff->diffcaps & GIT_DIFFCAPS_TRUST_NANOSECS) != 0);

status = GIT_DELTA_UNMODIFIED;

/* TODO: add check against index file st_mtime to avoid racy-git */

if (S_ISGITLINK(nmode)) {

if ((error = maybe_modified_submodule(&status, &noid, diff, info)) < 0)

return error;

}

/* if the stat data looks different, then mark modified - this just

else if (omode != nmode || oitem->file_size != nitem->file_size) {

status = GIT_DELTA_MODIFIED;

modified_uncertain =

(oitem->file_size <= 0 && nitem->file_size > 0);

}

else if (!diff_time_eq(&oitem->mtime, &nitem->mtime, use_nanos) ||

(use_ctime &&

!diff_time_eq(&oitem->ctime, &nitem->ctime, use_nanos)) ||

oitem->ino != nitem->ino ||

oitem->uid != nitem->uid ||

oitem->gid != nitem->gid)

{

status = GIT_DELTA_MODIFIED;

modified_uncertain = true;

}

}

/* if mode is GITLINK and submodules are ignored, then skip */

else if (S_ISGITLINK(nmode) &&

DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_SUBMODULES))

status = GIT_DELTA_UNMODIFIED;

/* if we got here and decided that the files are modified, but we

if (modified_uncertain && git_oid_iszero(&nitem->id)) {

if (git_oid_iszero(&noid)) {

const git_oid *update_check =

DIFF_FLAG_IS_SET(diff, GIT_DIFF_UPDATE_INDEX) ?

&oitem->id : NULL;

if ((error = git_diff__oid_for_entry(

&noid, diff, nitem, update_check)) < 0)

return error;

}

/* if oid matches, then mark unmodified (except submodules, where

if (omode == nmode && !S_ISGITLINK(omode) &&

git_oid_equal(&oitem->id, &noid))

status = GIT_DELTA_UNMODIFIED;

}

return diff_delta__from_two(

diff, status, oitem, omode, nitem, nmode,

git_oid_iszero(&noid) ? NULL : &noid, matched_pathspec);

}

static bool entry_is_prefixed(

git_diff *diff,

const git_index_entry *item,

const git_index_entry *prefix_item)

{

size_t pathlen;

if (!item || diff->pfxcomp(item->path, prefix_item->path) != 0)

return false;

pathlen = strlen(prefix_item->path);

return (prefix_item->path[pathlen - 1] == '/' ||

item->path[pathlen] == '\0' ||

item->path[pathlen] == '/');

}

static int handle_unmatched_new_item(

git_diff *diff, diff_in_progress *info)

{

int error = 0;

const git_index_entry *nitem = info->nitem;

git_delta_t delta_type = GIT_DELTA_UNTRACKED;

bool contains_oitem;

/* check if this is a prefix of the other side */

contains_oitem = entry_is_prefixed(diff, info->oitem, nitem);

/* update delta_type if this item is ignored */

if (git_iterator_current_is_ignored(info->new_iter))

delta_type = GIT_DELTA_IGNORED;

if (nitem->mode == GIT_FILEMODE_TREE) {

bool recurse_into_dir = contains_oitem;

/* check if user requests recursion into this type of dir */

recurse_into_dir = contains_oitem ||

(delta_type == GIT_DELTA_UNTRACKED &&

DIFF_FLAG_IS_SET(diff, GIT_DIFF_RECURSE_UNTRACKED_DIRS)) ||

(delta_type == GIT_DELTA_IGNORED &&

DIFF_FLAG_IS_SET(diff, GIT_DIFF_RECURSE_IGNORED_DIRS));

/* do not advance into directories that contain a .git file */

if (recurse_into_dir && !contains_oitem) {

git_buf *full = NULL;

if (git_iterator_current_workdir_path(&full, info->new_iter) < 0)

return -1;

if (full && git_path_contains(full, DOT_GIT)) {

/* TODO: warning if not a valid git repository */

recurse_into_dir = false;

}

}

/* still have to look into untracked directories to match core git -

if (!recurse_into_dir &&

delta_type == GIT_DELTA_UNTRACKED &&

DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS))

{

git_diff_delta *last;

git_iterator_status_t untracked_state;

/* attempt to insert record for this directory */

if ((error = diff_delta__from_one(diff, delta_type, nitem)) != 0)

return error;

/* if delta wasn't created (because of rules), just skip ahead */

last = diff_delta__last_for_item(diff, nitem);

if (!last)

return git_iterator_advance(&info->nitem, info->new_iter);

/* iterate into dir looking for an actual untracked file */

if ((error = git_iterator_advance_over_with_status(

&info->nitem, &untracked_state, info->new_iter)) < 0 &&

error != GIT_ITEROVER)

return error;

/* if we found nothing or just ignored items, update the record */

if (untracked_state == GIT_ITERATOR_STATUS_IGNORED ||

untracked_state == GIT_ITERATOR_STATUS_EMPTY) {

last->status = GIT_DELTA_IGNORED;

/* remove the record if we don't want ignored records */

if (DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_IGNORED)) {

git_vector_pop(&diff->deltas);

git__free(last);

}

}

return 0;

}

/* try to advance into directory if necessary */

if (recurse_into_dir) {

error = git_iterator_advance_into(&info->nitem, info->new_iter);

/* if real error or no error, proceed with iteration */

if (error != GIT_ENOTFOUND)

return error;

giterr_clear();

/* if directory is empty, can't advance into it, so either skip

if (contains_oitem)

return git_iterator_advance(&info->nitem, info->new_iter);

delta_type = GIT_DELTA_IGNORED;

}

}

else if (delta_type == GIT_DELTA_IGNORED &&

DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_RECURSE_IGNORED_DIRS) &&

git_iterator_current_tree_is_ignored(info->new_iter))

/* item contained in ignored directory, so skip over it */

return git_iterator_advance(&info->nitem, info->new_iter);

else if (info->new_iter->type != GIT_ITERATOR_TYPE_WORKDIR)

delta_type = GIT_DELTA_ADDED;

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

/* ignore things that are not actual submodules */

if (git_submodule_lookup(NULL, info->repo, nitem->path) != 0) {

giterr_clear();

delta_type = GIT_DELTA_IGNORED;

/* if this contains a tracked item, treat as normal TREE */

if (contains_oitem) {

error = git_iterator_advance_into(&info->nitem, info->new_iter);

if (error != GIT_ENOTFOUND)

return error;

giterr_clear();

return git_iterator_advance(&info->nitem, info->new_iter);

}

}

}

else if (nitem->mode == GIT_FILEMODE_UNREADABLE) {

if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_UNREADABLE_AS_UNTRACKED))

delta_type = GIT_DELTA_UNTRACKED;

else

delta_type = GIT_DELTA_UNREADABLE;

}

/* Actually create the record for this item if necessary */

if ((error = diff_delta__from_one(diff, delta_type, nitem)) != 0)

return error;

/* If user requested TYPECHANGE records, then check for that instead of

if (delta_type != GIT_DELTA_IGNORED &&

DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_TYPECHANGE_TREES) &&

contains_oitem)

{

/* this entry was prefixed with a tree - make TYPECHANGE */

git_diff_delta *last = diff_delta__last_for_item(diff, nitem);

if (last) {

last->status = GIT_DELTA_TYPECHANGE;

last->old_file.mode = GIT_FILEMODE_TREE;

}

}

return git_iterator_advance(&info->nitem, info->new_iter);

}

static int handle_unmatched_old_item(