/*

 * GIT - The information manager from hell

 *

 * Copyright (C) Linus Torvalds, 2005

 */

#define USE_THE_REPOSITORY_VARIABLE

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

#include "config.h"

#include "date.h"

#include "diff.h"

#include "diffcore.h"

#include "hex.h"

#include "tempfile.h"

#include "lockfile.h"

#include "cache-tree.h"

#include "refs.h"

#include "dir.h"

#include "object-file.h"

#include "odb.h"

#include "oid-array.h"

#include "tree.h"

#include "commit.h"

#include "environment.h"

#include "gettext.h"

#include "mem-pool.h"

#include "name-hash.h"

#include "object-name.h"

#include "path.h"

#include "preload-index.h"

#include "read-cache.h"

#include "repository.h"

#include "resolve-undo.h"

#include "revision.h"

#include "strbuf.h"

#include "trace2.h"

#include "varint.h"

#include "split-index.h"

#include "symlinks.h"

#include "utf8.h"

#include "fsmonitor.h"

#include "thread-utils.h"

#include "progress.h"

#include "sparse-index.h"

#include "csum-file.h"

#include "promisor-remote.h"

#include "hook.h"

#include "submodule.h"

#include "submodule-config.h"

#include "advice.h"

/* Mask for the name length in ce_flags in the on-disk index */

#define CE_NAMEMASK  (0x0fff)

/* Index extensions.

 *

 * The first letter should be 'A'..'Z' for extensions that are not

 * necessary for a correct operation (i.e. optimization data).

 * When new extensions are added that _needs_ to be understood in

 * order to correctly interpret the index file, pick character that

 * is outside the range, to cause the reader to abort.

 */

#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) )

#define CACHE_EXT_TREE 0x54524545  /* "TREE" */

#define CACHE_EXT_RESOLVE_UNDO 0x52455543 /* "REUC" */

#define CACHE_EXT_LINK 0x6c696e6b    /* "link" */

#define CACHE_EXT_UNTRACKED 0x554E5452    /* "UNTR" */

#define CACHE_EXT_FSMONITOR 0x46534D4E    /* "FSMN" */

#define CACHE_EXT_ENDOFINDEXENTRIES 0x454F4945  /* "EOIE" */

#define CACHE_EXT_INDEXENTRYOFFSETTABLE 0x49454F54 /* "IEOT" */

#define CACHE_EXT_SPARSE_DIRECTORIES 0x73646972 /* "sdir" */

/* changes that can be kept in $GIT_DIR/index (basically all extensions) */

#define EXTMASK (RESOLVE_UNDO_CHANGED | CACHE_TREE_CHANGED | \

     CE_ENTRY_ADDED | CE_ENTRY_REMOVED | CE_ENTRY_CHANGED | \

     SPLIT_INDEX_ORDERED | UNTRACKED_CHANGED | FSMONITOR_CHANGED)

/*

 * This is an estimate of the pathname length in the index.  We use

 * this for V4 index files to guess the un-deltafied size of the index

 * in memory because of pathname deltafication.  This is not required

 * for V2/V3 index formats because their pathnames are not compressed.

 * If the initial amount of memory set aside is not sufficient, the

 * mem pool will allocate extra memory.

 */

#define CACHE_ENTRY_PATH_LENGTH 80

enum index_search_mode {

  NO_EXPAND_SPARSE = 0,

  EXPAND_SPARSE = 1

};

static inline struct cache_entry *mem_pool__ce_alloc(struct mem_pool *mem_pool, size_t len)

{

  struct cache_entry *ce;

  ce = mem_pool_alloc(mem_pool, cache_entry_size(len));

  ce->mem_pool_allocated = 1;

  return ce;

}

static inline struct cache_entry *mem_pool__ce_calloc(struct mem_pool *mem_pool, size_t len)

{

  struct cache_entry * ce;

  ce = mem_pool_calloc(mem_pool, 1, cache_entry_size(len));

  ce->mem_pool_allocated = 1;

  return ce;

}

static struct mem_pool *find_mem_pool(struct index_state *istate)

{

  struct mem_pool **pool_ptr;

  if (istate->split_index && istate->split_index->base)

    pool_ptr = &istate->split_index->base->ce_mem_pool;

  else

