/*++

Copyright (c) Microsoft Corporation

Module Name:

    sxsstorage.c

Abstract:

    Side-by-side activation support for Windows/NT

    Implementation of the assembly storage map.


Author:

    Michael Grier (MGrier) 6/13/2000

Revision History:
    Xiaoyu Wu(xiaoyuw) 7/01/2000     .local directory
    Xiaoyu Wu(xiaoyuw) 8/04/2000     private assembly
    Jay Krell (a-JayK) October 2000  the little bit of system default context that wasn't already done
--*/

#if defined(__cplusplus)
extern "C" {
#endif
#pragma warning(disable:4214)   // bit field types other than int
#pragma warning(disable:4201)   // nameless struct/union
#pragma warning(disable:4115)   // named type definition in parentheses
#pragma warning(disable:4127)   // condition expression is constant
#include <ntos.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <sxstypes.h>
#include "sxsp.h"

#define IS_PATH_SEPARATOR(_wch) (((_wch) == L'\\') || ((_wch) == L'/'))
#define LOCAL_ASSEMBLY_STORAGE_DIR_SUFFIX L".Local"

#if DBG
PCUNICODE_STRING RtlpGetImagePathName(VOID);
#define RtlpGetCurrentProcessId() (HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess))
#define RtlpGetCurrentThreadId() (HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread))
#endif

#if DBG

PCUNICODE_STRING RtlpGetImagePathName(VOID)
{
    PPEB Peb = NtCurrentPeb();
    return (Peb->ProcessParameters != NULL) ? &Peb->ProcessParameters->ImagePathName : NULL;
}

static VOID
DbgPrintFunctionEntry(
    CONST CHAR* Function
    )
{
    DbgPrintEx(
        DPFLTR_SXS_ID,
        DPFLTR_TRACE_LEVEL,
        "SXS: [pid:0x%x, tid:0x%x, %wZ] enter %s%d()\n",
        RtlpGetCurrentProcessId(),
        RtlpGetCurrentThreadId(),
        RtlpGetImagePathName(),
        Function,
        (int)sizeof(PVOID) * 8
        );
}

static VOID
DbgPrintFunctionExit(
    CONST CHAR* Function,
    NTSTATUS    Status
    )
{
    DbgPrintEx(
        DPFLTR_SXS_ID,
        NT_SUCCESS(Status) ? DPFLTR_TRACE_LEVEL : DPFLTR_ERROR_LEVEL,
        "SXS: [0x%x.%x] %s%d() exiting with status 0x%lx\n",
        RtlpGetCurrentProcessId(),
        RtlpGetCurrentThreadId(),
        Function,
        (int)sizeof(PVOID) * 8,
        Status
        );
}
#else

#define DbgPrintFunctionEntry(function) /* nothing */
#define DbgPrintFunctionExit(function, status) /* nothing */

#endif // DBG

// Because we write to the peb, we must not be in 64bit code for a 32bit process,
// unless we know we are early enough in CreateProcess, which is not the case
// in this file. Also don't call the 32bit version of this in a 64bit process.
#if DBG
#define ASSERT_OK_TO_WRITE_PEB() \
{ \
    PVOID Peb32 = NULL; \
    NTSTATUS Status; \
 \
    Status = \
        NtQueryInformationProcess( \
            NtCurrentProcess(), \
            ProcessWow64Information, \
            &Peb32, \
            sizeof(Peb32), \
            NULL); \
    /* The other Peb must be The Peb or the other Peb must not exist. */ \
    ASSERT(Peb32 == NtCurrentPeb() || Peb32 == NULL); \
}
#else
#define ASSERT_OK_TO_WRITE_PEB() /* nothing */
#endif

NTSTATUS
RtlpInitializeAssemblyStorageMap(
    PASSEMBLY_STORAGE_MAP Map,
    ULONG EntryCount,
    PASSEMBLY_STORAGE_MAP_ENTRY *EntryArray
    )
{
    NTSTATUS Status = STATUS_SUCCESS;
    ULONG i;
    ULONG Flags = 0;

#if DBG
    DbgPrintFunctionEntry(__FUNCTION__);
    DbgPrintEx(
        DPFLTR_SXS_ID,
        DPFLTR_TRACE_LEVEL,
        "%s(Map:%p, EntryCount:0x%lx)\n",
        __FUNCTION__,
        Map,
        EntryCount
        );

    ASSERT_OK_TO_WRITE_PEB();
#endif // DBG

    if ((Map == NULL) ||
        (EntryCount == 0)) {

        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: %s() bad parameters:\n"
            "SXS:    Map        : 0x%lx\n"
            "SXS:    EntryCount : 0x%lx\n"
            __FUNCTION__,
            Map,
            EntryCount
            );
        Status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }

    if (EntryArray == NULL) {
        EntryArray = (PASSEMBLY_STORAGE_MAP_ENTRY *) RtlAllocateHeap(RtlProcessHeap(), 0, EntryCount * sizeof(PASSEMBLY_STORAGE_MAP_ENTRY));
        if (EntryArray == NULL) {
            Status = STATUS_NO_MEMORY;
            goto Exit;
        }

        Flags |= ASSEMBLY_STORAGE_MAP_ASSEMBLY_ARRAY_IS_HEAP_ALLOCATED;
    }

    for (i=0; i<EntryCount; i++)
        EntryArray[i] = NULL;

    Map->Flags = Flags;
    Map->AssemblyCount = EntryCount;
    Map->AssemblyArray = EntryArray;

    Status = STATUS_SUCCESS;
Exit:
#if DBG
    DbgPrintFunctionExit(__FUNCTION__, Status);
    DbgPrintEx(
        DPFLTR_SXS_ID,
        NT_SUCCESS(Status) ? DPFLTR_TRACE_LEVEL : DPFLTR_ERROR_LEVEL,
        "%s(Map:%p, EntryCount:0x%lx) : (Map:%p, Status:0x%lx)\n",
        __FUNCTION__,
        Map,        
        EntryCount,
        Map,
        Status
        );
#endif

    return Status;
}

VOID
RtlpUninitializeAssemblyStorageMap(
    PASSEMBLY_STORAGE_MAP Map
    )
{
    DbgPrintFunctionEntry(__FUNCTION__);
#if DBG
    DbgPrintEx(
        DPFLTR_SXS_ID,
        DPFLTR_TRACE_LEVEL,
        "%s(Map:%p)\n",
        __FUNCTION__,
        Map
        );
#endif

    if (Map != NULL) {
        ULONG i;

        for (i=0; i<Map->AssemblyCount; i++) {
            PASSEMBLY_STORAGE_MAP_ENTRY Entry = Map->AssemblyArray[i];

            if (Entry != NULL) {
                Entry->DosPath.Length = 0;
                Entry->DosPath.MaximumLength = 0;
                Entry->DosPath.Buffer = NULL;

                if (Entry->Handle != NULL) {
                    RTL_SOFT_VERIFY(NT_SUCCESS(NtClose(Entry->Handle)));
                    Entry->Handle = NULL;
                }

                Map->AssemblyArray[i] = NULL;

                RtlFreeHeap(RtlProcessHeap(), 0, Entry);
            }
        }

        if (Map->Flags & ASSEMBLY_STORAGE_MAP_ASSEMBLY_ARRAY_IS_HEAP_ALLOCATED) {
            RtlFreeHeap(RtlProcessHeap(), 0, Map->AssemblyArray);
        }

        Map->AssemblyArray = NULL;
        Map->AssemblyCount = 0;
        Map->Flags = 0;
    }
}

