ldrfuncs.h File Reference

#include <umtypes.h>
#include <ldrtypes.h>

Include dependency graph for ldrfuncs.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
NTSTATUS NTAPI	LdrAccessResource (_In_ PVOID BaseAddress, _In_ PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry, _Out_opt_ PVOID *Resource, _Out_opt_ PULONG Size)
NTSTATUS NTAPI	LdrFindResource_U (_In_ PVOID BaseAddress, _In_ PLDR_RESOURCE_INFO ResourceInfo, _In_ ULONG Level, _Out_ PIMAGE_RESOURCE_DATA_ENTRY *ResourceDataEntry)
NTSTATUS NTAPI	LdrEnumResources (_In_ PVOID BaseAddress, _In_ PLDR_RESOURCE_INFO ResourceInfo, _In_ ULONG Level, _Inout_ ULONG *ResourceCount, _Out_writes_to_(*ResourceCount, *ResourceCount) LDR_ENUM_RESOURCE_INFO *Resources)
NTSTATUS NTAPI	LdrFindResourceDirectory_U (_In_ PVOID BaseAddress, _In_ PLDR_RESOURCE_INFO ResourceInfo, _In_ ULONG Level, _Out_ PIMAGE_RESOURCE_DIRECTORY *ResourceDirectory)
NTSTATUS NTAPI	LdrLoadAlternateResourceModule (_In_ PVOID Module, _In_ PWSTR Buffer)
BOOLEAN NTAPI	LdrUnloadAlternateResourceModule (_In_ PVOID BaseAddress)
NTSTATUS NTAPI	LdrGetProcedureAddress (_In_ PVOID BaseAddress, _In_opt_ _When_(Ordinal==0, _Notnull_) PANSI_STRING Name, _In_opt_ _When_(Name==NULL, _In_range_(>, 0)) ULONG Ordinal, _Out_ PVOID *ProcedureAddress)
ULONG NTAPI	LdrRelocateImage (_In_ PVOID BaseAddress, _In_opt_ PCSTR LoaderName, _In_ ULONG Success, _In_ ULONG Conflict, _In_ ULONG Invalid)
NTSTATUS NTAPI	LdrLockLoaderLock (_In_ ULONG Flags, _Out_opt_ PULONG Disposition, _Out_opt_ PULONG_PTR Cookie)
NTSTATUS NTAPI	LdrUnlockLoaderLock (_In_ ULONG Flags, _In_opt_ ULONG_PTR Cookie)
BOOLEAN NTAPI	LdrVerifyMappedImageMatchesChecksum (_In_ PVOID BaseAddress, _In_ SIZE_T NumberOfBytes, _In_ ULONG FileLength)
PIMAGE_BASE_RELOCATION NTAPI	LdrProcessRelocationBlockLongLong (_In_ ULONG_PTR Address, _In_ ULONG Count, _In_ PUSHORT TypeOffset, _In_ LONGLONG Delta)
NTSTATUS NTAPI	LdrEnumerateLoadedModules (_Reserved_ ULONG ReservedFlag, _In_ PLDR_ENUM_CALLBACK EnumProc, _In_opt_ PVOID Context)
NTSTATUS NTAPI	LdrRegisterDllNotification (_In_ ULONG Flags, _In_ PLDR_DLL_NOTIFICATION_FUNCTION NotificationFunction, _In_opt_ PVOID Context, _Out_ PVOID *Cookie)
NTSTATUS NTAPI	LdrUnregisterDllNotification (_In_ PVOID Cookie)

Function Documentation

LdrAccessResource()

NTSTATUS NTAPI LdrAccessResource	(	_In_ PVOID	BaseAddress,
		_In_ PIMAGE_RESOURCE_DATA_ENTRY	ResourceDataEntry,
		_Out_opt_ PVOID *	Resource,
		_Out_opt_ PULONG	Size
	)

Referenced by FindBitmapResource(), get_manifest_in_module(), KiInitializeBugCheck(), KsLoadResource(), LoadResource(), NtGetVersionResource(), and RtlFindMessage().

LdrEnumerateLoadedModules()

NTSTATUS NTAPI LdrEnumerateLoadedModules	(	_Reserved_ ULONG	ReservedFlag,
		_In_ PLDR_ENUM_CALLBACK	EnumProc,
		_In_opt_ PVOID	Context
	)

