rugged 1.1.1 → 1.2.0

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

@@ -8,7 +8,6 @@
 #define INCLUDE_win32_path_w32_h__
 
 #include "common.h"
-#include "vector.h"
 
 /**
  * Create a Win32 path (in UCS-2 format) from a UTF-8 string.  If the given

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

@@ -14,7 +14,6 @@
 #include "utf-conv.h"
 #include "repository.h"
 #include "reparse.h"
-#include "global.h"
 #include "buffer.h"
 #include <errno.h>
 #include <io.h>
@@ -544,6 +543,13 @@ int p_open(const char *path, int flags, ...)
 	mode_t mode = 0;
 	struct open_opts opts = {0};
 
+	#ifdef GIT_DEBUG_STRICT_OPEN
+	if (strstr(path, "//") != NULL) {
+		errno = EACCES;
+		return -1;
+	}
+	#endif
+
 	if (git_win32_path_from_utf8(wpath, path) < 0)
 		return -1;
 

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

@@ -1,6 +1,5 @@
 #include "common.h"
 
-#include <assert.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdlib.h>

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

@@ -26,18 +26,18 @@ typedef struct _GIT_REPARSE_DATA_BUFFER {
 			USHORT PrintNameLength;
 			ULONG  Flags;
 			WCHAR  PathBuffer[1];
-		} SymbolicLinkReparseBuffer;
+		} SymbolicLink;
 		struct {
 			USHORT SubstituteNameOffset;
 			USHORT SubstituteNameLength;
 			USHORT PrintNameOffset;
 			USHORT PrintNameLength;
 			WCHAR  PathBuffer[1];
-		} MountPointReparseBuffer;
+		} MountPoint;
 		struct {
 			UCHAR DataBuffer[1];
-		} GenericReparseBuffer;
-	};
+		} Generic;
+	} ReparseBuffer;
 } GIT_REPARSE_DATA_BUFFER;
 
 #define REPARSE_DATA_HEADER_SIZE			8

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

@@ -6,8 +6,7 @@
  */
 
 #include "thread.h"
-
-#include "../global.h"
+#include "runtime.h"
 
 #define CLEAN_THREAD_EXIT 0x6F012842
 
@@ -19,6 +18,8 @@ static win32_srwlock_fn win32_srwlock_release_shared;
 static win32_srwlock_fn win32_srwlock_acquire_exclusive;
 static win32_srwlock_fn win32_srwlock_release_exclusive;
 
+static DWORD fls_index;
+
 /* The thread procedure stub used to invoke the caller's procedure
  * and capture the return value for later collection. Windows will
  * only hold a DWORD, but we need to be able to store an entire
@@ -28,14 +29,19 @@ static DWORD WINAPI git_win32__threadproc(LPVOID lpParameter)
 	git_thread *thread = lpParameter;
 
 	/* Set the current thread for `git_thread_exit` */
-	GIT_GLOBAL->current_thread = thread;
+	FlsSetValue(fls_index, thread);
 
 	thread->result = thread->proc(thread->param);
 
 	return CLEAN_THREAD_EXIT;
 }
 
-int git_threads_init(void)
+static void git_threads_global_shutdown(void)
+{
+	FlsFree(fls_index);
+}
+
+int git_threads_global_init(void)
 {
 	HMODULE hModule = GetModuleHandleW(L"kernel32");
 
@@ -52,7 +58,10 @@ int git_threads_init(void)
 			GetProcAddress(hModule, "ReleaseSRWLockExclusive");
 	}
 
