heapmem.c File Reference

#include <k32.h>
#include <debug.h>

Include dependency graph for heapmem.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID NTAPI	BaseDllInitializeMemoryManager (VOID)
HANDLE WINAPI	HeapCreate (DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize)
BOOL WINAPI	HeapDestroy (HANDLE hHeap)
HANDLE WINAPI	GetProcessHeap (VOID)
DWORD WINAPI	GetProcessHeaps (DWORD NumberOfHeaps, PHANDLE ProcessHeaps)
BOOL WINAPI	HeapLock (HANDLE hHeap)
BOOL WINAPI	HeapUnlock (HANDLE hHeap)
SIZE_T WINAPI	HeapCompact (HANDLE hHeap, DWORD dwFlags)
BOOL WINAPI	HeapValidate (HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem)
DWORD WINAPI	HeapCreateTagsW (_In_ HANDLE hHeap, _In_ DWORD dwFlags, _In_opt_ PWSTR lpTagName, _In_ PWSTR lpTagSubName)
DWORD WINAPI	HeapExtend (HANDLE hHeap, DWORD dwFlags, PVOID BaseAddress, DWORD dwBytes)
PWSTR WINAPI	HeapQueryTagW (HANDLE hHeap, DWORD dwFlags, WORD wTagIndex, BOOL bResetCounters, PVOID lpTagInfo)
BOOL WINAPI	HeapSummary (HANDLE hHeap, DWORD dwFlags, PVOID Summary)
BOOL WINAPI	HeapUsage (HANDLE hHeap, DWORD dwFlags, DWORD Unknown, DWORD Unknown2, IN PVOID Usage)
BOOL WINAPI	HeapWalk (HANDLE hHeap, LPPROCESS_HEAP_ENTRY lpEntry)
BOOL WINAPI	HeapQueryInformation (HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation OPTIONAL, SIZE_T HeapInformationLength OPTIONAL, PSIZE_T ReturnLength OPTIONAL)
BOOL WINAPI	HeapSetInformation (HANDLE HeapHandle, HEAP_INFORMATION_CLASS HeapInformationClass, PVOID HeapInformation OPTIONAL, SIZE_T HeapInformationLength OPTIONAL)
HGLOBAL NTAPI	GlobalAlloc (UINT uFlags, SIZE_T dwBytes)
SIZE_T NTAPI	GlobalCompact (DWORD dwMinFree)
VOID NTAPI	GlobalFix (HGLOBAL hMem)
UINT NTAPI	GlobalFlags (HGLOBAL hMem)
HGLOBAL NTAPI	GlobalFree (HGLOBAL hMem)
HGLOBAL NTAPI	GlobalHandle (LPCVOID pMem)
LPVOID NTAPI	GlobalLock (HGLOBAL hMem)
HGLOBAL NTAPI	GlobalReAlloc (HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags)
SIZE_T NTAPI	GlobalSize (HGLOBAL hMem)
VOID NTAPI	GlobalUnfix (HGLOBAL hMem)
BOOL NTAPI	GlobalUnlock (HGLOBAL hMem)
BOOL NTAPI	GlobalUnWire (HGLOBAL hMem)
LPVOID NTAPI	GlobalWire (HGLOBAL hMem)
BOOL NTAPI	GlobalMemoryStatusEx (LPMEMORYSTATUSEX lpBuffer)
VOID NTAPI	GlobalMemoryStatus (LPMEMORYSTATUS lpBuffer)
HLOCAL NTAPI	LocalAlloc (UINT uFlags, SIZE_T dwBytes)
SIZE_T NTAPI	LocalCompact (UINT dwMinFree)
UINT NTAPI	LocalFlags (HLOCAL hMem)
HLOCAL NTAPI	LocalFree (HLOCAL hMem)
HLOCAL NTAPI	LocalHandle (LPCVOID pMem)
LPVOID NTAPI	LocalLock (HLOCAL hMem)
HLOCAL NTAPI	LocalReAlloc (HLOCAL hMem, SIZE_T dwBytes, UINT uFlags)
SIZE_T WINAPI	LocalShrink (HLOCAL hMem, UINT cbNewSize)
SIZE_T NTAPI	LocalSize (HLOCAL hMem)
BOOL NTAPI	LocalUnlock (HLOCAL hMem)

Variables
RTL_HANDLE_TABLE	BaseHeapHandleTable
HANDLE	BaseHeap
ULONG_PTR	SystemRangeStart

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file heapmem.c.

Function Documentation

BaseDllInitializeMemoryManager()

VOID NTAPI BaseDllInitializeMemoryManager

(

VOID

)

Definition at line 26 of file heapmem.c.

{
    BaseHeap = RtlGetProcessHeap();
    RtlInitializeHandleTable(0xFFFF,
                             sizeof(BASE_HEAP_HANDLE_ENTRY),
                             &BaseHeapHandleTable);
    NtQuerySystemInformation(SystemRangeStartInformation,
                             &SystemRangeStart,
                             sizeof(SystemRangeStart),
                             NULL);
}

Referenced by DllMain().

GetProcessHeap()

HANDLE WINAPI GetProcessHeap

(

VOID

)

Definition at line 100 of file heapmem.c.

{
    /* Call the RTL API */
    return RtlGetProcessHeap();
}

GetProcessHeaps()

DWORD WINAPI GetProcessHeaps	(	DWORD	NumberOfHeaps,
		PHANDLE	ProcessHeaps
	)

Definition at line 111 of file heapmem.c.

{
    /* Call the RTL API */
    return RtlGetProcessHeaps(NumberOfHeaps, ProcessHeaps);
}

GlobalAlloc()

HGLOBAL NTAPI GlobalAlloc	(	UINT	uFlags,
		SIZE_T	dwBytes
	)

Definition at line 368 of file heapmem.c.

{
    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;
}

Referenced by AddValuesToList(), AdvProcDetailsDlgProc(), alloc_and_set_onevalue(), ata_adapter_info(), ata_bblk(), ata_send_ioctl(), ata_send_scsi(), BeginUpdateResourceW(), BindInfo_GetBindInfo(), BitmapToClipboardDIB(), build_wpad_url(), C1_OnCreate(), CDevSettings_GetData(), clipboard_thread(), ClipboardReadMemoryBlock(), CommandLineToArgvT(), CompressBegin(), copy_stg_medium(), CopyBlock(), CopyCurrentGlyph(), CopyEventEntry(), CopyKeyName(), CopyLines(), CopyMemToClipboard(), CopyStgMedium(), CopyTextToClipboard(), create_callback(), create_channelbsc(), create_decoder(), create_dib(), create_doc_with_string(), create_execute(), create_metafile(), create_metafilepict(), create_mfpict(), create_poke(), create_stream(), create_stream_from_map(), create_stream_on_data(), create_stream_on_file(), create_stream_on_mip_ro(), create_text(), create_textA(), create_textW(), CreateILockBytesOnHGlobal(), CreateMappedBitmap(), CreateMemoryDialog(), CreateStreamOnHGlobal(), DataObject_DAdvise(), DataObjectImpl_CreateComplex(), DataObjectImpl_CreateText(), dde_server_wndproc(), DdeCreateDataHandle(), DetermineDialogBoxType(), doc_load_string(), TMouse::doClip(), CDefaultContextMenu::DoCopyOrCut(), DoSanitizeClipboard(), dup_global_mem(), EDIT_WM_Copy(), EditVariableDlgProc(), EngComputeGlyphSet(), EnumFormatImpl_Create(), EnvironmentDlgProc(), ExpandEnvironmentStringsForUserA(), expose_marshalled_dataobject(), fgetws(), GatherDataFromEditBox(), GatherDataFromListView(), GdiCreateLocalMetaFilePict(), get_data_from_storage(), get_data_from_stream(), get_rtf_text(), get_unicode_text(), GetAllUsersProfileDirectoryA(), GetClipboardData(), GetDefaultUserProfileDirectoryA(), GetEnvironmentVariables(), GetHGlobalFromILockBytes(), GetProfilesDirectoryA(), GetUserProfileDirectoryA(), grab_clipboard_process(), HEXEDIT_Copy(), HGLOBAL_UserUnmarshal(), HMETAFILEPICT_UserUnmarshal(), ICImageDecompress(), IntSynthesizeMultiByte(), IntSynthesizeWideChar(), K32CreateDBMonMutex(), load_dib(), load_image(), load_mf_pict(), load_string(), LoadImageFromFileHandle(), LoadTextFileToEdit(), localui_AddPortUI(), main(), MainWndProc(), marshal_WdtpInterfacePointer(), ME_GetDataObject(), MessageBoxTextToClipboard(), MsgiKMToUMMessage(), BrowserNavigator::navigated(), NoStatStream_Construct(), ObjectFromLresult(), OLEClipbrd_Initialize(), OleCreateMenuDescriptor(), OleDuplicateData(), OleMetafilePictFromIconAndLabel(), OnEditVariable(), OnNewVariable(), OnPaint(), PackDDElParam(), pagesetup_change_printer_dialog(), pagesetup_set_devmode(), pagesetup_set_devnames(), PRINTDLG_CreateDevNames(), PRINTDLG_CreateDevNamesW(), PrintDlgA(), PrintDlgW(), PropertySheetA(), PropertySheetW(), read_post_data_stream(), RECORD_StreamFromFile(), render_embed_source_hack(), RenderFILENAMEA(), RenderFILENAMEW(), RenderHDROP(), RenderSHELLIDLIST(), round_global_size(), SaveTextFileFromEdit(), set_clipboard_data_process(), set_clipboard_data_thread(), set_clipboard_formats(), set_dataobject_format(), SetAllVars(), SetClipboard(), START_TEST(), synthesize_dib(), T1_OnCreate(), test_apm(), test_brush_pens(), test_bsc_marshaling(), test_bufferrawformat(), test_ClipboardOwner(), test_componentinfo(), test_CopyStgMedium(), test_createfromstream(), test_decode(), test_decode_1bpp(), test_decode_24bpp(), test_decode_4bpp(), test_decode_adobe_cmyk(), test_decode_bitfields(), test_decode_rle4(), test_decode_rle8(), test_DragQueryFile(), test_empty_image(), test_empty_image_2(), test_enhmetafile(), test_freed_hglobal(), test_FreeDDElParam(), test_GdipLoadImageFromStream(), test_getdatahere(), test_GlobalAlloc(), test_handles(), test_handles_process_open(), test_heap(), test_Invoke(), test_IStream_Clone(), test_load_save_bmp(), test_load_save_emf(), test_load_save_empty_picture(), test_load_save_icon(), test_loadwmf(), test_marshal_HGLOBAL(), test_marshal_HMETAFILEPICT(), test_metafile(), test_multi_encoder_impl(), test_multiframegif(), test_nonole_clipboard(), test_obsolete_flags(), test_paste(), test_pattern_brush(), test_pic(), test_RegisterClipboardFormatA(), test_set_clipboard(), test_string_data(), test_supported_encoders(), test_UnpackDDElParam(), TestGlobalAllocNFree(), TestGlobalDiscard(), TestGlobalFlagsFixed(), TestGlobalFlagsMoveable(), TestGlobalHandle(), TestGlobalLockNUnlock(), TestGlobalReAllocFixed(), TestGlobalReAllocMovable(), TestGlobalSize(), TestSetAndGetExtraFormat(), unpack_dde_message(), update_devmode_handleA(), update_devmode_handleW(), WDML_BuildExecuteCommand(), WDML_ClientQueueAdvise(), WDML_ClientQueuePoke(), WDML_DataHandle2Global(), WdtpInterfacePointer_UserMarshal(), WdtpInterfacePointer_UserUnmarshal(), WinHelpA(), WinHttpGetDefaultProxyConfiguration(), WinHttpGetIEProxyConfigForCurrentUser(), wmain(), and WndProc().

