rugged 1.9.0 → 1.9.5.1

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

@@ -611,6 +611,37 @@ bool git_fs_path_isfile(const char *path)
 	return S_ISREG(st.st_mode) != 0;
 }
 
+#ifdef GIT_WIN32
+
+bool git_fs_path_isexecutable(const char *path)
+{
+	struct stat st;
+
+	GIT_ASSERT_ARG_WITH_RETVAL(path, false);
+
+	if (git__suffixcmp_icase(path, ".exe") != 0 &&
+	    git__suffixcmp_icase(path, ".cmd") != 0)
+		return false;
+
+	return (p_stat(path, &st) == 0);
+}
+
+#else
+
+bool git_fs_path_isexecutable(const char *path)
+{
+	struct stat st;
+
+	GIT_ASSERT_ARG_WITH_RETVAL(path, false);
+	if (p_stat(path, &st) < 0)
+		return false;
+
+	return S_ISREG(st.st_mode) != 0 &&
+	       ((st.st_mode & S_IXUSR) != 0);
+}
+
+#endif
+
 bool git_fs_path_islink(const char *path)
 {
 	struct stat st;
@@ -2020,9 +2051,10 @@ int git_fs_path_owner_is_system(bool *out, const char *path)
 	return git_fs_path_owner_is(out, path, GIT_FS_PATH_OWNER_ADMINISTRATOR);
 }
 
