1 /*
2 * Copyright (C) the libgit2 contributors. All rights reserved.
3 *
4 * This file is part of libgit2, distributed under the GNU GPL v2 with
5 * a Linking Exception. For full terms see the included COPYING file.
6 */
7
8 #include "index.h"
9
10 #include <stddef.h>
11
12 #include "repository.h"
13 #include "tree.h"
14 #include "tree-cache.h"
15 #include "hash.h"
16 #include "iterator.h"
17 #include "pathspec.h"
18 #include "ignore.h"
19 #include "blob.h"
20 #include "idxmap.h"
21 #include "diff.h"
22 #include "varint.h"
23
24 #include "git2/odb.h"
25 #include "git2/oid.h"
26 #include "git2/blob.h"
27 #include "git2/config.h"
28 #include "git2/sys/index.h"
29
30 static int index_apply_to_wd_diff(git_index *index, int action, const git_strarray *paths,
31 unsigned int flags,
32 git_index_matched_path_cb cb, void *payload);
33
34 #define minimal_entry_size (offsetof(struct entry_short, path))
35
36 static const size_t INDEX_FOOTER_SIZE = GIT_OID_RAWSZ;
37 static const size_t INDEX_HEADER_SIZE = 12;
38
39 static const unsigned int INDEX_VERSION_NUMBER_DEFAULT = 2;
40 static const unsigned int INDEX_VERSION_NUMBER_LB = 2;
41 static const unsigned int INDEX_VERSION_NUMBER_EXT = 3;
42 static const unsigned int INDEX_VERSION_NUMBER_COMP = 4;
43 static const unsigned int INDEX_VERSION_NUMBER_UB = 4;
44
45 static const unsigned int INDEX_HEADER_SIG = 0x44495243;
46 static const char INDEX_EXT_TREECACHE_SIG[] = {'T', 'R', 'E', 'E'};
47 static const char INDEX_EXT_UNMERGED_SIG[] = {'R', 'E', 'U', 'C'};
48 static const char INDEX_EXT_CONFLICT_NAME_SIG[] = {'N', 'A', 'M', 'E'};
49
50 #define INDEX_OWNER(idx) ((git_repository *)(GIT_REFCOUNT_OWNER(idx)))
51
52 struct index_header {
53 uint32_t signature;
54 uint32_t version;
55 uint32_t entry_count;
56 };
57
58 struct index_extension {
59 char signature[4];
60 uint32_t extension_size;
61 };
62
63 struct entry_time {
64 uint32_t seconds;
65 uint32_t nanoseconds;
66 };
67
68 struct entry_short {
69 struct entry_time ctime;
70 struct entry_time mtime;
71 uint32_t dev;
72 uint32_t ino;
73 uint32_t mode;
74 uint32_t uid;
75 uint32_t gid;
76 uint32_t file_size;
77 git_oid oid;
78 uint16_t flags;
79 char path[1]; /* arbitrary length */
80 };
81
82 struct entry_long {
83 struct entry_time ctime;
84 struct entry_time mtime;
85 uint32_t dev;
86 uint32_t ino;
87 uint32_t mode;
88 uint32_t uid;
89 uint32_t gid;
90 uint32_t file_size;
91 git_oid oid;
92 uint16_t flags;
93 uint16_t flags_extended;
94 char path[1]; /* arbitrary length */
95 };
96
97 struct entry_srch_key {
98 const char *path;
99 size_t pathlen;
100 int stage;
101 };
102
103 struct entry_internal {
104 git_index_entry entry;
105 size_t pathlen;
106 char path[GIT_FLEX_ARRAY];
107 };
108
109 struct reuc_entry_internal {
110 git_index_reuc_entry entry;
111 size_t pathlen;
112 char path[GIT_FLEX_ARRAY];
113 };
114
115 bool git_index__enforce_unsaved_safety = false;
116
117 /* local declarations */
118 static int read_extension(size_t *read_len, git_index *index, const char *buffer, size_t buffer_size);
119 static int read_header(struct index_header *dest, const void *buffer);
120
121 static int parse_index(git_index *index, const char *buffer, size_t buffer_size);
122 static bool is_index_extended(git_index *index);
123 static int write_index(git_oid *checksum, git_index *index, git_filebuf *file);
124
125 static void index_entry_free(git_index_entry *entry);
126 static void index_entry_reuc_free(git_index_reuc_entry *reuc);
127
index_map_set(git_idxmap * map,git_index_entry * e,bool ignore_case)128 GIT_INLINE(int) index_map_set(git_idxmap *map, git_index_entry *e, bool ignore_case)
129 {
130 if (ignore_case)
131 return git_idxmap_icase_set((git_idxmap_icase *) map, e, e);
132 else
133 return git_idxmap_set(map, e, e);
134 }
135
index_map_delete(git_idxmap * map,git_index_entry * e,bool ignore_case)136 GIT_INLINE(int) index_map_delete(git_idxmap *map, git_index_entry *e, bool ignore_case)
137 {
138 if (ignore_case)
139 return git_idxmap_icase_delete((git_idxmap_icase *) map, e);
140 else
141 return git_idxmap_delete(map, e);
142 }
143
index_map_resize(git_idxmap * map,size_t count,bool ignore_case)144 GIT_INLINE(int) index_map_resize(git_idxmap *map, size_t count, bool ignore_case)
145 {
146 if (ignore_case)
147 return git_idxmap_icase_resize((git_idxmap_icase *) map, count);
148 else
149 return git_idxmap_resize(map, count);
150 }
151
git_index_entry_srch(const void * key,const void * array_member)152 int git_index_entry_srch(const void *key, const void *array_member)
153 {
154 const struct entry_srch_key *srch_key = key;
155 const struct entry_internal *entry = array_member;
156 int cmp;
157 size_t len1, len2, len;
158
159 len1 = srch_key->pathlen;
160 len2 = entry->pathlen;
161 len = len1 < len2 ? len1 : len2;
162
163 cmp = memcmp(srch_key->path, entry->path, len);
164 if (cmp)
165 return cmp;
166 if (len1 < len2)
167 return -1;
168 if (len1 > len2)
169 return 1;
170
171 if (srch_key->stage != GIT_INDEX_STAGE_ANY)
172 return srch_key->stage - GIT_INDEX_ENTRY_STAGE(&entry->entry);
173
174 return 0;
175 }
176
git_index_entry_isrch(const void * key,const void * array_member)177 int git_index_entry_isrch(const void *key, const void *array_member)
178 {
179 const struct entry_srch_key *srch_key = key;
180 const struct entry_internal *entry = array_member;
181 int cmp;
182 size_t len1, len2, len;
183
184 len1 = srch_key->pathlen;
185 len2 = entry->pathlen;
186 len = len1 < len2 ? len1 : len2;
187
188 cmp = strncasecmp(srch_key->path, entry->path, len);
189
190 if (cmp)
191 return cmp;
192 if (len1 < len2)
193 return -1;
194 if (len1 > len2)
195 return 1;
196
197 if (srch_key->stage != GIT_INDEX_STAGE_ANY)
198 return srch_key->stage - GIT_INDEX_ENTRY_STAGE(&entry->entry);
199
200 return 0;
201 }
202
index_entry_srch_path(const void * path,const void * array_member)203 static int index_entry_srch_path(const void *path, const void *array_member)
204 {
205 const git_index_entry *entry = array_member;
206
207 return strcmp((const char *)path, entry->path);
208 }
209
index_entry_isrch_path(const void * path,const void * array_member)210 static int index_entry_isrch_path(const void *path, const void *array_member)
211 {
212 const git_index_entry *entry = array_member;
213
214 return strcasecmp((const char *)path, entry->path);
215 }
216
git_index_entry_cmp(const void * a,const void * b)217 int git_index_entry_cmp(const void *a, const void *b)
218 {
219 int diff;
220 const git_index_entry *entry_a = a;
221 const git_index_entry *entry_b = b;
222
223 diff = strcmp(entry_a->path, entry_b->path);
224
225 if (diff == 0)
226 diff = (GIT_INDEX_ENTRY_STAGE(entry_a) - GIT_INDEX_ENTRY_STAGE(entry_b));
227
228 return diff;
229 }
230
git_index_entry_icmp(const void * a,const void * b)231 int git_index_entry_icmp(const void *a, const void *b)
232 {
233 int diff;
234 const git_index_entry *entry_a = a;
235 const git_index_entry *entry_b = b;
236
237 diff = strcasecmp(entry_a->path, entry_b->path);
238
239 if (diff == 0)
240 diff = (GIT_INDEX_ENTRY_STAGE(entry_a) - GIT_INDEX_ENTRY_STAGE(entry_b));
241
242 return diff;
243 }
244
conflict_name_cmp(const void * a,const void * b)245 static int conflict_name_cmp(const void *a, const void *b)
246 {
247 const git_index_name_entry *name_a = a;
248 const git_index_name_entry *name_b = b;
249
250 if (name_a->ancestor && !name_b->ancestor)
251 return 1;
252
253 if (!name_a->ancestor && name_b->ancestor)
254 return -1;
255
256 if (name_a->ancestor)
257 return strcmp(name_a->ancestor, name_b->ancestor);
258
259 if (!name_a->ours || !name_b->ours)
260 return 0;
261
262 return strcmp(name_a->ours, name_b->ours);
263 }
264
265 /**
266 * TODO: enable this when resolving case insensitive conflicts
267 */
268 #if 0
269 static int conflict_name_icmp(const void *a, const void *b)
270 {
271 const git_index_name_entry *name_a = a;
272 const git_index_name_entry *name_b = b;
273
274 if (name_a->ancestor && !name_b->ancestor)
275 return 1;
276
277 if (!name_a->ancestor && name_b->ancestor)
278 return -1;
279
280 if (name_a->ancestor)
281 return strcasecmp(name_a->ancestor, name_b->ancestor);
282
283 if (!name_a->ours || !name_b->ours)
284 return 0;
285
286 return strcasecmp(name_a->ours, name_b->ours);
287 }
288 #endif
289
reuc_srch(const void * key,const void * array_member)290 static int reuc_srch(const void *key, const void *array_member)
291 {
292 const git_index_reuc_entry *reuc = array_member;
293
294 return strcmp(key, reuc->path);
295 }
296
reuc_isrch(const void * key,const void * array_member)297 static int reuc_isrch(const void *key, const void *array_member)
298 {
299 const git_index_reuc_entry *reuc = array_member;
300
301 return strcasecmp(key, reuc->path);
302 }
303
reuc_cmp(const void * a,const void * b)304 static int reuc_cmp(const void *a, const void *b)
305 {
306 const git_index_reuc_entry *info_a = a;
307 const git_index_reuc_entry *info_b = b;
308
309 return strcmp(info_a->path, info_b->path);
310 }
311
reuc_icmp(const void * a,const void * b)312 static int reuc_icmp(const void *a, const void *b)
313 {
314 const git_index_reuc_entry *info_a = a;
315 const git_index_reuc_entry *info_b = b;
316
317 return strcasecmp(info_a->path, info_b->path);
318 }
319
index_entry_reuc_free(git_index_reuc_entry * reuc)320 static void index_entry_reuc_free(git_index_reuc_entry *reuc)
321 {
322 git__free(reuc);
323 }
324
index_entry_free(git_index_entry * entry)325 static void index_entry_free(git_index_entry *entry)
326 {
327 if (!entry)
328 return;
329
330 memset(&entry->id, 0, sizeof(entry->id));
331 git__free(entry);
332 }
333
git_index__create_mode(unsigned int mode)334 unsigned int git_index__create_mode(unsigned int mode)
335 {
336 if (S_ISLNK(mode))
337 return S_IFLNK;
338
339 if (S_ISDIR(mode) || (mode & S_IFMT) == (S_IFLNK | S_IFDIR))
340 return (S_IFLNK | S_IFDIR);
341
342 return S_IFREG | GIT_PERMS_CANONICAL(mode);
343 }
344
index_merge_mode(git_index * index,git_index_entry * existing,unsigned int mode)345 static unsigned int index_merge_mode(
346 git_index *index, git_index_entry *existing, unsigned int mode)
347 {
348 if (index->no_symlinks && S_ISREG(mode) &&
349 existing && S_ISLNK(existing->mode))
350 return existing->mode;
351
352 if (index->distrust_filemode && S_ISREG(mode))
353 return (existing && S_ISREG(existing->mode)) ?
354 existing->mode : git_index__create_mode(0666);
355
356 return git_index__create_mode(mode);
357 }
358
index_find_in_entries(size_t * out,git_vector * entries,git_vector_cmp entry_srch,const char * path,size_t path_len,int stage)359 GIT_INLINE(int) index_find_in_entries(
360 size_t *out, git_vector *entries, git_vector_cmp entry_srch,
361 const char *path, size_t path_len, int stage)
362 {
363 struct entry_srch_key srch_key;
364 srch_key.path = path;
365 srch_key.pathlen = !path_len ? strlen(path) : path_len;
366 srch_key.stage = stage;
367 return git_vector_bsearch2(out, entries, entry_srch, &srch_key);
368 }
369
index_find(size_t * out,git_index * index,const char * path,size_t path_len,int stage)370 GIT_INLINE(int) index_find(
371 size_t *out, git_index *index,
372 const char *path, size_t path_len, int stage)
373 {
374 git_vector_sort(&index->entries);
375
376 return index_find_in_entries(
377 out, &index->entries, index->entries_search, path, path_len, stage);
378 }
379
git_index__set_ignore_case(git_index * index,bool ignore_case)380 void git_index__set_ignore_case(git_index *index, bool ignore_case)
381 {
382 index->ignore_case = ignore_case;
383
384 if (ignore_case) {
385 index->entries_cmp_path = git__strcasecmp_cb;
386 index->entries_search = git_index_entry_isrch;
387 index->entries_search_path = index_entry_isrch_path;
388 index->reuc_search = reuc_isrch;
389 } else {
390 index->entries_cmp_path = git__strcmp_cb;
391 index->entries_search = git_index_entry_srch;
392 index->entries_search_path = index_entry_srch_path;
393 index->reuc_search = reuc_srch;
394 }
395
396 git_vector_set_cmp(&index->entries,
397 ignore_case ? git_index_entry_icmp : git_index_entry_cmp);
398 git_vector_sort(&index->entries);
399
400 git_vector_set_cmp(&index->reuc, ignore_case ? reuc_icmp : reuc_cmp);
401 git_vector_sort(&index->reuc);
402 }
403
git_index_open(git_index ** index_out,const char * index_path)404 int git_index_open(git_index **index_out, const char *index_path)
405 {
406 git_index *index;
407 int error = -1;
408
409 assert(index_out);
410
411 index = git__calloc(1, sizeof(git_index));
412 GIT_ERROR_CHECK_ALLOC(index);
413
414 if (git_pool_init(&index->tree_pool, 1) < 0)
415 goto fail;
416
417 if (index_path != NULL) {
418 index->index_file_path = git__strdup(index_path);
419 if (!index->index_file_path)
420 goto fail;
421
422 /* Check if index file is stored on disk already */
423 if (git_path_exists(index->index_file_path) == true)
424 index->on_disk = 1;
425 }
426
427 if (git_vector_init(&index->entries, 32, git_index_entry_cmp) < 0 ||
428 git_idxmap_new(&index->entries_map) < 0 ||
429 git_vector_init(&index->names, 8, conflict_name_cmp) < 0 ||
430 git_vector_init(&index->reuc, 8, reuc_cmp) < 0 ||
431 git_vector_init(&index->deleted, 8, git_index_entry_cmp) < 0)
432 goto fail;
433
434 index->entries_cmp_path = git__strcmp_cb;
435 index->entries_search = git_index_entry_srch;
436 index->entries_search_path = index_entry_srch_path;
437 index->reuc_search = reuc_srch;
438 index->version = INDEX_VERSION_NUMBER_DEFAULT;
439
440 if (index_path != NULL && (error = git_index_read(index, true)) < 0)
441 goto fail;
442
443 *index_out = index;
444 GIT_REFCOUNT_INC(index);
445
446 return 0;
447
448 fail:
449 git_pool_clear(&index->tree_pool);
450 git_index_free(index);
451 return error;
452 }
453
git_index_new(git_index ** out)454 int git_index_new(git_index **out)
455 {
456 return git_index_open(out, NULL);
457 }
458
index_free(git_index * index)459 static void index_free(git_index *index)
460 {
461 /* index iterators increment the refcount of the index, so if we
462 * get here then there should be no outstanding iterators.
463 */
464 assert(!git_atomic_get(&index->readers));
465
466 git_index_clear(index);
467 git_idxmap_free(index->entries_map);
468 git_vector_free(&index->entries);
469 git_vector_free(&index->names);
470 git_vector_free(&index->reuc);
471 git_vector_free(&index->deleted);
472
473 git__free(index->index_file_path);
474
475 git__memzero(index, sizeof(*index));
476 git__free(index);
477 }
478
git_index_free(git_index * index)479 void git_index_free(git_index *index)
480 {
481 if (index == NULL)
482 return;
483
484 GIT_REFCOUNT_DEC(index, index_free);
485 }
486
487 /* call with locked index */
index_free_deleted(git_index * index)488 static void index_free_deleted(git_index *index)
489 {
490 int readers = (int)git_atomic_get(&index->readers);
491 size_t i;
492
493 if (readers > 0 || !index->deleted.length)
494 return;
495
496 for (i = 0; i < index->deleted.length; ++i) {
497 git_index_entry *ie = git__swap(index->deleted.contents[i], NULL);
498 index_entry_free(ie);
499 }
500
501 git_vector_clear(&index->deleted);
502 }
503
504 /* call with locked index */
index_remove_entry(git_index * index,size_t pos)505 static int index_remove_entry(git_index *index, size_t pos)
506 {
507 int error = 0;
508 git_index_entry *entry = git_vector_get(&index->entries, pos);
509
510 if (entry != NULL) {
511 git_tree_cache_invalidate_path(index->tree, entry->path);
512 index_map_delete(index->entries_map, entry, index->ignore_case);
513 }
514
515 error = git_vector_remove(&index->entries, pos);
516
517 if (!error) {
518 if (git_atomic_get(&index->readers) > 0) {
519 error = git_vector_insert(&index->deleted, entry);
520 } else {
521 index_entry_free(entry);
522 }
523
524 index->dirty = 1;
525 }
526
527 return error;
528 }
529
git_index_clear(git_index * index)530 int git_index_clear(git_index *index)
531 {
532 int error = 0;
533
534 assert(index);
535
536 index->dirty = 1;
537 index->tree = NULL;
538 git_pool_clear(&index->tree_pool);
539
540 git_idxmap_clear(index->entries_map);
541 while (!error && index->entries.length > 0)
542 error = index_remove_entry(index, index->entries.length - 1);
543
544 if (error)
545 goto done;
546
547 index_free_deleted(index);
548
549 if ((error = git_index_name_clear(index)) < 0 ||
550 (error = git_index_reuc_clear(index)) < 0)
551 goto done;
552
553 git_futils_filestamp_set(&index->stamp, NULL);
554
555 done:
556 return error;
557 }
558
create_index_error(int error,const char * msg)559 static int create_index_error(int error, const char *msg)
560 {
561 git_error_set_str(GIT_ERROR_INDEX, msg);
562 return error;
563 }
564
git_index_set_caps(git_index * index,int caps)565 int git_index_set_caps(git_index *index, int caps)
566 {
567 unsigned int old_ignore_case;
568
569 assert(index);
570
571 old_ignore_case = index->ignore_case;
572
573 if (caps == GIT_INDEX_CAPABILITY_FROM_OWNER) {
574 git_repository *repo = INDEX_OWNER(index);
575 int val;
576
577 if (!repo)
578 return create_index_error(
579 -1, "cannot access repository to set index caps");
580
581 if (!git_repository__configmap_lookup(&val, repo, GIT_CONFIGMAP_IGNORECASE))
582 index->ignore_case = (val != 0);
583 if (!git_repository__configmap_lookup(&val, repo, GIT_CONFIGMAP_FILEMODE))
584 index->distrust_filemode = (val == 0);
585 if (!git_repository__configmap_lookup(&val, repo, GIT_CONFIGMAP_SYMLINKS))
586 index->no_symlinks = (val == 0);
587 }
588 else {
589 index->ignore_case = ((caps & GIT_INDEX_CAPABILITY_IGNORE_CASE) != 0);
590 index->distrust_filemode = ((caps & GIT_INDEX_CAPABILITY_NO_FILEMODE) != 0);
591 index->no_symlinks = ((caps & GIT_INDEX_CAPABILITY_NO_SYMLINKS) != 0);
592 }
593
594 if (old_ignore_case != index->ignore_case) {
595 git_index__set_ignore_case(index, (bool)index->ignore_case);
596 }
597
598 return 0;
599 }
600
git_index_caps(const git_index * index)601 int git_index_caps(const git_index *index)
602 {
603 return ((index->ignore_case ? GIT_INDEX_CAPABILITY_IGNORE_CASE : 0) |
604 (index->distrust_filemode ? GIT_INDEX_CAPABILITY_NO_FILEMODE : 0) |
605 (index->no_symlinks ? GIT_INDEX_CAPABILITY_NO_SYMLINKS : 0));
606 }
607
git_index_checksum(git_index * index)608 const git_oid *git_index_checksum(git_index *index)
609 {
610 return &index->checksum;
611 }
612
613 /**
614 * Returns 1 for changed, 0 for not changed and <0 for errors
615 */
compare_checksum(git_index * index)616 static int compare_checksum(git_index *index)
617 {
618 int fd;
619 ssize_t bytes_read;
620 git_oid checksum = {{ 0 }};
621
622 if ((fd = p_open(index->index_file_path, O_RDONLY)) < 0)
623 return fd;
624
625 if (p_lseek(fd, -20, SEEK_END) < 0) {
626 p_close(fd);
627 git_error_set(GIT_ERROR_OS, "failed to seek to end of file");
628 return -1;
629 }
630
631 bytes_read = p_read(fd, &checksum, GIT_OID_RAWSZ);
632 p_close(fd);
633
634 if (bytes_read < 0)
635 return -1;
636
637 return !!git_oid_cmp(&checksum, &index->checksum);
638 }
639
git_index_read(git_index * index,int force)640 int git_index_read(git_index *index, int force)
641 {
642 int error = 0, updated;
643 git_buf buffer = GIT_BUF_INIT;
644 git_futils_filestamp stamp = index->stamp;
645
646 if (!index->index_file_path)
647 return create_index_error(-1,
648 "failed to read index: The index is in-memory only");
649
650 index->on_disk = git_path_exists(index->index_file_path);
651
652 if (!index->on_disk) {
653 if (force && (error = git_index_clear(index)) < 0)
654 return error;
655
656 index->dirty = 0;
657 return 0;
658 }
659
660 if ((updated = git_futils_filestamp_check(&stamp, index->index_file_path) < 0) ||
661 ((updated = compare_checksum(index)) < 0)) {
662 git_error_set(
663 GIT_ERROR_INDEX,
664 "failed to read index: '%s' no longer exists",
665 index->index_file_path);
666 return updated;
667 }
668
669 if (!updated && !force)
670 return 0;
671
672 error = git_futils_readbuffer(&buffer, index->index_file_path);
673 if (error < 0)
674 return error;
675
676 index->tree = NULL;
677 git_pool_clear(&index->tree_pool);
678
679 error = git_index_clear(index);
680
681 if (!error)
682 error = parse_index(index, buffer.ptr, buffer.size);
683
684 if (!error) {
685 git_futils_filestamp_set(&index->stamp, &stamp);
686 index->dirty = 0;
687 }
688
689 git_buf_dispose(&buffer);
690 return error;
691 }
692
git_index_read_safely(git_index * index)693 int git_index_read_safely(git_index *index)
694 {
695 if (git_index__enforce_unsaved_safety && index->dirty) {
696 git_error_set(GIT_ERROR_INDEX,
697 "the index has unsaved changes that would be overwritten by this operation");
698 return GIT_EINDEXDIRTY;
699 }
700
701 return git_index_read(index, false);
702 }
703
git_index__changed_relative_to(git_index * index,const git_oid * checksum)704 int git_index__changed_relative_to(
705 git_index *index, const git_oid *checksum)
706 {
707 /* attempt to update index (ignoring errors) */
708 if (git_index_read(index, false) < 0)
709 git_error_clear();
710
711 return !!git_oid_cmp(&index->checksum, checksum);
712 }
713
is_racy_entry(git_index * index,const git_index_entry * entry)714 static bool is_racy_entry(git_index *index, const git_index_entry *entry)
715 {
716 /* Git special-cases submodules in the check */
717 if (S_ISGITLINK(entry->mode))
718 return false;
719
720 return git_index_entry_newer_than_index(entry, index);
721 }
722
723 /*
724 * Force the next diff to take a look at those entries which have the
725 * same timestamp as the current index.
726 */
truncate_racily_clean(git_index * index)727 static int truncate_racily_clean(git_index *index)
728 {
729 size_t i;
730 int error;
731 git_index_entry *entry;
732 git_diff_options diff_opts = GIT_DIFF_OPTIONS_INIT;
733 git_diff *diff = NULL;
734 git_vector paths = GIT_VECTOR_INIT;
735 git_diff_delta *delta;
736
737 /* Nothing to do if there's no repo to talk about */
738 if (!INDEX_OWNER(index))
739 return 0;
740
741 /* If there's no workdir, we can't know where to even check */
742 if (!git_repository_workdir(INDEX_OWNER(index)))
743 return 0;
744
745 diff_opts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE | GIT_DIFF_IGNORE_SUBMODULES | GIT_DIFF_DISABLE_PATHSPEC_MATCH;
746 git_vector_foreach(&index->entries, i, entry) {
747 if ((entry->flags_extended & GIT_INDEX_ENTRY_UPTODATE) == 0 &&
748 is_racy_entry(index, entry))
749 git_vector_insert(&paths, (char *)entry->path);
750 }
751
752 if (paths.length == 0)
753 goto done;
754
755 diff_opts.pathspec.count = paths.length;
756 diff_opts.pathspec.strings = (char **)paths.contents;
757
758 if ((error = git_diff_index_to_workdir(&diff, INDEX_OWNER(index), index, &diff_opts)) < 0)
759 return error;
760
761 git_vector_foreach(&diff->deltas, i, delta) {
762 entry = (git_index_entry *)git_index_get_bypath(index, delta->old_file.path, 0);
763
764 /* Ensure that we have a stage 0 for this file (ie, it's not a
765 * conflict), otherwise smudging it is quite pointless.
766 */
767 if (entry) {
768 entry->file_size = 0;
769 index->dirty = 1;
770 }
771 }
772
773 done:
774 git_diff_free(diff);
775 git_vector_free(&paths);
776 return 0;
777 }
778
git_index_version(git_index * index)779 unsigned git_index_version(git_index *index)
780 {
781 assert(index);
782
783 return index->version;
784 }
785
git_index_set_version(git_index * index,unsigned int version)786 int git_index_set_version(git_index *index, unsigned int version)
787 {
788 assert(index);
789
790 if (version < INDEX_VERSION_NUMBER_LB ||
791 version > INDEX_VERSION_NUMBER_UB) {
792 git_error_set(GIT_ERROR_INDEX, "invalid version number");
793 return -1;
794 }
795
796 index->version = version;
797
798 return 0;
799 }
800
git_index_write(git_index * index)801 int git_index_write(git_index *index)
802 {
803 git_indexwriter writer = GIT_INDEXWRITER_INIT;
804 int error;
805
806 truncate_racily_clean(index);
807
808 if ((error = git_indexwriter_init(&writer, index)) == 0 &&
809 (error = git_indexwriter_commit(&writer)) == 0)
810 index->dirty = 0;
811
812 git_indexwriter_cleanup(&writer);
813
814 return error;
815 }
816
git_index_path(const git_index * index)817 const char * git_index_path(const git_index *index)
818 {
819 assert(index);
820 return index->index_file_path;
821 }
822
git_index_write_tree(git_oid * oid,git_index * index)823 int git_index_write_tree(git_oid *oid, git_index *index)
824 {
825 git_repository *repo;
826
827 assert(oid && index);
828
829 repo = INDEX_OWNER(index);
830
831 if (repo == NULL)
832 return create_index_error(-1, "Failed to write tree. "
833 "the index file is not backed up by an existing repository");
834
835 return git_tree__write_index(oid, index, repo);
836 }
837
git_index_write_tree_to(git_oid * oid,git_index * index,git_repository * repo)838 int git_index_write_tree_to(
839 git_oid *oid, git_index *index, git_repository *repo)
840 {
841 assert(oid && index && repo);
842 return git_tree__write_index(oid, index, repo);
843 }
844
git_index_entrycount(const git_index * index)845 size_t git_index_entrycount(const git_index *index)
846 {
847 assert(index);
848 return index->entries.length;
849 }
850
git_index_get_byindex(git_index * index,size_t n)851 const git_index_entry *git_index_get_byindex(
852 git_index *index, size_t n)
853 {
854 assert(index);
855 git_vector_sort(&index->entries);
856 return git_vector_get(&index->entries, n);
857 }
858
git_index_get_bypath(git_index * index,const char * path,int stage)859 const git_index_entry *git_index_get_bypath(
860 git_index *index, const char *path, int stage)
861 {
862 git_index_entry key = {{ 0 }};
863 git_index_entry *value;
864
865 assert(index);
866
867 key.path = path;
868 GIT_INDEX_ENTRY_STAGE_SET(&key, stage);
869
870 if (index->ignore_case)
871 value = git_idxmap_icase_get((git_idxmap_icase *) index->entries_map, &key);
872 else
873 value = git_idxmap_get(index->entries_map, &key);
874
875 if (!value) {
876 git_error_set(GIT_ERROR_INDEX, "index does not contain '%s'", path);
877 return NULL;
878 }
879
880 return value;
881 }
882
git_index_entry__init_from_stat(git_index_entry * entry,struct stat * st,bool trust_mode)883 void git_index_entry__init_from_stat(
884 git_index_entry *entry, struct stat *st, bool trust_mode)
885 {
886 entry->ctime.seconds = (int32_t)st->st_ctime;
887 entry->mtime.seconds = (int32_t)st->st_mtime;
888 #if defined(GIT_USE_NSEC)
889 entry->mtime.nanoseconds = st->st_mtime_nsec;
890 entry->ctime.nanoseconds = st->st_ctime_nsec;
891 #endif
892 entry->dev = st->st_rdev;
893 entry->ino = st->st_ino;
894 entry->mode = (!trust_mode && S_ISREG(st->st_mode)) ?
895 git_index__create_mode(0666) : git_index__create_mode(st->st_mode);
896 entry->uid = st->st_uid;
897 entry->gid = st->st_gid;
898 entry->file_size = (uint32_t)st->st_size;
899 }
900
index_entry_adjust_namemask(git_index_entry * entry,size_t path_length)901 static void index_entry_adjust_namemask(
902 git_index_entry *entry,
903 size_t path_length)
904 {
905 entry->flags &= ~GIT_INDEX_ENTRY_NAMEMASK;
906
907 if (path_length < GIT_INDEX_ENTRY_NAMEMASK)
908 entry->flags |= path_length & GIT_INDEX_ENTRY_NAMEMASK;
909 else
910 entry->flags |= GIT_INDEX_ENTRY_NAMEMASK;
911 }
912
913 /* When `from_workdir` is true, we will validate the paths to avoid placing
914 * paths that are invalid for the working directory on the current filesystem
915 * (eg, on Windows, we will disallow `GIT~1`, `AUX`, `COM1`, etc). This
916 * function will *always* prevent `.git` and directory traversal `../` from
917 * being added to the index.
918 */
index_entry_create(git_index_entry ** out,git_repository * repo,const char * path,struct stat * st,bool from_workdir)919 static int index_entry_create(
920 git_index_entry **out,
921 git_repository *repo,
922 const char *path,
923 struct stat *st,
924 bool from_workdir)
925 {
926 size_t pathlen = strlen(path), alloclen;
927 struct entry_internal *entry;
928 unsigned int path_valid_flags = GIT_PATH_REJECT_INDEX_DEFAULTS;
929 uint16_t mode = 0;
930
931 /* always reject placing `.git` in the index and directory traversal.
932 * when requested, disallow platform-specific filenames and upgrade to
933 * the platform-specific `.git` tests (eg, `git~1`, etc).
934 */
935 if (from_workdir)
936 path_valid_flags |= GIT_PATH_REJECT_WORKDIR_DEFAULTS;
937 if (st)
938 mode = st->st_mode;
939
940 if (!git_path_isvalid(repo, path, mode, path_valid_flags)) {
941 git_error_set(GIT_ERROR_INDEX, "invalid path: '%s'", path);
942 return -1;
943 }
944
945 GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, sizeof(struct entry_internal), pathlen);
946 GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
947 entry = git__calloc(1, alloclen);
948 GIT_ERROR_CHECK_ALLOC(entry);
949
950 entry->pathlen = pathlen;
951 memcpy(entry->path, path, pathlen);
952 entry->entry.path = entry->path;
953
954 *out = (git_index_entry *)entry;
955 return 0;
956 }
957
index_entry_init(git_index_entry ** entry_out,git_index * index,const char * rel_path)958 static int index_entry_init(
959 git_index_entry **entry_out,
960 git_index *index,
961 const char *rel_path)
962 {
963 int error = 0;
964 git_index_entry *entry = NULL;
965 git_buf path = GIT_BUF_INIT;
966 struct stat st;
967 git_oid oid;
968 git_repository *repo;
969
970 if (INDEX_OWNER(index) == NULL)
971 return create_index_error(-1,
972 "could not initialize index entry. "
973 "Index is not backed up by an existing repository.");
974
975 /*
976 * FIXME: this is duplicated with the work in
977 * git_blob__create_from_paths. It should accept an optional stat
978 * structure so we can pass in the one we have to do here.
979 */
980 repo = INDEX_OWNER(index);
981 if (git_repository__ensure_not_bare(repo, "create blob from file") < 0)
982 return GIT_EBAREREPO;
983
984 if (git_buf_joinpath(&path, git_repository_workdir(repo), rel_path) < 0)
985 return -1;
986
987 error = git_path_lstat(path.ptr, &st);
988 git_buf_dispose(&path);
989
990 if (error < 0)
991 return error;
992
993 if (index_entry_create(&entry, INDEX_OWNER(index), rel_path, &st, true) < 0)
994 return -1;
995
996 /* write the blob to disk and get the oid and stat info */
997 error = git_blob__create_from_paths(
998 &oid, &st, INDEX_OWNER(index), NULL, rel_path, 0, true);
999
1000 if (error < 0) {
1001 index_entry_free(entry);
1002 return error;
1003 }
1004
1005 entry->id = oid;
1006 git_index_entry__init_from_stat(entry, &st, !index->distrust_filemode);
1007
1008 *entry_out = (git_index_entry *)entry;
1009 return 0;
1010 }
1011
reuc_entry_alloc(const char * path)1012 static git_index_reuc_entry *reuc_entry_alloc(const char *path)
1013 {
1014 size_t pathlen = strlen(path),
1015 structlen = sizeof(struct reuc_entry_internal),
1016 alloclen;
1017 struct reuc_entry_internal *entry;
1018
1019 if (GIT_ADD_SIZET_OVERFLOW(&alloclen, structlen, pathlen) ||
1020 GIT_ADD_SIZET_OVERFLOW(&alloclen, alloclen, 1))
1021 return NULL;
1022
1023 entry = git__calloc(1, alloclen);
1024 if (!entry)
1025 return NULL;
1026
1027 entry->pathlen = pathlen;
1028 memcpy(entry->path, path, pathlen);
1029 entry->entry.path = entry->path;
1030
1031 return (git_index_reuc_entry *)entry;
1032 }
1033
index_entry_reuc_init(git_index_reuc_entry ** reuc_out,const char * path,int ancestor_mode,const git_oid * ancestor_oid,int our_mode,const git_oid * our_oid,int their_mode,const git_oid * their_oid)1034 static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,
1035 const char *path,
1036 int ancestor_mode, const git_oid *ancestor_oid,
1037 int our_mode, const git_oid *our_oid,
1038 int their_mode, const git_oid *their_oid)
1039 {
1040 git_index_reuc_entry *reuc = NULL;
1041
1042 assert(reuc_out && path);
1043
1044 *reuc_out = reuc = reuc_entry_alloc(path);
1045 GIT_ERROR_CHECK_ALLOC(reuc);
1046
1047 if ((reuc->mode[0] = ancestor_mode) > 0) {
1048 assert(ancestor_oid);
1049 git_oid_cpy(&reuc->oid[0], ancestor_oid);
1050 }
1051
1052 if ((reuc->mode[1] = our_mode) > 0) {
1053 assert(our_oid);
1054 git_oid_cpy(&reuc->oid[1], our_oid);
1055 }
1056
1057 if ((reuc->mode[2] = their_mode) > 0) {
1058 assert(their_oid);
1059 git_oid_cpy(&reuc->oid[2], their_oid);
1060 }
1061
1062 return 0;
1063 }
1064
index_entry_cpy(git_index_entry * tgt,const git_index_entry * src)1065 static void index_entry_cpy(
1066 git_index_entry *tgt,
1067 const git_index_entry *src)
1068 {
1069 const char *tgt_path = tgt->path;
1070 memcpy(tgt, src, sizeof(*tgt));
1071 tgt->path = tgt_path;
1072 }
1073
index_entry_dup(git_index_entry ** out,git_index * index,const git_index_entry * src)1074 static int index_entry_dup(
1075 git_index_entry **out,
1076 git_index *index,
1077 const git_index_entry *src)
1078 {
1079 if (index_entry_create(out, INDEX_OWNER(index), src->path, NULL, false) < 0)
1080 return -1;
1081
1082 index_entry_cpy(*out, src);
1083 return 0;
1084 }
1085
index_entry_cpy_nocache(git_index_entry * tgt,const git_index_entry * src)1086 static void index_entry_cpy_nocache(
1087 git_index_entry *tgt,
1088 const git_index_entry *src)
1089 {
1090 git_oid_cpy(&tgt->id, &src->id);
1091 tgt->mode = src->mode;
1092 tgt->flags = src->flags;
1093 tgt->flags_extended = (src->flags_extended & GIT_INDEX_ENTRY_EXTENDED_FLAGS);
1094 }
1095
index_entry_dup_nocache(git_index_entry ** out,git_index * index,const git_index_entry * src)1096 static int index_entry_dup_nocache(
1097 git_index_entry **out,
1098 git_index *index,
1099 const git_index_entry *src)
1100 {
1101 if (index_entry_create(out, INDEX_OWNER(index), src->path, NULL, false) < 0)
1102 return -1;
1103
1104 index_entry_cpy_nocache(*out, src);
1105 return 0;
1106 }
1107
has_file_name(git_index * index,const git_index_entry * entry,size_t pos,int ok_to_replace)1108 static int has_file_name(git_index *index,
1109 const git_index_entry *entry, size_t pos, int ok_to_replace)
1110 {
1111 size_t len = strlen(entry->path);
1112 int stage = GIT_INDEX_ENTRY_STAGE(entry);
1113 const char *name = entry->path;
1114
1115 while (pos < index->entries.length) {
1116 struct entry_internal *p = index->entries.contents[pos++];
1117
1118 if (len >= p->pathlen)
1119 break;
1120 if (memcmp(name, p->path, len))
1121 break;
1122 if (GIT_INDEX_ENTRY_STAGE(&p->entry) != stage)
1123 continue;
1124 if (p->path[len] != '/')
1125 continue;
1126 if (!ok_to_replace)
1127 return -1;
1128
1129 if (index_remove_entry(index, --pos) < 0)
1130 break;
1131 }
1132 return 0;
1133 }
1134
1135 /*
1136 * Do we have another file with a pathname that is a proper
1137 * subset of the name we're trying to add?
1138 */
has_dir_name(git_index * index,const git_index_entry * entry,int ok_to_replace)1139 static int has_dir_name(git_index *index,
1140 const git_index_entry *entry, int ok_to_replace)
1141 {
1142 int stage = GIT_INDEX_ENTRY_STAGE(entry);
1143 const char *name = entry->path;
1144 const char *slash = name + strlen(name);
1145
1146 for (;;) {
1147 size_t len, pos;
1148
1149 for (;;) {
1150 if (*--slash == '/')
1151 break;
1152 if (slash <= entry->path)
1153 return 0;
1154 }
1155 len = slash - name;
1156
1157 if (!index_find(&pos, index, name, len, stage)) {
1158 if (!ok_to_replace)
1159 return -1;
1160
1161 if (index_remove_entry(index, pos) < 0)
1162 break;
1163 continue;
1164 }
1165
1166 /*
1167 * Trivial optimization: if we find an entry that
1168 * already matches the sub-directory, then we know
1169 * we're ok, and we can exit.
1170 */
1171 for (; pos < index->entries.length; ++pos) {
1172 struct entry_internal *p = index->entries.contents[pos];
1173
1174 if (p->pathlen <= len ||
1175 p->path[len] != '/' ||
1176 memcmp(p->path, name, len))
1177 break; /* not our subdirectory */
1178
1179 if (GIT_INDEX_ENTRY_STAGE(&p->entry) == stage)
1180 return 0;
1181 }
1182 }
1183
1184 return 0;
1185 }
1186
check_file_directory_collision(git_index * index,git_index_entry * entry,size_t pos,int ok_to_replace)1187 static int check_file_directory_collision(git_index *index,
1188 git_index_entry *entry, size_t pos, int ok_to_replace)
1189 {
1190 if (has_file_name(index, entry, pos, ok_to_replace) < 0 ||
1191 has_dir_name(index, entry, ok_to_replace) < 0) {
1192 git_error_set(GIT_ERROR_INDEX,
1193 "'%s' appears as both a file and a directory", entry->path);
1194 return -1;
1195 }
1196
1197 return 0;
1198 }
1199
canonicalize_directory_path(git_index * index,git_index_entry * entry,git_index_entry * existing)1200 static int canonicalize_directory_path(
1201 git_index *index,
1202 git_index_entry *entry,
1203 git_index_entry *existing)
1204 {
1205 const git_index_entry *match, *best = NULL;
1206 char *search, *sep;
1207 size_t pos, search_len, best_len;
1208
1209 if (!index->ignore_case)
1210 return 0;
1211
1212 /* item already exists in the index, simply re-use the existing case */
1213 if (existing) {
1214 memcpy((char *)entry->path, existing->path, strlen(existing->path));
1215 return 0;
1216 }
1217
1218 /* nothing to do */
1219 if (strchr(entry->path, '/') == NULL)
1220 return 0;
1221
1222 if ((search = git__strdup(entry->path)) == NULL)
1223 return -1;
1224
1225 /* starting at the parent directory and descending to the root, find the
1226 * common parent directory.
1227 */
1228 while (!best && (sep = strrchr(search, '/'))) {
1229 sep[1] = '\0';
1230
1231 search_len = strlen(search);
1232
1233 git_vector_bsearch2(
1234 &pos, &index->entries, index->entries_search_path, search);
1235
1236 while ((match = git_vector_get(&index->entries, pos))) {
1237 if (GIT_INDEX_ENTRY_STAGE(match) != 0) {
1238 /* conflicts do not contribute to canonical paths */
1239 } else if (strncmp(search, match->path, search_len) == 0) {
1240 /* prefer an exact match to the input filename */
1241 best = match;
1242 best_len = search_len;
1243 break;
1244 } else if (strncasecmp(search, match->path, search_len) == 0) {
1245 /* continue walking, there may be a path with an exact
1246 * (case sensitive) match later in the index, but use this
1247 * as the best match until that happens.
1248 */
1249 if (!best) {
1250 best = match;
1251 best_len = search_len;
1252 }
1253 } else {
1254 break;
1255 }
1256
1257 pos++;
1258 }
1259
1260 sep[0] = '\0';
1261 }
1262
1263 if (best)
1264 memcpy((char *)entry->path, best->path, best_len);
1265
1266 git__free(search);
1267 return 0;
1268 }
1269
index_no_dups(void ** old,void * new)1270 static int index_no_dups(void **old, void *new)
1271 {
1272 const git_index_entry *entry = new;
1273 GIT_UNUSED(old);
1274 git_error_set(GIT_ERROR_INDEX, "'%s' appears multiple times at stage %d",
1275 entry->path, GIT_INDEX_ENTRY_STAGE(entry));
1276 return GIT_EEXISTS;
1277 }
1278
index_existing_and_best(git_index_entry ** existing,size_t * existing_position,git_index_entry ** best,git_index * index,const git_index_entry * entry)1279 static void index_existing_and_best(
1280 git_index_entry **existing,
1281 size_t *existing_position,
1282 git_index_entry **best,
1283 git_index *index,
1284 const git_index_entry *entry)
1285 {
1286 git_index_entry *e;
1287 size_t pos;
1288 int error;
1289
1290 error = index_find(&pos,
1291 index, entry->path, 0, GIT_INDEX_ENTRY_STAGE(entry));
1292
1293 if (error == 0) {
1294 *existing = index->entries.contents[pos];
1295 *existing_position = pos;
1296 *best = index->entries.contents[pos];
1297 return;
1298 }
1299
1300 *existing = NULL;
1301 *existing_position = 0;
1302 *best = NULL;
1303
1304 if (GIT_INDEX_ENTRY_STAGE(entry) == 0) {
1305 for (; pos < index->entries.length; pos++) {
1306 int (*strcomp)(const char *a, const char *b) =
1307 index->ignore_case ? git__strcasecmp : git__strcmp;
1308
1309 e = index->entries.contents[pos];
1310
1311 if (strcomp(entry->path, e->path) != 0)
1312 break;
1313
1314 if (GIT_INDEX_ENTRY_STAGE(e) == GIT_INDEX_STAGE_ANCESTOR) {
1315 *best = e;
1316 continue;
1317 } else {
1318 *best = e;
1319 break;
1320 }
1321 }
1322 }
1323 }
1324
1325 /* index_insert takes ownership of the new entry - if it can't insert
1326 * it, then it will return an error **and also free the entry**. When
1327 * it replaces an existing entry, it will update the entry_ptr with the
1328 * actual entry in the index (and free the passed in one).
1329 *
1330 * trust_path is whether we use the given path, or whether (on case
1331 * insensitive systems only) we try to canonicalize the given path to
1332 * be within an existing directory.
1333 *
1334 * trust_mode is whether we trust the mode in entry_ptr.
1335 *
1336 * trust_id is whether we trust the id or it should be validated.
1337 */
index_insert(git_index * index,git_index_entry ** entry_ptr,int replace,bool trust_path,bool trust_mode,bool trust_id)1338 static int index_insert(
1339 git_index *index,
1340 git_index_entry **entry_ptr,
1341 int replace,
1342 bool trust_path,
1343 bool trust_mode,
1344 bool trust_id)
1345 {
1346 git_index_entry *existing, *best, *entry;
1347 size_t path_length, position;
1348 int error;
1349
1350 assert(index && entry_ptr);
1351
1352 entry = *entry_ptr;
1353
1354 /* Make sure that the path length flag is correct */
1355 path_length = ((struct entry_internal *)entry)->pathlen;
1356 index_entry_adjust_namemask(entry, path_length);
1357
1358 /* This entry is now up-to-date and should not be checked for raciness */
1359 entry->flags_extended |= GIT_INDEX_ENTRY_UPTODATE;
1360
1361 git_vector_sort(&index->entries);
1362
1363 /*
1364 * Look if an entry with this path already exists, either staged, or (if
1365 * this entry is a regular staged item) as the "ours" side of a conflict.
1366 */
1367 index_existing_and_best(&existing, &position, &best, index, entry);
1368
1369 /* Update the file mode */
1370 entry->mode = trust_mode ?
1371 git_index__create_mode(entry->mode) :
1372 index_merge_mode(index, best, entry->mode);
1373
1374 /* Canonicalize the directory name */
1375 if (!trust_path && (error = canonicalize_directory_path(index, entry, best)) < 0)
1376 goto out;
1377
1378 /* Ensure that the given id exists (unless it's a submodule) */
1379 if (!trust_id && INDEX_OWNER(index) &&
1380 (entry->mode & GIT_FILEMODE_COMMIT) != GIT_FILEMODE_COMMIT) {
1381
1382 if (!git_object__is_valid(INDEX_OWNER(index), &entry->id,
1383 git_object__type_from_filemode(entry->mode))) {
1384 error = -1;
1385 goto out;
1386 }
1387 }
1388
1389 /* Look for tree / blob name collisions, removing conflicts if requested */
1390 if ((error = check_file_directory_collision(index, entry, position, replace)) < 0)
1391 goto out;
1392
1393 /*
1394 * If we are replacing an existing item, overwrite the existing entry
1395 * and return it in place of the passed in one.
1396 */
1397 if (existing) {
1398 if (replace) {
1399 index_entry_cpy(existing, entry);
1400
1401 if (trust_path)
1402 memcpy((char *)existing->path, entry->path, strlen(entry->path));
1403 }
1404
1405 index_entry_free(entry);
1406 *entry_ptr = existing;
1407 } else {
1408 /*
1409 * If replace is not requested or no existing entry exists, insert
1410 * at the sorted position. (Since we re-sort after each insert to
1411 * check for dups, this is actually cheaper in the long run.)
1412 */
1413 if ((error = git_vector_insert_sorted(&index->entries, entry, index_no_dups)) < 0 ||
1414 (error = index_map_set(index->entries_map, entry, index->ignore_case)) < 0)
1415 goto out;
1416 }
1417
1418 index->dirty = 1;
1419
1420 out:
1421 if (error < 0) {
1422 index_entry_free(*entry_ptr);
1423 *entry_ptr = NULL;
1424 }
1425
1426 return error;
1427 }
1428
index_conflict_to_reuc(git_index * index,const char * path)1429 static int index_conflict_to_reuc(git_index *index, const char *path)
1430 {
1431 const git_index_entry *conflict_entries[3];
1432 int ancestor_mode, our_mode, their_mode;
1433 git_oid const *ancestor_oid, *our_oid, *their_oid;
1434 int ret;
1435
1436 if ((ret = git_index_conflict_get(&conflict_entries[0],
1437 &conflict_entries[1], &conflict_entries[2], index, path)) < 0)
1438 return ret;
1439
1440 ancestor_mode = conflict_entries[0] == NULL ? 0 : conflict_entries[0]->mode;
1441 our_mode = conflict_entries[1] == NULL ? 0 : conflict_entries[1]->mode;
1442 their_mode = conflict_entries[2] == NULL ? 0 : conflict_entries[2]->mode;
1443
1444 ancestor_oid = conflict_entries[0] == NULL ? NULL : &conflict_entries[0]->id;
1445 our_oid = conflict_entries[1] == NULL ? NULL : &conflict_entries[1]->id;
1446 their_oid = conflict_entries[2] == NULL ? NULL : &conflict_entries[2]->id;
1447
1448 if ((ret = git_index_reuc_add(index, path, ancestor_mode, ancestor_oid,
1449 our_mode, our_oid, their_mode, their_oid)) >= 0)
1450 ret = git_index_conflict_remove(index, path);
1451
1452 return ret;
1453 }
1454
is_file_or_link(const int filemode)1455 GIT_INLINE(bool) is_file_or_link(const int filemode)
1456 {
1457 return (filemode == GIT_FILEMODE_BLOB ||
1458 filemode == GIT_FILEMODE_BLOB_EXECUTABLE ||
1459 filemode == GIT_FILEMODE_LINK);
1460 }
1461
valid_filemode(const int filemode)1462 GIT_INLINE(bool) valid_filemode(const int filemode)
1463 {
1464 return (is_file_or_link(filemode) || filemode == GIT_FILEMODE_COMMIT);
1465 }
1466
git_index_add_from_buffer(git_index * index,const git_index_entry * source_entry,const void * buffer,size_t len)1467 int git_index_add_from_buffer(
1468 git_index *index, const git_index_entry *source_entry,
1469 const void *buffer, size_t len)
1470 {
1471 git_index_entry *entry = NULL;
1472 int error = 0;
1473 git_oid id;
1474
1475 assert(index && source_entry->path);
1476
1477 if (INDEX_OWNER(index) == NULL)
1478 return create_index_error(-1,
1479 "could not initialize index entry. "
1480 "Index is not backed up by an existing repository.");
1481
1482 if (!is_file_or_link(source_entry->mode)) {
1483 git_error_set(GIT_ERROR_INDEX, "invalid filemode");
1484 return -1;
1485 }
1486
1487 if (len > UINT32_MAX) {
1488 git_error_set(GIT_ERROR_INDEX, "buffer is too large");
1489 return -1;
1490 }
1491
1492 if (index_entry_dup(&entry, index, source_entry) < 0)
1493 return -1;
1494
1495 error = git_blob_create_from_buffer(&id, INDEX_OWNER(index), buffer, len);
1496 if (error < 0) {
1497 index_entry_free(entry);
1498 return error;
1499 }
1500
1501 git_oid_cpy(&entry->id, &id);
1502 entry->file_size = (uint32_t)len;
1503
1504 if ((error = index_insert(index, &entry, 1, true, true, true)) < 0)
1505 return error;
1506
1507 /* Adding implies conflict was resolved, move conflict entries to REUC */
1508 if ((error = index_conflict_to_reuc(index, entry->path)) < 0 && error != GIT_ENOTFOUND)
1509 return error;
1510
1511 git_tree_cache_invalidate_path(index->tree, entry->path);
1512 return 0;
1513 }
1514
add_repo_as_submodule(git_index_entry ** out,git_index * index,const char * path)1515 static int add_repo_as_submodule(git_index_entry **out, git_index *index, const char *path)
1516 {
1517 git_repository *sub;
1518 git_buf abspath = GIT_BUF_INIT;
1519 git_repository *repo = INDEX_OWNER(index);
1520 git_reference *head;
1521 git_index_entry *entry;
1522 struct stat st;
1523 int error;
1524
1525 if ((error = git_buf_joinpath(&abspath, git_repository_workdir(repo), path)) < 0)
1526 return error;
1527
1528 if ((error = p_stat(abspath.ptr, &st)) < 0) {
1529 git_error_set(GIT_ERROR_OS, "failed to stat repository dir");
1530 return -1;
1531 }
1532
1533 if (index_entry_create(&entry, INDEX_OWNER(index), path, &st, true) < 0)
1534 return -1;
1535
1536 git_index_entry__init_from_stat(entry, &st, !index->distrust_filemode);
1537
1538 if ((error = git_repository_open(&sub, abspath.ptr)) < 0)
1539 return error;
1540
1541 if ((error = git_repository_head(&head, sub)) < 0)
1542 return error;
1543
1544 git_oid_cpy(&entry->id, git_reference_target(head));
1545 entry->mode = GIT_FILEMODE_COMMIT;
1546
1547 git_reference_free(head);
1548 git_repository_free(sub);
1549 git_buf_dispose(&abspath);
1550
1551 *out = entry;
1552 return 0;
1553 }
1554
git_index_add_bypath(git_index * index,const char * path)1555 int git_index_add_bypath(git_index *index, const char *path)
1556 {
1557 git_index_entry *entry = NULL;
1558 int ret;
1559
1560 assert(index && path);
1561
1562 if ((ret = index_entry_init(&entry, index, path)) == 0)
1563 ret = index_insert(index, &entry, 1, false, false, true);
1564
1565 /* If we were given a directory, let's see if it's a submodule */
1566 if (ret < 0 && ret != GIT_EDIRECTORY)
1567 return ret;
1568
1569 if (ret == GIT_EDIRECTORY) {
1570 git_submodule *sm;
1571 git_error_state err;
1572
1573 git_error_state_capture(&err, ret);
1574
1575 ret = git_submodule_lookup(&sm, INDEX_OWNER(index), path);
1576 if (ret == GIT_ENOTFOUND)
1577 return git_error_state_restore(&err);
1578
1579 git_error_state_free(&err);
1580
1581 /*
1582 * EEXISTS means that there is a repository at that path, but it's not known
1583 * as a submodule. We add its HEAD as an entry and don't register it.
1584 */
1585 if (ret == GIT_EEXISTS) {
1586 if ((ret = add_repo_as_submodule(&entry, index, path)) < 0)
1587 return ret;
1588
1589 if ((ret = index_insert(index, &entry, 1, false, false, true)) < 0)
1590 return ret;
1591 } else if (ret < 0) {
1592 return ret;
1593 } else {
1594 ret = git_submodule_add_to_index(sm, false);
1595 git_submodule_free(sm);
1596 return ret;
1597 }
1598 }
1599
1600 /* Adding implies conflict was resolved, move conflict entries to REUC */
1601 if ((ret = index_conflict_to_reuc(index, path)) < 0 && ret != GIT_ENOTFOUND)
1602 return ret;
1603
1604 git_tree_cache_invalidate_path(index->tree, entry->path);
1605 return 0;
1606 }
1607
git_index_remove_bypath(git_index * index,const char * path)1608 int git_index_remove_bypath(git_index *index, const char *path)
1609 {
1610 int ret;
1611
1612 assert(index && path);
1613
1614 if (((ret = git_index_remove(index, path, 0)) < 0 &&
1615 ret != GIT_ENOTFOUND) ||
1616 ((ret = index_conflict_to_reuc(index, path)) < 0 &&
1617 ret != GIT_ENOTFOUND))
1618 return ret;
1619
1620 if (ret == GIT_ENOTFOUND)
1621 git_error_clear();
1622
1623 return 0;
1624 }
1625
git_index__fill(git_index * index,const git_vector * source_entries)1626 int git_index__fill(git_index *index, const git_vector *source_entries)
1627 {
1628 const git_index_entry *source_entry = NULL;
1629 int error = 0;
1630 size_t i;
1631
1632 assert(index);
1633
1634 if (!source_entries->length)
1635 return 0;
1636
1637 if (git_vector_size_hint(&index->entries, source_entries->length) < 0 ||
1638 index_map_resize(index->entries_map, (size_t)(source_entries->length * 1.3),
1639 index->ignore_case) < 0)
1640 return -1;
1641
1642 git_vector_foreach(source_entries, i, source_entry) {
1643 git_index_entry *entry = NULL;
1644
1645 if ((error = index_entry_dup(&entry, index, source_entry)) < 0)
1646 break;
1647
1648 index_entry_adjust_namemask(entry, ((struct entry_internal *)entry)->pathlen);
1649 entry->flags_extended |= GIT_INDEX_ENTRY_UPTODATE;
1650 entry->mode = git_index__create_mode(entry->mode);
1651
1652 if ((error = git_vector_insert(&index->entries, entry)) < 0)
1653 break;
1654
1655 if ((error = index_map_set(index->entries_map, entry, index->ignore_case)) < 0)
1656 break;
1657
1658 index->dirty = 1;
1659 }
1660
1661 if (!error)
1662 git_vector_sort(&index->entries);
1663
1664 return error;
1665 }
1666
1667
git_index_add(git_index * index,const git_index_entry * source_entry)1668 int git_index_add(git_index *index, const git_index_entry *source_entry)
1669 {
1670 git_index_entry *entry = NULL;
1671 int ret;
1672
1673 assert(index && source_entry && source_entry->path);
1674
1675 if (!valid_filemode(source_entry->mode)) {
1676 git_error_set(GIT_ERROR_INDEX, "invalid entry mode");
1677 return -1;
1678 }
1679
1680 if ((ret = index_entry_dup(&entry, index, source_entry)) < 0 ||
1681 (ret = index_insert(index, &entry, 1, true, true, false)) < 0)
1682 return ret;
1683
1684 git_tree_cache_invalidate_path(index->tree, entry->path);
1685 return 0;
1686 }
1687
git_index_remove(git_index * index,const char * path,int stage)1688 int git_index_remove(git_index *index, const char *path, int stage)
1689 {
1690 int error;
1691 size_t position;
1692 git_index_entry remove_key = {{ 0 }};
1693
1694 remove_key.path = path;
1695 GIT_INDEX_ENTRY_STAGE_SET(&remove_key, stage);
1696
1697 index_map_delete(index->entries_map, &remove_key, index->ignore_case);
1698
1699 if (index_find(&position, index, path, 0, stage) < 0) {
1700 git_error_set(
1701 GIT_ERROR_INDEX, "index does not contain %s at stage %d", path, stage);
1702 error = GIT_ENOTFOUND;
1703 } else {
1704 error = index_remove_entry(index, position);
1705 }
1706
1707 return error;
1708 }
1709
git_index_remove_directory(git_index * index,const char * dir,int stage)1710 int git_index_remove_directory(git_index *index, const char *dir, int stage)
1711 {
1712 git_buf pfx = GIT_BUF_INIT;
1713 int error = 0;
1714 size_t pos;
1715 git_index_entry *entry;
1716
1717 if (!(error = git_buf_sets(&pfx, dir)) &&
1718 !(error = git_path_to_dir(&pfx)))
1719 index_find(&pos, index, pfx.ptr, pfx.size, GIT_INDEX_STAGE_ANY);
1720
1721 while (!error) {
1722 entry = git_vector_get(&index->entries, pos);
1723 if (!entry || git__prefixcmp(entry->path, pfx.ptr) != 0)
1724 break;
1725
1726 if (GIT_INDEX_ENTRY_STAGE(entry) != stage) {
1727 ++pos;
1728 continue;
1729 }
1730
1731 error = index_remove_entry(index, pos);
1732
1733 /* removed entry at 'pos' so we don't need to increment */
1734 }
1735
1736 git_buf_dispose(&pfx);
1737
1738 return error;
1739 }
1740
git_index_find_prefix(size_t * at_pos,git_index * index,const char * prefix)1741 int git_index_find_prefix(size_t *at_pos, git_index *index, const char *prefix)
1742 {
1743 int error = 0;
1744 size_t pos;
1745 const git_index_entry *entry;
1746
1747 index_find(&pos, index, prefix, strlen(prefix), GIT_INDEX_STAGE_ANY);
1748 entry = git_vector_get(&index->entries, pos);
1749 if (!entry || git__prefixcmp(entry->path, prefix) != 0)
1750 error = GIT_ENOTFOUND;
1751
1752 if (!error && at_pos)
1753 *at_pos = pos;
1754
1755 return error;
1756 }
1757
git_index__find_pos(size_t * out,git_index * index,const char * path,size_t path_len,int stage)1758 int git_index__find_pos(
1759 size_t *out, git_index *index, const char *path, size_t path_len, int stage)
1760 {
1761 assert(index && path);
1762 return index_find(out, index, path, path_len, stage);
1763 }
1764
git_index_find(size_t * at_pos,git_index * index,const char * path)1765 int git_index_find(size_t *at_pos, git_index *index, const char *path)
1766 {
1767 size_t pos;
1768
1769 assert(index && path);
1770
1771 if (git_vector_bsearch2(
1772 &pos, &index->entries, index->entries_search_path, path) < 0) {
1773 git_error_set(GIT_ERROR_INDEX, "index does not contain %s", path);
1774 return GIT_ENOTFOUND;
1775 }
1776
1777 /* Since our binary search only looked at path, we may be in the
1778 * middle of a list of stages.
1779 */
1780 for (; pos > 0; --pos) {
1781 const git_index_entry *prev = git_vector_get(&index->entries, pos - 1);
1782
1783 if (index->entries_cmp_path(prev->path, path) != 0)
1784 break;
1785 }
1786
1787 if (at_pos)
1788 *at_pos = pos;
1789
1790 return 0;
1791 }
1792
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)1793 int git_index_conflict_add(git_index *index,
1794 const git_index_entry *ancestor_entry,
1795 const git_index_entry *our_entry,
1796 const git_index_entry *their_entry)
1797 {
1798 git_index_entry *entries[3] = { 0 };
1799 unsigned short i;
1800 int ret = 0;
1801
1802 assert (index);
1803
1804 if ((ancestor_entry &&
1805 (ret = index_entry_dup(&entries[0], index, ancestor_entry)) < 0) ||
1806 (our_entry &&
1807 (ret = index_entry_dup(&entries[1], index, our_entry)) < 0) ||
1808 (their_entry &&
1809 (ret = index_entry_dup(&entries[2], index, their_entry)) < 0))
1810 goto on_error;
1811
1812 /* Validate entries */
1813 for (i = 0; i < 3; i++) {
1814 if (entries[i] && !valid_filemode(entries[i]->mode)) {
1815 git_error_set(GIT_ERROR_INDEX, "invalid filemode for stage %d entry",
1816 i + 1);
1817 ret = -1;
1818 goto on_error;
1819 }
1820 }
1821
1822 /* Remove existing index entries for each path */
1823 for (i = 0; i < 3; i++) {
1824 if (entries[i] == NULL)
1825 continue;
1826
1827 if ((ret = git_index_remove(index, entries[i]->path, 0)) != 0) {
1828 if (ret != GIT_ENOTFOUND)
1829 goto on_error;
1830
1831 git_error_clear();
1832 ret = 0;
1833 }
1834 }
1835
1836 /* Add the conflict entries */
1837 for (i = 0; i < 3; i++) {
1838 if (entries[i] == NULL)
1839 continue;
1840
1841 /* Make sure stage is correct */
1842 GIT_INDEX_ENTRY_STAGE_SET(entries[i], i + 1);
1843
1844 if ((ret = index_insert(index, &entries[i], 1, true, true, false)) < 0)
1845 goto on_error;
1846
1847 entries[i] = NULL; /* don't free if later entry fails */
1848 }
1849
1850 return 0;
1851
1852 on_error:
1853 for (i = 0; i < 3; i++) {
1854 if (entries[i] != NULL)
1855 index_entry_free(entries[i]);
1856 }
1857
1858 return ret;
1859 }
1860
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)1861 static int index_conflict__get_byindex(
1862 const git_index_entry **ancestor_out,
1863 const git_index_entry **our_out,
1864 const git_index_entry **their_out,
1865 git_index *index,
1866 size_t n)
1867 {
1868 const git_index_entry *conflict_entry;
1869 const char *path = NULL;
1870 size_t count;
1871 int stage, len = 0;
1872
1873 assert(ancestor_out && our_out && their_out && index);
1874
1875 *ancestor_out = NULL;
1876 *our_out = NULL;
1877 *their_out = NULL;
1878
1879 for (count = git_index_entrycount(index); n < count; ++n) {
1880 conflict_entry = git_vector_get(&index->entries, n);
1881
1882 if (path && index->entries_cmp_path(conflict_entry->path, path) != 0)
1883 break;
1884
1885 stage = GIT_INDEX_ENTRY_STAGE(conflict_entry);
1886 path = conflict_entry->path;
1887
1888 switch (stage) {
1889 case 3:
1890 *their_out = conflict_entry;
1891 len++;
1892 break;
1893 case 2:
1894 *our_out = conflict_entry;
1895 len++;
1896 break;
1897 case 1:
1898 *ancestor_out = conflict_entry;
1899 len++;
1900 break;
1901 default:
1902 break;
1903 };
1904 }
1905
1906 return len;
1907 }
1908
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)1909 int git_index_conflict_get(
1910 const git_index_entry **ancestor_out,
1911 const git_index_entry **our_out,
1912 const git_index_entry **their_out,
1913 git_index *index,
1914 const char *path)
1915 {
1916 size_t pos;
1917 int len = 0;
1918
1919 assert(ancestor_out && our_out && their_out && index && path);
1920
1921 *ancestor_out = NULL;
1922 *our_out = NULL;
1923 *their_out = NULL;
1924
1925 if (git_index_find(&pos, index, path) < 0)
1926 return GIT_ENOTFOUND;
1927
1928 if ((len = index_conflict__get_byindex(
1929 ancestor_out, our_out, their_out, index, pos)) < 0)
1930 return len;
1931 else if (len == 0)
1932 return GIT_ENOTFOUND;
1933
1934 return 0;
1935 }
1936
index_conflict_remove(git_index * index,const char * path)1937 static int index_conflict_remove(git_index *index, const char *path)
1938 {
1939 size_t pos = 0;
1940 git_index_entry *conflict_entry;
1941 int error = 0;
1942
1943 if (path != NULL && git_index_find(&pos, index, path) < 0)
1944 return GIT_ENOTFOUND;
1945
1946 while ((conflict_entry = git_vector_get(&index->entries, pos)) != NULL) {
1947
1948 if (path != NULL &&
1949 index->entries_cmp_path(conflict_entry->path, path) != 0)
1950 break;
1951
1952 if (GIT_INDEX_ENTRY_STAGE(conflict_entry) == 0) {
1953 pos++;
1954 continue;
1955 }
1956
1957 if ((error = index_remove_entry(index, pos)) < 0)
1958 break;
1959 }
1960
1961 return error;
1962 }
1963
git_index_conflict_remove(git_index * index,const char * path)1964 int git_index_conflict_remove(git_index *index, const char *path)
1965 {
1966 assert(index && path);
1967 return index_conflict_remove(index, path);
1968 }
1969
git_index_conflict_cleanup(git_index * index)1970 int git_index_conflict_cleanup(git_index *index)
1971 {
1972 assert(index);
1973 return index_conflict_remove(index, NULL);
1974 }
1975
git_index_has_conflicts(const git_index * index)1976 int git_index_has_conflicts(const git_index *index)
1977 {
1978 size_t i;
1979 git_index_entry *entry;
1980
1981 assert(index);
1982
1983 git_vector_foreach(&index->entries, i, entry) {
1984 if (GIT_INDEX_ENTRY_STAGE(entry) > 0)
1985 return 1;
1986 }
1987
1988 return 0;
1989 }
1990
git_index_iterator_new(git_index_iterator ** iterator_out,git_index * index)1991 int git_index_iterator_new(
1992 git_index_iterator **iterator_out,
1993 git_index *index)
1994 {
1995 git_index_iterator *it;
1996 int error;
1997
1998 assert(iterator_out && index);
1999
2000 it = git__calloc(1, sizeof(git_index_iterator));
2001 GIT_ERROR_CHECK_ALLOC(it);
2002
2003 if ((error = git_index_snapshot_new(&it->snap, index)) < 0) {
2004 git__free(it);
2005 return error;
2006 }
2007
2008 it->index = index;
2009
2010 *iterator_out = it;
2011 return 0;
2012 }
2013
git_index_iterator_next(const git_index_entry ** out,git_index_iterator * it)2014 int git_index_iterator_next(
2015 const git_index_entry **out,
2016 git_index_iterator *it)
2017 {
2018 assert(out && it);
2019
2020 if (it->cur >= git_vector_length(&it->snap))
2021 return GIT_ITEROVER;
2022
2023 *out = (git_index_entry *)git_vector_get(&it->snap, it->cur++);
2024 return 0;
2025 }
2026
git_index_iterator_free(git_index_iterator * it)2027 void git_index_iterator_free(git_index_iterator *it)
2028 {
2029 if (it == NULL)
2030 return;
2031
2032 git_index_snapshot_release(&it->snap, it->index);
2033 git__free(it);
2034 }
2035
git_index_conflict_iterator_new(git_index_conflict_iterator ** iterator_out,git_index * index)2036 int git_index_conflict_iterator_new(
2037 git_index_conflict_iterator **iterator_out,
2038 git_index *index)
2039 {
2040 git_index_conflict_iterator *it = NULL;
2041
2042 assert(iterator_out && index);
2043
2044 it = git__calloc(1, sizeof(git_index_conflict_iterator));
2045 GIT_ERROR_CHECK_ALLOC(it);
2046
2047 it->index = index;
2048
2049 *iterator_out = it;
2050 return 0;
2051 }
2052
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)2053 int git_index_conflict_next(
2054 const git_index_entry **ancestor_out,
2055 const git_index_entry **our_out,
2056 const git_index_entry **their_out,
2057 git_index_conflict_iterator *iterator)
2058 {
2059 const git_index_entry *entry;
2060 int len;
2061
2062 assert(ancestor_out && our_out && their_out && iterator);
2063
2064 *ancestor_out = NULL;
2065 *our_out = NULL;
2066 *their_out = NULL;
2067
2068 while (iterator->cur < iterator->index->entries.length) {
2069 entry = git_index_get_byindex(iterator->index, iterator->cur);
2070
2071 if (git_index_entry_is_conflict(entry)) {
2072 if ((len = index_conflict__get_byindex(
2073 ancestor_out,
2074 our_out,
2075 their_out,
2076 iterator->index,
2077 iterator->cur)) < 0)
2078 return len;
2079
2080 iterator->cur += len;
2081 return 0;
2082 }
2083
2084 iterator->cur++;
2085 }
2086
2087 return GIT_ITEROVER;
2088 }
2089
git_index_conflict_iterator_free(git_index_conflict_iterator * iterator)2090 void git_index_conflict_iterator_free(git_index_conflict_iterator *iterator)
2091 {
2092 if (iterator == NULL)
2093 return;
2094
2095 git__free(iterator);
2096 }
2097
git_index_name_entrycount(git_index * index)2098 size_t git_index_name_entrycount(git_index *index)
2099 {
2100 assert(index);
2101 return index->names.length;
2102 }
2103
git_index_name_get_byindex(git_index * index,size_t n)2104 const git_index_name_entry *git_index_name_get_byindex(
2105 git_index *index, size_t n)
2106 {
2107 assert(index);
2108
2109 git_vector_sort(&index->names);
2110 return git_vector_get(&index->names, n);
2111 }
2112
index_name_entry_free(git_index_name_entry * ne)2113 static void index_name_entry_free(git_index_name_entry *ne)
2114 {
2115 if (!ne)
2116 return;
2117 git__free(ne->ancestor);
2118 git__free(ne->ours);
2119 git__free(ne->theirs);
2120 git__free(ne);
2121 }
2122
git_index_name_add(git_index * index,const char * ancestor,const char * ours,const char * theirs)2123 int git_index_name_add(git_index *index,
2124 const char *ancestor, const char *ours, const char *theirs)
2125 {
2126 git_index_name_entry *conflict_name;
2127
2128 assert((ancestor && ours) || (ancestor && theirs) || (ours && theirs));
2129
2130 conflict_name = git__calloc(1, sizeof(git_index_name_entry));
2131 GIT_ERROR_CHECK_ALLOC(conflict_name);
2132
2133 if ((ancestor && !(conflict_name->ancestor = git__strdup(ancestor))) ||
2134 (ours && !(conflict_name->ours = git__strdup(ours))) ||
2135 (theirs && !(conflict_name->theirs = git__strdup(theirs))) ||
2136 git_vector_insert(&index->names, conflict_name) < 0)
2137 {
2138 index_name_entry_free(conflict_name);
2139 return -1;
2140 }
2141
2142 index->dirty = 1;
2143 return 0;
2144 }
2145
git_index_name_clear(git_index * index)2146 int git_index_name_clear(git_index *index)
2147 {
2148 size_t i;
2149 git_index_name_entry *conflict_name;
2150
2151 assert(index);
2152
2153 git_vector_foreach(&index->names, i, conflict_name)
2154 index_name_entry_free(conflict_name);
2155
2156 git_vector_clear(&index->names);
2157
2158 index->dirty = 1;
2159
2160 return 0;
2161 }
2162
git_index_reuc_entrycount(git_index * index)2163 size_t git_index_reuc_entrycount(git_index *index)
2164 {
2165 assert(index);
2166 return index->reuc.length;
2167 }
2168
index_reuc_on_dup(void ** old,void * new)2169 static int index_reuc_on_dup(void **old, void *new)
2170 {
2171 index_entry_reuc_free(*old);
2172 *old = new;
2173 return GIT_EEXISTS;
2174 }
2175
index_reuc_insert(git_index * index,git_index_reuc_entry * reuc)2176 static int index_reuc_insert(
2177 git_index *index,
2178 git_index_reuc_entry *reuc)
2179 {
2180 int res;
2181
2182 assert(index && reuc && reuc->path != NULL);
2183 assert(git_vector_is_sorted(&index->reuc));
2184
2185 res = git_vector_insert_sorted(&index->reuc, reuc, &index_reuc_on_dup);
2186 index->dirty = 1;
2187
2188 return res == GIT_EEXISTS ? 0 : res;
2189 }
2190
git_index_reuc_add(git_index * index,const char * path,int ancestor_mode,const git_oid * ancestor_oid,int our_mode,const git_oid * our_oid,int their_mode,const git_oid * their_oid)2191 int git_index_reuc_add(git_index *index, const char *path,
2192 int ancestor_mode, const git_oid *ancestor_oid,
2193 int our_mode, const git_oid *our_oid,
2194 int their_mode, const git_oid *their_oid)
2195 {
2196 git_index_reuc_entry *reuc = NULL;
2197 int error = 0;
2198
2199 assert(index && path);
2200
2201 if ((error = index_entry_reuc_init(&reuc, path, ancestor_mode,
2202 ancestor_oid, our_mode, our_oid, their_mode, their_oid)) < 0 ||
2203 (error = index_reuc_insert(index, reuc)) < 0)
2204 index_entry_reuc_free(reuc);
2205
2206 return error;
2207 }
2208
git_index_reuc_find(size_t * at_pos,git_index * index,const char * path)2209 int git_index_reuc_find(size_t *at_pos, git_index *index, const char *path)
2210 {
2211 return git_vector_bsearch2(at_pos, &index->reuc, index->reuc_search, path);
2212 }
2213
git_index_reuc_get_bypath(git_index * index,const char * path)2214 const git_index_reuc_entry *git_index_reuc_get_bypath(
2215 git_index *index, const char *path)
2216 {
2217 size_t pos;
2218 assert(index && path);
2219
2220 if (!index->reuc.length)
2221 return NULL;
2222
2223 assert(git_vector_is_sorted(&index->reuc));
2224
2225 if (git_index_reuc_find(&pos, index, path) < 0)
2226 return NULL;
2227
2228 return git_vector_get(&index->reuc, pos);
2229 }
2230
git_index_reuc_get_byindex(git_index * index,size_t n)2231 const git_index_reuc_entry *git_index_reuc_get_byindex(
2232 git_index *index, size_t n)
2233 {
2234 assert(index);
2235 assert(git_vector_is_sorted(&index->reuc));
2236
2237 return git_vector_get(&index->reuc, n);
2238 }
2239
git_index_reuc_remove(git_index * index,size_t position)2240 int git_index_reuc_remove(git_index *index, size_t position)
2241 {
2242 int error;
2243 git_index_reuc_entry *reuc;
2244
2245 assert(git_vector_is_sorted(&index->reuc));
2246
2247 reuc = git_vector_get(&index->reuc, position);
2248 error = git_vector_remove(&index->reuc, position);
2249
2250 if (!error)
2251 index_entry_reuc_free(reuc);
2252
2253 index->dirty = 1;
2254 return error;
2255 }
2256
git_index_reuc_clear(git_index * index)2257 int git_index_reuc_clear(git_index *index)
2258 {
2259 size_t i;
2260
2261 assert(index);
2262
2263 for (i = 0; i < index->reuc.length; ++i)
2264 index_entry_reuc_free(git__swap(index->reuc.contents[i], NULL));
2265
2266 git_vector_clear(&index->reuc);
2267
2268 index->dirty = 1;
2269
2270 return 0;
2271 }
2272
index_error_invalid(const char * message)2273 static int index_error_invalid(const char *message)
2274 {
2275 git_error_set(GIT_ERROR_INDEX, "invalid data in index - %s", message);
2276 return -1;
2277 }
2278
read_reuc(git_index * index,const char * buffer,size_t size)2279 static int read_reuc(git_index *index, const char *buffer, size_t size)
2280 {
2281 const char *endptr;
2282 size_t len;
2283 int i;
2284
2285 /* If called multiple times, the vector might already be initialized */
2286 if (index->reuc._alloc_size == 0 &&
2287 git_vector_init(&index->reuc, 16, reuc_cmp) < 0)
2288 return -1;
2289
2290 while (size) {
2291 git_index_reuc_entry *lost;
2292
2293 len = p_strnlen(buffer, size) + 1;
2294 if (size <= len)
2295 return index_error_invalid("reading reuc entries");
2296
2297 lost = reuc_entry_alloc(buffer);
2298 GIT_ERROR_CHECK_ALLOC(lost);
2299
2300 size -= len;
2301 buffer += len;
2302
2303 /* read 3 ASCII octal numbers for stage entries */
2304 for (i = 0; i < 3; i++) {
2305 int64_t tmp;
2306
2307 if (git__strntol64(&tmp, buffer, size, &endptr, 8) < 0 ||
2308 !endptr || endptr == buffer || *endptr ||
2309 tmp < 0 || tmp > UINT32_MAX) {
2310 index_entry_reuc_free(lost);
2311 return index_error_invalid("reading reuc entry stage");
2312 }
2313
2314 lost->mode[i] = (uint32_t)tmp;
2315
2316 len = (endptr + 1) - buffer;
2317 if (size <= len) {
2318 index_entry_reuc_free(lost);
2319 return index_error_invalid("reading reuc entry stage");
2320 }
2321
2322 size -= len;
2323 buffer += len;
2324 }
2325
2326 /* read up to 3 OIDs for stage entries */
2327 for (i = 0; i < 3; i++) {
2328 if (!lost->mode[i])
2329 continue;
2330 if (size < 20) {
2331 index_entry_reuc_free(lost);
2332 return index_error_invalid("reading reuc entry oid");
2333 }
2334
2335 git_oid_fromraw(&lost->oid[i], (const unsigned char *) buffer);
2336 size -= 20;
2337 buffer += 20;
2338 }
2339
2340 /* entry was read successfully - insert into reuc vector */
2341 if (git_vector_insert(&index->reuc, lost) < 0)
2342 return -1;
2343 }
2344
2345 /* entries are guaranteed to be sorted on-disk */
2346 git_vector_set_sorted(&index->reuc, true);
2347
2348 return 0;
2349 }
2350
2351
read_conflict_names(git_index * index,const char * buffer,size_t size)2352 static int read_conflict_names(git_index *index, const char *buffer, size_t size)
2353 {
2354 size_t len;
2355
2356 /* This gets called multiple times, the vector might already be initialized */
2357 if (index->names._alloc_size == 0 &&
2358 git_vector_init(&index->names, 16, conflict_name_cmp) < 0)
2359 return -1;
2360
2361 #define read_conflict_name(ptr) \
2362 len = p_strnlen(buffer, size) + 1; \
2363 if (size < len) { \
2364 index_error_invalid("reading conflict name entries"); \
2365 goto out_err; \
2366 } \
2367 if (len == 1) \
2368 ptr = NULL; \
2369 else { \
2370 ptr = git__malloc(len); \
2371 GIT_ERROR_CHECK_ALLOC(ptr); \
2372 memcpy(ptr, buffer, len); \
2373 } \
2374 \
2375 buffer += len; \
2376 size -= len;
2377
2378 while (size) {
2379 git_index_name_entry *conflict_name = git__calloc(1, sizeof(git_index_name_entry));
2380 GIT_ERROR_CHECK_ALLOC(conflict_name);
2381
2382 read_conflict_name(conflict_name->ancestor);
2383 read_conflict_name(conflict_name->ours);
2384 read_conflict_name(conflict_name->theirs);
2385
2386 if (git_vector_insert(&index->names, conflict_name) < 0)
2387 goto out_err;
2388
2389 continue;
2390
2391 out_err:
2392 git__free(conflict_name->ancestor);
2393 git__free(conflict_name->ours);
2394 git__free(conflict_name->theirs);
2395 git__free(conflict_name);
2396 return -1;
2397 }
2398
2399 #undef read_conflict_name
2400
2401 /* entries are guaranteed to be sorted on-disk */
2402 git_vector_set_sorted(&index->names, true);
2403
2404 return 0;
2405 }
2406
index_entry_size(size_t path_len,size_t varint_len,uint32_t flags)2407 static size_t index_entry_size(size_t path_len, size_t varint_len, uint32_t flags)
2408 {
2409 if (varint_len) {
2410 if (flags & GIT_INDEX_ENTRY_EXTENDED)
2411 return offsetof(struct entry_long, path) + path_len + 1 + varint_len;
2412 else
2413 return offsetof(struct entry_short, path) + path_len + 1 + varint_len;
2414 } else {
2415 #define entry_size(type,len) ((offsetof(type, path) + (len) + 8) & ~7)
2416 if (flags & GIT_INDEX_ENTRY_EXTENDED)
2417 return entry_size(struct entry_long, path_len);
2418 else
2419 return entry_size(struct entry_short, path_len);
2420 #undef entry_size
2421 }
2422 }
2423
read_entry(git_index_entry ** out,size_t * out_size,git_index * index,const void * buffer,size_t buffer_size,const char * last)2424 static int read_entry(
2425 git_index_entry **out,
2426 size_t *out_size,
2427 git_index *index,
2428 const void *buffer,
2429 size_t buffer_size,
2430 const char *last)
2431 {
2432 size_t path_length, entry_size;
2433 const char *path_ptr;
2434 struct entry_short source;
2435 git_index_entry entry = {{0}};
2436 bool compressed = index->version >= INDEX_VERSION_NUMBER_COMP;
2437 char *tmp_path = NULL;
2438
2439 if (INDEX_FOOTER_SIZE + minimal_entry_size > buffer_size)
2440 return -1;
2441
2442 /* buffer is not guaranteed to be aligned */
2443 memcpy(&source, buffer, sizeof(struct entry_short));
2444
2445 entry.ctime.seconds = (git_time_t)ntohl(source.ctime.seconds);
2446 entry.ctime.nanoseconds = ntohl(source.ctime.nanoseconds);
2447 entry.mtime.seconds = (git_time_t)ntohl(source.mtime.seconds);
2448 entry.mtime.nanoseconds = ntohl(source.mtime.nanoseconds);
2449 entry.dev = ntohl(source.dev);
2450 entry.ino = ntohl(source.ino);
2451 entry.mode = ntohl(source.mode);
2452 entry.uid = ntohl(source.uid);
2453 entry.gid = ntohl(source.gid);
2454 entry.file_size = ntohl(source.file_size);
2455 git_oid_cpy(&entry.id, &source.oid);
2456 entry.flags = ntohs(source.flags);
2457
2458 if (entry.flags & GIT_INDEX_ENTRY_EXTENDED) {
2459 uint16_t flags_raw;
2460 size_t flags_offset;
2461
2462 flags_offset = offsetof(struct entry_long, flags_extended);
2463 memcpy(&flags_raw, (const char *) buffer + flags_offset,
2464 sizeof(flags_raw));
2465 flags_raw = ntohs(flags_raw);
2466
2467 memcpy(&entry.flags_extended, &flags_raw, sizeof(flags_raw));
2468 path_ptr = (const char *) buffer + offsetof(struct entry_long, path);
2469 } else
2470 path_ptr = (const char *) buffer + offsetof(struct entry_short, path);
2471
2472 if (!compressed) {
2473 path_length = entry.flags & GIT_INDEX_ENTRY_NAMEMASK;
2474
2475 /* if this is a very long string, we must find its
2476 * real length without overflowing */
2477 if (path_length == 0xFFF) {
2478 const char *path_end;
2479
2480 path_end = memchr(path_ptr, '\0', buffer_size);
2481 if (path_end == NULL)
2482 return -1;
2483
2484 path_length = path_end - path_ptr;
2485 }
2486
2487 entry_size = index_entry_size(path_length, 0, entry.flags);
2488 entry.path = (char *)path_ptr;
2489 } else {
2490 size_t varint_len, last_len, prefix_len, suffix_len, path_len;
2491 uintmax_t strip_len;
2492
2493 strip_len = git_decode_varint((const unsigned char *)path_ptr, &varint_len);
2494 last_len = strlen(last);
2495
2496 if (varint_len == 0 || last_len < strip_len)
2497 return index_error_invalid("incorrect prefix length");
2498
2499 prefix_len = last_len - (size_t)strip_len;
2500 suffix_len = strlen(path_ptr + varint_len);
2501
2502 GIT_ERROR_CHECK_ALLOC_ADD(&path_len, prefix_len, suffix_len);
2503 GIT_ERROR_CHECK_ALLOC_ADD(&path_len, path_len, 1);
2504
2505 if (path_len > GIT_PATH_MAX)
2506 return index_error_invalid("unreasonable path length");
2507
2508 tmp_path = git__malloc(path_len);
2509 GIT_ERROR_CHECK_ALLOC(tmp_path);
2510
2511 memcpy(tmp_path, last, prefix_len);
2512 memcpy(tmp_path + prefix_len, path_ptr + varint_len, suffix_len + 1);
2513 entry_size = index_entry_size(suffix_len, varint_len, entry.flags);
2514 entry.path = tmp_path;
2515 }
2516
2517 if (entry_size == 0)
2518 return -1;
2519
2520 if (INDEX_FOOTER_SIZE + entry_size > buffer_size)
2521 return -1;
2522
2523 if (index_entry_dup(out, index, &entry) < 0) {
2524 git__free(tmp_path);
2525 return -1;
2526 }
2527
2528 git__free(tmp_path);
2529 *out_size = entry_size;
2530 return 0;
2531 }
2532
read_header(struct index_header * dest,const void * buffer)2533 static int read_header(struct index_header *dest, const void *buffer)
2534 {
2535 const struct index_header *source = buffer;
2536
2537 dest->signature = ntohl(source->signature);
2538 if (dest->signature != INDEX_HEADER_SIG)
2539 return index_error_invalid("incorrect header signature");
2540
2541 dest->version = ntohl(source->version);
2542 if (dest->version < INDEX_VERSION_NUMBER_LB ||
2543 dest->version > INDEX_VERSION_NUMBER_UB)
2544 return index_error_invalid("incorrect header version");
2545
2546 dest->entry_count = ntohl(source->entry_count);
2547 return 0;
2548 }
2549
read_extension(size_t * read_len,git_index * index,const char * buffer,size_t buffer_size)2550 static int read_extension(size_t *read_len, git_index *index, const char *buffer, size_t buffer_size)
2551 {
2552 struct index_extension dest;
2553 size_t total_size;
2554
2555 /* buffer is not guaranteed to be aligned */
2556 memcpy(&dest, buffer, sizeof(struct index_extension));
2557 dest.extension_size = ntohl(dest.extension_size);
2558
2559 total_size = dest.extension_size + sizeof(struct index_extension);
2560
2561 if (dest.extension_size > total_size ||
2562 buffer_size < total_size ||
2563 buffer_size - total_size < INDEX_FOOTER_SIZE) {
2564 index_error_invalid("extension is truncated");
2565 return -1;
2566 }
2567
2568 /* optional extension */
2569 if (dest.signature[0] >= 'A' && dest.signature[0] <= 'Z') {
2570 /* tree cache */
2571 if (memcmp(dest.signature, INDEX_EXT_TREECACHE_SIG, 4) == 0) {
2572 if (git_tree_cache_read(&index->tree, buffer + 8, dest.extension_size, &index->tree_pool) < 0)
2573 return -1;
2574 } else if (memcmp(dest.signature, INDEX_EXT_UNMERGED_SIG, 4) == 0) {
2575 if (read_reuc(index, buffer + 8, dest.extension_size) < 0)
2576 return -1;
2577 } else if (memcmp(dest.signature, INDEX_EXT_CONFLICT_NAME_SIG, 4) == 0) {
2578 if (read_conflict_names(index, buffer + 8, dest.extension_size) < 0)
2579 return -1;
2580 }
2581 /* else, unsupported extension. We cannot parse this, but we can skip
2582 * it by returning `total_size */
2583 } else {
2584 /* we cannot handle non-ignorable extensions;
2585 * in fact they aren't even defined in the standard */
2586 git_error_set(GIT_ERROR_INDEX, "unsupported mandatory extension: '%.4s'", dest.signature);
2587 return -1;
2588 }
2589
2590 *read_len = total_size;
2591
2592 return 0;
2593 }
2594
parse_index(git_index * index,const char * buffer,size_t buffer_size)2595 static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
2596 {
2597 int error = 0;
2598 unsigned int i;
2599 struct index_header header = { 0 };
2600 git_oid checksum_calculated, checksum_expected;
2601 const char *last = NULL;
2602 const char *empty = "";
2603
2604 #define seek_forward(_increase) { \
2605 if (_increase >= buffer_size) { \
2606 error = index_error_invalid("ran out of data while parsing"); \
2607 goto done; } \
2608 buffer += _increase; \
2609 buffer_size -= _increase;\
2610 }
2611
2612 if (buffer_size < INDEX_HEADER_SIZE + INDEX_FOOTER_SIZE)
2613 return index_error_invalid("insufficient buffer space");
2614
2615 /* Precalculate the SHA1 of the files's contents -- we'll match it to
2616 * the provided SHA1 in the footer */
2617 git_hash_buf(&checksum_calculated, buffer, buffer_size - INDEX_FOOTER_SIZE);
2618
2619 /* Parse header */
2620 if ((error = read_header(&header, buffer)) < 0)
2621 return error;
2622
2623 index->version = header.version;
2624 if (index->version >= INDEX_VERSION_NUMBER_COMP)
2625 last = empty;
2626
2627 seek_forward(INDEX_HEADER_SIZE);
2628
2629 assert(!index->entries.length);
2630
2631 if ((error = index_map_resize(index->entries_map, header.entry_count, index->ignore_case)) < 0)
2632 return error;
2633
2634 /* Parse all the entries */
2635 for (i = 0; i < header.entry_count && buffer_size > INDEX_FOOTER_SIZE; ++i) {
2636 git_index_entry *entry = NULL;
2637 size_t entry_size;
2638
2639 if ((error = read_entry(&entry, &entry_size, index, buffer, buffer_size, last)) < 0) {
2640 error = index_error_invalid("invalid entry");
2641 goto done;
2642 }
2643
2644 if ((error = git_vector_insert(&index->entries, entry)) < 0) {
2645 index_entry_free(entry);
2646 goto done;
2647 }
2648
2649 if ((error = index_map_set(index->entries_map, entry, index->ignore_case)) < 0) {
2650 index_entry_free(entry);
2651 goto done;
2652 }
2653 error = 0;
2654
2655 if (index->version >= INDEX_VERSION_NUMBER_COMP)
2656 last = entry->path;
2657
2658 seek_forward(entry_size);
2659 }
2660
2661 if (i != header.entry_count) {
2662 error = index_error_invalid("header entries changed while parsing");
2663 goto done;
2664 }
2665
2666 /* There's still space for some extensions! */
2667 while (buffer_size > INDEX_FOOTER_SIZE) {
2668 size_t extension_size;
2669
2670 if ((error = read_extension(&extension_size, index, buffer, buffer_size)) < 0) {
2671 goto done;
2672 }
2673
2674 seek_forward(extension_size);
2675 }
2676
2677 if (buffer_size != INDEX_FOOTER_SIZE) {
2678 error = index_error_invalid(
2679 "buffer size does not match index footer size");
2680 goto done;
2681 }
2682
2683 /* 160-bit SHA-1 over the content of the index file before this checksum. */
2684 git_oid_fromraw(&checksum_expected, (const unsigned char *)buffer);
2685
2686 if (git_oid__cmp(&checksum_calculated, &checksum_expected) != 0) {
2687 error = index_error_invalid(
2688 "calculated checksum does not match expected");
2689 goto done;
2690 }
2691
2692 git_oid_cpy(&index->checksum, &checksum_calculated);
2693
2694 #undef seek_forward
2695
2696 /* Entries are stored case-sensitively on disk, so re-sort now if
2697 * in-memory index is supposed to be case-insensitive
2698 */
2699 git_vector_set_sorted(&index->entries, !index->ignore_case);
2700 git_vector_sort(&index->entries);
2701
2702 index->dirty = 0;
2703 done:
2704 return error;
2705 }
2706
is_index_extended(git_index * index)2707 static bool is_index_extended(git_index *index)
2708 {
2709 size_t i, extended;
2710 git_index_entry *entry;
2711
2712 extended = 0;
2713
2714 git_vector_foreach(&index->entries, i, entry) {
2715 entry->flags &= ~GIT_INDEX_ENTRY_EXTENDED;
2716 if (entry->flags_extended & GIT_INDEX_ENTRY_EXTENDED_FLAGS) {
2717 extended++;
2718 entry->flags |= GIT_INDEX_ENTRY_EXTENDED;
2719 }
2720 }
2721
2722 return (extended > 0);
2723 }
2724
write_disk_entry(git_filebuf * file,git_index_entry * entry,const char * last)2725 static int write_disk_entry(git_filebuf *file, git_index_entry *entry, const char *last)
2726 {
2727 void *mem = NULL;
2728 struct entry_short ondisk;
2729 size_t path_len, disk_size;
2730 int varint_len = 0;
2731 char *path;
2732 const char *path_start = entry->path;
2733 size_t same_len = 0;
2734
2735 path_len = ((struct entry_internal *)entry)->pathlen;
2736
2737 if (last) {
2738 const char *last_c = last;
2739
2740 while (*path_start == *last_c) {
2741 if (!*path_start || !*last_c)
2742 break;
2743 ++path_start;
2744 ++last_c;
2745 ++same_len;
2746 }
2747 path_len -= same_len;
2748 varint_len = git_encode_varint(NULL, 0, strlen(last) - same_len);
2749 }
2750
2751 disk_size = index_entry_size(path_len, varint_len, entry->flags);
2752
2753 if (git_filebuf_reserve(file, &mem, disk_size) < 0)
2754 return -1;
2755
2756 memset(mem, 0x0, disk_size);
2757
2758 /**
2759 * Yes, we have to truncate.
2760 *
2761 * The on-disk format for Index entries clearly defines
2762 * the time and size fields to be 4 bytes each -- so even if
2763 * we store these values with 8 bytes on-memory, they must
2764 * be truncated to 4 bytes before writing to disk.
2765 *
2766 * In 2038 I will be either too dead or too rich to care about this
2767 */
2768 ondisk.ctime.seconds = htonl((uint32_t)entry->ctime.seconds);
2769 ondisk.mtime.seconds = htonl((uint32_t)entry->mtime.seconds);
2770 ondisk.ctime.nanoseconds = htonl(entry->ctime.nanoseconds);
2771 ondisk.mtime.nanoseconds = htonl(entry->mtime.nanoseconds);
2772 ondisk.dev = htonl(entry->dev);
2773 ondisk.ino = htonl(entry->ino);
2774 ondisk.mode = htonl(entry->mode);
2775 ondisk.uid = htonl(entry->uid);
2776 ondisk.gid = htonl(entry->gid);
2777 ondisk.file_size = htonl((uint32_t)entry->file_size);
2778
2779 git_oid_cpy(&ondisk.oid, &entry->id);
2780
2781 ondisk.flags = htons(entry->flags);
2782
2783 if (entry->flags & GIT_INDEX_ENTRY_EXTENDED) {
2784 const size_t path_offset = offsetof(struct entry_long, path);
2785 struct entry_long ondisk_ext;
2786 memcpy(&ondisk_ext, &ondisk, sizeof(struct entry_short));
2787 ondisk_ext.flags_extended = htons(entry->flags_extended &
2788 GIT_INDEX_ENTRY_EXTENDED_FLAGS);
2789 memcpy(mem, &ondisk_ext, path_offset);
2790 path = (char *)mem + path_offset;
2791 disk_size -= path_offset;
2792 } else {
2793 const size_t path_offset = offsetof(struct entry_short, path);
2794 memcpy(mem, &ondisk, path_offset);
2795 path = (char *)mem + path_offset;
2796 disk_size -= path_offset;
2797 }
2798
2799 if (last) {
2800 varint_len = git_encode_varint((unsigned char *) path,
2801 disk_size, strlen(last) - same_len);
2802 assert(varint_len > 0);
2803 path += varint_len;
2804 disk_size -= varint_len;
2805
2806 /*
2807 * If using path compression, we are not allowed
2808 * to have additional trailing NULs.
2809 */
2810 assert(disk_size == path_len + 1);
2811 } else {
2812 /*
2813 * If no path compression is used, we do have
2814 * NULs as padding. As such, simply assert that
2815 * we have enough space left to write the path.
2816 */
2817 assert(disk_size > path_len);
2818 }
2819
2820 memcpy(path, path_start, path_len + 1);
2821
2822 return 0;
2823 }
2824
write_entries(git_index * index,git_filebuf * file)2825 static int write_entries(git_index *index, git_filebuf *file)
2826 {
2827 int error = 0;
2828 size_t i;
2829 git_vector case_sorted, *entries;
2830 git_index_entry *entry;
2831 const char *last = NULL;
2832
2833 /* If index->entries is sorted case-insensitively, then we need
2834 * to re-sort it case-sensitively before writing */
2835 if (index->ignore_case) {
2836 git_vector_dup(&case_sorted, &index->entries, git_index_entry_cmp);
2837 git_vector_sort(&case_sorted);
2838 entries = &case_sorted;
2839 } else {
2840 entries = &index->entries;
2841 }
2842
2843 if (index->version >= INDEX_VERSION_NUMBER_COMP)
2844 last = "";
2845
2846 git_vector_foreach(entries, i, entry) {
2847 if ((error = write_disk_entry(file, entry, last)) < 0)
2848 break;
2849 if (index->version >= INDEX_VERSION_NUMBER_COMP)
2850 last = entry->path;
2851 }
2852
2853 if (index->ignore_case)
2854 git_vector_free(&case_sorted);
2855
2856 return error;
2857 }
2858
write_extension(git_filebuf * file,struct index_extension * header,git_buf * data)2859 static int write_extension(git_filebuf *file, struct index_extension *header, git_buf *data)
2860 {
2861 struct index_extension ondisk;
2862
2863 memset(&ondisk, 0x0, sizeof(struct index_extension));
2864 memcpy(&ondisk, header, 4);
2865 ondisk.extension_size = htonl(header->extension_size);
2866
2867 git_filebuf_write(file, &ondisk, sizeof(struct index_extension));
2868 return git_filebuf_write(file, data->ptr, data->size);
2869 }
2870
create_name_extension_data(git_buf * name_buf,git_index_name_entry * conflict_name)2871 static int create_name_extension_data(git_buf *name_buf, git_index_name_entry *conflict_name)
2872 {
2873 int error = 0;
2874
2875 if (conflict_name->ancestor == NULL)
2876 error = git_buf_put(name_buf, "\0", 1);
2877 else
2878 error = git_buf_put(name_buf, conflict_name->ancestor, strlen(conflict_name->ancestor) + 1);
2879
2880 if (error != 0)
2881 goto on_error;
2882
2883 if (conflict_name->ours == NULL)
2884 error = git_buf_put(name_buf, "\0", 1);
2885 else
2886 error = git_buf_put(name_buf, conflict_name->ours, strlen(conflict_name->ours) + 1);
2887
2888 if (error != 0)
2889 goto on_error;
2890
2891 if (conflict_name->theirs == NULL)
2892 error = git_buf_put(name_buf, "\0", 1);
2893 else
2894 error = git_buf_put(name_buf, conflict_name->theirs, strlen(conflict_name->theirs) + 1);
2895
2896 on_error:
2897 return error;
2898 }
2899
write_name_extension(git_index * index,git_filebuf * file)2900 static int write_name_extension(git_index *index, git_filebuf *file)
2901 {
2902 git_buf name_buf = GIT_BUF_INIT;
2903 git_vector *out = &index->names;
2904 git_index_name_entry *conflict_name;
2905 struct index_extension extension;
2906 size_t i;
2907 int error = 0;
2908
2909 git_vector_foreach(out, i, conflict_name) {
2910 if ((error = create_name_extension_data(&name_buf, conflict_name)) < 0)
2911 goto done;
2912 }
2913
2914 memset(&extension, 0x0, sizeof(struct index_extension));
2915 memcpy(&extension.signature, INDEX_EXT_CONFLICT_NAME_SIG, 4);
2916 extension.extension_size = (uint32_t)name_buf.size;
2917
2918 error = write_extension(file, &extension, &name_buf);
2919
2920 git_buf_dispose(&name_buf);
2921
2922 done:
2923 return error;
2924 }
2925
create_reuc_extension_data(git_buf * reuc_buf,git_index_reuc_entry * reuc)2926 static int create_reuc_extension_data(git_buf *reuc_buf, git_index_reuc_entry *reuc)
2927 {
2928 int i;
2929 int error = 0;
2930
2931 if ((error = git_buf_put(reuc_buf, reuc->path, strlen(reuc->path) + 1)) < 0)
2932 return error;
2933
2934 for (i = 0; i < 3; i++) {
2935 if ((error = git_buf_printf(reuc_buf, "%o", reuc->mode[i])) < 0 ||
2936 (error = git_buf_put(reuc_buf, "\0", 1)) < 0)
2937 return error;
2938 }
2939
2940 for (i = 0; i < 3; i++) {
2941 if (reuc->mode[i] && (error = git_buf_put(reuc_buf, (char *)&reuc->oid[i].id, GIT_OID_RAWSZ)) < 0)
2942 return error;
2943 }
2944
2945 return 0;
2946 }
2947
write_reuc_extension(git_index * index,git_filebuf * file)2948 static int write_reuc_extension(git_index *index, git_filebuf *file)
2949 {
2950 git_buf reuc_buf = GIT_BUF_INIT;
2951 git_vector *out = &index->reuc;
2952 git_index_reuc_entry *reuc;
2953 struct index_extension extension;
2954 size_t i;
2955 int error = 0;
2956
2957 git_vector_foreach(out, i, reuc) {
2958 if ((error = create_reuc_extension_data(&reuc_buf, reuc)) < 0)
2959 goto done;
2960 }
2961
2962 memset(&extension, 0x0, sizeof(struct index_extension));
2963 memcpy(&extension.signature, INDEX_EXT_UNMERGED_SIG, 4);
2964 extension.extension_size = (uint32_t)reuc_buf.size;
2965
2966 error = write_extension(file, &extension, &reuc_buf);
2967
2968 git_buf_dispose(&reuc_buf);
2969
2970 done:
2971 return error;
2972 }
2973
write_tree_extension(git_index * index,git_filebuf * file)2974 static int write_tree_extension(git_index *index, git_filebuf *file)
2975 {
2976 struct index_extension extension;
2977 git_buf buf = GIT_BUF_INIT;
2978 int error;
2979
2980 if (index->tree == NULL)
2981 return 0;
2982
2983 if ((error = git_tree_cache_write(&buf, index->tree)) < 0)
2984 return error;
2985
2986 memset(&extension, 0x0, sizeof(struct index_extension));
2987 memcpy(&extension.signature, INDEX_EXT_TREECACHE_SIG, 4);
2988 extension.extension_size = (uint32_t)buf.size;
2989
2990 error = write_extension(file, &extension, &buf);
2991
2992 git_buf_dispose(&buf);
2993
2994 return error;
2995 }
2996
clear_uptodate(git_index * index)2997 static void clear_uptodate(git_index *index)
2998 {
2999 git_index_entry *entry;
3000 size_t i;
3001
3002 git_vector_foreach(&index->entries, i, entry)
3003 entry->flags_extended &= ~GIT_INDEX_ENTRY_UPTODATE;
3004 }
3005
write_index(git_oid * checksum,git_index * index,git_filebuf * file)3006 static int write_index(git_oid *checksum, git_index *index, git_filebuf *file)
3007 {
3008 git_oid hash_final;
3009 struct index_header header;
3010 bool is_extended;
3011 uint32_t index_version_number;
3012
3013 assert(index && file);
3014
3015 if (index->version <= INDEX_VERSION_NUMBER_EXT) {
3016 is_extended = is_index_extended(index);
3017 index_version_number = is_extended ? INDEX_VERSION_NUMBER_EXT : INDEX_VERSION_NUMBER_LB;
3018 } else {
3019 index_version_number = index->version;
3020 }
3021
3022 header.signature = htonl(INDEX_HEADER_SIG);
3023 header.version = htonl(index_version_number);
3024 header.entry_count = htonl((uint32_t)index->entries.length);
3025
3026 if (git_filebuf_write(file, &header, sizeof(struct index_header)) < 0)
3027 return -1;
3028
3029 if (write_entries(index, file) < 0)
3030 return -1;
3031
3032 /* write the tree cache extension */
3033 if (index->tree != NULL && write_tree_extension(index, file) < 0)
3034 return -1;
3035
3036 /* write the rename conflict extension */
3037 if (index->names.length > 0 && write_name_extension(index, file) < 0)
3038 return -1;
3039
3040 /* write the reuc extension */
3041 if (index->reuc.length > 0 && write_reuc_extension(index, file) < 0)
3042 return -1;
3043
3044 /* get out the hash for all the contents we've appended to the file */
3045 git_filebuf_hash(&hash_final, file);
3046 git_oid_cpy(checksum, &hash_final);
3047
3048 /* write it at the end of the file */
3049 if (git_filebuf_write(file, hash_final.id, GIT_OID_RAWSZ) < 0)
3050 return -1;
3051
3052 /* file entries are no longer up to date */
3053 clear_uptodate(index);
3054
3055 return 0;
3056 }
3057
git_index_entry_stage(const git_index_entry * entry)3058 int git_index_entry_stage(const git_index_entry *entry)
3059 {
3060 return GIT_INDEX_ENTRY_STAGE(entry);
3061 }
3062
git_index_entry_is_conflict(const git_index_entry * entry)3063 int git_index_entry_is_conflict(const git_index_entry *entry)
3064 {
3065 return (GIT_INDEX_ENTRY_STAGE(entry) > 0);
3066 }
3067
3068 typedef struct read_tree_data {
3069 git_index *index;
3070 git_vector *old_entries;
3071 git_vector *new_entries;
3072 git_vector_cmp entry_cmp;
3073 git_tree_cache *tree;
3074 } read_tree_data;
3075
read_tree_cb(const char * root,const git_tree_entry * tentry,void * payload)3076 static int read_tree_cb(
3077 const char *root, const git_tree_entry *tentry, void *payload)
3078 {
3079 read_tree_data *data = payload;
3080 git_index_entry *entry = NULL, *old_entry;
3081 git_buf path = GIT_BUF_INIT;
3082 size_t pos;
3083
3084 if (git_tree_entry__is_tree(tentry))
3085 return 0;
3086
3087 if (git_buf_joinpath(&path, root, tentry->filename) < 0)
3088 return -1;
3089
3090 if (index_entry_create(&entry, INDEX_OWNER(data->index), path.ptr, NULL, false) < 0)
3091 return -1;
3092
3093 entry->mode = tentry->attr;
3094 git_oid_cpy(&entry->id, git_tree_entry_id(tentry));
3095
3096 /* look for corresponding old entry and copy data to new entry */
3097 if (data->old_entries != NULL &&
3098 !index_find_in_entries(
3099 &pos, data->old_entries, data->entry_cmp, path.ptr, 0, 0) &&
3100 (old_entry = git_vector_get(data->old_entries, pos)) != NULL &&
3101 entry->mode == old_entry->mode &&
3102 git_oid_equal(&entry->id, &old_entry->id))
3103 {
3104 index_entry_cpy(entry, old_entry);
3105 entry->flags_extended = 0;
3106 }
3107
3108 index_entry_adjust_namemask(entry, path.size);
3109 git_buf_dispose(&path);
3110
3111 if (git_vector_insert(data->new_entries, entry) < 0) {
3112 index_entry_free(entry);
3113 return -1;
3114 }
3115
3116 return 0;
3117 }
3118
git_index_read_tree(git_index * index,const git_tree * tree)3119 int git_index_read_tree(git_index *index, const git_tree *tree)
3120 {
3121 int error = 0;
3122 git_vector entries = GIT_VECTOR_INIT;
3123 git_idxmap *entries_map;
3124 read_tree_data data;
3125 size_t i;
3126 git_index_entry *e;
3127
3128 if (git_idxmap_new(&entries_map) < 0)
3129 return -1;
3130
3131 git_vector_set_cmp(&entries, index->entries._cmp); /* match sort */
3132
3133 data.index = index;
3134 data.old_entries = &index->entries;
3135 data.new_entries = &entries;
3136 data.entry_cmp = index->entries_search;
3137
3138 index->tree = NULL;
3139 git_pool_clear(&index->tree_pool);
3140
3141 git_vector_sort(&index->entries);
3142
3143 if ((error = git_tree_walk(tree, GIT_TREEWALK_POST, read_tree_cb, &data)) < 0)
3144 goto cleanup;
3145
3146 if ((error = index_map_resize(entries_map, entries.length, index->ignore_case)) < 0)
3147 goto cleanup;
3148
3149 git_vector_foreach(&entries, i, e) {
3150 if ((error = index_map_set(entries_map, e, index->ignore_case)) < 0) {
3151 git_error_set(GIT_ERROR_INDEX, "failed to insert entry into map");
3152 return error;
3153 }
3154 }
3155
3156 error = 0;
3157
3158 git_vector_sort(&entries);
3159
3160 if ((error = git_index_clear(index)) < 0) {
3161 /* well, this isn't good */;
3162 } else {
3163 git_vector_swap(&entries, &index->entries);
3164 entries_map = git__swap(index->entries_map, entries_map);
3165 }
3166
3167 index->dirty = 1;
3168
3169 cleanup:
3170 git_vector_free(&entries);
3171 git_idxmap_free(entries_map);
3172 if (error < 0)
3173 return error;
3174
3175 error = git_tree_cache_read_tree(&index->tree, tree, &index->tree_pool);
3176
3177 return error;
3178 }
3179
git_index_read_iterator(git_index * index,git_iterator * new_iterator,size_t new_length_hint)3180 static int git_index_read_iterator(
3181 git_index *index,
3182 git_iterator *new_iterator,
3183 size_t new_length_hint)
3184 {
3185 git_vector new_entries = GIT_VECTOR_INIT,
3186 remove_entries = GIT_VECTOR_INIT;
3187 git_idxmap *new_entries_map = NULL;
3188 git_iterator *index_iterator = NULL;
3189 git_iterator_options opts = GIT_ITERATOR_OPTIONS_INIT;
3190 const git_index_entry *old_entry, *new_entry;
3191 git_index_entry *entry;
3192 size_t i;
3193 int error;
3194
3195 assert((new_iterator->flags & GIT_ITERATOR_DONT_IGNORE_CASE));
3196
3197 if ((error = git_vector_init(&new_entries, new_length_hint, index->entries._cmp)) < 0 ||
3198 (error = git_vector_init(&remove_entries, index->entries.length, NULL)) < 0 ||
3199 (error = git_idxmap_new(&new_entries_map)) < 0)
3200 goto done;
3201
3202 if (new_length_hint && (error = index_map_resize(new_entries_map, new_length_hint,
3203 index->ignore_case)) < 0)
3204 goto done;
3205
3206 opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE |
3207 GIT_ITERATOR_INCLUDE_CONFLICTS;
3208
3209 if ((error = git_iterator_for_index(&index_iterator,
3210 git_index_owner(index), index, &opts)) < 0 ||
3211 ((error = git_iterator_current(&old_entry, index_iterator)) < 0 &&
3212 error != GIT_ITEROVER) ||
3213 ((error = git_iterator_current(&new_entry, new_iterator)) < 0 &&
3214 error != GIT_ITEROVER))
3215 goto done;
3216
3217 while (true) {
3218 git_index_entry
3219 *dup_entry = NULL,
3220 *add_entry = NULL,
3221 *remove_entry = NULL;
3222 int diff;
3223
3224 error = 0;
3225
3226 if (old_entry && new_entry)
3227 diff = git_index_entry_cmp(old_entry, new_entry);
3228 else if (!old_entry && new_entry)
3229 diff = 1;
3230 else if (old_entry && !new_entry)
3231 diff = -1;
3232 else
3233 break;
3234
3235 if (diff < 0) {
3236 remove_entry = (git_index_entry *)old_entry;
3237 } else if (diff > 0) {
3238 dup_entry = (git_index_entry *)new_entry;
3239 } else {
3240 /* Path and stage are equal, if the OID is equal, keep it to
3241 * keep the stat cache data.
3242 */
3243 if (git_oid_equal(&old_entry->id, &new_entry->id) &&
3244 old_entry->mode == new_entry->mode) {
3245 add_entry = (git_index_entry *)old_entry;
3246 } else {
3247 dup_entry = (git_index_entry *)new_entry;
3248 remove_entry = (git_index_entry *)old_entry;
3249 }
3250 }
3251
3252 if (dup_entry) {
3253 if ((error = index_entry_dup_nocache(&add_entry, index, dup_entry)) < 0)
3254 goto done;
3255
3256 index_entry_adjust_namemask(add_entry,
3257 ((struct entry_internal *)add_entry)->pathlen);
3258 }
3259
3260 /* invalidate this path in the tree cache if this is new (to
3261 * invalidate the parent trees)
3262 */
3263 if (dup_entry && !remove_entry && index->tree)
3264 git_tree_cache_invalidate_path(index->tree, dup_entry->path);
3265
3266 if (add_entry) {
3267 if ((error = git_vector_insert(&new_entries, add_entry)) == 0)
3268 error = index_map_set(new_entries_map, add_entry,
3269 index->ignore_case);
3270 }
3271
3272 if (remove_entry && error >= 0)
3273 error = git_vector_insert(&remove_entries, remove_entry);
3274
3275 if (error < 0) {
3276 git_error_set(GIT_ERROR_INDEX, "failed to insert entry");
3277 goto done;
3278 }
3279
3280 if (diff <= 0) {
3281 if ((error = git_iterator_advance(&old_entry, index_iterator)) < 0 &&
3282 error != GIT_ITEROVER)
3283 goto done;
3284 }
3285
3286 if (diff >= 0) {
3287 if ((error = git_iterator_advance(&new_entry, new_iterator)) < 0 &&
3288 error != GIT_ITEROVER)
3289 goto done;
3290 }
3291 }
3292
3293 if ((error = git_index_name_clear(index)) < 0 ||
3294 (error = git_index_reuc_clear(index)) < 0)
3295 goto done;
3296
3297 git_vector_swap(&new_entries, &index->entries);
3298 new_entries_map = git__swap(index->entries_map, new_entries_map);
3299
3300 git_vector_foreach(&remove_entries, i, entry) {
3301 if (index->tree)
3302 git_tree_cache_invalidate_path(index->tree, entry->path);
3303
3304 index_entry_free(entry);
3305 }
3306
3307 clear_uptodate(index);
3308
3309 index->dirty = 1;
3310 error = 0;
3311
3312 done:
3313 git_idxmap_free(new_entries_map);
3314 git_vector_free(&new_entries);
3315 git_vector_free(&remove_entries);
3316 git_iterator_free(index_iterator);
3317 return error;
3318 }
3319
git_index_read_index(git_index * index,const git_index * new_index)3320 int git_index_read_index(
3321 git_index *index,
3322 const git_index *new_index)
3323 {
3324 git_iterator *new_iterator = NULL;
3325 git_iterator_options opts = GIT_ITERATOR_OPTIONS_INIT;
3326 int error;
3327
3328 opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE |
3329 GIT_ITERATOR_INCLUDE_CONFLICTS;
3330
3331 if ((error = git_iterator_for_index(&new_iterator,
3332 git_index_owner(new_index), (git_index *)new_index, &opts)) < 0 ||
3333 (error = git_index_read_iterator(index, new_iterator,
3334 new_index->entries.length)) < 0)
3335 goto done;
3336
3337 done:
3338 git_iterator_free(new_iterator);
3339 return error;
3340 }
3341
git_index_owner(const git_index * index)3342 git_repository *git_index_owner(const git_index *index)
3343 {
3344 return INDEX_OWNER(index);
3345 }
3346
3347 enum {
3348 INDEX_ACTION_NONE = 0,
3349 INDEX_ACTION_UPDATE = 1,
3350 INDEX_ACTION_REMOVE = 2,
3351 INDEX_ACTION_ADDALL = 3,
3352 };
3353
git_index_add_all(git_index * index,const git_strarray * paths,unsigned int flags,git_index_matched_path_cb cb,void * payload)3354 int git_index_add_all(
3355 git_index *index,
3356 const git_strarray *paths,
3357 unsigned int flags,
3358 git_index_matched_path_cb cb,
3359 void *payload)
3360 {
3361 int error;
3362 git_repository *repo;
3363 git_iterator *wditer = NULL;
3364 git_pathspec ps;
3365 bool no_fnmatch = (flags & GIT_INDEX_ADD_DISABLE_PATHSPEC_MATCH) != 0;
3366
3367 assert(index);
3368
3369 repo = INDEX_OWNER(index);
3370 if ((error = git_repository__ensure_not_bare(repo, "index add all")) < 0)
3371 return error;
3372
3373 if ((error = git_pathspec__init(&ps, paths)) < 0)
3374 return error;
3375
3376 /* optionally check that pathspec doesn't mention any ignored files */
3377 if ((flags & GIT_INDEX_ADD_CHECK_PATHSPEC) != 0 &&
3378 (flags & GIT_INDEX_ADD_FORCE) == 0 &&
3379 (error = git_ignore__check_pathspec_for_exact_ignores(
3380 repo, &ps.pathspec, no_fnmatch)) < 0)
3381 goto cleanup;
3382
3383 error = index_apply_to_wd_diff(index, INDEX_ACTION_ADDALL, paths, flags, cb, payload);
3384
3385 if (error)
3386 git_error_set_after_callback(error);
3387
3388 cleanup:
3389 git_iterator_free(wditer);
3390 git_pathspec__clear(&ps);
3391
3392 return error;
3393 }
3394
3395 struct foreach_diff_data {
3396 git_index *index;
3397 const git_pathspec *pathspec;
3398 unsigned int flags;
3399 git_index_matched_path_cb cb;
3400 void *payload;
3401 };
3402
apply_each_file(const git_diff_delta * delta,float progress,void * payload)3403 static int apply_each_file(const git_diff_delta *delta, float progress, void *payload)
3404 {
3405 struct foreach_diff_data *data = payload;
3406 const char *match, *path;
3407 int error = 0;
3408
3409 GIT_UNUSED(progress);
3410
3411 path = delta->old_file.path;
3412
3413 /* We only want those which match the pathspecs */
3414 if (!git_pathspec__match(
3415 &data->pathspec->pathspec, path, false, (bool)data->index->ignore_case,
3416 &match, NULL))
3417 return 0;
3418
3419 if (data->cb)
3420 error = data->cb(path, match, data->payload);
3421
3422 if (error > 0) /* skip this entry */
3423 return 0;
3424 if (error < 0) /* actual error */
3425 return error;
3426
3427 /* If the workdir item does not exist, remove it from the index. */
3428 if ((delta->new_file.flags & GIT_DIFF_FLAG_EXISTS) == 0)
3429 error = git_index_remove_bypath(data->index, path);
3430 else
3431 error = git_index_add_bypath(data->index, delta->new_file.path);
3432
3433 return error;
3434 }
3435
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)3436 static int index_apply_to_wd_diff(git_index *index, int action, const git_strarray *paths,
3437 unsigned int flags,
3438 git_index_matched_path_cb cb, void *payload)
3439 {
3440 int error;
3441 git_diff *diff;
3442 git_pathspec ps;
3443 git_repository *repo;
3444 git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
3445 struct foreach_diff_data data = {
3446 index,
3447 NULL,
3448 flags,
3449 cb,
3450 payload,
3451 };
3452
3453 assert(index);
3454 assert(action == INDEX_ACTION_UPDATE || action == INDEX_ACTION_ADDALL);
3455
3456 repo = INDEX_OWNER(index);
3457
3458 if (!repo) {
3459 return create_index_error(-1,
3460 "cannot run update; the index is not backed up by a repository.");
3461 }
3462
3463 /*
3464 * We do the matching ourselves intead of passing the list to
3465 * diff because we want to tell the callback which one
3466 * matched, which we do not know if we ask diff to filter for us.
3467 */
3468 if ((error = git_pathspec__init(&ps, paths)) < 0)
3469 return error;
3470
3471 opts.flags = GIT_DIFF_INCLUDE_TYPECHANGE;
3472 if (action == INDEX_ACTION_ADDALL) {
3473 opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED |
3474 GIT_DIFF_RECURSE_UNTRACKED_DIRS;
3475
3476 if (flags == GIT_INDEX_ADD_FORCE)
3477 opts.flags |= GIT_DIFF_INCLUDE_IGNORED;
3478 }
3479
3480 if ((error = git_diff_index_to_workdir(&diff, repo, index, &opts)) < 0)
3481 goto cleanup;
3482
3483 data.pathspec = &ps;
3484 error = git_diff_foreach(diff, apply_each_file, NULL, NULL, NULL, &data);
3485 git_diff_free(diff);
3486
3487 if (error) /* make sure error is set if callback stopped iteration */
3488 git_error_set_after_callback(error);
3489
3490 cleanup:
3491 git_pathspec__clear(&ps);
3492 return error;
3493 }
3494
index_apply_to_all(git_index * index,int action,const git_strarray * paths,git_index_matched_path_cb cb,void * payload)3495 static int index_apply_to_all(
3496 git_index *index,
3497 int action,
3498 const git_strarray *paths,
3499 git_index_matched_path_cb cb,
3500 void *payload)
3501 {
3502 int error = 0;
3503 size_t i;
3504 git_pathspec ps;
3505 const char *match;
3506 git_buf path = GIT_BUF_INIT;
3507
3508 assert(index);
3509
3510 if ((error = git_pathspec__init(&ps, paths)) < 0)
3511 return error;
3512
3513 git_vector_sort(&index->entries);
3514
3515 for (i = 0; !error && i < index->entries.length; ++i) {
3516 git_index_entry *entry = git_vector_get(&index->entries, i);
3517
3518 /* check if path actually matches */
3519 if (!git_pathspec__match(
3520 &ps.pathspec, entry->path, false, (bool)index->ignore_case,
3521 &match, NULL))
3522 continue;
3523
3524 /* issue notification callback if requested */
3525 if (cb && (error = cb(entry->path, match, payload)) != 0) {
3526 if (error > 0) { /* return > 0 means skip this one */
3527 error = 0;
3528 continue;
3529 }
3530 if (error < 0) /* return < 0 means abort */
3531 break;
3532 }
3533
3534 /* index manipulation may alter entry, so don't depend on it */
3535 if ((error = git_buf_sets(&path, entry->path)) < 0)
3536 break;
3537
3538 switch (action) {
3539 case INDEX_ACTION_NONE:
3540 break;
3541 case INDEX_ACTION_UPDATE:
3542 error = git_index_add_bypath(index, path.ptr);
3543
3544 if (error == GIT_ENOTFOUND) {
3545 git_error_clear();
3546
3547 error = git_index_remove_bypath(index, path.ptr);
3548
3549 if (!error) /* back up foreach if we removed this */
3550 i--;
3551 }
3552 break;
3553 case INDEX_ACTION_REMOVE:
3554 if (!(error = git_index_remove_bypath(index, path.ptr)))
3555 i--; /* back up foreach if we removed this */
3556 break;
3557 default:
3558 git_error_set(GIT_ERROR_INVALID, "unknown index action %d", action);
3559 error = -1;
3560 break;
3561 }
3562 }
3563
3564 git_buf_dispose(&path);
3565 git_pathspec__clear(&ps);
3566
3567 return error;
3568 }
3569
git_index_remove_all(git_index * index,const git_strarray * pathspec,git_index_matched_path_cb cb,void * payload)3570 int git_index_remove_all(
3571 git_index *index,
3572 const git_strarray *pathspec,
3573 git_index_matched_path_cb cb,
3574 void *payload)
3575 {
3576 int error = index_apply_to_all(
3577 index, INDEX_ACTION_REMOVE, pathspec, cb, payload);
3578
3579 if (error) /* make sure error is set if callback stopped iteration */
3580 git_error_set_after_callback(error);
3581
3582 return error;
3583 }
3584
git_index_update_all(git_index * index,const git_strarray * pathspec,git_index_matched_path_cb cb,void * payload)3585 int git_index_update_all(
3586 git_index *index,
3587 const git_strarray *pathspec,
3588 git_index_matched_path_cb cb,
3589 void *payload)
3590 {
3591 int error = index_apply_to_wd_diff(index, INDEX_ACTION_UPDATE, pathspec, 0, cb, payload);
3592 if (error) /* make sure error is set if callback stopped iteration */
3593 git_error_set_after_callback(error);
3594
3595 return error;
3596 }
3597
git_index_snapshot_new(git_vector * snap,git_index * index)3598 int git_index_snapshot_new(git_vector *snap, git_index *index)
3599 {
3600 int error;
3601
3602 GIT_REFCOUNT_INC(index);
3603
3604 git_atomic_inc(&index->readers);
3605 git_vector_sort(&index->entries);
3606
3607 error = git_vector_dup(snap, &index->entries, index->entries._cmp);
3608
3609 if (error < 0)
3610 git_index_snapshot_release(snap, index);
3611
3612 return error;
3613 }
3614
git_index_snapshot_release(git_vector * snap,git_index * index)3615 void git_index_snapshot_release(git_vector *snap, git_index *index)
3616 {
3617 git_vector_free(snap);
3618
3619 git_atomic_dec(&index->readers);
3620
3621 git_index_free(index);
3622 }
3623
git_index_snapshot_find(size_t * out,git_vector * entries,git_vector_cmp entry_srch,const char * path,size_t path_len,int stage)3624 int git_index_snapshot_find(
3625 size_t *out, git_vector *entries, git_vector_cmp entry_srch,
3626 const char *path, size_t path_len, int stage)
3627 {
3628 return index_find_in_entries(out, entries, entry_srch, path, path_len, stage);
3629 }
3630
git_indexwriter_init(git_indexwriter * writer,git_index * index)3631 int git_indexwriter_init(
3632 git_indexwriter *writer,
3633 git_index *index)
3634 {
3635 int error;
3636
3637 GIT_REFCOUNT_INC(index);
3638
3639 writer->index = index;
3640
3641 if (!index->index_file_path)
3642 return create_index_error(-1,
3643 "failed to write index: The index is in-memory only");
3644
3645 if ((error = git_filebuf_open(
3646 &writer->file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS, GIT_INDEX_FILE_MODE)) < 0) {
3647
3648 if (error == GIT_ELOCKED)
3649 git_error_set(GIT_ERROR_INDEX, "the index is locked; this might be due to a concurrent or crashed process");
3650
3651 return error;
3652 }
3653
3654 writer->should_write = 1;
3655
3656 return 0;
3657 }
3658
git_indexwriter_init_for_operation(git_indexwriter * writer,git_repository * repo,unsigned int * checkout_strategy)3659 int git_indexwriter_init_for_operation(
3660 git_indexwriter *writer,
3661 git_repository *repo,
3662 unsigned int *checkout_strategy)
3663 {
3664 git_index *index;
3665 int error;
3666
3667 if ((error = git_repository_index__weakptr(&index, repo)) < 0 ||
3668 (error = git_indexwriter_init(writer, index)) < 0)
3669 return error;
3670
3671 writer->should_write = (*checkout_strategy & GIT_CHECKOUT_DONT_WRITE_INDEX) == 0;
3672 *checkout_strategy |= GIT_CHECKOUT_DONT_WRITE_INDEX;
3673
3674 return 0;
3675 }
3676
git_indexwriter_commit(git_indexwriter * writer)3677 int git_indexwriter_commit(git_indexwriter *writer)
3678 {
3679 int error;
3680 git_oid checksum = {{ 0 }};
3681
3682 if (!writer->should_write)
3683 return 0;
3684
3685 git_vector_sort(&writer->index->entries);
3686 git_vector_sort(&writer->index->reuc);
3687
3688 if ((error = write_index(&checksum, writer->index, &writer->file)) < 0) {
3689 git_indexwriter_cleanup(writer);
3690 return error;
3691 }
3692
3693 if ((error = git_filebuf_commit(&writer->file)) < 0)
3694 return error;
3695
3696 if ((error = git_futils_filestamp_check(
3697 &writer->index->stamp, writer->index->index_file_path)) < 0) {
3698 git_error_set(GIT_ERROR_OS, "could not read index timestamp");
3699 return -1;
3700 }
3701
3702 writer->index->dirty = 0;
3703 writer->index->on_disk = 1;
3704 git_oid_cpy(&writer->index->checksum, &checksum);
3705
3706 git_index_free(writer->index);
3707 writer->index = NULL;
3708
3709 return 0;
3710 }
3711
git_indexwriter_cleanup(git_indexwriter * writer)3712 void git_indexwriter_cleanup(git_indexwriter *writer)
3713 {
3714 git_filebuf_cleanup(&writer->file);
3715
3716 git_index_free(writer->index);
3717 writer->index = NULL;
3718 }
3719
3720 /* Deprecated functions */
3721
3722 #ifndef GIT_DEPRECATE_HARD
git_index_add_frombuffer(git_index * index,const git_index_entry * source_entry,const void * buffer,size_t len)3723 int git_index_add_frombuffer(
3724 git_index *index, const git_index_entry *source_entry,
3725 const void *buffer, size_t len)
3726 {
3727 return git_index_add_from_buffer(index, source_entry, buffer, len);
3728 }
3729 #endif
3730