GlobalCompact()

SIZE_T NTAPI GlobalCompact

(

DWORD

dwMinFree

)

Definition at line 498 of file heapmem.c.

{
    /* Call the RTL Heap Manager */
    return RtlCompactHeap(BaseHeap, 0);
}

GlobalFix()

VOID NTAPI GlobalFix

(

HGLOBAL

hMem

)

Definition at line 509 of file heapmem.c.

{
    /* Lock the memory if it the handle is valid */
    if (INVALID_HANDLE_VALUE != hMem) GlobalLock(hMem);
}

GlobalFlags()

UINT NTAPI GlobalFlags

(

HGLOBAL

hMem

)

Definition at line 520 of file heapmem.c.

{
    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;
}

Referenced by DisplayImageInfo(), DisplayStatus(), ModifyStatus(), PrintDlgW(), PrintFlags(), ShowStatus(), test_CopyStgMedium(), test_heap(), test_ImmGetIMCCLockCount(), test_pattern_brush(), TestGlobalDiscard(), TestGlobalFlagsFixed(), TestGlobalFlagsMoveable(), TestSetAndGetExtraFormat(), User32DefWindowProc(), and ValidateFlags().

GlobalFree()

HGLOBAL NTAPI GlobalFree

(

HGLOBAL

hMem

)

Definition at line 611 of file heapmem.c.

{
    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;
}

Referenced by _tWinMain(), AddValuesToList(), AdvProcDetailsDlgProc(), alloc_and_set_onevalue(), ata_bblk(), ata_send_ioctl(), ata_send_scsi(), BeginUpdateResourceW(), BindStatusCallback_Release(), BitmapToClipboardDIB(), C1_OnCreate(), C1_OnDestroy(), CDevSettings_GetData(), ClipboardReadBitmap(), ClipboardReadEnhMetafile(), ClipboardReadMemory(), ClipboardReadMemoryBlock(), ClipboardReadMetafile(), ClipboardReadPalette(), CmdDebugService(), COMCTL32_ReleaseStgMedium(), CompressEnd(), CopyBlock(), CopyEventEntry(), CopyLines(), create_stream(), CreateMappedBitmap(), CreateMemoryDialog(), DataObjectImpl_Release(), dde_msg_client_wndproc(), DdeCreateDataHandle(), DdeFreeDataHandle(), DdePostAdvise(), DetermineDialogBoxType(), DragFinish(), dup_metafilepict(), EditVariableDlgProc(), EndUpdateResourceW(), EngComputeGlyphSet(), EnumFormatImpl_Release(), EnvironmentDlgProc(), ExpandEnvironmentStringsForUserA(), expose_marshalled_dataobject(), fgetws(), ShellDirectory::fill_w32fdata_shell(), CGlobalAllocator::Free(), free_metafilepict(), FreeDDElParam(), GatherDataFromEditBox(), GatherDataFromListView(), GdiCreateLocalMetaFilePict(), get_data_from_storage(), get_data_from_stream(), get_descriptors(), get_stgmed_for_storage(), get_stgmed_for_stream(), GetAllUsersProfileDirectoryA(), GetClipboardData(), GetDefaultUserProfileDirectoryA(), GetEnvironmentVariables(), GetProfilesDirectoryA(), GetUserProfileDirectoryA(), handle_release(), HEXEDIT_Copy(), HGLOBAL_UserFree(), HGLOBALLockBytesImpl_Release(), HMETAFILEPICT_UserFree(), ICImageDecompress(), K32CreateDBMonMutex(), load_dib(), load_mf_pict(), LoadImageFromFileHandle(), LoadTextFileToEdit(), LocalFree(), main(), MainWndProc(), MessageBoxTextToClipboard(), MsgiUMToKMCleanup(), BrowserNavigator::navigated(), NoStatStreamImpl_Destroy(), NOTEPAD_WndProc(), ObjectFromLresult(), OLEClipbrd_Initialize(), OleDestroyMenuDescriptor(), OleDuplicateData(), OleMetafilePictFromIconAndLabel(), CMainWindow::OnCommand(), OnDeleteVariable(), OnEditVariable(), OnNewVariable(), OnPaint(), pagesetup_change_printer_dialog(), PrintUIEntryW(), ProcessCommandLine(), PROPSHEET_CleanUp(), proxy_active(), read_post_data_stream(), RECORD_StreamFromFile(), release_request_data(), ReleaseListViewItems(), ReleaseStgMedium(), render_embed_source_hack(), render_format(), round_global_size(), SaveTextFileFromEdit(), set_clipboard_formats(), set_dataobject_format(), SetAllVars(), SetClipboard(), SHGetRealIDL(), START_TEST(), T1_OnCreate(), T1_OnDestroy(), test_abort_proc(), test_AddPortUI(), test_brush_pens(), test_componentinfo(), test_CopyStgMedium(), test_createfromstream(), test_decode(), test_decode_1bpp(), test_decode_24bpp(), test_decode_4bpp(), test_decode_adobe_cmyk(), test_decode_bitfields(), test_decode_rle4(), test_decode_rle8(), test_DeviceCapabilities(), test_freed_hglobal(), test_FreeDDElParam(), test_GlobalAlloc(), test_handles(), test_heap(), test_Invoke(), test_load_save_bmp(), test_load_save_emf(), test_load_save_icon(), test_marshal_HGLOBAL(), test_marshal_HMETAFILEPICT(), test_msg_client(), test_obsolete_flags(), test_onevalue_cap(), test_PageSetupDlgA(), test_pattern_brush(), test_physical(), test_PrintDlgA(), test_PrintDlgExW(), test_resolution(), test_supported_sizes(), test_UnpackDDElParam(), test_WinHttpDetectAutoProxyConfigUrl(), test_WinHttpGetIEProxyConfigForCurrentUser(), test_WinHttpGetProxyForUrl(), TestGlobalAllocNFree(), TestGlobalDiscard(), TestGlobalFlagsFixed(), TestGlobalFlagsMoveable(), TestGlobalHandle(), TestGlobalLockNUnlock(), TestGlobalReAllocFixed(), TestGlobalReAllocMovable(), TestGlobalSize(), unpack_dde_message(), CTravelEntry::Update(), update_devmode_handleA(), update_devmode_handleW(), WDML_BuildExecuteCommand(), WDML_FreeTransaction(), WDML_HandleAdviseReply(), WDML_HandleIncomingData(), WDML_HandlePokeReply(), WDML_HandleRequestReply(), WDML_ServerHandleAdvise(), WDML_ServerHandlePoke(), WDML_ServerHandleRequest(), WdtpInterfacePointer_UserMarshal(), WdtpInterfacePointer_UserUnmarshal(), WinHttpGetDefaultProxyConfiguration(), WinHttpGetIEProxyConfigForCurrentUser(), WinHttpGetProxyForUrl(), WinHttpOpen(), wmain(), WndProc(), wWinMain(), and CTravelEntry::~CTravelEntry().

GlobalHandle()

HGLOBAL NTAPI GlobalHandle

(

LPCVOID

pMem

)

Definition at line 705 of file heapmem.c.

{
    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;
}

Referenced by CompressEnd(), FreeDDElParam(), GetClipboardData(), LocalHandle(), test_GlobalAlloc(), test_ImmGetIMCCLockCount(), and TestGlobalHandle().

GlobalLock()

LPVOID NTAPI GlobalLock

(

HGLOBAL

hMem

)

Definition at line 755 of file heapmem.c.

{
    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;
}

