1 files changed, 146 insertions, 206 deletions

diff --git a/src/odb_loose.c b/src/odb_loose.c
index f5f6e35ac..989b03ab2 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -61,17 +61,17 @@ static int object_file_name(git_buf *name, const char *dir, const git_oid *id)
 	git_buf_sets(name, dir);
 
 	/* expand length for 40 hex sha1 chars + 2 * '/' + '\0' */
-	if (git_buf_grow(name, name->size + GIT_OID_HEXSZ + 3) < GIT_SUCCESS)
-		return GIT_ENOMEM;
+	if (git_buf_grow(name, git_buf_len(name) + GIT_OID_HEXSZ + 3) < 0)
+		return -1;
 
 	git_path_to_dir(name);
 
 	/* loose object filename: aa/aaa... (41 bytes) */
-	git_oid_pathfmt(name->ptr + name->size, id);
+	git_oid_pathfmt(name->ptr + git_buf_len(name), id);
 	name->size += GIT_OID_HEXSZ + 1;
 	name->ptr[name->size] = '\0';
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 
@@ -81,7 +81,7 @@ static size_t get_binary_object_header(obj_hdr *hdr, git_buf *obj)
 	unsigned char *data = (unsigned char *)obj->ptr;
 	size_t shift, size, used = 0;
 
-	if (obj->size == 0)
+	if (git_buf_len(obj) == 0)
 		return 0;
 
 	c = data[used++];