NTSTATUS
RtlpInsertAssemblyStorageMapEntry(
    PASSEMBLY_STORAGE_MAP Map,
    ULONG AssemblyRosterIndex,
    PCUNICODE_STRING StorageLocation,
    HANDLE* OpenDirectoryHandle
    )
{
    PASSEMBLY_STORAGE_MAP_ENTRY Entry = NULL;
    NTSTATUS Status = STATUS_SUCCESS;

    ASSERT(Map != NULL);
    ASSERT(AssemblyRosterIndex >= 1);
    ASSERT((Map != NULL) && (AssemblyRosterIndex < Map->AssemblyCount));
    ASSERT(StorageLocation != NULL);
    ASSERT((StorageLocation != NULL) && (StorageLocation->Length >= sizeof(WCHAR)));
    ASSERT((StorageLocation != NULL) && (StorageLocation->Buffer != NULL));

    DbgPrintFunctionEntry(__FUNCTION__);

    if ((Map == NULL) ||
        (AssemblyRosterIndex < 1) ||
        (AssemblyRosterIndex > Map->AssemblyCount) ||
        (StorageLocation == NULL) ||
        (StorageLocation->Length < sizeof(WCHAR)) ||
        (StorageLocation->Buffer == NULL) ||
        (OpenDirectoryHandle == NULL)) {

        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: %s() bad parameters\n"
            "SXS:  Map                    : %p\n"
            "SXS:  AssemblyRosterIndex    : 0x%lx\n"
            "SXS:  Map->AssemblyCount     : 0x%lx\n"
            "SXS:  StorageLocation        : %p\n"
            "SXS:  StorageLocation->Length: 0x%x\n"
            "SXS:  StorageLocation->Buffer: %p\n"
            "SXS:  OpenDirectoryHandle    : %p\n",
            __FUNCTION__,
            Map,
            AssemblyRosterIndex,
            Map ? Map->AssemblyCount : 0,
            StorageLocation,
            (StorageLocation != NULL) ? StorageLocation->Length : 0,
            (StorageLocation != NULL) ? StorageLocation->Buffer : NULL,
            OpenDirectoryHandle
            );

        Status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }

    if ((StorageLocation->Length + sizeof(WCHAR)) > UNICODE_STRING_MAX_BYTES) {
        Status = STATUS_NAME_TOO_LONG;
        goto Exit;
    }

    Entry = (PASSEMBLY_STORAGE_MAP_ENTRY) RtlAllocateHeap(RtlProcessHeap(), 0, sizeof(ASSEMBLY_STORAGE_MAP_ENTRY) + StorageLocation->Length + sizeof(WCHAR));
    if (Entry == NULL) {
        Status = STATUS_NO_MEMORY;
        goto Exit;
    }

    Entry->Flags = 0;
    Entry->DosPath.Length = StorageLocation->Length;
    Entry->DosPath.Buffer = (PWSTR) (Entry + 1);
    Entry->DosPath.MaximumLength = (USHORT) (StorageLocation->Length + sizeof(WCHAR));
    RtlCopyMemory(
        Entry->DosPath.Buffer,
        StorageLocation->Buffer,
        StorageLocation->Length);
    Entry->DosPath.Buffer[Entry->DosPath.Length / sizeof(WCHAR)] = L'\0';

    Entry->Handle = *OpenDirectoryHandle;

    // Ok, we're all set.  Let's try the big interlocked switcheroo
    if (InterlockedCompareExchangePointer(
            (PVOID *) &Map->AssemblyArray[AssemblyRosterIndex],
            (PVOID) Entry,
            (PVOID) NULL) == NULL) {
        // If we're the first ones in, avoid cleaning up in the exit path.
        Entry = NULL;
        *OpenDirectoryHandle = NULL;
    }

    Status = STATUS_SUCCESS;
Exit:
    DbgPrintFunctionExit(__FUNCTION__, Status);
    if (Entry != NULL) {
        RtlFreeHeap(RtlProcessHeap(), 0, Entry);
    }

    return Status;
}

