rugged 1.6.3 → 1.9.0

data/vendor/libgit2/src/libgit2/merge.c

@@ -32,7 +32,6 @@
 #include "commit.h"
 #include "oidarray.h"
 #include "merge_driver.h"
-#include "oidmap.h"
 #include "array.h"
 
 #include "git2/types.h"
@@ -124,11 +123,11 @@ static int merge_bases_many(git_commit_list **out, git_revwalk **walk_out, git_r
 	*out = result;
 	*walk_out = walk;
 
-	git_vector_free(&list);
+	git_vector_dispose(&list);
 	return 0;
 
 on_error:
-	git_vector_free(&list);
+	git_vector_dispose(&list);
 	git_revwalk_free(walk);
 	return error;
 }
@@ -511,7 +510,7 @@ static int remove_redundant(git_revwalk *walk, git_vector *commits, uint32_t min
 done:
 	git__free(redundant);
 	git__free(filled_index);
-	git_vector_free(&work);
+	git_vector_dispose(&work);
 	return error;
 }
 
@@ -570,7 +569,7 @@ int git_merge__bases_many(
 		if ((error = clear_commit_marks(one, ALL_FLAGS)) < 0 ||
 		    (error = clear_commit_marks_many(twos, ALL_FLAGS)) < 0 ||
 		    (error = remove_redundant(walk, &redundant, minimum_generation)) < 0) {
-			git_vector_free(&redundant);
+			git_vector_dispose(&redundant);
 			return error;
 		}
 
@@ -579,7 +578,7 @@ int git_merge__bases_many(
 				git_commit_list_insert_by_date(two, &result);
 		}
 
-		git_vector_free(&redundant);
+		git_vector_dispose(&redundant);
 	}
 
 	*out = result;
