rugged 0.19.0 → 0.28.0

data/vendor/libgit2/src/diff_tform.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_diff_tform_h__
+#define INCLUDE_diff_tform_h__
+
+#include "common.h"
+
+#include "diff_file.h"
+
+extern int git_diff_find_similar__hashsig_for_file(
+	void **out, const git_diff_file *f, const char *path, void *p);
+
+extern int git_diff_find_similar__hashsig_for_buf(
+	void **out, const git_diff_file *f, const char *buf, size_t len, void *p);
+
+extern void git_diff_find_similar__hashsig_free(void *sig, void *payload);
+
+extern int git_diff_find_similar__calc_similarity(
+	int *score, void *siga, void *sigb, void *payload);
+
+#endif

data/vendor/libgit2/src/diff_xdiff.c

@@ -4,11 +4,14 @@
  * 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 "common.h"
+
+#include "diff_xdiff.h"
+#include "util.h"
+
+#include "git2/errors.h"
 #include "diff.h"
 #include "diff_driver.h"
-#include "diff_patch.h"
-#include "diff_xdiff.h"
+#include "patch_generate.h"
 
 static int git_xdiff_scan_int(const char **str, int *value)
 {
@@ -24,66 +27,147 @@ static int git_xdiff_scan_int(const char **str, int *value)
 	return (digits > 0) ? 0 : -1;
 }
 
-static int git_xdiff_parse_hunk(git_diff_range *range, const char *header)
+static int git_xdiff_parse_hunk(git_diff_hunk *hunk, const char *header)
 {
 	/* expect something of the form "@@ -%d[,%d] +%d[,%d] @@" */
 	if (*header != '@')
-		return -1;
-	if (git_xdiff_scan_int(&header, &range->old_start) < 0)
-		return -1;
+		goto fail;
+	if (git_xdiff_scan_int(&header, &hunk->old_start) < 0)
+		goto fail;
 	if (*header == ',') {
-		if (git_xdiff_scan_int(&header, &range->old_lines) < 0)
-			return -1;
+		if (git_xdiff_scan_int(&header, &hunk->old_lines) < 0)
+			goto fail;
 	} else
-		range->old_lines = 1;
-	if (git_xdiff_scan_int(&header, &range->new_start) < 0)
-		return -1;
+		hunk->old_lines = 1;
+	if (git_xdiff_scan_int(&header, &hunk->new_start) < 0)
+		goto fail;
 	if (*header == ',') {
-		if (git_xdiff_scan_int(&header, &range->new_lines) < 0)
-			return -1;
+		if (git_xdiff_scan_int(&header, &hunk->new_lines) < 0)
+			goto fail;
 	} else
-		range->new_lines = 1;
-	if (range->old_start < 0 || range->new_start < 0)
-		return -1;
+		hunk->new_lines = 1;
+	if (hunk->old_start < 0 || hunk->new_start < 0)
+		goto fail;
 
 	return 0;
+
+fail:
+	git_error_set(GIT_ERROR_INVALID, "malformed hunk header from xdiff");
+	return -1;
 }
 
 typedef struct {
 	git_xdiff_output *xo;
-	git_diff_patch *patch;
-	git_diff_range range;
+	git_patch_generated *patch;
+	git_diff_hunk hunk;
+	int old_lineno, new_lineno;
+	mmfile_t xd_old_data, xd_new_data;
 } git_xdiff_info;
 