-int git_fs_path_find_executable(git_str *fullpath, const char *executable)
-{
 #ifdef GIT_WIN32
+
+static int find_executable(git_str *fullpath, const char *executable)
+{
 	git_win32_path fullpath_w, executable_w;
 	int error;
 
@@ -2035,9 +2067,15 @@ int git_fs_path_find_executable(git_str *fullpath, const char *executable)
 		error = git_str_put_w(fullpath, fullpath_w, wcslen(fullpath_w));
 
 	return error;
+}
+
 #else
+
+static int find_executable(git_str *fullpath, const char *executable)
+{
 	git_str path = GIT_STR_INIT;
 	const char *current_dir, *term;
+	size_t current_dirlen;
 	bool found = false;
 
 	if (git__getenv(&path, "PATH") < 0)
@@ -2049,20 +2087,28 @@ int git_fs_path_find_executable(git_str *fullpath, const char *executable)
 		if (! (term = strchr(current_dir, GIT_PATH_LIST_SEPARATOR)))
 			term = strchr(current_dir, '\0');
 
+		current_dirlen = term - current_dir;
 		git_str_clear(fullpath);
-		if (git_str_put(fullpath, current_dir, (term - current_dir)) < 0 ||
-		    git_str_putc(fullpath, '/') < 0 ||
+
+		/* An empty path segment is treated as '.' */
+		if (current_dirlen == 0 && git_str_putc(fullpath, '.'))
+			return -1;
+		else if (current_dirlen != 0 &&
+		         git_str_put(fullpath, current_dir, current_dirlen) < 0)
+			return -1;
+
+		if (git_str_putc(fullpath, '/') < 0 ||
 		    git_str_puts(fullpath, executable) < 0)
 			return -1;
 
-		if (git_fs_path_isfile(fullpath->ptr)) {
+		if (git_fs_path_isexecutable(fullpath->ptr)) {
 			found = true;
 			break;
 		}
 
 		current_dir = term;
 
-		while (*current_dir == GIT_PATH_LIST_SEPARATOR)
+		if (*current_dir == GIT_PATH_LIST_SEPARATOR)
 			current_dir++;
 	}
 
@@ -2073,5 +2119,19 @@ int git_fs_path_find_executable(git_str *fullpath, const char *executable)
 
 	git_str_clear(fullpath);
 	return GIT_ENOTFOUND;
+}
+
 #endif
+
+int git_fs_path_find_executable(git_str *fullpath, const char *executable)
+{
+	/* For qualified paths we do not look in PATH */
+	if (strchr(executable, '/') != NULL) {
+		if (!git_fs_path_isexecutable(executable))
+			return GIT_ENOTFOUND;
+
+		return git_str_puts(fullpath, executable);
+	}
+
+	return find_executable(fullpath, executable);
 }

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

@@ -204,6 +204,12 @@ extern bool git_fs_path_isdir(const char *path);
  */
 extern bool git_fs_path_isfile(const char *path);
 
+/**
+ * Check if the given path points to an executable.
+ * @return true or false
+ */
+extern bool git_fs_path_isexecutable(const char *path);
+
 /**
  * Check if the given path points to a symbolic link.
  * @return true or false
@@ -632,18 +638,18 @@ extern int git_fs_path_from_url_or_path(git_str *local_path_out, const char *url
  */
 #ifdef GIT_WIN32
 # define GIT_FS_PATH_REJECT_FILESYSTEM_DEFAULTS \
-	GIT_FS_PATH_REJECT_EMPTY_COMPONENT | \
-	GIT_FS_PATH_REJECT_TRAVERSAL | \
-	GIT_FS_PATH_REJECT_BACKSLASH | \
-	GIT_FS_PATH_REJECT_TRAILING_DOT | \
-	GIT_FS_PATH_REJECT_TRAILING_SPACE | \
-	GIT_FS_PATH_REJECT_TRAILING_COLON | \
-	GIT_FS_PATH_REJECT_DOS_PATHS | \
-	GIT_FS_PATH_REJECT_NT_CHARS
+	(GIT_FS_PATH_REJECT_EMPTY_COMPONENT | \
+	 GIT_FS_PATH_REJECT_TRAVERSAL | \
+	 GIT_FS_PATH_REJECT_BACKSLASH | \
+	 GIT_FS_PATH_REJECT_TRAILING_DOT | \
+	 GIT_FS_PATH_REJECT_TRAILING_SPACE | \
+	 GIT_FS_PATH_REJECT_TRAILING_COLON | \
+	 GIT_FS_PATH_REJECT_DOS_PATHS | \
+	 GIT_FS_PATH_REJECT_NT_CHARS)
 #else
 # define GIT_FS_PATH_REJECT_FILESYSTEM_DEFAULTS \
-	GIT_FS_PATH_REJECT_EMPTY_COMPONENT | \
-	GIT_FS_PATH_REJECT_TRAVERSAL
+	(GIT_FS_PATH_REJECT_EMPTY_COMPONENT | \
+	 GIT_FS_PATH_REJECT_TRAVERSAL)
 #endif
 
 /**

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

@@ -32,9 +32,17 @@ extern int git_futils_readbuffer_fd(git_str *obj, git_file fd, size_t len);
 
 /* Additional constants for `git_futils_writebuffer`'s `open_flags`.  We
  * support these internally and they will be removed before the `open` call.
- */
-#ifndef O_FSYNC
-# define O_FSYNC (1 << 31)
+ *
+ * Not all platforms define O_FSYNC.  Fall back to O_SYNC (the POSIX
+ * standard name; O_FSYNC is a non-standard alias) when available,
+ * otherwise use a sentinel value that won't collide with real open
+ * flags.  Avoid (1 << 31) since left-shifting into the sign bit of
+ * a signed int is undefined behavior.
+ */
+#if !defined(O_FSYNC) && defined(O_SYNC)
+# define O_FSYNC O_SYNC
+#elif !defined(O_FSYNC)
+# define O_FSYNC (1 << 30)
 #endif
 
 extern int git_futils_writebuffer(

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

@@ -32,13 +32,23 @@ int git_hash_sha256_init(git_hash_sha256_ctx *ctx)
 	return 0;
 }
 
-int git_hash_sha256_update(git_hash_sha256_ctx *ctx, const void *data, size_t len)
+int git_hash_sha256_update(git_hash_sha256_ctx *ctx, const void *_data, size_t len)
 {
+	const unsigned char *data = _data;
 	GIT_ASSERT_ARG(ctx);
-	if (SHA256Input(&ctx->c, data, len)) {
-		git_error_set(GIT_ERROR_SHA, "SHA256 error");
-		return -1;
+
+	while (len > 0) {
+		unsigned int chunk = (len > UINT_MAX) ? UINT_MAX : (unsigned int)len;
+
+		if (SHA256Input(&ctx->c, data, chunk)) {
+			git_error_set(GIT_ERROR_SHA, "SHA256 error");
+			return -1;
+		}
+
+		data += chunk;
+		len -= chunk;
 	}
+
 	return 0;
 }
 

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

@@ -189,8 +189,6 @@ int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *ctx)
 		return -1;
 	}
 
-	ctx->c = NULL;
-
 	return 0;
 }
 