    pool_ptr = &istate->ce_mem_pool;

  if (!*pool_ptr) {

    *pool_ptr = xmalloc(sizeof(**pool_ptr));

    mem_pool_init(*pool_ptr, 0);

  }

  return *pool_ptr;

}

static const char *alternate_index_output;

static void set_index_entry(struct index_state *istate, int nr, struct cache_entry *ce)

{

  if (S_ISSPARSEDIR(ce->ce_mode))

    istate->sparse_index = INDEX_COLLAPSED;

  istate->cache[nr] = ce;

  add_name_hash(istate, ce);

}

static void replace_index_entry(struct index_state *istate, int nr, struct cache_entry *ce)

{

  struct cache_entry *old = istate->cache[nr];

  replace_index_entry_in_base(istate, old, ce);

  remove_name_hash(istate, old);

  discard_cache_entry(old);

  ce->ce_flags &= ~CE_HASHED;

  set_index_entry(istate, nr, ce);

  ce->ce_flags |= CE_UPDATE_IN_BASE;

  mark_fsmonitor_invalid(istate, ce);

  istate->cache_changed |= CE_ENTRY_CHANGED;

}

void rename_index_entry_at(struct index_state *istate, int nr, const char *new_name)

{

  struct cache_entry *old_entry = istate->cache[nr], *new_entry, *refreshed;

  int namelen = strlen(new_name);

  new_entry = make_empty_cache_entry(istate, namelen);

  copy_cache_entry(new_entry, old_entry);

  new_entry->ce_flags &= ~CE_HASHED;

  new_entry->ce_namelen = namelen;

  new_entry->index = 0;

  memcpy(new_entry->name, new_name, namelen + 1);

  cache_tree_invalidate_path(istate, old_entry->name);

  untracked_cache_remove_from_index(istate, old_entry->name);

  remove_index_entry_at(istate, nr);

  /*

   * Refresh the new index entry. Using 'refresh_cache_entry' ensures

   * we only update stat info if the entry is otherwise up-to-date (i.e.,

   * the contents/mode haven't changed). This ensures that we reflect the

   * 'ctime' of the rename in the index without (incorrectly) updating

   * the cached stat info to reflect unstaged changes on disk.

   */

  refreshed = refresh_cache_entry(istate, new_entry, CE_MATCH_REFRESH);

  if (refreshed && refreshed != new_entry) {

    add_index_entry(istate, refreshed, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);

    discard_cache_entry(new_entry);

  } else

    add_index_entry(istate, new_entry, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);

}

/*

 * This only updates the "non-critical" parts of the directory

 * cache, ie the parts that aren't tracked by GIT, and only used

 * to validate the cache.

 */

void fill_stat_cache_info(struct index_state *istate, struct cache_entry *ce, struct stat *st)

{

  fill_stat_data(&ce->ce_stat_data, st);

  if (assume_unchanged)

    ce->ce_flags |= CE_VALID;

  if (S_ISREG(st->st_mode)) {

    ce_mark_uptodate(ce);

    mark_fsmonitor_valid(istate, ce);

  }

}

static unsigned int st_mode_from_ce(const struct cache_entry *ce)

{

  extern int trust_executable_bit, has_symlinks;

  switch (ce->ce_mode & S_IFMT) {

  case S_IFLNK:

    return has_symlinks ? S_IFLNK : (S_IFREG | 0644);

  case S_IFREG:

    return (ce->ce_mode & (trust_executable_bit ? 0755 : 0644)) | S_IFREG;

  case S_IFGITLINK:

    return S_IFDIR | 0755;

  case S_IFDIR:

    return ce->ce_mode;

  default:

    BUG("unsupported ce_mode: %o", ce->ce_mode);

  }

}

int fake_lstat(const struct cache_entry *ce, struct stat *st)

{

  fake_lstat_data(&ce->ce_stat_data, st);

  st->st_mode = st_mode_from_ce(ce);

  /* always succeed as lstat() replacement */

  return 0;

}

static int ce_compare_data(struct index_state *istate,

         const struct cache_entry *ce,

         struct stat *st)

{

  int match = -1;

  int fd = git_open_cloexec(ce->name, O_RDONLY);

