rugged 0.27.9 → 0.27.10

data/vendor/libgit2/src/oid.c

@@ -17,7 +17,7 @@ static char to_hex[] = "0123456789abcdef";
 
 static int oid_error_invalid(const char *msg)
 {
-	giterr_set(GITERR_INVALID, "unable to parse OID - %s", msg);
+	git_error_set(GIT_ERROR_INVALID, "unable to parse OID - %s", msg);
 	return -1;
 }
 
@@ -237,7 +237,7 @@ int git_oid_streq(const git_oid *oid_a, const char *str)
 	return git_oid_strcmp(oid_a, str) == 0 ? 0 : -1;
 }
 
-int git_oid_iszero(const git_oid *oid_a)
+int git_oid_is_zero(const git_oid *oid_a)
 {
 	const unsigned char *a = oid_a->id;
 	unsigned int i;
@@ -247,6 +247,11 @@ int git_oid_iszero(const git_oid *oid_a)
 	return 1;
 }
 
+int git_oid_iszero(const git_oid *oid_a)
+{
+	return git_oid_is_zero(oid_a);
+}
+
 typedef short node_index;
 
 typedef union {
@@ -263,7 +268,7 @@ struct git_oid_shorten {
 static int resize_trie(git_oid_shorten *self, size_t new_size)
 {
 	self->nodes = git__reallocarray(self->nodes, new_size, sizeof(trie_node));
-	GITERR_CHECK_ALLOC(self->nodes);
+	GIT_ERROR_CHECK_ALLOC(self->nodes);
 
 	if (new_size > self->size) {
 		memset(&self->nodes[self->size], 0x0, (new_size - self->size) * sizeof(trie_node));
@@ -381,7 +386,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 	node_index idx;
 
 	if (os->full) {
-		giterr_set(GITERR_INVALID, "unable to shorten OID - OID set full");
+		git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - OID set full");
 		return -1;
 	}
 
@@ -396,7 +401,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 		trie_node *node;
 
 		if (c == -1) {
-			giterr_set(GITERR_INVALID, "unable to shorten OID - invalid hex value");
+			git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - invalid hex value");
 			return -1;
 		}
 
@@ -411,7 +416,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 			node = push_leaf(os, idx, git__fromhex(tail[0]), &tail[1]);
 			if (node == NULL) {
 				if (os->full)
-					giterr_set(GITERR_INVALID, "unable to shorten OID - OID set full");
+					git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - OID set full");
 				return -1;
 			}
 		}
@@ -419,7 +424,7 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 		if (node->children[c] == 0) {
 			if (push_leaf(os, idx, c, &text_oid[i + 1]) == NULL) {
 				if (os->full)
-					giterr_set(GITERR_INVALID, "unable to shorten OID - OID set full");
+					git_error_set(GIT_ERROR_INVALID, "unable to shorten OID - OID set full");
 				return -1;
 			}
 			break;

data/vendor/libgit2/src/oidmap.c

@@ -7,6 +7,15 @@
 
 #include "oidmap.h"
 
+#define kmalloc git__malloc
+#define kcalloc git__calloc
+#define krealloc git__realloc
+#define kreallocarray git__reallocarray
+#define kfree git__free
+#include "khash.h"
+
+__KHASH_TYPE(oid, const git_oid *, void *)
+
 GIT_INLINE(khint_t) git_oidmap_hash(const git_oid *oid)
 {
 	khint_t h;
@@ -16,9 +25,12 @@ GIT_INLINE(khint_t) git_oidmap_hash(const git_oid *oid)
 
 __KHASH_IMPL(oid, static kh_inline, const git_oid *, void *, 1, git_oidmap_hash, git_oid_equal)
 
-git_oidmap *git_oidmap_alloc()
+int git_oidmap_new(git_oidmap **out)
 {
-	return kh_init(oid);
+	*out = kh_init(oid);
+	GIT_ERROR_CHECK_ALLOC(*out);
+
+	return 0;
 }
 
 void git_oidmap_free(git_oidmap *map)
@@ -36,70 +48,60 @@ size_t git_oidmap_size(git_oidmap *map)
 	return kh_size(map);
 }
 
-size_t git_oidmap_lookup_index(git_oidmap *map, const git_oid *key)
+void *git_oidmap_get(git_oidmap *map, const git_oid *key)
 {
-	return kh_get(oid, map, key);
+	size_t idx = kh_get(oid, map, key);
+	if (idx == kh_end(map) || !kh_exist(map, idx))
+		return NULL;
+	return kh_val(map, idx);
 }
 
-int git_oidmap_valid_index(git_oidmap *map, size_t idx)
+int git_oidmap_set(git_oidmap *map, const git_oid *key, void *value)
 {
-	return idx != kh_end(map);
-}
+	size_t idx;
+	int rval;
 
-int git_oidmap_exists(git_oidmap *map, const git_oid *key)
-{
-	return kh_get(oid, map, key) != kh_end(map);
-}
+	idx = kh_put(oid, map, key, &rval);
+	if (rval < 0)
+		return -1;
 
-int git_oidmap_has_data(git_oidmap *map, size_t idx)
-{
-	return kh_exist(map, idx);
-}
+	if (rval == 0)
+		kh_key(map, idx) = key;
 
-const git_oid *git_oidmap_key(git_oidmap *map, size_t idx)
-{
-	return kh_key(map, idx);
-}
+	kh_val(map, idx) = value;
 
-void git_oidmap_set_key_at(git_oidmap *map, size_t idx, git_oid *key)
-{
-	kh_key(map, idx) = key;
+	return 0;
 }
 
-void *git_oidmap_value_at(git_oidmap *map, size_t idx)
+int git_oidmap_delete(git_oidmap *map, const git_oid *key)
 {
-	return kh_val(map, idx);
+	khiter_t idx = kh_get(oid, map, key);
+	if (idx == kh_end(map))
+		return GIT_ENOTFOUND;
+	kh_del(oid, map, idx);
+	return 0;
 }
 
-void git_oidmap_set_value_at(git_oidmap *map, size_t idx, void *value)
+int git_oidmap_exists(git_oidmap *map, const git_oid *key)
 {
-	kh_val(map, idx) = value;
+	return kh_get(oid, map, key) != kh_end(map);
 }
 
-void git_oidmap_delete_at(git_oidmap *map, size_t idx)
+int git_oidmap_iterate(void **value, git_oidmap *map, size_t *iter, const git_oid **key)
 {
-	kh_del(oid, map, idx);
-}
+	size_t i = *iter;
 
-int git_oidmap_put(git_oidmap *map, const git_oid *key, int *err)
-{
-	return kh_put(oid, map, key, err);
-}
+	while (i < map->n_buckets && !kh_exist(map, i))
+		i++;
 
-void git_oidmap_insert(git_oidmap *map, const git_oid *key, void *value, int *rval)
-{
-	khiter_t idx = kh_put(oid, map, key, rval);
+	if (i >= map->n_buckets)
+		return GIT_ITEROVER;
 
-	if ((*rval) >= 0) {
-		if ((*rval) == 0)
-			kh_key(map, idx) = key;
-		kh_val(map, idx) = value;
-	}
-}
+	if (key)
+		*key = kh_key(map, i);
+	if (value)
+		*value = kh_value(map, i);
+	*iter = ++i;
 
-void git_oidmap_delete(git_oidmap *map, const git_oid *key)
-{
-	khiter_t idx = git_oidmap_lookup_index(map, key);
-	if (git_oidmap_valid_index(map, idx))
-		git_oidmap_delete_at(map, idx);
+	return 0;
 }

data/vendor/libgit2/src/oidmap.h

@@ -11,41 +11,118 @@
 
 #include "git2/oid.h"
 
-#define kmalloc git__malloc
-#define kcalloc git__calloc
-#define krealloc git__realloc
-#define kreallocarray git__reallocarray
-#define kfree git__free
-#include "khash.h"
+/** A map with `git_oid`s as key. */
+typedef struct kh_oid_s git_oidmap;
 
-__KHASH_TYPE(oid, const git_oid *, void *)
-typedef khash_t(oid) git_oidmap;
+/**
+ * Allocate a new OID map.
+ *
+ * @param out Pointer to the map that shall be allocated.
+ * @return 0 on success, an error code if allocation has failed.
+ */
+int git_oidmap_new(git_oidmap **out);
 
-git_oidmap *git_oidmap_alloc(void);
+/**
+ * Free memory associated with the map.
+ *
+ * Note that this function will _not_ free values added to this
+ * map.
+ *
+ * @param map Pointer to the map that is to be free'd. May be
+ *            `NULL`.
+ */
 void git_oidmap_free(git_oidmap *map);
+
+/**
+ * Clear all entries from the map.
+ *
+ * This function will remove all entries from the associated map.
+ * Memory associated with it will not be released, though.
+ *
+ * @param map Pointer to the map that shall be cleared. May be
+ *            `NULL`.
+ */
 void git_oidmap_clear(git_oidmap *map);
 
+/**
+ * Return the number of elements in the map.
+ *
+ * @parameter map map containing the elements
+ * @return number of elements in the map
+ */
 size_t git_oidmap_size(git_oidmap *map);
 
-size_t git_oidmap_lookup_index(git_oidmap *map, const git_oid *key);
-int git_oidmap_valid_index(git_oidmap *map, size_t idx);
+/**
+ * Return value associated with the given key.
+ *
+ * @param map map to search key in
+ * @param key key to search for
+ * @return value associated with the given key or NULL if the key was not found
+ */
+void *git_oidmap_get(git_oidmap *map, const git_oid *key);
 
-int git_oidmap_exists(git_oidmap *map, const git_oid *key);
-int git_oidmap_has_data(git_oidmap *map, size_t idx);
+/**
+ * Set the entry for key to value.
+ *
+ * If the map has no corresponding entry for the given key, a new
+ * entry will be created with the given value. If an entry exists
+ * already, its value will be updated to match the given value.
+ *
+ * @param map map to create new entry in
+ * @param key key to set
+ * @param value value to associate the key with; may be NULL
+ * @return zero if the key was successfully set, a negative error
+ *         code otherwise
+ */
+int git_oidmap_set(git_oidmap *map, const git_oid *key, void *value);
 
-const git_oid *git_oidmap_key(git_oidmap *map, size_t idx);
-void git_oidmap_set_key_at(git_oidmap *map, size_t idx, git_oid *key);
-void *git_oidmap_value_at(git_oidmap *map, size_t idx);
-void git_oidmap_set_value_at(git_oidmap *map, size_t idx, void *value);
-void git_oidmap_delete_at(git_oidmap *map, size_t idx);
+/**
+ * Delete an entry from the map.
+ *
+ * Delete the given key and its value from the map. If no such
+ * key exists, this will do nothing.
+ *
+ * @param map map to delete key in
+ * @param key key to delete
+ * @return `0` if the key has been deleted, GIT_ENOTFOUND if no
+ *         such key was found, a negative code in case of an
+ *         error
+ */
+int git_oidmap_delete(git_oidmap *map, const git_oid *key);
 
-int git_oidmap_put(git_oidmap *map, const git_oid *key, int *err);
-void git_oidmap_insert(git_oidmap *map, const git_oid *key, void *value, int *rval);
-void git_oidmap_delete(git_oidmap *map, const git_oid *key);
+/**
+ * Check whether a key exists in the given map.
+ *
+ * @param map map to query for the key
+ * @param key key to search for
+ * @return 0 if the key has not been found, 1 otherwise
+ */
+int git_oidmap_exists(git_oidmap *map, const git_oid *key);
 
-#define git_oidmap_foreach_value kh_foreach_value
+/**
+ * Iterate over entries of the map.
+ *
+ * This functions allows to iterate over all key-value entries of
+ * the map. The current position is stored in the `iter` variable
+ * and should be initialized to `0` before the first call to this
+ * function.
+ *
+ * @param map map to iterate over
+ * @param value pointer to the variable where to store the current
+ *            value. May be NULL.
+ * @param iter iterator storing the current position. Initialize
+ *             with zero previous to the first call.
+ * @param key pointer to the variable where to store the current
+ *            key. May be NULL.
+ * @return `0` if the next entry was correctly retrieved.
+ *        GIT_ITEROVER if no entries are left. A negative error
+ *        code otherwise.
+ */
+int git_oidmap_iterate(void **value, git_oidmap *map, size_t *iter, const git_oid **key);
 
-#define git_oidmap_begin	kh_begin
-#define git_oidmap_end		kh_end
+#define git_oidmap_foreach_value(h, vvar, code) { size_t __i = 0;		\
+	while (git_oidmap_iterate((void **) &(vvar), h, &__i, NULL) == 0) {	\
+		code;								\
+	} }
 
 #endif

data/vendor/libgit2/src/pack-objects.c

@@ -38,7 +38,13 @@ struct tree_walk_context {
 
 struct pack_write_context {
 	git_indexer *indexer;
-	git_transfer_progress *stats;
+	git_indexer_progress *stats;
+};
+
+struct walk_object {
+	git_oid id;
+	unsigned int uninteresting:1,
+		seen:1;
 };
 
 #ifdef GIT_THREADS
@@ -99,7 +105,7 @@ static int packbuilder_config(git_packbuilder *pb)
 	ret = git_config_get_int64(&val, config, KEY); \
 	if (!ret) { \
 		if (!git__is_sizet(val)) { \
-			giterr_set(GITERR_CONFIG, \
+			git_error_set(GIT_ERROR_CONFIG, \
 				"configuration value '%s' is too large", KEY); \
 			ret = -1; \
 			goto out; \
@@ -133,17 +139,15 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	*out = NULL;
 
 	pb = git__calloc(1, sizeof(*pb));
-	GITERR_CHECK_ALLOC(pb);
+	GIT_ERROR_CHECK_ALLOC(pb);
 
-	pb->object_ix = git_oidmap_alloc();
-	if (!pb->object_ix)
+	if (git_oidmap_new(&pb->object_ix) < 0)
 		goto on_error;
 
-	pb->walk_objects = git_oidmap_alloc();
-	if (!pb->walk_objects)
+	if (git_oidmap_new(&pb->walk_objects) < 0)
 		goto on_error;
 
-	git_pool_init(&pb->object_pool, sizeof(git_walk_object));
+	git_pool_init(&pb->object_pool, sizeof(struct walk_object));
 
 	pb->repo = repo;
 	pb->nr_threads = 1; /* do not spawn any thread by default */
@@ -160,7 +164,7 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 		git_mutex_init(&pb->progress_mutex) ||
 		git_cond_init(&pb->progress_cond))
 	{
-		giterr_set(GITERR_OS, "failed to initialize packbuilder mutex");
+		git_error_set(GIT_ERROR_OS, "failed to initialize packbuilder mutex");
 		goto on_error;
 	}
 
@@ -188,25 +192,25 @@ unsigned int git_packbuilder_set_threads(git_packbuilder *pb, unsigned int n)
 	return pb->nr_threads;
 }
 
-static void rehash(git_packbuilder *pb)
+static int rehash(git_packbuilder *pb)
 {
 	git_pobject *po;
-	khiter_t pos;
 	size_t i;
-	int ret;
 
 	git_oidmap_clear(pb->object_ix);
+
 	for (i = 0, po = pb->object_list; i < pb->nr_objects; i++, po++) {
-		pos = git_oidmap_put(pb->object_ix, &po->id, &ret);
-		git_oidmap_set_value_at(pb->object_ix, pos, po);
+		if (git_oidmap_set(pb->object_ix, &po->id, po) < 0)
+			return -1;
 	}
+
+	return 0;
 }
 
 int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 			   const char *name)
 {
 	git_pobject *po;
-	khiter_t pos;
 	size_t newsize;
 	int ret;
 
@@ -218,11 +222,11 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 		return 0;
 
 	if (pb->nr_objects >= pb->nr_alloc) {
-		GITERR_CHECK_ALLOC_ADD(&newsize, pb->nr_alloc, 1024);
-		GITERR_CHECK_ALLOC_MULTIPLY(&newsize, newsize, 3 / 2);
+		GIT_ERROR_CHECK_ALLOC_ADD(&newsize, pb->nr_alloc, 1024);
+		GIT_ERROR_CHECK_ALLOC_MULTIPLY(&newsize, newsize / 2, 3);
 
 		if (!git__is_uint32(newsize)) {
-			giterr_set(GITERR_NOMEMORY, "packfile too large to fit in memory.");
+			git_error_set(GIT_ERROR_NOMEMORY, "packfile too large to fit in memory.");
 			return -1;
 		}
 
@@ -230,8 +234,10 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 
 		pb->object_list = git__reallocarray(pb->object_list,
 			pb->nr_alloc, sizeof(*po));
-		GITERR_CHECK_ALLOC(pb->object_list);
-		rehash(pb);
+		GIT_ERROR_CHECK_ALLOC(pb->object_list);
+
+		if (rehash(pb) < 0)
+			return -1;
 	}
 
 	po = pb->object_list + pb->nr_objects;
@@ -244,13 +250,10 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 	git_oid_cpy(&po->id, oid);
 	po->hash = name_hash(name);
 
-	pos = git_oidmap_put(pb->object_ix, &po->id, &ret);
-	if (ret < 0) {
-		giterr_set_oom();
-		return ret;
+	if (git_oidmap_set(pb->object_ix, &po->id, po) < 0) {
+		git_error_set_oom();
+		return -1;
 	}
-	assert(ret != 0);
-	git_oidmap_set_value_at(pb->object_ix, pos, po);
 
 	pb->done = false;
 
@@ -266,7 +269,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 				pb->nr_objects, 0, pb->progress_cb_payload);
 
 			if (ret)
-				return giterr_set_after_callback(ret);
+				return git_error_set_after_callback(ret);
 		}
 	}
 
@@ -295,7 +298,7 @@ static int get_delta(void **out, git_odb *odb, git_pobject *po)
 		goto on_error;
 
 	if (error == GIT_EBUFS || delta_size != po->delta_size) {
-		giterr_set(GITERR_INVALID, "delta size changed");
+		git_error_set(GIT_ERROR_INVALID, "delta size changed");
 		goto on_error;
 	}
 
@@ -318,7 +321,7 @@ static int write_object(
 	void *cb_data)
 {
 	git_odb_object *obj = NULL;
-	git_otype type;
+	git_object_t type;
 	unsigned char hdr[10], *zbuf = NULL;
 	void *data = NULL;
 	size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len;
@@ -336,7 +339,7 @@ static int write_object(
 				goto done;
 
 		data_len = po->delta_size;
-		type = GIT_OBJ_REF_DELTA;
+		type = GIT_OBJECT_REF_DELTA;
 	} else {
 		if ((error = git_odb_read(&obj, pb->odb, &po->id)) < 0)
 			goto done;
@@ -353,7 +356,7 @@ static int write_object(
 		(error = git_hash_update(&pb->ctx, hdr, hdr_len)) < 0)
 		goto done;
 
-	if (type == GIT_OBJ_REF_DELTA) {
+	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)
 			goto done;
@@ -368,7 +371,7 @@ static int write_object(
 			goto done;
 	} else {
 		zbuf = git__malloc(zbuf_len);
-		GITERR_CHECK_ALLOC(zbuf);
+		GIT_ERROR_CHECK_ALLOC(zbuf);
 
 		git_zstream_reset(&pb->zstream);
 		git_zstream_set_input(&pb->zstream, data, data_len);
@@ -510,15 +513,12 @@ static int cb_tag_foreach(const char *name, git_oid *oid, void *data)
 {
 	git_packbuilder *pb = data;
 	git_pobject *po;
-	khiter_t pos;
 
 	GIT_UNUSED(name);
 
-	pos = git_oidmap_lookup_index(pb->object_ix, oid);
-	if (!git_oidmap_valid_index(pb->object_ix, pos))
+	if ((po = git_oidmap_get(pb->object_ix, oid)) == NULL)
 		return 0;
 
-	po = git_oidmap_value_at(pb->object_ix, pos);
 	po->tagged = 1;
 
 	/* TODO: peel objects */
@@ -590,8 +590,8 @@ static git_pobject **compute_write_order(git_packbuilder *pb)
 	 */
 	for (i = last_untagged; i < pb->nr_objects; i++) {
 		git_pobject *po = pb->object_list + i;
-		if (po->type != GIT_OBJ_COMMIT &&
-		    po->type != GIT_OBJ_TAG)
+		if (po->type != GIT_OBJECT_COMMIT &&
+		    po->type != GIT_OBJECT_TAG)
 			continue;
 		add_to_write_order(wo, &wo_end, po);
 	}
@@ -601,7 +601,7 @@ static git_pobject **compute_write_order(git_packbuilder *pb)
 	 */
 	for (i = last_untagged; i < pb->nr_objects; i++) {
 		git_pobject *po = pb->object_list + i;
-		if (po->type != GIT_OBJ_TREE)
+		if (po->type != GIT_OBJECT_TREE)
 			continue;
 		add_to_write_order(wo, &wo_end, po);
 	}
@@ -617,7 +617,7 @@ static git_pobject **compute_write_order(git_packbuilder *pb)
 
 	if (wo_end != pb->nr_objects) {
 		git__free(wo);
-		giterr_set(GITERR_INVALID, "invalid write order");
+		git_error_set(GIT_ERROR_INVALID, "invalid write order");
 		return NULL;
 	}
 
@@ -641,7 +641,7 @@ static int write_pack(git_packbuilder *pb,
 		return -1;
 
 	if (!git__is_uint32(pb->nr_objects)) {
-		giterr_set(GITERR_INVALID, "too many objects");
+		git_error_set(GIT_ERROR_INVALID, "too many objects");
 		return -1;
 	}
 
@@ -798,13 +798,13 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 
 		sz = git_odb_object_size(obj);
 		trg->data = git__malloc(sz);
-		GITERR_CHECK_ALLOC(trg->data);
+		GIT_ERROR_CHECK_ALLOC(trg->data);
 		memcpy(trg->data, git_odb_object_data(obj), sz);
 
 		git_odb_object_free(obj);
 
 		if (sz != trg_size) {
-			giterr_set(GITERR_INVALID,
+			git_error_set(GIT_ERROR_INVALID,
 				   "inconsistent target object length");
 			return -1;
 		}
@@ -820,13 +820,13 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 
 		sz = obj_sz;
 		src->data = git__malloc(sz);
-		GITERR_CHECK_ALLOC(src->data);
+		GIT_ERROR_CHECK_ALLOC(src->data);
 		memcpy(src->data, git_odb_object_data(obj), sz);
 
 		git_odb_object_free(obj);
 
 		if (sz != src_size) {
-			giterr_set(GITERR_INVALID,
+			git_error_set(GIT_ERROR_INVALID,
 				   "inconsistent source object length");
 			return -1;
 		}
@@ -872,7 +872,7 @@ static int try_delta(git_packbuilder *pb, struct unpacked *trg,
 		}
 
 		trg_object->delta_data = git__realloc(delta_buf, delta_size);
-		GITERR_CHECK_ALLOC(trg_object->delta_data);
+		GIT_ERROR_CHECK_ALLOC(trg_object->delta_data);
 	} else {
 		/* create delta when writing the pack */
 		git_packbuilder__cache_unlock(pb);
@@ -938,7 +938,7 @@ static int report_delta_progress(
 				count, pb->nr_objects, pb->progress_cb_payload);
 
 			if (ret)
-				return giterr_set_after_callback(ret);
+				return git_error_set_after_callback(ret);
 		}
 	}
 
@@ -957,7 +957,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 	int error = -1;
 
 	array = git__calloc(window, sizeof(struct unpacked));
-	GITERR_CHECK_ALLOC(array);
+	GIT_ERROR_CHECK_ALLOC(array);
 
 	for (;;) {
 		struct unpacked *n = array + idx;
@@ -1043,7 +1043,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 
 			git__free(po->delta_data);
 			po->delta_data = git__malloc(zbuf.size);
-			GITERR_CHECK_ALLOC(po->delta_data);
+			GIT_ERROR_CHECK_ALLOC(po->delta_data);
 
 			memcpy(po->delta_data, zbuf.ptr, zbuf.size);
 			po->z_delta_size = zbuf.size;
@@ -1095,7 +1095,7 @@ on_error:
 		git__free(array[i].data);
 	}
 	git__free(array);
-	git_buf_free(&zbuf);
+	git_buf_dispose(&zbuf);
 
 	return error;
 }
@@ -1136,7 +1136,7 @@ static void *threaded_find_deltas(void *arg)
 		git_packbuilder__progress_unlock(me->pb);
 
 		if (git_mutex_lock(&me->mutex)) {
-			giterr_set(GITERR_THREAD, "unable to lock packfile condition mutex");
+			git_error_set(GIT_ERROR_THREAD, "unable to lock packfile condition mutex");
 			return NULL;
 		}
 
@@ -1174,7 +1174,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 	}
 
 	p = git__mallocarray(pb->nr_threads, sizeof(*p));
-	GITERR_CHECK_ALLOC(p);
+	GIT_ERROR_CHECK_ALLOC(p);
 
 	/* Partition the work among the threads */
 	for (i = 0; i < pb->nr_threads; ++i) {
@@ -1215,7 +1215,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		ret = git_thread_create(&p[i].thread,
 					threaded_find_deltas, &p[i]);
 		if (ret) {
-			giterr_set(GITERR_THREAD, "unable to create thread");
+			git_error_set(GIT_ERROR_THREAD, "unable to create thread");
 			return -1;
 		}
 		active_threads++;
@@ -1284,7 +1284,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		git_packbuilder__progress_unlock(pb);
 
 		if (git_mutex_lock(&target->mutex)) {
-			giterr_set(GITERR_THREAD, "unable to lock packfile condition mutex");
+			git_error_set(GIT_ERROR_THREAD, "unable to lock packfile condition mutex");
 			git__free(p);
 			return -1;
 		}
@@ -1325,7 +1325,7 @@ static int prepare_pack(git_packbuilder *pb)
 			pb->progress_cb(GIT_PACKBUILDER_DELTAFICATION, 0, pb->nr_objects, pb->progress_cb_payload);
 
 	delta_list = git__mallocarray(pb->nr_objects, sizeof(*delta_list));
-	GITERR_CHECK_ALLOC(delta_list);
+	GIT_ERROR_CHECK_ALLOC(delta_list);
 
 	for (i = 0; i < pb->nr_objects; ++i) {
 		git_pobject *po = pb->object_list + i;
@@ -1379,21 +1379,25 @@ int git_packbuilder_write(
 	git_packbuilder *pb,
 	const char *path,
 	unsigned int mode,
-	git_transfer_progress_cb progress_cb,
+	git_indexer_progress_cb progress_cb,
 	void *progress_cb_payload)
 {
+	git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT;
 	git_indexer *indexer;
-	git_transfer_progress stats;
+	git_indexer_progress stats;
 	struct pack_write_context ctx;
 	int t;
 
 	PREPARE_PACK;
 
+	opts.progress_cb = progress_cb;
+	opts.progress_cb_payload = progress_cb_payload;
+
 	if (git_indexer_new(
-		&indexer, path, mode, pb->odb, progress_cb, progress_cb_payload) < 0)
+		&indexer, path, mode, pb->odb, &opts) < 0)
 		return -1;
 
-	if (!git_repository__cvar(&t, pb->repo, GIT_CVAR_FSYNCOBJECTFILES) && t)
+	if (!git_repository__configmap_lookup(&t, pb->repo, GIT_CONFIGMAP_FSYNCOBJECTFILES) && t)
 		git_indexer__set_fsync(indexer, 1);
 
 	ctx.indexer = indexer;
@@ -1426,7 +1430,7 @@ static int cb_tree_walk(
 	struct tree_walk_context *ctx = payload;
 
 	/* A commit inside a tree represents a submodule commit and should be skipped. */
-	if (git_tree_entry_type(entry) == GIT_OBJ_COMMIT)
+	if (git_tree_entry_type(entry) == GIT_OBJECT_COMMIT)
 		return 0;
 
 	if (!(error = git_buf_sets(&ctx->buf, root)) &&
@@ -1463,7 +1467,7 @@ int git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *oid)
 		error = git_tree_walk(tree, GIT_TREEWALK_PRE, cb_tree_walk, &context);
 
 	git_tree_free(tree);
-	git_buf_free(&context.buf);
+	git_buf_dispose(&context.buf);
 	return error;
 }
 
@@ -1474,27 +1478,27 @@ int git_packbuilder_insert_recur(git_packbuilder *pb, const git_oid *id, const c
 
 	assert(pb && id);
 
-	if ((error = git_object_lookup(&obj, pb->repo, id, GIT_OBJ_ANY)) < 0)
+	if ((error = git_object_lookup(&obj, pb->repo, id, GIT_OBJECT_ANY)) < 0)
 		return error;
 
 	switch (git_object_type(obj)) {
-	case GIT_OBJ_BLOB:
+	case GIT_OBJECT_BLOB:
 		error = git_packbuilder_insert(pb, id, name);
 		break;
-	case GIT_OBJ_TREE:
+	case GIT_OBJECT_TREE:
 		error = git_packbuilder_insert_tree(pb, id);
 		break;
-	case GIT_OBJ_COMMIT:
+	case GIT_OBJECT_COMMIT:
 		error = git_packbuilder_insert_commit(pb, id);
 		break;
-	case GIT_OBJ_TAG:
+	case GIT_OBJECT_TAG:
 		if ((error = git_packbuilder_insert(pb, id, name)) < 0)
 			goto cleanup;
 		error = git_packbuilder_insert_recur(pb, git_tag_target_id((git_tag *) obj), NULL);
 		break;
 
 	default:
-		giterr_set(GITERR_INVALID, "unknown object type");
+		git_error_set(GIT_ERROR_INVALID, "unknown object type");
 		error = -1;
 	}
 
@@ -1513,13 +1517,13 @@ size_t git_packbuilder_written(git_packbuilder *pb)
 	return pb->nr_written;
 }
 
-int lookup_walk_object(git_walk_object **out, git_packbuilder *pb, const git_oid *id)
+static int lookup_walk_object(struct walk_object **out, git_packbuilder *pb, const git_oid *id)
 {
-	git_walk_object *obj;
+	struct walk_object *obj;
 
 	obj = git_pool_mallocz(&pb->object_pool, 1);
 	if (!obj) {
-		giterr_set_oom();
+		git_error_set_oom();
 		return -1;
 	}
 
@@ -1529,20 +1533,17 @@ int lookup_walk_object(git_walk_object **out, git_packbuilder *pb, const git_oid
 	return 0;
 }
 
-static int retrieve_object(git_walk_object **out, git_packbuilder *pb, const git_oid *id)
+static int retrieve_object(struct walk_object **out, git_packbuilder *pb, const git_oid *id)
 {
+	struct walk_object *obj;
 	int error;
-	khiter_t pos;
-	git_walk_object *obj;
 
-	pos = git_oidmap_lookup_index(pb->walk_objects, id);
-	if (git_oidmap_valid_index(pb->walk_objects, pos)) {
-		obj = git_oidmap_value_at(pb->walk_objects, pos);
-	} else {
+	if ((obj = git_oidmap_get(pb->walk_objects, id)) == NULL) {
 		if ((error = lookup_walk_object(&obj, pb, id)) < 0)
 			return error;
 
-		git_oidmap_insert(pb->walk_objects, &obj->id, obj, &error);
+		if ((error = git_oidmap_set(pb->walk_objects, &obj->id, obj)) < 0)
+			return error;
 	}
 
 	*out = obj;
@@ -1552,7 +1553,7 @@ static int retrieve_object(git_walk_object **out, git_packbuilder *pb, const git
 static int mark_blob_uninteresting(git_packbuilder *pb, const git_oid *id)
 {
 	int error;
-	git_walk_object *obj;
+	struct walk_object *obj;
 
 	if ((error = retrieve_object(&obj, pb, id)) < 0)
 		return error;
@@ -1564,7 +1565,7 @@ static int mark_blob_uninteresting(git_packbuilder *pb, const git_oid *id)
 
 static int mark_tree_uninteresting(git_packbuilder *pb, const git_oid *id)
 {
-	git_walk_object *obj;
+	struct walk_object *obj;
 	git_tree *tree;
 	int error;
 	size_t i;
@@ -1584,11 +1585,11 @@ static int mark_tree_uninteresting(git_packbuilder *pb, const git_oid *id)
 		const git_tree_entry *entry = git_tree_entry_byindex(tree, i);
 		const git_oid *entry_id = git_tree_entry_id(entry);
 		switch (git_tree_entry_type(entry)) {
-		case GIT_OBJ_TREE:
+		case GIT_OBJECT_TREE:
 			if ((error = mark_tree_uninteresting(pb, entry_id)) < 0)
 				goto cleanup;
 			break;
-		case GIT_OBJ_BLOB:
+		case GIT_OBJECT_BLOB:
 			if ((error = mark_blob_uninteresting(pb, entry_id)) < 0)
 				goto cleanup;
 			break;
@@ -1636,7 +1637,7 @@ int insert_tree(git_packbuilder *pb, git_tree *tree)
 	size_t i;
 	int error;
 	git_tree *subtree;
-	git_walk_object *obj;
+	struct walk_object *obj;
 	const char *name;
 
 	if ((error = retrieve_object(&obj, pb, git_tree_id(tree))) < 0)
@@ -1654,7 +1655,7 @@ int insert_tree(git_packbuilder *pb, git_tree *tree)
 		const git_tree_entry *entry = git_tree_entry_byindex(tree, i);
 		const git_oid *entry_id = git_tree_entry_id(entry);
 		switch (git_tree_entry_type(entry)) {
-		case GIT_OBJ_TREE:
+		case GIT_OBJECT_TREE:
 			if ((error = git_tree_lookup(&subtree, pb->repo, entry_id)) < 0)
 				return error;
 
@@ -1665,7 +1666,7 @@ int insert_tree(git_packbuilder *pb, git_tree *tree)
 				return error;
 
 			break;
-		case GIT_OBJ_BLOB:
+		case GIT_OBJECT_BLOB:
 			if ((error = retrieve_object(&obj, pb, entry_id)) < 0)
 				return error;
 			if (obj->uninteresting)
@@ -1684,7 +1685,7 @@ int insert_tree(git_packbuilder *pb, git_tree *tree)
 	return error;
 }
 
-int insert_commit(git_packbuilder *pb, git_walk_object *obj)
+int insert_commit(git_packbuilder *pb, struct walk_object *obj)
 {
 	int error;
 	git_commit *commit = NULL;
@@ -1714,7 +1715,7 @@ int git_packbuilder_insert_walk(git_packbuilder *pb, git_revwalk *walk)
 {
 	int error;
 	git_oid id;
-	git_walk_object *obj;
+	struct walk_object *obj;
 
 	assert(pb && walk);