1 files changed, 135 insertions, 145 deletions

diff --git a/src/pack.c b/src/pack.c
index acab8734b..40b3ca77c 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -17,12 +17,12 @@
 #include <zlib.h>
 
 static int packfile_open(struct git_pack_file *p);
-static off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n);
+static git_off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n);
 int packfile_unpack_compressed(
 		git_rawobj *obj,
 		struct git_pack_file *p,
 		git_mwindow **w_curs,
-		off_t *curpos,
+		git_off_t *curpos,
 		size_t size,
 		git_otype type);
 
@@ -34,12 +34,18 @@ int packfile_unpack_compressed(
  * GIT_OID_MINPREFIXLEN and GIT_OID_HEXSZ.
  */
 static int pack_entry_find_offset(
-		off_t *offset_out,
+		git_off_t *offset_out,
 		git_oid *found_oid,
 		struct git_pack_file *p,
 		const git_oid *short_oid,
 		unsigned int len);
 
+static int packfile_error(const char *message)
+{
+	giterr_set(GITERR_ODB, "Invalid pack file - %s", message);
+	return -1;
+}
+
 /***********************************************************
  *
  * PACK INDEX METHODS
@@ -58,40 +64,31 @@ static int pack_index_check(const char *path, struct git_pack_file *p)
 {
 	struct git_pack_idx_header *hdr;
 	uint32_t version, nr, i, *index;
-
 	void *idx_map;
 	size_t idx_size;
-
 	struct stat st;
-
-	/* TODO: properly open the file without access time */
-	git_file fd = p_open(path, O_RDONLY /*| O_NOATIME */);
-
 	int error;
-
+	/* TODO: properly open the file without access time using O_NOATIME */
+	git_file fd = git_futils_open_ro(path);
 	if (fd < 0)
-		return git__throw(GIT_EOSERR, "Failed to check index. File missing or corrupted");
+		return fd;
 
-	if (p_fstat(fd, &st) < GIT_SUCCESS) {
+	if (p_fstat(fd, &st) < 0 ||
+		!S_ISREG(st.st_mode) ||
+		!git__is_sizet(st.st_size) ||
+		(idx_size = (size_t)st.st_size) < 4 * 256 + 20 + 20)
+	{
 		p_close(fd);
-		return git__throw(GIT_EOSERR, "Failed to check index. File appears to be corrupted");
-	}
-
-	if (!git__is_sizet(st.st_size))
-		return GIT_ENOMEM;
-
-	idx_size = (size_t)st.st_size;
-
-	if (idx_size < 4 * 256 + 20 + 20) {
-		p_close(fd);
-		return git__throw(GIT_EOBJCORRUPTED, "Failed to check index. Object is corrupted");
+		giterr_set(GITERR_OS, "Failed to check pack index.");
+		return -1;
 	}
 
 	error = git_futils_mmap_ro(&p->index_map, fd, 0, idx_size);
+
 	p_close(fd);
 
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to check index");
+	if (error < 0)
+		return error;
 
 	hdr = idx_map = p->index_map.data;
 
@@ -100,7 +97,7 @@ static int pack_index_check(const char *path, struct git_pack_file *p)
 
 		if (version < 2 || version > 2) {
 			git_futils_mmap_free(&p->index_map);
-			return git__throw(GIT_EOBJCORRUPTED, "Failed to check index. Unsupported index version");
+			return packfile_error("unsupported index version");
 		}
 
 	} else
@@ -116,7 +113,7 @@ static int pack_index_check(const char *path, struct git_pack_file *p)
 		uint32_t n = ntohl(index[i]);
 		if (n < nr) {
 			git_futils_mmap_free(&p->index_map);
-			return git__throw(GIT_EOBJCORRUPTED, "Failed to check index. Index is non-monotonic");
+			return packfile_error("index is non-monotonic");
 		}
 		nr = n;
 	}
