rugged 1.7.2 → 1.9.4

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

@@ -9,7 +9,7 @@
 
 #include "git2/oid.h"
 #include "repository.h"
-#include "threadstate.h"
+#include "runtime.h"
 #include <string.h>
 #include <limits.h>
 
@@ -22,6 +22,8 @@ const git_oid git_oid__empty_tree_sha1 =
 	  { 0x4b, 0x82, 0x5d, 0xc6, 0x42, 0xcb, 0x6e, 0xb9, 0xa0, 0x60,
 	    0xe5, 0x4b, 0xf8, 0xd6, 0x92, 0x88, 0xfb, 0xee, 0x49, 0x04 });
 
+static const unsigned char git_oid_zero[GIT_OID_MAX_SIZE] = {0};
+
 static int oid_error_invalid(const char *msg)
 {
 	git_error_set(GIT_ERROR_INVALID, "unable to parse OID - %s", msg);
@@ -153,15 +155,42 @@ int git_oid_pathfmt(char *str, const git_oid *oid)
 	return 0;
 }
 
+static git_tlsdata_key thread_str_key;
+
+static void GIT_SYSTEM_CALL thread_str_free(void *s)
+{
+	char *str = (char *)s;
+	git__free(str);
+}
+
+static void thread_str_global_shutdown(void)
+{
+	char *str = git_tlsdata_get(thread_str_key);
+	git_tlsdata_set(thread_str_key, NULL);
+
+	git__free(str);
+	git_tlsdata_dispose(thread_str_key);
+}
+
+int git_oid_global_init(void)
+{
+	if (git_tlsdata_init(&thread_str_key, thread_str_free) != 0)
+		return -1;
+
+	return git_runtime_shutdown_register(thread_str_global_shutdown);
+}
+
 char *git_oid_tostr_s(const git_oid *oid)
 {
-	git_threadstate *threadstate = git_threadstate_get();
 	char *str;
 
-	if (!threadstate)
-		return NULL;
+	if ((str = git_tlsdata_get(thread_str_key)) == NULL) {
+		if ((str = git__malloc(GIT_OID_MAX_HEXSIZE + 1)) == NULL)
+			return NULL;
+
+		git_tlsdata_set(thread_str_key, str);
+	}
 
-	str = threadstate->oid_fmt;
 	git_oid_nfmt(str, git_oid_hexsize(git_oid_type(oid)) + 1, oid);
 	return str;
 }
@@ -291,7 +320,7 @@ int git_oid_streq(const git_oid *oid_a, const char *str)
 int git_oid_is_zero(const git_oid *oid_a)
 {
 	const unsigned char *a = oid_a->id;
-	size_t size = git_oid_size(git_oid_type(oid_a)), i;
+	size_t size = git_oid_size(git_oid_type(oid_a));
 
 #ifdef GIT_EXPERIMENTAL_SHA256
 	if (!oid_a->type)
@@ -300,10 +329,7 @@ int git_oid_is_zero(const git_oid *oid_a)
 		return 0;
 #endif
 
-	for (i = 0; i < size; ++i, ++a)
-		if (*a != 0)
-			return 0;
-	return 1;
+	return git_oid_raw_cmp(a, git_oid_zero, size) == 0 ? 1 : 0;
 }
 
 #ifndef GIT_DEPRECATE_HARD

data/vendor/libgit2/src/libgit2/oid.h

@@ -66,6 +66,15 @@ GIT_INLINE(size_t) git_oid_hexsize(git_oid_t type)
 	return 0;
 }
 
