[ion] 53068: [KERNEL32]: Cleanup and fix the Global* APIs for heap allocation. Mostly parameter check fixing, checking for errors and failure cases, as well as adding SEH (no real functionality imp...
4 Aug
2011
4 Aug
'11
10:18 p.m.
Author: ion
Date: Thu Aug 4 22:18:01 2011
New Revision: 53068
URL: http://svn.reactos.org/svn/reactos?rev=53068&view=rev
Log:
[KERNEL32]: Cleanup and fix the Global* APIs for heap allocation. Mostly parameter check
fixing, checking for errors and failure cases, as well as adding SEH (no real
functionality improvement, other than fixing a security issue in GlobalLock).
[KERNEL32]: Rename hProcessHeap to BaseHeap, and only allow the heapmem.c access to this
(change find.c to use RtlGetProcessHeap() like everyone else).
Modified:
trunk/reactos/dll/win32/kernel32/client/dllmain.c
trunk/reactos/dll/win32/kernel32/client/file/find.c
trunk/reactos/dll/win32/kernel32/client/heapmem.c
trunk/reactos/dll/win32/kernel32/include/baseheap.h
trunk/reactos/dll/win32/kernel32/include/kernel32.h
Modified: trunk/reactos/dll/win32/kernel32/client/dllmain.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/client/…
==============================================================================
--- trunk/reactos/dll/win32/kernel32/client/dllmain.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/kernel32/client/dllmain.c [iso-8859-1] Thu Aug 4 22:18:01
2011
@@ -29,7 +29,6 @@
WCHAR BaseDefaultPathBuffer[6140];
HANDLE BaseNamedObjectDirectory;
-HANDLE hProcessHeap = NULL;
HMODULE hCurrentModule = NULL;
HMODULE kernel32_handle = NULL;
HANDLE hBaseDir = NULL;
@@ -57,13 +56,6 @@
extern BOOL FASTCALL NlsInit(VOID);
extern VOID FASTCALL NlsUninit(VOID);
BOOLEAN InWindows = FALSE;
-
-HANDLE
-WINAPI
-DuplicateConsoleHandle(HANDLE hConsole,
- DWORD dwDesiredAccess,
- BOOL bInheritHandle,
- DWORD dwOptions);
#define WIN_OBJ_DIR L"\\Windows"
#define SESSION_DIR L"\\Sessions"
@@ -323,11 +315,7 @@
}
/* Initialize heap handle table */
- hProcessHeap = RtlGetProcessHeap();
- RtlInitializeHandleTable(0xFFFF,
- sizeof(BASE_HEAP_HANDLE_ENTRY),
- &BaseHeapHandleTable);
- DPRINT("Heap: %p\n", hProcessHeap);
+ BaseDllInitializeMemoryManager();
/* Set HMODULE for our DLL */
kernel32_handle = hCurrentModule = hDll;
Modified: trunk/reactos/dll/win32/kernel32/client/file/find.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/client/…
==============================================================================
--- trunk/reactos/dll/win32/kernel32/client/file/find.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/kernel32/client/file/find.c [iso-8859-1] Thu Aug 4 22:18:01
2011
@@ -364,7 +364,7 @@
if (!NT_SUCCESS(Status))
{
- RtlFreeHeap (hProcessHeap,
+ RtlFreeHeap (RtlGetProcessHeap(),
0,
NtPathBuffer);
@@ -387,20 +387,20 @@
{
/* No file part?! */
NtClose(hDirectory);
- RtlFreeHeap (hProcessHeap,
+ RtlFreeHeap (RtlGetProcessHeap(),
0,
NtPathBuffer);
SetLastError(ERROR_FILE_NOT_FOUND);
return INVALID_HANDLE_VALUE;
}
- IHeader = RtlAllocateHeap (hProcessHeap,
+ IHeader = RtlAllocateHeap (RtlGetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(KERNEL32_FIND_DATA_HEADER) +
sizeof(KERNEL32_FIND_FILE_DATA) + FIND_DATA_SIZE);
if (NULL == IHeader)
{
- RtlFreeHeap (hProcessHeap,
+ RtlFreeHeap (RtlGetProcessHeap(),
0,
NtPathBuffer);
NtClose(hDirectory);
@@ -431,7 +431,7 @@
&PathFileName,
lpFindFileData);
- RtlFreeHeap (hProcessHeap,
+ RtlFreeHeap (RtlGetProcessHeap(),
0,
NtPathBuffer);
@@ -596,7 +596,7 @@
PKERNEL32_FIND_STREAM_DATA IData = (PKERNEL32_FIND_STREAM_DATA)(IHeader + 1);
if (IData->pFileStreamInfo != NULL)
{
- RtlFreeHeap (hProcessHeap, 0, IData->pFileStreamInfo);
+ RtlFreeHeap (RtlGetProcessHeap(), 0, IData->pFileStreamInfo);
}
break;
}
@@ -606,7 +606,7 @@
return FALSE;
}
- RtlFreeHeap (hProcessHeap, 0, IHeader);
+ RtlFreeHeap (RtlGetProcessHeap(), 0, IHeader);
return TRUE;
}
@@ -835,7 +835,7 @@
}
/* create the search context */
- IHeader = RtlAllocateHeap(hProcessHeap,
+ IHeader = RtlAllocateHeap(RtlGetProcessHeap(),
0,
sizeof(KERNEL32_FIND_DATA_HEADER) +
sizeof(KERNEL32_FIND_STREAM_DATA));
@@ -859,7 +859,7 @@
if (IData->pFileStreamInfo == NULL)
{
- IData->pFileStreamInfo = RtlAllocateHeap(hProcessHeap,
+ IData->pFileStreamInfo = RtlAllocateHeap(RtlGetProcessHeap(),
0,
BufferSize);
if (IData->pFileStreamInfo == NULL)
@@ -872,7 +872,7 @@
{
PFILE_STREAM_INFORMATION pfsi;
- pfsi = RtlReAllocateHeap(hProcessHeap,
+ pfsi = RtlReAllocateHeap(RtlGetProcessHeap(),
0,
IData->pFileStreamInfo,
BufferSize);
@@ -923,12 +923,12 @@
{
if (IData->pFileStreamInfo != NULL)
{
- RtlFreeHeap(hProcessHeap,
+ RtlFreeHeap(RtlGetProcessHeap(),
0,
IData->pFileStreamInfo);
}
- RtlFreeHeap(hProcessHeap,
+ RtlFreeHeap(RtlGetProcessHeap(),
0,
IHeader);
}
Modified: trunk/reactos/dll/win32/kernel32/client/heapmem.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/client/…
==============================================================================
--- trunk/reactos/dll/win32/kernel32/client/heapmem.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/kernel32/client/heapmem.c [iso-8859-1] Thu Aug 4 22:18:01
2011
@@ -6,18 +6,36 @@
* PROGRAMMERS: Alex Ionescu (alex.ionescu(a)reactos.org)
*/
-/* INCLUDES ******************************************************************/
+/* INCLUDES *******************************************************************/
#include <k32.h>
#define NDEBUG
#include <debug.h>
-/* TYPES *********************************************************************/
+/* GLOBALS ********************************************************************/
RTL_HANDLE_TABLE BaseHeapHandleTable;
-
-/* FUNCTIONS ***************************************************************/
+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
@@ -275,6 +293,8 @@
{
NTSTATUS Status;
+ DPRINT1("Warning, HeapWalk is calling RtlWalkHeap with Win32
parameters\n");
+
Status = RtlWalkHeap(hHeap, lpEntry);
if (!NT_SUCCESS(Status))
@@ -353,7 +373,7 @@
HANDLE hMemory;
PBASE_HEAP_HANDLE_ENTRY HandleEntry;
BASE_TRACE_ALLOC(dwBytes, uFlags);
- ASSERT(hProcessHeap);
+ ASSERT(BaseHeap);
/* Make sure the flags are valid */
if (uFlags & ~GMEM_VALID_FLAGS)
@@ -374,13 +394,14 @@
if (uFlags & GMEM_DDESHARE) Flags |= BASE_HEAP_ENTRY_FLAG_DDESHARE;
/* Allocate heap for it */
- Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes);
+ 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(hProcessHeap);
+ RtlLockHeap(BaseHeap);
/*
* Disable locking, enable custom flags, and write the
@@ -398,35 +419,35 @@
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(hProcessHeap, 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(hProcessHeap, HEAP_NO_SERIALIZE, Ptr, hMemory);
- }
- }
-
-Quickie:
+ }
+ 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(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
/* Check if a handle was allocated */
if (HandleEntry)
@@ -477,7 +498,7 @@
GlobalCompact(DWORD dwMinFree)
{
/* Call the RTL Heap Manager */
- return RtlCompactHeap(hProcessHeap, 0);
+ return RtlCompactHeap(BaseHeap, 0);
}
/*
@@ -504,71 +525,81 @@
UINT uFlags = GMEM_INVALID_HANDLE;
/* Start by locking the heap */
- RtlLockHeap(hProcessHeap);
-
- /* 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(hProcessHeap, 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);
+ 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(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
return uFlags;
}
@@ -587,7 +618,7 @@
if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY))
{
/* Free it with the RTL Heap Manager */
- if (RtlFreeHeap(hProcessHeap, 0, hMem))
+ if (RtlFreeHeap(BaseHeap, 0, hMem))
{
/* Return NULL since there's no handle */
return NULL;
@@ -602,51 +633,67 @@
}
/* It's a handle probably, so lock the heap */
- RtlLockHeap(hProcessHeap);
-
- /* 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;
+ 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
{
- /* 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 */
- RtlFreeHeap(hProcessHeap, HEAP_NO_SERIALIZE, Ptr);
- hMem = NULL;
- }
+ /* 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(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
return hMem;
}
@@ -661,28 +708,42 @@
ULONG Flags;
/* Lock the heap */
- RtlLockHeap(hProcessHeap);
-
- /* Query RTL Heap */
- RtlGetUserInfoHeap(hProcessHeap,
- HEAP_NO_SERIALIZE,
- (PVOID)pMem,
- &Handle,
- &Flags);
- BASE_TRACE_PTR(Handle, pMem);
-
- /*
- * Check if RTL Heap didn't find a handle for us or said that
- * this heap isn't movable.
- */
- if (!(Handle) || !(Flags & BASE_HEAP_FLAG_MOVABLE))
- {
- /* We're actually handle-based, so the pointer is a handle */
- Handle = (HANDLE)pMem;
- }
+ 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(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
return Handle;
}
@@ -699,13 +760,20 @@
/* Check if this was a simple allocated heap entry */
if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY))
{
- /* Verify and return the pointer */
- return IsBadReadPtr(hMem, 1) ? NULL : hMem;
+ /* 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(hProcessHeap);
-
+ RtlLockHeap(BaseHeap);
_SEH2_TRY
{
/* Get the handle entry */
@@ -745,10 +813,10 @@
SetLastError(ERROR_INVALID_HANDLE);
Ptr = NULL;
}
- _SEH2_END
+ _SEH2_END;
/* All done. Unlock the heap and return the pointer */
- RtlUnlockHeap(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
return Ptr;
}
@@ -763,6 +831,20 @@
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;
@@ -770,7 +852,7 @@
if (!(uFlags & GMEM_MOVEABLE)) Flags |= HEAP_REALLOC_IN_PLACE_ONLY;
/* Lock the heap and disable built-in locking in the RTL Heap funcitons */
- RtlLockHeap(hProcessHeap);
+ RtlLockHeap(BaseHeap);
Flags |= HEAP_NO_SERIALIZE;
/* Check if this is a simple handle-based block */
@@ -816,14 +898,15 @@
if ((uFlags & GMEM_MOVEABLE) &&
!(HandleEntry->LockCount))
{
/* Free the current heap */
- RtlFreeHeap(hProcessHeap, Flags, Ptr);
-
- /* Free the handle */
- HandleEntry->Object = NULL;
- HandleEntry->Flags |= BASE_HEAP_ENTRY_FLAG_REUSE;
-
- /* Get the object pointer */
- hMem = &HandleEntry->Object;
+ 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
@@ -839,12 +922,12 @@
if (!Ptr)
{
/* We don't have a base, so allocate one */
- Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes);
+ Ptr = RtlAllocateHeap(BaseHeap, Flags, dwBytes);
BASE_TRACE_ALLOC2(Ptr);
if (Ptr)
{
/* Allocation succeeded, so save our entry */
- RtlSetUserValueHeap(hProcessHeap,
+ RtlSetUserValueHeap(BaseHeap,
HEAP_NO_SERIALIZE,
Ptr,
hMem);
@@ -867,18 +950,8 @@
Flags &= ~HEAP_REALLOC_IN_PLACE_ONLY;
}
- /* And do the re-allocation */
- Ptr = RtlReAllocateHeap(hProcessHeap, Flags, Ptr, dwBytes);
-
- if (Ptr)
- {
- /* Allocation succeeded, so save our entry */
- RtlSetUserValueHeap(hProcessHeap,
- HEAP_NO_SERIALIZE,
- Ptr,
- hMem);
- }
-
+ /* 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 */
@@ -904,89 +977,95 @@
{
/* Get information on its current state */
Handle = hMem;
- DPRINT1("h h %lx %lx\n", Handle, hMem);
- RtlGetUserInfoHeap(hProcessHeap,
- HEAP_NO_SERIALIZE,
- hMem,
- &Handle,
- &Flags);
- DPRINT1("h h %lx %lx\n", Handle, hMem);
-
- /*
- * Check if the handle matches the pointer or if the moveable flag
- * isn't there, which is what we expect since it currenly isn't.
- */
- if (Handle == hMem || !(Flags & BASE_HEAP_FLAG_MOVABLE))
- {
- /* Allocate a handle for it */
- HandleEntry = BaseHeapAllocEntry();
-
- /* Calculate the size of the current heap */
- dwBytes = RtlSizeHeap(hProcessHeap, 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(hProcessHeap,
- Flags,
- dwBytes);
- BASE_TRACE_PTR(HandleEntry->Object, HandleEntry);
- if (!HandleEntry->Object)
+ 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 currenly isn't.
+ */
+ if ((Handle == hMem) || !(Flags & BASE_HEAP_FLAG_MOVABLE))
{
- /*
- * 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);
+ /* 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, copy the current heap and free the old one */
- RtlMoveMemory(HandleEntry->Object, hMem, dwBytes);
- RtlFreeHeap(hProcessHeap, 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(hProcessHeap,
- HEAP_NO_SERIALIZE,
- HandleEntry->Object,
- hMem);
- }
}
}
}
else
{
/* Otherwise, this is a simple RTL Managed Heap, so just call it */
- hMem = RtlReAllocateHeap(hProcessHeap,
+ hMem = RtlReAllocateHeap(BaseHeap,
Flags | HEAP_NO_SERIALIZE,
hMem,
dwBytes);
@@ -999,7 +1078,7 @@
}
/* All done, unlock the heap and return the pointer */
- RtlUnlockHeap(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
return hMem;
}
@@ -1016,30 +1095,30 @@
SIZE_T dwSize = MAXULONG_PTR;
/* Lock the heap */
- RtlLockHeap(hProcessHeap);
-
+ 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(hProcessHeap, 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))
- {
- /* This implies we're not a handle heap, so use the generic call */
- dwSize = RtlSizeHeap(hProcessHeap, HEAP_NO_SERIALIZE, hMem);
- }
- else
- {
- /* Otherwise we're a handle heap, so get the internal handle */
- hMem = Handle;
+ 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;
+ }
}
}
@@ -1065,30 +1144,30 @@
else
{
/* Otherwise, query RTL about it */
- dwSize = RtlSizeHeap(hProcessHeap,
+ dwSize = RtlSizeHeap(BaseHeap,
HEAP_NO_SERIALIZE,
HandleEntry->Object);
}
}
-
- /* 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;
- }
}
_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;
}
- _SEH2_END
/* All done! Unlock heap and return the size */
- RtlUnlockHeap(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
return dwSize;
}
@@ -1117,7 +1196,7 @@
if (!((ULONG_PTR)hMem & BASE_HEAP_IS_HANDLE_ENTRY)) return RetVal;
/* Otherwise, lock the heap */
- RtlLockHeap(hProcessHeap);
+ RtlLockHeap(BaseHeap);
/* Get the handle entry */
HandleEntry = BaseHeapGetEntry(hMem);
@@ -1156,10 +1235,10 @@
SetLastError(ERROR_INVALID_PARAMETER);
RetVal = FALSE;
}
- _SEH2_END
+ _SEH2_END;
/* All done. Unlock the heap and return the pointer */
- RtlUnlockHeap(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
return RetVal;
}
@@ -1292,7 +1371,7 @@
HANDLE hMemory;
PBASE_HEAP_HANDLE_ENTRY HandleEntry;
BASE_TRACE_ALLOC(dwBytes, uFlags);
- ASSERT(hProcessHeap);
+ ASSERT(BaseHeap);
/* Make sure the flags are valid */
if (uFlags & ~LMEM_VALID_FLAGS)
@@ -1310,13 +1389,13 @@
if (!(uFlags & LMEM_MOVEABLE))
{
/* Allocate heap for it */
- Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes);
+ Ptr = RtlAllocateHeap(BaseHeap, Flags, dwBytes);
BASE_TRACE_ALLOC2(Ptr);
return Ptr;
}
/* This is heap based, so lock it in first */
- RtlLockHeap(hProcessHeap);
+ RtlLockHeap(BaseHeap);
/*
* Disable locking, enable custom flags, and write the
@@ -1342,7 +1421,7 @@
if (dwBytes)
{
/* Allocate the actual memory for it */
- Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes);
+ Ptr = RtlAllocateHeap(BaseHeap, Flags, dwBytes);
BASE_TRACE_PTR(HandleEntry, Ptr);
if (!Ptr)
{
@@ -1356,13 +1435,13 @@
else
{
/* All worked well, save our heap entry */
- RtlSetUserValueHeap(hProcessHeap, HEAP_NO_SERIALIZE, Ptr, hMemory);
+ RtlSetUserValueHeap(BaseHeap, HEAP_NO_SERIALIZE, Ptr, hMemory);
}
}
Quickie:
/* Cleanup! First unlock the heap */
- RtlUnlockHeap(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
/* Check if a handle was allocated */
if (HandleEntry)
@@ -1406,7 +1485,7 @@
LocalCompact(UINT dwMinFree)
{
/* Call the RTL Heap Manager */
- return RtlCompactHeap(hProcessHeap, 0);
+ return RtlCompactHeap(BaseHeap, 0);
}
/*
@@ -1422,13 +1501,13 @@
UINT uFlags = LMEM_INVALID_HANDLE;
/* Start by locking the heap */
- RtlLockHeap(hProcessHeap);
+ 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(hProcessHeap, Flags, hMem, &Handle, &Flags);
+ RtlGetUserInfoHeap(BaseHeap, Flags, hMem, &Handle, &Flags);
BASE_TRACE_PTR(Handle, hMem);
/*
@@ -1479,7 +1558,7 @@
if (uFlags == LMEM_INVALID_HANDLE) SetLastError(ERROR_INVALID_HANDLE);
/* All done! Unlock heap and return Win32 Flags */
- RtlUnlockHeap(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
return uFlags;
}
@@ -1534,7 +1613,7 @@
if (!(uFlags & LMEM_MOVEABLE)) Flags |= HEAP_REALLOC_IN_PLACE_ONLY;
/* Lock the heap and disable built-in locking in the RTL Heap funcitons */
- RtlLockHeap(hProcessHeap);
+ RtlLockHeap(BaseHeap);
Flags |= HEAP_NO_SERIALIZE;
/* Check if this is a simple handle-based block */
@@ -1580,7 +1659,7 @@
if ((uFlags & LMEM_MOVEABLE) &&
!(HandleEntry->LockCount))
{
/* Free the current heap */
- RtlFreeHeap(hProcessHeap, Flags, Ptr);
+ RtlFreeHeap(BaseHeap, Flags, Ptr);
/* Free the handle */
HandleEntry->Object = NULL;
@@ -1603,12 +1682,12 @@
if (!Ptr)
{
/* We don't have a base, so allocate one */
- Ptr = RtlAllocateHeap(hProcessHeap, Flags, dwBytes);
+ Ptr = RtlAllocateHeap(BaseHeap, Flags, dwBytes);
BASE_TRACE_ALLOC2(Ptr);
if (Ptr)
{
/* Allocation succeeded, so save our entry */
- RtlSetUserValueHeap(hProcessHeap,
+ RtlSetUserValueHeap(BaseHeap,
HEAP_NO_SERIALIZE,
Ptr,
hMem);
@@ -1632,7 +1711,7 @@
}
/* And do the re-allocation */
- Ptr = RtlReAllocateHeap(hProcessHeap, Flags, Ptr, dwBytes);
+ Ptr = RtlReAllocateHeap(BaseHeap, Flags, Ptr, dwBytes);
}
/* Make sure we have a pointer by now */
@@ -1654,7 +1733,7 @@
else if (!(uFlags & LMEM_MODIFY))
{
/* Otherwise, this is a simple RTL Managed Heap, so just call it */
- hMem = RtlReAllocateHeap(hProcessHeap,
+ hMem = RtlReAllocateHeap(BaseHeap,
Flags | HEAP_NO_SERIALIZE,
hMem,
dwBytes);
@@ -1667,7 +1746,7 @@
}
/* All done, unlock the heap and return the pointer */
- RtlUnlockHeap(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
return hMem;
}
@@ -1680,7 +1759,7 @@
UINT cbNewSize)
{
/* Call RTL */
- return RtlCompactHeap(hProcessHeap, 0);
+ return RtlCompactHeap(BaseHeap, 0);
}
/*
@@ -1713,12 +1792,11 @@
}
/* Otherwise, lock the heap */
- RtlLockHeap(hProcessHeap);
+ RtlLockHeap(BaseHeap);
/* Get the handle entry */
HandleEntry = BaseHeapGetEntry(hMem);
BASE_TRACE_HANDLE(HandleEntry, hMem);
-
_SEH2_TRY
{
/* Make sure it's valid */
@@ -1752,10 +1830,10 @@
SetLastError(ERROR_INVALID_PARAMETER);
RetVal = FALSE;
}
- _SEH2_END
+ _SEH2_END;
/* All done. Unlock the heap and return the pointer */
- RtlUnlockHeap(hProcessHeap);
+ RtlUnlockHeap(BaseHeap);
return RetVal;
}
Modified: trunk/reactos/dll/win32/kernel32/include/baseheap.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/include…
==============================================================================
--- trunk/reactos/dll/win32/kernel32/include/baseheap.h [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/kernel32/include/baseheap.h [iso-8859-1] Thu Aug 4 22:18:01
2011
@@ -33,12 +33,6 @@
// API for it (such as GlobalLock).
//
-//
-// The Handle Table
-//
-extern RTL_HANDLE_TABLE BaseHeapHandleTable;
-
-//
// Tracing Support
// Define _BASE_HANDLE_TRACE for Traces
//
Modified: trunk/reactos/dll/win32/kernel32/include/kernel32.h
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/include…
==============================================================================
--- trunk/reactos/dll/win32/kernel32/include/kernel32.h [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/kernel32/include/kernel32.h [iso-8859-1] Thu Aug 4 22:18:01
2011
@@ -91,7 +91,6 @@
/* GLOBAL VARIABLES **********************************************************/
extern BOOL bIsFileApiAnsi;
-extern HANDLE hProcessHeap;
extern HANDLE hBaseDir;
extern HMODULE hCurrentModule;
@@ -109,6 +108,10 @@
extern BOOLEAN BaseRunningInServerProcess;
/* FUNCTION PROTOTYPES *******************************************************/
+
+VOID
+NTAPI
+BaseDllInitializeMemoryManager(VOID);
BOOL WINAPI VerifyConsoleIoHandle(HANDLE Handle);
@@ -249,3 +252,11 @@
/* FIXME */
WCHAR WINAPI RtlAnsiCharToUnicodeChar(LPSTR *);
+
+HANDLE
+WINAPI
+DuplicateConsoleHandle(HANDLE hConsole,
+ DWORD dwDesiredAccess,
+ BOOL bInheritHandle,
+ DWORD dwOptions);
+
4852
days inactive
4852
days old
0 comments
1 participants
participants (1)
-
ion＠svn.reactos.org