rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/path.h

@@ -13,8 +13,6 @@
 #include "buffer.h"
 #include "vector.h"
 
-#include "git2/sys/path.h"
-
 /**
  * Path manipulation utils
  *
@@ -647,9 +645,79 @@ extern bool git_path_isvalid(
  */
 int git_path_normalize_slashes(git_buf *out, const char *path);
 
-bool git_path_supports_symlinks(const char *dir);
+/**
+ * Check whether a path component corresponds to a .gitmodules file
+ *
+ * @param name the path component to check
+ * @param len the length of `name`
+ */
+extern int git_path_is_dotgit_modules(const char *name, size_t len);
+
+/**
+ * Check whether a path component corresponds to a .gitmodules file in NTFS
+ *
+ * @param name the path component to check
+ * @param len the length of `name`
+ */
+extern int git_path_is_ntfs_dotgit_modules(const char *name, size_t len);
+
+/**
+ * Check whether a path component corresponds to a .gitmodules file in HFS+
+ *
+ * @param name the path component to check
+ * @param len the length of `name`
+ */
+extern int git_path_is_hfs_dotgit_modules(const char *name, size_t len);
+
+/**
+ * Check whether a path component corresponds to a .gitignore file
+ *
+ * @param name the path component to check
+ * @param len the length of `name`
+ */
+extern int git_path_is_dotgit_ignore(const char *name, size_t len);
+
+/**
+ * Check whether a path component corresponds to a .gitignore file in NTFS
+ *
+ * @param name the path component to check
+ * @param len the length of `name`
+ */
+extern int git_path_is_ntfs_dotgit_ignore(const char *name, size_t len);
+
+/**
+ * Check whether a path component corresponds to a .gitignore file in HFS+
+ *
+ * @param name the path component to check
+ * @param len the length of `name`
+ */
+extern int git_path_is_hfs_dotgit_ignore(const char *name, size_t len);
+
+/**
+ * Check whether a path component corresponds to a .gitignore file
+ *
+ * @param name the path component to check
+ * @param len the length of `name`
+ */
+extern int git_path_is_dotgit_attributes(const char *name, size_t len);
+
+/**
+ * Check whether a path component corresponds to a .gitattributes file in NTFS
+ *
+ * @param name the path component to check
+ * @param len the length of `name`
+ */
+extern int git_path_is_ntfs_dotgit_attributes(const char *name, size_t len);
 
 /**
+ * Check whether a path component corresponds to a .gitattributes file in HFS+
+ *
+ * @param name the path component to check
+ * @param len the length of `name`
+ */
+extern int git_path_is_hfs_dotgit_attributes(const char *name, size_t len);
+
+/*
  * Validate a system file's ownership
  *
  * Verify that the file in question is owned by an administrator or system

data/vendor/libgit2/src/pathspec.c

@@ -16,7 +16,6 @@
 #include "index.h"
 #include "bitvec.h"
 #include "diff.h"
-#include "wildmatch.h"
 
 /* what is the common non-wildcard prefix for all items in the pathspec */
 char *git_pathspec_prefix(const git_strarray *pathspec)
@@ -37,7 +36,7 @@ char *git_pathspec_prefix(const git_strarray *pathspec)
 	git_buf_truncate(&prefix, scan - prefix.ptr);
 
 	if (prefix.size <= 0) {
-		git_buf_dispose(&prefix);
+		git_buf_free(&prefix);
 		return NULL;
 	}
 