+static int diff_update_lines(
+	git_xdiff_info *info,
+	git_diff_line *line,
+	const char *content,
+	size_t content_len)
+{
+	const char *scan = content, *scan_end = content + content_len;
+
+	for (line->num_lines = 0; scan < scan_end; ++scan)
+		if (*scan == '\n')
+			++line->num_lines;
+
+	line->content     = content;
+	line->content_len = content_len;
+
+	/* expect " "/"-"/"+", then data */
+	switch (line->origin) {
+	case GIT_DIFF_LINE_ADDITION:
+	case GIT_DIFF_LINE_DEL_EOFNL:
+		line->old_lineno = -1;
+		line->new_lineno = info->new_lineno;
+		info->new_lineno += (int)line->num_lines;
+		break;
+	case GIT_DIFF_LINE_DELETION:
+	case GIT_DIFF_LINE_ADD_EOFNL:
+		line->old_lineno = info->old_lineno;
+		line->new_lineno = -1;
+		info->old_lineno += (int)line->num_lines;
+		break;
+	case GIT_DIFF_LINE_CONTEXT:
+	case GIT_DIFF_LINE_CONTEXT_EOFNL:
+		line->old_lineno = info->old_lineno;
+		line->new_lineno = info->new_lineno;
+		info->old_lineno += (int)line->num_lines;
+		info->new_lineno += (int)line->num_lines;
+		break;
+	default:
+		git_error_set(GIT_ERROR_INVALID, "unknown diff line origin %02x",
+			(unsigned int)line->origin);
+		return -1;
+	}
+
+	return 0;
+}
+
 static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
 {
 	git_xdiff_info *info = priv;
-	git_diff_patch *patch = info->patch;
-	const git_diff_delta *delta = git_diff_patch_delta(patch);
-	git_diff_output *output = &info->xo->output;
+	git_patch_generated *patch = info->patch;
+	const git_diff_delta *delta = patch->base.delta;
+	git_patch_generated_output *output = &info->xo->output;
+	git_diff_line line;
+	size_t buffer_len;
 
 	if (len == 1) {
-		output->error = git_xdiff_parse_hunk(&info->range, bufs[0].ptr);
+		output->error = git_xdiff_parse_hunk(&info->hunk, bufs[0].ptr);
 		if (output->error < 0)
 			return output->error;
 
+		info->hunk.header_len = bufs[0].size;
+		if (info->hunk.header_len >= sizeof(info->hunk.header))
+			info->hunk.header_len = sizeof(info->hunk.header) - 1;
+
+		/* Sanitize the hunk header in case there is invalid Unicode */
+		buffer_len = git__utf8_valid_buf_length((const uint8_t *) bufs[0].ptr, info->hunk.header_len);
+		/* Sanitizing the hunk header may delete the newline, so add it back again if there is room */
+		if (buffer_len < info->hunk.header_len) {
+			bufs[0].ptr[buffer_len] = '\n';
+			buffer_len += 1;
+			info->hunk.header_len = buffer_len;
+		}
+
+		memcpy(info->hunk.header, bufs[0].ptr, info->hunk.header_len);
+		info->hunk.header[info->hunk.header_len] = '\0';
+
 		if (output->hunk_cb != NULL &&
-			output->hunk_cb(delta, &info->range,
-				bufs[0].ptr, bufs[0].size, output->payload))
-			output->error = GIT_EUSER;
+			(output->error = output->hunk_cb(
+				delta, &info->hunk, output->payload)))
+			return output->error;
+
+		info->old_lineno = info->hunk.old_start;
+		info->new_lineno = info->hunk.new_start;
 	}
 
 	if (len == 2 || len == 3) {
 		/* expect " "/"-"/"+", then data */
-		char origin =
+		line.origin =
 			(*bufs[0].ptr == '+') ? GIT_DIFF_LINE_ADDITION :
 			(*bufs[0].ptr == '-') ? GIT_DIFF_LINE_DELETION :
 			GIT_DIFF_LINE_CONTEXT;
 
-		if (output->data_cb != NULL &&
-			output->data_cb(delta, &info->range,
-				origin, bufs[1].ptr, bufs[1].size, output->payload))
-			output->error = GIT_EUSER;
+		if (line.origin == GIT_DIFF_LINE_ADDITION)
+			line.content_offset = bufs[1].ptr - info->xd_new_data.ptr;
+		else if (line.origin == GIT_DIFF_LINE_DELETION)
+			line.content_offset = bufs[1].ptr - info->xd_old_data.ptr;
+		else
+			line.content_offset = -1;
+
+		output->error = diff_update_lines(
+			info, &line, bufs[1].ptr, bufs[1].size);
+
+		if (!output->error && output->data_cb != NULL)
+			output->error = output->data_cb(
+				delta, &info->hunk, &line, output->payload);
 	}
 
 	if (len == 3 && !output->error) {
@@ -92,26 +176,29 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
 		 * If we have a '-' and a third buf, then we have removed a line
 		 * with out a newline but added a blank line, so ADD_EOFNL.
 		 */
-		char origin =
+		line.origin =
 			(*bufs[0].ptr == '+') ? GIT_DIFF_LINE_DEL_EOFNL :
 			(*bufs[0].ptr == '-') ? GIT_DIFF_LINE_ADD_EOFNL :
 			GIT_DIFF_LINE_CONTEXT_EOFNL;
 
-		if (output->data_cb != NULL &&
-			output->data_cb(delta, &info->range,
-				origin, bufs[2].ptr, bufs[2].size, output->payload))
-			output->error = GIT_EUSER;
+		line.content_offset = -1;
+
+		output->error = diff_update_lines(
+			info, &line, bufs[2].ptr, bufs[2].size);
+
+		if (!output->error && output->data_cb != NULL)
+			output->error = output->data_cb(
+				delta, &info->hunk, &line, output->payload);
 	}
 
 	return output->error;
 }
 
