rugged 0.28.4 → 0.28.4.1

data/vendor/libgit2/src/tree-cache.c

@@ -120,14 +120,12 @@ static int read_tree_internal(git_tree_cache **out,
 
 	/* Parse children: */
 	if (tree->children_count > 0) {
-		size_t i, bufsize;
+		unsigned int i;
 
-		GIT_ERROR_CHECK_ALLOC_MULTIPLY(&bufsize, tree->children_count, sizeof(git_tree_cache*));
-
-		tree->children = git_pool_malloc(pool, bufsize);
+		tree->children = git_pool_malloc(pool, tree->children_count * sizeof(git_tree_cache *));
 		GIT_ERROR_CHECK_ALLOC(tree->children);
 
-		memset(tree->children, 0x0, bufsize);
+		memset(tree->children, 0x0, tree->children_count * sizeof(git_tree_cache *));
 
 		for (i = 0; i < tree->children_count; ++i) {
 			if (read_tree_internal(&tree->children[i], &buffer, buffer_end, pool) < 0)
@@ -162,7 +160,7 @@ int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer
 static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_pool *pool)
 {
 	git_repository *repo;
-	size_t i, j, nentries, ntrees, alloc_size;
+	size_t i, j, nentries, ntrees;
 	int error;
 
 	repo = git_tree_owner(tree);
@@ -184,10 +182,8 @@ static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_
 			ntrees++;
 	}
 
-	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&alloc_size, ntrees, sizeof(git_tree_cache *));
-
 	cache->children_count = ntrees;
-	cache->children = git_pool_mallocz(pool, alloc_size);
+	cache->children = git_pool_mallocz(pool, ntrees * sizeof(git_tree_cache *));
 	GIT_ERROR_CHECK_ALLOC(cache->children);
 
 	j = 0;
@@ -236,14 +232,11 @@ int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_poo
 
 int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool)
 {
-	size_t name_len, alloc_size;
+	size_t name_len;
 	git_tree_cache *tree;
 
 	name_len = strlen(name);
-
-	GIT_ERROR_CHECK_ALLOC_ADD3(&alloc_size, sizeof(git_tree_cache), name_len, 1);
-
-	tree = git_pool_malloc(pool, alloc_size);
+	tree = git_pool_malloc(pool, sizeof(git_tree_cache) + name_len + 1);
 	GIT_ERROR_CHECK_ALLOC(tree);
 
 	memset(tree, 0x0, sizeof(git_tree_cache));

data/vendor/libgit2/src/tree.c

@@ -10,7 +10,7 @@
 #include "commit.h"
 #include "git2/repository.h"
 #include "git2/object.h"
-#include "futils.h"
+#include "fileops.h"
 #include "tree-cache.h"
 #include "index.h"
 
@@ -340,11 +340,11 @@ size_t git_tree_entrycount(const git_tree *tree)
 	return tree->entries.size;
 }
 
-size_t git_treebuilder_entrycount(git_treebuilder *bld)
+unsigned int git_treebuilder_entrycount(git_treebuilder *bld)
 {
 	assert(bld);
 
-	return git_strmap_size(bld->map);
+	return git_strmap_num_entries(bld->map);
 }
 
 static int tree_error(const char *str, const char *path)
