rugged 0.27.10.1 → 0.28.0

data/vendor/libgit2/src/merge_driver.c

@@ -181,7 +181,7 @@ static int merge_driver_registry_insert(
 	git_merge_driver_entry *entry;
 
 	entry = git__calloc(1, sizeof(git_merge_driver_entry) + strlen(name) + 1);
-	GITERR_CHECK_ALLOC(entry);
+	GIT_ERROR_CHECK_ALLOC(entry);
 
 	strcpy(entry->name, name);
 	entry->driver = driver;
@@ -265,12 +265,12 @@ int git_merge_driver_register(const char *name, git_merge_driver *driver)
 	assert(name && driver);
 
 	if (git_rwlock_wrlock(&merge_driver_registry.lock) < 0) {
-		giterr_set(GITERR_OS, "failed to lock merge driver registry");
+		git_error_set(GIT_ERROR_OS, "failed to lock merge driver registry");
 		return -1;
 	}
 
 	if (!merge_driver_registry_find(NULL, name)) {
-		giterr_set(GITERR_MERGE, "attempt to reregister existing driver '%s'",
+		git_error_set(GIT_ERROR_MERGE, "attempt to reregister existing driver '%s'",
 			name);
 		error = GIT_EEXISTS;
 		goto done;
@@ -290,12 +290,12 @@ int git_merge_driver_unregister(const char *name)
 	int error = 0;
 
 	if (git_rwlock_wrlock(&merge_driver_registry.lock) < 0) {
-		giterr_set(GITERR_OS, "failed to lock merge driver registry");
+		git_error_set(GIT_ERROR_OS, "failed to lock merge driver registry");
 		return -1;
 	}
 
 	if ((entry = merge_driver_registry_lookup(&pos, name)) == NULL) {
-		giterr_set(GITERR_MERGE, "cannot find merge driver '%s' to unregister",
+		git_error_set(GIT_ERROR_MERGE, "cannot find merge driver '%s' to unregister",
 			name);
 		error = GIT_ENOTFOUND;
 		goto done;
@@ -332,7 +332,7 @@ git_merge_driver *git_merge_driver_lookup(const char *name)
 		return &git_merge_driver__binary;
 
 	if (git_rwlock_rdlock(&merge_driver_registry.lock) < 0) {
-		giterr_set(GITERR_OS, "failed to lock merge driver registry");
+		git_error_set(GIT_ERROR_OS, "failed to lock merge driver registry");
 		return NULL;
 	}
 
@@ -341,7 +341,7 @@ git_merge_driver *git_merge_driver_lookup(const char *name)
 	git_rwlock_rdunlock(&merge_driver_registry.lock);
 
 	if (entry == NULL) {
-		giterr_set(GITERR_MERGE, "cannot use an unregistered filter");
+		git_error_set(GIT_ERROR_MERGE, "cannot use an unregistered filter");
 		return NULL;
 	}
 

data/vendor/libgit2/src/merge_file.c

@@ -130,7 +130,7 @@ static int merge_file__xdiff(
 
 	if ((xdl_result = xdl_merge(&ancestor_mmfile, &our_mmfile,
 		&their_mmfile, &xmparam, &mmbuffer)) < 0) {
-		giterr_set(GITERR_MERGE, "failed to merge files");
+		git_error_set(GIT_ERROR_MERGE, "failed to merge files");
 		error = -1;
 		goto done;
 	}

data/vendor/libgit2/src/mwindow.c

@@ -51,14 +51,14 @@ int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
 {
 	int error;
 	char *packname;
-	git_strmap_iter pos;
+	size_t pos;
 	struct git_pack_file *pack;
 
 	if ((error = git_packfile__name(&packname, path)) < 0)
 		return error;
 
 	if (git_mutex_lock(&git__mwindow_mutex) < 0) {
-		giterr_set(GITERR_OS, "failed to lock mwindow mutex");
+		git_error_set(GIT_ERROR_OS, "failed to lock mwindow mutex");
 		return -1;
 	}
 
@@ -97,7 +97,7 @@ int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
 void git_mwindow_put_pack(struct git_pack_file *pack)
 {
 	int count;
-	git_strmap_iter pos;
+	size_t pos;
 
 	if (git_mutex_lock(&git__mwindow_mutex) < 0)
 		return;
@@ -122,7 +122,7 @@ void git_mwindow_put_pack(struct git_pack_file *pack)
 void git_mwindow_free_all(git_mwindow_file *mwf)
 {
 	if (git_mutex_lock(&git__mwindow_mutex)) {
-		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 		return;
 	}
 
@@ -229,7 +229,7 @@ static int git_mwindow_close_lru(git_mwindow_file *mwf)
 	}
 
 	if (!lru_w) {
-		giterr_set(GITERR_OS, "failed to close memory window; couldn't find LRU");
+		git_error_set(GIT_ERROR_OS, "failed to close memory window; couldn't find LRU");
 		return -1;
 	}
 
@@ -324,7 +324,7 @@ unsigned char *git_mwindow_open(
 	git_mwindow *w = *cursor;
 
 	if (git_mutex_lock(&git__mwindow_mutex)) {
-		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 		return NULL;
 	}
 
@@ -376,7 +376,7 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 	int ret;
 
 	if (git_mutex_lock(&git__mwindow_mutex)) {
-		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+		git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 		return -1;
 	}
 
@@ -416,7 +416,7 @@ void git_mwindow_close(git_mwindow **window)
 	git_mwindow *w = *window;
 	if (w) {
 		if (git_mutex_lock(&git__mwindow_mutex)) {
-			giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+			git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
 			return;
 		}
 

data/vendor/libgit2/src/netops.c

@@ -119,6 +119,15 @@ int gitno__match_host(const char *pattern, const char *host)
 	return -1;
 }
 
+static const char *default_port_http = "80";
+static const char *default_port_https = "443";
+
+const char *gitno__default_port(
+	gitno_connection_data *data)
+{
+	return data->use_ssl ? default_port_https : default_port_http;
+}
+
 static const char *prefix_http = "http://";
 static const char *prefix_https = "https://";
 
@@ -141,21 +150,21 @@ int gitno_connection_data_from_url(
 
 	if (!git__prefixcmp(url, prefix_http)) {
 		path_search_start = url + strlen(prefix_http);
-		default_port = "80";
+		default_port = default_port_http;
 
 		if (data->use_ssl) {
-			giterr_set(GITERR_NET, "redirect from HTTPS to HTTP is not allowed");
+			git_error_set(GIT_ERROR_NET, "redirect from HTTPS to HTTP is not allowed");
 			goto cleanup;
 		}
 	} else if (!git__prefixcmp(url, prefix_https)) {
 		path_search_start = url + strlen(prefix_https);
-		default_port = "443";
+		default_port = default_port_https;
 		data->use_ssl = true;
 	} else if (url[0] == '/')
-		default_port = data->use_ssl ? "443" : "80";
+		default_port = gitno__default_port(data);
 
 	if (!default_port) {
-		giterr_set(GITERR_NET, "unrecognized URL prefix");
+		git_error_set(GIT_ERROR_NET, "unrecognized URL prefix");
 		goto cleanup;
 	}
 
@@ -187,7 +196,7 @@ int gitno_connection_data_from_url(
 
 		/* Check for errors in the resulting data */
 		if (original_host && url[0] != '/' && strcmp(original_host, data->host)) {
-			giterr_set(GITERR_NET, "cross host redirect not allowed");
+			git_error_set(GIT_ERROR_NET, "cross host redirect not allowed");
 			error = -1;
 		}
 	}
@@ -225,7 +234,7 @@ int gitno_extract_url_parts(
 	int error = 0;
 
 	if (http_parser_parse_url(url, strlen(url), false, &u)) {
-		giterr_set(GITERR_NET, "malformed URL '%s'", url);
+		git_error_set(GIT_ERROR_NET, "malformed URL '%s'", url);
 		error = GIT_EINVALIDSPEC;
 		goto done;
 	}
@@ -254,7 +263,7 @@ int gitno_extract_url_parts(
 		size_t url_path_len = u.field_data[UF_PATH].len;
 		git_buf_decode_percent(&path, url_path, url_path_len);
 	} else if (path_out) {
-		giterr_set(GITERR_NET, "invalid url, missing path");
+		git_error_set(GIT_ERROR_NET, "invalid url, missing path");
 		error = GIT_EINVALIDSPEC;
 		goto done;
 	}
@@ -292,10 +301,10 @@ int gitno_extract_url_parts(
 	*password_out = git_buf_detach(&password);
 
 done:
-	git_buf_free(&host);
-	git_buf_free(&port);
-	git_buf_free(&path);
-	git_buf_free(&username);
-	git_buf_free(&password);
+	git_buf_dispose(&host);
+	git_buf_dispose(&port);
+	git_buf_dispose(&path);
+	git_buf_dispose(&username);
+	git_buf_dispose(&password);
 	return error;
 }

data/vendor/libgit2/src/netops.h

@@ -96,4 +96,6 @@ int gitno_extract_url_parts(
 		const char *url,
 		const char *default_port);
 
+const char *gitno__default_port(gitno_connection_data *data);
+
 #endif

data/vendor/libgit2/src/notes.c

@@ -12,10 +12,11 @@
 #include "config.h"
 #include "iterator.h"
 #include "signature.h"
+#include "blob.h"
 
 static int note_error_notfound(void)
 {
-	giterr_set(GITERR_INVALID, "note could not be found");
+	git_error_set(GIT_ERROR_INVALID, "note could not be found");
 	return GIT_ENOTFOUND;
 }
 
@@ -226,7 +227,7 @@ static int remove_note_in_tree_enotfound_cb(
 	GIT_UNUSED(note_oid);
 	GIT_UNUSED(fanout);
 
-	giterr_set(GITERR_REPOSITORY, "object '%s' has no note", annotated_object_sha);
+	git_error_set(GIT_ERROR_REPOSITORY, "object '%s' has no note", annotated_object_sha);
 	return current_error;
 }
 
@@ -244,7 +245,7 @@ static int insert_note_in_tree_eexists_cb(git_tree **out,
 	GIT_UNUSED(note_oid);
 	GIT_UNUSED(fanout);
 
-	giterr_set(GITERR_REPOSITORY, "note for '%s' exists already", annotated_object_sha);
+	git_error_set(GIT_ERROR_REPOSITORY, "note for '%s' exists already", annotated_object_sha);
 	return current_error;
 }
 
@@ -285,7 +286,7 @@ static int note_write(
 	git_oid oid;
 	git_tree *tree = NULL;
 
-	// TODO: should we apply filters?
+	/* TODO: should we apply filters? */
 	/* create note object */
 	if ((error = git_blob_create_frombuffer(&oid, repo, note, strlen(note))) < 0)
 		goto cleanup;
@@ -319,9 +320,10 @@ static int note_new(
 	git_blob *blob)
 {
 	git_note *note = NULL;
+	git_off_t blobsize;
 
 	note = git__malloc(sizeof(git_note));
-	GITERR_CHECK_ALLOC(note);
+	GIT_ERROR_CHECK_ALLOC(note);
 
 	git_oid_cpy(&note->id, note_oid);
 
@@ -329,8 +331,11 @@ static int note_new(
 		git_signature_dup(&note->committer, git_commit_committer(commit)) < 0)
 		return -1;
 
-	note->message = git__strndup(git_blob_rawcontent(blob), git_blob_rawsize(blob));
-	GITERR_CHECK_ALLOC(note->message);
+	blobsize = git_blob_rawsize(blob);
+	GIT_ERROR_CHECK_BLOBSIZE(blobsize);
+
+	note->message = git__strndup(git_blob_rawcontent(blob), (size_t)blobsize);
+	GIT_ERROR_CHECK_ALLOC(note->message);
 
 	*out = note;
 	return 0;
@@ -417,7 +422,7 @@ static int normalize_namespace(char **out, git_repository *repo, const char *not
 {
 	if (notes_ref) {
 		*out = git__strdup(notes_ref);
-		GITERR_CHECK_ALLOC(*out);
+		GIT_ERROR_CHECK_ALLOC(*out);
 		return 0;
 	}
 
@@ -710,7 +715,7 @@ static int process_entry_path(
 	error = git_oid_fromstr(annotated_object_id, buf.ptr);
 
 cleanup:
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 	return error;
 }
 
@@ -729,7 +734,7 @@ int git_note_foreach(
 
 	while (!(error = git_note_next(&note_id, &annotated_id, iter))) {
 		if ((error = note_cb(&note_id, &annotated_id, payload)) != 0) {
-			giterr_set_after_callback(error);
+			git_error_set_after_callback(error);
 			break;
 		}
 	}

data/vendor/libgit2/src/object.c

@@ -12,6 +12,7 @@
 #include "repository.h"
 
 #include "commit.h"
+#include "hash.h"
 #include "tree.h"
 #include "blob.h"
 #include "oid.h"
@@ -19,43 +20,93 @@
 
 bool git_object__strict_input_validation = true;
 
+extern int git_odb_hash(git_oid *out, const void *data, size_t len, git_object_t type);
+
 typedef struct {
 	const char	*str;	/* type name string */
 	size_t		size;	/* size in bytes of the object structure */
 
 	int  (*parse)(void *self, git_odb_object *obj);
+	int  (*parse_raw)(void *self, const char *data, size_t size);
 	void (*free)(void *self);
 } git_object_def;
 
 static git_object_def git_objects_table[] = {
-	/* 0 = GIT_OBJ__EXT1 */
-	{ "", 0, NULL, NULL },
+	/* 0 = GIT_OBJECT__EXT1 */
+	{ "", 0, NULL, NULL, NULL },
 
-	/* 1 = GIT_OBJ_COMMIT */
-	{ "commit", sizeof(git_commit), git_commit__parse, git_commit__free },
+	/* 1 = GIT_OBJECT_COMMIT */
+	{ "commit", sizeof(git_commit), git_commit__parse, git_commit__parse_raw, git_commit__free },
 
-	/* 2 = GIT_OBJ_TREE */
-	{ "tree", sizeof(git_tree), git_tree__parse, git_tree__free },
+	/* 2 = GIT_OBJECT_TREE */
+	{ "tree", sizeof(git_tree), git_tree__parse, git_tree__parse_raw, git_tree__free },
 
-	/* 3 = GIT_OBJ_BLOB */
-	{ "blob", sizeof(git_blob), git_blob__parse, git_blob__free },
+	/* 3 = GIT_OBJECT_BLOB */
+	{ "blob", sizeof(git_blob), git_blob__parse, git_blob__parse_raw, git_blob__free },
 
-	/* 4 = GIT_OBJ_TAG */
-	{ "tag", sizeof(git_tag), git_tag__parse, git_tag__free },
+	/* 4 = GIT_OBJECT_TAG */
+	{ "tag", sizeof(git_tag), git_tag__parse, git_tag__parse_raw, git_tag__free },
 
-	/* 5 = GIT_OBJ__EXT2 */
-	{ "", 0, NULL, NULL },
-	/* 6 = GIT_OBJ_OFS_DELTA */
-	{ "OFS_DELTA", 0, NULL, NULL },
-	/* 7 = GIT_OBJ_REF_DELTA */
-	{ "REF_DELTA", 0, NULL, NULL },
+	/* 5 = GIT_OBJECT__EXT2 */
+	{ "", 0, NULL, NULL, NULL },
+	/* 6 = GIT_OBJECT_OFS_DELTA */
+	{ "OFS_DELTA", 0, NULL, NULL, NULL },
+	/* 7 = GIT_OBJECT_REF_DELTA */
+	{ "REF_DELTA", 0, NULL, NULL, NULL },
 };
 
+int git_object__from_raw(
+	git_object **object_out,
+	const char *data,
+	size_t size,
+	git_object_t type)
+{
+	git_object_def *def;
+	git_object *object;
+	size_t object_size;
+	int error;
+
+	assert(object_out);
+	*object_out = NULL;
+
+	/* Validate type match */
+	if (type != GIT_OBJECT_BLOB && type != GIT_OBJECT_TREE && type != GIT_OBJECT_COMMIT && type != GIT_OBJECT_TAG) {
+		git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
+		return GIT_ENOTFOUND;
+	}
+
+	if ((object_size = git_object__size(type)) == 0) {
+		git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
+		return GIT_ENOTFOUND;
+	}
+
+	/* Allocate and initialize base object */
+	object = git__calloc(1, object_size);
+	GIT_ERROR_CHECK_ALLOC(object);
+	object->cached.flags = GIT_CACHE_STORE_PARSED;
+	object->cached.type = type;
+	git_odb_hash(&object->cached.oid, data, size, type);
+
+	/* Parse raw object data */
+	def = &git_objects_table[type];
+	assert(def->free && def->parse_raw);
+
+	if ((error = def->parse_raw(object, data, size)) < 0) {
+		def->free(object);
+		return error;
+	}
+
+	git_cached_obj_incref(object);
+	*object_out = object;
+
+	return 0;
+}
+
 int git_object__from_odb_object(
 	git_object **object_out,
 	git_repository *repo,
 	git_odb_object *odb_obj,
-	git_otype type)
+	git_object_t type)
 {
 	int error;
 	size_t object_size;
@@ -66,20 +117,20 @@ int git_object__from_odb_object(
 	*object_out = NULL;
 
 	/* Validate type match */
-	if (type != GIT_OBJ_ANY && type != odb_obj->cached.type) {
-		giterr_set(GITERR_INVALID,
+	if (type != GIT_OBJECT_ANY && type != odb_obj->cached.type) {
+		git_error_set(GIT_ERROR_INVALID,
 			"the requested type does not match the type in the ODB");
 		return GIT_ENOTFOUND;
 	}
 
 	if ((object_size = git_object__size(odb_obj->cached.type)) == 0) {
-		giterr_set(GITERR_INVALID, "the requested type is invalid");
+		git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
 		return GIT_ENOTFOUND;
 	}
 
 	/* Allocate and initialize base object */
 	object = git__calloc(1, object_size);
-	GITERR_CHECK_ALLOC(object);
+	GIT_ERROR_CHECK_ALLOC(object);
 
 	git_oid_cpy(&object->cached.oid, &odb_obj->cached.oid);
 	object->cached.type = odb_obj->cached.type;
@@ -100,7 +151,7 @@ int git_object__from_odb_object(
 
 void git_object__free(void *obj)
 {
-	git_otype type = ((git_object *)obj)->cached.type;
+	git_object_t type = ((git_object *)obj)->cached.type;
 
 	if (type < 0 || ((size_t)type) >= ARRAY_SIZE(git_objects_table) ||
 		!git_objects_table[type].free)
@@ -114,7 +165,7 @@ int git_object_lookup_prefix(
 	git_repository *repo,
 	const git_oid *id,
 	size_t len,
-	git_otype type)
+	git_object_t type)
 {
 	git_object *object = NULL;
 	git_odb *odb = NULL;
@@ -124,7 +175,7 @@ int git_object_lookup_prefix(
 	assert(repo && object_out && id);
 
 	if (len < GIT_OID_MINPREFIXLEN) {
-		giterr_set(GITERR_OBJECT, "ambiguous lookup - OID prefix is too short");
+		git_error_set(GIT_ERROR_OBJECT, "ambiguous lookup - OID prefix is too short");
 		return GIT_EAMBIGUOUS;
 	}
 
@@ -146,9 +197,9 @@ int git_object_lookup_prefix(
 			if (cached->flags == GIT_CACHE_STORE_PARSED) {
 				object = (git_object *)cached;
 
-				if (type != GIT_OBJ_ANY && type != object->cached.type) {
+				if (type != GIT_OBJECT_ANY && type != object->cached.type) {
 					git_object_free(object);
-					giterr_set(GITERR_INVALID,
+					git_error_set(GIT_ERROR_INVALID,
 						"the requested type does not match the type in ODB");
 					return GIT_ENOTFOUND;
 				}
@@ -196,7 +247,7 @@ int git_object_lookup_prefix(
 	return error;
 }
 
-int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_otype type) {
+int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_object_t type) {
 	return git_object_lookup_prefix(object_out, repo, id, GIT_OID_HEXSZ, type);
 }
 
@@ -214,7 +265,7 @@ const git_oid *git_object_id(const git_object *obj)
 	return &obj->cached.oid;
 }
 
-git_otype git_object_type(const git_object *obj)
+git_object_t git_object_type(const git_object *obj)
 {
 	assert(obj);
 	return obj->cached.type;
@@ -226,7 +277,7 @@ git_repository *git_object_owner(const git_object *obj)
 	return obj->repo;
 }
 
-const char *git_object_type2string(git_otype type)
+const char *git_object_type2string(git_object_t type)
 {
 	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
 		return "";
@@ -234,30 +285,30 @@ const char *git_object_type2string(git_otype type)
 	return git_objects_table[type].str;
 }
 
-git_otype git_object_string2type(const char *str)
+git_object_t git_object_string2type(const char *str)
 {
 	if (!str)
-		return GIT_OBJ_BAD;
+		return GIT_OBJECT_INVALID;
 
 	return git_object_stringn2type(str, strlen(str));
 }
 
-git_otype git_object_stringn2type(const char *str, size_t len)
+git_object_t git_object_stringn2type(const char *str, size_t len)
 {
 	size_t i;
 
 	if (!str || !len || !*str)
-		return GIT_OBJ_BAD;
+		return GIT_OBJECT_INVALID;
 
 	for (i = 0; i < ARRAY_SIZE(git_objects_table); i++)
 		if (*git_objects_table[i].str &&
 			!git__prefixncmp(str, len, git_objects_table[i].str))
-			return (git_otype)i;
+			return (git_object_t)i;
 
-	return GIT_OBJ_BAD;
+	return GIT_OBJECT_INVALID;
 }
 
-int git_object_typeisloose(git_otype type)
+int git_object_typeisloose(git_object_t type)
 {
 	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
 		return 0;
@@ -265,7 +316,7 @@ int git_object_typeisloose(git_otype type)
 	return (git_objects_table[type].size > 0) ? 1 : 0;
 }
 
-size_t git_object__size(git_otype type)
+size_t git_object__size(git_object_t type)
 {
 	if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
 		return 0;
@@ -275,17 +326,17 @@ size_t git_object__size(git_otype type)
 
 static int dereference_object(git_object **dereferenced, git_object *obj)
 {
-	git_otype type = git_object_type(obj);
+	git_object_t type = git_object_type(obj);
 
 	switch (type) {
-	case GIT_OBJ_COMMIT:
+	case GIT_OBJECT_COMMIT:
 		return git_commit_tree((git_tree **)dereferenced, (git_commit*)obj);
 
-	case GIT_OBJ_TAG:
+	case GIT_OBJECT_TAG:
 		return git_tag_target(dereferenced, (git_tag*)obj);
 
-	case GIT_OBJ_BLOB:
-	case GIT_OBJ_TREE:
+	case GIT_OBJECT_BLOB:
+	case GIT_OBJECT_TREE:
 		return GIT_EPEEL;
 
 	default:
@@ -293,7 +344,7 @@ static int dereference_object(git_object **dereferenced, git_object *obj)
 	}
 }
 
-static int peel_error(int error, const git_oid *oid, git_otype type)
+static int peel_error(int error, const git_oid *oid, git_object_t type)
 {
 	const char *type_name;
 	char hex_oid[GIT_OID_HEXSZ + 1];
@@ -303,29 +354,29 @@ static int peel_error(int error, const git_oid *oid, git_otype type)
 	git_oid_fmt(hex_oid, oid);
 	hex_oid[GIT_OID_HEXSZ] = '\0';
 
-	giterr_set(GITERR_OBJECT, "the git_object of id '%s' can not be "
-		"successfully peeled into a %s (git_otype=%i).", hex_oid, type_name, type);
+	git_error_set(GIT_ERROR_OBJECT, "the git_object of id '%s' can not be "
+		"successfully peeled into a %s (git_object_t=%i).", hex_oid, type_name, type);
 
 	return error;
 }
 
-static int check_type_combination(git_otype type, git_otype target)
+static int check_type_combination(git_object_t type, git_object_t target)
 {
 	if (type == target)
 		return 0;
 
 	switch (type) {
-	case GIT_OBJ_BLOB:
-	case GIT_OBJ_TREE:
+	case GIT_OBJECT_BLOB:
+	case GIT_OBJECT_TREE:
 		/* a blob or tree can never be peeled to anything but themselves */
 		return GIT_EINVALIDSPEC;
 		break;
-	case GIT_OBJ_COMMIT:
+	case GIT_OBJECT_COMMIT:
 		/* a commit can only be peeled to a tree */
-		if (target != GIT_OBJ_TREE && target != GIT_OBJ_ANY)
+		if (target != GIT_OBJECT_TREE && target != GIT_OBJECT_ANY)
 			return GIT_EINVALIDSPEC;
 		break;
-	case GIT_OBJ_TAG:
+	case GIT_OBJECT_TAG:
 		/* a tag may point to anything, so we let anything through */
 		break;
 	default:
@@ -338,18 +389,18 @@ static int check_type_combination(git_otype type, git_otype target)
 int git_object_peel(
 	git_object **peeled,
 	const git_object *object,
-	git_otype target_type)
+	git_object_t target_type)
 {
 	git_object *source, *deref = NULL;
 	int error;
 
 	assert(object && peeled);
 
-	assert(target_type == GIT_OBJ_TAG ||
-		target_type == GIT_OBJ_COMMIT ||
-		target_type == GIT_OBJ_TREE ||
-		target_type == GIT_OBJ_BLOB ||
-		target_type == GIT_OBJ_ANY);
+	assert(target_type == GIT_OBJECT_TAG ||
+		target_type == GIT_OBJECT_COMMIT ||
+		target_type == GIT_OBJECT_TREE ||
+		target_type == GIT_OBJECT_BLOB ||
+		target_type == GIT_OBJECT_ANY);
 
 	if ((error = check_type_combination(git_object_type(object), target_type)) < 0)
 		return peel_error(error, git_object_id(object), target_type);
@@ -369,7 +420,7 @@ int git_object_peel(
 			return 0;
 		}
 
-		if (target_type == GIT_OBJ_ANY &&
+		if (target_type == GIT_OBJECT_ANY &&
 			git_object_type(deref) != git_object_type(object))
 		{
 			*peeled = deref;
@@ -402,7 +453,7 @@ int git_object_lookup_bypath(
 		git_object **out,
 		const git_object *treeish,
 		const char *path,
-		git_otype type)
+		git_object_t type)
 {
 	int error = -1;
 	git_tree *tree = NULL;
@@ -410,15 +461,15 @@ int git_object_lookup_bypath(
 
 	assert(out && treeish && path);
 
-	if ((error = git_object_peel((git_object**)&tree, treeish, GIT_OBJ_TREE)) < 0 ||
+	if ((error = git_object_peel((git_object**)&tree, treeish, GIT_OBJECT_TREE)) < 0 ||
 		 (error = git_tree_entry_bypath(&entry, tree, path)) < 0)
 	{
 		goto cleanup;
 	}
 
-	if (type != GIT_OBJ_ANY && git_tree_entry_type(entry) != type)
+	if (type != GIT_OBJECT_ANY && git_tree_entry_type(entry) != type)
 	{
-		giterr_set(GITERR_OBJECT,
+		git_error_set(GIT_ERROR_OBJECT,
 				"object at path '%s' is not of the asked-for type %d",
 				path, type);
 		error = GIT_EINVALIDSPEC;
@@ -461,7 +512,7 @@ int git_object_short_id(git_buf *out, const git_object *obj)
 		if (error != GIT_EAMBIGUOUS)
 			break;
 
-		giterr_clear();
+		git_error_clear();
 		len++;
 	}
 
@@ -476,10 +527,10 @@ int git_object_short_id(git_buf *out, const git_object *obj)
 }
 
 bool git_object__is_valid(
-	git_repository *repo, const git_oid *id, git_otype expected_type)
+	git_repository *repo, const git_oid *id, git_object_t expected_type)
 {
 	git_odb *odb;
-	git_otype actual_type;
+	git_object_t actual_type;
 	size_t len;
 	int error;
 
@@ -490,8 +541,8 @@ bool git_object__is_valid(
 		(error = git_odb_read_header(&len, &actual_type, odb, id)) < 0)
 		return false;
 
-	if (expected_type != GIT_OBJ_ANY && expected_type != actual_type) {
-		giterr_set(GITERR_INVALID,
+	if (expected_type != GIT_OBJECT_ANY && expected_type != actual_type) {
+		git_error_set(GIT_ERROR_INVALID,
 			"the requested type does not match the type in the ODB");
 		return false;
 	}