rugged 0.28.4 → 0.28.4.1

data/vendor/libgit2/src/win32/path_w32.c

@@ -140,24 +140,14 @@ int git_win32_path_canonicalize(git_win32_path path)
 
 	*to = L'\0';
 
-	if ((to - path) > INT_MAX) {
-		SetLastError(ERROR_FILENAME_EXCED_RANGE);
-		return -1;
-	}
-
-	return (int)(to - path);
+	return (to - path);
 }
 
 int git_win32_path__cwd(wchar_t *out, size_t len)
 {
 	int cwd_len;
 
-	if (len > INT_MAX) {
-		errno = ENAMETOOLONG;
-		return -1;
-	}
-
-	if ((cwd_len = path__cwd(out, (int)len)) < 0)
+	if ((cwd_len = path__cwd(out, len)) < 0)
 		return -1;
 
 	/* UNC paths */

data/vendor/libgit2/src/win32/path_w32.h

@@ -8,8 +8,37 @@
 #define INCLUDE_win32_path_w32_h__
 
 #include "common.h"
+
 #include "vector.h"
 
+/*
+ * Provides a large enough buffer to support Windows paths:  MAX_PATH is
+ * 260, corresponding to a maximum path length of 259 characters plus a
+ * NULL terminator.  Prefixing with "\\?\" adds 4 characters, but if the
+ * original was a UNC path, then we turn "\\server\share" into
+ * "\\?\UNC\server\share".  So we replace the first two characters with
+ * 8 characters, a net gain of 6, so the maximum length is MAX_PATH+6.
+ */
+#define GIT_WIN_PATH_UTF16		MAX_PATH+6
+
+/* Maximum size of a UTF-8 Win32 path.  We remove the "\\?\" or "\\?\UNC\"
+ * prefixes for presentation, bringing us back to 259 (non-NULL)
+ * characters.  UTF-8 does have 4-byte sequences, but they are encoded in
+ * UTF-16 using surrogate pairs, which takes up the space of two characters.
+ * Two characters in the range U+0800 -> U+FFFF take up more space in UTF-8
+ * (6 bytes) than one surrogate pair (4 bytes).
+ */
+#define GIT_WIN_PATH_UTF8		(259 * 3 + 1)
+
+/*
+ * The length of a Windows "shortname", for 8.3 compatibility.
+ */
+#define GIT_WIN_PATH_SHORTNAME  13
+
+/* Win32 path types */
+typedef wchar_t git_win32_path[GIT_WIN_PATH_UTF16];
+typedef char git_win32_utf8_path[GIT_WIN_PATH_UTF8];
+
 /**
  * Create a Win32 path (in UCS-2 format) from a UTF-8 string.
  *

data/vendor/libgit2/src/win32/posix.h

@@ -47,7 +47,7 @@ extern int p_chdir(const char* path);
 extern int p_chmod(const char* path, mode_t mode);
 extern int p_rmdir(const char* path);
 extern int p_access(const char* path, mode_t mode);
-extern int p_ftruncate(int fd, off64_t size);
+extern int p_ftruncate(int fd, git_off_t size);
 
 /* p_lstat is almost but not quite POSIX correct.  Specifically, the use of
  * ENOTDIR is wrong, in that it does not mean precisely that a non-directory
@@ -60,4 +60,7 @@ extern int p_lstat_posixly(const char *filename, struct stat *buf);
 extern struct tm * p_localtime_r(const time_t *timer, struct tm *result);
 extern struct tm * p_gmtime_r(const time_t *timer, struct tm *result);
 
+/* Use the bundled regcomp */
+#define p_regcomp regcomp
+
 #endif

data/vendor/libgit2/src/win32/posix_w32.c

@@ -8,7 +8,7 @@
 #include "common.h"
 
 #include "../posix.h"
-#include "../futils.h"
+#include "../fileops.h"
 #include "path.h"
 #include "path_w32.h"
 #include "utf-conv.h"
@@ -210,7 +210,7 @@ on_error:
  * We now take a "git_off_t" rather than "long" because
  * files may be longer than 2Gb.
  */
-int p_ftruncate(int fd, off64_t size)
+int p_ftruncate(int fd, git_off_t size)
 {
 	if (size < 0) {
 		errno = EINVAL;
@@ -251,25 +251,9 @@ int p_link(const char *old, const char *new)
 
 GIT_INLINE(int) unlink_once(const wchar_t *path)
 {
-	DWORD error;
-
 	if (DeleteFileW(path))
 		return 0;
 
-	if ((error = GetLastError()) == ERROR_ACCESS_DENIED) {
-		WIN32_FILE_ATTRIBUTE_DATA fdata;
-		if (!GetFileAttributesExW(path, GetFileExInfoStandard, &fdata) ||
-		    !(fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) ||
-		    !(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
-			goto out;
-
-		if (RemoveDirectoryW(path))
-			return 0;
-	}
-
-out:
-	SetLastError(error);
-
 	if (last_error_retryable())
 		return GIT_RETRY;
 
@@ -414,37 +398,18 @@ int p_readlink(const char *path, char *buf, size_t bufsiz)
 	return (int)bufsiz;
 }
 
-static bool target_is_dir(const char *target, const char *path)
-{
-	git_buf resolved = GIT_BUF_INIT;
-	git_win32_path resolved_w;
-	bool isdir = true;
-
-	if (git_path_is_absolute(target))
-		git_win32_path_from_utf8(resolved_w, target);
-	else if (git_path_dirname_r(&resolved, path) < 0 ||
-		 git_path_apply_relative(&resolved, target) < 0 ||
-		 git_win32_path_from_utf8(resolved_w, resolved.ptr) < 0)
-		goto out;
-
-	isdir = GetFileAttributesW(resolved_w) & FILE_ATTRIBUTE_DIRECTORY;
-
-out:
-	git_buf_dispose(&resolved);
-	return isdir;
-}
-
 int p_symlink(const char *target, const char *path)
 {
 	git_win32_path target_w, path_w;
 	DWORD dwFlags;
 
 	if (git_win32_path_from_utf8(path_w, path) < 0 ||
-	    git__utf8_to_16(target_w, MAX_PATH, target) < 0)
+		git__utf8_to_16(target_w, MAX_PATH, target) < 0)
 		return -1;
 
 	dwFlags = SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
-	if (target_is_dir(target, path))
+
+	if (GetFileAttributesW(target_w) & FILE_ATTRIBUTE_DIRECTORY)
 		dwFlags |= SYMBOLIC_LINK_FLAG_DIRECTORY;
 
 	if (!CreateSymbolicLinkW(path_w, target_w, dwFlags))

data/vendor/libgit2/src/win32/precompiled.h

@@ -13,6 +13,8 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 
+#include <regex.h>
+
 #include <io.h>
 #include <direct.h>
 #ifdef GIT_THREADS

data/vendor/libgit2/src/win32/thread.c

@@ -32,6 +32,8 @@ static DWORD WINAPI git_win32__threadproc(LPVOID lpParameter)
 
 	thread->result = thread->proc(thread->param);
 
+	git__free_tls_data();
+
 	return CLEAN_THREAD_EXIT;
 }
 
@@ -40,15 +42,15 @@ int git_threads_init(void)
 	HMODULE hModule = GetModuleHandleW(L"kernel32");
 
 	if (hModule) {
-		win32_srwlock_initialize = (win32_srwlock_fn)(void *)
+		win32_srwlock_initialize = (win32_srwlock_fn)
 			GetProcAddress(hModule, "InitializeSRWLock");
-		win32_srwlock_acquire_shared = (win32_srwlock_fn)(void *)
+		win32_srwlock_acquire_shared = (win32_srwlock_fn)
 			GetProcAddress(hModule, "AcquireSRWLockShared");
-		win32_srwlock_release_shared = (win32_srwlock_fn)(void *)
+		win32_srwlock_release_shared = (win32_srwlock_fn)
 			GetProcAddress(hModule, "ReleaseSRWLockShared");
-		win32_srwlock_acquire_exclusive = (win32_srwlock_fn)(void *)
+		win32_srwlock_acquire_exclusive = (win32_srwlock_fn)
 			GetProcAddress(hModule, "AcquireSRWLockExclusive");
-		win32_srwlock_release_exclusive = (win32_srwlock_fn)(void *)
+		win32_srwlock_release_exclusive = (win32_srwlock_fn)
 			GetProcAddress(hModule, "ReleaseSRWLockExclusive");
 	}
 
@@ -101,6 +103,9 @@ void git_thread_exit(void *value)
 {
 	assert(GIT_GLOBAL->current_thread);
 	GIT_GLOBAL->current_thread->result = value;
+
+	git__free_tls_data();
+
 	ExitThread(CLEAN_THREAD_EXIT);
 }
 

data/vendor/libgit2/src/win32/w32_buffer.c

@@ -25,17 +25,13 @@ int git_buf_put_w(git_buf *buf, const wchar_t *string_w, size_t len_w)
 	int utf8_len, utf8_write_len;
 	size_t new_size;
 
-	if (!len_w) {
+	if (!len_w)
 		return 0;
-	} else if (len_w > INT_MAX) {
-		git_error_set_oom();
-		return -1;
-	}
 
 	assert(string_w);
 
 	/* Measure the string necessary for conversion */
-	if ((utf8_len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, string_w, (int)len_w, NULL, 0, NULL, NULL)) == 0)
+	if ((utf8_len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, string_w, len_w, NULL, 0, NULL, NULL)) == 0)
 		return 0;
 
 	assert(utf8_len > 0);
@@ -47,7 +43,7 @@ int git_buf_put_w(git_buf *buf, const wchar_t *string_w, size_t len_w)
 		return -1;
 
 	if ((utf8_write_len = WideCharToMultiByte(
-			CP_UTF8, WC_ERR_INVALID_CHARS, string_w, (int)len_w, &buf->ptr[buf->size], utf8_len, NULL, NULL)) == 0)
+			CP_UTF8, WC_ERR_INVALID_CHARS, string_w, len_w, &buf->ptr[buf->size], utf8_len, NULL, NULL)) == 0)
 		return handle_wc_error();
 
 	assert(utf8_write_len == utf8_len);

