rugged 0.28.4 → 0.28.4.1

data/vendor/libgit2/src/path.h

@@ -647,8 +647,6 @@ extern bool git_path_isvalid(
  */
 int git_path_normalize_slashes(git_buf *out, const char *path);
 
-bool git_path_supports_symlinks(const char *dir);
-
 /**
  * Validate a system file's ownership
  *

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)
@@ -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 &&

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);
 
@@ -247,7 +247,7 @@ int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, off64_t offset
 		return -1;
 	}
 
-	out->data = git__malloc(len);
+	out->data = malloc(len);
 	GIT_ERROR_CHECK_ALLOC(out->data);
 
 	if (!git__is_ssizet(len) ||
@@ -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;
 }

data/vendor/libgit2/src/posix.h

@@ -11,6 +11,7 @@
 
 #include <fcntl.h>
 #include <time.h>
+#include "fnmatch.h"
 
 /* stat: file mode type testing macros */
 #ifndef S_IFGITLINK
@@ -89,18 +90,6 @@
 #define EAFNOSUPPORT (INT_MAX-1)
 #endif
 
-/* Provide a 64-bit size for offsets. */
-
-#if defined(_MSC_VER)
-typedef __int64 off64_t;
-#elif defined(__HAIKU__)
-typedef __haiku_std_int64 off64_t;
-#elif defined(__APPLE__)
-typedef __int64_t off64_t;
-#else
-typedef int64_t off64_t;
-#endif
-
 typedef int git_file;
 
 /**

data/vendor/libgit2/src/proxy.c

@@ -9,22 +9,17 @@
 
 #include "git2/proxy.h"
 
-int git_proxy_options_init(git_proxy_options *opts, unsigned int version)
+int git_proxy_init_options(git_proxy_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_proxy_options, GIT_PROXY_OPTIONS_INIT);
 	return 0;
 }
 
-int git_proxy_init_options(git_proxy_options *opts, unsigned int version)
-{
-	return git_proxy_options_init(opts, version);
-}
-
 int git_proxy_options_dup(git_proxy_options *tgt, const git_proxy_options *src)
 {
 	if (!src) {
-		git_proxy_options_init(tgt, GIT_PROXY_OPTIONS_VERSION);
+		git_proxy_init_options(tgt, GIT_PROXY_OPTIONS_VERSION);
 		return 0;
 	}
 

data/vendor/libgit2/src/push.c

@@ -196,7 +196,7 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 			continue;
 
 		/* Update the remote ref */
-		if (git_oid_is_zero(&push_spec->loid)) {
+		if (git_oid_iszero(&push_spec->loid)) {
 			error = git_reference_lookup(&remote_ref, push->remote->repo, git_buf_cstr(&remote_ref_name));
 
 			if (error >= 0) {
@@ -281,7 +281,7 @@ static int queue_objects(git_push *push)
 		git_object_t type;
 		size_t size;
 
-		if (git_oid_is_zero(&spec->loid))
+		if (git_oid_iszero(&spec->loid))
 			/*
 			 * Delete reference on remote side;
 			 * nothing to do here.
@@ -319,7 +319,7 @@ static int queue_objects(git_push *push)
 		if (!spec->refspec.force) {
 			git_oid base;
 
-			if (git_oid_is_zero(&spec->roid))
+			if (git_oid_iszero(&spec->roid))
 				continue;
 
 			if (!git_odb_exists(push->repo->_odb, &spec->roid)) {
@@ -346,7 +346,7 @@ static int queue_objects(git_push *push)
 	}
 
 	git_vector_foreach(&push->remote->refs, i, head) {
-		if (git_oid_is_zero(&head->oid))
+		if (git_oid_iszero(&head->oid))
 			continue;
 
 		/* TODO */
@@ -547,14 +547,9 @@ void git_push_free(git_push *push)
 	git__free(push);
 }
 
-int git_push_options_init(git_push_options *opts, unsigned int version)
+int git_push_init_options(git_push_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_push_options, GIT_PUSH_OPTIONS_INIT);
 	return 0;
 }
-
-int git_push_init_options(git_push_options *opts, unsigned int version)
-{
-	return git_push_options_init(opts, version);
-}

data/vendor/libgit2/src/reader.c

@@ -7,7 +7,7 @@
 
 #include "reader.h"
 
-#include "futils.h"
+#include "fileops.h"
 #include "blob.h"
 
 #include "git2/tree.h"
@@ -32,7 +32,7 @@ static int tree_reader_read(
 	tree_reader *reader = (tree_reader *)_reader;
 	git_tree_entry *tree_entry = NULL;
 	git_blob *blob = NULL;
-	git_object_size_t blobsize;
+	git_off_t blobsize;
 	int error;
 
 	if ((error = git_tree_entry_bypath(&tree_entry, reader->tree, filename)) < 0 ||

data/vendor/libgit2/src/rebase.c

@@ -268,7 +268,7 @@ static int rebase_alloc(git_rebase **out, const git_rebase_options *rebase_opts)
 	if (rebase_opts)
 		memcpy(&rebase->options, rebase_opts, sizeof(git_rebase_options));
 	else
-		git_rebase_options_init(&rebase->options, GIT_REBASE_OPTIONS_VERSION);
+		git_rebase_init_options(&rebase->options, GIT_REBASE_OPTIONS_VERSION);
 
 	if (rebase_opts && rebase_opts->rewrite_notes_ref) {
 		rebase->options.rewrite_notes_ref = git__strdup(rebase_opts->rewrite_notes_ref);
@@ -298,8 +298,7 @@ int git_rebase_open(
 	git_rebase *rebase;
 	git_buf path = GIT_BUF_INIT, orig_head_name = GIT_BUF_INIT,
 		orig_head_id = GIT_BUF_INIT, onto_id = GIT_BUF_INIT;
-	size_t state_path_len;
-	int error;
+	int state_path_len, error;
 
 	assert(repo);
 
@@ -494,18 +493,13 @@ static int rebase_setupfiles(git_rebase *rebase)
 	return rebase_setupfiles_merge(rebase);
 }
 
-int git_rebase_options_init(git_rebase_options *opts, unsigned int version)
+int git_rebase_init_options(git_rebase_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_rebase_options, GIT_REBASE_OPTIONS_INIT);
 	return 0;
 }
 
-int git_rebase_init_options(git_rebase_options *opts, unsigned int version)
-{
-	return git_rebase_options_init(opts, version);
-}
-
 static int rebase_ensure_not_in_progress(git_repository *repo)
 {
 	int error;
@@ -951,10 +945,6 @@ static int rebase_commit__create(
 	git_commit *current_commit = NULL, *commit = NULL;
 	git_tree *parent_tree = NULL, *tree = NULL;
 	git_oid tree_id, commit_id;
-	git_buf commit_content = GIT_BUF_INIT, commit_signature = GIT_BUF_INIT,
-		signature_field = GIT_BUF_INIT;
-	const char *signature_field_string = NULL,
-		*commit_signature_string = NULL;
 	int error;
 
 	operation = git_array_get(rebase->operations, rebase->current);
@@ -985,40 +975,10 @@ static int rebase_commit__create(
 		message = git_commit_message(current_commit);
 	}
 
-	if ((error = git_commit_create_buffer(&commit_content, rebase->repo, author, committer,
-			message_encoding, message, tree, 1, (const git_commit **)&parent_commit)) < 0)
-		goto done;
-
-	if (rebase->options.signing_cb) {
-		git_error_clear();
-		error = git_error_set_after_callback_function(rebase->options.signing_cb(
-			&commit_signature, &signature_field, git_buf_cstr(&commit_content),
-			rebase->options.payload), "commit signing_cb failed");
-		if (error == GIT_PASSTHROUGH) {
-			git_buf_dispose(&commit_signature);
-			git_buf_dispose(&signature_field);
-			git_error_clear();
-			error = GIT_OK;
-		} else if (error < 0)
-			goto done;
-	}
-
-	if (git_buf_is_allocated(&commit_signature)) {
-		assert(git_buf_contains_nul(&commit_signature));
-		commit_signature_string = git_buf_cstr(&commit_signature);
-	}
-
-	if (git_buf_is_allocated(&signature_field)) {
-		assert(git_buf_contains_nul(&signature_field));
-		signature_field_string = git_buf_cstr(&signature_field);
-	}
-
-	if ((error = git_commit_create_with_signature(&commit_id, rebase->repo,
-			git_buf_cstr(&commit_content), commit_signature_string,
-			signature_field_string)))
-		goto done;
-
-	if ((error = git_commit_lookup(&commit, rebase->repo, &commit_id)) < 0)
+	if ((error = git_commit_create(&commit_id, rebase->repo, NULL, author,
+		committer, message_encoding, message, tree, 1,
+		(const git_commit **)&parent_commit)) < 0 ||
+		(error = git_commit_lookup(&commit, rebase->repo, &commit_id)) < 0)
 		goto done;
 
 	*out = commit;
@@ -1027,9 +987,6 @@ done:
 	if (error < 0)
 		git_commit_free(commit);
 
-	git_buf_dispose(&commit_signature);
-	git_buf_dispose(&signature_field);
-	git_buf_dispose(&commit_content);
 	git_commit_free(current_commit);
 	git_tree_free(parent_tree);
 	git_tree_free(tree);
@@ -1370,22 +1327,6 @@ int git_rebase_finish(
 	return error;
 }
 
-const char *git_rebase_orig_head_name(git_rebase *rebase) {
-	return rebase->orig_head_name;
-}
-
-const git_oid *git_rebase_orig_head_id(git_rebase *rebase) {
-	return &rebase->orig_head_id;
-}
-
-const char *git_rebase_onto_name(git_rebase *rebase) {
-	return rebase->onto_name;
-}
-
-const git_oid *git_rebase_onto_id(git_rebase *rebase) {
-	return &rebase->onto_id;
-}
-
 size_t git_rebase_operation_entrycount(git_rebase *rebase)
 {
 	assert(rebase);