@@ -90,7 +90,7 @@ static size_t get_binary_object_header(obj_hdr *hdr, git_buf *obj)
 	size = c & 15;
 	shift = 4;
 	while (c & 0x80) {
-		if (obj->size <= used)
+		if (git_buf_len(obj) <= used)
 			return 0;
 		if (sizeof(size_t) * 8 <= shift)
 			return 0;
@@ -182,7 +182,7 @@ static int start_inflate(z_stream *s, git_buf *obj, void *out, size_t len)
 	int status;
 
 	init_stream(s, out, len);
-	set_stream_input(s, obj->ptr, obj->size);
+	set_stream_input(s, obj->ptr, git_buf_len(obj));
 
 	if ((status = inflateInit(s)) < Z_OK)
 		return status;
@@ -199,10 +199,12 @@ static int finish_inflate(z_stream *s)
 
 	inflateEnd(s);
 
-	if ((status != Z_STREAM_END) || (s->avail_in != 0))
-		return git__throw(GIT_ERROR, "Failed to finish inflation. Stream aborted prematurely");
+	if ((status != Z_STREAM_END) || (s->avail_in != 0)) {
+		giterr_set(GITERR_ZLIB, "Failed to finish ZLib inflation. Stream aborted prematurely");
+		return -1;
+	}
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 static int is_zlib_compressed_data(unsigned char *data)
@@ -226,21 +228,24 @@ static int inflate_buffer(void *in, size_t inlen, void *out, size_t outlen)
 	zs.next_in = in;
 	zs.avail_in = (uInt)inlen;
 
-	if (inflateInit(&zs) < Z_OK)
-		return git__throw(GIT_ERROR, "Failed to inflate buffer");
+	if (inflateInit(&zs) < Z_OK) {
+		giterr_set(GITERR_ZLIB, "Failed to inflate buffer");
+		return -1;
+	}
 
 	while (status == Z_OK)
 		status = inflate(&zs, Z_FINISH);
 
 	inflateEnd(&zs);
 
-	if ((status != Z_STREAM_END) /*|| (zs.avail_in != 0) */)
-		return git__throw(GIT_ERROR, "Failed to inflate buffer. Stream aborted prematurely");
-
-	if (zs.total_out != outlen)
-		return git__throw(GIT_ERROR, "Failed to inflate buffer. Stream aborted prematurely");
+	if (status != Z_STREAM_END /* || zs.avail_in != 0 */ ||
+		zs.total_out != outlen)
+	{
+		giterr_set(GITERR_ZLIB, "Failed to inflate buffer. Stream aborted prematurely");
+		return -1;
+	}
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 static void *inflate_tail(z_stream *s, void *hb, size_t used, obj_hdr *hdr)
@@ -297,24 +302,23 @@ static int inflate_packlike_loose_disk_obj(git_rawobj *out, git_buf *obj)
 	 * read the object header, which is an (uncompressed)
 	 * binary encoding of the object type and size.
 	 */
-	if ((used = get_binary_object_header(&hdr, obj)) == 0)
-		return git__throw(GIT_ERROR, "Failed to inflate loose object. Object has no header");
-
-	if (!git_object_typeisloose(hdr.type))
-		return git__throw(GIT_ERROR, "Failed to inflate loose object. Wrong object type");
+	if ((used = get_binary_object_header(&hdr, obj)) == 0 ||
+		!git_object_typeisloose(hdr.type)) {
+		giterr_set(GITERR_ODB, "Failed to inflate loose object.");
+		return -1;
+	}
 
 	/*
 	 * allocate a buffer and inflate the data into it
 	 */
 	buf = git__malloc(hdr.size + 1);
-	if (!buf)
-		return GIT_ENOMEM;
+	GITERR_CHECK_ALLOC(buf);
 
 	in = ((unsigned char *)obj->ptr) + used;
 	len = obj->size - used;
-	if (inflate_buffer(in, len, buf, hdr.size)) {
+	if (inflate_buffer(in, len, buf, hdr.size) < 0) {
 		git__free(buf);
-		return git__throw(GIT_ERROR, "Failed to inflate loose object. Could not inflate buffer");
+		return -1;
 	}
 	buf[hdr.size] = '\0';
 
@@ -322,7 +326,7 @@ static int inflate_packlike_loose_disk_obj(git_rawobj *out, git_buf *obj)
 	out->len = hdr.size;
 	out->type = hdr.type;
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 static int inflate_disk_obj(git_rawobj *out, git_buf *obj)
@@ -342,28 +346,27 @@ static int inflate_disk_obj(git_rawobj *out, git_buf *obj)
 	 * inflate the initial part of the io buffer in order
 	 * to parse the object header (type and size).
 	 */
-	if (start_inflate(&zs, obj, head, sizeof(head)) < Z_OK)
-		return git__throw(GIT_ERROR, "Failed to inflate disk object. Could not inflate buffer");
-
-	if ((used = get_object_header(&hdr, head)) == 0)
-		return git__throw(GIT_ERROR, "Failed to inflate disk object. Object has no header");
-
-	if (!git_object_typeisloose(hdr.type))
-		return git__throw(GIT_ERROR, "Failed to inflate disk object. Wrong object type");
+	if (start_inflate(&zs, obj, head, sizeof(head)) < Z_OK ||
+		(used = get_object_header(&hdr, head)) == 0 ||
+		!git_object_typeisloose(hdr.type))
+	{
+		giterr_set(GITERR_ODB, "Failed to inflate disk object.");
+		return -1;
+	}
 
 	/*
 	 * allocate a buffer and inflate the object data into it
 	 * (including the initial sequence in the head buffer).
 	 */
 	if ((buf = inflate_tail(&zs, head, used, &hdr)) == NULL)
-		return GIT_ENOMEM;
+		return -1;
 	buf[hdr.size] = '\0';
 
 	out->data = buf;
 	out->len = hdr.size;
 	out->type = hdr.type;
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 
@@ -387,25 +390,24 @@ static int read_loose(git_rawobj *out, git_buf *loc)
 
 	assert(out && loc);
 
-	if ((error = git_buf_lasterror(loc)) < GIT_SUCCESS)
-		return error;
+	if (git_buf_oom(loc))
+		return -1;
 
 	out->data = NULL;
 	out->len = 0;
 	out->type = GIT_OBJ_BAD;
 
-	if (git_futils_readbuffer(&obj, loc->ptr) < 0)
-		return git__throw(GIT_ENOTFOUND, "Failed to read loose object. File not found");
+	if (!(error = git_futils_readbuffer(&obj, loc->ptr)))
+		error = inflate_disk_obj(out, &obj);
 
-	error = inflate_disk_obj(out, &obj);
 	git_buf_free(&obj);
 
-	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to read loose object");
+	return error;
 }
 
 static int read_header_loose(git_rawobj *out, git_buf *loc)
 {
-	int error = GIT_SUCCESS, z_return = Z_ERRNO, read_bytes;
+	int error = 0, z_return = Z_ERRNO, read_bytes;
 	git_file fd;
 	z_stream zs;
 	obj_hdr header_obj;
@@ -413,49 +415,41 @@ static int read_header_loose(git_rawobj *out, git_buf *loc)
 
 	assert(out && loc);
 
-	if ((error = git_buf_lasterror(loc)) < GIT_SUCCESS)
-		return error;
+	if (git_buf_oom(loc))
+		return -1;
 
 	out->data = NULL;
 
-	if ((fd = p_open(loc->ptr, O_RDONLY)) < 0)
-		return git__throw(GIT_ENOTFOUND, "Failed to read loose object header. File not found");
+	if ((fd = git_futils_open_ro(loc->ptr)) < 0)
+		return fd;
 
 	init_stream(&zs, inflated_buffer, sizeof(inflated_buffer));
 
-	if (inflateInit(&zs) < Z_OK) {
-		error = GIT_EZLIB;
-		goto cleanup;
-	}
+	z_return = inflateInit(&zs);
 
-	do {
-		if ((read_bytes = read(fd, raw_buffer, sizeof(raw_buffer))) > 0) {
+	while (z_return == Z_OK) {
+		if ((read_bytes = p_read(fd, raw_buffer, sizeof(raw_buffer))) > 0) {
 			set_stream_input(&zs, raw_buffer, read_bytes);
 			z_return = inflate(&zs, 0);
-		} else {
+		} else
 			z_return = Z_STREAM_END;
-			break;
-		}
-	} while (z_return == Z_OK);
+	}
 
 	if ((z_return != Z_STREAM_END && z_return != Z_BUF_ERROR)
 		|| get_object_header(&header_obj, inflated_buffer) == 0
-		|| git_object_typeisloose(header_obj.type) == 0) {
-		error = GIT_EOBJCORRUPTED;
-		goto cleanup;
+		|| git_object_typeisloose(header_obj.type) == 0)
+	{
+		giterr_set(GITERR_ZLIB, "Failed to read loose object header");
+		error = -1;
+	} else {
+		out->len = header_obj.size;
+		out->type = header_obj.type;
 	}
 
-	out->len = header_obj.size;
-	out->type = header_obj.type;
-
-cleanup:
 	finish_inflate(&zs);
 	p_close(fd);
 
-	if (error < GIT_SUCCESS)
-		return git__throw(error, "Failed to read loose object header. Header is corrupted");
-
-	return GIT_SUCCESS;
+	return error;
 }
 
 static int locate_object(
@@ -465,8 +459,8 @@ static int locate_object(
 {
 	int error = object_file_name(object_location, backend->objects_dir, oid);
 
-	if (error == GIT_SUCCESS)
-		error = git_path_exists(git_buf_cstr(object_location));
+	if (!error && !git_path_exists(object_location->ptr))
+		return GIT_ENOTFOUND;
 
 	return error;
 }
@@ -475,12 +469,12 @@ static int locate_object(
 static int fn_locate_object_short_oid(void *state, git_buf *pathbuf) {
 	loose_locate_object_state *sstate = (loose_locate_object_state *)state;
 
-	if (pathbuf->size - sstate->dir_len != GIT_OID_HEXSZ - 2) {
+	if (git_buf_len(pathbuf) - sstate->dir_len != GIT_OID_HEXSZ - 2) {
 		/* Entry cannot be an object. Continue to next entry */
-		return GIT_SUCCESS;
+		return 0;
 	}
 
-	if (!git_path_exists(pathbuf->ptr) && git_path_isdir(pathbuf->ptr)) {
+	if (git_path_isdir(pathbuf->ptr) == false) {
 		/* We are already in the directory matching the 2 first hex characters,
 		 * compare the first ncmp characters of the oids */
 		if (!memcmp(sstate->short_oid + 2,
@@ -495,10 +489,11 @@ static int fn_locate_object_short_oid(void *state, git_buf *pathbuf) {
 			sstate->found++;
 		}
 	}
+
 	if (sstate->found > 1)
-		return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Ambiguous sha1 prefix within loose objects");
+		return git_odb__error_ambiguous("multiple matches in loose objects");
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 /* Locate an object matching a given short oid */
@@ -515,60 +510,56 @@ static int locate_object_short_oid(
 	int error;
 
 	/* prealloc memory for OBJ_DIR/xx/ */
-	if ((error = git_buf_grow(object_location, dir_len + 5)) < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to locate object from short oid");
+	if (git_buf_grow(object_location, dir_len + 5) < 0)
+		return -1;
 
 	git_buf_sets(object_location, objects_dir);
 	git_path_to_dir(object_location);
 
 	/* save adjusted position at end of dir so it can be restored later */
-	dir_len = object_location->size;
+	dir_len = git_buf_len(object_location);
 
 	/* Convert raw oid to hex formatted oid */
 	git_oid_fmt((char *)state.short_oid, short_oid);
 
 	/* Explore OBJ_DIR/xx/ where xx is the beginning of hex formatted short oid */
-	error = git_buf_printf(object_location, "%.2s/", state.short_oid);
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to locate object from short oid");
+	if (git_buf_printf(object_location, "%.2s/", state.short_oid) < 0)
+		return -1;
 
 	/* Check that directory exists */
-	if (git_path_exists(object_location->ptr) ||
-		git_path_isdir(object_location->ptr))
-		return git__throw(GIT_ENOTFOUND, "Failed to locate object from short oid. Object not found");
+	if (git_path_isdir(object_location->ptr) == false)
+		return git_odb__error_notfound("no matching loose object for prefix", short_oid);
 
-	state.dir_len = object_location->size;
+	state.dir_len = git_buf_len(object_location);
 	state.short_oid_len = len;
 	state.found = 0;
 
 	/* Explore directory to find a unique object matching short_oid */
-	error = git_path_direach(object_location, fn_locate_object_short_oid, &state);
+	error = git_path_direach(
+		object_location, fn_locate_object_short_oid, &state);
 	if (error)
-		return git__rethrow(error, "Failed to locate object from short oid");
+		return error;
 
-	if (!state.found) {
-		return git__throw(GIT_ENOTFOUND, "Failed to locate object from short oid. Object not found");
-	}
+	if (!state.found)
+		return git_odb__error_notfound("no matching loose object for prefix", short_oid);
 
 	/* Convert obtained hex formatted oid to raw */
 	error = git_oid_fromstr(res_oid, (char *)state.res_oid);
-	if (error) {
-		return git__rethrow(error, "Failed to locate object from short oid");
-	}
+	if (error)
+		return error;
 
 	/* Update the location according to the oid obtained */
 
 	git_buf_truncate(object_location, dir_len);
-	error = git_buf_grow(object_location, dir_len + GIT_OID_HEXSZ + 2);
-	if (error)
-		return git__rethrow(error, "Failed to locate object from short oid");
+	if (git_buf_grow(object_location, dir_len + GIT_OID_HEXSZ + 2) < 0)
+		return -1;
 
 	git_oid_pathfmt(object_location->ptr + dir_len, res_oid);
 
 	object_location->size += GIT_OID_HEXSZ + 1;
 	object_location->ptr[object_location->size] = '\0';
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 
@@ -591,7 +582,7 @@ static int loose_backend__read_header(size_t *len_p, git_otype *type_p, git_odb_
 {
 	git_buf object_path = GIT_BUF_INIT;
 	git_rawobj raw;
-	int error = GIT_SUCCESS;
+	int error;
 
 	assert(backend && oid);
 
@@ -599,8 +590,8 @@ static int loose_backend__read_header(size_t *len_p, git_otype *type_p, git_odb_
 	raw.type = GIT_OBJ_BAD;
 
 	if (locate_object(&object_path, (loose_backend *)backend, oid) < 0)
-		error = git__throw(GIT_ENOTFOUND, "Failed to read loose backend header. Object not found");
-	else if ((error = read_header_loose(&raw, &object_path)) == GIT_SUCCESS) {
+		error = git_odb__error_notfound("no matching loose object", oid);
+	else if ((error = read_header_loose(&raw, &object_path)) == 0) {
 		*len_p = raw.len;
 		*type_p = raw.type;
 	}
@@ -614,20 +605,17 @@ static int loose_backend__read(void **buffer_p, size_t *len_p, git_otype *type_p
 {
 	git_buf object_path = GIT_BUF_INIT;
 	git_rawobj raw;
-	int error = GIT_SUCCESS;
+	int error = 0;
 
 	assert(backend && oid);
 
 	if (locate_object(&object_path, (loose_backend *)backend, oid) < 0)
-		error = git__throw(GIT_ENOTFOUND, "Failed to read loose backend. Object not found");
-	else if ((error = read_loose(&raw, &object_path)) == GIT_SUCCESS) {
+		error = git_odb__error_notfound("no matching loose object", oid);
+	else if ((error = read_loose(&raw, &object_path)) == 0) {
 		*buffer_p = raw.data;
 		*len_p = raw.len;
 		*type_p = raw.type;
 	}
-	else {
-		git__rethrow(error, "Failed to read loose backend");
-	}
 
 	git_buf_free(&object_path);
 
@@ -643,16 +631,15 @@ static int loose_backend__read_prefix(
 	const git_oid *short_oid,
 	unsigned int len)
 {
-	int error = GIT_SUCCESS;
+	int error = 0;
 
 	if (len < GIT_OID_MINPREFIXLEN)
-		return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to read loose "
-			"backend. Prefix length is lower than %d.", GIT_OID_MINPREFIXLEN);
+		error = git_odb__error_ambiguous("prefix length too short");
 
-	if (len >= GIT_OID_HEXSZ) {
+	else if (len >= GIT_OID_HEXSZ) {
 		/* We can fall back to regular read method */
 		error = loose_backend__read(buffer_p, len_p, type_p, backend, short_oid);
-		if (error == GIT_SUCCESS)
+		if (!error)
 			git_oid_cpy(out_oid, short_oid);
 	} else {
 		git_buf object_path = GIT_BUF_INIT;
@@ -661,11 +648,9 @@ static int loose_backend__read_prefix(
 		assert(backend && short_oid);
 
 		if ((error = locate_object_short_oid(&object_path, out_oid,
-		    (loose_backend *)backend, short_oid, len)) < 0)
-			git__rethrow(error, "Failed to read loose backend");
-		else if ((error = read_loose(&raw, &object_path)) < GIT_SUCCESS)
-			git__rethrow(error, "Failed to read loose backend");
-		else {
+				(loose_backend *)backend, short_oid, len)) == 0 &&
+			(error = read_loose(&raw, &object_path)) == 0)
+		{
 			*buffer_p = raw.data;
 			*len_p = raw.len;
 			*type_p = raw.type;
@@ -688,47 +673,33 @@ static int loose_backend__exists(git_odb_backend *backend, const git_oid *oid)
 
 	git_buf_free(&object_path);
 
-	return (error == GIT_SUCCESS);
+	return !error;
 }
 
 static int loose_backend__stream_fwrite(git_oid *oid, git_odb_stream *_stream)
 {
 	loose_writestream *stream = (loose_writestream *)_stream;
 	loose_backend *backend = (loose_backend *)_stream->backend;
-
-	int error;
 	git_buf final_path = GIT_BUF_INIT;
+	int error = 0;
 
-	if ((error = git_filebuf_hash(oid, &stream->fbuf)) < GIT_SUCCESS)
-		goto cleanup;
-
-	if ((error = object_file_name(&final_path, backend->objects_dir, oid)) < GIT_SUCCESS)
-		goto cleanup;
-
-	if ((error = git_buf_lasterror(&final_path)) < GIT_SUCCESS)
-		goto cleanup;
-
-	if ((error = git_futils_mkpath2file(final_path.ptr, GIT_OBJECT_DIR_MODE)) < GIT_SUCCESS)
-		goto cleanup;
-
+	if (git_filebuf_hash(oid, &stream->fbuf) < 0 ||
+		object_file_name(&final_path, backend->objects_dir, oid) < 0 ||
+		git_futils_mkpath2file(final_path.ptr, GIT_OBJECT_DIR_MODE) < 0)
+		error = -1;
 	/*
 	 * Don't try to add an existing object to the repository. This
 	 * is what git does and allows us to sidestep the fact that
 	 * we're not allowed to overwrite a read-only file on Windows.
 	 */
-	if (git_path_exists(final_path.ptr) == GIT_SUCCESS) {
+	else if (git_path_exists(final_path.ptr) == true)
 		git_filebuf_cleanup(&stream->fbuf);
-		goto cleanup;
-	}
+	else
+		error = git_filebuf_commit_at(
+			&stream->fbuf, final_path.ptr, GIT_OBJECT_FILE_MODE);
 
-	error = git_filebuf_commit_at(&stream->fbuf, final_path.ptr, GIT_OBJECT_FILE_MODE);
-
-cleanup:
 	git_buf_free(&final_path);
 
-	if (error < GIT_SUCCESS)
-		git__rethrow(error, "Failed to write loose backend");
-
 	return error;
 }
 
@@ -752,22 +723,18 @@ static int format_object_header(char *hdr, size_t n, size_t obj_len, git_otype o
 	int len = snprintf(hdr, n, "%s %"PRIuZ, type_str, obj_len);
 
 	assert(len > 0);				/* otherwise snprintf() is broken */
-	assert(((size_t) len) < n); /* otherwise the caller is broken! */
+	assert(((size_t)len) < n);		/* otherwise the caller is broken! */
 
-	if (len < 0 || ((size_t) len) >= n)
-		return git__throw(GIT_ERROR, "Failed to format object header. Length is out of bounds");
 	return len+1;
 }
 
 static int loose_backend__stream(git_odb_stream **stream_out, git_odb_backend *_backend, size_t length, git_otype type)
 {
 	loose_backend *backend;
-	loose_writestream *stream;
-
+	loose_writestream *stream = NULL;
 	char hdr[64];
 	git_buf tmp_path = GIT_BUF_INIT;
 	int hdrlen;
-	int error;
 
 	assert(_backend);
 
@@ -775,12 +742,9 @@ static int loose_backend__stream(git_odb_stream **stream_out, git_odb_backend *_
 	*stream_out = NULL;
 
 	hdrlen = format_object_header(hdr, sizeof(hdr), length, type);
-	if (hdrlen < GIT_SUCCESS)
-		return git__throw(GIT_EOBJCORRUPTED, "Failed to create loose backend stream. Object is corrupted");
 
 	stream = git__calloc(1, sizeof(loose_writestream));
-	if (stream == NULL)
-		return GIT_ENOMEM;
+	GITERR_CHECK_ALLOC(stream);
 
 	stream->stream.backend = _backend;
 	stream->stream.read = NULL; /* read only */
@@ -789,36 +753,26 @@ static int loose_backend__stream(git_odb_stream **stream_out, git_odb_backend *_
 	stream->stream.free = &loose_backend__stream_free;
 	stream->stream.mode = GIT_STREAM_WRONLY;
 
-	error = git_buf_joinpath(&tmp_path, backend->objects_dir, "tmp_object");
-	if (error < GIT_SUCCESS)
-		goto cleanup;
-
-	error = git_filebuf_open(&stream->fbuf, tmp_path.ptr,
-		GIT_FILEBUF_HASH_CONTENTS |
-		GIT_FILEBUF_TEMPORARY |
-		(backend->object_zlib_level << GIT_FILEBUF_DEFLATE_SHIFT));
-	if (error < GIT_SUCCESS)
-		goto cleanup;
-
-	error = stream->stream.write((git_odb_stream *)stream, hdr, hdrlen);
-	if (error < GIT_SUCCESS)
-		goto cleanup;
-
+	if (git_buf_joinpath(&tmp_path, backend->objects_dir, "tmp_object") < 0 ||
+		git_filebuf_open(&stream->fbuf, tmp_path.ptr,
+			GIT_FILEBUF_HASH_CONTENTS |
+			GIT_FILEBUF_TEMPORARY |
+			(backend->object_zlib_level << GIT_FILEBUF_DEFLATE_SHIFT)) < 0 ||
+		stream->stream.write((git_odb_stream *)stream, hdr, hdrlen) < 0)
+	{
+		git_filebuf_cleanup(&stream->fbuf);
+		git__free(stream);
+		stream = NULL;
+	}
 	git_buf_free(&tmp_path);
-
 	*stream_out = (git_odb_stream *)stream;
-	return GIT_SUCCESS;
 
-cleanup:
-	git_buf_free(&tmp_path);
-	git_filebuf_cleanup(&stream->fbuf);
-	git__free(stream);
-	return git__rethrow(error, "Failed to create loose backend stream");
+	return !stream ? -1 : 0;
 }
 
 static int loose_backend__write(git_oid *oid, git_odb_backend *_backend, const void *data, size_t len, git_otype type)
 {
-	int error, header_len;
+	int error = 0, header_len;
 	git_buf final_path = GIT_BUF_INIT;
 	char header[64];
 	git_filebuf fbuf = GIT_FILEBUF_INIT;
@@ -827,39 +781,29 @@ static int loose_backend__write(git_oid *oid, git_odb_backend *_backend, const v
 	backend = (loose_backend *)_backend;
 
 	/* prepare the header for the file */
-	{
-		header_len = format_object_header(header, sizeof(header), len, type);
-		if (header_len < GIT_SUCCESS)
-			return GIT_EOBJCORRUPTED;
-	}
-
-	error = git_buf_joinpath(&final_path, backend->objects_dir, "tmp_object");
-	if (error < GIT_SUCCESS)
-		goto cleanup;
+	header_len = format_object_header(header, sizeof(header), len, type);
 
-	error = git_filebuf_open(&fbuf, final_path.ptr,
-		GIT_FILEBUF_HASH_CONTENTS |
-		GIT_FILEBUF_TEMPORARY |
-		(backend->object_zlib_level << GIT_FILEBUF_DEFLATE_SHIFT));
-	if (error < GIT_SUCCESS)
+	if (git_buf_joinpath(&final_path, backend->objects_dir, "tmp_object") < 0 ||
+		git_filebuf_open(&fbuf, final_path.ptr,
+			GIT_FILEBUF_HASH_CONTENTS |
+			GIT_FILEBUF_TEMPORARY |
+			(backend->object_zlib_level << GIT_FILEBUF_DEFLATE_SHIFT)) < 0)
+	{
+		error = -1;
 		goto cleanup;
+	}
 
 	git_filebuf_write(&fbuf, header, header_len);
 	git_filebuf_write(&fbuf, data, len);
 	git_filebuf_hash(oid, &fbuf);
 
-	error = object_file_name(&final_path, backend->objects_dir, oid);
-	if (error < GIT_SUCCESS)
-		goto cleanup;
-
-	error = git_futils_mkpath2file(final_path.ptr, GIT_OBJECT_DIR_MODE);
-	if (error < GIT_SUCCESS)
-		goto cleanup;
-
-	error = git_filebuf_commit_at(&fbuf, final_path.ptr, GIT_OBJECT_FILE_MODE);
+	if (object_file_name(&final_path, backend->objects_dir, oid) < 0 ||
+		git_futils_mkpath2file(final_path.ptr, GIT_OBJECT_DIR_MODE) < 0 ||
+		git_filebuf_commit_at(&fbuf, final_path.ptr, GIT_OBJECT_FILE_MODE) < 0)
+		error = -1;
 
 cleanup:
-	if (error < GIT_SUCCESS)
+	if (error < 0)
 		git_filebuf_cleanup(&fbuf);
 	git_buf_free(&final_path);
 	return error;
@@ -884,14 +828,10 @@ int git_odb_backend_loose(
 	loose_backend *backend;
 
 	backend = git__calloc(1, sizeof(loose_backend));
-	if (backend == NULL)
-		return GIT_ENOMEM;
+	GITERR_CHECK_ALLOC(backend);
 
 	backend->objects_dir = git__strdup(objects_dir);
-	if (backend->objects_dir == NULL) {
-		git__free(backend);
-		return GIT_ENOMEM;
-	}
+	GITERR_CHECK_ALLOC(backend->objects_dir);
 
 	if (compression_level < 0)
 		compression_level = Z_BEST_SPEED;
@@ -908,5 +848,5 @@ int git_odb_backend_loose(
 	backend->parent.free = &loose_backend__free;
 
 	*backend_out = (git_odb_backend *)backend;
-	return GIT_SUCCESS;
+	return 0;
 }