rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/{win32 → util/win32}/path_w32.c

@@ -7,7 +7,7 @@
 
 #include "path_w32.h"
 
-#include "path.h"
+#include "fs_path.h"
 #include "utf-conv.h"
 #include "posix.h"
 #include "reparse.h"
@@ -41,7 +41,7 @@ GIT_INLINE(int) path__cwd(wchar_t *path, int size)
 	}
 
 	/* The Win32 APIs may return "\\?\" once you've used it first.
-	 * But it may not.  What a gloriously predictible API!
+	 * But it may not.  What a gloriously predictable API!
 	 */
 	if (wcsncmp(path, PATH__NT_NAMESPACE, PATH__NT_NAMESPACE_LEN))
 		return len;
@@ -57,7 +57,7 @@ static wchar_t *path__skip_server(wchar_t *path)
 	wchar_t *c;
 
 	for (c = path; *c; c++) {
-		if (git_path_is_dirsep(*c))
+		if (git_fs_path_is_dirsep(*c))
 			return c + 1;
 	}
 
@@ -71,9 +71,9 @@ static wchar_t *path__skip_prefix(wchar_t *path)
 
 		if (wcsncmp(path, L"UNC\\", 4) == 0)
 			path = path__skip_server(path + 4);
-		else if (git_path_is_absolute(path))
+		else if (git_fs_path_is_absolute(path))
 			path += PATH__ABSOLUTE_LEN;
-	} else if (git_path_is_absolute(path)) {
+	} else if (git_fs_path_is_absolute(path)) {
 		path += PATH__ABSOLUTE_LEN;
 	} else if (path__is_unc(path)) {
 		path = path__skip_server(path + 2);
@@ -151,6 +151,137 @@ int git_win32_path_canonicalize(git_win32_path path)
 	return (int)(to - path);
 }
 
+static int git_win32_path_join(
+	git_win32_path dest,
+	const wchar_t *one,
+	size_t one_len,
+	const wchar_t *two,
+	size_t two_len)
+{
+	size_t backslash = 0;
+
+	if (one_len && two_len && one[one_len - 1] != L'\\')
+		backslash = 1;
+
+	if (one_len + two_len + backslash > MAX_PATH) {
+		git_error_set(GIT_ERROR_INVALID, "path too long");
+		return -1;
+	}
+
+	memmove(dest, one, one_len * sizeof(wchar_t));
+
+	if (backslash)
+		dest[one_len] = L'\\';
+
+	memcpy(dest + one_len + backslash, two, two_len * sizeof(wchar_t));
+	dest[one_len + backslash + two_len] = L'\0';
+
+	return 0;
+}
+
+struct win32_path_iter {
+	wchar_t *env;
+	const wchar_t *current_dir;
+};
+
+static int win32_path_iter_init(struct win32_path_iter *iter)
+{
+	DWORD len = GetEnvironmentVariableW(L"PATH", NULL, 0);
+
+	if (!len && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
+		iter->env = NULL;
+		iter->current_dir = NULL;
+		return 0;
+	} else if (!len) {
+		git_error_set(GIT_ERROR_OS, "could not load PATH");
+		return -1;
+	}
+
+	iter->env = git__malloc(len * sizeof(wchar_t));
+	GIT_ERROR_CHECK_ALLOC(iter->env);
+
+	len = GetEnvironmentVariableW(L"PATH", iter->env, len);
+
+	if (len == 0) {
+		git_error_set(GIT_ERROR_OS, "could not load PATH");
+		return -1;
+	}
+
+	iter->current_dir = iter->env;
+	return 0;
+}
+
+static int win32_path_iter_next(
+	const wchar_t **out,
+	size_t *out_len,
+	struct win32_path_iter *iter)
+{
+	const wchar_t *start;
+	wchar_t term;
+	size_t len = 0;
+
+	if (!iter->current_dir || !*iter->current_dir)
+		return GIT_ITEROVER;
+
+	term = (*iter->current_dir == L'"') ? *iter->current_dir++ : L';';
+	start = iter->current_dir;
+
+	while (*iter->current_dir && *iter->current_dir != term) {
+		iter->current_dir++;
+		len++;
+	}
+
+	*out = start;
+	*out_len = len;
+
+	if (term == L'"' && *iter->current_dir)
+		iter->current_dir++;
+
+	while (*iter->current_dir == L';')
+		iter->current_dir++;
+
+	return 0;
+}
+
+static void win32_path_iter_dispose(struct win32_path_iter *iter)
+{
+	if (!iter)
+		return;
+
+	git__free(iter->env);
+	iter->env = NULL;
+	iter->current_dir = NULL;
+}
+
+int git_win32_path_find_executable(git_win32_path fullpath, wchar_t *exe)
+{
+	struct win32_path_iter path_iter;
+	const wchar_t *dir;
+	size_t dir_len, exe_len = wcslen(exe);
+	bool found = false;
+
+	if (win32_path_iter_init(&path_iter) < 0)
+		return -1;
+
+	while (win32_path_iter_next(&dir, &dir_len, &path_iter) != GIT_ITEROVER) {
+		if (git_win32_path_join(fullpath, dir, dir_len, exe, exe_len) < 0)
+			continue;
+
+		if (_waccess(fullpath, 0) == 0) {
+			found = true;
+			break;
+		}
+	}
+
+	win32_path_iter_dispose(&path_iter);
+
+	if (found)
+		return 0;
+
+	fullpath[0] = L'\0';
+	return GIT_ENOTFOUND;
+}
+
 static int win32_path_cwd(wchar_t *out, size_t len)
 {
 	int cwd_len;
@@ -204,14 +335,14 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src)
 	dest += PATH__NT_NAMESPACE_LEN;
 
 	/* See if this is an absolute path (beginning with a drive letter) */
