index.c 72.3 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6 7 8 9 10
 */

#include <stddef.h>

#include "common.h"
11
#include "repository.h"
12
#include "index.h"
13
#include "tree.h"
14
#include "tree-cache.h"
15
#include "hash.h"
16 17
#include "iterator.h"
#include "pathspec.h"
18
#include "ignore.h"
19
#include "blob.h"
20

21
#include "git2/odb.h"
22
#include "git2/oid.h"
23
#include "git2/blob.h"
24
#include "git2/config.h"
25
#include "git2/sys/index.h"
26

27 28 29 30
static int index_apply_to_wd_diff(git_index *index, int action, const git_strarray *paths,
				  unsigned int flags,
				  git_index_matched_path_cb cb, void *payload);

31 32 33 34 35 36 37 38 39 40
#define entry_size(type,len) ((offsetof(type, path) + (len) + 8) & ~7)
#define short_entry_size(len) entry_size(struct entry_short, len)
#define long_entry_size(len) entry_size(struct entry_long, len)

#define minimal_entry_size (offsetof(struct entry_short, path))

static const size_t INDEX_FOOTER_SIZE = GIT_OID_RAWSZ;
static const size_t INDEX_HEADER_SIZE = 12;

static const unsigned int INDEX_VERSION_NUMBER = 2;
41 42 43 44
static const unsigned int INDEX_VERSION_NUMBER_EXT = 3;

static const unsigned int INDEX_HEADER_SIG = 0x44495243;
static const char INDEX_EXT_TREECACHE_SIG[] = {'T', 'R', 'E', 'E'};
45
static const char INDEX_EXT_UNMERGED_SIG[] = {'R', 'E', 'U', 'C'};
Edward Thomson committed
46
static const char INDEX_EXT_CONFLICT_NAME_SIG[] = {'N', 'A', 'M', 'E'};
47

48 49
#define INDEX_OWNER(idx) ((git_repository *)(GIT_REFCOUNT_OWNER(idx)))

50 51 52 53 54 55 56 57 58 59 60
struct index_header {
	uint32_t signature;
	uint32_t version;
	uint32_t entry_count;
};

struct index_extension {
	char signature[4];
	uint32_t extension_size;
};

61 62 63 64 65
struct entry_time {
	uint32_t seconds;
	uint32_t nanoseconds;
};

66
struct entry_short {
67 68
	struct entry_time ctime;
	struct entry_time mtime;
69 70 71 72 73 74 75 76
	uint32_t dev;
	uint32_t ino;
	uint32_t mode;
	uint32_t uid;
	uint32_t gid;
	uint32_t file_size;
	git_oid oid;
	uint16_t flags;
schu committed
77
	char path[1]; /* arbitrary length */
78 79 80
};

struct entry_long {
81 82
	struct entry_time ctime;
	struct entry_time mtime;
83 84 85 86 87 88 89 90 91
	uint32_t dev;
	uint32_t ino;
	uint32_t mode;
	uint32_t uid;
	uint32_t gid;
	uint32_t file_size;
	git_oid oid;
	uint16_t flags;
	uint16_t flags_extended;
schu committed
92
	char path[1]; /* arbitrary length */
93 94
};

Edward Thomson committed
95 96
struct entry_srch_key {
	const char *path;
97
	size_t pathlen;
Edward Thomson committed
98 99 100
	int stage;
};

101 102 103 104 105 106 107 108 109 110 111 112
struct entry_internal {
	git_index_entry entry;
	size_t pathlen;
	char path[GIT_FLEX_ARRAY];
};

struct reuc_entry_internal {
	git_index_reuc_entry entry;
	size_t pathlen;
	char path[GIT_FLEX_ARRAY];
};

113 114 115 116
/* local declarations */
static size_t read_extension(git_index *index, const char *buffer, size_t buffer_size);
static int read_header(struct index_header *dest, const void *buffer);

117
static int parse_index(git_index *index, const char *buffer, size_t buffer_size);
118
static bool is_index_extended(git_index *index);
119
static int write_index(git_oid *checksum, git_index *index, git_filebuf *file);
120

121
static void index_entry_free(git_index_entry *entry);
Edward Thomson committed
122 123
static void index_entry_reuc_free(git_index_reuc_entry *reuc);

124
int git_index_entry_srch(const void *key, const void *array_member)
125
{
Edward Thomson committed
126
	const struct entry_srch_key *srch_key = key;
127
	const struct entry_internal *entry = array_member;
128 129
	int cmp;
	size_t len1, len2, len;
130

131 132
	len1 = srch_key->pathlen;
	len2 = entry->pathlen;
133
	len = len1 < len2 ? len1 : len2;
Edward Thomson committed
134

135 136 137 138 139 140 141
	cmp = memcmp(srch_key->path, entry->path, len);
	if (cmp)
		return cmp;
	if (len1 < len2)
		return -1;
	if (len1 > len2)
		return 1;
Edward Thomson committed
142

143
	if (srch_key->stage != GIT_INDEX_STAGE_ANY)
144
		return srch_key->stage - GIT_IDXENTRY_STAGE(&entry->entry);
145 146

	return 0;
147 148
}

149
int git_index_entry_isrch(const void *key, const void *array_member)
150
{
Edward Thomson committed
151
	const struct entry_srch_key *srch_key = key;
152
	const struct entry_internal *entry = array_member;
153 154
	int cmp;
	size_t len1, len2, len;
Edward Thomson committed
155

156 157
	len1 = srch_key->pathlen;
	len2 = entry->pathlen;
158
	len = len1 < len2 ? len1 : len2;
Edward Thomson committed
159

160
	cmp = strncasecmp(srch_key->path, entry->path, len);
Edward Thomson committed
161

162 163 164 165 166 167 168 169
	if (cmp)
		return cmp;
	if (len1 < len2)
		return -1;
	if (len1 > len2)
		return 1;

	if (srch_key->stage != GIT_INDEX_STAGE_ANY)
170
		return srch_key->stage - GIT_IDXENTRY_STAGE(&entry->entry);
171 172

	return 0;
Edward Thomson committed
173 174
}

175
static int index_entry_srch_path(const void *path, const void *array_member)
Edward Thomson committed
176
{
177 178
	const git_index_entry *entry = array_member;

Edward Thomson committed
179 180 181
	return strcmp((const char *)path, entry->path);
}

182
static int index_entry_isrch_path(const void *path, const void *array_member)
Edward Thomson committed
183 184 185 186
{
	const git_index_entry *entry = array_member;

	return strcasecmp((const char *)path, entry->path);
187 188
}

189
int git_index_entry_cmp(const void *a, const void *b)
190
{
Edward Thomson committed
191
	int diff;
192 193
	const git_index_entry *entry_a = a;
	const git_index_entry *entry_b = b;
194

Edward Thomson committed
195 196 197
	diff = strcmp(entry_a->path, entry_b->path);

	if (diff == 0)
198
		diff = (GIT_IDXENTRY_STAGE(entry_a) - GIT_IDXENTRY_STAGE(entry_b));
Edward Thomson committed
199 200

	return diff;
201 202
}

203
int git_index_entry_icmp(const void *a, const void *b)
204
{
Edward Thomson committed
205
	int diff;
206 207 208
	const git_index_entry *entry_a = a;
	const git_index_entry *entry_b = b;

Edward Thomson committed
209 210 211
	diff = strcasecmp(entry_a->path, entry_b->path);

	if (diff == 0)
212
		diff = (GIT_IDXENTRY_STAGE(entry_a) - GIT_IDXENTRY_STAGE(entry_b));
Edward Thomson committed
213 214 215 216

	return diff;
}

Edward Thomson committed
217 218 219 220
static int conflict_name_cmp(const void *a, const void *b)
{
	const git_index_name_entry *name_a = a;
	const git_index_name_entry *name_b = b;
221

Edward Thomson committed
222 223
	if (name_a->ancestor && !name_b->ancestor)
		return 1;
224

Edward Thomson committed
225 226
	if (!name_a->ancestor && name_b->ancestor)
		return -1;
227

Edward Thomson committed
228 229
	if (name_a->ancestor)
		return strcmp(name_a->ancestor, name_b->ancestor);
230

Edward Thomson committed
231 232
	if (!name_a->ours || !name_b->ours)
		return 0;
233

Edward Thomson committed
234 235 236
	return strcmp(name_a->ours, name_b->ours);
}

Vicent Marti committed
237 238 239
/**
 * TODO: enable this when resolving case insensitive conflicts
 */
240
#if 0
Edward Thomson committed
241 242 243 244
static int conflict_name_icmp(const void *a, const void *b)
{
	const git_index_name_entry *name_a = a;
	const git_index_name_entry *name_b = b;
245

Edward Thomson committed
246 247
	if (name_a->ancestor && !name_b->ancestor)
		return 1;
248

Edward Thomson committed
249 250
	if (!name_a->ancestor && name_b->ancestor)
		return -1;
251

Edward Thomson committed
252 253
	if (name_a->ancestor)
		return strcasecmp(name_a->ancestor, name_b->ancestor);
254

Edward Thomson committed
255 256
	if (!name_a->ours || !name_b->ours)
		return 0;
257

Edward Thomson committed
258 259
	return strcasecmp(name_a->ours, name_b->ours);
}
260
#endif
Edward Thomson committed
261

Edward Thomson committed
262 263 264 265 266
static int reuc_srch(const void *key, const void *array_member)
{
	const git_index_reuc_entry *reuc = array_member;

	return strcmp(key, reuc->path);
267 268
}

Edward Thomson committed
269
static int reuc_isrch(const void *key, const void *array_member)
270
{
Edward Thomson committed
271
	const git_index_reuc_entry *reuc = array_member;
272

Edward Thomson committed
273
	return strcasecmp(key, reuc->path);
274 275
}

Edward Thomson committed
276
static int reuc_cmp(const void *a, const void *b)
277
{
Edward Thomson committed
278 279
	const git_index_reuc_entry *info_a = a;
	const git_index_reuc_entry *info_b = b;
280 281 282

	return strcmp(info_a->path, info_b->path);
}
283

Edward Thomson committed
284 285 286 287 288 289 290 291
static int reuc_icmp(const void *a, const void *b)
{
	const git_index_reuc_entry *info_a = a;
	const git_index_reuc_entry *info_b = b;

	return strcasecmp(info_a->path, info_b->path);
}

292 293 294 295 296 297 298
static void index_entry_reuc_free(git_index_reuc_entry *reuc)
{
	git__free(reuc);
}

static void index_entry_free(git_index_entry *entry)
{
299 300 301
	if (!entry)
		return;

302
	memset(&entry->id, 0, sizeof(entry->id));
303 304 305
	git__free(entry);
}

306
unsigned int git_index__create_mode(unsigned int mode)
307 308 309
{
	if (S_ISLNK(mode))
		return S_IFLNK;
310

311 312
	if (S_ISDIR(mode) || (mode & S_IFMT) == (S_IFLNK | S_IFDIR))
		return (S_IFLNK | S_IFDIR);
313

314
	return S_IFREG | GIT_PERMS_CANONICAL(mode);
315 316
}

317 318 319 320 321 322 323 324 325
static unsigned int index_merge_mode(
	git_index *index, git_index_entry *existing, unsigned int mode)
{
	if (index->no_symlinks && S_ISREG(mode) &&
		existing && S_ISLNK(existing->mode))
		return existing->mode;

	if (index->distrust_filemode && S_ISREG(mode))
		return (existing && S_ISREG(existing->mode)) ?
326
			existing->mode : git_index__create_mode(0666);
327

328
	return git_index__create_mode(mode);
329 330
}

331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
static int index_sort_if_needed(git_index *index, bool need_lock)
{
	/* not truly threadsafe because between when this checks and/or
	 * sorts the array another thread could come in and unsort it
	 */

	if (git_vector_is_sorted(&index->entries))
		return 0;

	if (need_lock && git_mutex_lock(&index->lock) < 0) {
		giterr_set(GITERR_OS, "Unable to lock index");
		return -1;
	}

	git_vector_sort(&index->entries);

	if (need_lock)
		git_mutex_unlock(&index->lock);

	return 0;
}

353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
GIT_INLINE(int) index_find_in_entries(
	size_t *out, git_vector *entries, git_vector_cmp entry_srch,
	const char *path, size_t path_len, int stage)
{
	struct entry_srch_key srch_key;
	srch_key.path = path;
	srch_key.pathlen = !path_len ? strlen(path) : path_len;
	srch_key.stage = stage;
	return git_vector_bsearch2(out, entries, entry_srch, &srch_key);
}

GIT_INLINE(int) index_find(
	size_t *out, git_index *index,
	const char *path, size_t path_len, int stage, bool need_lock)
{
	if (index_sort_if_needed(index, need_lock) < 0)
		return -1;

	return index_find_in_entries(
		out, &index->entries, index->entries_search, path, path_len, stage);
}

375
void git_index__set_ignore_case(git_index *index, bool ignore_case)
376
{
377 378
	index->ignore_case = ignore_case;

379 380 381 382 383 384 385 386 387 388 389
	if (ignore_case) {
		index->entries_cmp_path    = git__strcasecmp_cb;
		index->entries_search      = git_index_entry_isrch;
		index->entries_search_path = index_entry_isrch_path;
		index->reuc_search         = reuc_isrch;
	} else {
		index->entries_cmp_path    = git__strcmp_cb;
		index->entries_search      = git_index_entry_srch;
		index->entries_search_path = index_entry_srch_path;
		index->reuc_search         = reuc_srch;
	}
390

391 392
	git_vector_set_cmp(&index->entries,
		ignore_case ? git_index_entry_icmp : git_index_entry_cmp);
393
	index_sort_if_needed(index, true);
Edward Thomson committed
394

395
	git_vector_set_cmp(&index->reuc, ignore_case ? reuc_icmp : reuc_cmp);
Edward Thomson committed
396
	git_vector_sort(&index->reuc);
397 398
}

