rugged 0.23.2 → 0.23.3

data/vendor/libgit2/src/common.h

@@ -46,10 +46,6 @@
 # ifdef GIT_THREADS
 #	include "win32/pthread.h"
 # endif
-# if defined(GIT_MSVC_CRTDBG)
-#   include "win32/w32_stack.h"
-#   include "win32/w32_crtdbg_stacktrace.h"
-# endif
 
 #else
 
@@ -141,25 +137,20 @@ void giterr_system_set(int code);
  * Structure to preserve libgit2 error state
  */
 typedef struct {
-	int error_code;
-	unsigned int oom : 1;
+	int       error_code;
 	git_error error_msg;
 } git_error_state;
 
 /**
  * Capture current error state to restore later, returning error code.
- * If `error_code` is zero, this does not clear the current error state.
- * You must either restore this error state, or free it.
+ * If `error_code` is zero, this does nothing and returns zero.
  */
-extern int giterr_state_capture(git_error_state *state, int error_code);
+int giterr_capture(git_error_state *state, int error_code);
 
 /**
  * Restore error state to a previous value, returning saved error code.
  */
-extern int giterr_state_restore(git_error_state *state);
-
-/** Free an error state. */
-extern void giterr_state_free(git_error_state *state);
+int giterr_restore(git_error_state *state);
 
 /**
  * Check a versioned structure for validity
@@ -208,6 +199,15 @@ GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int v
 #define GITERR_CHECK_ALLOC_ADD(out, one, two) \
 	if (GIT_ADD_SIZET_OVERFLOW(out, one, two)) { return -1; }
 
+#define GITERR_CHECK_ALLOC_ADD3(out, one, two, three) \
+	if (GIT_ADD_SIZET_OVERFLOW(out, one, two) || \
+		GIT_ADD_SIZET_OVERFLOW(out, *(out), three)) { return -1; }
+
+#define GITERR_CHECK_ALLOC_ADD4(out, one, two, three, four) \
+	if (GIT_ADD_SIZET_OVERFLOW(out, one, two) || \
+		GIT_ADD_SIZET_OVERFLOW(out, *(out), three) || \
+		GIT_ADD_SIZET_OVERFLOW(out, *(out), four)) { return -1; }
+
 /** Check for multiplicative overflow, failing if it would occur. */
 #define GITERR_CHECK_ALLOC_MULTIPLY(out, nelem, elsize) \
 	if (GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize)) { return -1; }

data/vendor/libgit2/src/curl_stream.c

@@ -67,9 +67,9 @@ static int curls_certificate(git_cert **out, git_stream *stream)
 
 	/* No information is available, can happen with SecureTransport */
 	if (certinfo->num_of_certs == 0) {
-		s->cert_info.parent.cert_type = GIT_CERT_NONE;
-		s->cert_info.data             = NULL;
-		s->cert_info.len              = 0;
+		s->cert_info.cert_type = GIT_CERT_NONE;
+		s->cert_info.data      = NULL;
+		s->cert_info.len       = 0;
 		return 0;
 	}
 
@@ -85,11 +85,11 @@ static int curls_certificate(git_cert **out, git_stream *stream)
 	s->cert_info_strings.strings = (char **) strings.contents;
 	s->cert_info_strings.count   = strings.length;
 
-	s->cert_info.parent.cert_type = GIT_CERT_STRARRAY;
-	s->cert_info.data             = &s->cert_info_strings;
-	s->cert_info.len              = strings.length;
+	s->cert_info.cert_type = GIT_CERT_STRARRAY;
+	s->cert_info.data      = &s->cert_info_strings;
+	s->cert_info.len       = strings.length;
 
-	*out = &s->cert_info.parent;
+	*out = (git_cert *) &s->cert_info;
 
 	return 0;
 }
@@ -220,6 +220,7 @@ int git_curl_stream_new(git_stream **out, const char *host, const char *port)
 	curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, 1);
 	curl_easy_setopt(handle, CURLOPT_CERTINFO, 1);
 	curl_easy_setopt(handle, CURLOPT_HTTPPROXYTUNNEL, 1);
