rugged 0.23.0 → 0.23.1

data/vendor/libgit2/src/common.h

@@ -46,6 +46,10 @@
 # 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
 
@@ -137,20 +141,25 @@ void giterr_system_set(int code);
  * Structure to preserve libgit2 error state
  */
 typedef struct {
-	int       error_code;
+	int error_code;
+	unsigned int oom : 1;
 	git_error error_msg;
 } git_error_state;
 
 /**
  * Capture current error state to restore later, returning error code.
- * If `error_code` is zero, this does nothing and returns zero.
+ * If `error_code` is zero, this does not clear the current error state.
+ * You must either restore this error state, or free it.
  */
-int giterr_capture(git_error_state *state, int error_code);
+extern int giterr_state_capture(git_error_state *state, int error_code);
 
 /**
  * Restore error state to a previous value, returning saved error code.
  */
-int giterr_restore(git_error_state *state);
+extern int giterr_state_restore(git_error_state *state);
+
+/** Free an error state. */
+extern void giterr_state_free(git_error_state *state);
 
 /**
  * Check a versioned structure for validity

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.cert_type = GIT_CERT_NONE;
-		s->cert_info.data      = NULL;
-		s->cert_info.len       = 0;
+		s->cert_info.parent.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.cert_type = GIT_CERT_STRARRAY;
-	s->cert_info.data      = &s->cert_info_strings;
-	s->cert_info.len       = 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;
 
-	*out = (git_cert *) &s->cert_info;
+	*out = &s->cert_info.parent;
 
 	return 0;
 }

data/vendor/libgit2/src/describe.c

@@ -19,7 +19,7 @@
 #include "vector.h"
 #include "repository.h"
 
-GIT__USE_OIDMAP;
+GIT__USE_OIDMAP
 
 /* Ported from https://github.com/git/git/blob/89dde7882f71f846ccd0359756d27bebc31108de/builtin/describe.c */
 

data/vendor/libgit2/src/diff.c

@@ -1421,6 +1421,31 @@ 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/errors.c

@@ -18,19 +18,30 @@ static git_error g_git_oom_error = {
 	GITERR_NOMEMORY
 };
 
-static void set_error(int error_class, char *string)
+static void set_error_from_buffer(int error_class)
 {
 	git_error *error = &GIT_GLOBAL->error_t;
+	git_buf *buf = &GIT_GLOBAL->error_buf;
 
-	if (error->message != string)
-		git__free(error->message);
-
-	error->message = string;
+	error->message = buf->ptr;
 	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;
@@ -38,27 +49,28 @@ 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);
@@ -66,26 +78,29 @@ 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(error_class, git_buf_detach(&buf));
+	if (!git_buf_oom(buf))
+		set_error_from_buffer(error_class);
 }
 
 void giterr_set_str(int error_class, const char *string)
 {
-	char *message;
+	git_buf *buf = &GIT_GLOBAL->error_buf;
 
 	assert(string);
 
-	message = git__strdup(string);
+	if (!string)
+		return;
 
-	if (message)
-		set_error(error_class, message);
+	git_buf_clear(buf);
+	git_buf_puts(buf, string);
+	if (!git_buf_oom(buf))
+		set_error_from_buffer(error_class);
 }
 
 int giterr_set_regex(const regex_t *regex, int error_code)
@@ -116,45 +131,65 @@ void giterr_clear(void)
 #endif
 }
 
-int giterr_detach(git_error *cpy)
+const git_error *giterr_last(void)
+{
+	return GIT_GLOBAL->last_error;
+}
+
+int giterr_state_capture(git_error_state *state, int error_code)
 {
 	git_error *error = GIT_GLOBAL->last_error;
+	git_buf *error_buf = &GIT_GLOBAL->error_buf;
 
-	assert(cpy);
+	memset(state, 0, sizeof(git_error_state));
 
-	if (!error)
-		return -1;
+	if (!error_code)
+		return 0;
 
-	cpy->message = error->message;
-	cpy->klass = error->klass;
+	state->error_code = error_code;
+	state->oom = (error == &g_git_oom_error);
 
-	error->message = NULL;
-	giterr_clear();
+	if (error) {
+		state->error_msg.klass = error->klass;
 
-	return 0;
-}
+		if (state->oom)
+			state->error_msg.message = g_git_oom_error.message;
+		else
+			state->error_msg.message = git_buf_detach(error_buf);
+	}
 
-const git_error *giterr_last(void)
-{
-	return GIT_GLOBAL->last_error;
+	giterr_clear();
+	return error_code;
 }
 
-int giterr_capture(git_error_state *state, int error_code)
+int giterr_state_restore(git_error_state *state)
 {
-	state->error_code = error_code;
-	if (error_code)
-		giterr_detach(&state->error_msg);
-	return error_code;
+	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;
 }
 
-int giterr_restore(git_error_state *state)
+void giterr_state_free(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();
+	if (!state)
+		return;
+
+	if (!state->oom)
+		git__free(state->error_msg.message);
 
-	return state ? state->error_code : 0;
+	memset(state, 0, sizeof(git_error_state));
 }
 
 int giterr_system_last(void)

data/vendor/libgit2/src/filebuf.c

@@ -101,7 +101,7 @@ void git_filebuf_cleanup(git_filebuf *file)
 	if (file->fd_is_open && file->fd >= 0)
 		p_close(file->fd);
 