399
int git_index_open(git_index **index_out, const char *index_path)
400 401
{
	git_index *index;
402
	int error = -1;
403

404
	assert(index_out);
405

406 407
	index = git__calloc(1, sizeof(git_index));
	GITERR_CHECK_ALLOC(index);
408

409 410 411 412 413 414
	if (git_mutex_init(&index->lock)) {
		giterr_set(GITERR_OS, "Failed to initialize lock");
		git__free(index);
		return -1;
	}

415 416
	git_pool_init(&index->tree_pool, 1, 0);

417 418
	if (index_path != NULL) {
		index->index_file_path = git__strdup(index_path);
419 420
		if (!index->index_file_path)
			goto fail;
421 422 423 424 425

		/* Check if index file is stored on disk already */
		if (git_path_exists(index->index_file_path) == true)
			index->on_disk = 1;
	}
426

427
	if (git_vector_init(&index->entries, 32, git_index_entry_cmp) < 0 ||
428 429 430
		git_vector_init(&index->names, 8, conflict_name_cmp) < 0 ||
		git_vector_init(&index->reuc, 8, reuc_cmp) < 0 ||
		git_vector_init(&index->deleted, 8, git_index_entry_cmp) < 0)
431
		goto fail;
432

433 434 435
	index->entries_cmp_path = git__strcmp_cb;
	index->entries_search = git_index_entry_srch;
	index->entries_search_path = index_entry_srch_path;
Edward Thomson committed
436
	index->reuc_search = reuc_srch;
437

438 439
	if (index_path != NULL && (error = git_index_read(index, true)) < 0)
		goto fail;
440

Vicent Marti committed
441
	*index_out = index;
442
	GIT_REFCOUNT_INC(index);
443

444
	return 0;
445 446

fail:
447
	git_pool_clear(&index->tree_pool);
448 449
	git_index_free(index);
	return error;
450 451
}

452 453 454 455 456
int git_index_new(git_index **out)
{
	return git_index_open(out, NULL);
}

457
static void index_free(git_index *index)
458
{
459 460 461 462 463
	/* index iterators increment the refcount of the index, so if we
	 * get here then there should be no outstanding iterators.
	 */
	assert(!git_atomic_get(&index->readers));

464 465
	git_index_clear(index);
	git_vector_free(&index->entries);
Edward Thomson committed
466
	git_vector_free(&index->names);
Edward Thomson committed
467
	git_vector_free(&index->reuc);
468
	git_vector_free(&index->deleted);
469

470
	git__free(index->index_file_path);
471
	git_mutex_free(&index->lock);
472

473
	git__memzero(index, sizeof(*index));
474
	git__free(index);
475 476
}

477 478
void git_index_free(git_index *index)
{
479
	if (index == NULL)
480 481
		return;

482
	GIT_REFCOUNT_DEC(index, index_free);
483 484
}

485 486
/* call with locked index */
static void index_free_deleted(git_index *index)
487
{
488
	int readers = (int)git_atomic_get(&index->readers);
489
	size_t i;
490

491
	if (readers > 0 || !index->deleted.length)
492 493
		return;

494 495 496 497
	for (i = 0; i < index->deleted.length; ++i) {
		git_index_entry *ie = git__swap(index->deleted.contents[i], NULL);
		index_entry_free(ie);
	}
498 499 500 501

	git_vector_clear(&index->deleted);
}

502 503
/* call with locked index */
static int index_remove_entry(git_index *index, size_t pos)
504 505 506 507 508 509 510 511 512 513
{
	int error = 0;
	git_index_entry *entry = git_vector_get(&index->entries, pos);

	if (entry != NULL)
		git_tree_cache_invalidate_path(index->tree, entry->path);

	error = git_vector_remove(&index->entries, pos);

	if (!error) {
514
		if (git_atomic_get(&index->readers) > 0) {
515
			error = git_vector_insert(&index->deleted, entry);
516
		} else {
517
			index_entry_free(entry);
518
		}
519 520 521
	}

	return error;
522
}
523

524
int git_index_clear(git_index *index)
525
{
526 527
	int error = 0;

528 529
	assert(index);

530
	index->tree = NULL;
531
	git_pool_clear(&index->tree_pool);
532

533 534 535 536 537 538
	if (git_mutex_lock(&index->lock) < 0) {
		giterr_set(GITERR_OS, "Failed to lock index");
		return -1;
	}

	while (!error && index->entries.length > 0)
539
		error = index_remove_entry(index, index->entries.length - 1);
540 541
	index_free_deleted(index);

542
	git_index_reuc_clear(index);
Edward Thomson committed
543
	git_index_name_clear(index);
nulltoken committed
544

545
	git_futils_filestamp_set(&index->stamp, NULL);
546

547 548
	git_mutex_unlock(&index->lock);

549
	return error;
550 551
}

552 553 554 555 556 557
static int create_index_error(int error, const char *msg)
{
	giterr_set(GITERR_INDEX, msg);
	return error;
}

Russell Belfer committed
558
int git_index_set_caps(git_index *index, int caps)
559
{
Linquize committed
560
	unsigned int old_ignore_case;
561

562 563
	assert(index);

564 565
	old_ignore_case = index->ignore_case;

566
	if (caps == GIT_INDEXCAP_FROM_OWNER) {
567
		git_repository *repo = INDEX_OWNER(index);
568 569
		int val;

570 571 572
		if (!repo)
			return create_index_error(
				-1, "Cannot access repository to set index caps");
573

574
		if (!git_repository__cvar(&val, repo, GIT_CVAR_IGNORECASE))
575
			index->ignore_case = (val != 0);
576
		if (!git_repository__cvar(&val, repo, GIT_CVAR_FILEMODE))
577
			index->distrust_filemode = (val == 0);
578
		if (!git_repository__cvar(&val, repo, GIT_CVAR_SYMLINKS))
579
			index->no_symlinks = (val == 0);
580 581 582 583 584 585 586
	}
	else {
		index->ignore_case = ((caps & GIT_INDEXCAP_IGNORE_CASE) != 0);
		index->distrust_filemode = ((caps & GIT_INDEXCAP_NO_FILEMODE) != 0);
		index->no_symlinks = ((caps & GIT_INDEXCAP_NO_SYMLINKS) != 0);
	}

587
	if (old_ignore_case != index->ignore_case) {
Linquize committed
588
		git_index__set_ignore_case(index, (bool)index->ignore_case);
589 590
	}

591 592 593
	return 0;
}

Russell Belfer committed
594
int git_index_caps(const git_index *index)
595 596 597 598 599 600
{
	return ((index->ignore_case ? GIT_INDEXCAP_IGNORE_CASE : 0) |
			(index->distrust_filemode ? GIT_INDEXCAP_NO_FILEMODE : 0) |
			(index->no_symlinks ? GIT_INDEXCAP_NO_SYMLINKS : 0));
}

601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632
const git_oid *git_index_checksum(git_index *index)
{
	return &index->checksum;
}

/**
 * Returns 1 for changed, 0 for not changed and <0 for errors
 */
static int compare_checksum(git_index *index)
{
	int fd, error;
	ssize_t bytes_read;
	git_oid checksum = {{ 0 }};

	if ((fd = p_open(index->index_file_path, O_RDONLY)) < 0)
		return fd;

	if ((error = p_lseek(fd, -20, SEEK_END)) < 0) {
		p_close(fd);
		giterr_set(GITERR_OS, "failed to seek to end of file");
		return -1;
	}

	bytes_read = p_read(fd, &checksum, GIT_OID_RAWSZ);
	p_close(fd);

	if (bytes_read < 0)
		return -1;

	return !!git_oid_cmp(&checksum, &index->checksum);
}

633
int git_index_read(git_index *index, int force)
634
{
635
	int error = 0, updated;
636
	git_buf buffer = GIT_BUF_INIT;
637
	git_futils_filestamp stamp = index->stamp;
638

639 640
	if (!index->index_file_path)
		return create_index_error(-1,
641
			"Failed to read index: The index is in-memory only");
642

643 644 645
	index->on_disk = git_path_exists(index->index_file_path);

	if (!index->on_disk) {
646
		if (force)
647
			return git_index_clear(index);
648
		return 0;
649 650
	}

651 652
	if ((updated = git_futils_filestamp_check(&stamp, index->index_file_path) < 0) ||
	    ((updated = compare_checksum(index)) < 0)) {
653 654 655 656
		giterr_set(
			GITERR_INDEX,
			"Failed to read index: '%s' no longer exists",
			index->index_file_path);
657
		return updated;
658 659 660
	}
	if (!updated && !force)
		return 0;
661 662

	error = git_futils_readbuffer(&buffer, index->index_file_path);
663 664
	if (error < 0)
		return error;
665

666 667 668
	index->tree = NULL;
	git_pool_clear(&index->tree_pool);

669 670 671 672
	error = git_index_clear(index);

	if (!error)
		error = parse_index(index, buffer.ptr, buffer.size);
673

674 675
	if (!error)
		git_futils_filestamp_set(&index->stamp, &stamp);
676

677
	git_buf_free(&buffer);
678 679 680
	return error;
}

681
int git_index__changed_relative_to(
682
	git_index *index, const git_oid *checksum)
683 684 685 686 687
{
	/* attempt to update index (ignoring errors) */
	if (git_index_read(index, false) < 0)
		giterr_clear();

688
	return !!git_oid_cmp(&index->checksum, checksum);
689 690
}

691 692 693 694 695 696 697 698 699 700 701 702 703 704
static bool is_racy_timestamp(git_time_t stamp, git_index_entry *entry)
{
	/* Git special-cases submodules in the check */
	if (S_ISGITLINK(entry->mode))
		return false;

	/* If we never read the index, we can't have this race either */
	if (stamp == 0)
		return false;

	/* If the timestamp is the same or newer than the index, it's racy */
	return ((int32_t) stamp) <= entry->mtime.seconds;
}

705 706 707 708
/*
 * Force the next diff to take a look at those entries which have the
 * same timestamp as the current index.
 */
709
static int truncate_racily_clean(git_index *index)
710 711
{
	size_t i;
712
	int error;
713 714
	git_index_entry *entry;
	git_time_t ts = index->stamp.mtime;
715 716 717 718 719 720
	git_diff_options diff_opts = GIT_DIFF_OPTIONS_INIT;
	git_diff *diff;

	/* Nothing to do if there's no repo to talk about */
	if (!INDEX_OWNER(index))
		return 0;
721

722 723 724 725 726
	/* If there's no workdir, we can't know where to even check */
	if (!git_repository_workdir(INDEX_OWNER(index)))
		return 0;

	diff_opts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE | GIT_DIFF_IGNORE_SUBMODULES | GIT_DIFF_DISABLE_PATHSPEC_MATCH;
727
	git_vector_foreach(&index->entries, i, entry) {
728 729 730 731 732 733 734 735 736 737
		if (!is_racy_timestamp(ts, entry))
			continue;

		diff_opts.pathspec.count = 1;
		diff_opts.pathspec.strings = (char **) &entry->path;

		if ((error = git_diff_index_to_workdir(&diff, INDEX_OWNER(index), index, &diff_opts)) < 0)
			return error;

		if (git_diff_num_deltas(diff) > 0)
738
			entry->file_size = 0;
739 740

		git_diff_free(diff);
741
	}
742 743

	return 0;
744 745
}

746 747
int git_index_write(git_index *index)
{
748
	git_indexwriter writer = GIT_INDEXWRITER_INIT;
749
	int error;
750

751 752
	truncate_racily_clean(index);

753 754
	if ((error = git_indexwriter_init(&writer, index)) == 0)
		error = git_indexwriter_commit(&writer);
755

756
	git_indexwriter_cleanup(&writer);
757

758
	return error;
759
}
760

Jacques Germishuys committed
761
const char * git_index_path(const git_index *index)
762 763 764 765
{
	assert(index);
	return index->index_file_path;
}
766

767 768 769 770 771 772
int git_index_write_tree(git_oid *oid, git_index *index)
{
	git_repository *repo;

	assert(oid && index);

773
	repo = INDEX_OWNER(index);
774

775 776
	if (repo == NULL)
		return create_index_error(-1, "Failed to write tree. "
777 778 779 780 781
		  "The index file is not backed up by an existing repository");

	return git_tree__write_index(oid, index, repo);
}

782 783
int git_index_write_tree_to(
	git_oid *oid, git_index *index, git_repository *repo)
784 785 786 787 788
{
	assert(oid && index && repo);
	return git_tree__write_index(oid, index, repo);
}

789
size_t git_index_entrycount(const git_index *index)
790 791
{
	assert(index);
792
	return index->entries.length;
793 794
}

795 796
const git_index_entry *git_index_get_byindex(
	git_index *index, size_t n)
797 798
{
	assert(index);
799 800
	if (index_sort_if_needed(index, true) < 0)
		return NULL;
Edward Thomson committed
801
	return git_vector_get(&index->entries, n);
802 803
}

804 805
const git_index_entry *git_index_get_bypath(
	git_index *index, const char *path, int stage)
