1 files changed, 1040 insertions, 0 deletions

diff --git a/source/LeakFinder.cpp b/source/LeakFinder.cpp
new file mode 100644
index 000000000..1490025f8
--- /dev/null
+++ b/source/LeakFinder.cpp
@@ -0,0 +1,1040 @@
+

+// LeakFinder.cpp

+

+// Finds memory leaks rather effectively

+

+// _X: downloaded from http://www.codeproject.com/Articles/3134/Memory-Leak-and-Exception-Trace-CRT-and-COM-Leaks - the real link is in the comments, RC11 version

+

+

+

+

+

+/**********************************************************************

+ * 

+ * LEAKFINDER.CPP

+ *

+ *

+ *

+ * History:

+ *  2010-04-15   RC10   - Updated to VC10 RTM

+ *                        Fixed Bug: Application Verifier, thanks to handsinmypocket!

+ *                        http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=3439751#xx3439751xx

+ *  2008-08-04   RC6    - Updated to VC9 RTM

+ *                        Fixed Bug: Missing "ole32.lib" LIB

+ *                        http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=2253980#xx2253980xx

+ *                        Fixed Bug: Compiled with "WIN32_LEAN_AND_MEAN"

+ *                        http://www.codeproject.com/KB/applications/leakfinder.aspx?msg=1824718#xx1824718xx

+ *                        Fixed Bug: Compiling with "/Wall"

+ *                        http://www.codeproject.com/KB/threads/StackWalker.aspx?msg=2638243#xx2638243xx

+ *                        Removed "#pragma init_seg (compiler)" from h-file

+ *

+ *  2005-12-30   RC5    - Now again VC8 RTM compatible

+ *                      - Added Xml-Output (like in the old Leakfinder)

+ *                        YOu need to define XML_LEAK_FINDER to activate it

+ *                        So you can use the LeakAnalyseTool from

+ *                        http://www.codeproject.com/tools/leakfinder.asp

+ *

+ *  2005-12-13   RC4    - Merged with the new "StackWalker"-project on 

+ *                        http://www.codeproject.com/threads/StackWalker.asp

+ *

+ *  2005-08-01   RC3    - Merged with the new "StackWalker"-project on 

+ *                        http://www.codeproject.com/threads/StackWalker.asp

+ *

+ *  2005-07-05   RC2    - First version with x86, IA64 and x64 support

+ *

+ *  2005-07-04   RC1    - Added "OutputOptions"

+ *                      - New define "INIT_LEAK_FINDER_VERBOSE" to 

+ *                        display more info (for error reporting)

+ *

+ *  2005-07-01   Beta3  - Workaround for a bug in the new dbghelp.dll

+ *                        (version 6.5.3.7 from 2005-05-30; StakWalk64 no 

+ *                        refused to produce an callstack on x86 systems

+ *                        if the context is NULL or has some registers set 

+ *                        to 0 (for example Esp). This is against the 

+ *                        documented behaviour of StackWalk64...)

+ *                      - First version with x64-support

+ *

+ *   2005-06-16  Beta1  First public release with the following features:

+ *                      - Completely rewritten in C++ (object oriented)

+ *                      - CRT-Leak-Report

+ *                      - COM-Leak-Report

+ *                      - Report is done via "OutputDebugString" so

+ *                        the line can directly selected in the debugger

+ *                        and is opening the corresponding file/line of 

+ *                        the allocation

+ *                      - Tried to support x64 systems, bud had some

+ *                        trouble wih StackWalk64

+ *                        See: http://blog.kalmbachnet.de/?postid=43

+ *

+ * LICENSE (http://www.opensource.org/licenses/bsd-license.php)

+ *

+ *   Copyright (c) 2005-2010, Jochen Kalmbach

+ *   All rights reserved.

+ *

+ *   Redistribution and use in source and binary forms, with or without modification, 

+ *   are permitted provided that the following conditions are met:

+ *

+ *   Redistributions of source code must retain the above copyright notice, 

+ *   this list of conditions and the following disclaimer. 

+ *   Redistributions in binary form must reproduce the above copyright notice, 

+ *   this list of conditions and the following disclaimer in the documentation 

+ *   and/or other materials provided with the distribution. 

+ *   Neither the name of Jochen Kalmbach nor the names of its contributors may be 

+ *   used to endorse or promote products derived from this software without 

+ *   specific prior written permission. 

+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 

+ *   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 

+ *   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 

+ *   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 

+ *   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 

+ *   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 

+ *   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 

+ *   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 

+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 

+ *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ *

+ **********************************************************************/

+

+#include <windows.h>

+#include <objidl.h>  // Needed if compiled with "WIN32_LEAN_AND_MEAN"

+#include <tchar.h>

+#include <crtdbg.h>

+#include <stdio.h>

+

+#include <string>

+#include <vector>

+

+

+#include "LeakFinder.h"

+

+// Currently only tested with MS VC++ 5 to 10

+#if (_MSC_VER < 1100) || (_MSC_VER > 1600)

+#error Only MS VC++ 5/6/7/7.1/8/9 supported. Check if the '_CrtMemBlockHeader' has not changed with this compiler!

+#endif

+

+

+// Controlling the callstack depth

+#define MAX_CALLSTACK_LEN_BUF 0x2000

+

+#define IGNORE_CRT_ALLOC