NTSTATUS
RtlpResolveAssemblyStorageMapEntry(
    PASSEMBLY_STORAGE_MAP Map,
    PCACTIVATION_CONTEXT_DATA Data,
    ULONG AssemblyRosterIndex,
    PASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_ROUTINE Callback,
    PVOID CallbackContext
    )
{
    NTSTATUS Status = STATUS_SUCCESS;

    ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_DATA CallbackData;
    PVOID ResolutionContext;
    BOOLEAN ResolutionContextValid = FALSE;
    UNICODE_STRING AssemblyDirectory;
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER AssemblyRoster;
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_ENTRY AssemblyRosterEntry;
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION AssemblyInformation;
    PVOID AssemblyInformationSectionBase;
    UNICODE_STRING ResolvedPath;
    WCHAR ResolvedPathBuffer[DOS_MAX_PATH_LENGTH];
    UNICODE_STRING ResolvedDynamicPath;
    PUNICODE_STRING ResolvedPathUsed;
    HANDLE OpenDirectoryHandle = NULL;
    WCHAR QueryPathBuffer[DOS_MAX_PATH_LENGTH];
    UNICODE_STRING FileName;
    RTL_RELATIVE_NAME_U RelativeName;
    OBJECT_ATTRIBUTES Obja; 
    IO_STATUS_BLOCK IoStatusBlock;
    SIZE_T RootCount, CurrentRootIndex;
    PWSTR FreeBuffer = NULL;

    DbgPrintFunctionEntry(__FUNCTION__);

    ResolvedPath.Length = 0;
    ResolvedPath.MaximumLength = sizeof(ResolvedPathBuffer);
    ResolvedPath.Buffer = ResolvedPathBuffer;

    ResolvedDynamicPath.Length = 0;
    ResolvedDynamicPath.MaximumLength = 0;
    ResolvedDynamicPath.Buffer = NULL;

    FileName.Length = 0;
    FileName.MaximumLength = 0;
    FileName.Buffer = NULL;

    ResolutionContext = NULL;

    // First, let's validate parameters...
    if ((Map == NULL) ||
        (Data == NULL) ||
        (AssemblyRosterIndex < 1) ||
        (AssemblyRosterIndex > Map->AssemblyCount)) {

        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: %s() bad parameters\n"
            "SXS:   Map                : %p\n"
            "SXS:   Data               : %p\n"
            "SXS:   AssemblyRosterIndex: 0x%lx\n"
            "SXS:   Map->AssemblyCount : 0x%lx\n",
            __FUNCTION__,
            Map,
            Data,
            AssemblyRosterIndex,
            (Map != NULL) ? Map->AssemblyCount : 0
            );

        Status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }

    // Is it already resolved?
    if (Map->AssemblyArray[AssemblyRosterIndex] != NULL)
        goto Exit;

    AssemblyRoster = (PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER) (((ULONG_PTR) Data) + Data->AssemblyRosterOffset);
    AssemblyRosterEntry = (PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_ENTRY) (((ULONG_PTR) Data) + AssemblyRoster->FirstEntryOffset + (AssemblyRosterIndex * sizeof(ACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_ENTRY)));
    AssemblyInformation = (PCACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION) (((ULONG_PTR) Data) + AssemblyRosterEntry->AssemblyInformationOffset);
    AssemblyInformationSectionBase = (PVOID) (((ULONG_PTR) Data) + AssemblyRoster->AssemblyInformationSectionOffset);

    if (AssemblyInformation->AssemblyDirectoryNameLength > UNICODE_STRING_MAX_BYTES) {
        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: Assembly directory name stored in assembly information too long (%lu bytes) - ACTIVATION_CONTEXT_DATA at %p\n", AssemblyInformation->AssemblyDirectoryNameLength, Data);

        Status = STATUS_NAME_TOO_LONG;
        goto Exit;
    }

    // The root assembly may just be in the raw filesystem, in which case we want to resolve the path to be the
    // directory containing the application.
    if (AssemblyInformation->Flags & ACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION_PRIVATE_ASSEMBLY)
    {
        WCHAR * p = NULL;
        WCHAR * pManifestPath = NULL; 
        USHORT ManifestPathLength;
        
        //now, we have AssemblyInformation in hand, get the manifest path 
        ResolvedPathUsed = &ResolvedPath;

        pManifestPath = (PWSTR)((ULONG_PTR)AssemblyInformationSectionBase + AssemblyInformation->ManifestPathOffset);
        if ( !pManifestPath) { 
            Status = STATUS_INTERNAL_ERROR;
            goto Exit; 
    
        }

        p = wcsrchr(pManifestPath, L'\\'); 
        if (!p) {
            Status = STATUS_INTERNAL_ERROR;
            goto Exit; 
        }
        ManifestPathLength = (USHORT)((p - pManifestPath + 1) * sizeof(WCHAR)); // additional 1 WCHAR for "\"
        ManifestPathLength += sizeof(WCHAR); // for trailing NULL

        if (ManifestPathLength > sizeof(ResolvedPathBuffer)) {
            if (ManifestPathLength > UNICODE_STRING_MAX_BYTES) {
                Status = STATUS_NAME_TOO_LONG;
                goto Exit;
            }

            ResolvedDynamicPath.MaximumLength = (USHORT) (ManifestPathLength);

            ResolvedDynamicPath.Buffer = (PWSTR)(RtlAllocateStringRoutine)(ResolvedDynamicPath.MaximumLength);
            if (ResolvedDynamicPath.Buffer == NULL) {
                Status = STATUS_NO_MEMORY;
                goto Exit;
            }

            ResolvedPathUsed = &ResolvedDynamicPath;
        }

        RtlCopyMemory(
            ResolvedPathUsed->Buffer,
            (PVOID)(pManifestPath),
            ManifestPathLength-sizeof(WCHAR));

        ResolvedPathUsed->Buffer[ManifestPathLength / sizeof(WCHAR) - 1] = L'\0';
        ResolvedPathUsed->Length = (USHORT)ManifestPathLength-sizeof(WCHAR);
    } else if ((AssemblyInformation->Flags & ACTIVATION_CONTEXT_DATA_ASSEMBLY_INFORMATION_ROOT_ASSEMBLY) &&
        (AssemblyInformation->AssemblyDirectoryNameLength == 0)) {
        // Get the image directory for the process
        PRTL_USER_PROCESS_PARAMETERS ProcessParameters = NtCurrentPeb()->ProcessParameters;
        // We don't need to image name, just the length up to the last slash.
        PWSTR pszCursor;
        USHORT cbOriginalLength;
        USHORT cbLeft;
        USHORT cbIncludingSlash;

        ASSERT(ProcessParameters != NULL);
        if (ProcessParameters == NULL) {
            Status = STATUS_INTERNAL_ERROR;
            goto Exit;
        }

        // We don't need to image name, just the length up to the last slash.
        pszCursor = ProcessParameters->ImagePathName.Buffer;
        cbOriginalLength = ProcessParameters->ImagePathName.Length;
        cbLeft = cbOriginalLength;
        cbIncludingSlash = 0;

        while (cbLeft != 0) {
            const WCHAR wch = *pszCursor++;
            cbLeft -= sizeof(WCHAR);

            if (IS_PATH_SEPARATOR(wch)) {
                cbIncludingSlash = cbOriginalLength - cbLeft;
            }
        }

        ResolvedPathUsed = &ResolvedPath;

        if ((cbIncludingSlash + sizeof(WCHAR)) > sizeof(ResolvedPathBuffer)) {
            if ((cbIncludingSlash + sizeof(WCHAR)) > UNICODE_STRING_MAX_BYTES) {
                Status = STATUS_NAME_TOO_LONG;
                goto Exit;
            }

            ResolvedDynamicPath.MaximumLength = (USHORT) (cbIncludingSlash + sizeof(WCHAR));

            ResolvedDynamicPath.Buffer = (PWSTR)(RtlAllocateStringRoutine)(ResolvedDynamicPath.MaximumLength);
            if (ResolvedDynamicPath.Buffer == NULL) {
                Status = STATUS_NO_MEMORY;
                goto Exit;
            }

            ResolvedPathUsed = &ResolvedDynamicPath;
        }

        RtlCopyMemory(
            ResolvedPathUsed->Buffer,
            ProcessParameters->ImagePathName.Buffer,
            cbIncludingSlash);

        ResolvedPathUsed->Buffer[cbIncludingSlash / sizeof(WCHAR)] = L'\0';
        ResolvedPathUsed->Length = cbIncludingSlash;
    } else {
        // If the resolution is not to the root assembly path, we need to make our callbacks.

        ResolvedPathUsed = NULL;
        AssemblyDirectory.Length = (USHORT) AssemblyInformation->AssemblyDirectoryNameLength;
        AssemblyDirectory.MaximumLength = AssemblyDirectory.Length;
        AssemblyDirectory.Buffer = (PWSTR) (((ULONG_PTR) AssemblyInformationSectionBase) + AssemblyInformation->AssemblyDirectoryNameOffset);

        // Get ready to fire the resolution beginning event...
        CallbackData.ResolutionBeginning.Data = Data;
        CallbackData.ResolutionBeginning.AssemblyRosterIndex = AssemblyRosterIndex;
        CallbackData.ResolutionBeginning.ResolutionContext = NULL;
        CallbackData.ResolutionBeginning.Root.Length = 0;
        CallbackData.ResolutionBeginning.Root.MaximumLength = sizeof(QueryPathBuffer);
        CallbackData.ResolutionBeginning.Root.Buffer = QueryPathBuffer;
        CallbackData.ResolutionBeginning.KnownRoot = FALSE;
        CallbackData.ResolutionBeginning.CancelResolution = FALSE;
        CallbackData.ResolutionBeginning.RootCount = 0;

        (*Callback)(
            ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_REASON_RESOLUTION_BEGINNING,
            &CallbackData,
            CallbackContext);
        if (CallbackData.ResolutionBeginning.CancelResolution) {
            Status = STATUS_CANCELLED;
            goto Exit;
        }

        // If that was enough, then register it and we're outta here...
        if (CallbackData.ResolutionBeginning.KnownRoot) {
            DbgPrintEx(
                DPFLTR_SXS_ID,
                DPFLTR_TRACE_LEVEL,
                "SXS: Storage resolution callback said that this is a well known storage root\n");

            // See if it's there...
            Status = RtlpProbeAssemblyStorageRootForAssembly(
                0,
                &CallbackData.ResolutionBeginning.Root,
                &AssemblyDirectory,
                &ResolvedPath,
                &ResolvedDynamicPath,
                &ResolvedPathUsed,
                &OpenDirectoryHandle);
            if (!NT_SUCCESS(Status)) {
                DbgPrintEx(
                    DPFLTR_SXS_ID,
                    DPFLTR_ERROR_LEVEL,
                    "SXS: Attempt to probe known root of assembly storage (\"%wZ\") failed; Status = 0x%08lx\n", &CallbackData.ResolutionBeginning.Root, Status);
                goto Exit;
            }

            Status = RtlpInsertAssemblyStorageMapEntry(
                Map,
                AssemblyRosterIndex,
                &CallbackData.ResolutionBeginning.Root,
                &OpenDirectoryHandle);
            if (!NT_SUCCESS(Status)) {
                DbgPrintEx(
                    DPFLTR_SXS_ID,
                    DPFLTR_ERROR_LEVEL,
                    "SXS: Attempt to insert well known storage root into assembly storage map assembly roster index %lu failed; Status = 0x%08lx\n", AssemblyRosterIndex, Status);

                goto Exit;
            }

            Status = STATUS_SUCCESS;
            goto Exit;
        }

        // Otherwise, begin the grind...
        ResolutionContext = CallbackData.ResolutionBeginning.ResolutionContext;
        RootCount = CallbackData.ResolutionBeginning.RootCount;

        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_TRACE_LEVEL,
            "SXS: Assembly storage resolution trying %Id roots (-1 is ok)\n", (SSIZE_T/*from SIZE_T*/)RootCount);

        ResolutionContextValid = TRUE;

        for (CurrentRootIndex = 0; CurrentRootIndex < RootCount; CurrentRootIndex++) {
            CallbackData.GetRoot.ResolutionContext = ResolutionContext;
            CallbackData.GetRoot.RootIndex = CurrentRootIndex;
            CallbackData.GetRoot.Root.Length = 0;
            CallbackData.GetRoot.Root.MaximumLength = sizeof(QueryPathBuffer);
            CallbackData.GetRoot.Root.Buffer = QueryPathBuffer;
            CallbackData.GetRoot.CancelResolution = FALSE;
            CallbackData.GetRoot.NoMoreEntries = FALSE;

            (*Callback)(
                ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_REASON_GET_ROOT,
                &CallbackData,
                CallbackContext);

            if (CallbackData.GetRoot.CancelResolution) {
                DbgPrintEx(
                    DPFLTR_SXS_ID,
                    DPFLTR_TRACE_LEVEL,
                    "SXS: Callback routine cancelled storage root resolution on root number %Iu\n", CurrentRootIndex);

                Status = STATUS_CANCELLED;
                goto Exit;
            }

            if (CallbackData.GetRoot.NoMoreEntries) {
                if (CallbackData.GetRoot.Root.Length == 0) {
                    DbgPrintEx(
                        DPFLTR_SXS_ID,
                        DPFLTR_TRACE_LEVEL,
                        "SXS: Storage resolution finished because callback indicated no more entries on root number %Iu\n", CurrentRootIndex);

                    // we're done... 
                    RootCount = CurrentRootIndex;
                    break;
                }

                DbgPrintEx(
                    DPFLTR_SXS_ID,
                    DPFLTR_TRACE_LEVEL,
                    "SXS: Storage resolution callback has indicated that this is the last root to process: number %Iu\n", CurrentRootIndex);

                RootCount = CurrentRootIndex + 1;
            }

            // Allow the caller to skip this index.
            if (CallbackData.GetRoot.Root.Length == 0) {
                DbgPrintEx(
                    DPFLTR_SXS_ID,
                    DPFLTR_TRACE_LEVEL,
                    "SXS: Storage resolution for root number %lu returned blank root; skipping probing logic and moving to next.\n", CurrentRootIndex);

                continue;
            }

            if (OpenDirectoryHandle != NULL) {
                RTL_SOFT_VERIFY(NT_SUCCESS(NtClose(OpenDirectoryHandle)));
                OpenDirectoryHandle = NULL;
            }

            DbgPrintEx(
                DPFLTR_SXS_ID,
                DPFLTR_TRACE_LEVEL,
                "SXS: Assembly storage map probing root %wZ for assembly directory %wZ\n", &CallbackData.GetRoot.Root, &AssemblyDirectory);

            // See if it's there...
            Status = RtlpProbeAssemblyStorageRootForAssembly(
                0,
                &CallbackData.GetRoot.Root,
                &AssemblyDirectory,
                &ResolvedPath,
                &ResolvedDynamicPath,
                &ResolvedPathUsed,
                &OpenDirectoryHandle);

            // If we got it, leave the loop.
            if (NT_SUCCESS(Status)) {
                DbgPrintEx(
                    DPFLTR_SXS_ID,
                    DPFLTR_TRACE_LEVEL,
                    "SXS: Found good storage root for %wZ at index %Iu\n", &AssemblyDirectory, CurrentRootIndex);
                break;
            }

            if (Status != STATUS_SXS_ASSEMBLY_NOT_FOUND) {
                DbgPrintEx(
                    DPFLTR_SXS_ID,
                    DPFLTR_ERROR_LEVEL,
                    "SXS: Attempt to probe assembly storage root %wZ for assembly directory %wZ failed with status = 0x%08lx\n", &CallbackData.GetRoot.Root, &AssemblyDirectory, Status);

                goto Exit;
            }
        }

        if (CurrentRootIndex == RootCount) {
            DbgPrintEx(
                DPFLTR_SXS_ID,
                DPFLTR_ERROR_LEVEL,
                "SXS: Unable to resolve storage root for assembly directory %wZ in %Iu tries\n", &AssemblyDirectory, CurrentRootIndex);

            Status = STATUS_SXS_ASSEMBLY_NOT_FOUND;
            goto Exit;
        }
    }

    //
    // sometimes at this point probing has simultaneously opened the directory,
    // sometimes it has not.
    //
    if (OpenDirectoryHandle == NULL) {

        //create Handle for this directory
        if (!RtlDosPathNameToRelativeNtPathName_U(
                    ResolvedPathUsed->Buffer,
                    &FileName,
                    NULL,
                    &RelativeName
                    )) 
        {
            DbgPrintEx(
                DPFLTR_SXS_ID,
                DPFLTR_ERROR_LEVEL,
                "SXS: Attempt to translate DOS path name \"%S\" to NT format failed\n", ResolvedPathUsed->Buffer);

            Status = STATUS_OBJECT_PATH_NOT_FOUND;
            goto Exit;
        }

        FreeBuffer = FileName.Buffer;

        if (RelativeName.RelativeName.Length != 0) 
        {
            FileName = RelativeName.RelativeName;
        } else 
        {
            RelativeName.ContainingDirectory = NULL;
        }

        InitializeObjectAttributes(
            &Obja,
            &FileName,
            OBJ_CASE_INSENSITIVE,
            RelativeName.ContainingDirectory,
            NULL
            );

        // Open the directory to prevent deletion, just like set current working directory does...
        Status = NtOpenFile(
                    &OpenDirectoryHandle,
                    FILE_TRAVERSE | SYNCHRONIZE,
                    &Obja,
                    &IoStatusBlock,
                    FILE_SHARE_READ | FILE_SHARE_WRITE,
                    FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT
                    );
        RtlReleaseRelativeName(&RelativeName);
        if (!NT_SUCCESS(Status)) 
        {
            //
            // Don't map this to like SXS_blah_NOT_FOUND, because
            // probing says this is definitely where we expect to get stuff.
            //
            DbgPrintEx(
                DPFLTR_SXS_ID,
                DPFLTR_ERROR_LEVEL,
                "SXS: Unable to open assembly directory under storage root \"%S\"; Status = 0x%08lx\n", ResolvedPathUsed->Buffer, Status);
            goto Exit; 
        } else 
        { 
            DbgPrintEx(
                DPFLTR_SXS_ID,
                DPFLTR_TRACE_LEVEL,
                "SXS: It is resolved!!!, GOOD");
        }
    }

    // Hey, we made it.  Add us to the list!
    Status = RtlpInsertAssemblyStorageMapEntry(
        Map,
        AssemblyRosterIndex,
        ResolvedPathUsed,
        &OpenDirectoryHandle);
    if (!NT_SUCCESS(Status)) {
        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: Storage resolution failed to insert entry to storage map; Status = 0x%08lx\n", Status);

        goto Exit;
    }

    Status = STATUS_SUCCESS;
