rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/{pack.c → libgit2/pack.c}

@@ -13,6 +13,7 @@
 #include "odb.h"
 #include "oid.h"
 #include "oidarray.h"
+#include "hashmap_oid.h"
 
 /* Option to bypass checking existence of '.keep' files */
 bool git_disable_pack_keep_file_checks = false;
@@ -32,7 +33,7 @@ static int packfile_unpack_compressed(
  * Throws GIT_EAMBIGUOUSOIDPREFIX if short oid
  * is ambiguous within the pack.
  * This method assumes that len is between
- * GIT_OID_MINPREFIXLEN and GIT_OID_HEXSZ.
+ * GIT_OID_MINPREFIXLEN and the oid type's hexsize.
  */
 static int pack_entry_find_offset(
 		off64_t *offset_out,
@@ -41,6 +42,12 @@ static int pack_entry_find_offset(
 		const git_oid *short_oid,
 		size_t len);
 
+#define off64_hash(key) (uint32_t)((key)>>33^(key)^(key)<<11)
+#define off64_equal(a, b) ((a) == (b))
+
+GIT_HASHMAP_FUNCTIONS(git_pack_offsetmap, GIT_HASHMAP_INLINE, off64_t, git_pack_cache_entry *, off64_hash, off64_equal);
+GIT_HASHMAP_OID_FUNCTIONS(git_pack_oidmap, , struct git_pack_entry *);
+
 static int packfile_error(const char *message)
 {
 	git_error_set(GIT_ERROR_ODB, "invalid pack file - %s", message);
@@ -75,31 +82,21 @@ static void free_cache_object(void *o)
 
 static void cache_free(git_pack_cache *cache)
 {
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 	git_pack_cache_entry *entry;
 
-	if (cache->entries) {
-		git_offmap_foreach_value(cache->entries, entry, {
-			free_cache_object(entry);
-		});
+	while (git_pack_offsetmap_iterate(&iter, NULL, &entry, &cache->entries) == 0)
+		free_cache_object(entry);
 
-		git_offmap_free(cache->entries);
-		cache->entries = NULL;
-	}
+	git_pack_offsetmap_dispose(&cache->entries);
 }
 
 static int cache_init(git_pack_cache *cache)
 {
-	if (git_offmap_new(&cache->entries) < 0)
-		return -1;
-
 	cache->memory_limit = GIT_PACK_CACHE_MEMORY_LIMIT;
 
 	if (git_mutex_init(&cache->lock)) {
 		git_error_set(GIT_ERROR_OS, "failed to initialize pack cache mutex");
-
-		git__free(cache->entries);
-		cache->entries = NULL;
-
 		return -1;
 	}
 
@@ -108,15 +105,16 @@ static int cache_init(git_pack_cache *cache)
 
 static git_pack_cache_entry *cache_get(git_pack_cache *cache, off64_t offset)
 {
-	git_pack_cache_entry *entry;
+	git_pack_cache_entry *entry = NULL;
 
 	if (git_mutex_lock(&cache->lock) < 0)
 		return NULL;
 
-	if ((entry = git_offmap_get(cache->entries, offset)) != NULL) {
+	if (git_pack_offsetmap_get(&entry, &cache->entries, offset) == 0) {
 		git_atomic32_inc(&entry->refcount);
 		entry->last_usage = cache->use_ctr++;
 	}
+
 	git_mutex_unlock(&cache->lock);
 
 	return entry;
@@ -125,16 +123,17 @@ static git_pack_cache_entry *cache_get(git_pack_cache *cache, off64_t offset)
 /* Run with the cache lock held */
 static void free_lowest_entry(git_pack_cache *cache)
 {
-	off64_t offset;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 	git_pack_cache_entry *entry;
+	off64_t offset;
 
-	git_offmap_foreach(cache->entries, offset, entry, {
+	while (git_pack_offsetmap_iterate(&iter, &offset, &entry, &cache->entries) == 0) {
 		if (entry && git_atomic32_get(&entry->refcount) == 0) {
 			cache->memory_used -= entry->raw.len;
-			git_offmap_delete(cache->entries, offset);
+			git_pack_offsetmap_remove(&cache->entries, offset);
 			free_cache_object(entry);
 		}
-	});
+	}
 }
 
 static int cache_add(
@@ -157,12 +156,12 @@ static int cache_add(
 			return -1;
 		}
 		/* Add it to the cache if nobody else has */
-		exists = git_offmap_exists(cache->entries, offset);
+		exists = git_pack_offsetmap_contains(&cache->entries, offset);
 		if (!exists) {
 			while (cache->memory_used + base->len > cache->memory_limit)
 				free_lowest_entry(cache);
 
-			git_offmap_set(cache->entries, offset, entry);
+			git_pack_offsetmap_put(&cache->entries, offset, entry);
 			cache->memory_used += entry->raw.len;
 
 			*cached_out = entry;
@@ -186,9 +185,9 @@ static int cache_add(
 
 static void pack_index_free(struct git_pack_file *p)
 {
-	if (p->oids) {
-		git__free(p->oids);
-		p->oids = NULL;
+	if (p->ids) {
+		git__free(p->ids);
+		p->ids = NULL;
 	}
 	if (p->index_map.data) {
 		git_futils_mmap_free(&p->index_map);
@@ -200,11 +199,12 @@ static void pack_index_free(struct git_pack_file *p)
 static int pack_index_check_locked(const char *path, struct git_pack_file *p)
 {
 	struct git_pack_idx_header *hdr;
-	uint32_t version, nr, i, *index;
+	uint32_t version, nr = 0, i, *index;
 	void *idx_map;
 	size_t idx_size;
 	struct stat st;
 	int error;
+
 	/* TODO: properly open the file without access time using O_NOATIME */
 	git_file fd = git_futils_open_ro(path);
 	if (fd < 0)
@@ -218,8 +218,7 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p)
 
 	if (!S_ISREG(st.st_mode) ||
 		!git__is_sizet(st.st_size) ||
-		(idx_size = (size_t)st.st_size) < 4 * 256 + 20 + 20)
-	{
+		(idx_size = (size_t)st.st_size) < (size_t)((4 * 256) + (p->oid_size * 2))) {
 		p_close(fd);
 		git_error_set(GIT_ERROR_ODB, "invalid pack index '%s'", path);
 		return -1;
@@ -242,10 +241,10 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p)
 			return packfile_error("unsupported index version");
 		}
 
-	} else
+	} else {
 		version = 1;
+	}
 
-	nr = 0;
 	index = idx_map;
 
 	if (version > 1)
@@ -264,11 +263,11 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p)
 		/*
 		 * Total size:
 		 * - 256 index entries 4 bytes each
-		 * - 24-byte entries * nr (20-byte sha1 + 4-byte offset)
-		 * - 20-byte SHA1 of the packfile
-		 * - 20-byte SHA1 file checksum
+		 * - 24/36-byte entries * nr (20/32 byte SHA + 4-byte offset)
+		 * - 20/32-byte SHA of the packfile
+		 * - 20/32-byte SHA file checksum
 		 */
-		if (idx_size != 4*256 + nr * 24 + 20 + 20) {
+		if (idx_size != (4 * 256 + ((uint64_t) nr * (p->oid_size + 4)) + (p->oid_size * 2))) {
 			git_futils_mmap_free(&p->index_map);
 			return packfile_error("index is corrupted");
 		}
@@ -277,17 +276,17 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p)
 		 * Minimum size:
 		 * - 8 bytes of header
 		 * - 256 index entries 4 bytes each
-		 * - 20-byte sha1 entry * nr
+		 * - 20/32-byte SHA entry * nr
 		 * - 4-byte crc entry * nr
 		 * - 4-byte offset entry * nr
-		 * - 20-byte SHA1 of the packfile
-		 * - 20-byte SHA1 file checksum
+		 * - 20/32-byte SHA of the packfile
+		 * - 20/32-byte SHA file checksum
 		 * And after the 4-byte offset table might be a
 		 * variable sized table containing 8-byte entries
 		 * for offsets larger than 2^31.
 		 */
-		unsigned long min_size = 8 + 4*256 + nr*(20 + 4 + 4) + 20 + 20;
-		unsigned long max_size = min_size;
+		uint64_t min_size = 8 + (4 * 256) + ((uint64_t)nr * (p->oid_size + 4 + 4)) + (p->oid_size * 2);
+		uint64_t max_size = min_size;
 
 		if (nr)
 			max_size += (nr - 1)*8;
@@ -308,7 +307,7 @@ static int pack_index_open_locked(struct git_pack_file *p)
 {
 	int error = 0;
 	size_t name_len;
-	git_buf idx_name = GIT_BUF_INIT;
+	git_str idx_name = GIT_STR_INIT;
 
 	if (p->index_version > -1)
 		goto cleanup;
@@ -317,12 +316,12 @@ static int pack_index_open_locked(struct git_pack_file *p)
 	name_len = strlen(p->pack_name);
 	GIT_ASSERT(name_len > strlen(".pack"));
 
-	if ((error = git_buf_init(&idx_name, name_len)) < 0)
+	if ((error = git_str_init(&idx_name, name_len)) < 0)
 		goto cleanup;
 
-	git_buf_put(&idx_name, p->pack_name, name_len - strlen(".pack"));
-	git_buf_puts(&idx_name, ".idx");
-	if (git_buf_oom(&idx_name)) {
+	git_str_put(&idx_name, p->pack_name, name_len - strlen(".pack"));
+	git_str_puts(&idx_name, ".idx");
+	if (git_str_oom(&idx_name)) {
 		error = -1;
 		goto cleanup;
 	}
@@ -331,7 +330,7 @@ static int pack_index_open_locked(struct git_pack_file *p)
 		error = pack_index_check_locked(idx_name.ptr, p);
 
 cleanup:
-	git_buf_dispose(&idx_name);
+	git_str_dispose(&idx_name);
 
 	return error;
 }
@@ -365,12 +364,12 @@ static unsigned char *pack_window_open(
 	 * Don't allow a negative offset, as that means we've wrapped
 	 * around.
 	 */
-	if (offset > (p->mwf.size - 20))
+	if (offset > (p->mwf.size - p->oid_size))
 		goto cleanup;
 	if (offset < 0)
 		goto cleanup;
 
-	pack_data = git_mwindow_open(&p->mwf, w_cursor, offset, 20, left);
+	pack_data = git_mwindow_open(&p->mwf, w_cursor, offset, p->oid_size, left);
 
 cleanup:
 	git_mutex_unlock(&p->mwf.lock);
@@ -473,13 +472,13 @@ int git_packfile_unpack_header(
 		return error;
 	}
 
-	/* pack_window_open() assures us we have [base, base + 20) available
-	 * as a range that we can look at at. (Its actually the hash
-	 * size that is assured.) With our object header encoding
-	 * the maximum deflated object size is 2^137, which is just
-	 * insane, so we know won't exceed what we have been given.
+	/* pack_window_open() assures us we have [base, base + oid_size)
+	 * available as a range that we can look at at. (It's actually
+	 * the hash size that is assured.) With our object header
+	 * encoding the maximum deflated object size is 2^137, which is
+	 * just insane, so we know won't exceed what we have been given.
 	 */
-	base = git_mwindow_open(&p->mwf, w_curs, *curpos, 20, &left);
+	base = git_mwindow_open(&p->mwf, w_curs, *curpos, p->oid_size, &left);
 	git_mutex_unlock(&p->lock);
 	git_mutex_unlock(&p->mwf.lock);
 	if (base == NULL)
@@ -977,11 +976,12 @@ int get_delta_base(
 	/* Assumption: the only reason this would fail is because the file is too small */
 	if (base_info == NULL)
 		return GIT_EBUFS;
-	/* pack_window_open() assured us we have [base_info, base_info + 20)
-	 * as a range that we can look at without walking off the
-	 * end of the mapped window. Its actually the hash size
-	 * that is assured. An OFS_DELTA longer than the hash size
-	 * is stupid, as then a REF_DELTA would be smaller to store.
+	/* pack_window_open() assured us we have
+	 * [base_info, base_info + oid_size) as a range that we can look
+	 * at without walking off the end of the mapped window. Its
+	 * actually the hash size that is assured. An OFS_DELTA longer
+	 * than the hash size is stupid, as then a REF_DELTA would be
+	 * smaller to store.
 	 */
 	if (type == GIT_OBJECT_OFS_DELTA) {
 		unsigned used = 0;
@@ -1001,17 +1001,18 @@ int get_delta_base(
 		base_offset = delta_obj_offset - unsigned_base_offset;
 		*curpos += used;
 	} else if (type == GIT_OBJECT_REF_DELTA) {
+		git_oid base_oid;
+		git_oid__fromraw(&base_oid, base_info, p->oid_type);
+
 		/* If we have the cooperative cache, search in it first */
 		if (p->has_cache) {
 			struct git_pack_entry *entry;
-			git_oid oid;
 
-			git_oid_fromraw(&oid, base_info);
-			if ((entry = git_oidmap_get(p->idx_cache, &oid)) != NULL) {
+			if (git_pack_oidmap_get(&entry, &p->idx_cache, &base_oid) == 0) {
 				if (entry->offset == 0)
 					return packfile_error("delta offset is zero");
 
-				*curpos += 20;
+				*curpos += p->oid_size;
 				*delta_base_out = entry->offset;
 				return 0;
 			} else {
@@ -1024,9 +1025,9 @@ int 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) < 0)
+		if (pack_entry_find_offset(&base_offset, &unused, p, &base_oid, p->oid_hexsize) < 0)
 			return packfile_error("base entry delta is not in the same pack");
-		*curpos += 20;
+		*curpos += p->oid_size;
 	} else
 		return packfile_error("unknown object type");
 
@@ -1069,7 +1070,7 @@ void git_packfile_free(struct git_pack_file *p, bool unlink_packfile)
 
 	pack_index_free(p);
 
-	git__free(p->bad_object_sha1);
+	git__free(p->bad_object_ids);
 
 	git_mutex_free(&p->bases.lock);
 	git_mutex_free(&p->mwf.lock);
@@ -1082,8 +1083,8 @@ static int packfile_open_locked(struct git_pack_file *p)
 {
 	struct stat st;
 	struct git_pack_header hdr;
-	git_oid sha1;
-	unsigned char *idx_sha1;
+	unsigned char checksum[GIT_OID_MAX_SIZE];
+	unsigned char *idx_checksum;
 
 	if (pack_index_open_locked(p) < 0)
 		return git_odb__error_notfound("failed to open packfile", NULL, 0);
@@ -1130,12 +1131,13 @@ static int packfile_open_locked(struct git_pack_file *p)
 
 	/* Verify the pack matches its index. */
 	if (p->num_objects != ntohl(hdr.hdr_entries) ||
-		p_pread(p->mwf.fd, sha1.id, GIT_OID_RAWSZ, p->mwf.size - GIT_OID_RAWSZ) < 0)
+	    p_pread(p->mwf.fd, checksum, p->oid_size, p->mwf.size - p->oid_size) < 0)
 		goto cleanup;
 
-	idx_sha1 = ((unsigned char *)p->index_map.data) + p->index_map.len - 40;
+	idx_checksum = ((unsigned char *)p->index_map.data) +
+	               p->index_map.len - (p->oid_size * 2);
 
-	if (git_oid__cmp(&sha1, (git_oid *)idx_sha1) != 0)
+	if (git_oid_raw_cmp(checksum, idx_checksum, p->oid_size) != 0)
 		goto cleanup;
 
 	if (git_mwindow_file_register(&p->mwf) < 0)
@@ -1156,21 +1158,24 @@ cleanup:
 int git_packfile__name(char **out, const char *path)
 {
 	size_t path_len;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 
 	path_len = strlen(path);
 
 	if (path_len < strlen(".idx"))
 		return git_odb__error_notfound("invalid packfile path", NULL, 0);
 
-	if (git_buf_printf(&buf, "%.*s.pack", (int)(path_len - strlen(".idx")), path) < 0)
+	if (git_str_printf(&buf, "%.*s.pack", (int)(path_len - strlen(".idx")), path) < 0)
 		return -1;
 
-	*out = git_buf_detach(&buf);
+	*out = git_str_detach(&buf);
 	return 0;
 }
 
-int git_packfile_alloc(struct git_pack_file **pack_out, const char *path)
+int git_packfile_alloc(
+	struct git_pack_file **pack_out,
+	const char *path,
+	git_oid_t oid_type)
 {
 	struct stat st;
 	struct git_pack_file *p;
@@ -1198,7 +1203,7 @@ int git_packfile_alloc(struct git_pack_file **pack_out, const char *path)
 
 		if (!git_disable_pack_keep_file_checks) {
 			memcpy(p->pack_name + root_len, ".keep", sizeof(".keep"));
-			if (git_path_exists(p->pack_name) == true)
+			if (git_fs_path_exists(p->pack_name) == true)
 				p->pack_keep = 1;
 		}
 
@@ -1218,6 +1223,9 @@ int git_packfile_alloc(struct git_pack_file **pack_out, const char *path)
 	p->pack_local = 1;
 	p->mtime = (git_time_t)st.st_mtime;
 	p->index_version = -1;
+	p->oid_type = oid_type ? oid_type : GIT_OID_DEFAULT;
+	p->oid_size = (unsigned int)git_oid_size(p->oid_type);
+	p->oid_hexsize = (unsigned int)git_oid_hexsize(p->oid_type);
 
 	if (git_mutex_init(&p->lock) < 0) {
 		git_error_set(GIT_ERROR_OS, "failed to initialize packfile mutex");
@@ -1259,20 +1267,20 @@ static off64_t nth_packed_object_offset_locked(struct git_pack_file *p, uint32_t
 	end = index + p->index_map.len;
 	index += 4 * 256;
 	if (p->index_version == 1)
-		return ntohl(*((uint32_t *)(index + 24 * n)));
+		return ntohl(*((uint32_t *)(index + (p->oid_size + 4) * (size_t) n)));
 
-	index += 8 + p->num_objects * (20 + 4);
+	index += 8 + (size_t) p->num_objects * (p->oid_size + 4);
 	off32 = ntohl(*((uint32_t *)(index + 4 * n)));
 	if (!(off32 & 0x80000000))
 		return off32;
-	index += p->num_objects * 4 + (off32 & 0x7fffffff) * 8;
+	index += (size_t) p->num_objects * 4 + (off32 & 0x7fffffff) * 8;
 
 	/* Make sure we're not being sent out of bounds */
 	if (index >= end - 8)
 		return -1;
 
 	return (((uint64_t)ntohl(*((uint32_t *)(index + 0)))) << 32) |
-				ntohl(*((uint32_t *)(index + 4)));
+	       ntohl(*((uint32_t *)(index + 4)));
 }
 
 static int git__memcmp4(const void *a, const void *b) {
@@ -1311,7 +1319,7 @@ int git_pack_foreach_entry(
 
 	index += 4 * 256;
 
-	if (p->oids == NULL) {
+	if (p->ids == NULL) {
 		git_vector offsets, oids;
 
 		if ((error = git_vector_init(&oids, p->num_objects, NULL))) {
@@ -1325,25 +1333,32 @@ int git_pack_foreach_entry(
 		}
 
 		if (p->index_version > 1) {
-			const unsigned char *off = index + 24 * p->num_objects;
+			const unsigned char *off = index +
+				(p->oid_size + 4) * p->num_objects;
+
 			for (i = 0; i < p->num_objects; i++)
 				git_vector_insert(&offsets, (void*)&off[4 * i]);
+
 			git_vector_sort(&offsets);
 			git_vector_foreach(&offsets, i, current)
 				git_vector_insert(&oids, (void*)&index[5 * (current - off)]);
 		} else {
 			for (i = 0; i < p->num_objects; i++)
-				git_vector_insert(&offsets, (void*)&index[24 * i]);
+				git_vector_insert(&offsets, (void*)&index[(p->oid_size + 4) * i]);
 			git_vector_sort(&offsets);
 			git_vector_foreach(&offsets, i, current)
 				git_vector_insert(&oids, (void*)&current[4]);
 		}
 
-		git_vector_free(&offsets);
-		p->oids = (git_oid **)git_vector_detach(NULL, NULL, &oids);
+		git_vector_dispose(&offsets);
+		p->ids = (unsigned char **)git_vector_detach(NULL, NULL, &oids);
 	}
 
-	/* We need to copy the OIDs to another array before we relinquish the lock to avoid races. */
+	/*
+	 * We need to copy the OIDs to another array before we
+	 * relinquish the lock to avoid races.  We can also take
+	 * this opportunity to put them into normal form.
+	 */
 	git_array_init_to_size(oids, p->num_objects);
 	if (!oids.ptr) {
 		git_mutex_unlock(&p->lock);
@@ -1357,7 +1372,7 @@ int git_pack_foreach_entry(
 			git_array_clear(oids);
 			GIT_ERROR_CHECK_ALLOC(oid);
 		}
-		git_oid_cpy(oid, p->oids[i]);
+		git_oid__fromraw(oid, p->ids[i], p->oid_type);
 	}
 
 	git_mutex_unlock(&p->lock);
@@ -1380,7 +1395,7 @@ int git_pack_foreach_entry_offset(
 {
 	const unsigned char *index;
 	off64_t current_offset;
-	const git_oid *current_oid;
+	git_oid current_oid;
 	uint32_t i;
 	int error = 0;
 
@@ -1407,10 +1422,13 @@ int git_pack_foreach_entry_offset(
 
 	/* all offsets should have been validated by pack_index_check_locked */
 	if (p->index_version > 1) {
-		const unsigned char *offsets = index + 24 * p->num_objects;
+		const unsigned char *offsets = index +
+			(p->oid_size + 4) * p->num_objects;
 		const unsigned char *large_offset_ptr;
-		const unsigned char *large_offsets = index + 28 * p->num_objects;
-		const unsigned char *large_offsets_end = ((const unsigned char *)p->index_map.data) + p->index_map.len - 20;
+		const unsigned char *large_offsets = index +
+			(p->oid_size + 8) * p->num_objects;
+		const unsigned char *large_offsets_end = ((const unsigned char *)p->index_map.data) + p->index_map.len - p->oid_size;
+
 		for (i = 0; i < p->num_objects; i++) {
 			current_offset = ntohl(*(const uint32_t *)(offsets + 4 * i));
 			if (current_offset & 0x80000000) {
@@ -1422,17 +1440,18 @@ int git_pack_foreach_entry_offset(
 				current_offset = (((off64_t)ntohl(*((uint32_t *)(large_offset_ptr + 0)))) << 32) |
 						ntohl(*((uint32_t *)(large_offset_ptr + 4)));
 			}
-			current_oid = (const git_oid *)(index + 20 * i);
-			if ((error = cb(current_oid, current_offset, data)) != 0) {
+
+			git_oid__fromraw(&current_oid, (index + p->oid_size * i), p->oid_type);
+			if ((error = cb(&current_oid, current_offset, data)) != 0) {
 				error = git_error_set_after_callback(error);
 				goto cleanup;
 			}
 		}
 	} else {
 		for (i = 0; i < p->num_objects; i++) {
-			current_offset = ntohl(*(const uint32_t *)(index + 24 * i));
-			current_oid = (const git_oid *)(index + 24 * i + 4);
-			if ((error = cb(current_oid, current_offset, data)) != 0) {
+			current_offset = ntohl(*(const uint32_t *)(index + (p->oid_size + 4) * i));
+			git_oid__fromraw(&current_oid, (index + (p->oid_size + 4) * i + 4), p->oid_type);
+			if ((error = cb(&current_oid, current_offset, data)) != 0) {
 				error = git_error_set_after_callback(error);
 				goto cleanup;
 			}
@@ -1444,14 +1463,20 @@ cleanup:
 	return error;
 }
 
-int git_pack__lookup_sha1(const void *oid_lookup_table, size_t stride, unsigned lo,
-		unsigned hi, const unsigned char *oid_prefix)
+int git_pack__lookup_id(
+	const void *oid_lookup_table,
+	size_t stride,
+	unsigned lo,
+	unsigned hi,
+	const unsigned char *oid_prefix,
+	const git_oid_t oid_type)
 {
 	const unsigned char *base = oid_lookup_table;
+	size_t oid_size = git_oid_size(oid_type);
 
 	while (lo < hi) {
 		unsigned mi = (lo + hi) / 2;
-		int cmp = git_oid__hashcmp(base + mi * stride, oid_prefix);
+		int cmp = git_oid_raw_cmp(base + mi * stride, oid_prefix, oid_size);
 
 		if (!cmp)
 			return mi;
@@ -1473,6 +1498,7 @@ static int pack_entry_find_offset(
 	size_t len)
 {
 	const uint32_t *level1_ofs;
+	size_t ofs_delta = 0;
 	const unsigned char *index;
 	unsigned hi, lo, stride;
 	int pos, found = 0;
@@ -1498,17 +1524,23 @@ static int pack_entry_find_offset(
 
 	if (p->index_version > 1) {
 		level1_ofs += 2;
+		ofs_delta = 2;
 		index += 8;
 	}
 
+	if ((size_t)short_oid->id[0] + ofs_delta >= p->index_map.len) {
+		git_error_set(GIT_ERROR_INTERNAL, "internal error: p->short_oid->[0] out of bounds");
+		goto cleanup;
+	}
+
 	index += 4 * 256;
 	hi = ntohl(level1_ofs[(int)short_oid->id[0]]);
 	lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(level1_ofs[(int)short_oid->id[0] - 1]));
 
 	if (p->index_version > 1) {
-		stride = 20;
+		stride = p->oid_size;
 	} else {
-		stride = 24;
+		stride = p->oid_size + 4;
 		index += 4;
 	}
 
@@ -1517,7 +1549,8 @@ static int pack_entry_find_offset(
 		short_oid->id[0], short_oid->id[1], short_oid->id[2], lo, hi, p->num_objects);
 #endif
 
-	pos = git_pack__lookup_sha1(index, stride, lo, hi, short_oid->id);
+	pos = git_pack__lookup_id(index, stride, lo, hi,
+		short_oid->id, p->oid_type);
 
 	if (pos >= 0) {
 		/* An object matching exactly the oid was found */
@@ -1530,16 +1563,18 @@ static int pack_entry_find_offset(
 		if (pos < (int)p->num_objects) {
 			current = index + pos * stride;
 
-			if (!git_oid_ncmp(short_oid, (const git_oid *)current, len))
+			if (!git_oid_raw_ncmp(short_oid->id, current, len))
 				found = 1;
 		}
 	}
 
-	if (found && len != GIT_OID_HEXSZ && pos + 1 < (int)p->num_objects) {
+	if (found &&
+	    len != p->oid_hexsize &&
+	    pos + 1 < (int)p->num_objects) {
 		/* Check for ambiguousity */
 		const unsigned char *next = current + stride;
 
-		if (!git_oid_ncmp(short_oid, (const git_oid *)next, len)) {
+		if (!git_oid_raw_ncmp(short_oid->id, next, len)) {
 			found = 2;
 		}
 	}
@@ -1560,13 +1595,13 @@ static int pack_entry_find_offset(
 	}
 
 	*offset_out = offset;
-	git_oid_fromraw(found_oid, current);
+	git_oid__fromraw(found_oid, current, p->oid_type);
 
 #ifdef INDEX_DEBUG_LOOKUP
 	{
-		unsigned char hex_sha1[GIT_OID_HEXSZ + 1];
+		char hex_sha1[p->oid_hexsize + 1];
 		git_oid_fmt(hex_sha1, found_oid);
-		hex_sha1[GIT_OID_HEXSZ] = '\0';
+		hex_sha1[p->oid_hexsize] = '\0';
 		printf("found lo=%d %s\n", lo, hex_sha1);
 	}
 #endif
@@ -1588,10 +1623,10 @@ int git_pack_entry_find(
 
 	GIT_ASSERT_ARG(p);
 
-	if (len == GIT_OID_HEXSZ && p->num_bad_objects) {
+	if (len == p->oid_hexsize && p->num_bad_objects) {
 		unsigned i;
 		for (i = 0; i < p->num_bad_objects; i++)
-			if (git_oid__cmp(short_oid, &p->bad_object_sha1[i]) == 0)
+			if (git_oid__cmp(short_oid, &p->bad_object_ids[i]) == 0)
 				return packfile_error("bad object found in packfile");
 	}
 
@@ -1624,6 +1659,6 @@ int git_pack_entry_find(
 	e->offset = offset;
 	e->p = p;
 
-	git_oid_cpy(&e->sha1, &found_oid);
+	git_oid_cpy(&e->id, &found_oid);
 	return 0;
 }