/********************************************************************* * _heapchk (MSVCRT.@) */ int CDECL _heapchk(void) { if (!HeapValidate(heap, 0, NULL) || (sb_heap && !HeapValidate(sb_heap, 0, NULL))) { msvcrt_set_errno(GetLastError()); return MSVCRT__HEAPBADNODE; } return MSVCRT__HEAPOK; }
HIDDEN void TSTRACEValidateHeaps() { #ifdef DEBUG_HEAP if ( _heapchk() != _HEAPOK ) { CkmError("***** HEAP DAMAGE DETECTED *****"); LOG(CallTrace, "Error: ***** HEAP DAMAGE DETECTED *****"); DebugBreak(); } #endif #ifdef DEBUG_PROCESS_HEAP tsByteString buffer; DWORD heapCount; buffer.resize (sizeof(HANDLE)); heapCount = GetProcessHeaps(1, (PHANDLE)buffer.rawData()); if ( heapCount > 1 ) { buffer.resize(sizeof(HANDLE) * heapCount); heapCount = GetProcessHeaps(heapCount, (PHANDLE)buffer.rawData()); } for (int ii = 0; ii < heapCount; ii++) { if ( !HeapValidate(((PHANDLE)buffer.rawData())[ii], 0, NULL) ) { CkmError("***** PROCESS HEAP DAMAGE DETECTED *****"); LOG(CallTrace, "Error: ***** PROCESS HEAP DAMAGE DETECTED *****"); // DebugBreak(); } } #endif // DEBUG_PROCESS_HEAP }
int __cdecl _ic_heapwalk (struct _ic_heapinfo_t *phi) { PROCESS_HEAP_ENTRY phe; DWORD e; if (!phi) { ic_errno = IC_EINVAL; IC_INV_PARAM("Invalid argument"); return IC_HEAP_BAD_POINTER; } ic_memset (&phe, 0, sizeof (phe)); if (!(phe.lpData = phi->_pentry)) { if (!HeapWalk (_ic_theheap, &phe)) { if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) { _ic_doserrno = ERROR_CALL_NOT_IMPLEMENTED; ic_errno = IC_ENOSYS; return IC_HEAP_END; } return IC_HEAP_BAD_BEGIN; } } else { if (phi->_useflag == 1) { if (!HeapValidate (_ic_theheap, 0, phi->_pentry)) return IC_HEAP_BAD_NODE; phe.wFlags = PROCESS_HEAP_ENTRY_BUSY; } do { if (!HeapWalk (_ic_theheap, &phe)) { if ((e = GetLastError ()) == ERROR_NO_MORE_ITEMS) return IC_HEAP_END; if (e != ERROR_CALL_NOT_IMPLEMENTED) return IC_HEAP_BAD_NODE; _ic_doserrno = e; ic_errno = IC_ENOSYS; return IC_HEAP_END; } } while ((phe.wFlags & (PROCESS_HEAP_REGION | PROCESS_HEAP_UNCOMMITTED_RANGE)) != 0); } phi->_pentry = phe.lpData; phi->_size = phe.cbData; phi->_useflag = (phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) != 0; return IC_HEAP_OK; }
bool __cdecl xf_validate(void * _Memory /*= NULL*/) { _ASSERTE(ghHeap); #ifdef TRACK_MEMORY_ALLOCATIONS if (_Memory) { int nCCcmp; xf_mem_block* p = ((xf_mem_block*)_Memory)-1; if (p->bBlockUsed == TRUE) { nCCcmp = memcmp(((LPBYTE)_Memory)+p->nBlockSize, "\xCC\xCC\xCC\xCC\xCC\xCC\xCC\xCC", 8); _ASSERTE(nCCcmp == 0); } else { _ASSERTE(p->bBlockUsed == TRUE); } _Memory = (void*)p; } #endif BOOL b = HeapValidate(ghHeap, 0, _Memory); return (b!=FALSE); }
static void* msvcrt_heap_realloc(DWORD flags, void *ptr, MSVCRT_size_t size) { if(sb_heap && ptr && !HeapValidate(heap, 0, ptr)) { /* TODO: move data to normal heap if it exceeds sbh_threshold limit */ void *memblock, *temp, **saved; MSVCRT_size_t old_padding, new_padding, old_size; saved = SAVED_PTR(ptr); old_padding = (char*)ptr - (char*)*saved; old_size = HeapSize(sb_heap, 0, *saved); if(old_size == -1) return NULL; old_size -= old_padding; temp = HeapReAlloc(sb_heap, flags, *saved, size+sizeof(void*)+SB_HEAP_ALIGN); if(!temp) return NULL; memblock = ALIGN_PTR(temp, SB_HEAP_ALIGN, 0); saved = SAVED_PTR(memblock); new_padding = (char*)memblock - (char*)temp; if(new_padding != old_padding) memmove(memblock, (char*)temp+old_padding, old_size>size ? size : old_size); *saved = temp; return memblock; } return HeapReAlloc(heap, flags, ptr, size); }
extern "C" void MemFree(void *lpMem) { if (lpMem == NULL) return; if (HeapValidate(GetProcessHeap(),0,lpMem)) HeapFree(GetProcessHeap(),0,lpMem); }
inline static void _win32_freeMem( void *ptr ) { if ( ptr ) { MEM_INTERRUPT( HeapValidate( g_privateHeap, 0, ptr ) ); HeapFree( g_privateHeap, 0, ptr ); } }
BOOL STDMETHODCALLTYPE UtilExecutionEngine::ClrHeapValidate(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem) { #ifdef FEATURE_PAL return FALSE; #else return HeapValidate(hHeap, dwFlags, lpMem); #endif }
/********************************************************************* * _heapchk (MSVCRT.@) */ int CDECL _heapchk(void) { if (!HeapValidate( GetProcessHeap(), 0, NULL)) { _dosmaperr(GetLastError()); return _HEAPBADNODE; } return _HEAPOK; }
/********************************************************************* * _heapchk (MSVCRT.@) */ int CDECL _heapchk(void) { if (!HeapValidate( GetProcessHeap(), 0, NULL)) { msvcrt_set_errno(GetLastError()); return MSVCRT__HEAPBADNODE; } return MSVCRT__HEAPOK; }
int __cdecl _heapchk(void) { if ( !HeapValidate( _crtheap, 0, NULL ) ) { return _HEAPBADNODE; } else { return _HEAPOK; } }
MX_EXPORT int mx_heap_pointer_is_valid( void *pointer ) { if ( pointer == NULL ) { return FALSE; } else { return HeapValidate( GetProcessHeap(), 0, pointer ); } }
static MSVCRT_size_t msvcrt_heap_size(void *ptr) { if(sb_heap && ptr && !HeapValidate(heap, 0, ptr)) { void **saved = SAVED_PTR(ptr); return HeapSize(sb_heap, 0, *saved); } return HeapSize(heap, 0, ptr); }
int __cdecl _heapchk(void) { int retcode = _HEAPOK; if (!HeapValidate(_crtheap, 0, NULL) && (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)) { retcode = _HEAPBADNODE; } return retcode; }
void *pgp_realloc(void *orig, long newLen) { #ifdef PGP_MACINTOSH Ptr newSpace; long oldLen; if(orig) SetPtrSize((Ptr)orig, newLen); else orig=NewPtr(newLen); if(MemError()) { if((newSpace = NewPtr(newLen)) != NULL) { oldLen=GetPtrSize((Ptr)orig); BlockMove(orig, newSpace, oldLen); DisposePtr((Ptr)orig); orig=newSpace; } else orig = NIL; } return orig; #elif PGP_WIN32 void *ptr = NULL; #ifdef _DEBUG if (!HeapValidate(heapID, 0, NULL)) DebugLog("validation failed before reallocating %d bytes at %p", newLen, ptr); #endif // _DEBUG ptr = HeapReAlloc(heapID, HEAP_GENERATE_EXCEPTIONS|HEAP_ZERO_MEMORY, ptr, newLen); #ifdef _DEBUG if (!HeapValidate(heapID, 0, NULL)) DebugLog("validation failed after reallocating %d bytes at %p", newLen, ptr); #endif // _DEBUG return ptr; #endif // PGP_WIN32 }
static BOOL msvcrt_heap_free(void *ptr) { if(sb_heap && ptr && !HeapValidate(heap, 0, ptr)) { void **saved = SAVED_PTR(ptr); return HeapFree(sb_heap, 0, *saved); } return HeapFree(heap, 0, ptr); }
void pgp_free(void *freePtr) { #ifdef PGP_MACINTOSH /*long len = GetPtrSize((Ptr)freePtr); DebugLog("free:%ld\r",GetPtrSize((Ptr)freePtr));*/ DisposePtr((Ptr)freePtr); #elif PGP_WIN32 #ifdef _DEBUG if (!HeapValidate(heapID, 0, NULL)) DebugLog("validation failed before freeing %p", freePtr); #endif // _DEBUG HeapFree(heapID, 0, freePtr); #ifdef _DEBUG if (!HeapValidate(heapID, 0, NULL)) DebugLog("validation failed after freeing %p", freePtr); #endif // _DEBUG #endif // PGP_WIN32 }
void CHECKHEAP() // Validate all the heaps in this process { HANDLE rgHeap[100]; DWORD cHeap = GetProcessHeaps(100, rgHeap); ASSERT(cHeap > 0 && cHeap <= 100); for (ULONG iHeap=0; iHeap<cHeap; iHeap++) { ASSERT(HeapValidate(rgHeap[iHeap],0,NULL)); } }
static inline BOOLEAN FspNpValidateEnum(FSP_NP_ENUM *Enum) { #if 0 return 0 != Enum && HeapValidate(GetProcessHeap(), 0, Enum) && 'munE' == Enum->Signature; #else return 0 != Enum && 'munE' == Enum->Signature; #endif }
int __cdecl _ic_heapchk (void) { if (HeapValidate (_ic_theheap, 0, NULL)) return IC_HEAP_OK; if (GetLastError () != ERROR_CALL_NOT_IMPLEMENTED) return IC_HEAP_BAD_NODE; _ic_doserrno = ERROR_CALL_NOT_IMPLEMENTED; ic_errno = IC_ENOSYS; return IC_HEAP_OK; }
bool __cdecl xf_validate(void * _Memory /*= NULL*/) { _ASSERTE(ghHeap); #ifdef TRACK_MEMORY_ALLOCATIONS if (_Memory) { xf_mem_block* p = ((xf_mem_block*)_Memory)-1; _ASSERTE(p->bBlockUsed == TRUE); _Memory = (void*)p; } #endif BOOL b = HeapValidate(ghHeap, 0, _Memory); return (b!=FALSE); }
/* * @unimplemented */ int __getmainargs(int* argc, char*** argv, char*** env, int flag) { int i, afterlastspace, ignorespace, len, doexpand; /* missing threading init */ i = 0; afterlastspace = 0; ignorespace = 0; doexpand = flag; len = strlen(_acmdln); while (_acmdln[i]) { if (_acmdln[i] == '"') { if(ignorespace) { ignorespace = 0; } else { ignorespace = 1; doexpand = 0; } memmove(_acmdln + i, _acmdln + i + 1, len - i); len--; continue; } if (_acmdln[i] == ' ' && !ignorespace) { expand(strndup(_acmdln + afterlastspace, i - afterlastspace), doexpand); i++; while (_acmdln[i]==' ') i++; afterlastspace=i; doexpand = flag; } else { i++; } } if (_acmdln[afterlastspace] != 0) { expand(strndup(_acmdln+afterlastspace, i - afterlastspace), doexpand); } HeapValidate(hHeap, 0, NULL); *argc = __argc; *argv = __argv; *env = _environ; _pgmptr = strdup((char*)argv[0]); return 0; }
int __cdecl _heapset ( unsigned int _fill ) { int _retval = _HEAPOK; PROCESS_HEAP_ENTRY Entry; if ( !HeapValidate( _crtheap, 0, NULL ) ) { return _HEAPBADNODE; } if ( !HeapLock( _crtheap ) ) { return _HEAPBADBEGIN; } Entry.lpData = NULL; __try { while (TRUE) { if (!HeapWalk( _crtheap, &Entry )) { if (GetLastError() != ERROR_NO_MORE_ITEMS) { _retval = _HEAPBADNODE; } break; } if (Entry.wFlags & (PROCESS_HEAP_REGION | PROCESS_HEAP_UNCOMMITTED_RANGE)) { continue; } if (!(Entry.wFlags & PROCESS_HEAP_ENTRY_BUSY)) { __try { memset( Entry.lpData, _fill, Entry.cbData ); } __except( EXCEPTION_EXECUTE_HANDLER ) { // Chicago free blocks may contain uncommitted pages. Punt } } } }
int __cdecl _heapchk (void) { int retcode = _HEAPOK; _mlock(_HEAP_LOCK); if ( __sbh_heap_check() < 0 ) retcode = _HEAPBADNODE; _munlock(_HEAP_LOCK); if (!HeapValidate(_crtheap, 0, NULL)) { if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) { _doserrno = ERROR_CALL_NOT_IMPLEMENTED; errno = ENOSYS; } else retcode = _HEAPBADNODE; } return retcode; }
/********************************************************************* * _heapwalk (MSVCRT.@) */ int CDECL _heapwalk(struct MSVCRT__heapinfo* next) { PROCESS_HEAP_ENTRY phe; if (sb_heap) FIXME("small blocks heap not supported\n"); LOCK_HEAP; phe.lpData = next->_pentry; phe.cbData = next->_size; phe.wFlags = next->_useflag == MSVCRT__USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0; if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY && !HeapValidate( heap, 0, phe.lpData )) { UNLOCK_HEAP; msvcrt_set_errno(GetLastError()); return MSVCRT__HEAPBADNODE; } do { if (!HeapWalk( heap, &phe )) { UNLOCK_HEAP; if (GetLastError() == ERROR_NO_MORE_ITEMS) return MSVCRT__HEAPEND; msvcrt_set_errno(GetLastError()); if (!phe.lpData) return MSVCRT__HEAPBADBEGIN; return MSVCRT__HEAPBADNODE; } } while (phe.wFlags & (PROCESS_HEAP_REGION|PROCESS_HEAP_UNCOMMITTED_RANGE)); UNLOCK_HEAP; next->_pentry = phe.lpData; next->_size = phe.cbData; next->_useflag = phe.wFlags & PROCESS_HEAP_ENTRY_BUSY ? MSVCRT__USEDENTRY : MSVCRT__FREEENTRY; return MSVCRT__HEAPOK; }
void _BochsRpcServer::CheckHeap() { if (debug_heap) { ::std::lock_guard<::std::mutex> l(heap_lock); if (!HeapValidate(RpcDataHeap.get(), 0, NULL)) { OutputDebugStringA("bochs-rpc: RpcHeap is in a invalid state\n"); return; } if (heap_alloc_set.size() != 0) { OutputDebugStringA("bochs-rpc: RpcHeap is not completely freed\n"); ::std::stringstream buf; for (auto i = heap_alloc_set.begin(), j = heap_alloc_set.end(); i != j; ++i) { buf << "\t heap block: [" << *i << "]\n"; } OutputDebugStringA(buf.str().c_str()); } } }
//----------------------------------------------------------------------------- // Check the consistency of the heap on which all the PLC program stuff is // stored. //----------------------------------------------------------------------------- void CheckHeap(char *file, int line) { static unsigned int SkippedCalls; static SDWORD LastCallTime; SDWORD now = GetTickCount(); // It slows us down too much to do the check every time we are called; // but let's still do the check periodically; let's do it every 70 // calls or every 20 ms, whichever is sooner. if(SkippedCalls < 70 && (now - LastCallTime) < 20) { SkippedCalls++; return; } SkippedCalls = 0; LastCallTime = now; if(!HeapValidate(MainHeap, 0, NULL)) { dbp("file %s line %d", file, line); Error("Noticed memory corruption at file '%s' line %d.", file, line); oops(); } }
/********************************************************************* * _heapwalk (MSVCRT.@) */ int CDECL _heapwalk(_HEAPINFO* next) { PROCESS_HEAP_ENTRY phe; LOCK_HEAP; phe.lpData = next->_pentry; phe.cbData = (DWORD)next->_size; phe.wFlags = next->_useflag == _USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0; if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY && !HeapValidate( GetProcessHeap(), 0, phe.lpData )) { UNLOCK_HEAP; _dosmaperr(GetLastError()); return _HEAPBADNODE; } do { if (!HeapWalk( GetProcessHeap(), &phe )) { UNLOCK_HEAP; if (GetLastError() == ERROR_NO_MORE_ITEMS) return _HEAPEND; _dosmaperr(GetLastError()); if (!phe.lpData) return _HEAPBADBEGIN; return _HEAPBADNODE; } } while (phe.wFlags & (PROCESS_HEAP_REGION|PROCESS_HEAP_UNCOMMITTED_RANGE)); UNLOCK_HEAP; next->_pentry = phe.lpData; next->_size = phe.cbData; next->_useflag = phe.wFlags & PROCESS_HEAP_ENTRY_BUSY ? _USEDENTRY : _FREEENTRY; return _HEAPOK; }
/* * @implemented */ int _heapchk(void) { if (!HeapValidate(GetProcessHeap(), 0, NULL)) return -1; return 0; }
/* * @implemented */ void __wgetmainargs(int* argc, wchar_t*** wargv, wchar_t*** wenv, int expand_wildcards, int* new_mode) { int i, afterlastspace, ignorespace, doexpand; size_t len; wchar_t* wNewCmdln; /* missing threading init */ i = 0; afterlastspace = 0; ignorespace = 0; doexpand = expand_wildcards; if (__wargv && __winitenv) { *wargv = __wargv; *wenv = __winitenv; *argc = __argc; return; } __argc = 0; len = wcslen(_wcmdln); /* Allocate a temporary buffer to be used instead of the original _wcmdln parameter. */ wNewCmdln = wcsndup(_wcmdln, len); while (wNewCmdln[i]) { if (wNewCmdln[i] == L'"') { if(ignorespace) { ignorespace = 0; } else { ignorespace = 1; doexpand = 0; } memmove(wNewCmdln + i, wNewCmdln + i + 1, (len - i) * sizeof(wchar_t)); len--; continue; } if (wNewCmdln[i] == L' ' && !ignorespace) { wexpand(wcsndup(wNewCmdln + afterlastspace, i - afterlastspace), doexpand); i++; while (wNewCmdln[i] == L' ') i++; afterlastspace=i; doexpand = expand_wildcards; } else { i++; } } if (wNewCmdln[afterlastspace] != 0) { wexpand(wcsndup(wNewCmdln + afterlastspace, i - afterlastspace), doexpand); } /* Free the temporary buffer. */ free(wNewCmdln); HeapValidate(GetProcessHeap(), 0, NULL); *argc = __argc; if (__wargv == NULL) { __wargv = (wchar_t**)malloc(sizeof(wchar_t*)); __wargv[0] = 0; } *wargv = __wargv; *wenv = __winitenv; _wpgmptr = _wcsdup(__wargv[0]); // if (new_mode) _set_new_mode(*new_mode); }