Migrate ODB files to new error handling

This migrates odb.c, odb_loose.c, odb_pack.c and pack.c to
the new style of error handling.  Also got the unix and win32
versions of map.c.  There are some minor changes to other
files but no others were completely converted.

This also contains an update to filebuf so that a zeroed out
filebuf will not think that the fd (== 0) is actually open
(and inadvertently call close() on fd 0 if cleaned up).

Lastly, this was built and tested on win32 and contains a
bunch of fixes for the win32 build which was pretty broken.

1 files changed, 132 insertions, 191 deletions

diff --git a/src/odb_loose.c b/src/odb_loose.c
index 17fede4a3..c493cc60b 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -61,8 +61,8 @@ 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, name->size + GIT_OID_HEXSZ + 3) < 0)
+		return -1;
 
 	git_path_to_dir(name);
 
@@ -71,7 +71,7 @@ static int object_file_name(git_buf *name, const char *dir, const git_oid *id)
 	name->size += GIT_OID_HEXSZ + 1;
 	name->ptr[name->size] = '\0';
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 
@@ -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;
 }
 
 
@@ -388,24 +391,23 @@ static int read_loose(git_rawobj *out, git_buf *loc)
 	assert(out && loc);
 
 	if (git_buf_oom(loc))
-		return GIT_ENOMEM;
+		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;
@@ -414,48 +416,40 @@ static int read_header_loose(git_rawobj *out, git_buf *loc)
 	assert(out && loc);
 
 	if (git_buf_oom(loc))
-		return GIT_ENOMEM;
+		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)) ? GIT_SUCCESS : GIT_ENOTFOUND;
+	if (!error && !git_path_exists(object_location->ptr))
+		return GIT_ENOTFOUND;
 
 	return error;
 }
@@ -477,7 +471,7 @@ static int fn_locate_object_short_oid(void *state, git_buf *pathbuf) {
 
 	if (pathbuf->size - sstate->dir_len != GIT_OID_HEXSZ - 2) {
 		/* Entry cannot be an object. Continue to next entry */
-		return GIT_SUCCESS;
+		return 0;
 	}
 
 	if (git_path_isdir(pathbuf->ptr) == false) {
@@ -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,8 +510,8 @@ 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);
@@ -528,46 +523,43 @@ static int locate_object_short_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_isdir(object_location->ptr) == false)
-		return git__throw(GIT_ENOTFOUND, "Failed to locate object from short oid. Object not found");
+		return git_odb__error_notfound("failed to locate from short oid");
 
 	state.dir_len = object_location->size;
 	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("failed to locate from 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;
 }
 
 
@@ -598,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("in loose backend");
+	else if ((error = read_header_loose(&raw, &object_path)) == 0) {
 		*len_p = raw.len;
 		*type_p = raw.type;
 	}
@@ -613,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("in loose backend");
+	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);
 
@@ -642,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;
@@ -660,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;
@@ -687,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 (git_buf_oom(&final_path))
-		return GIT_ENOMEM;
-
-	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) == true) {
+	else if (git_path_exists(final_path.ptr) == true)
 		git_filebuf_cleanup(&stream->fbuf);
-		goto cleanup;
-	}
-
-	error = git_filebuf_commit_at(&stream->fbuf, final_path.ptr, GIT_OBJECT_FILE_MODE);
+	else
+		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;
 }
 
@@ -751,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);
 
@@ -774,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 */
@@ -788,31 +753,21 @@ 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)
@@ -826,36 +781,26 @@ 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)
@@ -883,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;
@@ -907,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;
 }