+

+// disable 64-bit compatibility-checks (because we explicite have here either x86 or x64!)

+#pragma warning(disable:4312)  // warning C4312: 'type cast' : conversion from 'DWORD' to 'LPCVOID' of greater size

+#pragma warning(disable:4826)

+

+

+// secure-CRT_functions are only available starting with VC8

+#if _MSC_VER < 1400

+#define _snprintf_s _snprintf

+#define _tcscat_s _tcscat

+#endif

+

+static std::string SimpleXMLEncode(LPCSTR szText)

+{

+  std::string szRet;

+  for (size_t i=0; i<strlen(szText); i++)

+  {

+    switch(szText[i])

+    {

+    case '&':

+      szRet.append("&amp;");

+      break;

+    case '<':

+      szRet.append("&lt;");

+      break;

+    case '>':

+      szRet.append("&gt;");

+      break;

+    case '"':

+      szRet.append("&quot;");

+      break;

+    case '\'':

+      szRet.append("&apos;");

+      break;

+    default:

+      szRet += szText[i];

+    }

+  }

+  return szRet;

+}

+

+

+LeakFinderOutput::LeakFinderOutput(int options, LPCSTR szSymPath)

+  : StackWalker(options, szSymPath)

+{

+}

+void LeakFinderOutput::OnLeakSearchStart(LPCSTR szLeakFinderName)

+{

+  CHAR buffer[1024];

+  _snprintf_s(buffer, 1024, "######## %s ########\n", szLeakFinderName);

+  this->OnOutput(buffer);

+}

+void LeakFinderOutput::OnLeakStartEntry(LPCSTR szKeyName, SIZE_T nDataSize)

+{

+  CHAR buffer[1024];

+  _snprintf_s(buffer, 1024, "--------------- Key: %s, %d bytes ---------\n", szKeyName, nDataSize);

+  this->OnOutput(buffer);

+}

+void LeakFinderOutput::OnCallstackEntry(CallstackEntryType eType, CallstackEntry &entry)

+{

+  if ( (eType != lastEntry) && (entry.offset != 0) )

+  {

+    if ( ((this->m_options & LeakFinderShowCompleteCallstack) == 0) && ( 

+      (strstr(entry.lineFileName, "afxmem.cpp") != NULL) ||

+      (strstr(entry.lineFileName, "dbgheap.c") != NULL) ||

+      (strstr(entry.lineFileName, "new.cpp") != NULL) ||

+      (strstr(entry.lineFileName, "newop.cpp") != NULL) ||

+      (strstr(entry.lineFileName, "leakfinder.cpp") != NULL) ||

+      (strstr(entry.lineFileName, "stackwalker.cpp") != NULL) 

+      ) )

+    {

+      return;

+    }

+  }

+  StackWalker::OnCallstackEntry(eType, entry);

+}

+

+

+// ####################################################################

+// XML-Output

+LeakFinderXmlOutput::LeakFinderXmlOutput()

+{

+  TCHAR szXMLFileName[1024];

+

+  GetModuleFileName(NULL, szXMLFileName, sizeof(szXMLFileName) / sizeof(TCHAR));

+  _tcscat_s(szXMLFileName, _T(".mem.xml-leaks"));

+#if _MSC_VER < 1400

+  m_fXmlFile = _tfopen(szXMLFileName, _T("w"));

+#else

+  m_fXmlFile = NULL;

+  _tfopen_s(&m_fXmlFile, szXMLFileName, _T("w"));

+#endif

+  if (m_fXmlFile != NULL)

+  {

+    SYSTEMTIME st;

+    GetLocalTime(&st);

+    fprintf(m_fXmlFile, "<MEMREPORT date=\"%.2d/%.2d/%.4d\" time=\"%.2d:%.2d:%.2d\">\n",

+      st.wMonth, st.wDay, st.wYear,

+      st.wHour, st.wMinute, st.wSecond);

+  }

+  else

+  {

+    MessageBox(NULL, _T("Could not open xml-logfile for leakfinder!"), _T("Warning"), MB_ICONHAND);

+  }

+}

+LeakFinderXmlOutput::LeakFinderXmlOutput(LPCTSTR szFileName)

+{

+#if _MSC_VER < 1400

+  m_fXmlFile = _tfopen(szFileName, _T("w"));

+#else

+  m_fXmlFile = NULL;

+  _tfopen_s(&m_fXmlFile, szFileName, _T("w"));

+#endif

+  if (m_fXmlFile == NULL)

+  {

+    MessageBox(NULL, _T("Could not open xml-logfile for leakfinder!"), _T("Warning"), MB_ICONHAND);

+  }

+}

+LeakFinderXmlOutput::~LeakFinderXmlOutput()

+{

+  if (m_fXmlFile != NULL) 

+  {

+    // Write the ending-tags and close the file

+    fprintf(m_fXmlFile, "</MEMREPORT>\n");

+    fclose(m_fXmlFile);

+  }

+  m_fXmlFile = NULL;

+}

+void LeakFinderXmlOutput::OnLeakSearchStart(LPCSTR sszLeakFinderName)

+{

+}

+void LeakFinderXmlOutput::OnLeakStartEntry(LPCSTR szKeyName, SIZE_T nDataSize)

