able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/adsi/ndsext/utils/memory.c

746 lines
12 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1990 Microsoft Corporation
Module Name:
memory.c
Abstract:
This module provides all the memory management functions
Author:
Krishna Ganugapati (KrishnaG) 03-Feb-1994
Revision History:
--*/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <imagehlp.h>
#include <stdio.h>
#include <stdlib.h>
#include "debug.h"
#include "memory.h"
#include "symhelp.h"
//#define WORD_ALIGN_DOWN(addr) ((LPBYTE)((DWORD)addr &= ~1))
#define DWORD_ALIGN_UP(size) ((size+3)&~3)
DWORD
MemSizeOri(
LPVOID pMem
);
int
UnicodeToAnsiString(
PCWSTR pszUnicode,
PSTR pszAnsi
)
/*++
Routine Description:
Convert a Unicode string to ansi. If the same string is passed in to the
result string pszAnsi, it will use the same blob of memory.
Arguments:
pszUnicode - the unicode string to be converted to an ansi string
pszAnsi - the result ansi string
Return Value:
--*/
{
PSTR pszTemp = NULL;
int rc = 0;
DWORD dwLength = 0;
dwLength = wcslen(pszUnicode) + 1;
//
// Unfortunately, WideCharToMultiByte doesn't do conversion in place,
// so allocate a temporary buffer, which we can then copy:
//
if(pszAnsi == (PSTR)pszUnicode) {
pszTemp = (PSTR)MemAlloc_E(dwLength);
if (!pszTemp) {
return rc;
}
pszAnsi = pszTemp;
}
if(pszAnsi) {
rc = WideCharToMultiByte( CP_ACP,
0,
pszUnicode,
dwLength,
pszAnsi,
dwLength,
NULL,
NULL );
}
//
// If szTemp is non-null, we must copy the resulting string
// so that it looks as if we did it in place:
//
if( pszTemp && ( rc > 0 ) ) {
pszAnsi = (PSTR)pszUnicode;
strcpy( pszAnsi, pszTemp );
MemFree( pszTemp );
}
return rc;
}
PSTR
AllocateAnsiString(
PCWSTR pszUnicodeString
)
/*++
Routine Description:
Allocate an Ansi string with a unicode string as input
Arguments:
pszUnicodeString - the unicode string to be converted to an ansi string
Return Value:
--*/
{
PSTR pszAnsiString = NULL;
int rc = 0;
ASSERT(pszUnicodeString);
pszAnsiString = (PSTR)MemAlloc(wcslen(pszUnicodeString)+1);
if (pszAnsiString) {
rc = UnicodeToAnsiString(
pszUnicodeString,
pszAnsiString
);
}
if (rc>0) {
return pszAnsiString;
}
if (pszAnsiString) {
MemFree(pszAnsiString);
}
return NULL;
}
int
AnsiToUnicodeString(
PCSTR pszAnsi,
PWSTR pszUnicode
)
/*++
Routine Description:
Convert an ansi string to unicode. An output string of enough size
is expected to be passed in.
Arguments:
pszUnicode - the unicode string to be converted to an ansi string
pszAnsi - the result ansi string
Return Value:
--*/
{
int rc;
DWORD dwLength = strlen(pszAnsi);
rc = MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
pszAnsi,
dwLength + 1,
pszUnicode,
dwLength + 1);
//
// Ensure NULL termination.
//
pszUnicode[dwLength] = 0;
return rc;
}
LPWSTR
AllocateUnicodeString(
PCSTR pszAnsiString
)
/*++
Routine Description:
Allocate a Unicode string with an ansi string as input
Arguments:
pszAnsiString - the ansi string to be converted to a unicode string
Return Value:
--*/
{
PWSTR pszUnicodeString = NULL;
int rc;
ASSERT(pszAnsiString);
pszUnicodeString = (PWSTR)MemAlloc(strlen(pszAnsiString)*sizeof(WCHAR) +
sizeof(WCHAR));
if (pszUnicodeString) {
rc = AnsiToUnicodeString(
pszAnsiString,
pszUnicodeString
);
}
if (rc>0) {
return pszUnicodeString;
}
if (pszUnicodeString) {
MemFree(pszUnicodeString);
}
return NULL;
}
PSTR MemAllocStr_E(
PSTR pszIn
)
{
PSTR pszTemp;
pszTemp = (PSTR)MemAlloc_E((strlen(pszIn)+1)*sizeof(char));
if (pszTemp==NULL) {
return NULL;
}
return strcpy(pszTemp, pszIn);
}
PWSTR MemAllocStrW_E(
PWSTR pszIn
)
{
PWSTR pszTemp;
pszTemp = (PWSTR)MemAlloc_E((wcslen(pszIn)+1)*sizeof(WCHAR));
if (pszTemp==NULL) {
return NULL;
}
return wcscpy(pszTemp, pszIn);
}
LPVOID MemAlloc_E(
DWORD dwBytes
)
{
LPVOID pReturn = NULL;
pReturn = MemAlloc(dwBytes);
if (!pReturn) {
RaiseException(LL_MEMORY_ERROR, 0, 0, NULL);
}
return pReturn;
}
LPVOID MemRealloc_E(
LPVOID IpMem,
DWORD dwBytes
)
{
DWORD dwSize;
LPVOID pReturn = NULL;
dwSize = MemSizeOri(IpMem);
pReturn = MemRealloc(IpMem,dwSize,dwBytes);
if (!pReturn) {
RaiseException(LL_MEMORY_ERROR, 0, 0, NULL);
}
return pReturn;
}
#if DBG
DWORD dwMemoryLog = 1;
#define MAXDEPTH 10
typedef struct _MEMTAG {
DWORD Tag ;
DWORD Size ;
PVOID pvBackTrace[MAXDEPTH+1];
LPSTR pszSymbol[MAXDEPTH+1];
DWORD uDepth;
LIST_ENTRY List ;
} MEMTAG, *PMEMTAG ;
LIST_ENTRY MemList ;
DWORD MemCount ;
CRITICAL_SECTION MemCritSect ;
/*++
Routine Description:
This function initializes the mem tracking code. Must be call
during DLL load an ONLY during DLL load.
Arguments:
None
Return Value:
None.
--*/
VOID InitMem(
VOID
)
{
InitializeCriticalSection(&MemCritSect) ;
InitializeListHead(&MemList) ;
MemCount = 0 ;
}
/*++
Routine Description:
This function asserts that the mem list is empty on exit.
Arguments:
None
Return Value:
None.
--*/
VOID AssertMemLeaks(
VOID
)
{
ASSERT(IsListEmpty(&MemList)) ;
}
#endif
LPVOID
MemAlloc(
DWORD cb
)
/*++
Routine Description:
This function will allocate local memory. It will possibly allocate extra
memory and fill this with debugging information for the debugging version.
Arguments:
cb - The amount of memory to allocate
Return Value:
NON-NULL - A pointer to the allocated memory
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
#if DBG
DWORD cbNew ;
PMEMTAG pMem ;
DWORD i = 0;
ULONG ulHash;
//
// adjust size for our tag and one spare dword at end
// and allocate the memory
//
cb = DWORD_ALIGN_UP(cb);
cbNew = cb + ( sizeof(MEMTAG) + sizeof(DWORD) );
pMem=(PMEMTAG)LocalAlloc(LPTR, cbNew);
if (!pMem) {
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return 0;
}
//
// fill in deadbeef at end and tag info.
// and insert it into the MemList
//
*(LPDWORD)((LPBYTE)pMem+cbNew-sizeof(DWORD)) = 0xdeadbeef;
pMem->Tag = 0xB00FB00F ;
pMem->Size = cb ;
//
// Capture a backtrace at this spot for debugging.
//
#if (defined(i386) && !defined(WIN95))
pMem->uDepth = RtlCaptureStackBackTrace(
0,
MAXDEPTH,
pMem->pvBackTrace,
&ulHash
);
#else
pMem->uDepth = 0;
#endif
EnterCriticalSection(&MemCritSect) ;
InsertHeadList(&MemList, &pMem->List) ;
MemCount++ ;
LeaveCriticalSection(&MemCritSect) ;
//
// skip past the mem tag
//
pMem++ ;
return (LPVOID)(pMem);
#else
return(LocalAlloc(LPTR, cb));
#endif
}
BOOL
MemFree(
LPVOID pMem
)
{
#if DBG
DWORD cb;
DWORD cbNew = 0;
PMEMTAG pNewMem ;
LPDWORD pRetAddr;
DWORD i = 0;
pNewMem = (PMEMTAG)pMem;
pNewMem -- ;
cb = pNewMem->Size;
cbNew = cb + sizeof(DWORD) + sizeof(MEMTAG);
//
// check the trailing deadbeef and remove from list
//
if (*(LPDWORD)(((LPBYTE)pNewMem) + cbNew - sizeof(DWORD)) != 0xdeadbeef) {
ERR(("Freeing memory not allocated by MemAlloc"));
return FALSE;
}
EnterCriticalSection(&MemCritSect) ;
RemoveEntryList(&pNewMem->List) ;
MemCount-- ;
LeaveCriticalSection(&MemCritSect) ;
for (i = 0; i < pNewMem->uDepth; i++) {
if (pNewMem->pszSymbol[i]) {
LocalFree(pNewMem->pszSymbol[i]);
}
}
//
// Whack freed memory with known pattern
//
memset(pMem, 0x65, cb);
return(LocalFree((LPVOID)pNewMem) == NULL);
#else
return(LocalFree(pMem) == NULL);
#endif
}
DWORD
MemSize(
LPVOID pMem
)
{
#if DBG
DWORD cb;
DWORD cbNew = 0;
PMEMTAG pNewMem ;
LPDWORD pRetAddr;
DWORD i = 0;
pNewMem = (PMEMTAG)pMem;
pNewMem -- ;
cb = pNewMem->Size;
cbNew = cb + sizeof(DWORD) + sizeof(MEMTAG);
if (*(LPDWORD)(((LPBYTE)pNewMem) + cbNew - sizeof(DWORD)) != 0xdeadbeef) {
ERR(("Getting size not allocated by MemAlloc!"));
return 0;
}
return((DWORD)LocalSize((LPVOID)pNewMem));
#else
return((DWORD)LocalSize(pMem));
#endif
}
DWORD
MemSizeOri(
LPVOID pMem
)
{
#if DBG
DWORD cb;
PMEMTAG pNewMem ;
pNewMem = (PMEMTAG)pMem;
pNewMem -- ;
cb = pNewMem->Size;
return((DWORD)cb);
#else
return((DWORD)LocalSize(pMem));
#endif
}
LPVOID
MemRealloc(
LPVOID pOldMem,
DWORD cbOld,
DWORD cbNew
)
{
LPVOID pNewMem;
pNewMem=MemAlloc(cbNew);
if (pOldMem && pNewMem) {
memcpy(pNewMem, pOldMem, min(cbNew, cbOld));
MemFree(pOldMem);
}
return pNewMem;
}
LPSTR
MemAllocStr(
LPSTR pStr
)
/*++
Routine Description:
This function will allocate enough local memory to store the specified
string, and copy that string to the allocated memory
Arguments:
pStr - Pointer to the string that needs to be allocated and stored
Return Value:
NON-NULL - A pointer to the allocated memory containing the string
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
LPSTR pMem;
if (!pStr)
return 0;
if (pMem = (LPSTR)MemAlloc( strlen(pStr)*sizeof(CHAR) + sizeof(CHAR) ))
strcpy(pMem, pStr);
return pMem;
}
PWSTR
MemAllocStrW(
PWSTR pStr
)
/*++
Routine Description:
This function will allocate enough local memory to store the specified
string, and copy that string to the allocated memory
Arguments:
pStr - Pointer to the string that needs to be allocated and stored
Return Value:
NON-NULL - A pointer to the allocated memory containing the string
FALSE/NULL - The operation failed. Extended error status is available
using GetLastError.
--*/
{
PWSTR pMem;
if (!pStr)
return 0;
if (pMem = (PWSTR)MemAlloc( wcslen(pStr)*sizeof(WCHAR) + sizeof(WCHAR) ))
wcscpy(pMem, pStr);
return pMem;
}
BOOL
MemReallocStr(
LPSTR *ppStr,
LPSTR pStr
)
{
if (ppStr && (*ppStr)) {
MemFree(*ppStr);
*ppStr=MemAllocStr(pStr);
return TRUE;
}
else {
return FALSE;
}
}
#if DBG
VOID
DumpMemoryTracker(
VOID
)
{
#ifndef _WIN64
LIST_ENTRY* pEntry;
MEMTAG* pMem;
BYTE* pTemp;
DWORD i = 0;
CHAR szSymbolPath[MAX_PATH+1];
DWORD dwCount = 0;
pEntry = MemList.Flink;
if (!dwMemoryLog) {
return;
}
if ( pEntry == &MemList ) {
OutputDebugStringA( "No Memory leaks found\n" );
}
while( pEntry != &MemList )
{
CHAR szLeak[1024];
pTemp = (BYTE*)pEntry;
pTemp = pTemp - sizeof(DWORD) - sizeof(DWORD)
- sizeof(DWORD) -
(sizeof(CHAR*) + sizeof(LPVOID))*( MAXDEPTH +1);
pMem = (MEMTAG*)pTemp;
sprintf(
szLeak,
"[oleds] Memory leak!!! Addresss = %.8x Size = %ld \n",
pMem + 1,
pMem->Size
);
OutputDebugStringA( szLeak );
for (i = 0; i < pMem->uDepth; i++) {
dwCount = TranslateAddress(
(ULONG)pMem->pvBackTrace[ i ],
szSymbolPath,
MAX_PATH
);
szSymbolPath[dwCount] = '\0';
sprintf(szLeak, "%s\n",szSymbolPath);
OutputDebugStringA( szLeak);
}
pEntry = pEntry->Flink;
}
#endif
}
#endif
Reference in a new issue Copy permalink