806
{
807
	size_t pos;
Edward Thomson committed
808 809 810

	assert(index);

811
	if (index_find(&pos, index, path, 0, stage, true) < 0) {
812
		giterr_set(GITERR_INDEX, "Index does not contain %s", path);
Edward Thomson committed
813
		return NULL;
814
	}
Edward Thomson committed
815 816

	return git_index_get_byindex(index, pos);
817 818
}

819 820
void git_index_entry__init_from_stat(
	git_index_entry *entry, struct stat *st, bool trust_mode)
821 822 823 824 825 826 827
{
	entry->ctime.seconds = (git_time_t)st->st_ctime;
	entry->mtime.seconds = (git_time_t)st->st_mtime;
	/* entry->mtime.nanoseconds = st->st_mtimensec; */
	/* entry->ctime.nanoseconds = st->st_ctimensec; */
	entry->dev  = st->st_rdev;
	entry->ino  = st->st_ino;
828
	entry->mode = (!trust_mode && S_ISREG(st->st_mode)) ?
829
		git_index__create_mode(0666) : git_index__create_mode(st->st_mode);
830 831 832 833 834
	entry->uid  = st->st_uid;
	entry->gid  = st->st_gid;
	entry->file_size = st->st_size;
}

835 836 837 838
static int index_entry_create(
	git_index_entry **out,
	git_repository *repo,
	const char *path)
839
{
840
	size_t pathlen = strlen(path), alloclen;
841 842
	struct entry_internal *entry;

843 844 845
	if (!git_path_isvalid(repo, path,
		GIT_PATH_REJECT_DEFAULTS | GIT_PATH_REJECT_DOT_GIT)) {
		giterr_set(GITERR_INDEX, "Invalid path: '%s'", path);
846
		return -1;
847
	}
848

849 850 851
	GITERR_CHECK_ALLOC_ADD(&alloclen, sizeof(struct entry_internal), pathlen);
	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
	entry = git__calloc(1, alloclen);
852
	GITERR_CHECK_ALLOC(entry);
853 854 855 856 857

	entry->pathlen = pathlen;
	memcpy(entry->path, path, pathlen);
	entry->entry.path = entry->path;

858 859
	*out = (git_index_entry *)entry;
	return 0;
860 861
}

862
static int index_entry_init(
863 864 865
	git_index_entry **entry_out,
	git_index *index,
	const char *rel_path)
866
{
867
	int error = 0;
868
	git_index_entry *entry = NULL;
869 870
	struct stat st;
	git_oid oid;
871

872 873 874 875 876
	if (INDEX_OWNER(index) == NULL)
		return create_index_error(-1,
			"Could not initialize index entry. "
			"Index is not backed up by an existing repository.");

877
	if (index_entry_create(&entry, INDEX_OWNER(index), rel_path) < 0)
878 879
		return -1;

880 881 882
	/* write the blob to disk and get the oid and stat info */
	error = git_blob__create_from_paths(
		&oid, &st, INDEX_OWNER(index), NULL, rel_path, 0, true);
883

884 885 886 887
	if (error < 0) {
		index_entry_free(entry);
		return error;
	}
888

889
	entry->id = oid;
890
	git_index_entry__init_from_stat(entry, &st, !index->distrust_filemode);
891

892
	*entry_out = (git_index_entry *)entry;
893
	return 0;
894 895
}

896 897
static git_index_reuc_entry *reuc_entry_alloc(const char *path)
{
898
	size_t pathlen = strlen(path),
899 900
		structlen = sizeof(struct reuc_entry_internal),
		alloclen;
901 902
	struct reuc_entry_internal *entry;

903 904
	if (GIT_ADD_SIZET_OVERFLOW(&alloclen, structlen, pathlen) ||
		GIT_ADD_SIZET_OVERFLOW(&alloclen, alloclen, 1))
905 906
		return NULL;

907
	entry = git__calloc(1, alloclen);
908 909 910 911 912 913 914 915 916 917
	if (!entry)
		return NULL;

	entry->pathlen = pathlen;
	memcpy(entry->path, path, pathlen);
	entry->entry.path = entry->path;

	return (git_index_reuc_entry *)entry;
}

Edward Thomson committed
918 919
static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,
	const char *path,
Edward Thomson committed
920 921 922
	int ancestor_mode, const git_oid *ancestor_oid,
	int our_mode, const git_oid *our_oid,
	int their_mode, const git_oid *their_oid)
Edward Thomson committed
923 924 925 926 927
{
	git_index_reuc_entry *reuc = NULL;

	assert(reuc_out && path);

928
	*reuc_out = reuc = reuc_entry_alloc(path);
Edward Thomson committed
929 930
	GITERR_CHECK_ALLOC(reuc);

931 932
	if ((reuc->mode[0] = ancestor_mode) > 0)
		git_oid_cpy(&reuc->oid[0], ancestor_oid);
Edward Thomson committed
933

934 935
	if ((reuc->mode[1] = our_mode) > 0)
		git_oid_cpy(&reuc->oid[1], our_oid);
Edward Thomson committed
936

937 938
	if ((reuc->mode[2] = their_mode) > 0)
		git_oid_cpy(&reuc->oid[2], their_oid);
Edward Thomson committed
939 940 941 942

	return 0;
}

943 944
static void index_entry_cpy(git_index_entry *tgt, const git_index_entry *src)
{
945
	const char *tgt_path = tgt->path;
946 947 948 949
	memcpy(tgt, src, sizeof(*tgt));
	tgt->path = tgt_path; /* reset to existing path data */
}

950 951 952 953
static int index_entry_dup(
	git_index_entry **out,
	git_repository *repo,
	const git_index_entry *src)
954 955 956
{
	git_index_entry *entry;

957 958 959 960 961
	if (!src) {
		*out = NULL;
		return 0;
	}

962
	if (index_entry_create(&entry, repo, src->path) < 0)
963
		return -1;
964

965
	index_entry_cpy(entry, src);
966
	*out = entry;
967
	return 0;
968 969
}

970
static int has_file_name(git_index *index,
971
	 const git_index_entry *entry, size_t pos, int ok_to_replace)
972 973
{
	int retval = 0;
974 975 976
	size_t len = strlen(entry->path);
	int stage = GIT_IDXENTRY_STAGE(entry);
	const char *name = entry->path;
977

978
	while (pos < index->entries.length) {
979
		struct entry_internal *p = index->entries.contents[pos++];
980

981
		if (len >= p->pathlen)
982
			break;
983
		if (memcmp(name, p->path, len))
984
			break;
985
		if (GIT_IDXENTRY_STAGE(&p->entry) != stage)
986
			continue;
987
		if (p->path[len] != '/')
988 989 990 991
			continue;
		retval = -1;
		if (!ok_to_replace)
			break;
992

993
		if (index_remove_entry(index, --pos) < 0)
994
			break;
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
	}
	return retval;
}

/*
 * Do we have another file with a pathname that is a proper
 * subset of the name we're trying to add?
 */
static int has_dir_name(git_index *index,
		const git_index_entry *entry, int ok_to_replace)
{
	int retval = 0;
1007 1008 1009
	int stage = GIT_IDXENTRY_STAGE(entry);
	const char *name = entry->path;
	const char *slash = name + strlen(name);
1010 1011

	for (;;) {
1012
		size_t len, pos;
1013 1014 1015 1016

		for (;;) {
			if (*--slash == '/')
				break;
1017
			if (slash <= entry->path)
1018 1019 1020 1021
				return retval;
		}
		len = slash - name;

1022
		if (!index_find(&pos, index, name, len, stage, false)) {
1023 1024 1025 1026
			retval = -1;
			if (!ok_to_replace)
				break;

1027
			if (index_remove_entry(index, pos) < 0)
1028
				break;
1029
			continue;
1030 1031 1032 1033 1034 1035 1036
		}

		/*
		 * Trivial optimization: if we find an entry that
		 * already matches the sub-directory, then we know
		 * we're ok, and we can exit.
		 */
1037 1038
		for (; pos < index->entries.length; ++pos) {
			struct entry_internal *p = index->entries.contents[pos];
1039

1040 1041
			if (p->pathlen <= len ||
			    p->path[len] != '/' ||
1042
			    memcmp(p->path, name, len))
1043
				break; /* not our subdirectory */
1044

1045
			if (GIT_IDXENTRY_STAGE(&p->entry) == stage)
1046 1047 1048
				return retval;
		}
	}
1049

1050 1051
	return retval;
}
1052

1053
static int check_file_directory_collision(git_index *index,
1054 1055 1056 1057 1058 1059
		git_index_entry *entry, size_t pos, int ok_to_replace)
{
	int retval = has_file_name(index, entry, pos, ok_to_replace);
	retval = retval + has_dir_name(index, entry, ok_to_replace);

	if (retval) {
1060 1061
		giterr_set(GITERR_INDEX,
			"'%s' appears as both a file and a directory", entry->path);
1062 1063 1064 1065 1066
		return -1;
	}

	return 0;
}
1067

1068 1069 1070 1071 1072 1073 1074 1075 1076
static int index_no_dups(void **old, void *new)
{
	const git_index_entry *entry = new;
	GIT_UNUSED(old);
	giterr_set(GITERR_INDEX, "'%s' appears multiple times at stage %d",
		entry->path, GIT_IDXENTRY_STAGE(entry));
	return GIT_EEXISTS;
}

1077 1078 1079 1080
/* index_insert takes ownership of the new entry - if it can't insert
 * it, then it will return an error **and also free the entry**.  When
 * it replaces an existing entry, it will update the entry_ptr with the
 * actual entry in the index (and free the passed in one).
1081
 * trust_mode is whether we trust the mode in entry_ptr.
1082 1083
 */
static int index_insert(
1084
	git_index *index, git_index_entry **entry_ptr, int replace, bool trust_mode)
1085
{
1086
	int error = 0;
1087
	size_t path_length, position;
1088
	git_index_entry *existing = NULL, *entry;
1089

1090 1091 1092
	assert(index && entry_ptr);

	entry = *entry_ptr;
1093

1094
	/* make sure that the path length flag is correct */
1095
	path_length = ((struct entry_internal *)entry)->pathlen;
1096

1097
	entry->flags &= ~GIT_IDXENTRY_NAMEMASK;
1098 1099

	if (path_length < GIT_IDXENTRY_NAMEMASK)
1100
		entry->flags |= path_length & GIT_IDXENTRY_NAMEMASK;
1101
	else
Edward Thomson committed
1102
		entry->flags |= GIT_IDXENTRY_NAMEMASK;
1103

1104
	if (git_mutex_lock(&index->lock) < 0) {
1105
		giterr_set(GITERR_OS, "Unable to acquire index lock");
1106
		return -1;
1107 1108 1109 1110
	}

	git_vector_sort(&index->entries);

1111
	/* look if an entry with this path already exists */
1112
	if (!index_find(
1113
			&position, index, entry->path, 0, GIT_IDXENTRY_STAGE(entry), false)) {
1114
		existing = index->entries.contents[position];
1115
		/* update filemode to existing values if stat is not trusted */
1116 1117 1118 1119
		if (trust_mode)
			entry->mode = git_index__create_mode(entry->mode);
		else
			entry->mode = index_merge_mode(index, existing, entry->mode);
1120 1121
	}

1122
	/* look for tree / blob name collisions, removing conflicts if requested */
1123 1124
	error = check_file_directory_collision(index, entry, position, replace);
	if (error < 0)
1125
		/* skip changes */;
1126 1127 1128 1129

	/* if we are replacing an existing item, overwrite the existing entry
	 * and return it in place of the passed in one.
	 */
1130 1131 1132
	else if (existing) {
		if (replace)
			index_entry_cpy(existing, entry);
1133
		index_entry_free(entry);
1134
		*entry_ptr = entry = existing;
1135
	}
1136
	else {
1137 1138 1139
		/* if replace is not requested or no existing entry exists, insert
		 * at the sorted position.  (Since we re-sort after each insert to
		 * check for dups, this is actually cheaper in the long run.)
1140
		 */
1141
		error = git_vector_insert_sorted(&index->entries, entry, index_no_dups);
1142
	}
1143

1144 1145 1146 1147
	if (error < 0) {
		index_entry_free(*entry_ptr);
		*entry_ptr = NULL;
	}
1148

1149 1150
	git_mutex_unlock(&index->lock);

1151
	return error;
1152 1153
}

Edward Thomson committed
1154
static int index_conflict_to_reuc(git_index *index, const char *path)
1155
{
1156
	const git_index_entry *conflict_entries[3];
Edward Thomson committed
1157
	int ancestor_mode, our_mode, their_mode;
Edward Thomson committed
1158
	git_oid const *ancestor_oid, *our_oid, *their_oid;
1159
	int ret;
1160

Edward Thomson committed
1161 1162
	if ((ret = git_index_conflict_get(&conflict_entries[0],
		&conflict_entries[1], &conflict_entries[2], index, path)) < 0)
1163
		return ret;
1164

Edward Thomson committed
1165 1166 1167
	ancestor_mode = conflict_entries[0] == NULL ? 0 : conflict_entries[0]->mode;
	our_mode = conflict_entries[1] == NULL ? 0 : conflict_entries[1]->mode;
	their_mode = conflict_entries[2] == NULL ? 0 : conflict_entries[2]->mode;
1168

1169 1170 1171
	ancestor_oid = conflict_entries[0] == NULL ? NULL : &conflict_entries[0]->id;
	our_oid = conflict_entries[1] == NULL ? NULL : &conflict_entries[1]->id;
	their_oid = conflict_entries[2] == NULL ? NULL : &conflict_entries[2]->id;
Edward Thomson committed
1172 1173 1174 1175 1176 1177

	if ((ret = git_index_reuc_add(index, path, ancestor_mode, ancestor_oid,
		our_mode, our_oid, their_mode, their_oid)) >= 0)
		ret = git_index_conflict_remove(index, path);

	return ret;
1178 1179
}