+{

+  if (m_fXmlFile != NULL)

+  {

+    fprintf(m_fXmlFile, "  <LEAK requestID=\"%s\" size=\"%d\">\n", SimpleXMLEncode(szKeyName).c_str(), nDataSize);

+  }

+}

+void LeakFinderXmlOutput::OnCallstackEntry(CallstackEntryType eType, CallstackEntry &entry)

+{

+  if (m_fXmlFile != NULL)

+  {

+    if (eType != lastEntry)

+    {

+      fprintf(m_fXmlFile, "    <STACKENTRY decl=\"%s\" decl_offset=\"%+ld\" ", SimpleXMLEncode(entry.undName).c_str(), entry.offsetFromSmybol);

+      fprintf(m_fXmlFile, "srcfile=\"%s\" line=\"%d\" line_offset=\"%+ld\" ", SimpleXMLEncode(entry.lineFileName).c_str(), entry.lineNumber, entry.offsetFromLine);

+      fprintf(m_fXmlFile, "module=\"%s\" base=\"%08lx\" ", SimpleXMLEncode(entry.moduleName).c_str(), entry.baseOfImage);

+      fprintf(m_fXmlFile, "/>\n");

+    }

+    else

+    {

+      fprintf(m_fXmlFile, "  </LEAK>\n");

+    }

+  }

+}

+

+// ##########################################################################

+// ##########################################################################

+// ##########################################################################

+// Base class for storing contexts in a hashtable

+template <typename HASHTABLE_KEY> class ContextHashtableBase