+GIT_INLINE(bool) git_oid_type_is_valid(git_oid_t type)
+{
+	return (type == GIT_OID_SHA1
+#ifdef GIT_EXPERIMENTAL_SHA256
+	     || type == GIT_OID_SHA256
+#endif
+	);
+}
+
 GIT_INLINE(const char *) git_oid_type_name(git_oid_t type)
 {
 	switch (type) {
@@ -270,4 +279,6 @@ int git_oid__fromstrn(
 
 int git_oid__fromraw(git_oid *out, const unsigned char *raw, git_oid_t type);
 
+int git_oid_global_init(void);
+
 #endif

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

@@ -64,6 +64,9 @@ struct walk_object {
 /* Size of the buffer to feed to zlib */
 #define COMPRESS_BUFLEN (1024 * 1024)
 
+GIT_HASHMAP_OID_FUNCTIONS(git_packbuilder_pobjectmap, GIT_HASHMAP_INLINE, git_pobject *);
+GIT_HASHMAP_OID_FUNCTIONS(git_packbuilder_walk_objectmap, GIT_HASHMAP_INLINE, struct walk_object *);
+
 static unsigned name_hash(const char *name)
 {
 	unsigned c, hash = 0;
@@ -139,9 +142,7 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	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)
+	if (git_pool_init(&pb->object_pool, sizeof(struct walk_object)) < 0)
 		goto on_error;
 
 	pb->repo = repo;
@@ -192,10 +193,10 @@ static int rehash(git_packbuilder *pb)
 	git_pobject *po;
 	size_t i;
 
-	git_oidmap_clear(pb->object_ix);
+	git_packbuilder_pobjectmap_clear(&pb->object_ix);
 
 	for (i = 0, po = pb->object_list; i < pb->nr_objects; i++, po++) {
-		if (git_oidmap_set(pb->object_ix, &po->id, po) < 0)
+		if (git_packbuilder_pobjectmap_put(&pb->object_ix, &po->id, po) < 0)
 			return -1;
 	}
 
@@ -214,7 +215,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 
 	/* If the object already exists in the hash table, then we don't
 	 * have any work to do */
-	if (git_oidmap_exists(pb->object_ix, oid))
+	if (git_packbuilder_pobjectmap_contains(&pb->object_ix, oid))
 		return 0;
 
 	if (pb->nr_objects >= pb->nr_alloc) {
@@ -246,7 +247,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 	git_oid_cpy(&po->id, oid);
 	po->hash = name_hash(name);
 
-	if (git_oidmap_set(pb->object_ix, &po->id, po) < 0) {
+	if (git_packbuilder_pobjectmap_put(&pb->object_ix, &po->id, po) < 0) {
 		git_error_set_oom();
 		return -1;
 	}
@@ -515,7 +516,7 @@ static int cb_tag_foreach(const char *name, git_oid *oid, void *data)
 
 	GIT_UNUSED(name);
 
-	if ((po = git_oidmap_get(pb->object_ix, oid)) == NULL)
+	if (git_packbuilder_pobjectmap_get(&po, &pb->object_ix, oid) != 0)
 		return 0;
 
 	po->tagged = 1;
@@ -932,6 +933,9 @@ static int report_delta_progress(
 {
 	int ret;
 
+	if (pb->failure)
+		return pb->failure;
+
 	if (pb->progress_cb) {
 		uint64_t current_time = git_time_monotonic();
 		uint64_t elapsed = current_time - pb->last_progress_report_time;
@@ -943,8 +947,10 @@ static int report_delta_progress(
 				GIT_PACKBUILDER_DELTAFICATION,
 				count, pb->nr_objects, pb->progress_cb_payload);
 
-			if (ret)
+			if (ret) {
+				pb->failure = ret;
 				return git_error_set_after_callback(ret);
+			}
 		}
 	}
 
@@ -976,7 +982,10 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 		}
 
 		pb->nr_deltified += 1;
-		report_delta_progress(pb, pb->nr_deltified, false);
+		if ((error = report_delta_progress(pb, pb->nr_deltified, false)) < 0) {
+				GIT_ASSERT(git_packbuilder__progress_unlock(pb) == 0);
+				goto on_error;
+		}
 
 		po = *list++;
 		(*list_size)--;
@@ -1124,6 +1133,10 @@ struct thread_params {
 	size_t depth;
 	size_t working;
 	size_t data_ready;
+
+	/* A pb->progress_cb can stop the packing process by returning an error.
+	   When that happens, all threads observe the error and stop voluntarily. */
+	bool stopped;
 };
 
 static void *threaded_find_deltas(void *arg)
@@ -1133,7 +1146,12 @@ static void *threaded_find_deltas(void *arg)
 	while (me->remaining) {
 		if (find_deltas(me->pb, me->list, &me->remaining,
 				me->window, me->depth) < 0) {
-			; /* TODO */
+			me->stopped = true;
+			GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_lock(me->pb) == 0, NULL);
+			me->working = false;
+			git_cond_signal(&me->pb->progress_cond);
+			GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_unlock(me->pb) == 0, NULL);
+			return NULL;
 		}
 
 		GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_lock(me->pb) == 0, NULL);
@@ -1175,8 +1193,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		pb->nr_threads = git__online_cpus();
 
 	if (pb->nr_threads <= 1) {
-		find_deltas(pb, list, &list_size, window, depth);
-		return 0;
+		return find_deltas(pb, list, &list_size, window, depth);
 	}
 
 	p = git__mallocarray(pb->nr_threads, sizeof(*p));
@@ -1195,6 +1212,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		p[i].depth = depth;
 		p[i].working = 1;
 		p[i].data_ready = 0;
+		p[i].stopped = 0;
 
 		/* try to split chunks on "path" boundaries */
 		while (sub_size && sub_size < list_size &&
@@ -1262,7 +1280,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 			    (!victim || victim->remaining < p[i].remaining))
 				victim = &p[i];
 
-		if (victim) {
+		if (victim && !target->stopped) {
 			sub_size = victim->remaining / 2;
 			list = victim->list + victim->list_size - sub_size;
 			while (sub_size && list[0]->hash &&
@@ -1286,7 +1304,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		}
 		target->list_size = sub_size;
 		target->remaining = sub_size;
-		target->working = 1;
+		target->working = 1; /* even when target->stopped, so that we don't process this thread again */
 		GIT_ASSERT(git_packbuilder__progress_unlock(pb) == 0);
 
 		if (git_mutex_lock(&target->mutex)) {
@@ -1299,7 +1317,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		git_cond_signal(&target->cond);
 		git_mutex_unlock(&target->mutex);
 
-		if (!sub_size) {
+		if (target->stopped || !sub_size) {
 			git_thread_join(&target->thread, NULL);
 			git_cond_free(&target->cond);
 			git_mutex_free(&target->mutex);
@@ -1308,7 +1326,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 	}
 
 	git__free(p);
-	return 0;
+	return pb->failure;
 }
 
 #else
@@ -1319,6 +1337,7 @@ int git_packbuilder__prepare(git_packbuilder *pb)
 {
 	git_pobject **delta_list;
 	size_t i, n = 0;
+	int error;
 
 	if (pb->nr_objects == 0 || pb->done)
 		return 0; /* nothing to do */
@@ -1327,8 +1346,10 @@ int git_packbuilder__prepare(git_packbuilder *pb)
 	 * Although we do not report progress during deltafication, we
 	 * at least report that we are in the deltafication stage
 	 */
-	if (pb->progress_cb)
-			pb->progress_cb(GIT_PACKBUILDER_DELTAFICATION, 0, pb->nr_objects, pb->progress_cb_payload);
+	if (pb->progress_cb) {
+		if ((error = pb->progress_cb(GIT_PACKBUILDER_DELTAFICATION, 0, pb->nr_objects, pb->progress_cb_payload)) < 0)
+			return git_error_set_after_callback(error);
+	}
 
 	delta_list = git__mallocarray(pb->nr_objects, sizeof(*delta_list));
 	GIT_ERROR_CHECK_ALLOC(delta_list);
@@ -1345,31 +1366,33 @@ int git_packbuilder__prepare(git_packbuilder *pb)
 
 	if (n > 1) {
 		git__tsort((void **)delta_list, n, type_size_sort);
-		if (ll_find_deltas(pb, delta_list, n,
+		if ((error = ll_find_deltas(pb, delta_list, n,
 				   GIT_PACK_WINDOW + 1,
-				   GIT_PACK_DEPTH) < 0) {
+				   GIT_PACK_DEPTH)) < 0) {
 			git__free(delta_list);
-			return -1;
+			return error;
 		}
 	}
 
-	report_delta_progress(pb, pb->nr_objects, true);
+	error = report_delta_progress(pb, pb->nr_objects, true);
 
 	pb->done = true;
 	git__free(delta_list);
-	return 0;
+	return error;
 }
 
-#define PREPARE_PACK if (git_packbuilder__prepare(pb) < 0) { return -1; }
+#define PREPARE_PACK error = git_packbuilder__prepare(pb); if (error < 0) { return error; }
 
 int git_packbuilder_foreach(git_packbuilder *pb, int (*cb)(void *buf, size_t size, void *payload), void *payload)
 {
+	int error;
 	PREPARE_PACK;
 	return write_pack(pb, cb, payload);
 }
 
 int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb)
 {
+	int error;
 	PREPARE_PACK;
 
 	return write_pack(pb, &write_pack_buf, buf);
@@ -1397,7 +1420,7 @@ int git_packbuilder_write(
 	git_str object_path = GIT_STR_INIT;
 	git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT;
 	git_indexer *indexer = NULL;
-	git_indexer_progress stats;
+	git_indexer_progress stats = { 0 };
 	struct pack_write_context ctx;
 	int t;
 
@@ -1414,13 +1437,12 @@ int git_packbuilder_write(
 	opts.progress_cb = progress_cb;
 	opts.progress_cb_payload = progress_cb_payload;
 
-	/* TODO: SHA256 */
-
 #ifdef GIT_EXPERIMENTAL_SHA256
 	opts.mode = mode;
 	opts.odb = pb->odb;
+	opts.oid_type = pb->oid_type;
 
-	error = git_indexer_new(&indexer, path, GIT_OID_SHA1, &opts);
+	error = git_indexer_new(&indexer, path, &opts);
 #else
 	error = git_indexer_new(&indexer, path, mode, pb->odb, &opts);
 #endif
@@ -1584,12 +1606,16 @@ static int retrieve_object(struct walk_object **out, git_packbuilder *pb, const
 	struct walk_object *obj;
 	int error;
 
-	if ((obj = git_oidmap_get(pb->walk_objects, id)) == NULL) {
+	error = git_packbuilder_walk_objectmap_get(&obj, &pb->walk_objects, id);
+
+	if (error == GIT_ENOTFOUND) {
 		if ((error = lookup_walk_object(&obj, pb, id)) < 0)
 			return error;
 
-		if ((error = git_oidmap_set(pb->walk_objects, &obj->id, obj)) < 0)
+		if ((error = git_packbuilder_walk_objectmap_put(&pb->walk_objects, &obj->id, obj)) < 0)
 			return error;
+	} else if (error != 0) {
+		return error;
 	}
 
 	*out = obj;
@@ -1821,13 +1847,12 @@ void git_packbuilder_free(git_packbuilder *pb)
 	if (pb->odb)
 		git_odb_free(pb->odb);
 
-	if (pb->object_ix)
-		git_oidmap_free(pb->object_ix);
+	git_packbuilder_pobjectmap_dispose(&pb->object_ix);
 
 	if (pb->object_list)
 		git__free(pb->object_list);
 
-	git_oidmap_free(pb->walk_objects);
+	git_packbuilder_walk_objectmap_dispose(&pb->walk_objects);
 	git_pool_clear(&pb->object_pool);
 
 	git_hash_ctx_cleanup(&pb->ctx);

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

@@ -12,10 +12,10 @@
 
 #include "str.h"
 #include "hash.h"
-#include "oidmap.h"
 #include "zstream.h"
 #include "pool.h"
 #include "indexer.h"
+#include "hashmap_oid.h"
 
 #include "git2/oid.h"
 #include "git2/pack.h"
@@ -51,6 +51,11 @@ typedef struct git_pobject {
 	             filled:1;
 } git_pobject;
 
+typedef struct walk_object walk_object;
+
+GIT_HASHMAP_OID_STRUCT(git_packbuilder_pobjectmap, git_pobject *);
+GIT_HASHMAP_OID_STRUCT(git_packbuilder_walk_objectmap, walk_object *);
+
 struct git_packbuilder {
 	git_repository *repo; /* associated repository */
 	git_odb *odb; /* associated object database */
@@ -69,9 +74,8 @@ struct git_packbuilder {
 
 	git_pobject *object_list;
 
-	git_oidmap *object_ix;
-
-	git_oidmap *walk_objects;
+	git_packbuilder_pobjectmap object_ix;
+	git_packbuilder_walk_objectmap walk_objects;
 	git_pool object_pool;
 
 #ifndef GIT_DEPRECATE_HARD
@@ -100,6 +104,10 @@ struct git_packbuilder {
 	uint64_t last_progress_report_time;
 
 	bool done;
+
+	/* A non-zero error code in failure causes all threads to shut themselves
+	   down. Some functions will return this error code.  */
+	volatile int failure;
 };
 
 int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb);

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;
@@ -942,6 +941,9 @@ static int packfile_unpack_compressed(
 		goto out;
 	}
 
+	/* zlib may have garbled the trailing buffer */
+	data[size] = '\0';
+
 	obj->type = type;
 	obj->len = size;
 	obj->data = data;
@@ -1009,7 +1011,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");
 
@@ -1351,7 +1353,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 +1501,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 +1527,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/patch_parse.c

@@ -562,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;
 }
 

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 {