rugged 1.6.5 → 1.7.2

data/vendor/libgit2/src/libgit2/commit_graph.c

@@ -138,19 +138,22 @@ static int commit_graph_parse_oid_lookup(
 		struct git_commit_graph_chunk *chunk_oid_lookup)
 {
 	uint32_t i;
-	unsigned char *oid, *prev_oid, zero_oid[GIT_OID_SHA1_SIZE] = {0};
+	unsigned char *oid, *prev_oid, zero_oid[GIT_OID_MAX_SIZE] = {0};
+	size_t oid_size;
+
+	oid_size = git_oid_size(file->oid_type);
 
 	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_SHA1_SIZE)
+	if (chunk_oid_lookup->length != file->num_commits * oid_size)
 		return commit_graph_error("OID Lookup chunk has wrong length");
 
 	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)
+	for (i = 0; i < file->num_commits; ++i, oid += oid_size) {
+		if (git_oid_raw_cmp(prev_oid, oid, oid_size) >= 0)
 			return commit_graph_error("OID Lookup index is non-monotonic");
 		prev_oid = oid;
 	}
@@ -163,11 +166,13 @@ static int commit_graph_parse_commit_data(
 		const unsigned char *data,
 		struct git_commit_graph_chunk *chunk_commit_data)
 {
+	size_t oid_size = git_oid_size(file->oid_type);
+
 	if (chunk_commit_data->offset == 0)
 		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_SHA1_SIZE + 16))
+	if (chunk_commit_data->length != file->num_commits * (oid_size + 16))
 		return commit_graph_error("Commit Data chunk has wrong length");
 
 	file->commit_data = data + chunk_commit_data->offset;
@@ -209,7 +214,9 @@ int git_commit_graph_file_parse(
 
 	GIT_ASSERT_ARG(file);
 
-	if (size < sizeof(struct git_commit_graph_header) + GIT_OID_SHA1_SIZE)
+	checksum_size = git_oid_size(file->oid_type);
+
+	if (size < sizeof(struct git_commit_graph_header) + checksum_size)
 		return commit_graph_error("commit-graph is too short");
 
 	hdr = ((struct git_commit_graph_header *)data);
@@ -226,8 +233,7 @@ 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_SHA1_SIZE;
-	checksum_size = GIT_HASH_SHA1_SIZE;
+	trailer_offset = size - checksum_size;
 
 	if (trailer_offset < last_chunk_offset)
 		return commit_graph_error("wrong commit-graph size");
@@ -295,25 +301,35 @@ int git_commit_graph_file_parse(
 	return 0;
 }
 
-int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir, bool open_file)
+int git_commit_graph_new(
+	git_commit_graph **cgraph_out,
+	const char *objects_dir,
+	bool open_file,
+	git_oid_t oid_type)
 {
 	git_commit_graph *cgraph = NULL;
 	int error = 0;
 
 	GIT_ASSERT_ARG(cgraph_out);
 	GIT_ASSERT_ARG(objects_dir);
+	GIT_ASSERT_ARG(oid_type);
 
 	cgraph = git__calloc(1, sizeof(git_commit_graph));
 	GIT_ERROR_CHECK_ALLOC(cgraph);
 
+	cgraph->oid_type = oid_type;
+
 	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_str_cstr(&cgraph->filename));
+		error = git_commit_graph_file_open(&cgraph->file,
+				git_str_cstr(&cgraph->filename), oid_type);
+
 		if (error < 0)
 			goto error;
+
 		cgraph->checked = 1;
 	}
 