+{

+public:

+  ContextHashtableBase(SIZE_T sizeOfHastable, LPCSTR finderName)

+  {

+    SIZE_T s = sizeOfHastable*sizeof(AllocHashEntryType);

+    m_hHeap = HeapCreate(0, 10*1024 + s, 0);

+    if (m_hHeap == NULL)

+      throw;

+    pAllocHashTable = (AllocHashEntryType*) own_malloc(s);

+    sAllocEntries = sizeOfHastable;

+    m_finderName = own_strdup(finderName);

+  }

+

+protected:

+  virtual ~ContextHashtableBase()

+  {

+    if (pAllocHashTable != NULL)

+      own_free(pAllocHashTable);

+    pAllocHashTable = NULL;

+

+    own_free(m_finderName);

+    m_finderName = NULL;

+

+    if (m_hHeap != NULL)

+      HeapDestroy(m_hHeap);

+  }

+

+  __inline LPVOID own_malloc(SIZE_T size)

+  {

+    return HeapAlloc(m_hHeap, HEAP_ZERO_MEMORY, size);

+  }

+  __inline VOID own_free(LPVOID memblock)

+  {

+    HeapFree(m_hHeap, 0, memblock);

+  }

+  __inline CHAR *own_strdup(const char *str)

+  {

+    size_t len = strlen(str)+1;

+    CHAR *c = (CHAR*)own_malloc(len);

+#if _MSC_VER >= 1400

+    strcpy_s(c, len, str);

+#else

+    strcpy(c, str);

+#endif

+    return c;

+  }

+

+  // Disables this leak-finder

+  virtual LONG Disable() = 0;

+  // enables the leak-finder again...

+  virtual LONG Enable() = 0;

+

+private:

+  // Entry for each allocation

+  typedef struct AllocHashEntryType {

+    HASHTABLE_KEY             key;

+    SIZE_T                    nDataSize;     // Size of the allocated memory

+    struct AllocHashEntryType *Next;

+    CONTEXT c;

+    PVOID                     pStackBaseAddr;

+    SIZE_T                    nMaxStackSize;

+

+    PVOID                     pCallstackOffset;

+    SIZE_T                    nCallstackLen;

+    char                      pcCallstackAddr[MAX_CALLSTACK_LEN_BUF];  // min of both values...

+  } AllocHashEntryType;

+

+protected:

+  virtual SIZE_T HashFunction(HASHTABLE_KEY &key) = 0;

+  virtual BOOL IsKeyEmpty(HASHTABLE_KEY &key) = 0;

+  virtual VOID SetEmptyKey(HASHTABLE_KEY &key) = 0;

+  virtual VOID GetKeyAsString(HASHTABLE_KEY &key, CHAR *szName, SIZE_T nBufferLen) = 0;

+  //virtual SIZE_T GetNativeBytes(HASHTABLE_KEY &key, CHAR *szName, SIZE_T nBufferLen) { return 0; }

+

+public:

+  VOID Insert(HASHTABLE_KEY &key, CONTEXT &context, SIZE_T nDataSize)

+  {

+    SIZE_T HashIdx;

+    AllocHashEntryType *pHashEntry;

+

+    // generate hash-value

+    HashIdx = HashFunction(key);

+

+    pHashEntry = &pAllocHashTable[HashIdx];

+    if (IsKeyEmpty(pHashEntry->key) != FALSE) {

+      // Entry is empty...

+    }

+    else {

+      // Entry is not empy! make a list of entries for this hash value...

+      while(pHashEntry->Next != NULL) {

+        pHashEntry = pHashEntry->Next;

+      }

+

+      pHashEntry->Next = (AllocHashEntryType*) own_malloc(sizeof(AllocHashEntryType));

+      pHashEntry = pHashEntry->Next;

+    }

+    pHashEntry->key = key;

+    pHashEntry->nDataSize = nDataSize;

+    pHashEntry->Next = NULL;

+#ifdef _M_IX86

+    pHashEntry->pCallstackOffset = (LPVOID) min(context.Ebp, context.Esp);

+#elif _M_X64

+    pHashEntry->pCallstackOffset = (LPVOID) min(context.Rdi, context.Rsp);

+#elif _M_IA64

+    pHashEntry->pCallstackOffset = (LPVOID) min(context.IntSp, context.RsBSP);

+#else

+#error "Platform not supported!"

+#endif

+    pHashEntry->c = context;

+

+    // Query the max. stack-area:

+    MEMORY_BASIC_INFORMATION MemBuffer;

+    if(VirtualQuery((LPCVOID) pHashEntry->pCallstackOffset, &MemBuffer, sizeof(MemBuffer)) > 0)

+    {

+      pHashEntry->pStackBaseAddr = MemBuffer.BaseAddress;

+      pHashEntry->nMaxStackSize = MemBuffer.RegionSize;

+    }

+    else

+    {

+      pHashEntry->pStackBaseAddr = 0;

+      pHashEntry->nMaxStackSize = 0;

+    }

+

+    SIZE_T bytesToRead = MAX_CALLSTACK_LEN_BUF;

+    if (pHashEntry->nMaxStackSize > 0)

+    {

+      SIZE_T len = ((SIZE_T) pHashEntry->pStackBaseAddr + pHashEntry->nMaxStackSize) - (SIZE_T)pHashEntry->pCallstackOffset;

+      bytesToRead = min(len, MAX_CALLSTACK_LEN_BUF);

+    }

+    // Now read the callstack:

+    if (ReadProcessMemory(GetCurrentProcess(), (LPCVOID) pHashEntry->pCallstackOffset, &(pHashEntry->pcCallstackAddr), bytesToRead, &(pHashEntry->nCallstackLen)) == 0) 

+    {

+      // Could not read memory...

+      pHashEntry->nCallstackLen = 0;

+      pHashEntry->pCallstackOffset = 0;

+    }  // read callstack

+  }  // Insert

+

+  BOOL Remove(HASHTABLE_KEY &key)

+  {

+    SIZE_T HashIdx;

+    AllocHashEntryType *pHashEntry, *pHashEntryLast;

+

+    // get the Hash-Value

+    HashIdx = HashFunction(key);

+

+    pHashEntryLast = NULL;

+    pHashEntry = &pAllocHashTable[HashIdx];

+    while(pHashEntry != NULL) {

+      if (pHashEntry->key == key) {

+        // release my memory

+        if (pHashEntryLast == NULL) {

+          // It is an entry in the table, so do not release this memory

+          if (pHashEntry->Next == NULL) {

+            // It was the last entry, so empty the table entry

+            SetEmptyKey(pAllocHashTable[HashIdx].key);

+            //memset(&pAllocHashTable[HashIdx], 0, sizeof(pAllocHashTable[HashIdx]));

+          }

+          else {

+            // There are some more entries, so shorten the list

+            AllocHashEntryType *pTmp = pHashEntry->Next;

+            *pHashEntry = *(pHashEntry->Next);

+            own_free(pTmp);

+          }

+          return TRUE;

+        }

+        else {

+          // now, I am in an dynamic allocated entry (it was a collision)

+          pHashEntryLast->Next = pHashEntry->Next;

+          own_free(pHashEntry);

+          return TRUE;

+        }

+      }

+      pHashEntryLast = pHashEntry;

+      pHashEntry = pHashEntry->Next;

+    }

+

+    // if we are here, we could not find the RequestID

+    return FALSE;

+  }

+

+  AllocHashEntryType *Find(HASHTABLE_KEY &key)

+  {

+    SIZE_T HashIdx;

+    AllocHashEntryType *pHashEntry;

+

+    // get the Hash-Value

+    HashIdx = HashFunction(key);

+

+    pHashEntry = &pAllocHashTable[HashIdx];

+    while(pHashEntry != NULL) {

+      if (pHashEntry->key == key) {

+        return pHashEntry;

+      }

+      pHashEntry = pHashEntry->Next;

+    }

+

+    // entry was not found!

+    return NULL;

+  }

+

+  // For the followong static-var See comment in "ShowCallstack"...

+  static BOOL CALLBACK ReadProcessMemoryFromHashEntry64(

+    HANDLE hProcess, // hProcess must be a pointer to an hash-entry!

+    DWORD64 lpBaseAddress, 

+    PVOID lpBuffer, 

+    DWORD nSize, 

+    LPDWORD lpNumberOfBytesRead,

+    LPVOID pUserData  // optional data, which was passed in "ShowCallstack"

+    )

+  {

+    *lpNumberOfBytesRead = 0;

+    AllocHashEntryType *pHashEntry = (AllocHashEntryType*) pUserData;

+    if (pHashEntry == NULL)

+    {

+      return FALSE;

+    }

+

+    if ( ( (DWORD64)lpBaseAddress >= (DWORD64)pHashEntry->pCallstackOffset) && ((DWORD64)lpBaseAddress <= ((DWORD64)pHashEntry->pCallstackOffset+pHashEntry->nCallstackLen)) ) {

+      // Memory is located in saved Callstack:

+      // Calculate the offset

+      DWORD dwOffset = (DWORD) ((DWORD64)lpBaseAddress - (DWORD64)pHashEntry->pCallstackOffset);

+      DWORD dwSize = __min(nSize, MAX_CALLSTACK_LEN_BUF-dwOffset);

+      memcpy(lpBuffer, &(pHashEntry->pcCallstackAddr[dwOffset]), dwSize);

+      *lpNumberOfBytesRead = dwSize;

+      if (dwSize != nSize)

+      {

+        return FALSE;

+      }

+      *lpNumberOfBytesRead = nSize;

+      return TRUE;

+    }

+

+    if (*lpNumberOfBytesRead == 0)  // Memory could not be found

+    {

+      if ( ( (DWORD64)lpBaseAddress < (DWORD64)pHashEntry->pStackBaseAddr) || ((DWORD64)lpBaseAddress > ((DWORD64)pHashEntry->pStackBaseAddr+pHashEntry->nMaxStackSize)) )

+      {

+        // Stackwalking is done by reading the "real memory" (normally this happens when the StackWalk64 tries to read some code)

+        SIZE_T st = 0;

+        BOOL bRet = ReadProcessMemory(hProcess, (LPCVOID) lpBaseAddress, lpBuffer, nSize, &st);

+        *lpNumberOfBytesRead = (DWORD) st;

+        return bRet;

+      }

+    }

+

+    return TRUE;

+  }

+

+  VOID ShowLeaks(LeakFinderOutput &leakFinderOutput)

+  {

+    SIZE_T ulTemp;

+    AllocHashEntryType *pHashEntry;

+    ULONG ulCount = 0;

+    SIZE_T ulLeaksByte = 0;

+

+    leakFinderOutput.OnLeakSearchStart(this->m_finderName);

+

+    // Move throu every entry

+    CHAR keyName[1024];

+    for(ulTemp = 0; ulTemp < this->sAllocEntries; ulTemp++) {

+      pHashEntry = &pAllocHashTable[ulTemp];

+      if (IsKeyEmpty(pHashEntry->key) == FALSE) {

+        while(pHashEntry != NULL) {

+          ulCount++;

+          CONTEXT c;

+          memcpy(&c, &(pHashEntry->c), sizeof(CONTEXT));

+

+          this->GetKeyAsString(pHashEntry->key, keyName, 1024);

+

+          leakFinderOutput.OnLeakStartEntry(keyName, pHashEntry->nDataSize);

+          leakFinderOutput.ShowCallstack(GetCurrentThread(), &c, ReadProcessMemoryFromHashEntry64, pHashEntry);

+

+          // Count the number of leaky bytes

+          ulLeaksByte += pHashEntry->nDataSize;

+

+          pHashEntry = pHashEntry->Next;

+        }  // while

+      }

+    }

+  }

+

+  AllocHashEntryType *pAllocHashTable;

+  SIZE_T sAllocEntries;

+  HANDLE m_hHeap;

+  LPSTR m_finderName;

+  bool m_bSupressUselessLines;

+};  // template <typename HASHTABLE_KEY> class ContextHashtableBase