-	if (git_path_is_absolute(src)) {
-		if (git__utf8_to_16(dest, GIT_WIN_PATH_MAX, src) < 0)
+	if (git_fs_path_is_absolute(src)) {
+		if (git_utf8_to_16(dest, GIT_WIN_PATH_MAX, src) < 0)
 			goto on_error;
 	}
 	/* File-prefixed NT-style paths beginning with \\?\ */
 	else if (path__is_nt_namespace(src)) {
 		/* Skip the NT prefix, the destination already contains it */
-		if (git__utf8_to_16(dest, GIT_WIN_PATH_MAX, src + PATH__NT_NAMESPACE_LEN) < 0)
+		if (git_utf8_to_16(dest, GIT_WIN_PATH_MAX, src + PATH__NT_NAMESPACE_LEN) < 0)
 			goto on_error;
 	}
 	/* UNC paths */
@@ -220,7 +351,7 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src)
 		dest += 4;
 
 		/* Skip the leading "\\" */
-		if (git__utf8_to_16(dest, GIT_WIN_PATH_MAX - 2, src + 2) < 0)
+		if (git_utf8_to_16(dest, GIT_WIN_PATH_MAX - 2, src + 2) < 0)
 			goto on_error;
 	}
 	/* Absolute paths omitting the drive letter */
@@ -228,13 +359,13 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src)
 		if (path__cwd(dest, GIT_WIN_PATH_MAX) < 0)
 			goto on_error;
 
-		if (!git_path_is_absolute(dest)) {
+		if (!git_fs_path_is_absolute(dest)) {
 			errno = ENOENT;
 			goto on_error;
 		}
 
 		/* Skip the drive letter specification ("C:") */
-		if (git__utf8_to_16(dest + 2, GIT_WIN_PATH_MAX - 2, src) < 0)
+		if (git_utf8_to_16(dest + 2, GIT_WIN_PATH_MAX - 2, src) < 0)
 			goto on_error;
 	}
 	/* Relative paths */
@@ -246,7 +377,7 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src)
 
 		dest[cwd_len++] = L'\\';
 
-		if (git__utf8_to_16(dest + cwd_len, GIT_WIN_PATH_MAX - cwd_len, src) < 0)
+		if (git_utf8_to_16(dest + cwd_len, GIT_WIN_PATH_MAX - cwd_len, src) < 0)
 			goto on_error;
 	}
 
@@ -266,14 +397,14 @@ int git_win32_path_relative_from_utf8(git_win32_path out, const char *src)
 	int len;
 
 	/* Handle absolute paths */
-	if (git_path_is_absolute(src) ||
+	if (git_fs_path_is_absolute(src) ||
 	    path__is_nt_namespace(src) ||
 	    path__is_unc(src) ||
 	    path__startswith_slash(src)) {
 		return git_win32_path_from_utf8(out, src);
 	}
 
-	if ((len = git__utf8_to_16(dest, GIT_WIN_PATH_MAX, src)) < 0)
+	if ((len = git_utf8_to_16(dest, GIT_WIN_PATH_MAX, src)) < 0)
 		return -1;
 
 	for (p = dest; p < (dest + len); p++) {
@@ -302,10 +433,10 @@ int git_win32_path_to_utf8(git_win32_utf8_path dest, const wchar_t *src)
 		}
 	}
 
-	if ((len = git__utf16_to_8(out, GIT_WIN_PATH_UTF8, src)) < 0)
+	if ((len = git_utf8_from_16(out, GIT_WIN_PATH_UTF8, src)) < 0)
 		return len;
 
