1222 lines
22 KiB
C++
1222 lines
22 KiB
C++
//+--------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1996 - 1999
|
|
//
|
|
// File: alloc.cpp
|
|
//
|
|
// Contents: Cert Server debug implementation
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
#include "pch.cpp"
|
|
|
|
#pragma hdrstop
|
|
|
|
#include <assert.h>
|
|
|
|
#define __dwFILE__ __dwFILE_CERTCLIB_ALLOC_CPP__
|
|
|
|
|
|
#if DBG_CERTSRV
|
|
|
|
#undef FormatMessageW
|
|
#undef LocalAlloc
|
|
#undef LocalReAlloc
|
|
#undef LocalFree
|
|
|
|
#undef CoTaskMemAlloc
|
|
#undef CoTaskMemRealloc
|
|
#undef CoTaskMemFree
|
|
|
|
#undef StringFromCLSID
|
|
#undef StringFromIID
|
|
|
|
#undef SysAllocString
|
|
#undef SysReAllocString
|
|
#undef SysAllocStringLen
|
|
#undef SysReAllocStringLen
|
|
#undef SysFreeString
|
|
#undef SysAllocStringByteLen
|
|
#undef PropVariantClear
|
|
#undef VariantClear
|
|
#undef VariantChangeType
|
|
#undef VariantChangeTypeEx
|
|
|
|
|
|
DWORD g_MemTrack = 0;
|
|
|
|
#define MTF_UNREGISTERED 0x00000002
|
|
#define MTF_ALLOCTRACE 0x00000004
|
|
#define MTF_FREETRACE 0x00000008
|
|
#define MTF_STACKTRACE 0x00000010
|
|
|
|
typedef struct _RMALLOC
|
|
{
|
|
LONG cAlloc;
|
|
LONG cAllocTotal;
|
|
} RMALLOC;
|
|
|
|
RMALLOC g_armAlloc[CSM_MAX];
|
|
|
|
#define C_BP_FRAME 16
|
|
#define C_BACK_TRACE_CHUNK 100
|
|
#define C_MEM_HEADER_CHUNK 100
|
|
|
|
typedef struct _BACKTRACE
|
|
{
|
|
LONG cAlloc; // count of outstanding allocations
|
|
LONG cAllocTotal; // count of total allocations
|
|
LONG cbAlloc; // size of outstanding allocations
|
|
LONG cbAllocTotal; // size of total allocations
|
|
ULONG apCaller[C_BP_FRAME]; // stack trace
|
|
} BACKTRACE;
|
|
|
|
typedef struct _MEMHEADER
|
|
{
|
|
DWORD iBackTrace; // backtrace index
|
|
VOID const *pvMemory; // Pointer to memory block allocated
|
|
LONG cbMemory; // Size of memory block allocated
|
|
DWORD Flags; // Allocator flags
|
|
} MEMHEADER;
|
|
|
|
|
|
// critical section around myRegister APIs since they
|
|
// operate on global data structures
|
|
CRITICAL_SECTION g_critsecRegisterMemory;
|
|
BOOL g_fRegisterMemoryCritSecInit = FALSE;
|
|
|
|
|
|
|
|
VOID
|
|
RegisterMemoryEnterCriticalSection(VOID)
|
|
{
|
|
HRESULT hr;
|
|
|
|
__try
|
|
{
|
|
if (!g_fRegisterMemoryCritSecInit)
|
|
{
|
|
InitializeCriticalSection(&g_critsecRegisterMemory);
|
|
g_fRegisterMemoryCritSecInit = TRUE;
|
|
}
|
|
EnterCriticalSection(&g_critsecRegisterMemory);
|
|
}
|
|
__except(hr = myHEXCEPTIONCODE(), EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
RegisterMemoryLeaveCriticalSection(VOID)
|
|
{
|
|
if (g_fRegisterMemoryCritSecInit)
|
|
{
|
|
LeaveCriticalSection(&g_critsecRegisterMemory);
|
|
}
|
|
}
|
|
|
|
|
|
BACKTRACE *g_rgbt = NULL;
|
|
DWORD g_cbtMax = 0;
|
|
DWORD g_cbt = 0;
|
|
|
|
MEMHEADER *g_rgmh = NULL;
|
|
DWORD g_cmhMax = 0;
|
|
DWORD g_cmh = 0;
|
|
|
|
|
|
MEMHEADER *
|
|
AllocMemHeader()
|
|
{
|
|
if (g_cmh >= g_cmhMax)
|
|
{
|
|
DWORD cb = (C_MEM_HEADER_CHUNK + g_cmhMax) * sizeof(g_rgmh[0]);
|
|
MEMHEADER *rgmhT;
|
|
|
|
if (NULL == g_rgmh)
|
|
{
|
|
rgmhT = (MEMHEADER *) LocalAlloc(LMEM_FIXED, cb);
|
|
}
|
|
else
|
|
{
|
|
rgmhT = (MEMHEADER *) LocalReAlloc(g_rgmh, cb, LMEM_MOVEABLE);
|
|
}
|
|
if (NULL == rgmhT)
|
|
{
|
|
DBGPRINT((
|
|
DBG_SS_CERTLIB,
|
|
"Error allocating memtrack header\n"));
|
|
return(NULL);
|
|
}
|
|
g_rgmh = rgmhT;
|
|
g_cmhMax += C_MEM_HEADER_CHUNK;
|
|
}
|
|
return(&g_rgmh[g_cmh++]);
|
|
}
|
|
|
|
|
|
MEMHEADER *
|
|
LookupMemHeader(
|
|
IN VOID const *pv)
|
|
{
|
|
MEMHEADER *pmh;
|
|
MEMHEADER *pmhEnd;
|
|
|
|
pmh = g_rgmh;
|
|
pmhEnd = &g_rgmh[g_cmh];
|
|
|
|
while (pmh < pmhEnd)
|
|
{
|
|
if (pv == pmh->pvMemory)
|
|
{
|
|
return(pmh);
|
|
}
|
|
pmh++;
|
|
}
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
VOID
|
|
FreeMemHeader(
|
|
IN MEMHEADER *pmh)
|
|
{
|
|
MEMHEADER *pmhLast;
|
|
|
|
assert(1 <= g_cmh);
|
|
pmhLast = &g_rgmh[g_cmh - 1];
|
|
|
|
*pmh = *pmhLast;
|
|
g_cmh--;
|
|
}
|
|
|
|
|
|
BACKTRACE *
|
|
AllocBackTrace(
|
|
OUT DWORD *pibt)
|
|
{
|
|
if (g_cbt >= g_cbtMax)
|
|
{
|
|
DWORD cb = (C_BACK_TRACE_CHUNK + g_cbtMax) * sizeof(g_rgbt[0]);
|
|
BACKTRACE *rgbtT;
|
|
|
|
if (NULL == g_rgbt)
|
|
{
|
|
rgbtT = (BACKTRACE *) LocalAlloc(LMEM_FIXED, cb);
|
|
}
|
|
else
|
|
{
|
|
rgbtT = (BACKTRACE *) LocalReAlloc(g_rgbt, cb, LMEM_MOVEABLE);
|
|
DBGPRINT((
|
|
DBG_SS_CERTLIB,
|
|
"Realloc'd memtrack backtrace from %x to %x\n",
|
|
g_rgbt,
|
|
rgbtT));
|
|
}
|
|
if (NULL == rgbtT)
|
|
{
|
|
DBGPRINT((
|
|
DBG_SS_CERTLIB,
|
|
"Error allocating memtrack backtrace\n"));
|
|
return(NULL);
|
|
}
|
|
g_rgbt = rgbtT;
|
|
g_cbtMax += C_BACK_TRACE_CHUNK;
|
|
}
|
|
*pibt = g_cbt + 1;
|
|
return(&g_rgbt[g_cbt++]);
|
|
}
|
|
|
|
|
|
BACKTRACE *
|
|
LookupBackTrace(
|
|
IN BACKTRACE *pbtIn,
|
|
OUT DWORD *pibt)
|
|
{
|
|
BACKTRACE *pbt;
|
|
BACKTRACE *pbtEnd;
|
|
|
|
pbt = g_rgbt;
|
|
pbtEnd = &g_rgbt[g_cbt];
|
|
|
|
while (pbt < pbtEnd)
|
|
{
|
|
if (0 == memcmp(pbt->apCaller, pbtIn->apCaller, sizeof(pbt->apCaller)))
|
|
{
|
|
*pibt = SAFE_SUBTRACT_POINTERS(pbt, g_rgbt) + 1;
|
|
return(pbt);
|
|
}
|
|
pbt++;
|
|
}
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
BACKTRACE *
|
|
BackTraceFromIndex(
|
|
IN DWORD ibt)
|
|
{
|
|
BACKTRACE *pbt = NULL;
|
|
|
|
if (0 == ibt)
|
|
{
|
|
DBGPRINT((DBG_SS_CERTLIB, "BackTraceFromIndex(0)\n"));
|
|
}
|
|
else if (g_cbt < ibt)
|
|
{
|
|
DBGPRINT((
|
|
DBG_SS_CERTLIB,
|
|
"BackTraceFromIndex(%u) -- out of range\n",
|
|
ibt));
|
|
}
|
|
else
|
|
{
|
|
pbt = &g_rgbt[ibt - 1];
|
|
}
|
|
return(pbt);
|
|
}
|
|
|
|
|
|
VOID
|
|
ReadEnvironmentFlags(VOID)
|
|
{
|
|
HRESULT hr;
|
|
DWORD MemTrack;
|
|
DWORD cb;
|
|
DWORD dwDisposition;
|
|
DWORD dwType;
|
|
HKEY hkey = NULL;
|
|
char *pszEnvVar;
|
|
|
|
pszEnvVar = getenv(szCERTSRV_MEMTRACK);
|
|
if (NULL != pszEnvVar)
|
|
{
|
|
g_MemTrack = (DWORD) strtol(pszEnvVar, NULL, 16);
|
|
}
|
|
else
|
|
{
|
|
hr = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
wszREGKEYCONFIGPATH,
|
|
0,
|
|
KEY_READ,
|
|
&hkey);
|
|
if (S_OK == hr)
|
|
{
|
|
cb = sizeof(MemTrack);
|
|
hr = RegQueryValueEx(
|
|
hkey,
|
|
wszREGCERTSRVMEMTRACK,
|
|
0,
|
|
&dwType,
|
|
(BYTE *) &MemTrack,
|
|
&cb);
|
|
if (S_OK == hr && REG_DWORD == dwType && sizeof(MemTrack) == cb)
|
|
{
|
|
g_MemTrack = MemTrack;
|
|
}
|
|
}
|
|
}
|
|
|
|
//error:
|
|
if (NULL != hkey)
|
|
{
|
|
RegCloseKey(hkey);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
CaptureStackBackTrace(
|
|
EXCEPTION_POINTERS *pep,
|
|
ULONG cSkip,
|
|
ULONG cFrames,
|
|
ULONG *aeip)
|
|
{
|
|
ZeroMemory(aeip, cFrames * sizeof(aeip[0]));
|
|
|
|
#if i386 == 1
|
|
ULONG ieip, *pebp;
|
|
ULONG *pebpMax = (ULONG *) MAXLONG; // 2 * 1024 * 1024 * 1024; // 2 gig - 1
|
|
ULONG *pebpMin = (ULONG *) (64 * 1024); // 64k
|
|
|
|
if (pep == NULL)
|
|
{
|
|
ieip = 0;
|
|
cSkip++; // always skip current frame
|
|
pebp = ((ULONG *) &pep) - 2;
|
|
}
|
|
else
|
|
{
|
|
ieip = 1;
|
|
assert(cSkip == 0);
|
|
aeip[0] = pep->ContextRecord->Eip;
|
|
pebp = (ULONG *) pep->ContextRecord->Ebp;
|
|
}
|
|
if (pebp >= pebpMin && pebp < pebpMax)
|
|
{
|
|
__try
|
|
{
|
|
for ( ; ieip < cSkip + cFrames; ieip++)
|
|
{
|
|
if (ieip >= cSkip)
|
|
{
|
|
aeip[ieip - cSkip] = *(pebp + 1); // save an eip
|
|
}
|
|
|
|
ULONG *pebpNext = (ULONG *) *pebp;
|
|
if (pebpNext < pebp + 2 ||
|
|
pebpNext >= pebpMax - 1 ||
|
|
pebpNext >= pebp + (256 * 1024) / sizeof(pebp[0]))
|
|
{
|
|
break;
|
|
}
|
|
pebp = pebpNext;
|
|
}
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
;
|
|
}
|
|
}
|
|
#endif // i386 == 1
|
|
}
|
|
|
|
|
|
WCHAR const *
|
|
wszAllocator(
|
|
IN DWORD Flags)
|
|
{
|
|
WCHAR const *pwsz;
|
|
|
|
switch (Flags)
|
|
{
|
|
case CSM_LOCALALLOC: pwsz = L"LocalAlloc"; break;
|
|
case CSM_COTASKALLOC: pwsz = L"CoTaskMemAlloc"; break;
|
|
case CSM_SYSALLOC: pwsz = L"SysAllocString"; break;
|
|
case CSM_MALLOC: pwsz = L"malloc"; break;
|
|
case CSM_NEW: pwsz = L"new"; break;
|
|
case CSM_NEW | CSM_GLOBALDESTRUCTOR:
|
|
pwsz = L"new-global"; break;
|
|
default: pwsz = L"???"; break;
|
|
}
|
|
return(pwsz);
|
|
}
|
|
|
|
|
|
WCHAR const *
|
|
wszFreeer(
|
|
IN DWORD Flags)
|
|
{
|
|
WCHAR const *pwsz;
|
|
|
|
switch (Flags)
|
|
{
|
|
case CSM_LOCALALLOC: pwsz = L"LocalFree"; break;
|
|
case CSM_COTASKALLOC: pwsz = L"CoTaskMemFree"; break;
|
|
case CSM_SYSALLOC: pwsz = L"SysFreeString"; break;
|
|
case CSM_MALLOC: pwsz = L"free"; break;
|
|
case CSM_NEW: pwsz = L"delete"; break;
|
|
case CSM_NEW | CSM_GLOBALDESTRUCTOR:
|
|
pwsz = L"delete-global"; break;
|
|
default: pwsz = L"???"; break;
|
|
}
|
|
return(pwsz);
|
|
}
|
|
|
|
|
|
VOID
|
|
DumpMemBlock(
|
|
IN WCHAR const *pwsz,
|
|
IN VOID const *pvMemory,
|
|
IN DWORD cbMemory,
|
|
IN DWORD Flags,
|
|
IN DWORD ibt,
|
|
OPTIONAL IN BACKTRACE const *pbt)
|
|
{
|
|
DBGPRINT((
|
|
DBG_SS_CERTLIB,
|
|
"%ws%wspv=%-6x cb=%-4x f=%x(%ws) pbt[%d]=%x:\n",
|
|
pwsz,
|
|
L'\0' != *pwsz? L": " : L"",
|
|
pvMemory,
|
|
cbMemory,
|
|
Flags,
|
|
wszAllocator(Flags),
|
|
ibt,
|
|
pbt));
|
|
|
|
if (NULL != pbt && DbgIsSSActive(DBG_SS_CERTLIB))
|
|
{
|
|
DBGPRINT((MAXDWORD, "%d: ", ibt));
|
|
|
|
for (int i = 0; i < ARRAYSIZE(pbt->apCaller); i++)
|
|
{
|
|
if (NULL == pbt->apCaller[i])
|
|
{
|
|
break;
|
|
}
|
|
DBGPRINT((MAXDWORD, "ln %x;", pbt->apCaller[i]));
|
|
}
|
|
DBGPRINT((MAXDWORD, "\n"));
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
myRegisterMemDump()
|
|
{
|
|
MEMHEADER *pmh;
|
|
MEMHEADER *pmhEnd;
|
|
LONG cTotal;
|
|
LONG cbTotal;
|
|
|
|
cTotal = 0;
|
|
cbTotal = 0;
|
|
|
|
RegisterMemoryEnterCriticalSection();
|
|
|
|
__try
|
|
{
|
|
pmh = g_rgmh;
|
|
pmhEnd = &g_rgmh[g_cmh];
|
|
|
|
while (pmh < pmhEnd)
|
|
{
|
|
if (0 == (CSM_GLOBALDESTRUCTOR & pmh->Flags) ||
|
|
(MTF_ALLOCTRACE & g_MemTrack))
|
|
{
|
|
if (0 == cTotal)
|
|
{
|
|
if (DbgIsSSActive(DBG_SS_CERTLIB))
|
|
{
|
|
DBGPRINT((MAXDWORD, "\n"));
|
|
}
|
|
DBGPRINT((DBG_SS_CERTLIB, "Allocated Memory Blocks:\n"));
|
|
}
|
|
cTotal++;
|
|
cbTotal += pmh->cbMemory;
|
|
|
|
DumpMemBlock(
|
|
L"",
|
|
pmh->pvMemory,
|
|
pmh->cbMemory,
|
|
pmh->Flags,
|
|
pmh->iBackTrace,
|
|
BackTraceFromIndex(pmh->iBackTrace));
|
|
}
|
|
pmh++;
|
|
}
|
|
if (0 != cTotal)
|
|
{
|
|
DBGPRINT((DBG_SS_CERTLIB, "Total: c=%x cb=%x\n\n", cTotal, cbTotal));
|
|
}
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
}
|
|
|
|
RegisterMemoryLeaveCriticalSection();
|
|
}
|
|
|
|
|
|
VOID *
|
|
_VariantMemory(
|
|
IN PROPVARIANT const *pvar,
|
|
OUT DWORD *pFlags,
|
|
OPTIONAL OUT DWORD *pcb)
|
|
{
|
|
VOID *pv = NULL;
|
|
DWORD cb = 0;
|
|
BOOL fString = FALSE;
|
|
|
|
*pFlags = CSM_COTASKALLOC;
|
|
if (NULL != pcb)
|
|
{
|
|
*pcb = 0;
|
|
}
|
|
switch (pvar->vt)
|
|
{
|
|
case VT_BSTR:
|
|
pv = pvar->bstrVal;
|
|
fString = TRUE;
|
|
*pFlags = CSM_SYSALLOC;
|
|
break;
|
|
|
|
case VT_BYREF | VT_BSTR:
|
|
pv = *pvar->pbstrVal;
|
|
fString = TRUE;
|
|
*pFlags = CSM_SYSALLOC;
|
|
break;
|
|
|
|
case VT_LPWSTR:
|
|
pv = pvar->pwszVal;
|
|
fString = TRUE;
|
|
break;
|
|
|
|
case VT_BLOB:
|
|
pv = pvar->blob.pBlobData;
|
|
cb = pvar->blob.cbSize;
|
|
break;
|
|
}
|
|
if (NULL != pcb)
|
|
{
|
|
if (fString)
|
|
{
|
|
cb = (wcslen((WCHAR const *) pv) + 1) * sizeof(WCHAR);
|
|
}
|
|
*pcb = cb;
|
|
}
|
|
return(pv);
|
|
}
|
|
|
|
|
|
VOID
|
|
myRegisterMemAlloc(
|
|
IN VOID const *pv,
|
|
IN LONG cb,
|
|
IN DWORD Flags)
|
|
{
|
|
BACKTRACE bt;
|
|
MEMHEADER *pmh;
|
|
BACKTRACE *pbt;
|
|
|
|
if (CSM_VARIANT == Flags)
|
|
{
|
|
pv = _VariantMemory((PROPVARIANT const *) pv, &Flags, (DWORD *) &cb);
|
|
if (NULL == pv)
|
|
{
|
|
return; // nothing to register
|
|
}
|
|
}
|
|
RegisterMemoryEnterCriticalSection();
|
|
|
|
__try
|
|
{
|
|
static BOOL s_fFirst = TRUE;
|
|
|
|
if (s_fFirst)
|
|
{
|
|
ReadEnvironmentFlags();
|
|
s_fFirst = FALSE;
|
|
}
|
|
if (0 != g_MemTrack)
|
|
{
|
|
// Do not register NULL as an allocation
|
|
CSASSERT(NULL != pv);
|
|
|
|
// see if we already have a reference to this memory
|
|
|
|
pmh = LookupMemHeader(pv);
|
|
if (NULL != pmh)
|
|
{
|
|
DBGPRINT((
|
|
DBG_SS_CERTLIB,
|
|
"Memory Leak: Tracked memory address reused. Previously allocated:\n"));
|
|
DumpMemBlock(
|
|
L"Memory leak",
|
|
pv,
|
|
pmh->cbMemory,
|
|
pmh->Flags,
|
|
pmh->iBackTrace,
|
|
BackTraceFromIndex(pmh->iBackTrace));
|
|
|
|
CSASSERT(!"Tracked memory address reused");
|
|
FreeMemHeader(pmh);
|
|
}
|
|
|
|
|
|
pmh = AllocMemHeader();
|
|
if (NULL != pmh)
|
|
{
|
|
DWORD ibt;
|
|
|
|
CaptureStackBackTrace(NULL, 0, C_BP_FRAME, bt.apCaller);
|
|
|
|
pbt = LookupBackTrace(&bt, &ibt);
|
|
if (NULL != pbt)
|
|
{
|
|
pbt->cAlloc++;
|
|
pbt->cAllocTotal++;
|
|
pbt->cbAlloc += cb;
|
|
pbt->cbAllocTotal += cb;
|
|
}
|
|
else
|
|
{
|
|
pbt = AllocBackTrace(&ibt);
|
|
if (NULL != pbt)
|
|
{
|
|
pbt->cAlloc = 1;
|
|
pbt->cAllocTotal = 1;
|
|
pbt->cbAlloc = cb;
|
|
pbt->cbAllocTotal = cb;
|
|
CopyMemory(pbt->apCaller, bt.apCaller, sizeof(pbt->apCaller));
|
|
}
|
|
}
|
|
if (NULL != pbt)
|
|
{
|
|
pmh->iBackTrace = ibt;
|
|
pmh->pvMemory = pv;
|
|
pmh->cbMemory = cb;
|
|
pmh->Flags = Flags;
|
|
|
|
CSASSERT(ARRAYSIZE(g_armAlloc) > Flags);
|
|
g_armAlloc[Flags].cAlloc++;
|
|
g_armAlloc[Flags].cAllocTotal++;
|
|
if (MTF_ALLOCTRACE & g_MemTrack)
|
|
{
|
|
DBGPRINT((
|
|
DBG_SS_CERTLIB,
|
|
"Alloc: pmh=%x: pv=%x cb=%x f=%x(%ws) -- pbt[%d]=%x: c=%x, cb=%x\n",
|
|
pmh,
|
|
pmh->pvMemory,
|
|
pmh->cbMemory,
|
|
pmh->Flags,
|
|
wszAllocator(pmh->Flags),
|
|
SAFE_SUBTRACT_POINTERS(pbt, g_rgbt),
|
|
pbt,
|
|
pbt->cAlloc,
|
|
pbt->cbAlloc));
|
|
if (MTF_STACKTRACE & g_MemTrack)
|
|
{
|
|
DumpMemBlock(
|
|
L"Alloc Trace memory block",
|
|
pv,
|
|
pmh->cbMemory, // cbMemory
|
|
pmh->Flags, // Flags
|
|
pmh->iBackTrace, // ibt
|
|
pbt);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FreeMemHeader(pmh);
|
|
}
|
|
} // if no problem allocating pmh
|
|
} // if g_MemTrack
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
}
|
|
|
|
RegisterMemoryLeaveCriticalSection();
|
|
}
|
|
|
|
|
|
VOID
|
|
myRegisterMemFree(
|
|
IN VOID const *pv,
|
|
IN DWORD Flags)
|
|
{
|
|
MEMHEADER *pmh;
|
|
|
|
if (CSM_VARIANT == Flags)
|
|
{
|
|
pv = _VariantMemory((PROPVARIANT const *) pv, &Flags, NULL);
|
|
if (NULL == pv)
|
|
{
|
|
return; // nothing to register
|
|
}
|
|
}
|
|
RegisterMemoryEnterCriticalSection();
|
|
CSASSERT(CSM_MAX > (~CSM_GLOBALDESTRUCTOR & Flags));
|
|
|
|
__try
|
|
{
|
|
pmh = LookupMemHeader(pv);
|
|
if (NULL != pmh)
|
|
{
|
|
BACKTRACE *pbt = BackTraceFromIndex(pmh->iBackTrace);
|
|
|
|
if (CSM_GLOBALDESTRUCTOR & Flags)
|
|
{
|
|
if ((CSM_GLOBALDESTRUCTOR | pmh->Flags) != Flags)
|
|
{
|
|
BACKTRACE bt;
|
|
|
|
CaptureStackBackTrace(NULL, 0, C_BP_FRAME, bt.apCaller);
|
|
DumpMemBlock(
|
|
L"Wrong memory allocator for global destructor",
|
|
pv,
|
|
MAXDWORD, // cbMemory
|
|
MAXDWORD, // Flags
|
|
MAXDWORD, // ibt
|
|
&bt);
|
|
CSASSERT(!"Wrong memory allocator for global destructor");
|
|
}
|
|
else
|
|
{
|
|
pmh->Flags |= CSM_GLOBALDESTRUCTOR;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_armAlloc[Flags].cAlloc--;
|
|
|
|
pbt->cAlloc--;
|
|
pbt->cbAlloc -= pmh->cbMemory;
|
|
|
|
if (CSM_GLOBALDESTRUCTOR & pmh->Flags)
|
|
{
|
|
Flags |= CSM_GLOBALDESTRUCTOR;
|
|
}
|
|
if (pmh->Flags != Flags)
|
|
{
|
|
DBGPRINT((
|
|
DBG_SS_CERTLIB,
|
|
"Wrong memory allocator: Freed with %ws, Allocated by %ws\n",
|
|
wszFreeer(Flags),
|
|
wszAllocator(pmh->Flags)));
|
|
DumpMemBlock(
|
|
L"Wrong memory allocator",
|
|
pv,
|
|
pmh->cbMemory,
|
|
pmh->Flags,
|
|
pmh->iBackTrace,
|
|
BackTraceFromIndex(pmh->iBackTrace));
|
|
CSASSERT(pmh->Flags == Flags);
|
|
}
|
|
else if (MTF_FREETRACE & g_MemTrack)
|
|
{
|
|
DBGPRINT((
|
|
DBG_SS_CERTLIB,
|
|
"Free: pmh=%x: pv=%x cb=%x f=%x(%ws) -- pbt[%d]=%x: c=%x, cb=%x\n",
|
|
pmh,
|
|
pv,
|
|
pmh->cbMemory,
|
|
pmh->Flags,
|
|
wszAllocator(pmh->Flags),
|
|
pmh->iBackTrace,
|
|
pbt,
|
|
pbt->cAlloc,
|
|
pbt->cbAlloc));
|
|
if (MTF_STACKTRACE & g_MemTrack)
|
|
{
|
|
BACKTRACE bt;
|
|
|
|
CaptureStackBackTrace(NULL, 0, C_BP_FRAME, bt.apCaller);
|
|
DumpMemBlock(
|
|
L"Free Trace memory block(alloc)",
|
|
pv,
|
|
pmh->cbMemory, // cbMemory
|
|
pmh->Flags, // Flags
|
|
pmh->iBackTrace, // ibt
|
|
pbt);
|
|
DumpMemBlock(
|
|
L"Free Trace memory block(free)",
|
|
pv,
|
|
pmh->cbMemory, // cbMemory
|
|
pmh->Flags, // Flags
|
|
MAXDWORD, // ibt
|
|
&bt);
|
|
}
|
|
}
|
|
FreeMemHeader(pmh);
|
|
}
|
|
}
|
|
else if (MTF_UNREGISTERED & g_MemTrack)
|
|
{
|
|
BACKTRACE bt;
|
|
|
|
CaptureStackBackTrace(NULL, 0, C_BP_FRAME, bt.apCaller);
|
|
DumpMemBlock(
|
|
L"Unregistered memory block",
|
|
pv,
|
|
MAXDWORD, // cbMemory
|
|
MAXDWORD, // Flags
|
|
MAXDWORD, // ibt
|
|
&bt);
|
|
CSASSERT(!"Unregistered memory block");
|
|
}
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
}
|
|
|
|
RegisterMemoryLeaveCriticalSection();
|
|
}
|
|
|
|
|
|
DWORD
|
|
myFormatMessageW(
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID lpSource,
|
|
IN DWORD dwMessageId,
|
|
IN DWORD dwLanguageId,
|
|
OUT LPWSTR lpBuffer,
|
|
IN DWORD nSize,
|
|
IN va_list *Arguments)
|
|
{
|
|
DWORD cwc;
|
|
|
|
cwc = FormatMessage(
|
|
dwFlags,
|
|
lpSource,
|
|
dwMessageId,
|
|
dwLanguageId,
|
|
lpBuffer,
|
|
nSize,
|
|
Arguments);
|
|
if (cwc != 0 && (FORMAT_MESSAGE_ALLOCATE_BUFFER & dwFlags))
|
|
{
|
|
myRegisterMemAlloc(
|
|
*(WCHAR **) lpBuffer,
|
|
(cwc + 1) * sizeof(WCHAR),
|
|
CSM_LOCALALLOC);
|
|
}
|
|
return(cwc);
|
|
}
|
|
|
|
|
|
HLOCAL
|
|
myLocalAlloc(
|
|
IN UINT uFlags,
|
|
IN UINT uBytes)
|
|
{
|
|
HLOCAL hMem;
|
|
|
|
// one of these should always be specified (see LocalAlloc specification)
|
|
assert((LMEM_FIXED == (uFlags & LMEM_FIXED)) ||
|
|
(LMEM_MOVEABLE == (uFlags & LMEM_MOVEABLE)) );
|
|
|
|
hMem = LocalAlloc(uFlags, uBytes);
|
|
if (NULL != hMem)
|
|
{
|
|
myRegisterMemAlloc(hMem, uBytes, CSM_LOCALALLOC);
|
|
}
|
|
return(hMem);
|
|
}
|
|
|
|
|
|
HLOCAL
|
|
myLocalReAlloc(
|
|
IN HLOCAL hMem,
|
|
IN UINT uBytes,
|
|
IN UINT uFlags)
|
|
{
|
|
HLOCAL hMemNew;
|
|
|
|
// if realloc called without MOVEABLE flag, realloc can't relocate allocation
|
|
assert(LMEM_MOVEABLE == (uFlags & LMEM_MOVEABLE));
|
|
|
|
hMemNew = LocalReAlloc(hMem, uBytes, uFlags);
|
|
if (NULL != hMemNew)
|
|
{
|
|
myRegisterMemFree(hMem, CSM_LOCALALLOC);
|
|
myRegisterMemAlloc(hMemNew, uBytes, CSM_LOCALALLOC);
|
|
}
|
|
|
|
return(hMemNew);
|
|
}
|
|
|
|
|
|
HLOCAL
|
|
myLocalFree(
|
|
IN HLOCAL hMem)
|
|
{
|
|
myRegisterMemFree(hMem, CSM_LOCALALLOC);
|
|
return(LocalFree(hMem));
|
|
}
|
|
|
|
|
|
VOID *
|
|
myCoTaskMemAlloc(
|
|
IN ULONG cb)
|
|
{
|
|
VOID *pv;
|
|
|
|
pv = CoTaskMemAlloc(cb);
|
|
if (NULL != pv)
|
|
{
|
|
myRegisterMemAlloc(pv, cb, CSM_COTASKALLOC);
|
|
}
|
|
return(pv);
|
|
}
|
|
|
|
|
|
VOID *
|
|
myCoTaskMemRealloc(
|
|
IN VOID *pv,
|
|
IN ULONG cb)
|
|
{
|
|
VOID *pvNew;
|
|
|
|
pvNew = CoTaskMemRealloc(pv, cb);
|
|
if (NULL != pvNew)
|
|
{
|
|
myRegisterMemFree(pv, CSM_COTASKALLOC);
|
|
myRegisterMemAlloc(pvNew, cb, CSM_COTASKALLOC);
|
|
}
|
|
return(pvNew);
|
|
}
|
|
|
|
|
|
VOID
|
|
myCoTaskMemFree(
|
|
IN VOID *pv)
|
|
{
|
|
myRegisterMemFree(pv, CSM_COTASKALLOC);
|
|
CoTaskMemFree(pv);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
myStringFromCLSID(
|
|
IN REFCLSID rclsid,
|
|
OUT LPOLESTR FAR *ppwsz)
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = StringFromCLSID(rclsid, ppwsz);
|
|
_JumpIfError(hr, error, "StringFromCLSID");
|
|
|
|
if (NULL != *ppwsz)
|
|
{
|
|
myRegisterMemAlloc(
|
|
*ppwsz, (wcslen(*ppwsz) + 1) * sizeof(WCHAR),
|
|
CSM_COTASKALLOC);
|
|
}
|
|
|
|
error:
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
myStringFromIID(
|
|
IN REFIID rclsid,
|
|
OUT LPOLESTR FAR *ppwsz)
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = StringFromIID(rclsid, ppwsz);
|
|
_JumpIfError(hr, error, "StringFromIID");
|
|
|
|
if (NULL != *ppwsz)
|
|
{
|
|
myRegisterMemAlloc(
|
|
*ppwsz, (wcslen(*ppwsz) + 1) * sizeof(WCHAR),
|
|
CSM_COTASKALLOC);
|
|
}
|
|
|
|
error:
|
|
return(hr);
|
|
}
|
|
|
|
|
|
BSTR
|
|
mySysAllocString(
|
|
IN const OLECHAR *pwszIn)
|
|
{
|
|
BSTR str;
|
|
|
|
str = SysAllocString(pwszIn);
|
|
if (NULL != str)
|
|
{
|
|
myRegisterMemAlloc(str, (wcslen(pwszIn) + 1) * sizeof(WCHAR), CSM_SYSALLOC);
|
|
}
|
|
return(str);
|
|
}
|
|
|
|
|
|
INT
|
|
mySysReAllocString(
|
|
IN OUT BSTR *pstr,
|
|
IN const OLECHAR *pwszIn)
|
|
{
|
|
BSTR str = *pstr;
|
|
INT i;
|
|
|
|
i = SysReAllocString(pstr, pwszIn);
|
|
if (i)
|
|
{
|
|
myRegisterMemFree(str, CSM_SYSALLOC);
|
|
myRegisterMemAlloc(*pstr, (wcslen(pwszIn) + 1) * sizeof(WCHAR), CSM_SYSALLOC);
|
|
}
|
|
return(i);
|
|
}
|
|
|
|
|
|
BSTR
|
|
mySysAllocStringLen(
|
|
IN const OLECHAR *pwcIn,
|
|
IN UINT cwc)
|
|
{
|
|
BSTR str;
|
|
|
|
str = SysAllocStringLen(pwcIn, cwc);
|
|
if (NULL != str)
|
|
{
|
|
myRegisterMemAlloc(str, cwc * sizeof(WCHAR), CSM_SYSALLOC);
|
|
}
|
|
return(str);
|
|
}
|
|
|
|
|
|
INT
|
|
mySysReAllocStringLen(
|
|
IN OUT BSTR *pstr,
|
|
IN const OLECHAR *pwcIn,
|
|
IN UINT cwc)
|
|
{
|
|
BSTR str = *pstr;
|
|
INT i;
|
|
|
|
i = SysReAllocStringLen(pstr, pwcIn, cwc);
|
|
if (i)
|
|
{
|
|
myRegisterMemFree(str, CSM_SYSALLOC);
|
|
myRegisterMemAlloc(*pstr, cwc * sizeof(WCHAR), CSM_SYSALLOC);
|
|
}
|
|
return(i);
|
|
}
|
|
|
|
|
|
VOID
|
|
mySysFreeString(
|
|
IN BSTR str)
|
|
{
|
|
if (NULL != str)
|
|
{
|
|
myRegisterMemFree(str, CSM_SYSALLOC);
|
|
}
|
|
SysFreeString(str);
|
|
}
|
|
|
|
|
|
BSTR
|
|
mySysAllocStringByteLen(
|
|
LPCSTR pszIn,
|
|
UINT cb)
|
|
{
|
|
BSTR str;
|
|
|
|
str = SysAllocStringByteLen(pszIn, cb);
|
|
if (NULL != str)
|
|
{
|
|
myRegisterMemAlloc(str, cb, CSM_SYSALLOC);
|
|
}
|
|
return(str);
|
|
}
|
|
|
|
|
|
VOID
|
|
_RegisterVariantMemAlloc(
|
|
IN PROPVARIANT *pvar)
|
|
{
|
|
VOID *pv;
|
|
DWORD Flags;
|
|
DWORD cb;
|
|
|
|
pv = _VariantMemory(pvar, &Flags, &cb);
|
|
if (NULL != pv)
|
|
{
|
|
myRegisterMemAlloc(pv, cb, Flags);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
_RegisterVariantMemFree(
|
|
IN PROPVARIANT *pvar)
|
|
{
|
|
VOID *pv;
|
|
DWORD Flags;
|
|
|
|
pv = _VariantMemory(pvar, &Flags, NULL);
|
|
if (NULL != pv)
|
|
{
|
|
myRegisterMemFree(pv, Flags);
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT
|
|
myPropVariantClear(
|
|
IN PROPVARIANT *pvar)
|
|
{
|
|
_RegisterVariantMemFree(pvar);
|
|
return(PropVariantClear(pvar));
|
|
}
|
|
|
|
|
|
HRESULT
|
|
myVariantClear(
|
|
IN VARIANTARG *pvar)
|
|
{
|
|
_RegisterVariantMemFree((PROPVARIANT *) pvar);
|
|
return(VariantClear(pvar));
|
|
}
|
|
|
|
|
|
HRESULT
|
|
myVariantChangeType(
|
|
OUT VARIANTARG *pvarDest,
|
|
IN VARIANTARG *pvarSrc,
|
|
IN unsigned short wFlags,
|
|
IN VARTYPE vt)
|
|
{
|
|
HRESULT hr;
|
|
|
|
// if converting in-place, memory will be freed by the API call
|
|
|
|
if (pvarDest == pvarSrc)
|
|
{
|
|
_RegisterVariantMemFree((PROPVARIANT *) pvarSrc);
|
|
}
|
|
hr = VariantChangeType(pvarDest, pvarSrc, wFlags, vt);
|
|
_RegisterVariantMemAlloc((PROPVARIANT *) pvarDest);
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
myVariantChangeTypeEx(
|
|
OUT VARIANTARG *pvarDest,
|
|
IN VARIANTARG *pvarSrc,
|
|
IN LCID lcid,
|
|
IN unsigned short wFlags,
|
|
IN VARTYPE vt)
|
|
{
|
|
HRESULT hr;
|
|
|
|
// if converting in-place, memory will be freed by the API call
|
|
|
|
if (pvarDest == pvarSrc)
|
|
{
|
|
_RegisterVariantMemFree((PROPVARIANT *) pvarSrc);
|
|
}
|
|
hr = VariantChangeTypeEx(pvarDest, pvarSrc, lcid, wFlags, vt);
|
|
_RegisterVariantMemAlloc((PROPVARIANT *) pvarDest);
|
|
return(hr);
|
|
}
|
|
|
|
|
|
VOID *
|
|
myNew(
|
|
IN size_t size)
|
|
{
|
|
VOID *pv;
|
|
|
|
pv = LocalAlloc(LMEM_FIXED, size);
|
|
if (NULL != pv)
|
|
{
|
|
myRegisterMemAlloc(pv, size, CSM_NEW);
|
|
}
|
|
return(pv);
|
|
}
|
|
|
|
|
|
VOID
|
|
myDelete(
|
|
IN VOID *pv)
|
|
{
|
|
myRegisterMemFree(pv, CSM_NEW);
|
|
LocalFree(pv);
|
|
}
|
|
|
|
#endif // DBG_CERTSRV
|