rugged 1.5.0.1 → 1.7.1

data/vendor/libgit2/src/libgit2/midx.c

@@ -114,23 +114,16 @@ static int midx_parse_oid_lookup(
 		const unsigned char *data,
 		struct git_midx_chunk *chunk_oid_lookup)
 {
-	uint32_t i;
-	unsigned char *oid, *prev_oid, zero_oid[GIT_OID_RAWSZ] = {0};
+	size_t oid_size = git_oid_size(idx->oid_type);
 
 	if (chunk_oid_lookup->offset == 0)
 		return midx_error("missing OID Lookup chunk");
 	if (chunk_oid_lookup->length == 0)
 		return midx_error("empty OID Lookup chunk");
-	if (chunk_oid_lookup->length != idx->num_objects * GIT_OID_RAWSZ)
+	if (chunk_oid_lookup->length != idx->num_objects * oid_size)
 		return midx_error("OID Lookup chunk has wrong length");
 
-	idx->oid_lookup = oid = (unsigned char *)(data + chunk_oid_lookup->offset);
-	prev_oid = zero_oid;
-	for (i = 0; i < idx->num_objects; ++i, oid += GIT_OID_RAWSZ) {
-		if (git_oid_raw_cmp(prev_oid, oid) >= 0)
-			return midx_error("OID Lookup index is non-monotonic");
-		prev_oid = oid;
-	}
+	idx->oid_lookup = (unsigned char *)(data + chunk_oid_lookup->offset);
 
 	return 0;
 }
