rugged 1.7.2 → 1.9.0

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))))
@@ -83,15 +83,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 +240,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 +250,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/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;
 }
 

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

@@ -0,0 +1,506 @@
+/*
+ * 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.
+ */
+
+#include <stdio.h>
+#include <git2.h>
+
+#include "git2_util.h"
+#include "process.h"
+#include "strlist.h"
+
+#ifndef DWORD_MAX
+# define DWORD_MAX INT32_MAX
+#endif
+
+#define ENV_MAX 32767
+
+struct git_process {
+	wchar_t *appname;
+	wchar_t *cmdline;
+	wchar_t *env;
+
+	wchar_t *cwd;
+
+	unsigned int capture_in  : 1,
+	             capture_out : 1,
+	             capture_err : 1;
+
+	PROCESS_INFORMATION process_info;
+
+	HANDLE child_in;
+	HANDLE child_out;
+	HANDLE child_err;
+
+	git_process_result_status status;
+};
+
+/*
+ * Windows processes have a single command-line that is split by the
+ * invoked application into arguments (instead of an array of
+ * command-line arguments).  This command-line is split by space or
+ * tab delimiters, unless that whitespace is within a double quote.
+ * Literal double-quotes themselves can be escaped by a backslash,
+ * but only when not within double quotes.  Literal backslashes can
+ * be escaped by a backslash.
+ *
+ * Effectively, this means that instead of thinking about quoting
+ * individual strings, think about double quotes as an escaping
+ * mechanism for whitespace.
+ *
+ * In other words (using ` as a string boundary):
+ * [ `foo`, `bar` ] => `foo bar`
+ * [ `foo bar` ] => `foo" "bar`
+ * [ `foo bar`, `foo bar` ] => `foo" "bar foo" "bar`
+ * [ `foo "bar" foo` ] => `foo" "\"bar\"" "foo`
+ */
+int git_process__cmdline(
+	git_str *out,
+	const char **in,
+	size_t in_len)
+{
+	bool quoted = false;
+	const char *c;
+	size_t i;
+
+	for (i = 0; i < in_len; i++) {
+		/* Arguments are delimited by an unquoted space */
+		if (i)
+			git_str_putc(out, ' ');
+
+		for (c = in[i]; *c; c++) {
+			/* Start or stop quoting spaces within an argument */
+			if ((*c == ' ' || *c == '\t') && !quoted) {
+				git_str_putc(out, '"');
+				quoted = true;
+			} else if (*c != ' ' && *c != '\t' && quoted) {
+				git_str_putc(out, '"');
+				quoted = false;
+			}
+
+			/* Escape double-quotes and backslashes */
+			if (*c == '"' || *c == '\\')
+				git_str_putc(out, '\\');
+
+			git_str_putc(out, *c);
+		}
+	}
+
+	return git_str_oom(out) ? -1 : 0;
+}
+
+GIT_INLINE(bool) is_delete_env(const char *env)
+{
+	char *c = strchr(env, '=');
+
+	if (c == NULL)
+		return false;
+
+	return *(c+1) == '\0';
+}
+
+static int merge_env(wchar_t **out, const char **in, size_t in_len, bool exclude_env)
+{
+	git_str merged = GIT_STR_INIT;
+	wchar_t *in16 = NULL, *env = NULL, *e;
+	char *e8 = NULL;
+	size_t e_len;
+	int ret = 0;
+	size_t i;
+
+	*out = NULL;
+
+	in16 = git__malloc(ENV_MAX * sizeof(wchar_t));
+	GIT_ERROR_CHECK_ALLOC(in16);
+
+	e8 = git__malloc(ENV_MAX);
+	GIT_ERROR_CHECK_ALLOC(e8);
+
+	for (i = 0; in && i < in_len; i++) {
+		if (is_delete_env(in[i]))
+			continue;
+
+		if ((ret = git_utf8_to_16(in16, ENV_MAX, in[i])) < 0)
+			goto done;
+
+		git_str_put(&merged, (const char *)in16, ret * 2);
+		git_str_put(&merged, "\0\0", 2);
+	}
+
+	if (!exclude_env) {
+		env = GetEnvironmentStringsW();
+
+		for (e = env; *e; e += (e_len + 1)) {
+			e_len = wcslen(e);
+
+			if ((ret = git_utf8_from_16(e8, ENV_MAX, e)) < 0)
+				goto done;
+
+			if (git_strlist_contains_key(in, in_len, e8, '='))
+				continue;
+
+			git_str_put(&merged, (const char *)e, e_len * 2);
+			git_str_put(&merged, "\0\0", 2);
+		}
+	}
+
+	git_str_put(&merged, "\0\0", 2);
+
+	*out = (wchar_t *)git_str_detach(&merged);
+
+done:
+	if (env)
+		FreeEnvironmentStringsW(env);
+
+	git_str_dispose(&merged);
+	git__free(e8);
+	git__free(in16);
+
+	return ret < 0 ? -1 : 0;
+}
+
+static int process_new(
+	git_process **out,
+	const char *appname,
+	const char *cmdline,
+	const char **env,
+	size_t env_len,
+	git_process_options *opts)
+{
+	git_process *process;
+	int error = 0;
+
+	*out = NULL;
+
+	process = git__calloc(1, sizeof(git_process));
+	GIT_ERROR_CHECK_ALLOC(process);
+
+	if (appname &&
+	    git_utf8_to_16_alloc(&process->appname, appname) < 0) {
+		error = -1;
+		goto done;
+	}
+
+	if (git_utf8_to_16_alloc(&process->cmdline, cmdline) < 0) {
+		error = -1;
+		goto done;
+	}
+
+	if (opts && opts->cwd &&
+	    git_utf8_to_16_alloc(&process->cwd, opts->cwd) < 0) {
+		error = -1;
+		goto done;
+	}
+
+	if (env && (error = merge_env(&process->env, env, env_len, opts && opts->exclude_env) < 0))
+		goto done;
+
+	if (opts) {
+		process->capture_in = opts->capture_in;
+		process->capture_out = opts->capture_out;
+		process->capture_err = opts->capture_err;
+	}
+
+done:
+	if (error)
+		git_process_free(process);
+	else
+		*out = process;
+
+	return error;
+}
+
+int git_process_new_from_cmdline(
+	git_process **out,
+	const char *cmdline,
+	const char **env,
+	size_t env_len,
+	git_process_options *opts)
+{
+	GIT_ASSERT_ARG(out && cmdline);
+
+	return process_new(out, NULL, cmdline, env, env_len, opts);
+}
+
+int git_process_new(
+	git_process **out,
+	const char **args,
+	size_t args_len,
+	const char **env,
+	size_t env_len,
+	git_process_options *opts)
+{
+	git_str cmdline = GIT_STR_INIT;
+	int error;
+
+	GIT_ASSERT_ARG(out && args && args_len > 0);
+
+	if ((error = git_process__cmdline(&cmdline, args, args_len)) < 0)
+		goto done;
+
+	error = process_new(out, args[0], cmdline.ptr, env, env_len, opts);
+
+done:
+	git_str_dispose(&cmdline);
+	return error;
+}
+
+#define CLOSE_HANDLE(h) do { if ((h) != NULL) CloseHandle(h); } while(0)
+
+int git_process_start(git_process *process)
+{
+	STARTUPINFOW startup_info;
+	SECURITY_ATTRIBUTES security_attrs;
+	DWORD flags = CREATE_UNICODE_ENVIRONMENT;
+	HANDLE in[2]  = { NULL, NULL },
+	       out[2] = { NULL, NULL },
+	       err[2] = { NULL, NULL };
+
+	memset(&security_attrs, 0, sizeof(SECURITY_ATTRIBUTES));
+	security_attrs.bInheritHandle = TRUE;
+
+	memset(&startup_info, 0, sizeof(STARTUPINFOW));
+	startup_info.cb = sizeof(STARTUPINFOW);
+	startup_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
+	startup_info.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+	startup_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
+
+	if (process->capture_in) {
+		if (!CreatePipe(&in[0], &in[1], &security_attrs, 0) ||
+		    !SetHandleInformation(in[1], HANDLE_FLAG_INHERIT, 0)) {
+			git_error_set(GIT_ERROR_OS, "could not create pipe");
+			goto on_error;
+		}
+
+		startup_info.hStdInput = in[0];
+		startup_info.dwFlags |= STARTF_USESTDHANDLES;
+	}
+
+	if (process->capture_out) {
+		if (!CreatePipe(&out[0], &out[1], &security_attrs, 0) ||
+		    !SetHandleInformation(out[0], HANDLE_FLAG_INHERIT, 0)) {
+			git_error_set(GIT_ERROR_OS, "could not create pipe");
+			goto on_error;
+		}
+
+		startup_info.hStdOutput = out[1];
+		startup_info.dwFlags |= STARTF_USESTDHANDLES;
+	}
+
+	if (process->capture_err) {
+		if (!CreatePipe(&err[0], &err[1], &security_attrs, 0) ||
+		    !SetHandleInformation(err[0], HANDLE_FLAG_INHERIT, 0)) {
+			git_error_set(GIT_ERROR_OS, "could not create pipe");
+			goto on_error;
+		}
+
+		startup_info.hStdError = err[1];
+		startup_info.dwFlags |= STARTF_USESTDHANDLES;
+	}
+
+	memset(&process->process_info, 0, sizeof(PROCESS_INFORMATION));
+
+	if (!CreateProcessW(process->appname, process->cmdline,
+	                    NULL, NULL, TRUE, flags, process->env,
+	                    process->cwd,
+	                    &startup_info,
+	                    &process->process_info)) {
+		git_error_set(GIT_ERROR_OS, "could not create process");
+		goto on_error;
+	}
+
+	CLOSE_HANDLE(in[0]);  process->child_in  = in[1];
+	CLOSE_HANDLE(out[1]); process->child_out = out[0];
+	CLOSE_HANDLE(err[1]); process->child_err = err[0];
+
+	return 0;
+
+on_error:
+	CLOSE_HANDLE(in[0]);  CLOSE_HANDLE(in[1]);
+	CLOSE_HANDLE(out[0]); CLOSE_HANDLE(out[1]);
+	CLOSE_HANDLE(err[0]); CLOSE_HANDLE(err[1]);
+	return -1;
+}
+
+int git_process_id(p_pid_t *out, git_process *process)
+{
+	GIT_ASSERT(out && process);
+
+	if (!process->process_info.dwProcessId) {
+		git_error_set(GIT_ERROR_INVALID, "process not running");
+		return -1;
+	}
+
+	*out = process->process_info.dwProcessId;
+	return 0;
+}
+
+ssize_t git_process_read(git_process *process, void *buf, size_t count)
+{
+	DWORD ret;
+
+	if (count > DWORD_MAX)
+		count = DWORD_MAX;
+	if (count > SSIZE_MAX)
+		count = SSIZE_MAX;
+
+	if (!ReadFile(process->child_out, buf, (DWORD)count, &ret, NULL)) {
+		if (GetLastError() == ERROR_BROKEN_PIPE)
+			return 0;
+
+		git_error_set(GIT_ERROR_OS, "could not read");
+		return -1;
+	}
+
+	return ret;
+}
+
+ssize_t git_process_write(git_process *process, const void *buf, size_t count)
+{
+	DWORD ret;
+
+	if (count > DWORD_MAX)
+		count = DWORD_MAX;
+	if (count > SSIZE_MAX)
+		count = SSIZE_MAX;
+
+	if (!WriteFile(process->child_in, buf, (DWORD)count, &ret, NULL)) {
+		git_error_set(GIT_ERROR_OS, "could not write");
+		return -1;
+	}
+
+	return ret;
+}
+
+int git_process_close_in(git_process *process)
+{
+	if (!process->capture_in) {
+		git_error_set(GIT_ERROR_INVALID, "input is not open");
+		return -1;
+	}
+
+	if (process->child_in) {
+		CloseHandle(process->child_in);
+		process->child_in = NULL;
+	}
+
+	return 0;
+}
+
+int git_process_close_out(git_process *process)
+{
+	if (!process->capture_out) {
+		git_error_set(GIT_ERROR_INVALID, "output is not open");
+		return -1;
+	}
+
+	if (process->child_out) {
+		CloseHandle(process->child_out);
+		process->child_out = NULL;
+	}
+
+	return 0;
+}
+
+int git_process_close_err(git_process *process)
+{
+	if (!process->capture_err) {
+		git_error_set(GIT_ERROR_INVALID, "error is not open");
+		return -1;
+	}
+
+	if (process->child_err) {
+		CloseHandle(process->child_err);
+		process->child_err = NULL;
+	}
+
+	return 0;
+}
+
+int git_process_close(git_process *process)
+{
+	if (process->child_in) {
+		CloseHandle(process->child_in);
+		process->child_in = NULL;
+	}
+
+	if (process->child_out) {
+		CloseHandle(process->child_out);
+		process->child_out = NULL;
+	}
+
+	if (process->child_err) {
+		CloseHandle(process->child_err);
+		process->child_err = NULL;
+	}
+
+	CloseHandle(process->process_info.hProcess);
+	process->process_info.hProcess = NULL;
+
+	CloseHandle(process->process_info.hThread);
+	process->process_info.hThread = NULL;
+
+	return 0;
+}
+
+int git_process_wait(git_process_result *result, git_process *process)
+{
+	DWORD exitcode;
+
+	if (result)
+		memset(result, 0, sizeof(git_process_result));
+
+	if (!process->process_info.dwProcessId) {
+		git_error_set(GIT_ERROR_INVALID, "process is stopped");
+		return -1;
+	}
+
+	if (WaitForSingleObject(process->process_info.hProcess, INFINITE) == WAIT_FAILED) {
+		git_error_set(GIT_ERROR_OS, "could not wait for process");
+		return -1;
+	}
+
+	if (!GetExitCodeProcess(process->process_info.hProcess, &exitcode)) {
+		git_error_set(GIT_ERROR_OS, "could not get process exit code");
+		return -1;
+	}
+
+	result->status = GIT_PROCESS_STATUS_NORMAL;
+	result->exitcode = exitcode;
+
+	memset(&process->process_info, 0, sizeof(PROCESS_INFORMATION));
+	return 0;
+}
+
+int git_process_result_msg(git_str *out, git_process_result *result)
+{
+	if (result->status == GIT_PROCESS_STATUS_NONE) {
+		return git_str_puts(out, "process not started");
+	} else if (result->status == GIT_PROCESS_STATUS_NORMAL) {
+		return git_str_printf(out, "process exited with code %d",
+		                      result->exitcode);
+	} else if (result->signal) {
+		return git_str_printf(out, "process exited on signal %d",
+		                      result->signal);
+	}
+
+	return git_str_puts(out, "unknown error");
+}
+
+void git_process_free(git_process *process)
+{
+	if (!process)
+		return;
+
+	if (process->process_info.hProcess)
+		git_process_close(process);
+
+	git__free(process->env);
+	git__free(process->cwd);
+	git__free(process->cmdline);
+	git__free(process->appname);
+	git__free(process);
+}