1180 1181 1182 1183 1184 1185 1186 1187 1188
static bool valid_filemode(const int filemode)
{
	return (filemode == GIT_FILEMODE_BLOB ||
		filemode == GIT_FILEMODE_BLOB_EXECUTABLE ||
		filemode == GIT_FILEMODE_LINK ||
		filemode == GIT_FILEMODE_COMMIT);
}

int git_index_add_frombuffer(
1189
    git_index *index, const git_index_entry *source_entry,
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
    const void *buffer, size_t len)
{
	git_index_entry *entry = NULL;
	int error = 0;
	git_oid id;

	assert(index && source_entry->path);

	if (INDEX_OWNER(index) == NULL)
		return create_index_error(-1,
			"Could not initialize index entry. "
			"Index is not backed up by an existing repository.");

	if (!valid_filemode(source_entry->mode)) {
		giterr_set(GITERR_INDEX, "invalid filemode");
		return -1;
	}

	if (index_entry_dup(&entry, INDEX_OWNER(index), source_entry) < 0)
		return -1;

	error = git_blob_create_frombuffer(&id, INDEX_OWNER(index), buffer, len);
	if (error < 0) {
		index_entry_free(entry);
		return error;
	}

	git_oid_cpy(&entry->id, &id);
	entry->file_size = len;

1220
	if ((error = index_insert(index, &entry, 1, true)) < 0)
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
		return error;

	/* Adding implies conflict was resolved, move conflict entries to REUC */
	if ((error = index_conflict_to_reuc(index, entry->path)) < 0 && error != GIT_ENOTFOUND)
		return error;

	git_tree_cache_invalidate_path(index->tree, entry->path);
	return 0;
}


1232
int git_index_add_bypath(git_index *index, const char *path)
1233
{
Edward Thomson committed
1234 1235 1236 1237 1238 1239
	git_index_entry *entry = NULL;
	int ret;

	assert(index && path);

	if ((ret = index_entry_init(&entry, index, path)) < 0 ||
1240
		(ret = index_insert(index, &entry, 1, false)) < 0)
1241
		return ret;
Edward Thomson committed
1242 1243 1244

	/* Adding implies conflict was resolved, move conflict entries to REUC */
	if ((ret = index_conflict_to_reuc(index, path)) < 0 && ret != GIT_ENOTFOUND)
1245
		return ret;
Edward Thomson committed
1246 1247 1248

	git_tree_cache_invalidate_path(index->tree, entry->path);
	return 0;
1249 1250
}

1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
int git_index_remove_bypath(git_index *index, const char *path)
{
	int ret;

	assert(index && path);

	if (((ret = git_index_remove(index, path, 0)) < 0 &&
		ret != GIT_ENOTFOUND) ||
		((ret = index_conflict_to_reuc(index, path)) < 0 &&
		ret != GIT_ENOTFOUND))
		return ret;

1263 1264 1265
	if (ret == GIT_ENOTFOUND)
		giterr_clear();

1266 1267 1268
	return 0;
}

1269

Edward Thomson committed
1270
int git_index_add(git_index *index, const git_index_entry *source_entry)
1271 1272 1273 1274
{
	git_index_entry *entry = NULL;
	int ret;

1275
	assert(index && source_entry && source_entry->path);
1276

1277 1278 1279 1280 1281
	if (!valid_filemode(source_entry->mode)) {
		giterr_set(GITERR_INDEX, "invalid filemode");
		return -1;
	}

1282
	if ((ret = index_entry_dup(&entry, INDEX_OWNER(index), source_entry)) < 0 ||
1283
		(ret = index_insert(index, &entry, 1, true)) < 0)
1284
		return ret;
1285

1286
	git_tree_cache_invalidate_path(index->tree, entry->path);
1287
	return 0;
1288 1289
}

Edward Thomson committed
1290
int git_index_remove(git_index *index, const char *path, int stage)
1291
{
1292
	int error;
1293
	size_t position;
1294

1295 1296 1297 1298 1299
	if (git_mutex_lock(&index->lock) < 0) {
		giterr_set(GITERR_OS, "Failed to lock index");
		return -1;
	}

1300
	if (index_find(&position, index, path, 0, stage, false) < 0) {
1301 1302 1303 1304 1305
		giterr_set(
			GITERR_INDEX, "Index does not contain %s at stage %d", path, stage);
		error = GIT_ENOTFOUND;
	} else {
		error = index_remove_entry(index, position);
1306
	}
Edward Thomson committed
1307

1308 1309
	git_mutex_unlock(&index->lock);
	return error;
1310
}
1311

1312 1313 1314 1315 1316 1317 1318
int git_index_remove_directory(git_index *index, const char *dir, int stage)
{
	git_buf pfx = GIT_BUF_INIT;
	int error = 0;
	size_t pos;
	git_index_entry *entry;

1319 1320
	if (git_mutex_lock(&index->lock) < 0) {
		giterr_set(GITERR_OS, "Failed to lock index");
1321
		return -1;
1322
	}
1323

1324 1325
	if (!(error = git_buf_sets(&pfx, dir)) &&
		!(error = git_path_to_dir(&pfx)))
1326
		index_find(&pos, index, pfx.ptr, pfx.size, GIT_INDEX_STAGE_ANY, false);
1327

1328
	while (!error) {
1329 1330 1331 1332
		entry = git_vector_get(&index->entries, pos);
		if (!entry || git__prefixcmp(entry->path, pfx.ptr) != 0)
			break;

1333
		if (GIT_IDXENTRY_STAGE(entry) != stage) {
1334 1335 1336 1337
			++pos;
			continue;
		}

1338
		error = index_remove_entry(index, pos);
1339

1340
		/* removed entry at 'pos' so we don't need to increment */
1341 1342
	}

1343
	git_mutex_unlock(&index->lock);
1344 1345 1346 1347 1348
	git_buf_free(&pfx);

	return error;
}

1349
int git_index__find_pos(
1350 1351 1352
	size_t *out, git_index *index, const char *path, size_t path_len, int stage)
{
	assert(index && path);
1353
	return index_find(out, index, path, path_len, stage, true);
Edward Thomson committed
1354 1355
}

1356
int git_index_find(size_t *at_pos, git_index *index, const char *path)
1357
{
1358
	size_t pos;
Edward Thomson committed
1359 1360 1361

	assert(index && path);

1362 1363 1364 1365 1366
	if (git_mutex_lock(&index->lock) < 0) {
		giterr_set(GITERR_OS, "Failed to lock index");
		return -1;
	}

1367 1368
	if (git_vector_bsearch2(
			&pos, &index->entries, index->entries_search_path, path) < 0) {
1369
		git_mutex_unlock(&index->lock);
1370
		giterr_set(GITERR_INDEX, "Index does not contain %s", path);
1371
		return GIT_ENOTFOUND;
1372
	}
Edward Thomson committed
1373 1374

	/* Since our binary search only looked at path, we may be in the
1375 1376
	 * middle of a list of stages.
	 */
1377 1378
	for (; pos > 0; --pos) {
		const git_index_entry *prev = git_vector_get(&index->entries, pos - 1);
Edward Thomson committed
1379 1380 1381 1382 1383

		if (index->entries_cmp_path(prev->path, path) != 0)
			break;
	}

1384 1385 1386
	if (at_pos)
		*at_pos = pos;

1387
	git_mutex_unlock(&index->lock);
1388
	return 0;
1389 1390
}

Edward Thomson committed
1391 1392 1393 1394 1395 1396
int git_index_conflict_add(git_index *index,
	const git_index_entry *ancestor_entry,
	const git_index_entry *our_entry,
	const git_index_entry *their_entry)
{
	git_index_entry *entries[3] = { 0 };
1397
	unsigned short i;
Edward Thomson committed
1398 1399 1400 1401
	int ret = 0;

	assert (index);

1402 1403 1404
	if ((ret = index_entry_dup(&entries[0], INDEX_OWNER(index), ancestor_entry)) < 0 ||
		(ret = index_entry_dup(&entries[1], INDEX_OWNER(index), our_entry)) < 0 ||
		(ret = index_entry_dup(&entries[2], INDEX_OWNER(index), their_entry)) < 0)
1405
		goto on_error;
Edward Thomson committed
1406

1407 1408 1409 1410 1411 1412 1413 1414 1415
	/* Validate entries */
	for (i = 0; i < 3; i++) {
		if (entries[i] && !valid_filemode(entries[i]->mode)) {
			giterr_set(GITERR_INDEX, "invalid filemode for stage %d entry",
				i);
			return -1;
		}
	}

1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
	/* Remove existing index entries for each path */
	for (i = 0; i < 3; i++) {
		if (entries[i] == NULL)
			continue;

		if ((ret = git_index_remove(index, entries[i]->path, 0)) != 0) {
			if (ret != GIT_ENOTFOUND)
				goto on_error;

			giterr_clear();
			ret = 0;
		}
	}

	/* Add the conflict entries */
Edward Thomson committed
1431 1432 1433 1434 1435
	for (i = 0; i < 3; i++) {
		if (entries[i] == NULL)
			continue;

		/* Make sure stage is correct */
1436
		GIT_IDXENTRY_STAGE_SET(entries[i], i + 1);
Edward Thomson committed
1437

1438
		if ((ret = index_insert(index, &entries[i], 0, true)) < 0)
Edward Thomson committed
1439
			goto on_error;
1440 1441

		entries[i] = NULL; /* don't free if later entry fails */
Edward Thomson committed
1442 1443
	}

nulltoken committed
1444
	return 0;
Edward Thomson committed
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454

on_error:
	for (i = 0; i < 3; i++) {
		if (entries[i] != NULL)
			index_entry_free(entries[i]);
	}

	return ret;
}

1455 1456 1457 1458 1459 1460
static int index_conflict__get_byindex(
	const git_index_entry **ancestor_out,
	const git_index_entry **our_out,
	const git_index_entry **their_out,
	git_index *index,
	size_t n)
Edward Thomson committed
1461
{
1462 1463 1464 1465
	const git_index_entry *conflict_entry;
	const char *path = NULL;
	size_t count;
	int stage, len = 0;
Edward Thomson committed
1466

1467
	assert(ancestor_out && our_out && their_out && index);
1468

Edward Thomson committed
1469 1470 1471 1472
	*ancestor_out = NULL;
	*our_out = NULL;
	*their_out = NULL;

1473 1474
	for (count = git_index_entrycount(index); n < count; ++n) {
		conflict_entry = git_vector_get(&index->entries, n);
Edward Thomson committed
1475

1476
		if (path && index->entries_cmp_path(conflict_entry->path, path) != 0)
Edward Thomson committed
1477 1478
			break;

1479
		stage = GIT_IDXENTRY_STAGE(conflict_entry);
1480
		path = conflict_entry->path;
1481

Edward Thomson committed
1482 1483 1484
		switch (stage) {
		case 3:
			*their_out = conflict_entry;
1485
			len++;
Edward Thomson committed
1486 1487 1488
			break;
		case 2:
			*our_out = conflict_entry;
1489
			len++;
Edward Thomson committed
1490 1491 1492
			break;
		case 1:
			*ancestor_out = conflict_entry;
1493
			len++;
Edward Thomson committed
1494 1495 1496 1497 1498 1499
			break;
		default:
			break;
		};
	}

1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
	return len;
}

int git_index_conflict_get(
	const git_index_entry **ancestor_out,
	const git_index_entry **our_out,
	const git_index_entry **their_out,
	git_index *index,
	const char *path)
{
	size_t pos;
	int len = 0;

	assert(ancestor_out && our_out && their_out && index && path);

	*ancestor_out = NULL;
	*our_out = NULL;
	*their_out = NULL;

	if (git_index_find(&pos, index, path) < 0)
		return GIT_ENOTFOUND;

	if ((len = index_conflict__get_byindex(
		ancestor_out, our_out, their_out, index, pos)) < 0)
		return len;
	else if (len == 0)
		return GIT_ENOTFOUND;

	return 0;
Edward Thomson committed
1529 1530
}

1531
static int index_conflict_remove(git_index *index, const char *path)
Edward Thomson committed
1532
{
1533
	size_t pos = 0;
Edward Thomson committed
1534
	git_index_entry *conflict_entry;
1535
	int error = 0;
Edward Thomson committed
1536

1537
	if (path != NULL && git_index_find(&pos, index, path) < 0)
1538
		return GIT_ENOTFOUND;
Edward Thomson committed
1539

1540 1541 1542 1543 1544
	if (git_mutex_lock(&index->lock) < 0) {
		giterr_set(GITERR_OS, "Unable to lock index");
		return -1;
	}

1545
	while ((conflict_entry = git_vector_get(&index->entries, pos)) != NULL) {
Edward Thomson committed
1546

1547 1548
		if (path != NULL &&
			index->entries_cmp_path(conflict_entry->path, path) != 0)
Edward Thomson committed
1549 1550
			break;

1551
		if (GIT_IDXENTRY_STAGE(conflict_entry) == 0) {
Edward Thomson committed
1552 1553 1554 1555
			pos++;
			continue;
		}

1556
		if ((error = index_remove_entry(index, pos)) < 0)
1557
			break;
Edward Thomson committed
1558 1559
	}

1560 1561
	git_mutex_unlock(&index->lock);

1562
	return error;
Edward Thomson committed
1563 1564
}