-	return 0;
+	if ((fls_index = FlsAlloc(NULL)) == FLS_OUT_OF_INDEXES)
+		return -1;
+
+	return git_runtime_shutdown_register(git_threads_global_shutdown);
 }
 
 int git_thread_create(
@@ -85,10 +94,7 @@ int git_thread_join(
 
 	/* Check for the thread having exited uncleanly. If exit was unclean,
 	 * then we don't have a return value to give back to the caller. */
-	if (exit != CLEAN_THREAD_EXIT) {
-		assert(false);
-		thread->result = NULL;
-	}
+	GIT_ASSERT(exit == CLEAN_THREAD_EXIT);
 
 	if (value_ptr)
 		*value_ptr = thread->result;
@@ -99,8 +105,11 @@ int git_thread_join(
 
 void git_thread_exit(void *value)
 {
-	assert(GIT_GLOBAL->current_thread);
-	GIT_GLOBAL->current_thread->result = value;
+	git_thread *thread = FlsGetValue(fls_index);
+
+	if (thread)
+		thread->result = value;
+
 	ExitThread(CLEAN_THREAD_EXIT);
 }
 
@@ -137,7 +146,7 @@ int git_cond_init(git_cond *cond)
 {
 	/* This is an auto-reset event. */
 	*cond = CreateEventW(NULL, FALSE, FALSE, NULL);
-	assert(*cond);
+	GIT_ASSERT(*cond);
 
 	/* If we can't create the event, claim that the reason was out-of-memory.
 	 * The actual reason can be fetched with GetLastError(). */
@@ -152,7 +161,7 @@ int git_cond_free(git_cond *cond)
 		return EINVAL;
 
 	closed = CloseHandle(*cond);
-	assert(closed);
+	GIT_ASSERT(closed);
 	GIT_UNUSED(closed);
 
 	*cond = NULL;
@@ -174,7 +183,7 @@ int git_cond_wait(git_cond *cond, git_mutex *mutex)
 		return error;
 
 	wait_result = WaitForSingleObject(*cond, INFINITE);
-	assert(WAIT_OBJECT_0 == wait_result);
+	GIT_ASSERT(WAIT_OBJECT_0 == wait_result);
 	GIT_UNUSED(wait_result);
 
 	return git_mutex_lock(mutex);
@@ -188,7 +197,7 @@ int git_cond_signal(git_cond *cond)
 		return EINVAL;
 
 	signaled = SetEvent(*cond);
-	assert(signaled);
+	GIT_ASSERT(signaled);
 	GIT_UNUSED(signaled);
 
 	return 0;

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

@@ -35,7 +35,7 @@ typedef struct {
 	} native;
 } git_rwlock;
 
-int git_threads_init(void);
+int git_threads_global_init(void);
 
 int git_thread_create(git_thread *GIT_RESTRICT,
 	void *(*) (void *),

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

@@ -32,13 +32,13 @@ int git_buf_put_w(git_buf *buf, const wchar_t *string_w, size_t len_w)
 		return -1;
 	}
 
-	assert(string_w);
+	GIT_ASSERT(string_w);
 
 	/* Measure the string necessary for conversion */
 	if ((utf8_len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, string_w, (int)len_w, NULL, 0, NULL, NULL)) == 0)
 		return 0;
 
-	assert(utf8_len > 0);
+	GIT_ASSERT(utf8_len > 0);
 
 	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, buf->size, (size_t)utf8_len);
 	GIT_ERROR_CHECK_ALLOC_ADD(&new_size, new_size, 1);
@@ -50,7 +50,7 @@ int git_buf_put_w(git_buf *buf, const wchar_t *string_w, size_t len_w)
 			CP_UTF8, WC_ERR_INVALID_CHARS, string_w, (int)len_w, &buf->ptr[buf->size], utf8_len, NULL, NULL)) == 0)
 		return handle_wc_error();
 
-	assert(utf8_write_len == utf8_len);
+	GIT_ASSERT(utf8_write_len == utf8_len);
 
 	buf->size += utf8_write_len;
 	buf->ptr[buf->size] = '\0';

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

@@ -8,24 +8,33 @@
 #ifndef INCLUDE_win32_w32_common_h__
 #define INCLUDE_win32_w32_common_h__
 
+#include <git2/common.h>
+
+/*
+ * 4096 is the max allowed Git path. `MAX_PATH` (260) is the typical max allowed
+ * Windows path length, however win32 Unicode APIs generally allow up to 32,767
+ * if prefixed with "\\?\" (i.e. converted to an NT-style name).
+ */
+#define GIT_WIN_PATH_MAX GIT_PATH_MAX
+
 /*
- * Provides a large enough buffer to support Windows paths:  MAX_PATH is
- * 260, corresponding to a maximum path length of 259 characters plus a
- * NULL terminator.  Prefixing with "\\?\" adds 4 characters, but if the
- * original was a UNC path, then we turn "\\server\share" into
+ * Provides a large enough buffer to support Windows Git paths:
+ * GIT_WIN_PATH_MAX is 4096, corresponding to a maximum path length of 4095
+ * characters plus a NULL terminator.  Prefixing with "\\?\" adds 4 characters,
+ * but if the original was a UNC path, then we turn "\\server\share" into
  * "\\?\UNC\server\share".  So we replace the first two characters with
- * 8 characters, a net gain of 6, so the maximum length is MAX_PATH+6.
+ * 8 characters, a net gain of 6, so the maximum length is GIT_WIN_PATH_MAX+6.
  */