Referenced by _clipboard_range_contains(), CRecyclerDropTarget::_DoDeleteDataObject(), CFSDropTarget::_DoDrop(), AdvProcDetailsDlgProc(), alloc_and_set_onevalue(), BeginUpdateResourceW(), BitmapFromClipboardDIB(), BitmapToClipboardDIB(), bsc_OnStopBinding(), C1_OnButtonUp(), C1_OnCreate(), C1_OnDestroy(), C1_OnDraw(), C1_OnImeControl(), C1_OnMouseMove(), C1_OnSetCursor(), C1_SetData(), check_dib_size(), check_get(), check_iml_data(), check_output(), check_output_raw(), ClipboardReadBitmap(), ClipboardReadEnhMetafile(), ClipboardReadMemoryBlock(), ClipboardReadMetafile(), ClipboardReadPalette(), ClipboardWriteMemory(), CommandLineToArgvT(), CompressBegin(), anonymous_namespace{mstscax.cpp}::CoClass::ControlInfoToString(), copy_stg_medium(), CopyBlock(), CopyCurrentGlyph(), CopyEventEntry(), CopyKeyName(), CopyLines(), CopyMemToClipboard(), CopyStgMedium(), CopyTextToClipboard(), create_decoder(), create_dib(), create_execute(), create_map_from_stream(), create_metafile(), create_metafilepict(), create_mfpict(), create_poke(), create_stream(), create_stream_from_map(), create_stream_on_data(), create_stream_on_file(), create_stream_on_mip_ro(), create_text(), create_textA(), create_textW(), CreateDIBPatternBrush(), CreateMemoryDialog(), D3DXSaveSurfaceToFileInMemory(), DataCache_Draw(), DataCache_GetExtent(), DataObjectImpl_CreateComplex(), DataObjectImpl_CreateText(), DataObjectImpl_Release(), dde_msg_client_wndproc(), dde_server_wndproc(), dde_server_wndprocA(), dde_server_wndprocW(), DdeAccessData(), DdeCreateDataHandle(), TMouse::doClip(), CDefaultContextMenu::DoCopyOrCut(), CDefaultContextMenu::DoPaste(), DoSanitizeClipboard(), DragQueryFileA(), DragQueryFileW(), DragQueryPoint(), DrawTextFromClipboard(), CExeDropHandler::Drop(), dup_global_mem(), dup_metafilepict(), EDIT_WM_Copy(), EDIT_WM_Paste(), EndUpdateResourceW(), ExtCreatePen(), FILEDLG95_FILENAME_FillFromSelection(), ShellDirectory::fill_w32fdata_shell(), free_metafilepict(), GdiConvertMetaFilePict(), GdiCreateLocalMetaFilePict(), get_current_dataobject(), get_current_ole_clip_window(), get_descriptors(), get_onevalue(), get_priv_data(), get_stgdef(), get_unicode_text(), GetClipboardData(), GetClipboardDataDimensions(), PIDList::GetData(), GetHGlobalFromILockBytes(), GetNumSelected(), GetPidlFromDataObject(), GlobalFix(), GlobalWire(), GuiPasteToTextModeBuffer(), handle_read(), handle_write(), HEXEDIT_Copy(), HEXEDIT_Paste(), HGLOBAL_UserMarshal(), HGLOBAL_UserUnmarshal(), HGLOBALLockBytesImpl_ReadAt(), HGLOBALLockBytesImpl_WriteAt(), HMETAFILEPICT_UserFree(), HMETAFILEPICT_UserMarshal(), HMETAFILEPICT_UserSize(), HMETAFILEPICT_UserUnmarshal(), ICImageDecompress(), BtrfsContextMenu::Initialize(), BtrfsPropSheet::Initialize(), BtrfsVolPropSheet::Initialize(), CZipFolder::Initialize(), CLayerUIPropPage::Initialize(), IntSynthesizeMultiByte(), IntSynthesizeWideChar(), BtrfsContextMenu::InvokeCommand(), InvokeObjectPickerDialog(), InvokeRemoteRegistryPickerDialog(), is_fixed(), is_moveable(), IsDataUnicode(), IsMovable(), load_dib(), load_image(), load_mf_pict(), LoadImageFromFileHandle(), LocalLock(), MainWndProc(), make_dc(), marshal_WdtpInterfacePointer(), ME_AppendToHGLOBAL(), ME_ReadFromHGLOBALRTF(), ME_ReadFromHGLOBALUnicode(), MessageBoxTextToClipboard(), MsgiKMToUMMessage(), MsgiUMToKMMessage(), NoStatStreamImpl_Read(), NoStatStreamImpl_Write(), ok_attributes_(), OleCreateMenuDescriptor(), OleDuplicateData(), OLEMenu_CallWndProc(), OLEMenu_GetMsgProc(), OleMetafilePictFromIconAndLabel(), OleSetMenuDescriptor(), DesktopDropTarget::OnDrop(), TreeDropTarget::OnDrop(), OnPaint(), OverrideFileContent(), PackDDElParam(), pagesetup_change_printer_dialog(), pagesetup_get_a_devname(), pagesetup_get_devmode(), pagesetup_get_orientation(), pagesetup_get_papersize(), pagesetup_set_defaultsource(), pagesetup_set_devmode(), pagesetup_set_devnames(), pagesetup_set_orientation(), pagesetup_set_papersize(), Tnclip::Paste(), PasteIntoCurrentGlyph(), PlayMetaFileFromClipboard(), post_dde_message(), PRINTDLG_ChangePrinterA(), PRINTDLG_ChangePrinterW(), PRINTDLG_CreateDCA(), PRINTDLG_CreateDCW(), PRINTDLG_CreateDevNames(), PRINTDLG_CreateDevNamesW(), PRINTDLG_WMInitDialog(), PRINTDLG_WMInitDialogW(), PrintDlgA(), PrintDlgW(), QueryDeskCplExtInterface(), QueryDeskCplString(), ReadClipboard(), CConsole::ReadLine(), ReleaseStgMedium(), render_embed_source_hack(), RenderFILENAMEA(), RenderFILENAMEW(), RenderHDROP(), RenderSHELLIDLIST(), ReuseDDElParam(), RunningObjectTableImpl_Register(), save_dib(), save_mfpict(), set_clipboard_formats(), set_dataobject_format(), SetClipboard(), SetClipboardData(), SetDIBitsToDeviceFromClipboard(), SHGetRealIDL(), show_reflink_paste(), snapshot_GetDataHere(), START_TEST(), stgmedium_cmp(), synthesize_bitmap(), synthesize_dib(), synthesize_emf(), T1_OnButtonUp(), T1_OnCreate(), T1_OnDestroy(), T1_OnDraw(), T1_OnImeControl(), T1_OnMouseMove(), T1_OnSetCursor(), T1_SetData(), test_apm(), test_brush_pens(), test_bufferrawformat(), test_cf_dataobject(), test_componentinfo(), test_CopyStgMedium(), test_createfromstream(), test_data_cache_dib_contents_stream(), test_data_handles(), test_DataObject_FirstFile(), test_DataObject_FirstFolder(), test_decode(), test_decode_1bpp(), test_decode_24bpp(), test_decode_4bpp(), test_decode_adobe_cmyk(), test_decode_bitfields(), test_decode_rle4(), test_decode_rle8(), test_DeviceCapabilities(), test_DragQueryFile(), test_empty_image(), test_empty_image_2(), test_enhmetafile(), test_EnumObjects_Files(), test_EnumObjects_Folders(), test_freed_hglobal(), test_freethreadedmarshaldata(), test_GdipLoadImageFromStream(), test_GlobalAlloc(), test_handles_process(), test_handles_process_open(), test_handles_thread2(), test_heap(), test_Invoke(), test_load_save_bmp(), test_load_save_emf(), test_load_save_empty_picture(), test_load_save_icon(), test_loadwmf(), test_marshal_HGLOBAL(), test_marshal_HMETAFILEPICT(), test_metafile(), test_moniker(), test_multiframegif(), test_mxwriter_encoding(), test_omitxmldeclaration(), test_PackDDElParam(), test_paste(), test_pattern_brush(), test_persist_save_data(), test_pic(), test_PrintDlgA(), test_PrintDlgExW(), test_resolution(), test_save(), test_set_clipboard(), test_single_source(), test_synthesized(), test_UnpackDDElParam(), test_writeenddocument(), TestDefaultFormat(), TestGlobalFlagsFixed(), TestGlobalFlagsMoveable(), TestGlobalHandle(), TestGlobalLockNUnlock(), TestGlobalReAllocFixed(), TestGlobalReAllocMovable(), TestSetAndGetExtraFormat(), unpack_dde_message(), UnpackDDElParam(), update_devmode_handleA(), update_devmode_handleW(), UpdateResourceW(), WDML_BuildExecuteCommand(), WDML_ClientQueueAdvise(), WDML_ClientQueuePoke(), WDML_DataHandle2Global(), WDML_Global2DataHandle(), WDML_IsAppOwned(), WDML_ServerHandleAdvise(), WDML_ServerHandleExecute(), WDML_ServerHandlePoke(), WdtpInterfacePointer_UserMarshal(), WdtpInterfacePointer_UserUnmarshal(), WinHelpA(), wmain(), WndProc(), WorkerThread(), and xslprocessor_transform().

GlobalMemoryStatus()

VOID NTAPI GlobalMemoryStatus

(

LPMEMORYSTATUS

lpBuffer

)

Definition at line 1365 of file heapmem.c.

{
    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);
    }
}

Referenced by AllSysInfo(), CommandMemory(), CookupNodeId(), and SHIsLowMemoryMachine().

GlobalMemoryStatusEx()

BOOL NTAPI GlobalMemoryStatusEx

(

LPMEMORYSTATUSEX

lpBuffer

)

Definition at line 1272 of file heapmem.c.