1565
int git_index_conflict_remove(git_index *index, const char *path)
Edward Thomson committed
1566
{
1567 1568
	assert(index && path);
	return index_conflict_remove(index, path);
Edward Thomson committed
1569 1570
}

1571
int git_index_conflict_cleanup(git_index *index)
Edward Thomson committed
1572 1573
{
	assert(index);
1574
	return index_conflict_remove(index, NULL);
Edward Thomson committed
1575 1576
}

1577
int git_index_has_conflicts(const git_index *index)
1578
{
1579
	size_t i;
1580 1581 1582 1583 1584
	git_index_entry *entry;

	assert(index);

	git_vector_foreach(&index->entries, i, entry) {
1585
		if (GIT_IDXENTRY_STAGE(entry) > 0)
1586 1587 1588 1589 1590 1591
			return 1;
	}

	return 0;
}

1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626
int git_index_conflict_iterator_new(
	git_index_conflict_iterator **iterator_out,
	git_index *index)
{
	git_index_conflict_iterator *it = NULL;

	assert(iterator_out && index);

	it = git__calloc(1, sizeof(git_index_conflict_iterator));
	GITERR_CHECK_ALLOC(it);

	it->index = index;

	*iterator_out = it;
	return 0;
}

int git_index_conflict_next(
	const git_index_entry **ancestor_out,
	const git_index_entry **our_out,
	const git_index_entry **their_out,
	git_index_conflict_iterator *iterator)
{
	const git_index_entry *entry;
	int len;

	assert(ancestor_out && our_out && their_out && iterator);

	*ancestor_out = NULL;
	*our_out = NULL;
	*their_out = NULL;

	while (iterator->cur < iterator->index->entries.length) {
		entry = git_index_get_byindex(iterator->index, iterator->cur);

1627
		if (git_index_entry_is_conflict(entry)) {
1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653
			if ((len = index_conflict__get_byindex(
				ancestor_out,
				our_out,
				their_out,
				iterator->index,
				iterator->cur)) < 0)
				return len;

			iterator->cur += len;
			return 0;
		}

		iterator->cur++;
	}

	return GIT_ITEROVER;
}

void git_index_conflict_iterator_free(git_index_conflict_iterator *iterator)
{
	if (iterator == NULL)
		return;

	git__free(iterator);
}

1654
size_t git_index_name_entrycount(git_index *index)
Edward Thomson committed
1655 1656
{
	assert(index);
1657
	return index->names.length;
Edward Thomson committed
1658 1659 1660 1661 1662 1663
}

const git_index_name_entry *git_index_name_get_byindex(
	git_index *index, size_t n)
{
	assert(index);
nulltoken committed
1664

Edward Thomson committed
1665 1666 1667 1668
	git_vector_sort(&index->names);
	return git_vector_get(&index->names, n);
}

1669 1670 1671 1672 1673 1674 1675 1676 1677 1678
static void index_name_entry_free(git_index_name_entry *ne)
{
	if (!ne)
		return;
	git__free(ne->ancestor);
	git__free(ne->ours);
	git__free(ne->theirs);
	git__free(ne);
}

Edward Thomson committed
1679 1680 1681 1682 1683
int git_index_name_add(git_index *index,
	const char *ancestor, const char *ours, const char *theirs)
{
	git_index_name_entry *conflict_name;

1684
	assert((ancestor && ours) || (ancestor && theirs) || (ours && theirs));
Edward Thomson committed
1685 1686 1687

	conflict_name = git__calloc(1, sizeof(git_index_name_entry));
	GITERR_CHECK_ALLOC(conflict_name);
nulltoken committed
1688

1689 1690 1691 1692 1693 1694 1695
	if ((ancestor && !(conflict_name->ancestor = git__strdup(ancestor))) ||
		(ours     && !(conflict_name->ours     = git__strdup(ours))) ||
		(theirs   && !(conflict_name->theirs   = git__strdup(theirs))) ||
		git_vector_insert(&index->names, conflict_name) < 0)
	{
		index_name_entry_free(conflict_name);
		return -1;
Edward Thomson committed
1696
	}
nulltoken committed
1697

1698
	return 0;
Edward Thomson committed
1699 1700 1701 1702 1703 1704 1705 1706
}

void git_index_name_clear(git_index *index)
{
	size_t i;
	git_index_name_entry *conflict_name;

	assert(index);
nulltoken committed
1707

1708 1709
	git_vector_foreach(&index->names, i, conflict_name)
		index_name_entry_free(conflict_name);
nulltoken committed
1710

Edward Thomson committed
1711 1712 1713
	git_vector_clear(&index->names);
}

1714
size_t git_index_reuc_entrycount(git_index *index)
Edward Thomson committed
1715 1716
{
	assert(index);
1717
	return index->reuc.length;
Edward Thomson committed
1718 1719
}

Edward Thomson committed
1720 1721 1722 1723
static int index_reuc_insert(
	git_index *index,
	git_index_reuc_entry *reuc,
	int replace)
Edward Thomson committed
1724 1725
{
	git_index_reuc_entry **existing = NULL;
1726
	size_t position;
Edward Thomson committed
1727 1728 1729

	assert(index && reuc && reuc->path != NULL);

1730
	if (!git_index_reuc_find(&position, index, reuc->path))
Edward Thomson committed
1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
		existing = (git_index_reuc_entry **)&index->reuc.contents[position];

	if (!replace || !existing)
		return git_vector_insert(&index->reuc, reuc);

	/* exists, replace it */
	git__free(*existing);
	*existing = reuc;

	return 0;
}

int git_index_reuc_add(git_index *index, const char *path,
Edward Thomson committed
1744 1745 1746
	int ancestor_mode, const git_oid *ancestor_oid,
	int our_mode, const git_oid *our_oid,
	int their_mode, const git_oid *their_oid)
Edward Thomson committed
1747 1748 1749 1750 1751 1752
{
	git_index_reuc_entry *reuc = NULL;
	int error = 0;

	assert(index && path);

1753 1754
	if ((error = index_entry_reuc_init(&reuc, path, ancestor_mode,
			ancestor_oid, our_mode, our_oid, their_mode, their_oid)) < 0 ||
Edward Thomson committed
1755 1756 1757 1758
		(error = index_reuc_insert(index, reuc, 1)) < 0)
		index_entry_reuc_free(reuc);

	return error;
1759
}
Edward Thomson committed
1760

1761
int git_index_reuc_find(size_t *at_pos, git_index *index, const char *path)
1762
{
1763
	return git_vector_bsearch2(at_pos, &index->reuc, index->reuc_search, path);
1764 1765
}

Edward Thomson committed
1766
const git_index_reuc_entry *git_index_reuc_get_bypath(
1767
	git_index *index, const char *path)
1768
{
1769
	size_t pos;
1770
	assert(index && path);
1771

Edward Thomson committed
1772
	if (!index->reuc.length)
1773
		return NULL;
1774

Edward Thomson committed
1775 1776
	git_vector_sort(&index->reuc);

1777
	if (git_index_reuc_find(&pos, index, path) < 0)
1778
		return NULL;
1779

Edward Thomson committed
1780
	return git_vector_get(&index->reuc, pos);
1781 1782
}

Edward Thomson committed
1783
const git_index_reuc_entry *git_index_reuc_get_byindex(
1784
	git_index *index, size_t n)
1785 1786
{
	assert(index);
Edward Thomson committed
1787 1788 1789 1790 1791

	git_vector_sort(&index->reuc);
	return git_vector_get(&index->reuc, n);
}

Ben Straub committed
1792
int git_index_reuc_remove(git_index *index, size_t position)
Edward Thomson committed
1793 1794 1795 1796 1797 1798 1799
{
	int error;
	git_index_reuc_entry *reuc;

	git_vector_sort(&index->reuc);

	reuc = git_vector_get(&index->reuc, position);
1800
	error = git_vector_remove(&index->reuc, position);
Edward Thomson committed
1801 1802 1803 1804 1805

	if (!error)
		index_entry_reuc_free(reuc);

	return error;
1806 1807
}

Edward Thomson committed
1808 1809 1810 1811 1812 1813
void git_index_reuc_clear(git_index *index)
{
	size_t i;

	assert(index);

1814 1815
	for (i = 0; i < index->reuc.length; ++i)
		index_entry_reuc_free(git__swap(index->reuc.contents[i], NULL));
Edward Thomson committed
1816 1817 1818 1819

	git_vector_clear(&index->reuc);
}

1820 1821 1822 1823 1824 1825
static int index_error_invalid(const char *message)
{
	giterr_set(GITERR_INDEX, "Invalid data in index - %s", message);
	return -1;
}

Edward Thomson committed
1826
static int read_reuc(git_index *index, const char *buffer, size_t size)
1827
{
1828 1829
	const char *endptr;
	size_t len;
1830 1831
	int i;

1832 1833 1834
	/* If called multiple times, the vector might already be initialized */
	if (index->reuc._alloc_size == 0 &&
		git_vector_init(&index->reuc, 16, reuc_cmp) < 0)
1835
		return -1;
1836 1837

	while (size) {
Edward Thomson committed
1838
		git_index_reuc_entry *lost;
1839

1840
		len = p_strnlen(buffer, size) + 1;
1841
		if (size <= len)
Edward Thomson committed
1842
			return index_error_invalid("reading reuc entries");
1843

1844
		lost = reuc_entry_alloc(buffer);
1845
		GITERR_CHECK_ALLOC(lost);
1846 1847 1848 1849

		size -= len;
		buffer += len;

1850
		/* read 3 ASCII octal numbers for stage entries */
1851
		for (i = 0; i < 3; i++) {
1852
			int tmp;
1853

1854 1855
			if (git__strtol32(&tmp, buffer, &endptr, 8) < 0 ||
				!endptr || endptr == buffer || *endptr ||
1856 1857
				(unsigned)tmp > UINT_MAX) {
				index_entry_reuc_free(lost);
Edward Thomson committed
1858
				return index_error_invalid("reading reuc entry stage");
1859
			}
1860

1861 1862
			lost->mode[i] = tmp;

1863
			len = (endptr + 1) - buffer;
1864 1865
			if (size <= len) {
				index_entry_reuc_free(lost);
Edward Thomson committed
1866
				return index_error_invalid("reading reuc entry stage");
1867
			}
1868

1869 1870 1871 1872
			size -= len;
			buffer += len;
		}

1873
		/* read up to 3 OIDs for stage entries */
1874 1875 1876
		for (i = 0; i < 3; i++) {
			if (!lost->mode[i])
				continue;
1877 1878
			if (size < 20) {
				index_entry_reuc_free(lost);
Edward Thomson committed
1879
				return index_error_invalid("reading reuc entry oid");
1880
			}
1881

1882
			git_oid_fromraw(&lost->oid[i], (const unsigned char *) buffer);
1883 1884 1885
			size -= 20;
			buffer += 20;
		}
1886 1887 1888 1889

		/* entry was read successfully - insert into reuc vector */
		if (git_vector_insert(&index->reuc, lost) < 0)
			return -1;
1890 1891
	}

Edward Thomson committed
1892
	/* entries are guaranteed to be sorted on-disk */
1893
	git_vector_set_sorted(&index->reuc, true);
Edward Thomson committed
1894

1895
	return 0;
1896 1897
}

Edward Thomson committed
1898 1899 1900 1901

static int read_conflict_names(git_index *index, const char *buffer, size_t size)
{
	size_t len;
nulltoken committed
1902

Edward Thomson committed
1903 1904 1905 1906 1907 1908
	/* This gets called multiple times, the vector might already be initialized */
	if (index->names._alloc_size == 0 &&
		git_vector_init(&index->names, 16, conflict_name_cmp) < 0)
		return -1;

#define read_conflict_name(ptr) \
1909
	len = p_strnlen(buffer, size) + 1; \
Edward Thomson committed
1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922
	if (size < len) \
		return index_error_invalid("reading conflict name entries"); \
	\
	if (len == 1) \
		ptr = NULL; \
	else { \
		ptr = git__malloc(len); \
		GITERR_CHECK_ALLOC(ptr); \
		memcpy(ptr, buffer, len); \
	} \
	\
	buffer += len; \
	size -= len;
nulltoken committed
1923

Edward Thomson committed
1924 1925 1926 1927 1928 1929 1930
	while (size) {
		git_index_name_entry *conflict_name = git__calloc(1, sizeof(git_index_name_entry));
		GITERR_CHECK_ALLOC(conflict_name);

		read_conflict_name(conflict_name->ancestor);
		read_conflict_name(conflict_name->ours);
		read_conflict_name(conflict_name->theirs);
nulltoken committed
1931

Edward Thomson committed
1932 1933 1934 1935 1936
		if (git_vector_insert(&index->names, conflict_name) < 0)
			return -1;
	}

#undef read_conflict_name
nulltoken committed
1937

Edward Thomson committed
1938
	/* entries are guaranteed to be sorted on-disk */
1939
	git_vector_set_sorted(&index->names, true);
nulltoken committed
1940 1941

	return 0;
Edward Thomson committed
1942 1943
}

1944
static size_t read_entry(
1945 1946 1947 1948
	git_index_entry **out,
	git_index *index,
	const void *buffer,
	size_t buffer_size)