  if (fd >= 0) {

    struct object_id oid;

    if (!index_fd(istate, &oid, fd, st, OBJ_BLOB, ce->name, 0))

      match = !oideq(&oid, &ce->oid);

    /* index_fd() closed the file descriptor already */

  }

  return match;

}

static int ce_compare_link(const struct cache_entry *ce, size_t expected_size)

{

  int match = -1;

  void *buffer;

  unsigned long size;

  enum object_type type;

  struct strbuf sb = STRBUF_INIT;

  if (strbuf_readlink(&sb, ce->name, expected_size))

    return -1;

  buffer = odb_read_object(the_repository->objects, &ce->oid, &type, &size);

  if (buffer) {

    if (size == sb.len)

      match = memcmp(buffer, sb.buf, size);

    free(buffer);

  }

  strbuf_release(&sb);

  return match;

}

static int ce_compare_gitlink(const struct cache_entry *ce)

{

  struct object_id oid;

  /*

   * We don't actually require that the .git directory

   * under GITLINK directory be a valid git directory. It

   * might even be missing (in case nobody populated that

   * sub-project).

   *

   * If so, we consider it always to match.

   */

  if (repo_resolve_gitlink_ref(the_repository, ce->name,

             "HEAD", &oid) < 0)

    return 0;

  return !oideq(&oid, &ce->oid);

}

static int ce_modified_check_fs(struct index_state *istate,

        const struct cache_entry *ce,

        struct stat *st)

{

  switch (st->st_mode & S_IFMT) {

  case S_IFREG:

    if (ce_compare_data(istate, ce, st))

      return DATA_CHANGED;

    break;

  case S_IFLNK:

    if (ce_compare_link(ce, xsize_t(st->st_size)))

      return DATA_CHANGED;

    break;

  case S_IFDIR:

    if (S_ISGITLINK(ce->ce_mode))

      return ce_compare_gitlink(ce) ? DATA_CHANGED : 0;

    /* else fallthrough */

  default:

    return TYPE_CHANGED;

  }

  return 0;

}

static int ce_match_stat_basic(const struct cache_entry *ce, struct stat *st)

{

  unsigned int changed = 0;

  if (ce->ce_flags & CE_REMOVE)

    return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED;

  switch (ce->ce_mode & S_IFMT) {

  case S_IFREG:

    changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED : 0;

    /* We consider only the owner x bit to be relevant for

     * "mode changes"

     */

    if (trust_executable_bit &&

        (0100 & (ce->ce_mode ^ st->st_mode)))

      changed |= MODE_CHANGED;

    break;

  case S_IFLNK:

    if (!S_ISLNK(st->st_mode) &&

        (has_symlinks || !S_ISREG(st->st_mode)))

      changed |= TYPE_CHANGED;

    break;

  case S_IFGITLINK:

    /* We ignore most of the st_xxx fields for gitlinks */

    if (!S_ISDIR(st->st_mode))

      changed |= TYPE_CHANGED;

    else if (ce_compare_gitlink(ce))

      changed |= DATA_CHANGED;

    return changed;

  default:

    BUG("unsupported ce_mode: %o", ce->ce_mode);

  }

  changed |= match_stat_data(&ce->ce_stat_data, st);

  /* Racily smudged entry? */

  if (!ce->ce_stat_data.sd_size) {

    if (!is_empty_blob_oid(&ce->oid, the_repository->hash_algo))

      changed |= DATA_CHANGED;

  }

  return changed;

}

static int is_racy_stat(const struct index_state *istate,

      const struct stat_data *sd)

{

  return (istate->timestamp.sec &&

#ifdef USE_NSEC

     /* nanosecond timestamped files can also be racy! */

    (istate->timestamp.sec < sd->sd_mtime.sec ||

     (istate->timestamp.sec == sd->sd_mtime.sec &&

      istate->timestamp.nsec <= sd->sd_mtime.nsec))

#else

    istate->timestamp.sec <= sd->sd_mtime.sec

#endif

    );

}

int is_racy_timestamp(const struct index_state *istate,

           const struct cache_entry *ce)

{

  return (!S_ISGITLINK(ce->ce_mode) &&

    is_racy_stat(istate, &ce->ce_stat_data));

}

int match_stat_data_racy(const struct index_state *istate,

       const struct stat_data *sd, struct stat *st)

