rugged 0.19.0 → 0.28.0

data/vendor/libgit2/src/win32/w32_stack.c

@@ -0,0 +1,193 @@
+/*
+ * 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 "w32_stack.h"
+
+#if defined(GIT_MSVC_CRTDBG)
+#include "Windows.h"
+#include "Dbghelp.h"
+#include "win32/posix.h"
+#include "hash.h"
+
+/**
+ * This is supposedly defined in WinBase.h (from Windows.h) but there were linker issues.
+ */
+USHORT WINAPI RtlCaptureStackBackTrace(ULONG, ULONG, PVOID*, PULONG);
+
+static bool   g_win32_stack_initialized = false;
+static HANDLE g_win32_stack_process = INVALID_HANDLE_VALUE;
+static git_win32__stack__aux_cb_alloc  g_aux_cb_alloc  = NULL;
+static git_win32__stack__aux_cb_lookup g_aux_cb_lookup = NULL;
+
+int git_win32__stack__set_aux_cb(
+	git_win32__stack__aux_cb_alloc cb_alloc,
+	git_win32__stack__aux_cb_lookup cb_lookup)
+{
+	g_aux_cb_alloc = cb_alloc;
+	g_aux_cb_lookup = cb_lookup;
+
+	return 0;
+}
+
+void git_win32__stack_init(void)
+{
+	if (!g_win32_stack_initialized) {
+		g_win32_stack_process = GetCurrentProcess();
+		SymSetOptions(SYMOPT_LOAD_LINES);
+		SymInitialize(g_win32_stack_process, NULL, TRUE);
+		g_win32_stack_initialized = true;
+	}
+}
+
+void git_win32__stack_cleanup(void)
+{
+	if (g_win32_stack_initialized) {
+		SymCleanup(g_win32_stack_process);
+		g_win32_stack_process = INVALID_HANDLE_VALUE;
+		g_win32_stack_initialized = false;
+	}
+}
+
+int git_win32__stack_capture(git_win32__stack__raw_data *pdata, int skip)
+{
+	if (!g_win32_stack_initialized) {
+		git_error_set(GIT_ERROR_INVALID, "git_win32_stack not initialized.");
+		return GIT_ERROR;
+	}
+
+	memset(pdata, 0, sizeof(*pdata));
+	pdata->nr_frames = RtlCaptureStackBackTrace(
+		skip+1, GIT_WIN32__STACK__MAX_FRAMES, pdata->frames, NULL);
+
+	/* If an "aux" data provider was registered, ask it to capture
+	 * whatever data it needs and give us an "aux_id" to it so that
+	 * we can refer to it later when reporting.
+	 */
+	if (g_aux_cb_alloc)
+		(g_aux_cb_alloc)(&pdata->aux_id);
+
+	return 0;
+}
+
+int git_win32__stack_compare(
+	git_win32__stack__raw_data *d1,
+	git_win32__stack__raw_data *d2)
+{
+	return memcmp(d1, d2, sizeof(*d1));
+}
+
+int git_win32__stack_format(
+	char *pbuf, int buf_len,
+	const git_win32__stack__raw_data *pdata,
+	const char *prefix, const char *suffix)
+{
+#define MY_MAX_FILENAME 255
+
+	/* SYMBOL_INFO has char FileName[1] at the end.  The docs say to
+	 * to malloc it with extra space for your desired max filename.
+	 */
+	struct {
+		SYMBOL_INFO symbol;
+		char extra[MY_MAX_FILENAME + 1];
+	} s;
+
+	IMAGEHLP_LINE64 line;
+	int buf_used = 0;
+	unsigned int k;
+	char detail[MY_MAX_FILENAME * 2]; /* filename plus space for function name and formatting */
+	int detail_len;
+
+	if (!g_win32_stack_initialized) {
+		git_error_set(GIT_ERROR_INVALID, "git_win32_stack not initialized.");
+		return GIT_ERROR;
+	}
+
+	if (!prefix)
+		prefix = "\t";
+	if (!suffix)
+		suffix = "\n";
+
+	memset(pbuf, 0, buf_len);
+
+	memset(&s, 0, sizeof(s));
+	s.symbol.MaxNameLen = MY_MAX_FILENAME;
+	s.symbol.SizeOfStruct = sizeof(SYMBOL_INFO);
+
+	memset(&line, 0, sizeof(line));
+	line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
+
+	for (k=0; k < pdata->nr_frames; k++) {
+		DWORD64 frame_k = (DWORD64)pdata->frames[k];
+		DWORD dwUnused;
+
+		if (SymFromAddr(g_win32_stack_process, frame_k, 0, &s.symbol) &&
+			SymGetLineFromAddr64(g_win32_stack_process, frame_k, &dwUnused, &line)) {
+			const char *pslash;
+			const char *pfile;
+
+			pslash = strrchr(line.FileName, '\\');
+			pfile = ((pslash) ? (pslash+1) : line.FileName);
+			p_snprintf(detail, sizeof(detail), "%s%s:%d> %s%s",
+					   prefix, pfile, line.LineNumber, s.symbol.Name, suffix);
+		} else {
+			/* This happens when we cross into another module.
+			 * For example, in CLAR tests, this is typically
+			 * the CRT startup code.  Just print an unknown
+			 * frame and continue.
+			 */
+			p_snprintf(detail, sizeof(detail), "%s??%s", prefix, suffix);
+		}
+		detail_len = strlen(detail);
+
+		if (buf_len < (buf_used + detail_len + 1)) {
+			/* we don't have room for this frame in the buffer, so just stop. */
+			break;
+		}
+
+		memcpy(&pbuf[buf_used], detail, detail_len);
+		buf_used += detail_len;
+	}
+
+	/* "aux_id" 0 is reserved to mean no aux data. This is needed to handle
+	 * allocs that occur before the aux callbacks were registered.
+	 */
+	if (pdata->aux_id > 0) {
+		p_snprintf(detail, sizeof(detail), "%saux_id: %d%s",
+				   prefix, pdata->aux_id, suffix);
+		detail_len = strlen(detail);
+		if ((buf_used + detail_len + 1) < buf_len) {
+			memcpy(&pbuf[buf_used], detail, detail_len);
+			buf_used += detail_len;
+		}
+
+		/* If an "aux" data provider is still registered, ask it to append its detailed
+		 * data to the end of ours using the "aux_id" it gave us when this de-duped
+		 * item was created.
+		 */
+		if (g_aux_cb_lookup)
+			(g_aux_cb_lookup)(pdata->aux_id, &pbuf[buf_used], (buf_len - buf_used - 1));
+	}
+
+	return GIT_OK;
+}
+
+int git_win32__stack(
+	char * pbuf, int buf_len,
+	int skip,
+	const char *prefix, const char *suffix)
+{
+	git_win32__stack__raw_data data;
+	int error;
+
+	if ((error = git_win32__stack_capture(&data, skip)) < 0)
+		return error;
+	if ((error = git_win32__stack_format(pbuf, buf_len, &data, prefix, suffix)) < 0)
+		return error;
+	return 0;
+}
+
+#endif

