rugged 1.6.5 → 1.7.2

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

@@ -108,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);
@@ -143,6 +141,23 @@ 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);
@@ -181,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);
@@ -196,10 +212,12 @@ int git_object_lookup_prefix(
 	if (error < 0)
 		return error;
 
-	if (len > GIT_OID_SHA1_HEXSIZE)
-		len = GIT_OID_SHA1_HEXSIZE;
+	oid_hexsize = git_oid_hexsize(repo->oid_type);
 
-	if (len == GIT_OID_SHA1_HEXSIZE) {
+	if (len > oid_hexsize)
+		len = oid_hexsize;
+
+	if (len == oid_hexsize) {
 		git_cached_obj *cached = NULL;
 
 		/* We want to match the full id : we can first look up in the cache,
@@ -233,8 +251,9 @@ int git_object_lookup_prefix(
 			error = git_odb_read(&odb_obj, odb, id);
 		}
 	} else {
-		git_oid short_oid = GIT_OID_SHA1_ZERO;
+		git_oid short_oid;
 
+		git_oid_clear(&short_oid, repo->oid_type);
 		git_oid__cpy_prefix(&short_oid, id, len);
 
 		/* If len < GIT_OID_SHA1_HEXSIZE (a strict short oid was given), we have
@@ -262,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_SHA1_HEXSIZE, type);
+	return git_object_lookup_prefix(object_out,
+		repo, id, git_oid_hexsize(repo->oid_type), type);
 }
 
 void git_object_free(git_object *object)
@@ -503,31 +523,36 @@ 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 = GIT_OID_SHA1_ZERO;
+	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_SHA1_HEXSIZE) {
+	while ((size_t)len < oid_hexsize) {
 		/* set up short oid */
 		memcpy(&id.id, &obj->cached.oid.id, (len + 1) / 2);
 		if (len & 1)
 			id.id[len / 2] &= 0xf0;
 
-#ifdef GIT_EXPERIMENTAL_SHA256
-		id.type = GIT_OID_SHA1;
-#endif
-
 		error = git_odb_exists_prefix(NULL, odb, &id, len);
 		if (error != GIT_EAMBIGUOUS)
 			break;

data/vendor/libgit2/src/libgit2/object.h

@@ -36,6 +36,12 @@ int git_object__from_raw(
 	git_object_t object_type,
 	git_oid_t oid_type);
 
+int git_object__init_from_odb_object(
+	git_object **object_out,
+	git_repository *repo,
+	git_odb_object *odb_obj,
+	git_object_t type);
+
 int git_object__from_odb_object(
 	git_object **object_out,
 	git_repository *repo,

data/vendor/libgit2/src/libgit2/odb.c

@@ -748,7 +748,8 @@ int git_odb__add_default_backends(
 		git_error_set(GIT_ERROR_ODB, "failed to acquire the odb lock");
 		return -1;
 	}
-	if (!db->cgraph && git_commit_graph_new(&db->cgraph, objects_dir, false) < 0) {
+	if (!db->cgraph &&
+	    git_commit_graph_new(&db->cgraph, objects_dir, false, db->options.oid_type) < 0) {
 		git_mutex_unlock(&db->lock);
 		return -1;
 	}
@@ -1493,11 +1494,16 @@ static int read_prefix_1(git_odb_object **out, git_odb *db,
 
 			if (found && git_oid__cmp(&full_oid, &found_full_oid)) {
 				git_str buf = GIT_STR_INIT;
+				const char *idstr;
 
-				git_str_printf(&buf, "multiple matches for prefix: %s",
-					git_oid_tostr_s(&full_oid));
-				git_str_printf(&buf, " %s",
-					git_oid_tostr_s(&found_full_oid));
+				if ((idstr = git_oid_tostr_s(&full_oid)) == NULL) {
+					git_str_puts(&buf, "failed to parse object id");
+				} else {
+					git_str_printf(&buf, "multiple matches for prefix: %s", idstr);
+
+					if ((idstr = git_oid_tostr_s(&found_full_oid)) != NULL)
+						git_str_printf(&buf, " %s", idstr);
+				}
 
 				error = git_odb__error_ambiguous(buf.ptr);
 				git_str_dispose(&buf);

data/vendor/libgit2/src/libgit2/odb_pack.c

@@ -309,11 +309,17 @@ static int pack_entry_find_prefix(
 {
 	int error;
 	size_t i;
-	git_oid found_full_oid = GIT_OID_SHA1_ZERO;
+	git_oid found_full_oid;
 	bool found = false;
 	struct git_pack_file *last_found = backend->last_found, *p;
 	git_midx_entry midx_entry;
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	git_oid_clear(&found_full_oid, short_oid->type);
+#else
+	git_oid_clear(&found_full_oid, GIT_OID_SHA1);
+#endif
+
 	if (backend->midx) {
 		error = git_midx_entry_find(&midx_entry, backend->midx, short_oid, len);
 		if (error == GIT_EAMBIGUOUS)
@@ -473,7 +479,9 @@ static int refresh_multi_pack_index(struct pack_backend *backend)
 		}
 	}
 
-	error = git_midx_open(&backend->midx, git_str_cstr(&midx_path));
+	error = git_midx_open(&backend->midx, git_str_cstr(&midx_path),
+		backend->opts.oid_type);
+
 	git_str_dispose(&midx_path);
 	if (error < 0)
 		return error;
@@ -792,7 +800,12 @@ static int pack_backend__writemidx(git_odb_backend *_backend)
 
 	backend = (struct pack_backend *)_backend;
 
-	error = git_midx_writer_new(&w, backend->pack_folder);
+	error = git_midx_writer_new(&w, backend->pack_folder
+#ifdef GIT_EXPERIMENTAL_SHA256
+		, backend->opts.oid_type
+#endif
+		);
+
 	if (error < 0)
 		return error;
 

data/vendor/libgit2/src/libgit2/oid.c

@@ -155,7 +155,13 @@ int git_oid_pathfmt(char *str, const git_oid *oid)
 
 char *git_oid_tostr_s(const git_oid *oid)
 {
-	char *str = GIT_THREADSTATE->oid_fmt;
+	git_threadstate *threadstate = git_threadstate_get();
+	char *str;
+
+	if (!threadstate)
+		return NULL;
+
+	str = threadstate->oid_fmt;
 	git_oid_nfmt(str, git_oid_hexsize(git_oid_type(oid)) + 1, oid);
 	return str;
 }

data/vendor/libgit2/src/libgit2/oidarray.c

@@ -15,10 +15,17 @@ void git_oidarray_dispose(git_oidarray *arr)
 	git__free(arr->ids);
 }
 
-void git_oidarray__from_array(git_oidarray *arr, git_array_oid_t *array)
+void git_oidarray__from_array(git_oidarray *out, const git_array_oid_t *array)
 {
-	arr->count = array->size;
-	arr->ids = array->ptr;
+	out->count = array->size;
+	out->ids = array->ptr;
+}
+
+void git_oidarray__to_array(git_array_oid_t *out, const git_oidarray *array)
+{
+	out->ptr = array->ids;
+	out->size = array->count;
+	out->asize = array->count;
 }
 
 void git_oidarray__reverse(git_oidarray *arr)
@@ -33,6 +40,45 @@ void git_oidarray__reverse(git_oidarray *arr)
 	}
 }
 
+int git_oidarray__add(git_array_oid_t *arr, git_oid *id)
+{
+	git_oid *add, *iter;
+	size_t i;
+
+	git_array_foreach(*arr, i, iter) {
+		if (git_oid_cmp(iter, id) == 0)
+			return 0;
+	}
+
+	if ((add = git_array_alloc(*arr)) == NULL)
+		return -1;
+
+	git_oid_cpy(add, id);
+	return 0;
+}
+
+bool git_oidarray__remove(git_array_oid_t *arr, git_oid *id)
+{
+	bool found = false;
+	size_t remain, i;
+	git_oid *iter;
+
+	git_array_foreach(*arr, i, iter) {
+		if (git_oid_cmp(iter, id) == 0) {
+			arr->size--;
+			remain = arr->size - i;
+
+			if (remain > 0)
+				memmove(&arr->ptr[i], &arr->ptr[i+1], remain * sizeof(git_oid));
+
+			found = true;
+			break;
+		}
+	}
+
+	return found;
+}
+
 #ifndef GIT_DEPRECATE_HARD
 
 void git_oidarray_free(git_oidarray *arr)

data/vendor/libgit2/src/libgit2/oidarray.h

@@ -15,6 +15,10 @@
 typedef git_array_t(git_oid) git_array_oid_t;
 
 extern void git_oidarray__reverse(git_oidarray *arr);
-extern void git_oidarray__from_array(git_oidarray *arr, git_array_oid_t *array);
+extern void git_oidarray__from_array(git_oidarray *out, const git_array_oid_t *array);
+extern void git_oidarray__to_array(git_array_oid_t *out, const git_oidarray *array);
+
+int git_oidarray__add(git_array_oid_t *arr, git_oid *id);
+bool git_oidarray__remove(git_array_oid_t *arr, git_oid *id);
 
 #endif

data/vendor/libgit2/src/libgit2/pack-objects.c

@@ -11,7 +11,6 @@
 #include "zstream.h"
 #include "delta.h"
 #include "iterator.h"
-#include "netops.h"
 #include "pack.h"
 #include "thread.h"
 #include "tree.h"
@@ -127,6 +126,7 @@ out:
 
 int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 {
+	git_hash_algorithm_t hash_algorithm;
 	git_packbuilder *pb;
 
 	*out = NULL;
@@ -134,6 +134,11 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	pb = git__calloc(1, sizeof(*pb));
 	GIT_ERROR_CHECK_ALLOC(pb);
 
+	pb->oid_type = repo->oid_type;
+
+	hash_algorithm = git_oid_algorithm(pb->oid_type);
+	GIT_ASSERT(hash_algorithm);
+
 	if (git_oidmap_new(&pb->object_ix) < 0 ||
 	    git_oidmap_new(&pb->walk_objects) < 0 ||
 	    git_pool_init(&pb->object_pool, sizeof(struct walk_object)) < 0)
@@ -142,7 +147,7 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	pb->repo = repo;
 	pb->nr_threads = 1; /* do not spawn any thread by default */
 
-	if (git_hash_ctx_init(&pb->ctx, GIT_HASH_ALGORITHM_SHA1) < 0 ||
+	if (git_hash_ctx_init(&pb->ctx, hash_algorithm) < 0 ||
 		git_zstream_init(&pb->zstream, GIT_ZSTREAM_DEFLATE) < 0 ||
 		git_repository_odb(&pb->odb, repo) < 0 ||
 		packbuilder_config(pb) < 0)
@@ -249,10 +254,10 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 	pb->done = false;
 
 	if (pb->progress_cb) {
-		double current_time = git__timer();
-		double elapsed = current_time - pb->last_progress_report_time;
+		uint64_t current_time = git_time_monotonic();
+		uint64_t elapsed = current_time - pb->last_progress_report_time;
 
-		if (elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
+		if (elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
 			pb->last_progress_report_time = current_time;
 
 			ret = pb->progress_cb(
@@ -315,9 +320,11 @@ static int write_object(
 	git_object_t type;
 	unsigned char hdr[10], *zbuf = NULL;
 	void *data = NULL;
-	size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len;
+	size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len, oid_size;
 	int error;
 
+	oid_size = git_oid_size(pb->oid_type);
+
 	/*
 	 * If we have a delta base, let's use the delta to save space.
 	 * Otherwise load the whole object. 'data' ends up pointing to
@@ -347,8 +354,8 @@ static int write_object(
 		goto done;
 
 	if (type == GIT_OBJECT_REF_DELTA) {
-		if ((error = write_cb(po->delta->id.id, GIT_OID_SHA1_SIZE, cb_data)) < 0 ||
-			(error = git_hash_update(&pb->ctx, po->delta->id.id, GIT_OID_SHA1_SIZE)) < 0)
+		if ((error = write_cb(po->delta->id.id, oid_size, cb_data)) < 0 ||
+		    (error = git_hash_update(&pb->ctx, po->delta->id.id, oid_size)) < 0)
 			goto done;
 	}
 
@@ -668,7 +675,7 @@ static int write_pack(git_packbuilder *pb,
 	if ((error = git_hash_final(entry_oid.id, &pb->ctx)) < 0)
 		goto done;
 
-	error = write_cb(entry_oid.id, GIT_OID_SHA1_SIZE, cb_data);
+	error = write_cb(entry_oid.id, git_oid_size(pb->oid_type), cb_data);
 
 done:
 	/* if callback cancelled writing, we must still free delta_data */
@@ -926,10 +933,10 @@ static int report_delta_progress(
 	int ret;
 
 	if (pb->progress_cb) {
-		double current_time = git__timer();
-		double elapsed = current_time - pb->last_progress_report_time;
+		uint64_t current_time = git_time_monotonic();
+		uint64_t elapsed = current_time - pb->last_progress_report_time;
 
-		if (force || elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
+		if (force || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
 			pb->last_progress_report_time = current_time;
 
 			ret = pb->progress_cb(

data/vendor/libgit2/src/libgit2/pack-objects.h

@@ -13,7 +13,6 @@
 #include "str.h"
 #include "hash.h"
 #include "oidmap.h"
-#include "netops.h"
 #include "zstream.h"
 #include "pool.h"
 #include "indexer.h"
@@ -56,6 +55,8 @@ struct git_packbuilder {
 	git_repository *repo; /* associated repository */
 	git_odb *odb; /* associated object database */
 
+	git_oid_t oid_type;
+
 	git_hash_ctx ctx;
 	git_zstream zstream;
 
@@ -94,7 +95,9 @@ struct git_packbuilder {
 
 	git_packbuilder_progress progress_cb;
 	void *progress_cb_payload;
-	double last_progress_report_time; /* the time progress was last reported */
+
+	/* the time progress was last reported, in millisecond ticks */
+	uint64_t last_progress_report_time;
 
 	bool done;
 };

data/vendor/libgit2/src/libgit2/pack.c

@@ -1268,13 +1268,13 @@ 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 + (p->oid_size + 4) * n)));
+		return ntohl(*((uint32_t *)(index + (p->oid_size + 4) * (size_t) n)));
 
-	index += 8 + p->num_objects * (p->oid_size + 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)

data/vendor/libgit2/src/libgit2/parse.c

@@ -102,13 +102,16 @@ int git_parse_advance_digit(int64_t *out, git_parse_ctx *ctx, int base)
 	return 0;
 }
 
-int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx)
+int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx, git_oid_t oid_type)
 {
-	if (ctx->line_len < GIT_OID_SHA1_HEXSIZE)
+	size_t oid_hexsize = git_oid_hexsize(oid_type);
+	GIT_ASSERT(oid_hexsize);
+
+	if (ctx->line_len < oid_hexsize)
 		return -1;
-	if ((git_oid__fromstrn(out, ctx->line, GIT_OID_SHA1_HEXSIZE, GIT_OID_SHA1)) < 0)
+	if ((git_oid__fromstrn(out, ctx->line, oid_hexsize, oid_type)) < 0)
 		return -1;
-	git_parse_advance_chars(ctx, GIT_OID_SHA1_HEXSIZE);
+	git_parse_advance_chars(ctx, oid_hexsize);
 	return 0;
 }
 

data/vendor/libgit2/src/libgit2/parse.h

@@ -50,7 +50,7 @@ int git_parse_advance_expected(
 int git_parse_advance_ws(git_parse_ctx *ctx);
 int git_parse_advance_nl(git_parse_ctx *ctx);
 int git_parse_advance_digit(int64_t *out, git_parse_ctx *ctx, int base);
-int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx);
+int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx, git_oid_t oid_type);
 
 enum GIT_PARSE_PEEK_FLAGS {
 	GIT_PARSE_PEEK_SKIP_WHITESPACE = (1 << 0)

data/vendor/libgit2/src/libgit2/patch.h

@@ -59,9 +59,15 @@ typedef struct {
 	 * This prefix will be removed when looking for files.  The default is 1.
 	 */
 	uint32_t prefix_len;
+
+	/**
+	 * The type of object IDs in the patch file. The default is
+	 * `GIT_OID_DEFAULT`.
+	 */
+	git_oid_t oid_type;
 } git_patch_options;
 
-#define GIT_PATCH_OPTIONS_INIT { 1 }
+#define GIT_PATCH_OPTIONS_INIT { 1, GIT_OID_DEFAULT }
 
 extern int git_patch__to_buf(git_str *out, git_patch *patch);
 extern void git_patch_free(git_patch *patch);

data/vendor/libgit2/src/libgit2/patch_generate.c

@@ -81,7 +81,8 @@ static void patch_generated_init_common(git_patch_generated *patch)
 
 static int patch_generated_normalize_options(
 	git_diff_options *out,
-	const git_diff_options *opts)
+	const git_diff_options *opts,
+	git_repository *repo)
 {
 	if (opts) {
 		GIT_ERROR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options");
@@ -91,6 +92,23 @@ static int patch_generated_normalize_options(
 		memcpy(out, &default_opts, sizeof(git_diff_options));
 	}
 
+	if (repo && opts && opts->oid_type && repo->oid_type != opts->oid_type) {
+		/*
+		 * This limitation feels unnecessary - we should consider
+		 * allowing users to generate diffs with a different object
+		 * ID format than the repository.
+		 */
+		git_error_set(GIT_ERROR_INVALID,
+			"specified object ID type does not match repository object ID type");
+		return -1;
+	} else if (repo) {
+		out->oid_type = repo->oid_type;
+	} else if (opts && opts->oid_type) {
+		out->oid_type = opts->oid_type;
+	} else {
+		out->oid_type = GIT_OID_DEFAULT;
+	}
+
 	out->old_prefix = opts && opts->old_prefix ?
 		git__strdup(opts->old_prefix) :
 		git__strdup(DIFF_OLD_PREFIX_DEFAULT);
@@ -118,7 +136,7 @@ static int patch_generated_init(
 	patch->delta_index = delta_index;
 
 	if ((error = patch_generated_normalize_options(
-			&patch->base.diff_opts, &diff->opts)) < 0 ||
+			&patch->base.diff_opts, &diff->opts, diff->repo)) < 0 ||
 		(error = git_diff_file_content__init_from_diff(
 			&patch->ofile, diff, patch->base.delta, true)) < 0 ||
 		(error = git_diff_file_content__init_from_diff(
@@ -449,7 +467,7 @@ static int patch_generated_from_sources(
 	git_xdiff_output *xo,
 	git_diff_file_content_src *oldsrc,
 	git_diff_file_content_src *newsrc,
-	const git_diff_options *opts)
+	const git_diff_options *given_opts)
 {
 	int error = 0;
 	git_repository *repo =
@@ -457,11 +475,12 @@ static int patch_generated_from_sources(
 		newsrc->blob ? git_blob_owner(newsrc->blob) : NULL;
 	git_diff_file *lfile = &pd->delta.old_file, *rfile = &pd->delta.new_file;
 	git_diff_file_content *ldata = &pd->patch.ofile, *rdata = &pd->patch.nfile;
+	git_diff_options *opts = &pd->patch.base.diff_opts;
 
-	if ((error = patch_generated_normalize_options(&pd->patch.base.diff_opts, opts)) < 0)
+	if ((error = patch_generated_normalize_options(opts, given_opts, repo)) < 0)
 		return error;
 
-	if (opts && (opts->flags & GIT_DIFF_REVERSE) != 0) {
+	if ((opts->flags & GIT_DIFF_REVERSE) != 0) {
 		void *tmp = lfile; lfile = rfile; rfile = tmp;
 		tmp = ldata; ldata = rdata; rdata = tmp;
 	}

data/vendor/libgit2/src/libgit2/patch_parse.c

@@ -166,15 +166,19 @@ static int parse_header_oid(
 	uint16_t *oid_len,
 	git_patch_parse_ctx *ctx)
 {
-	size_t len;
+	size_t hexsize, len;
+
+	hexsize = git_oid_hexsize(ctx->opts.oid_type);
 
-	for (len = 0; len < ctx->parse_ctx.line_len && len < GIT_OID_SHA1_HEXSIZE; len++) {
+	for (len = 0;
+	     len < ctx->parse_ctx.line_len && len < hexsize;
+	     len++) {
 		if (!git__isxdigit(ctx->parse_ctx.line[len]))
 			break;
 	}
 
-	if (len < GIT_OID_MINPREFIXLEN || len > GIT_OID_SHA1_HEXSIZE ||
-		git_oid__fromstrn(oid, ctx->parse_ctx.line, len, GIT_OID_SHA1) < 0)
+	if (len < GIT_OID_MINPREFIXLEN || len > hexsize ||
+		git_oid__fromstrn(oid, ctx->parse_ctx.line, len, ctx->opts.oid_type) < 0)
 		return git_parse_err("invalid hex formatted object id at line %"PRIuZ,
 			ctx->parse_ctx.line_num);
 
@@ -1065,12 +1069,14 @@ static int check_patch(git_patch_parsed *patch)
 		return git_parse_err("patch with no hunks");
 
 	if (delta->status == GIT_DELTA_ADDED) {
-		git_oid_clear(&delta->old_file.id, GIT_OID_SHA1);
+		git_oid_clear(&delta->old_file.id,
+			patch->base.diff_opts.oid_type);
 		delta->old_file.id_abbrev = 0;
 	}
 
 	if (delta->status == GIT_DELTA_DELETED) {
-		git_oid_clear(&delta->new_file.id, GIT_OID_SHA1);
+		git_oid_clear(&delta->new_file.id,
+			patch->base.diff_opts.oid_type);
 		delta->new_file.id_abbrev = 0;
 	}
 
@@ -1187,11 +1193,13 @@ int git_patch_parse(
 	patch->base.delta->status = GIT_DELTA_MODIFIED;
 	patch->base.delta->nfiles = 2;
 
+	patch->base.diff_opts.oid_type = ctx->opts.oid_type;
+
 	start = ctx->parse_ctx.remain_len;
 
 	if ((error = parse_patch_header(patch, ctx)) < 0 ||
-		(error = parse_patch_body(patch, ctx)) < 0 ||
-		(error = check_patch(patch)) < 0)
+	    (error = parse_patch_body(patch, ctx)) < 0 ||
+	    (error = check_patch(patch)) < 0)
 		goto done;
 
 	used = start - ctx->parse_ctx.remain_len;

data/vendor/libgit2/src/libgit2/push.c

@@ -118,8 +118,8 @@ static int parse_refspec(git_push *push, push_spec **spec, const char *str)
 	s = git__calloc(1, sizeof(*s));
 	GIT_ERROR_CHECK_ALLOC(s);
 
-	git_oid_clear(&s->loid, GIT_OID_SHA1);
-	git_oid_clear(&s->roid, GIT_OID_SHA1);
+	git_oid_clear(&s->loid, push->repo->oid_type);
+	git_oid_clear(&s->roid, push->repo->oid_type);
 
 	if (git_refspec__parse(&s->refspec, str, false) < 0) {
 		git_error_set(GIT_ERROR_INVALID, "invalid refspec %s", str);

data/vendor/libgit2/src/libgit2/reader.c

@@ -125,7 +125,7 @@ static int workdir_reader_read(
 		goto done;
 
 	if (out_id || reader->index) {
-		if ((error = git_odb__hash(&id, out->ptr, out->size, GIT_OBJECT_BLOB, GIT_OID_SHA1)) < 0)
+		if ((error = git_odb__hash(&id, out->ptr, out->size, GIT_OBJECT_BLOB, reader->repo->oid_type)) < 0)
 			goto done;
 	}