@@ -479,7 +479,7 @@ static int check_entry(git_repository *repo, const char *filename, const git_oid
 	if (!valid_entry_name(repo, filename))
 		return tree_error("failed to insert entry: invalid name for a tree entry", filename);
 
-	if (git_oid_is_zero(id))
+	if (git_oid_iszero(id))
 		return tree_error("failed to insert entry: invalid null OID", filename);
 
 	if (filemode != GIT_FILEMODE_COMMIT &&
@@ -507,7 +507,8 @@ static int append_entry(
 
 	entry->attr = (uint16_t)filemode;
 
-	if ((error = git_strmap_set(bld->map, entry->filename, entry)) < 0) {
+	git_strmap_insert(bld->map, entry->filename, entry, &error);
+	if (error < 0) {
 		git_tree_entry_free(entry);
 		git_error_set(GIT_ERROR_TREE, "failed to append entry %s to the tree builder", filename);
 		return -1;
@@ -687,7 +688,7 @@ int git_treebuilder_new(
 
 	bld->repo = repo;
 
-	if (git_strmap_new(&bld->map) < 0) {
+	if (git_strmap_alloc(&bld->map) < 0) {
 		git__free(bld);
 		return -1;
 	}
@@ -722,19 +723,24 @@ int git_treebuilder_insert(
 {
 	git_tree_entry *entry;
 	int error;
+	size_t pos;
 
 	assert(bld && id && filename);
 
 	if ((error = check_entry(bld->repo, filename, id, filemode)) < 0)
 		return error;
 
-	if ((entry = git_strmap_get(bld->map, filename)) != NULL) {
+	pos = git_strmap_lookup_index(bld->map, filename);
+	if (git_strmap_valid_index(bld->map, pos)) {
+		entry = git_strmap_value_at(bld->map, pos);
 		git_oid_cpy((git_oid *) entry->oid, id);
 	} else {
 		entry = alloc_entry(filename, strlen(filename), id);
 		GIT_ERROR_CHECK_ALLOC(entry);
 
-		if ((error = git_strmap_set(bld->map, entry->filename, entry)) < 0) {
+		git_strmap_insert(bld->map, entry->filename, entry, &error);
+
+		if (error < 0) {
 			git_tree_entry_free(entry);
 			git_error_set(GIT_ERROR_TREE, "failed to insert %s", filename);
 			return -1;
@@ -751,8 +757,16 @@ int git_treebuilder_insert(
 
 static git_tree_entry *treebuilder_get(git_treebuilder *bld, const char *filename)
 {
+	git_tree_entry *entry = NULL;
+	size_t pos;
+
 	assert(bld && filename);
-	return git_strmap_get(bld->map, filename);
+
+	pos = git_strmap_lookup_index(bld->map, filename);
+	if (git_strmap_valid_index(bld->map, pos))
+		entry = git_strmap_value_at(bld->map, pos);
+
+	return entry;
 }
 
 const git_tree_entry *git_treebuilder_get(git_treebuilder *bld, const char *filename)
@@ -797,7 +811,7 @@ int git_treebuilder_write_with_buffer(git_oid *oid, git_treebuilder *bld, git_bu
 
 	git_buf_clear(tree);
 
-	entrycount = git_strmap_size(bld->map);
+	entrycount = git_strmap_num_entries(bld->map);
 	if ((error = git_vector_init(&entries, entrycount, entry_sort_cmp)) < 0)
 		goto out;
 

data/vendor/libgit2/src/unix/map.c

@@ -32,7 +32,7 @@ int git__mmap_alignment(size_t *alignment)
   return git__page_size(alignment);
 }
 
-int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, off64_t offset)
+int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset)
 {
 	int mprot = PROT_READ;
 	int mflag = 0;

data/vendor/libgit2/src/unix/posix.h

@@ -59,7 +59,7 @@ GIT_INLINE(int) p_fsync(int fd)
 #define p_strcasecmp(s1, s2) strcasecmp(s1, s2)
 #define p_strncasecmp(s1, s2, c) strncasecmp(s1, s2, c)
 #define p_vsnprintf(b, c, f, a) vsnprintf(b, c, f, a)
-#define p_snprintf snprintf
+#define p_snprintf(b, c, ...) snprintf(b, c, __VA_ARGS__)
 #define p_mkstemp(p) mkstemp(p)
 #define p_chdir(p) chdir(p)
 #define p_chmod(p,m) chmod(p, m)
@@ -89,4 +89,14 @@ GIT_INLINE(int) p_futimes(int f, const struct p_timeval t[2])
 # define p_futimes futimes
 #endif
 
+#ifdef GIT_USE_REGCOMP_L
+#include <xlocale.h>
+GIT_INLINE(int) p_regcomp(regex_t *preg, const char *pattern, int cflags)
+{
+	return regcomp_l(preg, pattern, cflags, (locale_t) 0);
+}
+#else
+# define p_regcomp regcomp
+#endif
+
 #endif

data/vendor/libgit2/src/userdiff.h

@@ -7,8 +7,6 @@
 #ifndef INCLUDE_userdiff_h__
 #define INCLUDE_userdiff_h__
 
-#include "regexp.h"
-
 /*
  * This file isolates the built in diff driver function name patterns.
  * Most of these patterns are taken from Git (with permission from the
@@ -31,7 +29,7 @@ typedef struct {
 #define PATTERNS(NAME, FN_PATS, WORD_PAT) \
 	{ NAME, FN_PATS, WORD_PAT WORD_DEFAULT, 0 }
 #define IPATTERN(NAME, FN_PATS, WORD_PAT) \
-	{ NAME, FN_PATS, WORD_PAT WORD_DEFAULT, GIT_REGEXP_ICASE }
+	{ NAME, FN_PATS, WORD_PAT WORD_DEFAULT, REG_ICASE }
 
 /*
  * The table of diff driver patterns

data/vendor/libgit2/src/util.c

@@ -192,7 +192,7 @@ int git__strntol32(int32_t *result, const char *nptr, size_t nptr_len, const cha
 
 	tmp_int = tmp_long & 0xFFFFFFFF;
 	if (tmp_int != tmp_long) {
-		int len = (int)(tmp_endptr - nptr);
+		int len = tmp_endptr - nptr;
 		git_error_set(GIT_ERROR_INVALID, "failed to convert: '%.*s' is too large", len, nptr);
 		return -1;
 	}
@@ -204,6 +204,13 @@ int git__strntol32(int32_t *result, const char *nptr, size_t nptr_len, const cha
 	return error;
 }
 
+int git__strcmp(const char *a, const char *b)
+{
+	while (*a && *b && *a == *b)
+		++a, ++b;
+	return (int)(*(const unsigned char *)a) - (int)(*(const unsigned char *)b);
+}
+
 int git__strcasecmp(const char *a, const char *b)
 {
 	while (*a && *b && git__tolower(*a) == git__tolower(*b))
@@ -233,6 +240,15 @@ int git__strcasesort_cmp(const char *a, const char *b)
 	return cmp;
 }
 
+int git__strncmp(const char *a, const char *b, size_t sz)
+{
+	while (sz && *a && *b && *a == *b)
+		--sz, ++a, ++b;
+	if (!sz)
+		return 0;
+	return (int)(*(const unsigned char *)a) - (int)(*(const unsigned char *)b);
+}
+
 int git__strncasecmp(const char *a, const char *b, size_t sz)
 {
 	int al, bl;
@@ -285,18 +301,7 @@ GIT_INLINE(int) prefixcmp(const char *str, size_t str_n, const char *prefix, boo
 
 int git__prefixcmp(const char *str, const char *prefix)
 {
-	unsigned char s, p;
-
-	while (1) {
-		p = *prefix++;
-		s = *str++;
-
-		if (!p)
-			return 0;
-
-		if (s != p)
-			return s - p;
-	}
+	return prefixcmp(str, SIZE_MAX, prefix, false);
 }
 
 int git__prefixncmp(const char *str, size_t str_n, const char *prefix)
@@ -719,37 +724,6 @@ static int GIT_STDLIB_CALL git__qsort_r_glue_cmp(
 }
 #endif
 
-
-#if !defined(HAVE_QSORT_R_BSD) && \
-	!defined(HAVE_QSORT_R_GNU) && \
-	!defined(HAVE_QSORT_S)
-static void swap(uint8_t *a, uint8_t *b, size_t elsize)
-{
-	char tmp[256];
-
-	while (elsize) {
-		size_t n = elsize < sizeof(tmp) ? elsize : sizeof(tmp);
-		memcpy(tmp, a + elsize - n, n);
-		memcpy(a + elsize - n, b + elsize - n, n);
-		memcpy(b + elsize - n, tmp, n);
-		elsize -= n;
-	}
-}
-
-static void insertsort(
-	void *els, size_t nel, size_t elsize,
-	git__sort_r_cmp cmp, void *payload)
-{
-	uint8_t *base = els;
-	uint8_t *end = base + nel * elsize;
-	uint8_t *i, *j;
-
-	for (i = base + elsize; i < end; i += elsize)
-		for (j = i; j > base && cmp(j, j - elsize, payload) < 0; j -= elsize)
-			swap(j, j - elsize, elsize);
-}
-#endif
-
 void git__qsort_r(
 	void *els, size_t nel, size_t elsize, git__sort_r_cmp cmp, void *payload)
 {
@@ -762,10 +736,33 @@ void git__qsort_r(
 	git__qsort_r_glue glue = { cmp, payload };
 	qsort_s(els, nel, elsize, git__qsort_r_glue_cmp, &glue);
 #else
-	insertsort(els, nel, elsize, cmp, payload);
+	git__insertsort_r(els, nel, elsize, NULL, cmp, payload);
 #endif
 }
 
+void git__insertsort_r(
+	void *els, size_t nel, size_t elsize, void *swapel,
+	git__sort_r_cmp cmp, void *payload)
+{
+	uint8_t *base = els;
+	uint8_t *end = base + nel * elsize;
+	uint8_t *i, *j;
+	bool freeswap = !swapel;
+
+	if (freeswap)
+		swapel = git__malloc(elsize);
+
+	for (i = base + elsize; i < end; i += elsize)
+		for (j = i; j > base && cmp(j, j - elsize, payload) < 0; j -= elsize) {
+			memcpy(swapel, j, elsize);
+			memcpy(j, j - elsize, elsize);
+			memcpy(j - elsize, swapel, elsize);
+		}
+
+	if (freeswap)
+		git__free(swapel);
+}
+
 /*
  * git__utf8_iterate is taken from the utf8proc project,
  * http://www.public-software-group.org/utf8proc
@@ -810,23 +807,23 @@ static const int8_t utf8proc_utf8class[256] = {
 	4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0
 };
 
-int git__utf8_charlen(const uint8_t *str, size_t str_len)
+int git__utf8_charlen(const uint8_t *str, int str_len)
 {
-	size_t length, i;
+	int length, i;
 
 	length = utf8proc_utf8class[str[0]];
 	if (!length)
 		return -1;
 
-	if (str_len > 0 && length > str_len)
-		return -1;
+	if (str_len >= 0 && length > str_len)
+		return -str_len;
 
 	for (i = 1; i < length; i++) {
 		if ((str[i] & 0xC0) != 0x80)
-			return -1;
+			return -i;
 	}
 
-	return (int)length;
+	return length;
 }
 
 int git__utf8_iterate(const uint8_t *str, int str_len, int32_t *dst)
@@ -867,6 +864,11 @@ int git__utf8_iterate(const uint8_t *str, int str_len, int32_t *dst)
 	return length;
 }
 
+double git_time_monotonic(void)
+{
+	return git__timer();
+}
+
 size_t git__utf8_valid_buf_length(const uint8_t *str, size_t str_len)
 {
 	size_t offset = 0;

data/vendor/libgit2/src/util.h

@@ -30,17 +30,6 @@
 # define max(a,b) ((a) > (b) ? (a) : (b))
 #endif
 
-#if defined(__GNUC__)
-# define GIT_CONTAINER_OF(ptr, type, member) \
-	__builtin_choose_expr( \
-	    __builtin_offsetof(type, member) == 0 && \
-	    __builtin_types_compatible_p(typeof(&((type *) 0)->member), typeof(ptr)), \
-		((type *) (ptr)), \
-		(void)0)
-#else
-# define GIT_CONTAINER_OF(ptr, type, member) (type *)(ptr)
-#endif
-
 #define GIT_DATE_RFC2822_SZ  32
 
 /**
@@ -137,6 +126,10 @@ extern void git__tsort_r(
 extern void git__qsort_r(
 	void *els, size_t nel, size_t elsize, git__sort_r_cmp cmp, void *payload);
 
+extern void git__insertsort_r(
+	void *els, size_t nel, size_t elsize, void *swapel,
+	git__sort_r_cmp cmp, void *payload);
+
 /**
  * @param position If non-NULL, this will be set to the position where the
  * 		element is or would be inserted if not found.
@@ -157,13 +150,12 @@ extern int git__bsearch_r(
 	void *payload,
 	size_t *position);
 
-#define git__strcmp strcmp
-#define git__strncmp strncmp
-
 extern int git__strcmp_cb(const void *a, const void *b);
 extern int git__strcasecmp_cb(const void *a, const void *b);
 
+extern int git__strcmp(const char *a, const char *b);
 extern int git__strcasecmp(const char *a, const char *b);
+extern int git__strncmp(const char *a, const char *b, size_t sz);
 extern int git__strncasecmp(const char *a, const char *b, size_t sz);
 
 extern int git__strcasesort_cmp(const char *a, const char *b);
@@ -357,9 +349,22 @@ GIT_INLINE(void) git__memzero(void *data, size_t size)
 
 GIT_INLINE(double) git__timer(void)
 {
-	/* GetTickCount64 returns the number of milliseconds that have
+	/* We need the initial tick count to detect if the tick
+	 * count has rolled over. */
+	static DWORD initial_tick_count = 0;
+
+	/* GetTickCount returns the number of milliseconds that have
 	 * elapsed since the system was started. */
-	return (double) GetTickCount64() / (double) 1000;
+	DWORD count = GetTickCount();
+
+	if(initial_tick_count == 0) {
+		initial_tick_count = count;
+	} else if (count < initial_tick_count) {
+		/* The tick count has rolled over - adjust for it. */
+		count = (0xFFFFFFFF - initial_tick_count) + count;
+	}
+
+	return (double) count / (double) 1000;
 }
 
 #elif __APPLE__

data/vendor/libgit2/src/win32/map.c

@@ -50,7 +50,7 @@ int git__mmap_alignment(size_t *page_size)
 	return 0;
 }
 
-int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, off64_t offset)
+int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset)
 {
 	HANDLE fh = (HANDLE)_get_osfhandle(fd);
 	DWORD alignment = get_allocation_granularity();
@@ -58,8 +58,8 @@ int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, off64_t offset
 	DWORD view_prot = 0;
 	DWORD off_low = 0;
 	DWORD off_hi = 0;
-	off64_t page_start;
-	off64_t page_offset;
+	git_off_t page_start;
+	git_off_t page_offset;
 
 	GIT_MMAP_VALIDATE(out, len, prot, flags);
 
@@ -99,6 +99,8 @@ int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, off64_t offset
 		return -1;
 	}
 
+	assert(sizeof(git_off_t) == 8);
+
 	off_low = (DWORD)(page_start);
 	off_hi = (DWORD)(page_start >> 32);
 	out->data = MapViewOfFile(out->fmh, view_prot, off_hi, off_low, len);