{
    SYSTEM_PERFORMANCE_INFORMATION PerformanceInfo;
    VM_COUNTERS VmCounters;
    QUOTA_LIMITS QuotaLimits;
    ULONGLONG PageFile, PhysicalMemory;
    NTSTATUS Status;
 
    if (lpBuffer->dwLength != sizeof(*lpBuffer))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* Query performance information */
    Status = NtQuerySystemInformation(SystemPerformanceInformation,
                                      &PerformanceInfo,
                                      sizeof(PerformanceInfo),
                                      NULL);
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return FALSE;
    }
 
    /* 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 */
    Status = NtQueryInformationProcess(NtCurrentProcess(),
                                       ProcessQuotaLimits,
                                       &QuotaLimits,
                                       sizeof(QUOTA_LIMITS),
                                       NULL);
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return FALSE;
    }
 
    Status = NtQueryInformationProcess(NtCurrentProcess(),
                                       ProcessVmCounters,
                                       &VmCounters,
                                       sizeof(VM_COUNTERS),
                                       NULL);
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return FALSE;
    }
 
    /* 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;
}

Referenced by AboutDlgProc(), build_systeminfo_tree(), CommandMemory(), get_available_physical_memory(), get_total_physical_memory(), GetSystemInformation(), GlobalMemoryStatus(), Hib_InitDialog(), InitializeSystemPage(), OnSelChange(), set_installer_properties(), and test_GetPhysicallyInstalledSystemMemory().

GlobalReAlloc()

HGLOBAL NTAPI GlobalReAlloc	(	HGLOBAL	hMem,
		SIZE_T	dwBytes,
		UINT	uFlags
	)

Definition at line 825 of file heapmem.c.

{
    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;
}

Referenced by DdeAddData(), get_rtf_text(), handle_setsize(), handle_write(), HGLOBALLockBytesImpl_SetSize(), ME_AppendToHGLOBAL(), NoStatStreamImpl_SetSize(), pagesetup_set_devmode(), pagesetup_set_devnames(), PRINTDLG_CreateDevNames(), PRINTDLG_CreateDevNamesW(), PrintDlgA(), PrintDlgW(), test_GlobalAlloc(), test_heap(), TestGlobalReAllocFixed(), TestGlobalReAllocMovable(), update_devmode_handleA(), update_devmode_handleW(), and wmain().

GlobalSize()

SIZE_T NTAPI GlobalSize

(

HGLOBAL

hMem

)

Definition at line 1090 of file heapmem.c.

{
    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;
}

Referenced by bsc_OnStopBinding(), check_output(), check_output_raw(), ClipboardWriteMemory(), CopyStgMedium(), create_map_from_stream(), CreateILockBytesOnHGlobal(), dde_server_wndproc(), DdeAccessData(), dup_global_mem(), ShellDirectory::fill_w32fdata_shell(), get_current_dataobject(), GetClipboardData(), handle_create(), HGLOBAL_UserMarshal(), HGLOBAL_UserSize(), is_freed(), IsDataUnicode(), LocalSize(), ME_AppendToHGLOBAL(), MyAllocatePool(), MyFreePool(), NoStatStream_Construct(), ok_attributes_(), OleDuplicateData(), post_dde_message(), PostMessageA(), PostMessageW(), round_global_size(), RunningObjectTableImpl_Register(), save_dib(), SetClipboardData(), snapshot_GetDataHere(), stgmedium_cmp(), test_cf_dataobject(), test_CopyStgMedium(), test_data_cache_dib_contents_stream(), test_freethreadedmarshaldata(), test_GlobalAlloc(), test_handles(), test_heap(), test_marshal_HGLOBAL(), test_moniker(), test_persist_save_data(), test_string_data_process(), test_synthesized(), TestDefaultFormat(), TestGlobalSize(), TestSetAndGetExtraFormat(), unpack_dde_message(), update_devmode_handleA(), update_devmode_handleW(), WDML_ClientQueuePoke(), WDML_DataHandle2Global(), WDML_Global2DataHandle(), WDML_ServerHandleExecute(), WDML_ServerHandlePoke(), WdtpInterfacePointer_UserMarshal(), wmain(), and xslprocessor_transform().

GlobalUnfix()

VOID NTAPI GlobalUnfix

(

HGLOBAL

hMem

)

Definition at line 1179 of file heapmem.c.

{
    /* If the handle is valid, unlock it */
    if (hMem != INVALID_HANDLE_VALUE) GlobalUnlock(hMem);
}

GlobalUnlock()

BOOL NTAPI GlobalUnlock

(

HGLOBAL

hMem

)

Definition at line 1190 of file heapmem.c.

{
    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;
}

Referenced by _clipboard_range_contains(), CRecyclerDropTarget::_DoDeleteDataObject(), AdvProcDetailsDlgProc(), alloc_and_set_onevalue(), BeginUpdateResourceW(), BitmapFromClipboardDIB(), BitmapToClipboardDIB(), bsc_OnStopBinding(), C1_OnButtonUp(), C1_OnCreate(), C1_OnDestroy(), C1_OnDraw(), C1_OnImeControl(), C1_OnMouseMove(), C1_OnSetCursor(), C1_SetData(), check_dib_size(), check_get(), check_iml_data(), check_output(), check_output_raw(), ClipboardReadBitmap(), ClipboardReadEnhMetafile(), ClipboardReadMemoryBlock(), ClipboardReadMetafile(), ClipboardReadPalette(), ClipboardWriteMemory(), COMCTL32_ReleaseStgMedium(), CompressEnd(), anonymous_namespace{mstscax.cpp}::CoClass::ControlInfoToString(), copy_stg_medium(), CopyBlock(), CopyCurrentGlyph(), CopyEventEntry(), CopyKeyName(), CopyLines(), CopyMemToClipboard(), CopyStgMedium(), CopyTextToClipboard(), create_decoder(), create_dib(), create_execute(), create_map_from_stream(), create_metafile(), create_metafilepict(), create_mfpict(), create_poke(), create_stream(), create_stream_from_map(), create_stream_on_data(), create_stream_on_file(), create_stream_on_mip_ro(), create_text(), create_textA(), create_textW(), CreateDIBPatternBrush(), CreateMemoryDialog(), D3DXSaveSurfaceToFileInMemory(), DataCache_Draw(), DataCache_GetExtent(), DataObjectImpl_CreateComplex(), DataObjectImpl_CreateText(), DataObjectImpl_Release(), dde_msg_client_wndproc(), dde_server_wndproc(), dde_server_wndprocA(), dde_server_wndprocW(), DdeCreateDataHandle(), DdeUnaccessData(), TMouse::doClip(), CDefaultContextMenu::DoCopyOrCut(), CDefaultContextMenu::DoPaste(), DoSanitizeClipboard(), DragQueryFileA(), DragQueryFileW(), DragQueryPoint(), DrawTextFromClipboard(), CExeDropHandler::Drop(), dup_global_mem(), dup_metafilepict(), EDIT_WM_Copy(), EDIT_WM_Paste(), EndUpdateResourceW(), ExtCreatePen(), ShellDirectory::fill_w32fdata_shell(), free_metafilepict(), GdiConvertMetaFilePict(), GdiCreateLocalMetaFilePict(), get_current_dataobject(), get_current_ole_clip_window(), get_descriptors(), get_onevalue(), get_priv_data(), get_stgdef(), get_unicode_text(), GetClipboardData(), GetClipboardDataDimensions(), GetHGlobalFromILockBytes(), GlobalUnfix(), GlobalUnWire(), GuiPasteToTextModeBuffer(), handle_read(), handle_write(), HEXEDIT_Copy(), HEXEDIT_Paste(), HGLOBAL_UserMarshal(), HGLOBAL_UserUnmarshal(), HGLOBALLockBytesImpl_ReadAt(), HGLOBALLockBytesImpl_WriteAt(), HMETAFILEPICT_UserFree(), HMETAFILEPICT_UserMarshal(), HMETAFILEPICT_UserSize(), HMETAFILEPICT_UserUnmarshal(), ICImageDecompress(), BtrfsContextMenu::Initialize(), BtrfsPropSheet::Initialize(), BtrfsVolPropSheet::Initialize(), CZipFolder::Initialize(), CLayerUIPropPage::Initialize(), BtrfsContextMenu::InvokeCommand(), InvokeObjectPickerDialog(), InvokeRemoteRegistryPickerDialog(), is_fixed(), is_moveable(), IsDataUnicode(), IsMovable(), load_dib(), load_image(), load_mf_pict(), LoadImageFromFileHandle(), MainWndProc(), make_dc(), marshal_WdtpInterfacePointer(), ME_AppendToHGLOBAL(), ME_ReadFromHGLOBALRTF(), ME_ReadFromHGLOBALUnicode(), MessageBoxTextToClipboard(), MsgiKMToUMCleanup(), MsgiKMToUMMessage(), MsgiUMToKMCleanup(), NoStatStreamImpl_Read(), NoStatStreamImpl_Write(), ok_attributes_(), OleCreateMenuDescriptor(), OleDuplicateData(), OLEMenu_CallWndProc(), OLEMenu_GetMsgProc(), OleMetafilePictFromIconAndLabel(), OleSetMenuDescriptor(), DesktopDropTarget::OnDrop(), TreeDropTarget::OnDrop(), OnPaint(), OverrideFileContent(), PackDDElParam(), pagesetup_change_printer_dialog(), pagesetup_get_a_devname(), pagesetup_get_devmode(), pagesetup_get_orientation(), pagesetup_get_papersize(), pagesetup_set_defaultsource(), pagesetup_set_devmode(), pagesetup_set_devnames(), pagesetup_set_orientation(), pagesetup_set_papersize(), Tnclip::Paste(), PasteIntoCurrentGlyph(), PlayMetaFileFromClipboard(), post_dde_message(), PRINTDLG_ChangePrinterA(), PRINTDLG_ChangePrinterW(), PRINTDLG_CreateDCA(), PRINTDLG_CreateDCW(), PRINTDLG_CreateDevNames(), PRINTDLG_CreateDevNamesW(), PRINTDLG_WMInitDialog(), PRINTDLG_WMInitDialogW(), PrintDlgA(), PrintDlgW(), QueryDeskCplExtInterface(), QueryDeskCplString(), ReadClipboard(), CConsole::ReadLine(), ReleaseStgMedium(), render_embed_source_hack(), RenderFILENAMEA(), RenderFILENAMEW(), RenderHDROP(), RenderSHELLIDLIST(), ReuseDDElParam(), RunningObjectTableImpl_Register(), save_dib(), save_mfpict(), set_clipboard_formats(), set_dataobject_format(), SetClipboard(), SetClipboardData(), SetDIBitsToDeviceFromClipboard(), SHGetRealIDL(), show_reflink_paste(), snapshot_GetDataHere(), START_TEST(), stgmedium_cmp(), synthesize_bitmap(), synthesize_dib(), synthesize_emf(), T1_OnButtonUp(), T1_OnCreate(), T1_OnDestroy(), T1_OnDraw(), T1_OnImeControl(), T1_OnMouseMove(), T1_OnSetCursor(), T1_SetData(), test_brush_pens(), test_bufferrawformat(), test_cf_dataobject(), test_componentinfo(), test_CopyStgMedium(), test_createfromstream(), test_data_cache_dib_contents_stream(), test_data_handles(), test_DataObject_FirstFile(), test_DataObject_FirstFolder(), test_decode(), test_decode_1bpp(), test_decode_24bpp(), test_decode_4bpp(), test_decode_adobe_cmyk(), test_decode_bitfields(), test_decode_rle4(), test_decode_rle8(), test_DeviceCapabilities(), test_DragQueryFile(), test_EnumObjects_Files(), test_EnumObjects_Folders(), test_freed_hglobal(), test_freethreadedmarshaldata(), test_GdipLoadImageFromStream(), test_GlobalAlloc(), test_handles_process(), test_handles_process_open(), test_handles_thread2(), test_heap(), test_ImmGetIMCCLockCount(), test_Invoke(), test_load_save_bmp(), test_load_save_emf(), test_load_save_empty_picture(), test_load_save_icon(), test_loadwmf(), test_marshal_HGLOBAL(), test_marshal_HMETAFILEPICT(), test_moniker(), test_multiframegif(), test_mxwriter_encoding(), test_omitxmldeclaration(), test_PackDDElParam(), test_paste(), test_persist_save_data(), test_pic(), test_PrintDlgA(), test_PrintDlgExW(), test_resolution(), test_save(), test_set_clipboard(), test_single_source(), test_synthesized(), test_UnpackDDElParam(), TestDefaultFormat(), TestGlobalFlagsMoveable(), TestGlobalHandle(), TestGlobalLockNUnlock(), TestGlobalReAllocFixed(), TestGlobalReAllocMovable(), TestSetAndGetExtraFormat(), unpack_dde_message(), UnpackDDElParam(), update_devmode_handleA(), update_devmode_handleW(), UpdateResourceW(), WDML_BuildExecuteCommand(), WDML_ClientQueueAdvise(), WDML_ClientQueuePoke(), WDML_DataHandle2Global(), WDML_Global2DataHandle(), WDML_IsAppOwned(), WDML_ServerHandleAdvise(), WDML_ServerHandleExecute(), WDML_ServerHandlePoke(), WdtpInterfacePointer_UserMarshal(), WdtpInterfacePointer_UserUnmarshal(), WinHelpA(), wmain(), WndProc(), WorkerThread(), xslprocessor_transform(), BtrfsContextMenu::~BtrfsContextMenu(), BtrfsPropSheet::~BtrfsPropSheet(), BtrfsVolPropSheet::~BtrfsVolPropSheet(), and PIDList::~PIDList().