data/vendor/libgit2/src/win32/w32_crtdbg_stacktrace.c

@@ -71,6 +71,99 @@ static bool g_limit_reached = false; /* had allocs after we filled row table */
 static unsigned int g_checkpoint_id = 0; /* to better label leak checkpoints */
 static bool g_transient_leaks_since_mark = false; /* payload for hook */
 
+static void *crtdbg__malloc(size_t len, const char *file, int line)
+{
+	void *ptr = _malloc_dbg(len, _NORMAL_BLOCK, git_win32__crtdbg_stacktrace(1,file), line);
+	if (!ptr) git_error_set_oom();
+	return ptr;
+}
+
+static void *crtdbg__calloc(size_t nelem, size_t elsize, const char *file, int line)
+{
+	void *ptr = _calloc_dbg(nelem, elsize, _NORMAL_BLOCK, git_win32__crtdbg_stacktrace(1,file), line);
+	if (!ptr) git_error_set_oom();
+	return ptr;
+}
+
+static char *crtdbg__strdup(const char *str, const char *file, int line)
+{
+	char *ptr = _strdup_dbg(str, _NORMAL_BLOCK, git_win32__crtdbg_stacktrace(1,file), line);
+	if (!ptr) git_error_set_oom();
+	return ptr;
+}
+
+static char *crtdbg__strndup(const char *str, size_t n, const char *file, int line)
+{
+	size_t length = 0, alloclength;
+	char *ptr;
+
+	length = p_strnlen(str, n);
+
+	if (GIT_ADD_SIZET_OVERFLOW(&alloclength, length, 1) ||
+		!(ptr = crtdbg__malloc(alloclength, file, line)))
+		return NULL;
+
+	if (length)
+		memcpy(ptr, str, length);
+
+	ptr[length] = '\0';
+
+	return ptr;
+}
+
+static char *crtdbg__substrdup(const char *start, size_t n, const char *file, int line)
+{
+	char *ptr;
+	size_t alloclen;
+
+	if (GIT_ADD_SIZET_OVERFLOW(&alloclen, n, 1) ||
+		!(ptr = crtdbg__malloc(alloclen, file, line)))
+		return NULL;
+
+	memcpy(ptr, start, n);
+	ptr[n] = '\0';
+	return ptr;
+}
+
+static void *crtdbg__realloc(void *ptr, size_t size, const char *file, int line)
+{
+	void *new_ptr = _realloc_dbg(ptr, size, _NORMAL_BLOCK, git_win32__crtdbg_stacktrace(1,file), line);
+	if (!new_ptr) git_error_set_oom();
+	return new_ptr;
+}
+
+static void *crtdbg__reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line)
+{
+	size_t newsize;
+
+	return GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize) ?
+		NULL : _realloc_dbg(ptr, newsize, _NORMAL_BLOCK, git_win32__crtdbg_stacktrace(1,file), line);
+}
+
+static void *crtdbg__mallocarray(size_t nelem, size_t elsize, const char *file, int line)
+{
+	return crtdbg__reallocarray(NULL, nelem, elsize, file, line);
+}
+
+static void crtdbg__free(void *ptr)
+{
+	free(ptr);
+}
+
+int git_win32_crtdbg_init_allocator(git_allocator *allocator)
+{
+	allocator->gmalloc = crtdbg__malloc;
+	allocator->gcalloc = crtdbg__calloc;
+	allocator->gstrdup = crtdbg__strdup;
+	allocator->gstrndup = crtdbg__strndup;
+	allocator->gsubstrdup = crtdbg__substrdup;
+	allocator->grealloc = crtdbg__realloc;
+	allocator->greallocarray = crtdbg__reallocarray;
+	allocator->gmallocarray = crtdbg__mallocarray;
+	allocator->gfree = crtdbg__free;
+	return 0;
+}
+
 /**
  * Compare function for bsearch on g_cs_index table.
  */

