rugged 1.3.2 → 1.6.2

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

@@ -8,6 +8,7 @@
 #include "commit_graph.h"
 
 #include "array.h"
+#include "buf.h"
 #include "filebuf.h"
 #include "futils.h"
 #include "hash.h"
@@ -137,19 +138,19 @@ static int commit_graph_parse_oid_lookup(
 		struct git_commit_graph_chunk *chunk_oid_lookup)
 {
 	uint32_t i;
-	git_oid *oid, *prev_oid, zero_oid = {{0}};
+	unsigned char *oid, *prev_oid, zero_oid[GIT_OID_SHA1_SIZE] = {0};
 
 	if (chunk_oid_lookup->offset == 0)
 		return commit_graph_error("missing OID Lookup chunk");
 	if (chunk_oid_lookup->length == 0)
 		return commit_graph_error("empty OID Lookup chunk");
-	if (chunk_oid_lookup->length != file->num_commits * GIT_OID_RAWSZ)
+	if (chunk_oid_lookup->length != file->num_commits * GIT_OID_SHA1_SIZE)
 		return commit_graph_error("OID Lookup chunk has wrong length");
 
-	file->oid_lookup = oid = (git_oid *)(data + chunk_oid_lookup->offset);
-	prev_oid = &zero_oid;
-	for (i = 0; i < file->num_commits; ++i, ++oid) {
-		if (git_oid_cmp(prev_oid, oid) >= 0)
+	file->oid_lookup = oid = (unsigned char *)(data + chunk_oid_lookup->offset);
+	prev_oid = zero_oid;
+	for (i = 0; i < file->num_commits; ++i, oid += GIT_OID_SHA1_SIZE) {
+		if (git_oid_raw_cmp(prev_oid, oid, GIT_OID_SHA1_SIZE) >= 0)
 			return commit_graph_error("OID Lookup index is non-monotonic");
 		prev_oid = oid;
 	}
@@ -166,7 +167,7 @@ static int commit_graph_parse_commit_data(
 		return commit_graph_error("missing Commit Data chunk");
 	if (chunk_commit_data->length == 0)
 		return commit_graph_error("empty Commit Data chunk");
-	if (chunk_commit_data->length != file->num_commits * (GIT_OID_RAWSZ + 16))
+	if (chunk_commit_data->length != file->num_commits * (GIT_OID_SHA1_SIZE + 16))
 		return commit_graph_error("Commit Data chunk has wrong length");
 
 	file->commit_data = data + chunk_commit_data->offset;
@@ -199,8 +200,8 @@ int git_commit_graph_file_parse(
 	const unsigned char *chunk_hdr;
 	struct git_commit_graph_chunk *last_chunk;
 	uint32_t i;
-	off64_t last_chunk_offset, chunk_offset, trailer_offset;
-	git_oid cgraph_checksum = {{0}};
+	uint64_t last_chunk_offset, chunk_offset, trailer_offset;
+	size_t checksum_size;
 	int error;
 	struct git_commit_graph_chunk chunk_oid_fanout = {0}, chunk_oid_lookup = {0},
 				      chunk_commit_data = {0}, chunk_extra_edge_list = {0},
@@ -208,7 +209,7 @@ int git_commit_graph_file_parse(
 
 	GIT_ASSERT_ARG(file);
 
-	if (size < sizeof(struct git_commit_graph_header) + GIT_OID_RAWSZ)
+	if (size < sizeof(struct git_commit_graph_header) + GIT_OID_SHA1_SIZE)
 		return commit_graph_error("commit-graph is too short");
 
 	hdr = ((struct git_commit_graph_header *)data);
@@ -225,21 +226,18 @@ int git_commit_graph_file_parse(
 	 * headers, and a special zero chunk.
 	 */
 	last_chunk_offset = sizeof(struct git_commit_graph_header) + (1 + hdr->chunks) * 12;
-	trailer_offset = size - GIT_OID_RAWSZ;
+	trailer_offset = size - GIT_OID_SHA1_SIZE;
+	checksum_size = GIT_HASH_SHA1_SIZE;
+
 	if (trailer_offset < last_chunk_offset)
 		return commit_graph_error("wrong commit-graph size");
-	git_oid_cpy(&file->checksum, (git_oid *)(data + trailer_offset));
-
-	if (git_hash_buf(&cgraph_checksum, data, (size_t)trailer_offset) < 0)
-		return commit_graph_error("could not calculate signature");
-	if (!git_oid_equal(&cgraph_checksum, &file->checksum))
-		return commit_graph_error("index signature mismatch");
+	memcpy(file->checksum, (data + trailer_offset), checksum_size);
 
 	chunk_hdr = data + sizeof(struct git_commit_graph_header);
 	last_chunk = NULL;
 	for (i = 0; i < hdr->chunks; ++i, chunk_hdr += 12) {
-		chunk_offset = ((off64_t)ntohl(*((uint32_t *)(chunk_hdr + 4)))) << 32
-				| ((off64_t)ntohl(*((uint32_t *)(chunk_hdr + 8))));
+		chunk_offset = ((uint64_t)ntohl(*((uint32_t *)(chunk_hdr + 4)))) << 32
+				| ((uint64_t)ntohl(*((uint32_t *)(chunk_hdr + 8))));
 		if (chunk_offset < last_chunk_offset)
 			return commit_graph_error("chunks are non-monotonic");
 		if (chunk_offset >= trailer_offset)
@@ -308,12 +306,12 @@ int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir,
 	cgraph = git__calloc(1, sizeof(git_commit_graph));
 	GIT_ERROR_CHECK_ALLOC(cgraph);
 
-	error = git_buf_joinpath(&cgraph->filename, objects_dir, "info/commit-graph");
+	error = git_str_joinpath(&cgraph->filename, objects_dir, "info/commit-graph");
 	if (error < 0)
 		goto error;
 
 	if (open_file) {
-		error = git_commit_graph_file_open(&cgraph->file, git_buf_cstr(&cgraph->filename));
+		error = git_commit_graph_file_open(&cgraph->file, git_str_cstr(&cgraph->filename));
 		if (error < 0)
 			goto error;
 		cgraph->checked = 1;
@@ -327,9 +325,29 @@ error:
 	return error;
 }
 
+int git_commit_graph_validate(git_commit_graph *cgraph) {
+	unsigned char checksum[GIT_HASH_SHA1_SIZE];
+	size_t checksum_size = GIT_HASH_SHA1_SIZE;
+	size_t trailer_offset = cgraph->file->graph_map.len - checksum_size;
+
+	if (cgraph->file->graph_map.len < checksum_size)
+		return commit_graph_error("map length too small");
+
+	if (git_hash_buf(checksum, cgraph->file->graph_map.data, trailer_offset, GIT_HASH_ALGORITHM_SHA1) < 0)
+		return commit_graph_error("could not calculate signature");
+	if (memcmp(checksum, cgraph->file->checksum, checksum_size) != 0)
+		return commit_graph_error("index signature mismatch");
+
+	return 0;
+}
+
 int git_commit_graph_open(git_commit_graph **cgraph_out, const char *objects_dir)
 {
-	return git_commit_graph_new(cgraph_out, objects_dir, true);
+	int error = git_commit_graph_new(cgraph_out, objects_dir, true);
+	if (!error) {
+		return git_commit_graph_validate(*cgraph_out);
+	}
+	return error;
 }
 
 int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *path)
@@ -387,7 +405,7 @@ int git_commit_graph_get_file(git_commit_graph_file **file_out, git_commit_graph
 		cgraph->checked = 1;
 
 		/* Best effort */
-		error = git_commit_graph_file_open(&result, git_buf_cstr(&cgraph->filename));
+		error = git_commit_graph_file_open(&result, git_str_cstr(&cgraph->filename));
 
 		if (error < 0)
 			return error;
@@ -407,7 +425,7 @@ void git_commit_graph_refresh(git_commit_graph *cgraph)
 		return;
 
 	if (cgraph->file
-	    && git_commit_graph_file_needs_refresh(cgraph->file, git_buf_cstr(&cgraph->filename))) {
+	    && git_commit_graph_file_needs_refresh(cgraph->file, git_str_cstr(&cgraph->filename))) {
 		/* We just free the commit graph. The next time it is requested, it will be
 		 * re-loaded. */
 		git_commit_graph_file_free(cgraph->file);
@@ -432,15 +450,15 @@ static int git_commit_graph_entry_get_byindex(
 		return GIT_ENOTFOUND;
 	}
 
-	commit_data = file->commit_data + pos * (GIT_OID_RAWSZ + 4 * sizeof(uint32_t));
-	git_oid_cpy(&e->tree_oid, (const git_oid *)commit_data);
-	e->parent_indices[0] = ntohl(*((uint32_t *)(commit_data + GIT_OID_RAWSZ)));
+	commit_data = file->commit_data + pos * (GIT_OID_SHA1_SIZE + 4 * sizeof(uint32_t));
+	git_oid__fromraw(&e->tree_oid, commit_data, GIT_OID_SHA1);
+	e->parent_indices[0] = ntohl(*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE)));
 	e->parent_indices[1] = ntohl(
-			*((uint32_t *)(commit_data + GIT_OID_RAWSZ + sizeof(uint32_t))));
+			*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE + sizeof(uint32_t))));
 	e->parent_count = (e->parent_indices[0] != GIT_COMMIT_GRAPH_MISSING_PARENT)
 			+ (e->parent_indices[1] != GIT_COMMIT_GRAPH_MISSING_PARENT);
-	e->generation = ntohl(*((uint32_t *)(commit_data + GIT_OID_RAWSZ + 2 * sizeof(uint32_t))));
-	e->commit_time = ntohl(*((uint32_t *)(commit_data + GIT_OID_RAWSZ + 3 * sizeof(uint32_t))));
+	e->generation = ntohl(*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE + 2 * sizeof(uint32_t))));
+	e->commit_time = ntohl(*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE + 3 * sizeof(uint32_t))));
 
 	e->commit_time |= (e->generation & UINT64_C(0x3)) << UINT64_C(32);
 	e->generation >>= 2u;