@@ -178,17 +171,20 @@ int git_midx_parse(
 	struct git_midx_chunk *last_chunk;
 	uint32_t i;
 	off64_t last_chunk_offset, chunk_offset, trailer_offset;
-	size_t checksum_size;
+	size_t checksum_size, oid_size;
 	int error;
 	struct git_midx_chunk chunk_packfile_names = {0},
 					 chunk_oid_fanout = {0},
 					 chunk_oid_lookup = {0},
 					 chunk_object_offsets = {0},
-					 chunk_object_large_offsets = {0};
+					 chunk_object_large_offsets = {0},
+					 chunk_unknown = {0};
 
 	GIT_ASSERT_ARG(idx);
 
-	if (size < sizeof(struct git_midx_header) + GIT_OID_RAWSZ)
+	oid_size = git_oid_size(idx->oid_type);
+
+	if (size < sizeof(struct git_midx_header) + oid_size)
 		return midx_error("multi-pack index is too short");
 
 	hdr = ((struct git_midx_header *)data);
@@ -209,7 +205,7 @@ int git_midx_parse(
 			sizeof(struct git_midx_header) +
 			(1 + hdr->chunks) * 12;
 
-	checksum_size = GIT_HASH_SHA1_SIZE;
+	checksum_size = oid_size;
 	trailer_offset = size - checksum_size;
 
 	if (trailer_offset < last_chunk_offset)
@@ -261,7 +257,9 @@ int git_midx_parse(
 			break;
 
 		default:
-			return midx_error("unrecognized chunk ID");
+			chunk_unknown.offset = last_chunk_offset;
+			last_chunk = &chunk_unknown;
+			break;
 		}
 	}
 	last_chunk->length = (size_t)(trailer_offset - last_chunk_offset);
@@ -287,8 +285,9 @@ int git_midx_parse(
 }
 
 int git_midx_open(
-		git_midx_file **idx_out,
-		const char *path)
+	git_midx_file **idx_out,
+	const char *path,
+	git_oid_t oid_type)
 {
 	git_midx_file *idx;
 	git_file fd = -1;
@@ -296,6 +295,8 @@ int git_midx_open(
 	struct stat st;
 	int error;
 
+	GIT_ASSERT_ARG(idx_out && path && oid_type);
+
 	/* TODO: properly open the file without access time using O_NOATIME */
 	fd = git_futils_open_ro(path);
 	if (fd < 0)
@@ -317,6 +318,8 @@ int git_midx_open(
 	idx = git__calloc(1, sizeof(git_midx_file));
 	GIT_ERROR_CHECK_ALLOC(idx);
 
+	idx->oid_type = oid_type;
+
 	error = git_str_sets(&idx->filename, path);
 	if (error < 0)
 		return error;
@@ -344,7 +347,7 @@ bool git_midx_needs_refresh(
 	git_file fd = -1;
 	struct stat st;
 	ssize_t bytes_read;
-	unsigned char checksum[GIT_HASH_SHA1_SIZE];
+	unsigned char checksum[GIT_HASH_MAX_SIZE];
 	size_t checksum_size;
 
 	/* TODO: properly open the file without access time using O_NOATIME */
@@ -364,8 +367,8 @@ bool git_midx_needs_refresh(
 		return true;
 	}
 
-	checksum_size = GIT_HASH_SHA1_SIZE;
-	bytes_read = p_pread(fd, checksum, checksum_size, st.st_size - GIT_OID_RAWSZ);
+	checksum_size = git_oid_size(idx->oid_type);
+	bytes_read = p_pread(fd, checksum, checksum_size, st.st_size - checksum_size);
 	p_close(fd);
 
 	if (bytes_read != (ssize_t)checksum_size)
@@ -381,7 +384,7 @@ int git_midx_entry_find(
 		size_t len)
 {
 	int pos, found = 0;
-	size_t pack_index;
+	size_t pack_index, oid_size, oid_hexsize;
 	uint32_t hi, lo;
 	unsigned char *current = NULL;
 	const unsigned char *object_offset;
@@ -389,30 +392,33 @@ int git_midx_entry_find(
 
 	GIT_ASSERT_ARG(idx);
 
+	oid_size = git_oid_size(idx->oid_type);
+	oid_hexsize = git_oid_hexsize(idx->oid_type);
+
 	hi = ntohl(idx->oid_fanout[(int)short_oid->id[0]]);
 	lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(idx->oid_fanout[(int)short_oid->id[0] - 1]));
 
-	pos = git_pack__lookup_sha1(idx->oid_lookup, GIT_OID_RAWSZ, lo, hi, short_oid->id);
+	pos = git_pack__lookup_id(idx->oid_lookup, oid_size, lo, hi, short_oid->id, idx->oid_type);
 
 	if (pos >= 0) {
 		/* An object matching exactly the oid was found */
 		found = 1;
-		current = idx->oid_lookup + (pos * GIT_OID_RAWSZ);
+		current = idx->oid_lookup + (pos * oid_size);
 	} else {
 		/* No object was found */
 		/* pos refers to the object with the "closest" oid to short_oid */
 		pos = -1 - pos;
 		if (pos < (int)idx->num_objects) {
-			current = idx->oid_lookup + (pos * GIT_OID_RAWSZ);
+			current = idx->oid_lookup + (pos * oid_size);
 
 			if (!git_oid_raw_ncmp(short_oid->id, current, len))
 				found = 1;
 		}
 	}
 
-	if (found && len != GIT_OID_HEXSZ && pos + 1 < (int)idx->num_objects) {
+	if (found && len != oid_hexsize && pos + 1 < (int)idx->num_objects) {
 		/* Check for ambiguousity */
-		const unsigned char *next = current + GIT_OID_RAWSZ;
+		const unsigned char *next = current + oid_size;
 
 		if (!git_oid_raw_ncmp(short_oid->id, next, len))
 			found = 2;
@@ -443,7 +449,7 @@ int git_midx_entry_find(
 		return midx_error("invalid index into the packfile names table");
 	e->pack_index = pack_index;
 	e->offset = offset;
-	git_oid_fromraw(&e->sha1, current);
+	git_oid__fromraw(&e->sha1, current, idx->oid_type);
 	return 0;
 }
 
@@ -453,13 +459,15 @@ int git_midx_foreach_entry(
 		void *data)
 {
 	git_oid oid;
-	size_t i;
+	size_t oid_size, i;
 	int error;
 
 	GIT_ASSERT_ARG(idx);
 
+	oid_size = git_oid_size(idx->oid_type);
+
 	for (i = 0; i < idx->num_objects; ++i) {
-		if ((error = git_oid_fromraw(&oid, &idx->oid_lookup[i * GIT_OID_RAWSZ])) < 0)
+		if ((error = git_oid__fromraw(&oid, &idx->oid_lookup[i * oid_size], idx->oid_type)) < 0)
 			return error;
 
 		if ((error = cb(&oid, data)) != 0)
@@ -501,9 +509,21 @@ static int packfile__cmp(const void *a_, const void *b_)
 
 int git_midx_writer_new(
 		git_midx_writer **out,
-		const char *pack_dir)
+		const char *pack_dir
+#ifdef GIT_EXPERIMENTAL_SHA256
+		, git_oid_t oid_type
+#endif
+		)
 {
-	git_midx_writer *w = git__calloc(1, sizeof(git_midx_writer));
+	git_midx_writer *w;
+
+#ifndef GIT_EXPERIMENTAL_SHA256
+	git_oid_t oid_type = GIT_OID_SHA1;
+#endif
+
+	GIT_ASSERT_ARG(out && pack_dir && oid_type);
+
+	w = git__calloc(1, sizeof(git_midx_writer));
 	GIT_ERROR_CHECK_ALLOC(w);
 
 	if (git_str_sets(&w->pack_dir, pack_dir) < 0) {
@@ -518,6 +538,8 @@ int git_midx_writer_new(
 		return -1;
 	}
 
+	w->oid_type = oid_type;
+
 	*out = w;
 	return 0;
 }
@@ -549,7 +571,8 @@ int git_midx_writer_add(
 	if (error < 0)
 		return error;
 
-	error = git_mwindow_get_pack(&p, git_str_cstr(&idx_path_buf));
+	/* TODO: SHA256 */
+	error = git_mwindow_get_pack(&p, git_str_cstr(&idx_path_buf), 0);
 	git_str_dispose(&idx_path_buf);
 	if (error < 0)
 		return error;
@@ -661,12 +684,13 @@ static int midx_write(
 		oid_lookup = GIT_STR_INIT,
 		object_offsets = GIT_STR_INIT,
 		object_large_offsets = GIT_STR_INIT;
-	unsigned char checksum[GIT_HASH_SHA1_SIZE];
-	size_t checksum_size;
+	unsigned char checksum[GIT_HASH_MAX_SIZE];
+	size_t checksum_size, oid_size;
 	git_midx_entry *entry;
 	object_entry_array_t object_entries_array = GIT_ARRAY_INIT;
 	git_vector object_entries = GIT_VECTOR_INIT;
 	git_hash_ctx ctx;
+	git_hash_algorithm_t checksum_type;
 	struct midx_write_hash_context hash_cb_data = {0};
 
 	hdr.signature = htonl(MIDX_SIGNATURE);
@@ -678,10 +702,14 @@ static int midx_write(
 	hash_cb_data.cb_data = cb_data;
 	hash_cb_data.ctx = &ctx;
 
-	checksum_size = GIT_HASH_SHA1_SIZE;
-	error = git_hash_ctx_init(&ctx, GIT_HASH_ALGORITHM_SHA1);
-	if (error < 0)
+	oid_size = git_oid_size(w->oid_type);
+
+	GIT_ASSERT((checksum_type = git_oid_algorithm(w->oid_type)));
+	checksum_size = git_hash_size(checksum_type);
+
+	if ((error = git_hash_ctx_init(&ctx, checksum_type)) < 0)
 		return error;
+
 	cb_data = &hash_cb_data;
 	write_cb = midx_write_hash;
 
@@ -748,7 +776,9 @@ static int midx_write(
 
 	/* Fill the OID Lookup table. */
 	git_vector_foreach (&object_entries, i, entry) {
-		error = git_str_put(&oid_lookup, (char *)&entry->sha1.id, GIT_OID_RAWSZ);
+		error = git_str_put(&oid_lookup,
+			(char *)&entry->sha1.id, oid_size);
+
 		if (error < 0)
 			goto cleanup;
 	}

data/vendor/libgit2/src/libgit2/midx.h

@@ -51,8 +51,14 @@ typedef struct git_midx_file {
 	/* The number of entries in the Object Large Offsets table. Each entry has an 8-byte with an offset */
 	size_t num_object_large_offsets;
 
-	/* The trailer of the file. Contains the SHA1-checksum of the whole file. */
-	unsigned char checksum[GIT_HASH_SHA1_SIZE];
+	/*
+	 * The trailer of the file. Contains the checksum of the whole
+	 * file, in the repository's object format hash.
+	 */
+	unsigned char checksum[GIT_HASH_MAX_SIZE];
+
+	/* The type of object IDs in the midx. */
+	git_oid_t oid_type;
 
 	/* something like ".git/objects/pack/multi-pack-index". */
 	git_str filename;
@@ -82,11 +88,15 @@ struct git_midx_writer {
 
 	/* The list of `git_pack_file`s. */
 	git_vector packs;
+
+	/* The object ID type of the writer. */
+	git_oid_t oid_type;
 };
 
 int git_midx_open(
 		git_midx_file **idx_out,
-		const char *path);
+		const char *path,
+		git_oid_t oid_type);
 bool git_midx_needs_refresh(
 		const git_midx_file *idx,
 		const char *path);

data/vendor/libgit2/src/libgit2/mwindow.c

@@ -61,7 +61,10 @@ int git_mwindow_global_init(void)
 	return git_runtime_shutdown_register(git_mwindow_global_shutdown);
 }
 
-int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
+int git_mwindow_get_pack(
+	struct git_pack_file **out,
+	const char *path,
+	git_oid_t oid_type)
 {
 	struct git_pack_file *pack;
 	char *packname;
@@ -86,7 +89,7 @@ int git_mwindow_get_pack(struct git_pack_file **out, const char *path)
 	}
 
 	/* If we didn't find it, we need to create it */
-	if ((error = git_packfile_alloc(&pack, path)) < 0) {
+	if ((error = git_packfile_alloc(&pack, path, oid_type)) < 0) {
 		git_mutex_unlock(&git__mwindow_mutex);
 		return error;
 	}

data/vendor/libgit2/src/libgit2/mwindow.h

@@ -48,7 +48,10 @@ void git_mwindow_close(git_mwindow **w_cursor);
 extern int git_mwindow_global_init(void);
 
 struct git_pack_file; /* just declaration to avoid cyclical includes */
-int git_mwindow_get_pack(struct git_pack_file **out, const char *path);
+int git_mwindow_get_pack(
+	struct git_pack_file **out,
+	const char *path,
+	git_oid_t oid_type);
 int git_mwindow_put_pack(struct git_pack_file *pack);
 
 #endif

data/vendor/libgit2/src/libgit2/notes.c

@@ -460,7 +460,7 @@ int git_note_commit_read(
 {
 	int error;
 	git_tree *tree = NULL;
-	char target[GIT_OID_HEXSZ + 1];
+	char target[GIT_OID_MAX_HEXSIZE + 1];
 
 	git_oid_tostr(target, sizeof(target), oid);
 
@@ -507,7 +507,7 @@ int git_note_commit_create(
 {
 	int error;
 	git_tree *tree = NULL;
-	char target[GIT_OID_HEXSZ + 1];
+	char target[GIT_OID_MAX_HEXSIZE + 1];
 
 	git_oid_tostr(target, sizeof(target), oid);
 
@@ -578,7 +578,7 @@ int git_note_commit_remove(
 {
 	int error;
 	git_tree *tree = NULL;
-	char target[GIT_OID_HEXSZ + 1];
+	char target[GIT_OID_MAX_HEXSIZE + 1];
 
 	git_oid_tostr(target, sizeof(target), oid);
 
@@ -665,8 +665,9 @@ void git_note_free(git_note *note)
 }
 
 static int process_entry_path(
-	const char *entry_path,
-	git_oid *annotated_object_id)
+	git_oid *annotated_object_id,
+	git_note_iterator *it,
+	const char *entry_path)
 {
 	int error = 0;
 	size_t i = 0, j = 0, len;
@@ -698,12 +699,12 @@ static int process_entry_path(
 	buf.ptr[j] = '\0';
 	buf.size = j;
 
-	if (j != GIT_OID_HEXSZ) {
+	if (j != git_oid_hexsize(it->repo->oid_type)) {
 		/* This is not a note entry */
 		goto cleanup;
 	}
 
-	error = git_oid_fromstr(annotated_object_id, buf.ptr);
+	error = git_oid__fromstr(annotated_object_id, buf.ptr, it->repo->oid_type);
 
 cleanup:
 	git_str_dispose(&buf);
@@ -799,7 +800,7 @@ int git_note_next(
 
 	git_oid_cpy(note_id, &item->id);
 
-	if ((error = process_entry_path(item->path, annotated_id)) < 0)
+	if ((error = process_entry_path(annotated_id, it, item->path)) < 0)
 		return error;
 
 	if ((error = git_iterator_advance(NULL, it)) < 0 && error != GIT_ITEROVER)

data/vendor/libgit2/src/libgit2/object.c

@@ -21,15 +21,14 @@
 
 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);
 size_t git_object__size(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);
+	int  (*parse)(void *self, git_odb_object *obj, git_oid_t oid_type);
+	int  (*parse_raw)(void *self, const char *data, size_t size, git_oid_t oid_type);
 	void (*free)(void *self);
 } git_object_def;
 
@@ -61,7 +60,8 @@ int git_object__from_raw(
 	git_object **object_out,
 	const char *data,
 	size_t size,
-	git_object_t type)
+	git_object_t object_type,
+	git_oid_t oid_type)
 {
 	git_object_def *def;
 	git_object *object;
@@ -72,12 +72,15 @@ int git_object__from_raw(
 	*object_out = NULL;
 
 	/* Validate type match */
-	if (type != GIT_OBJECT_BLOB && type != GIT_OBJECT_TREE && type != GIT_OBJECT_COMMIT && type != GIT_OBJECT_TAG) {
+	if (object_type != GIT_OBJECT_BLOB &&
+	    object_type != GIT_OBJECT_TREE &&
+	    object_type != GIT_OBJECT_COMMIT &&
+	    object_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) {
+	if ((object_size = git_object__size(object_type)) == 0) {
 		git_error_set(GIT_ERROR_INVALID, "the requested type is invalid");
 		return GIT_ENOTFOUND;
 	}
@@ -86,15 +89,15 @@ int git_object__from_raw(
 	object = git__calloc(1, object_size);
 	GIT_ERROR_CHECK_ALLOC(object);
 	object->cached.flags = GIT_CACHE_STORE_PARSED;
-	object->cached.type = type;
-	if ((error = git_odb_hash(&object->cached.oid, data, size, type)) < 0)
+	object->cached.type = object_type;
+	if ((error = git_odb__hash(&object->cached.oid, data, size, object_type, oid_type)) < 0)
 		return error;
 
 	/* Parse raw object data */
-	def = &git_objects_table[type];
+	def = &git_objects_table[object_type];
 	GIT_ASSERT(def->free && def->parse_raw);
 
-	if ((error = def->parse_raw(object, data, size)) < 0) {
+	if ((error = def->parse_raw(object, data, size, oid_type)) < 0) {
 		def->free(object);
 		return error;
 	}
@@ -105,15 +108,13 @@ int git_object__from_raw(
 	return 0;
 }
 
-int git_object__from_odb_object(
+int git_object__init_from_odb_object(
 	git_object **object_out,
 	git_repository *repo,
 	git_odb_object *odb_obj,
 	git_object_t type)
 {
-	int error;
 	size_t object_size;
-	git_object_def *def;
 	git_object *object = NULL;
 
 	GIT_ASSERT_ARG(object_out);
@@ -140,11 +141,28 @@ int git_object__from_odb_object(
 	object->cached.size = odb_obj->cached.size;
 	object->repo = repo;
 
+	*object_out = object;
+	return 0;
+}
+
+int git_object__from_odb_object(
+	git_object **object_out,
+	git_repository *repo,
+	git_odb_object *odb_obj,
+	git_object_t type)
+{
+	int error;
+	git_object_def *def;
+	git_object *object = NULL;
+
+	if ((error = git_object__init_from_odb_object(&object, repo, odb_obj, type)) < 0)
+		return error;
+
 	/* Parse raw object data */
 	def = &git_objects_table[odb_obj->cached.type];
 	GIT_ASSERT(def->free && def->parse);
 
-	if ((error = def->parse(object, odb_obj)) < 0) {
+	if ((error = def->parse(object, odb_obj, repo->oid_type)) < 0) {
 		/*
 		 * parse returns EINVALID on invalid data; downgrade
 		 * that to a normal -1 error code.
@@ -178,6 +196,7 @@ int git_object_lookup_prefix(
 	git_object *object = NULL;
 	git_odb *odb = NULL;
 	git_odb_object *odb_obj = NULL;
+	size_t oid_hexsize;
 	int error = 0;
 
 	GIT_ASSERT_ARG(repo);
@@ -193,10 +212,12 @@ int git_object_lookup_prefix(
 	if (error < 0)
 		return error;
 
-	if (len > GIT_OID_HEXSZ)
-		len = GIT_OID_HEXSZ;
+	oid_hexsize = git_oid_hexsize(repo->oid_type);
+
+	if (len > oid_hexsize)
+		len = oid_hexsize;
 
-	if (len == GIT_OID_HEXSZ) {
+	if (len == oid_hexsize) {
 		git_cached_obj *cached = NULL;
 
 		/* We want to match the full id : we can first look up in the cache,
@@ -230,11 +251,12 @@ int git_object_lookup_prefix(
 			error = git_odb_read(&odb_obj, odb, id);
 		}
 	} else {
-		git_oid short_oid = {{ 0 }};
+		git_oid short_oid;
 
+		git_oid_clear(&short_oid, repo->oid_type);
 		git_oid__cpy_prefix(&short_oid, id, len);
 
-		/* If len < GIT_OID_HEXSZ (a strict short oid was given), we have
+		/* If len < GIT_OID_SHA1_HEXSIZE (a strict short oid was given), we have
 		 * 2 options :
 		 * - We always search in the cache first. If we find that short oid is
 		 *	ambiguous, we can stop. But in all the other cases, we must then
@@ -259,7 +281,8 @@ int git_object_lookup_prefix(
 }
 
 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);
+	return git_object_lookup_prefix(object_out,
+		repo, id, git_oid_hexsize(repo->oid_type), type);
 }
 
 void git_object_free(git_object *object)
@@ -358,12 +381,11 @@ static int dereference_object(git_object **dereferenced, git_object *obj)
 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];
+	char hex_oid[GIT_OID_MAX_HEXSIZE + 1];
 
 	type_name = git_object_type2string(type);
 
-	git_oid_fmt(hex_oid, oid);
-	hex_oid[GIT_OID_HEXSZ] = '\0';
+	git_oid_nfmt(hex_oid, GIT_OID_MAX_HEXSIZE + 1, oid);
 
 	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);
@@ -501,22 +523,31 @@ cleanup:
 static int git_object__short_id(git_str *out, const git_object *obj)
 {
 	git_repository *repo;
-	int len = GIT_ABBREV_DEFAULT, error;
-	git_oid id = {{0}};
+	git_oid id;
 	git_odb *odb;
+	size_t oid_hexsize;
+	int len = GIT_ABBREV_DEFAULT, error;
 
 	GIT_ASSERT_ARG(out);
 	GIT_ASSERT_ARG(obj);
 
 	repo = git_object_owner(obj);
 
+	git_oid_clear(&id, repo->oid_type);
+	oid_hexsize = git_oid_hexsize(repo->oid_type);
+
 	if ((error = git_repository__configmap_lookup(&len, repo, GIT_CONFIGMAP_ABBREV)) < 0)
 		return error;
 
+	if (len < 0 || (size_t)len > oid_hexsize) {
+		git_error_set(GIT_ERROR_CONFIG, "invalid oid abbreviation setting: '%d'", len);
+		return -1;
+	}
+
 	if ((error = git_repository_odb(&odb, repo)) < 0)
 		return error;
 
-	while (len < GIT_OID_HEXSZ) {
+	while ((size_t)len < oid_hexsize) {
 		/* set up short oid */
 		memcpy(&id.id, &obj->cached.oid.id, (len + 1) / 2);
 		if (len & 1)
@@ -573,21 +604,29 @@ int git_object_rawcontent_is_valid(
 	int *valid,
 	const char *buf,
 	size_t len,
-	git_object_t type)
+	git_object_t object_type
+#ifdef GIT_EXPERIMENTAL_SHA256
+	, git_oid_t oid_type
+#endif
+	)
 {
 	git_object *obj = NULL;
 	int error;
 
+#ifndef GIT_EXPERIMENTAL_SHA256
+	git_oid_t oid_type = GIT_OID_SHA1;
+#endif
+
 	GIT_ASSERT_ARG(valid);
 	GIT_ASSERT_ARG(buf);
 
 	/* Blobs are always valid; don't bother parsing. */
-	if (type == GIT_OBJECT_BLOB) {
+	if (object_type == GIT_OBJECT_BLOB) {
 		*valid = 1;
 		return 0;
 	}
 
-	error = git_object__from_raw(&obj, buf, len, type);
+	error = git_object__from_raw(&obj, buf, len, object_type, oid_type);
 	git_object_free(obj);
 
 	if (error == 0) {
@@ -600,3 +639,53 @@ int git_object_rawcontent_is_valid(
 
 	return error;
 }
+
+int git_object__parse_oid_header(
+	git_oid *oid,
+	const char **buffer_out,
+	const char *buffer_end,
+	const char *header,
+	git_oid_t oid_type)
+{
+	const size_t sha_len = git_oid_hexsize(oid_type);
+	const size_t header_len = strlen(header);
+
+	const char *buffer = *buffer_out;
+
+	if (buffer + (header_len + sha_len + 1) > buffer_end)
+		return -1;
+
+	if (memcmp(buffer, header, header_len) != 0)
+		return -1;
+
+	if (buffer[header_len + sha_len] != '\n')
+		return -1;
+
+	if (git_oid__fromstr(oid, buffer + header_len, oid_type) < 0)
+		return -1;
+
+	*buffer_out = buffer + (header_len + sha_len + 1);
+
+	return 0;
+}
+
+int git_object__write_oid_header(
+	git_str *buf,
+	const char *header,
+	const git_oid *oid)
+{
+	size_t hex_size = git_oid_hexsize(git_oid_type(oid));
+	char hex_oid[GIT_OID_MAX_HEXSIZE];
+
+	if (!hex_size) {
+		git_error_set(GIT_ERROR_INVALID, "unknown type");
+		return -1;
+	}
+
+	git_oid_fmt(hex_oid, oid);
+	git_str_puts(buf, header);
+	git_str_put(buf, hex_oid, hex_size);
+	git_str_putc(buf, '\n');
+
+	return git_str_oom(buf) ? -1 : 0;
+}