1949 1950 1951
{
	size_t path_length, entry_size;
	const char *path_ptr;
1952
	struct entry_short source;
1953
	git_index_entry entry = {{0}};
1954 1955 1956 1957

	if (INDEX_FOOTER_SIZE + minimal_entry_size > buffer_size)
		return 0;

1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972
	/* buffer is not guaranteed to be aligned */
	memcpy(&source, buffer, sizeof(struct entry_short));

	entry.ctime.seconds = (git_time_t)ntohl(source.ctime.seconds);
	entry.ctime.nanoseconds = ntohl(source.ctime.nanoseconds);
	entry.mtime.seconds = (git_time_t)ntohl(source.mtime.seconds);
	entry.mtime.nanoseconds = ntohl(source.mtime.nanoseconds);
	entry.dev = ntohl(source.dev);
	entry.ino = ntohl(source.ino);
	entry.mode = ntohl(source.mode);
	entry.uid = ntohl(source.uid);
	entry.gid = ntohl(source.gid);
	entry.file_size = ntohl(source.file_size);
	git_oid_cpy(&entry.id, &source.oid);
	entry.flags = ntohs(source.flags);
1973 1974

	if (entry.flags & GIT_IDXENTRY_EXTENDED) {
1975 1976
		uint16_t flags_raw;
		size_t flags_offset;
1977

1978 1979 1980 1981 1982 1983 1984
		flags_offset = offsetof(struct entry_long, flags_extended);
		memcpy(&flags_raw, (const char *) buffer + flags_offset,
			sizeof(flags_raw));
		flags_raw = ntohs(flags_raw);

		memcpy(&entry.flags_extended, &flags_raw, sizeof(flags_raw));
		path_ptr = (const char *) buffer + offsetof(struct entry_long, path);
1985
	} else
1986
		path_ptr = (const char *) buffer + offsetof(struct entry_short, path);
1987

1988
	path_length = entry.flags & GIT_IDXENTRY_NAMEMASK;
1989 1990 1991 1992 1993 1994 1995 1996

	/* if this is a very long string, we must find its
	 * real length without overflowing */
	if (path_length == 0xFFF) {
		const char *path_end;

		path_end = memchr(path_ptr, '\0', buffer_size);
		if (path_end == NULL)
1997
			return 0;
1998 1999 2000 2001

		path_length = path_end - path_ptr;
	}

2002
	if (entry.flags & GIT_IDXENTRY_EXTENDED)
2003 2004 2005 2006 2007 2008 2009
		entry_size = long_entry_size(path_length);
	else
		entry_size = short_entry_size(path_length);

	if (INDEX_FOOTER_SIZE + entry_size > buffer_size)
		return 0;

2010 2011
	entry.path = (char *)path_ptr;

2012
	if (index_entry_dup(out, INDEX_OWNER(index), &entry) < 0)
2013
		return 0;
2014 2015 2016 2017 2018 2019

	return entry_size;
}

static int read_header(struct index_header *dest, const void *buffer)
{
2020
	const struct index_header *source = buffer;
2021

2022 2023
	dest->signature = ntohl(source->signature);
	if (dest->signature != INDEX_HEADER_SIG)
2024
		return index_error_invalid("incorrect header signature");
2025 2026

	dest->version = ntohl(source->version);
2027 2028
	if (dest->version != INDEX_VERSION_NUMBER_EXT &&
		dest->version != INDEX_VERSION_NUMBER)
2029
		return index_error_invalid("incorrect header version");
2030 2031

	dest->entry_count = ntohl(source->entry_count);
2032
	return 0;
2033 2034 2035 2036 2037 2038 2039
}

static size_t read_extension(git_index *index, const char *buffer, size_t buffer_size)
{
	struct index_extension dest;
	size_t total_size;

2040 2041 2042
	/* buffer is not guaranteed to be aligned */
	memcpy(&dest, buffer, sizeof(struct index_extension));
	dest.extension_size = ntohl(dest.extension_size);
2043 2044 2045

	total_size = dest.extension_size + sizeof(struct index_extension);

2046 2047
	if (dest.extension_size > total_size ||
		buffer_size < total_size ||
2048
		buffer_size - total_size < INDEX_FOOTER_SIZE)
2049 2050 2051 2052 2053 2054
		return 0;

	/* optional extension */
	if (dest.signature[0] >= 'A' && dest.signature[0] <= 'Z') {
		/* tree cache */
		if (memcmp(dest.signature, INDEX_EXT_TREECACHE_SIG, 4) == 0) {
2055
			if (git_tree_cache_read(&index->tree, buffer + 8, dest.extension_size, &index->tree_pool) < 0)
2056
				return 0;
2057
		} else if (memcmp(dest.signature, INDEX_EXT_UNMERGED_SIG, 4) == 0) {
Edward Thomson committed
2058
			if (read_reuc(index, buffer + 8, dest.extension_size) < 0)
2059
				return 0;
Edward Thomson committed
2060 2061 2062
		} else if (memcmp(dest.signature, INDEX_EXT_CONFLICT_NAME_SIG, 4) == 0) {
			if (read_conflict_names(index, buffer + 8, dest.extension_size) < 0)
				return 0;
2063
		}
2064 2065
		/* else, unsupported extension. We cannot parse this, but we can skip
		 * it by returning `total_size */
2066 2067 2068 2069 2070 2071 2072 2073 2074
	} else {
		/* we cannot handle non-ignorable extensions;
		 * in fact they aren't even defined in the standard */
		return 0;
	}

	return total_size;
}

2075
static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
2076
{
2077
	int error = 0;
2078
	unsigned int i;
2079
	struct index_header header = { 0 };
2080 2081 2082
	git_oid checksum_calculated, checksum_expected;

#define seek_forward(_increase) { \
2083 2084 2085
	if (_increase >= buffer_size) { \
		error = index_error_invalid("ran out of data while parsing"); \
		goto done; } \
2086 2087 2088 2089 2090
	buffer += _increase; \
	buffer_size -= _increase;\
}

	if (buffer_size < INDEX_HEADER_SIZE + INDEX_FOOTER_SIZE)
2091
		return index_error_invalid("insufficient buffer space");
2092 2093 2094

	/* Precalculate the SHA1 of the files's contents -- we'll match it to
	 * the provided SHA1 in the footer */
2095
	git_hash_buf(&checksum_calculated, buffer, buffer_size - INDEX_FOOTER_SIZE);
2096 2097

	/* Parse header */
2098 2099
	if ((error = read_header(&header, buffer)) < 0)
		return error;
2100 2101 2102

	seek_forward(INDEX_HEADER_SIZE);

2103 2104 2105 2106 2107
	if (git_mutex_lock(&index->lock) < 0) {
		giterr_set(GITERR_OS, "Unable to acquire index lock");
		return -1;
	}

2108
	assert(!index->entries.length);
2109 2110

	/* Parse all the entries */
2111 2112
	for (i = 0; i < header.entry_count && buffer_size > INDEX_FOOTER_SIZE; ++i) {
		git_index_entry *entry;
2113
		size_t entry_size = read_entry(&entry, index, buffer, buffer_size);
2114 2115

		/* 0 bytes read means an object corruption */
2116 2117 2118 2119
		if (entry_size == 0) {
			error = index_error_invalid("invalid entry");
			goto done;
		}
2120

2121 2122
		if ((error = git_vector_insert(&index->entries, entry)) < 0) {
			index_entry_free(entry);
2123
			goto done;
2124
		}
2125

2126 2127 2128
		seek_forward(entry_size);
	}

2129 2130 2131 2132
	if (i != header.entry_count) {
		error = index_error_invalid("header entries changed while parsing");
		goto done;
	}
2133

2134 2135 2136 2137 2138 2139 2140
	/* There's still space for some extensions! */
	while (buffer_size > INDEX_FOOTER_SIZE) {
		size_t extension_size;

		extension_size = read_extension(index, buffer, buffer_size);

		/* see if we have read any bytes from the extension */
2141 2142 2143 2144
		if (extension_size == 0) {
			error = index_error_invalid("extension is truncated");
			goto done;
		}
2145 2146 2147 2148

		seek_forward(extension_size);
	}

2149 2150 2151 2152 2153
	if (buffer_size != INDEX_FOOTER_SIZE) {
		error = index_error_invalid(
			"buffer size does not match index footer size");
		goto done;
	}
2154 2155

	/* 160-bit SHA-1 over the content of the index file before this checksum. */
Vicent Marti committed
2156
	git_oid_fromraw(&checksum_expected, (const unsigned char *)buffer);
2157

2158 2159 2160 2161 2162
	if (git_oid__cmp(&checksum_calculated, &checksum_expected) != 0) {
		error = index_error_invalid(
			"calculated checksum does not match expected");
		goto done;
	}
2163

2164 2165
	git_oid_cpy(&index->checksum, &checksum_calculated);

2166 2167
#undef seek_forward

2168 2169 2170 2171
	/* Entries are stored case-sensitively on disk, so re-sort now if
	 * in-memory index is supposed to be case-insensitive
	 */
	git_vector_set_sorted(&index->entries, !index->ignore_case);
2172
	error = index_sort_if_needed(index, false);
2173

2174
done:
2175
	git_mutex_unlock(&index->lock);
2176
	return error;
2177 2178
}

2179
static bool is_index_extended(git_index *index)
Vicent Marti committed
2180
{
2181
	size_t i, extended;
2182
	git_index_entry *entry;
Vicent Marti committed
2183 2184 2185

	extended = 0;

2186
	git_vector_foreach(&index->entries, i, entry) {
Vicent Marti committed
2187 2188 2189 2190 2191 2192
		entry->flags &= ~GIT_IDXENTRY_EXTENDED;
		if (entry->flags_extended & GIT_IDXENTRY_EXTENDED_FLAGS) {
			extended++;
			entry->flags |= GIT_IDXENTRY_EXTENDED;
		}
	}
2193

2194
	return (extended > 0);
Vicent Marti committed
2195 2196
}

2197
static int write_disk_entry(git_filebuf *file, git_index_entry *entry)
2198
{
2199
	void *mem = NULL;
2200
	struct entry_short *ondisk;
2201
	size_t path_len, disk_size;
2202
	char *path;
2203

2204
	path_len = ((struct entry_internal *)entry)->pathlen;
2205

2206
	if (entry->flags & GIT_IDXENTRY_EXTENDED)
2207
		disk_size = long_entry_size(path_len);
2208
	else
2209
		disk_size = short_entry_size(path_len);
2210

2211 2212
	if (git_filebuf_reserve(file, &mem, disk_size) < 0)
		return -1;
2213

2214 2215
	ondisk = (struct entry_short *)mem;

2216
	memset(ondisk, 0x0, disk_size);
2217

2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229
	/**
	 * Yes, we have to truncate.
	 *
	 * The on-disk format for Index entries clearly defines
	 * the time and size fields to be 4 bytes each -- so even if
	 * we store these values with 8 bytes on-memory, they must
	 * be truncated to 4 bytes before writing to disk.
	 *
	 * In 2038 I will be either too dead or too rich to care about this
	 */
	ondisk->ctime.seconds = htonl((uint32_t)entry->ctime.seconds);
	ondisk->mtime.seconds = htonl((uint32_t)entry->mtime.seconds);
2230 2231
	ondisk->ctime.nanoseconds = htonl(entry->ctime.nanoseconds);
	ondisk->mtime.nanoseconds = htonl(entry->mtime.nanoseconds);
Vicent Marti committed
2232 2233
	ondisk->dev = htonl(entry->dev);
	ondisk->ino = htonl(entry->ino);
2234
	ondisk->mode = htonl(entry->mode);
Vicent Marti committed
2235 2236
	ondisk->uid = htonl(entry->uid);
	ondisk->gid = htonl(entry->gid);
2237
	ondisk->file_size = htonl((uint32_t)entry->file_size);
2238

2239
	git_oid_cpy(&ondisk->oid, &entry->id);
2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252

	ondisk->flags = htons(entry->flags);

	if (entry->flags & GIT_IDXENTRY_EXTENDED) {
		struct entry_long *ondisk_ext;
		ondisk_ext = (struct entry_long *)ondisk;
		ondisk_ext->flags_extended = htons(entry->flags_extended);
		path = ondisk_ext->path;
	}
	else
		path = ondisk->path;

	memcpy(path, entry->path, path_len);
2253

2254
	return 0;
2255 2256
}

2257
static int write_entries(git_index *index, git_filebuf *file)
2258
{
2259
	int error = 0;
2260
	size_t i;
2261
	git_vector case_sorted, *entries;
2262 2263
	git_index_entry *entry;

2264 2265 2266 2267 2268
	if (git_mutex_lock(&index->lock) < 0) {
		giterr_set(GITERR_OS, "Failed to lock index");
		return -1;
	}

2269 2270 2271
	/* If index->entries is sorted case-insensitively, then we need
	 * to re-sort it case-sensitively before writing */
	if (index->ignore_case) {
2272
		git_vector_dup(&case_sorted, &index->entries, git_index_entry_cmp);
2273
		git_vector_sort(&case_sorted);
2274 2275 2276
		entries = &case_sorted;
	} else {
		entries = &index->entries;
2277 2278
	}

2279
	git_vector_foreach(entries, i, entry)
2280 2281 2282
		if ((error = write_disk_entry(file, entry)) < 0)
			break;

2283 2284
	git_mutex_unlock(&index->lock);

2285 2286 2287 2288
	if (index->ignore_case)
		git_vector_free(&case_sorted);

	return error;
2289 2290
}

