static
BOOLEAN
ReAllocBuffer(
PUCHAR *Buffer,
SIZE_T Size,
SIZE_T *OldSizePtr,
PCSTR Action)
{
PUCHAR NewBuffer;
SIZE_T OldSize = *OldSizePtr;
RtlFillMemory(*Buffer, OldSize, 0x7a);
NewBuffer = RtlReAllocateHeap(RtlGetProcessHeap(),
HEAP_ZERO_MEMORY,
*Buffer,
Size);
if (!NewBuffer)
{
skip("RtlReAllocateHeap failed for size %lu (%s)\n", Size, Action);
return FALSE;
}
*Buffer = NewBuffer;
ok_hex(RtlSizeHeap(RtlGetProcessHeap(), 0, NewBuffer), Size);
if (OldSize < Size)
{
ok(CheckBuffer(NewBuffer, OldSize, 0x7a), "CheckBuffer failed at size 0x%lx -> 0x%lx\n", OldSize, Size);
ok(CheckBuffer(NewBuffer + OldSize, Size - OldSize, 0), "HEAP_ZERO_MEMORY not respected for 0x%lx -> 0x%lx\n", OldSize, Size);
}
else
{
ok(CheckBuffer(NewBuffer, Size, 0x7a), "CheckBuffer failed at size 0x%lx -> 0x%lx\n", OldSize, Size);
}
*OldSizePtr = Size;
return TRUE;
}
SIZE_T WINAPI
redirect_RtlSizeHeap(HANDLE heap, ULONG flags, byte *ptr)
{
if (redirect_heap_call(heap) && is_dynamo_address(ptr)/*see above*/) {
ASSERT(IF_CLIENT_INTERFACE_ELSE(INTERNAL_OPTION(privlib_privheap), true));
if (ptr != NULL)
return wrapped_dr_size(ptr);
else
return 0;
} else {
return RtlSizeHeap(heap, flags, ptr);
}
}
SIZE_T NTAPI
RtlDebugSizeHeap(HANDLE HeapPtr,
ULONG Flags,
PVOID Ptr)
{
PHEAP Heap = (PHEAP)HeapPtr;
BOOLEAN HeapLocked = FALSE;
PHEAP_ENTRY HeapEntry;
SIZE_T Result = ~(SIZE_T)0;
if (Heap->ForceFlags & HEAP_FLAG_PAGE_ALLOCS)
return RtlpPageHeapSize(HeapPtr, Flags, Ptr);
/* Check heap signature */
if (Heap->Signature != HEAP_SIGNATURE)
{
DPRINT1("HEAP: Invalid heap %p signature 0x%x\n", Heap, Heap->Signature);
return FALSE;
}
/* Add skip validation flag */
Flags |= Heap->ForceFlags | HEAP_SKIP_VALIDATION_CHECKS;
/* Lock the heap ourselves */
if (!(Flags & HEAP_NO_SERIALIZE))
{
RtlEnterHeapLock(Heap->LockVariable, TRUE);
HeapLocked = TRUE;
/* Add no serialize flag so that the main routine won't try to acquire the lock again */
Flags |= HEAP_NO_SERIALIZE;
}
/* Validate the heap if necessary */
RtlpValidateHeap(Heap, FALSE);
/* Get the existing heap entry */
HeapEntry = (PHEAP_ENTRY)Ptr - 1;
/* Validate it */
if (RtlpValidateHeapEntry(Heap, HeapEntry))
{
/* If it succeeded - call the main routine */
Result = RtlSizeHeap(HeapPtr, Flags, Ptr);
}
/* Release the lock */
if (HeapLocked) RtlLeaveHeapLock(Heap->LockVariable);
return Result;
}
BOOL WINAPI
redirect_RtlFreeHeap(HANDLE heap, ULONG flags, byte *ptr)
{
if (redirect_heap_call(heap) && is_dynamo_address(ptr)/*see above*/) {
ASSERT(IF_CLIENT_INTERFACE_ELSE(INTERNAL_OPTION(privlib_privheap), true));
if (ptr != NULL) {
LOG(GLOBAL, LOG_LOADER, 2, "%s "PFX"\n", __FUNCTION__, ptr);
wrapped_dr_free(ptr);
return TRUE;
} else
return FALSE;
} else {
LOG(GLOBAL, LOG_LOADER, 2, "native %s "PFX" "PIFX"\n", __FUNCTION__,
ptr, (ptr == NULL ? 0 : RtlSizeHeap(heap, flags, ptr)));
return RtlFreeHeap(heap, flags, ptr);
}
}
/*
* @implemented
*/
size_t __cdecl _msize(void* _ptr)
{
return RtlSizeHeap(RtlGetProcessHeap(), 0, _ptr);
}
SIZE_T WINAPI HeapSize( HANDLE heap, DWORD flags, LPCVOID ptr )
{
return RtlSizeHeap( heap, flags, ptr );
}