rugged 1.1.1 → 1.4.3

data/vendor/libgit2/src/integer.h

@@ -43,10 +43,10 @@ GIT_INLINE(int) git__is_ulong(int64_t p)
 }
 
 /** @return true if p fits into the range of an int */
-GIT_INLINE(int) git__is_int(long long p)
+GIT_INLINE(int) git__is_int(int64_t p)
 {
 	int r = (int)p;
-	return p == (long long)r;
+	return p == (int64_t)r;
 }
 
 /* Use clang/gcc compiler intrinsics whenever possible */
@@ -80,6 +80,12 @@ GIT_INLINE(int) git__is_int(long long p)
 # define git__add_int64_overflow(out, one, two) \
     __builtin_add_overflow(one, two, out)
 
+/* clang on 32-bit systems produces an undefined reference to `__mulodi4`. */
+# if !defined(__clang__) || !defined(GIT_ARCH_32)
+#  define git__multiply_int64_overflow(out, one, two) \
+     __builtin_mul_overflow(one, two, out)
+# endif
+
 /* Use Microsoft's safe integer handling functions where available */
 #elif defined(_MSC_VER)
 
@@ -90,6 +96,7 @@ GIT_INLINE(int) git__is_int(long long p)
     (SizeTAdd(one, two, out) != S_OK)
 # define git__multiply_sizet_overflow(out, one, two) \
     (SizeTMult(one, two, out) != S_OK)
+
 #define git__add_int_overflow(out, one, two) \
     (IntAdd(one, two, out) != S_OK)
 #define git__sub_int_overflow(out, one, two) \
@@ -97,6 +104,8 @@ GIT_INLINE(int) git__is_int(long long p)
 
 #define git__add_int64_overflow(out, one, two) \
     (LongLongAdd(one, two, out) != S_OK)
+#define git__multiply_int64_overflow(out, one, two) \
+    (LongLongMult(one, two, out) != S_OK)
 
 #else
 
@@ -153,4 +162,57 @@ GIT_INLINE(bool) git__add_int64_overflow(int64_t *out, int64_t one, int64_t two)
 
 #endif
 
+/* If we could not provide an intrinsic implementation for this, provide a (slow) fallback. */
+#if !defined(git__multiply_int64_overflow)
+GIT_INLINE(bool) git__multiply_int64_overflow(int64_t *out, int64_t one, int64_t two)
+{
+	/*
+	 * Detects whether `INT64_MAX < (one * two) || INT64_MIN > (one * two)`,
+	 * without incurring in undefined behavior. That is done by performing the
+	 * comparison with a division instead of a multiplication, which translates
+	 * to `INT64_MAX / one < two || INT64_MIN / one > two`. Some caveats:
+	 *
+	 * - The comparison sign is inverted when both sides of the inequality are
+	 *   multiplied/divided by a negative number, so if `one < 0` the comparison
+	 *   needs to be flipped.
+	 * - `INT64_MAX / -1` itself overflows (or traps), so that case should be
+	 *   avoided.
+	 * - Since the overflow flag is defined as the discrepance between the result
+	 *   of performing the multiplication in a signed integer at twice the width
+	 *   of the operands, and the truncated+sign-extended version of that same
+	 *   result, there are four cases where the result is the opposite of what
+	 *   would be expected:
+	 *   * `INT64_MIN * -1` / `-1 * INT64_MIN`
+	 *   * `INT64_MIN * 1 / `1 * INT64_MIN`
+	 */
+	if (one && two) {
+		if (one > 0 && two > 0) {
+			if (INT64_MAX / one < two)
+				return true;
+		} else if (one < 0 && two < 0) {
+			if ((one == -1 && two == INT64_MIN) ||
+				  (two == -1 && one == INT64_MIN)) {
+				*out = INT64_MIN;
+				return false;
+			}
+			if (INT64_MAX / one > two)
+				return true;
+		} else if (one > 0 && two < 0) {
+			if ((one == 1 && two == INT64_MIN) ||
+			    (INT64_MIN / one > two))
+				return true;
+		} else if (one == -1) {
+			if (INT64_MIN / two > one)
+				return true;
+		} else {
+			if ((one == INT64_MIN && two == 1) ||
+			    (INT64_MIN / one < two))
+				return true;
+		}
+	}
+	*out = one * two;
+	return false;
+}
+#endif
+
 #endif

