rugged 1.6.3 → 1.9.0

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

@@ -17,13 +17,14 @@
 #	define GIT_FILEBUF_THREADS
 #endif
 
-#define GIT_FILEBUF_HASH_CONTENTS		(1 << 0)
-#define GIT_FILEBUF_APPEND				(1 << 2)
+#define GIT_FILEBUF_HASH_SHA1           (1 << 0)
+#define GIT_FILEBUF_HASH_SHA256         (1 << 1)
+#define GIT_FILEBUF_APPEND              (1 << 2)
 #define GIT_FILEBUF_CREATE_LEADING_DIRS	(1 << 3)
-#define GIT_FILEBUF_TEMPORARY			(1 << 4)
-#define GIT_FILEBUF_DO_NOT_BUFFER		(1 << 5)
-#define GIT_FILEBUF_FSYNC				(1 << 6)
-#define GIT_FILEBUF_DEFLATE_SHIFT		(7)
+#define GIT_FILEBUF_TEMPORARY           (1 << 4)
+#define GIT_FILEBUF_DO_NOT_BUFFER       (1 << 5)
+#define GIT_FILEBUF_FSYNC               (1 << 6)
+#define GIT_FILEBUF_DEFLATE_SHIFT       (7)
 
 #define GIT_FILELOCK_EXTENSION ".lock\0"
 #define GIT_FILELOCK_EXTLENGTH 6
@@ -91,4 +92,16 @@ int git_filebuf_hash(unsigned char *out, git_filebuf *file);
 int git_filebuf_flush(git_filebuf *file);
 int git_filebuf_stats(time_t *mtime, size_t *size, git_filebuf *file);
 
+GIT_INLINE(int) git_filebuf_hash_flags(git_hash_algorithm_t algorithm)
+{
+	switch (algorithm) {
+	case GIT_HASH_ALGORITHM_SHA1:
+		return GIT_FILEBUF_HASH_SHA1;
+	case GIT_HASH_ALGORITHM_SHA256:
+		return GIT_FILEBUF_HASH_SHA256;
+	default:
+		return 0;
+	}
+}
+
 #endif

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);
@@ -1938,12 +1948,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);
@@ -2015,7 +2026,7 @@ int git_fs_path_find_executable(git_str *fullpath, const char *executable)
 	git_win32_path fullpath_w, executable_w;
 	int error;
 
-	if (git__utf8_to_16(executable_w, GIT_WIN_PATH_MAX, executable) < 0)
+	if (git_utf8_to_16(executable_w, GIT_WIN_PATH_MAX, executable) < 0)
 		return -1;
 
 	error = git_win32_path_find_executable(fullpath_w, executable_w);

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 "..".
  */

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>
 
@@ -221,14 +221,14 @@ int git_futils_readbuffer_fd_full(git_str *buf, git_file fd)
 int git_futils_readbuffer_updated(
 	git_str *out,
 	const char *path,
-	unsigned char checksum[GIT_HASH_SHA1_SIZE],
+	unsigned char checksum[GIT_HASH_SHA256_SIZE],
 	int *updated)
 {
 	int error;
 	git_file fd;
 	struct stat st;
 	git_str buf = GIT_STR_INIT;
-	unsigned char checksum_new[GIT_HASH_SHA1_SIZE];
+	unsigned char checksum_new[GIT_HASH_SHA256_SIZE];
 
 	GIT_ASSERT_ARG(out);
 	GIT_ASSERT_ARG(path && *path);
@@ -261,7 +261,10 @@ int git_futils_readbuffer_updated(
 	p_close(fd);
 
 	if (checksum) {
-		if ((error = git_hash_buf(checksum_new, buf.ptr, buf.size, GIT_HASH_ALGORITHM_SHA1)) < 0) {
+		error = git_hash_buf(checksum_new, buf.ptr,
+		                     buf.size, GIT_HASH_ALGORITHM_SHA256);
+
+		if (error < 0) {
 			git_str_dispose(&buf);
 			return error;
 		}
@@ -269,7 +272,7 @@ int git_futils_readbuffer_updated(
 		/*
 		 * If we were given a checksum, we only want to use it if it's different
 		 */
-		if (!memcmp(checksum, checksum_new, GIT_HASH_SHA1_SIZE)) {
+		if (!memcmp(checksum, checksum_new, GIT_HASH_SHA256_SIZE)) {
 			git_str_dispose(&buf);
 			if (updated)
 				*updated = 0;
@@ -277,7 +280,7 @@ int git_futils_readbuffer_updated(
 			return 0;
 		}
 
-		memcpy(checksum, checksum_new, GIT_HASH_SHA1_SIZE);
+		memcpy(checksum, checksum_new, GIT_HASH_SHA256_SIZE);
 	}
 
 	/*
@@ -650,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 */
@@ -685,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,7 +25,7 @@ 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);
@@ -109,8 +109,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

@@ -24,12 +24,15 @@
 #cmakedefine GIT_REGEX_PCRE2
 #cmakedefine GIT_REGEX_BUILTIN 1
 
-#cmakedefine GIT_QSORT_R_BSD
-#cmakedefine GIT_QSORT_R_GNU
-#cmakedefine GIT_QSORT_S
+#cmakedefine GIT_QSORT_BSD
+#cmakedefine GIT_QSORT_GNU
+#cmakedefine GIT_QSORT_C11
+#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
@@ -41,11 +44,17 @@
 #cmakedefine GIT_OPENSSL_DYNAMIC 1
 #cmakedefine GIT_SECURE_TRANSPORT 1
 #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
 
@@ -53,10 +62,18 @@
 #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
 
+#cmakedefine GIT_IO_POLL 1
+#cmakedefine GIT_IO_WSAPOLL 1
+#cmakedefine GIT_IO_SELECT 1
+
 #endif

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/openssl.c

@@ -120,6 +120,82 @@ 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;
+	}
+
+	ctx->c = NULL;
+
+	return 0;
+}
+
+#endif
+
 #ifdef GIT_SHA256_OPENSSL
 
 # ifdef GIT_OPENSSL_DYNAMIC
@@ -193,3 +269,79 @@ 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;
+	}
+
+	ctx->c = NULL;
+
+	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/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