rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/object.h

@@ -11,8 +11,6 @@
 
 #include "repository.h"
 
-#define GIT_OBJECT_SIZE_MAX UINT64_MAX
-
 extern bool git_object__strict_input_validation;
 
 /** Base git object for inheritance */
@@ -24,47 +22,36 @@ struct git_object {
 /* fully free the object; internal method, DO NOT EXPORT */
 void git_object__free(void *object);
 
-/*
- * Parse object from raw data. Note that the resulting object is
- * tied to the lifetime of the data, as some objects simply point
- * into it.
- */
-int git_object__from_raw(
-	git_object **object_out,
-	const char *data,
-	size_t size,
-	git_object_t type);
-
 int git_object__from_odb_object(
 	git_object **object_out,
 	git_repository *repo,
 	git_odb_object *odb_obj,
-	git_object_t type);
+	git_otype type);
 
-int git_object__resolve_to_type(git_object **obj, git_object_t type);
+int git_object__resolve_to_type(git_object **obj, git_otype type);
 
-git_object_t git_object_stringn2type(const char *str, size_t len);
+git_otype git_object_stringn2type(const char *str, size_t len);
 
 int git_oid__parse(git_oid *oid, const char **buffer_out, const char *buffer_end, const char *header);
 
 void git_oid__writebuf(git_buf *buf, const char *header, const git_oid *oid);
 
 bool git_object__is_valid(
-	git_repository *repo, const git_oid *id, git_object_t expected_type);
+	git_repository *repo, const git_oid *id, git_otype expected_type);
 
-GIT_INLINE(git_object_t) git_object__type_from_filemode(git_filemode_t mode)
+GIT_INLINE(git_otype) git_object__type_from_filemode(git_filemode_t mode)
 {
 	switch (mode) {
 	case GIT_FILEMODE_TREE:
-		return GIT_OBJECT_TREE;
+		return GIT_OBJ_TREE;
 	case GIT_FILEMODE_COMMIT:
-		return GIT_OBJECT_COMMIT;
+		return GIT_OBJ_COMMIT;
 	case GIT_FILEMODE_BLOB:
 	case GIT_FILEMODE_BLOB_EXECUTABLE:
 	case GIT_FILEMODE_LINK:
-		return GIT_OBJECT_BLOB;
+		return GIT_OBJ_BLOB;
 	default:
-		return GIT_OBJECT_INVALID;
+		return GIT_OBJ_BAD;
 	}
 }
 

data/vendor/libgit2/src/object_api.c

@@ -20,12 +20,12 @@
  */
 int git_commit_lookup(git_commit **out, git_repository *repo, const git_oid *id)
 {
-	return git_object_lookup((git_object **)out, repo, id, GIT_OBJECT_COMMIT);
+	return git_object_lookup((git_object **)out, repo, id, GIT_OBJ_COMMIT);
 }
 
 int git_commit_lookup_prefix(git_commit **out, git_repository *repo, const git_oid *id, size_t len)
 {
-	return git_object_lookup_prefix((git_object **)out, repo, id, len, GIT_OBJECT_COMMIT);
+	return git_object_lookup_prefix((git_object **)out, repo, id, len, GIT_OBJ_COMMIT);
 }
 
 void git_commit_free(git_commit *obj)
@@ -53,12 +53,12 @@ int git_commit_dup(git_commit **out, git_commit *obj)
  */
 int git_tree_lookup(git_tree **out, git_repository *repo, const git_oid *id)
 {
-	return git_object_lookup((git_object **)out, repo, id, GIT_OBJECT_TREE);
+	return git_object_lookup((git_object **)out, repo, id, GIT_OBJ_TREE);
 }
 
 int git_tree_lookup_prefix(git_tree **out, git_repository *repo, const git_oid *id, size_t len)
 {
-	return git_object_lookup_prefix((git_object **)out, repo, id, len, GIT_OBJECT_TREE);
+	return git_object_lookup_prefix((git_object **)out, repo, id, len, GIT_OBJ_TREE);
 }
 
 void git_tree_free(git_tree *obj)
