rugged 0.23.0b2 → 0.23.0b4

data/vendor/libgit2/src/diff_tform.c

@@ -15,7 +15,7 @@
 #include "fileops.h"
 #include "config.h"
 
-static git_diff_delta *diff_delta__dup(
+git_diff_delta *git_diff__delta_dup(
 	const git_diff_delta *d, git_pool *pool)
 {
 	git_diff_delta *delta = git__malloc(sizeof(git_diff_delta));
@@ -46,7 +46,7 @@ fail:
 	return NULL;
 }
 
-static git_diff_delta *diff_delta__merge_like_cgit(
+git_diff_delta *git_diff__merge_like_cgit(
 	const git_diff_delta *a,
 	const git_diff_delta *b,
 	git_pool *pool)
@@ -65,19 +65,26 @@ static git_diff_delta *diff_delta__merge_like_cgit(
 	 *  f3 = b->new_file
 	 */
 
+	/* If one of the diffs is a conflict, just dup it */
+	if (b->status == GIT_DELTA_CONFLICTED)
+		return git_diff__delta_dup(b, pool);
+	if (a->status == GIT_DELTA_CONFLICTED)
+		return git_diff__delta_dup(a, pool);
+
 	/* if f2 == f3 or f2 is deleted, then just dup the 'a' diff */
 	if (b->status == GIT_DELTA_UNMODIFIED || a->status == GIT_DELTA_DELETED)
-		return diff_delta__dup(a, pool);
+		return git_diff__delta_dup(a, pool);
 
 	/* otherwise, base this diff on the 'b' diff */
-	if ((dup = diff_delta__dup(b, pool)) == NULL)
+	if ((dup = git_diff__delta_dup(b, pool)) == NULL)
 		return NULL;
 
 	/* If 'a' status is uninteresting, then we're done */
-	if (a->status == GIT_DELTA_UNMODIFIED)
+	if (a->status == GIT_DELTA_UNMODIFIED ||
+		a->status == GIT_DELTA_UNTRACKED ||
+		a->status == GIT_DELTA_UNREADABLE)
 		return dup;
 
-	assert(a->status != GIT_DELTA_UNMODIFIED);
 	assert(b->status != GIT_DELTA_UNMODIFIED);
 
 	/* A cgit exception is that the diff of a file that is only in the
@@ -102,43 +109,8 @@ static git_diff_delta *diff_delta__merge_like_cgit(
 	return dup;
 }
 
-static git_diff_delta *diff_delta__merge_like_cgit_reversed(
-	const git_diff_delta *a,
-	const git_diff_delta *b,
-	git_pool *pool)
-{
-	git_diff_delta *dup;
-
-	/* reversed version of above logic */
-
-	if (a->status == GIT_DELTA_UNMODIFIED)
-		return diff_delta__dup(b, pool);
-
-	if ((dup = diff_delta__dup(a, pool)) == NULL)
-		return NULL;
-
-	if (b->status == GIT_DELTA_UNMODIFIED || b->status == GIT_DELTA_UNTRACKED || b->status == GIT_DELTA_UNREADABLE)
-		return dup;
-
-	if (dup->status == GIT_DELTA_DELETED) {
-		if (b->status == GIT_DELTA_ADDED) {
-			dup->status = GIT_DELTA_UNMODIFIED;
-			dup->nfiles = 2;
-		}
-	} else {
-		dup->status = b->status;
-		dup->nfiles = b->nfiles;
-	}
-
-	git_oid_cpy(&dup->old_file.id, &b->old_file.id);
-	dup->old_file.mode  = b->old_file.mode;
-	dup->old_file.size  = b->old_file.size;
-	dup->old_file.flags = b->old_file.flags;
-
-	return dup;
-}
-
-int git_diff_merge(git_diff *onto, const git_diff *from)
+int git_diff__merge(
+	git_diff *onto, const git_diff *from, git_diff__merge_cb cb)
 {
 	int error = 0;
 	git_pool onto_pool;
@@ -174,15 +146,16 @@ int git_diff_merge(git_diff *onto, const git_diff *from)
 			STRCMP_CASESELECT(ignore_case, o->old_file.path, f->old_file.path);
 
 		if (cmp < 0) {
-			delta = diff_delta__dup(o, &onto_pool);
+			delta = git_diff__delta_dup(o, &onto_pool);
 			i++;
 		} else if (cmp > 0) {
-			delta = diff_delta__dup(f, &onto_pool);
+			delta = git_diff__delta_dup(f, &onto_pool);
 			j++;
 		} else {
-			delta = reversed ?
-				diff_delta__merge_like_cgit_reversed(o, f, &onto_pool) :
-				diff_delta__merge_like_cgit(o, f, &onto_pool);
+			const git_diff_delta *left = reversed ? f : o;
+			const git_diff_delta *right = reversed ? o : f;
+
+			delta = cb(left, right, &onto_pool);
 			i++;
 			j++;
 		}
@@ -190,7 +163,7 @@ int git_diff_merge(git_diff *onto, const git_diff *from)
 		/* the ignore rules for the target may not match the source
 		 * or the result of a merged delta could be skippable...
 		 */
-		if (git_diff_delta__should_skip(&onto->opts, delta)) {
+		if (delta && git_diff_delta__should_skip(&onto->opts, delta)) {
 			git__free(delta);
 			continue;
 		}
@@ -221,6 +194,11 @@ int git_diff_merge(git_diff *onto, const git_diff *from)
 	return error;
 }
 
+int git_diff_merge(git_diff *onto, const git_diff *from)
+{
+	return git_diff__merge(onto, from, git_diff__merge_like_cgit);
+}
+
 int git_diff_find_similar__hashsig_for_file(
 	void **out, const git_diff_file *f, const char *path, void *p)
 {
@@ -369,7 +347,7 @@ static int insert_delete_side_of_split(
 	git_diff *diff, git_vector *onto, const git_diff_delta *delta)
 {
 	/* make new record for DELETED side of split */
-	git_diff_delta *deleted = diff_delta__dup(delta, &diff->pool);
+	git_diff_delta *deleted = git_diff__delta_dup(delta, &diff->pool);
 	GITERR_CHECK_ALLOC(deleted);
 
 	deleted->status = GIT_DELTA_DELETED;
@@ -676,11 +654,13 @@ static bool is_rename_target(
 		return false;
 
 	/* only consider ADDED, RENAMED, COPIED, and split MODIFIED as
-	 * targets; maybe include UNTRACKED and IGNORED if requested.
+	 * targets; maybe include UNTRACKED if requested.
 	 */
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED:
 	case GIT_DELTA_DELETED:
+	case GIT_DELTA_IGNORED:
+	case GIT_DELTA_CONFLICTED:
 		return false;
 
 	case GIT_DELTA_MODIFIED:
@@ -707,9 +687,6 @@ static bool is_rename_target(
 			return false;
 		break;
 
-	case GIT_DELTA_IGNORED:
-		return false;
-
 	default: /* all other status values should be checked */
 		break;
 	}
@@ -735,6 +712,7 @@ static bool is_rename_source(
 	case GIT_DELTA_UNTRACKED:
 	case GIT_DELTA_UNREADABLE:
 	case GIT_DELTA_IGNORED:
+	case GIT_DELTA_CONFLICTED:
 		return false;
 
 	case GIT_DELTA_DELETED:

data/vendor/libgit2/src/fetch.c

@@ -19,14 +19,14 @@
 #include "repository.h"
 #include "refs.h"
 
-static int maybe_want(git_remote *remote, git_remote_head *head, git_odb *odb, git_refspec *tagspec)
+static int maybe_want(git_remote *remote, git_remote_head *head, git_odb *odb, git_refspec *tagspec, git_remote_autotag_option_t tagopt)
 {
 	int match = 0;
 
 	if (!git_reference_is_valid_name(head->name))
 		return 0;
 
-	if (remote->download_tags == GIT_REMOTE_DOWNLOAD_TAGS_ALL) {
+	if (tagopt == GIT_REMOTE_DOWNLOAD_TAGS_ALL) {
 		/*
 		 * If tagopt is --tags, always request tags
 		 * in addition to the remote's refspecs
@@ -51,13 +51,17 @@ static int maybe_want(git_remote *remote, git_remote_head *head, git_odb *odb, g
 	return git_vector_insert(&remote->refs, head);
 }
 
-static int filter_wants(git_remote *remote)
+static int filter_wants(git_remote *remote, const git_fetch_options *opts)
 {
 	git_remote_head **heads;
 	git_refspec tagspec, head;
 	int error = 0;
 	git_odb *odb;
 	size_t i, heads_len;
+	git_remote_autotag_option_t tagopt = remote->download_tags;
+
+	if (opts && opts->download_tags != GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED)
+		tagopt = opts->download_tags;
 
 	git_vector_clear(&remote->refs);
 	if ((error = git_refspec__parse(&tagspec, GIT_REFSPEC_TAGS, true)) < 0)
@@ -87,7 +91,7 @@ static int filter_wants(git_remote *remote)
 		goto cleanup;
 
 	for (i = 0; i < heads_len; i++) {
-		if ((error = maybe_want(remote, heads[i], odb, &tagspec)) < 0)
+		if ((error = maybe_want(remote, heads[i], odb, &tagspec, tagopt)) < 0)
 			break;
 	}
 
@@ -102,13 +106,13 @@ cleanup:
  * them out. When we get an ACK we hide that commit and continue
  * traversing until we're done
  */
-int git_fetch_negotiate(git_remote *remote)
+int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts)
 {
 	git_transport *t = remote->transport;
 
-    remote->need_pack = 0;
+	remote->need_pack = 0;
 
-	if (filter_wants(remote) < 0) {
+	if (filter_wants(remote, opts) < 0) {
 		giterr_set(GITERR_NET, "Failed to filter the reference list for wants");
 		return -1;
 	}
@@ -127,13 +131,26 @@ int git_fetch_negotiate(git_remote *remote)
 		remote->refs.length);
 }
 
-int git_fetch_download_pack(git_remote *remote)
+int git_fetch_download_pack(git_remote *remote, const git_remote_callbacks *callbacks)
 {
 	git_transport *t = remote->transport;
+	git_transfer_progress_cb progress = NULL;
+	void *payload = NULL;
 
 	if (!remote->need_pack)
 		return 0;
 
-	return t->download_pack(t, remote->repo, &remote->stats,
-			remote->callbacks.transfer_progress, remote->callbacks.payload);
+	if (callbacks) {
+		progress = callbacks->transfer_progress;
+		payload  = callbacks->payload;
+	}
+
+	return t->download_pack(t, remote->repo, &remote->stats, progress, payload);
+}
+
+int git_fetch_init_options(git_fetch_options *opts, unsigned int version)
+{
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_fetch_options, GIT_FETCH_OPTIONS_INIT);
+	return 0;
 }

data/vendor/libgit2/src/fetch.h

@@ -9,9 +9,9 @@
 
 #include "netops.h"
 
-int git_fetch_negotiate(git_remote *remote);
+int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts);
 
-int git_fetch_download_pack(git_remote *remote);
+int git_fetch_download_pack(git_remote *remote, const git_remote_callbacks *callbacks);
 
 int git_fetch__download_pack(
 		git_transport *t,

data/vendor/libgit2/src/filebuf.c

@@ -68,7 +68,7 @@ static int lock_file(git_filebuf *file, int flags, mode_t mode)
 
 	if ((flags & GIT_FILEBUF_APPEND) && git_path_exists(file->path_original) == true) {
 		git_file source;
-		char buffer[2048];
+		char buffer[FILEIO_BUFSIZE];
 		ssize_t read_bytes;
 
 		source = p_open(file->path_original, O_RDONLY);

data/vendor/libgit2/src/fileops.c

@@ -689,7 +689,7 @@ int git_futils_fake_symlink(const char *old, const char *new)
 static int cp_by_fd(int ifd, int ofd, bool close_fd_when_done)
 {
 	int error = 0;
-	char buffer[4096];
+	char buffer[FILEIO_BUFSIZE];
 	ssize_t len = 0;
 
 	while (!error && (len = p_read(ifd, buffer, sizeof(buffer))) > 0)
@@ -703,6 +703,9 @@ static int cp_by_fd(int ifd, int ofd, bool close_fd_when_done)
 		error = (int)len;
 	}
 
+	if (error < 0)
+		giterr_set(GITERR_OS, "write error while copying file");
+
 	if (close_fd_when_done) {
 		p_close(ifd);
 		p_close(ofd);
@@ -861,7 +864,8 @@ static int _cp_r_callback(void *ref, git_buf *from)
 
 	/* make symlink or regular file */
 	if (info->flags & GIT_CPDIR_LINK_FILES) {
-		error = p_link(from->ptr, info->to.ptr);
+		if ((error = p_link(from->ptr, info->to.ptr)) < 0)
+			giterr_set(GITERR_OS, "failed to link '%s'", from->ptr);
 	} else if (S_ISLNK(from_st.st_mode)) {
 		error = cp_link(from->ptr, info->to.ptr, (size_t)from_st.st_size);
 	} else {

data/vendor/libgit2/src/filter.c

@@ -27,6 +27,7 @@ struct git_filter_source {
 };
 
 typedef struct {
+	const char *filter_name;
 	git_filter *filter;
 	void *payload;
 } git_filter_entry;
@@ -526,7 +527,9 @@ int git_filter_list__load_ext(
 
 			fe = git_array_alloc(fl->filters);
 			GITERR_CHECK_ALLOC(fe);
-			fe->filter  = fdef->filter;
+
+			fe->filter = fdef->filter;
+			fe->filter_name = fdef->filter_name;
 			fe->payload = payload;
 		}
 	}
@@ -574,6 +577,25 @@ void git_filter_list_free(git_filter_list *fl)
 	git__free(fl);
 }
 
+int git_filter_list_contains(
+	git_filter_list *fl,
+	const char *name)
+{
+	size_t i;
+
+	assert(name);
+
+	if (!fl)
+		return 0;
+
+	for (i = 0; i < fl->filters.size; i++) {
+		if (strcmp(fl->filters.ptr[i].filter_name, name) == 0)
+			return 1;
+	}
+
+	return 0;
+}
+
 int git_filter_list_push(
 	git_filter_list *fl, git_filter *filter, void *payload)
 {
@@ -875,21 +897,19 @@ void stream_list_free(git_vector *streams)
 	git_vector_free(streams);
 }
 
-#define STREAM_BUFSIZE 10240
-
 int git_filter_list_stream_file(
 	git_filter_list *filters,
 	git_repository *repo,
 	const char *path,
 	git_writestream *target)
 {
-	char buf[STREAM_BUFSIZE];
+	char buf[FILTERIO_BUFSIZE];
 	git_buf abspath = GIT_BUF_INIT;
 	const char *base = repo ? git_repository_workdir(repo) : NULL;
 	git_vector filter_streams = GIT_VECTOR_INIT;
 	git_writestream *stream_start;
 	ssize_t readlen;
-	int fd, error;
+	int fd = -1, error;
 
 	if ((error = stream_list_init(
 			&stream_start, &filter_streams, filters, target)) < 0 ||
@@ -901,7 +921,7 @@ int git_filter_list_stream_file(
 		goto done;
 	}
 
-	while ((readlen = p_read(fd, buf, STREAM_BUFSIZE)) > 0) {
+	while ((readlen = p_read(fd, buf, sizeof(buf))) > 0) {
 		if ((error = stream_start->write(stream_start, buf, readlen)) < 0)
 			goto done;
 	}
@@ -911,9 +931,10 @@ int git_filter_list_stream_file(
 	else if (readlen < 0)
 		error = readlen;
 
-	p_close(fd);
 
 done:
+	if (fd >= 0)
+		p_close(fd);
 	stream_list_free(&filter_streams);
 	git_buf_free(&abspath);
 	return error;

data/vendor/libgit2/src/fnmatch.c

@@ -164,8 +164,8 @@ p_fnmatchx(const char *pattern, const char *string, int flags, size_t recurs)
 				default:
 				normal:
 						if (c != *string && !((flags & FNM_CASEFOLD) &&
-									(tolower((unsigned char)c) ==
-									tolower((unsigned char)*string))))
+									(git__tolower((unsigned char)c) ==
+									git__tolower((unsigned char)*string))))
 								return (FNM_NOMATCH);
 						++string;
 						break;
@@ -190,7 +190,7 @@ rangematch(const char *pattern, char test, int flags, char **newp)
 				++pattern;
 
 		if (flags & FNM_CASEFOLD)
-				test = (char)tolower((unsigned char)test);
+				test = (char)git__tolower((unsigned char)test);
 
 		/*
 			* A right bracket shall lose its special meaning and represent
@@ -207,7 +207,7 @@ rangematch(const char *pattern, char test, int flags, char **newp)
 				if (c == '/' && (flags & FNM_PATHNAME))
 						return (RANGE_NOMATCH);
 				if ((flags & FNM_CASEFOLD))
-						c = (char)tolower((unsigned char)c);
+						c = (char)git__tolower((unsigned char)c);
 				if (*pattern == '-'
 					&& (c2 = *(pattern+1)) != EOS && c2 != ']') {
 						pattern += 2;
@@ -216,7 +216,7 @@ rangematch(const char *pattern, char test, int flags, char **newp)
 						if (c2 == EOS)
 								return (RANGE_ERROR);
 						if (flags & FNM_CASEFOLD)
-								c2 = (char)tolower((unsigned char)c2);
+								c2 = (char)git__tolower((unsigned char)c2);
 						if (c <= test && test <= c2)
 								ok = 1;
 				} else if (c == test)

data/vendor/libgit2/src/global.c

@@ -116,6 +116,20 @@ static void init_ssl(void)
 #endif
 }
 
+/**
+ * This function aims to clean-up the SSL context which
+ * we allocated.
+ */
+static void uninit_ssl(void)
+{
+#ifdef GIT_OPENSSL
+	if (git__ssl_ctx) {
+		SSL_CTX_free(git__ssl_ctx);
+		git__ssl_ctx = NULL;
+	}
+#endif
+}
+
 int git_openssl_set_locking(void)
 {
 #ifdef GIT_OPENSSL
@@ -333,6 +347,7 @@ int git_libgit2_shutdown(void)
 
 	/* Shut down any subsystems that have global state */
 	git__shutdown();
+	uninit_ssl();
 
 	ptr = pthread_getspecific(_tls_key);
 	pthread_setspecific(_tls_key, NULL);
@@ -391,6 +406,7 @@ int git_libgit2_shutdown(void)
 
 	git__shutdown();
 	git__global_state_cleanup(&__state);
+	uninit_ssl();
 
 	return 0;
 }