Edward Thomson committed
2291 2292 2293 2294 2295 2296 2297 2298
static int write_extension(git_filebuf *file, struct index_extension *header, git_buf *data)
{
	struct index_extension ondisk;

	memset(&ondisk, 0x0, sizeof(struct index_extension));
	memcpy(&ondisk, header, 4);
	ondisk.extension_size = htonl(header->extension_size);

2299 2300
	git_filebuf_write(file, &ondisk, sizeof(struct index_extension));
	return git_filebuf_write(file, data->ptr, data->size);
Edward Thomson committed
2301 2302
}

Edward Thomson committed
2303 2304 2305 2306 2307 2308 2309 2310
static int create_name_extension_data(git_buf *name_buf, git_index_name_entry *conflict_name)
{
	int error = 0;

	if (conflict_name->ancestor == NULL)
		error = git_buf_put(name_buf, "\0", 1);
	else
		error = git_buf_put(name_buf, conflict_name->ancestor, strlen(conflict_name->ancestor) + 1);
nulltoken committed
2311

Edward Thomson committed
2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339
	if (error != 0)
		goto on_error;

	if (conflict_name->ours == NULL)
		error = git_buf_put(name_buf, "\0", 1);
	else
		error = git_buf_put(name_buf, conflict_name->ours, strlen(conflict_name->ours) + 1);

	if (error != 0)
		goto on_error;

	if (conflict_name->theirs == NULL)
		error = git_buf_put(name_buf, "\0", 1);
	else
		error = git_buf_put(name_buf, conflict_name->theirs, strlen(conflict_name->theirs) + 1);

on_error:
	return error;
}

static int write_name_extension(git_index *index, git_filebuf *file)
{
	git_buf name_buf = GIT_BUF_INIT;
	git_vector *out = &index->names;
	git_index_name_entry *conflict_name;
	struct index_extension extension;
	size_t i;
	int error = 0;
nulltoken committed
2340

Edward Thomson committed
2341 2342 2343 2344
	git_vector_foreach(out, i, conflict_name) {
		if ((error = create_name_extension_data(&name_buf, conflict_name)) < 0)
			goto done;
	}
nulltoken committed
2345

Edward Thomson committed
2346 2347 2348
	memset(&extension, 0x0, sizeof(struct index_extension));
	memcpy(&extension.signature, INDEX_EXT_CONFLICT_NAME_SIG, 4);
	extension.extension_size = (uint32_t)name_buf.size;
nulltoken committed
2349

Edward Thomson committed
2350
	error = write_extension(file, &extension, &name_buf);
nulltoken committed
2351

Edward Thomson committed
2352
	git_buf_free(&name_buf);
nulltoken committed
2353

Edward Thomson committed
2354 2355 2356 2357
done:
	return error;
}

Edward Thomson committed
2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385
static int create_reuc_extension_data(git_buf *reuc_buf, git_index_reuc_entry *reuc)
{
	int i;
	int error = 0;

	if ((error = git_buf_put(reuc_buf, reuc->path, strlen(reuc->path) + 1)) < 0)
		return error;

	for (i = 0; i < 3; i++) {
		if ((error = git_buf_printf(reuc_buf, "%o", reuc->mode[i])) < 0 ||
			(error = git_buf_put(reuc_buf, "\0", 1)) < 0)
			return error;
	}

	for (i = 0; i < 3; i++) {
		if (reuc->mode[i] && (error = git_buf_put(reuc_buf, (char *)&reuc->oid[i].id, GIT_OID_RAWSZ)) < 0)
			return error;
	}

	return 0;
}

static int write_reuc_extension(git_index *index, git_filebuf *file)
{
	git_buf reuc_buf = GIT_BUF_INIT;
	git_vector *out = &index->reuc;
	git_index_reuc_entry *reuc;
	struct index_extension extension;
2386
	size_t i;
Edward Thomson committed
2387 2388 2389 2390 2391 2392 2393 2394 2395
	int error = 0;

	git_vector_foreach(out, i, reuc) {
		if ((error = create_reuc_extension_data(&reuc_buf, reuc)) < 0)
			goto done;
	}

	memset(&extension, 0x0, sizeof(struct index_extension));
	memcpy(&extension.signature, INDEX_EXT_UNMERGED_SIG, 4);
2396
	extension.extension_size = (uint32_t)reuc_buf.size;
Edward Thomson committed
2397 2398 2399 2400 2401 2402 2403 2404 2405

	error = write_extension(file, &extension, &reuc_buf);

	git_buf_free(&reuc_buf);

done:
	return error;
}

2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428
static int write_tree_extension(git_index *index, git_filebuf *file)
{
	struct index_extension extension;
	git_buf buf = GIT_BUF_INIT;
	int error;

	if (index->tree == NULL)
		return 0;

	if ((error = git_tree_cache_write(&buf, index->tree)) < 0)
		return error;

	memset(&extension, 0x0, sizeof(struct index_extension));
	memcpy(&extension.signature, INDEX_EXT_TREECACHE_SIG, 4);
	extension.extension_size = (uint32_t)buf.size;

	error = write_extension(file, &extension, &buf);

	git_buf_free(&buf);

	return error;
}

2429
static int write_index(git_oid *checksum, git_index *index, git_filebuf *file)
2430 2431 2432
{
	git_oid hash_final;
	struct index_header header;
2433
	bool is_extended;
Ben Straub committed
2434
	uint32_t index_version_number;
2435

2436
	assert(index && file);
2437

Vicent Marti committed
2438
	is_extended = is_index_extended(index);
Ben Straub committed
2439
	index_version_number = is_extended ? INDEX_VERSION_NUMBER_EXT : INDEX_VERSION_NUMBER;
Vicent Marti committed
2440

2441
	header.signature = htonl(INDEX_HEADER_SIG);
Ben Straub committed
2442
	header.version = htonl(index_version_number);
2443
	header.entry_count = htonl((uint32_t)index->entries.length);
2444

2445 2446
	if (git_filebuf_write(file, &header, sizeof(struct index_header)) < 0)
		return -1;
2447

2448 2449
	if (write_entries(index, file) < 0)
		return -1;
2450

2451 2452 2453
	/* write the tree cache extension */
	if (index->tree != NULL && write_tree_extension(index, file) < 0)
		return -1;
Edward Thomson committed
2454

Edward Thomson committed
2455 2456 2457
	/* write the rename conflict extension */
	if (index->names.length > 0 && write_name_extension(index, file) < 0)
		return -1;
nulltoken committed
2458

Edward Thomson committed
2459 2460 2461
	/* write the reuc extension */
	if (index->reuc.length > 0 && write_reuc_extension(index, file) < 0)
		return -1;
2462

2463 2464
	/* get out the hash for all the contents we've appended to the file */
	git_filebuf_hash(&hash_final, file);
2465
	git_oid_cpy(checksum, &hash_final);
2466 2467

	/* write it at the end of the file */
2468
	return git_filebuf_write(file, hash_final.id, GIT_OID_RAWSZ);
2469
}
2470 2471 2472

int git_index_entry_stage(const git_index_entry *entry)
{
2473
	return GIT_IDXENTRY_STAGE(entry);
2474
}
2475

2476 2477 2478 2479 2480
int git_index_entry_is_conflict(const git_index_entry *entry)
{
	return (GIT_IDXENTRY_STAGE(entry) > 0);
}

2481
typedef struct read_tree_data {
2482
	git_index *index;
2483
	git_vector *old_entries;
2484
	git_vector *new_entries;
2485
	git_vector_cmp entry_cmp;
2486
	git_tree_cache *tree;
2487 2488
} read_tree_data;

2489 2490
static int read_tree_cb(
	const char *root, const git_tree_entry *tentry, void *payload)
2491
{
2492 2493
	read_tree_data *data = payload;
	git_index_entry *entry = NULL, *old_entry;
2494
	git_buf path = GIT_BUF_INIT;
2495
	size_t pos;
2496

Vicent Martí committed
2497
	if (git_tree_entry__is_tree(tentry))
2498
		return 0;
2499

2500 2501
	if (git_buf_joinpath(&path, root, tentry->filename) < 0)
		return -1;
2502

2503
	if (index_entry_create(&entry, INDEX_OWNER(data->index), path.ptr) < 0)
2504
		return -1;
2505 2506

	entry->mode = tentry->attr;
2507
	entry->id = tentry->oid;
2508

2509
	/* look for corresponding old entry and copy data to new entry */
2510
	if (data->old_entries != NULL &&
2511
		!index_find_in_entries(
2512 2513 2514 2515 2516
			&pos, data->old_entries, data->entry_cmp, path.ptr, 0, 0) &&
		(old_entry = git_vector_get(data->old_entries, pos)) != NULL &&
		entry->mode == old_entry->mode &&
		git_oid_equal(&entry->id, &old_entry->id))
	{
2517
		index_entry_cpy(entry, old_entry);
2518
		entry->flags_extended = 0;
2519 2520
	}

2521 2522 2523 2524 2525
	if (path.size < GIT_IDXENTRY_NAMEMASK)
		entry->flags = path.size & GIT_IDXENTRY_NAMEMASK;
	else
		entry->flags = GIT_IDXENTRY_NAMEMASK;

2526 2527
	git_buf_free(&path);

2528
	if (git_vector_insert(data->new_entries, entry) < 0) {
2529
		index_entry_free(entry);
2530 2531 2532 2533
		return -1;
	}

	return 0;
2534 2535
}

Ben Straub committed
2536
int git_index_read_tree(git_index *index, const git_tree *tree)
2537
{
2538 2539 2540 2541
	int error = 0;
	git_vector entries = GIT_VECTOR_INIT;
	read_tree_data data;

2542
	git_vector_set_cmp(&entries, index->entries._cmp); /* match sort */
2543

2544
	data.index = index;
2545 2546
	data.old_entries = &index->entries;
	data.new_entries = &entries;
2547
	data.entry_cmp   = index->entries_search;
2548

2549 2550 2551
	index->tree = NULL;
	git_pool_clear(&index->tree_pool);

2552 2553
	if (index_sort_if_needed(index, true) < 0)
		return -1;
2554 2555 2556

	error = git_tree_walk(tree, GIT_TREEWALK_POST, read_tree_cb, &data);

2557 2558
	if (!error) {
		git_vector_sort(&entries);
2559 2560 2561

		if ((error = git_index_clear(index)) < 0)
			/* well, this isn't good */;
2562 2563 2564 2565
		else if (git_mutex_lock(&index->lock) < 0) {
			giterr_set(GITERR_OS, "Unable to acquire index lock");
			error = -1;
		} else {
2566
			git_vector_swap(&entries, &index->entries);
2567 2568
			git_mutex_unlock(&index->lock);
		}
2569 2570
	}

2571
	git_vector_free(&entries);
2572 2573 2574 2575
	if (error < 0)
		return error;

	error = git_tree_cache_read_tree(&index->tree, tree, &index->tree_pool);
2576 2577

	return error;
2578
}
2579

2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677
int git_index_read_index(
	git_index *index,
	const git_index *new_index)
{
	git_vector new_entries = GIT_VECTOR_INIT,
		remove_entries = GIT_VECTOR_INIT;
	git_iterator *index_iterator = NULL;
	git_iterator *new_iterator = NULL;
	const git_index_entry *old_entry, *new_entry;
	git_index_entry *entry;
	size_t i;
	int error;

	if ((error = git_vector_init(&new_entries, new_index->entries.length, index->entries._cmp)) < 0 ||
		(error = git_vector_init(&remove_entries, index->entries.length, NULL)) < 0)
		goto done;

	if ((error = git_iterator_for_index(&index_iterator,
			index, GIT_ITERATOR_DONT_IGNORE_CASE, NULL, NULL)) < 0 ||
		(error = git_iterator_for_index(&new_iterator,
			(git_index *)new_index, GIT_ITERATOR_DONT_IGNORE_CASE, NULL, NULL)) < 0)
		goto done;

	if (((error = git_iterator_current(&old_entry, index_iterator)) < 0 && 
			error != GIT_ITEROVER) ||
		((error = git_iterator_current(&new_entry, new_iterator)) < 0 && 
			error != GIT_ITEROVER))
		goto done;

	while (true) {
		int diff;

		if (old_entry && new_entry)
			diff = git_index_entry_cmp(old_entry, new_entry);
		else if (!old_entry && new_entry)
			diff = 1;
		else if (old_entry && !new_entry)
			diff = -1;
		else
			break;

		if (diff < 0) {
			git_vector_insert(&remove_entries, (git_index_entry *)old_entry);
		} else if (diff > 0) {
			if ((error = index_entry_dup(&entry, git_index_owner(index), new_entry)) < 0)
				goto done;

			git_vector_insert(&new_entries, entry);
		} else {
			/* Path and stage are equal, if the OID is equal, keep it to
			 * keep the stat cache data.
			 */
			if (git_oid_equal(&old_entry->id, &new_entry->id)) {
				git_vector_insert(&new_entries, (git_index_entry *)old_entry);
			} else {
				if ((error = index_entry_dup(&entry, git_index_owner(index), new_entry)) < 0)
					goto done;

				git_vector_insert(&new_entries, entry);
				git_vector_insert(&remove_entries, (git_index_entry *)old_entry);
			}
		}

		if (diff <= 0) {
			if ((error = git_iterator_advance(&old_entry, index_iterator)) < 0 &&
				error != GIT_ITEROVER)
				goto done;
		}

		if (diff >= 0) {
			if ((error = git_iterator_advance(&new_entry, new_iterator)) < 0 &&
				error != GIT_ITEROVER)
				goto done;
		}
	}

	git_index_name_clear(index);
	git_index_reuc_clear(index);

	git_vector_swap(&new_entries, &index->entries);

	git_vector_foreach(&remove_entries, i, entry) {
		if (index->tree)
			git_tree_cache_invalidate_path(index->tree, entry->path);

		index_entry_free(entry);
	}

	error = 0;

done:
	git_vector_free(&new_entries);
	git_vector_free(&remove_entries);
	git_iterator_free(index_iterator);
	git_iterator_free(new_iterator);
	return error;
}

