rugged 0.23.0 → 0.23.1

data/vendor/libgit2/src/stransport_stream.c

@@ -108,7 +108,7 @@ int stransport_certificate(git_cert **out, git_stream *stream)
 		return -1;
 	}
 
-	st->cert_info.cert_type = GIT_CERT_X509;
+	st->cert_info.parent.cert_type = GIT_CERT_X509;
 	st->cert_info.data = (void *) CFDataGetBytePtr(st->der_data);
 	st->cert_info.len = CFDataGetLength(st->der_data);
 

data/vendor/libgit2/src/submodule.c

@@ -781,11 +781,21 @@ const char *git_submodule_url(git_submodule *submodule)
 int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *url)
 {
 	int error = 0;
+	git_buf normalized = GIT_BUF_INIT;
 
 	assert(out && repo && url);
 
 	git_buf_sanitize(out);
 
+	/* We do this in all platforms in case someone on Windows created the .gitmodules */
+	if (strchr(url, '\\')) {
+		if ((error = git_path_normalize_slashes(&normalized, url)) < 0)
+			return error;
+
+		url = normalized.ptr;
+	}
+
+
 	if (git_path_is_relative(url)) {
 		if (!(error = get_url_base(out, repo)))
 			error = git_path_apply_relative(out, url);
@@ -796,6 +806,7 @@ int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *ur
 		error = -1;
 	}
 
+	git_buf_free(&normalized);
 	return error;
 }
 
@@ -1647,7 +1658,7 @@ static int submodule_load_from_config(
 	} else {
 		khiter_t pos;
 		git_strmap *map = data->map;
-		pos = git_strmap_lookup_index(map, name.ptr);
+		pos = git_strmap_lookup_index(map, path ? path : name.ptr);
 		if (git_strmap_valid_index(map, pos)) {
 			sm = git_strmap_value_at(map, pos);
 		} else {

data/vendor/libgit2/src/sysdir.c

@@ -29,7 +29,14 @@ static int git_sysdir_guess_global_dirs(git_buf *out)
 #ifdef GIT_WIN32
 	return git_win32__find_global_dirs(out);
 #else
-	return git_buf_sets(out, getenv("HOME"));
+	int error = git__getenv(out, "HOME");
+
+	if (error == GIT_ENOTFOUND) {
+		giterr_clear();
+		error = 0;
+	}
+
+	return error;
 #endif
 }
 
@@ -38,15 +45,22 @@ static int git_sysdir_guess_xdg_dirs(git_buf *out)
 #ifdef GIT_WIN32
 	return git_win32__find_xdg_dirs(out);
 #else
-	const char *env = NULL;
+	git_buf env = GIT_BUF_INIT;
+	int error;
 
-	if ((env = getenv("XDG_CONFIG_HOME")) != NULL)
-		return git_buf_joinpath(out, env, "git");
-	else if ((env = getenv("HOME")) != NULL)
-		return git_buf_joinpath(out, env, ".config/git");
+	if ((error = git__getenv(&env, "XDG_CONFIG_HOME")) == 0)
+		error = git_buf_joinpath(out, env.ptr, "git");
 
-	git_buf_clear(out);
-	return 0;
+	if (error == GIT_ENOTFOUND && (error = git__getenv(&env, "HOME")) == 0)
+		error = git_buf_joinpath(out, env.ptr, ".config/git");
+
+	if (error == GIT_ENOTFOUND) {
+		giterr_clear();
+		error = 0;
+	}
+
+	git_buf_free(&env);
+	return error;
 #endif
 }
 

data/vendor/libgit2/src/thread-utils.c

@@ -8,7 +8,9 @@
 #include "thread-utils.h"
 
 #ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
 #	define WIN32_LEAN_AND_MEAN
+#endif
 #	include <windows.h>
 #elif defined(hpux) || defined(__hpux) || defined(_hpux)
 #	include <sys/pstat.h>

data/vendor/libgit2/src/transports/git.c

@@ -50,6 +50,8 @@ static int gen_proto(git_buf *request, const char *cmd, const char *url)
 	}
 
 	repo = delim;