Definition at line 1090 of file ldrapi.c.

{
    PLIST_ENTRY ListHead, ListEntry;
    PLDR_DATA_TABLE_ENTRY LdrEntry;
    NTSTATUS Status;
    ULONG_PTR Cookie;
    BOOLEAN Stop = FALSE;
 
    /* Check parameters */
    if ((ReservedFlag) || !(EnumProc)) return STATUS_INVALID_PARAMETER;
 
    /* Acquire the loader lock */
    Status = LdrLockLoaderLock(0, NULL, &Cookie);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Loop all the modules and call enum proc */
    ListHead = &NtCurrentPeb()->Ldr->InLoadOrderModuleList;
    ListEntry = ListHead->Flink;
    while (ListHead != ListEntry)
    {
        /* Get the entry */
        LdrEntry = CONTAINING_RECORD(ListEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
 
        /* Call the enumeration proc inside SEH */
        _SEH2_TRY
        {
            EnumProc(LdrEntry, Context, &Stop);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* Ignoring the exception */
        } _SEH2_END;
 
        /* Break if we were asked to stop enumeration */
        if (Stop)
        {
            break;
        }
 
        /* Advance to the next module */
        ListEntry = ListEntry->Flink;
    }
 
    /* Release loader lock */
    Status = LdrUnlockLoaderLock(0, Cookie);
    ASSERT(NT_SUCCESS(Status));
 
    /* Reset any successful status to STATUS_SUCCESS,
     * but leave failure to the caller */
    if (NT_SUCCESS(Status))
        Status = STATUS_SUCCESS;
 
    /* Return any possible failure status */
    return Status;
}

Referenced by BasepComputeProcessPath(), and LoadLibraryExW().

LdrEnumResources()

NTSTATUS NTAPI LdrEnumResources	(	_In_ PVOID	BaseAddress,
		_In_ PLDR_RESOURCE_INFO	ResourceInfo,
		_In_ ULONG	Level,
		_Inout_ ULONG *	ResourceCount,
		_Out_writes_to_ *, *ResourceCount LDR_ENUM_RESOURCE_INFO *	Resources
	)

Definition at line 343 of file res.c.

{
    PUCHAR ResourceData;
    NTSTATUS Status;
    ULONG i, j, k;
    ULONG NumberOfTypeEntries, NumberOfNameEntries, NumberOfLangEntries;
    ULONG Count, MaxResourceCount;
    PIMAGE_RESOURCE_DIRECTORY TypeDirectory, NameDirectory, LangDirectory;
    PIMAGE_RESOURCE_DIRECTORY_ENTRY TypeEntry, NameEntry, LangEntry;
    PIMAGE_RESOURCE_DATA_ENTRY DataEntry;
    ULONG Size;
    LONG Result;
 
    /* If the caller wants data, get the maximum count of entries */
    MaxResourceCount = (Resources != NULL) ? *ResourceCount : 0;
 
    /* Default to 0 */
    *ResourceCount = 0;
 
    /* Locate the resource directory */
    ResourceData = RtlImageDirectoryEntryToData(ImageBase,
                                                TRUE,
                                                IMAGE_DIRECTORY_ENTRY_RESOURCE,
                                                &Size);
    if (ResourceData == NULL)
        return STATUS_RESOURCE_DATA_NOT_FOUND;
 
    /* The type directory is at the root, followed by the entries */
    TypeDirectory = (PIMAGE_RESOURCE_DIRECTORY)ResourceData;
    TypeEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(TypeDirectory + 1);
 
    /* Get the number of entries in the type directory */
    NumberOfTypeEntries = TypeDirectory->NumberOfNamedEntries +
                          TypeDirectory->NumberOfIdEntries;
 
    /* Start with 0 resources and status success */
    Status = STATUS_SUCCESS;
    Count = 0;
 
    /* Loop all entries in the type directory */
    for (i = 0; i < NumberOfTypeEntries; ++i, ++TypeEntry)
    {
        /* Check if comparison of types is requested */
        if (Level > RESOURCE_TYPE_LEVEL)
        {
            /* Compare the type with the requested Type */
            Result = LdrpCompareResourceNames_U(ResourceData,
                                                TypeEntry,
                                                ResourceInfo->Type);
 
            /* Not equal, continue with next entry */
            if (Result != 0) continue;
        }
 
        /* The entry must point to the name directory */
        if (!TypeEntry->DataIsDirectory)
        {
            return STATUS_INVALID_IMAGE_FORMAT;
        }
 
        /* Get a pointer to the name subdirectory and it's first entry */
        NameDirectory = (PIMAGE_RESOURCE_DIRECTORY)(ResourceData +
                                                    TypeEntry->OffsetToDirectory);
        NameEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(NameDirectory + 1);
 
        /* Get the number of entries in the name directory */
        NumberOfNameEntries = NameDirectory->NumberOfNamedEntries +
                              NameDirectory->NumberOfIdEntries;
 
        /* Loop all entries in the name directory */
        for (j = 0; j < NumberOfNameEntries; ++j, ++NameEntry)
        {
            /* Check if comparison of names is requested */
            if (Level > RESOURCE_NAME_LEVEL)
            {
                /* Compare the name with the requested name */
                Result = LdrpCompareResourceNames_U(ResourceData,
                                                    NameEntry,
                                                    ResourceInfo->Name);
 
                /* Not equal, continue with next entry */
                if (Result != 0) continue;
            }
 
            /* The entry must point to the language directory */
            if (!NameEntry->DataIsDirectory)
            {
                return STATUS_INVALID_IMAGE_FORMAT;
            }
 
            /* Get a pointer to the language subdirectory and it's first entry */
            LangDirectory = (PIMAGE_RESOURCE_DIRECTORY)(ResourceData +
                                                        NameEntry->OffsetToDirectory);
            LangEntry = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)(LangDirectory + 1);
 
            /* Get the number of entries in the language directory */
            NumberOfLangEntries = LangDirectory->NumberOfNamedEntries +
                                  LangDirectory->NumberOfIdEntries;
 
            /* Loop all entries in the language directory */
            for (k = 0; k < NumberOfLangEntries; ++k, ++LangEntry)
            {
                /* Check if comparison of languages is requested */
                if (Level > RESOURCE_LANGUAGE_LEVEL)
                {
                    /* Compare the language with the requested language */
                    Result = LdrpCompareResourceNames_U(ResourceData,
                                                        LangEntry,
                                                        ResourceInfo->Language);
 
                    /* Not equal, continue with next entry */
                    if (Result != 0) continue;
                }
 
                /* This entry must point to data */
                if (LangEntry->DataIsDirectory)
                {
                    return STATUS_INVALID_IMAGE_FORMAT;
                }
 
                /* Get a pointer to the data entry */
                DataEntry = (PIMAGE_RESOURCE_DATA_ENTRY)(ResourceData +
                                                         LangEntry->OffsetToData);
 
                /* Check if there is still space to store the data */
                if (Count < MaxResourceCount)
                {
                    /* There is, fill the entry */
                    Resources[Count].Type =
                        NAME_FROM_RESOURCE_ENTRY(ResourceData, TypeEntry);
                    Resources[Count].Name =
                        NAME_FROM_RESOURCE_ENTRY(ResourceData, NameEntry);
                    Resources[Count].Language =
                        NAME_FROM_RESOURCE_ENTRY(ResourceData, LangEntry);
                    Resources[Count].Data = (PUCHAR)ImageBase + DataEntry->OffsetToData;
                    Resources[Count].Reserved = 0;
                    Resources[Count].Size = DataEntry->Size;
                }
                else
                {
                    /* There is not enough space, save error status */
                    Status = STATUS_INFO_LENGTH_MISMATCH;
                }
 
                /* Count this resource */
                ++Count;
            }
        }
    }
 
    /* Return the number of matching resources */
    *ResourceCount = Count;
    return Status;
}