data/vendor/libgit2/src/iterator.c

@@ -9,6 +9,7 @@
 
 #include "tree.h"
 #include "index.h"
+#include "path.h"
 
 #define GIT_ITERATOR_FIRST_ACCESS   (1 << 15)
 #define GIT_ITERATOR_HONOR_IGNORES  (1 << 16)
@@ -292,7 +293,7 @@ typedef enum {
 	ITERATOR_PATHLIST_IS_FILE = 1,
 	ITERATOR_PATHLIST_IS_DIR = 2,
 	ITERATOR_PATHLIST_IS_PARENT = 3,
-	ITERATOR_PATHLIST_FULL = 4,
+	ITERATOR_PATHLIST_FULL = 4
 } iterator_pathlist_search_t;
 
 static iterator_pathlist_search_t iterator_pathlist_search(
@@ -330,7 +331,7 @@ static iterator_pathlist_search_t iterator_pathlist_search(
 			break;
 
 		/* an exact match would have been matched by the bsearch above */
-		assert(p[path_len]);
+		GIT_ASSERT_WITH_RETVAL(p[path_len], ITERATOR_PATHLIST_NONE);
 
 		/* is this a literal directory entry (eg `foo/`) or a file beneath */
 		if (p[path_len] == '/') {
@@ -424,7 +425,7 @@ typedef struct {
 	git_tree *tree;
 
 	/* path to this particular frame (folder) */
-	git_buf path;
+	git_str path;
 
 	/* a sorted list of the entries for this frame (folder), these are
 	 * actually pointers to the iterator's entry pool.
@@ -441,7 +442,7 @@ typedef struct {
 	 * parent path.
 	 */
 	git_vector similar_trees;
-	git_array_t(git_buf) similar_paths;
+	git_array_t(git_str) similar_paths;
 } tree_iterator_frame;
 
 typedef struct {
@@ -450,7 +451,7 @@ typedef struct {
 	git_array_t(tree_iterator_frame) frames;
 
 	git_index_entry entry;
-	git_buf entry_path;
+	git_str entry_path;
 
 	/* a pool of entries to reduce the number of allocations */
 	git_pool entry_pool;
@@ -472,7 +473,7 @@ GIT_INLINE(tree_iterator_frame *) tree_iterator_current_frame(
 GIT_INLINE(int) tree_entry_cmp(
 	const git_tree_entry *a, const git_tree_entry *b, bool icase)
 {
-	return git_path_cmp(
+	return git_fs_path_cmp(
 		a->filename, a->filename_len, a->attr == GIT_FILEMODE_TREE,
 		b->filename, b->filename_len, b->attr == GIT_FILEMODE_TREE,
 		icase ? git__strncasecmp : git__strncmp);
@@ -508,20 +509,20 @@ static int tree_iterator_entry_sort_icase(const void *ptr_a, const void *ptr_b)
 }
 
 static int tree_iterator_compute_path(
-	git_buf *out,
+	git_str *out,
 	tree_iterator_entry *entry)
 {
-	git_buf_clear(out);
+	git_str_clear(out);
 
 	if (entry->parent_path)
-		git_buf_joinpath(out, entry->parent_path, entry->tree_entry->filename);
+		git_str_joinpath(out, entry->parent_path, entry->tree_entry->filename);
 	else
-		git_buf_puts(out, entry->tree_entry->filename);
+		git_str_puts(out, entry->tree_entry->filename);
 
 	if (git_tree_entry__is_tree(entry->tree_entry))
-		git_buf_putc(out, '/');
+		git_str_putc(out, '/');
 
-	if (git_buf_oom(out))
+	if (git_str_oom(out))
 		return -1;
 
 	return 0;
@@ -601,7 +602,7 @@ GIT_INLINE(int) tree_iterator_frame_push_neighbors(
 	tree_iterator_entry *entry, *new_entry;
 	git_tree *tree = NULL;
 	git_tree_entry *tree_entry;
-	git_buf *path;
+	git_str *path;
 	size_t new_size, i;
 	int error = 0;
 
@@ -621,7 +622,7 @@ GIT_INLINE(int) tree_iterator_frame_push_neighbors(
 		path = git_array_alloc(parent_frame->similar_paths);
 		GIT_ERROR_CHECK_ALLOC(path);
 
-		memset(path, 0, sizeof(git_buf));
+		memset(path, 0, sizeof(git_str));
 
 		if ((error = tree_iterator_compute_path(path, entry)) < 0)
 			break;
@@ -678,14 +679,14 @@ done:
 	return error;
 }
 
-static void tree_iterator_frame_pop(tree_iterator *iter)
+static int tree_iterator_frame_pop(tree_iterator *iter)
 {
 	tree_iterator_frame *frame;
-	git_buf *buf = NULL;
+	git_str *buf = NULL;
 	git_tree *tree;
 	size_t i;
 
-	assert(iter->frames.size);
+	GIT_ASSERT(iter->frames.size);
 
 	frame = git_array_pop(iter->frames);
 
@@ -694,7 +695,7 @@ static void tree_iterator_frame_pop(tree_iterator *iter)
 
 	do {
 		buf = git_array_pop(frame->similar_paths);
-		git_buf_dispose(buf);
+		git_str_dispose(buf);
 	} while (buf != NULL);
 
 	git_array_clear(frame->similar_paths);
@@ -704,7 +705,9 @@ static void tree_iterator_frame_pop(tree_iterator *iter)
 
 	git_vector_free(&frame->similar_trees);
 
-	git_buf_dispose(&frame->path);
+	git_str_dispose(&frame->path);
+
+	return 0;
 }
 
 static int tree_iterator_current(
@@ -760,7 +763,9 @@ static int tree_iterator_advance(const git_index_entry **out, git_iterator *i)
 
 		/* no more entries in this frame.  pop the frame out */
 		if (frame->next_idx == frame->entries.length) {
-			tree_iterator_frame_pop(iter);
+			if ((error = tree_iterator_frame_pop(iter)) < 0)
+				break;
+
 			continue;
 		}
 
@@ -838,7 +843,7 @@ static int tree_iterator_advance_into(
 	const git_index_entry **out, git_iterator *i)
 {
 	tree_iterator *iter = (tree_iterator *)i;
-    tree_iterator_frame *frame;
+	tree_iterator_frame *frame;
 	tree_iterator_entry *prev_entry;
 	int error;
 
@@ -855,7 +860,7 @@ static int tree_iterator_advance_into(
 	 * we will have pushed a new (empty) frame on to the stack for this
 	 * new directory.  since it's empty, its current_entry should be null.
 	 */
-	assert(iterator__do_autoexpand(i) ^ (prev_entry != NULL));
+	GIT_ASSERT(iterator__do_autoexpand(i) ^ (prev_entry != NULL));
 
 	if (prev_entry) {
 		if (!git_tree_entry__is_tree(prev_entry->tree_entry))
@@ -888,7 +893,7 @@ static void tree_iterator_clear(tree_iterator *iter)
 	git_array_clear(iter->frames);
 
 	git_pool_clear(&iter->entry_pool);
-	git_buf_clear(&iter->entry_path);
+	git_str_clear(&iter->entry_path);
 
 	iterator_clear(&iter->base);
 }
@@ -921,7 +926,7 @@ static void tree_iterator_free(git_iterator *i)
 	tree_iterator_clear(iter);
 
 	git_tree_free(iter->root);
-	git_buf_dispose(&iter->entry_path);
+	git_str_dispose(&iter->entry_path);
 }
 
 int git_iterator_for_tree(
@@ -973,7 +978,7 @@ int git_iterator_current_tree_entry(
 	tree_iterator_frame *frame;
 	tree_iterator_entry *entry;
 
-	assert(i->type == GIT_ITERATOR_TREE);
+	GIT_ASSERT(i->type == GIT_ITERATOR_TREE);
 
 	iter = (tree_iterator *)i;
 
@@ -990,11 +995,11 @@ int git_iterator_current_parent_tree(
 	tree_iterator *iter;
 	tree_iterator_frame *frame;
 
-	assert(i->type == GIT_ITERATOR_TREE);
+	GIT_ASSERT(i->type == GIT_ITERATOR_TREE);
 
 	iter = (tree_iterator *)i;
 
-	assert(depth < iter->frames.size);
+	GIT_ASSERT(depth < iter->frames.size);
 	frame = &iter->frames.ptr[iter->frames.size-depth-1];
 
 	*parent_tree = frame->tree;
@@ -1036,11 +1041,11 @@ typedef struct {
 
 	/* info about the current entry */
 	git_index_entry entry;
-	git_buf current_path;
+	git_str current_path;
 	int current_is_ignored;
 
 	/* temporary buffer for advance_over */
-	git_buf tmp_buf;
+	git_str tmp_buf;
 } filesystem_iterator;
 
 
@@ -1262,7 +1267,7 @@ static int filesystem_iterator_entry_hash(
 	filesystem_iterator *iter,
 	filesystem_iterator_entry *entry)
 {
-	git_buf fullpath = GIT_BUF_INIT;
+	git_str fullpath = GIT_STR_INIT;
 	int error;
 
 	if (S_ISDIR(entry->st.st_mode)) {
@@ -1274,10 +1279,11 @@ static int filesystem_iterator_entry_hash(
 		return git_repository_hashfile(&entry->id,
 			iter->base.repo, entry->path, GIT_OBJECT_BLOB, NULL);
 
-	if (!(error = git_buf_joinpath(&fullpath, iter->root, entry->path)))
+	if (!(error = git_str_joinpath(&fullpath, iter->root, entry->path)) &&
+	    !(error = git_path_validate_str_length(iter->base.repo, &fullpath)))
 		error = git_odb_hashfile(&entry->id, fullpath.ptr, GIT_OBJECT_BLOB);
 
-	git_buf_dispose(&fullpath);
+	git_str_dispose(&fullpath);
 	return error;
 }
 
@@ -1331,8 +1337,8 @@ static int filesystem_iterator_frame_push(
 	filesystem_iterator_entry *frame_entry)
 {
 	filesystem_iterator_frame *new_frame = NULL;
-	git_path_diriter diriter = GIT_PATH_DIRITER_INIT;
-	git_buf root = GIT_BUF_INIT;
+	git_fs_path_diriter diriter = GIT_FS_PATH_DIRITER_INIT;
+	git_str root = GIT_STR_INIT;
 	const char *path;
 	filesystem_iterator_entry *entry;
 	struct stat statbuf;
@@ -1351,11 +1357,12 @@ static int filesystem_iterator_frame_push(
 	memset(new_frame, 0, sizeof(filesystem_iterator_frame));
 
 	if (frame_entry)
-		git_buf_joinpath(&root, iter->root, frame_entry->path);
+		git_str_joinpath(&root, iter->root, frame_entry->path);
 	else
-		git_buf_puts(&root, iter->root);
+		git_str_puts(&root, iter->root);
 
-	if (git_buf_oom(&root)) {
+	if (git_str_oom(&root) ||
+	    git_path_validate_str_length(iter->base.repo, &root) < 0) {
 		error = -1;
 		goto done;
 	}
@@ -1363,7 +1370,7 @@ static int filesystem_iterator_frame_push(
 	new_frame->path_len = frame_entry ? frame_entry->path_len : 0;
 
 	/* Any error here is equivalent to the dir not existing, skip over it */
-	if ((error = git_path_diriter_init(
+	if ((error = git_fs_path_diriter_init(
 			&diriter, root.ptr, iter->dirload_flags)) < 0) {
 		error = GIT_ENOTFOUND;
 		goto done;
@@ -1381,14 +1388,21 @@ static int filesystem_iterator_frame_push(
 	/* check if this directory is ignored */
 	filesystem_iterator_frame_push_ignores(iter, frame_entry, new_frame);
 
-	while ((error = git_path_diriter_next(&diriter)) == 0) {
+	while ((error = git_fs_path_diriter_next(&diriter)) == 0) {
 		iterator_pathlist_search_t pathlist_match = ITERATOR_PATHLIST_FULL;
+		git_str path_str = GIT_STR_INIT;
 		bool dir_expected = false;
 
-		if ((error = git_path_diriter_fullpath(&path, &path_len, &diriter)) < 0)
+		if ((error = git_fs_path_diriter_fullpath(&path, &path_len, &diriter)) < 0)
+			goto done;
+
+		path_str.ptr = (char *)path;
+		path_str.size = path_len;
+
+		if ((error = git_path_validate_str_length(iter->base.repo, &path_str)) < 0)
 			goto done;
 
-		assert(path_len > iter->root_len);
+		GIT_ASSERT(path_len > iter->root_len);
 
 		/* remove the prefix if requested */
 		path += iter->root_len;
@@ -1407,7 +1421,7 @@ static int filesystem_iterator_frame_push(
 		 * we have an index, we can just copy the data out of it.
 		 */
 
-		if ((error = git_path_diriter_stat(&statbuf, &diriter)) < 0) {
+		if ((error = git_fs_path_diriter_stat(&statbuf, &diriter)) < 0) {
 			/* file was removed between readdir and lstat */
 			if (error == GIT_ENOTFOUND)
 				continue;
@@ -1464,22 +1478,24 @@ done:
 	if (error < 0)
 		git_array_pop(iter->frames);
 
-	git_buf_dispose(&root);
-	git_path_diriter_free(&diriter);
+	git_str_dispose(&root);
+	git_fs_path_diriter_free(&diriter);
 	return error;
 }
 
-GIT_INLINE(void) filesystem_iterator_frame_pop(filesystem_iterator *iter)
+GIT_INLINE(int) filesystem_iterator_frame_pop(filesystem_iterator *iter)
 {
 	filesystem_iterator_frame *frame;
 
-	assert(iter->frames.size);
+	GIT_ASSERT(iter->frames.size);
 
 	frame = git_array_pop(iter->frames);
 	filesystem_iterator_frame_pop_ignores(iter);
 
 	git_pool_clear(&frame->entry_pool);
 	git_vector_free(&frame->entries);
+
+	return 0;
 }
 
 static void filesystem_iterator_set_current(
@@ -1542,7 +1558,7 @@ static int filesystem_iterator_is_dir(
 	const filesystem_iterator_entry *entry)
 {
 	struct stat st;
-	git_buf fullpath = GIT_BUF_INIT;
+	git_str fullpath = GIT_STR_INIT;
 	int error = 0;
 
 	if (S_ISDIR(entry->st.st_mode)) {
@@ -1555,14 +1571,15 @@ static int filesystem_iterator_is_dir(
 		goto done;
 	}
 
-	if ((error = git_buf_joinpath(&fullpath, iter->root, entry->path)) < 0 ||
-		(error = p_stat(fullpath.ptr, &st)) < 0)
+	if ((error = git_str_joinpath(&fullpath, iter->root, entry->path)) < 0 ||
+	    (error = git_path_validate_str_length(iter->base.repo, &fullpath)) < 0 ||
+	    (error = p_stat(fullpath.ptr, &st)) < 0)
 		goto done;
 
 	*is_dir = S_ISDIR(st.st_mode);
 
 done:
-	git_buf_dispose(&fullpath);
+	git_str_dispose(&fullpath);
 	return error;
 }
 
@@ -1646,7 +1663,7 @@ static int filesystem_iterator_advance_into(
 	 * we will have pushed a new (empty) frame on to the stack for this
 	 * new directory.  since it's empty, its current_entry should be null.
 	 */
-	assert(iterator__do_autoexpand(i) ^ (prev_entry != NULL));
+	GIT_ASSERT(iterator__do_autoexpand(i) ^ (prev_entry != NULL));
 
 	if (prev_entry) {
 		if (prev_entry->st.st_mode != GIT_FILEMODE_COMMIT &&
@@ -1663,7 +1680,7 @@ static int filesystem_iterator_advance_into(
 	return filesystem_iterator_advance(out, i);
 }
 
-int git_iterator_current_workdir_path(git_buf **out, git_iterator *i)
+int git_iterator_current_workdir_path(git_str **out, git_iterator *i)
 {
 	filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base);
 	const git_index_entry *entry;
@@ -1674,10 +1691,10 @@ int git_iterator_current_workdir_path(git_buf **out, git_iterator *i)
 		return 0;
 	}
 
-	git_buf_truncate(&iter->current_path, iter->root_len);
+	git_str_truncate(&iter->current_path, iter->root_len);
 
 	if (git_iterator_current(&entry, i) < 0 ||
-		git_buf_puts(&iter->current_path, entry->path) < 0)
+		git_str_puts(&iter->current_path, entry->path) < 0)
 		return -1;
 
 	*out = &iter->current_path;
@@ -1762,12 +1779,13 @@ static int filesystem_iterator_advance_over(
 	*out = NULL;
 	*status = GIT_ITERATOR_STATUS_NORMAL;
 
-	assert(iterator__has_been_accessed(i));
+	GIT_ASSERT(iterator__has_been_accessed(i));
 
 	current_frame = filesystem_iterator_current_frame(iter);
-	assert(current_frame);
+	GIT_ASSERT(current_frame);
+
 	current_entry = filesystem_iterator_current_entry(current_frame);
-	assert(current_entry);
+	GIT_ASSERT(current_entry);
 
 	if ((error = git_iterator_current(&entry, i)) < 0)
 		return error;
@@ -1779,8 +1797,8 @@ static int filesystem_iterator_advance_over(
 		return filesystem_iterator_advance(out, i);
 	}
 
-	git_buf_clear(&iter->tmp_buf);
-	if ((error = git_buf_puts(&iter->tmp_buf, entry->path)) < 0)
+	git_str_clear(&iter->tmp_buf);
+	if ((error = git_str_puts(&iter->tmp_buf, entry->path)) < 0)
 		return error;
 
 	base = iter->tmp_buf.ptr;
@@ -1847,7 +1865,7 @@ static void filesystem_iterator_clear(filesystem_iterator *iter)
 	git_array_clear(iter->frames);
 	git_ignore__free(&iter->ignores);
 
-	git_buf_dispose(&iter->tmp_buf);
+	git_str_dispose(&iter->tmp_buf);
 
 	iterator_clear(&iter->base);
 }
@@ -1881,7 +1899,7 @@ static void filesystem_iterator_free(git_iterator *i)
 {
 	filesystem_iterator *iter = GIT_CONTAINER_OF(i, filesystem_iterator, base);
 	git__free(iter->root);
-	git_buf_dispose(&iter->current_path);
+	git_str_dispose(&iter->current_path);
 	git_tree_free(iter->tree);
 	if (iter->index)
 		git_index_snapshot_release(&iter->index_snapshot, iter->index);
@@ -1935,7 +1953,7 @@ static int iterator_for_filesystem(
 	iter->root[root_len] = '\0';
 	iter->root_len = root_len;
 
-	if ((error = git_buf_puts(&iter->current_path, iter->root)) < 0)
+	if ((error = git_str_puts(&iter->current_path, iter->root)) < 0)
 		goto on_error;
 
 	if ((error = iterator_init_common(&iter->base, repo, index, options)) < 0)
@@ -1950,9 +1968,10 @@ static int iterator_for_filesystem(
 
 	iter->index = index;
 	iter->dirload_flags =
-		(iterator__ignore_case(&iter->base) ? GIT_PATH_DIR_IGNORE_CASE : 0) |
+		(iterator__ignore_case(&iter->base) ?
+			GIT_FS_PATH_DIR_IGNORE_CASE : 0) |
 		(iterator__flag(&iter->base, PRECOMPOSE_UNICODE) ?
-			 GIT_PATH_DIR_PRECOMPOSE_UNICODE : 0);
+			GIT_FS_PATH_DIR_PRECOMPOSE_UNICODE : 0);
 
 	if ((error = filesystem_iterator_init(iter)) < 0)
 		goto on_error;
@@ -2013,7 +2032,7 @@ typedef struct {
 
 	/* the pseudotree entry */
 	git_index_entry tree_entry;
-	git_buf tree_buf;
+	git_str tree_buf;
 	bool skip_tree;
 
 	const git_index_entry *entry;
@@ -2047,14 +2066,14 @@ static bool index_iterator_create_pseudotree(
 	prev_path = iter->entry ? iter->entry->path : "";
 
 	/* determine if the new path is in a different directory from the old */
-	common_len = git_path_common_dirlen(prev_path, path);
+	common_len = git_fs_path_common_dirlen(prev_path, path);
 	relative_path = path + common_len;
 
 	if ((dirsep = strchr(relative_path, '/')) == NULL)
 		return false;
 
-	git_buf_clear(&iter->tree_buf);
-	git_buf_put(&iter->tree_buf, path, (dirsep - path) + 1);
+	git_str_clear(&iter->tree_buf);
+	git_str_put(&iter->tree_buf, path, (dirsep - path) + 1);
 
 	iter->tree_entry.mode = GIT_FILEMODE_TREE;
 	iter->tree_entry.path = iter->tree_buf.ptr;
@@ -2065,8 +2084,8 @@ static bool index_iterator_create_pseudotree(
 
 static int index_iterator_skip_pseudotree(index_iterator *iter)
 {
-	assert(iterator__has_been_accessed(&iter->base));
-	assert(S_ISDIR(iter->entry->mode));
+	GIT_ASSERT(iterator__has_been_accessed(&iter->base));
+	GIT_ASSERT(S_ISDIR(iter->entry->mode));
 
 	while (true) {
 		const git_index_entry *next_entry = NULL;
@@ -2219,7 +2238,7 @@ static void index_iterator_free(git_iterator *i)
 	index_iterator *iter = GIT_CONTAINER_OF(i, index_iterator, base);
 
 	git_index_snapshot_release(&iter->entries, iter->base.index);
-	git_buf_dispose(&iter->tree_buf);
+	git_str_dispose(&iter->tree_buf);
 }
 
 int git_iterator_for_index(
@@ -2280,10 +2299,11 @@ int git_iterator_reset_range(
 	return i->cb->reset(i);
 }
 
-void git_iterator_set_ignore_case(git_iterator *i, bool ignore_case)
+int git_iterator_set_ignore_case(git_iterator *i, bool ignore_case)
 {
-	assert(!iterator__has_been_accessed(i));
+	GIT_ASSERT(!iterator__has_been_accessed(i));
 	iterator_set_ignore_case(i, ignore_case);
+	return 0;
 }
 
 void git_iterator_free(git_iterator *iter)

data/vendor/libgit2/src/iterator.h

@@ -11,7 +11,7 @@
 
 #include "git2/index.h"
 #include "vector.h"
-#include "buffer.h"
+#include "str.h"
 #include "ignore.h"
 
 typedef struct git_iterator git_iterator;
@@ -21,7 +21,7 @@ typedef enum {
 	GIT_ITERATOR_TREE = 1,
 	GIT_ITERATOR_INDEX = 2,
 	GIT_ITERATOR_WORKDIR = 3,
-	GIT_ITERATOR_FS = 4,
+	GIT_ITERATOR_FS = 4
 } git_iterator_t;
 
 typedef enum {
@@ -42,7 +42,7 @@ typedef enum {
 	/** descend into symlinked directories */
 	GIT_ITERATOR_DESCEND_SYMLINKS = (1u << 7),
 	/** hash files in workdir or filesystem iterators */
-	GIT_ITERATOR_INCLUDE_HASH = (1u << 8),
+	GIT_ITERATOR_INCLUDE_HASH = (1u << 8)
 } git_iterator_flag_t;
 
 typedef enum {
@@ -263,7 +263,7 @@ GIT_INLINE(bool) git_iterator_ignore_case(git_iterator *iter)
 	return ((iter->flags & GIT_ITERATOR_IGNORE_CASE) != 0);
 }
 
-extern void git_iterator_set_ignore_case(
+extern int git_iterator_set_ignore_case(
 	git_iterator *iter, bool ignore_case);
 
 extern int git_iterator_current_tree_entry(
@@ -278,11 +278,11 @@ extern bool git_iterator_current_tree_is_ignored(git_iterator *iter);
 
 /**
  * Get full path of the current item from a workdir iterator.  This will
- * return NULL for a non-workdir iterator.  The git_buf is still owned by
+ * return NULL for a non-workdir iterator.  The git_str is still owned by
  * the iterator; this is exposed just for efficiency.
  */
 extern int git_iterator_current_workdir_path(
-	git_buf **path, git_iterator *iter);
+	git_str **path, git_iterator *iter);
 
 /**
  * Retrieve the index stored in the iterator.