{

  if (is_racy_stat(istate, sd))

    return MTIME_CHANGED;

  return match_stat_data(sd, st);

}

int ie_match_stat(struct index_state *istate,

      const struct cache_entry *ce, struct stat *st,

      unsigned int options)

{

  unsigned int changed;

  int ignore_valid = options & CE_MATCH_IGNORE_VALID;

  int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;

  int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY;

  int ignore_fsmonitor = options & CE_MATCH_IGNORE_FSMONITOR;

  if (!ignore_fsmonitor)

    refresh_fsmonitor(istate);

  /*

   * If it's marked as always valid in the index, it's

   * valid whatever the checked-out copy says.

   *

   * skip-worktree has the same effect with higher precedence

   */

  if (!ignore_skip_worktree && ce_skip_worktree(ce))

    return 0;

  if (!ignore_valid && (ce->ce_flags & CE_VALID))

    return 0;

  if (!ignore_fsmonitor && (ce->ce_flags & CE_FSMONITOR_VALID))

    return 0;

  /*

   * Intent-to-add entries have not been added, so the index entry

   * by definition never matches what is in the work tree until it

   * actually gets added.

   */

  if (ce_intent_to_add(ce))

    return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED;

  changed = ce_match_stat_basic(ce, st);

  /*

   * Within 1 second of this sequence:

   *  echo xyzzy >file && git-update-index --add file

   * running this command:

   *  echo frotz >file

   * would give a falsely clean cache entry.  The mtime and

   * length match the cache, and other stat fields do not change.

   *

   * We could detect this at update-index time (the cache entry

   * being registered/updated records the same time as "now")

   * and delay the return from git-update-index, but that would

   * effectively mean we can make at most one commit per second,

   * which is not acceptable.  Instead, we check cache entries

   * whose mtime are the same as the index file timestamp more

   * carefully than others.

   */

  if (!changed && is_racy_timestamp(istate, ce)) {

    if (assume_racy_is_modified)

      changed |= DATA_CHANGED;

    else

      changed |= ce_modified_check_fs(istate, ce, st);

  }

  return changed;

}

int ie_modified(struct index_state *istate,

    const struct cache_entry *ce,

    struct stat *st, unsigned int options)

{

  int changed, changed_fs;

  changed = ie_match_stat(istate, ce, st, options);

  if (!changed)

    return 0;

  /*

   * If the mode or type has changed, there's no point in trying

   * to refresh the entry - it's not going to match

   */

  if (changed & (MODE_CHANGED | TYPE_CHANGED))

    return changed;

  /*

   * Immediately after read-tree or update-index --cacheinfo,

   * the length field is zero, as we have never even read the

   * lstat(2) information once, and we cannot trust DATA_CHANGED

   * returned by ie_match_stat() which in turn was returned by

   * ce_match_stat_basic() to signal that the filesize of the

   * blob changed.  We have to actually go to the filesystem to

   * see if the contents match, and if so, should answer "unchanged".

   *

   * The logic does not apply to gitlinks, as ce_match_stat_basic()

   * already has checked the actual HEAD from the filesystem in the

   * subproject.  If ie_match_stat() already said it is different,

   * then we know it is.

   */

  if ((changed & DATA_CHANGED) &&

#ifdef GIT_WINDOWS_NATIVE

      /*

       * Work around Git for Windows v2.27.0 fixing a bug where symlinks'

       * target path lengths were not read at all, and instead recorded

       * as 4096: now, all symlinks would appear as modified.

       *

       * So let's just special-case symlinks with a target path length

       * (i.e. `sd_size`) of 4096 and force them to be re-checked.

       */

      (!S_ISLNK(st->st_mode) || ce->ce_stat_data.sd_size != MAX_PATH) &&

#endif

      (S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size != 0))

    return changed;

  changed_fs = ce_modified_check_fs(istate, ce, st);

  if (changed_fs)

    return changed | changed_fs;

  return 0;

}

static int cache_name_stage_compare(const char *name1, int len1, int stage1,

            const char *name2, int len2, int stage2)

{

  int cmp;

  cmp = name_compare(name1, len1, name2, len2);

  if (cmp)

    return cmp;

  if (stage1 < stage2)

    return -1;

  if (stage1 > stage2)

    return 1;

  return 0;

}