@@ -466,7 +484,8 @@ static int git_commit_graph_entry_get_byindex(
 			e->parent_count++;
 		}
 	}
-	git_oid_cpy(&e->sha1, &file->oid_lookup[pos]);
+
+	git_oid__fromraw(&e->sha1, &file->oid_lookup[pos * GIT_OID_SHA1_SIZE], GIT_OID_SHA1);
 	return 0;
 }
 
@@ -475,7 +494,8 @@ bool git_commit_graph_file_needs_refresh(const git_commit_graph_file *file, cons
 	git_file fd = -1;
 	struct stat st;
 	ssize_t bytes_read;
-	git_oid cgraph_checksum = {{0}};
+	unsigned char checksum[GIT_HASH_SHA1_SIZE];
+	size_t checksum_size = GIT_HASH_SHA1_SIZE;
 
 	/* TODO: properly open the file without access time using O_NOATIME */
 	fd = git_futils_open_ro(path);
@@ -493,12 +513,12 @@ bool git_commit_graph_file_needs_refresh(const git_commit_graph_file *file, cons
 		return true;
 	}
 
-	bytes_read = p_pread(fd, cgraph_checksum.id, GIT_OID_RAWSZ, st.st_size - GIT_OID_RAWSZ);
+	bytes_read = p_pread(fd, checksum, checksum_size, st.st_size - checksum_size);
 	p_close(fd);
-	if (bytes_read != GIT_OID_RAWSZ)
+	if (bytes_read != (ssize_t)checksum_size)
 		return true;
 
-	return !git_oid_equal(&cgraph_checksum, &file->checksum);
+	return (memcmp(checksum, file->checksum, checksum_size) != 0);
 }
 
 int git_commit_graph_entry_find(
@@ -509,7 +529,7 @@ int git_commit_graph_entry_find(
 {
 	int pos, found = 0;
 	uint32_t hi, lo;
-	const git_oid *current = NULL;
+	const unsigned char *current = NULL;
 
 	GIT_ASSERT_ARG(e);
 	GIT_ASSERT_ARG(file);
@@ -518,31 +538,30 @@ int git_commit_graph_entry_find(
 	hi = ntohl(file->oid_fanout[(int)short_oid->id[0]]);
 	lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(file->oid_fanout[(int)short_oid->id[0] - 1]));
 
-	pos = git_pack__lookup_sha1(file->oid_lookup, GIT_OID_RAWSZ, lo, hi, short_oid->id);
+	pos = git_pack__lookup_id(file->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1);
 
 	if (pos >= 0) {
 		/* An object matching exactly the oid was found */
 		found = 1;
-		current = file->oid_lookup + pos;
+		current = file->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
 	} else {
 		/* No object was found */
 		/* pos refers to the object with the "closest" oid to short_oid */
 		pos = -1 - pos;
 		if (pos < (int)file->num_commits) {
-			current = file->oid_lookup + pos;
+			current = file->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
 
-			if (!git_oid_ncmp(short_oid, current, len))
+			if (!git_oid_raw_ncmp(short_oid->id, current, len))
 				found = 1;
 		}
 	}
 
-	if (found && len != GIT_OID_HEXSZ && pos + 1 < (int)file->num_commits) {
+	if (found && len != GIT_OID_SHA1_HEXSIZE && pos + 1 < (int)file->num_commits) {
 		/* Check for ambiguousity */
-		const git_oid *next = current + 1;
+		const unsigned char *next = current + GIT_OID_SHA1_SIZE;
 
-		if (!git_oid_ncmp(short_oid, next, len)) {
+		if (!git_oid_raw_ncmp(short_oid->id, next, len))
 			found = 2;
-		}
 	}
 
 	if (!found)
@@ -597,7 +616,7 @@ void git_commit_graph_free(git_commit_graph *cgraph)
 	if (!cgraph)
 		return;
 
-	git_buf_dispose(&cgraph->filename);
+	git_str_dispose(&cgraph->filename);
 	git_commit_graph_file_free(cgraph->file);
 	git__free(cgraph);
 }
@@ -623,13 +642,13 @@ int git_commit_graph_writer_new(git_commit_graph_writer **out, const char *objec
 	git_commit_graph_writer *w = git__calloc(1, sizeof(git_commit_graph_writer));
 	GIT_ERROR_CHECK_ALLOC(w);
 
-	if (git_buf_sets(&w->objects_info_dir, objects_info_dir) < 0) {
+	if (git_str_sets(&w->objects_info_dir, objects_info_dir) < 0) {
 		git__free(w);
 		return -1;
 	}
 
 	if (git_vector_init(&w->commits, 0, packed_commit__cmp) < 0) {
-		git_buf_dispose(&w->objects_info_dir);
+		git_str_dispose(&w->objects_info_dir);
 		git__free(w);
 		return -1;
 	}
@@ -649,7 +668,7 @@ void git_commit_graph_writer_free(git_commit_graph_writer *w)
 	git_vector_foreach (&w->commits, i, packed_commit)
 		packed_commit_free(packed_commit);
 	git_vector_free(&w->commits);
-	git_buf_dispose(&w->objects_info_dir);
+	git_str_dispose(&w->objects_info_dir);
 	git__free(w);
 }
 
@@ -707,7 +726,8 @@ int git_commit_graph_writer_add_index_file(
 	if (error < 0)
 		goto cleanup;
 
-	error = git_mwindow_get_pack(&p, idx_path);
+	/* TODO: SHA256 */
+	error = git_mwindow_get_pack(&p, idx_path, 0);
 	if (error < 0)
 		goto cleanup;
 
@@ -753,7 +773,7 @@ enum generation_number_commit_state {
 	GENERATION_NUMBER_COMMIT_STATE_UNVISITED = 0,
 	GENERATION_NUMBER_COMMIT_STATE_ADDED = 1,
 	GENERATION_NUMBER_COMMIT_STATE_EXPANDED = 2,
-	GENERATION_NUMBER_COMMIT_STATE_VISITED = 3,
+	GENERATION_NUMBER_COMMIT_STATE_VISITED = 3
 };
 
 static int compute_generation_numbers(git_vector *commits)
@@ -931,8 +951,8 @@ static int write_chunk_header(
 
 static int commit_graph_write_buf(const char *buf, size_t size, void *data)
 {
-	git_buf *b = (git_buf *)data;
-	return git_buf_put(b, buf, size);
+	git_str *b = (git_str *)data;
+	return git_str_put(b, buf, size);
 }
 
 struct commit_graph_write_hash_context {
@@ -971,9 +991,10 @@ static int commit_graph_write(
 	uint32_t extra_edge_list_count;
 	uint32_t oid_fanout[256];
 	off64_t offset;
-	git_buf oid_lookup = GIT_BUF_INIT, commit_data = GIT_BUF_INIT,
-		extra_edge_list = GIT_BUF_INIT;
-	git_oid cgraph_checksum = {{0}};
+	git_str oid_lookup = GIT_STR_INIT, commit_data = GIT_STR_INIT,
+		extra_edge_list = GIT_STR_INIT;
+	unsigned char checksum[GIT_HASH_SHA1_SIZE];
+	size_t checksum_size;
 	git_hash_ctx ctx;
 	struct commit_graph_write_hash_context hash_cb_data = {0};
 
@@ -986,7 +1007,8 @@ static int commit_graph_write(
 	hash_cb_data.cb_data = cb_data;
 	hash_cb_data.ctx = &ctx;
 
-	error = git_hash_ctx_init(&ctx);
+	checksum_size = GIT_HASH_SHA1_SIZE;
+	error = git_hash_ctx_init(&ctx, GIT_HASH_ALGORITHM_SHA1);
 	if (error < 0)
 		return error;
 	cb_data = &hash_cb_data;
@@ -1011,8 +1033,10 @@ static int commit_graph_write(
 
 	/* Fill the OID Lookup table. */
 	git_vector_foreach (&w->commits, i, packed_commit) {
-		error = git_buf_put(&oid_lookup,
-			(const char *)&packed_commit->sha1, sizeof(git_oid));
+		error = git_str_put(&oid_lookup,
+			(const char *)&packed_commit->sha1.id,
+			GIT_OID_SHA1_SIZE);
+
 		if (error < 0)
 			goto cleanup;
 	}
@@ -1026,9 +1050,10 @@ static int commit_graph_write(
 		size_t *packed_index;
 		unsigned int parentcount = (unsigned int)git_array_size(packed_commit->parents);
 
-		error = git_buf_put(&commit_data,
-				(const char *)&packed_commit->tree_oid,
-				sizeof(git_oid));
+		error = git_str_put(&commit_data,
+			(const char *)&packed_commit->tree_oid.id,
+			GIT_OID_SHA1_SIZE);
+
 		if (error < 0)
 			goto cleanup;
 
@@ -1038,7 +1063,7 @@ static int commit_graph_write(
 			packed_index = git_array_get(packed_commit->parent_indices, 0);
 			word = htonl((uint32_t)*packed_index);
 		}
-		error = git_buf_put(&commit_data, (const char *)&word, sizeof(word));
+		error = git_str_put(&commit_data, (const char *)&word, sizeof(word));
 		if (error < 0)
 			goto cleanup;
 
@@ -1050,7 +1075,7 @@ static int commit_graph_write(
 		} else {
 			word = htonl(0x80000000u | extra_edge_list_count);
 		}
-		error = git_buf_put(&commit_data, (const char *)&word, sizeof(word));
+		error = git_str_put(&commit_data, (const char *)&word, sizeof(word));
 		if (error < 0)
 			goto cleanup;
 
@@ -1061,7 +1086,7 @@ static int commit_graph_write(
 					packed_commit->parent_indices, parent_i);
 				word = htonl((uint32_t)(*packed_index | (parent_i + 1 == parentcount ? 0x80000000u : 0)));
 
-				error = git_buf_put(&extra_edge_list,
+				error = git_str_put(&extra_edge_list,
 						(const char *)&word,
 						sizeof(word));
 				if (error < 0)
@@ -1074,19 +1099,19 @@ static int commit_graph_write(
 		commit_time = (uint64_t)packed_commit->commit_time;
 		if (generation > GIT_COMMIT_GRAPH_GENERATION_NUMBER_MAX)
 			generation = GIT_COMMIT_GRAPH_GENERATION_NUMBER_MAX;
-		word = ntohl((uint32_t)((generation << 2) | ((commit_time >> 32ull) & 0x3ull)));
-		error = git_buf_put(&commit_data, (const char *)&word, sizeof(word));
+		word = ntohl((uint32_t)((generation << 2) | (((uint32_t)(commit_time >> 32)) & 0x3) ));
+		error = git_str_put(&commit_data, (const char *)&word, sizeof(word));
 		if (error < 0)
 			goto cleanup;
-		word = ntohl((uint32_t)(commit_time & 0xffffffffull));
-		error = git_buf_put(&commit_data, (const char *)&word, sizeof(word));
+		word = ntohl((uint32_t)(commit_time & 0xfffffffful));
+		error = git_str_put(&commit_data, (const char *)&word, sizeof(word));
 		if (error < 0)
 			goto cleanup;
 	}
 
 	/* Write the header. */
 	hdr.chunks = 3;
-	if (git_buf_len(&extra_edge_list) > 0)
+	if (git_str_len(&extra_edge_list) > 0)
 		hdr.chunks++;
 	error = write_cb((const char *)&hdr, sizeof(hdr), cb_data);
 	if (error < 0)
@@ -1101,17 +1126,17 @@ static int commit_graph_write(
 	error = write_chunk_header(COMMIT_GRAPH_OID_LOOKUP_ID, offset, write_cb, cb_data);
 	if (error < 0)
 		goto cleanup;
-	offset += git_buf_len(&oid_lookup);
+	offset += git_str_len(&oid_lookup);
 	error = write_chunk_header(COMMIT_GRAPH_COMMIT_DATA_ID, offset, write_cb, cb_data);
 	if (error < 0)
 		goto cleanup;
-	offset += git_buf_len(&commit_data);
-	if (git_buf_len(&extra_edge_list) > 0) {
+	offset += git_str_len(&commit_data);
+	if (git_str_len(&extra_edge_list) > 0) {
 		error = write_chunk_header(
 				COMMIT_GRAPH_EXTRA_EDGE_LIST_ID, offset, write_cb, cb_data);
 		if (error < 0)
 			goto cleanup;
-		offset += git_buf_len(&extra_edge_list);
+		offset += git_str_len(&extra_edge_list);
 	}
 	error = write_chunk_header(0, offset, write_cb, cb_data);
 	if (error < 0)
@@ -1121,28 +1146,28 @@ static int commit_graph_write(
 	error = write_cb((const char *)oid_fanout, sizeof(oid_fanout), cb_data);
 	if (error < 0)
 		goto cleanup;
-	error = write_cb(git_buf_cstr(&oid_lookup), git_buf_len(&oid_lookup), cb_data);
+	error = write_cb(git_str_cstr(&oid_lookup), git_str_len(&oid_lookup), cb_data);
 	if (error < 0)
 		goto cleanup;
-	error = write_cb(git_buf_cstr(&commit_data), git_buf_len(&commit_data), cb_data);
+	error = write_cb(git_str_cstr(&commit_data), git_str_len(&commit_data), cb_data);
 	if (error < 0)
 		goto cleanup;
-	error = write_cb(git_buf_cstr(&extra_edge_list), git_buf_len(&extra_edge_list), cb_data);
+	error = write_cb(git_str_cstr(&extra_edge_list), git_str_len(&extra_edge_list), cb_data);
 	if (error < 0)
 		goto cleanup;
 
 	/* Finalize the checksum and write the trailer. */
-	error = git_hash_final(&cgraph_checksum, &ctx);
+	error = git_hash_final(checksum, &ctx);
 	if (error < 0)
 		goto cleanup;
-	error = write_cb((const char *)&cgraph_checksum, sizeof(cgraph_checksum), cb_data);
+	error = write_cb((char *)checksum, checksum_size, cb_data);
 	if (error < 0)
 		goto cleanup;
 
 cleanup:
-	git_buf_dispose(&oid_lookup);
-	git_buf_dispose(&commit_data);
-	git_buf_dispose(&extra_edge_list);
+	git_str_dispose(&oid_lookup);
+	git_str_dispose(&commit_data);
+	git_str_dispose(&extra_edge_list);
 	git_hash_ctx_cleanup(&ctx);
 	return error;
 }
@@ -1171,21 +1196,21 @@ int git_commit_graph_writer_commit(
 {
 	int error;
 	int filebuf_flags = GIT_FILEBUF_DO_NOT_BUFFER;
-	git_buf commit_graph_path = GIT_BUF_INIT;
+	git_str commit_graph_path = GIT_STR_INIT;
 	git_filebuf output = GIT_FILEBUF_INIT;
 
 	/* TODO: support options and fill in defaults. */
 	GIT_UNUSED(opts);
 
-	error = git_buf_joinpath(
-			&commit_graph_path, git_buf_cstr(&w->objects_info_dir), "commit-graph");
+	error = git_str_joinpath(
+			&commit_graph_path, git_str_cstr(&w->objects_info_dir), "commit-graph");
 	if (error < 0)
 		return error;
 
 	if (git_repository__fsync_gitdir)
 		filebuf_flags |= GIT_FILEBUF_FSYNC;
-	error = git_filebuf_open(&output, git_buf_cstr(&commit_graph_path), filebuf_flags, 0644);
-	git_buf_dispose(&commit_graph_path);
+	error = git_filebuf_open(&output, git_str_cstr(&commit_graph_path), filebuf_flags, 0644);
+	git_str_dispose(&commit_graph_path);
 	if (error < 0)
 		return error;
 
@@ -1199,9 +1224,17 @@ int git_commit_graph_writer_commit(
 }
 
 int git_commit_graph_writer_dump(
-		git_buf *cgraph,
-		git_commit_graph_writer *w,
-		git_commit_graph_writer_options *opts)
+	git_buf *cgraph,
+	git_commit_graph_writer *w,
+	git_commit_graph_writer_options *opts)
+{
+	GIT_BUF_WRAP_PRIVATE(cgraph, git_commit_graph__writer_dump, w, opts);
+}
+
+int git_commit_graph__writer_dump(
+	git_str *cgraph,
+	git_commit_graph_writer *w,
+	git_commit_graph_writer_options *opts)
 {
 	/* TODO: support options. */
 	GIT_UNUSED(opts);

data/vendor/libgit2/src/{commit_graph.h → libgit2/commit_graph.h}

@@ -15,6 +15,8 @@
 
 #include "map.h"
 #include "vector.h"
+#include "oid.h"
+#include "hash.h"
 
 /**
  * A commit-graph file.
@@ -34,7 +36,7 @@ typedef struct git_commit_graph_file {
 	uint32_t num_commits;
 
 	/* The OID Lookup table. */
-	git_oid *oid_lookup;
+	unsigned char *oid_lookup;
 
 	/*
 	 * The Commit Data table. Each entry contains the OID of the commit followed
@@ -55,7 +57,7 @@ typedef struct git_commit_graph_file {
 	size_t num_extra_edge_list;
 
 	/* The trailer of the file. Contains the SHA1-checksum of the whole file. */
-	git_oid checksum;
+	unsigned char checksum[GIT_HASH_SHA1_SIZE];
 } git_commit_graph_file;
 
 /**
@@ -92,7 +94,7 @@ typedef struct git_commit_graph_entry {
 /* A wrapper for git_commit_graph_file to enable lazy loading in the ODB. */
 struct git_commit_graph {
 	/* The path to the commit-graph file. Something like ".git/objects/info/commit-graph". */
-	git_buf filename;
+	git_str filename;
 
 	/* The underlying commit-graph file. */
 	git_commit_graph_file *file;
@@ -104,6 +106,9 @@ struct git_commit_graph {
 /** Create a new commit-graph, optionally opening the underlying file. */
 int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir, bool open_file);
 
+/** Validate the checksum of a commit graph */
+int git_commit_graph_validate(git_commit_graph *cgraph);
+
 /** Open and validate a commit-graph file. */
 int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *path);
 
@@ -127,12 +132,17 @@ struct git_commit_graph_writer {
 	 * The path of the `objects/info` directory where the `commit-graph` will be
 	 * stored.
 	 */
-	git_buf objects_info_dir;
+	git_str objects_info_dir;
 
 	/* The list of packed commits. */
 	git_vector commits;
 };
 
+int git_commit_graph__writer_dump(
+	git_str *cgraph,
+	git_commit_graph_writer *w,
+	git_commit_graph_writer_options *opts);
+
 /*
  * Returns whether the git_commit_graph_file needs to be reloaded since the
  * contents of the commit-graph file have changed on disk.

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

@@ -124,16 +124,19 @@ static int commit_quick_parse(
 {
 	git_oid *parent_oid;
 	git_commit *commit;
-	int error;
+	git_commit__parse_options parse_opts = {
+		GIT_OID_SHA1,
+		GIT_COMMIT_PARSE_QUICK
+	};
 	size_t i;
 
 	commit = git__calloc(1, sizeof(*commit));
 	GIT_ERROR_CHECK_ALLOC(commit);
 	commit->object.repo = walk->repo;
 
-	if ((error = git_commit__parse_ext(commit, obj, GIT_COMMIT_PARSE_QUICK)) < 0) {
+	if (git_commit__parse_ext(commit, obj, &parse_opts) < 0) {
 		git__free(commit);
-		return error;
+		return -1;
 	}
 
 	if (!git__is_uint16(git_array_size(commit->parent_ids))) {
@@ -173,7 +176,7 @@ int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit)
 	if (cgraph_file) {
 		git_commit_graph_entry e;
 
-		error = git_commit_graph_entry_find(&e, cgraph_file, &commit->oid, GIT_OID_RAWSZ);
+		error = git_commit_graph_entry_find(&e, cgraph_file, &commit->oid, GIT_OID_SHA1_SIZE);
 		if (error == 0 && git__is_uint16(e.parent_count)) {
 			size_t i;
 			commit->generation = (uint32_t)e.generation;

data/vendor/libgit2/src/libgit2/common.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_common_h__
+#define INCLUDE_common_h__
+
+#include "git2_util.h"
+#include "errors.h"
+
+/*
+* Include the declarations for deprecated functions; this ensures
+* that they're decorated with the proper extern/visibility attributes.
+*/
+#include "git2/deprecated.h"
+
+#include "posix.h"
+
+/**
+ * Initialize a structure with a version.
+ */
+GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int version)
+{
+	memset(structure, 0, len);
+	*((int*)structure) = version;
+}
+#define GIT_INIT_STRUCTURE(S,V) git__init_structure(S, sizeof(*S), V)
+
+#define GIT_INIT_STRUCTURE_FROM_TEMPLATE(PTR,VERSION,TYPE,TPL) do { \
+	TYPE _tmpl = TPL; \
+	GIT_ERROR_CHECK_VERSION(&(VERSION), _tmpl.version, #TYPE);      \
+	memcpy((PTR), &_tmpl, sizeof(_tmpl)); } while (0)
+
+/**
+ * Check a versioned structure for validity
+ */
+GIT_INLINE(int) git_error__check_version(const void *structure, unsigned int expected_max, const char *name)
+{
+	unsigned int actual;
+
+	if (!structure)
+		return 0;
+
+	actual = *(const unsigned int*)structure;
+	if (actual > 0 && actual <= expected_max)
+		return 0;
+
+	git_error_set(GIT_ERROR_INVALID, "invalid version %d on %s", actual, name);
+	return -1;
+}
+#define GIT_ERROR_CHECK_VERSION(S,V,N) if (git_error__check_version(S,V,N) < 0) return -1
+
+#endif