rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/libgit2/oidarray.c

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "oidarray.h"
+
+#include "git2/oidarray.h"
+#include "array.h"
+
+void git_oidarray_dispose(git_oidarray *arr)
+{
+	git__free(arr->ids);
+}
+
+void git_oidarray__from_array(git_oidarray *out, const git_array_oid_t *array)
+{
+	out->count = array->size;
+	out->ids = array->ptr;
+}
+
+void git_oidarray__to_array(git_array_oid_t *out, const git_oidarray *array)
+{
+	out->ptr = array->ids;
+	out->size = array->count;
+	out->asize = array->count;
+}
+
+void git_oidarray__reverse(git_oidarray *arr)
+{
+	size_t i;
+	git_oid tmp;
+
+	for (i = 0; i < arr->count / 2; i++) {
+		git_oid_cpy(&tmp, &arr->ids[i]);
+		git_oid_cpy(&arr->ids[i], &arr->ids[(arr->count-1)-i]);
+		git_oid_cpy(&arr->ids[(arr->count-1)-i], &tmp);
+	}
+}
+
+int git_oidarray__add(git_array_oid_t *arr, git_oid *id)
+{
+	git_oid *add, *iter;
+	size_t i;
+
+	git_array_foreach(*arr, i, iter) {
+		if (git_oid_cmp(iter, id) == 0)
+			return 0;
+	}
+
+	if ((add = git_array_alloc(*arr)) == NULL)
+		return -1;
+
+	git_oid_cpy(add, id);
+	return 0;
+}
+
+bool git_oidarray__remove(git_array_oid_t *arr, git_oid *id)
+{
+	bool found = false;
+	size_t remain, i;
+	git_oid *iter;
+
+	git_array_foreach(*arr, i, iter) {
+		if (git_oid_cmp(iter, id) == 0) {
+			arr->size--;
+			remain = arr->size - i;
+
+			if (remain > 0)
+				memmove(&arr->ptr[i], &arr->ptr[i+1], remain * sizeof(git_oid));
+
+			found = true;
+			break;
+		}
+	}
+
+	return found;
+}
+
+#ifndef GIT_DEPRECATE_HARD
+
+void git_oidarray_free(git_oidarray *arr)
+{
+	git_oidarray_dispose(arr);
+}
+
+#endif

data/vendor/libgit2/src/{oidarray.h → libgit2/oidarray.h}

@@ -15,6 +15,10 @@
 typedef git_array_t(git_oid) git_array_oid_t;
 
 extern void git_oidarray__reverse(git_oidarray *arr);
-extern void git_oidarray__from_array(git_oidarray *arr, git_array_oid_t *array);
+extern void git_oidarray__from_array(git_oidarray *out, const git_array_oid_t *array);
+extern void git_oidarray__to_array(git_array_oid_t *out, const git_oidarray *array);
+
+int git_oidarray__add(git_array_oid_t *arr, git_oid *id);
+bool git_oidarray__remove(git_array_oid_t *arr, git_oid *id);
 
 #endif

data/vendor/libgit2/src/{pack-objects.c → libgit2/pack-objects.c}

@@ -7,10 +7,10 @@
 
 #include "pack-objects.h"
 
+#include "buf.h"
 #include "zstream.h"
 #include "delta.h"
 #include "iterator.h"
-#include "netops.h"
 #include "pack.h"
 #include "thread.h"
 #include "tree.h"