data/vendor/libgit2/src/win32/w32_stack.h

@@ -0,0 +1,140 @@
+/*
+ * 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.
+ */
+
+#ifndef INCLUDE_win32_w32_stack_h__
+#define INCLUDE_win32_w32_stack_h__
+
+#include "common.h"
+
+#if defined(GIT_MSVC_CRTDBG)
+
+/**
+ * This type defines a callback to be used to augment a C stacktrace
+ * with "aux" data. This can be used, for example, to allow LibGit2Sharp
+ * (or other interpreted consumer libraries) to give us C# stacktrace
+ * data for the PInvoke.
+ *
+ * This callback will be called during crtdbg-instrumented allocs.
+ *
+ * @param aux_id [out] A returned "aux_id" representing a unique
+ * (de-duped at the C# layer) stacktrace.  "aux_id" 0 is reserved
+ * to mean no aux stacktrace data.
+ */
+typedef void (*git_win32__stack__aux_cb_alloc)(unsigned int *aux_id);
+
+/**
+ * This type defines a callback to be used to augment the output of
+ * a stacktrace.  This will be used to request the C# layer format
+ * the C# stacktrace associated with "aux_id" into the provided
+ * buffer.
+ *
+ * This callback will be called during leak reporting.
+ *
+ * @param aux_id The "aux_id" key associated with a stacktrace.
+ * @param aux_msg A buffer where a formatted message should be written.
+ * @param aux_msg_len The size of the buffer.
+ */
+typedef void (*git_win32__stack__aux_cb_lookup)(unsigned int aux_id, char *aux_msg, unsigned int aux_msg_len);
+
+/**
+ * Register an "aux" data provider to augment our C stacktrace data.
+ *
+ * This can be used, for example, to allow LibGit2Sharp (or other
+ * interpreted consumer libraries) to give us the C# stacktrace of
+ * the PInvoke.
+ *
+ * If you choose to use this feature, it should be registered during
+ * initialization and not changed for the duration of the process.
+ */
+GIT_EXTERN(int) git_win32__stack__set_aux_cb(
+	git_win32__stack__aux_cb_alloc cb_alloc,
+	git_win32__stack__aux_cb_lookup cb_lookup);
+
+/**
+ * Maximum number of stackframes to record for a
+ * single stacktrace.
+ */
+#define GIT_WIN32__STACK__MAX_FRAMES 30
+
+/**
+ * Wrapper containing the raw unprocessed stackframe
+ * data for a single stacktrace and any "aux_id".
+ *
+ * I put the aux_id first so leaks will be sorted by it.
+ * So, for example, if a specific callstack in C# leaks
+ * a repo handle, all of the pointers within the associated
+ * repo pointer will be grouped together.
+ */
+typedef struct {
+	unsigned int aux_id;
+	unsigned int nr_frames;
+	void *frames[GIT_WIN32__STACK__MAX_FRAMES];
+} git_win32__stack__raw_data;
+
+
+/**
+ * Load symbol table data.  This should be done in the primary
+ * thread at startup (under a lock if there are other threads
+ * active).
+ */
+void git_win32__stack_init(void);
+
+/**
+ * Cleanup symbol table data.  This should be done in the
+ * primary thead at shutdown (under a lock if there are other
+ * threads active).
+ */
+void git_win32__stack_cleanup(void);
+
+
+/**
+ * Capture raw stack trace data for the current process/thread.
+ *
+ * @param skip Number of initial frames to skip.  Pass 0 to
+ * begin with the caller of this routine. Pass 1 to begin
+ * with its caller.  And so on.
+ */
+int git_win32__stack_capture(git_win32__stack__raw_data *pdata, int skip);
+
+/**
+ * Compare 2 raw stacktraces with the usual -1,0,+1 result.
+ * This includes any "aux_id" values in the comparison, so that
+ * our de-dup is also "aux" context relative.
+ */
+int git_win32__stack_compare(
+	git_win32__stack__raw_data *d1,
+	git_win32__stack__raw_data *d2);
+
+/**
+ * Format raw stacktrace data into buffer WITHOUT using any mallocs.
+ *
+ * @param prefix String written before each frame; defaults to "\t".
+ * @param suffix String written after each frame; defaults to "\n".
+ */
+int git_win32__stack_format(
+	char *pbuf, int buf_len,
+	const git_win32__stack__raw_data *pdata,
+	const char *prefix, const char *suffix);
+
+/**
+ * Convenience routine to capture and format stacktrace into
+ * a buffer WITHOUT using any mallocs.  This is primarily a
+ * wrapper for testing.
+ *
+ * @param skip Number of initial frames to skip. Pass 0 to
+ * begin with the caller of this routine.  Pass 1 to begin
+ * with its caller.  And so on.
+ * @param prefix String written before each frame; defaults to "\t".
+ * @param suffix String written after each frame; defaults to "\n".
+ */
+int git_win32__stack(
+	char * pbuf, int buf_len,
+	int skip,
+	const char *prefix, const char *suffix);
+
+#endif /* GIT_MSVC_CRTDBG */
+#endif