int cmp_cache_name_compare(const void *a_, const void *b_)

{

  const struct cache_entry *ce1, *ce2;

  ce1 = *((const struct cache_entry **)a_);

  ce2 = *((const struct cache_entry **)b_);

  return cache_name_stage_compare(ce1->name, ce1->ce_namelen, ce_stage(ce1),

          ce2->name, ce2->ce_namelen, ce_stage(ce2));

}

static int index_name_stage_pos(struct index_state *istate,

        const char *name, int namelen,

        int stage,

        enum index_search_mode search_mode)

{

  int first, last;

  first = 0;

  last = istate->cache_nr;

  while (last > first) {

    int next = first + ((last - first) >> 1);

    struct cache_entry *ce = istate->cache[next];

    int cmp = cache_name_stage_compare(name, namelen, stage, ce->name, ce_namelen(ce), ce_stage(ce));

    if (!cmp)

      return next;

    if (cmp < 0) {

      last = next;

      continue;

    }

    first = next+1;

  }

  if (search_mode == EXPAND_SPARSE && istate->sparse_index &&

      first > 0) {

    /* Note: first <= istate->cache_nr */

    struct cache_entry *ce = istate->cache[first - 1];

    /*

     * If we are in a sparse-index _and_ the entry before the

     * insertion position is a sparse-directory entry that is

     * an ancestor of 'name', then we need to expand the index

     * and search again. This will only trigger once, because

     * thereafter the index is fully expanded.

     */

    if (S_ISSPARSEDIR(ce->ce_mode) &&

        ce_namelen(ce) < namelen &&

        !strncmp(name, ce->name, ce_namelen(ce))) {

      ensure_full_index(istate);

      return index_name_stage_pos(istate, name, namelen, stage, search_mode);

    }

  }

  return -first-1;

}

int index_name_pos(struct index_state *istate, const char *name, int namelen)

{

  return index_name_stage_pos(istate, name, namelen, 0, EXPAND_SPARSE);

}

int index_name_pos_sparse(struct index_state *istate, const char *name, int namelen)

{

  return index_name_stage_pos(istate, name, namelen, 0, NO_EXPAND_SPARSE);

}

int index_entry_exists(struct index_state *istate, const char *name, int namelen)

{

  return index_name_stage_pos(istate, name, namelen, 0, NO_EXPAND_SPARSE) >= 0;

}

int remove_index_entry_at(struct index_state *istate, int pos)

{

  struct cache_entry *ce = istate->cache[pos];

  record_resolve_undo(istate, ce);

  remove_name_hash(istate, ce);

  save_or_free_index_entry(istate, ce);

  istate->cache_changed |= CE_ENTRY_REMOVED;

  istate->cache_nr--;

  if (pos >= istate->cache_nr)

    return 0;

  MOVE_ARRAY(istate->cache + pos, istate->cache + pos + 1,

       istate->cache_nr - pos);

  return 1;

}

/*

 * Remove all cache entries marked for removal, that is where

 * CE_REMOVE is set in ce_flags.  This is much more effective than

 * calling remove_index_entry_at() for each entry to be removed.

 */

void remove_marked_cache_entries(struct index_state *istate, int invalidate)

{

  struct cache_entry **ce_array = istate->cache;

  unsigned int i, j;

  for (i = j = 0; i < istate->cache_nr; i++) {

    if (ce_array[i]->ce_flags & CE_REMOVE) {

      if (invalidate) {

        cache_tree_invalidate_path(istate,

                 ce_array[i]->name);

        untracked_cache_remove_from_index(istate,

                  ce_array[i]->name);

      }

      remove_name_hash(istate, ce_array[i]);

      save_or_free_index_entry(istate, ce_array[i]);

    }

    else

      ce_array[j++] = ce_array[i];

  }

  if (j == istate->cache_nr)

    return;

  istate->cache_changed |= CE_ENTRY_REMOVED;

  istate->cache_nr = j;

}

int remove_file_from_index(struct index_state *istate, const char *path)

{

  int pos = index_name_pos(istate, path, strlen(path));

  if (pos < 0)

    pos = -pos-1;

  cache_tree_invalidate_path(istate, path);

  untracked_cache_remove_from_index(istate, path);

  while (pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path))

    remove_index_entry_at(istate, pos);

  return 0;

}

