--- /dev/null
+/*
+ * PROJECT: ReactOS Win32 Base API
+ * LICENSE: GPL - See COPYING in the top level directory
+ * FILE: dll/win32/kernel32/client/heapmem.c
+ * PURPOSE: Heap Memory APIs (wrappers for RtlHeap*)
+ * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
+ */
+
+/* INCLUDES *******************************************************************/
+
+#include <k32.h>
+
+#define NDEBUG
+#include <debug.h>
+
+/* GLOBALS ********************************************************************/
+
+RTL_HANDLE_TABLE BaseHeapHandleTable;
+HANDLE BaseHeap;
+ULONG_PTR SystemRangeStart;
+
+/* PRIVATE FUNCTIONS **********************************************************/
+
+VOID
+NTAPI
+BaseDllInitializeMemoryManager(VOID)
+{
+ BaseHeap = RtlGetProcessHeap();
+ RtlInitializeHandleTable(0xFFFF,
+ sizeof(BASE_HEAP_HANDLE_ENTRY),
+ &BaseHeapHandleTable);
+ NtQuerySystemInformation(SystemRangeStartInformation,
+ &SystemRangeStart,
+ sizeof(SystemRangeStart),
+ NULL);
+}
+
+/* PUBLIC FUNCTIONS ***********************************************************/
+
+/*
+ * @implemented
+ */
+HANDLE
+WINAPI
+HeapCreate(DWORD flOptions,
+ SIZE_T dwInitialSize,
+ SIZE_T dwMaximumSize)
+{
+ HANDLE hRet;
+ ULONG Flags;
+
+ /* Remove non-Win32 flags and tag this allocation */
+ Flags = (flOptions & (HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE)) |
+ HEAP_CLASS_1;
+
+ /* Check if heap is growable and ensure max size is correct */
+ if (dwMaximumSize == 0)
+ Flags |= HEAP_GROWABLE;
+ else if (dwMaximumSize < BaseStaticServerData->SysInfo.PageSize &&
+ dwInitialSize > dwMaximumSize)
+ {
+ /* Max size is non-zero but less than page size which can't be correct.
+ Fix it up by bumping it to the initial size whatever it is. */
+ dwMaximumSize = dwInitialSize;
+ }
+
+ /* Call RTL Heap */
+ hRet = RtlCreateHeap(Flags,
+ NULL,
+ dwMaximumSize,
+ dwInitialSize,
+ NULL,
+ NULL);
+
+ /* Set the last error if we failed, and return the pointer */
+ if (!hRet) SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ return hRet;
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+HeapDestroy(HANDLE hHeap)
+{
+ /* Return TRUE if the heap was destroyed */
+ if (!RtlDestroyHeap(hHeap)) return TRUE;
+
+ /* Otherwise, we got the handle back, so fail */
+ SetLastError(ERROR_INVALID_HANDLE);
+ return FALSE;
+}
+
+/*
+ * @implemented
+ */
+HANDLE
+WINAPI
+GetProcessHeap(VOID)
+{
+ /* Call the RTL API */
+ return RtlGetProcessHeap();
+}
+
+/*
+ * @implemented
+ */
+DWORD
+WINAPI
+GetProcessHeaps(DWORD NumberOfHeaps,
+ PHANDLE ProcessHeaps)
+{
+ /* Call the RTL API */
+ return RtlGetProcessHeaps(NumberOfHeaps, ProcessHeaps);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+HeapLock(HANDLE hHeap)
+{
+ /* Call the RTL API */
+ return RtlLockHeap(hHeap);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+HeapUnlock(HANDLE hHeap)
+{
+ /* Call the RTL API */
+ return RtlUnlockHeap(hHeap);
+}
+
+/*
+ * @implemented
+ */
+SIZE_T
+WINAPI
+HeapCompact(HANDLE hHeap, DWORD dwFlags)
+{
+ /* Call the RTL API */
+ return RtlCompactHeap(hHeap, dwFlags);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+HeapValidate(HANDLE hHeap,
+ DWORD dwFlags,
+ LPCVOID lpMem)
+{
+ /* Call the RTL API */
+ return RtlValidateHeap(hHeap, dwFlags, (PVOID)lpMem);
+}
+
+/*
+ * @implemented
+ */
+DWORD
+WINAPI
+HeapCreateTagsW(HANDLE hHeap,
+ DWORD dwFlags,
+ PWSTR lpTagName,
+ PWSTR lpTagSubName)
+{
+ /* Call the RTL API */
+ return RtlCreateTagHeap(hHeap,
+ dwFlags,
+ lpTagName,
+ lpTagSubName);
+}
+
+/*
+ * @implemented
+ */
+DWORD
+WINAPI
+HeapExtend(HANDLE hHeap,
+ DWORD dwFlags,
+ PVOID BaseAddress,
+ DWORD dwBytes)
+{
+ NTSTATUS Status;
+
+ /* Call the RTL API. Gone in Vista, so commented out. */
+ Status = STATUS_NOT_IMPLEMENTED; //RtlExtendHeap(hHeap, dwFlags, BaseAddress, dwBytes);
+ if (!NT_SUCCESS(Status))
+ {
+ /* We failed */
+ BaseSetLastNTError(Status);
+ return FALSE;
+ }
+
+ /* Return success */
+ return TRUE;
+}
+
+/*
+ * @implemented
+ */
+PWSTR
+WINAPI
+HeapQueryTagW(HANDLE hHeap,
+ DWORD dwFlags,
+ WORD wTagIndex,
+ BOOL bResetCounters,
+ PVOID lpTagInfo)
+{
+ /* Call the RTL API */
+ return RtlQueryTagHeap(hHeap,
+ dwFlags,
+ wTagIndex,
+ (BOOLEAN)bResetCounters,
+ lpTagInfo);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+HeapSummary(HANDLE hHeap,
+ DWORD dwFlags,
+ PVOID Summary)
+{
+ NTSTATUS Status;
+ RTL_HEAP_USAGE Usage;
+
+ /* Fill in the length information */
+ Usage.Length = sizeof(Usage);
+
+ /* Call RTL. Gone in Vista, so commented out */
+ Status = STATUS_NOT_IMPLEMENTED; //RtlUsageHeap(hHeap, dwFlags, &Usage);
+ if (!NT_SUCCESS(Status))
+ {
+ /* We failed */
+ BaseSetLastNTError(Status);
+ return FALSE;
+ }
+
+ /* FIXME: Summary == Usage?! */
+ RtlCopyMemory(Summary, &Usage, sizeof(Usage));
+ return TRUE;
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+HeapUsage(HANDLE hHeap,
+ DWORD dwFlags,
+ DWORD Unknown,
+ DWORD Unknown2,
+ IN PVOID Usage)
+{
+ NTSTATUS Status;
+
+ /* Call RTL. Gone in Vista, so commented out */
+ Status = STATUS_NOT_IMPLEMENTED; //RtlUsageHeap(hHeap, dwFlags, &Usage);
+ if (!NT_SUCCESS(Status))
+ {
+ /* We failed */
+ BaseSetLastNTError(Status);
+ return FALSE;
+ }
+ else if (Status == STATUS_MORE_ENTRIES)
+ {
+ /* There are still more entries to parse */
+ return TRUE;
+ }
+
+ /* Otherwise, we're completely done, so we return FALSE, but NO_ERROR */
+ SetLastError(NO_ERROR);
+ return FALSE;
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+HeapWalk(HANDLE hHeap,
+ LPPROCESS_HEAP_ENTRY lpEntry)
+{
+ NTSTATUS Status;
+
+ DPRINT1("Warning, HeapWalk is calling RtlWalkHeap with Win32 parameters\n");
+
+ Status = RtlWalkHeap(hHeap, lpEntry);
+
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastError(RtlNtStatusToDosError(Status));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+HeapQueryInformation(HANDLE HeapHandle,
+ HEAP_INFORMATION_CLASS HeapInformationClass,
+ PVOID HeapInformation OPTIONAL,
+ SIZE_T HeapInformationLength OPTIONAL,
+ PSIZE_T ReturnLength OPTIONAL)
+{
+ NTSTATUS Status;
+
+ Status = RtlQueryHeapInformation(HeapHandle,
+ HeapInformationClass,
+ HeapInformation,
+ HeapInformationLength,
+ ReturnLength);
+
+ if (!NT_SUCCESS(Status))
+ {
+ BaseSetLastNTError(Status);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+HeapSetInformation(HANDLE HeapHandle,
+ HEAP_INFORMATION_CLASS HeapInformationClass,
+ PVOID HeapInformation OPTIONAL,
+ SIZE_T HeapInformationLength OPTIONAL)
+{
+ NTSTATUS Status;
+
+ Status = RtlSetHeapInformation(HeapHandle,
+ HeapInformationClass,
+ HeapInformation,
+ HeapInformationLength);
+
+ if (!NT_SUCCESS(Status))
+ {
+ BaseSetLastNTError(Status);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/*
+ * @implemented
+ */
+HGLOBAL
+NTAPI
+GlobalAlloc(UINT uFlags,
+ SIZE_T dwBytes)
+{
+ ULONG Flags = 0;
+ PVOID Ptr = NULL;
+ HANDLE hMemory;
+ PBASE_HEAP_HANDLE_ENTRY HandleEntry;
+ BASE_TRACE_ALLOC(dwBytes, uFlags);
+ ASSERT(BaseHeap);
+
+ /* Make sure the flags are valid */
+ if (uFlags & ~GMEM_VALID_FLAGS)
+ {
+ /* They aren't, fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ /* Convert ZEROINIT */
+ if (uFlags & GMEM_ZEROINIT) Flags |= HEAP_ZERO_MEMORY;
+
+ /* Check if we're not movable, which means pointer-based heap */
+ if (!(uFlags & GMEM_MOVEABLE))
+ {
+ /* Check if this is DDESHARE (deprecated) */
+ if (uFlags & GMEM_DDESHARE) Flags |= BASE_HEAP_ENTRY_FLAG_DDESHARE;
+
+ /* Allocate heap for it */
+ Ptr = RtlAllocateHeap(BaseHeap, Flags, dwBytes ? dwBytes : 1);
+ if (!Ptr) SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ BASE_TRACE_ALLOC2(Ptr);
+ return Ptr;
+ }
+
+ /* This is heap based, so lock it in first */
+ RtlLockHeap(BaseHeap);
+
+ /*
+ * Disable locking, enable custom flags, and write the
+ * movable flag (deprecated)
+ */
+ Flags |= HEAP_NO_SERIALIZE |
+ HEAP_SETTABLE_USER_VALUE |
+ BASE_HEAP_FLAG_MOVABLE;
+
+ /* Allocate the handle */
+ HandleEntry = BaseHeapAllocEntry();
+ if (!HandleEntry)
+ {
+ /* Fail */
+ hMemory = NULL;
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ BASE_TRACE_FAILURE();
+ }
+ else
+ {
+ /* Get the object and make sure we have size */
+ hMemory = &HandleEntry->Object;
+ if (dwBytes)
+ {
+ /* Allocate the actual memory for it */
+ Ptr = RtlAllocateHeap(BaseHeap, Flags, dwBytes);
+ BASE_TRACE_PTR(HandleEntry, Ptr);
+ if (!Ptr)
+ {
+ /* We failed, manually set the allocate flag and free the handle */
+ HandleEntry->Flags = RTL_HANDLE_VALID;
+ BaseHeapFreeEntry(HandleEntry);
+
+ /* For the cleanup case */
+ HandleEntry = NULL;
+ }
+ else
+ {
+ /* All worked well, save our heap entry */
+ RtlSetUserValueHeap(BaseHeap, HEAP_NO_SERIALIZE, Ptr, hMemory);
+ }
+ }
+ }
+
+ /* Cleanup! First unlock the heap */
+ RtlUnlockHeap(BaseHeap);
+
+ /* Check if a handle was allocated */
+ if (HandleEntry)
+ {
+ /* Set the pointer and allocated flag */
+ HandleEntry->Object = Ptr;
+ HandleEntry->Flags = RTL_HANDLE_VALID;
+ if (!Ptr)
+ {
+ /* We don't have a valid pointer, but so reuse this handle */
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSE;
+ }
+
+ /* Check if the handle is discardable */
+ if (uFlags & GMEM_DISCARDABLE)
+ {
+ /* Save it in the handle entry */
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSABLE;
+ }
+
+ /* Check if the handle is moveable */
+ if (uFlags & GMEM_MOVEABLE)
+ {
+ /* Save it in the handle entry */
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_MOVABLE;
+ }
+
+ /* Check if the handle is DDE Shared */
+ if (uFlags & GMEM_DDESHARE)
+ {
+ /* Save it in the handle entry */
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_DDESHARE;
+ }
+
+ /* Set the pointer */
+ Ptr = hMemory;
+ }
+
+ /* Return the pointer */
+ return Ptr;
+}
+
+/*
+ * @implemented
+ */
+SIZE_T
+NTAPI
+GlobalCompact(DWORD dwMinFree)
+{
+ /* Call the RTL Heap Manager */
+ return RtlCompactHeap(BaseHeap, 0);
+}
+
+/*
+ * @implemented
+ */
+VOID
+NTAPI
+GlobalFix(HGLOBAL hMem)
+{
+ /* Lock the memory if it the handle is valid */
+ if (INVALID_HANDLE_VALUE != hMem) GlobalLock(hMem);
+}
+
+/*
+ * @implemented
+ */
+UINT
+NTAPI
+GlobalFlags(HGLOBAL hMem)
+{
+ PBASE_HEAP_HANDLE_ENTRY HandleEntry;
+ HANDLE Handle = NULL;
+ ULONG Flags = 0;
+ UINT uFlags = GMEM_INVALID_HANDLE;
+
+ /* Start by locking the heap */
+ RtlLockHeap(BaseHeap);
+ _SEH2_TRY
+ {
+ /* Check if this is a simple RTL Heap Managed block */
+ if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY))
+ {
+ /* Then we'll query RTL Heap */
+ RtlGetUserInfoHeap(BaseHeap, Flags, hMem, &Handle, &Flags);
+ BASE_TRACE_PTR(Handle, hMem);
+
+ /*
+ * Check if RTL Heap didn't find a handle associated with us or
+ * said that this heap isn't movable, which means something we're
+ * really not a handle-based heap.
+ */
+ if (!(Handle) || !(Flags & BASE_HEAP_FLAG_MOVABLE))
+ {
+ /* Then set the flags to 0 */
+ uFlags = 0;
+ }
+ else
+ {
+ /* Otherwise we're handle-based, so get the internal handle */
+ hMem = Handle;
+ }
+ }
+
+ /* Check if the handle is actually an entry in our table */
+ if ((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)
+ {
+ /* Then get the entry */
+ HandleEntry = BaseHeapGetEntry(hMem);
+ BASE_TRACE_HANDLE(HandleEntry, hMem);
+
+ /* Make sure it's a valid handle */
+ if (BaseHeapValidateEntry(HandleEntry))
+ {
+ /* Get the lock count first */
+ uFlags = HandleEntry->LockCount & GMEM_LOCKCOUNT;
+
+ /* Now check if it's discardable */
+ if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_REUSABLE)
+ {
+ /* Set the Win32 Flag */
+ uFlags |= GMEM_DISCARDABLE;
+ }
+
+ /* Check if it's DDE Shared */
+ if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_DDESHARE)
+ {
+ /* Set the Win32 Flag */
+ uFlags |= GMEM_DDESHARE;
+ }
+
+ /* Now check if it's discarded */
+ if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_REUSE)
+ {
+ /* Set the Win32 Flag */
+ uFlags |= GMEM_DISCARDED;
+ }
+ }
+ }
+
+ /* Check if by now, we still haven't gotten any useful flags */
+ if (uFlags == GMEM_INVALID_HANDLE) SetLastError(ERROR_INVALID_HANDLE);
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ /* Set the exception code */
+ BaseSetLastNTError(_SEH2_GetExceptionCode());
+ }
+ _SEH2_END;
+
+ /* All done! Unlock heap and return Win32 Flags */
+ RtlUnlockHeap(BaseHeap);
+ return uFlags;
+}
+
+/*
+ * @implemented
+ */
+HGLOBAL
+NTAPI
+GlobalFree(HGLOBAL hMem)
+{
+ PBASE_HEAP_HANDLE_ENTRY HandleEntry;
+ LPVOID Ptr;
+ BASE_TRACE_DEALLOC(hMem);
+
+ /* Check if this was a simple allocated heap entry */
+ if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY))
+ {
+ /* Free it with the RTL Heap Manager */
+ if (RtlFreeHeap(BaseHeap, 0, hMem))
+ {
+ /* Return NULL since there's no handle */
+ return NULL;
+ }
+ else
+ {
+ /* Otherwise fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_INVALID_HANDLE);
+ return hMem;
+ }
+ }
+
+ /* It's a handle probably, so lock the heap */
+ RtlLockHeap(BaseHeap);
+ _SEH2_TRY
+ {
+ /* Make sure that this is an entry in our handle database */
+ if ((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)
+ {
+ /* Get the entry */
+ HandleEntry = BaseHeapGetEntry(hMem);
+ BASE_TRACE_HANDLE(HandleEntry, hMem);
+
+ /* Make sure the handle is valid */
+ if (!BaseHeapValidateEntry(HandleEntry))
+ {
+ /* It's not, fail */
+ SetLastError(ERROR_INVALID_HANDLE);
+ Ptr = NULL;
+ }
+ else
+ {
+ /* It's valid, so get the pointer */
+ Ptr = HandleEntry->Object;
+
+ /* Free this handle */
+ BaseHeapFreeEntry(HandleEntry);
+
+ /* If the pointer is 0, then we don't have a handle either */
+ if (!Ptr) hMem = NULL;
+ }
+ }
+ else
+ {
+ /* Otherwise, reuse the handle as a pointer */
+ BASE_TRACE_FAILURE();
+ Ptr = hMem;
+ }
+
+ /* Check if we got here with a valid heap pointer */
+ if (Ptr)
+ {
+ /* Free it with the RTL Heap Manager */
+ if (RtlFreeHeap(BaseHeap, HEAP_NO_SERIALIZE, Ptr))
+ {
+ /* Everything worked */
+ hMem = NULL;
+ }
+ else
+ {
+ /* This wasn't a real heap handle */
+ SetLastError(ERROR_INVALID_HANDLE);
+ }
+ }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ /* Set the exception code */
+ BaseSetLastNTError(_SEH2_GetExceptionCode());
+ }
+ _SEH2_END;
+
+ /* We're done, so unlock the heap and return the handle */
+ RtlUnlockHeap(BaseHeap);
+ return hMem;
+}
+
+/*
+ * @implemented
+ */
+HGLOBAL
+NTAPI
+GlobalHandle(LPCVOID pMem)
+{
+ HANDLE Handle = NULL;
+ ULONG Flags;
+
+ /* Lock the heap */
+ RtlLockHeap(BaseHeap);
+ _SEH2_TRY
+ {
+ /* Query RTL Heap */
+ if (!RtlGetUserInfoHeap(BaseHeap,
+ HEAP_NO_SERIALIZE,
+ (PVOID)pMem,
+ &Handle,
+ &Flags))
+ {
+ /* RTL Heap Manager does not know about this heap */
+ SetLastError(ERROR_INVALID_HANDLE);
+ }
+ else
+ {
+ /*
+ * Check if RTL Heap didn't find a handle for us or said that
+ * this heap isn't movable.
+ */
+ BASE_TRACE_PTR(Handle, pMem);
+ if (!(Handle) || !(Flags & BASE_HEAP_FLAG_MOVABLE))
+ {
+ /* We're actually handle-based, so the pointer is a handle */
+ Handle = (HANDLE)pMem;
+ }
+ }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ /* Set the exception code */
+ BaseSetLastNTError(_SEH2_GetExceptionCode());
+ }
+ _SEH2_END;
+
+ /* All done, unlock the heap and return the handle */
+ RtlUnlockHeap(BaseHeap);
+ return Handle;
+}
+
+/*
+ * @implemented
+ */
+LPVOID
+NTAPI
+GlobalLock(HGLOBAL hMem)
+{
+ PBASE_HEAP_HANDLE_ENTRY HandleEntry;
+ LPVOID Ptr;
+
+ /* Check if this was a simple allocated heap entry */
+ if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY))
+ {
+ /* Make sure it's not a kernel or invalid address */
+ if ((hMem >= (HGLOBAL)SystemRangeStart) || (IsBadReadPtr(hMem, 1)))
+ {
+ /* Signal an error */
+ SetLastError(ERROR_INVALID_HANDLE);
+ return NULL;
+ }
+
+ /* It's all good */
+ return hMem;
+ }
+
+ /* Otherwise, lock the heap */
+ RtlLockHeap(BaseHeap);
+ _SEH2_TRY
+ {
+ /* Get the handle entry */
+ HandleEntry = BaseHeapGetEntry(hMem);
+ BASE_TRACE_HANDLE(HandleEntry, hMem);
+
+ /* Make sure it's valid */
+ if (!BaseHeapValidateEntry(HandleEntry))
+ {
+ /* It's not, fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_INVALID_HANDLE);
+ Ptr = NULL;
+ }
+ else
+ {
+ /* Otherwise, get the pointer */
+ Ptr = HandleEntry->Object;
+ if (Ptr)
+ {
+ /* Increase the lock count, unless we've went too far */
+ if (HandleEntry->LockCount++ == GMEM_LOCKCOUNT)
+ {
+ /* In which case we simply unlock once */
+ HandleEntry->LockCount--;
+ }
+ }
+ else
+ {
+ /* The handle is still there but the memory was already freed */
+ SetLastError(ERROR_DISCARDED);
+ }
+ }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ SetLastError(ERROR_INVALID_HANDLE);
+ Ptr = NULL;
+ }
+ _SEH2_END;
+
+ /* All done. Unlock the heap and return the pointer */
+ RtlUnlockHeap(BaseHeap);
+ return Ptr;
+}
+
+HGLOBAL
+NTAPI
+GlobalReAlloc(HGLOBAL hMem,
+ SIZE_T dwBytes,
+ UINT uFlags)
+{
+ PBASE_HEAP_HANDLE_ENTRY HandleEntry;
+ HANDLE Handle;
+ LPVOID Ptr;
+ ULONG Flags = 0;
+
+ /* Throw out invalid flags */
+ if (uFlags & ~(GMEM_VALID_FLAGS | GMEM_MODIFY))
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ /* Throw out invalid combo */
+ if ((uFlags & GMEM_DISCARDABLE) && !(uFlags & GMEM_MODIFY))
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ /* Convert ZEROINIT */
+ if (uFlags & GMEM_ZEROINIT) Flags |= HEAP_ZERO_MEMORY;
+
+ /* If this wasn't a movable heap, then we MUST re-alloc in place */
+ if (!(uFlags & GMEM_MOVEABLE)) Flags |= HEAP_REALLOC_IN_PLACE_ONLY;
+
+ /* Lock the heap and disable built-in locking in the RTL Heap functions */
+ RtlLockHeap(BaseHeap);
+ Flags |= HEAP_NO_SERIALIZE;
+
+ /* Check if this is a simple handle-based block */
+ if (((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY))
+ {
+ /* Get the entry */
+ HandleEntry = BaseHeapGetEntry(hMem);
+ BASE_TRACE_HANDLE(HandleEntry, hMem);
+
+ /* Make sure the handle is valid */
+ if (!BaseHeapValidateEntry(HandleEntry))
+ {
+ /* Fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_INVALID_HANDLE);
+ hMem = NULL;
+ }
+ else if (uFlags & GMEM_MODIFY)
+ {
+ /* User is changing flags... check if the memory was discardable */
+ if (uFlags & GMEM_DISCARDABLE)
+ {
+ /* Then set the flag */
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSABLE;
+ }
+ else
+ {
+ /* Otherwise, remove the flag */
+ HandleEntry->Flags &= ~BASE_HEAP_ENTRY_FLAG_REUSABLE;
+ }
+ }
+ else
+ {
+ /* Otherwise, get the object and check if we have no size */
+ Ptr = HandleEntry->Object;
+ if (!dwBytes)
+ {
+ /* Clear the handle and check for a pointer */
+ hMem = NULL;
+ if (Ptr)
+ {
+ /* Make sure the handle isn't locked */
+ if ((uFlags & GMEM_MOVEABLE) && !(HandleEntry->LockCount))
+ {
+ /* Free the current heap */
+ if (RtlFreeHeap(BaseHeap, Flags, Ptr))
+ {
+ /* Free the handle */
+ HandleEntry->Object = NULL;
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSE;
+
+ /* Get the object pointer */
+ hMem = &HandleEntry->Object;
+ }
+ }
+ }
+ else
+ {
+ /* Otherwise just return the object pointer */
+ hMem = &HandleEntry->Object;
+ }
+ }
+ else
+ {
+ /* Otherwise, we're allocating, so set the new flags needed */
+ Flags |= HEAP_SETTABLE_USER_VALUE | BASE_HEAP_FLAG_MOVABLE;
+ if (!Ptr)
+ {
+ /* We don't have a base, so allocate one */
+ Ptr = RtlAllocateHeap(BaseHeap, Flags, dwBytes);
+ BASE_TRACE_ALLOC2(Ptr);
+ if (Ptr)
+ {
+ /* Allocation succeeded, so save our entry */
+ RtlSetUserValueHeap(BaseHeap,
+ HEAP_NO_SERIALIZE,
+ Ptr,
+ hMem);
+ }
+ }
+ else
+ {
+ /*
+ * If it's not movable or currently locked, we MUST allocate
+ * in-place!
+ */
+ if (!(uFlags & GMEM_MOVEABLE) && (HandleEntry->LockCount))
+ {
+ /* Set the flag */
+ Flags |= HEAP_REALLOC_IN_PLACE_ONLY;
+ }
+ else
+ {
+ /* Otherwise clear the flag if we set it previously */
+ Flags &= ~HEAP_REALLOC_IN_PLACE_ONLY;
+ }
+
+ /* Do the re-allocation. No need to save the entry again */
+ Ptr = RtlReAllocateHeap(BaseHeap, Flags, Ptr, dwBytes);
+ }
+
+ /* Make sure we have a pointer by now */
+ if (Ptr)
+ {
+ /* Write it in the handle entry and mark it in use */
+ HandleEntry->Object = Ptr;
+ HandleEntry->Flags &= ~BASE_HEAP_ENTRY_FLAG_REUSE;
+ }
+ else
+ {
+ /* Otherwise we failed */
+ hMem = NULL;
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ }
+ }
+ }
+ }
+ else if (uFlags & GMEM_MODIFY)
+ {
+ /* This is not a handle-based heap and the caller wants it to be one */
+ if (uFlags & GMEM_MOVEABLE)
+ {
+ /* Get information on its current state */
+ Handle = hMem;
+ if (RtlGetUserInfoHeap(BaseHeap,
+ HEAP_NO_SERIALIZE,
+ hMem,
+ &Handle,
+ NULL))
+ {
+ /*
+ * Check if the handle matches the pointer or the moveable flag
+ * isn't there, which is what we expect since it currently isn't.
+ */
+ if ((Handle == hMem) || !(Flags & BASE_HEAP_FLAG_MOVABLE))
+ {
+ /* Allocate a handle for it */
+ HandleEntry = BaseHeapAllocEntry();
+ if (!HandleEntry)
+ {
+ /* No entry could be allocated */
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ RtlUnlockHeap(BaseHeap);
+ return NULL;
+ }
+
+ /* Calculate the size of the current heap */
+ dwBytes = RtlSizeHeap(BaseHeap, HEAP_NO_SERIALIZE, hMem);
+
+ /* Set the movable flag */
+ Flags |= HEAP_SETTABLE_USER_VALUE | BASE_HEAP_FLAG_MOVABLE;
+
+ /* Now allocate the actual heap for it */
+ HandleEntry->Object = RtlAllocateHeap(BaseHeap,
+ Flags,
+ dwBytes);
+ BASE_TRACE_PTR(HandleEntry->Object, HandleEntry);
+ if (!HandleEntry->Object)
+ {
+ /*
+ * We failed, manually set the allocate flag and
+ * free the handle
+ */
+ HandleEntry->Flags = RTL_HANDLE_VALID;
+ BaseHeapFreeEntry(HandleEntry);
+
+ /* For the cleanup case */
+ BASE_TRACE_FAILURE();
+ HandleEntry = NULL;
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ }
+ else
+ {
+ /* Otherwise, copy the new heap and free the old one */
+ RtlMoveMemory(HandleEntry->Object, hMem, dwBytes);
+ RtlFreeHeap(BaseHeap, HEAP_NO_SERIALIZE, hMem);
+
+ /* Select the heap pointer */
+ hMem = (HANDLE)&HandleEntry->Object;
+
+ /* Initialize the count and default flags */
+ HandleEntry->LockCount = 0;
+ HandleEntry->Flags = RTL_HANDLE_VALID |
+ BASE_HEAP_ENTRY_FLAG_MOVABLE;
+
+ /* Check if it's also discardable */
+ if (uFlags & GMEM_DISCARDABLE)
+ {
+ /* Set the internal flag */
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSABLE;
+ }
+
+ /* Check if it's also DDE Shared */
+ if (uFlags & GMEM_DDESHARE)
+ {
+ /* Set the internal flag */
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_DDESHARE;
+ }
+
+ /* Allocation succeeded, so save our entry */
+ RtlSetUserValueHeap(BaseHeap,
+ HEAP_NO_SERIALIZE,
+ HandleEntry->Object,
+ hMem);
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ /* Otherwise, this is a simple RTL Managed Heap, so just call it */
+ hMem = RtlReAllocateHeap(BaseHeap,
+ Flags | HEAP_NO_SERIALIZE,
+ hMem,
+ dwBytes);
+ if (!hMem)
+ {
+ /* Fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ }
+ }
+
+ /* All done, unlock the heap and return the pointer */
+ RtlUnlockHeap(BaseHeap);
+ return hMem;
+}
+
+/*
+ * @implemented
+ */
+SIZE_T
+NTAPI
+GlobalSize(HGLOBAL hMem)
+{
+ PBASE_HEAP_HANDLE_ENTRY HandleEntry;
+ PVOID Handle = NULL;
+ ULONG Flags = 0;
+ SIZE_T dwSize = MAXULONG_PTR;
+
+ /* Lock the heap */
+ RtlLockHeap(BaseHeap);
+ _SEH2_TRY
+ {
+ /* Check if this is a simple RTL Heap Managed block */
+ if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY))
+ {
+ /* Then we'll query RTL Heap */
+ if (RtlGetUserInfoHeap(BaseHeap, Flags, hMem, &Handle, &Flags))
+ {
+ BASE_TRACE_PTR(Handle, hMem);
+ /*
+ * Check if RTL Heap didn't give us a handle or said that this
+ * heap isn't movable.
+ */
+ if (!(Handle) || !(Flags & BASE_HEAP_FLAG_MOVABLE))
+ {
+ /* We're not a handle heap, so use the generic call */
+ dwSize = RtlSizeHeap(BaseHeap, HEAP_NO_SERIALIZE, hMem);
+ }
+ else
+ {
+ /* We're a handle heap so get the internal handle */
+ hMem = Handle;
+ }
+ }
+ }
+
+ /* Make sure that this is an entry in our handle database */
+ if ((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)
+ {
+ /* Get the entry */
+ HandleEntry = BaseHeapGetEntry(hMem);
+ BASE_TRACE_HANDLE(HandleEntry, hMem);
+
+ /* Make sure the handle is valid */
+ if (!BaseHeapValidateEntry(HandleEntry))
+ {
+ /* Fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_INVALID_HANDLE);
+ }
+ else if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_REUSE)
+ {
+ /* We've reused this block, but we've saved the size for you */
+ dwSize = HandleEntry->OldSize;
+ }
+ else
+ {
+ /* Otherwise, query RTL about it */
+ dwSize = RtlSizeHeap(BaseHeap,
+ HEAP_NO_SERIALIZE,
+ HandleEntry->Object);
+ }
+ }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ /* Set failure for later */
+ dwSize = MAXULONG_PTR;
+ }
+ _SEH2_END;
+
+ /* Check if by now, we still haven't gotten any useful size */
+ if (dwSize == MAXULONG_PTR)
+ {
+ /* Fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_INVALID_HANDLE);
+ dwSize = 0;
+ }
+
+ /* All done! Unlock heap and return the size */
+ RtlUnlockHeap(BaseHeap);
+ return dwSize;
+}
+
+/*
+ * @implemented
+ */
+VOID
+NTAPI
+GlobalUnfix(HGLOBAL hMem)
+{
+ /* If the handle is valid, unlock it */
+ if (hMem != INVALID_HANDLE_VALUE) GlobalUnlock(hMem);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+NTAPI
+GlobalUnlock(HGLOBAL hMem)
+{
+ PBASE_HEAP_HANDLE_ENTRY HandleEntry;
+ BOOL RetVal = TRUE;
+
+ /* Check if this was a simple allocated heap entry */
+ if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)) return RetVal;
+
+ /* Otherwise, lock the heap */
+ RtlLockHeap(BaseHeap);
+
+ /* Get the handle entry */
+ HandleEntry = BaseHeapGetEntry(hMem);
+ BASE_TRACE_HANDLE(HandleEntry, hMem);
+
+ _SEH2_TRY
+ {
+ /* Make sure it's valid */
+ if (!BaseHeapValidateEntry(HandleEntry))
+ {
+ /* It's not, fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_INVALID_HANDLE);
+ RetVal = FALSE;
+ }
+ else
+ {
+ /* Otherwise, decrement lock count, unless we're already at 0*/
+ if (!HandleEntry->LockCount--)
+ {
+ /* In which case we simply lock it back and fail */
+ HandleEntry->LockCount++;
+ SetLastError(ERROR_NOT_LOCKED);
+ RetVal = FALSE;
+ }
+ else if (!HandleEntry->LockCount)
+ {
+ /* Nothing to unlock */
+ SetLastError(NO_ERROR);
+ RetVal = FALSE;
+ }
+ }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ RetVal = FALSE;
+ }
+ _SEH2_END;
+
+ /* All done. Unlock the heap and return the pointer */
+ RtlUnlockHeap(BaseHeap);
+ return RetVal;
+}
+
+/*
+ * @implemented
+ */
+BOOL
+NTAPI
+GlobalUnWire(HGLOBAL hMem)
+{
+ /* This is simply an unlock */
+ return GlobalUnlock(hMem);
+}
+
+/*
+ * @implemented
+ */
+LPVOID
+NTAPI
+GlobalWire(HGLOBAL hMem)
+{
+ /* This is just a lock */
+ return GlobalLock(hMem);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+NTAPI
+GlobalMemoryStatusEx(LPMEMORYSTATUSEX lpBuffer)
+{
+ SYSTEM_PERFORMANCE_INFORMATION PerformanceInfo;
+ VM_COUNTERS VmCounters;
+ QUOTA_LIMITS QuotaLimits;
+ ULONGLONG PageFile, PhysicalMemory;
+
+ if (lpBuffer->dwLength != sizeof(*lpBuffer))
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+
+ /* Query performance information */
+ NtQuerySystemInformation(SystemPerformanceInformation,
+ &PerformanceInfo,
+ sizeof(PerformanceInfo),
+ NULL);
+
+ /* Calculate memory load */
+ lpBuffer->dwMemoryLoad = ((DWORD)(BaseStaticServerData->SysInfo.NumberOfPhysicalPages -
+ PerformanceInfo.AvailablePages) * 100) /
+ BaseStaticServerData->SysInfo.NumberOfPhysicalPages;
+
+ /* Save physical memory */
+ PhysicalMemory = BaseStaticServerData->SysInfo.NumberOfPhysicalPages *
+ BaseStaticServerData->SysInfo.PageSize;
+ lpBuffer->ullTotalPhys = PhysicalMemory;
+
+ /* Now save available physical memory */
+ PhysicalMemory = PerformanceInfo.AvailablePages *
+ BaseStaticServerData->SysInfo.PageSize;
+ lpBuffer->ullAvailPhys = PhysicalMemory;
+
+ /* Query VM and Quota Limits */
+ NtQueryInformationProcess(NtCurrentProcess(),
+ ProcessQuotaLimits,
+ &QuotaLimits,
+ sizeof(QUOTA_LIMITS),
+ NULL);
+ NtQueryInformationProcess(NtCurrentProcess(),
+ ProcessVmCounters,
+ &VmCounters,
+ sizeof(VM_COUNTERS),
+ NULL);
+
+ /* Save the commit limit */
+ lpBuffer->ullTotalPageFile = min(QuotaLimits.PagefileLimit,
+ PerformanceInfo.CommitLimit);
+ lpBuffer->ullTotalPageFile *= BaseStaticServerData->SysInfo.PageSize;
+
+ /* Calculate how many pages are left */
+ PageFile = PerformanceInfo.CommitLimit - PerformanceInfo.CommittedPages;
+
+ /* Save the total */
+ lpBuffer->ullAvailPageFile = min(PageFile,
+ QuotaLimits.PagefileLimit -
+ VmCounters.PagefileUsage);
+ lpBuffer->ullAvailPageFile *= BaseStaticServerData->SysInfo.PageSize;
+
+ /* Now calculate the total virtual space */
+ lpBuffer->ullTotalVirtual = (BaseStaticServerData->SysInfo.MaximumUserModeAddress -
+ BaseStaticServerData->SysInfo.MinimumUserModeAddress) + 1;
+
+ /* And finally the available virtual space */
+ lpBuffer->ullAvailVirtual = lpBuffer->ullTotalVirtual - VmCounters.VirtualSize;
+ lpBuffer->ullAvailExtendedVirtual = 0;
+
+ return TRUE;
+}
+
+/*
+ * @implemented
+ */
+VOID
+NTAPI
+GlobalMemoryStatus(LPMEMORYSTATUS lpBuffer)
+{
+ MEMORYSTATUSEX lpBufferEx;
+
+ /* Call the extended function */
+ lpBufferEx.dwLength = sizeof(MEMORYSTATUSEX);
+ if (GlobalMemoryStatusEx(&lpBufferEx))
+ {
+ /* Reset the right size and fill out the information */
+ lpBuffer->dwLength = sizeof(MEMORYSTATUS);
+ lpBuffer->dwMemoryLoad = lpBufferEx.dwMemoryLoad;
+ lpBuffer->dwTotalPhys = (SIZE_T)min(lpBufferEx.ullTotalPhys, MAXULONG_PTR);
+ lpBuffer->dwAvailPhys = (SIZE_T)min(lpBufferEx.ullAvailPhys, MAXULONG_PTR);
+ lpBuffer->dwTotalPageFile = (SIZE_T)min(lpBufferEx.ullTotalPageFile, MAXULONG_PTR);
+ lpBuffer->dwAvailPageFile = (SIZE_T)min(lpBufferEx.ullAvailPageFile, MAXULONG_PTR);
+ lpBuffer->dwTotalVirtual = (SIZE_T)min(lpBufferEx.ullTotalVirtual, MAXULONG_PTR);
+ lpBuffer->dwAvailVirtual = (SIZE_T)min(lpBufferEx.ullAvailVirtual, MAXULONG_PTR);
+ }
+}
+
+/*
+ * @implemented
+ */
+HLOCAL
+NTAPI
+LocalAlloc(UINT uFlags,
+ SIZE_T dwBytes)
+{
+ ULONG Flags = 0;
+ PVOID Ptr = NULL;
+ HANDLE hMemory;
+ PBASE_HEAP_HANDLE_ENTRY HandleEntry;
+ BASE_TRACE_ALLOC(dwBytes, uFlags);
+ ASSERT(BaseHeap);
+
+ /* Make sure the flags are valid */
+ if (uFlags & ~LMEM_VALID_FLAGS)
+ {
+ /* They aren't, fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return NULL;
+ }
+
+ /* Convert ZEROINIT */
+ if (uFlags & LMEM_ZEROINIT) Flags |= HEAP_ZERO_MEMORY;
+
+ /* Check if we're not movable, which means pointer-based heap */
+ if (!(uFlags & LMEM_MOVEABLE))
+ {
+ /* Allocate heap for it */
+ Ptr = RtlAllocateHeap(BaseHeap, Flags, dwBytes);
+ BASE_TRACE_ALLOC2(Ptr);
+ return Ptr;
+ }
+
+ /* This is heap based, so lock it in first */
+ RtlLockHeap(BaseHeap);
+
+ /*
+ * Disable locking, enable custom flags, and write the
+ * movable flag (deprecated)
+ */
+ Flags |= HEAP_NO_SERIALIZE |
+ HEAP_SETTABLE_USER_VALUE |
+ BASE_HEAP_FLAG_MOVABLE;
+
+ /* Allocate the handle */
+ HandleEntry = BaseHeapAllocEntry();
+ if (!HandleEntry)
+ {
+ /* Fail */
+ hMemory = NULL;
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ BASE_TRACE_FAILURE();
+ goto Quickie;
+ }
+
+ /* Get the object and make sure we have size */
+ hMemory = &HandleEntry->Object;
+ if (dwBytes)
+ {
+ /* Allocate the actual memory for it */
+ Ptr = RtlAllocateHeap(BaseHeap, Flags, dwBytes);
+ BASE_TRACE_PTR(HandleEntry, Ptr);
+ if (!Ptr)
+ {
+ /* We failed, manually set the allocate flag and free the handle */
+ HandleEntry->Flags = RTL_HANDLE_VALID;
+ BaseHeapFreeEntry(HandleEntry);
+
+ /* For the cleanup case */
+ HandleEntry = NULL;
+ }
+ else
+ {
+ /* All worked well, save our heap entry */
+ RtlSetUserValueHeap(BaseHeap, HEAP_NO_SERIALIZE, Ptr, hMemory);
+ }
+ }
+
+Quickie:
+ /* Cleanup! First unlock the heap */
+ RtlUnlockHeap(BaseHeap);
+
+ /* Check if a handle was allocated */
+ if (HandleEntry)
+ {
+ /* Set the pointer and allocated flag */
+ HandleEntry->Object = Ptr;
+ HandleEntry->Flags = RTL_HANDLE_VALID;
+ if (!Ptr)
+ {
+ /* We don't have a valid pointer, but so reuse this handle */
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSE;
+ }
+
+ /* Check if the handle is discardable */
+ if (uFlags & GMEM_DISCARDABLE)
+ {
+ /* Save it in the handle entry */
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSABLE;
+ }
+
+ /* Check if the handle is moveable */
+ if (uFlags & GMEM_MOVEABLE)
+ {
+ /* Save it in the handle entry */
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_MOVABLE;
+ }
+
+ /* Set the pointer */
+ Ptr = hMemory;
+ }
+
+ /* Return the pointer */
+ return Ptr;
+}
+
+/*
+ * @implemented
+ */
+SIZE_T
+NTAPI
+LocalCompact(UINT dwMinFree)
+{
+ /* Call the RTL Heap Manager */
+ return RtlCompactHeap(BaseHeap, 0);
+}
+
+/*
+ * @implemented
+ */
+UINT
+NTAPI
+LocalFlags(HLOCAL hMem)
+{
+ PBASE_HEAP_HANDLE_ENTRY HandleEntry;
+ HANDLE Handle = NULL;
+ ULONG Flags = 0;
+ UINT uFlags = LMEM_INVALID_HANDLE;
+
+ /* Start by locking the heap */
+ RtlLockHeap(BaseHeap);
+
+ /* Check if this is a simple RTL Heap Managed block */
+ if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY))
+ {
+ /* Then we'll query RTL Heap */
+ RtlGetUserInfoHeap(BaseHeap, Flags, hMem, &Handle, &Flags);
+ BASE_TRACE_PTR(Handle, hMem);
+
+ /*
+ * Check if RTL Heap didn't find a handle associated with us or
+ * said that this heap isn't movable, which means something we're
+ * really not a handle-based heap.
+ */
+ if (!(Handle) || !(Flags & BASE_HEAP_FLAG_MOVABLE))
+ {
+ /* Then set the flags to 0 */
+ uFlags = 0;
+ }
+ else
+ {
+ /* Otherwise we're handle-based, so get the internal handle */
+ hMem = Handle;
+ }
+ }
+
+ /* Check if the handle is actually an entry in our table */
+ if ((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)
+ {
+ /* Then get the entry */
+ HandleEntry = BaseHeapGetEntry(hMem);
+ BASE_TRACE_HANDLE(HandleEntry, hMem);
+
+ /* Make sure it's a valid handle */
+ if (BaseHeapValidateEntry(HandleEntry))
+ {
+ /* Get the lock count first */
+ uFlags = HandleEntry->LockCount & LMEM_LOCKCOUNT;
+
+ /* Now check if it's discardable */
+ if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_REUSABLE)
+ {
+ /* Set the Win32 Flag */
+ uFlags |= LMEM_DISCARDABLE;
+ }
+
+ /* Now check if it's discarded */
+ if (HandleEntry->Flags & BASE_HEAP_ENTRY_FLAG_REUSE)
+ /* Set the Win32 Flag */
+ uFlags |= LMEM_DISCARDED;
+ }
+ }
+
+ /* Check if by now, we still haven't gotten any useful flags */
+ if (uFlags == LMEM_INVALID_HANDLE) SetLastError(ERROR_INVALID_HANDLE);
+
+ /* All done! Unlock heap and return Win32 Flags */
+ RtlUnlockHeap(BaseHeap);
+ return uFlags;
+}
+
+/*
+ * @implemented
+ */
+HLOCAL
+NTAPI
+LocalFree(HLOCAL hMem)
+{
+ /* This is identical to a Global Free */
+ return GlobalFree(hMem);
+}
+
+/*
+ * @implemented
+ */
+HLOCAL
+NTAPI
+LocalHandle(LPCVOID pMem)
+{
+ /* This is identical to a Global Handle */
+ return GlobalHandle(pMem);
+}
+
+/*
+ * @implemented
+ */
+LPVOID
+NTAPI
+LocalLock(HLOCAL hMem)
+{
+ /* This is the same as a GlobalLock, assuming these never change */
+ C_ASSERT(LMEM_LOCKCOUNT == GMEM_LOCKCOUNT);
+ return GlobalLock(hMem);
+}
+
+HLOCAL
+NTAPI
+LocalReAlloc(HLOCAL hMem,
+ SIZE_T dwBytes,
+ UINT uFlags)
+{
+ PBASE_HEAP_HANDLE_ENTRY HandleEntry;
+ LPVOID Ptr;
+ ULONG Flags = 0;
+
+ /* Convert ZEROINIT */
+ if (uFlags & LMEM_ZEROINIT) Flags |= HEAP_ZERO_MEMORY;
+
+ /* If this wasn't a movable heap, then we MUST re-alloc in place */
+ if (!(uFlags & LMEM_MOVEABLE)) Flags |= HEAP_REALLOC_IN_PLACE_ONLY;
+
+ /* Lock the heap and disable built-in locking in the RTL Heap functions */
+ RtlLockHeap(BaseHeap);
+ Flags |= HEAP_NO_SERIALIZE;
+
+ /* Check if this is a simple handle-based block */
+ if (((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY))
+ {
+ /* Get the entry */
+ HandleEntry = BaseHeapGetEntry(hMem);
+ BASE_TRACE_HANDLE(HandleEntry, hMem);
+
+ /* Make sure the handle is valid */
+ if (!BaseHeapValidateEntry(HandleEntry))
+ {
+ /* Fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_INVALID_HANDLE);
+ hMem = NULL;
+ }
+ else if (uFlags & LMEM_MODIFY)
+ {
+ /* User is changing flags... check if the memory was discardable */
+ if (uFlags & LMEM_DISCARDABLE)
+ {
+ /* Then set the flag */
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSABLE;
+ }
+ else
+ {
+ /* Otherwise, remove the flag */
+ HandleEntry->Flags &= ~BASE_HEAP_ENTRY_FLAG_REUSABLE;
+ }
+ }
+ else
+ {
+ /* Otherwise, get the object and check if we have no size */
+ Ptr = HandleEntry->Object;
+ if (!dwBytes)
+ {
+ /* Clear the handle and check for a pointer */
+ hMem = NULL;
+ if (Ptr)
+ {
+ /* Make sure the handle isn't locked */
+ if ((uFlags & LMEM_MOVEABLE) && !(HandleEntry->LockCount))
+ {
+ /* Free the current heap */
+ RtlFreeHeap(BaseHeap, Flags, Ptr);
+
+ /* Free the handle */
+ HandleEntry->Object = NULL;
+ HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSE;
+
+ /* Get the object pointer */
+ hMem = &HandleEntry->Object;
+ }
+ }
+ else
+ {
+ /* Otherwise just return the object pointer */
+ hMem = &HandleEntry->Object;
+ }
+ }
+ else
+ {
+ /* Otherwise, we're allocating, so set the new flags needed */
+ Flags |= HEAP_SETTABLE_USER_VALUE | BASE_HEAP_FLAG_MOVABLE;
+ if (!Ptr)
+ {
+ /* We don't have a base, so allocate one */
+ Ptr = RtlAllocateHeap(BaseHeap, Flags, dwBytes);
+ BASE_TRACE_ALLOC2(Ptr);
+ if (Ptr)
+ {
+ /* Allocation succeeded, so save our entry */
+ RtlSetUserValueHeap(BaseHeap,
+ HEAP_NO_SERIALIZE,
+ Ptr,
+ hMem);
+ }
+ }
+ else
+ {
+ /*
+ * If it's not movable or currently locked, we MUST allocate
+ * in-place!
+ */
+ if (!(uFlags & LMEM_MOVEABLE) && (HandleEntry->LockCount))
+ {
+ /* Set the flag */
+ Flags |= HEAP_REALLOC_IN_PLACE_ONLY;
+ }
+ else
+ {
+ /* Otherwise clear the flag if we set it previously */
+ Flags &= ~HEAP_REALLOC_IN_PLACE_ONLY;
+ }
+
+ /* And do the re-allocation */
+ Ptr = RtlReAllocateHeap(BaseHeap, Flags, Ptr, dwBytes);
+ }
+
+ /* Make sure we have a pointer by now */
+ if (Ptr)
+ {
+ /* Write it in the handle entry and mark it in use */
+ HandleEntry->Object = Ptr;
+ HandleEntry->Flags &= ~BASE_HEAP_ENTRY_FLAG_REUSE;
+ }
+ else
+ {
+ /* Otherwise we failed */
+ hMem = NULL;
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ }
+ }
+ }
+ }
+ else if (!(uFlags & LMEM_MODIFY))
+ {
+ /* Otherwise, this is a simple RTL Managed Heap, so just call it */
+ hMem = RtlReAllocateHeap(BaseHeap,
+ Flags | HEAP_NO_SERIALIZE,
+ hMem,
+ dwBytes);
+ if (!hMem)
+ {
+ /* Fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ }
+ }
+
+ /* All done, unlock the heap and return the pointer */
+ RtlUnlockHeap(BaseHeap);
+ return hMem;
+}
+
+/*
+ * @implemented
+ */
+SIZE_T
+WINAPI
+LocalShrink(HLOCAL hMem,
+ UINT cbNewSize)
+{
+ /* Call RTL */
+ return RtlCompactHeap(BaseHeap, 0);
+}
+
+/*
+ * @implemented
+ */
+SIZE_T
+NTAPI
+LocalSize(HLOCAL hMem)
+{
+ /* This is the same as a Global Size */
+ return GlobalSize(hMem);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+NTAPI
+LocalUnlock(HLOCAL hMem)
+{
+ PBASE_HEAP_HANDLE_ENTRY HandleEntry;
+ BOOL RetVal = TRUE;
+
+ /* Check if this was a simple allocated heap entry */
+ if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY))
+ {
+ /* Fail, because LocalUnlock is not supported on LMEM_FIXED allocations */
+ SetLastError(ERROR_NOT_LOCKED);
+ return FALSE;
+ }
+
+ /* Otherwise, lock the heap */
+ RtlLockHeap(BaseHeap);
+
+ /* Get the handle entry */
+ HandleEntry = BaseHeapGetEntry(hMem);
+ BASE_TRACE_HANDLE(HandleEntry, hMem);
+ _SEH2_TRY
+ {
+ /* Make sure it's valid */
+ if (!BaseHeapValidateEntry(HandleEntry))
+ {
+ /* It's not, fail */
+ BASE_TRACE_FAILURE();
+ SetLastError(ERROR_INVALID_HANDLE);
+ RetVal = FALSE;
+ }
+ else
+ {
+ /* Otherwise, decrement lock count, unless we're already at 0*/
+ if (!HandleEntry->LockCount--)
+ {
+ /* In which case we simply lock it back and fail */
+ HandleEntry->LockCount++;
+ SetLastError(ERROR_NOT_LOCKED);
+ RetVal = FALSE;
+ }
+ else if (!HandleEntry->LockCount)
+ {
+ /* Nothing to unlock */
+ SetLastError(NO_ERROR);
+ RetVal = FALSE;
+ }
+ }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ RetVal = FALSE;
+ }
+ _SEH2_END;
+
+ /* All done. Unlock the heap and return the pointer */
+ RtlUnlockHeap(BaseHeap);
+ return RetVal;
+}
+
+/* EOF */
projects / reactos.git / blobdiff