Exit:
    DbgPrintFunctionExit(__FUNCTION__, Status);

    // Let the caller run down their context...
    if (ResolutionContextValid) {
        CallbackData.ResolutionEnding.ResolutionContext = ResolutionContext;

        (*Callback)(
            ASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_REASON_RESOLUTION_ENDING,
            &CallbackData,
            CallbackContext);
    }

    if (ResolvedDynamicPath.Buffer != NULL) {
        (RtlFreeStringRoutine)(ResolvedDynamicPath.Buffer);
    }

    //
    // RtlpInsertAssemblyStorageMapEntry gives ownership to the storage map, and
    // NULLs out our local, when successful.
    //
    if (OpenDirectoryHandle != NULL) {
        RTL_SOFT_VERIFY(NT_SUCCESS(NtClose(OpenDirectoryHandle)));
    }

    if (FreeBuffer != NULL) {
        RtlFreeHeap(RtlProcessHeap(), 0, FreeBuffer);
    }

    return Status;
}

NTSTATUS
RtlpProbeAssemblyStorageRootForAssembly(
    ULONG Flags,
    PCUNICODE_STRING Root,
    PCUNICODE_STRING AssemblyDirectory,
    PUNICODE_STRING PreAllocatedString,
    PUNICODE_STRING DynamicString,
    PUNICODE_STRING *StringUsed,
    HANDLE *OpenDirectoryHandle
    )
{
    NTSTATUS Status = STATUS_SUCCESS;
    WCHAR Buffer[DOS_MAX_PATH_LENGTH];
    UNICODE_STRING String = {0};
    SIZE_T TotalLength;
    BOOLEAN SeparatorNeededAfterRoot = FALSE;
    PWSTR Cursor;
    OBJECT_ATTRIBUTES Obja;
    IO_STATUS_BLOCK IoStatusBlock;
    UNICODE_STRING FileName = {0};
    RTL_RELATIVE_NAME_U RelativeName;
    PWSTR FreeBuffer = NULL;
    HANDLE TempDirectoryHandle = NULL;
    BOOLEAN fExistDir; 
    FILE_BASIC_INFORMATION BasicInfo;

    DbgPrintFunctionEntry(__FUNCTION__);

    if (StringUsed != NULL)
        *StringUsed = NULL;

    if (OpenDirectoryHandle != NULL)
        *OpenDirectoryHandle = NULL;

    if ((Flags != 0) ||
        (Root == NULL) ||
        (AssemblyDirectory == NULL) ||
        (PreAllocatedString == NULL) ||
        (DynamicString == NULL) ||
        (StringUsed == NULL) ||
        (OpenDirectoryHandle == NULL)) {

        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: %s() bad parameters\n"
            "SXS:  Flags:               0x%lx\n"
            // %p is good enough because the checks are only against NULL
            "SXS:  Root:                %p\n"
            "SXS:  AssemblyDirectory:   %p\n"
            "SXS:  PreAllocatedString:  %p\n"
            "SXS:  DynamicString:       %p\n"
            "SXS:  StringUsed:          %p\n"
            "SXS:  OpenDirectoryHandle: %p\n",
            __FUNCTION__,
            Flags,
            Root,
            AssemblyDirectory,
            PreAllocatedString,
            DynamicString,
            StringUsed,
            OpenDirectoryHandle
            );

        Status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }

    TotalLength = Root->Length;

    if (Root->Length != 0) {
        if (!IS_PATH_SEPARATOR(Root->Buffer[(Root->Length / sizeof(WCHAR)) - 1])) {
            SeparatorNeededAfterRoot = TRUE;
            TotalLength += sizeof(WCHAR);
        }
    }

    TotalLength += AssemblyDirectory->Length;

    // And space for the trailing slash
    TotalLength += sizeof(WCHAR);

    // And space for a trailing null character because the path functions want one
    TotalLength += sizeof(WCHAR);

    //
    //  We do not add in space for the trailing slash so as to not cause a dynamic
    //  allocation until necessary in the boundary condition.  If the name of the
    //  directory we're probing fits fine in the stack-allocated buffer, we'll do
    //  the heap allocation if the probe succeeds.  Otherwise we'll not bother.
    //
    //  Maybe the relative complexity of the extra "+ sizeof(WCHAR)"s that are
    //  around aren't worth it, but extra unnecessary heap allocations are my
    //  hot button.
    //

    // Check to see if the string, plus a trailing slash that we don't write until
    // the end of this function plus the trailing null accounted for above
    // fits into a UNICODE_STRING.  If not, bail out.
    if (TotalLength > UNICODE_STRING_MAX_BYTES) {
        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: Assembly storage resolution failing probe because combined path length does not fit in an UNICODE_STRING.\n");

        Status = STATUS_NAME_TOO_LONG;
        goto Exit;
    }

    if (TotalLength > sizeof(Buffer)) {
        String.MaximumLength = (USHORT) TotalLength;

        String.Buffer = (PWSTR)(RtlAllocateStringRoutine)(String.MaximumLength);
        if (String.Buffer == NULL) {
            DbgPrintEx(
                DPFLTR_SXS_ID,
                DPFLTR_ERROR_LEVEL,
                "SXS: Assembly storage resolution failing probe because attempt to allocate %u bytes failed.\n", String.MaximumLength);

            Status = STATUS_NO_MEMORY;
            goto Exit;
        }
    } else {
        String.Buffer = Buffer;
        String.MaximumLength = sizeof(Buffer);
    }

    RtlCopyMemory(
        String.Buffer,
        Root->Buffer,
        Root->Length);

    Cursor = (PWSTR) (((ULONG_PTR) String.Buffer) + Root->Length);

    if (SeparatorNeededAfterRoot) {
        *Cursor++ = L'\\';
    }

    RtlCopyMemory(
        Cursor,
        AssemblyDirectory->Buffer,
        AssemblyDirectory->Length);

    Cursor = (PWSTR) (((ULONG_PTR) Cursor) + AssemblyDirectory->Length);

    *Cursor = L'\0';

    String.Length =
        Root->Length +
        (SeparatorNeededAfterRoot ? sizeof(WCHAR) : 0) +
        AssemblyDirectory->Length;

    if (!RtlDosPathNameToRelativeNtPathName_U(
                                String.Buffer,
                                &FileName,
                                NULL,
                                &RelativeName
                                )) {
        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: Attempt to translate DOS path name \"%S\" to NT format failed\n", String.Buffer);

        Status = STATUS_OBJECT_PATH_NOT_FOUND;
        goto Exit;
    }

    FreeBuffer = FileName.Buffer;

    if (RelativeName.RelativeName.Length != 0) {
        FileName = RelativeName.RelativeName;
    } else {
        RelativeName.ContainingDirectory = NULL;
    }

    InitializeObjectAttributes(
        &Obja,
        &FileName,
        OBJ_CASE_INSENSITIVE,
        RelativeName.ContainingDirectory,
        NULL
        );
    // check the existence of directories
    Status = NtQueryAttributesFile(
                &Obja,
                &BasicInfo
                );

    fExistDir = FALSE; 
    if ( !NT_SUCCESS(Status) ) {
        if ( (Status == STATUS_SHARING_VIOLATION) || (Status == STATUS_ACCESS_DENIED) ) 
            fExistDir = TRUE; 
        else 
            fExistDir = FALSE;
    }
    else 
        fExistDir = TRUE;
    
    if (! fExistDir) {
        RtlReleaseRelativeName(&RelativeName);
        if (( Status == STATUS_NO_SUCH_FILE) || Status == STATUS_OBJECT_NAME_NOT_FOUND || Status == STATUS_OBJECT_PATH_NOT_FOUND)
             Status = STATUS_SXS_ASSEMBLY_NOT_FOUND;
        else 
            DbgPrintEx(
                DPFLTR_SXS_ID,
                DPFLTR_ERROR_LEVEL,
                "SXS: Unable to open assembly directory under storage root \"%S\"; Status = 0x%08lx\n", String.Buffer, Status);

        goto Exit; 
    }

    // Open the directory to prevent deletion, just like set current working directory does...
    Status = NtOpenFile(
                &TempDirectoryHandle,
                FILE_TRAVERSE | SYNCHRONIZE,
                &Obja,
                &IoStatusBlock,
                FILE_SHARE_READ | FILE_SHARE_WRITE,
                FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT
                );
    RtlReleaseRelativeName(&RelativeName);
    if (!NT_SUCCESS(Status)) {
        // If we failed, remap no such file to STATUS_SXS_ASSEMBLY_NOT_FOUND.
        if (Status == STATUS_NO_SUCH_FILE) {
            Status = STATUS_SXS_ASSEMBLY_NOT_FOUND;
        } else {
            DbgPrintEx(
                DPFLTR_SXS_ID,
                DPFLTR_ERROR_LEVEL,
                "SXS: Unable to open assembly directory under storage root \"%S\"; Status = 0x%08lx\n", String.Buffer, Status);
        }

        goto Exit;
    }

    // Hey, we found it!
    // add a slash to the path on the way out and we're done!

    if (TotalLength <= PreAllocatedString->MaximumLength) {
        // The caller's static string is big enough; just use it.
        RtlCopyMemory(
            PreAllocatedString->Buffer,
            String.Buffer,
            String.Length);

        *StringUsed = PreAllocatedString;
    } else {
        // If we already have a dynamic string, just give them our pointer.
        if (String.Buffer != Buffer) {
            DynamicString->Buffer = String.Buffer;
            String.Buffer = NULL;
        } else {
            // Otherwise we do our first allocation on the way out...
            DynamicString->Buffer = (PWSTR)(RtlAllocateStringRoutine)(TotalLength);
            if (DynamicString->Buffer == NULL) {
                Status = STATUS_NO_MEMORY;
                goto Exit;
            }

            RtlCopyMemory(
                DynamicString->Buffer,
                String.Buffer,
                String.Length);
        }

        DynamicString->MaximumLength = (USHORT) TotalLength;
        *StringUsed = DynamicString;
    }

    Cursor = (PWSTR) (((ULONG_PTR) (*StringUsed)->Buffer) + String.Length);
    *Cursor++ = L'\\';
    *Cursor++ = L'\0';
    (*StringUsed)->Length = (USHORT) (String.Length + sizeof(WCHAR)); // aka "TotalLength - sizeof(WCHAR)" but this seemed cleaner

    *OpenDirectoryHandle = TempDirectoryHandle;
    TempDirectoryHandle = NULL;

    Status = STATUS_SUCCESS;