-#define GIT_WIN_PATH_UTF16		MAX_PATH+6
+#define GIT_WIN_PATH_UTF16		GIT_WIN_PATH_MAX+6
 
-/* Maximum size of a UTF-8 Win32 path.  We remove the "\\?\" or "\\?\UNC\"
- * prefixes for presentation, bringing us back to 259 (non-NULL)
+/* Maximum size of a UTF-8 Win32 Git path.  We remove the "\\?\" or "\\?\UNC\"
+ * prefixes for presentation, bringing us back to 4095 (non-NULL)
  * characters.  UTF-8 does have 4-byte sequences, but they are encoded in
  * UTF-16 using surrogate pairs, which takes up the space of two characters.
  * Two characters in the range U+0800 -> U+FFFF take up more space in UTF-8
  * (6 bytes) than one surrogate pair (4 bytes).
  */
-#define GIT_WIN_PATH_UTF8		(259 * 3 + 1)
+#define GIT_WIN_PATH_UTF8		((GIT_WIN_PATH_MAX - 1) * 3 + 1)
 
 /*
  * The length of a Windows "shortname", for 8.3 compatibility.

data/vendor/libgit2/src/win32/{w32_crtdbg_stacktrace.c → w32_leakcheck.c}

@@ -5,12 +5,203 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "w32_crtdbg_stacktrace.h"
+#include "w32_leakcheck.h"
 
-#if defined(GIT_MSVC_CRTDBG)
-#include "w32_stack.h"
+#if defined(GIT_WIN32_LEAKCHECK)
 
-#define CRTDBG_STACKTRACE__UID_LEN (15)
+#include "Windows.h"
+#include "Dbghelp.h"
+#include "win32/posix.h"
+#include "hash.h"
+#include "runtime.h"
+
+/* Stack frames (for stack tracing, below) */
+
+static bool   g_win32_stack_initialized = false;
+static HANDLE g_win32_stack_process = INVALID_HANDLE_VALUE;
+static git_win32_leakcheck_stack_aux_cb_alloc  g_aux_cb_alloc  = NULL;
+static git_win32_leakcheck_stack_aux_cb_lookup g_aux_cb_lookup = NULL;
+
+int git_win32_leakcheck_stack_set_aux_cb(
+	git_win32_leakcheck_stack_aux_cb_alloc cb_alloc,
+	git_win32_leakcheck_stack_aux_cb_lookup cb_lookup)
+{
+	g_aux_cb_alloc = cb_alloc;
+	g_aux_cb_lookup = cb_lookup;
+
+	return 0;
+}
+
+/**
+ * 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_leakcheck_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;
+	}
+}
+
+/**
+ * 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_leakcheck_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_leakcheck_stack_capture(git_win32_leakcheck_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_LEAKCHECK_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_leakcheck_stack_compare(
+	git_win32_leakcheck_stack_raw_data *d1,
+	git_win32_leakcheck_stack_raw_data *d2)
+{
+	return memcmp(d1, d2, sizeof(*d1));
+}
+
+int git_win32_leakcheck_stack_format(
+	char *pbuf, size_t buf_len,
+	const git_win32_leakcheck_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;
+	size_t buf_used = 0;
+	unsigned int k;
+	char detail[MY_MAX_FILENAME * 2]; /* filename plus space for function name and formatting */
+	size_t 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_leakcheck_stack(
+	char * pbuf, size_t buf_len,
+	int skip,
+	const char *prefix, const char *suffix)
+{
+	git_win32_leakcheck_stack_raw_data data;
+	int error;
+
+	if ((error = git_win32_leakcheck_stack_capture(&data, skip)) < 0)
+		return error;
+	if ((error = git_win32_leakcheck_stack_format(pbuf, buf_len, &data, prefix, suffix)) < 0)
+		return error;
+	return 0;
+}
+
+/* Strack tracing */
+
+#define STACKTRACE_UID_LEN (15)
 
 /**
  * The stacktrace of an allocation can be distilled
@@ -20,20 +211,20 @@
  * give to the CRT malloc routines.
  */
 typedef struct {
-	char uid[CRTDBG_STACKTRACE__UID_LEN + 1];
-} git_win32__crtdbg_stacktrace__uid;
+	char uid[STACKTRACE_UID_LEN + 1];
+} git_win32_leakcheck_stacktrace_uid;
 
 /**
  * All mallocs with the same stacktrace will be de-duped
  * and aggregated into this row.
  */
 typedef struct {
-	git_win32__crtdbg_stacktrace__uid uid; /* must be first */
-	git_win32__stack__raw_data raw_data;
+	git_win32_leakcheck_stacktrace_uid uid; /* must be first */
+	git_win32_leakcheck_stack_raw_data raw_data;
 	unsigned int count_allocs; /* times this alloc signature seen since init */
 	unsigned int count_allocs_at_last_checkpoint; /* times since last mark */
 	unsigned int transient_count_leaks; /* sum of leaks */
-} git_win32__crtdbg_stacktrace__row;
+} git_win32_leakcheck_stacktrace_row;
 
 static CRITICAL_SECTION g_crtdbg_stacktrace_cs;
 