static int compare_name(struct cache_entry *ce, const char *path, int namelen)

{

  return namelen != ce_namelen(ce) || memcmp(path, ce->name, namelen);

}

static int index_name_pos_also_unmerged(struct index_state *istate,

  const char *path, int namelen)

{

  int pos = index_name_pos(istate, path, namelen);

  struct cache_entry *ce;

  if (pos >= 0)

    return pos;

  /* maybe unmerged? */

  pos = -1 - pos;

  if (pos >= istate->cache_nr ||

      compare_name((ce = istate->cache[pos]), path, namelen))

    return -1;

  /* order of preference: stage 2, 1, 3 */

  if (ce_stage(ce) == 1 && pos + 1 < istate->cache_nr &&

      ce_stage((ce = istate->cache[pos + 1])) == 2 &&

      !compare_name(ce, path, namelen))

    pos++;

  return pos;

}

static int different_name(struct cache_entry *ce, struct cache_entry *alias)

{

  int len = ce_namelen(ce);

  return ce_namelen(alias) != len || memcmp(ce->name, alias->name, len);

}

/*

 * If we add a filename that aliases in the cache, we will use the

 * name that we already have - but we don't want to update the same

 * alias twice, because that implies that there were actually two

 * different files with aliasing names!

 *

 * So we use the CE_ADDED flag to verify that the alias was an old

 * one before we accept it as

 */

static struct cache_entry *create_alias_ce(struct index_state *istate,

             struct cache_entry *ce,

             struct cache_entry *alias)

{

  int len;

  struct cache_entry *new_entry;

  if (alias->ce_flags & CE_ADDED)

    die(_("will not add file alias '%s' ('%s' already exists in index)"),

        ce->name, alias->name);

  /* Ok, create the new entry using the name of the existing alias */

  len = ce_namelen(alias);

  new_entry = make_empty_cache_entry(istate, len);

  memcpy(new_entry->name, alias->name, len);

  copy_cache_entry(new_entry, ce);

  save_or_free_index_entry(istate, ce);

  return new_entry;

}

void set_object_name_for_intent_to_add_entry(struct cache_entry *ce)

{

  struct object_id oid;

  if (odb_write_object(the_repository->objects, "", 0, OBJ_BLOB, &oid))

    die(_("cannot create an empty blob in the object database"));

  oidcpy(&ce->oid, &oid);

}

int add_to_index(struct index_state *istate, const char *path, struct stat *st, int flags)

{

  int namelen, was_same;

  mode_t st_mode = st->st_mode;

  struct cache_entry *ce, *alias = NULL;

  unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY;

  int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND);

  int pretend = flags & ADD_CACHE_PRETEND;

  int intent_only = flags & ADD_CACHE_INTENT;

  int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE|

        (intent_only ? ADD_CACHE_NEW_ONLY : 0));

  unsigned hash_flags = pretend ? 0 : INDEX_WRITE_OBJECT;

  if (flags & ADD_CACHE_RENORMALIZE)

    hash_flags |= INDEX_RENORMALIZE;

  if (!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode))

    return error(_("%s: can only add regular files, symbolic links or git-directories"), path);

  namelen = strlen(path);

  if (S_ISDIR(st_mode)) {

    while (namelen && path[namelen-1] == '/')

      namelen--;

  }

  ce = make_empty_cache_entry(istate, namelen);

  memcpy(ce->name, path, namelen);

  ce->ce_namelen = namelen;

  if (!intent_only)

    fill_stat_cache_info(istate, ce, st);

  else

    ce->ce_flags |= CE_INTENT_TO_ADD;

  if (trust_executable_bit && has_symlinks) {

    ce->ce_mode = create_ce_mode(st_mode);

  } else {

    /* If there is an existing entry, pick the mode bits and type

     * from it, otherwise assume unexecutable regular file.

     */

    struct cache_entry *ent;

    int pos = index_name_pos_also_unmerged(istate, path, namelen);

    ent = (0 <= pos) ? istate->cache[pos] : NULL;

    ce->ce_mode = ce_mode_from_stat(ent, st_mode);

  }

  /* When core.ignorecase=true, determine if a directory of the same name but differing

   * case already exists within the Git repository.  If it does, ensure the directory

   * case of the file being added to the repository matches (is folded into) the existing

   * entry's directory case.

   */

  if (ignore_case) {

    adjust_dirname_case(istate, ce->name);

  }

  if (!(flags & ADD_CACHE_RENORMALIZE)) {

    alias = index_file_exists(istate, ce->name,

            ce_namelen(ce), ignore_case);

    if (alias &&

        !ce_stage(alias) &&

        !ie_match_stat(istate, alias, st, ce_option)) {

      /* Nothing changed, really */

      if (!S_ISGITLINK(alias->ce_mode))

        ce_mark_uptodate(alias);

      alias->ce_flags |= CE_ADDED;

      discard_cache_entry(ce);

      return 0;

    }

  }

  if (!intent_only) {

    if (index_path(istate, &ce->oid, path, st, hash_flags)) {

      discard_cache_entry(ce);

      return error(_("unable to index file '%s'"), path);

    }

  } else

    set_object_name_for_intent_to_add_entry(ce);

  if (ignore_case && alias && different_name(ce, alias))

    ce = create_alias_ce(istate, ce, alias);

  ce->ce_flags |= CE_ADDED;

  /* It was suspected to be racily clean, but it turns out to be Ok */

  was_same = (alias &&

        !ce_stage(alias) &&

        oideq(&alias->oid, &ce->oid) &&

        ce->ce_mode == alias->ce_mode);

  if (pretend)

    discard_cache_entry(ce);

  else if (add_index_entry(istate, ce, add_option)) {

    discard_cache_entry(ce);

    return error(_("unable to add '%s' to index"), path);

  }

  if (verbose && !was_same)

    printf("add '%s'\n", path);

  return 0;

}