2678 2679 2680 2681
git_repository *git_index_owner(const git_index *index)
{
	return INDEX_OWNER(index);
}
2682

2683 2684 2685 2686 2687 2688 2689
enum {
	INDEX_ACTION_NONE = 0,
	INDEX_ACTION_UPDATE = 1,
	INDEX_ACTION_REMOVE = 2,
	INDEX_ACTION_ADDALL = 3,
};

2690 2691 2692 2693 2694 2695 2696 2697 2698 2699
int git_index_add_all(
	git_index *index,
	const git_strarray *paths,
	unsigned int flags,
	git_index_matched_path_cb cb,
	void *payload)
{
	int error;
	git_repository *repo;
	git_iterator *wditer = NULL;
2700
	git_pathspec ps;
2701 2702 2703 2704 2705 2706 2707 2708
	bool no_fnmatch = (flags & GIT_INDEX_ADD_DISABLE_PATHSPEC_MATCH) != 0;

	assert(index);

	repo = INDEX_OWNER(index);
	if ((error = git_repository__ensure_not_bare(repo, "index add all")) < 0)
		return error;

2709
	if ((error = git_pathspec__init(&ps, paths)) < 0)
2710 2711 2712 2713 2714 2715 2716 2717 2718
		return error;

	/* optionally check that pathspec doesn't mention any ignored files */
	if ((flags & GIT_INDEX_ADD_CHECK_PATHSPEC) != 0 &&
		(flags & GIT_INDEX_ADD_FORCE) == 0 &&
		(error = git_ignore__check_pathspec_for_exact_ignores(
			repo, &ps.pathspec, no_fnmatch)) < 0)
		goto cleanup;

2719
	error = index_apply_to_wd_diff(index, INDEX_ACTION_ADDALL, paths, flags, cb, payload);
2720

2721 2722
	if (error)
		giterr_set_after_callback(error);
2723 2724 2725

cleanup:
	git_iterator_free(wditer);
2726
	git_pathspec__clear(&ps);
2727 2728 2729 2730

	return error;
}

2731 2732 2733
struct foreach_diff_data {
	git_index *index;
	const git_pathspec *pathspec;
2734
	unsigned int flags;
2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762
	git_index_matched_path_cb cb;
	void *payload;
};

static int apply_each_file(const git_diff_delta *delta, float progress, void *payload)
{
	struct foreach_diff_data *data = payload;
	const char *match, *path;
	int error = 0;

	GIT_UNUSED(progress);

	path = delta->old_file.path;

	/* We only want those which match the pathspecs */
	if (!git_pathspec__match(
		    &data->pathspec->pathspec, path, false, (bool)data->index->ignore_case,
		    &match, NULL))
		return 0;

	if (data->cb)
		error = data->cb(path, match, data->payload);

	if (error > 0) /* skip this entry */
		return 0;
	if (error < 0) /* actual error */
		return error;

2763 2764
	/* If the workdir item does not exist, remove it from the index. */
	if ((delta->new_file.flags & GIT_DIFF_FLAG_EXISTS) == 0)
2765 2766
		error = git_index_remove_bypath(data->index, path);
	else
2767
		error = git_index_add_bypath(data->index, delta->new_file.path);
2768 2769 2770 2771 2772

	return error;
}

static int index_apply_to_wd_diff(git_index *index, int action, const git_strarray *paths,
2773
				  unsigned int flags,
2774 2775 2776 2777 2778 2779
				  git_index_matched_path_cb cb, void *payload)
{
	int error;
	git_diff *diff;
	git_pathspec ps;
	git_repository *repo;
2780
	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
2781 2782 2783
	struct foreach_diff_data data = {
		index,
		NULL,
2784
		flags,
2785 2786 2787 2788 2789
		cb,
		payload,
	};

	assert(index);
2790
	assert(action == INDEX_ACTION_UPDATE || action == INDEX_ACTION_ADDALL);
2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806

	repo = INDEX_OWNER(index);

	if (!repo) {
		return create_index_error(-1,
			"cannot run update; the index is not backed up by a repository.");
	}

	/*
	 * We do the matching ourselves intead of passing the list to
	 * diff because we want to tell the callback which one
	 * matched, which we do not know if we ask diff to filter for us.
	 */
	if ((error = git_pathspec__init(&ps, paths)) < 0)
		return error;

2807
	opts.flags = GIT_DIFF_INCLUDE_TYPECHANGE;
2808
	if (action == INDEX_ACTION_ADDALL) {
2809
		opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED |
2810
			GIT_DIFF_RECURSE_UNTRACKED_DIRS;
2811

2812 2813 2814 2815 2816
		if (flags == GIT_INDEX_ADD_FORCE)
			opts.flags |= GIT_DIFF_INCLUDE_IGNORED;
	}

	if ((error = git_diff_index_to_workdir(&diff, repo, index, &opts)) < 0)
2817 2818 2819
		goto cleanup;

	data.pathspec = &ps;
2820
	error = git_diff_foreach(diff, apply_each_file, NULL, NULL, NULL, &data);
2821 2822 2823 2824 2825 2826 2827 2828 2829 2830
	git_diff_free(diff);

	if (error) /* make sure error is set if callback stopped iteration */
		giterr_set_after_callback(error);

cleanup:
	git_pathspec__clear(&ps);
	return error;
}

2831 2832 2833 2834 2835 2836 2837 2838 2839
static int index_apply_to_all(
	git_index *index,
	int action,
	const git_strarray *paths,
	git_index_matched_path_cb cb,
	void *payload)
{
	int error = 0;
	size_t i;
2840
	git_pathspec ps;
2841
	const char *match;
2842
	git_buf path = GIT_BUF_INIT;
2843 2844 2845

	assert(index);

2846
	if ((error = git_pathspec__init(&ps, paths)) < 0)
2847 2848 2849 2850 2851 2852 2853 2854
		return error;

	git_vector_sort(&index->entries);

	for (i = 0; !error && i < index->entries.length; ++i) {
		git_index_entry *entry = git_vector_get(&index->entries, i);

		/* check if path actually matches */
2855
		if (!git_pathspec__match(
Linquize committed
2856
				&ps.pathspec, entry->path, false, (bool)index->ignore_case,
2857
				&match, NULL))
2858 2859 2860 2861 2862 2863 2864 2865
			continue;

		/* issue notification callback if requested */
		if (cb && (error = cb(entry->path, match, payload)) != 0) {
			if (error > 0) { /* return > 0 means skip this one */
				error = 0;
				continue;
			}
2866
			if (error < 0)   /* return < 0 means abort */
2867 2868 2869
				break;
		}

2870 2871 2872 2873
		/* index manipulation may alter entry, so don't depend on it */
		if ((error = git_buf_sets(&path, entry->path)) < 0)
			break;

2874 2875 2876 2877
		switch (action) {
		case INDEX_ACTION_NONE:
			break;
		case INDEX_ACTION_UPDATE:
2878
			error = git_index_add_bypath(index, path.ptr);
2879 2880 2881 2882

			if (error == GIT_ENOTFOUND) {
				giterr_clear();

2883
				error = git_index_remove_bypath(index, path.ptr);
2884 2885 2886 2887 2888 2889

				if (!error) /* back up foreach if we removed this */
					i--;
			}
			break;
		case INDEX_ACTION_REMOVE:
2890
			if (!(error = git_index_remove_bypath(index, path.ptr)))
2891 2892 2893 2894 2895 2896 2897 2898 2899
				i--; /* back up foreach if we removed this */
			break;
		default:
			giterr_set(GITERR_INVALID, "Unknown index action %d", action);
			error = -1;
			break;
		}
	}

2900
	git_buf_free(&path);
2901
	git_pathspec__clear(&ps);
2902 2903 2904 2905 2906 2907 2908 2909 2910 2911

	return error;
}

int git_index_remove_all(
	git_index *index,
	const git_strarray *pathspec,
	git_index_matched_path_cb cb,
	void *payload)
{
2912
	int error = index_apply_to_all(
2913
		index, INDEX_ACTION_REMOVE, pathspec, cb, payload);
2914 2915 2916 2917 2918

	if (error) /* make sure error is set if callback stopped iteration */
		giterr_set_after_callback(error);

	return error;
2919 2920 2921 2922 2923 2924 2925 2926
}

int git_index_update_all(
	git_index *index,
	const git_strarray *pathspec,
	git_index_matched_path_cb cb,
	void *payload)
{
2927
	int error = index_apply_to_wd_diff(index, INDEX_ACTION_UPDATE, pathspec, 0, cb, payload);
2928 2929 2930 2931
	if (error) /* make sure error is set if callback stopped iteration */
		giterr_set_after_callback(error);

	return error;
2932
}
2933

2934
int git_index_snapshot_new(git_vector *snap, git_index *index)
2935 2936 2937 2938
{
	int error;

	GIT_REFCOUNT_INC(index);
2939 2940 2941 2942 2943 2944 2945

	if (git_mutex_lock(&index->lock) < 0) {
		giterr_set(GITERR_OS, "Failed to lock index");
		return -1;
	}

	git_atomic_inc(&index->readers);
2946
	git_vector_sort(&index->entries);
2947

2948
	error = git_vector_dup(snap, &index->entries, index->entries._cmp);
2949

2950 2951
	git_mutex_unlock(&index->lock);

2952 2953 2954 2955 2956 2957
	if (error < 0)
		git_index_free(index);

	return error;
}

2958
void git_index_snapshot_release(git_vector *snap, git_index *index)
2959
{
2960 2961
	git_vector_free(snap);

2962 2963 2964 2965 2966 2967
	git_atomic_dec(&index->readers);

	if (!git_mutex_lock(&index->lock)) {
		index_free_deleted(index); /* try to free pending deleted items */
		git_mutex_unlock(&index->lock);
	}
2968 2969

	git_index_free(index);
2970
}
2971 2972 2973 2974 2975 2976 2977

int git_index_snapshot_find(
	size_t *out, git_vector *entries, git_vector_cmp entry_srch,
	const char *path, size_t path_len, int stage)
{
	return index_find_in_entries(out, entries, entry_srch, path, path_len, stage);
}
2978 2979 2980 2981 2982 2983 2984

int git_indexwriter_init(
	git_indexwriter *writer,
	git_index *index)
{
	int error;

2985 2986
	GIT_REFCOUNT_INC(index);

2987 2988 2989 2990 2991 2992 2993 2994
	writer->index = index;

	if (!index->index_file_path)
		return create_index_error(-1,
			"Failed to write index: The index is in-memory only");

	if ((error = git_filebuf_open(
		&writer->file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS, GIT_INDEX_FILE_MODE)) < 0) {
2995

2996 2997 2998 2999 3000 3001
		if (error == GIT_ELOCKED)
			giterr_set(GITERR_INDEX, "The index is locked. This might be due to a concurrent or crashed process");

		return error;
	}

3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021
	writer->should_write = 1;

	return 0;
}

int git_indexwriter_init_for_operation(
	git_indexwriter *writer,
	git_repository *repo,
	unsigned int *checkout_strategy)
{
	git_index *index;
	int error;

	if ((error = git_repository_index__weakptr(&index, repo)) < 0 ||
		(error = git_indexwriter_init(writer, index)) < 0)
		return error;

	writer->should_write = (*checkout_strategy & GIT_CHECKOUT_DONT_WRITE_INDEX) == 0;
	*checkout_strategy |= GIT_CHECKOUT_DONT_WRITE_INDEX;

3022 3023 3024 3025 3026 3027
	return 0;
}

int git_indexwriter_commit(git_indexwriter *writer)
{
	int error;
3028
	git_oid checksum = {{ 0 }};
3029

3030 3031 3032
	if (!writer->should_write)
		return 0;

3033 3034 3035 3036 3037
	if (index_sort_if_needed(writer->index, true) < 0)
		return -1;

	git_vector_sort(&writer->index->reuc);

3038
	if ((error = write_index(&checksum, writer->index, &writer->file)) < 0) {
3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052
		git_indexwriter_cleanup(writer);
		return error;
	}

	if ((error = git_filebuf_commit(&writer->file)) < 0)
		return error;

	if ((error = git_futils_filestamp_check(
		&writer->index->stamp, writer->index->index_file_path)) < 0) {
		giterr_set(GITERR_OS, "Could not read index timestamp");
		return -1;
	}

	writer->index->on_disk = 1;
3053
	git_oid_cpy(&writer->index->checksum, &checksum);
3054

3055 3056 3057
	git_index_free(writer->index);
	writer->index = NULL;

3058 3059 3060 3061 3062 3063
	return 0;
}

void git_indexwriter_cleanup(git_indexwriter *writer)
{
	git_filebuf_cleanup(&writer->file);
3064 3065 3066

	git_index_free(writer->index);
	writer->index = NULL;
3067
}