Exit:
    DbgPrintFunctionExit(__FUNCTION__, Status);

    if (FreeBuffer != NULL) {
        RtlFreeHeap(RtlProcessHeap(), 0, FreeBuffer);
    }

    if ((String.Buffer != NULL) && (String.Buffer != Buffer)) {
        (RtlFreeStringRoutine)(String.Buffer);
    }

    if (TempDirectoryHandle != NULL) {
        RTL_SOFT_VERIFY(NT_SUCCESS(NtClose(TempDirectoryHandle)));
    }

    return Status;
}

#if 0 /* dead code */

NTSTATUS
NTAPI
RtlResolveAssemblyStorageMapEntry(
    IN ULONG Flags,
    IN PACTIVATION_CONTEXT ActivationContext,
    IN ULONG AssemblyRosterIndex,
    IN PASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_ROUTINE Callback,
    IN PVOID CallbackContext
    )
{
    NTSTATUS Status = STATUS_SUCCESS;
    PCACTIVATION_CONTEXT_DATA ActivationContextData = NULL;
    PASSEMBLY_STORAGE_MAP Map = NULL;
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER AssemblyRosterHeader = NULL;
    PPEB Peb = NtCurrentPeb();

    DbgPrintFunctionEntry(__FUNCTION__);
    ASSERT_OK_TO_WRITE_PEB();
    RTLP_DISALLOW_THE_EMPTY_ACTIVATION_CONTEXT(ActivationContext);

    Status = RtlpGetActivationContextDataStorageMapAndRosterHeader(
                    0,
                    Peb,
                    ActivationContext,
                    &ActivationContextData,
                    &Map,
                    &AssemblyRosterHeader);
    if (!NT_SUCCESS(Status))
        goto Exit;

    if (ActivationContextData == NULL) {
        ASSERT(ActivationContext == NULL);

        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: RtlResolveAssemblyStorageMapEntry() asked to resolve an assembly storage entry when no activation context data is available.\n");

        Status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }

    if (AssemblyRosterIndex >= AssemblyRosterHeader->EntryCount) {

        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: %s() bad parameters: AssemblyRosterIndex 0x%lx >= AssemblyRosterHeader->EntryCount 0x%lx\n",
            __FUNCTION__,
            AssemblyRosterIndex,
            AssemblyRosterHeader->EntryCount
            );
        Status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }

    Status = RtlpResolveAssemblyStorageMapEntry(Map, ActivationContextData, AssemblyRosterIndex, Callback, CallbackContext);
    if (!NT_SUCCESS(Status))
        goto Exit;

    Status = STATUS_SUCCESS;