Referenced by Test_Data(), and Test_Parameters().

LdrFindResource_U()

NTSTATUS NTAPI LdrFindResource_U	(	_In_ PVOID	BaseAddress,
		_In_ PLDR_RESOURCE_INFO	ResourceInfo,
		_In_ ULONG	Level,
		_Out_ PIMAGE_RESOURCE_DATA_ENTRY *	ResourceDataEntry
	)

Referenced by BasepProbeForDllManifest(), find_resourceA(), find_resourceW(), FindBitmapResource(), FindResourceExW(), get_manifest_in_module(), KiInitializeBugCheck(), KsLoadResource(), NtGetVersionResource(), and RtlFindMessage().

LdrFindResourceDirectory_U()

NTSTATUS NTAPI LdrFindResourceDirectory_U	(	_In_ PVOID	BaseAddress,
		_In_ PLDR_RESOURCE_INFO	ResourceInfo,
		_In_ ULONG	Level,
		_Out_ PIMAGE_RESOURCE_DIRECTORY *	ResourceDirectory
	)

Referenced by EnumResourceLanguagesA(), EnumResourceLanguagesExA(), EnumResourceLanguagesExW(), EnumResourceLanguagesW(), EnumResourceNamesA(), EnumResourceNamesExA(), EnumResourceNamesExW(), EnumResourceNamesW(), EnumResourceTypesA(), EnumResourceTypesExA(), EnumResourceTypesExW(), and EnumResourceTypesW().