-	if (file->fd_is_open && file->path_lock && git_path_exists(file->path_lock))
+	if (file->created_lock && !file->did_rename && file->path_lock && git_path_exists(file->path_lock))
 		p_unlink(file->path_lock);
 
 	if (file->compute_digest) {
@@ -258,6 +258,7 @@ int git_filebuf_open(git_filebuf *file, const char *path, int flags, mode_t mode
 			goto cleanup;
 		}
 		file->fd_is_open = true;
+		file->created_lock = true;
 
 		/* No original path */
 		file->path_original = NULL;
@@ -281,6 +282,8 @@ int git_filebuf_open(git_filebuf *file, const char *path, int flags, mode_t mode
 		/* open the file for locking */
 		if ((error = lock_file(file, flags, mode)) < 0)
 			goto cleanup;
+
+		file->created_lock = true;
 	}
 
 	return 0;
@@ -340,6 +343,8 @@ int git_filebuf_commit(git_filebuf *file)
 		goto on_error;
 	}
 
+	file->did_rename = true;
+
 	git_filebuf_cleanup(file);
 	return 0;
 

data/vendor/libgit2/src/filebuf.h

@@ -44,6 +44,8 @@ struct git_filebuf {
 	size_t buf_size, buf_pos;
 	git_file fd;
 	bool fd_is_open;
+	bool created_lock;
+	bool did_rename;
 	bool do_not_buffer;
 	int last_error;
 };

data/vendor/libgit2/src/filter.c

@@ -433,8 +433,11 @@ static int filter_list_check_attributes(
 		want_type  = git_attr_value(want);
 		found_type = git_attr_value(strs[i]);
 
-		if (want_type != found_type ||
-			(want_type == GIT_ATTR_VALUE_T && strcmp(want, strs[i])))
+		if (want_type != found_type)
+			error = GIT_ENOTFOUND;
+		else if (want_type == GIT_ATTR_VALUE_T &&
+				strcmp(want, strs[i]) &&
+				strcmp(want, "*"))
 			error = GIT_ENOTFOUND;
 	}
 
@@ -947,18 +950,20 @@ int git_filter_list_stream_data(
 {
 	git_vector filter_streams = GIT_VECTOR_INIT;
 	git_writestream *stream_start;
-	int error = 0;
+	int error = 0, close_error;
 
 	git_buf_sanitize(data);
 
-	if ((error = stream_list_init(
-			&stream_start, &filter_streams, filters, target)) == 0 &&
-		(error =
-			stream_start->write(stream_start, data->ptr, data->size)) == 0)
-		error = stream_start->close(stream_start);
+	if ((error = stream_list_init(&stream_start, &filter_streams, filters, target)) < 0)
+		goto out;
+
+	error = stream_start->write(stream_start, data->ptr, data->size);
 
+out:
+	close_error = stream_start->close(stream_start);
 	stream_list_free(&filter_streams);
-	return error;
+	/* propagate the stream init or write error */
+	return error < 0 ? error : close_error;
 }
 
 int git_filter_list_stream_blob(

data/vendor/libgit2/src/global.c

@@ -11,7 +11,10 @@
 #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;
 
@@ -225,6 +228,11 @@ 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;
 	}
@@ -254,9 +262,15 @@ 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);
 
@@ -265,18 +279,19 @@ int git_libgit2_shutdown(void)
 
 git_global_st *git__global_state(void)
 {
-	void *ptr;
+	git_global_st *ptr;
 
 	assert(git_atomic_get(&git__n_inits) > 0);
 
 	if ((ptr = TlsGetValue(_tls_index)) != NULL)
 		return ptr;
 
-	ptr = git__malloc(sizeof(git_global_st));
+	ptr = git__calloc(1, sizeof(git_global_st));
 	if (!ptr)
 		return NULL;
 
-	memset(ptr, 0x0, sizeof(git_global_st));
+	git_buf_init(&ptr->error_buf, 0);
+
 	TlsSetValue(_tls_index, ptr);
 	return ptr;
 }
@@ -330,8 +345,8 @@ int git_libgit2_init(void)
 {
 	int ret;
 
-	pthread_once(&_once_init, init_once);
 	ret = git_atomic_inc(&git__n_inits);
+	pthread_once(&_once_init, init_once);
 
 	return init_error ? init_error : ret;
 }
@@ -364,18 +379,18 @@ int git_libgit2_shutdown(void)
 
 git_global_st *git__global_state(void)
 {
-	void *ptr;
+	git_global_st *ptr;
 
 	assert(git_atomic_get(&git__n_inits) > 0);
 
 	if ((ptr = pthread_getspecific(_tls_key)) != NULL)
 		return ptr;
 
-	ptr = git__malloc(sizeof(git_global_st));
+	ptr = git__calloc(1, sizeof(git_global_st));
 	if (!ptr)
 		return NULL;
 
-	memset(ptr, 0x0, sizeof(git_global_st));
+	git_buf_init(&ptr->error_buf, 0);
 	pthread_setspecific(_tls_key, ptr);
 	return ptr;
 }
@@ -393,6 +408,7 @@ int git_libgit2_init(void)
 		ssl_inited = 1;
 	}
 
+	git_buf_init(&__state.error_buf, 0);
 	return git_atomic_inc(&git__n_inits);
 }