rugged 0.28.4 → 0.28.4.1

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

@@ -38,7 +38,7 @@ struct tree_walk_context {
 
 struct pack_write_context {
 	git_indexer *indexer;
-	git_indexer_progress *stats;
+	git_transfer_progress *stats;
 };
 
 struct walk_object {
@@ -141,10 +141,12 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	pb = git__calloc(1, sizeof(*pb));
 	GIT_ERROR_CHECK_ALLOC(pb);
 
-	if (git_oidmap_new(&pb->object_ix) < 0)
+	pb->object_ix = git_oidmap_alloc();
+	if (!pb->object_ix)
 		goto on_error;
 
-	if (git_oidmap_new(&pb->walk_objects) < 0)
+	pb->walk_objects = git_oidmap_alloc();
+	if (!pb->walk_objects)
 		goto on_error;
 
 	git_pool_init(&pb->object_pool, sizeof(struct walk_object));
@@ -192,26 +194,24 @@ unsigned int git_packbuilder_set_threads(git_packbuilder *pb, unsigned int n)
 	return pb->nr_threads;
 }
 
-static int rehash(git_packbuilder *pb)
+static void rehash(git_packbuilder *pb)
 {
 	git_pobject *po;
-	size_t i;
+	size_t pos, i;
+	int ret;
 
 	git_oidmap_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)
-			return -1;
+		pos = git_oidmap_put(pb->object_ix, &po->id, &ret);
+		git_oidmap_set_value_at(pb->object_ix, pos, po);
 	}
