rugged 1.4.2 → 1.5.0

data/vendor/libgit2/src/{fs_path.c → util/fs_path.c}

@@ -7,8 +7,9 @@
 
 #include "fs_path.h"
 
+#include "git2_util.h"
+#include "futils.h"
 #include "posix.h"
-#include "repository.h"
 #ifdef GIT_WIN32
 #include "win32/posix.h"
 #include "win32/w32_buffer.h"
@@ -21,6 +22,13 @@
 #include <stdio.h>
 #include <ctype.h>
 
+#define ensure_error_set(code) do { \
+		const git_error *e = git_error_last(); \
+		if (!e || !e->message) \
+			git_error_set(e ? e->klass : GIT_ERROR_CALLBACK, \
+				"filesystem callback returned %d", code); \
+	} while(0)
+
 static int dos_drive_prefix_length(const char *path)
 {
 	int i;
@@ -101,7 +109,7 @@ int git_fs_path_basename_r(git_str *buffer, const char *path)
 	/* Empty or NULL string gets treated as "." */
 	if (path == NULL || *path == '\0') {
 		startp = ".";
-		len		= 1;
+		len = 1;
 		goto Exit;
 	}
 
@@ -113,7 +121,7 @@ int git_fs_path_basename_r(git_str *buffer, const char *path)
 	/* All slashes becomes "/" */
 	if (endp == path && *endp == '/') {
 		startp = "/";
-		len	= 1;
+		len = 1;
 		goto Exit;
 	}
 
@@ -185,8 +193,7 @@ int git_fs_path_dirname_r(git_str *buffer, const char *path)
 
 	if (endp - path + 1 > INT_MAX) {
 		git_error_set(GIT_ERROR_INVALID, "path too long");
-		len = -1;
-		goto Exit;
+		return -1;
 	}
 
 	if ((len = win32_prefix_length(path, (int)(endp - path + 1))) > 0) {
@@ -211,8 +218,7 @@ int git_fs_path_dirname_r(git_str *buffer, const char *path)
 
 	if (endp - path + 1 > INT_MAX) {
 		git_error_set(GIT_ERROR_INVALID, "path too long");
-		len = -1;
-		goto Exit;
+		return -1;
 	}
 
 	if ((len = win32_prefix_length(path, (int)(endp - path + 1))) > 0) {
@@ -530,7 +536,7 @@ int git_fs_path_walk_up(
 	if (!scan) {
 		error = cb(data, "");
 		if (error)
-			git_error_set_after_callback(error);
+			ensure_error_set(error);
 		return error;
 	}
 
@@ -543,7 +549,7 @@ int git_fs_path_walk_up(
 		iter.ptr[scan] = oldc;
 
 		if (error) {
-			git_error_set_after_callback(error);
+			ensure_error_set(error);
 			break;
 		}
 
@@ -563,7 +569,7 @@ int git_fs_path_walk_up(
 	if (!error && stop == 0 && iter.ptr[0] != '/') {
 		error = cb(data, "");
 		if (error)
-			git_error_set_after_callback(error);
+			ensure_error_set(error);
 	}
 
 	return error;
@@ -1167,7 +1173,7 @@ int git_fs_path_direach(
 		/* Only set our own error if the callback did not set one already */
 		if (error != 0) {
 			if (!git_error_last())
-				git_error_set_after_callback(error);
+				ensure_error_set(error);
 
 			break;
 		}
@@ -1779,80 +1785,228 @@ done:
 	return supported;
 }
 
-int git_fs_path_validate_system_file_ownership(const char *path)
+static git_fs_path_owner_t mock_owner = GIT_FS_PATH_OWNER_NONE;
+
+void git_fs_path__set_owner(git_fs_path_owner_t owner)
+{
+	mock_owner = owner;
+}
+
+#ifdef GIT_WIN32
+static PSID *sid_dup(PSID sid)
+{
+	DWORD len;
+	PSID dup;
+
+	len = GetLengthSid(sid);
+
+	if ((dup = git__malloc(len)) == NULL)
+		return NULL;
+
+	if (!CopySid(len, dup, sid)) {
+		git_error_set(GIT_ERROR_OS, "could not duplicate sid");
+		git__free(dup);
+		return NULL;
+	}
+
+	return dup;
+}
+
+static int current_user_sid(PSID *out)
 {
-#ifndef GIT_WIN32
-	GIT_UNUSED(path);
-	return GIT_OK;
-#else
-	git_win32_path buf;
-	PSID owner_sid;
-	PSECURITY_DESCRIPTOR descriptor = NULL;
-	HANDLE token;
 	TOKEN_USER *info = NULL;
-	DWORD err, len;
-	int ret;
+	HANDLE token = NULL;
+	DWORD len = 0;
+	int error = -1;
 
-	if (git_win32_path_from_utf8(buf, path) < 0)
-		return -1;
+	if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token)) {
+		git_error_set(GIT_ERROR_OS, "could not lookup process information");
+		goto done;
+	}
 
-	err = GetNamedSecurityInfoW(buf, SE_FILE_OBJECT,
-				    OWNER_SECURITY_INFORMATION |
-					    DACL_SECURITY_INFORMATION,
-				    &owner_sid, NULL, NULL, NULL, &descriptor);
+	if (GetTokenInformation(token, TokenUser, NULL, 0, &len) ||
+		GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+		git_error_set(GIT_ERROR_OS, "could not lookup token metadata");
+		goto done;
+	}
 
-	if (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND) {
-		ret = GIT_ENOTFOUND;
-		goto cleanup;
+	info = git__malloc(len);
+	GIT_ERROR_CHECK_ALLOC(info);
+
+	if (!GetTokenInformation(token, TokenUser, info, len, &len)) {
+		git_error_set(GIT_ERROR_OS, "could not lookup current user");
+		goto done;
 	}
 
-	if (err != ERROR_SUCCESS) {
+	if ((*out = sid_dup(info->User.Sid)))
+		error = 0;
+
+done:
+	if (token)
+		CloseHandle(token);
+
+	git__free(info);
+	return error;
+}
+
+static int file_owner_sid(PSID *out, const char *path)
+{
+	git_win32_path path_w32;
+	PSECURITY_DESCRIPTOR descriptor = NULL;
+	PSID owner_sid;
+	DWORD ret;
+	int error = -1;
+
+	if (git_win32_path_from_utf8(path_w32, path) < 0)
+		return -1;
+
+	ret = GetNamedSecurityInfoW(path_w32, SE_FILE_OBJECT,
+		OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
+		&owner_sid, NULL, NULL, NULL, &descriptor);
+
+	if (ret == ERROR_FILE_NOT_FOUND || ret == ERROR_PATH_NOT_FOUND)
+		error = GIT_ENOTFOUND;
+	else if (ret != ERROR_SUCCESS)
 		git_error_set(GIT_ERROR_OS, "failed to get security information");
-		ret = GIT_ERROR;
-		goto cleanup;
+	else if (!IsValidSid(owner_sid))
+		git_error_set(GIT_ERROR_OS, "file owner is not valid");
+	else if ((*out = sid_dup(owner_sid)))
+		error = 0;
+
+	if (descriptor)
+		LocalFree(descriptor);
+
+	return error;
+}
+
+int git_fs_path_owner_is(
+	bool *out,
+	const char *path,
+	git_fs_path_owner_t owner_type)
+{
+	PSID owner_sid = NULL, user_sid = NULL;
+	BOOL is_admin, admin_owned;
+	int error;
+
+	if (mock_owner) {
+		*out = ((mock_owner & owner_type) != 0);
+		return 0;
 	}
 
-	if (!IsValidSid(owner_sid)) {
-		git_error_set(GIT_ERROR_INVALID, "programdata configuration file owner is unknown");
-		ret = GIT_ERROR;
-		goto cleanup;
+	if ((error = file_owner_sid(&owner_sid, path)) < 0)
+		goto done;
+
+	if ((owner_type & GIT_FS_PATH_OWNER_CURRENT_USER) != 0) {
+		if ((error = current_user_sid(&user_sid)) < 0)
+			goto done;
+
+		if (EqualSid(owner_sid, user_sid)) {
+			*out = true;
+			goto done;
+		}
 	}
 
-	if (IsWellKnownSid(owner_sid, WinBuiltinAdministratorsSid) ||
-	    IsWellKnownSid(owner_sid, WinLocalSystemSid)) {
-		ret = GIT_OK;
-		goto cleanup;
+	admin_owned =
+		IsWellKnownSid(owner_sid, WinBuiltinAdministratorsSid) ||
+		IsWellKnownSid(owner_sid, WinLocalSystemSid);
+
+	if (admin_owned &&
+	    (owner_type & GIT_FS_PATH_OWNER_ADMINISTRATOR) != 0) {
+		*out = true;
+		goto done;
 	}
 
-	/* Obtain current user's SID */
-	if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token) &&
-	    !GetTokenInformation(token, TokenUser, NULL, 0, &len)) {
-		info = git__malloc(len);
-		GIT_ERROR_CHECK_ALLOC(info);
-		if (!GetTokenInformation(token, TokenUser, info, len, &len)) {
-			git__free(info);
-			info = NULL;
-		}
+	if (admin_owned &&
+	    (owner_type & GIT_FS_PATH_USER_IS_ADMINISTRATOR) != 0 &&
+	    CheckTokenMembership(NULL, owner_sid, &is_admin) &&
+	    is_admin) {
+		*out = true;
+		goto done;
 	}
 
-	/*
-	 * If the file is owned by the same account that is running the current
-	 * process, it's okay to read from that file.
-	 */
-	if (info && EqualSid(owner_sid, info->User.Sid))
-		ret = GIT_OK;
-	else {
-		git_error_set(GIT_ERROR_INVALID, "programdata configuration file owner is not valid");
-		ret = GIT_ERROR;
+	*out = false;
+
+done:
+	git__free(owner_sid);
+	git__free(user_sid);
+	return error;
+}
+
+#else
+
+static int sudo_uid_lookup(uid_t *out)
+{
+	git_str uid_str = GIT_STR_INIT;
+	int64_t uid;
+	int error;
+
+	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)) {
+		*out = (uid_t)uid;
 	}
-	git__free(info);
 
-cleanup:
-	if (descriptor)
-		LocalFree(descriptor);
+	git_str_dispose(&uid_str);
+	return error;
+}
+
+int git_fs_path_owner_is(
+	bool *out,
+	const char *path,
+	git_fs_path_owner_t owner_type)
+{
+	struct stat st;
+	uid_t euid, sudo_uid;
+
+	if (mock_owner) {
+		*out = ((mock_owner & owner_type) != 0);
+		return 0;
+	}
+
+	euid = geteuid();
+
+	if (p_lstat(path, &st) != 0) {
+		if (errno == ENOENT)
+			return GIT_ENOTFOUND;
+
+		git_error_set(GIT_ERROR_OS, "could not stat '%s'", path);
+		return -1;
+	}
+
+	if ((owner_type & GIT_FS_PATH_OWNER_CURRENT_USER) != 0 &&
+	    st.st_uid == euid) {
+		*out = true;
+		return 0;
+	}
+
+	if ((owner_type & GIT_FS_PATH_OWNER_ADMINISTRATOR) != 0 &&
+	    st.st_uid == 0) {
+		*out = true;
+		return 0;
+	}
+
+	if ((owner_type & GIT_FS_PATH_OWNER_RUNNING_SUDO) != 0 &&
+	    euid == 0 &&
+	    sudo_uid_lookup(&sudo_uid) == 0 &&
+	    st.st_uid == sudo_uid) {
+		*out = true;
+		return 0;
+	}
+
+	*out = false;
+	return 0;
+}
 
-	return ret;
 #endif
+
+int git_fs_path_owner_is_current_user(bool *out, const char *path)
+{
+	return git_fs_path_owner_is(out, path, GIT_FS_PATH_OWNER_CURRENT_USER);
+}
+
+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)

data/vendor/libgit2/src/{fs_path.h → util/fs_path.h}

@@ -7,7 +7,7 @@
 #ifndef INCLUDE_fs_path_h__
 #define INCLUDE_fs_path_h__
 
-#include "common.h"
+#include "git2_util.h"
 
 #include "posix.h"
 #include "str.h"
@@ -731,17 +731,55 @@ int git_fs_path_normalize_slashes(git_str *out, const char *path);
 
 bool git_fs_path_supports_symlinks(const char *dir);
 
+typedef enum {
+	GIT_FS_PATH_OWNER_NONE = 0,
+
+	/** The file must be owned by the current user. */
+	GIT_FS_PATH_OWNER_CURRENT_USER = (1 << 0),
+
+	/** The file must be owned by the system account. */
+	GIT_FS_PATH_OWNER_ADMINISTRATOR = (1 << 1),
+
+	/**
+	 * The file may be owned by a system account if the current
+	 * user is in an administrator group. Windows only; this is
+	 * a noop on non-Windows systems.
+	 */
+	GIT_FS_PATH_USER_IS_ADMINISTRATOR = (1 << 2),
+
+	/**
+	 * The file is owned by the current user, who is running `sudo`.
+	 */
+	GIT_FS_PATH_OWNER_RUNNING_SUDO = (1 << 3),
+
+	/** The file may be owned by another user. */
+	GIT_FS_PATH_OWNER_OTHER = (1 << 4)
+} git_fs_path_owner_t;
+
+/**
+ * Sets the mock ownership for files; subsequent calls to
+ * `git_fs_path_owner_is_*` functions will return this data until
+ * cleared with `GIT_FS_PATH_OWNER_NONE`.
+ */
+void git_fs_path__set_owner(git_fs_path_owner_t owner);
+
+/** Verify that the file in question is owned by the given owner. */
+int git_fs_path_owner_is(
+	bool *out,
+	const char *path,
+	git_fs_path_owner_t owner_type);
+
 /**
- * Validate a system file's ownership
- *
  * Verify that the file in question is owned by an administrator or system
- * account, or at least by the current user.
- *
- * This function returns 0 if successful. If the file is not owned by any of
- * these, or any other if there have been problems determining the file
- * ownership, it returns -1.
+ * account.
  */
-int git_fs_path_validate_system_file_ownership(const char *path);
+int git_fs_path_owner_is_system(bool *out, const char *path);
+
+/**
+ * Verify that the file in question is owned by the current user;
+ */
+
+int git_fs_path_owner_is_current_user(bool *out, const char *path);
 
 /**
  * Search the current PATH for the given executable, returning the full

data/vendor/libgit2/src/{futils.c → util/futils.c}

@@ -167,18 +167,60 @@ int git_futils_readbuffer_fd(git_str *buf, git_file fd, size_t len)
 	/* p_read loops internally to read len bytes */
 	read_size = p_read(fd, buf->ptr, len);
 
-	if (read_size != (ssize_t)len) {
+	if (read_size < 0) {
 		git_error_set(GIT_ERROR_OS, "failed to read descriptor");
 		git_str_dispose(buf);
 		return -1;
 	}
 
+	if ((size_t)read_size != len) {
+		git_error_set(GIT_ERROR_FILESYSTEM, "could not read (expected %" PRIuZ " bytes, read %" PRIuZ ")", len, (size_t)read_size);
+		git_str_dispose(buf);
+		return -1;
+	}
+
 	buf->ptr[read_size] = '\0';
 	buf->size = read_size;
 
 	return 0;
 }
 
+int git_futils_readbuffer_fd_full(git_str *buf, git_file fd)
+{
+	static size_t blocksize = 10240;
+	size_t alloc_len = 0, total_size = 0;
+	ssize_t read_size = 0;
+
+	git_str_clear(buf);
+
+	while (true) {
+		GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, blocksize);
+
+		if (git_str_grow(buf, alloc_len) < 0)
+			return -1;
+
+		/* p_read loops internally to read blocksize bytes */
+		read_size = p_read(fd, buf->ptr, blocksize);
+
+		if (read_size < 0) {
+			git_error_set(GIT_ERROR_OS, "failed to read descriptor");
+			git_str_dispose(buf);
+			return -1;
+		}
+
+		total_size += read_size;
+
+		if ((size_t)read_size < blocksize) {
+			break;
+		}
+	}
+
+	buf->ptr[total_size] = '\0';
+	buf->size = total_size;
+
+	return 0;
+}
+
 int git_futils_readbuffer_updated(
 	git_str *out,
 	const char *path,
@@ -856,7 +898,7 @@ int git_futils_fake_symlink(const char *target, const char *path)
 static int cp_by_fd(int ifd, int ofd, bool close_fd_when_done)
 {
 	int error = 0;
-	char buffer[FILEIO_BUFSIZE];
+	char buffer[GIT_BUFSIZE_FILEIO];
 	ssize_t len = 0;
 
 	while (!error && (len = p_read(ifd, buffer, sizeof(buffer))) > 0)

data/vendor/libgit2/src/{futils.h → util/futils.h}

@@ -7,7 +7,7 @@
 #ifndef INCLUDE_futils_h__
 #define INCLUDE_futils_h__
 
-#include "common.h"
+#include "git2_util.h"
 
 #include "map.h"
 #include "posix.h"
@@ -27,6 +27,7 @@ extern int git_futils_readbuffer_updated(
 	const char *path,
 	unsigned char checksum[GIT_HASH_SHA1_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

data/vendor/libgit2/src/{common.h → util/git2_util.h}

@@ -4,8 +4,8 @@
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
  */
-#ifndef INCLUDE_common_h__
-#define INCLUDE_common_h__
+#ifndef INCLUDE_git2_util_h__
+#define INCLUDE_git2_util_h__
 
 #ifndef LIBGIT2_NO_FEATURES_H
 # include "git2/sys/features.h"
@@ -14,13 +14,13 @@
 #include "git2/common.h"
 #include "cc-compat.h"
 
+typedef struct git_str git_str;
+
 /** Declare a function as always inlined. */
 #if defined(_MSC_VER)
 # define GIT_INLINE(type) static __inline type
 #elif defined(__GNUC__)
 # define GIT_INLINE(type) static __inline__ type
-#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
-# define GIT_INLINE(type) static inline type
 #else
 # define GIT_INLINE(type) static type
 #endif
@@ -67,12 +67,12 @@
 # include <ws2tcpip.h>
 # include "win32/msvc-compat.h"
 # include "win32/mingw-compat.h"
-# include "win32/w32_common.h"
 # include "win32/win32-compat.h"
-# include "win32/error.h"
+# include "win32/w32_common.h"
 # include "win32/version.h"
+# include "win32/error.h"
 # ifdef GIT_THREADS
-#	include "win32/thread.h"
+#  include "win32/thread.h"
 # endif
 
 #else
@@ -99,24 +99,17 @@
 
 #include "git2/types.h"
 #include "git2/errors.h"
-#include "errors.h"
 #include "thread.h"
 #include "integer.h"
 #include "assert_safe.h"
-#include "utf8.h"
-
-/*
- * Include the declarations for deprecated functions; this ensures
- * that they're decorated with the proper extern/visibility attributes.
- */
-#include "git2/deprecated.h"
 
 #include "posix.h"
 
-#define DEFAULT_BUFSIZE 65536
-#define FILEIO_BUFSIZE DEFAULT_BUFSIZE
-#define FILTERIO_BUFSIZE DEFAULT_BUFSIZE
-#define NETIO_BUFSIZE DEFAULT_BUFSIZE
+#define GIT_BUFSIZE_DEFAULT 65536
+#define GIT_BUFSIZE_FILEIO GIT_BUFSIZE_DEFAULT
+#define GIT_BUFSIZE_FILTERIO GIT_BUFSIZE_DEFAULT
+#define GIT_BUFSIZE_NETIO GIT_BUFSIZE_DEFAULT
+
 
 /**
  * Check a pointer allocation result, returning -1 if it failed.
@@ -126,7 +119,7 @@
 	} while(0)
 
 /**
- * Check a string buffer allocation result, returning -1 if it failed.
+ * Check a buffer allocation result, returning -1 if it failed.
  */
 #define GIT_ERROR_CHECK_ALLOC_STR(buf) do { \
 	if ((void *)(buf) == NULL || git_str_oom(buf)) { return -1; } \
@@ -138,40 +131,6 @@
 #define GIT_ERROR_CHECK_ERROR(code) \
 	do { int _err = (code); if (_err) return _err; } while (0)
 
-/**
- * Check a versioned structure for validity
- */
-GIT_INLINE(int) git_error__check_version(const void *structure, unsigned int expected_max, const char *name)
-{
-	unsigned int actual;
-
-	if (!structure)
-		return 0;
-
-	actual = *(const unsigned int*)structure;
-	if (actual > 0 && actual <= expected_max)
-		return 0;
-
-	git_error_set(GIT_ERROR_INVALID, "invalid version %d on %s", actual, name);
-	return -1;
-}
-#define GIT_ERROR_CHECK_VERSION(S,V,N) if (git_error__check_version(S,V,N) < 0) return -1
-
-/**
- * Initialize a structure with a version.
- */
-GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int version)
-{
-	memset(structure, 0, len);
-	*((int*)structure) = version;
-}
-#define GIT_INIT_STRUCTURE(S,V) git__init_structure(S, sizeof(*S), V)
-
-#define GIT_INIT_STRUCTURE_FROM_TEMPLATE(PTR,VERSION,TYPE,TPL) do { \
-	TYPE _tmpl = TPL; \
-	GIT_ERROR_CHECK_VERSION(&(VERSION), _tmpl.version, #TYPE);	\
-	memcpy((PTR), &_tmpl, sizeof(_tmpl)); } while (0)
-
 
 /** Check for additive overflow, setting an error if would occur. */
 #define GIT_ADD_SIZET_OVERFLOW(out, one, two) \
@@ -204,11 +163,6 @@ GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int v
 #define GIT_ERROR_CHECK_ALLOC_MULTIPLY(out, nelem, elsize) \
 	if (GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize)) { return -1; }
 
-/* NOTE: other git_error functions are in the public errors.h header file */
-
-/* Forward declare git_str */
-typedef struct git_str git_str;
-
 #include "util.h"
 
 #endif