rugged 1.7.2 → 1.9.4

data/vendor/libgit2/src/libgit2/mwindow.c

@@ -11,7 +11,6 @@
 #include "futils.h"
 #include "map.h"
 #include "runtime.h"
-#include "strmap.h"
 #include "pack.h"
 
 #define DEFAULT_WINDOW_SIZE \
@@ -29,33 +28,27 @@ size_t git_mwindow__window_size = DEFAULT_WINDOW_SIZE;
 size_t git_mwindow__mapped_limit = DEFAULT_MAPPED_LIMIT;
 size_t git_mwindow__file_limit = DEFAULT_FILE_LIMIT;
 
-/* Mutex to control access to `git_mwindow__mem_ctl` and `git__pack_cache`. */
-git_mutex git__mwindow_mutex;
+/* Mutex to control access to `git_mwindow__mem_ctl` and `git_mwindow__pack_cache`. */
+git_mutex git_mwindow__mutex;
 
-/* Whenever you want to read or modify this, grab `git__mwindow_mutex` */
+/* Whenever you want to read or modify this, grab `git_mwindow__mutex` */
 git_mwindow_ctl git_mwindow__mem_ctl;
 
 /* Global list of mwindow files, to open packs once across repos */
-git_strmap *git__pack_cache = NULL;
+GIT_HASHMAP_STR_FUNCTIONS(git_mwindow_packmap, , struct git_pack_file *);
+git_mwindow_packmap git_mwindow__pack_cache;
 
 static void git_mwindow_global_shutdown(void)
 {
-	git_strmap *tmp = git__pack_cache;
-
-	git_mutex_free(&git__mwindow_mutex);
-
-	git__pack_cache = NULL;
-	git_strmap_free(tmp);
+	git_mutex_free(&git_mwindow__mutex);
+	git_mwindow_packmap_dispose(&git_mwindow__pack_cache);
 }
 
 int git_mwindow_global_init(void)
 {
 	int error;
 
-	GIT_ASSERT(!git__pack_cache);
-
-	if ((error = git_mutex_init(&git__mwindow_mutex)) < 0 ||
-	    (error = git_strmap_new(&git__pack_cache)) < 0)
+	if ((error = git_mutex_init(&git_mwindow__mutex)) < 0)
 	    return error;
 
 	return git_runtime_shutdown_register(git_mwindow_global_shutdown);
@@ -73,31 +66,34 @@ int git_mwindow_get_pack(
 	if ((error = git_packfile__name(&packname, path)) < 0)
 		return error;
 
-	if (git_mutex_lock(&git__mwindow_mutex) < 0) {
+	if (git_mutex_lock(&git_mwindow__mutex) < 0) {
 		git_error_set(GIT_ERROR_OS, "failed to lock mwindow mutex");
 		return -1;
 	}
 
-	pack = git_strmap_get(git__pack_cache, packname);
+	error = git_mwindow_packmap_get(&pack, &git_mwindow__pack_cache, packname);
 	git__free(packname);
 
-	if (pack != NULL) {
+	if (error == 0) {
 		git_atomic32_inc(&pack->refcount);
-		git_mutex_unlock(&git__mwindow_mutex);
+		git_mutex_unlock(&git_mwindow__mutex);
 		*out = pack;
 		return 0;
+	} else if (error != GIT_ENOTFOUND) {
+		return error;
 	}
 
 	/* If we didn't find it, we need to create it */
 	if ((error = git_packfile_alloc(&pack, path, oid_type)) < 0) {
-		git_mutex_unlock(&git__mwindow_mutex);
+		git_mutex_unlock(&git_mwindow__mutex);
 		return error;
 	}
 
 	git_atomic32_inc(&pack->refcount);
 
-	error = git_strmap_set(git__pack_cache, pack->pack_name, pack);
-	git_mutex_unlock(&git__mwindow_mutex);
+	error = git_mwindow_packmap_put(&git_mwindow__pack_cache, pack->pack_name, pack);
+	git_mutex_unlock(&git_mwindow__mutex);
+
 	if (error < 0) {
 		git_packfile_free(pack, false);
 		return error;
@@ -112,21 +108,18 @@ int git_mwindow_put_pack(struct git_pack_file *pack)
 	int count, error;
 	struct git_pack_file *pack_to_delete = NULL;
 
-	if ((error = git_mutex_lock(&git__mwindow_mutex)) < 0)
+	if ((error = git_mutex_lock(&git_mwindow__mutex)) < 0)
 		return error;
 
-	/* put before get would be a corrupted state */
-	GIT_ASSERT(git__pack_cache);
-
 	/* if we cannot find it, the state is corrupted */
-	GIT_ASSERT(git_strmap_exists(git__pack_cache, pack->pack_name));
+	GIT_ASSERT(git_mwindow_packmap_contains(&git_mwindow__pack_cache, pack->pack_name));
 
 	count = git_atomic32_dec(&pack->refcount);
 	if (count == 0) {
-		git_strmap_delete(git__pack_cache, pack->pack_name);
+		git_mwindow_packmap_remove(&git_mwindow__pack_cache, pack->pack_name);
 		pack_to_delete = pack;
 	}
-	git_mutex_unlock(&git__mwindow_mutex);
+	git_mutex_unlock(&git_mwindow__mutex);
 	git_packfile_free(pack_to_delete, false);
 
 	return 0;
@@ -134,7 +127,7 @@ int git_mwindow_put_pack(struct git_pack_file *pack)
 
 /*
  * Free all the windows in a sequence, typically because we're done
- * with the file. Needs to hold the git__mwindow_mutex.
+ * with the file. Needs to hold the git_mwindow__mutex.
  */
 static int git_mwindow_free_all_locked(git_mwindow_file *mwf)
 {
@@ -152,7 +145,7 @@ static int git_mwindow_free_all_locked(git_mwindow_file *mwf)
 	}
 
 	if (ctl->windowfiles.length == 0) {
-		git_vector_free(&ctl->windowfiles);
+		git_vector_dispose(&ctl->windowfiles);
 		ctl->windowfiles.contents = NULL;
 	}
 
@@ -176,14 +169,14 @@ int git_mwindow_free_all(git_mwindow_file *mwf)
 {
 	int error;
 
-	if (git_mutex_lock(&git__mwindow_mutex)) {
+	if (git_mutex_lock(&git_mwindow__mutex)) {
 		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 		return -1;
 	}
 
 	error = git_mwindow_free_all_locked(mwf);
 
-	git_mutex_unlock(&git__mwindow_mutex);
+	git_mutex_unlock(&git_mwindow__mutex);
 
 	return error;
 }
@@ -405,7 +398,7 @@ unsigned char *git_mwindow_open(
 	git_mwindow_ctl *ctl = &git_mwindow__mem_ctl;
 	git_mwindow *w = *cursor;
 
-	if (git_mutex_lock(&git__mwindow_mutex)) {
+	if (git_mutex_lock(&git_mwindow__mutex)) {
 		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 		return NULL;
 	}
@@ -427,7 +420,7 @@ unsigned char *git_mwindow_open(
 		if (!w) {
 			w = new_window_locked(mwf->fd, mwf->size, offset);
 			if (w == NULL) {
-				git_mutex_unlock(&git__mwindow_mutex);
+				git_mutex_unlock(&git_mwindow__mutex);
 				return NULL;
 			}
 			w->next = mwf->windows;
@@ -447,7 +440,7 @@ unsigned char *git_mwindow_open(
 	if (left)
 		*left = (unsigned int)(w->window_map.len - offset);
 
-	git_mutex_unlock(&git__mwindow_mutex);
+	git_mutex_unlock(&git_mwindow__mutex);
 	return (unsigned char *) w->window_map.data + offset;
 }
 
@@ -459,14 +452,14 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 	size_t i;
 	git_mwindow_file *closed_file = NULL;
 
-	if (git_mutex_lock(&git__mwindow_mutex)) {
+	if (git_mutex_lock(&git_mwindow__mutex)) {
 		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 		return -1;
 	}
 
 	if (ctl->windowfiles.length == 0 &&
 	    (error = git_vector_init(&ctl->windowfiles, 8, NULL)) < 0) {
-		git_mutex_unlock(&git__mwindow_mutex);
+		git_mutex_unlock(&git_mwindow__mutex);
 		goto cleanup;
 	}
 
@@ -486,7 +479,7 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 	}
 
 	error = git_vector_insert(&ctl->windowfiles, mwf);
-	git_mutex_unlock(&git__mwindow_mutex);
+	git_mutex_unlock(&git_mwindow__mutex);
 	if (error < 0)
 		goto cleanup;
 
@@ -505,7 +498,7 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 	}
 
 cleanup:
-	git_vector_free(&closed_files);
+	git_vector_dispose(&closed_files);
 	return error;
 }
 
@@ -515,30 +508,30 @@ void git_mwindow_file_deregister(git_mwindow_file *mwf)
 	git_mwindow_file *cur;
 	size_t i;
 
-	if (git_mutex_lock(&git__mwindow_mutex))
+	if (git_mutex_lock(&git_mwindow__mutex))
 		return;
 
 	git_vector_foreach(&ctl->windowfiles, i, cur) {
 		if (cur == mwf) {
 			git_vector_remove(&ctl->windowfiles, i);
-			git_mutex_unlock(&git__mwindow_mutex);
+			git_mutex_unlock(&git_mwindow__mutex);
 			return;
 		}
 	}
-	git_mutex_unlock(&git__mwindow_mutex);
+	git_mutex_unlock(&git_mwindow__mutex);
 }
 
 void git_mwindow_close(git_mwindow **window)
 {
 	git_mwindow *w = *window;
 	if (w) {
-		if (git_mutex_lock(&git__mwindow_mutex)) {
+		if (git_mutex_lock(&git_mwindow__mutex)) {
 			git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 			return;
 		}
 
 		w->inuse_cnt--;
-		git_mutex_unlock(&git__mwindow_mutex);
+		git_mutex_unlock(&git_mwindow__mutex);
 		*window = NULL;
 	}
 }

data/vendor/libgit2/src/libgit2/mwindow.h

@@ -12,6 +12,10 @@
 
 #include "map.h"
 #include "vector.h"
+#include "hashmap_str.h"
+
+GIT_HASHMAP_STR_STRUCT(git_mwindow_packmap, struct git_pack_file *);
+GIT_HASHMAP_STR_PROTOTYPES(git_mwindow_packmap, struct git_pack_file *);
 
 typedef struct git_mwindow {
 	struct git_mwindow *next;

data/vendor/libgit2/src/libgit2/object.c

@@ -526,7 +526,7 @@ static int git_object__short_id(git_str *out, const git_object *obj)
 	git_oid id;
 	git_odb *odb;
 	size_t oid_hexsize;
-	int len = GIT_ABBREV_DEFAULT, error;
+	int len, error;
 
 	GIT_ASSERT_ARG(out);
 	GIT_ASSERT_ARG(obj);
@@ -536,12 +536,13 @@ static int git_object__short_id(git_str *out, const git_object *obj)
 	git_oid_clear(&id, repo->oid_type);
 	oid_hexsize = git_oid_hexsize(repo->oid_type);
 
-	if ((error = git_repository__configmap_lookup(&len, repo, GIT_CONFIGMAP_ABBREV)) < 0)
+	if ((error = git_repository__abbrev_length(&len, repo)) < 0)
 		return error;
 
-	if (len < 0 || (size_t)len > oid_hexsize) {
-		git_error_set(GIT_ERROR_CONFIG, "invalid oid abbreviation setting: '%d'", len);
-		return -1;
+	if ((size_t)len == oid_hexsize) {
+		if ((error = git_oid_cpy(&id, &obj->cached.oid)) < 0) {
+			return error;
+		}
 	}
 
 	if ((error = git_repository_odb(&odb, repo)) < 0)

data/vendor/libgit2/src/libgit2/odb.c

@@ -790,12 +790,8 @@ static int load_alternates(git_odb *odb, const char *objects_dir, int alternate_
 		if (*alternate == '\0' || *alternate == '#')
 			continue;
 
-		/*
-		 * Relative path: build based on the current `objects`
-		 * folder. However, relative paths are only allowed in
-		 * the current repository.
-		 */
-		if (*alternate == '.' && !alternate_depth) {
+		/* Relative path: build based on the current `objects` folder. */
+		if (*alternate == '.') {
 			if ((result = git_str_joinpath(&alternates_path, objects_dir, alternate)) < 0)
 				break;
 			alternate = git_str_cstr(&alternates_path);
@@ -915,7 +911,7 @@ static void odb_free(git_odb *db)
 		git_mutex_unlock(&db->lock);
 
 	git_commit_graph_free(db->cgraph);
-	git_vector_free(&db->backends);
+	git_vector_dispose(&db->backends);
 	git_cache_dispose(&db->own_cache);
 	git_mutex_free(&db->lock);
 
@@ -1609,7 +1605,7 @@ int git_odb_foreach(git_odb *db, git_odb_foreach_cb cb, void *payload)
 	}
 
 cleanup:
-	git_vector_free(&backends);
+	git_vector_dispose(&backends);
 
 	return error;
 }
@@ -1796,7 +1792,8 @@ void git_odb_stream_free(git_odb_stream *stream)
 	if (stream == NULL)
 		return;
 
-	git_hash_ctx_cleanup(stream->hash_ctx);
+	if (stream->hash_ctx)
+		git_hash_ctx_cleanup(stream->hash_ctx);
 	git__free(stream->hash_ctx);
 	stream->free(stream);
 }
@@ -1922,7 +1919,7 @@ void git_odb_backend_data_free(git_odb_backend *backend, void *data)
 	git__free(data);
 }
 
-int git_odb_refresh(struct git_odb *db)
+int git_odb_refresh(git_odb *db)
 {
 	size_t i;
 	int error;

data/vendor/libgit2/src/libgit2/odb_loose.c

@@ -276,8 +276,8 @@ done:
 static int read_loose_standard(git_rawobj *out, git_str *obj)
 {
 	git_zstream zstream = GIT_ZSTREAM_INIT;
-	unsigned char head[MAX_HEADER_LEN], *body = NULL;
-	size_t decompressed, head_len, body_len, alloc_size;
+	unsigned char head[MAX_HEADER_LEN], *body = NULL, *body_out;
+	size_t decompressed, head_len, body_remain, alloc_size;
 	obj_hdr hdr;
 	int error;
 
@@ -285,16 +285,16 @@ static int read_loose_standard(git_rawobj *out, git_str *obj)
 		(error = git_zstream_set_input(&zstream, git_str_cstr(obj), git_str_len(obj))) < 0)
 		goto done;
 
-	decompressed = sizeof(head);
-
 	/*
 	 * inflate the initial part of the compressed buffer in order to
-	 * parse the header; read the largest header possible, then push the
-	 * remainder into the body buffer.
+	 * parse the header and read the largest header possible. later, we'll
+	 * push the remainder into the body buffer.
 	 */
+	decompressed = sizeof(head);
 	if ((error = git_zstream_get_output(head, &decompressed, &zstream)) < 0 ||
 		(error = parse_header(&hdr, &head_len, head, decompressed)) < 0)
 		goto done;
+	GIT_ASSERT(head_len <= decompressed);
 
 	if (!git_object_typeisloose(hdr.type)) {
 		git_error_set(GIT_ERROR_ODB, "failed to inflate disk object");
@@ -311,16 +311,24 @@ static int read_loose_standard(git_rawobj *out, git_str *obj)
 		error = -1;
 		goto done;
 	}
+	body_out = body;
+	body_remain = hdr.size;
 
-	GIT_ASSERT(decompressed >= head_len);
-	body_len = decompressed - head_len;
-
-	if (body_len)
-		memcpy(body, head + head_len, body_len);
+	decompressed -= head_len;
+	if (decompressed > body_remain) {
+		git_error_set(GIT_ERROR_ODB, "malformed object: body was longer than specified in header");
+		error = -1;
+		goto done;
+	}
+	if (decompressed)
+		memcpy(body_out, head + head_len, decompressed);
+	body_out += decompressed;
+	body_remain -= decompressed;
 
-	decompressed = hdr.size - body_len;
-	if ((error = git_zstream_get_output(body + body_len, &decompressed, &zstream)) < 0)
+	decompressed = body_remain;
+	if ((error = git_zstream_get_output(body_out, &decompressed, &zstream)) < 0)
 		goto done;
+	body_out += decompressed;
 
 	if (!git_zstream_done(&zstream)) {
 		git_error_set(GIT_ERROR_ZLIB, "failed to finish zlib inflation: stream aborted prematurely");
@@ -328,7 +336,9 @@ static int read_loose_standard(git_rawobj *out, git_str *obj)
 		goto done;
 	}
 
-	body[hdr.size] = '\0';
+	/* object bodies that are too short are silently zero-padded */
+	GIT_ASSERT(body_out <= body + hdr.size);
+	*body_out = '\0';
 
 	out->data = body;
 	out->len = hdr.size;

data/vendor/libgit2/src/libgit2/odb_mempack.c

@@ -12,7 +12,6 @@
 #include "hash.h"
 #include "odb.h"
 #include "array.h"
-#include "oidmap.h"
 #include "pack-objects.h"
 
 #include "git2/odb_backend.h"
@@ -29,9 +28,11 @@ struct memobject {
 	char data[GIT_FLEX_ARRAY];
 };
 
+GIT_HASHMAP_OID_SETUP(git_odb_mempack_oidmap, struct memobject *);
+
 struct memory_packer_db {
 	git_odb_backend parent;
-	git_oidmap *objects;
+	git_odb_mempack_oidmap objects;
 	git_array_t(struct memobject *) commits;
 };
 
@@ -41,7 +42,7 @@ static int impl__write(git_odb_backend *_backend, const git_oid *oid, const void
 	struct memobject *obj = NULL;
 	size_t alloc_len;
 
-	if (git_oidmap_exists(db->objects, oid))
+	if (git_odb_mempack_oidmap_contains(&db->objects, oid))
 		return 0;
 
 	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, sizeof(struct memobject), len);
@@ -53,7 +54,7 @@ static int impl__write(git_odb_backend *_backend, const git_oid *oid, const void
 	obj->len = len;
 	obj->type = type;
 
-	if (git_oidmap_set(db->objects, &obj->oid, obj) < 0)
+	if (git_odb_mempack_oidmap_put(&db->objects, &obj->oid, obj) < 0)
 		return -1;
 
 	if (type == GIT_OBJECT_COMMIT) {
@@ -69,16 +70,17 @@ static int impl__exists(git_odb_backend *backend, const git_oid *oid)
 {
 	struct memory_packer_db *db = (struct memory_packer_db *)backend;
 
-	return git_oidmap_exists(db->objects, oid);
+	return git_odb_mempack_oidmap_contains(&db->objects, oid);
 }
 
 static int impl__read(void **buffer_p, size_t *len_p, git_object_t *type_p, git_odb_backend *backend, const git_oid *oid)
 {
 	struct memory_packer_db *db = (struct memory_packer_db *)backend;
 	struct memobject *obj;
+	int error;
 
-	if ((obj = git_oidmap_get(db->objects, oid)) == NULL)
-		return GIT_ENOTFOUND;
+	if ((error = git_odb_mempack_oidmap_get(&obj, &db->objects, oid)) != 0)
+		return error;
 
 	*len_p = obj->len;
 	*type_p = obj->type;
@@ -93,9 +95,10 @@ static int impl__read_header(size_t *len_p, git_object_t *type_p, git_odb_backen
 {
 	struct memory_packer_db *db = (struct memory_packer_db *)backend;
 	struct memobject *obj;
+	int error;
 
-	if ((obj = git_oidmap_get(db->objects, oid)) == NULL)
-		return GIT_ENOTFOUND;
+	if ((error = git_odb_mempack_oidmap_get(&obj, &db->objects, oid)) != 0)
+		return error;
 
 	*len_p = obj->len;
 	*type_p = obj->type;
@@ -132,6 +135,29 @@ cleanup:
 	return err;
 }
 
+int git_mempack_write_thin_pack(git_odb_backend *backend, git_packbuilder *pb)
+{
+	struct memory_packer_db *db = (struct memory_packer_db *)backend;
+	const git_oid *oid;
+	git_hashmap_iter_t iter = GIT_HASHMAP_INIT;
+	int err;
+
+	while (true) {
+		err = git_odb_mempack_oidmap_iterate(&iter, &oid, NULL, &db->objects);
+
+		if (err == GIT_ITEROVER)
+			break;
+		else if (err != 0)
+			return err;
+
+		err = git_packbuilder_insert(pb, oid, NULL);
+		if (err != 0)
+			return err;
+	}
+
+	return 0;
+}
+
 int git_mempack_dump(
 	git_buf *pack,
 	git_repository *repo,
@@ -144,14 +170,13 @@ int git_mempack_reset(git_odb_backend *_backend)
 {
 	struct memory_packer_db *db = (struct memory_packer_db *)_backend;
 	struct memobject *object = NULL;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
-	git_oidmap_foreach_value(db->objects, object, {
+	while (git_odb_mempack_oidmap_iterate(&iter, NULL, &object, &db->objects) == 0)
 		git__free(object);
-	});
 
 	git_array_clear(db->commits);
-
-	git_oidmap_clear(db->objects);
+	git_odb_mempack_oidmap_clear(&db->objects);
 
 	return 0;
 }
@@ -161,7 +186,7 @@ static void impl__free(git_odb_backend *_backend)
 	struct memory_packer_db *db = (struct memory_packer_db *)_backend;
 
 	git_mempack_reset(_backend);
-	git_oidmap_free(db->objects);
+	git_odb_mempack_oidmap_dispose(&db->objects);
 	git__free(db);
 }
 
@@ -174,9 +199,6 @@ int git_mempack_new(git_odb_backend **out)
 	db = git__calloc(1, sizeof(struct memory_packer_db));
 	GIT_ERROR_CHECK_ALLOC(db);
 
-	if (git_oidmap_new(&db->objects) < 0)
-		return -1;
-
 	db->parent.version = GIT_ODB_BACKEND_VERSION;
 	db->parent.read = &impl__read;
 	db->parent.write = &impl__write;
@@ -187,3 +209,13 @@ int git_mempack_new(git_odb_backend **out)
 	*out = (git_odb_backend *)db;
 	return 0;
 }
+
+int git_mempack_object_count(size_t *out, git_odb_backend *_backend)
+{
+	struct memory_packer_db *db = (struct memory_packer_db *)_backend;
+
+	GIT_ASSERT_ARG(_backend);
+
+	*out = (size_t)git_odb_mempack_oidmap_size(&db->objects);
+	return 0;
+}

data/vendor/libgit2/src/libgit2/odb_pack.c

@@ -743,10 +743,10 @@ static int pack_backend__writepack(struct git_odb_writepack **out,
 
 #ifdef GIT_EXPERIMENTAL_SHA256
 	opts.odb = odb;
+	opts.oid_type = backend->opts.oid_type;
 
 	error = git_indexer_new(&writepack->indexer,
 		backend->pack_folder,
-		backend->opts.oid_type,
 		&opts);
 #else
 	error = git_indexer_new(&writepack->indexer,
@@ -796,13 +796,21 @@ static int pack_backend__writemidx(git_odb_backend *_backend)
 	size_t i;
 	int error = 0;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	git_midx_writer_options midx_opts = GIT_MIDX_WRITER_OPTIONS_INIT;
+#endif
+
 	GIT_ASSERT_ARG(_backend);
 
 	backend = (struct pack_backend *)_backend;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	midx_opts.oid_type = backend->opts.oid_type;
+#endif
+
 	error = git_midx_writer_new(&w, backend->pack_folder
 #ifdef GIT_EXPERIMENTAL_SHA256
-		, backend->opts.oid_type
+		, &midx_opts
 #endif
 		);
 
@@ -863,8 +871,8 @@ static void pack_backend__free(git_odb_backend *_backend)
 		git_mwindow_put_pack(p);
 
 	git_midx_free(backend->midx);
-	git_vector_free(&backend->midx_packs);
-	git_vector_free(&backend->packs);
+	git_vector_dispose(&backend->midx_packs);
+	git_vector_dispose(&backend->packs);
 	git__free(backend->pack_folder);
 	git__free(backend);
 }
@@ -883,7 +891,7 @@ static int pack_backend__alloc(
 	}
 
 	if (git_vector_init(&backend->packs, initial_size, packfile_sort__cb) < 0) {
-		git_vector_free(&backend->midx_packs);
+		git_vector_dispose(&backend->midx_packs);
 		git__free(backend);
 		return -1;
 	}