-
-	return 0;
 }
 
 int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 			   const char *name)
 {
 	git_pobject *po;
-	size_t newsize;
+	size_t newsize, pos;
 	int ret;
 
 	assert(pb && oid);
@@ -223,7 +223,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 
 	if (pb->nr_objects >= pb->nr_alloc) {
 		GIT_ERROR_CHECK_ALLOC_ADD(&newsize, pb->nr_alloc, 1024);
-		GIT_ERROR_CHECK_ALLOC_MULTIPLY(&newsize, newsize / 2, 3);
+		GIT_ERROR_CHECK_ALLOC_MULTIPLY(&newsize, newsize, 3 / 2);
 
 		if (!git__is_uint32(newsize)) {
 			git_error_set(GIT_ERROR_NOMEMORY, "packfile too large to fit in memory.");
@@ -235,9 +235,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 		pb->object_list = git__reallocarray(pb->object_list,
 			pb->nr_alloc, sizeof(*po));
 		GIT_ERROR_CHECK_ALLOC(pb->object_list);
-
-		if (rehash(pb) < 0)
-			return -1;
+		rehash(pb);
 	}
 
 	po = pb->object_list + pb->nr_objects;
@@ -250,10 +248,13 @@ 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) {
+	pos = git_oidmap_put(pb->object_ix, &po->id, &ret);
+	if (ret < 0) {
 		git_error_set_oom();
-		return -1;
+		return ret;
 	}
+	assert(ret != 0);
+	git_oidmap_set_value_at(pb->object_ix, pos, po);
 
 	pb->done = false;
 
@@ -513,12 +514,15 @@ static int cb_tag_foreach(const char *name, git_oid *oid, void *data)
 {
 	git_packbuilder *pb = data;
 	git_pobject *po;
+	size_t pos;
 
 	GIT_UNUSED(name);
 
-	if ((po = git_oidmap_get(pb->object_ix, oid)) == NULL)
+	pos = git_oidmap_lookup_index(pb->object_ix, oid);
+	if (!git_oidmap_valid_index(pb->object_ix, pos))
 		return 0;
 
+	po = git_oidmap_value_at(pb->object_ix, pos);
 	po->tagged = 1;
 
 	/* TODO: peel objects */
@@ -1379,12 +1383,12 @@ int git_packbuilder_write(
 	git_packbuilder *pb,
 	const char *path,
 	unsigned int mode,
-	git_indexer_progress_cb progress_cb,
+	git_transfer_progress_cb progress_cb,
 	void *progress_cb_payload)
 {
 	git_indexer_options opts = GIT_INDEXER_OPTIONS_INIT;
 	git_indexer *indexer;
-	git_indexer_progress stats;
+	git_transfer_progress stats;
 	struct pack_write_context ctx;
 	int t;
 
@@ -1397,7 +1401,7 @@ int git_packbuilder_write(
 		&indexer, path, mode, pb->odb, &opts) < 0)
 		return -1;
 
-	if (!git_repository__configmap_lookup(&t, pb->repo, GIT_CONFIGMAP_FSYNCOBJECTFILES) && t)
+	if (!git_repository__cvar(&t, pb->repo, GIT_CVAR_FSYNCOBJECTFILES) && t)
 		git_indexer__set_fsync(indexer, 1);
 
 	ctx.indexer = indexer;
@@ -1535,15 +1539,18 @@ static int lookup_walk_object(struct walk_object **out, git_packbuilder *pb, con
 
 static int retrieve_object(struct walk_object **out, git_packbuilder *pb, const git_oid *id)
 {
-	struct walk_object *obj;
 	int error;
+	size_t pos;
+	struct walk_object *obj;
 
-	if ((obj = git_oidmap_get(pb->walk_objects, id)) == NULL) {
+	pos = git_oidmap_lookup_index(pb->walk_objects, id);
+	if (git_oidmap_valid_index(pb->walk_objects, pos)) {
+		obj = git_oidmap_value_at(pb->walk_objects, pos);
+	} else {
 		if ((error = lookup_walk_object(&obj, pb, id)) < 0)
 			return error;
 
-		if ((error = git_oidmap_set(pb->walk_objects, &obj->id, obj)) < 0)
-			return error;
+		git_oidmap_insert(pb->walk_objects, &obj->id, obj, &error);
 	}
 
 	*out = obj;

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

@@ -30,7 +30,7 @@
 typedef struct git_pobject {
 	git_oid id;
 	git_object_t type;
-	off64_t offset;
+	git_off_t offset;
 
 	size_t size;
 

data/vendor/libgit2/src/pack.c

@@ -11,21 +11,18 @@
 #include "delta.h"
 #include "sha1_lookup.h"
 #include "mwindow.h"
-#include "futils.h"
+#include "fileops.h"
 #include "oid.h"
 
 #include <zlib.h>
 
-/* Option to bypass checking existence of '.keep' files */
-bool git_disable_pack_keep_file_checks = false;
-
 static int packfile_open(struct git_pack_file *p);
-static off64_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n);
+static git_off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n);
 static int packfile_unpack_compressed(
 		git_rawobj *obj,
 		struct git_pack_file *p,
 		git_mwindow **w_curs,
-		off64_t *curpos,
+		git_off_t *curpos,
 		size_t size,
 		git_object_t type);
 
@@ -37,7 +34,7 @@ static int packfile_unpack_compressed(
  * GIT_OID_MINPREFIXLEN and GIT_OID_HEXSZ.
  */
 static int pack_entry_find_offset(
-		off64_t *offset_out,
+		git_off_t *offset_out,
 		git_oid *found_oid,
 		struct git_pack_file *p,
 		const git_oid *short_oid,
@@ -92,8 +89,8 @@ static void cache_free(git_pack_cache *cache)
 
 static int cache_init(git_pack_cache *cache)
 {
-	if (git_offmap_new(&cache->entries) < 0)
-		return -1;
+	cache->entries = git_offmap_alloc();
+	GIT_ERROR_CHECK_ALLOC(cache->entries);
 
 	cache->memory_limit = GIT_PACK_CACHE_MEMORY_LIMIT;
 
@@ -109,14 +106,17 @@ static int cache_init(git_pack_cache *cache)
 	return 0;
 }
 
-static git_pack_cache_entry *cache_get(git_pack_cache *cache, off64_t offset)
+static git_pack_cache_entry *cache_get(git_pack_cache *cache, git_off_t offset)
 {
-	git_pack_cache_entry *entry;
+	git_pack_cache_entry *entry = NULL;
+	size_t k;
 
 	if (git_mutex_lock(&cache->lock) < 0)
 		return NULL;
 
-	if ((entry = git_offmap_get(cache->entries, offset)) != NULL) {
+	k = git_offmap_lookup_index(cache->entries, offset);
+	if (git_offmap_valid_index(cache->entries, k)) { /* found it */
+		entry = git_offmap_value_at(cache->entries, k);
 		git_atomic_inc(&entry->refcount);
 		entry->last_usage = cache->use_ctr++;
 	}
@@ -128,7 +128,7 @@ 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_off_t offset;
 	git_pack_cache_entry *entry;
 
 	git_offmap_foreach(cache->entries, offset, entry, {
@@ -144,10 +144,11 @@ static int cache_add(
 		git_pack_cache_entry **cached_out,
 		git_pack_cache *cache,
 		git_rawobj *base,
-		off64_t offset)
+		git_off_t offset)
 {
 	git_pack_cache_entry *entry;
-	int exists;
+	int error, exists = 0;
+	size_t k;
 
 	if (base->len > GIT_PACK_CACHE_SIZE_LIMIT)
 		return -1;
@@ -165,7 +166,9 @@ static int cache_add(
 			while (cache->memory_used + base->len > cache->memory_limit)
 				free_lowest_entry(cache);
 
-			git_offmap_set(cache->entries, offset, entry);
+			k = git_offmap_put(cache->entries, offset, &error);
+			assert(error != 0);
+			git_offmap_set_value_at(cache->entries, k, entry);
 			cache->memory_used += entry->raw.len;
 
 			*cached_out = entry;
@@ -345,7 +348,7 @@ static int pack_index_open(struct git_pack_file *p)
 static unsigned char *pack_window_open(
 		struct git_pack_file *p,
 		git_mwindow **w_cursor,
-		off64_t offset,
+		git_off_t offset,
 		unsigned int *left)
 {
 	if (p->mwf.fd == -1 && packfile_open(p) < 0)
@@ -441,7 +444,7 @@ int git_packfile_unpack_header(
 		git_object_t *type_p,
 		git_mwindow_file *mwf,
 		git_mwindow **w_curs,
-		off64_t *curpos)
+		git_off_t *curpos)
 {
 	unsigned char *base;
 	unsigned int left;
@@ -474,13 +477,13 @@ int git_packfile_resolve_header(
 		size_t *size_p,
 		git_object_t *type_p,
 		struct git_pack_file *p,
-		off64_t offset)
+		git_off_t offset)
 {
 	git_mwindow *w_curs = NULL;
-	off64_t curpos = offset;
+	git_off_t curpos = offset;
 	size_t size;
 	git_object_t type;
-	off64_t base_offset;
+	git_off_t base_offset;
 	int error;
 
 	error = git_packfile_unpack_header(&size, &type, &p->mwf, &w_curs, &curpos);
@@ -528,13 +531,13 @@ int git_packfile_resolve_header(
  * cache, we stop calculating there.
  */
 static int pack_dependency_chain(git_dependency_chain *chain_out,
-				 git_pack_cache_entry **cached_out, off64_t *cached_off,
+				 git_pack_cache_entry **cached_out, git_off_t *cached_off,
 				 struct pack_chain_elem *small_stack, size_t *stack_sz,
-				 struct git_pack_file *p, off64_t obj_offset)
+				 struct git_pack_file *p, git_off_t obj_offset)
 {
 	git_dependency_chain chain = GIT_ARRAY_INIT;
 	git_mwindow *w_curs = NULL;
-	off64_t curpos = obj_offset, base_offset;
+	git_off_t curpos = obj_offset, base_offset;
 	int error = 0, use_heap = 0;
 	size_t size, elem_pos;
 	git_object_t type;
@@ -619,10 +622,10 @@ on_error:
 int git_packfile_unpack(
 	git_rawobj *obj,
 	struct git_pack_file *p,
-	off64_t *obj_offset)
+	git_off_t *obj_offset)
 {
 	git_mwindow *w_curs = NULL;
-	off64_t curpos = *obj_offset;
+	git_off_t curpos = *obj_offset;
 	int error, free_base = 0;
 	git_dependency_chain chain = GIT_ARRAY_INIT;
 	struct pack_chain_elem *elem = NULL, *stack;
@@ -777,7 +780,7 @@ static void use_git_free(void *opaq, void *ptr)
 	git__free(ptr);
 }
 
-int git_packfile_stream_open(git_packfile_stream *obj, struct git_pack_file *p, off64_t curpos)
+int git_packfile_stream_open(git_packfile_stream *obj, struct git_pack_file *p, git_off_t curpos)
 {
 	int st;
 
@@ -846,7 +849,7 @@ static int packfile_unpack_compressed(
 	git_rawobj *obj,
 	struct git_pack_file *p,
 	git_mwindow **w_curs,
-	off64_t *curpos,
+	git_off_t *curpos,
 	size_t size,
 	git_object_t type)
 {
@@ -909,16 +912,16 @@ static int packfile_unpack_compressed(
  * curpos is where the data starts, delta_obj_offset is the where the
  * header starts
  */
-off64_t get_delta_base(
+git_off_t get_delta_base(
 	struct git_pack_file *p,
 	git_mwindow **w_curs,
-	off64_t *curpos,
+	git_off_t *curpos,
 	git_object_t type,
-	off64_t delta_obj_offset)
+	git_off_t delta_obj_offset)
 {
 	unsigned int left = 0;
 	unsigned char *base_info;
-	off64_t base_offset;
+	git_off_t base_offset;
 	git_oid unused;
 
 	base_info = pack_window_open(p, w_curs, *curpos, &left);
@@ -951,13 +954,14 @@ off64_t get_delta_base(
 	} else if (type == GIT_OBJECT_REF_DELTA) {
 		/* If we have the cooperative cache, search in it first */
 		if (p->has_cache) {
-			struct git_pack_entry *entry;
 			git_oid oid;
+			size_t k;
 
 			git_oid_fromraw(&oid, base_info);
-			if ((entry = git_oidmap_get(p->idx_cache, &oid)) != NULL) {
+			k = git_oidmap_lookup_index(p->idx_cache, &oid);
+			if (git_oidmap_valid_index(p->idx_cache, k)) {
 				*curpos += 20;
-				return entry->offset;
+				return ((struct git_pack_entry *)git_oidmap_value_at(p->idx_cache, k))->offset;
 			} else {
 				/* If we're building an index, don't try to find the pack
 				 * entry; we just haven't seen it yet.  We'll make
@@ -1045,7 +1049,7 @@ static int packfile_open(struct git_pack_file *p)
 	if (!p->mwf.size) {
 		if (!S_ISREG(st.st_mode))
 			goto cleanup;
-		p->mwf.size = (off64_t)st.st_size;
+		p->mwf.size = (git_off_t)st.st_size;
 	} else if (p->mwf.size != st.st_size)
 		goto cleanup;
 
@@ -1137,11 +1141,9 @@ int git_packfile_alloc(struct git_pack_file **pack_out, const char *path)
 	if (git__suffixcmp(path, ".idx") == 0) {
 		size_t root_len = path_len - strlen(".idx");
 
-		if (!git_disable_pack_keep_file_checks) {
-			memcpy(p->pack_name + root_len, ".keep", sizeof(".keep"));
-			if (git_path_exists(p->pack_name) == true)
-				p->pack_keep = 1;
-		}
+		memcpy(p->pack_name + root_len, ".keep", sizeof(".keep"));
+		if (git_path_exists(p->pack_name) == true)
+			p->pack_keep = 1;
 
 		memcpy(p->pack_name + root_len, ".pack", sizeof(".pack"));
 	}
@@ -1182,7 +1184,7 @@ int git_packfile_alloc(struct git_pack_file **pack_out, const char *path)
  *
  ***********************************************************/
 
-static off64_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n)
+static git_off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n)
 {
 	const unsigned char *index = p->index_map.data;
 	const unsigned char *end = index + p->index_map.len;
@@ -1270,7 +1272,7 @@ int git_pack_foreach_entry(
 }
 
 static int pack_entry_find_offset(
-	off64_t *offset_out,
+	git_off_t *offset_out,
 	git_oid *found_oid,
 	struct git_pack_file *p,
 	const git_oid *short_oid,
@@ -1280,7 +1282,7 @@ static int pack_entry_find_offset(
 	const unsigned char *index;
 	unsigned hi, lo, stride;
 	int pos, found = 0;
-	off64_t offset;
+	git_off_t offset;
 	const unsigned char *current = 0;
 
 	*offset_out = 0;
@@ -1375,7 +1377,7 @@ int git_pack_entry_find(
 		const git_oid *short_oid,
 		size_t len)
 {
-	off64_t offset;
+	git_off_t offset;
 	git_oid found_oid;
 	int error;
 

data/vendor/libgit2/src/pack.h

@@ -17,7 +17,6 @@
 #include "map.h"
 #include "mwindow.h"
 #include "odb.h"
-#include "offmap.h"
 #include "oidmap.h"
 #include "array.h"
 
@@ -64,14 +63,17 @@ typedef struct git_pack_cache_entry {
 } git_pack_cache_entry;
 
 struct pack_chain_elem {
-	off64_t base_key;
-	off64_t offset;
+	git_off_t base_key;
+	git_off_t offset;
 	size_t size;
 	git_object_t type;
 };
 
 typedef git_array_t(struct pack_chain_elem) git_dependency_chain;
 
+#include "offmap.h"
+#include "oidmap.h"
+
 #define GIT_PACK_CACHE_MEMORY_LIMIT 16 * 1024 * 1024
 #define GIT_PACK_CACHE_SIZE_LIMIT 1024 * 1024 /* don't bother caching anything over 1MB */
 
@@ -108,13 +110,13 @@ struct git_pack_file {
 };
 
 struct git_pack_entry {
-	off64_t offset;
+	git_off_t offset;
 	git_oid sha1;
 	struct git_pack_file *p;
 };
 
 typedef struct git_packfile_stream {
-	off64_t curpos;
+	git_off_t curpos;
 	int done;
 	z_stream zstream;
 	struct git_pack_file *p;
@@ -130,23 +132,23 @@ int git_packfile_unpack_header(
 		git_object_t *type_p,
 		git_mwindow_file *mwf,
 		git_mwindow **w_curs,
-		off64_t *curpos);
+		git_off_t *curpos);
 
 int git_packfile_resolve_header(
 		size_t *size_p,
 		git_object_t *type_p,
 		struct git_pack_file *p,
-		off64_t offset);
+		git_off_t offset);
 
-int git_packfile_unpack(git_rawobj *obj, struct git_pack_file *p, off64_t *obj_offset);
+int git_packfile_unpack(git_rawobj *obj, struct git_pack_file *p, git_off_t *obj_offset);
 
-int git_packfile_stream_open(git_packfile_stream *obj, struct git_pack_file *p, off64_t curpos);
+int git_packfile_stream_open(git_packfile_stream *obj, struct git_pack_file *p, git_off_t curpos);
 ssize_t git_packfile_stream_read(git_packfile_stream *obj, void *buffer, size_t len);
 void git_packfile_stream_dispose(git_packfile_stream *obj);
 
-off64_t get_delta_base(struct git_pack_file *p, git_mwindow **w_curs,
-		off64_t *curpos, git_object_t type,
-		off64_t delta_obj_offset);
+git_off_t get_delta_base(struct git_pack_file *p, git_mwindow **w_curs,
+		git_off_t *curpos, git_object_t type,
+		git_off_t delta_obj_offset);
 
 void git_packfile_close(struct git_pack_file *p, bool unlink_packfile);
 void git_packfile_free(struct git_pack_file *p);