rugged 1.7.2 → 1.9.4

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

@@ -419,6 +419,16 @@ int git_fs_path_to_dir(git_str *path)
 	return git_str_oom(path) ? -1 : 0;
 }
 
+size_t git_fs_path_dirlen(const char *path)
+{
+	size_t len = strlen(path);
+
+	while (len > 1 && path[len - 1] == '/')
+		len--;
+
+	return len;
+}
+
 void git_fs_path_string_to_dir(char *path, size_t size)
 {
 	size_t end = strlen(path);
@@ -601,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;
@@ -1938,12 +1979,13 @@ static int sudo_uid_lookup(uid_t *out)
 {
 	git_str uid_str = GIT_STR_INIT;
 	int64_t uid;
-	int error;
+	int error = -1;
 
-	if ((error = git__getenv(&uid_str, "SUDO_UID")) == 0 &&
-	    (error = git__strntol64(&uid, uid_str.ptr, uid_str.size, NULL, 10)) == 0 &&
-	    uid == (int64_t)((uid_t)uid)) {
+	if (git__getenv(&uid_str, "SUDO_UID") == 0 &&
+		git__strntol64(&uid, uid_str.ptr, uid_str.size, NULL, 10) == 0 &&
+		uid == (int64_t)((uid_t)uid)) {
 		*out = (uid_t)uid;
+		error = 0;
 	}
 
 	git_str_dispose(&uid_str);
@@ -2009,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;
 
@@ -2024,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)
@@ -2038,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++;
 	}
 
@@ -2062,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

@@ -86,6 +86,29 @@ extern int git_fs_path_to_dir(git_str *path);
  */
 extern void git_fs_path_string_to_dir(char *path, size_t size);
 
+/**
+ * Provides the length of the given path string with no trailing
+ * slashes.
+ */
+size_t git_fs_path_dirlen(const char *path);
+
+/**
+ * Returns nonzero if the given path is a filesystem root; on Windows, this
+ * means a drive letter (eg `A:/`, `C:\`). On POSIX this is `/`.
+ */
+GIT_INLINE(int) git_fs_path_is_root(const char *name)
+{
+#ifdef GIT_WIN32
+	if (((name[0] >= 'A' && name[0] <= 'Z') || (name[0] >= 'a' && name[0] <= 'z')) &&
+	      name[1] == ':' &&
+	     (name[2] == '/' || name[2] == '\\') &&
+	      name[3] == '\0')
+		return 1;
+#endif
+
+	return (name[0] == '/' && name[1] == '\0');
+}
+
 /**
  * Taken from git.git; returns nonzero if the given path is "." or "..".
  */
@@ -181,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

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

@@ -8,9 +8,9 @@
 #include "futils.h"
 
 #include "runtime.h"
-#include "strmap.h"
 #include "hash.h"
 #include "rand.h"
+#include "hashmap_str.h"
 
 #include <ctype.h>
 
@@ -653,7 +653,8 @@ int git_futils_mkdir_relative(
 		*tail = '\0';
 		st.st_mode = 0;
 
-		if (opts->dir_map && git_strmap_exists(opts->dir_map, make_path.ptr))
+		if (opts->cache_pathset &&
+		    git_hashset_str_contains(opts->cache_pathset, make_path.ptr))
 			continue;
 
 		/* See what's going on with this path component */
@@ -688,17 +689,17 @@ retry_lstat:
 			make_path.ptr, &st, (lastch == '\0'), mode, flags, opts)) < 0)
 			goto done;
 
-		if (opts->dir_map && opts->pool) {
+		if (opts->cache_pathset && opts->cache_pool) {
 			char *cache_path;
 			size_t alloc_size;
 
 			GIT_ERROR_CHECK_ALLOC_ADD(&alloc_size, make_path.size, 1);
-			cache_path = git_pool_malloc(opts->pool, alloc_size);
+			cache_path = git_pool_malloc(opts->cache_pool, alloc_size);
 			GIT_ERROR_CHECK_ALLOC(cache_path);
 
 			memcpy(cache_path, make_path.ptr, make_path.size + 1);
 
-			if ((error = git_strmap_set(opts->dir_map, cache_path, cache_path)) < 0)
+			if ((error = git_hashset_str_add(opts->cache_pathset, cache_path)) < 0)
 				goto done;
 		}
 	}

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

@@ -13,8 +13,8 @@
 #include "posix.h"
 #include "fs_path.h"
 #include "pool.h"
-#include "strmap.h"
 #include "hash.h"