LdrGetProcedureAddress()

NTSTATUS NTAPI LdrGetProcedureAddress	(	_In_ PVOID	BaseAddress,
		_In_opt_ _When_(Ordinal==0, _Notnull_) PANSI_STRING	Name,
		_In_opt_ _When_(Name==NULL, _In_range_(>, 0)) ULONG	Ordinal,
		_Out_ PVOID *	ProcedureAddress
	)

Definition at line 789 of file ldrapi.c.

{
    /* Call the internal routine and tell it to execute DllInit */
    return LdrpGetProcedureAddress(BaseAddress, Name, Ordinal, ProcedureAddress, TRUE);
}

LdrLoadAlternateResourceModule()

NTSTATUS NTAPI LdrLoadAlternateResourceModule	(	_In_ PVOID	Module,
		_In_ PWSTR	Buffer
	)

Definition at line 1587 of file ldrapi.c.

{
    /* Is MUI Support enabled? */
    if (!LdrAlternateResourcesEnabled()) return STATUS_SUCCESS;
 
    UNIMPLEMENTED;
    return STATUS_MUI_FILE_NOT_FOUND;
}

LdrLockLoaderLock()

NTSTATUS NTAPI LdrLockLoaderLock	(	_In_ ULONG	Flags,
		_Out_opt_ PULONG	Disposition,
		_Out_opt_ PULONG_PTR	Cookie
	)

Definition at line 174 of file ldrapi.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    BOOLEAN InInit = LdrpInLdrInit;
 
    DPRINT("LdrLockLoaderLock(%x %p %p)\n", Flags, Disposition, Cookie);
 
    /* Zero out the outputs */
    if (Disposition) *Disposition = LDR_LOCK_LOADER_LOCK_DISPOSITION_INVALID;
    if (Cookie) *Cookie = 0;
 
    /* Validate the flags */
    if (Flags & ~(LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS |
                  LDR_LOCK_LOADER_LOCK_FLAG_TRY_ONLY))
    {
        /* Flags are invalid, check how to fail */
        if (Flags & LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS)
        {
            /* The caller wants us to raise status */
            RtlRaiseStatus(STATUS_INVALID_PARAMETER_1);
        }
 
        /* A normal failure */
        return STATUS_INVALID_PARAMETER_1;
    }
 
    /* Make sure we got a cookie */
    if (!Cookie)
    {
        /* No cookie check how to fail */
        if (Flags & LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS)
        {
            /* The caller wants us to raise status */
            RtlRaiseStatus(STATUS_INVALID_PARAMETER_3);
        }
 
        /* A normal failure */
        return STATUS_INVALID_PARAMETER_3;
    }
 
    /* If the flag is set, make sure we have a valid pointer to use */
    if ((Flags & LDR_LOCK_LOADER_LOCK_FLAG_TRY_ONLY) && !(Disposition))
    {
        /* No pointer to return the data to */
        if (Flags & LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS)
        {
            /* The caller wants us to raise status */
            RtlRaiseStatus(STATUS_INVALID_PARAMETER_2);
        }
 
        /* Fail */
        return STATUS_INVALID_PARAMETER_2;
    }
 
    /* Return now if we are in the init phase */
    if (InInit) return STATUS_SUCCESS;
 
    /* Check what locking semantic to use */
    if (Flags & LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS)
    {
        /* Check if we should enter or simply try */
        if (Flags & LDR_LOCK_LOADER_LOCK_FLAG_TRY_ONLY)
        {
            /* Do a try */
            if (!RtlTryEnterCriticalSection(&LdrpLoaderLock))
            {
                /* It's locked */
                *Disposition = LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_NOT_ACQUIRED;
            }
            else
            {
                /* It worked */
                *Disposition = LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_ACQUIRED;
                *Cookie = LdrpMakeCookie();
            }
        }
        else
        {
            /* Do a enter */
            RtlEnterCriticalSection(&LdrpLoaderLock);
 
            /* See if result was requested */
            if (Disposition) *Disposition = LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_ACQUIRED;
            *Cookie = LdrpMakeCookie();
        }
    }
    else
    {
        /* Wrap this in SEH, since we're not supposed to raise */
        _SEH2_TRY
        {
            /* Check if we should enter or simply try */
            if (Flags & LDR_LOCK_LOADER_LOCK_FLAG_TRY_ONLY)
            {
                /* Do a try */
                if (!RtlTryEnterCriticalSection(&LdrpLoaderLock))
                {
                    /* It's locked */
                    *Disposition = LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_NOT_ACQUIRED;
                }
                else
                {
                    /* It worked */
                    *Disposition = LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_ACQUIRED;
                    *Cookie = LdrpMakeCookie();
                }
            }
            else
            {
                /* Do an enter */
                RtlEnterCriticalSection(&LdrpLoaderLock);
 
                /* See if result was requested */
                if (Disposition) *Disposition = LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_ACQUIRED;
                *Cookie = LdrpMakeCookie();
            }
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* We should use the LDR Filter instead */
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
    }
 
    /* Return status */
    return Status;
}