@@ -326,14 +342,18 @@ 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;
+	unsigned char checksum[GIT_HASH_MAX_SIZE];
+	git_hash_algorithm_t checksum_type;
+	size_t checksum_size, trailer_offset;
+
+	checksum_type = git_oid_algorithm(cgraph->oid_type);
+	checksum_size = git_hash_size(checksum_type);
+	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)
+	if (git_hash_buf(checksum, cgraph->file->graph_map.data, trailer_offset, checksum_type) < 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");
@@ -341,16 +361,32 @@ int git_commit_graph_validate(git_commit_graph *cgraph) {
 	return 0;
 }
 
-int git_commit_graph_open(git_commit_graph **cgraph_out, const char *objects_dir)
+int git_commit_graph_open(
+	git_commit_graph **cgraph_out,
+	const char *objects_dir
+#ifdef GIT_EXPERIMENTAL_SHA256
+	, git_oid_t oid_type
+#endif
+	)
 {
-	int error = git_commit_graph_new(cgraph_out, objects_dir, true);
-	if (!error) {
+#ifndef GIT_EXPERIMENTAL_SHA256
+	git_oid_t oid_type = GIT_OID_SHA1;
+#endif
+	int error;
+
+	error = git_commit_graph_new(cgraph_out, objects_dir, true,
+			oid_type);
+
+	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)
+int git_commit_graph_file_open(
+	git_commit_graph_file **file_out,
+	const char *path,
+	git_oid_t oid_type)
 {
 	git_commit_graph_file *file;
 	git_file fd = -1;
@@ -379,6 +415,8 @@ int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *pat
 	file = git__calloc(1, sizeof(git_commit_graph_file));
 	GIT_ERROR_CHECK_ALLOC(file);
 
+	file->oid_type = oid_type;
+
 	error = git_futils_mmap_ro(&file->graph_map, fd, 0, cgraph_size);
 	p_close(fd);
 	if (error < 0) {
@@ -395,7 +433,9 @@ int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *pat
 	return 0;
 }
 
-int git_commit_graph_get_file(git_commit_graph_file **file_out, git_commit_graph *cgraph)
+int git_commit_graph_get_file(
+	git_commit_graph_file **file_out,
+	git_commit_graph *cgraph)
 {
 	if (!cgraph->checked) {
 		int error = 0;
@@ -405,7 +445,8 @@ 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_str_cstr(&cgraph->filename));
+		error = git_commit_graph_file_open(&result,
+			git_str_cstr(&cgraph->filename), cgraph->oid_type);
 
 		if (error < 0)
 			return error;
@@ -441,6 +482,7 @@ static int git_commit_graph_entry_get_byindex(
 		size_t pos)
 {
 	const unsigned char *commit_data;
+	size_t oid_size = git_oid_size(file->oid_type);
 
 	GIT_ASSERT_ARG(e);
 	GIT_ASSERT_ARG(file);
@@ -450,15 +492,15 @@ static int git_commit_graph_entry_get_byindex(
 		return GIT_ENOTFOUND;
 	}
 
-	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)));
+	commit_data = file->commit_data + pos * (oid_size + 4 * sizeof(uint32_t));
+	git_oid__fromraw(&e->tree_oid, commit_data, file->oid_type);
+	e->parent_indices[0] = ntohl(*((uint32_t *)(commit_data + oid_size)));
 	e->parent_indices[1] = ntohl(
-			*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE + sizeof(uint32_t))));
+			*((uint32_t *)(commit_data + oid_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_SHA1_SIZE + 2 * sizeof(uint32_t))));
-	e->commit_time = ntohl(*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE + 3 * sizeof(uint32_t))));
+	e->generation = ntohl(*((uint32_t *)(commit_data + oid_size + 2 * sizeof(uint32_t))));
+	e->commit_time = ntohl(*((uint32_t *)(commit_data + oid_size + 3 * sizeof(uint32_t))));
 
 	e->commit_time |= (e->generation & UINT64_C(0x3)) << UINT64_C(32);
 	e->generation >>= 2u;
@@ -485,7 +527,7 @@ static int git_commit_graph_entry_get_byindex(
 		}
 	}
 
-	git_oid__fromraw(&e->sha1, &file->oid_lookup[pos * GIT_OID_SHA1_SIZE], GIT_OID_SHA1);
+	git_oid__fromraw(&e->sha1, &file->oid_lookup[pos * oid_size], file->oid_type);
 	return 0;
 }
 
@@ -494,8 +536,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;
-	unsigned char checksum[GIT_HASH_SHA1_SIZE];
-	size_t checksum_size = GIT_HASH_SHA1_SIZE;
+	unsigned char checksum[GIT_HASH_MAX_SIZE];
+	size_t checksum_size = git_oid_size(file->oid_type);
 
 	/* TODO: properly open the file without access time using O_NOATIME */
 	fd = git_futils_open_ro(path);