@@ -86,12 +86,12 @@ int git_tree_dup(git_tree **out, git_tree *obj)
  */
 int git_tag_lookup(git_tag **out, git_repository *repo, const git_oid *id)
 {
-	return git_object_lookup((git_object **)out, repo, id, GIT_OBJECT_TAG);
+	return git_object_lookup((git_object **)out, repo, id, GIT_OBJ_TAG);
 }
 
 int git_tag_lookup_prefix(git_tag **out, git_repository *repo, const git_oid *id, size_t len)
 {
-	return git_object_lookup_prefix((git_object **)out, repo, id, len, GIT_OBJECT_TAG);
+	return git_object_lookup_prefix((git_object **)out, repo, id, len, GIT_OBJ_TAG);
 }
 
 void git_tag_free(git_tag *obj)
@@ -119,12 +119,12 @@ int git_tag_dup(git_tag **out, git_tag *obj)
  */
 int git_blob_lookup(git_blob **out, git_repository *repo, const git_oid *id)
 {
-	return git_object_lookup((git_object **)out, repo, id, GIT_OBJECT_BLOB);
+	return git_object_lookup((git_object **)out, repo, id, GIT_OBJ_BLOB);
 }
 
 int git_blob_lookup_prefix(git_blob **out, git_repository *repo, const git_oid *id, size_t len)
 {
-	return git_object_lookup_prefix((git_object **)out, repo, id, len, GIT_OBJECT_BLOB);
+	return git_object_lookup_prefix((git_object **)out, repo, id, len, GIT_OBJ_BLOB);
 }
 
 void git_blob_free(git_blob *obj)

data/vendor/libgit2/src/odb.c

@@ -10,12 +10,11 @@
 #include <zlib.h>
 #include "git2/object.h"
 #include "git2/sys/odb_backend.h"
-#include "futils.h"
+#include "fileops.h"
 #include "hash.h"
 #include "delta.h"
 #include "filter.h"
 #include "repository.h"
-#include "blob.h"
 
 #include "git2/odb_backend.h"
 #include "git2/oid.h"
@@ -52,34 +51,34 @@ static git_cache *odb_cache(git_odb *odb)
 	return &odb->own_cache;
 }
 
-static int odb_otype_fast(git_object_t *type_p, git_odb *db, const git_oid *id);
+static int odb_otype_fast(git_otype *type_p, git_odb *db, const git_oid *id);
 static int load_alternates(git_odb *odb, const char *objects_dir, int alternate_depth);
 static int error_null_oid(int error, const char *message);
 