Referenced by BasepGetModuleHandleExW(), find_query_actctx(), get_module_filename(), GetModuleFileNameW(), LdrAddRefDll(), LdrDisableThreadCalloutsForDll(), LdrEnumerateLoadedModules(), LdrGetDllHandleEx(), LdrInitShimEngineDynamic(), LdrLoadDll(), and LdrUnloadAlternateResourceModule().

LdrProcessRelocationBlockLongLong()

PIMAGE_BASE_RELOCATION NTAPI LdrProcessRelocationBlockLongLong	(	_In_ ULONG_PTR	Address,
		_In_ ULONG	Count,
		_In_ PUSHORT	TypeOffset,
		_In_ LONGLONG	Delta
	)

Referenced by LdrProcessRelocationBlock().

LdrRegisterDllNotification()

NTSTATUS NTAPI LdrRegisterDllNotification	(	_In_ ULONG	Flags,
		_In_ PLDR_DLL_NOTIFICATION_FUNCTION	NotificationFunction,
		_In_opt_ PVOID	Context,
		_Out_ PVOID *	Cookie
	)

Definition at line 39 of file ldrnotify.c.

{
    PLDR_DLL_NOTIFICATION_ENTRY NewEntry;
 
    /* Check input parameters */
    if (Flags != 0 || NotificationFunction == NULL || Cookie == NULL)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Allocate new entry and assign input values */
    NewEntry = RtlAllocateHeap(LdrpHeap, 0, sizeof(*NewEntry));
    if (NewEntry == NULL)
    {
        return STATUS_NO_MEMORY;
    }
    NewEntry->Callback = NotificationFunction;
    NewEntry->Context = Context;
 
    /* Add node to the end of global list */
    RtlEnterCriticalSection(&LdrpDllNotificationLock);
    InsertTailList(&LdrpDllNotificationList, &NewEntry->List);
    RtlLeaveCriticalSection(&LdrpDllNotificationLock);
 
    /* Cookie is address of the new entry */
    *Cookie = NewEntry;
    return STATUS_SUCCESS;
}

LdrRelocateImage()

ULONG NTAPI LdrRelocateImage	(	_In_ PVOID	BaseAddress,
		_In_opt_ PCSTR	LoaderName,
		_In_ ULONG	Success,
		_In_ ULONG	Conflict,
		_In_ ULONG	Invalid
	)

Definition at line 462 of file image.c.

{
    return LdrRelocateImageWithBias(BaseAddress, 0, LoaderName, Success, Conflict, Invalid);
}

Referenced by ImgpLoadPEImage().

LdrUnloadAlternateResourceModule()

BOOLEAN NTAPI LdrUnloadAlternateResourceModule

(

_In_ PVOID

BaseAddress

)

Definition at line 1603 of file ldrapi.c.