-	git_path_mkposix(dest);
+	git_fs_path_mkposix(dest);
 
 	return len;
 }
@@ -340,7 +471,7 @@ char *git_win32_path_8dot3_name(const char *path)
 	if (namelen > 12 || (shortname = git__malloc(namelen + 1)) == NULL)
 		return NULL;
 
-	if ((len = git__utf16_to_8(shortname, namelen + 1, start)) < 0)
+	if ((len = git_utf8_from_16(shortname, namelen + 1, start)) < 0)
 		return NULL;
 
 	return shortname;

data/vendor/libgit2/src/{win32 → util/win32}/path_w32.h

@@ -7,7 +7,7 @@
 #ifndef INCLUDE_win32_path_w32_h__
 #define INCLUDE_win32_path_w32_h__
 
-#include "common.h"
+#include "git2_util.h"
 
 /**
  * Create a Win32 path (in UCS-2 format) from a UTF-8 string.  If the given
@@ -86,4 +86,6 @@ size_t git_win32_path_trim_end(wchar_t *str, size_t len);
  */
 size_t git_win32_path_remove_namespace(wchar_t *str, size_t len);
 
+int git_win32_path_find_executable(git_win32_path fullpath, wchar_t* exe);
+
 #endif

data/vendor/libgit2/src/{win32 → util/win32}/posix.h

@@ -7,7 +7,7 @@
 #ifndef INCLUDE_win32_posix_h__
 #define INCLUDE_win32_posix_h__
 
-#include "common.h"
+#include "git2_util.h"
 #include "../posix.h"
 #include "win32-compat.h"
 #include "path_w32.h"
@@ -42,7 +42,6 @@ extern int p_inet_pton(int af, const char *src, void* dst);
 
 extern int p_vsnprintf(char *buffer, size_t count, const char *format, va_list argptr);
 extern int p_snprintf(char *buffer, size_t count, const char *format, ...) GIT_FORMAT_PRINTF(3, 4);
-extern int p_mkstemp(char *tmp_path);
 extern int p_chdir(const char *path);
 extern int p_chmod(const char *path, mode_t mode);
 extern int p_rmdir(const char *path);

data/vendor/libgit2/src/{win32 → util/win32}/posix_w32.c

@@ -5,16 +5,14 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "common.h"
+#include "git2_util.h"
 
 #include "../posix.h"
 #include "../futils.h"
-#include "path.h"
+#include "fs_path.h"
 #include "path_w32.h"
 #include "utf-conv.h"
-#include "repository.h"
 #include "reparse.h"
-#include "buffer.h"
 #include <errno.h>
 #include <io.h>
 #include <fcntl.h>