@@ -339,8 +337,6 @@ int git_hash_sha256_final(unsigned char *out, git_hash_sha256_ctx *ctx)
 		return -1;
 	}
 
-	ctx->c = NULL;
-
 	return 0;
 }
 

data/vendor/libgit2/src/util/hash/rfc6234/sha224-256.c

@@ -83,12 +83,14 @@
  * Add "length" to the length.
  * Set Corrupted when overflow has occurred.
  */
-static uint32_t addTemp;
-#define SHA224_256AddLength(context, length)               \
-  (addTemp = (context)->Length_Low, (context)->Corrupted = \
-    (((context)->Length_Low += (length)) < addTemp) &&     \
-    (++(context)->Length_High == 0) ? shaInputTooLong :    \
-                                      (context)->Corrupted )
+static int SHA224_256AddLength(SHA256Context *context, unsigned int length)
+{
+  uint32_t addTemp = context->Length_Low;
+  context->Length_Low += length;
+  if (context->Length_Low < addTemp && ++context->Length_High == 0)
+    context->Corrupted = shaInputTooLong;
+  return context->Corrupted;
+}
 
 /* Local Function Prototypes */
 static int SHA224_256Reset(SHA256Context *context, uint32_t *H0);

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

@@ -107,6 +107,7 @@ typedef uint32_t git_hashmap_iter_t;
 	} \
 	GIT_INLINE(int) name##__idx(uint32_t *out, name *h, key_t key) \
 	{ \
+		*out = UINT32_MAX; \
 		if (h->n_buckets) { \
 			uint32_t k, i, last, mask, step = 0; \
 			GIT_ASSERT((h)->flags); \

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

@@ -184,8 +184,8 @@ static int url_parse_authority(
 	const char *authority,
 	size_t len)
 {
-	const char *c, *hostport_end, *host_end = NULL,
-	           *userpass_end, *user_end = NULL;
+	const char *c, *hostport_end = NULL, *host_end = NULL,
+	           *userpass_end = NULL, *user_end = NULL;
 
 	enum {
 		HOSTPORT, HOST, IPV6, HOST_END, USERPASS, USER
@@ -464,7 +464,7 @@ done:
 int git_net_url_parse(git_net_url *url, const char *given)
 {
 	git_net_url_parser parser = GIT_NET_URL_PARSER_INIT;
-	const char *c, *authority, *path;
+	const char *c, *authority = NULL, *path = NULL;
 	size_t authority_len = 0, path_len = 0;
 	int error = 0;
 
@@ -574,7 +574,7 @@ int git_net_url_parse_http(
 	const char *given)
 {
 	git_net_url_parser parser = GIT_NET_URL_PARSER_INIT;
-	const char *c, *authority, *path = NULL;
+	const char *c = NULL, *authority = NULL, *path = NULL;
 	size_t authority_len = 0, path_len = 0;
 	int error;
 
@@ -661,7 +661,7 @@ static bool has_at(const char *str)
 int git_net_url_parse_scp(git_net_url *url, const char *given)
 {
 	const char *default_port = default_port_for_scheme("ssh");
-	const char *c, *user, *host, *port = NULL, *path = NULL;
+	const char *c, *user = NULL, *host = NULL, *port = NULL, *path = NULL;
 	size_t user_len = 0, host_len = 0, port_len = 0;
 	unsigned short bracket = 0;
 

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

@@ -11,7 +11,8 @@
 typedef struct git_process git_process;
 
 typedef struct {
-	unsigned int capture_in  : 1,
+	unsigned int use_shell   : 1,
+	             capture_in  : 1,
 	             capture_out : 1,
 	             capture_err : 1,
 	             exclude_env : 1;

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

@@ -7,7 +7,7 @@
 
 #include "regexp.h"
 
-#if defined(GIT_REGEX_BUILTIN) || defined(GIT_REGEX_PCRE)
+#if defined(GIT_REGEX_PCRE)
 
 int git_regexp_compile(git_regexp *r, const char *pattern, int flags)
 {
@@ -73,7 +73,7 @@ out:
 	return 0;
 }
 
-#elif defined(GIT_REGEX_PCRE2)
+#elif defined(GIT_REGEX_BUILTIN) || defined(GIT_REGEX_PCRE2)
 
 int git_regexp_compile(git_regexp *r, const char *pattern, int flags)
 {
@@ -84,8 +84,9 @@ int git_regexp_compile(git_regexp *r, const char *pattern, int flags)
 	if (flags & GIT_REGEXP_ICASE)
 		cflags |= PCRE2_CASELESS;
 
-	if ((*r = pcre2_compile((const unsigned char *) pattern, PCRE2_ZERO_TERMINATED,
-				cflags, &error, &erroff, NULL)) == NULL) {
+	if ((*r = pcre2_compile((const unsigned char *) pattern,
+			PCRE2_ZERO_TERMINATED,
+			cflags, &error, &erroff, NULL)) == NULL) {
 		pcre2_get_error_message(error, errmsg, sizeof(errmsg));
 		git_error_set_str(GIT_ERROR_REGEX, (char *) errmsg);
 		return GIT_EINVALIDSPEC;
@@ -110,37 +111,51 @@ int git_regexp_match(const git_regexp *r, const char *string)
 
 	error = pcre2_match(*r, (const unsigned char *) string, strlen(string), 0, 0, data, NULL);
 	pcre2_match_data_free(data);
+
 	if (error < 0)
 		return (error == PCRE2_ERROR_NOMATCH) ? GIT_ENOTFOUND : GIT_EINVALIDSPEC;
 
 	return 0;
 }
 
-int git_regexp_search(const git_regexp *r, const char *string, size_t nmatches, git_regmatch *matches)
+int git_regexp_search(
+	const git_regexp *r,
+	const char *string,
+	size_t given_nmatches,
+	git_regmatch *matches)
 {
 	pcre2_match_data *data = NULL;
 	PCRE2_SIZE *ovec;
+	size_t i, captures;
+	uint32_t nmatches;
 	int error;
-	size_t i;
+
+	GIT_ASSERT(given_nmatches <= UINT32_MAX);
+
+	nmatches = (uint32_t) given_nmatches;
 
 	if ((data = pcre2_match_data_create(nmatches, NULL)) == NULL) {
 		git_error_set_oom();
 		return -1;
 	}
 
-	if ((error = pcre2_match(*r, (const unsigned char *) string, strlen(string),
-			     0, 0, data, NULL)) < 0)
+	if ((error = pcre2_match(*r, (const unsigned char *) string,
+			strlen(string), 0, 0, data, NULL)) < 0)
 		goto out;
 
-	if (error == 0 || (unsigned int) error  > nmatches)
-		error = nmatches;
+	captures = (size_t) error;
+
+	if (!captures || captures > nmatches)
+		captures = nmatches;
+
 	ovec = pcre2_get_ovector_pointer(data);
 
-	for (i = 0; i < (unsigned int) error; i++) {
+	for (i = 0; i < captures; i++) {
 		matches[i].start = (ovec[i * 2] == PCRE2_UNSET) ? -1 : (ssize_t) ovec[i * 2];
 		matches[i].end = (ovec[i * 2 + 1] == PCRE2_UNSET) ? -1 :  (ssize_t) ovec[i * 2 + 1];
 	}
-	for (i = (unsigned int) error; i < nmatches; i++)
+
+	for (i = captures; i < nmatches; i++)
 		matches[i].start = matches[i].end = -1;
 
 out:

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

@@ -10,8 +10,13 @@
 
 #include "git2_util.h"
 
-#if defined(GIT_REGEX_BUILTIN) || defined(GIT_REGEX_PCRE)
-# include "pcre.h"
+#if defined(GIT_REGEX_BUILTIN)
+# define PCRE2_CODE_UNIT_WIDTH 8
+# include "pcre2.h"
+typedef pcre2_code *git_regexp;
+# define GIT_REGEX_INIT NULL
+#elif defined(GIT_REGEX_PCRE)
+# include <pcre.h>
 typedef pcre *git_regexp;
 # define GIT_REGEX_INIT NULL
 #elif defined(GIT_REGEX_PCRE2)

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

@@ -16,7 +16,7 @@ static git_atomic32 init_count;
 static int init_common(git_runtime_init_fn init_fns[], size_t cnt)
 {
 	size_t i;
-	int ret;
+	int ret = 0;
 
 	/* Initialize subsystems that have global state */
 	for (i = 0; i < cnt; i++) {
@@ -110,7 +110,7 @@ GIT_INLINE(int) init_unlock(void)
 
 int git_runtime_init(git_runtime_init_fn init_fns[], size_t cnt)
 {
-	int ret;
+	int ret = 0;
 
 	if (init_lock() < 0)
 		return -1;

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

@@ -1065,10 +1065,13 @@ int git_str_puts_escaped(
 	git_str *buf,
 	const char *string,
 	const char *esc_chars,
-	const char *esc_with)
+	const char *esc_prefix,
+	const char *esc_suffix)
 {
 	const char *scan;
-	size_t total = 0, esc_len = strlen(esc_with), count, alloclen;
+	size_t total = 0, count, alloclen;
+	size_t esc_prefix_len = esc_prefix ? strlen(esc_prefix) : 0;
+	size_t esc_suffix_len = esc_suffix ? strlen(esc_suffix) : 0;
 
 	if (!string)
 		return 0;
@@ -1080,7 +1083,7 @@ int git_str_puts_escaped(
 		scan += count;
 		/* count run of escaped characters */
 		count = strspn(scan, esc_chars);
-		total += count * (esc_len + 1);
+		total += count * (esc_prefix_len + esc_suffix_len + 1);
 		scan += count;
 	}
 
@@ -1096,13 +1099,22 @@ int git_str_puts_escaped(
 		buf->size += count;
 
 		for (count = strspn(scan, esc_chars); count > 0; --count) {
-			/* copy escape sequence */
-			memmove(buf->ptr + buf->size, esc_with, esc_len);
-			buf->size += esc_len;
+			/* copy escape prefix sequence */
+			if (esc_prefix) {
+				memmove(buf->ptr + buf->size, esc_prefix, esc_prefix_len);
+				buf->size += esc_prefix_len;
+			}
+
 			/* copy character to be escaped */
 			buf->ptr[buf->size] = *scan;
 			buf->size++;
 			scan++;
+
+			/* copy escape suffix sequence */
+			if (esc_suffix) {
+				memmove(buf->ptr + buf->size, esc_suffix, esc_suffix_len);
+				buf->size += esc_suffix_len;
+			}
 		}
 	}
 

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

@@ -268,21 +268,23 @@ int git_str_splice(
  * @param str String buffer to append data to
  * @param string String to escape and append
  * @param esc_chars Characters to be escaped
- * @param esc_with String to insert in from of each found character
+ * @param esc_prefix String to insert as prefix of each found character
+ * @param esc_suffix String to insert as suffix of each found character
  * @return 0 on success, <0 on failure (probably allocation problem)
  */
 extern int git_str_puts_escaped(
 	git_str *str,
 	const char *string,
 	const char *esc_chars,
-	const char *esc_with);
+	const char *esc_prefix,
+	const char *esc_suffix);
 
 /**
  * Append string escaping characters that are regex special
  */
 GIT_INLINE(int) git_str_puts_escape_regex(git_str *str, const char *string)
 {
-	return git_str_puts_escaped(str, string, "^.[]$()|*+?{}\\", "\\");
+	return git_str_puts_escaped(str, string, "^.[]$()|*+?{}\\", "\\", NULL);
 }
 
 /**