-static int git_xdiff(git_diff_output *output, git_diff_patch *patch)
+static int git_xdiff(git_patch_generated_output *output, git_patch_generated *patch)
 {
 	git_xdiff_output *xo = (git_xdiff_output *)output;
 	git_xdiff_info info;
 	git_diff_find_context_payload findctxt;
-	mmfile_t xd_old_data, xd_new_data;
 
 	memset(&info, 0, sizeof(info));
 	info.patch = patch;
@@ -120,7 +207,7 @@ static int git_xdiff(git_diff_output *output, git_diff_patch *patch)
 	xo->callback.priv = &info;
 
 	git_diff_find_context_init(
-		&xo->config.find_func, &findctxt, git_diff_patch__driver(patch));
+		&xo->config.find_func, &findctxt, git_patch_generated_driver(patch));
 	xo->config.find_func_priv = &findctxt;
 
 	if (xo->config.find_func != NULL)
@@ -132,10 +219,16 @@ static int git_xdiff(git_diff_output *output, git_diff_patch *patch)
 	 * updates are needed to xo->params.flags
 	 */
 
-	git_diff_patch__old_data(&xd_old_data.ptr, &xd_old_data.size, patch);
-	git_diff_patch__new_data(&xd_new_data.ptr, &xd_new_data.size, patch);
+	git_patch_generated_old_data(&info.xd_old_data.ptr, &info.xd_old_data.size, patch);
+	git_patch_generated_new_data(&info.xd_new_data.ptr, &info.xd_new_data.size, patch);
 
