rugged 1.6.3 → 1.9.0

data/vendor/libgit2/src/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;
@@ -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;
@@ -1009,7 +1008,7 @@ int get_delta_base(
 		if (p->has_cache) {
 			struct git_pack_entry *entry;
 
-			if ((entry = git_oidmap_get(p->idx_cache, &base_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");
 
@@ -1268,13 +1267,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)
@@ -1351,7 +1350,7 @@ int git_pack_foreach_entry(
 				git_vector_insert(&oids, (void*)&current[4]);
 		}
 
-		git_vector_free(&offsets);
+		git_vector_dispose(&offsets);
 		p->ids = (unsigned char **)git_vector_detach(NULL, NULL, &oids);
 	}
 
@@ -1499,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;
@@ -1524,9 +1524,15 @@ 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]));

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

@@ -16,10 +16,9 @@
 #include "map.h"
 #include "mwindow.h"
 #include "odb.h"
-#include "offmap.h"
-#include "oidmap.h"
 #include "zstream.h"
 #include "oid.h"
+#include "hashmap_oid.h"
 
 /**
  * Function type for callbacks from git_pack_foreach_entry_offset.
@@ -83,12 +82,23 @@ typedef git_array_t(struct pack_chain_elem) git_dependency_chain;
 #define GIT_PACK_CACHE_MEMORY_LIMIT 16 * 1024 * 1024
 #define GIT_PACK_CACHE_SIZE_LIMIT 1024 * 1024 /* don't bother caching anything over 1MB */
 