GlobalUnWire()

BOOL NTAPI GlobalUnWire

(

HGLOBAL

hMem

)

Definition at line 1250 of file heapmem.c.

{
    /* This is simply an unlock */
    return GlobalUnlock(hMem);
}

GlobalWire()

LPVOID NTAPI GlobalWire

(

HGLOBAL

hMem

)

Definition at line 1261 of file heapmem.c.

{
    /* This is just a lock */
    return GlobalLock(hMem);
}

HeapCompact()

SIZE_T WINAPI HeapCompact	(	HANDLE	hHeap,
		DWORD	dwFlags
	)

Definition at line 145 of file heapmem.c.

{
    /* Call the RTL API */
    return RtlCompactHeap(hHeap, dwFlags);
}

Referenced by _heapmin().

HeapCreate()

HANDLE WINAPI HeapCreate	(	DWORD	flOptions,
		SIZE_T	dwInitialSize,
		SIZE_T	dwMaximumSize
	)

Definition at line 45 of file heapmem.c.

{
    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;
}

Referenced by _set_sbh_threshold(), DllMain(), msvcrt_init_heap(), CListNode::operator new(), runtimehost_init(), ShimLib_Init(), test_dpa(), and test_HeapCreate().

HeapCreateTagsW()

DWORD WINAPI HeapCreateTagsW	(	_In_ HANDLE	hHeap,
		_In_ DWORD	dwFlags,
		_In_opt_ PWSTR	lpTagName,
		_In_ PWSTR	lpTagSubName
	)

Definition at line 169 of file heapmem.c.

{
    /* Call the RTL API */
    return RtlCreateTagHeap(hHeap,
                            dwFlags,
                            lpTagName,
                            lpTagSubName);
}

HeapDestroy()

BOOL WINAPI HeapDestroy

(

HANDLE

hHeap

)

Definition at line 85 of file heapmem.c.

{
    /* 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;
}

Referenced by DllMain(), msvcrt_destroy_heap(), CListNode::operator delete(), runtimehost_uninit(), ShimLib_Deinit(), and test_HeapCreate().

HeapExtend()

DWORD WINAPI HeapExtend	(	HANDLE	hHeap,
		DWORD	dwFlags,
		PVOID	BaseAddress,
		DWORD	dwBytes
	)

Definition at line 186 of file heapmem.c.

{
    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;
}

HeapLock()

BOOL WINAPI HeapLock

(

HANDLE

hHeap

)

Definition at line 123 of file heapmem.c.

{
    /* Call the RTL API */
    return RtlLockHeap(hHeap);
}

Referenced by dll_entry_point(), IsBlockFromHeap(), mutex_thread_proc(), and RtlInitializeHeapLock().

HeapQueryInformation()

BOOL WINAPI HeapQueryInformation	(	HANDLE	HeapHandle,
		HEAP_INFORMATION_CLASS	HeapInformationClass,
		PVOID HeapInformation	OPTIONAL,
		SIZE_T HeapInformationLength	OPTIONAL,
		PSIZE_T ReturnLength	OPTIONAL
	)

Definition at line 314 of file heapmem.c.