data/vendor/libgit2/src/win32/w32_crtdbg_stacktrace.h

@@ -43,6 +43,8 @@
  * startup.  See tests/main.c for an example.
  */
 
+int git_win32_crtdbg_init_allocator(git_allocator *allocator);
+
 /**
  * Initialize our memory leak tracking and de-dup data structures.
  * This should ONLY be called by git_libgit2_init().

data/vendor/libgit2/src/win32/w32_stack.c

@@ -13,6 +13,11 @@
 #include "win32/posix.h"
 #include "hash.h"
 
+/**
+ * This is supposedly defined in WinBase.h (from Windows.h) but there were linker issues.
+ */
+USHORT WINAPI RtlCaptureStackBackTrace(ULONG, ULONG, PVOID*, PULONG);
+
 static bool   g_win32_stack_initialized = false;
 static HANDLE g_win32_stack_process = INVALID_HANDLE_VALUE;
 static git_win32__stack__aux_cb_alloc  g_aux_cb_alloc  = NULL;
@@ -76,7 +81,7 @@ int git_win32__stack_compare(
 }
 
 int git_win32__stack_format(
-	char *pbuf, size_t buf_len,
+	char *pbuf, int buf_len,
 	const git_win32__stack__raw_data *pdata,
 	const char *prefix, const char *suffix)
 {
@@ -91,10 +96,10 @@ int git_win32__stack_format(
 	} s;
 
 	IMAGEHLP_LINE64 line;
-	size_t buf_used = 0;
+	int buf_used = 0;
 	unsigned int k;
 	char detail[MY_MAX_FILENAME * 2]; /* filename plus space for function name and formatting */
-	size_t detail_len;
+	int detail_len;
 
 	if (!g_win32_stack_initialized) {
 		git_error_set(GIT_ERROR_INVALID, "git_win32_stack not initialized.");
@@ -171,7 +176,7 @@ int git_win32__stack_format(
 }
 
 int git_win32__stack(
-	char * pbuf, size_t buf_len,
+	char * pbuf, int buf_len,
 	int skip,
 	const char *prefix, const char *suffix)
 {

data/vendor/libgit2/src/win32/w32_stack.h

@@ -38,7 +38,7 @@ typedef void (*git_win32__stack__aux_cb_alloc)(unsigned int *aux_id);
  * @param aux_msg A buffer where a formatted message should be written.
  * @param aux_msg_len The size of the buffer.
  */
-typedef void (*git_win32__stack__aux_cb_lookup)(unsigned int aux_id, char *aux_msg, size_t aux_msg_len);
+typedef void (*git_win32__stack__aux_cb_lookup)(unsigned int aux_id, char *aux_msg, unsigned int aux_msg_len);
 
 /**
  * Register an "aux" data provider to augment our C stacktrace data.
@@ -116,7 +116,7 @@ int git_win32__stack_compare(
  * @param suffix String written after each frame; defaults to "\n".
  */
 int git_win32__stack_format(
-	char *pbuf, size_t buf_len,
+	char *pbuf, int buf_len,
 	const git_win32__stack__raw_data *pdata,
 	const char *prefix, const char *suffix);
 
@@ -132,7 +132,7 @@ int git_win32__stack_format(
  * @param suffix String written after each frame; defaults to "\n".
  */
 int git_win32__stack(
-	char * pbuf, size_t buf_len,
+	char * pbuf, int buf_len,
 	int skip,
 	const char *prefix, const char *suffix);
 

data/vendor/libgit2/src/win32/w32_util.c

@@ -93,34 +93,3 @@ int git_win32__hidden(bool *out, const char *path)
 	*out = (attrs & FILE_ATTRIBUTE_HIDDEN) ? true : false;
 	return 0;
 }
-
-int git_win32__file_attribute_to_stat(
-	struct stat *st,
-	const WIN32_FILE_ATTRIBUTE_DATA *attrdata,
-	const wchar_t *path)
-{
-	git_win32__stat_init(st,
-		attrdata->dwFileAttributes,
-		attrdata->nFileSizeHigh,
-		attrdata->nFileSizeLow,
-		attrdata->ftCreationTime,
-		attrdata->ftLastAccessTime,
-		attrdata->ftLastWriteTime);
-
-	if (attrdata->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT && path) {
-		git_win32_path target;
-
-		if (git_win32_path_readlink_w(target, path) >= 0) {
-			st->st_mode = (st->st_mode & ~S_IFMT) | S_IFLNK;
-
-			/* st_size gets the UTF-8 length of the target name, in bytes,
-			 * not counting the NULL terminator */
-			if ((st->st_size = git__utf16_to_8(NULL, 0, target)) < 0) {
-				git_error_set(GIT_ERROR_OS, "could not convert reparse point name for '%ls'", path);
-				return -1;
-			}
-		}
-	}
-
-	return 0;
-}