+

+

+// ##########################################################################

+// ##########################################################################

+// ##########################################################################

+// Specialization for CRT-Leaks:

+// VC5 has excluded all types in release-builds

+#ifdef _DEBUG

+

+// The follwoing is copied from dbgint.h:

+// <CRT_INTERNALS>

+/*

+* For diagnostic purpose, blocks are allocated with extra information and

+* stored in a doubly-linked list.  This makes all blocks registered with

+* how big they are, when they were allocated, and what they are used for.

+*/

+

+// forward declaration:

+#ifndef _M_CEE_PURE

+#define MyAllocHookCallingConvention __cdecl

+#endif

+#if _MSC_VER >= 1400

+#ifdef _M_CEE

+#define MyAllocHookCallingConvention __clrcall

+#endif

+#endif

+

+static int MyAllocHookCallingConvention MyAllocHook(int nAllocType, void *pvData, 

+  size_t nSize, int nBlockUse, long lRequest, 

+#if _MSC_VER <= 1100 // Special case for VC 5 and before

+  const char * szFileName, 

+#else

+  const unsigned char * szFileName, 

+#endif

+  int nLine);

+

+static _CRT_ALLOC_HOOK s_pfnOldCrtAllocHook = NULL;

+static LONG s_CrtDisableCount = 0;

+static LONG s_lMallocCalled = 0;

+

+

+class CRTTable : public ContextHashtableBase<LONG>

+{

+public:

+  CRTTable() : ContextHashtableBase<LONG>(1021, "CRT-Leaks")

+  {

+    // save the previous alloc hook

+    s_pfnOldCrtAllocHook = _CrtSetAllocHook(MyAllocHook);

+  }

+

+  virtual ~CRTTable()

+  {

+    _CrtSetAllocHook(s_pfnOldCrtAllocHook);

+  }

+

+  virtual LONG Disable()

+  {

+    return InterlockedIncrement(&s_CrtDisableCount);

+  }

+  virtual LONG Enable()

+  {

+    return InterlockedDecrement(&s_CrtDisableCount);

+  }

+

+  virtual SIZE_T HashFunction(LONG &key)

+  {

+    // I couldn´t find any better and faster

+    return key % sAllocEntries;

+  }

+  virtual BOOL IsKeyEmpty(LONG &key)

+  {

+    if (key == 0)

+      return TRUE;

+    return FALSE;

+  }

+  virtual VOID SetEmptyKey(LONG &key)

+  {

+    key = 0;

+  }

+  virtual VOID GetKeyAsString(LONG &key, CHAR *szName, SIZE_T nBufferLen)

+  {

+#if _MSC_VER < 1400

+    _snprintf_s(szName, nBufferLen, "%d", key);

+#else

+    _snprintf_s(szName, nBufferLen, nBufferLen, "%d", key);

+#endif

+  }

+

+protected:

+  CHAR *m_pBuffer;

+  SIZE_T m_maxBufferLen;

+  SIZE_T m_bufferLen;

+};  // class CRTTable