-static git_object_t odb_hardcoded_type(const git_oid *id)
+static git_otype odb_hardcoded_type(const git_oid *id)
 {
 	static git_oid empty_tree = {{ 0x4b, 0x82, 0x5d, 0xc6, 0x42, 0xcb, 0x6e, 0xb9, 0xa0, 0x60,
 					   0xe5, 0x4b, 0xf8, 0xd6, 0x92, 0x88, 0xfb, 0xee, 0x49, 0x04 }};
 
 	if (!git_oid_cmp(id, &empty_tree))
-		return GIT_OBJECT_TREE;
+		return GIT_OBJ_TREE;
 
-	return GIT_OBJECT_INVALID;
+	return GIT_OBJ_BAD;
 }
 
 static int odb_read_hardcoded(bool *found, git_rawobj *raw, const git_oid *id)
 {
-	git_object_t type;
+	git_otype type;
 
 	*found = false;
 
-	if ((type = odb_hardcoded_type(id)) == GIT_OBJECT_INVALID)
+	if ((type = odb_hardcoded_type(id)) == GIT_OBJ_BAD)
 		return 0;
 
 	raw->type = type;
 	raw->len = 0;
 	raw->data = git__calloc(1, sizeof(uint8_t));
-	GIT_ERROR_CHECK_ALLOC(raw->data);
+	GITERR_CHECK_ALLOC(raw->data);
 
 	*found = true;
 	return 0;
@@ -89,17 +88,17 @@ int git_odb__format_object_header(
 	size_t *written,
 	char *hdr,
 	size_t hdr_size,
-	git_object_size_t obj_len,
-	git_object_t obj_type)
+	git_off_t obj_len,
+	git_otype obj_type)
 {
 	const char *type_str = git_object_type2string(obj_type);
 	int hdr_max = (hdr_size > INT_MAX-2) ? (INT_MAX-2) : (int)hdr_size;
 	int len;
 
-	len = p_snprintf(hdr, hdr_max, "%s %"PRId64, type_str, (int64_t)obj_len);
+	len = p_snprintf(hdr, hdr_max, "%s %lld", type_str, (long long)obj_len);
 
 	if (len < 0 || len >= hdr_max) {
-		git_error_set(GIT_ERROR_OS, "object header creation failed");
+		giterr_set(GITERR_OS, "object header creation failed");
 		return -1;
 	}
 
@@ -117,12 +116,12 @@ int git_odb__hashobj(git_oid *id, git_rawobj *obj)
 	assert(id && obj);
 
 	if (!git_object_typeisloose(obj->type)) {
-		git_error_set(GIT_ERROR_INVALID, "invalid object type");
+		giterr_set(GITERR_INVALID, "invalid object type");
 		return -1;
 	}
 
 	if (!obj->data && obj->len != 0) {
-		git_error_set(GIT_ERROR_INVALID, "invalid object");
+		giterr_set(GITERR_INVALID, "invalid object");
 		return -1;
 	}
 
@@ -176,7 +175,7 @@ size_t git_odb_object_size(git_odb_object *object)
 	return object->cached.size;
 }
 
-git_object_t git_odb_object_type(git_odb_object *object)
+git_otype git_odb_object_type(git_odb_object *object)
 {
 	return object->cached.type;
 }
@@ -196,7 +195,7 @@ void git_odb_object_free(git_odb_object *object)
 	git_cached_obj_decref(object);
 }
 
-int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_object_t type)
+int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_otype type)
 {
 	size_t hdr_len;
 	char hdr[64], buffer[FILEIO_BUFSIZE];
@@ -205,7 +204,7 @@ int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_object_t type)
 	int error = 0;
 
 	if (!git_object_typeisloose(type)) {
-		git_error_set(GIT_ERROR_INVALID, "invalid object type for hash");
+		giterr_set(GITERR_INVALID, "invalid object type for hash");
 		return -1;
 	}
 
@@ -230,7 +229,7 @@ int git_odb__hashfd(git_oid *out, git_file fd, size_t size, git_object_t type)
 	 * If size is not zero, the file was truncated after we originally
 	 * stat'd it, so we consider this a read failure too */
 	if (read_len < 0 || size > 0) {
-		git_error_set(GIT_ERROR_OS, "error reading file for hashing");
+		giterr_set(GITERR_OS, "error reading file for hashing");
 		error = -1;
 
 		goto done;
@@ -244,7 +243,7 @@ done:
 }
 
 int git_odb__hashfd_filtered(
-	git_oid *out, git_file fd, size_t size, git_object_t type, git_filter_list *fl)
+	git_oid *out, git_file fd, size_t size, git_otype type, git_filter_list *fl)
 {
 	int error;
 	git_buf raw = GIT_BUF_INIT;
@@ -261,12 +260,12 @@ int git_odb__hashfd_filtered(
 
 		error = git_filter_list_apply_to_data(&post, fl, &raw);
 
-		git_buf_dispose(&raw);
+		git_buf_free(&raw);
 
 		if (!error)
 			error = git_odb_hash(out, post.ptr, post.size, type);
 
-		git_buf_dispose(&post);
+		git_buf_free(&post);
 	}
 
 	return error;
@@ -282,7 +281,7 @@ int git_odb__hashlink(git_oid *out, const char *path)
 		return -1;
 
 	if (!git__is_int(st.st_size) || (int)st.st_size < 0) {
-		git_error_set(GIT_ERROR_FILESYSTEM, "file size overflow for 32-bit systems");
+		giterr_set(GITERR_FILESYSTEM, "file size overflow for 32-bit systems");
 		return -1;
 	}
 
@@ -293,56 +292,50 @@ int git_odb__hashlink(git_oid *out, const char *path)
 		int read_len;
 		size_t alloc_size;
 
-		GIT_ERROR_CHECK_ALLOC_ADD(&alloc_size, size, 1);
+		GITERR_CHECK_ALLOC_ADD(&alloc_size, size, 1);
 		link_data = git__malloc(alloc_size);
-		GIT_ERROR_CHECK_ALLOC(link_data);
+		GITERR_CHECK_ALLOC(link_data);
 
 		read_len = p_readlink(path, link_data, size);
 		link_data[size] = '\0';
 		if (read_len != size) {
-			git_error_set(GIT_ERROR_OS, "failed to read symlink data for '%s'", path);
+			giterr_set(GITERR_OS, "failed to read symlink data for '%s'", path);
 			git__free(link_data);
 			return -1;
 		}
 
-		result = git_odb_hash(out, link_data, size, GIT_OBJECT_BLOB);
+		result = git_odb_hash(out, link_data, size, GIT_OBJ_BLOB);
 		git__free(link_data);
 	} else {
 		int fd = git_futils_open_ro(path);
 		if (fd < 0)
 			return -1;
-		result = git_odb__hashfd(out, fd, size, GIT_OBJECT_BLOB);
+		result = git_odb__hashfd(out, fd, size, GIT_OBJ_BLOB);
 		p_close(fd);
 	}
 
 	return result;
 }
 