@@ -415,21 +413,21 @@ int p_readlink(const char *path, char *buf, size_t bufsiz)
 
 static bool target_is_dir(const char *target, const char *path)
 {
-	git_buf resolved = GIT_BUF_INIT;
+	git_str resolved = GIT_STR_INIT;
 	git_win32_path resolved_w;
 	bool isdir = true;
 
-	if (git_path_is_absolute(target))
+	if (git_fs_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 ||
+	else if (git_fs_path_dirname_r(&resolved, path) < 0 ||
+		 git_fs_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);
+	git_str_dispose(&resolved);
 	return isdir;
 }
 
@@ -443,7 +441,7 @@ int p_symlink(const char *target, const char *path)
 	 * not want to use `git_win32_path_from_utf8` for converting the target,
 	 * as that function will automatically pre-pend the current working
 	 * directory in case the path is not absolute. As Git will instead use
-	 * relative symlinks, this is not someting we want.
+	 * relative symlinks, this is not something we want.
 	 */
 	if (git_win32_path_from_utf8(path_w, path) < 0 ||
 	    git_win32_path_relative_from_utf8(target_w, target) < 0)
@@ -651,7 +649,7 @@ int p_getcwd(char *buffer_out, size_t size)
 	git_win32_path_remove_namespace(cwd, wcslen(cwd));
 
 	/* Convert the working directory back to UTF-8 */
-	if (git__utf16_to_8(buffer_out, size, cwd) < 0) {
+	if (git_utf8_from_16(buffer_out, size, cwd) < 0) {
 		DWORD code = GetLastError();
 
 		if (code == ERROR_INSUFFICIENT_BUFFER)
@@ -662,7 +660,7 @@ int p_getcwd(char *buffer_out, size_t size)
 		return -1;
 	}
 
-	git_path_mkposix(buffer_out);
+	git_fs_path_mkposix(buffer_out);
 	return 0;
 }
 
@@ -772,6 +770,7 @@ int p_rmdir(const char *path)
 			 * handle to the directory."  This sounds like what everybody else calls
 			 * EBUSY.  Let's convert appropriate error codes.
 			 */
+			case ERROR_ACCESS_DENIED:
 			case ERROR_SHARING_VIOLATION:
 				errno = EBUSY;
 				break;
@@ -789,13 +788,19 @@ int p_rmdir(const char *path)
 char *p_realpath(const char *orig_path, char *buffer)
 {
 	git_win32_path orig_path_w, buffer_w;
+	DWORD long_len;
 
 	if (git_win32_path_from_utf8(orig_path_w, orig_path) < 0)
 		return NULL;
 
-	/* Note that if the path provided is a relative path, then the current directory
+	/*
+	 * POSIX realpath performs two functions: first, it turns relative
+	 * paths into absolute paths. For this, we need GetFullPathName.
+	 *
+	 * Note that if the path provided is a relative path, then the current directory
 	 * is used to resolve the path -- which is a concurrency issue because the current
-	 * directory is a process-wide variable. */
+	 * directory is a process-wide variable.
+	 */
 	if (!GetFullPathNameW(orig_path_w, GIT_WIN_PATH_UTF16, buffer_w, NULL)) {
 		if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 			errno = ENAMETOOLONG;
@@ -805,9 +810,26 @@ char *p_realpath(const char *orig_path, char *buffer)
 		return NULL;
 	}
 
-	/* The path must exist. */
-	if (GetFileAttributesW(buffer_w) == INVALID_FILE_ATTRIBUTES) {
-		errno = ENOENT;
+	/*
+	 * Then, the path is canonicalized. eg, on macOS,
+	 * "/TMP" -> "/private/tmp". For this, we need GetLongPathName.
+	 */
+	if ((long_len = GetLongPathNameW(buffer_w, buffer_w, GIT_WIN_PATH_UTF16)) == 0) {
+		DWORD error = GetLastError();
+
+		if (error == ERROR_FILE_NOT_FOUND ||
+		    error == ERROR_PATH_NOT_FOUND)
+			errno = ENOENT;
+		else if (error == ERROR_ACCESS_DENIED)
+			errno = EPERM;
+		else
+			errno = EINVAL;
+
+		return NULL;
+	}
+
+	if (long_len > GIT_WIN_PATH_UTF16) {
+		errno = ENAMETOOLONG;
 		return NULL;
 	}
 
@@ -822,8 +844,7 @@ char *p_realpath(const char *orig_path, char *buffer)
 	if (git_win32_path_to_utf8(buffer, buffer_w) < 0)
 		return NULL;
 
-	git_path_mkposix(buffer);
-
+	git_fs_path_mkposix(buffer);
 	return buffer;
 }
 
@@ -862,20 +883,6 @@ int p_snprintf(char *buffer, size_t count, const char *format, ...)
 	return r;
 }
 
-/* TODO: wut? */
-int p_mkstemp(char *tmp_path)
-{
-#if defined(_MSC_VER) && _MSC_VER >= 1500
-	if (_mktemp_s(tmp_path, strlen(tmp_path) + 1) != 0)
-		return -1;
-#else
-	if (_mktemp(tmp_path) == NULL)
-		return -1;
-#endif
-
-	return p_open(tmp_path, O_RDWR | O_CREAT | O_EXCL, 0744); /* -V536 */
-}
-
 int p_access(const char *path, mode_t mode)
 {
 	git_win32_path buf;
@@ -1003,7 +1010,7 @@ ssize_t p_pread(int fd, void *data, size_t size, off64_t offset)
 	/* Fail if the final offset would have overflowed to match POSIX semantics. */
 	if (!git__is_ssizet(size) || git__add_int64_overflow(&final_offset, offset, (int64_t)size)) {
 		errno = EINVAL;
-		return -1;	
+		return -1;
 	}
 
 	/*
@@ -1038,7 +1045,7 @@ ssize_t p_pwrite(int fd, const void *data, size_t size, off64_t offset)
 	/* Fail if the final offset would have overflowed to match POSIX semantics. */
 	if (!git__is_ssizet(size) || git__add_int64_overflow(&final_offset, offset, (int64_t)size)) {
 		errno = EINVAL;
-		return -1;	
+		return -1;
 	}
 
 	/*

data/vendor/libgit2/src/util/win32/precompiled.c

@@ -0,0 +1 @@
+#include "precompiled.h"

data/vendor/libgit2/src/{win32 → util/win32}/precompiled.h

@@ -1,4 +1,4 @@
-#include "common.h"
+#include "git2_util.h"
 
 #include <errno.h>
 #include <limits.h>