@@ -33,7 +33,7 @@ struct unpacked {
 
 struct tree_walk_context {
 	git_packbuilder *pb;
-	git_buf buf;
+	git_str buf;
 };
 
 struct pack_write_context {
@@ -64,6 +64,9 @@ struct walk_object {
 /* Size of the buffer to feed to zlib */
 #define COMPRESS_BUFLEN (1024 * 1024)
 
+GIT_HASHMAP_OID_FUNCTIONS(git_packbuilder_pobjectmap, GIT_HASHMAP_INLINE, git_pobject *);
+GIT_HASHMAP_OID_FUNCTIONS(git_packbuilder_walk_objectmap, GIT_HASHMAP_INLINE, struct walk_object *);
+
 static unsigned name_hash(const char *name)
 {
 	unsigned c, hash = 0;
@@ -126,6 +129,7 @@ out:
 
 int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 {
+	git_hash_algorithm_t hash_algorithm;
 	git_packbuilder *pb;
 
 	*out = NULL;
@@ -133,15 +137,18 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	pb = git__calloc(1, sizeof(*pb));
 	GIT_ERROR_CHECK_ALLOC(pb);
 
-	if (git_oidmap_new(&pb->object_ix) < 0 ||
-	    git_oidmap_new(&pb->walk_objects) < 0 ||
-	    git_pool_init(&pb->object_pool, sizeof(struct walk_object)) < 0)
+	pb->oid_type = repo->oid_type;
+
+	hash_algorithm = git_oid_algorithm(pb->oid_type);
+	GIT_ASSERT(hash_algorithm);
+
+	if (git_pool_init(&pb->object_pool, sizeof(struct walk_object)) < 0)
 		goto on_error;
 
 	pb->repo = repo;
 	pb->nr_threads = 1; /* do not spawn any thread by default */
 
-	if (git_hash_ctx_init(&pb->ctx) < 0 ||
+	if (git_hash_ctx_init(&pb->ctx, hash_algorithm) < 0 ||
 		git_zstream_init(&pb->zstream, GIT_ZSTREAM_DEFLATE) < 0 ||
 		git_repository_odb(&pb->odb, repo) < 0 ||
 		packbuilder_config(pb) < 0)
@@ -186,10 +193,10 @@ static int rehash(git_packbuilder *pb)
 	git_pobject *po;
 	size_t i;
 
-	git_oidmap_clear(pb->object_ix);
+	git_packbuilder_pobjectmap_clear(&pb->object_ix);
 
 	for (i = 0, po = pb->object_list; i < pb->nr_objects; i++, po++) {
-		if (git_oidmap_set(pb->object_ix, &po->id, po) < 0)
+		if (git_packbuilder_pobjectmap_put(&pb->object_ix, &po->id, po) < 0)
 			return -1;
 	}
 
@@ -208,7 +215,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 
 	/* If the object already exists in the hash table, then we don't
 	 * have any work to do */
-	if (git_oidmap_exists(pb->object_ix, oid))
+	if (git_packbuilder_pobjectmap_contains(&pb->object_ix, oid))
 		return 0;
 
 	if (pb->nr_objects >= pb->nr_alloc) {
@@ -240,7 +247,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 	git_oid_cpy(&po->id, oid);
 	po->hash = name_hash(name);
 
-	if (git_oidmap_set(pb->object_ix, &po->id, po) < 0) {
+	if (git_packbuilder_pobjectmap_put(&pb->object_ix, &po->id, po) < 0) {
 		git_error_set_oom();
 		return -1;
 	}
@@ -248,10 +255,10 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 	pb->done = false;
 
 	if (pb->progress_cb) {
-		double current_time = git__timer();
-		double elapsed = current_time - pb->last_progress_report_time;
+		uint64_t current_time = git_time_monotonic();
+		uint64_t elapsed = current_time - pb->last_progress_report_time;
 
-		if (elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
+		if (elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
 			pb->last_progress_report_time = current_time;
 
 			ret = pb->progress_cb(
@@ -314,9 +321,11 @@ static int write_object(
 	git_object_t type;
 	unsigned char hdr[10], *zbuf = NULL;
 	void *data = NULL;
-	size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len;
+	size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len, oid_size;
 	int error;
 
+	oid_size = git_oid_size(pb->oid_type);
+
 	/*
 	 * If we have a delta base, let's use the delta to save space.
 	 * Otherwise load the whole object. 'data' ends up pointing to
@@ -346,8 +355,8 @@ static int write_object(
 		goto done;
 
 	if (type == GIT_OBJECT_REF_DELTA) {
-		if ((error = write_cb(po->delta->id.id, GIT_OID_RAWSZ, cb_data)) < 0 ||
-			(error = git_hash_update(&pb->ctx, po->delta->id.id, GIT_OID_RAWSZ)) < 0)
+		if ((error = write_cb(po->delta->id.id, oid_size, cb_data)) < 0 ||
+		    (error = git_hash_update(&pb->ctx, po->delta->id.id, oid_size)) < 0)
 			goto done;
 	}
 
@@ -507,7 +516,7 @@ static int cb_tag_foreach(const char *name, git_oid *oid, void *data)
 
 	GIT_UNUSED(name);
 
-	if ((po = git_oidmap_get(pb->object_ix, oid)) == NULL)
+	if (git_packbuilder_pobjectmap_get(&po, &pb->object_ix, oid) != 0)
 		return 0;
 
 	po->tagged = 1;
@@ -664,10 +673,10 @@ static int write_pack(git_packbuilder *pb,
 		pb->nr_remaining -= pb->nr_written;
 	} while (pb->nr_remaining && i < pb->nr_objects);
 
-	if ((error = git_hash_final(&entry_oid, &pb->ctx)) < 0)
+	if ((error = git_hash_final(entry_oid.id, &pb->ctx)) < 0)
 		goto done;
 
-	error = write_cb(entry_oid.id, GIT_OID_RAWSZ, cb_data);
+	error = write_cb(entry_oid.id, git_oid_size(pb->oid_type), cb_data);
 
 done:
 	/* if callback cancelled writing, we must still free delta_data */
@@ -685,8 +694,8 @@ done:
 
 static int write_pack_buf(void *buf, size_t size, void *data)
 {
-	git_buf *b = (git_buf *)data;
-	return git_buf_put(b, buf, size);
+	git_str *b = (git_str *)data;
+	return git_str_put(b, buf, size);
 }
 
 static int type_size_sort(const void *_a, const void *_b)
@@ -924,19 +933,24 @@ static int report_delta_progress(
 {
 	int ret;
 
+	if (pb->failure)
+		return pb->failure;
+
 	if (pb->progress_cb) {
-		double current_time = git__timer();
-		double elapsed = current_time - pb->last_progress_report_time;
+		uint64_t current_time = git_time_monotonic();
+		uint64_t elapsed = current_time - pb->last_progress_report_time;
 
-		if (force || elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
+		if (force || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
 			pb->last_progress_report_time = current_time;
 
 			ret = pb->progress_cb(
 				GIT_PACKBUILDER_DELTAFICATION,
 				count, pb->nr_objects, pb->progress_cb_payload);
 
-			if (ret)
+			if (ret) {
+				pb->failure = ret;
 				return git_error_set_after_callback(ret);
+			}
 		}
 	}
 
@@ -947,7 +961,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 	size_t *list_size, size_t window, size_t depth)
 {
 	git_pobject *po;
-	git_buf zbuf = GIT_BUF_INIT;
+	git_str zbuf = GIT_STR_INIT;
 	struct unpacked *array;
 	size_t idx = 0, count = 0;
 	size_t mem_usage = 0;
@@ -968,7 +982,10 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 		}
 
 		pb->nr_deltified += 1;
-		report_delta_progress(pb, pb->nr_deltified, false);
+		if ((error = report_delta_progress(pb, pb->nr_deltified, false)) < 0) {
+				GIT_ASSERT(git_packbuilder__progress_unlock(pb) == 0);
+				goto on_error;
+		}
 
 		po = *list++;
 		(*list_size)--;
@@ -1045,7 +1062,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 
 			memcpy(po->delta_data, zbuf.ptr, zbuf.size);
 			po->z_delta_size = zbuf.size;
-			git_buf_clear(&zbuf);
+			git_str_clear(&zbuf);
 
 			GIT_ASSERT(git_packbuilder__cache_lock(pb) == 0);
 			pb->delta_cache_size -= po->delta_size;
@@ -1093,7 +1110,7 @@ on_error:
 		git__free(array[i].data);
 	}
 	git__free(array);
-	git_buf_dispose(&zbuf);
+	git_str_dispose(&zbuf);
 
 	return error;
 }
@@ -1116,6 +1133,10 @@ struct thread_params {
 	size_t depth;
 	size_t working;
 	size_t data_ready;
+
+	/* A pb->progress_cb can stop the packing process by returning an error.
+	   When that happens, all threads observe the error and stop voluntarily. */
+	bool stopped;
 };
 
 static void *threaded_find_deltas(void *arg)
@@ -1125,7 +1146,12 @@ static void *threaded_find_deltas(void *arg)
 	while (me->remaining) {
 		if (find_deltas(me->pb, me->list, &me->remaining,
 				me->window, me->depth) < 0) {
-			; /* TODO */
+			me->stopped = true;
+			GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_lock(me->pb) == 0, NULL);
+			me->working = false;
+			git_cond_signal(&me->pb->progress_cond);
+			GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_unlock(me->pb) == 0, NULL);
+			return NULL;
 		}
 
 		GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_lock(me->pb) == 0, NULL);
@@ -1167,8 +1193,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		pb->nr_threads = git__online_cpus();
 
 	if (pb->nr_threads <= 1) {
-		find_deltas(pb, list, &list_size, window, depth);
-		return 0;
+		return find_deltas(pb, list, &list_size, window, depth);
 	}
 
 	p = git__mallocarray(pb->nr_threads, sizeof(*p));
@@ -1187,6 +1212,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		p[i].depth = depth;
 		p[i].working = 1;
 		p[i].data_ready = 0;
+		p[i].stopped = 0;
 
 		/* try to split chunks on "path" boundaries */
 		while (sub_size && sub_size < list_size &&
@@ -1254,7 +1280,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 			    (!victim || victim->remaining < p[i].remaining))
 				victim = &p[i];
 
-		if (victim) {
+		if (victim && !target->stopped) {
 			sub_size = victim->remaining / 2;
 			list = victim->list + victim->list_size - sub_size;
 			while (sub_size && list[0]->hash &&
@@ -1278,7 +1304,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		}
 		target->list_size = sub_size;
 		target->remaining = sub_size;
-		target->working = 1;
+		target->working = 1; /* even when target->stopped, so that we don't process this thread again */
 		GIT_ASSERT(git_packbuilder__progress_unlock(pb) == 0);
 
 		if (git_mutex_lock(&target->mutex)) {
@@ -1291,7 +1317,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		git_cond_signal(&target->cond);
 		git_mutex_unlock(&target->mutex);
 
-		if (!sub_size) {
+		if (target->stopped || !sub_size) {
 			git_thread_join(&target->thread, NULL);
 			git_cond_free(&target->cond);
 			git_mutex_free(&target->mutex);
@@ -1300,17 +1326,18 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 	}
 
 	git__free(p);
-	return 0;
+	return pb->failure;
 }
 
 #else
 #define ll_find_deltas(pb, l, ls, w, d) find_deltas(pb, l, &ls, w, d)
 #endif
 
-static int prepare_pack(git_packbuilder *pb)
+int git_packbuilder__prepare(git_packbuilder *pb)
 {
 	git_pobject **delta_list;
 	size_t i, n = 0;
+	int error;
 
 	if (pb->nr_objects == 0 || pb->done)
 		return 0; /* nothing to do */
@@ -1319,8 +1346,10 @@ static int prepare_pack(git_packbuilder *pb)
 	 * Although we do not report progress during deltafication, we
 	 * at least report that we are in the deltafication stage
 	 */
-	if (pb->progress_cb)
-			pb->progress_cb(GIT_PACKBUILDER_DELTAFICATION, 0, pb->nr_objects, pb->progress_cb_payload);
+	if (pb->progress_cb) {
+		if ((error = pb->progress_cb(GIT_PACKBUILDER_DELTAFICATION, 0, pb->nr_objects, pb->progress_cb_payload)) < 0)
+			return git_error_set_after_callback(error);
+	}
 
 	delta_list = git__mallocarray(pb->nr_objects, sizeof(*delta_list));
 	GIT_ERROR_CHECK_ALLOC(delta_list);
@@ -1337,41 +1366,43 @@ static int prepare_pack(git_packbuilder *pb)
 
 	if (n > 1) {
 		git__tsort((void **)delta_list, n, type_size_sort);
-		if (ll_find_deltas(pb, delta_list, n,
+		if ((error = ll_find_deltas(pb, delta_list, n,
 				   GIT_PACK_WINDOW + 1,
-				   GIT_PACK_DEPTH) < 0) {
+				   GIT_PACK_DEPTH)) < 0) {
 			git__free(delta_list);
-			return -1;
+			return error;
 		}
 	}
 
-	report_delta_progress(pb, pb->nr_objects, true);
+	error = report_delta_progress(pb, pb->nr_objects, true);
 
 	pb->done = true;
 	git__free(delta_list);
-	return 0;
+	return error;
 }
 
-#define PREPARE_PACK if (prepare_pack(pb) < 0) { return -1; }
+#define PREPARE_PACK error = git_packbuilder__prepare(pb); if (error < 0) { return error; }
 
 int git_packbuilder_foreach(git_packbuilder *pb, int (*cb)(void *buf, size_t size, void *payload), void *payload)
 {
+	int error;
 	PREPARE_PACK;
 	return write_pack(pb, cb, payload);
 }
 
-int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb)
+int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb)
 {
 	int error;
-
-	if ((error = git_buf_sanitize(buf)) < 0)
-		return error;
-
 	PREPARE_PACK;
 
 	return write_pack(pb, &write_pack_buf, buf);
 }
 
+int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb)
+{
+	GIT_BUF_WRAP_PRIVATE(buf, git_packbuilder__write_buf, pb);
+}
+
 static int write_cb(void *buf, size_t len, void *payload)
 {
 	struct pack_write_context *ctx = payload;
@@ -1386,7 +1417,7 @@ int git_packbuilder_write(
 	void *progress_cb_payload)
 {
 	int error = -1;
-	git_buf object_path = GIT_BUF_INIT;
+	git_str object_path = GIT_STR_INIT;
 	git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT;
 	git_indexer *indexer = NULL;
 	git_indexer_progress stats;
@@ -1396,17 +1427,29 @@ int git_packbuilder_write(
 	PREPARE_PACK;
 
 	if (path == NULL) {
-		if ((error = git_repository_item_path(&object_path, pb->repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0)
+		if ((error = git_repository__item_path(&object_path, pb->repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0)
 			goto cleanup;
-		if ((error = git_buf_joinpath(&object_path, git_buf_cstr(&object_path), "pack")) < 0)
+		if ((error = git_str_joinpath(&object_path, git_str_cstr(&object_path), "pack")) < 0)
 			goto cleanup;
-		path = git_buf_cstr(&object_path);
+		path = git_str_cstr(&object_path);
 	}
 
 	opts.progress_cb = progress_cb;
 	opts.progress_cb_payload = progress_cb_payload;
 
-	if ((error = git_indexer_new(&indexer, path, mode, pb->odb, &opts)) < 0)
+	/* TODO: SHA256 */
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+	opts.mode = mode;
+	opts.odb = pb->odb;
+	opts.oid_type = GIT_OID_SHA1;
+
+	error = git_indexer_new(&indexer, path, &opts);
+#else
+	error = git_indexer_new(&indexer, path, mode, pb->odb, &opts);
+#endif
+
+	if (error < 0)
 		goto cleanup;
 
 	if (!git_repository__configmap_lookup(&t, pb->repo, GIT_CONFIGMAP_FSYNCOBJECTFILES) && t)
@@ -1421,20 +1464,32 @@ int git_packbuilder_write(
 	if ((error = git_indexer_commit(indexer, &stats)) < 0)
 		goto cleanup;
 
+#ifndef GIT_DEPRECATE_HARD
 	git_oid_cpy(&pb->pack_oid, git_indexer_hash(indexer));
+#endif
+
+	pb->pack_name = git__strdup(git_indexer_name(indexer));
+	GIT_ERROR_CHECK_ALLOC(pb->pack_name);
 
 cleanup:
 	git_indexer_free(indexer);
-	git_buf_dispose(&object_path);
+	git_str_dispose(&object_path);
 	return error;
 }
 
 #undef PREPARE_PACK
 
+#ifndef GIT_DEPRECATE_HARD
 const git_oid *git_packbuilder_hash(git_packbuilder *pb)
 {
 	return &pb->pack_oid;
 }
+#endif
+
+const char *git_packbuilder_name(git_packbuilder *pb)
+{
+	return pb->pack_name;
+}
 
 
 static int cb_tree_walk(
@@ -1447,10 +1502,10 @@ static int cb_tree_walk(
 	if (git_tree_entry_type(entry) == GIT_OBJECT_COMMIT)
 		return 0;
 
-	if (!(error = git_buf_sets(&ctx->buf, root)) &&
-		!(error = git_buf_puts(&ctx->buf, git_tree_entry_name(entry))))
+	if (!(error = git_str_sets(&ctx->buf, root)) &&
+		!(error = git_str_puts(&ctx->buf, git_tree_entry_name(entry))))
 		error = git_packbuilder_insert(
-			ctx->pb, git_tree_entry_id(entry), git_buf_cstr(&ctx->buf));
+			ctx->pb, git_tree_entry_id(entry), git_str_cstr(&ctx->buf));
 
 	return error;
 }
@@ -1474,14 +1529,14 @@ int git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *oid)
 {
 	int error;
 	git_tree *tree = NULL;
-	struct tree_walk_context context = { pb, GIT_BUF_INIT };
+	struct tree_walk_context context = { pb, GIT_STR_INIT };
 
 	if (!(error = git_tree_lookup(&tree, pb->repo, oid)) &&
 	    !(error = git_packbuilder_insert(pb, oid, NULL)))
 		error = git_tree_walk(tree, GIT_TREEWALK_PRE, cb_tree_walk, &context);
 
 	git_tree_free(tree);
-	git_buf_dispose(&context.buf);
+	git_str_dispose(&context.buf);
 	return error;
 }
 
@@ -1553,12 +1608,16 @@ static int retrieve_object(struct walk_object **out, git_packbuilder *pb, const
 	struct walk_object *obj;
 	int error;
 
-	if ((obj = git_oidmap_get(pb->walk_objects, id)) == NULL) {
+	error = git_packbuilder_walk_objectmap_get(&obj, &pb->walk_objects, id);
+
+	if (error == GIT_ENOTFOUND) {
 		if ((error = lookup_walk_object(&obj, pb, id)) < 0)
 			return error;
 
-		if ((error = git_oidmap_set(pb->walk_objects, &obj->id, obj)) < 0)
+		if ((error = git_packbuilder_walk_objectmap_put(&pb->walk_objects, &obj->id, obj)) < 0)
 			return error;
+	} else if (error != 0) {
+		return error;
 	}
 
 	*out = obj;
@@ -1790,17 +1849,18 @@ void git_packbuilder_free(git_packbuilder *pb)
 	if (pb->odb)
 		git_odb_free(pb->odb);
 
-	if (pb->object_ix)
-		git_oidmap_free(pb->object_ix);
+	git_packbuilder_pobjectmap_dispose(&pb->object_ix);
 
 	if (pb->object_list)
 		git__free(pb->object_list);
 
-	git_oidmap_free(pb->walk_objects);
+	git_packbuilder_walk_objectmap_dispose(&pb->walk_objects);
 	git_pool_clear(&pb->object_pool);
 
 	git_hash_ctx_cleanup(&pb->ctx);
 	git_zstream_free(&pb->zstream);
 
+	git__free(pb->pack_name);
+
 	git__free(pb);
 }