@@ -57,9 +248,9 @@ static CRITICAL_SECTION g_crtdbg_stacktrace_cs;
  * it and try again.
  */
 
-#define MY_ROW_LIMIT (1024 * 1024)
-static git_win32__crtdbg_stacktrace__row  g_cs_rows[MY_ROW_LIMIT];
-static git_win32__crtdbg_stacktrace__row *g_cs_index[MY_ROW_LIMIT];
+#define MY_ROW_LIMIT (2 * 1024 * 1024)
+static git_win32_leakcheck_stacktrace_row  g_cs_rows[MY_ROW_LIMIT];
+static git_win32_leakcheck_stacktrace_row *g_cs_index[MY_ROW_LIMIT];
 
 static unsigned int g_cs_end = MY_ROW_LIMIT;
 static unsigned int g_cs_ins = 0; /* insertion point == unique allocs seen */
@@ -76,18 +267,18 @@ static bool g_transient_leaks_since_mark = false; /* payload for hook */
  */
 static int row_cmp(const void *v1, const void *v2)
 {
-	git_win32__stack__raw_data *d1 = (git_win32__stack__raw_data*)v1;
-	git_win32__crtdbg_stacktrace__row *r2 = (git_win32__crtdbg_stacktrace__row *)v2;
+	git_win32_leakcheck_stack_raw_data *d1 = (git_win32_leakcheck_stack_raw_data*)v1;
+	git_win32_leakcheck_stacktrace_row *r2 = (git_win32_leakcheck_stacktrace_row *)v2;
 
-	return (git_win32__stack_compare(d1, &r2->raw_data));
+	return (git_win32_leakcheck_stack_compare(d1, &r2->raw_data));
 }
 
 /**
  * Unique insert the new data into the row and index tables.
  * We have to sort by the stackframe data itself, not the uid.
  */
