efc4aaed98af84a4f1cffb87416f0730b73bbaef
   1/*
   2 * GIT - The information manager from hell
   3 *
   4 * Copyright (C) Linus Torvalds, 2005
   5 */
   6#define NO_THE_INDEX_COMPATIBILITY_MACROS
   7#include "cache.h"
   8#include "cache-tree.h"
   9#include "refs.h"
  10#include "dir.h"
  11#include "tree.h"
  12#include "commit.h"
  13#include "blob.h"
  14#include "resolve-undo.h"
  15#include "strbuf.h"
  16#include "varint.h"
  17
  18static struct cache_entry *refresh_cache_entry(struct cache_entry *ce, int really);
  19
  20/* Mask for the name length in ce_flags in the on-disk index */
  21
  22#define CE_NAMEMASK  (0x0fff)
  23
  24/* Index extensions.
  25 *
  26 * The first letter should be 'A'..'Z' for extensions that are not
  27 * necessary for a correct operation (i.e. optimization data).
  28 * When new extensions are added that _needs_ to be understood in
  29 * order to correctly interpret the index file, pick character that
  30 * is outside the range, to cause the reader to abort.
  31 */
  32
  33#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) )
  34#define CACHE_EXT_TREE 0x54524545       /* "TREE" */
  35#define CACHE_EXT_RESOLVE_UNDO 0x52455543 /* "REUC" */
  36
  37struct index_state the_index;
  38
  39static void set_index_entry(struct index_state *istate, int nr, struct cache_entry *ce)
  40{
  41        istate->cache[nr] = ce;
  42        add_name_hash(istate, ce);
  43}
  44
  45static void replace_index_entry(struct index_state *istate, int nr, struct cache_entry *ce)
  46{
  47        struct cache_entry *old = istate->cache[nr];
  48
  49        remove_name_hash(istate, old);
  50        set_index_entry(istate, nr, ce);
  51        istate->cache_changed = 1;
  52}
  53
  54void rename_index_entry_at(struct index_state *istate, int nr, const char *new_name)
  55{
  56        struct cache_entry *old = istate->cache[nr], *new;
  57        int namelen = strlen(new_name);
  58
  59        new = xmalloc(cache_entry_size(namelen));
  60        copy_cache_entry(new, old);
  61        new->ce_flags &= ~CE_STATE_MASK;
  62        new->ce_namelen = namelen;
  63        memcpy(new->name, new_name, namelen + 1);
  64
  65        cache_tree_invalidate_path(istate->cache_tree, old->name);
  66        remove_index_entry_at(istate, nr);
  67        add_index_entry(istate, new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);
  68}
  69
  70void fill_stat_data(struct stat_data *sd, struct stat *st)
  71{
  72        sd->sd_ctime.sec = (unsigned int)st->st_ctime;
  73        sd->sd_mtime.sec = (unsigned int)st->st_mtime;
  74        sd->sd_ctime.nsec = ST_CTIME_NSEC(*st);
  75        sd->sd_mtime.nsec = ST_MTIME_NSEC(*st);
  76        sd->sd_dev = st->st_dev;
  77        sd->sd_ino = st->st_ino;
  78        sd->sd_uid = st->st_uid;
  79        sd->sd_gid = st->st_gid;
  80        sd->sd_size = st->st_size;
  81}
  82
  83int match_stat_data(const struct stat_data *sd, struct stat *st)
  84{
  85        int changed = 0;
  86
  87        if (sd->sd_mtime.sec != (unsigned int)st->st_mtime)
  88                changed |= MTIME_CHANGED;
  89        if (trust_ctime && check_stat &&
  90            sd->sd_ctime.sec != (unsigned int)st->st_ctime)
  91                changed |= CTIME_CHANGED;
  92
  93#ifdef USE_NSEC
  94        if (check_stat && sd->sd_mtime.nsec != ST_MTIME_NSEC(*st))
  95                changed |= MTIME_CHANGED;
  96        if (trust_ctime && check_stat &&
  97            sd->sd_ctime.nsec != ST_CTIME_NSEC(*st))
  98                changed |= CTIME_CHANGED;
  99#endif
 100
 101        if (check_stat) {
 102                if (sd->sd_uid != (unsigned int) st->st_uid ||
 103                        sd->sd_gid != (unsigned int) st->st_gid)
 104                        changed |= OWNER_CHANGED;
 105                if (sd->sd_ino != (unsigned int) st->st_ino)
 106                        changed |= INODE_CHANGED;
 107        }
 108
 109#ifdef USE_STDEV
 110        /*
 111         * st_dev breaks on network filesystems where different
 112         * clients will have different views of what "device"
 113         * the filesystem is on
 114         */
 115        if (check_stat && sd->sd_dev != (unsigned int) st->st_dev)
 116                        changed |= INODE_CHANGED;
 117#endif
 118
 119        if (sd->sd_size != (unsigned int) st->st_size)
 120                changed |= DATA_CHANGED;
 121
 122        return changed;
 123}
 124
 125/*
 126 * This only updates the "non-critical" parts of the directory
 127 * cache, ie the parts that aren't tracked by GIT, and only used
 128 * to validate the cache.
 129 */
 130void fill_stat_cache_info(struct cache_entry *ce, struct stat *st)
 131{
 132        fill_stat_data(&ce->ce_stat_data, st);
 133
 134        if (assume_unchanged)
 135                ce->ce_flags |= CE_VALID;
 136
 137        if (S_ISREG(st->st_mode))
 138                ce_mark_uptodate(ce);
 139}
 140
 141static int ce_compare_data(const struct cache_entry *ce, struct stat *st)
 142{
 143        int match = -1;
 144        int fd = open(ce->name, O_RDONLY);
 145
 146        if (fd >= 0) {
 147                unsigned char sha1[20];
 148                if (!index_fd(sha1, fd, st, OBJ_BLOB, ce->name, 0))
 149                        match = hashcmp(sha1, ce->sha1);
 150                /* index_fd() closed the file descriptor already */
 151        }
 152        return match;
 153}
 154
 155static int ce_compare_link(const struct cache_entry *ce, size_t expected_size)
 156{
 157        int match = -1;
 158        void *buffer;
 159        unsigned long size;
 160        enum object_type type;
 161        struct strbuf sb = STRBUF_INIT;
 162
 163        if (strbuf_readlink(&sb, ce->name, expected_size))
 164                return -1;
 165
 166        buffer = read_sha1_file(ce->sha1, &type, &size);
 167        if (buffer) {
 168                if (size == sb.len)
 169                        match = memcmp(buffer, sb.buf, size);
 170                free(buffer);
 171        }
 172        strbuf_release(&sb);
 173        return match;
 174}
 175
 176static int ce_compare_gitlink(const struct cache_entry *ce)
 177{
 178        unsigned char sha1[20];
 179
 180        /*
 181         * We don't actually require that the .git directory
 182         * under GITLINK directory be a valid git directory. It
 183         * might even be missing (in case nobody populated that
 184         * sub-project).
 185         *
 186         * If so, we consider it always to match.
 187         */
 188        if (resolve_gitlink_ref(ce->name, "HEAD", sha1) < 0)
 189                return 0;
 190        return hashcmp(sha1, ce->sha1);
 191}
 192
 193static int ce_modified_check_fs(const struct cache_entry *ce, struct stat *st)
 194{
 195        switch (st->st_mode & S_IFMT) {
 196        case S_IFREG:
 197                if (ce_compare_data(ce, st))
 198                        return DATA_CHANGED;
 199                break;
 200        case S_IFLNK:
 201                if (ce_compare_link(ce, xsize_t(st->st_size)))
 202                        return DATA_CHANGED;
 203                break;
 204        case S_IFDIR:
 205                if (S_ISGITLINK(ce->ce_mode))
 206                        return ce_compare_gitlink(ce) ? DATA_CHANGED : 0;
 207        default:
 208                return TYPE_CHANGED;
 209        }
 210        return 0;
 211}
 212
 213static int ce_match_stat_basic(const struct cache_entry *ce, struct stat *st)
 214{
 215        unsigned int changed = 0;
 216
 217        if (ce->ce_flags & CE_REMOVE)
 218                return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED;
 219
 220        switch (ce->ce_mode & S_IFMT) {
 221        case S_IFREG:
 222                changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED : 0;
 223                /* We consider only the owner x bit to be relevant for
 224                 * "mode changes"
 225                 */
 226                if (trust_executable_bit &&
 227                    (0100 & (ce->ce_mode ^ st->st_mode)))
 228                        changed |= MODE_CHANGED;
 229                break;
 230        case S_IFLNK:
 231                if (!S_ISLNK(st->st_mode) &&
 232                    (has_symlinks || !S_ISREG(st->st_mode)))
 233                        changed |= TYPE_CHANGED;
 234                break;
 235        case S_IFGITLINK:
 236                /* We ignore most of the st_xxx fields for gitlinks */
 237                if (!S_ISDIR(st->st_mode))
 238                        changed |= TYPE_CHANGED;
 239                else if (ce_compare_gitlink(ce))
 240                        changed |= DATA_CHANGED;
 241                return changed;
 242        default:
 243                die("internal error: ce_mode is %o", ce->ce_mode);
 244        }
 245
 246        changed |= match_stat_data(&ce->ce_stat_data, st);
 247
 248        /* Racily smudged entry? */
 249        if (!ce->ce_stat_data.sd_size) {
 250                if (!is_empty_blob_sha1(ce->sha1))
 251                        changed |= DATA_CHANGED;
 252        }
 253
 254        return changed;
 255}
 256
 257static int is_racy_timestamp(const struct index_state *istate,
 258                             const struct cache_entry *ce)
 259{
 260        return (!S_ISGITLINK(ce->ce_mode) &&
 261                istate->timestamp.sec &&
 262#ifdef USE_NSEC
 263                 /* nanosecond timestamped files can also be racy! */
 264                (istate->timestamp.sec < ce->ce_stat_data.sd_mtime.sec ||
 265                 (istate->timestamp.sec == ce->ce_stat_data.sd_mtime.sec &&
 266                  istate->timestamp.nsec <= ce->ce_stat_data.sd_mtime.nsec))
 267#else
 268                istate->timestamp.sec <= ce->ce_stat_data.sd_mtime.sec
 269#endif
 270                 );
 271}
 272
 273int ie_match_stat(const struct index_state *istate,
 274                  const struct cache_entry *ce, struct stat *st,
 275                  unsigned int options)
 276{
 277        unsigned int changed;
 278        int ignore_valid = options & CE_MATCH_IGNORE_VALID;
 279        int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;
 280        int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY;
 281
 282        /*
 283         * If it's marked as always valid in the index, it's
 284         * valid whatever the checked-out copy says.
 285         *
 286         * skip-worktree has the same effect with higher precedence
 287         */
 288        if (!ignore_skip_worktree && ce_skip_worktree(ce))
 289                return 0;
 290        if (!ignore_valid && (ce->ce_flags & CE_VALID))
 291                return 0;
 292
 293        /*
 294         * Intent-to-add entries have not been added, so the index entry
 295         * by definition never matches what is in the work tree until it
 296         * actually gets added.
 297         */
 298        if (ce->ce_flags & CE_INTENT_TO_ADD)
 299                return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED;
 300
 301        changed = ce_match_stat_basic(ce, st);
 302
 303        /*
 304         * Within 1 second of this sequence:
 305         *      echo xyzzy >file && git-update-index --add file
 306         * running this command:
 307         *      echo frotz >file
 308         * would give a falsely clean cache entry.  The mtime and
 309         * length match the cache, and other stat fields do not change.
 310         *
 311         * We could detect this at update-index time (the cache entry
 312         * being registered/updated records the same time as "now")
 313         * and delay the return from git-update-index, but that would
 314         * effectively mean we can make at most one commit per second,
 315         * which is not acceptable.  Instead, we check cache entries
 316         * whose mtime are the same as the index file timestamp more
 317         * carefully than others.
 318         */
 319        if (!changed && is_racy_timestamp(istate, ce)) {
 320                if (assume_racy_is_modified)
 321                        changed |= DATA_CHANGED;
 322                else
 323                        changed |= ce_modified_check_fs(ce, st);
 324        }
 325
 326        return changed;
 327}
 328
 329int ie_modified(const struct index_state *istate,
 330                const struct cache_entry *ce,
 331                struct stat *st, unsigned int options)
 332{
 333        int changed, changed_fs;
 334
 335        changed = ie_match_stat(istate, ce, st, options);
 336        if (!changed)
 337                return 0;
 338        /*
 339         * If the mode or type has changed, there's no point in trying
 340         * to refresh the entry - it's not going to match
 341         */
 342        if (changed & (MODE_CHANGED | TYPE_CHANGED))
 343                return changed;
 344
 345        /*
 346         * Immediately after read-tree or update-index --cacheinfo,
 347         * the length field is zero, as we have never even read the
 348         * lstat(2) information once, and we cannot trust DATA_CHANGED
 349         * returned by ie_match_stat() which in turn was returned by
 350         * ce_match_stat_basic() to signal that the filesize of the
 351         * blob changed.  We have to actually go to the filesystem to
 352         * see if the contents match, and if so, should answer "unchanged".
 353         *
 354         * The logic does not apply to gitlinks, as ce_match_stat_basic()
 355         * already has checked the actual HEAD from the filesystem in the
 356         * subproject.  If ie_match_stat() already said it is different,
 357         * then we know it is.
 358         */
 359        if ((changed & DATA_CHANGED) &&
 360            (S_ISGITLINK(ce->ce_mode) || ce->ce_stat_data.sd_size != 0))
 361                return changed;
 362
 363        changed_fs = ce_modified_check_fs(ce, st);
 364        if (changed_fs)
 365                return changed | changed_fs;
 366        return 0;
 367}
 368
 369int base_name_compare(const char *name1, int len1, int mode1,
 370                      const char *name2, int len2, int mode2)
 371{
 372        unsigned char c1, c2;
 373        int len = len1 < len2 ? len1 : len2;
 374        int cmp;
 375
 376        cmp = memcmp(name1, name2, len);
 377        if (cmp)
 378                return cmp;
 379        c1 = name1[len];
 380        c2 = name2[len];
 381        if (!c1 && S_ISDIR(mode1))
 382                c1 = '/';
 383        if (!c2 && S_ISDIR(mode2))
 384                c2 = '/';
 385        return (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;
 386}
 387
 388/*
 389 * df_name_compare() is identical to base_name_compare(), except it
 390 * compares conflicting directory/file entries as equal. Note that
 391 * while a directory name compares as equal to a regular file, they
 392 * then individually compare _differently_ to a filename that has
 393 * a dot after the basename (because '\0' < '.' < '/').
 394 *
 395 * This is used by routines that want to traverse the git namespace
 396 * but then handle conflicting entries together when possible.
 397 */
 398int df_name_compare(const char *name1, int len1, int mode1,
 399                    const char *name2, int len2, int mode2)
 400{
 401        int len = len1 < len2 ? len1 : len2, cmp;
 402        unsigned char c1, c2;
 403
 404        cmp = memcmp(name1, name2, len);
 405        if (cmp)
 406                return cmp;
 407        /* Directories and files compare equal (same length, same name) */
 408        if (len1 == len2)
 409                return 0;
 410        c1 = name1[len];
 411        if (!c1 && S_ISDIR(mode1))
 412                c1 = '/';
 413        c2 = name2[len];
 414        if (!c2 && S_ISDIR(mode2))
 415                c2 = '/';
 416        if (c1 == '/' && !c2)
 417                return 0;
 418        if (c2 == '/' && !c1)
 419                return 0;
 420        return c1 - c2;
 421}
 422
 423int cache_name_stage_compare(const char *name1, int len1, int stage1, const char *name2, int len2, int stage2)
 424{
 425        int len = len1 < len2 ? len1 : len2;
 426        int cmp;
 427
 428        cmp = memcmp(name1, name2, len);
 429        if (cmp)
 430                return cmp;
 431        if (len1 < len2)
 432                return -1;
 433        if (len1 > len2)
 434                return 1;
 435
 436        if (stage1 < stage2)
 437                return -1;
 438        if (stage1 > stage2)
 439                return 1;
 440        return 0;
 441}
 442
 443int cache_name_compare(const char *name1, int len1, const char *name2, int len2)
 444{
 445        return cache_name_stage_compare(name1, len1, 0, name2, len2, 0);
 446}
 447
 448static int index_name_stage_pos(const struct index_state *istate, const char *name, int namelen, int stage)
 449{
 450        int first, last;
 451
 452        first = 0;
 453        last = istate->cache_nr;
 454        while (last > first) {
 455                int next = (last + first) >> 1;
 456                struct cache_entry *ce = istate->cache[next];
 457                int cmp = cache_name_stage_compare(name, namelen, stage, ce->name, ce_namelen(ce), ce_stage(ce));
 458                if (!cmp)
 459                        return next;
 460                if (cmp < 0) {
 461                        last = next;
 462                        continue;
 463                }
 464                first = next+1;
 465        }
 466        return -first-1;
 467}
 468
 469int index_name_pos(const struct index_state *istate, const char *name, int namelen)
 470{
 471        return index_name_stage_pos(istate, name, namelen, 0);
 472}
 473
 474/* Remove entry, return true if there are more entries to go.. */
 475int remove_index_entry_at(struct index_state *istate, int pos)
 476{
 477        struct cache_entry *ce = istate->cache[pos];
 478
 479        record_resolve_undo(istate, ce);
 480        remove_name_hash(istate, ce);
 481        istate->cache_changed = 1;
 482        istate->cache_nr--;
 483        if (pos >= istate->cache_nr)
 484                return 0;
 485        memmove(istate->cache + pos,
 486                istate->cache + pos + 1,
 487                (istate->cache_nr - pos) * sizeof(struct cache_entry *));
 488        return 1;
 489}
 490
 491/*
 492 * Remove all cache entries marked for removal, that is where
 493 * CE_REMOVE is set in ce_flags.  This is much more effective than
 494 * calling remove_index_entry_at() for each entry to be removed.
 495 */
 496void remove_marked_cache_entries(struct index_state *istate)
 497{
 498        struct cache_entry **ce_array = istate->cache;
 499        unsigned int i, j;
 500
 501        for (i = j = 0; i < istate->cache_nr; i++) {
 502                if (ce_array[i]->ce_flags & CE_REMOVE)
 503                        remove_name_hash(istate, ce_array[i]);
 504                else
 505                        ce_array[j++] = ce_array[i];
 506        }
 507        istate->cache_changed = 1;
 508        istate->cache_nr = j;
 509}
 510
 511int remove_file_from_index(struct index_state *istate, const char *path)
 512{
 513        int pos = index_name_pos(istate, path, strlen(path));
 514        if (pos < 0)
 515                pos = -pos-1;
 516        cache_tree_invalidate_path(istate->cache_tree, path);
 517        while (pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path))
 518                remove_index_entry_at(istate, pos);
 519        return 0;
 520}
 521
 522static int compare_name(struct cache_entry *ce, const char *path, int namelen)
 523{
 524        return namelen != ce_namelen(ce) || memcmp(path, ce->name, namelen);
 525}
 526
 527static int index_name_pos_also_unmerged(struct index_state *istate,
 528        const char *path, int namelen)
 529{
 530        int pos = index_name_pos(istate, path, namelen);
 531        struct cache_entry *ce;
 532
 533        if (pos >= 0)
 534                return pos;
 535
 536        /* maybe unmerged? */
 537        pos = -1 - pos;
 538        if (pos >= istate->cache_nr ||
 539                        compare_name((ce = istate->cache[pos]), path, namelen))
 540                return -1;
 541
 542        /* order of preference: stage 2, 1, 3 */
 543        if (ce_stage(ce) == 1 && pos + 1 < istate->cache_nr &&
 544                        ce_stage((ce = istate->cache[pos + 1])) == 2 &&
 545                        !compare_name(ce, path, namelen))
 546                pos++;
 547        return pos;
 548}
 549
 550static int different_name(struct cache_entry *ce, struct cache_entry *alias)
 551{
 552        int len = ce_namelen(ce);
 553        return ce_namelen(alias) != len || memcmp(ce->name, alias->name, len);
 554}
 555
 556/*
 557 * If we add a filename that aliases in the cache, we will use the
 558 * name that we already have - but we don't want to update the same
 559 * alias twice, because that implies that there were actually two
 560 * different files with aliasing names!
 561 *
 562 * So we use the CE_ADDED flag to verify that the alias was an old
 563 * one before we accept it as
 564 */
 565static struct cache_entry *create_alias_ce(struct cache_entry *ce, struct cache_entry *alias)
 566{
 567        int len;
 568        struct cache_entry *new;
 569
 570        if (alias->ce_flags & CE_ADDED)
 571                die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name);
 572
 573        /* Ok, create the new entry using the name of the existing alias */
 574        len = ce_namelen(alias);
 575        new = xcalloc(1, cache_entry_size(len));
 576        memcpy(new->name, alias->name, len);
 577        copy_cache_entry(new, ce);
 578        free(ce);
 579        return new;
 580}
 581
 582static void record_intent_to_add(struct cache_entry *ce)
 583{
 584        unsigned char sha1[20];
 585        if (write_sha1_file("", 0, blob_type, sha1))
 586                die("cannot create an empty blob in the object database");
 587        hashcpy(ce->sha1, sha1);
 588}
 589
 590int add_to_index(struct index_state *istate, const char *path, struct stat *st, int flags)
 591{
 592        int size, namelen, was_same;
 593        mode_t st_mode = st->st_mode;
 594        struct cache_entry *ce, *alias;
 595        unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY;
 596        int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND);
 597        int pretend = flags & ADD_CACHE_PRETEND;
 598        int intent_only = flags & ADD_CACHE_INTENT;
 599        int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE|
 600                          (intent_only ? ADD_CACHE_NEW_ONLY : 0));
 601
 602        if (!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode))
 603                return error("%s: can only add regular files, symbolic links or git-directories", path);
 604
 605        namelen = strlen(path);
 606        if (S_ISDIR(st_mode)) {
 607                while (namelen && path[namelen-1] == '/')
 608                        namelen--;
 609        }
 610        size = cache_entry_size(namelen);
 611        ce = xcalloc(1, size);
 612        memcpy(ce->name, path, namelen);
 613        ce->ce_namelen = namelen;
 614        if (!intent_only)
 615                fill_stat_cache_info(ce, st);
 616        else
 617                ce->ce_flags |= CE_INTENT_TO_ADD;
 618
 619        if (trust_executable_bit && has_symlinks)
 620                ce->ce_mode = create_ce_mode(st_mode);
 621        else {
 622                /* If there is an existing entry, pick the mode bits and type
 623                 * from it, otherwise assume unexecutable regular file.
 624                 */
 625                struct cache_entry *ent;
 626                int pos = index_name_pos_also_unmerged(istate, path, namelen);
 627
 628                ent = (0 <= pos) ? istate->cache[pos] : NULL;
 629                ce->ce_mode = ce_mode_from_stat(ent, st_mode);
 630        }
 631
 632        /* When core.ignorecase=true, determine if a directory of the same name but differing
 633         * case already exists within the Git repository.  If it does, ensure the directory
 634         * case of the file being added to the repository matches (is folded into) the existing
 635         * entry's directory case.
 636         */
 637        if (ignore_case) {
 638                const char *startPtr = ce->name;
 639                const char *ptr = startPtr;
 640                while (*ptr) {
 641                        while (*ptr && *ptr != '/')
 642                                ++ptr;
 643                        if (*ptr == '/') {
 644                                struct cache_entry *foundce;
 645                                ++ptr;
 646                                foundce = index_dir_exists(istate, ce->name, ptr - ce->name - 1);
 647                                if (foundce) {
 648                                        memcpy((void *)startPtr, foundce->name + (startPtr - ce->name), ptr - startPtr);
 649                                        startPtr = ptr;
 650                                }
 651                        }
 652                }
 653        }
 654
 655        alias = index_file_exists(istate, ce->name, ce_namelen(ce), ignore_case);
 656        if (alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) {
 657                /* Nothing changed, really */
 658                free(ce);
 659                if (!S_ISGITLINK(alias->ce_mode))
 660                        ce_mark_uptodate(alias);
 661                alias->ce_flags |= CE_ADDED;
 662                return 0;
 663        }
 664        if (!intent_only) {
 665                if (index_path(ce->sha1, path, st, HASH_WRITE_OBJECT))
 666                        return error("unable to index file %s", path);
 667        } else
 668                record_intent_to_add(ce);
 669
 670        if (ignore_case && alias && different_name(ce, alias))
 671                ce = create_alias_ce(ce, alias);
 672        ce->ce_flags |= CE_ADDED;
 673
 674        /* It was suspected to be racily clean, but it turns out to be Ok */
 675        was_same = (alias &&
 676                    !ce_stage(alias) &&
 677                    !hashcmp(alias->sha1, ce->sha1) &&
 678                    ce->ce_mode == alias->ce_mode);
 679
 680        if (pretend)
 681                ;
 682        else if (add_index_entry(istate, ce, add_option))
 683                return error("unable to add %s to index",path);
 684        if (verbose && !was_same)
 685                printf("add '%s'\n", path);
 686        return 0;
 687}
 688
 689int add_file_to_index(struct index_state *istate, const char *path, int flags)
 690{
 691        struct stat st;
 692        if (lstat(path, &st))
 693                die_errno("unable to stat '%s'", path);
 694        return add_to_index(istate, path, &st, flags);
 695}
 696
 697struct cache_entry *make_cache_entry(unsigned int mode,
 698                const unsigned char *sha1, const char *path, int stage,
 699                int refresh)
 700{
 701        int size, len;
 702        struct cache_entry *ce;
 703
 704        if (!verify_path(path)) {
 705                error("Invalid path '%s'", path);
 706                return NULL;
 707        }
 708
 709        len = strlen(path);
 710        size = cache_entry_size(len);
 711        ce = xcalloc(1, size);
 712
 713        hashcpy(ce->sha1, sha1);
 714        memcpy(ce->name, path, len);
 715        ce->ce_flags = create_ce_flags(stage);
 716        ce->ce_namelen = len;
 717        ce->ce_mode = create_ce_mode(mode);
 718
 719        if (refresh)
 720                return refresh_cache_entry(ce, 0);
 721
 722        return ce;
 723}
 724
 725int ce_same_name(const struct cache_entry *a, const struct cache_entry *b)
 726{
 727        int len = ce_namelen(a);
 728        return ce_namelen(b) == len && !memcmp(a->name, b->name, len);
 729}
 730
 731int ce_path_match(const struct cache_entry *ce, const struct pathspec *pathspec)
 732{
 733        return match_pathspec_depth(pathspec, ce->name, ce_namelen(ce), 0, NULL);
 734}
 735
 736/*
 737 * We fundamentally don't like some paths: we don't want
 738 * dot or dot-dot anywhere, and for obvious reasons don't
 739 * want to recurse into ".git" either.
 740 *
 741 * Also, we don't want double slashes or slashes at the
 742 * end that can make pathnames ambiguous.
 743 */
 744static int verify_dotfile(const char *rest)
 745{
 746        /*
 747         * The first character was '.', but that
 748         * has already been discarded, we now test
 749         * the rest.
 750         */
 751
 752        /* "." is not allowed */
 753        if (*rest == '\0' || is_dir_sep(*rest))
 754                return 0;
 755
 756        switch (*rest) {
 757        /*
 758         * ".git" followed by  NUL or slash is bad. This
 759         * shares the path end test with the ".." case.
 760         */
 761        case 'g':
 762                if (rest[1] != 'i')
 763                        break;
 764                if (rest[2] != 't')
 765                        break;
 766                rest += 2;
 767        /* fallthrough */
 768        case '.':
 769                if (rest[1] == '\0' || is_dir_sep(rest[1]))
 770                        return 0;
 771        }
 772        return 1;
 773}
 774
 775int verify_path(const char *path)
 776{
 777        char c;
 778
 779        if (has_dos_drive_prefix(path))
 780                return 0;
 781
 782        goto inside;
 783        for (;;) {
 784                if (!c)
 785                        return 1;
 786                if (is_dir_sep(c)) {
 787inside:
 788                        c = *path++;
 789                        if ((c == '.' && !verify_dotfile(path)) ||
 790                            is_dir_sep(c) || c == '\0')
 791                                return 0;
 792                }
 793                c = *path++;
 794        }
 795}
 796
 797/*
 798 * Do we have another file that has the beginning components being a
 799 * proper superset of the name we're trying to add?
 800 */
 801static int has_file_name(struct index_state *istate,
 802                         const struct cache_entry *ce, int pos, int ok_to_replace)
 803{
 804        int retval = 0;
 805        int len = ce_namelen(ce);
 806        int stage = ce_stage(ce);
 807        const char *name = ce->name;
 808
 809        while (pos < istate->cache_nr) {
 810                struct cache_entry *p = istate->cache[pos++];
 811
 812                if (len >= ce_namelen(p))
 813                        break;
 814                if (memcmp(name, p->name, len))
 815                        break;
 816                if (ce_stage(p) != stage)
 817                        continue;
 818                if (p->name[len] != '/')
 819                        continue;
 820                if (p->ce_flags & CE_REMOVE)
 821                        continue;
 822                retval = -1;
 823                if (!ok_to_replace)
 824                        break;
 825                remove_index_entry_at(istate, --pos);
 826        }
 827        return retval;
 828}
 829
 830/*
 831 * Do we have another file with a pathname that is a proper
 832 * subset of the name we're trying to add?
 833 */
 834static int has_dir_name(struct index_state *istate,
 835                        const struct cache_entry *ce, int pos, int ok_to_replace)
 836{
 837        int retval = 0;
 838        int stage = ce_stage(ce);
 839        const char *name = ce->name;
 840        const char *slash = name + ce_namelen(ce);
 841
 842        for (;;) {
 843                int len;
 844
 845                for (;;) {
 846                        if (*--slash == '/')
 847                                break;
 848                        if (slash <= ce->name)
 849                                return retval;
 850                }
 851                len = slash - name;
 852
 853                pos = index_name_stage_pos(istate, name, len, stage);
 854                if (pos >= 0) {
 855                        /*
 856                         * Found one, but not so fast.  This could
 857                         * be a marker that says "I was here, but
 858                         * I am being removed".  Such an entry is
 859                         * not a part of the resulting tree, and
 860                         * it is Ok to have a directory at the same
 861                         * path.
 862                         */
 863                        if (!(istate->cache[pos]->ce_flags & CE_REMOVE)) {
 864                                retval = -1;
 865                                if (!ok_to_replace)
 866                                        break;
 867                                remove_index_entry_at(istate, pos);
 868                                continue;
 869                        }
 870                }
 871                else
 872                        pos = -pos-1;
 873
 874                /*
 875                 * Trivial optimization: if we find an entry that
 876                 * already matches the sub-directory, then we know
 877                 * we're ok, and we can exit.
 878                 */
 879                while (pos < istate->cache_nr) {
 880                        struct cache_entry *p = istate->cache[pos];
 881                        if ((ce_namelen(p) <= len) ||
 882                            (p->name[len] != '/') ||
 883                            memcmp(p->name, name, len))
 884                                break; /* not our subdirectory */
 885                        if (ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))
 886                                /*
 887                                 * p is at the same stage as our entry, and
 888                                 * is a subdirectory of what we are looking
 889                                 * at, so we cannot have conflicts at our
 890                                 * level or anything shorter.
 891                                 */
 892                                return retval;
 893                        pos++;
 894                }
 895        }
 896        return retval;
 897}
 898
 899/* We may be in a situation where we already have path/file and path
 900 * is being added, or we already have path and path/file is being
 901 * added.  Either one would result in a nonsense tree that has path
 902 * twice when git-write-tree tries to write it out.  Prevent it.
 903 *
 904 * If ok-to-replace is specified, we remove the conflicting entries
 905 * from the cache so the caller should recompute the insert position.
 906 * When this happens, we return non-zero.
 907 */
 908static int check_file_directory_conflict(struct index_state *istate,
 909                                         const struct cache_entry *ce,
 910                                         int pos, int ok_to_replace)
 911{
 912        int retval;
 913
 914        /*
 915         * When ce is an "I am going away" entry, we allow it to be added
 916         */
 917        if (ce->ce_flags & CE_REMOVE)
 918                return 0;
 919
 920        /*
 921         * We check if the path is a sub-path of a subsequent pathname
 922         * first, since removing those will not change the position
 923         * in the array.
 924         */
 925        retval = has_file_name(istate, ce, pos, ok_to_replace);
 926
 927        /*
 928         * Then check if the path might have a clashing sub-directory
 929         * before it.
 930         */
 931        return retval + has_dir_name(istate, ce, pos, ok_to_replace);
 932}
 933
 934static int add_index_entry_with_check(struct index_state *istate, struct cache_entry *ce, int option)
 935{
 936        int pos;
 937        int ok_to_add = option & ADD_CACHE_OK_TO_ADD;
 938        int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE;
 939        int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK;
 940        int new_only = option & ADD_CACHE_NEW_ONLY;
 941
 942        cache_tree_invalidate_path(istate->cache_tree, ce->name);
 943        pos = index_name_stage_pos(istate, ce->name, ce_namelen(ce), ce_stage(ce));
 944
 945        /* existing match? Just replace it. */
 946        if (pos >= 0) {
 947                if (!new_only)
 948                        replace_index_entry(istate, pos, ce);
 949                return 0;
 950        }
 951        pos = -pos-1;
 952
 953        /*
 954         * Inserting a merged entry ("stage 0") into the index
 955         * will always replace all non-merged entries..
 956         */
 957        if (pos < istate->cache_nr && ce_stage(ce) == 0) {
 958                while (ce_same_name(istate->cache[pos], ce)) {
 959                        ok_to_add = 1;
 960                        if (!remove_index_entry_at(istate, pos))
 961                                break;
 962                }
 963        }
 964
 965        if (!ok_to_add)
 966                return -1;
 967        if (!verify_path(ce->name))
 968                return error("Invalid path '%s'", ce->name);
 969
 970        if (!skip_df_check &&
 971            check_file_directory_conflict(istate, ce, pos, ok_to_replace)) {
 972                if (!ok_to_replace)
 973                        return error("'%s' appears as both a file and as a directory",
 974                                     ce->name);
 975                pos = index_name_stage_pos(istate, ce->name, ce_namelen(ce), ce_stage(ce));
 976                pos = -pos-1;
 977        }
 978        return pos + 1;
 979}
 980
 981int add_index_entry(struct index_state *istate, struct cache_entry *ce, int option)
 982{
 983        int pos;
 984
 985        if (option & ADD_CACHE_JUST_APPEND)
 986                pos = istate->cache_nr;
 987        else {
 988                int ret;
 989                ret = add_index_entry_with_check(istate, ce, option);
 990                if (ret <= 0)
 991                        return ret;
 992                pos = ret - 1;
 993        }
 994
 995        /* Make sure the array is big enough .. */
 996        if (istate->cache_nr == istate->cache_alloc) {
 997                istate->cache_alloc = alloc_nr(istate->cache_alloc);
 998                istate->cache = xrealloc(istate->cache,
 999                                        istate->cache_alloc * sizeof(*istate->cache));
1000        }
1001
1002        /* Add it in.. */
1003        istate->cache_nr++;
1004        if (istate->cache_nr > pos + 1)
1005                memmove(istate->cache + pos + 1,
1006                        istate->cache + pos,
1007                        (istate->cache_nr - pos - 1) * sizeof(ce));
1008        set_index_entry(istate, pos, ce);
1009        istate->cache_changed = 1;
1010        return 0;
1011}
1012
1013/*
1014 * "refresh" does not calculate a new sha1 file or bring the
1015 * cache up-to-date for mode/content changes. But what it
1016 * _does_ do is to "re-match" the stat information of a file
1017 * with the cache, so that you can refresh the cache for a
1018 * file that hasn't been changed but where the stat entry is
1019 * out of date.
1020 *
1021 * For example, you'd want to do this after doing a "git-read-tree",
1022 * to link up the stat cache details with the proper files.
1023 */
1024static struct cache_entry *refresh_cache_ent(struct index_state *istate,
1025                                             struct cache_entry *ce,
1026                                             unsigned int options, int *err,
1027                                             int *changed_ret)
1028{
1029        struct stat st;
1030        struct cache_entry *updated;
1031        int changed, size;
1032        int ignore_valid = options & CE_MATCH_IGNORE_VALID;
1033        int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;
1034
1035        if (ce_uptodate(ce))
1036                return ce;
1037
1038        /*
1039         * CE_VALID or CE_SKIP_WORKTREE means the user promised us
1040         * that the change to the work tree does not matter and told
1041         * us not to worry.
1042         */
1043        if (!ignore_skip_worktree && ce_skip_worktree(ce)) {
1044                ce_mark_uptodate(ce);
1045                return ce;
1046        }
1047        if (!ignore_valid && (ce->ce_flags & CE_VALID)) {
1048                ce_mark_uptodate(ce);
1049                return ce;
1050        }
1051
1052        if (lstat(ce->name, &st) < 0) {
1053                if (err)
1054                        *err = errno;
1055                return NULL;
1056        }
1057
1058        changed = ie_match_stat(istate, ce, &st, options);
1059        if (changed_ret)
1060                *changed_ret = changed;
1061        if (!changed) {
1062                /*
1063                 * The path is unchanged.  If we were told to ignore
1064                 * valid bit, then we did the actual stat check and
1065                 * found that the entry is unmodified.  If the entry
1066                 * is not marked VALID, this is the place to mark it
1067                 * valid again, under "assume unchanged" mode.
1068                 */
1069                if (ignore_valid && assume_unchanged &&
1070                    !(ce->ce_flags & CE_VALID))
1071                        ; /* mark this one VALID again */
1072                else {
1073                        /*
1074                         * We do not mark the index itself "modified"
1075                         * because CE_UPTODATE flag is in-core only;
1076                         * we are not going to write this change out.
1077                         */
1078                        if (!S_ISGITLINK(ce->ce_mode))
1079                                ce_mark_uptodate(ce);
1080                        return ce;
1081                }
1082        }
1083
1084        if (ie_modified(istate, ce, &st, options)) {
1085                if (err)
1086                        *err = EINVAL;
1087                return NULL;
1088        }
1089
1090        size = ce_size(ce);
1091        updated = xmalloc(size);
1092        memcpy(updated, ce, size);
1093        fill_stat_cache_info(updated, &st);
1094        /*
1095         * If ignore_valid is not set, we should leave CE_VALID bit
1096         * alone.  Otherwise, paths marked with --no-assume-unchanged
1097         * (i.e. things to be edited) will reacquire CE_VALID bit
1098         * automatically, which is not really what we want.
1099         */
1100        if (!ignore_valid && assume_unchanged &&
1101            !(ce->ce_flags & CE_VALID))
1102                updated->ce_flags &= ~CE_VALID;
1103
1104        return updated;
1105}
1106
1107static void show_file(const char * fmt, const char * name, int in_porcelain,
1108                      int * first, const char *header_msg)
1109{
1110        if (in_porcelain && *first && header_msg) {
1111                printf("%s\n", header_msg);
1112                *first = 0;
1113        }
1114        printf(fmt, name);
1115}
1116
1117int refresh_index(struct index_state *istate, unsigned int flags,
1118                  const struct pathspec *pathspec,
1119                  char *seen, const char *header_msg)
1120{
1121        int i;
1122        int has_errors = 0;
1123        int really = (flags & REFRESH_REALLY) != 0;
1124        int allow_unmerged = (flags & REFRESH_UNMERGED) != 0;
1125        int quiet = (flags & REFRESH_QUIET) != 0;
1126        int not_new = (flags & REFRESH_IGNORE_MISSING) != 0;
1127        int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) != 0;
1128        int first = 1;
1129        int in_porcelain = (flags & REFRESH_IN_PORCELAIN);
1130        unsigned int options = really ? CE_MATCH_IGNORE_VALID : 0;
1131        const char *modified_fmt;
1132        const char *deleted_fmt;
1133        const char *typechange_fmt;
1134        const char *added_fmt;
1135        const char *unmerged_fmt;
1136
1137        modified_fmt = (in_porcelain ? "M\t%s\n" : "%s: needs update\n");
1138        deleted_fmt = (in_porcelain ? "D\t%s\n" : "%s: needs update\n");
1139        typechange_fmt = (in_porcelain ? "T\t%s\n" : "%s needs update\n");
1140        added_fmt = (in_porcelain ? "A\t%s\n" : "%s needs update\n");
1141        unmerged_fmt = (in_porcelain ? "U\t%s\n" : "%s: needs merge\n");
1142        for (i = 0; i < istate->cache_nr; i++) {
1143                struct cache_entry *ce, *new;
1144                int cache_errno = 0;
1145                int changed = 0;
1146                int filtered = 0;
1147
1148                ce = istate->cache[i];
1149                if (ignore_submodules && S_ISGITLINK(ce->ce_mode))
1150                        continue;
1151
1152                if (pathspec &&
1153                    !match_pathspec_depth(pathspec, ce->name, ce_namelen(ce), 0, seen))
1154                        filtered = 1;
1155
1156                if (ce_stage(ce)) {
1157                        while ((i < istate->cache_nr) &&
1158                               ! strcmp(istate->cache[i]->name, ce->name))
1159                                i++;
1160                        i--;
1161                        if (allow_unmerged)
1162                                continue;
1163                        if (!filtered)
1164                                show_file(unmerged_fmt, ce->name, in_porcelain,
1165                                          &first, header_msg);
1166                        has_errors = 1;
1167                        continue;
1168                }
1169
1170                if (filtered)
1171                        continue;
1172
1173                new = refresh_cache_ent(istate, ce, options, &cache_errno, &changed);
1174                if (new == ce)
1175                        continue;
1176                if (!new) {
1177                        const char *fmt;
1178
1179                        if (not_new && cache_errno == ENOENT)
1180                                continue;
1181                        if (really && cache_errno == EINVAL) {
1182                                /* If we are doing --really-refresh that
1183                                 * means the index is not valid anymore.
1184                                 */
1185                                ce->ce_flags &= ~CE_VALID;
1186                                istate->cache_changed = 1;
1187                        }
1188                        if (quiet)
1189                                continue;
1190
1191                        if (cache_errno == ENOENT)
1192                                fmt = deleted_fmt;
1193                        else if (ce->ce_flags & CE_INTENT_TO_ADD)
1194                                fmt = added_fmt; /* must be before other checks */
1195                        else if (changed & TYPE_CHANGED)
1196                                fmt = typechange_fmt;
1197                        else
1198                                fmt = modified_fmt;
1199                        show_file(fmt,
1200                                  ce->name, in_porcelain, &first, header_msg);
1201                        has_errors = 1;
1202                        continue;
1203                }
1204
1205                replace_index_entry(istate, i, new);
1206        }
1207        return has_errors;
1208}
1209
1210static struct cache_entry *refresh_cache_entry(struct cache_entry *ce, int really)
1211{
1212        return refresh_cache_ent(&the_index, ce, really, NULL, NULL);
1213}
1214
1215
1216/*****************************************************************
1217 * Index File I/O
1218 *****************************************************************/
1219
1220#define INDEX_FORMAT_DEFAULT 3
1221
1222static unsigned int get_index_format_default(void)
1223{
1224        char *envversion = getenv("GIT_INDEX_VERSION");
1225        if (!envversion) {
1226                return INDEX_FORMAT_DEFAULT;
1227        } else {
1228                char *endp;
1229                unsigned int version = strtoul(envversion, &endp, 10);
1230
1231                if (*endp ||
1232                    version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < version) {
1233                        warning(_("GIT_INDEX_VERSION set, but the value is invalid.\n"
1234                                  "Using version %i"), INDEX_FORMAT_DEFAULT);
1235                        version = INDEX_FORMAT_DEFAULT;
1236                }
1237                return version;
1238        }
1239}
1240
1241/*
1242 * dev/ino/uid/gid/size are also just tracked to the low 32 bits
1243 * Again - this is just a (very strong in practice) heuristic that
1244 * the inode hasn't changed.
1245 *
1246 * We save the fields in big-endian order to allow using the
1247 * index file over NFS transparently.
1248 */
1249struct ondisk_cache_entry {
1250        struct cache_time ctime;
1251        struct cache_time mtime;
1252        uint32_t dev;
1253        uint32_t ino;
1254        uint32_t mode;
1255        uint32_t uid;
1256        uint32_t gid;
1257        uint32_t size;
1258        unsigned char sha1[20];
1259        uint16_t flags;
1260        char name[FLEX_ARRAY]; /* more */
1261};
1262
1263/*
1264 * This struct is used when CE_EXTENDED bit is 1
1265 * The struct must match ondisk_cache_entry exactly from
1266 * ctime till flags
1267 */
1268struct ondisk_cache_entry_extended {
1269        struct cache_time ctime;
1270        struct cache_time mtime;
1271        uint32_t dev;
1272        uint32_t ino;
1273        uint32_t mode;
1274        uint32_t uid;
1275        uint32_t gid;
1276        uint32_t size;
1277        unsigned char sha1[20];
1278        uint16_t flags;
1279        uint16_t flags2;
1280        char name[FLEX_ARRAY]; /* more */
1281};
1282
1283/* These are only used for v3 or lower */
1284#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)
1285#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)
1286#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)
1287#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \
1288                            ondisk_cache_entry_extended_size(ce_namelen(ce)) : \
1289                            ondisk_cache_entry_size(ce_namelen(ce)))
1290
1291static int verify_hdr(struct cache_header *hdr, unsigned long size)
1292{
1293        git_SHA_CTX c;
1294        unsigned char sha1[20];
1295        int hdr_version;
1296
1297        if (hdr->hdr_signature != htonl(CACHE_SIGNATURE))
1298                return error("bad signature");
1299        hdr_version = ntohl(hdr->hdr_version);
1300        if (hdr_version < INDEX_FORMAT_LB || INDEX_FORMAT_UB < hdr_version)
1301                return error("bad index version %d", hdr_version);
1302        git_SHA1_Init(&c);
1303        git_SHA1_Update(&c, hdr, size - 20);
1304        git_SHA1_Final(sha1, &c);
1305        if (hashcmp(sha1, (unsigned char *)hdr + size - 20))
1306                return error("bad index file sha1 signature");
1307        return 0;
1308}
1309
1310static int read_index_extension(struct index_state *istate,
1311                                const char *ext, void *data, unsigned long sz)
1312{
1313        switch (CACHE_EXT(ext)) {
1314        case CACHE_EXT_TREE:
1315                istate->cache_tree = cache_tree_read(data, sz);
1316                break;
1317        case CACHE_EXT_RESOLVE_UNDO:
1318                istate->resolve_undo = resolve_undo_read(data, sz);
1319                break;
1320        default:
1321                if (*ext < 'A' || 'Z' < *ext)
1322                        return error("index uses %.4s extension, which we do not understand",
1323                                     ext);
1324                fprintf(stderr, "ignoring %.4s extension\n", ext);
1325                break;
1326        }
1327        return 0;
1328}
1329
1330int read_index(struct index_state *istate)
1331{
1332        return read_index_from(istate, get_index_file());
1333}
1334
1335#ifndef NEEDS_ALIGNED_ACCESS
1336#define ntoh_s(var) ntohs(var)
1337#define ntoh_l(var) ntohl(var)
1338#else
1339static inline uint16_t ntoh_s_force_align(void *p)
1340{
1341        uint16_t x;
1342        memcpy(&x, p, sizeof(x));
1343        return ntohs(x);
1344}
1345static inline uint32_t ntoh_l_force_align(void *p)
1346{
1347        uint32_t x;
1348        memcpy(&x, p, sizeof(x));
1349        return ntohl(x);
1350}
1351#define ntoh_s(var) ntoh_s_force_align(&(var))
1352#define ntoh_l(var) ntoh_l_force_align(&(var))
1353#endif
1354
1355static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,
1356                                                   unsigned int flags,
1357                                                   const char *name,
1358                                                   size_t len)
1359{
1360        struct cache_entry *ce = xmalloc(cache_entry_size(len));
1361
1362        ce->ce_stat_data.sd_ctime.sec = ntoh_l(ondisk->ctime.sec);
1363        ce->ce_stat_data.sd_mtime.sec = ntoh_l(ondisk->mtime.sec);
1364        ce->ce_stat_data.sd_ctime.nsec = ntoh_l(ondisk->ctime.nsec);
1365        ce->ce_stat_data.sd_mtime.nsec = ntoh_l(ondisk->mtime.nsec);
1366        ce->ce_stat_data.sd_dev   = ntoh_l(ondisk->dev);
1367        ce->ce_stat_data.sd_ino   = ntoh_l(ondisk->ino);
1368        ce->ce_mode  = ntoh_l(ondisk->mode);
1369        ce->ce_stat_data.sd_uid   = ntoh_l(ondisk->uid);
1370        ce->ce_stat_data.sd_gid   = ntoh_l(ondisk->gid);
1371        ce->ce_stat_data.sd_size  = ntoh_l(ondisk->size);
1372        ce->ce_flags = flags & ~CE_NAMEMASK;
1373        ce->ce_namelen = len;
1374        hashcpy(ce->sha1, ondisk->sha1);
1375        memcpy(ce->name, name, len);
1376        ce->name[len] = '\0';
1377        return ce;
1378}
1379
1380/*
1381 * Adjacent cache entries tend to share the leading paths, so it makes
1382 * sense to only store the differences in later entries.  In the v4
1383 * on-disk format of the index, each on-disk cache entry stores the
1384 * number of bytes to be stripped from the end of the previous name,
1385 * and the bytes to append to the result, to come up with its name.
1386 */
1387static unsigned long expand_name_field(struct strbuf *name, const char *cp_)
1388{
1389        const unsigned char *ep, *cp = (const unsigned char *)cp_;
1390        size_t len = decode_varint(&cp);
1391
1392        if (name->len < len)
1393                die("malformed name field in the index");
1394        strbuf_remove(name, name->len - len, len);
1395        for (ep = cp; *ep; ep++)
1396                ; /* find the end */
1397        strbuf_add(name, cp, ep - cp);
1398        return (const char *)ep + 1 - cp_;
1399}
1400
1401static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,
1402                                            unsigned long *ent_size,
1403                                            struct strbuf *previous_name)
1404{
1405        struct cache_entry *ce;
1406        size_t len;
1407        const char *name;
1408        unsigned int flags;
1409
1410        /* On-disk flags are just 16 bits */
1411        flags = ntoh_s(ondisk->flags);
1412        len = flags & CE_NAMEMASK;
1413
1414        if (flags & CE_EXTENDED) {
1415                struct ondisk_cache_entry_extended *ondisk2;
1416                int extended_flags;
1417                ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;
1418                extended_flags = ntoh_s(ondisk2->flags2) << 16;
1419                /* We do not yet understand any bit out of CE_EXTENDED_FLAGS */
1420                if (extended_flags & ~CE_EXTENDED_FLAGS)
1421                        die("Unknown index entry format %08x", extended_flags);
1422                flags |= extended_flags;
1423                name = ondisk2->name;
1424        }
1425        else
1426                name = ondisk->name;
1427
1428        if (!previous_name) {
1429                /* v3 and earlier */
1430                if (len == CE_NAMEMASK)
1431                        len = strlen(name);
1432                ce = cache_entry_from_ondisk(ondisk, flags, name, len);
1433
1434                *ent_size = ondisk_ce_size(ce);
1435        } else {
1436                unsigned long consumed;
1437                consumed = expand_name_field(previous_name, name);
1438                ce = cache_entry_from_ondisk(ondisk, flags,
1439                                             previous_name->buf,
1440                                             previous_name->len);
1441
1442                *ent_size = (name - ((char *)ondisk)) + consumed;
1443        }
1444        return ce;
1445}
1446
1447/* remember to discard_cache() before reading a different cache! */
1448int read_index_from(struct index_state *istate, const char *path)
1449{
1450        int fd, i;
1451        struct stat st;
1452        unsigned long src_offset;
1453        struct cache_header *hdr;
1454        void *mmap;
1455        size_t mmap_size;
1456        struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;
1457
1458        if (istate->initialized)
1459                return istate->cache_nr;
1460
1461        istate->timestamp.sec = 0;
1462        istate->timestamp.nsec = 0;
1463        fd = open(path, O_RDONLY);
1464        if (fd < 0) {
1465                if (errno == ENOENT)
1466                        return 0;
1467                die_errno("index file open failed");
1468        }
1469
1470        if (fstat(fd, &st))
1471                die_errno("cannot stat the open index");
1472
1473        mmap_size = xsize_t(st.st_size);
1474        if (mmap_size < sizeof(struct cache_header) + 20)
1475                die("index file smaller than expected");
1476
1477        mmap = xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
1478        if (mmap == MAP_FAILED)
1479                die_errno("unable to map index file");
1480        close(fd);
1481
1482        hdr = mmap;
1483        if (verify_hdr(hdr, mmap_size) < 0)
1484                goto unmap;
1485
1486        istate->version = ntohl(hdr->hdr_version);
1487        istate->cache_nr = ntohl(hdr->hdr_entries);
1488        istate->cache_alloc = alloc_nr(istate->cache_nr);
1489        istate->cache = xcalloc(istate->cache_alloc, sizeof(*istate->cache));
1490        istate->initialized = 1;
1491
1492        if (istate->version == 4)
1493                previous_name = &previous_name_buf;
1494        else
1495                previous_name = NULL;
1496
1497        src_offset = sizeof(*hdr);
1498        for (i = 0; i < istate->cache_nr; i++) {
1499                struct ondisk_cache_entry *disk_ce;
1500                struct cache_entry *ce;
1501                unsigned long consumed;
1502
1503                disk_ce = (struct ondisk_cache_entry *)((char *)mmap + src_offset);
1504                ce = create_from_disk(disk_ce, &consumed, previous_name);
1505                set_index_entry(istate, i, ce);
1506
1507                src_offset += consumed;
1508        }
1509        strbuf_release(&previous_name_buf);
1510        istate->timestamp.sec = st.st_mtime;
1511        istate->timestamp.nsec = ST_MTIME_NSEC(st);
1512
1513        while (src_offset <= mmap_size - 20 - 8) {
1514                /* After an array of active_nr index entries,
1515                 * there can be arbitrary number of extended
1516                 * sections, each of which is prefixed with
1517                 * extension name (4-byte) and section length
1518                 * in 4-byte network byte order.
1519                 */
1520                uint32_t extsize;
1521                memcpy(&extsize, (char *)mmap + src_offset + 4, 4);
1522                extsize = ntohl(extsize);
1523                if (read_index_extension(istate,
1524                                         (const char *) mmap + src_offset,
1525                                         (char *) mmap + src_offset + 8,
1526                                         extsize) < 0)
1527                        goto unmap;
1528                src_offset += 8;
1529                src_offset += extsize;
1530        }
1531        munmap(mmap, mmap_size);
1532        return istate->cache_nr;
1533
1534unmap:
1535        munmap(mmap, mmap_size);
1536        die("index file corrupt");
1537}
1538
1539int is_index_unborn(struct index_state *istate)
1540{
1541        return (!istate->cache_nr && !istate->timestamp.sec);
1542}
1543
1544int discard_index(struct index_state *istate)
1545{
1546        int i;
1547
1548        for (i = 0; i < istate->cache_nr; i++)
1549                free(istate->cache[i]);
1550        resolve_undo_clear_index(istate);
1551        istate->cache_nr = 0;
1552        istate->cache_changed = 0;
1553        istate->timestamp.sec = 0;
1554        istate->timestamp.nsec = 0;
1555        free_name_hash(istate);
1556        cache_tree_free(&(istate->cache_tree));
1557        istate->initialized = 0;
1558        free(istate->cache);
1559        istate->cache = NULL;
1560        istate->cache_alloc = 0;
1561        return 0;
1562}
1563
1564int unmerged_index(const struct index_state *istate)
1565{
1566        int i;
1567        for (i = 0; i < istate->cache_nr; i++) {
1568                if (ce_stage(istate->cache[i]))
1569                        return 1;
1570        }
1571        return 0;
1572}
1573
1574#define WRITE_BUFFER_SIZE 8192
1575static unsigned char write_buffer[WRITE_BUFFER_SIZE];
1576static unsigned long write_buffer_len;
1577
1578static int ce_write_flush(git_SHA_CTX *context, int fd)
1579{
1580        unsigned int buffered = write_buffer_len;
1581        if (buffered) {
1582                git_SHA1_Update(context, write_buffer, buffered);
1583                if (write_in_full(fd, write_buffer, buffered) != buffered)
1584                        return -1;
1585                write_buffer_len = 0;
1586        }
1587        return 0;
1588}
1589
1590static int ce_write(git_SHA_CTX *context, int fd, void *data, unsigned int len)
1591{
1592        while (len) {
1593                unsigned int buffered = write_buffer_len;
1594                unsigned int partial = WRITE_BUFFER_SIZE - buffered;
1595                if (partial > len)
1596                        partial = len;
1597                memcpy(write_buffer + buffered, data, partial);
1598                buffered += partial;
1599                if (buffered == WRITE_BUFFER_SIZE) {
1600                        write_buffer_len = buffered;
1601                        if (ce_write_flush(context, fd))
1602                                return -1;
1603                        buffered = 0;
1604                }
1605                write_buffer_len = buffered;
1606                len -= partial;
1607                data = (char *) data + partial;
1608        }
1609        return 0;
1610}
1611
1612static int write_index_ext_header(git_SHA_CTX *context, int fd,
1613                                  unsigned int ext, unsigned int sz)
1614{
1615        ext = htonl(ext);
1616        sz = htonl(sz);
1617        return ((ce_write(context, fd, &ext, 4) < 0) ||
1618                (ce_write(context, fd, &sz, 4) < 0)) ? -1 : 0;
1619}
1620
1621static int ce_flush(git_SHA_CTX *context, int fd)
1622{
1623        unsigned int left = write_buffer_len;
1624
1625        if (left) {
1626                write_buffer_len = 0;
1627                git_SHA1_Update(context, write_buffer, left);
1628        }
1629
1630        /* Flush first if not enough space for SHA1 signature */
1631        if (left + 20 > WRITE_BUFFER_SIZE) {
1632                if (write_in_full(fd, write_buffer, left) != left)
1633                        return -1;
1634                left = 0;
1635        }
1636
1637        /* Append the SHA1 signature at the end */
1638        git_SHA1_Final(write_buffer + left, context);
1639        left += 20;
1640        return (write_in_full(fd, write_buffer, left) != left) ? -1 : 0;
1641}
1642
1643static void ce_smudge_racily_clean_entry(struct cache_entry *ce)
1644{
1645        /*
1646         * The only thing we care about in this function is to smudge the
1647         * falsely clean entry due to touch-update-touch race, so we leave
1648         * everything else as they are.  We are called for entries whose
1649         * ce_stat_data.sd_mtime match the index file mtime.
1650         *
1651         * Note that this actually does not do much for gitlinks, for
1652         * which ce_match_stat_basic() always goes to the actual
1653         * contents.  The caller checks with is_racy_timestamp() which
1654         * always says "no" for gitlinks, so we are not called for them ;-)
1655         */
1656        struct stat st;
1657
1658        if (lstat(ce->name, &st) < 0)
1659                return;
1660        if (ce_match_stat_basic(ce, &st))
1661                return;
1662        if (ce_modified_check_fs(ce, &st)) {
1663                /* This is "racily clean"; smudge it.  Note that this
1664                 * is a tricky code.  At first glance, it may appear
1665                 * that it can break with this sequence:
1666                 *
1667                 * $ echo xyzzy >frotz
1668                 * $ git-update-index --add frotz
1669                 * $ : >frotz
1670                 * $ sleep 3
1671                 * $ echo filfre >nitfol
1672                 * $ git-update-index --add nitfol
1673                 *
1674                 * but it does not.  When the second update-index runs,
1675                 * it notices that the entry "frotz" has the same timestamp
1676                 * as index, and if we were to smudge it by resetting its
1677                 * size to zero here, then the object name recorded
1678                 * in index is the 6-byte file but the cached stat information
1679                 * becomes zero --- which would then match what we would
1680                 * obtain from the filesystem next time we stat("frotz").
1681                 *
1682                 * However, the second update-index, before calling
1683                 * this function, notices that the cached size is 6
1684                 * bytes and what is on the filesystem is an empty
1685                 * file, and never calls us, so the cached size information
1686                 * for "frotz" stays 6 which does not match the filesystem.
1687                 */
1688                ce->ce_stat_data.sd_size = 0;
1689        }
1690}
1691
1692/* Copy miscellaneous fields but not the name */
1693static char *copy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,
1694                                       struct cache_entry *ce)
1695{
1696        short flags;
1697
1698        ondisk->ctime.sec = htonl(ce->ce_stat_data.sd_ctime.sec);
1699        ondisk->mtime.sec = htonl(ce->ce_stat_data.sd_mtime.sec);
1700        ondisk->ctime.nsec = htonl(ce->ce_stat_data.sd_ctime.nsec);
1701        ondisk->mtime.nsec = htonl(ce->ce_stat_data.sd_mtime.nsec);
1702        ondisk->dev  = htonl(ce->ce_stat_data.sd_dev);
1703        ondisk->ino  = htonl(ce->ce_stat_data.sd_ino);
1704        ondisk->mode = htonl(ce->ce_mode);
1705        ondisk->uid  = htonl(ce->ce_stat_data.sd_uid);
1706        ondisk->gid  = htonl(ce->ce_stat_data.sd_gid);
1707        ondisk->size = htonl(ce->ce_stat_data.sd_size);
1708        hashcpy(ondisk->sha1, ce->sha1);
1709
1710        flags = ce->ce_flags;
1711        flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK : ce_namelen(ce));
1712        ondisk->flags = htons(flags);
1713        if (ce->ce_flags & CE_EXTENDED) {
1714                struct ondisk_cache_entry_extended *ondisk2;
1715                ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;
1716                ondisk2->flags2 = htons((ce->ce_flags & CE_EXTENDED_FLAGS) >> 16);
1717                return ondisk2->name;
1718        }
1719        else {
1720                return ondisk->name;
1721        }
1722}
1723
1724static int ce_write_entry(git_SHA_CTX *c, int fd, struct cache_entry *ce,
1725                          struct strbuf *previous_name)
1726{
1727        int size;
1728        struct ondisk_cache_entry *ondisk;
1729        char *name;
1730        int result;
1731
1732        if (!previous_name) {
1733                size = ondisk_ce_size(ce);
1734                ondisk = xcalloc(1, size);
1735                name = copy_cache_entry_to_ondisk(ondisk, ce);
1736                memcpy(name, ce->name, ce_namelen(ce));
1737        } else {
1738                int common, to_remove, prefix_size;
1739                unsigned char to_remove_vi[16];
1740                for (common = 0;
1741                     (ce->name[common] &&
1742                      common < previous_name->len &&
1743                      ce->name[common] == previous_name->buf[common]);
1744                     common++)
1745                        ; /* still matching */
1746                to_remove = previous_name->len - common;
1747                prefix_size = encode_varint(to_remove, to_remove_vi);
1748
1749                if (ce->ce_flags & CE_EXTENDED)
1750                        size = offsetof(struct ondisk_cache_entry_extended, name);
1751                else
1752                        size = offsetof(struct ondisk_cache_entry, name);
1753                size += prefix_size + (ce_namelen(ce) - common + 1);
1754
1755                ondisk = xcalloc(1, size);
1756                name = copy_cache_entry_to_ondisk(ondisk, ce);
1757                memcpy(name, to_remove_vi, prefix_size);
1758                memcpy(name + prefix_size, ce->name + common, ce_namelen(ce) - common);
1759
1760                strbuf_splice(previous_name, common, to_remove,
1761                              ce->name + common, ce_namelen(ce) - common);
1762        }
1763
1764        result = ce_write(c, fd, ondisk, size);
1765        free(ondisk);
1766        return result;
1767}
1768
1769static int has_racy_timestamp(struct index_state *istate)
1770{
1771        int entries = istate->cache_nr;
1772        int i;
1773
1774        for (i = 0; i < entries; i++) {
1775                struct cache_entry *ce = istate->cache[i];
1776                if (is_racy_timestamp(istate, ce))
1777                        return 1;
1778        }
1779        return 0;
1780}
1781
1782/*
1783 * Opportunistically update the index but do not complain if we can't
1784 */
1785void update_index_if_able(struct index_state *istate, struct lock_file *lockfile)
1786{
1787        if ((istate->cache_changed || has_racy_timestamp(istate)) &&
1788            !write_index(istate, lockfile->fd))
1789                commit_locked_index(lockfile);
1790        else
1791                rollback_lock_file(lockfile);
1792}
1793
1794int write_index(struct index_state *istate, int newfd)
1795{
1796        git_SHA_CTX c;
1797        struct cache_header hdr;
1798        int i, err, removed, extended, hdr_version;
1799        struct cache_entry **cache = istate->cache;
1800        int entries = istate->cache_nr;
1801        struct stat st;
1802        struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;
1803
1804        for (i = removed = extended = 0; i < entries; i++) {
1805                if (cache[i]->ce_flags & CE_REMOVE)
1806                        removed++;
1807
1808                /* reduce extended entries if possible */
1809                cache[i]->ce_flags &= ~CE_EXTENDED;
1810                if (cache[i]->ce_flags & CE_EXTENDED_FLAGS) {
1811                        extended++;
1812                        cache[i]->ce_flags |= CE_EXTENDED;
1813                }
1814        }
1815
1816        if (!istate->version)
1817                istate->version = get_index_format_default();
1818
1819        /* demote version 3 to version 2 when the latter suffices */
1820        if (istate->version == 3 || istate->version == 2)
1821                istate->version = extended ? 3 : 2;
1822
1823        hdr_version = istate->version;
1824
1825        hdr.hdr_signature = htonl(CACHE_SIGNATURE);
1826        hdr.hdr_version = htonl(hdr_version);
1827        hdr.hdr_entries = htonl(entries - removed);
1828
1829        git_SHA1_Init(&c);
1830        if (ce_write(&c, newfd, &hdr, sizeof(hdr)) < 0)
1831                return -1;
1832
1833        previous_name = (hdr_version == 4) ? &previous_name_buf : NULL;
1834        for (i = 0; i < entries; i++) {
1835                struct cache_entry *ce = cache[i];
1836                if (ce->ce_flags & CE_REMOVE)
1837                        continue;
1838                if (!ce_uptodate(ce) && is_racy_timestamp(istate, ce))
1839                        ce_smudge_racily_clean_entry(ce);
1840                if (is_null_sha1(ce->sha1)) {
1841                        static const char msg[] = "cache entry has null sha1: %s";
1842                        static int allow = -1;
1843
1844                        if (allow < 0)
1845                                allow = git_env_bool("GIT_ALLOW_NULL_SHA1", 0);
1846                        if (allow)
1847                                warning(msg, ce->name);
1848                        else
1849                                return error(msg, ce->name);
1850                }
1851                if (ce_write_entry(&c, newfd, ce, previous_name) < 0)
1852                        return -1;
1853        }
1854        strbuf_release(&previous_name_buf);
1855
1856        /* Write extension data here */
1857        if (istate->cache_tree) {
1858                struct strbuf sb = STRBUF_INIT;
1859
1860                cache_tree_write(&sb, istate->cache_tree);
1861                err = write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) < 0
1862                        || ce_write(&c, newfd, sb.buf, sb.len) < 0;
1863                strbuf_release(&sb);
1864                if (err)
1865                        return -1;
1866        }
1867        if (istate->resolve_undo) {
1868                struct strbuf sb = STRBUF_INIT;
1869
1870                resolve_undo_write(&sb, istate->resolve_undo);
1871                err = write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,
1872                                             sb.len) < 0
1873                        || ce_write(&c, newfd, sb.buf, sb.len) < 0;
1874                strbuf_release(&sb);
1875                if (err)
1876                        return -1;
1877        }
1878
1879        if (ce_flush(&c, newfd) || fstat(newfd, &st))
1880                return -1;
1881        istate->timestamp.sec = (unsigned int)st.st_mtime;
1882        istate->timestamp.nsec = ST_MTIME_NSEC(st);
1883        return 0;
1884}
1885
1886/*
1887 * Read the index file that is potentially unmerged into given
1888 * index_state, dropping any unmerged entries.  Returns true if
1889 * the index is unmerged.  Callers who want to refuse to work
1890 * from an unmerged state can call this and check its return value,
1891 * instead of calling read_cache().
1892 */
1893int read_index_unmerged(struct index_state *istate)
1894{
1895        int i;
1896        int unmerged = 0;
1897
1898        read_index(istate);
1899        for (i = 0; i < istate->cache_nr; i++) {
1900                struct cache_entry *ce = istate->cache[i];
1901                struct cache_entry *new_ce;
1902                int size, len;
1903
1904                if (!ce_stage(ce))
1905                        continue;
1906                unmerged = 1;
1907                len = ce_namelen(ce);
1908                size = cache_entry_size(len);
1909                new_ce = xcalloc(1, size);
1910                memcpy(new_ce->name, ce->name, len);
1911                new_ce->ce_flags = create_ce_flags(0) | CE_CONFLICTED;
1912                new_ce->ce_namelen = len;
1913                new_ce->ce_mode = ce->ce_mode;
1914                if (add_index_entry(istate, new_ce, 0))
1915                        return error("%s: cannot drop to stage #0",
1916                                     ce->name);
1917                i = index_name_pos(istate, new_ce->name, len);
1918        }
1919        return unmerged;
1920}
1921
1922/*
1923 * Returns 1 if the path is an "other" path with respect to
1924 * the index; that is, the path is not mentioned in the index at all,
1925 * either as a file, a directory with some files in the index,
1926 * or as an unmerged entry.
1927 *
1928 * We helpfully remove a trailing "/" from directories so that
1929 * the output of read_directory can be used as-is.
1930 */
1931int index_name_is_other(const struct index_state *istate, const char *name,
1932                int namelen)
1933{
1934        int pos;
1935        if (namelen && name[namelen - 1] == '/')
1936                namelen--;
1937        pos = index_name_pos(istate, name, namelen);
1938        if (0 <= pos)
1939                return 0;       /* exact match */
1940        pos = -pos - 1;
1941        if (pos < istate->cache_nr) {
1942                struct cache_entry *ce = istate->cache[pos];
1943                if (ce_namelen(ce) == namelen &&
1944                    !memcmp(ce->name, name, namelen))
1945                        return 0; /* Yup, this one exists unmerged */
1946        }
1947        return 1;
1948}
1949
1950void *read_blob_data_from_index(struct index_state *istate, const char *path, unsigned long *size)
1951{
1952        int pos, len;
1953        unsigned long sz;
1954        enum object_type type;
1955        void *data;
1956
1957        len = strlen(path);
1958        pos = index_name_pos(istate, path, len);
1959        if (pos < 0) {
1960                /*
1961                 * We might be in the middle of a merge, in which
1962                 * case we would read stage #2 (ours).
1963                 */
1964                int i;
1965                for (i = -pos - 1;
1966                     (pos < 0 && i < istate->cache_nr &&
1967                      !strcmp(istate->cache[i]->name, path));
1968                     i++)
1969                        if (ce_stage(istate->cache[i]) == 2)
1970                                pos = i;
1971        }
1972        if (pos < 0)
1973                return NULL;
1974        data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz);
1975        if (!data || type != OBJ_BLOB) {
1976                free(data);
1977                return NULL;
1978        }
1979        if (size)
1980                *size = sz;
1981        return data;
1982}
1983
1984void stat_validity_clear(struct stat_validity *sv)
1985{
1986        free(sv->sd);
1987        sv->sd = NULL;
1988}
1989
1990int stat_validity_check(struct stat_validity *sv, const char *path)
1991{
1992        struct stat st;
1993
1994        if (stat(path, &st) < 0)
1995                return sv->sd == NULL;
1996        if (!sv->sd)
1997                return 0;
1998        return S_ISREG(st.st_mode) && !match_stat_data(sv->sd, &st);
1999}
2000
2001void stat_validity_update(struct stat_validity *sv, int fd)
2002{
2003        struct stat st;
2004
2005        if (fstat(fd, &st) < 0 || !S_ISREG(st.st_mode))
2006                stat_validity_clear(sv);
2007        else {
2008                if (!sv->sd)
2009                        sv->sd = xcalloc(1, sizeof(struct stat_data));
2010                fill_stat_data(sv->sd, &st);
2011        }
2012}