+

+

+#define nNoMansLandSize 4

+

+typedef struct _CrtMemBlockHeader

+{

+  struct _CrtMemBlockHeader * pBlockHeaderNext;

+  struct _CrtMemBlockHeader * pBlockHeaderPrev;

+  char *                      szFileName;

+  int                         nLine;

+#ifdef _WIN64

+  /* These items are reversed on Win64 to eliminate gaps in the struct

+  * and ensure that sizeof(struct)%16 == 0, so 16-byte alignment is

+  * maintained in the debug heap.

+  */

+  int                         nBlockUse;

+  size_t                      nDataSize;

+#else  /* _WIN64 */

+  size_t                      nDataSize;

+  int                         nBlockUse;

+#endif  /* _WIN64 */

+  long                        lRequest;

+  unsigned char               gap[nNoMansLandSize];

+  /* followed by:

+  *  unsigned char           data[nDataSize];

+  *  unsigned char           anotherGap[nNoMansLandSize];

+  */

+} _CrtMemBlockHeader;

+#define pbData(pblock) ((unsigned char *)((_CrtMemBlockHeader *)pblock + 1))

+#define pHdr(pbData) (((_CrtMemBlockHeader *)pbData)-1) 

+// </CRT_INTERNALS>

+

+static CRTTable *g_pCRTTable = NULL;

+

+

+// MyAllocHook is Single-Threaded, that means the the calls are serialized in the calling function!

+static int MyAllocHook(int nAllocType, void *pvData, 

+  size_t nSize, int nBlockUse, long lRequest, 

+#if _MSC_VER <= 1100 // Special case for VC 5

+  const char * szFileName, 

+#else

+  const unsigned char * szFileName, 

+#endif

+  int nLine) 

+{

+  //static TCHAR *operation[] = { _T(""), _T("ALLOCATIONG"), _T("RE-ALLOCATING"), _T("FREEING") };

+  //static TCHAR *blockType[] = { _T("Free"), _T("Normal"), _T("CRT"), _T("Ignore"), _T("Client") };

+

+#ifdef IGNORE_CRT_ALLOC

+  if (_BLOCK_TYPE(nBlockUse) == _CRT_BLOCK)  // Ignore internal C runtime library allocations

+    return TRUE;

+#endif

+  extern int _crtDbgFlag;

+  if  ( ((_CRTDBG_ALLOC_MEM_DF & _crtDbgFlag) == 0) && ( (nAllocType == _HOOK_ALLOC) || (nAllocType == _HOOK_REALLOC) ) )

+  {

+    // Someone has disabled that the runtime should log this allocation

+    // so we do not log this allocation

+    if (s_pfnOldCrtAllocHook != NULL)

+      s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);

+    return TRUE;

+  }

+

+  // Handle the Disable/Enable setting

+  if (InterlockedExchangeAdd(&s_CrtDisableCount, 0) != 0)

+    return TRUE;

+

+  // Prevent from reentrat calls

+  if (InterlockedIncrement(&s_lMallocCalled) > 1) { // I was already called

+    InterlockedDecrement(&s_lMallocCalled);

+    // call the previous alloc hook

+    if (s_pfnOldCrtAllocHook != NULL)

+      s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);

+    return TRUE;

+  }

+

+  _ASSERT( (nAllocType == _HOOK_ALLOC) || (nAllocType == _HOOK_REALLOC) || (nAllocType == _HOOK_FREE) );

+  _ASSERT( ( _BLOCK_TYPE(nBlockUse) >= 0 ) && ( _BLOCK_TYPE(nBlockUse) < 5 ) );

+

+  if (nAllocType == _HOOK_FREE) { // freeing

+    // Try to get the header information

+    if (_CrtIsValidHeapPointer(pvData)) {  // it is a valid Heap-Pointer

+      // get the ID

+      _CrtMemBlockHeader *pHead;

+      // get a pointer to memory block header

+      pHead = pHdr(pvData);

+      nSize = pHead->nDataSize;

+      lRequest = pHead->lRequest; // This is the ID!

+

+      if (pHead->nBlockUse == _IGNORE_BLOCK)

+      {

+        InterlockedDecrement(&s_lMallocCalled);

+        if (s_pfnOldCrtAllocHook != NULL)

+          s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);

+        return TRUE;

+      }

+    }

+    if (lRequest != 0) {  // RequestID was found

+      g_pCRTTable->Remove(lRequest);

+    }

+  }  // freeing

+