-int git_odb_hashfile(git_oid *out, const char *path, git_object_t type)
+int git_odb_hashfile(git_oid *out, const char *path, git_otype type)
 {
-	uint64_t size;
-	int fd, error = 0;
-
-	if ((fd = git_futils_open_ro(path)) < 0)
+	git_off_t size;
+	int result, fd = git_futils_open_ro(path);
+	if (fd < 0)
 		return fd;
 
-	if ((error = git_futils_filesize(&size, fd)) < 0)
-		goto done;
-
-	if (!git__is_sizet(size)) {
-		git_error_set(GIT_ERROR_OS, "file size overflow for 32-bit systems");
-		error = -1;
-		goto done;
+	if ((size = git_futils_filesize(fd)) < 0 || !git__is_sizet(size)) {
+		giterr_set(GITERR_OS, "file size overflow for 32-bit systems");
+		p_close(fd);
+		return -1;
 	}
 
-	error = git_odb__hashfd(out, fd, (size_t)size, type);
-
-done:
+	result = git_odb__hashfd(out, fd, (size_t)size, type);
 	p_close(fd);
-	return error;
+	return result;
 }
 
-int git_odb_hash(git_oid *id, const void *data, size_t len, git_object_t type)
+int git_odb_hash(git_oid *id, const void *data, size_t len, git_otype type)
 {
 	git_rawobj raw;
 
@@ -363,7 +356,7 @@ typedef struct {
 	git_odb_stream stream;
 	char *buffer;
 	size_t size, written;
-	git_object_t type;
+	git_otype type;
 } fake_wstream;
 
 static int fake_wstream__fwrite(git_odb_stream *_stream, const git_oid *oid)
@@ -391,20 +384,21 @@ static void fake_wstream__free(git_odb_stream *_stream)
 	git__free(stream);
 }
 
-static int init_fake_wstream(git_odb_stream **stream_p, git_odb_backend *backend, git_object_size_t size, git_object_t type)
+static int init_fake_wstream(git_odb_stream **stream_p, git_odb_backend *backend, git_off_t size, git_otype type)
 {
 	fake_wstream *stream;
-	size_t blobsize;
 
-	GIT_ERROR_CHECK_BLOBSIZE(size);
-	blobsize = (size_t)size;
+	if (!git__is_ssizet(size)) {
+		giterr_set(GITERR_ODB, "object size too large to keep in memory");
+		return -1;
+	}
 
 	stream = git__calloc(1, sizeof(fake_wstream));
-	GIT_ERROR_CHECK_ALLOC(stream);
+	GITERR_CHECK_ALLOC(stream);
 
-	stream->size = blobsize;
+	stream->size = size;
 	stream->type = type;
-	stream->buffer = git__malloc(blobsize);
+	stream->buffer = git__malloc(size);
 	if (stream->buffer == NULL) {
 		git__free(stream);
 		return -1;
@@ -447,14 +441,10 @@ static int backend_sort_cmp(const void *a, const void *b)
 int git_odb_new(git_odb **out)
 {
 	git_odb *db = git__calloc(1, sizeof(*db));
-	GIT_ERROR_CHECK_ALLOC(db);
+	GITERR_CHECK_ALLOC(db);
 
-	if (git_cache_init(&db->own_cache) < 0) {
-		git__free(db);
-		return -1;
-	}
-	if (git_vector_init(&db->backends, 4, backend_sort_cmp) < 0) {
-		git_cache_dispose(&db->own_cache);
+	if (git_cache_init(&db->own_cache) < 0 ||
+		git_vector_init(&db->backends, 4, backend_sort_cmp) < 0) {
 		git__free(db);
 		return -1;
 	}
@@ -472,13 +462,13 @@ static int add_backend_internal(
 
 	assert(odb && backend);
 
-	GIT_ERROR_CHECK_VERSION(backend, GIT_ODB_BACKEND_VERSION, "git_odb_backend");
+	GITERR_CHECK_VERSION(backend, GIT_ODB_BACKEND_VERSION, "git_odb_backend");
 
 	/* Check if the backend is already owned by another ODB */
 	assert(!backend->odb || backend->odb == odb);
 
 	internal = git__malloc(sizeof(backend_internal));
-	GIT_ERROR_CHECK_ALLOC(internal);
+	GITERR_CHECK_ALLOC(internal);
 
 	internal->backend = backend;
 	internal->priority = priority;
@@ -513,7 +503,7 @@ size_t git_odb_num_backends(git_odb *odb)
 
 static int git_odb__error_unsupported_in_backend(const char *action)
 {
-	git_error_set(GIT_ERROR_ODB,
+	giterr_set(GITERR_ODB,
 		"cannot %s - unsupported in the loaded odb backends", action);
 	return -1;
 }
@@ -531,7 +521,7 @@ int git_odb_get_backend(git_odb_backend **out, git_odb *odb, size_t pos)
 		return 0;
 	}
 
-	git_error_set(GIT_ERROR_ODB, "no ODB backend loaded at index %" PRIuZ, pos);
+	giterr_set(GITERR_ODB, "no ODB backend loaded at index %" PRIuZ, pos);
 	return GIT_ENOTFOUND;
 }
 
@@ -554,10 +544,9 @@ int git_odb__add_default_backends(
 #else
 	if (p_stat(objects_dir, &st) < 0) {
 		if (as_alternates)
-			/* this should warn */
 			return 0;
 
-		git_error_set(GIT_ERROR_ODB, "failed to load object database in '%s'", objects_dir);
+		giterr_set(GITERR_ODB, "failed to load object database in '%s'", objects_dir);
 		return -1;
 	}
 
@@ -599,12 +588,12 @@ static int load_alternates(git_odb *odb, const char *objects_dir, int alternate_
 		return -1;
 
 	if (git_path_exists(alternates_path.ptr) == false) {
-		git_buf_dispose(&alternates_path);
+		git_buf_free(&alternates_path);
 		return 0;
 	}
 
 	if (git_futils_readbuffer(&alternates_buf, alternates_path.ptr) < 0) {
-		git_buf_dispose(&alternates_path);
+		git_buf_free(&alternates_path);
 		return -1;
 	}
 
@@ -630,8 +619,8 @@ static int load_alternates(git_odb *odb, const char *objects_dir, int alternate_
 			break;
 	}
 
-	git_buf_dispose(&alternates_path);
-	git_buf_dispose(&alternates_buf);
+	git_buf_free(&alternates_path);
+	git_buf_free(&alternates_buf);
 
 	return result;
 }
@@ -668,11 +657,11 @@ int git_odb__set_caps(git_odb *odb, int caps)
 		int val;
 
 		if (!repo) {
-			git_error_set(GIT_ERROR_ODB, "cannot access repository to set odb caps");
+			giterr_set(GITERR_ODB, "cannot access repository to set odb caps");
 			return -1;
 		}
 
-		if (!git_repository__configmap_lookup(&val, repo, GIT_CONFIGMAP_FSYNCOBJECTFILES))
+		if (!git_repository__cvar(&val, repo, GIT_CVAR_FSYNCOBJECTFILES))
 			odb->do_fsync = !!val;
 	}
 
@@ -693,7 +682,7 @@ static void odb_free(git_odb *db)
 	}
 
 	git_vector_free(&db->backends);
-	git_cache_dispose(&db->own_cache);
+	git_cache_free(&db->own_cache);
 
 	git__memzero(db, sizeof(*db));
 	git__free(db);
@@ -773,7 +762,7 @@ int git_odb_exists(git_odb *db, const git_oid *id)
 
 	assert(db && id);
 
-	if (git_oid_is_zero(id))
+	if (git_oid_iszero(id))
 		return 0;
 
 	if ((object = git_cache_get_raw(odb_cache(db), id)) != NULL) {
@@ -882,7 +871,7 @@ int git_odb_expand_ids(
 		int error = GIT_EAMBIGUOUS;
 
 		if (!query->type)
-			query->type = GIT_OBJECT_ANY;
+			query->type = GIT_OBJ_ANY;
 
 		/* if we have a short OID, expand it first */
 		if (query->length >= GIT_OID_MINPREFIXLEN && query->length < GIT_OID_HEXSZ) {
@@ -900,11 +889,11 @@ int git_odb_expand_ids(
 		 * or because the user passed a full OID. Ensure its type is right.
 		 */
 		if (query->length >= GIT_OID_HEXSZ) {
-			git_object_t actual_type;
+			git_otype actual_type;
 
 			error = odb_otype_fast(&actual_type, db, &query->id);
 			if (!error) {
-				if (query->type != GIT_OBJECT_ANY && query->type != actual_type)
+				if (query->type != GIT_OBJ_ANY && query->type != actual_type)
 					error = GIT_ENOTFOUND;
 				else
 					query->type = actual_type;
@@ -930,11 +919,11 @@ int git_odb_expand_ids(
 		}
 	}
 
-	git_error_clear();
+	giterr_clear();
 	return 0;
 }
 
-int git_odb_read_header(size_t *len_p, git_object_t *type_p, git_odb *db, const git_oid *id)
+int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id)
 {
 	int error;
 	git_odb_object *object;
@@ -948,15 +937,15 @@ int git_odb_read_header(size_t *len_p, git_object_t *type_p, git_odb *db, const
 }
 
 static int odb_read_header_1(
-	size_t *len_p, git_object_t *type_p, git_odb *db,
+	size_t *len_p, git_otype *type_p, git_odb *db,
 	const git_oid *id, bool only_refreshed)
 {
 	size_t i;
-	git_object_t ht;
+	git_otype ht;
 	bool passthrough = false;
 	int error;
 
-	if (!only_refreshed && (ht = odb_hardcoded_type(id)) != GIT_OBJECT_INVALID) {
+	if (!only_refreshed && (ht = odb_hardcoded_type(id)) != GIT_OBJ_BAD) {
 		*type_p = ht;
 		*len_p = 0;
 		return 0;
@@ -991,7 +980,7 @@ static int odb_read_header_1(
 }
 
 int git_odb__read_header_or_object(
-	git_odb_object **out, size_t *len_p, git_object_t *type_p,
+	git_odb_object **out, size_t *len_p, git_otype *type_p,
 	git_odb *db, const git_oid *id)
 {
 	int error = GIT_ENOTFOUND;
@@ -1001,7 +990,7 @@ int git_odb__read_header_or_object(
 
 	*out = NULL;
 
-	if (git_oid_is_zero(id))
+	if (git_oid_iszero(id))
 		return error_null_oid(GIT_ENOTFOUND, "cannot read object");
 
 	if ((object = git_cache_get_raw(odb_cache(db), id)) != NULL) {
@@ -1086,7 +1075,7 @@ static int odb_read_1(git_odb_object **out, git_odb *db, const git_oid *id,
 		}
 	}
 
-	git_error_clear();
+	giterr_clear();
 	if ((object = odb_object__alloc(id, &raw)) == NULL) {
 		error = -1;
 		goto out;
@@ -1106,7 +1095,7 @@ int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id)
 
 	assert(out && db && id);
 
-	if (git_oid_is_zero(id))
+	if (git_oid_iszero(id))
 		return error_null_oid(GIT_ENOTFOUND, "cannot read object");
 
 	*out = git_cache_get_raw(odb_cache(db), id);
@@ -1124,18 +1113,17 @@ int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id)
 	return error;
 }
 
-static int odb_otype_fast(git_object_t *type_p, git_odb *db, const git_oid *id)
+static int odb_otype_fast(git_otype *type_p, git_odb *db, const git_oid *id)
 {
 	git_odb_object *object;
 	size_t _unused;
 	int error;
 
-	if (git_oid_is_zero(id))
+	if (git_oid_iszero(id))
 		return error_null_oid(GIT_ENOTFOUND, "cannot get object type");
 
 	if ((object = git_cache_get_raw(odb_cache(db), id)) != NULL) {
 		*type_p = object->cached.type;
-		git_odb_object_free(object);
 		return 0;
 	}
 
@@ -1193,7 +1181,7 @@ static int read_prefix_1(git_odb_object **out, git_odb *db,
 					git_oid_tostr_s(&found_full_oid));
 
 				error = git_odb__error_ambiguous(buf.ptr);
-				git_buf_dispose(&buf);
+				git_buf_free(&buf);
 				goto out;
 			}
 
@@ -1272,7 +1260,7 @@ int git_odb_foreach(git_odb *db, git_odb_foreach_cb cb, void *payload)
 	git_vector_foreach(&db->backends, i, internal) {
 		git_odb_backend *b = internal->backend;
 		int error = b->foreach(b, cb, payload);
-		if (error != 0)
+		if (error < 0)
 			return error;
 	}
 
@@ -1280,7 +1268,7 @@ int git_odb_foreach(git_odb *db, git_odb_foreach_cb cb, void *payload)
 }
 
 int git_odb_write(
-	git_oid *oid, git_odb *db, const void *data, size_t len, git_object_t type)
+	git_oid *oid, git_odb *db, const void *data, size_t len, git_otype type)
 {
 	size_t i;
 	int error = GIT_ERROR;
@@ -1290,7 +1278,7 @@ int git_odb_write(
 
 	git_odb_hash(oid, data, len, type);
 
-	if (git_oid_is_zero(oid))
+	if (git_oid_iszero(oid))
 		return error_null_oid(GIT_EINVALID, "cannot write object");
 
 	if (git_odb__freshen(db, oid))
@@ -1325,7 +1313,7 @@ int git_odb_write(
 	return error;
 }
 
-static int hash_header(git_hash_ctx *ctx, git_object_size_t size, git_object_t type)
+static int hash_header(git_hash_ctx *ctx, git_off_t size, git_otype type)
 {
 	char header[64];
 	size_t hdrlen;
@@ -1339,7 +1327,7 @@ static int hash_header(git_hash_ctx *ctx, git_object_size_t size, git_object_t t
 }
 
 int git_odb_open_wstream(
-	git_odb_stream **stream, git_odb *db, git_object_size_t size, git_object_t type)
+	git_odb_stream **stream, git_odb *db, git_off_t size, git_otype type)
 {
 	size_t i, writes = 0;
 	int error = GIT_ERROR;
@@ -1374,7 +1362,7 @@ int git_odb_open_wstream(
 	}
 
 	ctx = git__malloc(sizeof(git_hash_ctx));
-	GIT_ERROR_CHECK_ALLOC(ctx);
+	GITERR_CHECK_ALLOC(ctx);
 
 	if ((error = git_hash_ctx_init(ctx)) < 0 ||
 		(error = hash_header(ctx, size, type)) < 0)
@@ -1394,7 +1382,7 @@ static int git_odb_stream__invalid_length(
 	const git_odb_stream *stream,
 	const char *action)
 {
-	git_error_set(GIT_ERROR_ODB,
+	giterr_set(GITERR_ODB,
 		"cannot %s - "
 		"Invalid length. %"PRId64" was expected. The "
 		"total size of the received chunks amounts to %"PRId64".",
@@ -1448,7 +1436,7 @@ void git_odb_stream_free(git_odb_stream *stream)
 int git_odb_open_rstream(
 	git_odb_stream **stream,
 	size_t *len,
-	git_object_t *type,
+	git_otype *type,
 	git_odb *db,
 	const git_oid *oid)
 {
@@ -1475,7 +1463,7 @@ int git_odb_open_rstream(
 	return error;
 }
 
-int git_odb_write_pack(struct git_odb_writepack **out, git_odb *db, git_indexer_progress_cb progress_cb, void *progress_payload)
+int git_odb_write_pack(struct git_odb_writepack **out, git_odb *db, git_transfer_progress_cb progress_cb, void *progress_payload)
 {
 	size_t i, writes = 0;
 	int error = GIT_ERROR;
@@ -1504,21 +1492,10 @@ int git_odb_write_pack(struct git_odb_writepack **out, git_odb *db, git_indexer_
 	return error;
 }
 
-void *git_odb_backend_data_alloc(git_odb_backend *backend, size_t len)
-{
-	GIT_UNUSED(backend);
-	return git__malloc(len);
-}
-
 void *git_odb_backend_malloc(git_odb_backend *backend, size_t len)
-{
-	return git_odb_backend_data_alloc(backend, len);
-}
-
-void git_odb_backend_data_free(git_odb_backend *backend, void *data)
 {
 	GIT_UNUSED(backend);
-	git__free(data);
+	return git__malloc(len);
 }
 
 int git_odb_refresh(struct git_odb *db)
@@ -1547,7 +1524,7 @@ int git_odb__error_mismatch(const git_oid *expected, const git_oid *actual)
 	git_oid_tostr(expected_oid, sizeof(expected_oid), expected);
 	git_oid_tostr(actual_oid, sizeof(actual_oid), actual);
 
-	git_error_set(GIT_ERROR_ODB, "object hash mismatch - expected %s but got %s",
+	giterr_set(GITERR_ODB, "object hash mismatch - expected %s but got %s",
 		expected_oid, actual_oid);
 
 	return GIT_EMISMATCH;
@@ -1559,23 +1536,23 @@ int git_odb__error_notfound(
 	if (oid != NULL) {
 		char oid_str[GIT_OID_HEXSZ + 1];
 		git_oid_tostr(oid_str, oid_len+1, oid);
-		git_error_set(GIT_ERROR_ODB, "object not found - %s (%.*s)",
+		giterr_set(GITERR_ODB, "object not found - %s (%.*s)",
 			message, (int) oid_len, oid_str);
 	} else
-		git_error_set(GIT_ERROR_ODB, "object not found - %s", message);
+		giterr_set(GITERR_ODB, "object not found - %s", message);
 
 	return GIT_ENOTFOUND;
 }
 
 static int error_null_oid(int error, const char *message)
 {
-	git_error_set(GIT_ERROR_ODB, "odb: %s: null OID cannot exist", message);
+	giterr_set(GITERR_ODB, "odb: %s: null OID cannot exist", message);
 	return error;
 }
 
 int git_odb__error_ambiguous(const char *message)
 {
-	git_error_set(GIT_ERROR_ODB, "ambiguous SHA1 prefix - %s", message);
+	giterr_set(GITERR_ODB, "ambiguous SHA1 prefix - %s", message);
 	return GIT_EAMBIGUOUS;
 }