+struct git_pack_entry {
+	off64_t offset;
+	git_oid id;
+	struct git_pack_file *p;
+};
+
+GIT_HASHMAP_STRUCT(git_pack_offsetmap, off64_t, git_pack_cache_entry *);
+
+GIT_HASHMAP_OID_STRUCT(git_pack_oidmap, struct git_pack_entry *);
+GIT_HASHMAP_OID_PROTOTYPES(git_pack_oidmap, struct git_pack_entry *);
+
 typedef struct {
 	size_t memory_used;
 	size_t memory_limit;
 	size_t use_ctr;
 	git_mutex lock;
-	git_offmap *entries;
+	git_pack_offsetmap entries;
 } git_pack_cache;
 
 struct git_pack_file {
@@ -110,7 +120,8 @@ struct git_pack_file {
 
 	int index_version;
 	git_time_t mtime;
-	git_oidmap *idx_cache;
+
+	git_pack_oidmap idx_cache;
 	unsigned char **ids;
 
 	git_pack_cache bases; /* delta base cache */
@@ -139,12 +150,6 @@ int git_pack__lookup_id(
 	const unsigned char *id_prefix,
 	const git_oid_t oid_type);
 
-struct git_pack_entry {
-	off64_t offset;
-	git_oid id;
-	struct git_pack_file *p;
-};
-
 typedef struct git_packfile_stream {
 	off64_t curpos;
 	int done;

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);
 
@@ -558,9 +562,9 @@ fail:
 
 static int eof_for_origin(int origin) {
 	if (origin == GIT_DIFF_LINE_ADDITION)
-		return GIT_DIFF_LINE_ADD_EOFNL;
-	if (origin == GIT_DIFF_LINE_DELETION)
 		return GIT_DIFF_LINE_DEL_EOFNL;
+	if (origin == GIT_DIFF_LINE_DELETION)
+		return GIT_DIFF_LINE_ADD_EOFNL;
 	return GIT_DIFF_LINE_CONTEXT_EOFNL;
 }
 
@@ -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/path.c

@@ -202,7 +202,7 @@ GIT_INLINE(size_t) common_prefix_icase(const char *str, size_t len, const char *
 {
 	size_t count = 0;
 
-	while (len > 0 && tolower(*str) == tolower(*prefix)) {
+	while (len > 0 && git__tolower(*str) == git__tolower(*prefix)) {
 		count++;
 		str++;
 		prefix++;

data/vendor/libgit2/src/libgit2/pathspec.c

@@ -105,7 +105,7 @@ int git_pathspec__vinit(
 /* free data from the pathspec vector */
 void git_pathspec__vfree(git_vector *vspec)
 {
-	git_vector_free_deep(vspec);
+	git_vector_dispose_deep(vspec);
 }
 
 struct pathspec_match_context {

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

@@ -56,14 +56,22 @@ int git_push_new(git_push **out, git_remote *remote, const git_push_options *opt
 	}
 
 	if (git_vector_init(&p->status, 0, push_status_ref_cmp) < 0) {
-		git_vector_free(&p->specs);
+		git_vector_dispose(&p->specs);
 		git__free(p);
 		return -1;
 	}
 
 	if (git_vector_init(&p->updates, 0, NULL) < 0) {
-		git_vector_free(&p->status);
-		git_vector_free(&p->specs);
+		git_vector_dispose(&p->status);
+		git_vector_dispose(&p->specs);
+		git__free(p);
+		return -1;
+	}
+
+	if (git_vector_init(&p->remote_push_options, 0, git__strcmp_cb) < 0) {
+		git_vector_dispose(&p->status);
+		git_vector_dispose(&p->specs);
+		git_vector_dispose(&p->updates);
 		git__free(p);
 		return -1;
 	}
@@ -118,8 +126,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);
@@ -213,12 +221,25 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 			fire_callback = 0;
 		}
 
-		if (fire_callback && callbacks && callbacks->update_tips) {
-			error = callbacks->update_tips(git_str_cstr(&remote_ref_name),
-						&push_spec->roid, &push_spec->loid, callbacks->payload);
+		if (!fire_callback || !callbacks)
+			continue;
 
-			if (error < 0)
-				goto on_error;
+		if (callbacks->update_refs)
+			error = callbacks->update_refs(
+				git_str_cstr(&remote_ref_name),
+				&push_spec->roid, &push_spec->loid,
+				&push_spec->refspec, callbacks->payload);
+#ifndef GIT_DEPRECATE_HARD
+		else if (callbacks->update_tips)
+			error = callbacks->update_tips(
+				git_str_cstr(&remote_ref_name),
+				&push_spec->roid, &push_spec->loid,
+				callbacks->payload);
+#endif
+
+		if (error < 0) {
+			git_error_set_after_callback_function(error, "git_remote_push");
+			goto on_error;
 		}
 	}
 
@@ -275,6 +296,7 @@ static int queue_objects(git_push *push)
 
 	git_vector_foreach(&push->specs, i, spec) {
 		git_object_t type;
+		git_oid id;
 		size_t size;
 
 		if (git_oid_is_zero(&spec->loid))
@@ -296,20 +318,20 @@ static int queue_objects(git_push *push)
 			if ((error = enqueue_tag(&target, push, &spec->loid)) < 0)
 				goto on_error;
 
-			if (git_object_type(target) == GIT_OBJECT_COMMIT) {
-				if ((error = git_revwalk_push(rw, git_object_id(target))) < 0) {
-					git_object_free(target);
-					goto on_error;
-				}
-			} else {
-				if ((error = git_packbuilder_insert(
-					push->pb, git_object_id(target), NULL)) < 0) {
-					git_object_free(target);
-					goto on_error;
-				}
-			}
+			type = git_object_type(target);
+			git_oid_cpy(&id, git_object_id(target));
+
 			git_object_free(target);
-		} else if ((error = git_revwalk_push(rw, &spec->loid)) < 0)
+		} else {
+			git_oid_cpy(&id, &spec->loid);
+		}
+
+		if (type == GIT_OBJECT_COMMIT)
+			error = git_revwalk_push(rw, &id);
+		else
+			error = git_packbuilder_insert(push->pb, &id, NULL);
+
+		if (error < 0)
 			goto on_error;
 
 		if (!spec->refspec.force) {
@@ -444,10 +466,21 @@ static int do_push(git_push *push)
 	if ((error = calculate_work(push)) < 0)
 		goto on_error;
 
-	if (callbacks && callbacks->push_negotiation &&
-	    (error = callbacks->push_negotiation((const git_push_update **) push->updates.contents,
-					  push->updates.length, callbacks->payload)) < 0)
-	    goto on_error;
+	if (callbacks && callbacks->push_negotiation) {
+		git_error_clear();
+
+		error = callbacks->push_negotiation(
+			(const git_push_update **) push->updates.contents,
+			push->updates.length, callbacks->payload);
+
+		if (error < 0) {
+			git_error_set_after_callback_function(error,
+				"push_negotiation");
+			goto on_error;
+		}
+
+		error = 0;
+	}
 
 	if ((error = queue_objects(push)) < 0 ||
 	    (error = transport->push(transport, push)) < 0)
@@ -479,12 +512,24 @@ static int filter_refs(git_remote *remote)
 int git_push_finish(git_push *push)
 {
 	int error;
+	unsigned int remote_caps;
 
 	if (!git_remote_connected(push->remote)) {
 		git_error_set(GIT_ERROR_NET, "remote is disconnected");
 		return -1;
 	}
 
+	if ((error = git_remote_capabilities(&remote_caps, push->remote)) < 0) {
+		git_error_set(GIT_ERROR_INVALID, "remote capabilities not available");
+		return -1;
+	}
+
+	if (git_vector_length(&push->remote_push_options) > 0 &&
+	    !(remote_caps & GIT_REMOTE_CAPABILITY_PUSH_OPTIONS)) {
+		git_error_set(GIT_ERROR_INVALID, "push-options not supported by remote");
+		return -1;
+	}
+
 	if ((error = filter_refs(push->remote)) < 0 ||
 	    (error = do_push(push)) < 0)
 		return error;
@@ -528,6 +573,7 @@ void git_push_free(git_push *push)
 	push_spec *spec;
 	push_status *status;
 	git_push_update *update;
+	char *option;
 	unsigned int i;
 
 	if (push == NULL)
@@ -536,19 +582,24 @@ void git_push_free(git_push *push)
 	git_vector_foreach(&push->specs, i, spec) {
 		free_refspec(spec);
 	}
-	git_vector_free(&push->specs);
+	git_vector_dispose(&push->specs);
 
 	git_vector_foreach(&push->status, i, status) {
 		git_push_status_free(status);
 	}
-	git_vector_free(&push->status);
+	git_vector_dispose(&push->status);
 
 	git_vector_foreach(&push->updates, i, update) {
 		git__free(update->src_refname);
 		git__free(update->dst_refname);
 		git__free(update);
 	}
-	git_vector_free(&push->updates);
+	git_vector_dispose(&push->updates);
+
+	git_vector_foreach(&push->remote_push_options, i, option) {
+		git__free(option);
+	}
+	git_vector_dispose(&push->remote_push_options);
 
 	git__free(push);
 }

data/vendor/libgit2/src/libgit2/push.h

@@ -34,6 +34,7 @@ struct git_push {
 	git_vector specs;
 	git_vector updates;
 	bool report_status;
+	git_vector remote_push_options;
 
 	/* report-status */
 	bool unpack_ok;

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;
 	}