-	xdl_diff(&xd_old_data, &xd_new_data,
+	if (info.xd_old_data.size > GIT_XDIFF_MAX_SIZE ||
+		info.xd_new_data.size > GIT_XDIFF_MAX_SIZE) {
+		git_error_set(GIT_ERROR_INVALID, "files too large for diff");
+		return -1;
+	}
+
+	xdl_diff(&info.xd_old_data, &info.xd_new_data,
 		&xo->params, &xo->config, &xo->callback);
 
 	git_diff_find_context_clear(&findctxt);
@@ -145,22 +238,26 @@ static int git_xdiff(git_diff_output *output, git_diff_patch *patch)
 
 void git_xdiff_init(git_xdiff_output *xo, const git_diff_options *opts)
 {
-	uint32_t flags = opts ? opts->flags : GIT_DIFF_NORMAL;
+	uint32_t flags = opts ? opts->flags : 0;
 
 	xo->output.diff_cb = git_xdiff;
 
-	memset(&xo->config, 0, sizeof(xo->config));
 	xo->config.ctxlen = opts ? opts->context_lines : 3;
 	xo->config.interhunkctxlen = opts ? opts->interhunk_lines : 0;
 
-	memset(&xo->params, 0, sizeof(xo->params));
 	if (flags & GIT_DIFF_IGNORE_WHITESPACE)
 		xo->params.flags |= XDF_WHITESPACE_FLAGS;
 	if (flags & GIT_DIFF_IGNORE_WHITESPACE_CHANGE)
 		xo->params.flags |= XDF_IGNORE_WHITESPACE_CHANGE;
 	if (flags & GIT_DIFF_IGNORE_WHITESPACE_EOL)
 		xo->params.flags |= XDF_IGNORE_WHITESPACE_AT_EOL;
+	if (flags & GIT_DIFF_INDENT_HEURISTIC)
+		xo->params.flags |= XDF_INDENT_HEURISTIC;
+
+	if (flags & GIT_DIFF_PATIENCE)
+		xo->params.flags |= XDF_PATIENCE_DIFF;
+	if (flags & GIT_DIFF_MINIMAL)
+		xo->params.flags |= XDF_NEED_MINIMAL;
 
-	memset(&xo->callback, 0, sizeof(xo->callback));
 	xo->callback.outf = git_xdiff_cb;
 }

data/vendor/libgit2/src/diff_xdiff.h

@@ -7,16 +7,23 @@
 #ifndef INCLUDE_diff_xdiff_h__
 #define INCLUDE_diff_xdiff_h__
 
+#include "common.h"
+
 #include "diff.h"
-#include "diff_patch.h"
 #include "xdiff/xdiff.h"
+#include "patch_generate.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.
+/* A git_xdiff_output is a git_patch_generate_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.
  */
 typedef struct {
-	git_diff_output output;
+	git_patch_generated_output output;
 
 	xdemitconf_t config;
 	xpparam_t    params;

data/vendor/libgit2/src/errors.c

@@ -4,11 +4,12 @@
  * 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 "common.h"
+
 #include "global.h"
 #include "posix.h"
 #include "buffer.h"
-#include <stdarg.h>
 
 /********************************************
  * New error handling
@@ -16,84 +17,102 @@
 
 static git_error g_git_oom_error = {
 	"Out of memory",
-	GITERR_NOMEMORY
+	GIT_ERROR_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;
 
-	git__free(error->message);
-
-	error->message = string;
+	error->message = buf->ptr;
 	error->klass = error_class;
 
 	GIT_GLOBAL->last_error = error;
 }
 
-void giterr_set_oom(void)
+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 git_error_set_oom(void)
 {
 	GIT_GLOBAL->last_error = &g_git_oom_error;
 }
 
-void giterr_set(int error_class, const char *string, ...)
+void git_error_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;
+	DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0;
 #endif
-	int error_code = (error_class == GITERR_OS) ? errno : 0;
+	int error_code = (error_class == GIT_ERROR_OS) ? errno : 0;
+	git_buf *buf = &GIT_GLOBAL->error_buf;
 
-	va_start(arglist, string);
-	git_buf_vprintf(&buf, string, arglist);
-	va_end(arglist);
+	git_buf_clear(buf);
+	if (string) {
+		va_start(arglist, string);
+		git_buf_vprintf(buf, string, arglist);
+		va_end(arglist);
+
+		if (error_class == GIT_ERROR_OS)
+			git_buf_PUTS(buf, ": ");
+	}
 
-	if (error_class == GITERR_OS) {
+	if (error_class == GIT_ERROR_OS) {
 #ifdef GIT_WIN32
 		char * win32_error = git_win32_get_error_message(win32_error_code);
 		if (win32_error) {
-			git_buf_PUTS(&buf, ": ");
-			git_buf_puts(&buf, win32_error);
+			git_buf_puts(buf, win32_error);
 			git__free(win32_error);
 
 			SetLastError(0);
 		}
 		else
 #endif
-		if (error_code) {
-			git_buf_PUTS(&buf, ": ");
-			git_buf_puts(&buf, strerror(error_code));
-		}
+		if (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)
+void git_error_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)
+int git_error_set_regex(const regex_t *regex, int error_code)
 {
 	char error_buf[1024];
 
 	assert(error_code);
 
 	regerror(error_code, regex, error_buf, sizeof(error_buf));
-	giterr_set_str(GITERR_REGEX, error_buf);
+	git_error_set_str(GIT_ERROR_REGEX, error_buf);
 
 	if (error_code == REG_NOMATCH)
 		return GIT_ENOTFOUND;
@@ -101,10 +120,12 @@ int giterr_set_regex(const regex_t *regex, int error_code)
 	return GIT_EINVALIDSPEC;
 }
 
-void giterr_clear(void)
+void git_error_clear(void)
 {
-	set_error(0, NULL);
-	GIT_GLOBAL->last_error = NULL;
+	if (GIT_GLOBAL->last_error != NULL) {
+		set_error(0, NULL);
+		GIT_GLOBAL->last_error = NULL;
+	}
 
 	errno = 0;
 #ifdef GIT_WIN32
@@ -112,8 +133,103 @@ void giterr_clear(void)
 #endif
 }
 
-const git_error *giterr_last(void)
+const git_error *git_error_last(void)
 {
 	return GIT_GLOBAL->last_error;
 }
 
+int git_error_state_capture(git_error_state *state, int error_code)
+{
+	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;
+
+	state->error_code = error_code;
+	state->oom = (error == &g_git_oom_error);
+
+	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);
+	}
+
+	git_error_clear();
+	return error_code;
+}
+
+int git_error_state_restore(git_error_state *state)
+{
+	int ret = 0;
+
+	git_error_clear();
+
+	if (state && state->error_msg.message) {
+		if (state->oom)
+			git_error_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;
+}
+
+void git_error_state_free(git_error_state *state)
+{
+	if (!state)
+		return;
+
+	if (!state->oom)
+		git__free(state->error_msg.message);
+
+	memset(state, 0, sizeof(git_error_state));
+}
+
+int git_error_system_last(void)
+{
+#ifdef GIT_WIN32
+	return GetLastError();
+#else
+	return errno;
+#endif
+}
+
+void git_error_system_set(int code)
+{
+#ifdef GIT_WIN32
+	SetLastError(code);
+#else
+	errno = code;
+#endif
+}
+
+/* Deprecated error values and functions */
+
+const git_error *giterr_last(void)
+{
+	return git_error_last();
+}
+
+void giterr_clear(void)
+{
+	git_error_clear();
+}
+
+void giterr_set_str(int error_class, const char *string)
+{
+	git_error_set_str(error_class, string);
+}
+
+void giterr_set_oom(void)
+{
+	git_error_set_oom();
+}

data/vendor/libgit2/src/features.h.in

@@ -0,0 +1,37 @@
+#ifndef INCLUDE_features_h__
+#define INCLUDE_features_h__
+
+#cmakedefine GIT_DEBUG_POOL 1
+#cmakedefine GIT_TRACE 1
+#cmakedefine GIT_THREADS 1
+#cmakedefine GIT_MSVC_CRTDBG 1
+
+#cmakedefine GIT_ARCH_64 1
+#cmakedefine GIT_ARCH_32 1
+
+#cmakedefine GIT_USE_ICONV 1
+#cmakedefine GIT_USE_NSEC 1
+#cmakedefine GIT_USE_STAT_MTIM 1
+#cmakedefine GIT_USE_STAT_MTIMESPEC 1
+#cmakedefine GIT_USE_STAT_MTIME_NSEC 1
+#cmakedefine GIT_USE_FUTIMENS 1
+#cmakedefine GIT_USE_REGCOMP_L 1
+
+#cmakedefine GIT_SSH 1
+#cmakedefine GIT_SSH_MEMORY_CREDENTIALS 1
+
+#cmakedefine GIT_GSSAPI 1
+#cmakedefine GIT_WINHTTP 1
+
+#cmakedefine GIT_HTTPS 1
+#cmakedefine GIT_OPENSSL 1
+#cmakedefine GIT_SECURE_TRANSPORT 1
+#cmakedefine GIT_MBEDTLS 1
+
+#cmakedefine GIT_SHA1_COLLISIONDETECT 1
+#cmakedefine GIT_SHA1_WIN32 1
+#cmakedefine GIT_SHA1_COMMON_CRYPTO 1
+#cmakedefine GIT_SHA1_OPENSSL 1
+#cmakedefine GIT_SHA1_MBEDTLS 1
+
+#endif