data/vendor/libgit2/src/win32/w32_util.c

@@ -0,0 +1,95 @@
+/*
+ * 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 "w32_util.h"
+
+/**
+ * Creates a FindFirstFile(Ex) filter string from a UTF-8 path.
+ * The filter string enumerates all items in the directory.
+ *
+ * @param dest The buffer to receive the filter string.
+ * @param src The UTF-8 path of the directory to enumerate.
+ * @return True if the filter string was created successfully; false otherwise
+ */
+bool git_win32__findfirstfile_filter(git_win32_path dest, const char *src)
+{
+	static const wchar_t suffix[] = L"\\*";
+	int len = git_win32_path_from_utf8(dest, src);
+
+	/* Ensure the path was converted */
+	if (len < 0)
+		return false;
+
+	/* Ensure that the path does not end with a trailing slash,
+	 * because we're about to add one. Don't rely our trim_end
+	 * helper, because we want to remove the backslash even for
+	 * drive letter paths, in this case. */
+	if (len > 0 &&
+		(dest[len - 1] == L'/' || dest[len - 1] == L'\\')) {
+		dest[len - 1] = L'\0';
+		len--;
+	}
+
+	/* Ensure we have enough room to add the suffix */
+	if ((size_t)len >= GIT_WIN_PATH_UTF16 - CONST_STRLEN(suffix))
+		return false;
+
+	wcscat(dest, suffix);
+	return true;
+}
+
+/**
+ * Ensures the given path (file or folder) has the +H (hidden) attribute set.
+ *
+ * @param path The path which should receive the +H bit.
+ * @return 0 on success; -1 on failure
+ */
+int git_win32__set_hidden(const char *path, bool hidden)
+{
+	git_win32_path buf;
+	DWORD attrs, newattrs;
+
+	if (git_win32_path_from_utf8(buf, path) < 0)
+		return -1;
+
+	attrs = GetFileAttributesW(buf);
+
+	/* Ensure the path exists */
+	if (attrs == INVALID_FILE_ATTRIBUTES)
+		return -1;
+
+	if (hidden)
+		newattrs = attrs | FILE_ATTRIBUTE_HIDDEN;
+	else
+		newattrs = attrs & ~FILE_ATTRIBUTE_HIDDEN;
+
+	if (attrs != newattrs && !SetFileAttributesW(buf, newattrs)) {
+		git_error_set(GIT_ERROR_OS, "failed to %s hidden bit for '%s'",
+			hidden ? "set" : "unset", path);
+		return -1;
+	}
+
+	return 0;
+}
+
+int git_win32__hidden(bool *out, const char *path)
+{
+	git_win32_path buf;
+	DWORD attrs;
+
+	if (git_win32_path_from_utf8(buf, path) < 0)
+		return -1;
+
+	attrs = GetFileAttributesW(buf);
+
+	/* Ensure the path exists */
+	if (attrs == INVALID_FILE_ATTRIBUTES)
+		return -1;
+
+	*out = (attrs & FILE_ATTRIBUTE_HIDDEN) ? true : false;
+	return 0;
+}