int add_file_to_index(struct index_state *istate, const char *path, int flags)

{

  struct stat st;

  if (lstat(path, &st))

    die_errno(_("unable to stat '%s'"), path);

  return add_to_index(istate, path, &st, flags);

}

struct cache_entry *make_empty_cache_entry(struct index_state *istate, size_t len)

{

  return mem_pool__ce_calloc(find_mem_pool(istate), len);

}

struct cache_entry *make_empty_transient_cache_entry(size_t len,

                 struct mem_pool *ce_mem_pool)

{

  if (ce_mem_pool)

    return mem_pool__ce_calloc(ce_mem_pool, len);

  return xcalloc(1, cache_entry_size(len));

}

enum verify_path_result {

  PATH_OK,

  PATH_INVALID,

  PATH_DIR_WITH_SEP,

};

static enum verify_path_result verify_path_internal(const char *, unsigned);

int verify_path(const char *path, unsigned mode)

{

  return verify_path_internal(path, mode) == PATH_OK;

}

struct cache_entry *make_cache_entry(struct index_state *istate,

             unsigned int mode,

             const struct object_id *oid,

             const char *path,

             int stage,

             unsigned int refresh_options)

{

  struct cache_entry *ce, *ret;

  int len;

  if (verify_path_internal(path, mode) == PATH_INVALID) {

    error(_("invalid path '%s'"), path);

    return NULL;

  }

  len = strlen(path);

  ce = make_empty_cache_entry(istate, len);

  oidcpy(&ce->oid, oid);

  memcpy(ce->name, path, len);

  ce->ce_flags = create_ce_flags(stage);

  ce->ce_namelen = len;

  ce->ce_mode = create_ce_mode(mode);

  ret = refresh_cache_entry(istate, ce, refresh_options);

  if (ret != ce)

    discard_cache_entry(ce);

  return ret;

}

struct cache_entry *make_transient_cache_entry(unsigned int mode,

                 const struct object_id *oid,

                 const char *path,

                 int stage,

                 struct mem_pool *ce_mem_pool)

{

  struct cache_entry *ce;

  int len;

  if (!verify_path(path, mode)) {

    error(_("invalid path '%s'"), path);

    return NULL;

  }

  len = strlen(path);

  ce = make_empty_transient_cache_entry(len, ce_mem_pool);

  oidcpy(&ce->oid, oid);

  memcpy(ce->name, path, len);

  ce->ce_flags = create_ce_flags(stage);

  ce->ce_namelen = len;

  ce->ce_mode = create_ce_mode(mode);

  return ce;

}