@@ -530,35 +572,40 @@ int git_commit_graph_entry_find(
 	int pos, found = 0;
 	uint32_t hi, lo;
 	const unsigned char *current = NULL;
+	size_t oid_size, oid_hexsize;
 
 	GIT_ASSERT_ARG(e);
 	GIT_ASSERT_ARG(file);
 	GIT_ASSERT_ARG(short_oid);
 
+	oid_size = git_oid_size(file->oid_type);
+	oid_hexsize = git_oid_hexsize(file->oid_type);
+
 	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_id(file->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1);
+	pos = git_pack__lookup_id(file->oid_lookup, oid_size, lo, hi,
+		short_oid->id, file->oid_type);
 
 	if (pos >= 0) {
 		/* An object matching exactly the oid was found */
 		found = 1;
-		current = file->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
+		current = file->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)file->num_commits) {
-			current = file->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
+			current = file->oid_lookup + (pos * oid_size);
 
 			if (!git_oid_raw_ncmp(short_oid->id, current, len))
 				found = 1;
 		}
 	}
 
-	if (found && len != GIT_OID_SHA1_HEXSIZE && pos + 1 < (int)file->num_commits) {
+	if (found && len != oid_hexsize && pos + 1 < (int)file->num_commits) {
 		/* Check for ambiguousity */
-		const unsigned char *next = current + GIT_OID_SHA1_SIZE;
+		const unsigned char *next = current + oid_size;
 
 		if (!git_oid_raw_ncmp(short_oid->id, next, len))
 			found = 2;
@@ -637,11 +684,27 @@ static int packed_commit__cmp(const void *a_, const void *b_)
 	return git_oid_cmp(&a->sha1, &b->sha1);
 }
 
-int git_commit_graph_writer_new(git_commit_graph_writer **out, const char *objects_info_dir)
+int git_commit_graph_writer_new(
+	git_commit_graph_writer **out,
+	const char *objects_info_dir
+#ifdef GIT_EXPERIMENTAL_SHA256
+	, git_oid_t oid_type
+#endif
+	)
 {
-	git_commit_graph_writer *w = git__calloc(1, sizeof(git_commit_graph_writer));
+	git_commit_graph_writer *w;
+
+#ifndef GIT_EXPERIMENTAL_SHA256
+	git_oid_t oid_type = GIT_OID_SHA1;
+#endif
+
+	GIT_ASSERT_ARG(out && objects_info_dir && oid_type);
+
+	w = git__calloc(1, sizeof(git_commit_graph_writer));
 	GIT_ERROR_CHECK_ALLOC(w);
 
+	w->oid_type = oid_type;
+
 	if (git_str_sets(&w->objects_info_dir, objects_info_dir) < 0) {
 		git__free(w);
 		return -1;
@@ -993,8 +1056,9 @@ static int commit_graph_write(
 	off64_t offset;
 	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;
+	unsigned char checksum[GIT_HASH_MAX_SIZE];
+	git_hash_algorithm_t checksum_type;
+	size_t checksum_size, oid_size;
 	git_hash_ctx ctx;
 	struct commit_graph_write_hash_context hash_cb_data = {0};
 
@@ -1007,8 +1071,11 @@ static int commit_graph_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);
+	oid_size = git_oid_size(w->oid_type);
+	checksum_type = git_oid_algorithm(w->oid_type);
+	checksum_size = git_hash_size(checksum_type);
+
+	error = git_hash_ctx_init(&ctx, checksum_type);
 	if (error < 0)
 		return error;
 	cb_data = &hash_cb_data;
@@ -1035,7 +1102,7 @@ static int commit_graph_write(
 	git_vector_foreach (&w->commits, i, packed_commit) {
 		error = git_str_put(&oid_lookup,
 			(const char *)&packed_commit->sha1.id,
-			GIT_OID_SHA1_SIZE);
+			oid_size);
 
 		if (error < 0)
 			goto cleanup;
@@ -1052,7 +1119,7 @@ static int commit_graph_write(
 
 		error = git_str_put(&commit_data,
 			(const char *)&packed_commit->tree_oid.id,
-			GIT_OID_SHA1_SIZE);
+			oid_size);
 
 		if (error < 0)
 			goto cleanup;

data/vendor/libgit2/src/libgit2/commit_graph.h

@@ -30,6 +30,9 @@
 typedef struct git_commit_graph_file {
 	git_map graph_map;
 
+	/* The type of object IDs in the commit graph file. */
+	git_oid_t oid_type;
+
 	/* The OID Fanout table. */
 	const uint32_t *oid_fanout;
 	/* The total number of commits in the graph. */
@@ -84,10 +87,10 @@ typedef struct git_commit_graph_entry {
 	/* The index within the Extra Edge List of any parent after the first two. */
 	size_t extra_parents_index;
 
-	/* The SHA-1 hash of the root tree of the commit. */
+	/* The object ID of the root tree of the commit. */
 	git_oid tree_oid;
 
-	/* The SHA-1 hash of the requested commit. */
+	/* The object ID hash of the requested commit. */
 	git_oid sha1;
 } git_commit_graph_entry;
 
@@ -99,18 +102,28 @@ struct git_commit_graph {
 	/* The underlying commit-graph file. */
 	git_commit_graph_file *file;
 
+	/* The object ID types in the commit graph. */
+	git_oid_t oid_type;
+
 	/* Whether the commit-graph file was already checked for validity. */
 	bool checked;
 };
 
 /** 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);
+int git_commit_graph_new(
+	git_commit_graph **cgraph_out,
+	const char *objects_dir,
+	bool open_file,
+	git_oid_t oid_type);
 
 /** 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);
+int git_commit_graph_file_open(
+	git_commit_graph_file **file_out,
+	const char *path,
+	git_oid_t oid_type);
 
 /*
  * Attempt to get the git_commit_graph's commit-graph file. This object is
@@ -134,6 +147,9 @@ struct git_commit_graph_writer {
 	 */
 	git_str objects_info_dir;
 
+	/* The object ID type of the commit graph. */
+	git_oid_t oid_type;
+
 	/* The list of packed commits. */
 	git_vector commits;
 };

data/vendor/libgit2/src/libgit2/commit_list.c

@@ -43,13 +43,18 @@ int git_commit_list_time_cmp(const void *a, const void *b)
 	return 0;
 }
 
-git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p)
-{
+git_commit_list *git_commit_list_create(git_commit_list_node *item, git_commit_list *next) {
 	git_commit_list *new_list = git__malloc(sizeof(git_commit_list));
 	if (new_list != NULL) {
 		new_list->item = item;
-		new_list->next = *list_p;
+		new_list->next = next;
 	}
+	return new_list;
+}
+
+git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p)
+{
+	git_commit_list *new_list = git_commit_list_create(item, *list_p);
 	*list_p = new_list;
 	return new_list;
 }
@@ -125,7 +130,7 @@ static int commit_quick_parse(
 	git_oid *parent_oid;
 	git_commit *commit;
 	git_commit__parse_options parse_opts = {
-		GIT_OID_SHA1,
+		walk->repo->oid_type,
 		GIT_COMMIT_PARSE_QUICK
 	};
 	size_t i;
@@ -176,7 +181,9 @@ 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_SHA1_SIZE);
+		error = git_commit_graph_entry_find(&e, cgraph_file,
+			&commit->oid, git_oid_size(walk->repo->oid_type));
+
 		if (error == 0 && git__is_uint16(e.parent_count)) {
 			size_t i;
 			commit->generation = (uint32_t)e.generation;

data/vendor/libgit2/src/libgit2/commit_list.h

@@ -49,6 +49,7 @@ git_commit_list_node *git_commit_list_alloc_node(git_revwalk *walk);
 int git_commit_list_generation_cmp(const void *a, const void *b);
 int git_commit_list_time_cmp(const void *a, const void *b);
 void git_commit_list_free(git_commit_list **list_p);
+git_commit_list *git_commit_list_create(git_commit_list_node *item, git_commit_list *next);
 git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p);
 git_commit_list *git_commit_list_insert_by_date(git_commit_list_node *item, git_commit_list **list_p);
 int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit);

data/vendor/libgit2/src/libgit2/config_file.c

@@ -26,7 +26,7 @@
 
 typedef struct config_file {
 	git_futils_filestamp stamp;
-	unsigned char checksum[GIT_HASH_SHA1_SIZE];
+	unsigned char checksum[GIT_HASH_SHA256_SIZE];
 	char *path;
 	git_array_t(struct config_file) includes;
 } config_file;
@@ -133,7 +133,7 @@ static int config_file_is_modified(int *modified, config_file *file)
 {
 	config_file *include;
 	git_str buf = GIT_STR_INIT;
-	unsigned char checksum[GIT_HASH_SHA1_SIZE];
+	unsigned char checksum[GIT_HASH_SHA256_SIZE];
 	uint32_t i;
 	int error = 0;
 
@@ -145,10 +145,10 @@ static int config_file_is_modified(int *modified, config_file *file)
 	if ((error = git_futils_readbuffer(&buf, file->path)) < 0)
 		goto out;
 
-	if ((error = git_hash_buf(checksum, buf.ptr, buf.size, GIT_HASH_ALGORITHM_SHA1)) < 0)
+	if ((error = git_hash_buf(checksum, buf.ptr, buf.size, GIT_HASH_ALGORITHM_SHA256)) < 0)
 		goto out;
 
-	if (memcmp(checksum, file->checksum, GIT_HASH_SHA1_SIZE) != 0) {
+	if (memcmp(checksum, file->checksum, GIT_HASH_SHA256_SIZE) != 0) {
 		*modified = 1;
 		goto out;
 	}
@@ -881,7 +881,7 @@ static int config_file_read(
 		goto out;
 
 	git_futils_filestamp_set_from_stat(&file->stamp, &st);
-	if ((error = git_hash_buf(file->checksum, contents.ptr, contents.size, GIT_HASH_ALGORITHM_SHA1)) < 0)
+	if ((error = git_hash_buf(file->checksum, contents.ptr, contents.size, GIT_HASH_ALGORITHM_SHA256)) < 0)
 		goto out;
 
 	if ((error = config_file_read_buffer(entries, repo, file, level, depth,
@@ -1116,7 +1116,12 @@ static int write_on_eof(
 /*
  * This is pretty much the parsing, except we write out anything we don't have
  */
-static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char *value)
+static int config_file_write(
+	config_file_backend *cfg,
+	const char *orig_key,
+	const char *key,
+	const git_regexp *preg,
+	const char *value)
 
 {
 	char *orig_section = NULL, *section = NULL, *orig_name, *name, *ldot;
@@ -1131,8 +1136,9 @@ static int config_file_write(config_file_backend *cfg, const char *orig_key, con
 	if (cfg->locked) {
 		error = git_str_puts(&contents, git_str_cstr(&cfg->locked_content) == NULL ? "" : git_str_cstr(&cfg->locked_content));
 	} else {
-		if ((error = git_filebuf_open(&file, cfg->file.path, GIT_FILEBUF_HASH_CONTENTS,
-					      GIT_CONFIG_FILE_MODE)) < 0)
+		if ((error = git_filebuf_open(&file, cfg->file.path,
+				GIT_FILEBUF_HASH_SHA256,
+				GIT_CONFIG_FILE_MODE)) < 0)
 			goto done;
 
 		/* We need to read in our own config file */

data/vendor/libgit2/src/libgit2/describe.c

@@ -363,12 +363,15 @@ static int find_unique_abbrev_size(
 	size_t size = abbreviated_size;
 	git_odb *odb;
 	git_oid dummy;
+	size_t hexsize;
 	int error;
 
 	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
 		return error;
 
-	while (size < GIT_OID_SHA1_HEXSIZE) {
+	hexsize = git_oid_hexsize(repo->oid_type);
+
+	while (size < hexsize) {
 		if ((error = git_odb_exists_prefix(&dummy, odb, oid_in, size)) == 0) {
 			*out = (int) size;
 			return 0;
@@ -383,7 +386,7 @@ static int find_unique_abbrev_size(
 	}
 
 	/* If we didn't find any shorter prefix, we have to do the whole thing */
-	*out = GIT_OID_SHA1_HEXSIZE;
+	*out = (int)hexsize;
 
 	return 0;
 }
@@ -397,7 +400,7 @@ static int show_suffix(
 {
 	int error, size = 0;
 
-	char hex_oid[GIT_OID_SHA1_HEXSIZE];
+	char hex_oid[GIT_OID_MAX_HEXSIZE];
 
 	if ((error = find_unique_abbrev_size(&size, repo, id, abbrev_size)) < 0)
 		return error;
@@ -414,7 +417,7 @@ static int show_suffix(
 #define MAX_CANDIDATES_TAGS FLAG_BITS - 1
 
 static int describe_not_found(const git_oid *oid, const char *message_format) {
-	char oid_str[GIT_OID_SHA1_HEXSIZE + 1];
+	char oid_str[GIT_OID_MAX_HEXSIZE + 1];
 	git_oid_tostr(oid_str, sizeof(oid_str), oid);
 
 	git_error_set(GIT_ERROR_DESCRIBE, message_format, oid_str);
@@ -525,7 +528,7 @@ static int describe(
 		if (annotated_cnt && (git_pqueue_size(&list) == 0)) {
 			/*
 			if (debug) {
-				char oid_str[GIT_OID_SHA1_HEXSIZE + 1];
+				char oid_str[GIT_OID_MAX_HEXSIZE + 1];
 				git_oid_tostr(oid_str, sizeof(oid_str), &c->oid);
 
 				fprintf(stderr, "finished search at %s\n", oid_str);
@@ -592,7 +595,7 @@ static int describe(
 			"head", "lightweight", "annotated",
 		};
 
-		char oid_str[GIT_OID_SHA1_HEXSIZE + 1];
+		char oid_str[GIT_OID_MAX_HEXSIZE + 1];
 
 		if (debug) {
 			for (cur_match = 0; cur_match < match_cnt; cur_match++) {
@@ -816,7 +819,7 @@ static int git_describe__format(
 
 	/* If we didn't find *any* tags, we fall back to the commit's id */
 	if (result->fallback_to_id) {
-		char hex_oid[GIT_OID_SHA1_HEXSIZE + 1] = {0};
+		char hex_oid[GIT_OID_MAX_HEXSIZE + 1] = {0};
 		int size = 0;
 
 		if ((error = find_unique_abbrev_size(

data/vendor/libgit2/src/libgit2/diff.c

@@ -19,8 +19,10 @@
 #include "git2/email.h"
 
 struct patch_id_args {
+	git_diff *diff;
 	git_hash_ctx ctx;
 	git_oid result;
+	git_oid_t oid_type;
 	int first_file;
 };
 
@@ -280,17 +282,19 @@ int git_diff_find_options_init(
 	return 0;
 }
 
-static int flush_hunk(git_oid *result, git_hash_ctx *ctx)
+static int flush_hunk(git_oid *result, struct patch_id_args *args)
 {
+	git_hash_ctx *ctx = &args->ctx;
 	git_oid hash;
 	unsigned short carry = 0;
-	int error, i;
+	size_t i;
+	int error;
 
 	if ((error = git_hash_final(hash.id, ctx)) < 0 ||
 	    (error = git_hash_init(ctx)) < 0)
 		return error;
 
-	for (i = 0; i < GIT_OID_SHA1_SIZE; i++) {
+	for (i = 0; i < git_oid_size(args->oid_type); i++) {
 		carry += result->id[i] + hash.id[i];
 		result->id[i] = (unsigned char)carry;
 		carry >>= 8;
@@ -338,7 +342,7 @@ static int diff_patchid_print_callback_to_buf(
 
 	if (line->origin == GIT_DIFF_LINE_FILE_HDR &&
 	    !args->first_file &&
-	    (error = flush_hunk(&args->result, &args->ctx) < 0))
+	    (error = flush_hunk(&args->result, args) < 0))
 			goto out;
 
 	if ((error = git_hash_update(&args->ctx, buf.ptr, buf.size)) < 0)
@@ -362,14 +366,19 @@ int git_diff_patchid_options_init(git_diff_patchid_options *opts, unsigned int v
 int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opts)
 {
 	struct patch_id_args args;
+	git_hash_algorithm_t algorithm;
 	int error;
 
 	GIT_ERROR_CHECK_VERSION(
 		opts, GIT_DIFF_PATCHID_OPTIONS_VERSION, "git_diff_patchid_options");
 
+	algorithm = git_oid_algorithm(diff->opts.oid_type);
+
 	memset(&args, 0, sizeof(args));
+	args.diff = diff;
 	args.first_file = 1;
-	if ((error = git_hash_ctx_init(&args.ctx, GIT_HASH_ALGORITHM_SHA1)) < 0)
+	args.oid_type = diff->opts.oid_type;
+	if ((error = git_hash_ctx_init(&args.ctx, algorithm)) < 0)
 		goto out;
 
 	if ((error = git_diff_print(diff,
@@ -378,11 +387,11 @@ int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opt
 				    &args)) < 0)
 		goto out;
 
-	if ((error = (flush_hunk(&args.result, &args.ctx))) < 0)
+	if ((error = (flush_hunk(&args.result, &args))) < 0)
 		goto out;
 
 #ifdef GIT_EXPERIMENTAL_SHA256
-	args.result.type = GIT_OID_SHA1;
+	args.result.type = diff->opts.oid_type;
 #endif
 
 	git_oid_cpy(out, &args.result);