Exit:
    DbgPrintFunctionExit(__FUNCTION__, Status);

    return Status;
}

#endif /* dead code */

NTSTATUS
NTAPI
RtlGetAssemblyStorageRoot(
    IN ULONG Flags,
    IN PACTIVATION_CONTEXT ActivationContext,
    IN ULONG AssemblyRosterIndex,
    OUT PCUNICODE_STRING *AssemblyStorageRoot,
    IN PASSEMBLY_STORAGE_MAP_RESOLUTION_CALLBACK_ROUTINE Callback,
    IN PVOID CallbackContext
    )
{
    NTSTATUS Status = STATUS_SUCCESS;

    PCACTIVATION_CONTEXT_DATA ActivationContextData = NULL;
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER AssemblyRosterHeader = NULL;
    PASSEMBLY_STORAGE_MAP AssemblyStorageMap = NULL;

    const PPEB Peb = NtCurrentPeb();

    DbgPrintFunctionEntry(__FUNCTION__);
    ASSERT_OK_TO_WRITE_PEB();
    RTLP_DISALLOW_THE_EMPTY_ACTIVATION_CONTEXT(ActivationContext);

    if (AssemblyStorageRoot != NULL) {
        *AssemblyStorageRoot = NULL;
    }

    if ((Flags & ~(RTL_GET_ASSEMBLY_STORAGE_ROOT_FLAG_ACTIVATION_CONTEXT_USE_PROCESS_DEFAULT
            | RTL_GET_ASSEMBLY_STORAGE_ROOT_FLAG_ACTIVATION_CONTEXT_USE_SYSTEM_DEFAULT))
        ||
        (AssemblyRosterIndex < 1) ||
        (AssemblyStorageRoot == NULL) ||
        (Callback == NULL)) {

        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: %s() bad parameters:\n"
            "SXS:    Flags              : 0x%lx\n"
            "SXS:    AssemblyRosterIndex: 0x%lx\n"
            "SXS:    AssemblyStorageRoot: %p\n"
            "SXS:    Callback           : %p\n",
            __FUNCTION__,
            Flags,
            AssemblyRosterIndex,
            AssemblyStorageRoot,
            Callback
            );
        Status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }

    // Simple implementation: just resolve it and if it resolves OK, return the string in the
    // storage map.
    Status =
        RtlpGetActivationContextDataStorageMapAndRosterHeader(
            ((Flags & RTL_GET_ASSEMBLY_STORAGE_ROOT_FLAG_ACTIVATION_CONTEXT_USE_PROCESS_DEFAULT)
                ? RTLP_GET_ACTIVATION_CONTEXT_DATA_STORAGE_MAP_AND_ROSTER_HEADER_USE_PROCESS_DEFAULT
                : 0)
            | ((Flags & RTL_GET_ASSEMBLY_STORAGE_ROOT_FLAG_ACTIVATION_CONTEXT_USE_SYSTEM_DEFAULT)
                ? RTLP_GET_ACTIVATION_CONTEXT_DATA_STORAGE_MAP_AND_ROSTER_HEADER_USE_SYSTEM_DEFAULT
                : 0),
            Peb,
            ActivationContext,
            &ActivationContextData,
            &AssemblyStorageMap,
            &AssemblyRosterHeader
            );
    if (!NT_SUCCESS(Status)) {
        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: RtlGetAssemblyStorageRoot() unable to get activation context data, storage map and assembly roster header.  Status = 0x%08lx\n", Status);

        goto Exit;
    }

    // It's possible that there wasn't anything...
    if (ActivationContextData != NULL) {
        ASSERT(AssemblyRosterHeader != NULL);
        ASSERT(AssemblyStorageMap != NULL);

        if ((AssemblyRosterHeader == NULL) || (AssemblyStorageMap == NULL)) {
            Status = STATUS_INTERNAL_ERROR;
            goto Exit;
        }

        if (AssemblyRosterIndex >= AssemblyRosterHeader->EntryCount) {

            DbgPrintEx(
                DPFLTR_SXS_ID,
                DPFLTR_ERROR_LEVEL,
                "SXS: %s() bad parameters AssemblyRosterIndex 0x%lx "
                           ">= AssemblyRosterHeader->EntryCount: 0x%lx\n",
                __FUNCTION__,
                AssemblyRosterIndex,
                AssemblyRosterHeader->EntryCount
                );
            Status = STATUS_INVALID_PARAMETER;
            goto Exit;
        }

        Status = RtlpResolveAssemblyStorageMapEntry(AssemblyStorageMap, ActivationContextData, AssemblyRosterIndex, Callback, CallbackContext);
        if (!NT_SUCCESS(Status)) {
            DbgPrintEx(
                DPFLTR_SXS_ID,
                DPFLTR_ERROR_LEVEL,
                "SXS: RtlGetAssemblyStorageRoot() unable to resolve storage map entry.  Status = 0x%08lx\n", Status);

            goto Exit;
        }

        // I guess we're done!
        ASSERT(AssemblyStorageMap->AssemblyArray[AssemblyRosterIndex] != NULL);
        if (AssemblyStorageMap->AssemblyArray[AssemblyRosterIndex] == NULL) {
            Status = STATUS_INTERNAL_ERROR;
            goto Exit;
        }

        *AssemblyStorageRoot = &AssemblyStorageMap->AssemblyArray[AssemblyRosterIndex]->DosPath;
    }

    Status = STATUS_SUCCESS;