{
    NTSTATUS Status;
 
    Status = RtlQueryHeapInformation(HeapHandle,
                                     HeapInformationClass,
                                     HeapInformation,
                                     HeapInformationLength,
                                     ReturnLength);
 
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by is_contraction_possible().

HeapQueryTagW()

PWSTR WINAPI HeapQueryTagW	(	HANDLE	hHeap,
		DWORD	dwFlags,
		WORD	wTagIndex,
		BOOL	bResetCounters,
		PVOID	lpTagInfo
	)

Definition at line 211 of file heapmem.c.

{
    /* Call the RTL API */
    return RtlQueryTagHeap(hHeap,
                           dwFlags,
                           wTagIndex,
                           (BOOLEAN)bResetCounters,
                           lpTagInfo);
}

HeapSetInformation()

BOOL WINAPI HeapSetInformation	(	HANDLE	HeapHandle,
		HEAP_INFORMATION_CLASS	HeapInformationClass,
		PVOID HeapInformation	OPTIONAL,
		SIZE_T HeapInformationLength	OPTIONAL
	)

Definition at line 342 of file heapmem.c.

{
    NTSTATUS Status;
 
    Status = RtlSetHeapInformation(HeapHandle,
                                   HeapInformationClass,
                                   HeapInformation,
                                   HeapInformationLength);
 
    if (!NT_SUCCESS(Status))
    {
        BaseSetLastNTError(Status);
        return FALSE;
    }
 
    return TRUE;
}

HeapSummary()

BOOL WINAPI HeapSummary	(	HANDLE	hHeap,
		DWORD	dwFlags,
		PVOID	Summary
	)

Definition at line 230 of file heapmem.c.

{
    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;
}

HeapUnlock()

BOOL WINAPI HeapUnlock

(

HANDLE

hHeap

)

Definition at line 134 of file heapmem.c.

{
    /* Call the RTL API */
    return RtlUnlockHeap(hHeap);
}

Referenced by IsBlockFromHeap().

HeapUsage()

BOOL WINAPI HeapUsage	(	HANDLE	hHeap,
		DWORD	dwFlags,
		DWORD	Unknown,
		DWORD	Unknown2,
		IN PVOID	Usage
	)

Definition at line 259 of file heapmem.c.

{
    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;
}

HeapValidate()

BOOL WINAPI HeapValidate	(	HANDLE	hHeap,
		DWORD	dwFlags,
		LPCVOID	lpMem
	)

Definition at line 156 of file heapmem.c.

{
    /* Call the RTL API */
    return RtlValidateHeap(hHeap, dwFlags, (PVOID)lpMem);
}

Referenced by __getmainargs(), __wgetmainargs(), _CrtCheckMemory(), _CrtIsValidHeapPointer(), _heapchk(), _heapwalk(), free_dbg_nolock(), IMalloc_fnDidAlloc(), msvcrt_heap_free(), msvcrt_heap_realloc(), msvcrt_heap_size(), pdb_process_internal(), test_heap_checks(), and test_tp_io().

HeapWalk()

BOOL WINAPI HeapWalk	(	HANDLE	hHeap,
		LPPROCESS_HEAP_ENTRY	lpEntry
	)

Definition at line 291 of file heapmem.c.

{
    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;
}

Referenced by _heapwalk(), IsBlockFromHeap(), and try_walk().

LocalAlloc()

HLOCAL NTAPI LocalAlloc	(	UINT	uFlags,
		SIZE_T	dwBytes
	)

Definition at line 1390 of file heapmem.c.

{
    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;
}

Referenced by CMruBase::_AddItem(), CMruPidlList::_InitNodeSlots(), CMruShortList::_InitSlots(), CMruLongList::_InitSlots(), CMruBase::_LoadItem(), CRegPropertyBag::_ReadBinary(), CRegPropertyBag::_WriteStream(), AccpLookupCurrentUser(), AccpLookupSidByName(), AccpOpenNamedObject(), AccRewriteGetExplicitEntriesFromAcl(), AccRewriteGetHandleRights(), AccRewriteSetEntriesInAcl(), Alloc(), AllocAndLoadString(), AllocAndLoadStringsCat(), AllocFunction(), AppendUserEnvironmentVariable(), asn_dump(), AuthzInitializeContextFromSid(), AuthzInitializeResourceManager(), AuthzpQueryToken(), blob_to_str(), CallBackConvertToAscii(), CheckEscapesA(), cicMemAlloc(), cicMemAllocClear(), cicMemReAlloc(), client_start(), CommandLineToArgvW(), compat_catpath(), CompressBegin(), ConvertSecurityDescriptorToStringSecurityDescriptorW(), ConvertSidToStringSidA(), ConvertSidToStringSidW(), ConvertStringSecurityDescriptorToSecurityDescriptorW(), ConvertStringSidToSidW(), CShellLink::CopyDataBlock(), CreateDefaultSecurityDescriptor(), CreateFileOpStrings(), CreateRestrictedToken(), CRYPT_DecodeEnsureSpace(), CRYPT_EncodeDataContentInfoHeader(), CRYPT_EncodeEnsureSpace(), CryptUnprotectData(), DecompressBegin(), DIALOG_FilePrint(), DllMain(), Dns_AllocZero(), DoGetHandbagFromTicket(), DoSendData(), DoStartService(), DSEnumProc(), DuplicationString(), EDIT_EM_GetHandle(), EDIT_EM_SetHandle(), EDIT_WM_NCCreate(), EnumDeviceDrivers(), EnumPageFilesW(), EnumProcesses(), ExtractZipImage(), FindDeviceDriver(), FindDfltProvRegVals(), FindProvRegVals(), FindProvTypesRegVals(), FormatDlgProcWorker(), FormatMessageA(), FormatMessageW(), GdiConvertEnhMetaFile(), GdiConvertMetaFilePict(), GdiCreateLocalEnhMetaFile(), GdiCreateLocalMetaFilePict(), generateTestSignal(), get_module_version(), get_security_cert_struct(), GetDeviceDriverBaseNameW(), GetDeviceDriverFileNameW(), getDeviceInterfaceDetail(), GetMappedFileNameA(), GetModuleBaseNameA(), GetModuleFileNameExA(), GetMonitorDevInstID(), GetPerformanceInfo(), GetProcessImageFileNameA(), GetProcessImageFileNameW(), CDefView::GetSelectedObjects(), GetShellSecurityDescriptor(), GetUserAndDomainName(), GetUserNameA(), GetUserNameW(), GetUserSid(), GetUserSidStringFromToken(), HandleSetHandlePrintHex(), HEXEDIT_HEM_LOADBUFFER(), HEXEDIT_HEM_SETMAXBUFFERSIZE(), HidD_GetPreparsedData(), I_ScQueryServiceTagInfo(), IEffectivePermission_fnGetEffectivePermission(), IMAPIMalloc_fnAlloc(), IMAPIMalloc_fnRealloc(), Imm32InternalLockIMC(), ImmCreateIMCC(), InfoMessageBox(), CMruBase::InitData(), InitializeConnectionInfo(), InitMonitorDialog(), InstallScreenSaverA(), IntCreateDICW(), ISecurityObjectTypeInfo_fnGetInheritSource(), LookupAccountSidA(), malloc(), MonSelSetMonitorsInfo(), OF(), Open(), CTestShellFolder::operator new(), PathAllocCanonicalize(), pCDevSettings_AllocAndCopyString(), pCDevSettings_GetDeviceInstanceId(), pCDevSettings_GetMonitorDevice(), pCDevSettings_GetMonitorName(), pCDevSettings_Initialize(), PrintPartitionData(), ProcessNewLinesAndNulls(), query_reg_path(), QueryDeskCplExtInterface(), QueryDeskCplString(), ReAlloc(), RegisterGPNotification(), ReloadPrincipalsList(), RpcpAddInterface(), serialize(), server_start(), SetSpyedBlockTableLength(), SetSystemEnvironment(), SetUserEnvironment(), SetUserEnvironmentVariable(), SHAddDataBlock(), SHCloneIETHREADPARAM(), SHCreateIETHREADPARAM(), SHCreatePropSheetExtArrayEx(), SHQueryValueExA(), SHQueryValueExW(), SHReadDataBlockList(), SHTestTokenPrivilegeW(), SKAllocValueW(), START_TEST(), StatisticsMain(), StrDupA(), StrDupW(), test__hwrite(), test__lwrite(), test_EM_GETHANDLE(), test_enum_provider_types(), test_enum_providers(), test_get_default_provider(), test_heap(), test_LocalAlloc(), test_lsa(), test_sequence(), test_set_provider_ex(), U32AccelCacheAdd(), U32LoadAccelerators(), UXTHEME_GetParseErrorInfo(), VfdCheckDriverFile(), VfdCreateImageFile(), VfdFormatMedia(), VfdGetDriverConfig(), VfdGetImageInfo(), VfdOpenImage(), VfdSaveImage(), and WlxInitialize().

LocalCompact()

SIZE_T NTAPI LocalCompact

(

UINT

dwMinFree

)

Definition at line 1509 of file heapmem.c.

{
    /* Call the RTL Heap Manager */
    return RtlCompactHeap(BaseHeap, 0);
}

LocalFlags()

UINT NTAPI LocalFlags

(

HLOCAL

hMem

)

Definition at line 1520 of file heapmem.c.

{
    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;
}

Referenced by AcpiNsLookup(), ImmGetIMCCLockCount(), ImmGetIMCLockCount(), START_TEST(), and test_heap().

LocalFree()

HLOCAL NTAPI LocalFree

(

HLOCAL

hMem

)

Definition at line 1594 of file heapmem.c.

{
    /* This is identical to a Global Free */
    return GlobalFree(hMem);
}

Referenced by CMruBase::_AddItem(), CMruBase::_DeleteItem(), CMruBase::_LoadItem(), CRegPropertyBag::_ReadBinary(), _SHGetUserProfilePath(), _tmain(), _tWinMain(), CRegPropertyBag::_WriteStream(), AboutDialogProc(), AccFreeIndexArray(), AccpLookupSidByName(), AccpOpenNamedObject(), AccRewriteGetExplicitEntriesFromAcl(), AccRewriteGetHandleRights(), AccRewriteSetEntriesInAcl(), AddMenuItem(), AddPrincipalListEntry(), AddUserProfiles(), AllocAndLoadString(), AllocAndLoadStringsCat(), AppendUserEnvironmentVariable(), ApplyParameterStringsToMessage(), asn_dump(), AuthzFreeContext(), AuthzFreeResourceManager(), AuthzInitializeContextFromSid(), AuthzInitializeResourceManager(), AuthzpQueryToken(), BuildAdvPropTitle(), BuildLogListAndFilterList(), CallBackConvertToAscii(), CDataEncodeMsg_Close(), CDataEncodeMsg_Update(), CDecodeMsg_Close(), CDecodeMsg_DecodeContent(), CDecodeMsg_DecodeDataContent(), CDecodeMsg_DecodeHashedContent(), CDecodeMsg_FinalizeSignedContent(), CDecodeSignedMsg_GetParam(), Cert_free(), cert_get_name_from_rdn_attr(), cert_name_to_str_with_indent(), CertComparePublicKeyInfo(), CertCreateCTLContext(), CertCreateSelfSignCertificate(), CertGetEnhancedKeyUsage(), CertGetNameStringW(), CertGetPublicKeyLength(), CertIsRDNAttrsInCertificateName(), CertIsValidCRLForCertificate(), CertNameToStrA(), CertSetEnhancedKeyUsage(), CertStrToNameW(), ChangeListViewText(), CheckEscapesA(), CheckForError(), cicMemFree(), cleanUp(), client_stop(), Close(), CM_Set_Class_Registry_PropertyW(), cmd_type(), cmdHelpMsg(), CNG_ImportECCPubKey(), CNG_PrepareSignatureECC(), command_line_to_args(), CommandLineToArgvW(), compare_alt_name_with_constraints(), compare_crl_issued_by(), compare_subject_with_email_constraints(), compat_catpath(), CompressEnd(), ConMsgPrintf2V(), ConMsgPrintfV(), ConMsgPuts(), ConResMsgPrintfExV(), ConvertSecurityDescriptorToStringSecurityDescriptorA(), ConvertSecurityDescriptorToStringSecurityDescriptorW(), ConvertSidToStringSidA(), ConvertStringSecurityDescriptorToSecurityDescriptorW(), ConvertStringSidToSidW(), CopySystemProfile(), CreateApplicationWindow(), CreateDefaultSecurityDescriptor(), CreateEnvironmentBlock(), CreateFileOpStrings(), CreateFontWindow(), CreateRestrictedToken(), CreateUserProfileExW(), CRL_free(), CRYPT_AsnDecodeCert(), CRYPT_AsnDecodeCRL(), CRYPT_AsnDecodeRsaPrivKey(), CRYPT_AsnDecodeRsaPubKey(), CRYPT_AsnEncodeNameConstraints(), CRYPT_CheckChainNameConstraints(), CRYPT_CheckChainPolicies(), CRYPT_CheckUsages(), CRYPT_CreateSignedCert(), CRYPT_DecodeBasicConstraints(), CRYPT_EncodePKCSDigestedData(), CRYPT_FormatAltName(), CRYPT_FormatAuthorityInfoAccess(), CRYPT_FormatAuthorityKeyId2(), CRYPT_FormatBasicConstraints2(), CRYPT_FormatCPS(), CRYPT_FormatCRLDistPoints(), CRYPT_FormatEnhancedKeyUsage(), CRYPT_FormatKeyUsage(), CRYPT_FormatNetscapeCertType(), CRYPT_FormatUserNotice(), CRYPT_FreeSpace(), CRYPT_GetIssuer(), CRYPT_GetUrlFromCertificateIssuer(), CRYPT_GetUrlFromCRLDistPointsExt(), CRYPT_IsCertificateSelfSigned(), CryptHashPublicKeyInfo(), CryptHashToBeSigned(), CryptMsgEncodeAndSignCTL(), CryptUnprotectData(), CryptVerifyCertificateSignatureEx(), CSignedEncodeMsg_GetParam(), CSignedMsgData_AppendMessageDigestAttribute(), CSignedMsgData_UpdateAuthenticatedAttributes(), CTL_free(), debugstr_sid(), DecompressEnd(), DeleteTreeItem(), DestroyAcceleratorTable(), DestroySecurityPage(), DeviceProblemTextW(), DIALOG_FilePrint(), DIALOG_Printing_DialogProc(), directory_name_matches(), display_app_usages(), display_error(), DisplayApplet(), DisplayDacl(), DisplayDns(), DisplayError(), DisplayWin32Error(), dlg_win32error(), DllMain(), Dns_Free(), DoCreate(), DoDeleteService(), DoEntry(), DoFormatMessage(), DoSendData(), DoStartService(), DoTypeFile(), CVfdShExt::DoVfdDrop(), dump_alt_name(), dump_basic_constraints(), dump_cert_policies(), dump_enhanced_key_usage(), dump_name_constraints(), DumpEnum(), DumpUDT(), DwInitializeSdFromThreadToken(), EDIT_EM_SetHandle(), EDIT_WM_NCCreate(), EDIT_WM_NCDestroy(), EditSecurity(), EnterCriticalPolicySection(), enum_components(), enum_patches(), enum_products(), EnumDeviceDrivers(), EnumPageFilesW(), EnumProcesses(), COMExceptionBase::ErrorMessage(), ErrorMessage(), ErrorMessageBox(), export_validate_filename(), ExtractZipImage(), fill_sid(), find_cert_by_issuer(), FindDeviceDriver(), FindDfltProvRegVals(), FindProvTypesRegVals(), FontWndProc(), format_message(), FormatDlgProcWorker(), ATL::CStringT< BaseType, StringTraits >::FormatMessageV(), FormatMsgBox(), FormatOutput(), FormatVerisignExtension(), FrameOnCommand(), CLocalAllocator::Free(), Free(), free(), free_file_op_queue(), FreeConnectionInfo(), FreeFunction(), FreePrincipalsList(), GdiConvertEnhMetaFile(), GdiConvertMetaFilePict(), GdiCreateLocalEnhMetaFile(), GdiCreateLocalMetaFilePict(), get_cert_common_name(), get_cps_str_from_qualifier(), get_file_handle(), get_module_version(), get_user_notice_from_qualifier(), DriveVolume::GetClusterInfo(), getCurrentChannelConfig(), GetDeviceDriverBaseNameW(), GetDeviceDriverFileNameW(), getDeviceInterfaceDetail(), GetDeviceLocationString(), GetError(), GetEventCategory(), GetEventMessage(), GetEventUserName(), GetLastErrorText(), GetMappedFileNameA(), GetModuleBaseNameA(), GetModuleFileNameExA(), GetMonitorDevInstID(), GetOwnerModuleFromTagEntry(), GetPerformanceInfo(), GetProcessImageFileNameA(), GetProcessImageFileNameW(), GetShellSecurityDescriptor(), GetUserAndDomainName(), GetUserNameA(), GetUserNameW(), GetUserSid(), GetUserSIDString(), GetUserSidStringFromToken(), GRPFILE_ReadGroupFile(), HandleSetHandlePrintHex(), Help(), HEXEDIT_HEM_LOADBUFFER(), HEXEDIT_HEM_SETMAXBUFFERSIZE(), HEXEDIT_WM_NCDESTROY(), HidD_FreePreparsedData(), HidD_GetPreparsedData(), HTTPREQ_QueryOption(), IDeskDisplayAdapter_Destroy(), IDeskMonitor_Destroy(), IEffectivePermission_fnGetEffectivePermission(), IFileDialog2_fnRelease(), IFileDialog2_fnSetCancelButtonLabel(), IFileDialog2_fnSetDefaultExtension(), IFileDialog2_fnSetFileNameLabel(), IFileDialog2_fnSetOkButtonLabel(), IFileDialog2_fnSetTitle(), IMAPIMalloc_fnFree(), IMAPIMalloc_fnRealloc(), Imm32InternalLockIMC(), ImmDestroyIMCC(), ImmUnlockClientImc(), import_validate_filename(), InfoMessageBox(), RecycleBin5::Init(), InitDialog(), InitDisplayAdapterDialog(), InitializeSecurity(), InitMonitorDialog(), InitRecoveryPage(), InitUserSidString(), InstallBuiltinAccounts(), InstallOneService(), InstallPrivileges(), InstallScreenSaverA(), CFindFolderContextMenu::InvokeCommand(), CRecycleBinItemContextMenu::InvokeCommand(), is_ca_cert(), IStream_fnRelease(), last_error::last_error(), LoadAndFormatString(), LoadAndFormatStringsCat(), LogToFile(), LookupAccountSidA(), LsapGetDomainInfo(), LsapLookupAccountDomainSids(), LsapLookupBuiltinDomainSids(), LsapLookupWellKnownSids(), LsarpCreateAccount(), LsarpOpenAccount(), main(), map_name_2_sid(), match_dns_to_subject_alt_name(), match_dns_to_subject_dn(), CFindFolder::MessageSFVCB(), mi_show_error(), MonSelSetMonitorsInfo(), DriveVolume::MoveFileDumb(), MsiGetShortcutTargetW(), MSIREG_DeleteUserDataComponentKey(), MSIREG_DeleteUserDataPatchKey(), MSIREG_DeleteUserDataProductKey(), MSIREG_OpenFeaturesKey(), MSIREG_OpenInstallProps(), MSIREG_OpenProductKey(), MSIREG_OpenUserDataComponentKey(), MSIREG_OpenUserDataFeaturesKey(), MSIREG_OpenUserDataPatchKey(), MSIREG_OpenUserDataProductKey(), MSIREG_OpenUserDataProductPatchesKey(), MsiSourceListAddSourceW(), MyMessageBox(), NewDocSelDlgProc(), ntstatus_error::ntstatus_error(), OF(), OnBrowse(), OnDestroy(), OnOK(), CMruBase::operator delete(), CMruClassFactory::operator delete(), operator delete(), CTestShellFolder::operator delete(), output_formatstring(), OutputError(), OutputText(), ParseLogonHours(), PathCchCanonicalizeEx(), PathCchCombineEx(), pCDevSettings_Free(), pCDevSettings_FreeString(), pCDevSettings_GetDeviceInstanceId(), pCDevSettings_Initialize(), PerfDataRefresh(), playTestTone(), PrintError(), PrintErrorMessage(), PrintFileDacl(), PrintLastError(), printm(), PrintMessage(), PrintMessageString(), PrintMessageStringV(), PrintMessageV(), PrintNetMessage(), PrintPaddedMessageString(), PrintSid(), PrintWin32Error(), ProcessCmdLine(), ProcessNewLinesAndNulls(), query_reg_path(), read_key_value(), RegisterGPNotification(), registry_callback(), REGPROC_print_error(), release_cert_info(), ReloadPrincipalsList(), ReportLastError(), ResetProgressDialog(), RpcpAddInterface(), RSAENH_CPGetProvParam(), SampAddMemberToAlias(), SampRemoveMemberFromAlias(), SampRemoveMemberFromAllAliases(), SampSetupAddMemberToAlias(), SamrGetAliasMembership(), SdSet(), SdShow(), serialize(), server_stop(), service_main(), set_file_name(), set_issuer_statement(), set_user_sid_prop(), SetControlText(), setCurrentChannelConfig(), SetRegUlong(), SetServiceStatusText(), SetStartupType(), SetSystemEnvironment(), SetUserEnvironment(), SetUserEnvironmentVariable(), SHChangeNotification_Unlock(), SHDestroyIETHREADPARAM(), SHDestroyPropSheetExtArray(), ShellMessageBoxA(), ShellMessageBoxW(), ShellMessageBoxWrapW(), SHFreeDataBlockList(), SHLoadIndirectString(), ShowError(), CZipExtract::ShowExtractError(), ShowHelpWindow(), ShowItemError(), ShowLastError(), ShowLastWin32Error(), ShowMonitorProperties(), ShowWin32Error(), SHParseDisplayName(), SHQueryValueExA(), SHQueryValueExW(), SHReadDataBlockList(), SHRemoveDataBlock(), SHTestTokenPrivilegeW(), START_TEST(), StartDocW(), StatisticsMain(), StatusBarLoadAndFormatString(), StatusBarLoadString(), stopTestTone(), store_key_pair(), test__hwrite(), test__lwrite(), test_appsearch_complocator(), test_BuildSecurityDescriptorW(), test_child_token_sd(), test_commandline2argv(), test_ConvertSecurityDescriptorToString(), test_ConvertStringSecurityDescriptor(), test_CreateDirectoryA(), test_CreateWellKnownSid(), test_cryptunprotectdata(), test_datalink(), test_decodeAltName(), test_decodeAuthorityInfoAccess(), test_decodeAuthorityKeyId(), test_decodeAuthorityKeyId2(), test_decodeBasicConstraints(), test_decodeBits(), test_decodeCatMemberInfo(), test_decodeCatNameValue(), test_decodeCert(), test_decodeCertPolicies(), test_decodeCertPolicyConstraints(), test_decodeCertPolicyMappings(), test_decodeCertToBeSigned(), test_decodeCMSSignerInfo(), test_decodeCRLDistPoints(), test_decodeCRLIssuingDistPoint(), test_decodeCRLToBeSigned(), test_decodeCTL(), test_decodeEnhancedKeyUsage(), test_decodeExtensions(), test_decodeInt(), test_decodeName(), test_decodeNameConstraints(), test_decodeNameValue(), test_decodeOctets(), test_decodePKCSAttribute(), test_decodePKCSAttributes(), test_decodePKCSContentInfo(), test_decodePKCSSignerInfo(), test_decodePKCSSMimeCapabilities(), test_decodePolicyQualifierUserNotice(), test_decodePublicKeyInfo(), test_decodeRsaPrivateKey(), test_decodeRsaPublicKey(), test_decodeSequenceOfAny(), test_decodeSPCLink(), test_decodeSPCPEImage(), test_decodeSpOpusInfo(), test_decodeUnicodeName(), test_decodeUnicodeNameValue(), test_EM_GETHANDLE(), test_encodeAltName(), test_encodeAuthorityInfoAccess(), test_encodeAuthorityKeyId(), test_encodeAuthorityKeyId2(), test_encodeBasicConstraints(), test_encodeBits(), test_encodeCatMemberInfo(), test_encodeCatNameValue(), test_encodeCert(), test_encodeCertPolicies(), test_encodeCertPolicyConstraints(), test_encodeCertPolicyMappings(), test_encodeCertToBeSigned(), test_encodeCMSSignerInfo(), test_encodeCRLDistPoints(), test_encodeCRLIssuingDistPoint(), test_encodeCRLToBeSigned(), test_encodeCTL(), test_encodeEnhancedKeyUsage(), test_encodeEnumerated(), test_encodeExtensions(), test_encodeInt(), test_encodeName(), test_encodeNameConstraints(), test_encodeNameValue(), test_encodeOctets(), test_encodePKCSAttribute(), test_encodePKCSAttributes(), test_encodePKCSContentInfo(), test_encodePKCSSignerInfo(), test_encodePKCSSMimeCapabilities(), test_encodePolicyQualifierUserNotice(), test_encodePublicKeyInfo(), test_encodeRsaPublicKey(), test_encodeSequenceOfAny(), test_encodeSPCFinancialCriteria(), test_encodeSPCLink(), test_encodeSPCPEImage(), test_encodeSpOpusInfo(), test_encodeUnicodeName(), test_encodeUnicodeNameValue(), test_enum_provider_types(), test_enum_providers(), test_get_default_provider(), test_GetExplicitEntriesFromAclW(), test_GetNamedSecurityInfoA(), test_GetSecurityInfo(), test_GetShellSecurityDescriptor(), test_GetSidSubAuthority(), test_heap(), test_IMalloc(), test_LocalAlloc(), test_LookupAccountSid(), test_lsa(), test_message_allocate_buffer(), test_message_allocate_buffer_wide(), test_MsiEnumClients(), test_MsiEnumComponents(), test_MsiEnumComponentsEx(), test_MsiEnumPatches(), test_MsiEnumPatchesEx(), test_MsiEnumProducts(), test_MsiEnumProductsEx(), test_MsiGetComponentPath(), test_MsiGetComponentPathEx(), test_MsiGetPatchInfoEx(), test_MsiGetProductCode(), test_MsiGetProductInfoEx(), test_MsiGetUserInfo(), test_MsiOpenProduct(), test_MsiQueryComponentState(), test_MsiQueryFeatureState(), test_MsiQueryProductState(), test_MsiSourceListAddMediaDisk(), test_MsiSourceListAddSource(), test_MsiSourceListAddSourceEx(), test_MsiSourceListEnumMediaDisks(), test_MsiSourceListEnumSources(), test_MsiSourceListGetInfo(), test_MsiSourceListSetInfo(), test_one_cmdline(), test_PrivateObjectSecurity(), test_process_components(), test_publish_features(), test_publish_product(), test_reg_create_key(), test_reg_open_key(), test_register_product(), test_register_user(), test_secure_connection(), test_security_descriptor(), test_security_flags(), test_sequence(), test_set_provider_ex(), test_SetEntriesInAclA(), test_SetEntriesInAclW(), test_SHGetShellKey(), test_sid(), test_sid_str(), test_simpleroundtrip(), TEST_StrDupA(), test_StrDupA(), TEST_StrDupW(), test_system_security_access(), test_token_attr(), test_token_label(), test_token_security_descriptor(), testAcquireCertPrivateKey(), TestCommandLine(), testTimeEncoding(), testVerifyCertSig(), testVerifyCertSigEx(), TrustIsCertificateSelfSigned(), TV1_AddDependantsToTree(), TV2_AddDependantsToTree(), U32LoadAccelerators(), UnregisterGPNotification(), UpdateControlStates(), UpdateMonitorSelection(), UpdatePrincipalInfo(), UpdatePrincipalListItem(), UpdateServiceCount(), UXTHEME_DeleteParseErrorInfo(), verify_cert_revocation_from_aia_ext(), VfdCheckDriverFile(), VfdCreateImageFile(), VfdFormatMedia(), VfdGetDriverConfig(), VfdGetImageInfo(), VfdGuiClose(), VfdGuiFormat(), VfdImageTip(), VfdMakeFileDesc(), VfdOpenImage(), VfdSaveImage(), WhoamiGroups(), WhoamiLogonId(), WhoamiUser(), WINTRUST_GetTimeFromSigner(), WlxInitialize(), wWinMain(), XCOPY_FailMessage(), CIniPropertyBag::~CIniPropertyBag(), CMruBase::~CMruBase(), CMruLongList::~CMruLongList(), CMruPidlList::~CMruPidlList(), CMruShortList::~CMruShortList(), and CViewStatePropertyBag::~CViewStatePropertyBag().

LocalHandle()

HLOCAL NTAPI LocalHandle

(

LPCVOID

pMem

)

Definition at line 1605 of file heapmem.c.

{
    /* This is identical to a Global Handle */
    return GlobalHandle(pMem);
}

Referenced by BcdOpenStoreFromFile(), CreateGreenFdo(), HandleSetHandlePrintHex(), IopCreateFile(), and test_LocalAlloc().

LocalLock()

LPVOID NTAPI LocalLock

(

HLOCAL

hMem

)

Definition at line 1616 of file heapmem.c.

{
    /* This is the same as a GlobalLock, assuming these never change */
    C_ASSERT(LMEM_LOCKCOUNT == GMEM_LOCKCOUNT);
    return GlobalLock(hMem);
}

Referenced by DoSaveFile(), EDIT_EM_GetHandle(), EDIT_EM_SetHandle(), EDIT_LockBuffer(), EDIT_UnlockBuffer(), GetSelectionText(), GRPFILE_ReadGroupFile(), GRPFILE_WriteGroupFile(), HandleSetHandlePrintHex(), HEXEDIT_Copy(), HEXEDIT_Delete(), HEXEDIT_HEM_COPYBUFFER(), HEXEDIT_HEM_LOADBUFFER(), HEXEDIT_PaintLines(), HEXEDIT_Paste(), HEXEDIT_WM_CHAR(), HEXEDIT_WM_KEYDOWN(), Imm32InternalLockIMC(), ImmLockIMCC(), ProcessNewLinesAndNulls(), ReadText(), test__hwrite(), test__lwrite(), test_EM_GETHANDLE(), test_heap(), and test_LocalAlloc().

LocalReAlloc()

HLOCAL NTAPI LocalReAlloc	(	HLOCAL	hMem,
		SIZE_T	dwBytes,
		UINT	uFlags
	)

Definition at line 1625 of file heapmem.c.

{
    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;
}

Referenced by AccRewriteGetHandleRights(), cicMemReAlloc(), CreateFileOpStrings(), EDIT_LockBuffer(), EDIT_MakeFit(), EDIT_UnlockBuffer(), GetUserSid(), GetUserSidStringFromToken(), HEXEDIT_HEM_LOADBUFFER(), HEXEDIT_HEM_SETMAXBUFFERSIZE(), IMAPIMalloc_fnRealloc(), ImmReSizeIMCC(), ReadText(), ReAlloc(), realloc(), SetSpyedBlockTableLength(), SHAddDataBlock(), SHReadDataBlockList(), SHRemoveDataBlock(), test_heap(), and test_LocalAlloc().

LocalShrink()

SIZE_T WINAPI LocalShrink	(	HLOCAL	hMem,
		UINT	cbNewSize
	)

Definition at line 1782 of file heapmem.c.

{
    /* Call RTL */
    return RtlCompactHeap(BaseHeap, 0);
}

LocalSize()

SIZE_T NTAPI LocalSize

(

HLOCAL

hMem

)

Definition at line 1794 of file heapmem.c.

{
    /* This is the same as a Global Size */
    return GlobalSize(hMem);
}

Referenced by CreateFileMappingW(), EDIT_EM_GetHandle(), EDIT_EM_SetHandle(), EDIT_LockBuffer(), EDIT_MakeFit(), EDIT_UnlockBuffer(), EDIT_WM_NCCreate(), GetSize(), HEXEDIT_Delete(), HEXEDIT_HEM_COPYBUFFER(), HEXEDIT_HEM_LOADBUFFER(), HEXEDIT_IndexFromPoint(), HEXEDIT_PaintLines(), HEXEDIT_Paste(), HEXEDIT_SelectAll(), HEXEDIT_Update(), HEXEDIT_WM_CHAR(), HEXEDIT_WM_KEYDOWN(), IMAPIMalloc_fnGetSize(), ImmGetIMCCSize(), MyFreePool(), SHRemoveDataBlock(), START_TEST(), test_heap(), test_IMalloc(), and test_LocalAlloc().

LocalUnlock()

BOOL NTAPI LocalUnlock

(

HLOCAL

hMem

)

Definition at line 1805 of file heapmem.c.

{
    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;
}

Referenced by DoSaveFile(), EDIT_EM_GetHandle(), EDIT_EM_SetHandle(), EDIT_LockBuffer(), EDIT_UnlockBuffer(), GetSelectionText(), HandleSetHandlePrintHex(), HEXEDIT_Copy(), HEXEDIT_Delete(), HEXEDIT_HEM_COPYBUFFER(), HEXEDIT_HEM_LOADBUFFER(), HEXEDIT_PaintLines(), HEXEDIT_Paste(), HEXEDIT_WM_CHAR(), HEXEDIT_WM_KEYDOWN(), Imm32InternalLockIMC(), ImmUnlockIMC(), ImmUnlockIMCC(), ProcessNewLinesAndNulls(), ReadText(), test_EM_GETHANDLE(), test_heap(), and test_LocalAlloc().

Variable Documentation

BaseHeap

HANDLE BaseHeap

Definition at line 19 of file heapmem.c.

Referenced by BaseDllInitializeMemoryManager(), GlobalAlloc(), GlobalCompact(), GlobalFlags(), GlobalFree(), GlobalHandle(), GlobalLock(), GlobalReAlloc(), GlobalSize(), GlobalUnlock(), LocalAlloc(), LocalCompact(), LocalFlags(), LocalReAlloc(), LocalShrink(), and LocalUnlock().

BaseHeapHandleTable

RTL_HANDLE_TABLE BaseHeapHandleTable

Definition at line 18 of file heapmem.c.

Referenced by BaseDllInitializeMemoryManager().

SystemRangeStart

ULONG_PTR SystemRangeStart

Definition at line 20 of file heapmem.c.

Referenced by BaseDllInitializeMemoryManager(), and GlobalLock().