rugged 1.7.2 → 1.9.4

data/vendor/libgit2/src/util/unix/realpath.c

@@ -16,17 +16,35 @@
 
 char *p_realpath(const char *pathname, char *resolved)
 {
-	char *ret;
-	if ((ret = realpath(pathname, resolved)) == NULL)
+	char *result;
+
+	if ((result = realpath(pathname, resolved)) == NULL)
 		return NULL;
 
 #ifdef __OpenBSD__
 	/* The OpenBSD realpath function behaves differently,
 	 * figure out if the file exists */
-	if (access(ret, F_OK) < 0)
-		ret = NULL;
+	if (access(result, F_OK) < 0) {
+		if (!resolved)
+			free(result);
+
+		return NULL;
+	}
 #endif
-	return ret;
+
+	/*
+	 * If resolved == NULL, the system has allocated the result
+	 * string. We need to strdup this into _our_ allocator pool
+	 * so that callers can free it with git__free.
+	 */
+	if (!resolved) {
+		char *dup = git__strdup(result);
+		free(result);
+
+		result = dup;
+	}
+
+	return result;
 }
 
 #endif

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

@@ -269,13 +269,26 @@ int git__prefixncmp_icase(const char *str, size_t str_n, const char *prefix)
 	return prefixcmp(str, str_n, prefix, true);
 }
 
-int git__suffixcmp(const char *str, const char *suffix)
+static int suffixcmp(const char *str, const char *suffix, bool icase)
 {
 	size_t a = strlen(str);
 	size_t b = strlen(suffix);
+
 	if (a < b)
 		return -1;
-	return strcmp(str + (a - b), suffix);
+
+	return icase ? strcasecmp(str + (a - b), suffix) :
+	               strcmp(str + (a - b), suffix);
+}
+
+int git__suffixcmp(const char *str, const char *suffix)
+{
+	return suffixcmp(str, suffix, false);
+}
+
+int git__suffixcmp_icase(const char *str, const char *suffix)
+{
+	return suffixcmp(str, suffix, true);
 }
 
 char *git__strtok(char **end, const char *sep)
@@ -323,7 +336,7 @@ char *git__strsep(char **end, const char *sep)
 
 size_t git__linenlen(const char *buffer, size_t buffer_len)
 {
-	char *nl = memchr(buffer, '\n', buffer_len);
+	const char *nl = memchr(buffer, '\n', buffer_len);
 	return nl ? (size_t)(nl - buffer) + 1 : buffer_len;
 }
 