+	curl_easy_setopt(handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
 
 	/* curl_easy_setopt(handle, CURLOPT_VERBOSE, 1); */
 

data/vendor/libgit2/src/diff.c

@@ -1421,31 +1421,6 @@ int git_diff_tree_to_workdir_with_index(
 	return error;
 }
 
-int git_diff_index_to_index(
-	git_diff **diff,
-	git_repository *repo,
-	git_index *old_index,
-	git_index *new_index,
-	const git_diff_options *opts)
-{
-	int error = 0;
-
-	assert(diff && old_index && new_index);
-
-	DIFF_FROM_ITERATORS(
-		git_iterator_for_index(
-			&a, old_index, GIT_ITERATOR_DONT_IGNORE_CASE, pfx, pfx),
-		git_iterator_for_index(
-			&b, new_index, GIT_ITERATOR_DONT_IGNORE_CASE, pfx, pfx)
-	);
-
-	/* if index is in case-insensitive order, re-sort deltas to match */
-	if (!error && (old_index->ignore_case || new_index->ignore_case))
-		diff_set_ignore_case(*diff, true);
-
-	return error;
-}
-
 size_t git_diff_num_deltas(const git_diff *diff)
 {
 	assert(diff);

data/vendor/libgit2/src/diff_driver.c

@@ -97,8 +97,7 @@ static int diff_driver_add_patterns(
 	for (scan = regex_str; scan; scan = end) {
 		/* get pattern to fill in */
 		if ((pat = git_array_alloc(drv->fn_patterns)) == NULL) {
-			error = -1;
-			break;
+			return -1;
 		}
 
 		pat->flags = regex_flags;
@@ -117,10 +116,9 @@ static int diff_driver_add_patterns(
 			break;
 
 		if ((error = regcomp(&pat->re, buf.ptr, regex_flags)) != 0) {
-			/* if regex fails to compile, warn? fail? */
-			error = giterr_set_regex(&pat->re, error);
-			regfree(&pat->re);
-			break;
+			/*
+			 * TODO: issue a warning
+			 */
 		}
 	}
 
@@ -128,7 +126,8 @@ static int diff_driver_add_patterns(
 		(void)git_array_pop(drv->fn_patterns); /* release last item */
 	git_buf_free(&buf);
 
-	return error;
+	/* We want to ignore bad patterns, so return success regardless */
+	return 0;
 }
 
 static int diff_driver_xfuncname(const git_config_entry *entry, void *payload)

data/vendor/libgit2/src/diff_patch.c

@@ -30,6 +30,10 @@ static void diff_patch_update_binary(git_patch *patch)
 		(patch->nfile.file->flags & GIT_DIFF_FLAG_BINARY) != 0)
 		patch->delta->flags |= GIT_DIFF_FLAG_BINARY;
 
+	else if (patch->ofile.file->size > GIT_XDIFF_MAX_SIZE ||
+			 patch->nfile.file->size > GIT_XDIFF_MAX_SIZE)
+		patch->delta->flags |= GIT_DIFF_FLAG_BINARY;
+
 	else if ((patch->ofile.file->flags & DIFF_FLAGS_NOT_BINARY) != 0 &&
 			 (patch->nfile.file->flags & DIFF_FLAGS_NOT_BINARY) != 0)
 		patch->delta->flags |= GIT_DIFF_FLAG_NOT_BINARY;

data/vendor/libgit2/src/diff_xdiff.c

@@ -4,6 +4,7 @@
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
  */
+#include "git2/errors.h"
 #include "common.h"
 #include "diff.h"
 #include "diff_driver.h"
@@ -208,6 +209,12 @@ static int git_xdiff(git_diff_output *output, git_patch *patch)
 	git_patch__old_data(&info.xd_old_data.ptr, &info.xd_old_data.size, patch);
 	git_patch__new_data(&info.xd_new_data.ptr, &info.xd_new_data.size, patch);
 
+	if (info.xd_old_data.size > GIT_XDIFF_MAX_SIZE ||
+		info.xd_new_data.size > GIT_XDIFF_MAX_SIZE) {
+		giterr_set(GITERR_INVALID, "files too large for diff");
+		return -1;
+	}
+
 	xdl_diff(&info.xd_old_data, &info.xd_new_data,
 		&xo->params, &xo->config, &xo->callback);
 

data/vendor/libgit2/src/diff_xdiff.h

@@ -11,6 +11,11 @@
 #include "diff_patch.h"
 #include "xdiff/xdiff.h"
 
+/* xdiff cannot cope with large files.  these files should not be passed to
+ * xdiff.  callers should treat these large files as binary.
+ */
+#define GIT_XDIFF_MAX_SIZE (1024LL * 1024 * 1023)
+
 /* A git_xdiff_output is a git_diff_output with extra fields necessary
  * to use libxdiff.  Calling git_xdiff_init() will set the diff_cb field
  * of the output to use xdiff to generate the diffs.

data/vendor/libgit2/src/errors.c

@@ -18,30 +18,19 @@ static git_error g_git_oom_error = {
 	GITERR_NOMEMORY
 };
 
-static void set_error_from_buffer(int error_class)
+static void set_error(int error_class, char *string)
 {
 	git_error *error = &GIT_GLOBAL->error_t;
-	git_buf *buf = &GIT_GLOBAL->error_buf;
 
-	error->message = buf->ptr;
+	if (error->message != string)
+		git__free(error->message);
+
+	error->message = string;
 	error->klass = error_class;
 
 	GIT_GLOBAL->last_error = error;
 }
 
-static void set_error(int error_class, char *string)
-{
-	git_buf *buf = &GIT_GLOBAL->error_buf;
-
-	git_buf_clear(buf);
-	if (string) {
-		git_buf_puts(buf, string);
-		git__free(string);
-	}
-
-	set_error_from_buffer(error_class);
-}
-
 void giterr_set_oom(void)
 {
 	GIT_GLOBAL->last_error = &g_git_oom_error;
@@ -49,28 +38,27 @@ void giterr_set_oom(void)
 
 void giterr_set(int error_class, const char *string, ...)
 {
+	git_buf buf = GIT_BUF_INIT;
 	va_list arglist;
 #ifdef GIT_WIN32
 	DWORD win32_error_code = (error_class == GITERR_OS) ? GetLastError() : 0;
 #endif
 	int error_code = (error_class == GITERR_OS) ? errno : 0;
-	git_buf *buf = &GIT_GLOBAL->error_buf;
 
-	git_buf_clear(buf);
 	if (string) {
 		va_start(arglist, string);
-		git_buf_vprintf(buf, string, arglist);
+		git_buf_vprintf(&buf, string, arglist);
 		va_end(arglist);
 
 		if (error_class == GITERR_OS)
-			git_buf_PUTS(buf, ": ");
+			git_buf_PUTS(&buf, ": ");
 	}
 
 	if (error_class == GITERR_OS) {
 #ifdef GIT_WIN32
 		char * win32_error = git_win32_get_error_message(win32_error_code);
 		if (win32_error) {
-			git_buf_puts(buf, win32_error);
+			git_buf_puts(&buf, win32_error);
 			git__free(win32_error);
 
 			SetLastError(0);
@@ -78,29 +66,26 @@ void giterr_set(int error_class, const char *string, ...)
 		else
 #endif
 		if (error_code)
-			git_buf_puts(buf, strerror(error_code));
+			git_buf_puts(&buf, strerror(error_code));
 
 		if (error_code)
 			errno = 0;
 	}
 
-	if (!git_buf_oom(buf))
-		set_error_from_buffer(error_class);
+	if (!git_buf_oom(&buf))
+		set_error(error_class, git_buf_detach(&buf));
 }
 
 void giterr_set_str(int error_class, const char *string)
 {
-	git_buf *buf = &GIT_GLOBAL->error_buf;
+	char *message;
 
 	assert(string);
 
-	if (!string)
-		return;
+	message = git__strdup(string);
 
-	git_buf_clear(buf);
-	git_buf_puts(buf, string);
-	if (!git_buf_oom(buf))
-		set_error_from_buffer(error_class);
+	if (message)
+		set_error(error_class, message);
 }
 
 int giterr_set_regex(const regex_t *regex, int error_code)
@@ -131,65 +116,45 @@ void giterr_clear(void)
 #endif
 }
 
-const git_error *giterr_last(void)
-{
-	return GIT_GLOBAL->last_error;
-}
-
-int giterr_state_capture(git_error_state *state, int error_code)
+int giterr_detach(git_error *cpy)
 {
 	git_error *error = GIT_GLOBAL->last_error;
-	git_buf *error_buf = &GIT_GLOBAL->error_buf;
-
-	memset(state, 0, sizeof(git_error_state));
 
-	if (!error_code)
-		return 0;
+	assert(cpy);
 
-	state->error_code = error_code;
-	state->oom = (error == &g_git_oom_error);
+	if (!error)
+		return -1;
 
-	if (error) {
-		state->error_msg.klass = error->klass;
-
-		if (state->oom)
-			state->error_msg.message = g_git_oom_error.message;
-		else
-			state->error_msg.message = git_buf_detach(error_buf);
-	}
+	cpy->message = error->message;
+	cpy->klass = error->klass;
 
+	error->message = NULL;
 	giterr_clear();
-	return error_code;
+
+	return 0;
 }
 
-int giterr_state_restore(git_error_state *state)
+const git_error *giterr_last(void)
 {
-	int ret = 0;
-
-	giterr_clear();
-
-	if (state && state->error_msg.message) {
-		if (state->oom)
-			giterr_set_oom();
-		else
-			set_error(state->error_msg.klass, state->error_msg.message);
-
-		ret = state->error_code;
-		memset(state, 0, sizeof(git_error_state));
-	}
-
-	return ret;
+	return GIT_GLOBAL->last_error;
 }
 
-void giterr_state_free(git_error_state *state)
+int giterr_capture(git_error_state *state, int error_code)
 {
-	if (!state)
-		return;
+	state->error_code = error_code;
+	if (error_code)
+		giterr_detach(&state->error_msg);
+	return error_code;
+}
 
-	if (!state->oom)
-		git__free(state->error_msg.message);
+int giterr_restore(git_error_state *state)
+{
+	if (state && state->error_code && state->error_msg.message)
+		set_error(state->error_msg.klass, state->error_msg.message);
+	else
+		giterr_clear();
 
-	memset(state, 0, sizeof(git_error_state));
+	return state ? state->error_code : 0;
 }
 
 int giterr_system_last(void)

data/vendor/libgit2/src/filter.c

@@ -433,11 +433,8 @@ static int filter_list_check_attributes(
 		want_type  = git_attr_value(want);
 		found_type = git_attr_value(strs[i]);
 
-		if (want_type != found_type)
-			error = GIT_ENOTFOUND;
-		else if (want_type == GIT_ATTR_VALUE_T &&
-				strcmp(want, strs[i]) &&
-				strcmp(want, "*"))
+		if (want_type != found_type ||
+			(want_type == GIT_ATTR_VALUE_T && strcmp(want, strs[i])))
 			error = GIT_ENOTFOUND;
 	}
 

data/vendor/libgit2/src/global.c

@@ -11,10 +11,7 @@
 #include "git2/global.h"
 #include "git2/sys/openssl.h"
 #include "thread-utils.h"
-#if defined(GIT_MSVC_CRTDBG)
-#include "win32/w32_stack.h"
-#include "win32/w32_crtdbg_stacktrace.h"
-#endif
+
 
 git_mutex git__mwindow_mutex;
 
@@ -228,11 +225,6 @@ int git_libgit2_init(void)
 
 	/* Only do work on a 0 -> 1 transition of the refcount */
 	if ((ret = git_atomic_inc(&git__n_inits)) == 1) {
-#if defined(GIT_MSVC_CRTDBG)
-		git_win32__crtdbg_stacktrace_init();
-		git_win32__stack_init();
-#endif
-
 		if (synchronized_threads_init() < 0)
 			ret = -1;
 	}
@@ -262,15 +254,9 @@ int git_libgit2_shutdown(void)
 	while (InterlockedCompareExchange(&_mutex, 1, 0)) { Sleep(0); }
 
 	/* Only do work on a 1 -> 0 transition of the refcount */
-	if ((ret = git_atomic_dec(&git__n_inits)) == 0) {
+	if ((ret = git_atomic_dec(&git__n_inits)) == 0)
 		synchronized_threads_shutdown();
 
-#if defined(GIT_MSVC_CRTDBG)
-		git_win32__crtdbg_stacktrace_cleanup();
-		git_win32__stack_cleanup();
-#endif
-	}
-
 	/* Exit the lock */
 	InterlockedExchange(&_mutex, 0);
 
@@ -279,19 +265,18 @@ int git_libgit2_shutdown(void)
 
 git_global_st *git__global_state(void)
 {
-	git_global_st *ptr;
+	void *ptr;
 
 	assert(git_atomic_get(&git__n_inits) > 0);
 
 	if ((ptr = TlsGetValue(_tls_index)) != NULL)
 		return ptr;
 
-	ptr = git__calloc(1, sizeof(git_global_st));
+	ptr = git__malloc(sizeof(git_global_st));
 	if (!ptr)
 		return NULL;
 
-	git_buf_init(&ptr->error_buf, 0);
-
+	memset(ptr, 0x0, sizeof(git_global_st));
 	TlsSetValue(_tls_index, ptr);
 	return ptr;
 }
@@ -345,8 +330,8 @@ int git_libgit2_init(void)
 {
 	int ret;
 
-	ret = git_atomic_inc(&git__n_inits);
 	pthread_once(&_once_init, init_once);
+	ret = git_atomic_inc(&git__n_inits);
 
 	return init_error ? init_error : ret;
 }
@@ -379,18 +364,18 @@ int git_libgit2_shutdown(void)
 
 git_global_st *git__global_state(void)
 {
-	git_global_st *ptr;
+	void *ptr;
 
 	assert(git_atomic_get(&git__n_inits) > 0);
 
 	if ((ptr = pthread_getspecific(_tls_key)) != NULL)
 		return ptr;
 
-	ptr = git__calloc(1, sizeof(git_global_st));
+	ptr = git__malloc(sizeof(git_global_st));
 	if (!ptr)
 		return NULL;
 
-	git_buf_init(&ptr->error_buf, 0);
+	memset(ptr, 0x0, sizeof(git_global_st));
 	pthread_setspecific(_tls_key, ptr);
 	return ptr;
 }
@@ -408,7 +393,6 @@ int git_libgit2_init(void)
 		ssl_inited = 1;
 	}
 
-	git_buf_init(&__state.error_buf, 0);
 	return git_atomic_inc(&git__n_inits);
 }