-static git_win32__crtdbg_stacktrace__row * insert_unique(
-	const git_win32__stack__raw_data *pdata)
+static git_win32_leakcheck_stacktrace_row * insert_unique(
+	const git_win32_leakcheck_stack_raw_data *pdata)
 {
 	size_t pos;
 	if (git__bsearch(g_cs_index, g_cs_ins, pdata, row_cmp, &pos) < 0) {
@@ -206,7 +397,7 @@ static void dump_summary(const char *label)
 					g_cs_rows[k].count_allocs);
 			my_output(buf);
 
-			if (git_win32__stack_format(
+			if (git_win32_leakcheck_stack_format(
 					buf, sizeof(buf), &g_cs_rows[k].raw_data,
 					NULL, NULL) >= 0) {
 				my_output(buf);
@@ -219,7 +410,11 @@ static void dump_summary(const char *label)
 	fflush(stderr);
 }
 
-void git_win32__crtdbg_stacktrace_init(void)
+/**
+ * Initialize our memory leak tracking and de-dup data structures.
+ * This should ONLY be called by git_libgit2_init().
+ */
+void git_win32_leakcheck_stacktrace_init(void)
 {
 	InitializeCriticalSection(&g_crtdbg_stacktrace_cs);
 
@@ -238,8 +433,8 @@ void git_win32__crtdbg_stacktrace_init(void)
 	LeaveCriticalSection(&g_crtdbg_stacktrace_cs);
 }
 
-int git_win32__crtdbg_stacktrace__dump(
-	git_win32__crtdbg_stacktrace_options opt,
+int git_win32_leakcheck_stacktrace_dump(
+	git_win32_leakcheck_stacktrace_options opt,
 	const char *label)
 {
 	_CRT_REPORT_HOOK old;
@@ -248,10 +443,10 @@ int git_win32__crtdbg_stacktrace__dump(
 
 #define IS_BIT_SET(o,b) (((o) & (b)) != 0)
 
-	bool b_set_mark         = IS_BIT_SET(opt, GIT_WIN32__CRTDBG_STACKTRACE__SET_MARK);
-	bool b_leaks_since_mark = IS_BIT_SET(opt, GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_SINCE_MARK);
-	bool b_leaks_total      = IS_BIT_SET(opt, GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_TOTAL);
-	bool b_quiet            = IS_BIT_SET(opt, GIT_WIN32__CRTDBG_STACKTRACE__QUIET);
+	bool b_set_mark         = IS_BIT_SET(opt, GIT_WIN32_LEAKCHECK_STACKTRACE_SET_MARK);
+	bool b_leaks_since_mark = IS_BIT_SET(opt, GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_SINCE_MARK);
+	bool b_leaks_total      = IS_BIT_SET(opt, GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_TOTAL);
+	bool b_quiet            = IS_BIT_SET(opt, GIT_WIN32_LEAKCHECK_STACKTRACE_QUIET);
 
 	if (b_leaks_since_mark && b_leaks_total) {
 		git_error_set(GIT_ERROR_INVALID, "cannot combine LEAKS_SINCE_MARK and LEAKS_TOTAL.");
@@ -301,29 +496,44 @@ int git_win32__crtdbg_stacktrace__dump(
 	return r;
 }
 
-void git_win32__crtdbg_stacktrace_cleanup(void)
+/**
+ * Shutdown our memory leak tracking and dump summary data.
+ * This should ONLY be called by git_libgit2_shutdown().
+ *
+ * We explicitly call _CrtDumpMemoryLeaks() during here so
+ * that we can compute summary data for the leaks. We print
+ * the stacktrace of each unique leak.
+ *
+ * This cleanup does not happen if the app calls exit()
+ * without calling the libgit2 shutdown code.
+ *
+ * This info we print here is independent of any automatic
+ * reporting during exit() caused by _CRTDBG_LEAK_CHECK_DF.
+ * Set it in your app if you also want traditional reporting.
+ */
+void git_win32_leakcheck_stacktrace_cleanup(void)
 {
-	/* At shutdown/cleanup, dump cummulative leak info
+	/* At shutdown/cleanup, dump cumulative leak info
 	 * with everything since startup.  This might generate
 	 * extra noise if the caller has been doing checkpoint
 	 * dumps, but it might also eliminate some false
 	 * positives for resources previously reported during
 	 * checkpoints.
 	 */
-	git_win32__crtdbg_stacktrace__dump(
-		GIT_WIN32__CRTDBG_STACKTRACE__LEAKS_TOTAL,
+	git_win32_leakcheck_stacktrace_dump(
+		GIT_WIN32_LEAKCHECK_STACKTRACE_LEAKS_TOTAL,
 		"CLEANUP");
 
 	DeleteCriticalSection(&g_crtdbg_stacktrace_cs);
 }
 
-const char *git_win32__crtdbg_stacktrace(int skip, const char *file)
+const char *git_win32_leakcheck_stacktrace(int skip, const char *file)
 {
-	git_win32__stack__raw_data new_data;
-	git_win32__crtdbg_stacktrace__row *row;
+	git_win32_leakcheck_stack_raw_data new_data;
+	git_win32_leakcheck_stacktrace_row *row;
 	const char * result = file;
 
-	if (git_win32__stack_capture(&new_data, skip+1) < 0)
+	if (git_win32_leakcheck_stack_capture(&new_data, skip+1) < 0)
 		return result;
 
 	EnterCriticalSection(&g_crtdbg_stacktrace_cs);
@@ -342,4 +552,30 @@ const char *git_win32__crtdbg_stacktrace(int skip, const char *file)
 	return result;
 }
 
+static void git_win32_leakcheck_global_shutdown(void)
+{
+	git_win32_leakcheck_stacktrace_cleanup();
+	git_win32_leakcheck_stack_cleanup();
+}
+
+bool git_win32_leakcheck_has_leaks(void)
+{
+	return (g_transient_count_total_leaks > 0);
+}
+
+int git_win32_leakcheck_global_init(void)
+{
+	git_win32_leakcheck_stacktrace_init();
+	git_win32_leakcheck_stack_init();
+
+	return git_runtime_shutdown_register(git_win32_leakcheck_global_shutdown);
+}
+
+#else
+
+int git_win32_leakcheck_global_init(void)
+{
+	return 0;
+}
+
 #endif