@@ -131,7 +128,7 @@ static int pack_index_check(const char *path, struct git_pack_file *p)
 		 */
 		if (idx_size != 4*256 + nr * 24 + 20 + 20) {
 			git_futils_mmap_free(&p->index_map);
-			return git__throw(GIT_EOBJCORRUPTED, "Failed to check index. Object is corrupted");
+			return packfile_error("index is corrupted");
 		}
 	} else if (version == 2) {
 		/*
@@ -155,13 +152,13 @@ static int pack_index_check(const char *path, struct git_pack_file *p)
 
 		if (idx_size < min_size || idx_size > max_size) {
 			git_futils_mmap_free(&p->index_map);
-			return git__throw(GIT_EOBJCORRUPTED, "Failed to check index. Wrong index size");
+			return packfile_error("wrong index size");
 		}
 	}
 
 	p->index_version = version;
 	p->num_objects = nr;
-	return GIT_SUCCESS;
+	return 0;
 }
 
 static int pack_index_open(struct git_pack_file *p)
@@ -170,24 +167,26 @@ static int pack_index_open(struct git_pack_file *p)
 	int error;
 
 	if (p->index_map.data)
-		return GIT_SUCCESS;
+		return 0;
 
 	idx_name = git__strdup(p->pack_name);
+	GITERR_CHECK_ALLOC(idx_name);
+
 	strcpy(idx_name + strlen(idx_name) - strlen(".pack"), ".idx");
 
 	error = pack_index_check(idx_name, p);
 	git__free(idx_name);
 
-	return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to open index");
+	return error;
 }
 
 static unsigned char *pack_window_open(
 		struct git_pack_file *p,
 		git_mwindow **w_cursor,
-		off_t offset,
+		git_off_t offset,
 		unsigned int *left)
 {
-	if (p->mwf.fd == -1 && packfile_open(p) < GIT_SUCCESS)
+	if (p->mwf.fd == -1 && packfile_open(p) < 0)
 		return NULL;
 
 	/* Since packfiles end in a hash of their content and it's
@@ -233,7 +232,7 @@ int git_packfile_unpack_header(
 		git_otype *type_p,
 		git_mwindow_file *mwf,
 		git_mwindow **w_curs,
-		off_t *curpos)
+		git_off_t *curpos)
 {
 	unsigned char *base;
 	unsigned int left;
@@ -248,35 +247,34 @@ int git_packfile_unpack_header(
 //	base = pack_window_open(p, w_curs, *curpos, &left);
 	base = git_mwindow_open(mwf, w_curs, *curpos, 20, &left);
 	if (base == NULL)
-		return GIT_ENOMEM;
+		return -1;
 
 	used = packfile_unpack_header1(size_p, type_p, base, left);
-
 	if (used == 0)
-		return git__throw(GIT_EOBJCORRUPTED, "Header length is zero");
+		return packfile_error("header length is zero");
 
 	*curpos += used;
-	return GIT_SUCCESS;
+	return 0;
 }
 
 static int packfile_unpack_delta(
 		git_rawobj *obj,
 		struct git_pack_file *p,
 		git_mwindow **w_curs,
-		off_t *curpos,
+		git_off_t *curpos,
 		size_t delta_size,
 		git_otype delta_type,
-		off_t obj_offset)
+		git_off_t obj_offset)
 {
-	off_t base_offset;
+	git_off_t base_offset;
 	git_rawobj base, delta;
 	int error;
 
 	base_offset = get_delta_base(p, w_curs, curpos, delta_type, obj_offset);
 	if (base_offset == 0)
-		return git__throw(GIT_EOBJCORRUPTED, "Delta offset is zero");
-	if (base_offset < 0)
-		return git__rethrow(base_offset, "Failed to get delta base");
+		return packfile_error("delta offset is zero");
+	if (base_offset < 0) /* must actually be an error code */
+		return (int)base_offset;
 
 	git_mwindow_close(w_curs);
 	error = git_packfile_unpack(&base, p, &base_offset);
@@ -287,35 +285,34 @@ static int packfile_unpack_delta(
 	 *
 	 * We'll need to do this in order to support thin packs.
 	 */
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Corrupted delta");
+	if (error < 0)
+		return error;
 
 	error = packfile_unpack_compressed(&delta, p, w_curs, curpos, delta_size, delta_type);
-	if (error < GIT_SUCCESS) {
+	if (error < 0) {
 		git__free(base.data);
-		return git__rethrow(error, "Corrupted delta");
+		return error;
 	}
 
 	obj->type = base.type;
-	error = git__delta_apply(obj,
-			base.data, base.len,
-			delta.data, delta.len);
+	error = git__delta_apply(obj, base.data, base.len, delta.data, delta.len);
 
 	git__free(base.data);
 	git__free(delta.data);
 
 	/* TODO: we might want to cache this shit. eventually */
 	//add_delta_base_cache(p, base_offset, base, base_size, *type);
+
 	return error; /* error set by git__delta_apply */
 }
 
 int git_packfile_unpack(
-		git_rawobj *obj,
-		struct git_pack_file *p,
-		off_t *obj_offset)
+	git_rawobj *obj,
+	struct git_pack_file *p,
+	git_off_t *obj_offset)
 {
 	git_mwindow *w_curs = NULL;
-	off_t curpos = *obj_offset;
+	git_off_t curpos = *obj_offset;
 	int error;
 
 	size_t size = 0;
@@ -330,8 +327,8 @@ int git_packfile_unpack(
 	obj->type = GIT_OBJ_BAD;
 
 	error = git_packfile_unpack_header(&size, &type, &p->mwf, &w_curs, &curpos);
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to unpack packfile");
+	if (error < 0)
+		return error;
 
 	switch (type) {
 	case GIT_OBJ_OFS_DELTA:
@@ -351,33 +348,30 @@ int git_packfile_unpack(
 		break;
 
 	default:
-		error = GIT_EOBJCORRUPTED;
+		error = packfile_error("invalid packfile type in header");;
 		break;
 	}
 
 	git_mwindow_close(&w_curs);
 
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to unpack object");
-
 	*obj_offset = curpos;
-	return GIT_SUCCESS;
+	return error;
 }
 
 int packfile_unpack_compressed(
-		git_rawobj *obj,
-		struct git_pack_file *p,
-		git_mwindow **w_curs,
-		off_t *curpos,
-		size_t size,
-		git_otype type)
+	git_rawobj *obj,
+	struct git_pack_file *p,
+	git_mwindow **w_curs,
+	git_off_t *curpos,
+	size_t size,
+	git_otype type)
 {
 	int st;
 	z_stream stream;
 	unsigned char *buffer, *in;
 
-	buffer = git__malloc(size + 1);
-	memset(buffer, 0x0, size + 1);
+	buffer = git__calloc(1, size + 1);
+	GITERR_CHECK_ALLOC(buffer);
 
 	memset(&stream, 0, sizeof(stream));
 	stream.next_out = buffer;
@@ -386,7 +380,8 @@ int packfile_unpack_compressed(
 	st = inflateInit(&stream);
 	if (st != Z_OK) {
 		git__free(buffer);
-		return git__throw(GIT_EZLIB, "Error in zlib");
+		giterr_set(GITERR_ZLIB, "Failed to inflate packfile");
+		return -1;
 	}
 
 	do {
@@ -404,28 +399,29 @@ int packfile_unpack_compressed(
 
 	if ((st != Z_STREAM_END) || stream.total_out != size) {
 		git__free(buffer);
-		return git__throw(GIT_EZLIB, "Error in zlib");
+		giterr_set(GITERR_ZLIB, "Failed to inflate packfile");
+		return -1;
 	}
 
 	obj->type = type;
 	obj->len = size;
 	obj->data = buffer;
-	return GIT_SUCCESS;
+	return 0;
 }
 
 /*
  * curpos is where the data starts, delta_obj_offset is the where the
  * header starts
  */
-off_t get_delta_base(
-		struct git_pack_file *p,
-		git_mwindow **w_curs,
-		off_t *curpos,
-		git_otype type,
-		off_t delta_obj_offset)
+git_off_t get_delta_base(
+	struct git_pack_file *p,
+	git_mwindow **w_curs,
+	git_off_t *curpos,
+	git_otype type,
+	git_off_t delta_obj_offset)
 {
 	unsigned char *base_info = pack_window_open(p, w_curs, *curpos, NULL);
-	off_t base_offset;
+	git_off_t base_offset;
 	git_oid unused;
 
 	/* pack_window_open() assured us we have [base_info, base_info + 20)
@@ -463,8 +459,8 @@ off_t get_delta_base(
 			}
 		}
 		/* The base entry _must_ be in the same pack */
-		if (pack_entry_find_offset(&base_offset, &unused, p, (git_oid *)base_info, GIT_OID_HEXSZ) < GIT_SUCCESS)
-			return git__rethrow(GIT_EPACKCORRUPTED, "Base entry delta is not in the same pack");
+		if (pack_entry_find_offset(&base_offset, &unused, p, (git_oid *)base_info, GIT_OID_HEXSZ) < 0)
+			return packfile_error("base entry delta is not in the same pack");
 		*curpos += 20;
 	} else
 		return 0;
@@ -480,9 +476,9 @@ off_t get_delta_base(
 
 static struct git_pack_file *packfile_alloc(int extra)
 {
-	struct git_pack_file *p = git__malloc(sizeof(*p) + extra);
-	memset(p, 0, sizeof(*p));
-	p->mwf.fd = -1;
+	struct git_pack_file *p = git__calloc(1, sizeof(*p) + extra);
+	if (p != NULL)
+		p->mwf.fd = -1;
 	return p;
 }
 
@@ -510,24 +506,25 @@ static int packfile_open(struct git_pack_file *p)
 	git_oid sha1;
 	unsigned char *idx_sha1;
 
+	assert(p->index_map.data);
+
 	if (!p->index_map.data && pack_index_open(p) < GIT_SUCCESS)
-		return git__throw(GIT_ENOTFOUND, "Failed to open packfile. File not found");
+		return git_odb__error_notfound("failed to open packfile");
 
 	/* TODO: open with noatime */
-	p->mwf.fd = p_open(p->pack_name, O_RDONLY);
-	if (p->mwf.fd < 0 || p_fstat(p->mwf.fd, &st) < GIT_SUCCESS)
-		return git__throw(GIT_EOSERR, "Failed to open packfile. File appears to be corrupted");
+	p->mwf.fd = git_futils_open_ro(p->pack_name);
+	if (p->mwf.fd < 0)
+		return p->mwf.fd;
 
-	if (git_mwindow_file_register(&p->mwf) < GIT_SUCCESS) {
-		p_close(p->mwf.fd);
-		return git__throw(GIT_ERROR, "Failed to register packfile windows");
-	}
+	if (p_fstat(p->mwf.fd, &st) < 0 ||
+		git_mwindow_file_register(&p->mwf) < 0)
+		goto cleanup;
 
 	/* If we created the struct before we had the pack we lack size. */
 	if (!p->mwf.size) {
 		if (!S_ISREG(st.st_mode))
 			goto cleanup;
-		p->mwf.size = (off_t)st.st_size;
+		p->mwf.size = (git_off_t)st.st_size;
 	} else if (p->mwf.size != st.st_size)
 		goto cleanup;
 
@@ -537,44 +534,35 @@ static int packfile_open(struct git_pack_file *p)
 	 */
 	fd_flag = fcntl(p->mwf.fd, F_GETFD, 0);
 	if (fd_flag < 0)
-		return error("cannot determine file descriptor flags");
+		goto cleanup;
 
 	fd_flag |= FD_CLOEXEC;
 	if (fcntl(p->pack_fd, F_SETFD, fd_flag) == -1)
-		return GIT_EOSERR;
+		goto cleanup;
 #endif
 
 	/* Verify we recognize this pack file format. */
-	if (p_read(p->mwf.fd, &hdr, sizeof(hdr)) < GIT_SUCCESS)
-		goto cleanup;
-
-	if (hdr.hdr_signature != htonl(PACK_SIGNATURE))
-		goto cleanup;
-
-	if (!pack_version_ok(hdr.hdr_version))
+	if (p_read(p->mwf.fd, &hdr, sizeof(hdr)) < 0 ||
+		hdr.hdr_signature != htonl(PACK_SIGNATURE) ||
+		!pack_version_ok(hdr.hdr_version))
 		goto cleanup;
 
 	/* Verify the pack matches its index. */
-	if (p->num_objects != ntohl(hdr.hdr_entries))
-		goto cleanup;
-
-	if (p_lseek(p->mwf.fd, p->mwf.size - GIT_OID_RAWSZ, SEEK_SET) == -1)
-		goto cleanup;
-
-	if (p_read(p->mwf.fd, sha1.id, GIT_OID_RAWSZ) < GIT_SUCCESS)
+	if (p->num_objects != ntohl(hdr.hdr_entries) ||
+		p_lseek(p->mwf.fd, p->mwf.size - GIT_OID_RAWSZ, SEEK_SET) == -1 ||
+		p_read(p->mwf.fd, sha1.id, GIT_OID_RAWSZ) < 0)
 		goto cleanup;
 
 	idx_sha1 = ((unsigned char *)p->index_map.data) + p->index_map.len - 40;
 
-	if (git_oid_cmp(&sha1, (git_oid *)idx_sha1) != 0)
-		goto cleanup;
-
-	return GIT_SUCCESS;
+	if (git_oid_cmp(&sha1, (git_oid *)idx_sha1) == 0)
+		return 0;
 
 cleanup:
+	giterr_set(GITERR_OS, "Invalid packfile '%s'", p->pack_name);
 	p_close(p->mwf.fd);
 	p->mwf.fd = -1;
-	return git__throw(GIT_EPACKCORRUPTED, "Failed to open packfile. Pack is corrupted");
+	return -1;
 }
 
 int git_packfile_check(struct git_pack_file **pack_out, const char *path)
@@ -586,6 +574,7 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path)
 	*pack_out = NULL;
 	path_len = strlen(path);
 	p = packfile_alloc(path_len + 2);
+	GITERR_CHECK_ALLOC(p);
 
 	/*
 	 * Make sure a corresponding .pack file exists and that
@@ -594,7 +583,7 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path)
 	path_len -= strlen(".idx");
 	if (path_len < 1) {
 		git__free(p);
-		return git__throw(GIT_ENOTFOUND, "Failed to check packfile. Wrong path name");
+		return git_odb__error_notfound("invalid packfile path");
 	}
 
 	memcpy(p->pack_name, path, path_len);
@@ -604,9 +593,9 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path)
 		p->pack_keep = 1;
 
 	strcpy(p->pack_name + path_len, ".pack");
-	if (p_stat(p->pack_name, &st) < GIT_SUCCESS || !S_ISREG(st.st_mode)) {
+	if (p_stat(p->pack_name, &st) < 0 || !S_ISREG(st.st_mode)) {
 		git__free(p);
-		return git__throw(GIT_ENOTFOUND, "Failed to check packfile. File not found");
+		return git_odb__error_notfound("packfile not found");
 	}
 
 	/* ok, it looks sane as far as we can check without
@@ -618,11 +607,12 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path)
 
 	/* see if we can parse the sha1 oid in the packfile name */
 	if (path_len < 40 ||
-		git_oid_fromstr(&p->sha1, path + path_len - GIT_OID_HEXSZ) < GIT_SUCCESS)
+		git_oid_fromstr(&p->sha1, path + path_len - GIT_OID_HEXSZ) < 0)
 		memset(&p->sha1, 0x0, GIT_OID_RAWSZ);
 
 	*pack_out = p;
-	return GIT_SUCCESS;
+
+	return 0;
 }
 
 /***********************************************************
@@ -631,7 +621,7 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path)
  *
  ***********************************************************/
 
-static off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n)
+static git_off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n)
 {
 	const unsigned char *index = p->index_map.data;
 	index += 4 * 256;
@@ -650,11 +640,11 @@ static off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n)
 }
 
 static int pack_entry_find_offset(
-		off_t *offset_out,
-		git_oid *found_oid,
-		struct git_pack_file *p,
-		const git_oid *short_oid,
-		unsigned int len)
+	git_off_t *offset_out,
+	git_oid *found_oid,
+	struct git_pack_file *p,
+	const git_oid *short_oid,
+	unsigned int len)
 {
 	const uint32_t *level1_ofs = p->index_map.data;
 	const unsigned char *index = p->index_map.data;
@@ -667,8 +657,8 @@ static int pack_entry_find_offset(
 	if (index == NULL) {
 		int error;
 
-		if ((error = pack_index_open(p)) < GIT_SUCCESS)
-			return git__rethrow(error, "Failed to find offset for pack entry");
+		if ((error = pack_index_open(p)) < 0)
+			return error;
 
 		assert(p->index_map.data);
 
@@ -726,22 +716,22 @@ static int pack_entry_find_offset(
 		}
 	}
 
-	if (!found) {
-		return git__throw(GIT_ENOTFOUND, "Failed to find offset for pack entry. Entry not found");
-	} else if (found > 1) {
-		return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to find offset for pack entry. Ambiguous sha1 prefix within pack");
-	} else {
-		*offset_out = nth_packed_object_offset(p, pos);
-		git_oid_fromraw(found_oid, current);
+	if (!found)
+		return git_odb__error_notfound("failed to find offset for pack entry");
+	if (found > 1)
+		return git_odb__error_ambiguous("found multiple offsets for pack entry");
+	*offset_out = nth_packed_object_offset(p, pos);
+	git_oid_fromraw(found_oid, current);
 
 #ifdef INDEX_DEBUG_LOOKUP
+	{
 		unsigned char hex_sha1[GIT_OID_HEXSZ + 1];
 		git_oid_fmt(hex_sha1, found_oid);
 		hex_sha1[GIT_OID_HEXSZ] = '\0';
 		printf("found lo=%d %s\n", lo, hex_sha1);
-#endif
-		return GIT_SUCCESS;
 	}
+#endif
+	return 0;
 }
 
 int git_pack_entry_find(
@@ -750,7 +740,7 @@ int git_pack_entry_find(
 		const git_oid *short_oid,
 		unsigned int len)
 {
-	off_t offset;
+	git_off_t offset;
 	git_oid found_oid;
 	int error;
 
@@ -760,22 +750,22 @@ int git_pack_entry_find(
 		unsigned i;
 		for (i = 0; i < p->num_bad_objects; i++)
 			if (git_oid_cmp(short_oid, &p->bad_object_sha1[i]) == 0)
-				return git__throw(GIT_ERROR, "Failed to find pack entry. Bad object found");
+				return packfile_error("bad object found in packfile");
 	}
 
 	error = pack_entry_find_offset(&offset, &found_oid, p, short_oid, len);
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to find pack entry. Couldn't find offset");
+	if (error < 0)
+		return error;
 
 	/* we found a unique entry in the index;
 	 * make sure the packfile backing the index
 	 * still exists on disk */
-	if (p->mwf.fd == -1 && packfile_open(p) < GIT_SUCCESS)
-		return git__throw(GIT_EOSERR, "Failed to find pack entry. Packfile doesn't exist on disk");
+	if (p->mwf.fd == -1 && (error = packfile_open(p)) < 0)
+		return error;
 
 	e->offset = offset;
 	e->p = p;
 
 	git_oid_cpy(&e->sha1, &found_oid);
-	return GIT_SUCCESS;
+	return 0;
 }