+#include "hashmap_str.h"
 
 /**
  * Filebuffer methods
@@ -25,16 +25,24 @@ extern int git_futils_readbuffer(git_str *obj, const char *path);
 extern int git_futils_readbuffer_updated(
 	git_str *obj,
 	const char *path,
-	unsigned char checksum[GIT_HASH_SHA1_SIZE],
+	unsigned char checksum[GIT_HASH_SHA256_SIZE],
 	int *updated);
 extern int git_futils_readbuffer_fd_full(git_str *obj, git_file fd);
 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(
@@ -109,8 +117,17 @@ struct git_futils_mkdir_perfdata
 
 struct git_futils_mkdir_options
 {
-	git_strmap *dir_map;
-	git_pool *pool;
+	/*
+	 * Callers can optionally pass an allocation pool and a
+	 * hashset of strings; mkdir will populate these with the
+	 * path(s) it creates; this can be useful for repeated calls
+	 * to mkdir. This will reduce I/O by avoiding testing for the
+	 * existence of intermediate directories that it knows already
+	 * exist (because it created them).
+	 */
+	git_pool *cache_pool;
+	git_hashset_str *cache_pathset;
+
 	struct git_futils_mkdir_perfdata perfdata;
 };
 

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

@@ -30,7 +30,9 @@
 #cmakedefine GIT_QSORT_MSC
 
 #cmakedefine GIT_SSH 1
-#cmakedefine GIT_SSH_MEMORY_CREDENTIALS 1
+#cmakedefine GIT_SSH_EXEC 1
+#cmakedefine GIT_SSH_LIBSSH2 1
+#cmakedefine GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS 1
 
 #cmakedefine GIT_NTLM 1
 #cmakedefine GIT_GSSAPI 1
@@ -44,10 +46,15 @@
 #cmakedefine GIT_MBEDTLS 1
 #cmakedefine GIT_SCHANNEL 1
 
+#cmakedefine GIT_HTTPPARSER_HTTPPARSER 1
+#cmakedefine GIT_HTTPPARSER_LLHTTP 1
+#cmakedefine GIT_HTTPPARSER_BUILTIN 1
+
 #cmakedefine GIT_SHA1_COLLISIONDETECT 1
 #cmakedefine GIT_SHA1_WIN32 1
 #cmakedefine GIT_SHA1_COMMON_CRYPTO 1
 #cmakedefine GIT_SHA1_OPENSSL 1
+#cmakedefine GIT_SHA1_OPENSSL_FIPS 1
 #cmakedefine GIT_SHA1_OPENSSL_DYNAMIC 1
 #cmakedefine GIT_SHA1_MBEDTLS 1
 
@@ -55,9 +62,13 @@
 #cmakedefine GIT_SHA256_WIN32 1
 #cmakedefine GIT_SHA256_COMMON_CRYPTO 1
 #cmakedefine GIT_SHA256_OPENSSL 1
+#cmakedefine GIT_SHA256_OPENSSL_FIPS 1
 #cmakedefine GIT_SHA256_OPENSSL_DYNAMIC 1
 #cmakedefine GIT_SHA256_MBEDTLS 1
 
+#cmakedefine GIT_COMPRESSION_BUILTIN 1
+#cmakedefine GIT_COMPRESSION_ZLIB 1
+
 #cmakedefine GIT_RAND_GETENTROPY 1
 #cmakedefine GIT_RAND_GETLOADAVG 1
 

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

@@ -12,6 +12,7 @@
 #endif
 
 #include "git2/common.h"
+#include "git2/sys/errors.h"
 #include "cc-compat.h"
 
 typedef struct git_str git_str;
@@ -48,6 +49,10 @@ typedef struct git_str git_str;
 # define GIT_WARN_UNUSED_RESULT
 #endif
 
+#if (defined(_WIN32)) && !defined(__CYGWIN__)
+# define GIT_WIN32 1
+#endif
+
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>
@@ -164,5 +169,6 @@ typedef struct git_str git_str;
 	if (GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize)) { return -1; }
 
 #include "util.h"
+#include "ctype_compat.h"
 
 #endif

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

@@ -120,6 +120,80 @@ int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *ctx)
 
 #endif
 
+#ifdef GIT_SHA1_OPENSSL_FIPS
+
+static const EVP_MD *SHA1_ENGINE_DIGEST_TYPE = NULL;
+
+int git_hash_sha1_global_init(void)
+{
+	SHA1_ENGINE_DIGEST_TYPE = EVP_sha1();
+	return SHA1_ENGINE_DIGEST_TYPE != NULL ? 0 : -1;
+}
+
+int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
+{
+	return git_hash_sha1_init(ctx);
+}
+
+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
+{
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+	EVP_MD_CTX_destroy(ctx->c);
+#else
+	EVP_MD_CTX_free(ctx->c);
+#endif
+}
+
+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
+{
+	GIT_ASSERT_ARG(ctx);
+	GIT_ASSERT(SHA1_ENGINE_DIGEST_TYPE);
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+	ctx->c = EVP_MD_CTX_create();
+#else
+	ctx->c = EVP_MD_CTX_new();
+#endif
+
+	GIT_ASSERT(ctx->c);
+
+	if (EVP_DigestInit_ex(ctx->c, SHA1_ENGINE_DIGEST_TYPE, NULL) != 1) {
+		git_hash_sha1_ctx_cleanup(ctx);
+		git_error_set(GIT_ERROR_SHA, "failed to initialize sha1 context");
+		return -1;
+	}
+
+	return 0;
+}
+
+int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
+{
+	GIT_ASSERT_ARG(ctx && ctx->c);
+
+	if (EVP_DigestUpdate(ctx->c, data, len) != 1) {
+		git_error_set(GIT_ERROR_SHA, "failed to update sha1");
+		return -1;
+	}
+
+	return 0;
+}
+
+int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *ctx)
+{
+	unsigned int len = 0;
+
+	GIT_ASSERT_ARG(ctx && ctx->c);
+
+	if (EVP_DigestFinal(ctx->c, out, &len) != 1) {
+		git_error_set(GIT_ERROR_SHA, "failed to finalize sha1");
+		return -1;
+	}
+
+	return 0;
+}
+
+#endif
+
 #ifdef GIT_SHA256_OPENSSL
 
 # ifdef GIT_OPENSSL_DYNAMIC