{
    ULONG_PTR Cookie;
 
    /* Acquire the loader lock */
    LdrLockLoaderLock(LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS, NULL, &Cookie);
 
    /* Check if there's any alternate resources loaded */
    if (AlternateResourceModuleCount)
    {
        UNIMPLEMENTED;
    }
 
    /* Release the loader lock */
    LdrUnlockLoaderLock(LDR_UNLOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS, Cookie);
 
    /* All done */
    return TRUE;
}

Referenced by FreeLibrary(), FreeLibraryAndExitThread(), and LdrUnloadDll().

LdrUnlockLoaderLock()

NTSTATUS NTAPI LdrUnlockLoaderLock	(	_In_ ULONG	Flags,
		_In_opt_ ULONG_PTR	Cookie
	)

Definition at line 101 of file ldrapi.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT("LdrUnlockLoaderLock(%x %Ix)\n", Flags, Cookie);
 
    /* Check for valid flags */
    if (Flags & ~LDR_UNLOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS)
    {
        /* Flags are invalid, check how to fail */
        if (Flags & LDR_UNLOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS)
        {
            /* The caller wants us to raise status */
            RtlRaiseStatus(STATUS_INVALID_PARAMETER_1);
        }
 
        /* A normal failure */
        return STATUS_INVALID_PARAMETER_1;
    }
 
    /* If we don't have a cookie, just return */
    if (!Cookie) return STATUS_SUCCESS;
 
    /* Validate the cookie */
    if ((Cookie & 0xF0000000) ||
        ((Cookie >> 16) ^ (HandleToUlong(NtCurrentTeb()->RealClientId.UniqueThread) & 0xFFF)))
    {
        DPRINT1("LdrUnlockLoaderLock() called with an invalid cookie!\n");
 
        /* Invalid cookie, check how to fail */
        if (Flags & LDR_UNLOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS)
        {
            /* The caller wants us to raise status */
            RtlRaiseStatus(STATUS_INVALID_PARAMETER_2);
        }
 
        /* A normal failure */
        return STATUS_INVALID_PARAMETER_2;
    }
 
    /* Ready to release the lock */
    if (Flags & LDR_UNLOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS)
    {
        /* Do a direct leave */
        RtlLeaveCriticalSection(&LdrpLoaderLock);
    }
    else
    {
        /* Wrap this in SEH, since we're not supposed to raise */
        _SEH2_TRY
        {
            /* Leave the lock */
            RtlLeaveCriticalSection(&LdrpLoaderLock);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* We should use the LDR Filter instead */
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
    }
 
    /* All done */
    return Status;
}

Referenced by BasepGetModuleHandleExW(), find_query_actctx(), get_module_filename(), GetModuleFileNameW(), LdrAddRefDll(), LdrDisableThreadCalloutsForDll(), LdrEnumerateLoadedModules(), LdrGetDllHandleEx(), LdrInitShimEngineDynamic(), LdrLoadDll(), and LdrUnloadAlternateResourceModule().

LdrUnregisterDllNotification()

NTSTATUS NTAPI LdrUnregisterDllNotification

(

_In_ PVOID

Cookie

)

Definition at line 74 of file ldrnotify.c.

{
    NTSTATUS Status = STATUS_DLL_NOT_FOUND;
    PLIST_ENTRY Entry;
 
    /* Find entry to remove */
    RtlEnterCriticalSection(&LdrpDllNotificationLock);
    for (Entry = LdrpDllNotificationList.Flink;
         Entry != &LdrpDllNotificationList;
         Entry = Entry->Flink)
    {
        if (Entry == Cookie)
        {
            RemoveEntryList(Entry);
            Status = STATUS_SUCCESS;
            break;
        }
    }
    RtlLeaveCriticalSection(&LdrpDllNotificationLock);
 
    if (NT_SUCCESS(Status))
    {
        RtlFreeHeap(LdrpHeap, 0, Entry);
    }
    return Status;
}

LdrVerifyMappedImageMatchesChecksum()

BOOLEAN NTAPI LdrVerifyMappedImageMatchesChecksum	(	_In_ PVOID	BaseAddress,
		_In_ SIZE_T	NumberOfBytes,
		_In_ ULONG	FileLength
	)

Referenced by LdrVerifyImageMatchesChecksum(), and MmCheckSystemImage().