data/vendor/libgit2/src/win32/w32_util.h

@@ -0,0 +1,170 @@
+/*
+ * 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.
+ */
+
+#ifndef INCLUDE_win32_w32_util_h__
+#define INCLUDE_win32_w32_util_h__
+
+#include "common.h"
+
+#include "utf-conv.h"
+#include "posix.h"
+#include "path_w32.h"
+
+/*
+
+#include "common.h"
+#include "path.h"
+#include "path_w32.h"
+#include "utf-conv.h"
+#include "posix.h"
+#include "reparse.h"
+#include "dir.h"
+*/
+
+
+GIT_INLINE(bool) git_win32__isalpha(wchar_t c)
+{
+	return ((c >= L'A' && c <= L'Z') || (c >= L'a' && c <= L'z'));
+}
+
+/**
+ * Creates a FindFirstFile(Ex) filter string from a UTF-8 path.
+ * The filter string enumerates all items in the directory.
+ *
+ * @param dest The buffer to receive the filter string.
+ * @param src The UTF-8 path of the directory to enumerate.
+ * @return True if the filter string was created successfully; false otherwise
+ */
+bool git_win32__findfirstfile_filter(git_win32_path dest, const char *src);
+
+/**
+ * Ensures the given path (file or folder) has the +H (hidden) attribute set
+ * or unset.
+ *
+ * @param path The path that should receive the +H bit.
+ * @param hidden true to set +H, false to unset it
+ * @return 0 on success; -1 on failure
+ */
+extern int git_win32__set_hidden(const char *path, bool hidden);
+
+/**
+ * Determines if the given file or folder has the hidden attribute set.
+ * @param hidden pointer to store hidden value
+ * @param path The path that should be queried for hiddenness.
+ * @return 0 on success or an error code.
+ */
+extern int git_win32__hidden(bool *hidden, const char *path);
+
+/**
+ * Converts a FILETIME structure to a struct timespec.
+ *
+ * @param FILETIME A pointer to a FILETIME
+ * @param ts A pointer to the timespec structure to fill in
+ */
+GIT_INLINE(void) git_win32__filetime_to_timespec(
+	const FILETIME *ft,
+	struct timespec *ts)
+{
+	long long winTime = ((long long)ft->dwHighDateTime << 32) + ft->dwLowDateTime;
+	winTime -= 116444736000000000LL; /* Windows to Unix Epoch conversion */
+	ts->tv_sec = (time_t)(winTime / 10000000);
+#ifdef GIT_USE_NSEC
+	ts->tv_nsec = (winTime % 10000000) * 100;
+#else
+	ts->tv_nsec = 0;
+#endif
+}
+
+GIT_INLINE(void) git_win32__timeval_to_filetime(
+	FILETIME *ft, const struct p_timeval tv)
+{
+	long long ticks = (tv.tv_sec * 10000000LL) +
+		(tv.tv_usec * 10LL) + 116444736000000000LL;
+
+	ft->dwHighDateTime = ((ticks >> 32) & 0xffffffffLL);
+	ft->dwLowDateTime = (ticks & 0xffffffffLL);
+}
+
+GIT_INLINE(void) git_win32__stat_init(
+	struct stat *st,
+	DWORD dwFileAttributes,
+	DWORD nFileSizeHigh,
+	DWORD nFileSizeLow,
+	FILETIME ftCreationTime,
+	FILETIME ftLastAccessTime,
+	FILETIME ftLastWriteTime)
+{
+	mode_t mode = S_IREAD;
+
+	memset(st, 0, sizeof(struct stat));
+
+	if (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+		mode |= S_IFDIR;
+	else
+		mode |= S_IFREG;
+
+	if ((dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0)
+		mode |= S_IWRITE;
+
+	st->st_ino = 0;
+	st->st_gid = 0;
+	st->st_uid = 0;
+	st->st_nlink = 1;
+	st->st_mode = mode;
+	st->st_size = ((git_off_t)nFileSizeHigh << 32) + nFileSizeLow;
+	st->st_dev = _getdrive() - 1;
+	st->st_rdev = st->st_dev;
+	git_win32__filetime_to_timespec(&ftLastAccessTime, &(st->st_atim));
+	git_win32__filetime_to_timespec(&ftLastWriteTime, &(st->st_mtim));
+	git_win32__filetime_to_timespec(&ftCreationTime, &(st->st_ctim));
+}
+
+GIT_INLINE(void) git_win32__file_information_to_stat(
+	struct stat *st,
+	const BY_HANDLE_FILE_INFORMATION *fileinfo)
+{
+	git_win32__stat_init(st,
+		fileinfo->dwFileAttributes,
+		fileinfo->nFileSizeHigh,
+		fileinfo->nFileSizeLow,
+		fileinfo->ftCreationTime,
+		fileinfo->ftLastAccessTime,
+		fileinfo->ftLastWriteTime);
+}
+
+GIT_INLINE(int) git_win32__file_attribute_to_stat(
+	struct stat *st,
+	const WIN32_FILE_ATTRIBUTE_DATA *attrdata,
+	const wchar_t *path)
+{
+	git_win32__stat_init(st,
+		attrdata->dwFileAttributes,
+		attrdata->nFileSizeHigh,
+		attrdata->nFileSizeLow,
+		attrdata->ftCreationTime,
+		attrdata->ftLastAccessTime,
+		attrdata->ftLastWriteTime);
+
+	if (attrdata->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT && path) {
+		git_win32_path target;
+
+		if (git_win32_path_readlink_w(target, path) >= 0) {
+			st->st_mode = (st->st_mode & ~S_IFMT) | S_IFLNK;
+
+			/* st_size gets the UTF-8 length of the target name, in bytes,
+			 * not counting the NULL terminator */
+			if ((st->st_size = git__utf16_to_8(NULL, 0, target)) < 0) {
+				git_error_set(GIT_ERROR_OS, "could not convert reparse point name for '%ls'", path);
+				return -1;
+			}
+		}
+	}
+
+	return 0;
+}
+
+#endif

data/vendor/libgit2/src/win32/win32-compat.h

@@ -0,0 +1,52 @@
+/*
+ * 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.
+ */
+#ifndef INCLUDE_win32_win32_compat_h__
+#define INCLUDE_win32_win32_compat_h__
+
+#include <stdint.h>
+#include <time.h>
+#include <wchar.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+typedef long suseconds_t;
+
+struct p_timeval {
+	time_t tv_sec;
+	suseconds_t tv_usec;
+};
+
+struct p_timespec {
+	time_t tv_sec;
+	long tv_nsec;
+};
+
+#define timespec p_timespec
+
+struct p_stat {
+	_dev_t st_dev;
+	_ino_t st_ino;
+	mode_t st_mode;
+	short st_nlink;
+	short st_uid;
+	short st_gid;
+	_dev_t st_rdev;
+	__int64 st_size;
+	struct timespec st_atim;
+	struct timespec st_mtim;
+	struct timespec st_ctim;
+#define st_atime st_atim.tv_sec
+#define st_mtime st_mtim.tv_sec
+#define st_ctime st_ctim.tv_sec
+#define st_atime_nsec st_atim.tv_nsec
+#define st_mtime_nsec st_mtim.tv_nsec
+#define st_ctime_nsec st_ctim.tv_nsec
+};
+
+#define stat p_stat
+
+#endif