@@ -85,7 +84,8 @@ int git_pathspec__vinit(
 		if (!match)
 			return -1;
 
-		match->flags = GIT_ATTR_FNMATCH_ALLOWSPACE | GIT_ATTR_FNMATCH_ALLOWNEG;
+		match->flags = GIT_ATTR_FNMATCH_ALLOWSPACE |
+			GIT_ATTR_FNMATCH_ALLOWNEG | GIT_ATTR_FNMATCH_NOLEADINGDIR;
 
 		ret = git_attr_fnmatch__parse(match, strpool, NULL, &pattern);
 		if (ret == GIT_ENOTFOUND) {
@@ -110,7 +110,7 @@ void git_pathspec__vfree(git_vector *vspec)
 }
 
 struct pathspec_match_context {
-	int wildmatch_flags;
+	int fnmatch_flags;
 	int (*strcomp)(const char *, const char *);
 	int (*strncomp)(const char *, const char *, size_t);
 };
@@ -121,11 +121,11 @@ static void pathspec_match_context_init(
 	bool casefold)
 {
 	if (disable_fnmatch)
-		ctxt->wildmatch_flags = -1;
+		ctxt->fnmatch_flags = -1;
 	else if (casefold)
-		ctxt->wildmatch_flags = WM_CASEFOLD;
+		ctxt->fnmatch_flags = FNM_CASEFOLD;
 	else
-		ctxt->wildmatch_flags = 0;
+		ctxt->fnmatch_flags = 0;
 
 	if (casefold) {
 		ctxt->strcomp  = git__strcasecmp;
@@ -141,16 +141,16 @@ static int pathspec_match_one(
 	struct pathspec_match_context *ctxt,
 	const char *path)
 {
-	int result = (match->flags & GIT_ATTR_FNMATCH_MATCH_ALL) ? 0 : WM_NOMATCH;
+	int result = (match->flags & GIT_ATTR_FNMATCH_MATCH_ALL) ? 0 : FNM_NOMATCH;
 
-	if (result == WM_NOMATCH)
-		result = ctxt->strcomp(match->pattern, path) ? WM_NOMATCH : 0;
+	if (result == FNM_NOMATCH)
+		result = ctxt->strcomp(match->pattern, path) ? FNM_NOMATCH : 0;
 
-	if (ctxt->wildmatch_flags >= 0 && result == WM_NOMATCH)
-		result = wildmatch(match->pattern, path, ctxt->wildmatch_flags);
+	if (ctxt->fnmatch_flags >= 0 && result == FNM_NOMATCH)
+		result = p_fnmatch(match->pattern, path, ctxt->fnmatch_flags);
 
 	/* if we didn't match, look for exact dirname prefix match */
-	if (result == WM_NOMATCH &&
+	if (result == FNM_NOMATCH &&
 		(match->flags & GIT_ATTR_FNMATCH_HASWILD) == 0 &&
 		ctxt->strncomp(path, match->pattern, match->length) == 0 &&
 		path[match->length] == '/')
@@ -159,7 +159,7 @@ static int pathspec_match_one(
 	/* if we didn't match and this is a negative match, check for exact
 	 * match of filename with leading '!'
 	 */
-	if (result == WM_NOMATCH &&
+	if (result == FNM_NOMATCH &&
 		(match->flags & GIT_ATTR_FNMATCH_NEGATIVE) != 0 &&
 		*path == '!' &&
 		ctxt->strncomp(path + 1, match->pattern, match->length) == 0 &&
@@ -258,7 +258,7 @@ int git_pathspec_new(git_pathspec **out, const git_strarray *pathspec)
 {
 	int error = 0;
 	git_pathspec *ps = git__malloc(sizeof(git_pathspec));
-	GIT_ERROR_CHECK_ALLOC(ps);
+	GITERR_CHECK_ALLOC(ps);
 
 	if ((error = git_pathspec__init(ps, pathspec)) < 0) {
 		git__free(ps);
@@ -416,7 +416,7 @@ static int pathspec_match_from_iterator(
 
 	if (out) {
 		*out = m = pathspec_match_alloc(ps, PATHSPEC_DATATYPE_STRINGS);
-		GIT_ERROR_CHECK_ALLOC(m);
+		GITERR_CHECK_ALLOC(m);
 	}
 
 	if ((error = git_iterator_reset_range(iter, ps->prefix, ps->prefix)) < 0)
@@ -488,7 +488,7 @@ static int pathspec_match_from_iterator(
 
 	/* if every pattern failed to match, then we have failed */
 	if ((flags & GIT_PATHSPEC_NO_MATCH_ERROR) != 0 && !found_files) {
-		git_error_set(GIT_ERROR_INVALID, "no matching files were found");
+		giterr_set(GITERR_INVALID, "no matching files were found");
 		error = GIT_ENOTFOUND;
 	}
 
@@ -604,7 +604,7 @@ int git_pathspec_match_diff(
 
 	if (out) {
 		*out = m = pathspec_match_alloc(ps, PATHSPEC_DATATYPE_DIFF);
-		GIT_ERROR_CHECK_ALLOC(m);
+		GITERR_CHECK_ALLOC(m);
 	}
 
 	pathspec_match_context_init(
@@ -659,7 +659,7 @@ int git_pathspec_match_diff(
 
 	/* if every pattern failed to match, then we have failed */
 	if ((flags & GIT_PATHSPEC_NO_MATCH_ERROR) != 0 && !found_deltas) {
-		git_error_set(GIT_ERROR_INVALID, "no matching deltas were found");
+		giterr_set(GITERR_INVALID, "no matching deltas were found");
 		error = GIT_ENOTFOUND;
 	}
 

data/vendor/libgit2/src/pool.c

@@ -14,30 +14,30 @@
 
 struct git_pool_page {
 	git_pool_page *next;
-	size_t size;
-	size_t avail;
+	uint32_t size;
+	uint32_t avail;
 	GIT_ALIGN(char data[GIT_FLEX_ARRAY], 8);
 };
 
-static void *pool_alloc_page(git_pool *pool, size_t size);
+static void *pool_alloc_page(git_pool *pool, uint32_t size);
 
-size_t git_pool__system_page_size(void)
+uint32_t git_pool__system_page_size(void)
 {
-	static size_t size = 0;
+	static uint32_t size = 0;
 
 	if (!size) {
 		size_t page_size;
 		if (git__page_size(&page_size) < 0)
 			page_size = 4096;
 		/* allow space for malloc overhead */
-		size = (page_size - (2 * sizeof(void *)) - sizeof(git_pool_page));
+		size = page_size - (2 * sizeof(void *)) - sizeof(git_pool_page);
 	}
 
 	return size;
 }
 
 #ifndef GIT_DEBUG_POOL
-void git_pool_init(git_pool *pool, size_t item_size)
+void git_pool_init(git_pool *pool, uint32_t item_size)
 {
 	assert(pool);
 	assert(item_size >= 1);
@@ -59,10 +59,10 @@ void git_pool_clear(git_pool *pool)
 	pool->pages = NULL;
 }
 
-static void *pool_alloc_page(git_pool *pool, size_t size)
+static void *pool_alloc_page(git_pool *pool, uint32_t size)
 {
 	git_pool_page *page;
-	const size_t new_page_size = (size <= pool->page_size) ? pool->page_size : size;
+	const uint32_t new_page_size = (size <= pool->page_size) ? pool->page_size : size;
 	size_t alloc_size;
 
 	if (GIT_ADD_SIZET_OVERFLOW(&alloc_size, new_page_size, sizeof(git_pool_page)) ||
@@ -78,7 +78,7 @@ static void *pool_alloc_page(git_pool *pool, size_t size)
 	return page->data;
 }
 
-static void *pool_alloc(git_pool *pool, size_t size)
+static void *pool_alloc(git_pool *pool, uint32_t size)
 {
 	git_pool_page *page = pool->pages;
 	void *ptr = NULL;
@@ -125,7 +125,7 @@ static int git_pool__ptr_cmp(const void * a, const void * b)
 	}
 }
 
-void git_pool_init(git_pool *pool, size_t item_size)
+void git_pool_init(git_pool *pool, uint32_t item_size)
 {
 	assert(pool);
 	assert(item_size >= 1);
@@ -141,7 +141,7 @@ void git_pool_clear(git_pool *pool)
 	git_vector_free_deep(&pool->allocations);
 }
 
-static void *pool_alloc(git_pool *pool, size_t size) {
+static void *pool_alloc(git_pool *pool, uint32_t size) {
 	void *ptr = NULL;
 	if((ptr = git__malloc(size)) == NULL) {
 		return NULL;
@@ -169,26 +169,26 @@ void git_pool_swap(git_pool *a, git_pool *b)
 	memcpy(b, &temp, sizeof(temp));
 }
 
-static size_t alloc_size(git_pool *pool, size_t count)
+static uint32_t alloc_size(git_pool *pool, uint32_t count)
 {
-	const size_t align = sizeof(void *) - 1;
+	const uint32_t align = sizeof(void *) - 1;
 
 	if (pool->item_size > 1) {
-		const size_t item_size = (pool->item_size + align) & ~align;
+		const uint32_t item_size = (pool->item_size + align) & ~align;
 		return item_size * count;
 	}
 
 	return (count + align) & ~align;
 }
 
-void *git_pool_malloc(git_pool *pool, size_t items)
+void *git_pool_malloc(git_pool *pool, uint32_t items)
 {
 	return pool_alloc(pool, alloc_size(pool, items));
 }
 
-void *git_pool_mallocz(git_pool *pool, size_t items)
+void *git_pool_mallocz(git_pool *pool, uint32_t items)
 {
-	const size_t size = alloc_size(pool, items);
+	const uint32_t size = alloc_size(pool, items);
 	void *ptr = pool_alloc(pool, size);
 	if (ptr)
 		memset(ptr, 0x0, size);
@@ -201,10 +201,10 @@ char *git_pool_strndup(git_pool *pool, const char *str, size_t n)
 
 	assert(pool && str && pool->item_size == sizeof(char));
 
-	if (n == SIZE_MAX)
+	if ((uint32_t)(n + 1) < n)
 		return NULL;
 
-	if ((ptr = git_pool_malloc(pool, (n + 1))) != NULL) {
+	if ((ptr = git_pool_malloc(pool, (uint32_t)(n + 1))) != NULL) {
 		memcpy(ptr, str, n);
 		ptr[n] = '\0';
 	}
@@ -226,18 +226,14 @@ char *git_pool_strdup_safe(git_pool *pool, const char *str)
 char *git_pool_strcat(git_pool *pool, const char *a, const char *b)
 {
 	void *ptr;
-	size_t len_a, len_b, total;
+	size_t len_a, len_b;
 
 	assert(pool && pool->item_size == sizeof(char));
 
 	len_a = a ? strlen(a) : 0;
 	len_b = b ? strlen(b) : 0;
 
-	if (GIT_ADD_SIZET_OVERFLOW(&total, len_a, len_b) ||
-		GIT_ADD_SIZET_OVERFLOW(&total, total, 1))
-		return NULL;
-
-	if ((ptr = git_pool_malloc(pool, total)) != NULL) {
+	if ((ptr = git_pool_malloc(pool, (uint32_t)(len_a + len_b + 1))) != NULL) {
 		if (len_a)
 			memcpy(ptr, a, len_a);
 		if (len_b)

data/vendor/libgit2/src/pool.h

@@ -32,8 +32,8 @@ typedef struct git_pool_page git_pool_page;
  */
 typedef struct {
 	git_pool_page *pages; /* allocated pages */
-	size_t item_size;  /* size of single alloc unit in bytes */
-	size_t page_size;  /* size of page in bytes */
+	uint32_t item_size;  /* size of single alloc unit in bytes */
+	uint32_t page_size;  /* size of page in bytes */
 } git_pool;
 
 #define GIT_POOL_INIT { NULL, 0, 0 }
@@ -57,8 +57,8 @@ typedef struct {
  */
 typedef struct {
 	git_vector allocations;
-	size_t item_size;
-	size_t page_size;
+	uint32_t item_size;
+	uint32_t page_size;
 } git_pool;
 
 #define GIT_POOL_INIT { GIT_VECTOR_INIT, 0, 0 }
@@ -81,7 +81,7 @@ typedef struct {
  * Of course, you can use this in other ways, but those are the
  * two most common patterns.
  */
-extern void git_pool_init(git_pool *pool, size_t item_size);
+extern void git_pool_init(git_pool *pool, uint32_t item_size);
 
 /**
  * Free all items in pool
@@ -96,8 +96,8 @@ extern void git_pool_swap(git_pool *a, git_pool *b);
 /**
  * Allocate space for one or more items from a pool.
  */
-extern void *git_pool_malloc(git_pool *pool, size_t items);
-extern void *git_pool_mallocz(git_pool *pool, size_t items);
+extern void *git_pool_malloc(git_pool *pool, uint32_t items);
+extern void *git_pool_mallocz(git_pool *pool, uint32_t items);
 
 /**
  * Allocate space and duplicate string data into it.

data/vendor/libgit2/src/posix.c

@@ -28,11 +28,11 @@ int p_getaddrinfo(
 
 	GIT_UNUSED(hints);
 
-	if ((ainfo = git__malloc(sizeof(struct addrinfo))) == NULL)
+	if ((ainfo = malloc(sizeof(struct addrinfo))) == NULL)
 		return -1;
 
 	if ((ainfo->ai_hostent = gethostbyname(host)) == NULL) {
-		git__free(ainfo);
+		free(ainfo);
 		return -2;
 	}
 
@@ -65,7 +65,7 @@ int p_getaddrinfo(
 	ai = ainfo;
 
 	for (p = 1; ainfo->ai_hostent->h_addr_list[p] != NULL; p++) {
-		if (!(ai->ai_next = git__malloc(sizeof(struct addrinfo)))) {
+		if (!(ai->ai_next = malloc(sizeof(struct addrinfo)))) {
 			p_freeaddrinfo(ainfo);
 			return -1;
 		}
@@ -89,7 +89,7 @@ void p_freeaddrinfo(struct addrinfo *info)
 
 	while(p != NULL) {
 		next = p->ai_next;
-		git__free(p);
+		free(p);
 		p = next;
 	}
 }
@@ -235,7 +235,7 @@ int git__mmap_alignment(size_t *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)
 {
 	GIT_MMAP_VALIDATE(out, len, prot, flags);
 
@@ -243,17 +243,17 @@ int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, off64_t offset
 	out->len = 0;
 
 	if ((prot & GIT_PROT_WRITE) && ((flags & GIT_MAP_TYPE) == GIT_MAP_SHARED)) {
-		git_error_set(GIT_ERROR_OS, "trying to map shared-writeable");
+		giterr_set(GITERR_OS, "trying to map shared-writeable");
 		return -1;
 	}
 
-	out->data = git__malloc(len);
-	GIT_ERROR_CHECK_ALLOC(out->data);
+	out->data = malloc(len);
+	GITERR_CHECK_ALLOC(out->data);
 
 	if (!git__is_ssizet(len) ||
 		(p_lseek(fd, offset, SEEK_SET) < 0) ||
 		(p_read(fd, out->data, len) != (ssize_t)len)) {
-		git_error_set(GIT_ERROR_OS, "mmap emulation failed");
+		giterr_set(GITERR_OS, "mmap emulation failed");
 		return -1;
 	}
 
@@ -264,7 +264,7 @@ int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, off64_t offset
 int p_munmap(git_map *map)
 {
 	assert(map != NULL);
-	git__free(map->data);
+	free(map->data);
 
 	return 0;
 }