+  if (nAllocType == _HOOK_REALLOC) { // re-allocating

+    // Try to get the header information

+    if (_CrtIsValidHeapPointer(pvData)) {  // it is a valid Heap-Pointer

+      BOOL bRet;

+      LONG lReallocRequest;

+      // get the ID

+      _CrtMemBlockHeader *pHead;

+      // get a pointer to memory block header

+      pHead = pHdr(pvData);

+      // Try to find the RequestID in the Hash-Table, mark it that it was freed

+      lReallocRequest = pHead->lRequest;

+      bRet = g_pCRTTable->Remove(lReallocRequest);

+    }  // ValidHeapPointer

+  }  // re-allocating

+

+  //if ( (g_ulShowStackAtAlloc < 3) && (nAllocType == _HOOK_FREE) ) {

+  if (nAllocType == _HOOK_FREE) {

+    InterlockedDecrement(&s_lMallocCalled);

+    // call the previous alloc hook

+    if (s_pfnOldCrtAllocHook != NULL)

+      s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);

+    return TRUE;

+  }

+

+  CONTEXT c;

+  GET_CURRENT_CONTEXT(c, CONTEXT_FULL);

+

+  // Only insert in the Hash-Table if it is not a "freeing"

+  if (nAllocType != _HOOK_FREE) {

+    if(lRequest != 0) // Always a valid RequestID should be provided (see comments in the header)

+      g_pCRTTable->Insert(lRequest, c, nSize);

+  }

+

+  InterlockedDecrement(&s_lMallocCalled);

+  // call the previous alloc hook

+  if (s_pfnOldCrtAllocHook != NULL)

+    s_pfnOldCrtAllocHook(nAllocType, pvData, nSize, nBlockUse, lRequest, szFileName, nLine);

+  return TRUE; // allow the memory operation to proceed

+}  // MyAllocHook

+

+#endif  // _DEBUG

+

+

+// ##########################################################################

+// ##########################################################################

+// ##########################################################################

+// Specialization for COM-Leaks:

+

+// forwards:

+class COMTable;

+class CMallocSpy : public IMallocSpy

+{

+public: 

+  CMallocSpy() { m_cbRequest = 0; m_cRef = 0; m_disableCount = 0; }

+  virtual ~CMallocSpy() {}

+  // IUnknown methods

+  STDMETHOD(QueryInterface) (REFIID riid, LPVOID *ppUnk);

+  STDMETHOD_(ULONG, AddRef) ();

+  STDMETHOD_(ULONG, Release) ();

+  // IMallocSpy methods

+  STDMETHOD_(SIZE_T, PreAlloc) (SIZE_T cbRequest);

+  STDMETHOD_(void *, PostAlloc) (void *pActual);

+  STDMETHOD_(void *, PreFree) (void *pRequest, BOOL fSpyed);

+  STDMETHOD_(void, PostFree) (BOOL fSpyed) { return; };

+  STDMETHOD_(SIZE_T, PreRealloc) (void *pRequest, SIZE_T cbRequest, void **ppNewRequest, BOOL fSpyed);

+  STDMETHOD_(void *, PostRealloc) (void *pActual, BOOL fSpyed);

+  STDMETHOD_(void *, PreGetSize) (void *pRequest, BOOL fSpyed) { return pRequest; }

+  STDMETHOD_(SIZE_T, PostGetSize) (SIZE_T cbActual, BOOL fSpyed) { return cbActual; }

+  STDMETHOD_(void *, PreDidAlloc) (void *pRequest, BOOL fSpyed) { return pRequest; }

+  STDMETHOD_(BOOL, PostDidAlloc) (void *pRequest, BOOL fSpyed, BOOL fActual) { return fActual; }

+  STDMETHOD_(void, PreHeapMinimize) (void) { return; }

+  STDMETHOD_(void, PostHeapMinimize) (void) { return; }

+private:

+  LONG m_cRef;

+  SIZE_T m_cbRequest;

+protected:

+  COMTable *m_pComTable;

+  LONG m_disableCount;

+  friend COMTable;

+};

+

+class COMTable : public ContextHashtableBase<LPVOID>

+{

+public:

+  COMTable() : ContextHashtableBase<LPVOID>(1021, "COM-Leaks")

+  {

+    m_pMallocSpy = new CMallocSpy(); // wird später durch Release freigegeben

+    if (m_pMallocSpy != NULL)

+    {

+      m_pMallocSpy->m_pComTable = this;

+      // CoInitilize(); // ??? Is this necessary ?

+      HRESULT hr = CoRegisterMallocSpy(m_pMallocSpy);

+      if FAILED(hr)

+      {

+        _tprintf(_T("\nCoRegisterMallocSpay failed with %.8x"), hr);

+      }

+    }

+  }

+

+  virtual ~COMTable()

+  {

+    if (m_pMallocSpy != NULL)

+      m_pMallocSpy->m_pComTable = NULL;

+    CoRevokeMallocSpy();

+  }

+

+  virtual LONG Disable()

+  {

+    return InterlockedIncrement(&(m_pMallocSpy->m_disableCount));

+  }

+  virtual LONG Enable()

+  {

+    return InterlockedDecrement(&(m_pMallocSpy->m_disableCount));

+  }

+

+  virtual SIZE_T HashFunction(LPVOID &key)

+  {

+    // I couldn´t find any better and faster

+#ifdef _M_IX86

+#if _MSC_VER > 1100

+#pragma warning (push)

+#endif

+#pragma warning (disable: 4311)

+    DWORD llP = (DWORD) key;

+#if _MSC_VER > 1100

+#pragma warning (pop)

+#endif

+#else

+    ULONGLONG llP = (ULONGLONG) key;

+#endif

+    return (SIZE_T) llP % sAllocEntries;

+  }

+  virtual BOOL IsKeyEmpty(LPVOID &key)

+  {

+    if (key == 0)

+      return TRUE;

+    return FALSE;

+  }

+  virtual VOID SetEmptyKey(LPVOID &key)

+  {

+    key = 0;

+  }

+  virtual VOID GetKeyAsString(LPVOID &key, CHAR *szName, SIZE_T nBufferLen)

+  {

+#if _MSC_VER < 1400

+    _snprintf_s(szName, nBufferLen, "%p", key);

+#else

+    _snprintf_s(szName, nBufferLen, nBufferLen, "%p", key);

+#endif

+  }

+

+  CMallocSpy *m_pMallocSpy;

+  friend CMallocSpy;

+};  // class COMTable