+	if (repo[1] == '~')
+		++repo;
 
 	delim = strchr(url, ':');
 	if (delim == NULL)

data/vendor/libgit2/src/transports/http.c

@@ -255,7 +255,7 @@ static int on_header_ready(http_subtransport *t)
 			GITERR_CHECK_ALLOC(t->content_type);
 		}
 	}
-	else if (!strcmp("WWW-Authenticate", git_buf_cstr(name))) {
+	else if (!strcasecmp("WWW-Authenticate", git_buf_cstr(name))) {
 		char *dup = git__strdup(git_buf_cstr(value));
 		GITERR_CHECK_ALLOC(dup);
 
@@ -511,7 +511,7 @@ static int write_chunk(git_stream *io, const char *buffer, size_t len)
 	git_buf buf = GIT_BUF_INIT;
 
 	/* Chunk header */
-	git_buf_printf(&buf, "%X\r\n", (unsigned)len);
+	git_buf_printf(&buf, "%" PRIxZ "\r\n", len);
 
 	if (git_buf_oom(&buf))
 		return -1;

data/vendor/libgit2/src/transports/smart_pkt.c

@@ -523,7 +523,7 @@ static int buffer_want_with_caps(const git_remote_head *head, transport_smart_ca
 
 	if (len > 0xffff) {
 		giterr_set(GITERR_NET,
-			"Tried to produce packet with invalid length %d", len);
+			"Tried to produce packet with invalid length %" PRIuZ, len);
 		return -1;
 	}
 

data/vendor/libgit2/src/transports/ssh.c

@@ -66,6 +66,8 @@ static int gen_proto(git_buf *request, const char *cmd, const char *url)
 	if (!git__prefixcmp(url, prefix_ssh)) {
 		url = url + strlen(prefix_ssh);
 		repo = strchr(url, '/');
+		if (repo && repo[1] == '~')
+			++repo;
 	} else {
 		repo = strchr(url, ':');
 		if (repo) repo++;
@@ -525,10 +527,10 @@ static int _git_ssh_setup_conn(
 		goto done;
 
 	if (t->owner->certificate_check_cb != NULL) {
-		git_cert_hostkey cert = { 0 }, *cert_ptr;
+		git_cert_hostkey cert = {{ 0 }}, *cert_ptr;
 		const char *key;
 
-		cert.cert_type = GIT_CERT_HOSTKEY_LIBSSH2;
+		cert.parent.cert_type = GIT_CERT_HOSTKEY_LIBSSH2;
 
 		key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
 		if (key != NULL) {

data/vendor/libgit2/src/transports/winhttp.c

@@ -228,7 +228,7 @@ static int certificate_check(winhttp_stream *s, int valid)
 	}
 
 	giterr_clear();
-	cert.cert_type = GIT_CERT_X509;
+	cert.parent.cert_type = GIT_CERT_X509;
 	cert.data = cert_ctx->pbCertEncoded;
 	cert.len = cert_ctx->cbCertEncoded;
 	error = t->owner->certificate_check_cb((git_cert *) &cert, valid, t->connection_data.host, t->owner->cred_acquire_payload);

data/vendor/libgit2/src/util.c

@@ -10,6 +10,10 @@
 #include <ctype.h>
 #include "posix.h"
 
+#ifdef GIT_WIN32
+# include "win32/w32_buffer.h"
+#endif
+
 #ifdef _MSC_VER
 # include <Shlwapi.h>
 #endif
@@ -765,3 +769,47 @@ int git__utf8_iterate(const uint8_t *str, int str_len, int32_t *dst)
 	*dst = uc;
 	return length;
 }
+
+#ifdef GIT_WIN32
+int git__getenv(git_buf *out, const char *name)
+{
+	wchar_t *wide_name = NULL, *wide_value = NULL;
+	DWORD value_len;
+	int error = -1;
+
+	git_buf_clear(out);
+
+	if (git__utf8_to_16_alloc(&wide_name, name) < 0)
+		return -1;
+
+	if ((value_len = GetEnvironmentVariableW(wide_name, NULL, 0)) > 0) {
+		wide_value = git__malloc(value_len * sizeof(wchar_t));
+		GITERR_CHECK_ALLOC(wide_value);
+
+		value_len = GetEnvironmentVariableW(wide_name, wide_value, value_len);
+	}
+
+	if (value_len)
+		error = git_buf_put_w(out, wide_value, value_len);
+	else if (GetLastError() == ERROR_ENVVAR_NOT_FOUND)
+		error = GIT_ENOTFOUND;
+	else
+		giterr_set(GITERR_OS, "could not read environment variable '%s'", name);
+
+	git__free(wide_name);
+	git__free(wide_value);
+	return error;
+}
+#else
+int git__getenv(git_buf *out, const char *name)
+{
+	const char *val = getenv(name);
+
+	git_buf_clear(out);
+
+	if (!val)
+		return GIT_ENOTFOUND;
+
+	return git_buf_puts(out, val);
+}
+#endif

data/vendor/libgit2/src/util.h

@@ -7,6 +7,9 @@
 #ifndef INCLUDE_util_h__
 #define INCLUDE_util_h__
 
+#include "git2/buffer.h"
+#include "buffer.h"
+
 #if defined(GIT_MSVC_CRTDBG)
 /* Enable MSVC CRTDBG memory leak reporting.
  *
@@ -35,6 +38,7 @@
  */
 #include <stdlib.h>
 #include <crtdbg.h>
+#include "win32/w32_crtdbg_stacktrace.h"
 #endif
 
 #include "common.h"
@@ -62,23 +66,24 @@
 #define CONST_STRLEN(x) ((sizeof(x)/sizeof(x[0])) - 1)
 
 #if defined(GIT_MSVC_CRTDBG)
+
 GIT_INLINE(void *) git__crtdbg__malloc(size_t len, const char *file, int line)
 {
-	void *ptr = _malloc_dbg(len, _NORMAL_BLOCK, file, line);
+	void *ptr = _malloc_dbg(len, _NORMAL_BLOCK, git_win32__crtdbg_stacktrace(1,file), line);
 	if (!ptr) giterr_set_oom();
 	return ptr;
 }
 
 GIT_INLINE(void *) git__crtdbg__calloc(size_t nelem, size_t elsize, const char *file, int line)
 {
-	void *ptr = _calloc_dbg(nelem, elsize, _NORMAL_BLOCK, file, line);
+	void *ptr = _calloc_dbg(nelem, elsize, _NORMAL_BLOCK, git_win32__crtdbg_stacktrace(1,file), line);
 	if (!ptr) giterr_set_oom();
 	return ptr;
 }
 
 GIT_INLINE(char *) git__crtdbg__strdup(const char *str, const char *file, int line)
 {
-	char *ptr = _strdup_dbg(str, _NORMAL_BLOCK, file, line);
+	char *ptr = _strdup_dbg(str, _NORMAL_BLOCK, git_win32__crtdbg_stacktrace(1,file), line);
 	if (!ptr) giterr_set_oom();
 	return ptr;
 }
@@ -118,7 +123,7 @@ GIT_INLINE(char *) git__crtdbg__substrdup(const char *start, size_t n, const cha
 
 GIT_INLINE(void *) git__crtdbg__realloc(void *ptr, size_t size, const char *file, int line)
 {
-	void *new_ptr = _realloc_dbg(ptr, size, _NORMAL_BLOCK, file, line);
+	void *new_ptr = _realloc_dbg(ptr, size, _NORMAL_BLOCK, git_win32__crtdbg_stacktrace(1,file), line);
 	if (!new_ptr) giterr_set_oom();
 	return new_ptr;
 }
@@ -126,8 +131,9 @@ GIT_INLINE(void *) git__crtdbg__realloc(void *ptr, size_t size, const char *file
 GIT_INLINE(void *) git__crtdbg__reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line)
 {
 	size_t newsize;
+
 	return GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize) ?
-		NULL : _realloc_dbg(ptr, newsize, _NORMAL_BLOCK, file, line);
+		NULL : _realloc_dbg(ptr, newsize, _NORMAL_BLOCK, git_win32__crtdbg_stacktrace(1,file), line);
 }
 
 GIT_INLINE(void *) git__crtdbg__mallocarray(size_t nelem, size_t elsize, const char *file, int line)
@@ -596,4 +602,6 @@ GIT_INLINE(double) git__timer(void)
 
 #endif
 
+extern int git__getenv(git_buf *out, const char *name);
+
 #endif /* INCLUDE_util_h__ */

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

@@ -11,6 +11,8 @@
 #include "utf-conv.h"
 #include "repository.h"
 #include "reparse.h"
+#include "global.h"
+#include "buffer.h"
 #include <errno.h>
 #include <io.h>
 #include <fcntl.h>

data/vendor/libgit2/src/win32/{buffer.c → w32_buffer.c}

@@ -6,7 +6,7 @@
  */
 
 #include "common.h"
-#include "buffer.h"
+#include "w32_buffer.h"
 #include "../buffer.h"
 #include "utf-conv.h"
 
@@ -52,4 +52,3 @@ int git_buf_put_w(git_buf *buf, const wchar_t *string_w, size_t len_w)
 	buf->ptr[buf->size] = '\0';
 	return 0;
 }
-

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

@@ -0,0 +1,343 @@
+/*
+ * 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.
+ */
+
+#if defined(GIT_MSVC_CRTDBG)
+#include "w32_stack.h"
+#include "w32_crtdbg_stacktrace.h"
+
+#define CRTDBG_STACKTRACE__UID_LEN (15)
+
+/**
+ * The stacktrace of an allocation can be distilled
+ * to a unique id based upon the stackframe pointers
+ * and ignoring any size arguments. We will use these
+ * UIDs as the (char const*) __FILE__ argument we
+ * give to the CRT malloc routines.
+ */
+typedef struct {
+	char uid[CRTDBG_STACKTRACE__UID_LEN + 1];
+} git_win32__crtdbg_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;
+	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;
+
+static CRITICAL_SECTION g_crtdbg_stacktrace_cs;
+
+/**
+ * CRTDBG memory leak tracking takes a "char const * const file_name"
+ * and stores the pointer in the heap data (instead of allocing a copy
+ * for itself).  Normally, this is not a problem, since we usually pass
+ * in __FILE__.  But I'm going to lie to it and pass in the address of
+ * the UID in place of the file_name.  Also, I do not want to alloc the
+ * stacktrace data (because we are called from inside our alloc routines).
+ * Therefore, I'm creating a very large static pool array to store row
+ * data. This also eliminates the temptation to realloc it (and move the
+ * UID pointers).
+ *
+ * And to efficiently look for duplicates we need an index on the rows
+ * so we can bsearch it.  Again, without mallocing.
+ *
+ * If we observe more than MY_ROW_LIMIT unique malloc signatures, we
+ * fall through and use the traditional __FILE__ processing and don't
+ * try to de-dup them.  If your testing hits this limit, just increase
+ * 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];
+
+static unsigned int g_cs_end = MY_ROW_LIMIT;
+static unsigned int g_cs_ins = 0; /* insertion point == unique allocs seen */
+static unsigned int g_count_total_allocs = 0; /* number of allocs seen */
+static unsigned int g_transient_count_total_leaks = 0; /* number of total leaks */
+static unsigned int g_transient_count_dedup_leaks = 0; /* number of unique leaks */
+static bool g_limit_reached = false; /* had allocs after we filled row table */
+
+static unsigned int g_checkpoint_id = 0; /* to better label leak checkpoints */
+static bool g_transient_leaks_since_mark = false; /* payload for hook */
+
+/**
+ * Compare function for bsearch on g_cs_index table.
+ */
+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;
+
+	return (git_win32__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)
+{
+	size_t pos;
+	if (git__bsearch(g_cs_index, g_cs_ins, pdata, row_cmp, &pos) < 0) {
+		/* Append new unique item to row table. */
+		memcpy(&g_cs_rows[g_cs_ins].raw_data, pdata, sizeof(*pdata));
+		sprintf(g_cs_rows[g_cs_ins].uid.uid, "##%08lx", g_cs_ins);
+
+		/* Insert pointer to it into the proper place in the index table. */
+		if (pos < g_cs_ins)
+			memmove(&g_cs_index[pos+1], &g_cs_index[pos], (g_cs_ins - pos)*sizeof(g_cs_index[0]));
+		g_cs_index[pos] = &g_cs_rows[g_cs_ins];
+
+		g_cs_ins++;
+	}
+
+	g_cs_index[pos]->count_allocs++;
+
+	return g_cs_index[pos];
+}
+
+/**
+ * Hook function to receive leak data from the CRT. (This includes
+ * both "<file_name>:(<line_number>)" data, but also each of the
+ * various headers and fields.
+ *
+ * Scan this for the special "##<pos>" UID forms that we substituted
+ * for the "<file_name>".  Map <pos> back to the row data and
+ * increment its leak count.
+ *
+ * See https://msdn.microsoft.com/en-us/library/74kabxyx.aspx
+ *
+ * We suppress the actual crtdbg output.
+ */
+static int __cdecl report_hook(int nRptType, char *szMsg, int *retVal)
+{
+	static int hook_result = TRUE; /* FALSE to get stock dump; TRUE to suppress. */
+	unsigned int pos;
+
+	*retVal = 0; /* do not invoke debugger */
+
+	if ((szMsg[0] != '#') || (szMsg[1] != '#'))
+		return hook_result;
+
+	if (sscanf(&szMsg[2], "%08lx", &pos) < 1)
+		return hook_result;
+	if (pos >= g_cs_ins)
+		return hook_result;
+
+	if (g_transient_leaks_since_mark) {
+		if (g_cs_rows[pos].count_allocs == g_cs_rows[pos].count_allocs_at_last_checkpoint)
+			return hook_result;
+	}
+
+	g_cs_rows[pos].transient_count_leaks++;
+
+	if (g_cs_rows[pos].transient_count_leaks == 1)
+		g_transient_count_dedup_leaks++;
+
+	g_transient_count_total_leaks++;
+
+	return hook_result;
+}
+
+/**
+ * Write leak data to all of the various places we need.
+ * We force the caller to sprintf() the message first
+ * because we want to avoid fprintf() because it allocs.
+ */
+static void my_output(const char *buf)
+{
+	fwrite(buf, strlen(buf), 1, stderr);
+	OutputDebugString(buf);
+}
+
+/**
+ * For each row with leaks, dump a stacktrace for it.
+ */
+static void dump_summary(const char *label)
+{
+	unsigned int k;
+	char buf[10 * 1024];
+
+	if (g_transient_count_total_leaks == 0)
+		return;
+
+	fflush(stdout);
+	fflush(stderr);
+	my_output("\n");
+
+	if (g_limit_reached) {
+		sprintf(buf,
+				"LEAK SUMMARY: de-dup row table[%d] filled. Increase MY_ROW_LIMIT.\n",
+				MY_ROW_LIMIT);
+		my_output(buf);
+	}
+
+	if (!label)
+		label = "";
+
+	if (g_transient_leaks_since_mark) {
+		sprintf(buf, "LEAK CHECKPOINT %d: leaks %d unique %d: %s\n",
+				g_checkpoint_id, g_transient_count_total_leaks, g_transient_count_dedup_leaks, label);
+		my_output(buf);
+	} else {
+		sprintf(buf, "LEAK SUMMARY: TOTAL leaks %d de-duped %d: %s\n",
+				g_transient_count_total_leaks, g_transient_count_dedup_leaks, label);
+		my_output(buf);
+	}
+	my_output("\n");
+
+	for (k = 0; k < g_cs_ins; k++) {
+		if (g_cs_rows[k].transient_count_leaks > 0) {
+			sprintf(buf, "LEAK: %s leaked %d of %d times:\n",
+					g_cs_rows[k].uid.uid,
+					g_cs_rows[k].transient_count_leaks,
+					g_cs_rows[k].count_allocs);
+			my_output(buf);
+
+			if (git_win32__stack_format(
+					buf, sizeof(buf), &g_cs_rows[k].raw_data,
+					NULL, NULL) >= 0) {
+				my_output(buf);
+			}
+
+			my_output("\n");
+		}
+	}
+
+	fflush(stderr);
+}
+
+void git_win32__crtdbg_stacktrace_init(void)
+{
+	InitializeCriticalSection(&g_crtdbg_stacktrace_cs);
+
+	EnterCriticalSection(&g_crtdbg_stacktrace_cs);
+
+	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
+
+	_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
+	_CrtSetReportMode(_CRT_ERROR,  _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
+	_CrtSetReportMode(_CRT_WARN,   _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
+
+	_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
+	_CrtSetReportFile(_CRT_ERROR,  _CRTDBG_FILE_STDERR);
+	_CrtSetReportFile(_CRT_WARN,   _CRTDBG_FILE_STDERR);
+
+	LeaveCriticalSection(&g_crtdbg_stacktrace_cs);
+}
+
+int git_win32__crtdbg_stacktrace__dump(
+	git_win32__crtdbg_stacktrace_options opt,
+	const char *label)
+{
+	_CRT_REPORT_HOOK old;
+	unsigned int k;
+	int r = 0;
+
+#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);
+
+	if (b_leaks_since_mark && b_leaks_total) {
+		giterr_set(GITERR_INVALID, "Cannot combine LEAKS_SINCE_MARK and LEAKS_TOTAL.");
+		return GIT_ERROR;
+	}
+	if (!b_set_mark && !b_leaks_since_mark && !b_leaks_total) {
+		giterr_set(GITERR_INVALID, "Nothing to do.");
+		return GIT_ERROR;
+	}
+
+	EnterCriticalSection(&g_crtdbg_stacktrace_cs);
+
+	if (b_leaks_since_mark || b_leaks_total) {
+		/* All variables with "transient" in the name are per-dump counters
+		 * and reset before each dump.  This lets us handle checkpoints.
+		 */
+		g_transient_count_total_leaks = 0;
+		g_transient_count_dedup_leaks = 0;
+		for (k = 0; k < g_cs_ins; k++) {
+			g_cs_rows[k].transient_count_leaks = 0;
+		}
+	}
+
+	g_transient_leaks_since_mark = b_leaks_since_mark;
+
+	old = _CrtSetReportHook(report_hook);
+	_CrtDumpMemoryLeaks();
+	_CrtSetReportHook(old);
+
+	if (b_leaks_since_mark || b_leaks_total) {
+		r = g_transient_count_dedup_leaks;
+
+		if (!b_quiet)
+			dump_summary(label);
+	}
+
+	if (b_set_mark) {
+		for (k = 0; k < g_cs_ins; k++) {
+			g_cs_rows[k].count_allocs_at_last_checkpoint = g_cs_rows[k].count_allocs;
+		}
+
+		g_checkpoint_id++;
+	}
+
+	LeaveCriticalSection(&g_crtdbg_stacktrace_cs);
+
+	return r;
+}
+
+void git_win32__crtdbg_stacktrace_cleanup(void)
+{
+	/* At shutdown/cleanup, dump cummulative 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,
+		"CLEANUP");
+
+	DeleteCriticalSection(&g_crtdbg_stacktrace_cs);
+}
+
+const char *git_win32__crtdbg_stacktrace(int skip, const char *file)
+{
+	git_win32__stack__raw_data new_data;
+	git_win32__crtdbg_stacktrace__row *row;
+	const char * result = file;
+
+	if (git_win32__stack_capture(&new_data, skip+1) < 0)
+		return result;
+
+	EnterCriticalSection(&g_crtdbg_stacktrace_cs);
+
+	if (g_cs_ins < g_cs_end) {
+		row = insert_unique(&new_data);
+		result = row->uid.uid;
+	} else {
+		g_limit_reached = true;
+	}
+
+	g_count_total_allocs++;
+
+	LeaveCriticalSection(&g_crtdbg_stacktrace_cs);
+
+	return result;
+}
+#endif