@@ -611,13 +610,13 @@ int git_repository_mergehead_foreach(
 	buffer = merge_head_file.ptr;
 
 	while ((line = git__strsep(&buffer, "\n")) != NULL) {
-		if (strlen(line) != GIT_OID_SHA1_HEXSIZE) {
+		if (strlen(line) != git_oid_hexsize(repo->oid_type)) {
 			git_error_set(GIT_ERROR_INVALID, "unable to parse OID - invalid length");
 			error = -1;
 			goto cleanup;
 		}
 
-		if ((error = git_oid__fromstr(&oid, line, GIT_OID_SHA1)) < 0)
+		if ((error = git_oid__fromstr(&oid, line, repo->oid_type)) < 0)
 			goto cleanup;
 
 		if ((error = cb(&oid, payload)) != 0) {
@@ -1061,7 +1060,7 @@ static int index_entry_similarity_calc(
 	const git_merge_options *opts)
 {
 	git_blob *blob;
-	git_diff_file diff_file = { GIT_OID_SHA1_ZERO };
+	git_diff_file diff_file;
 	git_object_size_t blobsize;
 	int error;
 
@@ -1070,6 +1069,8 @@ static int index_entry_similarity_calc(
 
 	*out = NULL;
 
+	git_oid_clear(&diff_file.id, repo->oid_type);
+
 	if ((error = git_blob_lookup(&blob, repo, &entry->id)) < 0)
 		return error;
 
@@ -1142,24 +1143,28 @@ typedef struct {
 	size_t first_entry;
 } deletes_by_oid_queue;
 
-static void deletes_by_oid_free(git_oidmap *map) {
+GIT_HASHMAP_OID_SETUP(git_merge_deletes_oidmap, deletes_by_oid_queue *);
+
+static void deletes_by_oid_dispose(git_merge_deletes_oidmap *map)
+{
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 	deletes_by_oid_queue *queue;
 
 	if (!map)
 		return;
 
-	git_oidmap_foreach_value(map, queue, {
+	while (git_merge_deletes_oidmap_iterate(&iter, NULL, &queue, map) == 0)
 		git_array_clear(queue->arr);
-	});
-	git_oidmap_free(map);
+
+	git_merge_deletes_oidmap_dispose(map);
 }
 
-static int deletes_by_oid_enqueue(git_oidmap *map, git_pool *pool, const git_oid *id, size_t idx)
+static int deletes_by_oid_enqueue(git_merge_deletes_oidmap *map, git_pool *pool, const git_oid *id, size_t idx)
 {
 	deletes_by_oid_queue *queue;
 	size_t *array_entry;
 
-	if ((queue = git_oidmap_get(map, id)) == NULL) {
+	if (git_merge_deletes_oidmap_get(&queue, map, id) != 0) {
 		queue = git_pool_malloc(pool, sizeof(deletes_by_oid_queue));
 		GIT_ERROR_CHECK_ALLOC(queue);
 
@@ -1167,7 +1172,7 @@ static int deletes_by_oid_enqueue(git_oidmap *map, git_pool *pool, const git_oid
 		queue->next_pos = 0;
 		queue->first_entry = idx;
 
-		if (git_oidmap_set(map, id, queue) < 0)
+		if (git_merge_deletes_oidmap_put(map, id, queue) < 0)
 			return -1;
 	} else {
 		array_entry = git_array_alloc(queue->arr);
@@ -1178,13 +1183,14 @@ static int deletes_by_oid_enqueue(git_oidmap *map, git_pool *pool, const git_oid
 	return 0;
 }
 
-static int deletes_by_oid_dequeue(size_t *idx, git_oidmap *map, const git_oid *id)
+static int deletes_by_oid_dequeue(size_t *idx, git_merge_deletes_oidmap *map, const git_oid *id)
 {
 	deletes_by_oid_queue *queue;
 	size_t *array_entry;
+	int error;
 
-	if ((queue = git_oidmap_get(map, id)) == NULL)
-		return GIT_ENOTFOUND;
+	if ((error = git_merge_deletes_oidmap_get(&queue, map, id)) != 0)
+		return error;
 
 	if (queue->next_pos == 0) {
 		*idx = queue->first_entry;
@@ -1207,15 +1213,10 @@ static int merge_diff_mark_similarity_exact(
 {
 	size_t i, j;
 	git_merge_diff *conflict_src, *conflict_tgt;
-	git_oidmap *ours_deletes_by_oid = NULL, *theirs_deletes_by_oid = NULL;
+	git_merge_deletes_oidmap ours_deletes_by_oid = GIT_HASHMAP_INIT,
+	                         theirs_deletes_by_oid = GIT_HASHMAP_INIT;
 	int error = 0;
 
-	if (git_oidmap_new(&ours_deletes_by_oid) < 0 ||
-	    git_oidmap_new(&theirs_deletes_by_oid) < 0) {
-		error = -1;
-		goto done;
-	}
-
 	/* Build a map of object ids to conflicts */
 	git_vector_foreach(&diff_list->conflicts, i, conflict_src) {
 		/* Items can be the source of a rename iff they have an item in the
@@ -1223,14 +1224,21 @@ static int merge_diff_mark_similarity_exact(
 		if (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_src->ancestor_entry))
 			continue;
 
+		/*
+		 * Ignore empty files because it has always the same blob sha1
+		 * and will lead to incorrect matches between all entries.
+		 */
+		if (git_oid_equal(&conflict_src->ancestor_entry.id, &git_oid__empty_blob_sha1))
+			continue;
+
 		if (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_src->our_entry)) {
-			error = deletes_by_oid_enqueue(ours_deletes_by_oid, &diff_list->pool, &conflict_src->ancestor_entry.id, i);
+			error = deletes_by_oid_enqueue(&ours_deletes_by_oid, &diff_list->pool, &conflict_src->ancestor_entry.id, i);
 			if (error < 0)
 				goto done;
 		}
 
 		if (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_src->their_entry)) {
-			error = deletes_by_oid_enqueue(theirs_deletes_by_oid, &diff_list->pool, &conflict_src->ancestor_entry.id, i);
+			error = deletes_by_oid_enqueue(&theirs_deletes_by_oid, &diff_list->pool, &conflict_src->ancestor_entry.id, i);
 			if (error < 0)
 				goto done;
 		}
@@ -1241,7 +1249,7 @@ static int merge_diff_mark_similarity_exact(
 			continue;
 
 		if (GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_tgt->our_entry)) {
-			if (deletes_by_oid_dequeue(&i, ours_deletes_by_oid, &conflict_tgt->our_entry.id) == 0) {
+			if (deletes_by_oid_dequeue(&i, &ours_deletes_by_oid, &conflict_tgt->our_entry.id) == 0) {
 				similarity_ours[i].similarity = 100;
 				similarity_ours[i].other_idx = j;
 
@@ -1251,7 +1259,7 @@ static int merge_diff_mark_similarity_exact(
 		}
 
 		if (GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_tgt->their_entry)) {
-			if (deletes_by_oid_dequeue(&i, theirs_deletes_by_oid, &conflict_tgt->their_entry.id) == 0) {
+			if (deletes_by_oid_dequeue(&i, &theirs_deletes_by_oid, &conflict_tgt->their_entry.id) == 0) {
 				similarity_theirs[i].similarity = 100;
 				similarity_theirs[i].other_idx = j;
 
@@ -1262,8 +1270,8 @@ static int merge_diff_mark_similarity_exact(
 	}
 
 done:
-	deletes_by_oid_free(ours_deletes_by_oid);
-	deletes_by_oid_free(theirs_deletes_by_oid);
+	deletes_by_oid_dispose(&ours_deletes_by_oid);
+	deletes_by_oid_dispose(&theirs_deletes_by_oid);
 
 	return error;
 }
@@ -1857,9 +1865,9 @@ void git_merge_diff_list__free(git_merge_diff_list *diff_list)
 	if (!diff_list)
 		return;
 
-	git_vector_free(&diff_list->staged);
-	git_vector_free(&diff_list->conflicts);
-	git_vector_free(&diff_list->resolved);
+	git_vector_dispose(&diff_list->staged);
+	git_vector_dispose(&diff_list->conflicts);
+	git_vector_dispose(&diff_list->resolved);
 	git_pool_clear(&diff_list->pool);
 	git__free(diff_list);
 }
@@ -1997,8 +2005,11 @@ static int index_update_reuc(git_index *index, git_merge_diff_list *diff_list)
 	return 0;
 }
 
-static int index_from_diff_list(git_index **out,
-	git_merge_diff_list *diff_list, bool skip_reuc)
+static int index_from_diff_list(
+	git_index **out,
+	git_merge_diff_list *diff_list,
+	git_oid_t oid_type,
+	bool skip_reuc)
 {
 	git_index *index;
 	size_t i;
@@ -2007,7 +2018,7 @@ static int index_from_diff_list(git_index **out,
 
 	*out = NULL;
 
-	if ((error = git_index_new(&index)) < 0)
+	if ((error = git_index__new(&index, oid_type)) < 0)
 		return error;
 
 	if ((error = git_index__fill(index, &diff_list->staged)) < 0)
@@ -2157,7 +2168,7 @@ int git_merge__iterators(
 		}
 	}
 
-	error = index_from_diff_list(out, diff_list,
+	error = index_from_diff_list(out, diff_list, repo->oid_type,
 		(opts.flags & GIT_MERGE_SKIP_REUC));
 
 done:
@@ -2200,8 +2211,8 @@ int git_merge_trees(
 			result = our_tree;
 
 		if (result) {
-			if ((error = git_index_new(out)) == 0)
-    			error = git_index_read_tree(*out, result);
+			if ((error = git_index__new(out, repo->oid_type)) == 0)
+				error = git_index_read_tree(*out, result);
 
 			return error;
 		}
@@ -2824,7 +2835,7 @@ cleanup:
 
 	git_str_dispose(&file_path);
 
-	git_vector_free(&matching);
+	git_vector_dispose(&matching);
 	git__free(entries);
 
 	return error;
@@ -3003,7 +3014,7 @@ done:
 	git_iterator_free(iter_new);
 	git_diff_free(staged_diff_list);
 	git_diff_free(index_diff_list);
-	git_vector_free(&staged_paths);
+	git_vector_dispose(&staged_paths);
 
 	return error;
 }
@@ -3100,7 +3111,7 @@ int git_merge__check_result(git_repository *repo, git_index *index_new)
 	}
 
 done:
-	git_vector_free(&paths);
+	git_vector_dispose(&paths);
 	git_tree_free(head_tree);
 	git_iterator_free(iter_head);
 	git_iterator_free(iter_new);
@@ -3341,8 +3352,7 @@ int git_merge(
 		goto done;
 
 	checkout_strategy = given_checkout_opts ?
-		given_checkout_opts->checkout_strategy :
-		GIT_CHECKOUT_SAFE;
+		given_checkout_opts->checkout_strategy : 0;
 
 	if ((error = git_indexwriter_init_for_operation(&indexwriter, repo,
 		&checkout_strategy)) < 0)

data/vendor/libgit2/src/libgit2/merge_driver.c

@@ -218,7 +218,7 @@ int git_merge_driver_global_init(void)
 
 done:
 	if (error < 0)
-		git_vector_free_deep(&merge_driver_registry.drivers);
+		git_vector_dispose_deep(&merge_driver_registry.drivers);
 
 	return error;
 }
@@ -238,7 +238,7 @@ static void git_merge_driver_global_shutdown(void)
 		git__free(entry);
 	}
 
-	git_vector_free(&merge_driver_registry.drivers);
+	git_vector_dispose(&merge_driver_registry.drivers);
 
 	git_rwlock_wrunlock(&merge_driver_registry.lock);
 	git_rwlock_free(&merge_driver_registry.lock);

data/vendor/libgit2/src/libgit2/merge_file.c

@@ -19,8 +19,6 @@
 #include "git2/index.h"
 #include "git2/merge.h"
 
-#include "xdiff/xdiff.h"
-
 /* only examine the first 8000 bytes for binaryness.
  * https://github.com/git/git/blob/77bd3ea9f54f1584147b594abc04c26ca516d987/xdiff-interface.c#L197
  */

data/vendor/libgit2/src/libgit2/midx.c

@@ -114,23 +114,16 @@ static int midx_parse_oid_lookup(
 		const unsigned char *data,
 		struct git_midx_chunk *chunk_oid_lookup)
 {
-	uint32_t i;
-	unsigned char *oid, *prev_oid, zero_oid[GIT_OID_SHA1_SIZE] = {0};
+	size_t oid_size = git_oid_size(idx->oid_type);
 
 	if (chunk_oid_lookup->offset == 0)
 		return midx_error("missing OID Lookup chunk");
 	if (chunk_oid_lookup->length == 0)
 		return midx_error("empty OID Lookup chunk");
-	if (chunk_oid_lookup->length != idx->num_objects * GIT_OID_SHA1_SIZE)
+	if (chunk_oid_lookup->length != idx->num_objects * oid_size)
 		return midx_error("OID Lookup chunk has wrong length");
 
-	idx->oid_lookup = oid = (unsigned char *)(data + chunk_oid_lookup->offset);
-	prev_oid = zero_oid;
-	for (i = 0; i < idx->num_objects; ++i, oid += GIT_OID_SHA1_SIZE) {
-		if (git_oid_raw_cmp(prev_oid, oid, GIT_OID_SHA1_SIZE) >= 0)
-			return midx_error("OID Lookup index is non-monotonic");
-		prev_oid = oid;
-	}
+	idx->oid_lookup = (unsigned char *)(data + chunk_oid_lookup->offset);
 
 	return 0;
 }
@@ -178,17 +171,20 @@ int git_midx_parse(
 	struct git_midx_chunk *last_chunk;
 	uint32_t i;
 	off64_t last_chunk_offset, chunk_offset, trailer_offset;
-	size_t checksum_size;
+	size_t checksum_size, oid_size;
 	int error;
 	struct git_midx_chunk chunk_packfile_names = {0},
 					 chunk_oid_fanout = {0},
 					 chunk_oid_lookup = {0},
 					 chunk_object_offsets = {0},
-					 chunk_object_large_offsets = {0};
+					 chunk_object_large_offsets = {0},
+					 chunk_unknown = {0};
 
 	GIT_ASSERT_ARG(idx);
 
-	if (size < sizeof(struct git_midx_header) + GIT_OID_SHA1_SIZE)
+	oid_size = git_oid_size(idx->oid_type);
+
+	if (size < sizeof(struct git_midx_header) + oid_size)
 		return midx_error("multi-pack index is too short");
 
 	hdr = ((struct git_midx_header *)data);
@@ -209,7 +205,7 @@ int git_midx_parse(
 			sizeof(struct git_midx_header) +
 			(1 + hdr->chunks) * 12;
 
-	checksum_size = GIT_HASH_SHA1_SIZE;
+	checksum_size = oid_size;
 	trailer_offset = size - checksum_size;
 
 	if (trailer_offset < last_chunk_offset)
@@ -261,7 +257,9 @@ int git_midx_parse(
 			break;
 
 		default:
-			return midx_error("unrecognized chunk ID");
+			chunk_unknown.offset = last_chunk_offset;
+			last_chunk = &chunk_unknown;
+			break;
 		}
 	}
 	last_chunk->length = (size_t)(trailer_offset - last_chunk_offset);
@@ -287,8 +285,9 @@ int git_midx_parse(
 }
 
 int git_midx_open(
-		git_midx_file **idx_out,
-		const char *path)
+	git_midx_file **idx_out,
+	const char *path,
+	git_oid_t oid_type)
 {
 	git_midx_file *idx;
 	git_file fd = -1;
@@ -296,6 +295,8 @@ int git_midx_open(
 	struct stat st;
 	int error;
 
+	GIT_ASSERT_ARG(idx_out && path && oid_type);
+
 	/* TODO: properly open the file without access time using O_NOATIME */
 	fd = git_futils_open_ro(path);
 	if (fd < 0)
@@ -317,6 +318,8 @@ int git_midx_open(
 	idx = git__calloc(1, sizeof(git_midx_file));
 	GIT_ERROR_CHECK_ALLOC(idx);
 
+	idx->oid_type = oid_type;
+
 	error = git_str_sets(&idx->filename, path);
 	if (error < 0)
 		return error;
@@ -344,7 +347,7 @@ bool git_midx_needs_refresh(
 	git_file fd = -1;
 	struct stat st;
 	ssize_t bytes_read;
-	unsigned char checksum[GIT_HASH_SHA1_SIZE];
+	unsigned char checksum[GIT_HASH_MAX_SIZE];
 	size_t checksum_size;
 
 	/* TODO: properly open the file without access time using O_NOATIME */
@@ -364,8 +367,8 @@ bool git_midx_needs_refresh(
 		return true;
 	}
 
-	checksum_size = GIT_HASH_SHA1_SIZE;
-	bytes_read = p_pread(fd, checksum, checksum_size, st.st_size - GIT_OID_SHA1_SIZE);
+	checksum_size = git_oid_size(idx->oid_type);
+	bytes_read = p_pread(fd, checksum, checksum_size, st.st_size - checksum_size);
 	p_close(fd);
 
 	if (bytes_read != (ssize_t)checksum_size)
@@ -381,7 +384,7 @@ int git_midx_entry_find(
 		size_t len)
 {
 	int pos, found = 0;
-	size_t pack_index;
+	size_t pack_index, oid_size, oid_hexsize;
 	uint32_t hi, lo;
 	unsigned char *current = NULL;
 	const unsigned char *object_offset;
@@ -389,30 +392,33 @@ int git_midx_entry_find(
 
 	GIT_ASSERT_ARG(idx);
 
+	oid_size = git_oid_size(idx->oid_type);
+	oid_hexsize = git_oid_hexsize(idx->oid_type);
+
 	hi = ntohl(idx->oid_fanout[(int)short_oid->id[0]]);
 	lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(idx->oid_fanout[(int)short_oid->id[0] - 1]));
 
-	pos = git_pack__lookup_id(idx->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1);
+	pos = git_pack__lookup_id(idx->oid_lookup, oid_size, lo, hi, short_oid->id, idx->oid_type);
 
 	if (pos >= 0) {
 		/* An object matching exactly the oid was found */
 		found = 1;
-		current = idx->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
+		current = idx->oid_lookup + (pos * oid_size);
 	} else {
 		/* No object was found */
 		/* pos refers to the object with the "closest" oid to short_oid */
 		pos = -1 - pos;
 		if (pos < (int)idx->num_objects) {
-			current = idx->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
+			current = idx->oid_lookup + (pos * oid_size);
 
 			if (!git_oid_raw_ncmp(short_oid->id, current, len))
 				found = 1;
 		}
 	}
 
-	if (found && len != GIT_OID_SHA1_HEXSIZE && pos + 1 < (int)idx->num_objects) {
+	if (found && len != oid_hexsize && pos + 1 < (int)idx->num_objects) {
 		/* Check for ambiguousity */
-		const unsigned char *next = current + GIT_OID_SHA1_SIZE;
+		const unsigned char *next = current + oid_size;
 
 		if (!git_oid_raw_ncmp(short_oid->id, next, len))
 			found = 2;
@@ -443,7 +449,7 @@ int git_midx_entry_find(
 		return midx_error("invalid index into the packfile names table");
 	e->pack_index = pack_index;
 	e->offset = offset;
-	git_oid__fromraw(&e->sha1, current, GIT_OID_SHA1);
+	git_oid__fromraw(&e->sha1, current, idx->oid_type);
 	return 0;
 }
 
@@ -453,13 +459,15 @@ int git_midx_foreach_entry(
 		void *data)
 {
 	git_oid oid;
-	size_t i;
+	size_t oid_size, i;
 	int error;
 
 	GIT_ASSERT_ARG(idx);
 
+	oid_size = git_oid_size(idx->oid_type);
+
 	for (i = 0; i < idx->num_objects; ++i) {
-		if ((error = git_oid__fromraw(&oid, &idx->oid_lookup[i * GIT_OID_SHA1_SIZE], GIT_OID_SHA1)) < 0)
+		if ((error = git_oid__fromraw(&oid, &idx->oid_lookup[i * oid_size], idx->oid_type)) < 0)
 			return error;
 
 		if ((error = cb(&oid, data)) != 0)
@@ -476,7 +484,7 @@ int git_midx_close(git_midx_file *idx)
 	if (idx->index_map.data)
 		git_futils_mmap_free(&idx->index_map);
 
-	git_vector_free(&idx->packfile_names);
+	git_vector_dispose(&idx->packfile_names);
 
 	return 0;
 }
@@ -500,10 +508,30 @@ static int packfile__cmp(const void *a_, const void *b_)
 }
 
 int git_midx_writer_new(
-		git_midx_writer **out,
-		const char *pack_dir)
+	git_midx_writer **out,
+	const char *pack_dir
+#ifdef GIT_EXPERIMENTAL_SHA256
+	, git_midx_writer_options *opts
+#endif
+		)
 {
-	git_midx_writer *w = git__calloc(1, sizeof(git_midx_writer));
+	git_midx_writer *w;
+	git_oid_t oid_type;
+
+	GIT_ASSERT_ARG(out && pack_dir);
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+	GIT_ERROR_CHECK_VERSION(opts,
+		GIT_MIDX_WRITER_OPTIONS_VERSION,
+		"git_midx_writer_options");
+
+	oid_type = opts && opts->oid_type ? opts->oid_type : GIT_OID_DEFAULT;
+	GIT_ASSERT_ARG(git_oid_type_is_valid(oid_type));
+#else
+	oid_type = GIT_OID_SHA1;
+#endif
+
+	w = git__calloc(1, sizeof(git_midx_writer));
 	GIT_ERROR_CHECK_ALLOC(w);
 
 	if (git_str_sets(&w->pack_dir, pack_dir) < 0) {
@@ -518,6 +546,8 @@ int git_midx_writer_new(
 		return -1;
 	}
 
+	w->oid_type = oid_type;
+
 	*out = w;
 	return 0;
 }
@@ -532,7 +562,7 @@ void git_midx_writer_free(git_midx_writer *w)
 
 	git_vector_foreach (&w->packs, i, p)
 		git_mwindow_put_pack(p);
-	git_vector_free(&w->packs);
+	git_vector_dispose(&w->packs);
 	git_str_dispose(&w->pack_dir);
 	git__free(w);
 }
@@ -638,9 +668,11 @@ static int midx_write_hash(const char *buf, size_t size, void *data)
 	struct midx_write_hash_context *ctx = (struct midx_write_hash_context *)data;
 	int error;
 
-	error = git_hash_update(ctx->ctx, buf, size);
-	if (error < 0)
-		return error;
+	if (ctx->ctx) {
+		error = git_hash_update(ctx->ctx, buf, size);
+		if (error < 0)
+			return error;
+	}
 
 	return ctx->write_cb(buf, size, ctx->cb_data);
 }
@@ -662,12 +694,13 @@ static int midx_write(
 		oid_lookup = GIT_STR_INIT,
 		object_offsets = GIT_STR_INIT,
 		object_large_offsets = GIT_STR_INIT;
-	unsigned char checksum[GIT_HASH_SHA1_SIZE];
-	size_t checksum_size;
+	unsigned char checksum[GIT_HASH_MAX_SIZE];
+	size_t checksum_size, oid_size;
 	git_midx_entry *entry;
 	object_entry_array_t object_entries_array = GIT_ARRAY_INIT;
 	git_vector object_entries = GIT_VECTOR_INIT;
 	git_hash_ctx ctx;
+	git_hash_algorithm_t checksum_type;
 	struct midx_write_hash_context hash_cb_data = {0};
 
 	hdr.signature = htonl(MIDX_SIGNATURE);
@@ -679,10 +712,14 @@ static int midx_write(
 	hash_cb_data.cb_data = cb_data;
 	hash_cb_data.ctx = &ctx;
 
-	checksum_size = GIT_HASH_SHA1_SIZE;
-	error = git_hash_ctx_init(&ctx, GIT_HASH_ALGORITHM_SHA1);
-	if (error < 0)
+	oid_size = git_oid_size(w->oid_type);
+	checksum_type = git_oid_algorithm(w->oid_type);
+	checksum_size = git_hash_size(checksum_type);
+	GIT_ASSERT(oid_size && checksum_type && checksum_size);
+
+	if ((error = git_hash_ctx_init(&ctx, checksum_type)) < 0)
 		return error;
+
 	cb_data = &hash_cb_data;
 	write_cb = midx_write_hash;
 
@@ -749,7 +786,9 @@ static int midx_write(
 
 	/* Fill the OID Lookup table. */
 	git_vector_foreach (&object_entries, i, entry) {
-		error = git_str_put(&oid_lookup, (char *)&entry->sha1.id, GIT_OID_SHA1_SIZE);
+		error = git_str_put(&oid_lookup,
+			(char *)&entry->sha1.id, oid_size);
+
 		if (error < 0)
 			goto cleanup;
 	}
@@ -834,13 +873,16 @@ static int midx_write(
 	error = git_hash_final(checksum, &ctx);
 	if (error < 0)
 		goto cleanup;
+
+	hash_cb_data.ctx = NULL;
+
 	error = write_cb((char *)checksum, checksum_size, cb_data);
 	if (error < 0)
 		goto cleanup;
 
 cleanup:
 	git_array_clear(object_entries_array);
-	git_vector_free(&object_entries);
+	git_vector_dispose(&object_entries);
 	git_str_dispose(&packfile_names);
 	git_str_dispose(&oid_lookup);
 	git_str_dispose(&object_offsets);

data/vendor/libgit2/src/libgit2/midx.h

@@ -51,8 +51,14 @@ typedef struct git_midx_file {
 	/* The number of entries in the Object Large Offsets table. Each entry has an 8-byte with an offset */
 	size_t num_object_large_offsets;
 
-	/* The trailer of the file. Contains the SHA1-checksum of the whole file. */
-	unsigned char checksum[GIT_HASH_SHA1_SIZE];
+	/*
+	 * The trailer of the file. Contains the checksum of the whole
+	 * file, in the repository's object format hash.
+	 */
+	unsigned char checksum[GIT_HASH_MAX_SIZE];
+
+	/* The type of object IDs in the midx. */
+	git_oid_t oid_type;
 
 	/* something like ".git/objects/pack/multi-pack-index". */
 	git_str filename;
@@ -82,11 +88,15 @@ struct git_midx_writer {
 
 	/* The list of `git_pack_file`s. */
 	git_vector packs;
+
+	/* The object ID type of the writer. */
+	git_oid_t oid_type;
 };
 
 int git_midx_open(
 		git_midx_file **idx_out,
-		const char *path);
+		const char *path,
+		git_oid_t oid_type);
 bool git_midx_needs_refresh(
 		const git_midx_file *idx,
 		const char *path);