@@ -623,12 +636,12 @@ int git__bsearch_r(
  */
 int git__strcmp_cb(const void *a, const void *b)
 {
-	return strcmp((const char *)a, (const char *)b);
+	return git__strcmp((const char *)a, (const char *)b);
 }
 
 int git__strcasecmp_cb(const void *a, const void *b)
 {
-	return strcasecmp((const char *)a, (const char *)b);
+	return git__strcasecmp((const char *)a, (const char *)b);
 }
 
 int git__parse_bool(int *out, const char *value)

data/vendor/libgit2/src/util/util.h

@@ -7,15 +7,15 @@
 #ifndef INCLUDE_util_h__
 #define INCLUDE_util_h__
 
-#ifndef GIT_WIN32
-# include <ctype.h>
-#endif
-
 #include "str.h"
 #include "git2_util.h"
 #include "strnlen.h"
 #include "thread.h"
 
+#ifndef GIT_WIN32
+# include <ctype.h>
+#endif
+
 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
 #define bitsizeof(x) (CHAR_BIT * sizeof(x))
 #define MSB(x, bits) ((x) & (~UINT64_C(0) << (bitsizeof(x) - (bits))))
@@ -57,6 +57,7 @@ extern int git__prefixcmp_icase(const char *str, const char *prefix);
 extern int git__prefixncmp(const char *str, size_t str_n, const char *prefix);
 extern int git__prefixncmp_icase(const char *str, size_t str_n, const char *prefix);
 extern int git__suffixcmp(const char *str, const char *suffix);
+extern int git__suffixcmp_icase(const char *str, const char *suffix);
 
 GIT_INLINE(int) git__signum(int val)
 {
@@ -83,15 +84,6 @@ extern char *git__strsep(char **end, const char *sep);
 extern void git__strntolower(char *str, size_t len);
 extern void git__strtolower(char *str);
 
-#ifdef GIT_WIN32
-GIT_INLINE(int) git__tolower(int c)
-{
-	return (c >= 'A' && c <= 'Z') ? (c + 32) : c;
-}
-#else
-# define git__tolower(a) tolower(a)
-#endif
-
 extern size_t git__linenlen(const char *buffer, size_t buffer_len);
 
 GIT_INLINE(const char *) git__next_line(const char *s)
@@ -249,26 +241,6 @@ GIT_INLINE(size_t) git__size_t_powerof2(size_t v)
 	return git__size_t_bitmask(v) + 1;
 }
 
-GIT_INLINE(bool) git__isupper(int c)
-{
-	return (c >= 'A' && c <= 'Z');
-}
-
-GIT_INLINE(bool) git__isalpha(int c)
-{
-	return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
-}
-
-GIT_INLINE(bool) git__isdigit(int c)
-{
-	return (c >= '0' && c <= '9');
-}
-
-GIT_INLINE(bool) git__isspace(int c)
-{
-	return (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r' || c == '\v');
-}
-
 GIT_INLINE(bool) git__isspace_nonlf(int c)
 {
 	return (c == ' ' || c == '\t' || c == '\f' || c == '\r' || c == '\v');
@@ -279,11 +251,6 @@ GIT_INLINE(bool) git__iswildcard(int c)
 	return (c == '*' || c == '?' || c == '[');
 }
 
-GIT_INLINE(bool) git__isxdigit(int c)
-{
-	return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'));
-}
-
 /*
  * Parse a string value as a boolean, just like Core Git does.
  *

data/vendor/libgit2/src/util/vector.c

@@ -76,7 +76,7 @@ int git_vector_dup(git_vector *v, const git_vector *src, git_vector_cmp cmp)
 	return 0;
 }
 
-void git_vector_free(git_vector *v)
+void git_vector_dispose(git_vector *v)
 {
 	if (!v)
 		return;
@@ -88,7 +88,7 @@ void git_vector_free(git_vector *v)
 	v->_alloc_size = 0;
 }
 
-void git_vector_free_deep(git_vector *v)
+void git_vector_dispose_deep(git_vector *v)
 {
 	size_t i;
 
@@ -100,7 +100,7 @@ void git_vector_free_deep(git_vector *v)
 		v->contents[i] = NULL;
 	}
 
-	git_vector_free(v);
+	git_vector_dispose(v);
 }
 
 int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp)

data/vendor/libgit2/src/util/vector.h

@@ -28,8 +28,8 @@ typedef struct git_vector {
 
 GIT_WARN_UNUSED_RESULT int git_vector_init(
 	git_vector *v, size_t initial_size, git_vector_cmp cmp);
-void git_vector_free(git_vector *v);
-void git_vector_free_deep(git_vector *v); /* free each entry and self */
+void git_vector_dispose(git_vector *v);
+void git_vector_dispose_deep(git_vector *v); /* free each entry and self */
 void git_vector_clear(git_vector *v);
 GIT_WARN_UNUSED_RESULT int git_vector_dup(
 	git_vector *v, const git_vector *src, git_vector_cmp cmp);

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

@@ -153,6 +153,7 @@ int git_win32_path_canonicalize(git_win32_path path)
 
 static int git_win32_path_join(
 	git_win32_path dest,
+	size_t *dest_len,
 	const wchar_t *one,
 	size_t one_len,
 	const wchar_t *two,
@@ -176,6 +177,9 @@ static int git_win32_path_join(
 	memcpy(dest + one_len + backslash, two, two_len * sizeof(wchar_t));
 	dest[one_len + backslash + two_len] = L'\0';
 
+	if (dest_len)
+		*dest_len = one_len + backslash + two_len;
+
 	return 0;
 }
 
@@ -253,21 +257,92 @@ static void win32_path_iter_dispose(struct win32_path_iter *iter)
 	iter->current_dir = NULL;
 }
 
+struct executable_suffix {
+	const wchar_t *suffix;
+	size_t len;
+};
+
+static struct executable_suffix suffixes[] = { { NULL, 0 }, { L".exe", 4 }, { L".cmd", 4 } };
+
+static bool has_executable_suffix(wchar_t *exe, size_t exe_len)
+{
+	size_t i;
+
+	for (i = 0; i < ARRAY_SIZE(suffixes); i++) {
+		struct executable_suffix *suffix = &suffixes[i];
+
+		if (!suffix->len)
+			continue;
+
+		if (exe_len < suffix->len)
+			continue;
+
+		if (memcmp(&exe[exe_len - suffix->len], suffix->suffix, suffix->len) == 0)
+			return true;
+	}
+
+	return false;
+}
+
+static int is_executable(git_win32_path path, size_t path_len, bool suffixed)
+{
+	size_t i;
+
+	/*
+	 * if the given name has an executable suffix, then try looking for it
+	 * directly. in all cases, append executable extensions
+	 * (".exe", ".cmd"...)
+	 */
+	for (i = suffixed ? 0 : 1; i < ARRAY_SIZE(suffixes); i++) {
+		struct executable_suffix *suffix = &suffixes[i];
+
+		if (suffix->len) {
+			if (path_len + suffix->len > MAX_PATH)
+				continue;
+
+			wcscat(path, suffix->suffix);
+		}
+
+		if (_waccess(path, 0) == 0)
+			return true;
+
+		path[path_len] = L'\0';
+	}
+
+	return false;
+}
+
 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;
+	size_t dir_len, exe_len, fullpath_len;
+	bool suffixed = false, found = false;
+
+	if ((exe_len = wcslen(exe)) > MAX_PATH)
+		goto done;
+
+	/* see if the given executable has an executable suffix; if so we will
+	 * look for the explicit name directly, as well as with added suffixes.
+	 */
+	suffixed = has_executable_suffix(exe, exe_len);
+
+	/* For fully-qualified paths we do not look in PATH */
+	if (wcschr(exe, L'\\') != NULL || wcschr(exe, L'/') != NULL) {
+		if ((found = is_executable(exe, exe_len, suffixed)))
+			wcscpy(fullpath, exe);
+
+		goto done;
+	}
 
 	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)
+	while (win32_path_iter_next(&dir, &dir_len, &path_iter) != GIT_ITEROVER && !found) {
+		if (git_win32_path_join(fullpath, &fullpath_len, dir, dir_len, exe, exe_len) < 0)
 			continue;
 
-		if (_waccess(fullpath, 0) == 0) {
+		if (is_executable(fullpath, fullpath_len, suffixed)) {
 			found = true;
 			break;
 		}
@@ -275,6 +350,7 @@ int git_win32_path_find_executable(git_win32_path fullpath, wchar_t *exe)
 
 	win32_path_iter_dispose(&path_iter);
 
+done:
 	if (found)
 		return 0;
 

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

@@ -770,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;
@@ -787,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;
@@ -803,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;
 	}
 
@@ -821,7 +845,6 @@ char *p_realpath(const char *orig_path, char *buffer)
 		return NULL;
 
 	git_fs_path_mkposix(buffer);
-
 	return buffer;
 }