@@ -193,3 +267,77 @@ int git_hash_sha256_final(unsigned char *out, git_hash_sha256_ctx *ctx)
 }
 
 #endif
+
+#ifdef GIT_SHA256_OPENSSL_FIPS
+
+static const EVP_MD *SHA256_ENGINE_DIGEST_TYPE = NULL;
+
+int git_hash_sha256_global_init(void)
+{
+	SHA256_ENGINE_DIGEST_TYPE = EVP_sha256();
+	return SHA256_ENGINE_DIGEST_TYPE != NULL ? 0 : -1;
+}
+
+int git_hash_sha256_ctx_init(git_hash_sha256_ctx *ctx)
+{
+	return git_hash_sha256_init(ctx);
+}
+
+void git_hash_sha256_ctx_cleanup(git_hash_sha256_ctx *ctx)
+{
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+	EVP_MD_CTX_destroy(ctx->c);
+#else
+	EVP_MD_CTX_free(ctx->c);
+#endif
+}
+
+int git_hash_sha256_init(git_hash_sha256_ctx *ctx)
+{
+	GIT_ASSERT_ARG(ctx);
+	GIT_ASSERT(SHA256_ENGINE_DIGEST_TYPE);
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+	ctx->c = EVP_MD_CTX_create();
+#else
+	ctx->c = EVP_MD_CTX_new();
+#endif
+
+	GIT_ASSERT(ctx->c);
+
+	if (EVP_DigestInit_ex(ctx->c, SHA256_ENGINE_DIGEST_TYPE, NULL) != 1) {
+		git_hash_sha256_ctx_cleanup(ctx);
+		git_error_set(GIT_ERROR_SHA, "failed to initialize sha256 context");
+		return -1;
+	}
+
+	return 0;
+}
+
+int git_hash_sha256_update(git_hash_sha256_ctx *ctx, const void *data, size_t len)
+{
+	GIT_ASSERT_ARG(ctx && ctx->c);
+
+	if (EVP_DigestUpdate(ctx->c, data, len) != 1) {
+		git_error_set(GIT_ERROR_SHA, "failed to update sha256");
+		return -1;
+	}
+
+	return 0;
+}
+
+int git_hash_sha256_final(unsigned char *out, git_hash_sha256_ctx *ctx)
+{
+	unsigned int len = 0;
+
+	GIT_ASSERT_ARG(ctx && ctx->c);
+
+	if (EVP_DigestFinal(ctx->c, out, &len) != 1) {
+		git_error_set(GIT_ERROR_SHA, "failed to finalize sha256");
+		return -1;
+	}
+
+	return 0;
+}
+
+#endif

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

@@ -11,7 +11,11 @@
 #include "hash/sha.h"
 
 #ifndef GIT_OPENSSL_DYNAMIC
-# include <openssl/sha.h>
+# if defined(GIT_SHA1_OPENSSL_FIPS) || defined(GIT_SHA256_OPENSSL_FIPS)
+#  include <openssl/evp.h>
+# else
+#  include <openssl/sha.h>
+# endif
 #else
 
 typedef struct {
@@ -36,10 +40,22 @@ struct git_hash_sha1_ctx {
 };
 #endif
 
+#ifdef GIT_SHA1_OPENSSL_FIPS
+struct git_hash_sha1_ctx {
+	EVP_MD_CTX* c;
+};
+#endif
+
 #ifdef GIT_SHA256_OPENSSL
 struct git_hash_sha256_ctx {
 	SHA256_CTX c;
 };
 #endif
 
+#ifdef GIT_SHA256_OPENSSL_FIPS
+struct git_hash_sha256_ctx {
+	EVP_MD_CTX* c;
+};
+#endif
+
 #endif

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/hash/sha.h

@@ -17,7 +17,10 @@ typedef struct git_hash_sha256_ctx git_hash_sha256_ctx;
 # include "common_crypto.h"
 #endif
 
-#if defined(GIT_SHA1_OPENSSL) || defined(GIT_SHA256_OPENSSL)
+#if defined(GIT_SHA1_OPENSSL) || \
+    defined(GIT_SHA1_OPENSSL_FIPS) || \
+    defined(GIT_SHA256_OPENSSL) || \
+    defined(GIT_SHA256_OPENSSL_FIPS)
 # include "openssl.h"
 #endif