[ros-diffs] [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...

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);
+