Exit:
    DbgPrintFunctionExit(__FUNCTION__, Status);
    return Status;
}

NTSTATUS
RtlpGetActivationContextDataStorageMapAndRosterHeader(
    ULONG Flags,
    PPEB Peb,
    PACTIVATION_CONTEXT ActivationContext,
    PCACTIVATION_CONTEXT_DATA *ActivationContextData,
    PASSEMBLY_STORAGE_MAP *AssemblyStorageMap,
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER  *AssemblyRosterHeader
    )
{
    NTSTATUS Status = STATUS_SUCCESS;
    PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER TempAssemblyRosterHeader = NULL;
    PCACTIVATION_CONTEXT_DATA* TempActivationContextData = NULL;
    PASSEMBLY_STORAGE_MAP* TempAssemblyStorageMap = NULL;
    WCHAR LocalAssemblyDirectoryBuffer[DOS_MAX_PATH_LENGTH];
    UNICODE_STRING LocalAssemblyDirectory = {0};

    DbgPrintFunctionEntry(__FUNCTION__);
    LocalAssemblyDirectoryBuffer[0] = 0;
    LocalAssemblyDirectory.Length = 0;
    LocalAssemblyDirectory.MaximumLength = sizeof(WCHAR);
    LocalAssemblyDirectory.Buffer = LocalAssemblyDirectoryBuffer;

    ASSERT(Peb != NULL);
    RTLP_DISALLOW_THE_EMPTY_ACTIVATION_CONTEXT(ActivationContext);

    if (ActivationContextData != NULL) {
        *ActivationContextData = NULL;
    }

    if (AssemblyStorageMap != NULL) {
        *AssemblyStorageMap = NULL;
    }

    if (AssemblyRosterHeader != NULL) {
        *AssemblyRosterHeader = NULL;
    }

    if (
        (Flags & ~(RTLP_GET_ACTIVATION_CONTEXT_DATA_STORAGE_MAP_AND_ROSTER_HEADER_USE_PROCESS_DEFAULT
            | RTLP_GET_ACTIVATION_CONTEXT_DATA_STORAGE_MAP_AND_ROSTER_HEADER_USE_SYSTEM_DEFAULT))
        ||
        (Peb == NULL) ||
        (ActivationContextData == NULL) ||
        (AssemblyStorageMap == NULL)) {

        DbgPrintEx(
            DPFLTR_SXS_ID,
            DPFLTR_ERROR_LEVEL,
            "SXS: %s() bad parameters:\n"
            "SXS:    Flags                : 0x%lx\n"
            "SXS:    Peb                  : %p\n"
            "SXS:    ActivationContextData: %p\n"
            "SXS:    AssemblyStorageMap   : %p\n"
            __FUNCTION__,
            Flags,
            Peb,
            ActivationContextData,
            AssemblyStorageMap
            );
        Status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }

    if (ActivationContext == ACTCTX_PROCESS_DEFAULT
        || ActivationContext == ACTCTX_SYSTEM_DEFAULT
        || (Flags & (
        RTLP_GET_ACTIVATION_CONTEXT_DATA_STORAGE_MAP_AND_ROSTER_HEADER_USE_PROCESS_DEFAULT
        | RTLP_GET_ACTIVATION_CONTEXT_DATA_STORAGE_MAP_AND_ROSTER_HEADER_USE_SYSTEM_DEFAULT))) {

        //
        // NOTE the ambiguity here. Maybe we'll clean this up.
        //
        // The flags override.
        // ActivationContext == ACTCTX_PROCESS_DEFAULT could still be system default.
        //

        if (ActivationContext == ACTCTX_SYSTEM_DEFAULT
            || (Flags & RTLP_GET_ACTIVATION_CONTEXT_DATA_STORAGE_MAP_AND_ROSTER_HEADER_USE_SYSTEM_DEFAULT)
            ) {
            TempActivationContextData = &Peb->SystemDefaultActivationContextData;
            TempAssemblyStorageMap = &Peb->SystemAssemblyStorageMap;

            if (*TempActivationContextData != NULL) {
                TempAssemblyRosterHeader = (PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER) (((ULONG_PTR) *TempActivationContextData) + (*TempActivationContextData)->AssemblyRosterOffset);
            }
        }
        else if (ActivationContext == ACTCTX_PROCESS_DEFAULT || (Flags & RTLP_GET_ACTIVATION_CONTEXT_DATA_STORAGE_MAP_AND_ROSTER_HEADER_USE_PROCESS_DEFAULT)) {
            TempActivationContextData = &Peb->ActivationContextData;
            TempAssemblyStorageMap = &Peb->ProcessAssemblyStorageMap;

            if (*TempActivationContextData != NULL) {
                TempAssemblyRosterHeader = (PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER) (((ULONG_PTR) *TempActivationContextData) + (*TempActivationContextData)->AssemblyRosterOffset);
                if (*TempAssemblyStorageMap == NULL) {
                    UNICODE_STRING ImagePathName;

                    // Capture the image path name so that we don't overrun allocated buffers because someone's
                    // randomly tweaking the RTL_USER_PROCESS_PARAMETERS.
                    ImagePathName = Peb->ProcessParameters->ImagePathName;

                    // The process default local assembly directory is the image name plus ".local".
                    // The process default private assembly directory is the image path.
                    if ((ImagePathName.Length + sizeof(LOCAL_ASSEMBLY_STORAGE_DIR_SUFFIX)) > sizeof(LocalAssemblyDirectoryBuffer)) {
                        if ((ImagePathName.Length + sizeof(LOCAL_ASSEMBLY_STORAGE_DIR_SUFFIX)) > UNICODE_STRING_MAX_BYTES) {
                            Status = STATUS_NAME_TOO_LONG;
                            goto Exit;
                        }

                        LocalAssemblyDirectory.MaximumLength = (USHORT) (ImagePathName.Length + sizeof(LOCAL_ASSEMBLY_STORAGE_DIR_SUFFIX));

                        LocalAssemblyDirectory.Buffer = (PWSTR)(RtlAllocateStringRoutine)(LocalAssemblyDirectory.MaximumLength);
                        if (LocalAssemblyDirectory.Buffer == NULL) {
                            Status = STATUS_NO_MEMORY;
                            goto Exit;
                        }
                    } else {
                        LocalAssemblyDirectory.MaximumLength = sizeof(LocalAssemblyDirectoryBuffer);
                        LocalAssemblyDirectory.Buffer = LocalAssemblyDirectoryBuffer;
                    }

                    RtlCopyMemory(
                        LocalAssemblyDirectory.Buffer,
                        ImagePathName.Buffer,
                        ImagePathName.Length);

                    RtlCopyMemory(
                        &LocalAssemblyDirectory.Buffer[ImagePathName.Length / sizeof(WCHAR)],
                        LOCAL_ASSEMBLY_STORAGE_DIR_SUFFIX,
                        sizeof(LOCAL_ASSEMBLY_STORAGE_DIR_SUFFIX));

                    LocalAssemblyDirectory.Length = ImagePathName.Length + sizeof(LOCAL_ASSEMBLY_STORAGE_DIR_SUFFIX) - sizeof(WCHAR);

                    if (!NT_SUCCESS(Status))
                        goto Exit;
                }
            }
        }
        if (*TempActivationContextData != NULL) {
            if (*TempAssemblyStorageMap == NULL) {
                PASSEMBLY_STORAGE_MAP Map = (PASSEMBLY_STORAGE_MAP) RtlAllocateHeap(RtlProcessHeap(), 0, sizeof(ASSEMBLY_STORAGE_MAP) + (TempAssemblyRosterHeader->EntryCount * sizeof(PASSEMBLY_STORAGE_MAP_ENTRY)));
                if (Map == NULL) {
                    Status = STATUS_NO_MEMORY;
                    goto Exit;
                }
                Status = RtlpInitializeAssemblyStorageMap(Map, TempAssemblyRosterHeader->EntryCount, (PASSEMBLY_STORAGE_MAP_ENTRY *) (Map + 1));
                if (!NT_SUCCESS(Status)) {
                    RtlFreeHeap(RtlProcessHeap(), 0, Map);
                    goto Exit;
                }

                if (InterlockedCompareExchangePointer((PVOID*)TempAssemblyStorageMap, Map, NULL) != NULL) {
                    // We were not the first ones in.  Free ours and use the one allocated.
                    RtlpUninitializeAssemblyStorageMap(Map);
                    RtlFreeHeap(RtlProcessHeap(), 0, Map);
                }
            }
        } else {
            ASSERT(*TempAssemblyStorageMap == NULL);
        }
        *AssemblyStorageMap = (PASSEMBLY_STORAGE_MAP) *TempAssemblyStorageMap;
    } else {
        TempActivationContextData = &ActivationContext->ActivationContextData;

        ASSERT(*TempActivationContextData != NULL);
        if (*TempActivationContextData == NULL) {
            Status = STATUS_INTERNAL_ERROR;
            goto Exit;
        }

        TempAssemblyRosterHeader = (PCACTIVATION_CONTEXT_DATA_ASSEMBLY_ROSTER_HEADER) (((ULONG_PTR) *TempActivationContextData) + (*TempActivationContextData)->AssemblyRosterOffset);
        *AssemblyStorageMap = &ActivationContext->StorageMap;
    }

    if (ActivationContextData != NULL)
        *ActivationContextData = *TempActivationContextData;

    if (AssemblyRosterHeader != NULL)
        *AssemblyRosterHeader = TempAssemblyRosterHeader;

    Status = STATUS_SUCCESS;
Exit:
    DbgPrintFunctionExit(__FUNCTION__, Status);
    if ((LocalAssemblyDirectory.Buffer != NULL) &&
        (LocalAssemblyDirectory.Buffer != LocalAssemblyDirectoryBuffer)) {
        RtlFreeUnicodeString(&LocalAssemblyDirectory);
    }
    return Status;
}

#if defined(__cplusplus)
} /* extern "C" */
#endif