+

+

+STDMETHODIMP CMallocSpy::QueryInterface(REFIID riid, LPVOID *ppUnk) {

+  HRESULT hr = S_OK;

+  if (IsEqualIID(riid, IID_IUnknown)) {

+      *ppUnk = (IUnknown *) this;

+  }

+  else if (IsEqualIID(riid, IID_IMallocSpy)) {

+      *ppUnk =  (IMalloc *) this;

+  }

+  else {

+      *ppUnk = NULL;

+      hr =  E_NOINTERFACE;

+  }

+  AddRef();

+  return hr;

+}

+STDMETHODIMP_(ULONG) CMallocSpy::AddRef(void) {

+  return (ULONG) InterlockedIncrement(&m_cRef);

+}

+STDMETHODIMP_(ULONG) CMallocSpy::Release(void) {

+  LONG cRef;

+  cRef = InterlockedDecrement(&m_cRef);

+  if (cRef == 0)

+  {

+    delete this;

+  }

+  return (ULONG) cRef;

+} 

+// IMallocSpy methods

+STDMETHODIMP_(SIZE_T) CMallocSpy::PreAlloc(SIZE_T cbRequest) {

+  m_cbRequest = cbRequest;

+  return cbRequest;

+}

+STDMETHODIMP_(void *) CMallocSpy::PostAlloc(void *pActual) {

+  if (m_pComTable != NULL)

+  {

+    CONTEXT c;

+    GET_CURRENT_CONTEXT(c, CONTEXT_FULL);

+    m_pComTable->Insert(pActual, c, m_cbRequest);

+  }

+  return pActual;

+}

+STDMETHODIMP_(void *) CMallocSpy::PreFree(void *pRequest, BOOL fSpyed) {

+  if (m_pComTable != NULL)

+  {

+    m_pComTable->Remove(pRequest);

+  }

+  return pRequest;

+}

+STDMETHODIMP_(SIZE_T) CMallocSpy::PreRealloc(void *pRequest, SIZE_T cbRequest,

+  void **ppNewRequest, BOOL fSpyed) {

+  if (m_pComTable != NULL)

+  {

+    m_pComTable->Remove(pRequest);

+  }

+  *ppNewRequest = pRequest;  // Bug fixed. Thanx to Christoph Weber

+  return cbRequest;

+}

+STDMETHODIMP_(void *) CMallocSpy::PostRealloc(void *pActual, BOOL fSpyed) {

+  if (m_pComTable != NULL)

+  {

+    CONTEXT c;

+    GET_CURRENT_CONTEXT(c, CONTEXT_FULL);

+    m_pComTable->Insert(pActual, c, m_cbRequest);

+  }

+  return pActual;

+}

+

+

+

+

+// ##########################################################################

+// ##########################################################################

+// ##########################################################################

+// Init/Deinit functions

+

+

+static COMTable *g_pCOMTable;

+HRESULT InitLeakFinder()

+{

+  // _X: Disabled COM monitoring: g_pCOMTable = new COMTable();

+#ifdef _DEBUG

+  g_pCRTTable = new CRTTable();

+#endif

+  return S_OK;

+}

+

+void DeinitLeakFinder(LeakFinderOutput *output)

+{

+  LeakFinderOutput *pLeakFinderOutput = output;

+

+#ifdef _DEBUG

+  g_pCRTTable->Disable();

+#endif

+  // _X: Disabled COM monitoring: g_pCOMTable->Disable();

+

+  if (pLeakFinderOutput == NULL)

+    pLeakFinderOutput = new LeakFinderOutput();

+

+  // explicite load the modules:

+  pLeakFinderOutput->LoadModules();

+

+#ifdef _DEBUG

+  g_pCRTTable->ShowLeaks(*pLeakFinderOutput);

+  if (g_pCRTTable != NULL)

+    delete g_pCRTTable;

+  g_pCRTTable = NULL;

+#endif

+

+  /*

+  // _X: Disabled COM monitoring:

+  g_pCOMTable->ShowLeaks(*pLeakFinderOutput);

+  if (g_pCOMTable != NULL)

+    delete g_pCOMTable;

+  g_pCOMTable = NULL;

+  */

+

+  if (output == NULL)

+    delete pLeakFinderOutput;

+}

+void DeinitLeakFinder()

+{

+  DeinitLeakFinder(NULL);

+}