windows-server-2003/base/subsys/sm/server/sminit.c

/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    sminit.c

Abstract:

    Session Manager Initialization

Author:

    Mark Lucovsky (markl) 04-Oct-1989

Revision History:

--*/

#include "smsrvp.h"
#include "pagefile.h"

#include <stdio.h>
#include <string.h>
#include <safeboot.h>
#include <wow64t.h>

#if defined(REMOTE_BOOT)
#include <windows.h>
#ifdef DeleteFile
#undef DeleteFile
#endif
#include <shdcom.h>     // CSC definitions
#endif // defined(REMOTE_BOOT)

#include "sfcfiles.h"

void
SmpDisplayString( char *s );

//
// Protection mode flags
//

#define SMP_NO_PROTECTION           (0x0)
#define SMP_STANDARD_PROTECTION     (0x1)
#define SMP_PROTECTION_REQUIRED     (SMP_STANDARD_PROTECTION)

#define REMOTE_BOOT_CFG_FILE L"RemoteBoot.cfg"

//
// Shows where was SmpInit execution when it returned
// with an error code. This aids debugging smss crashes a lot.
//

ULONG SmpInitProgressByLine;
NTSTATUS SmpInitReturnStatus;
PVOID SmpInitLastCall;

#define SAVE_SMPINIT_STATUS(caller, status) {  \
                                               \
        SmpInitProgressByLine = __LINE__;      \
        SmpInitReturnStatus = (status);        \
        SmpInitLastCall = (PVOID)(caller);     \
    }



PSECURITY_DESCRIPTOR SmpPrimarySecurityDescriptor;
SECURITY_DESCRIPTOR SmpPrimarySDBody;
PSECURITY_DESCRIPTOR SmpLiberalSecurityDescriptor;
SECURITY_DESCRIPTOR SmpLiberalSDBody;
PSECURITY_DESCRIPTOR SmpKnownDllsSecurityDescriptor;
SECURITY_DESCRIPTOR SmpKnownDllsSDBody;
PSECURITY_DESCRIPTOR SmpApiPortSecurityDescriptor;
SECURITY_DESCRIPTOR SmpApiPortSDBody;
ULONG SmpProtectionMode = SMP_STANDARD_PROTECTION;
UCHAR TmpBuffer[ 1024 + 2 * DOS_MAX_PATH_LENGTH * sizeof(WCHAR)];
ULONG AttachedSessionId = (-1);

#if defined(REMOTE_BOOT)
WCHAR wszRemoteBootCfgFile[DOS_MAX_PATH_LENGTH];
#endif // defined(REMOTE_BOOT)

#if DBG
BOOLEAN SmpEnableDots = FALSE;
#else
BOOLEAN SmpEnableDots = TRUE;
#endif


WCHAR InitialCommandBuffer[ 256 ];

UNICODE_STRING SmpDebugKeyword;
UNICODE_STRING SmpASyncKeyword;
UNICODE_STRING SmpAutoChkKeyword;
#if defined(REMOTE_BOOT)
UNICODE_STRING SmpAutoFmtKeyword;
#endif // defined(REMOTE_BOOT)
UNICODE_STRING SmpKnownDllPath;
#ifdef _WIN64
UNICODE_STRING SmpKnownDllPath32;
#endif

HANDLE SmpWindowsSubSysProcess;
ULONG_PTR SmpWindowsSubSysProcessId;
ULONG_PTR SmpInitialCommandProcessId;
UNICODE_STRING PosixName;
UNICODE_STRING Os2Name;
BOOLEAN RegPosixSingleInstance; // Make Softway Work.
ULONG SmpAllowProtectedRenames;
BOOLEAN MiniNTBoot = FALSE;
ULONG SmpCalledConfigEnv = 0;

LIST_ENTRY SmpBootExecuteList;
LIST_ENTRY SmpSetupExecuteList;
LIST_ENTRY SmpPagingFileList;
LIST_ENTRY SmpDosDevicesList;
LIST_ENTRY SmpFileRenameList;
LIST_ENTRY SmpKnownDllsList;
LIST_ENTRY SmpExcludeKnownDllsList;
LIST_ENTRY SmpSubSystemList;
LIST_ENTRY SmpSubSystemsToLoad;
LIST_ENTRY SmpSubSystemsToDefer;
LIST_ENTRY SmpExecuteList;

NTSTATUS
SmpCreateSecurityDescriptors(
    IN BOOLEAN InitialCall
    );

NTSTATUS
SmpLoadDataFromRegistry(
    OUT PUNICODE_STRING InitialCommand
    );

NTSTATUS
SmpCreateDynamicEnvironmentVariables(
    VOID
    );

NTSTATUS
SmpConfigureProtectionMode(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    );

NTSTATUS
SmpConfigureAllowProtectedRenames(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    );

NTSTATUS
SmpConfigureObjectDirectories(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    );

NTSTATUS
SmpConfigureExecute(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    );

NTSTATUS
SmpConfigureFileRenames(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    );

NTSTATUS
SmpConfigureMemoryMgmt(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    );

NTSTATUS
SmpConfigureDosDevices(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    );

NTSTATUS
SmpConfigureKnownDlls(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    );

NTSTATUS
SmpConfigureExcludeKnownDlls(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    );

NTSTATUS
SmpConfigureSubSystems(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    );

NTSTATUS
SmpConfigureEnvironment(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    );

ULONGLONG
SmpGetFileVersion(
    IN HANDLE FileHandle,
    IN PUNICODE_STRING FileName
    );

NTSTATUS
SmpCallCsrCreateProcess(
    IN OUT PSBAPIMSG m,
    IN size_t ArgLength,
    IN HANDLE CommunicationPort
    );


RTL_QUERY_REGISTRY_TABLE SmpRegistryConfigurationTable[] = {

    //
    // Note that the SmpConfigureProtectionMode entry should preceed others
    // to ensure we set up the right protection for use by the others.
    //

    {SmpConfigureProtectionMode, 0,
     L"ProtectionMode",          NULL,
     REG_DWORD, (PVOID)0, 0},

    {SmpConfigureAllowProtectedRenames, RTL_QUERY_REGISTRY_DELETE,
     L"AllowProtectedRenames",   NULL,
     REG_DWORD, (PVOID)0, 0},

    {SmpConfigureObjectDirectories, 0,
     L"ObjectDirectories",          NULL,
     REG_MULTI_SZ, (PVOID)L"\\Windows\0\\RPC Control\0", 0},

    {SmpConfigureExecute,       0,
     L"BootExecute",            &SmpBootExecuteList,
     REG_MULTI_SZ, L"autocheck AutoChk.exe *\0", 0},

    {SmpConfigureExecute,       RTL_QUERY_REGISTRY_TOPKEY,
     L"SetupExecute",           &SmpSetupExecuteList,
     REG_NONE, NULL, 0},

    {SmpConfigureFileRenames,   RTL_QUERY_REGISTRY_DELETE,
     L"PendingFileRenameOperations",   &SmpFileRenameList,
     REG_NONE, NULL, 0},

    {SmpConfigureFileRenames,   RTL_QUERY_REGISTRY_DELETE,
     L"PendingFileRenameOperations2",   &SmpFileRenameList,
     REG_NONE, NULL, 0},

    {SmpConfigureExcludeKnownDlls, 0,
     L"ExcludeFromKnownDlls",   &SmpExcludeKnownDllsList,
     REG_MULTI_SZ, L"\0", 0},

    {NULL,                      RTL_QUERY_REGISTRY_SUBKEY,
     L"Memory Management",      NULL,
     REG_NONE, NULL, 0},

    {SmpConfigureMemoryMgmt,    0,
     L"PagingFiles",            &SmpPagingFileList,
     REG_MULTI_SZ, L"?:\\pagefile.sys\0", 0},

    {SmpConfigureDosDevices,    RTL_QUERY_REGISTRY_SUBKEY,
     L"DOS Devices",            &SmpDosDevicesList,
     REG_NONE, NULL, 0},

    {SmpConfigureKnownDlls,     RTL_QUERY_REGISTRY_SUBKEY,
     L"KnownDlls",              &SmpKnownDllsList,
     REG_NONE, NULL, 0},

    //
    // NOTICE-2002/05/23-ELi
    // SmpConfigureEnvironment assumes that it will be called twice
    // If you change the number of times SmpConfigureEnvironment is called,
    // then make sure that you do not break SmpConfigureEnvironment.
    // see bug 318452 in the old Windows NT Bugs RAID database for the
    // reason why SmpConfigureEnvironment is called twice.
    //

    //
    // this needs to happen twice so that forward references to environment
    // variables, which may be defined under the Environment registry key, are
    // properly resolved
    //

    {SmpConfigureEnvironment,   RTL_QUERY_REGISTRY_SUBKEY,
     L"Environment",            NULL,
     REG_NONE, NULL, 0},

    {SmpConfigureEnvironment,   RTL_QUERY_REGISTRY_SUBKEY,
     L"Environment",            NULL,
     REG_NONE, NULL, 0},

    {SmpConfigureSubSystems,    RTL_QUERY_REGISTRY_SUBKEY,
     L"SubSystems",             &SmpSubSystemList,
     REG_NONE, NULL, 0},

    {SmpConfigureSubSystems,    RTL_QUERY_REGISTRY_NOEXPAND,
     L"Required",               &SmpSubSystemList,
     REG_MULTI_SZ, L"Debug\0Windows\0", 0},

    {SmpConfigureSubSystems,    RTL_QUERY_REGISTRY_NOEXPAND,
     L"Optional",               &SmpSubSystemList,
     REG_NONE, NULL, 0},

    {SmpConfigureSubSystems,    0,
     L"Kmode",                  &SmpSubSystemList,
     REG_NONE, NULL, 0},

    {SmpConfigureExecute,       RTL_QUERY_REGISTRY_TOPKEY,
     L"Execute",                &SmpExecuteList,
     REG_NONE, NULL, 0},

    {NULL, 0,
     NULL, NULL,
     REG_NONE, NULL, 0}

};


NTSTATUS
SmpInvokeAutoChk(
    IN PUNICODE_STRING ImageFileName,
    IN PUNICODE_STRING CurrentDirectory,
    IN PUNICODE_STRING Arguments,
    IN ULONG Flags
    );

#if defined(REMOTE_BOOT)
NTSTATUS
SmpInvokeAutoFmt(
    IN PUNICODE_STRING ImageFileName,
    IN PUNICODE_STRING CurrentDirectory,
    IN PUNICODE_STRING Arguments,
    IN ULONG Flags
    );
#endif // defined(REMOTE_BOOT)

NTSTATUS
SmpLoadSubSystem(
    IN PUNICODE_STRING ImageFileName,
    IN PUNICODE_STRING CurrentDirectory,
    IN PUNICODE_STRING CommandLine,
    IN ULONG MuSessionId,
    OUT PULONG_PTR pWindowsSubSysProcessId,
    IN ULONG Flags
    );

NTSTATUS
SmpExecuteCommand(
    IN PUNICODE_STRING CommandLine,
    IN ULONG MuSessionId,
    OUT PULONG_PTR pWindowsSubSysProcessId,
    IN ULONG Flags
    );

NTSTATUS
SmpInitializeDosDevices( VOID );

NTSTATUS
SmpInitializeKnownDlls( VOID );

NTSTATUS
SmpInitializeKnownDllPath(
    IN PUNICODE_STRING KnownDllPath,
    IN PVOID ValueData,
    IN ULONG ValueLength);

NTSTATUS
SmpInitializeKnownDllsInternal(
    IN PUNICODE_STRING ObjectDirectoryName,
    IN PUNICODE_STRING KnownDllPath
    );


#if defined(REMOTE_BOOT)
NTSTATUS
SmpExecuteCommandLineArguments( VOID );
#endif // defined(REMOTE_BOOT)

VOID
SmpProcessFileRenames( VOID );

NTSTATUS
SmpParseToken(
    IN PUNICODE_STRING Source,
    IN BOOLEAN RemainderOfSource,
    OUT PUNICODE_STRING Token
    );

NTSTATUS
SmpParseCommandLine(
    IN PUNICODE_STRING CommandLine,
    OUT PULONG Flags,
    OUT PUNICODE_STRING ImageFileName,
    OUT PUNICODE_STRING ImageFileDirectory OPTIONAL,
    OUT PUNICODE_STRING Arguments
    );

#define SMP_DEBUG_FLAG      0x00000001
#define SMP_ASYNC_FLAG      0x00000002
#define SMP_AUTOCHK_FLAG    0x00000004
#define SMP_SUBSYSTEM_FLAG  0x00000008
#define SMP_IMAGE_NOT_FOUND 0x00000010
#define SMP_DONT_START      0x00000020
#if defined(REMOTE_BOOT)
#define SMP_AUTOFMT_FLAG    0x00000040
#endif // defined(REMOTE_BOOT)
#define SMP_POSIX_SI_FLAG   0x00000080
#define SMP_POSIX_FLAG      0x00000100
#define SMP_OS2_FLAG        0x00000200

ULONG
SmpConvertInteger(
    IN PWSTR String
    );

VOID
SmpTranslateSystemPartitionInformation( VOID );


#if defined(REMOTE_BOOT)
//
// Useful functions for iterating thru directories and files
//
typedef enum {
    NormalReturn,   // if the whole process completes uninterrupted
    EnumFileError,  // if an error occurs while enumerating files
    CallbackReturn  // if the callback returns FALSE, causing termination
} ENUMFILESRESULT;

typedef BOOLEAN (*ENUMFILESPROC) (
    IN  PWSTR,
    IN  PFILE_BOTH_DIR_INFORMATION,
    OUT PULONG,
    IN  PVOID
    );

typedef struct {
    PVOID           OptionalPtr;
    ENUMFILESPROC   EnumProc;
} RECURSION_DATA, *PRECURSION_DATA;



ENUMFILESRESULT
SmpEnumFiles(
    IN  PWSTR         DirName,
    IN  ENUMFILESPROC EnumFilesProc,
    OUT PULONG        ReturnData,
    IN  PVOID         Pointer
    );

ENUMFILESRESULT
SmpEnumFilesRecursive (
    IN  PWSTR         DirName,
    IN  ENUMFILESPROC EnumFilesProc,
    OUT PULONG        ReturnData,
    IN  PVOID         Pointer       OPTIONAL
    );

VOID
SmpConcatenatePaths(
    IN OUT LPWSTR  Path1,
    IN     LPCWSTR Path2
    );

BOOLEAN
SmppRecursiveEnumProc (
    IN  PWSTR                      DirName,
    IN  PFILE_BOTH_DIR_INFORMATION FileInfo,
    OUT PULONG                     ret,
    IN  PVOID                      Param
    );

BOOLEAN
SmpDelEnumFile(
    IN  PWSTR                      DirName,
    IN  PFILE_BOTH_DIR_INFORMATION FileInfo,
    OUT PULONG                     ret,
    IN  PVOID                      Pointer
    );

#endif // defined(REMOTE_BOOT)



//
// routines
//



BOOLEAN
SmpQueryRegistrySosOption(
    VOID
    )

/*++

Routine Description:

    This function queries the registry to determine if the loadoptions
    boot environment variable contains the string "SOS".

    HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control:SystemStartOptions

Arguments:

    None.

Return Value:

    TRUE if "SOS" was set.  Otherwise FALSE.

--*/

{

    NTSTATUS Status;
    UNICODE_STRING KeyName;
    UNICODE_STRING ValueName;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE Key;
    UCHAR ValueBuffer[VALUE_BUFFER_SIZE];
    PKEY_VALUE_PARTIAL_INFORMATION KeyValueInfo;
    ULONG ValueLength;

    //
    // Open the registry key.
    //

    KeyValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
    RtlInitUnicodeString(&KeyName,
                         L"\\Registry\\Machine\\System\\CurrentControlSet\\Control");

    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);

    Status = NtOpenKey(&Key, KEY_READ, &ObjectAttributes);
    if (!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: can't open control key: 0x%x\n",
                   Status));

        return FALSE;
    }

    //
    // Query the key value.
    //

    RtlInitUnicodeString(&ValueName, L"SystemStartOptions");
    Status = NtQueryValueKey(Key,
                             &ValueName,
                             KeyValuePartialInformation,
                             (PVOID)KeyValueInfo,
                             sizeof (ValueBuffer),
                             &ValueLength);

    ASSERT(ValueLength < VALUE_BUFFER_SIZE);

    NtClose(Key);
    if (!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: can't query value key: 0x%x\n",
                   Status));

        return FALSE;
    }

    //
    // Check is "sos" or "SOS" ois specified.
    //

    if (NULL != wcsstr((PWCHAR)&KeyValueInfo->Data, L"SOS") ||
        NULL != wcsstr((PWCHAR)&KeyValueInfo->Data, L"sos")) {
        return TRUE;
    }

    return FALSE;
}


NTSTATUS
SmpInit(
    OUT PUNICODE_STRING InitialCommand,
    OUT PHANDLE WindowsSubSystem
    )
{
    NTSTATUS st;
    OBJECT_ATTRIBUTES ObjA;
    HANDLE SmpApiConnectionPort;
    UNICODE_STRING Unicode;
    NTSTATUS Status, Status2;
    ULONG HardErrorMode;
    UNICODE_STRING UnicodeString;
    HANDLE VolumeSafeEvent;

    SmBaseTag = RtlCreateTagHeap( RtlProcessHeap(),
                                  0,
                                  L"SMSS!",
                                  L"INIT\0"
                                  L"DBG\0"
                                  L"SM\0"
                                );
    //
    // Make sure we specify hard error popups
    //

    HardErrorMode = 1;
    NtSetInformationProcess( NtCurrentProcess(),
                             ProcessDefaultHardErrorMode,
                             (PVOID) &HardErrorMode,
                             sizeof( HardErrorMode )
                           );

    RtlInitUnicodeString( &SmpSubsystemName, L"NT-Session Manager" );


    RtlInitializeCriticalSection(&SmpKnownSubSysLock);
    InitializeListHead(&SmpKnownSubSysHead);

    RtlInitializeCriticalSection(&SmpSessionListLock);
    InitializeListHead(&SmpSessionListHead);
    SmpNextSessionId = 1;
    SmpNextSessionIdScanMode = FALSE;
    SmpDbgSsLoaded = FALSE;

    //
    // Initialize security descriptors to grant wide access
    // (protection mode not yet read in from registry).
    //

    st = SmpCreateSecurityDescriptors( TRUE );
    if (!NT_SUCCESS(st)) {

        SAVE_SMPINIT_STATUS (SmpCreateSecurityDescriptors, st);
        return(st);
    }

    InitializeListHead(&NativeProcessList);

    SmpHeap = RtlProcessHeap();

    RtlInitUnicodeString( &PosixName, L"POSIX" );
    RtlInitUnicodeString( &Os2Name, L"OS2" );

    RtlInitUnicodeString( &Unicode, L"\\SmApiPort" );
    InitializeObjectAttributes( &ObjA, &Unicode, 0, NULL, SmpApiPortSecurityDescriptor);

    st = NtCreatePort(
            &SmpApiConnectionPort,
            &ObjA,
            sizeof(SBCONNECTINFO),
            sizeof(SMMESSAGE_SIZE),
            sizeof(SBAPIMSG) * 32
            );
    ASSERT( NT_SUCCESS(st) );

    SmpDebugPort = SmpApiConnectionPort;

    st = RtlCreateUserThread(
            NtCurrentProcess(),
            NULL,
            FALSE,
            0L,
            0L,
            0L,
            SmpApiLoop,
            (PVOID) SmpApiConnectionPort,
            NULL,
            NULL
            );
    ASSERT( NT_SUCCESS(st) );

    st = RtlCreateUserThread(
            NtCurrentProcess(),
            NULL,
            FALSE,
            0L,
            0L,
            0L,
            SmpApiLoop,
            (PVOID) SmpApiConnectionPort,
            NULL,
            NULL
            );
    ASSERT( NT_SUCCESS(st) );



    //
    // Create a event to signal that volume are safe for write access opens.
    // Call this event 'VolumesSafeForWriteAccess'.  This event will be
    // signalled after AUTOCHK/AUTOCONV/AUTOFMT have done their business.
    //

    RtlInitUnicodeString( &UnicodeString, L"\\Device\\VolumesSafeForWriteAccess");

    InitializeObjectAttributes( &ObjA,
                                &UnicodeString,
                                OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
                                NULL,
                                NULL
                              );

    Status2 = NtCreateEvent( &VolumeSafeEvent,
                             EVENT_ALL_ACCESS,
                             &ObjA,
                             NotificationEvent,
                             FALSE
                           );
    if (!NT_SUCCESS( Status2 )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to create %wZ event - Status == %lx\n",
                   &UnicodeString,
                   Status2));

        ASSERT( NT_SUCCESS(Status2) );
    }

    //
    // Configure the system
    //

    Status = SmpLoadDataFromRegistry( InitialCommand );

    if (NT_SUCCESS( Status )) {
        
        *WindowsSubSystem = SmpWindowsSubSysProcess;
    }

    //
    // AUTOCHK/AUTOCONV/AUTOFMT are finished.
    //

    if (NT_SUCCESS(Status2)) {
        NtSetEvent(VolumeSafeEvent, NULL);
        NtClose(VolumeSafeEvent);
    }

    return( Status );
}


NTSTATUS
SmpLoadDataFromRegistry(
    OUT PUNICODE_STRING InitialCommand
    )

/*++

Routine Description:

    This function loads all of the configurable data for the NT Session
    Manager from the registry.

Arguments:

    None

Return Value:

    Status of operation

--*/

{
    NTSTATUS Status;
    PLIST_ENTRY Head, Next;
    PSMP_REGISTRY_VALUE p;
    PVOID OriginalEnvironment;
    ULONG MuSessionId = 0;
    UNICODE_STRING KeyName;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE Key;
    UNICODE_STRING SessionDirName;
#if defined(REMOTE_BOOT)
    HANDLE RdrHandle = NULL;
    IO_STATUS_BLOCK Iosb;
    SHADOWINFO ShadowInfo;
#endif // defined(REMOTE_BOOT)


    RtlInitUnicodeString( &SmpDebugKeyword, L"debug" );
    RtlInitUnicodeString( &SmpASyncKeyword, L"async" );
    RtlInitUnicodeString( &SmpAutoChkKeyword, L"autocheck" );
#if defined(REMOTE_BOOT)
    RtlInitUnicodeString( &SmpAutoFmtKeyword, L"autoformat" );
#endif // defined(REMOTE_BOOT)

    InitializeListHead( &SmpBootExecuteList );
    InitializeListHead( &SmpSetupExecuteList );
    InitializeListHead( &SmpPagingFileList );
    InitializeListHead( &SmpDosDevicesList );
    InitializeListHead( &SmpFileRenameList );
    InitializeListHead( &SmpKnownDllsList );
    InitializeListHead( &SmpExcludeKnownDllsList );
    InitializeListHead( &SmpSubSystemList );
    InitializeListHead( &SmpSubSystemsToLoad );
    InitializeListHead( &SmpSubSystemsToDefer );
    InitializeListHead( &SmpExecuteList );

    SmpPagingFileInitialize ();

    Status = RtlCreateEnvironment( TRUE, &SmpDefaultEnvironment );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to allocate default environment - Status == %X\n",
                   Status));


        SAVE_SMPINIT_STATUS (RtlCreateEnvironment, Status);
        return( Status );
        }

    RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\MiniNT" );

    InitializeObjectAttributes( &ObjectAttributes,
                                &KeyName,
                                OBJ_CASE_INSENSITIVE,
                                NULL,
                                NULL
                              );

    Status = NtOpenKey( &Key, KEY_ALL_ACCESS, &ObjectAttributes );

    if (NT_SUCCESS( Status )) {
        NtClose( Key );
        MiniNTBoot = TRUE;
    }

    if (MiniNTBoot) {
        DbgPrint("SMSS: !!! MiniNT Boot !!!\n");
    }

    //
    // before the environment is created we MUST delete the
    // safemode reg value
    //

    RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Session Manager\\Environment" );
    InitializeObjectAttributes( &ObjectAttributes,
                                &KeyName,
                                OBJ_CASE_INSENSITIVE,
                                NULL,
                                NULL
                              );
    Status = NtOpenKey( &Key, KEY_ALL_ACCESS, &ObjectAttributes );
    if (NT_SUCCESS( Status )) {
        RtlInitUnicodeString( &KeyName, L"SAFEBOOT_OPTION" );
        NtDeleteValueKey( Key, &KeyName );
        NtClose( Key );
    }

    //
    // In order to track growth in smpdefaultenvironment, make it sm's environment
    // while doing the registry groveling and then restore it
    //

    OriginalEnvironment = NtCurrentPeb()->ProcessParameters->Environment;
    NtCurrentPeb()->ProcessParameters->Environment = SmpDefaultEnvironment;

    Status = RtlQueryRegistryValues( RTL_REGISTRY_CONTROL,
                                     L"Session Manager",
                                     SmpRegistryConfigurationTable,
                                     NULL,
                                     NULL
                                   );

    SmpDefaultEnvironment = NtCurrentPeb()->ProcessParameters->Environment;
    NtCurrentPeb()->ProcessParameters->Environment = OriginalEnvironment;

    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: RtlQueryRegistryValues failed - Status == %lx\n",
                   Status));

        SAVE_SMPINIT_STATUS (RtlQueryRegistryValues, Status);
        return( Status );
        }

    Status = SmpInitializeDosDevices();
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to initialize DosDevices configuration - Status == %lx\n",
                   Status));

        SAVE_SMPINIT_STATUS (SmpInitializeDosDevices, Status);
        return( Status );
        }

    //
    // Create the root "Sessions Directory". This is the container for all session
    // specific directories. Each session specific CSRSS during startup will
    // create a <sessionid> direcotry under "\Sessions". "\Sessions\<sessionid>
    // directory will be the container for that session.
    //

    RtlInitUnicodeString( &SessionDirName, L"\\Sessions" );

    InitializeObjectAttributes( &ObjectAttributes,
                                &SessionDirName,
                                OBJ_CASE_INSENSITIVE | OBJ_OPENIF | OBJ_PERMANENT,
                                NULL,
                                SmpPrimarySecurityDescriptor
                              );

    if (!NT_SUCCESS(Status = NtCreateDirectoryObject( &SmpSessionsObjectDirectory,
                                      DIRECTORY_ALL_ACCESS,
                                      &ObjectAttributes
                                    ))) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to create %wZ object directory - Status == %lx\n",
                   &SessionDirName,
                   Status));

        SAVE_SMPINIT_STATUS (NtCreateDirectoryObject, Status);
        return Status;
    }


#if defined(REMOTE_BOOT)
    //
    // On a remote boot client, the client-side cache is already initialized.
    // We need to tell CSC not to cache database handles during the next phase
    // so that autochk can run.
    //

    if (SmpNetboot) {

        OBJECT_ATTRIBUTES ObjectAttributes;
        UNICODE_STRING RdrNameString;

        RtlInitUnicodeString( &RdrNameString, L"\\Device\\LanmanRedirector" );

        InitializeObjectAttributes(
            &ObjectAttributes,
            &RdrNameString,
            OBJ_CASE_INSENSITIVE,
            NULL,
            NULL
            );

        Status = NtCreateFile(
                    &RdrHandle,
                    GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                    &ObjectAttributes,
                    &Iosb,
                    NULL,
                    0,
                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                    FILE_OPEN,
                    FILE_SYNCHRONOUS_IO_NONALERT,
                    NULL,
                    0
                    );
        if ( !NT_SUCCESS(Status) ) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SmpLoadDataFromRegistry: Unable to open redirector: %x\n",
                       Status));

            RdrHandle = NULL;
            }
        else {

            ShadowInfo.uOp = SHADOW_CHANGE_HANDLE_CACHING_STATE;
            ShadowInfo.uStatus = FALSE;

            Status = NtDeviceIoControlFile(
                        RdrHandle,
                        NULL,
                        NULL,
                        NULL,
                        &Iosb,
                        IOCTL_DO_SHADOW_MAINTENANCE,
                        &ShadowInfo,
                        sizeof(ShadowInfo),
                        NULL,
                        0
                        );

            if ( NT_SUCCESS(Status) ) {
                Status = Iosb.Status;
                }
            if ( !NT_SUCCESS(Status) ) {
                KdPrintEx((DPFLTR_SMSS_ID,
                           DPFLTR_WARNING_LEVEL,
                           "SmpLoadDataFromRegistry: Unable to IOCTL CSC: %x\n",
                           Status));
                }
            }
        }

    Status = SmpExecuteCommandLineArguments();
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to process command line arguments - Status == %lx\n",
                   Status));

        return( Status );
        }
#endif // defined(REMOTE_BOOT)

    Head = &SmpBootExecuteList;
    while (!IsListEmpty( Head )) {
        Next = RemoveHeadList( Head );
        p = CONTAINING_RECORD( Next,
                               SMP_REGISTRY_VALUE,
                               Entry
                             );
#if SMP_SHOW_REGISTRY_DATA
        DbgPrint( "SMSS: BootExecute( %wZ )\n", &p->Name );
#endif
        SmpExecuteCommand( &p->Name, 0, NULL, 0 );
        if (p->AnsiValue)    { RtlFreeHeap( RtlProcessHeap(), 0, p->AnsiValue ); }
        if (p->Value.Buffer) { RtlFreeHeap( RtlProcessHeap(), 0, p->Value.Buffer ); }
        RtlFreeHeap( RtlProcessHeap(), 0, p );
        }

#if defined(REMOTE_BOOT)
    //
    // On a remote boot client, we can now reenable CSC handle caching.
    //

    if (SmpNetboot && (RdrHandle != NULL)) {

        ShadowInfo.uOp = SHADOW_CHANGE_HANDLE_CACHING_STATE;
        ShadowInfo.uStatus = TRUE;

        Status = NtDeviceIoControlFile(
                    RdrHandle,
                    NULL,
                    NULL,
                    NULL,
                    &Iosb,
                    IOCTL_DO_SHADOW_MAINTENANCE,
                    &ShadowInfo,
                    sizeof(ShadowInfo),
                    NULL,
                    0
                    );

        if ( NT_SUCCESS(Status) ) {
            Status = Iosb.Status;
            }
        if ( !NT_SUCCESS(Status) ) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SmpLoadDataFromRegistry: Unable to IOCTL CSC (2): %x\n",
                       Status));
            }
        }
#endif // defined(REMOTE_BOOT)

    if (!MiniNTBoot) {
        SmpProcessFileRenames();
    }

    //
    //  Begin process of verifying system DLL's
    //

    Status = SmpInitializeKnownDlls();
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to initialize KnownDll configuration - Status == %lx\n",
                   Status));

        SAVE_SMPINIT_STATUS (SmpInitializeKnownDlls, Status);
        return( Status );
        }

    //
    // Create paging files.
    //

    if (! MiniNTBoot) {

        Head = &SmpPagingFileList;

        try {

            //
            // Process the list of paging file descriptors
            // read from registry.
            //

            while (! IsListEmpty (Head)) {

                Next = RemoveHeadList (Head);

                p = CONTAINING_RECORD (Next,
                                       SMP_REGISTRY_VALUE,
                                       Entry);

                SmpCreatePagingFileDescriptor (&p->Name);


                if (p->AnsiValue)    { RtlFreeHeap( RtlProcessHeap(), 0, p->AnsiValue ); }
                if (p->Value.Buffer) { RtlFreeHeap( RtlProcessHeap(), 0, p->Value.Buffer ); }
                RtlFreeHeap (RtlProcessHeap(), 0, p);
            }

            //
            // Create any paging files specified.
            //

            SmpCreatePagingFiles();
        }
        except (SmpPagingFileExceptionFilter (_exception_code(), _exception_info())) {

            //
            // Nothing.
            //
        }
    }

    //
    // Finish registry initialization
    //

    NtInitializeRegistry(REG_INIT_BOOT_SM);

    Status = SmpCreateDynamicEnvironmentVariables( );
    if (!NT_SUCCESS( Status )) {
        
        SAVE_SMPINIT_STATUS (SmpCreateDynamicEnvironmentVariables, Status);
        return Status;
        }


    //
    // Load subsystems for the console session. Console always has
    // MuSessionId = 0
    //
    Status = SmpLoadSubSystemsForMuSession( &MuSessionId,
                 &SmpWindowsSubSysProcessId, InitialCommand );

    ASSERT(MuSessionId == 0);

    if (! NT_SUCCESS(Status)) {
        
        SAVE_SMPINIT_STATUS (SmpLoadSubSystemsForMuSession, Status);
    }

    return( Status );
}


NTSTATUS
SmpLoadSubSystemsForMuSession(
    PULONG pMuSessionId,
    PULONG_PTR pWindowsSubSysProcessId,
    PUNICODE_STRING InitialCommand )

/*++

Routine Description:

    This function starts all of the configured subsystems for the
    specified Multi-User Session.  For regular NT this routine is called once
    to start CSRSS etc. For Terminal Server, this routine is called every time
    we want to start a new Multi-User Session to start session specific subsystems

Arguments:


Return Value:

    Status of operation

--*/

{
    NTSTATUS Status = 0, Status1;
    PLIST_ENTRY Head, Next;
    PSMP_REGISTRY_VALUE p;

    //
    // Translate the system partition information stored during IoInitSystem into
    // a DOS path and store in Win32-standard location.
    //

    SmpTranslateSystemPartitionInformation();

    //
    // Second pass of execution.
    //

    Next = SmpSetupExecuteList.Flink;
    while( Next != &SmpSetupExecuteList ) {
        p = CONTAINING_RECORD( Next,
                               SMP_REGISTRY_VALUE,
                               Entry
                             );
#if SMP_SHOW_REGISTRY_DATA
        DbgPrint( "SMSS: SetupExecute( %wZ )\n", &p->Name );
#endif
        SmpExecuteCommand( &p->Name, 0, NULL, 0 );

        //
        // Note this function is reentrant and is called every time we start
        // a new Multi-User Session.
        //

        Next = Next->Flink;
    }

    Next = SmpSubSystemList.Flink;
    while ( Next != &SmpSubSystemList ) {
        p = CONTAINING_RECORD( Next,
                               SMP_REGISTRY_VALUE,
                               Entry
                             );
        if ( !_wcsicmp( p->Name.Buffer, L"Kmode" )) {
            BOOLEAN TranslationStatus;
            UNICODE_STRING FileName;
            UNICODE_STRING Win32kFileName;

            TranslationStatus = RtlDosPathNameToNtPathName_U(
                                    p->Value.Buffer,
                                    &FileName,
                                    NULL,
                                    NULL
                                    );

            if ( TranslationStatus ) {
                PVOID State;

                Status = SmpAcquirePrivilege( SE_LOAD_DRIVER_PRIVILEGE, &State );
                if (NT_SUCCESS( Status )) {


                    //
                    // Create a session space before loading any extended
                    // service table providers.  This call will create a session
                    // space for the Multi-User session. The session mananger
                    // will see the instance of the newly created session space
                    // after this call. Once session manager is done creating
                    // CSRSS and winlogon it will detach itself from this
                    // session space.
                    //

                    ASSERT( AttachedSessionId == -1 );

                    Status = NtSetSystemInformation(
                                SystemSessionCreate,
                                (PVOID)pMuSessionId,
                                sizeof(*pMuSessionId)
                                );

                    if ( !NT_SUCCESS(Status) ) {
                        KdPrintEx((DPFLTR_SMSS_ID,
                                   DPFLTR_WARNING_LEVEL,
                                   "SMSS: Session space creation failed\n"));

                        //
                        // Do not load any subsystems without SessionSpace.
                        //

                        SmpReleasePrivilege( State );
                        RtlFreeHeap(RtlProcessHeap(), 0, FileName.Buffer);
                        return( Status );
                    };

                    AttachedSessionId = *pMuSessionId;

                    RtlInitUnicodeString(&Win32kFileName,L"\\SystemRoot\\System32\\win32k.sys");

                    Status = NtSetSystemInformation(
                                SystemExtendServiceTableInformation,
                                (PVOID)&Win32kFileName,
                                sizeof(Win32kFileName)
                                );
                    RtlFreeHeap(RtlProcessHeap(), 0, FileName.Buffer);
                    SmpReleasePrivilege( State );
                    if ( !NT_SUCCESS(Status) ) {

                        //
                        // Do not load any subsystems without WIN32K!
                        //

                        KdPrintEx((DPFLTR_SMSS_ID,
                                   DPFLTR_ERROR_LEVEL,
                                   "SMSS: Load of WIN32K failed.\n"));

                        return( Status );
                        }
                    }
                else {
                    RtlFreeHeap(RtlProcessHeap(), 0, FileName.Buffer);
                    }
                }
            else {
                Status = STATUS_OBJECT_PATH_SYNTAX_BAD;
                }
            }
#if SMP_SHOW_REGISTRY_DATA
            DbgPrint( "SMSS: Unused SubSystem( %wZ = %wZ )\n", &p->Name, &p->Value );
#endif
            Next = Next->Flink;
        }

    Next = SmpSubSystemsToLoad.Flink;
    while ( Next != &SmpSubSystemsToLoad ) {
        p = CONTAINING_RECORD( Next,
                               SMP_REGISTRY_VALUE,
                               Entry
                             );
#if SMP_SHOW_REGISTRY_DATA
        DbgPrint( "SMSS: Loaded SubSystem( %wZ = %wZ )\n", &p->Name, &p->Value );
#endif
        if (!_wcsicmp( p->Name.Buffer, L"debug" )) {
            Status = SmpExecuteCommand( &p->Value, *pMuSessionId, pWindowsSubSysProcessId, SMP_SUBSYSTEM_FLAG | SMP_DEBUG_FLAG );
        }
        else {
            Status = SmpExecuteCommand( &p->Value, *pMuSessionId, pWindowsSubSysProcessId, SMP_SUBSYSTEM_FLAG );
        }

        if ( !NT_SUCCESS(Status) ) {
            DbgPrint ("SMSS: Subsystem execute failed (%WZ)\n", &p->Value);
            return( Status );
        }

        Next = Next->Flink;
    }

    Head = &SmpExecuteList;
    if ( !IsListEmpty( Head ) ) {
        Next = Head->Blink;
        p = CONTAINING_RECORD( Next,
                               SMP_REGISTRY_VALUE,
                               Entry
                             );

        *InitialCommand = p->Name;

        //
        // This path is only taken when people want to run ntsd -p -1 winlogon
        //
        // This is nearly impossible to do in a race free manner. In some
        // cases, we can get in a state where we can not properly fail
        // a debug API. This is due to the subsystem switch that occurs
        // when ntsd is invoked on csr. If csr is relatively idle, this
        // does not occur. If it is active when you attach, then we can get
        // into a potential race. The slimy fix is to do a 5 second delay
        // if the command line is anything other that the default.
        //

            {
                LARGE_INTEGER DelayTime;
                DelayTime.QuadPart = Int32x32To64( 5000, -10000 );
                NtDelayExecution(
                    FALSE,
                    &DelayTime
                    );
            }
        }
    else {
        RtlInitUnicodeString( InitialCommand, L"winlogon.exe" );
        InitialCommandBuffer[ 0 ] = UNICODE_NULL;
        Status1 = LdrQueryImageFileExecutionOptions( InitialCommand,
                                                     L"Debugger",
                                                     REG_SZ,
                                                     InitialCommandBuffer,
                                                     sizeof( InitialCommandBuffer ) - InitialCommand->Length - sizeof (WCHAR),
                                                     NULL);
        if (NT_SUCCESS (Status1) && InitialCommandBuffer[ 0 ] != UNICODE_NULL) {
            wcscat( InitialCommandBuffer, L" " );
            wcscat( InitialCommandBuffer, InitialCommand->Buffer );
            RtlInitUnicodeString( InitialCommand, InitialCommandBuffer );
        }
    }

    Next = SmpExecuteList.Flink;
    while( Next != &SmpExecuteList ) {

        //
        // We do not want to execute the last entry. It's
        // the winlogon initial command.
        //

        if( Next == SmpExecuteList.Blink ) {
            Next = Next->Flink;
            continue;
        }

        p = CONTAINING_RECORD( Next,
                               SMP_REGISTRY_VALUE,
                               Entry
                             );
#if SMP_SHOW_REGISTRY_DATA
        DbgPrint( "SMSS: Execute( %wZ )\n", &p->Name );
#endif
        SmpExecuteCommand( &p->Name, *pMuSessionId, NULL, 0 );
        Next = Next->Flink;
    }

#if SMP_SHOW_REGISTRY_DATA
    DbgPrint( "SMSS: InitialCommand( %wZ )\n", InitialCommand );
#endif

    return( Status );
}


NTSTATUS
SmpCreateDynamicEnvironmentVariables(
    VOID
    )
{
    NTSTATUS Status;
    SYSTEM_BASIC_INFORMATION SystemInfo;
    SYSTEM_PROCESSOR_INFORMATION ProcessorInfo;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyName;
    UNICODE_STRING ValueName;
    PWSTR ValueData;
    WCHAR ValueBuffer[ 256 ];
    WCHAR ValueBuffer1[ 256 ];
    PKEY_VALUE_PARTIAL_INFORMATION KeyValueInfo;
    ULONG ValueLength;
    HANDLE Key, Key1;

    Status = NtQuerySystemInformation( SystemBasicInformation,
                                       &SystemInfo,
                                       sizeof( SystemInfo ),
                                       NULL
                                     );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to query system basic information - %x\n",
                   Status));

        return Status;
        }

    Status = NtQuerySystemInformation( SystemProcessorInformation,
                                       &ProcessorInfo,
                                       sizeof( ProcessorInfo ),
                                       NULL
                                     );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to query system processor information - %x\n",
                   Status));

        return Status;
        }

    RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Session Manager\\Environment" );
    InitializeObjectAttributes( &ObjectAttributes,
                                &KeyName,
                                OBJ_CASE_INSENSITIVE,
                                NULL,
                                NULL
                              );
    Status = NtOpenKey( &Key, KEY_ALL_ACCESS, &ObjectAttributes );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to open %wZ - %x\n",
                   &KeyName,
                   Status));

        return Status;
        }

    RtlInitUnicodeString( &ValueName, L"OS" );
    ValueData = L"Windows_NT";
    Status = NtSetValueKey( Key,
                            &ValueName,
                            0,
                            REG_SZ,
                            ValueData,
                            (wcslen( ValueData ) + 1) * sizeof( WCHAR )
                          );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Failed writing %wZ environment variable - %x\n",
                   &ValueName,
                   Status));

        goto failexit;
        }

    RtlInitUnicodeString( &ValueName, L"PROCESSOR_ARCHITECTURE" );
    switch( ProcessorInfo.ProcessorArchitecture ) {
    case PROCESSOR_ARCHITECTURE_INTEL:
        ValueData = L"x86";
        break;

    case PROCESSOR_ARCHITECTURE_IA64:
        ValueData = L"IA64";
        break;

    case PROCESSOR_ARCHITECTURE_AMD64:
        ValueData = L"AMD64";
        break;

    default:
        ValueData = L"Unknown";
        break;
    }

    Status = NtSetValueKey( Key,
                            &ValueName,
                            0,
                            REG_SZ,
                            ValueData,
                            (wcslen( ValueData ) + 1) * sizeof( WCHAR )
                          );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Failed writing %wZ environment variable - %x\n",
                   &ValueName,
                   Status));

        goto failexit;
        }

    RtlInitUnicodeString( &ValueName, L"PROCESSOR_LEVEL" );
    switch( ProcessorInfo.ProcessorArchitecture ) {
    case PROCESSOR_ARCHITECTURE_INTEL:
    case PROCESSOR_ARCHITECTURE_IA64:
    case PROCESSOR_ARCHITECTURE_AMD64:
    default:
        //
        // All others use a single level number
        //
        swprintf( ValueBuffer, L"%u", ProcessorInfo.ProcessorLevel );
        break;
    }
    Status = NtSetValueKey( Key,
                            &ValueName,
                            0,
                            REG_SZ,
                            ValueBuffer,
                            (wcslen( ValueBuffer ) + 1) * sizeof( WCHAR )
                          );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Failed writing %wZ environment variable - %x\n",
                   &ValueName,
                   Status));

        goto failexit;
        }

    RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\Hardware\\Description\\System\\CentralProcessor\\0" );
    InitializeObjectAttributes( &ObjectAttributes,
                                &KeyName,
                                OBJ_CASE_INSENSITIVE,
                                NULL,
                                NULL
                              );
    Status = NtOpenKey( &Key1, KEY_READ, &ObjectAttributes );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to open %wZ - %x\n",
                   &KeyName,
                   Status));

        goto failexit;
        }
    RtlInitUnicodeString( &ValueName, L"Identifier" );
    KeyValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
    Status = NtQueryValueKey( Key1,
                              &ValueName,
                              KeyValuePartialInformation,
                              (PVOID)KeyValueInfo,
                              sizeof( ValueBuffer ),
                              &ValueLength
                             );
    if (!NT_SUCCESS( Status )) {
        NtClose( Key1 );
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to read %wZ\\%wZ - %x\n",
                   &KeyName,
                   &ValueName,
                   Status));

        goto failexit;
        }

    ValueData = (PWSTR)KeyValueInfo->Data;
    RtlInitUnicodeString( &ValueName, L"VendorIdentifier" );
    KeyValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer1;
    Status = NtQueryValueKey( Key1,
                              &ValueName,
                              KeyValuePartialInformation,
                              (PVOID)KeyValueInfo,
                              sizeof( ValueBuffer1 ),
                              &ValueLength
                             );
    NtClose( Key1 );
    if (NT_SUCCESS( Status )) {
        swprintf( ValueData + wcslen( ValueData ),
                  L", %ws",
                  (PWSTR)KeyValueInfo->Data
                );
        }

    RtlInitUnicodeString( &ValueName, L"PROCESSOR_IDENTIFIER" );
    Status = NtSetValueKey( Key,
                            &ValueName,
                            0,
                            REG_SZ,
                            ValueData,
                            (wcslen( ValueData ) + 1) * sizeof( WCHAR )
                          );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Failed writing %wZ environment variable - %x\n",
                   &ValueName,
                   Status));

        goto failexit;
        }

    RtlInitUnicodeString( &ValueName, L"PROCESSOR_REVISION" );
    switch( ProcessorInfo.ProcessorArchitecture ) {
    case PROCESSOR_ARCHITECTURE_INTEL:
        if ((ProcessorInfo.ProcessorRevision >> 8) == 0xFF) {
            //
            // Intel 386/486 are An stepping format
            //
            swprintf( ValueBuffer, L"%02x",
                      ProcessorInfo.ProcessorRevision & 0xFF
                    );
            _wcsupr( ValueBuffer );
            break;
        }

        //
        // Post-486 processors will fall through
        //

    case PROCESSOR_ARCHITECTURE_IA64:
    case PROCESSOR_ARCHITECTURE_AMD64:
        //
        // Modern X86 processors, IA64 and Amd64 use a fixed point
        // binary number.  Output is 4 hex digits, no formatting.
        //
        swprintf( ValueBuffer, L"%04x", ProcessorInfo.ProcessorRevision );
        break;

    default:
        //
        // All others use a single revision number
        //
        swprintf( ValueBuffer, L"%u", ProcessorInfo.ProcessorRevision );
        break;
    }

    Status = NtSetValueKey( Key,
                            &ValueName,
                            0,
                            REG_SZ,
                            ValueBuffer,
                            (wcslen( ValueBuffer ) + 1) * sizeof( WCHAR )
                          );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Failed writing %wZ environment variable - %x\n",
                   &ValueName,
                   Status));

        goto failexit;
        }

    RtlInitUnicodeString( &ValueName, L"NUMBER_OF_PROCESSORS" );
    swprintf( ValueBuffer, L"%u", SystemInfo.NumberOfProcessors );
    Status = NtSetValueKey( Key,
                            &ValueName,
                            0,
                            REG_SZ,
                            ValueBuffer,
                            (wcslen( ValueBuffer ) + 1) * sizeof( WCHAR )
                          );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Failed writing %wZ environment variable - %x\n",
                   &ValueName,
                   Status));

        goto failexit;
        }


    //
    // get the safeboot option
    //

    RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Safeboot\\Option" );
    InitializeObjectAttributes(
        &ObjectAttributes,
        &KeyName,
        OBJ_CASE_INSENSITIVE,
        NULL,
        NULL
        );
    Status = NtOpenKey( &Key1, KEY_ALL_ACCESS, &ObjectAttributes );
    if (NT_SUCCESS(Status)) {
        RtlInitUnicodeString( &ValueName, L"OptionValue" );
        KeyValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
        Status = NtQueryValueKey(
            Key1,
            &ValueName,
            KeyValuePartialInformation,
            (PVOID)KeyValueInfo,
            sizeof(ValueBuffer),
            &ValueLength
            );
        NtClose( Key1 );
        if (NT_SUCCESS(Status)) {
            RtlInitUnicodeString( &ValueName, L"SAFEBOOT_OPTION" );
            switch (*(PULONG)(KeyValueInfo->Data)) {
                case SAFEBOOT_MINIMAL:
                    wcscpy(ValueBuffer,SAFEBOOT_MINIMAL_STR_W);
                    break;

                case SAFEBOOT_NETWORK:
                    wcscpy(ValueBuffer,SAFEBOOT_NETWORK_STR_W);
                    break;

                case SAFEBOOT_DSREPAIR:
                    wcscpy(ValueBuffer,SAFEBOOT_DSREPAIR_STR_W);
                    break;
            }
            Status = NtSetValueKey(
                Key,
                &ValueName,
                0,
                REG_SZ,
                ValueBuffer,
                (wcslen(ValueBuffer)+1) * sizeof( WCHAR )
                );
            if (!NT_SUCCESS( Status )) {
                KdPrintEx((DPFLTR_SMSS_ID,
                           DPFLTR_WARNING_LEVEL,
                           "SMSS: Failed writing %wZ environment variable - %x\n",
                           &ValueName,
                           Status));

                goto failexit;
            }
        } else {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Failed querying safeboot option = %x\n",
                       Status));
        }
    }
    Status = STATUS_SUCCESS;

failexit:
    NtClose( Key );
    return Status;
}


NTSTATUS
SmpInitializeDosDevices( VOID )
{
    NTSTATUS Status;
    PLIST_ENTRY Head, Next;
    PSMP_REGISTRY_VALUE p;
    UNICODE_STRING UnicodeString;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE LinkHandle;
    SECURITY_DESCRIPTOR_CONTROL OriginalSdControl=0;

    //
    // Do DosDevices initialization - the directory object is created in I/O init
    //

    RtlInitUnicodeString( &UnicodeString, L"\\??" );
    InitializeObjectAttributes( &ObjectAttributes,
                                &UnicodeString,
                                OBJ_CASE_INSENSITIVE | OBJ_OPENIF | OBJ_PERMANENT,
                                NULL,
                                NULL
                              );
    Status = NtOpenDirectoryObject( &SmpDosDevicesObjectDirectory,
                                    DIRECTORY_ALL_ACCESS,
                                    &ObjectAttributes
                                    );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to open %wZ directory - Status == %lx\n",
                   &UnicodeString,
                   Status));

        return( Status );
        }


    //
    // Process the list of defined DOS devices and create their
    // associated symbolic links in the \DosDevices object directory.
    //

    Head = &SmpDosDevicesList;
    while (!IsListEmpty( Head )) {
        Next = RemoveHeadList( Head );
        p = CONTAINING_RECORD( Next,
                               SMP_REGISTRY_VALUE,
                               Entry
                             );
#if SMP_SHOW_REGISTRY_DATA
        DbgPrint( "SMSS: DosDevices( %wZ = %wZ )\n", &p->Name, &p->Value );
#endif
        InitializeObjectAttributes( &ObjectAttributes,
                                    &p->Name,
                                    OBJ_CASE_INSENSITIVE | OBJ_PERMANENT | OBJ_OPENIF,
                                    SmpDosDevicesObjectDirectory,
                                    SmpPrimarySecurityDescriptor
                                  );
        SmpSetDaclDefaulted( &ObjectAttributes, &OriginalSdControl );  //Use inheritable protection if available
        Status = NtCreateSymbolicLinkObject( &LinkHandle,
                                             SYMBOLIC_LINK_ALL_ACCESS,
                                             &ObjectAttributes,
                                             &p->Value
                                           );

        if (Status == STATUS_OBJECT_NAME_EXISTS) {
            NtMakeTemporaryObject( LinkHandle );
            NtClose( LinkHandle );
            if (p->Value.Length != 0) {
                ObjectAttributes.Attributes &= ~OBJ_OPENIF;
                Status = NtCreateSymbolicLinkObject( &LinkHandle,
                                                     SYMBOLIC_LINK_ALL_ACCESS,
                                                     &ObjectAttributes,
                                                     &p->Value
                                                   );
                }
            else {
                Status = STATUS_SUCCESS;
                }
            }
        SmpRestoreDaclDefaulted( &ObjectAttributes, OriginalSdControl );

        if (!NT_SUCCESS( Status )) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Unable to create %wZ => %wZ symbolic link object - Status == 0x%lx\n",
                       &p->Name,
                       &p->Value,
                       Status));

            return( Status );
            }

        NtClose( LinkHandle );

        if (p->AnsiValue)    { RtlFreeHeap( RtlProcessHeap(), 0, p->AnsiValue ); }
        if (p->Value.Buffer) { RtlFreeHeap( RtlProcessHeap(), 0, p->Value.Buffer ); }
        RtlFreeHeap( RtlProcessHeap(), 0, p );
        }

    return( Status );
}


VOID
SmpProcessModuleImports(
    IN PVOID Parameter,
    IN PCHAR ModuleName
    )
{
    NTSTATUS Status;
    WCHAR NameBuffer[ DOS_MAX_PATH_LENGTH ];
    UNICODE_STRING UnicodeString;
    ANSI_STRING AnsiString;
    PWSTR Name, Value;
    ULONG n;
    PWSTR s;

    //
    // Skip NTDLL.DLL as it is implicitly added to KnownDll list by kernel
    // before SMSS.EXE is started.
    //
    if (!_stricmp( ModuleName, "ntdll.dll" )) {
        return;
    }

    RtlInitAnsiString( &AnsiString, ModuleName );
    UnicodeString.Buffer = NameBuffer;
    UnicodeString.Length = 0;
    UnicodeString.MaximumLength = sizeof( NameBuffer );

    Status = RtlAnsiStringToUnicodeString( &UnicodeString, &AnsiString, FALSE );
    if (!NT_SUCCESS( Status )) {
        return;
    }
    UnicodeString.MaximumLength = (USHORT)(UnicodeString.Length + sizeof( UNICODE_NULL ));

    s = UnicodeString.Buffer;
    n = 0;
    while (n < UnicodeString.Length) {
        if (*s == L'.') {
            break;
        } else {
            n += sizeof( WCHAR );
            s += 1;
        }
    }

    Value = UnicodeString.Buffer;
    Name = UnicodeString.Buffer + (UnicodeString.MaximumLength / sizeof( WCHAR ));
    n = n / sizeof( WCHAR );

    if ((Name - Value) + n >= DOS_MAX_PATH_LENGTH) {
        return;
    }
    wcsncpy( Name, Value, n );
    Name[ n ] = UNICODE_NULL;

    Status = SmpSaveRegistryValue( (PLIST_ENTRY)&SmpKnownDllsList,
                                   Name,
                                   Value,
                                   TRUE
                                 );
    if (Status == STATUS_OBJECT_NAME_EXISTS || !NT_SUCCESS( Status )) {
        return;
    }

    return;
}


NTSTATUS
SmpInitializeKnownDlls( VOID )
{
    NTSTATUS Status;
    UNICODE_STRING DirectoryObjectName;
    PLIST_ENTRY Head, Next;
    PSMP_REGISTRY_VALUE p;

    RtlInitUnicodeString( &DirectoryObjectName, L"\\KnownDlls" );

    Status = SmpInitializeKnownDllsInternal(
        &DirectoryObjectName,
        &SmpKnownDllPath);

#ifdef _WIN64
    if (!MiniNTBoot && NT_SUCCESS(Status))
    {
        RtlInitUnicodeString( &DirectoryObjectName, L"\\KnownDlls32" );

        Status = SmpInitializeKnownDllsInternal(
            &DirectoryObjectName,
            &SmpKnownDllPath32);
    }
#endif

    Head = &SmpKnownDllsList;
    while (!IsListEmpty( Head )) {
        Next = RemoveHeadList( Head );
        p = CONTAINING_RECORD( Next,
                               SMP_REGISTRY_VALUE,
                               Entry
                             );
        if (p->AnsiValue)    { RtlFreeHeap( RtlProcessHeap(), 0, p->AnsiValue ); }
        if (p->Value.Buffer) { RtlFreeHeap( RtlProcessHeap(), 0, p->Value.Buffer ); }
        RtlFreeHeap( RtlProcessHeap(), 0, p );
        }

    return Status;
}



NTSTATUS
SmpInitializeKnownDllsInternal(
    IN PUNICODE_STRING ObjectDirectoryName,
    IN PUNICODE_STRING KnownDllPath
    )
{
    NTSTATUS Status, Status1;
    PLIST_ENTRY Head, Next;
    PSMP_REGISTRY_VALUE p;
    PSMP_REGISTRY_VALUE pExclude;
    UNICODE_STRING UnicodeString;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE LinkHandle, FileHandle, SectionHandle;
    IO_STATUS_BLOCK IoStatusBlock;
    UNICODE_STRING FileName;
    SECURITY_DESCRIPTOR_CONTROL OriginalSdControl;
    USHORT ImageCharacteristics;
    HANDLE KnownDllFileDirectory = NULL;
    HANDLE KnownDllObjectDirectory = NULL;


    FileName.Buffer = NULL;

    //
    // Create \KnownDllsxx object directory
    //

    InitializeObjectAttributes (&ObjectAttributes,
                                ObjectDirectoryName,
                                OBJ_CASE_INSENSITIVE | OBJ_OPENIF | OBJ_PERMANENT,
                                NULL,
                                SmpKnownDllsSecurityDescriptor);

    Status = NtCreateDirectoryObject (&KnownDllObjectDirectory,
                                      DIRECTORY_ALL_ACCESS,
                                      &ObjectAttributes);
    if (!NT_SUCCESS (Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to create %wZ directory - Status == %lx\n",
                   ObjectDirectoryName,
                   Status));

        return Status;
    }

    //
    // Open a handle to the file system directory that contains all the
    // known DLL files so we can do relative opens.
    //

    if (!RtlDosPathNameToNtPathName_U (KnownDllPath->Buffer,
                                       &FileName,
                                       NULL,
                                       NULL)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to to convert %wZ to an Nt path\n",
                   KnownDllPath));

        Status = STATUS_OBJECT_NAME_INVALID;
        goto exit_and_free;
    }

    InitializeObjectAttributes (&ObjectAttributes,
                                &FileName,
                                OBJ_CASE_INSENSITIVE,
                                NULL,
                                NULL);

    //
    // Open a handle to the known dll file directory. Don't allow
    // deletes of the directory.
    //

    Status = NtOpenFile (&KnownDllFileDirectory,
                         FILE_LIST_DIRECTORY | SYNCHRONIZE,
                         &ObjectAttributes,
                         &IoStatusBlock,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);

    if (!NT_SUCCESS (Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to open a handle to the KnownDll directory (%wZ) - Status == %lx\n",
                   KnownDllPath,
                   Status));

        KnownDllFileDirectory = NULL;
        goto exit_and_free;
    }

    RtlInitUnicodeString (&UnicodeString, L"KnownDllPath");
    InitializeObjectAttributes (&ObjectAttributes,
                                &UnicodeString,
                                OBJ_CASE_INSENSITIVE | OBJ_OPENIF | OBJ_PERMANENT,
                                KnownDllObjectDirectory,
                                SmpPrimarySecurityDescriptor);

    SmpSetDaclDefaulted (&ObjectAttributes, &OriginalSdControl);   //Use inheritable protection if available

    Status = NtCreateSymbolicLinkObject (&LinkHandle,
                                         SYMBOLIC_LINK_ALL_ACCESS,
                                         &ObjectAttributes,
                                         KnownDllPath);

    SmpRestoreDaclDefaulted (&ObjectAttributes, OriginalSdControl);

    if (!NT_SUCCESS (Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to create %wZ symbolic link - Status == %lx\n",
                   &UnicodeString,
                   Status));

        LinkHandle = NULL;
        goto exit_and_free;
    }

    Status1 = NtClose (LinkHandle);
    ASSERT (NT_SUCCESS (Status1));

    Head = &SmpKnownDllsList;
    Next = Head->Flink;
    while (Next != Head) {
        HANDLE ObjectDirectory;

        ObjectDirectory = NULL;
        p = CONTAINING_RECORD (Next,
                               SMP_REGISTRY_VALUE,
                               Entry);

        pExclude = SmpFindRegistryValue (&SmpExcludeKnownDllsList, p->Name.Buffer);
        if (pExclude == NULL) {
            pExclude = SmpFindRegistryValue (&SmpExcludeKnownDllsList, p->Value.Buffer);
        }

        if (pExclude != NULL) {
            Status = STATUS_OBJECT_NAME_NOT_FOUND;
        } else {
#if SMP_SHOW_REGISTRY_DATA
            DbgPrint( "SMSS: KnownDll( %wZ = %wZ )\n", &p->Name, &p->Value );
#endif
            InitializeObjectAttributes (&ObjectAttributes,
                                        &p->Value,
                                        OBJ_CASE_INSENSITIVE,
                                        KnownDllFileDirectory,
                                        NULL);

            Status = NtOpenFile (&FileHandle,
                                 SYNCHRONIZE | FILE_EXECUTE,
                                 &ObjectAttributes,
                                 &IoStatusBlock,
                                 FILE_SHARE_READ | FILE_SHARE_DELETE,
                                 FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
        }

        if (NT_SUCCESS (Status)) {

            //
            // We want the side effects of this call (import
            // callout, but don't want to checksum anymore, so supress with
            // handle tag bit
            //

            ObjectDirectory = KnownDllObjectDirectory;
            Status = LdrVerifyImageMatchesChecksum ((HANDLE)((UINT_PTR)FileHandle|1),
                                                    SmpProcessModuleImports,
                                                    Next,
                                                    &ImageCharacteristics);
            if ( Status == STATUS_IMAGE_CHECKSUM_MISMATCH ) {

                ULONG_PTR ErrorParameters;
                ULONG ErrorResponse;

                //
                // Hard error time. One of the know DLL's is corrupt !
                //

                ErrorParameters = (ULONG_PTR)(&p->Value);

                NtRaiseHardError (Status,
                                  1,
                                  1,
                                  &ErrorParameters,
                                  OptionOk,
                                  &ErrorResponse);
            } else if (ImageCharacteristics & IMAGE_FILE_DLL) {
                InitializeObjectAttributes (&ObjectAttributes,
                                            &p->Value,
                                            OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
                                            ObjectDirectory,
                                            SmpLiberalSecurityDescriptor);

                SmpSetDaclDefaulted( &ObjectAttributes, &OriginalSdControl );  //use inheritable protection if available

                Status = NtCreateSection (&SectionHandle,
                                          SECTION_ALL_ACCESS,
                                          &ObjectAttributes,
                                          NULL,
                                          PAGE_EXECUTE,
                                          SEC_IMAGE,
                                          FileHandle);

                SmpRestoreDaclDefaulted (&ObjectAttributes, OriginalSdControl);

                if (!NT_SUCCESS (Status)) {
                    KdPrintEx((DPFLTR_SMSS_ID,
                               DPFLTR_WARNING_LEVEL,
                               "SMSS: CreateSection for KnownDll %wZ failed - Status == %lx\n",
                               &p->Value,
                               Status));
                } else {
                    Status1 = NtClose (SectionHandle);
                    ASSERT (NT_SUCCESS (Status1));
                }
            } else {
                KdPrintEx((DPFLTR_SMSS_ID,
                           DPFLTR_WARNING_LEVEL,
                           "SMSS: Ignoring %wZ as KnownDll since it is not a DLL\n",
                           &p->Value));
            }

            Status1 = NtClose (FileHandle);
            ASSERT (NT_SUCCESS (Status1));
        }

        Next = Next->Flink;

        //
        // Note that section remains open. This will keep it around.
        // Maybe this should be a permenent section ?
        //
    }

    Status = STATUS_SUCCESS;

exit_and_free:

    if (KnownDllObjectDirectory != NULL) {
        Status1 = NtClose (KnownDllObjectDirectory);
        ASSERT (NT_SUCCESS (Status1));
    }

    if (KnownDllFileDirectory != NULL) {
        Status1 = NtClose (KnownDllFileDirectory);
        ASSERT (NT_SUCCESS (Status1));
    }

    if (FileName.Buffer != NULL) {
        RtlFreeHeap (RtlProcessHeap (), 0, FileName.Buffer);
    }
    return Status;
}

NTSTATUS
SmpSetProtectedFilesEnvVars(
    IN BOOLEAN SetEnvVar
    )
/*++

Routine Description:

    This function sets some environment variables that are not part of the
    default environment.  (These environment variables are normally set by
    winlogon.)  The environment variables need to be set for us to resolve
    all the environment variables in our protected files list.

    Note that SFC mirrors the data into the location below since smss can't
    get at the actual variable location

    The variables are:

    ProgramFiles
    CommonProgramFiles

    ProgramFiles(x86)
    CommonProgramFiles(x86)

Arguments:

    SetEnvVar - if TRUE, we should query the registry for this variables and
                set them.  if FALSE, we should clear the environment variables


Return Value:

    Status of operation

--*/
{
    NTSTATUS Status;
    UNICODE_STRING KeyName;
    UNICODE_STRING ValueName;
    UNICODE_STRING EnvVar;
    UNICODE_STRING EnvVarValue;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE Key;
    WCHAR ValueBuffer[VALUE_BUFFER_SIZE];
    PKEY_VALUE_PARTIAL_INFORMATION KeyValueInfo;
    ULONG ValueLength;
    ULONG Count;

    PCWSTR RegistryValues[] = {
          L"ProgramFilesDir"
        , L"CommonFilesDir"
#ifdef WX86
        , L"ProgramFilesDir(x86)"
        , L"CommonFilesDir(x86)"
#endif
    };

    PCWSTR EnvVars[] = {
          L"ProgramFiles"
        , L"CommonProgramFiles"
#ifdef WX86
        , L"ProgramFiles(x86)"
        , L"CommonProgramFiles(x86)"
#endif
    };

    #define EnvVarCount  sizeof(RegistryValues)/sizeof(PCWSTR)

    if (SetEnvVar) {


        //
        // Open the registry key.
        //

        KeyValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
        RtlInitUnicodeString(&KeyName,
                             L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Session Manager\\SFC");

        InitializeObjectAttributes(&ObjectAttributes,
                                   &KeyName,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);

        Status = NtOpenKey(&Key, KEY_READ, &ObjectAttributes);
        if (!NT_SUCCESS(Status)) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: can't open control key: 0x%x\n",
                       Status));

            return Status;
        }

        //
        // Query the key values.
        //
        for (Count = 0; Count < EnvVarCount; Count++) {

            RtlInitUnicodeString(&ValueName, RegistryValues[Count]);
            Status = NtQueryValueKey(Key,
                                     &ValueName,
                                     KeyValuePartialInformation,
                                     (PVOID)KeyValueInfo,
                                     sizeof (ValueBuffer),
                                     &ValueLength);

            ASSERT(ValueLength < VALUE_BUFFER_SIZE);

            if (!NT_SUCCESS(Status)) {
                KdPrintEx((DPFLTR_SMSS_ID,
                           DPFLTR_WARNING_LEVEL,
                           "SMSS: can't query value key %ws: 0x%x\n",
                           RegistryValues[Count],
                           Status));

            } else {


                ASSERT(KeyValueInfo->Type == REG_SZ);

                RtlInitUnicodeString(&EnvVar, EnvVars[Count]);

                EnvVarValue.Length = (USHORT)KeyValueInfo->DataLength;
                EnvVarValue.MaximumLength = (USHORT)KeyValueInfo->DataLength;
                EnvVarValue.Buffer = (PWSTR)KeyValueInfo->Data;

                Status = RtlSetEnvironmentVariable( NULL,
                                                    &EnvVar,
                                                    &EnvVarValue
                                                   );

                if (!NT_SUCCESS(Status)) {
                    KdPrintEx((DPFLTR_SMSS_ID,
                               DPFLTR_WARNING_LEVEL,
                               "SMSS: can't set environment variable %ws: 0x%x\n",
                               EnvVars[Count],
                               Status));
                }

            }

        }

        NtClose(Key);

    } else {
        //
        // clear out the variables
        //
        for (Count = 0; Count < EnvVarCount; Count++) {

            RtlInitUnicodeString(&EnvVar,      EnvVars[Count]);
            RtlInitUnicodeString(&EnvVarValue, NULL);

            Status = RtlSetEnvironmentVariable( NULL,
                                                &EnvVar,
                                                &EnvVarValue
                                               );

            if (!NT_SUCCESS(Status)) {
                KdPrintEx((DPFLTR_SMSS_ID,
                           DPFLTR_WARNING_LEVEL,
                           "SMSS: can't clear environment variable %ws: 0x%x\n",
                           EnvVars[Count],
                           Status));
            }
        }
    }

    return Status;
}

NTSTATUS
SmpGetProtectedFiles(
    OUT PPROTECT_FILE_ENTRY *Files,
    OUT PULONG FileCount,
    OUT PVOID *hModule
    )
{
    NTSTATUS Status;
    UNICODE_STRING DllName;
    STRING ProcedureName;
    PSFCGETFILES pSfcGetFiles;

	ASSERT(hModule != NULL);
    *hModule = NULL;
    RtlInitUnicodeString( &DllName, L"sfcfiles.dll" );

    Status = LdrLoadDll(
        NULL,
        NULL,
        &DllName,
        hModule
        );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: LdrLoadDll failed for %ws, ec=%lx\n",
                   DllName.Buffer,
                   Status));

        return Status;
    }

    RtlInitString( &ProcedureName, "SfcGetFiles" );

    Status = LdrGetProcedureAddress(
        *hModule,
        &ProcedureName,
        0,
        (PVOID*)&pSfcGetFiles
        );
    if (NT_SUCCESS(Status)) {
#if SMP_SHOW_REGISTRY_DATA
		DbgPrint( "SMSS: sfcfile.dll loaded successfully, address=%08x\n", *hModule );
#endif

		Status = pSfcGetFiles( Files, FileCount );
	}
	else {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: LdrGetProcedureAddress failed for %ws, ec=%lx\n",
                   ProcedureName.Buffer,
                   Status));

		LdrUnloadDll(*hModule);
		*hModule = NULL;
    }

	return Status;
}


LONG
SpecialStringCompare(
    PUNICODE_STRING s1,
    PUNICODE_STRING s2
    )
{
    UNICODE_STRING tmp;


    if (s1->Buffer[0] != L'!') {
        return RtlCompareUnicodeString( s1, s2, TRUE );
    }

    tmp.Length = s1->Length - sizeof(WCHAR);
    tmp.MaximumLength = s1->MaximumLength - sizeof(WCHAR);
    tmp.Buffer = s1->Buffer + 1;

    return RtlCompareUnicodeString( &tmp, s2, TRUE );
}


VOID
SmpProcessFileRenames( VOID )
{
    NTSTATUS Status,OpenStatus;
    PLIST_ENTRY Head, Next;
    PSMP_REGISTRY_VALUE p;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    HANDLE OldFileHandle,SetAttributesHandle;
    PFILE_RENAME_INFORMATION RenameInformation;
    FILE_DISPOSITION_INFORMATION DeleteInformation;
    FILE_INFORMATION_CLASS SetInfoClass;
    FILE_BASIC_INFORMATION BasicInfo;
    ULONG SetInfoLength;
    PVOID SetInfoBuffer;
    PWSTR s;
    BOOLEAN WasEnabled;
    UNICODE_STRING NewName;
    ULONG i;
    UNICODE_STRING ProtFileName = {0};
    UNICODE_STRING Tier2Name;
    UNICODE_STRING ProtName;
    PPROTECT_FILE_ENTRY Tier2Files;
    ULONG CountTier2Files;
    PVOID hModule = NULL;
    BOOLEAN EnvVarSet;


    Status = RtlAdjustPrivilege( SE_RESTORE_PRIVILEGE,
                                 TRUE,
                                 FALSE,
                                 &WasEnabled
                               );
    if (!NT_SUCCESS( Status )) {
        WasEnabled = TRUE;
    }

    if (SmpAllowProtectedRenames == 0) {
        Status = SmpGetProtectedFiles( &Tier2Files, &CountTier2Files, &hModule );
        if (!NT_SUCCESS( Status )) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: SmpGetProtectedFiles failed, ec=%08x\n",
                       Status));

            SmpAllowProtectedRenames = 1;
        }
    }

    //
    // our list of protected files includes environment variables that are not
    // in the default environment, they are normally set by winlogon.  Set
    // those environment variables temporarily until we process the file rename
    // section, then we can clear them out again.
    //
    EnvVarSet = TRUE;
    Status = SmpSetProtectedFilesEnvVars( TRUE );
    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: SmpSetProtectedFilesEnvVars failed, ec=%08x\n",
                   Status));

        EnvVarSet = FALSE;
    }

    //
    // Process the list of file rename operations.
    //

    Head = &SmpFileRenameList;
    while (!IsListEmpty( Head )) {
        Next = RemoveHeadList( Head );
        p = CONTAINING_RECORD( Next, SMP_REGISTRY_VALUE, Entry );

#if SMP_SHOW_REGISTRY_DATA
        DbgPrint( "SMSS: FileRename( [%wZ] => [%wZ] )\n", &p->Name, &p->Value );
#endif

        //
        // ignore any file that is protected
        //

        if (SmpAllowProtectedRenames == 0) {
            ProtName.MaximumLength = 256 * sizeof(WCHAR);
            ProtName.Buffer = (PWSTR) RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( INIT_TAG ), ProtName.MaximumLength );
            if (ProtName.Buffer) {
                for (i=0; i<CountTier2Files; i++) {
                    //
                    // if the file name is prefixed by the '@' character
                    // then we ignore the check and say the file is ok
                    //
                    if (p->Name.Buffer[0] == '@' || p->Value.Buffer[0] == L'@') {
                        break;
                    }
                    //
                    // convert the tier2 file name to an nt style file name
                    //
                    RtlInitUnicodeString(&Tier2Name,Tier2Files[i].FileName);
                    ProtName.Length = 0;
                    RtlZeroMemory( ProtName.Buffer, ProtName.MaximumLength );
                    if (ProtName.Buffer == NULL) {
                        continue;
                    }
                    Status = RtlExpandEnvironmentStrings_U(
                        NULL,
                        &Tier2Name,
                        &ProtName,
                        NULL
                        );
                    if (!NT_SUCCESS(Status)) {
                        continue;
                    }
                    if (!RtlDosPathNameToNtPathName_U( ProtName.Buffer, &ProtFileName, NULL, NULL )) {
                        continue;
                    }
                    //
                    // check for matches against both file names
                    //
                    if (SpecialStringCompare( &p->Name, &ProtFileName ) == 0 ||
                        SpecialStringCompare( &p->Value, &ProtFileName ) == 0)
                    {
                        break;
                    }
                    RtlFreeUnicodeString(&ProtFileName);
                    ProtFileName.Buffer = NULL;
                }
                RtlFreeHeap( RtlProcessHeap(), 0, ProtName.Buffer );
                if (i < CountTier2Files) {
                    if (p->Name.Buffer[0] == L'@' || p->Value.Buffer[0] == L'@') {
                    } else {
#if SMP_SHOW_REGISTRY_DATA
                        DbgPrint( "SMSS: Skipping rename because it is protected\n" );
#endif
                        //
                        // delete the source file so we don't leave any turds
                        //
                        if (p->Value.Length > 0 && ProtFileName.Buffer && SpecialStringCompare( &p->Name, &ProtFileName ) != 0) {
                            InitializeObjectAttributes(
                                &ObjectAttributes,
                                &p->Name,
                                OBJ_CASE_INSENSITIVE,
                                NULL,
                                NULL
                                );
                            Status = NtOpenFile(
                                &OldFileHandle,
                                (ACCESS_MASK)DELETE | SYNCHRONIZE,
                                &ObjectAttributes,
                                &IoStatusBlock,
                                FILE_SHARE_READ | FILE_SHARE_WRITE,
                                FILE_SYNCHRONOUS_IO_NONALERT
                                );
                            if (NT_SUCCESS( Status )) {
                                SetInfoClass = FileDispositionInformation;
                                SetInfoLength = sizeof( DeleteInformation );
                                SetInfoBuffer = &DeleteInformation;
                                DeleteInformation.DeleteFile = TRUE;
                                Status = NtSetInformationFile(
                                    OldFileHandle,
                                    &IoStatusBlock,
                                    SetInfoBuffer,
                                    SetInfoLength,
                                    SetInfoClass
                                    );
                                NtClose( OldFileHandle );
                            }
                        }
                        RtlFreeHeap( RtlProcessHeap(), 0, p );
                        RtlFreeUnicodeString(&ProtFileName);
                        ProtFileName.Buffer = NULL;
                        continue;
                    }
                } else {
#if SMP_SHOW_REGISTRY_DATA
                    DbgPrint( "SMSS: File is not in the protected list\n" );
#endif
                }
                if (ProtFileName.Buffer) {
                    RtlFreeUnicodeString(&ProtFileName);
                    ProtFileName.Buffer = NULL;
                }
            }
        }

        //
        // Open the file for delete access
        //

        if (p->Value.Length == 0 && p->Name.Buffer[0] == '@') {
            p->Name.Buffer += 1;
            p->Name.Length -= sizeof(WCHAR);
        }

        InitializeObjectAttributes(
            &ObjectAttributes,
            &p->Name,
            OBJ_CASE_INSENSITIVE,
            NULL,
            NULL
            );

        Status = NtOpenFile( &OldFileHandle,
                             (ACCESS_MASK)DELETE | SYNCHRONIZE,
                             &ObjectAttributes,
                             &IoStatusBlock,
                             FILE_SHARE_READ | FILE_SHARE_WRITE,
                             FILE_SYNCHRONOUS_IO_NONALERT
                           );
        if (NT_SUCCESS( Status )) {
            if (p->Value.Length == 0) {
                SetInfoClass = FileDispositionInformation;
                SetInfoLength = sizeof( DeleteInformation );
                SetInfoBuffer = &DeleteInformation;
                DeleteInformation.DeleteFile = TRUE;
                RenameInformation = NULL;
            } else {
                SetInfoClass = FileRenameInformation;
                SetInfoLength = p->Value.Length +
                                    sizeof( *RenameInformation );
                s = p->Value.Buffer;
                if (*s == L'!' || *s == L'@') {
                    s++;
                    SetInfoLength -= sizeof( UNICODE_NULL );
                }

                SetInfoBuffer = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( INIT_TAG ),
                                                 SetInfoLength
                                               );

                if (SetInfoBuffer != NULL) {
                    RenameInformation = SetInfoBuffer;
                    RenameInformation->ReplaceIfExists = (BOOLEAN)(s != p->Value.Buffer);
                    RenameInformation->RootDirectory = NULL;
                    RenameInformation->FileNameLength = SetInfoLength - sizeof( *RenameInformation );
                    RtlCopyMemory( RenameInformation->FileName,
                                   s,
                                   RenameInformation->FileNameLength
                                 );
                } else {
                    Status = STATUS_NO_MEMORY;
                }
            }

            if (NT_SUCCESS( Status )) {
                Status = NtSetInformationFile( OldFileHandle,
                                               &IoStatusBlock,
                                               SetInfoBuffer,
                                               SetInfoLength,
                                               SetInfoClass
                                             );
                if (!NT_SUCCESS( Status ) && SetInfoClass == FileRenameInformation && Status == STATUS_OBJECT_NAME_COLLISION && RenameInformation->ReplaceIfExists ) {
                    KdPrintEx((DPFLTR_SMSS_ID,
                               DPFLTR_WARNING_LEVEL,
                               "\nSMSS: %wZ => %wZ failed - Status == %x, Possible readonly target\n",
                               &p->Name,
                               &p->Value,
                               Status));

                    //
                    // A rename was attempted, but the source existing file is readonly.
                    // this is a problem because folks that use movefileex to do delayed
                    // renames expect this to work and can leave a machine unbootable if
                    // the rename fails
                    //

                    //
                    // Open the file for Write Attributes access
                    //

                    NewName.Length = p->Value.Length - sizeof(L'!');
                    NewName.MaximumLength = p->Value.MaximumLength - sizeof(L'!');
                    NewName.Buffer = s;;

                    InitializeObjectAttributes(
                        &ObjectAttributes,
                        &NewName,
                        OBJ_CASE_INSENSITIVE,
                        NULL,
                        NULL
                        );

                    OpenStatus = NtOpenFile( &SetAttributesHandle,
                                             (ACCESS_MASK)FILE_WRITE_ATTRIBUTES | SYNCHRONIZE,
                                             &ObjectAttributes,
                                             &IoStatusBlock,
                                             FILE_SHARE_READ | FILE_SHARE_WRITE,
                                             FILE_SYNCHRONOUS_IO_NONALERT
                                           );
                    if (NT_SUCCESS( OpenStatus )) {
                        KdPrintEx((DPFLTR_SMSS_ID,
                                   DPFLTR_INFO_LEVEL,
                                   "     SMSS: Open Existing Success\n"));

                        RtlZeroMemory(&BasicInfo,sizeof(BasicInfo));
                        BasicInfo.FileAttributes = FILE_ATTRIBUTE_NORMAL;

                        OpenStatus = NtSetInformationFile(
                                        SetAttributesHandle,
                                        &IoStatusBlock,
                                        &BasicInfo,
                                        sizeof(BasicInfo),
                                        FileBasicInformation
                                        );
                        NtClose( SetAttributesHandle );
                        if ( NT_SUCCESS(OpenStatus) ) {
                            KdPrintEx((DPFLTR_SMSS_ID,
                                       DPFLTR_INFO_LEVEL,
                                       "     SMSS: Set To NORMAL OK\n"));

                            Status = NtSetInformationFile( OldFileHandle,
                                                           &IoStatusBlock,
                                                           SetInfoBuffer,
                                                           SetInfoLength,
                                                           SetInfoClass
                                                         );

                            if ( NT_SUCCESS(Status) ) {
                                KdPrintEx((DPFLTR_SMSS_ID,
                                           DPFLTR_INFO_LEVEL,
                                           "     SMSS: Re-Rename Worked OK\n"));
                                }
                            else {
                                KdPrintEx((DPFLTR_SMSS_ID,
                                           DPFLTR_WARNING_LEVEL,
                                           "     SMSS: Re-Rename Failed - Status == %x\n",
                                           Status));
                                }
                            }
                        else {
                            KdPrintEx((DPFLTR_SMSS_ID,
                                       DPFLTR_WARNING_LEVEL,
                                       "     SMSS: Set To NORMAL Failed - Status == %x\n",
                                       OpenStatus));
                            }
                        }
                    else {
                        KdPrintEx((DPFLTR_SMSS_ID,
                                   DPFLTR_WARNING_LEVEL,
                                   "     SMSS: Open Existing file Failed - Status == %x\n",
                                   OpenStatus));
                        }
                    }
                }

            NtClose( OldFileHandle );
            }

        if (!NT_SUCCESS( Status )) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: %wZ => %wZ failed - Status == %x\n",
                       &p->Name,
                       &p->Value,
                       Status));
            }
        else
        if (p->Value.Length == 0) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_INFO_LEVEL,
                       "SMSS: %wZ (deleted)\n",
                       &p->Name ));
            }
        else {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_INFO_LEVEL,
                       "SMSS: %wZ (renamed to) %wZ\n",
                       &p->Name,
                       &p->Value ));
            }

        if (p->AnsiValue)    { RtlFreeHeap( RtlProcessHeap(), 0, p->AnsiValue ); }
        if (p->Value.Buffer) { RtlFreeHeap( RtlProcessHeap(), 0, p->Value.Buffer ); }
        RtlFreeHeap( RtlProcessHeap(), 0, p );
    }

    if (EnvVarSet) {
        SmpSetProtectedFilesEnvVars( FALSE );
    }

    if (!WasEnabled) {
        Status = RtlAdjustPrivilege( SE_RESTORE_PRIVILEGE,
                                     FALSE,
                                     FALSE,
                                     &WasEnabled
                                   );
    }

    if (hModule) {
        LdrUnloadDll( hModule );
    }

    return;
}


NTSTATUS
SmpConfigureObjectDirectories(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    )
{
    PWSTR s;
    UNICODE_STRING UnicodeString;
    UNICODE_STRING RpcControl;
    UNICODE_STRING Windows;
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE DirectoryHandle;
    PSECURITY_DESCRIPTOR SecurityDescriptor;

    UNREFERENCED_PARAMETER( Context );

    RtlInitUnicodeString( &RpcControl, L"\\RPC Control");
    RtlInitUnicodeString( &Windows, L"\\Windows");
#if SMP_SHOW_REGISTRY_DATA
    SmpDumpQuery( L"SMSS", "ObjectDirectories", ValueName, ValueType, ValueData, ValueLength );
#else
    UNREFERENCED_PARAMETER( ValueName );
    UNREFERENCED_PARAMETER( ValueType );
    UNREFERENCED_PARAMETER( ValueLength );
#endif
    s = (PWSTR)ValueData;
    while (*s) {
        RtlInitUnicodeString( &UnicodeString, s );

        //
        // This is NOT how I would choose to do this if starting from
        // scratch, but we are very close to shipping Daytona and I
        // needed to get the right protection on these objects.
        //

        SecurityDescriptor = SmpPrimarySecurityDescriptor;
        if (RtlEqualString( (PSTRING)&UnicodeString, (PSTRING)&RpcControl, TRUE ) ||
            RtlEqualString( (PSTRING)&UnicodeString, (PSTRING)&Windows, TRUE)  ) {
            SecurityDescriptor = SmpLiberalSecurityDescriptor;
        }

        InitializeObjectAttributes( &ObjectAttributes,
                                    &UnicodeString,
                                    OBJ_CASE_INSENSITIVE | OBJ_OPENIF | OBJ_PERMANENT,
                                    NULL,
                                    SecurityDescriptor
                                  );
        Status = NtCreateDirectoryObject( &DirectoryHandle,
                                          DIRECTORY_ALL_ACCESS,
                                          &ObjectAttributes
                                        );
        if (!NT_SUCCESS( Status )) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Unable to create %wZ object directory - Status == %lx\n",
                       &UnicodeString,
                       Status));
            }
        else {
            NtClose( DirectoryHandle );
            }

        while (*s++) {
            }
        }

    //
    // We dont care if the creates failed.
    //

    return( STATUS_SUCCESS );
}

NTSTATUS
SmpConfigureExecute(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    )
{
    UNREFERENCED_PARAMETER( Context );

#if SMP_SHOW_REGISTRY_DATA
    SmpDumpQuery( L"SMSS", "Execute", ValueName, ValueType, ValueData, ValueLength );
#else
    UNREFERENCED_PARAMETER( ValueName );
    UNREFERENCED_PARAMETER( ValueType );
    UNREFERENCED_PARAMETER( ValueLength );
#endif
    return (SmpSaveRegistryValue( (PLIST_ENTRY)EntryContext,
                                  ValueData,
                                  NULL,
                                  TRUE
                                )
           );
}

NTSTATUS
SmpConfigureMemoryMgmt(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    )
{
    UNREFERENCED_PARAMETER( Context );

#if SMP_SHOW_REGISTRY_DATA
    SmpDumpQuery( L"SMSS", "MemoryMgmt", ValueName, ValueType, ValueData, ValueLength );
#else
    UNREFERENCED_PARAMETER( ValueName );
    UNREFERENCED_PARAMETER( ValueType );
    UNREFERENCED_PARAMETER( ValueLength );
#endif
    return (SmpSaveRegistryValue( (PLIST_ENTRY)EntryContext,
                                  ValueData,
                                  NULL,
                                  TRUE
                                )
           );
}

NTSTATUS
SmpConfigureFileRenames(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    )
{
    NTSTATUS Status;
    static PWSTR OldName = NULL;

    UNREFERENCED_PARAMETER( Context );
#if SMP_SHOW_REGISTRY_DATA
    SmpDumpQuery( L"SMSS", "FileRenameOperation", ValueName, ValueType, ValueData, ValueLength );
#else
    UNREFERENCED_PARAMETER( ValueType );
#endif

    //
    // This routine gets called for each string in the MULTI_SZ. The
    // first string we get is the old name, the next string is the new name.
    //
    if (OldName == NULL) {
        //
        // Save a pointer to the old name, we'll need it on the next
        // callback.
        //
        OldName = ValueData;
        return(STATUS_SUCCESS);
    } else {
        Status = SmpSaveRegistryValue((PLIST_ENTRY)EntryContext,
                                      OldName,
                                      ValueData,
                                      FALSE);
        if (!NT_SUCCESS(Status)) {
#if SMP_SHOW_REGISTRY_DATA
            DbgPrint("SMSS: SmpSaveRegistryValue returned %08lx for FileRenameOperation\n", Status);
            DbgPrint("SMSS:     %ws %ws\n", OldName, ValueData);
#endif
        }
        OldName = NULL;
        return(Status);
    }
}

NTSTATUS
SmpConfigureDosDevices(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    )
{
    UNREFERENCED_PARAMETER( Context );

#if SMP_SHOW_REGISTRY_DATA
    SmpDumpQuery( L"SMSS", "DosDevices", ValueName, ValueType, ValueData, ValueLength );
#else
    UNREFERENCED_PARAMETER( ValueType );
    UNREFERENCED_PARAMETER( ValueLength );
#endif
    return (SmpSaveRegistryValue( (PLIST_ENTRY)EntryContext,
                                  ValueName,
                                  ValueData,
                                  TRUE
                                )
           );
}


NTSTATUS
SmpInitializeKnownDllPath(
    IN PUNICODE_STRING KnownDllPath,
    IN PVOID ValueData,
    IN ULONG ValueLength)
{
    KnownDllPath->Buffer = RtlAllocateHeap(
        RtlProcessHeap(),
        MAKE_TAG( INIT_TAG ),
        ValueLength);

    if (KnownDllPath->Buffer == NULL) {
        return STATUS_NO_MEMORY;
    }

    KnownDllPath->Length = (USHORT)( ValueLength - sizeof( UNICODE_NULL ) );
    KnownDllPath->MaximumLength = (USHORT)ValueLength;
    RtlCopyMemory(
        KnownDllPath->Buffer,
        ValueData,
        ValueLength);

    return STATUS_SUCCESS;
}




NTSTATUS
SmpConfigureKnownDlls(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    )
{
    UNREFERENCED_PARAMETER( Context );

#if SMP_SHOW_REGISTRY_DATA
    SmpDumpQuery( L"SMSS", "KnownDlls", ValueName, ValueType, ValueData, ValueLength );
#else
    UNREFERENCED_PARAMETER( ValueType );
#endif
    if (!_wcsicmp( ValueName, L"DllDirectory" )) {
        return SmpInitializeKnownDllPath( &SmpKnownDllPath,
                                          ValueData,
                                          ValueLength
                                        );
    }
#ifdef _WIN64
    if (!MiniNTBoot && !_wcsicmp( ValueName, L"DllDirectory32" )) {
        return SmpInitializeKnownDllPath( &SmpKnownDllPath32,
                                          ValueData,
                                          ValueLength
                                        );
    }
#endif
    else {
        return (SmpSaveRegistryValue( (PLIST_ENTRY)EntryContext,
                                      ValueName,
                                      ValueData,
                                      TRUE
                                    )
               );
        }
}

NTSTATUS
SmpConfigureExcludeKnownDlls(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    )
{
    NTSTATUS Status;
    UNREFERENCED_PARAMETER( Context );

#if SMP_SHOW_REGISTRY_DATA
    SmpDumpQuery( L"SMSS", "ExcludeKnownDlls", ValueName, ValueType, ValueData, ValueLength );
#else
    UNREFERENCED_PARAMETER( ValueType );
#endif
    if (ValueType == REG_MULTI_SZ || ValueType == REG_SZ) {
        PWSTR s;

        s = (PWSTR)ValueData;
        while (*s != UNICODE_NULL) {
            Status = SmpSaveRegistryValue( (PLIST_ENTRY)EntryContext,
                                           s,
                                           NULL,
                                           TRUE
                                         );
            if (!NT_SUCCESS( Status ) || ValueType == REG_SZ) {
                return Status;
                }

            while (*s++ != UNICODE_NULL) {
                }
            }
        }

    return( STATUS_SUCCESS );
}

NTSTATUS
SmpConfigureEnvironment(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    )
{
    NTSTATUS Status;
    UNICODE_STRING Name, Value;
    UNREFERENCED_PARAMETER( Context );
    UNREFERENCED_PARAMETER( EntryContext );

#if SMP_SHOW_REGISTRY_DATA
    SmpDumpQuery( L"SMSS", "Environment", ValueName, ValueType, ValueData, ValueLength );
#else
    UNREFERENCED_PARAMETER( ValueType );
#endif


    RtlInitUnicodeString( &Name, ValueName );
    RtlInitUnicodeString( &Value, ValueData );

    Status = RtlSetEnvironmentVariable( NULL,
                                        &Name,
                                        &Value
                                      );

    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: 'SET %wZ = %wZ' failed - Status == %lx\n",
                   &Name,
                   &Value,
                   Status));

        return( Status );
    }

    if (!_wcsicmp( ValueName, L"Path" )) {

        SmpCalledConfigEnv++;

        //
        // Check if this is the second time this function is invoked
        // This routine is called twice to resolve forward references to
        // other environment variables defined in this key
        //

        if( SmpCalledConfigEnv == 2 ) {

            SmpDefaultLibPathBuffer = RtlAllocateHeap(
                                        RtlProcessHeap(),
                                        MAKE_TAG( INIT_TAG ),
                                        ValueLength
                                        );
            if ( !SmpDefaultLibPathBuffer ) {
                return ( STATUS_NO_MEMORY );
            }

            RtlCopyMemory( SmpDefaultLibPathBuffer,
                           ValueData,
                           ValueLength
                         );

            RtlInitUnicodeString( &SmpDefaultLibPath, SmpDefaultLibPathBuffer );
        }
    }

    return( STATUS_SUCCESS );
}

NTSTATUS
SmpConfigureSubSystems(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    )
{

    UNREFERENCED_PARAMETER( Context );

#if SMP_SHOW_REGISTRY_DATA
    SmpDumpQuery( L"SMSS", "SubSystems", ValueName, ValueType, ValueData, ValueLength );
#else
    UNREFERENCED_PARAMETER( ValueLength );
#endif

    if (!_wcsicmp( ValueName, L"Required" ) || !_wcsicmp( ValueName, L"Optional" )) {
        if (ValueType == REG_MULTI_SZ) {
            //
            // Here if processing Required= or Optional= values, since they are
            // the only REG_MULTI_SZ value types under the SubSystem key.
            //
            PSMP_REGISTRY_VALUE p;
            PWSTR s;

            s = (PWSTR)ValueData;
            while (*s != UNICODE_NULL) {
                p = SmpFindRegistryValue( (PLIST_ENTRY)EntryContext,
                                          s
                                        );
                if (p != NULL) {
                    RemoveEntryList( &p->Entry );


                    //
                    // Required Subsystems are loaded. Optional subsystems are
                    // defered.
                    //

                    if (!_wcsicmp( ValueName, L"Required" ) ) {
                        InsertTailList( &SmpSubSystemsToLoad, &p->Entry );
                        }
                    else {
                        InsertTailList( &SmpSubSystemsToDefer, &p->Entry );
                        }
                    }
                else {
                    KdPrintEx((DPFLTR_SMSS_ID,
                               DPFLTR_WARNING_LEVEL,
                               "SMSS: Invalid subsystem name - %ws\n",
                               s));
                    }

                while (*s++ != UNICODE_NULL) {
                    }
                }
            }

        return( STATUS_SUCCESS );
        }
    else if (!_wcsicmp( ValueName, L"PosixSingleInstance" ) &&
        (ValueType == REG_DWORD)) {
        RegPosixSingleInstance = TRUE;
#if 0
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_INFO_LEVEL,
                   "SMSS: Single Instance Posix Subsystem Configured\n"));
#endif
        return( STATUS_SUCCESS );
    }
    else {
        return (SmpSaveRegistryValue( (PLIST_ENTRY)EntryContext,
                                      ValueName,
                                      ValueData,
                                      TRUE
                                    )
               );
        }
}


NTSTATUS
SmpParseToken(
    IN PUNICODE_STRING Source,
    IN BOOLEAN RemainderOfSource,
    OUT PUNICODE_STRING Token
    )
{
    PWSTR s, s1;
    ULONG i, cb;

    RtlInitUnicodeString( Token, NULL );
    s = Source->Buffer;
    if (Source->Length == 0) {
        return( STATUS_SUCCESS );
    }

    i = 0;
    while ((USHORT)i < Source->Length && *s <= L' ') {
        s++;
        i += 2;
    }

    if (RemainderOfSource) {
        cb = Source->Length - (i * sizeof( WCHAR ));
        s1 = (PWSTR)((PCHAR)s + cb);
        i = Source->Length / sizeof( WCHAR );
    } else {
        s1 = s;
        while ((USHORT)i < Source->Length && *s1 > L' ') {
            s1++;
            i += 2;
        }
        cb = (ULONG)((PCHAR)s1 - (PCHAR)s);
        while ((USHORT)i < Source->Length && *s1 <= L' ') {
            s1++;
            i += 2;
        }
    }

    if (cb > 0) {
        Token->Buffer = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( INIT_TAG ), cb + sizeof( UNICODE_NULL ) );
        if (Token->Buffer == NULL) {
            return( STATUS_NO_MEMORY );
        }

        Token->Length = (USHORT)cb;
        Token->MaximumLength = (USHORT)(cb + sizeof( UNICODE_NULL ));
        RtlCopyMemory( Token->Buffer, s, cb );
        Token->Buffer[ cb / sizeof( WCHAR ) ] = UNICODE_NULL;
    }

    Source->Length -= (USHORT)((PCHAR)s1 - (PCHAR)Source->Buffer);
    Source->Buffer = s1;
    return( STATUS_SUCCESS );
}


NTSTATUS
SmpParseCommandLine(
    IN PUNICODE_STRING CommandLine,
    OUT PULONG Flags OPTIONAL,
    OUT PUNICODE_STRING ImageFileName,
    OUT PUNICODE_STRING ImageFileDirectory,
    OUT PUNICODE_STRING Arguments
    )
{
    NTSTATUS Status;
    UNICODE_STRING Input, Token;
    UNICODE_STRING PathVariableName;
    UNICODE_STRING PathVariableValue;
    PWSTR DosFilePart;
    WCHAR FullDosPathBuffer[ DOS_MAX_PATH_LENGTH ];
    ULONG SpResult;

    RtlInitUnicodeString( ImageFileName, NULL );
    RtlInitUnicodeString( Arguments, NULL );

    if (ARGUMENT_PRESENT( ImageFileDirectory )) {
        RtlInitUnicodeString( ImageFileDirectory, NULL );
        }

    //
    // make sure lib path has systemroot\system32. Otherwise, the system will
    // not boot properly
    //

    if ( !SmpSystemRoot.Length ) {
        UNICODE_STRING NewLibString;

        RtlInitUnicodeString( &SmpSystemRoot,USER_SHARED_DATA->NtSystemRoot );


        NewLibString.Length = 0;
        NewLibString.MaximumLength =
            SmpSystemRoot.MaximumLength +
            20 +                          // length of \system32;
            SmpDefaultLibPath.MaximumLength;

        NewLibString.Buffer = RtlAllocateHeap(
                                RtlProcessHeap(),
                                MAKE_TAG( INIT_TAG ),
                                NewLibString.MaximumLength
                                );

        if ( NewLibString.Buffer ) {
            RtlAppendUnicodeStringToString(&NewLibString,&SmpSystemRoot );
            RtlAppendUnicodeToString(&NewLibString,L"\\system32;");
            RtlAppendUnicodeStringToString(&NewLibString,&SmpDefaultLibPath );

            RtlFreeHeap(RtlProcessHeap(), 0, SmpDefaultLibPath.Buffer );

            SmpDefaultLibPath = NewLibString;
            }
        }

    Input = *CommandLine;
    while (TRUE) {
        Status = SmpParseToken( &Input, FALSE, &Token );
        if (!NT_SUCCESS( Status ) || Token.Buffer == NULL) {
            return( STATUS_UNSUCCESSFUL );
            }

        if (ARGUMENT_PRESENT( Flags )) {
            if (RtlEqualUnicodeString( &Token, &SmpDebugKeyword, TRUE )) {
                *Flags |= SMP_DEBUG_FLAG;
                RtlFreeHeap( RtlProcessHeap(), 0, Token.Buffer );
                continue;
                }
            else
            if (RtlEqualUnicodeString( &Token, &SmpASyncKeyword, TRUE )) {
                *Flags |= SMP_ASYNC_FLAG;
                RtlFreeHeap( RtlProcessHeap(), 0, Token.Buffer );
                continue;
                }
            else
            if (RtlEqualUnicodeString( &Token, &SmpAutoChkKeyword, TRUE )) {
                *Flags |= SMP_AUTOCHK_FLAG;
                RtlFreeHeap( RtlProcessHeap(), 0, Token.Buffer );
                continue;
                }
#if defined(REMOTE_BOOT)
            else
            if (RtlEqualUnicodeString( &Token, &SmpAutoFmtKeyword, TRUE )) {
                *Flags |= SMP_AUTOFMT_FLAG;
                RtlFreeHeap( RtlProcessHeap(), 0, Token.Buffer );
                continue;
                }
#endif // defined(REMOTE_BOOT)
            }

        SpResult = 0;
        RtlInitUnicodeString( &PathVariableName, L"Path" );
        PathVariableValue.Length = 0;
        PathVariableValue.MaximumLength = 4096;
        PathVariableValue.Buffer = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( INIT_TAG ),
                                                    PathVariableValue.MaximumLength
                                                  );
        if (PathVariableValue.Buffer == NULL) {
           RtlFreeHeap( RtlProcessHeap(), 0, Token.Buffer );
           return STATUS_INSUFFICIENT_RESOURCES;
        }

        Status = RtlQueryEnvironmentVariable_U( SmpDefaultEnvironment,
                                                &PathVariableName,
                                                &PathVariableValue
                                              );
        if ( Status == STATUS_BUFFER_TOO_SMALL ) {
            RtlFreeHeap( RtlProcessHeap(), 0, PathVariableValue.Buffer );
            PathVariableValue.MaximumLength = PathVariableValue.Length + 2;
            PathVariableValue.Length = 0;
            PathVariableValue.Buffer = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( INIT_TAG ),
                                                        PathVariableValue.MaximumLength
                                                      );
           if (PathVariableValue.Buffer == NULL) {
               RtlFreeHeap( RtlProcessHeap(), 0, Token.Buffer );
               return STATUS_INSUFFICIENT_RESOURCES;
           }

            Status = RtlQueryEnvironmentVariable_U( SmpDefaultEnvironment,
                                                    &PathVariableName,
                                                    &PathVariableValue
                                                  );
            }
        if (!NT_SUCCESS( Status )) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: %wZ environment variable not defined.\n",
                       &PathVariableName));

            Status = STATUS_OBJECT_NAME_NOT_FOUND;
            }
        else
        if (!ARGUMENT_PRESENT( Flags ) ||
#pragma prefast(suppress: 209, "This *does* take a byte count--not a character count")
            !(SpResult = RtlDosSearchPath_U( PathVariableValue.Buffer,
                                 Token.Buffer,
                                 L".exe",
                                 sizeof( FullDosPathBuffer ),
                                 FullDosPathBuffer,
                                 &DosFilePart
                               ))
           ) {
            if (!ARGUMENT_PRESENT( Flags )) {
                wcscpy( FullDosPathBuffer, Token.Buffer );
                }
            else {

                if ( !SpResult ) {

                    //
                    // The search path call failed. Now try the call again using
                    // the default lib path. This always has systemroot\system32
                    // at the front.
                    //
#pragma prefast(suppress: 209, "This *does* take a byte count--not a character count")
                    SpResult = RtlDosSearchPath_U(
                                 SmpDefaultLibPath.Buffer,
                                 Token.Buffer,
                                 L".exe",
                                 sizeof( FullDosPathBuffer ),
                                 FullDosPathBuffer,
                                 &DosFilePart
                               );
                    }
                if ( !SpResult ) {
                    *Flags |= SMP_IMAGE_NOT_FOUND;
                    *ImageFileName = Token;
                    RtlFreeHeap( RtlProcessHeap(), 0, PathVariableValue.Buffer );
                    return( STATUS_SUCCESS );
                    }
                }
            }

        RtlFreeHeap( RtlProcessHeap(), 0, Token.Buffer );
        RtlFreeHeap( RtlProcessHeap(), 0, PathVariableValue.Buffer );
        if (NT_SUCCESS( Status ) &&
            !RtlDosPathNameToNtPathName_U( FullDosPathBuffer,
                                           ImageFileName,
                                           NULL,
                                           NULL
                                         )
           ) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Unable to translate %ws into an NT File Name\n",
                       FullDosPathBuffer));

            Status = STATUS_OBJECT_PATH_INVALID;
            }

        if (!NT_SUCCESS( Status )) {
            return( Status );
            }

        if (ARGUMENT_PRESENT( ImageFileDirectory )) {
            if (DosFilePart > FullDosPathBuffer) {
                *--DosFilePart = UNICODE_NULL;
                RtlCreateUnicodeString( ImageFileDirectory,
                                        FullDosPathBuffer
                                      );
                }
            else {
                RtlInitUnicodeString( ImageFileDirectory, NULL );
                }
            }

        break;
        }

    Status = SmpParseToken( &Input, TRUE, Arguments );
    return( Status );
}


ULONG
SmpConvertInteger(
    IN PWSTR String
    )
{
    NTSTATUS Status;
    UNICODE_STRING UnicodeString;
    ULONG Value;

    RtlInitUnicodeString( &UnicodeString, String );
    Status = RtlUnicodeStringToInteger( &UnicodeString, 0, &Value );
    if (NT_SUCCESS( Status )) {
        return( Value );
        }
    else {
        return( 0 );
        }
}


NTSTATUS
SmpExecuteImage(
    IN PUNICODE_STRING ImageFileName,
    IN PUNICODE_STRING CurrentDirectory,
    IN PUNICODE_STRING CommandLine,
    IN ULONG MuSessionId,
    IN ULONG Flags,
    IN OUT PRTL_USER_PROCESS_INFORMATION ProcessInformation OPTIONAL
    )

/*++

Routine Description:

    This function creates and starts a process specified by the
    CommandLine parameter.  After starting the process, the procedure
    will optionally wait for the first thread in the process to
    terminate.

Arguments:

    ImageFileName - Supplies the full NT path for the image file to
        execute.  Presumably computed or extracted from the first
        token of the CommandLine.

    CommandLine - Supplies the command line to execute.  The first blank
        separate token on the command line must be a fully qualified NT
        Path name of an image file to execute.

    Flags - Supplies information about how to invoke the command.

    ProcessInformation - Optional parameter, which if specified, receives
        information for images invoked with the SMP_ASYNC_FLAG.  Ignore
        if this flag is not set.

Return Value:

    Status of operation

--*/

{
    NTSTATUS Status;
    RTL_USER_PROCESS_INFORMATION MyProcessInformation;
    PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
#if 0
    BOOLEAN ImageWhacked;
#endif
    if (!ARGUMENT_PRESENT( ProcessInformation )) {
        ProcessInformation = &MyProcessInformation;
        }


#if 0
    //
    // this seems to break setup's sense of what SystemRoot is
    ImageWhacked = FALSE;
    if ( ImageFileName && ImageFileName->Length > 8 ) {
        if (    ImageFileName->Buffer[0] == L'\\'
            &&  ImageFileName->Buffer[1] == L'?'
            &&  ImageFileName->Buffer[2] == L'?'
            &&  ImageFileName->Buffer[3] == L'\\' ) {
            ImageWhacked = TRUE;
            ImageFileName->Buffer[1] = L'\\';
            }
        }
#endif

    Status = RtlCreateProcessParameters( &ProcessParameters,
                                         ImageFileName,
                                         (SmpDefaultLibPath.Length == 0 ?
                                                   NULL : &SmpDefaultLibPath
                                         ),
                                         CurrentDirectory,
                                         CommandLine,
                                         SmpDefaultEnvironment,
                                         NULL,
                                         NULL,
                                         NULL,
                                         NULL
                                       );

#if 0
    if ( ImageWhacked ) {
        ImageFileName->Buffer[1] = L'?';
        }
#endif

    ASSERTMSG( "RtlCreateProcessParameters", NT_SUCCESS( Status ) );
    if ( !NT_SUCCESS( Status ) ) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: RtlCreateProcessParameters failed for %wZ - Status == %lx\n",
                   ImageFileName,
                   Status));

        return( Status );
    }
    if (Flags & SMP_DEBUG_FLAG) {
        ProcessParameters->DebugFlags = TRUE;
        }
    else {
        ProcessParameters->DebugFlags = SmpDebug;
        }

    if ( Flags & SMP_SUBSYSTEM_FLAG ) {
        ProcessParameters->Flags |= RTL_USER_PROC_RESERVE_1MB;
        }

    ProcessInformation->Length = sizeof( RTL_USER_PROCESS_INFORMATION );
    Status = RtlCreateUserProcess( ImageFileName,
                                   OBJ_CASE_INSENSITIVE,
                                   ProcessParameters,
                                   NULL,
                                   NULL,
                                   NULL,
                                   FALSE,
                                   NULL,
                                   NULL,
                                   ProcessInformation
                                 );
    RtlDestroyProcessParameters( ProcessParameters );

    if ( !NT_SUCCESS( Status ) ) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Failed load of %wZ - Status  == %lx\n",
                   ImageFileName,
                   Status));

        return( Status );
        }

    //
    // Set the MuSessionId in the PEB of the new process.
    //

    Status = SmpSetProcessMuSessionId( ProcessInformation->Process, MuSessionId );

    if (!(Flags & SMP_DONT_START)) {
        if (ProcessInformation->ImageInformation.SubSystemType !=
            IMAGE_SUBSYSTEM_NATIVE
           ) {
            NtTerminateProcess( ProcessInformation->Process,
                                STATUS_INVALID_IMAGE_FORMAT
                              );
            NtWaitForSingleObject( ProcessInformation->Thread, FALSE, NULL );
            NtClose( ProcessInformation->Thread );
            NtClose( ProcessInformation->Process );
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Not an NT image - %wZ\n",
                       ImageFileName));

            return( STATUS_INVALID_IMAGE_FORMAT );
            }

        NtResumeThread( ProcessInformation->Thread, NULL );

        if (!(Flags & SMP_ASYNC_FLAG)) {
            NtWaitForSingleObject( ProcessInformation->Thread, FALSE, NULL );
            }

        NtClose( ProcessInformation->Thread );
        NtClose( ProcessInformation->Process );
        }

    return( Status );
}


NTSTATUS
SmpExecuteCommand(
    IN PUNICODE_STRING CommandLine,
    IN ULONG MuSessionId,
    OUT PULONG_PTR pWindowsSubSysProcessId,
    IN ULONG Flags
    )
/*++

Routine Description:

    This function is called to execute a command.

    The format of CommandLine is:

        Nt-Path-To-AutoChk.exe Nt-Path-To-Disk-Partition

    If the NT path to the disk partition is an asterisk, then invoke
    the AutoChk.exe utility on all hard disk partitions.

#if defined(REMOTE_BOOT)
                      -or-

        Nt-Path-To-AutoFmt.exe Nt-Path-To-Disk-Partition
#endif // defined(REMOTE_BOOT)

Arguments:

    CommandLine - Supplies the Command line to invoke.

    Flags - Specifies the type of command and options.

Return Value:

    Status of operation

--*/
{
    NTSTATUS Status;
    UNICODE_STRING ImageFileName;
    UNICODE_STRING CurrentDirectory;
    UNICODE_STRING Arguments;

    if (Flags & SMP_DEBUG_FLAG) {
        return( STATUS_SUCCESS );
    }

    Status = SmpParseCommandLine( CommandLine,
                                  &Flags,
                                  &ImageFileName,
                                  &CurrentDirectory,
                                  &Arguments
                                );

    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: SmpParseCommand( %wZ ) failed - Status == %lx\n",
                   CommandLine,
                   Status));

        return( Status );
        }

    if (Flags & SMP_AUTOCHK_FLAG) {
        Status = SmpInvokeAutoChk( &ImageFileName, &CurrentDirectory, &Arguments, Flags );
        }
#if defined(REMOTE_BOOT)
    else
    if (Flags & SMP_AUTOFMT_FLAG) {
        Status = SmpInvokeAutoFmt( &ImageFileName, &CurrentDirectory, &Arguments, Flags );
        }
#endif // defined(REMOTE_BOOT)
    else
    if (Flags & SMP_SUBSYSTEM_FLAG) {
        Status = SmpLoadSubSystem( &ImageFileName, &CurrentDirectory, CommandLine, MuSessionId, pWindowsSubSysProcessId, Flags );
        }
    else {
        if (Flags & SMP_IMAGE_NOT_FOUND) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Image file (%wZ) not found\n",
                       &ImageFileName));

            Status = STATUS_OBJECT_NAME_NOT_FOUND;
            }
        else {
            Status = SmpExecuteImage( &ImageFileName,
                                      &CurrentDirectory,
                                      CommandLine,
                                      MuSessionId,
                                      Flags,
                                      NULL
                                    );
            }
        }

    // ImageFileName may be returned even
    // when SMP_IMAGE_NOT_FOUND flag is set
    if (ImageFileName.Buffer) {
        RtlFreeHeap( RtlProcessHeap(), 0, ImageFileName.Buffer );
        if (CurrentDirectory.Buffer != NULL) {
            RtlFreeHeap( RtlProcessHeap(), 0, CurrentDirectory.Buffer );
            }
        }

    if (Arguments.Buffer) {
        RtlFreeHeap( RtlProcessHeap(), 0, Arguments.Buffer );
        }

    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Command '%wZ' failed - Status == %x\n",
                   CommandLine,
                   Status));
        }

    return( Status );
}

BOOLEAN
SmpSaveAndClearBootStatusData(
    OUT PBOOLEAN BootOkay,
    OUT PBOOLEAN ShutdownOkay
    )
/*++

Routine Description:

    This routine saves the boot status flags in the boot status data and then
    sets the data file to indicate a successful boot and shutdown.  This is 
    used to avoid triggering auto-recovery in the loader if autoconvert or 
    autochk reboots the machine as part of its run.  
    
    The caller is responsible for calling SmpRestoreBootStatusData if the 
    auto* program allows boot to continue.

Arguments:

    BootOkay - the status of the boot
    
    ShutdownOkay - the status of the shutdown    

Return Value:

    TRUE if the values were saved and should be restored.
    FALSE if an error occurred and no values were saved.
    
--*/        
{
    NTSTATUS Status;

    PVOID BootStatusDataHandle;

    *BootOkay = FALSE;
    *ShutdownOkay = FALSE;

    Status = RtlLockBootStatusData(&BootStatusDataHandle);
    
    if(NT_SUCCESS(Status)) {

        BOOLEAN t = TRUE;

        RtlGetSetBootStatusData(BootStatusDataHandle,
                                TRUE,
                                RtlBsdItemBootGood,
                                BootOkay,
                                sizeof(BOOLEAN),
                                NULL);

        RtlGetSetBootStatusData(BootStatusDataHandle,
                                TRUE,
                                RtlBsdItemBootShutdown,
                                ShutdownOkay,
                                sizeof(BOOLEAN),
                                NULL);

        RtlGetSetBootStatusData(BootStatusDataHandle,
                                FALSE,
                                RtlBsdItemBootGood,
                                &t,
                                sizeof(BOOLEAN),
                                NULL);

        RtlGetSetBootStatusData(BootStatusDataHandle,
                                FALSE,
                                RtlBsdItemBootShutdown,
                                &t,
                                sizeof(BOOLEAN),
                                NULL);

        RtlUnlockBootStatusData(BootStatusDataHandle);

        return TRUE;
    }

    return FALSE;
}

VOID
SmpRestoreBootStatusData(
    IN BOOLEAN BootOkay,
    IN BOOLEAN ShutdownOkay
    )
/*++

Routine Description:

    This routine restores the boot status flags in the boot status data to
    the provided values.
    
Arguments:

    BootOkay - the status of the boot
    
    ShutdownOkay - the status of the shutdown    

Return Value:

    none.
    
--*/        
{
    NTSTATUS Status;

    PVOID BootStatusDataHandle;

    Status = RtlLockBootStatusData(&BootStatusDataHandle);
    
    if(NT_SUCCESS(Status)) {

        RtlGetSetBootStatusData(BootStatusDataHandle,
                                FALSE,
                                RtlBsdItemBootGood,
                                &BootOkay,
                                sizeof(BOOLEAN),
                                NULL);

        RtlGetSetBootStatusData(BootStatusDataHandle,
                                FALSE,
                                RtlBsdItemBootShutdown,
                                &ShutdownOkay,
                                sizeof(BOOLEAN),
                                NULL);

        RtlUnlockBootStatusData(BootStatusDataHandle);
    }

    return;
}


NTSTATUS
SmpInvokeAutoChk(
    IN PUNICODE_STRING ImageFileName,
    IN PUNICODE_STRING CurrentDirectory,
    IN PUNICODE_STRING Arguments,
    IN ULONG Flags
    )
{
    NTSTATUS Status;

    CHAR DisplayBuffer[ MAXIMUM_FILENAME_LENGTH ];
    ANSI_STRING AnsiDisplayString;
    UNICODE_STRING DisplayString;

    UNICODE_STRING CmdLine;
    WCHAR CmdLineBuffer[ 2 * MAXIMUM_FILENAME_LENGTH ];

    BOOLEAN BootStatusDataSaved = FALSE;
    BOOLEAN BootOkay;
    BOOLEAN ShutdownOkay;

    //
    // Query the system environment variable "osloadoptions" to determine
    // if SOS is specified.  What for though?  No one is using it.
    //

    if (SmpQueryRegistrySosOption() != FALSE) {
        SmpEnableDots = FALSE;
    }

    if (Flags & SMP_IMAGE_NOT_FOUND) {
        sprintf( DisplayBuffer,
                 "%wZ program not found - skipping AUTOCHECK\n",
                 ImageFileName
               );

        RtlInitAnsiString( &AnsiDisplayString, DisplayBuffer );
        Status = RtlAnsiStringToUnicodeString( &DisplayString,
                                               &AnsiDisplayString,
                                               TRUE
                                             );
        if (NT_SUCCESS( Status )) {
            NtDisplayString( &DisplayString );
            RtlFreeUnicodeString( &DisplayString );
            }

        return( STATUS_SUCCESS );
        }

    //
    // Save away the boot & shutdown status flags in the boot status data 
    // and restore them after autochk returns.  This way if autochk forces
    // a reboot the loader won't put up the autorecovery menu.
    //

    BootStatusDataSaved = SmpSaveAndClearBootStatusData(&BootOkay,
                                                        &ShutdownOkay);

    CmdLine.Buffer = CmdLineBuffer;
    CmdLine.MaximumLength = sizeof( CmdLineBuffer );
    CmdLine.Length = 0;
    RtlAppendUnicodeStringToString( &CmdLine, ImageFileName );
    RtlAppendUnicodeToString( &CmdLine, L" " );
    RtlAppendUnicodeStringToString( &CmdLine, Arguments );
    SmpExecuteImage( ImageFileName,
                     CurrentDirectory,
                     &CmdLine,
                     0,          // MuSessionId
                     Flags & ~SMP_AUTOCHK_FLAG,
                     NULL
                   );

    //
    // If autochk doesn't shut us down then we end up back here.  Restore the 
    // values we saved.
    //

    if(BootStatusDataSaved) {
        SmpRestoreBootStatusData(BootOkay, ShutdownOkay);
    }

    return( STATUS_SUCCESS );
}

#if defined(REMOTE_BOOT)
NTSTATUS
SmpInvokeAutoFmt(
    IN PUNICODE_STRING ImageFileName,
    IN PUNICODE_STRING CurrentDirectory,
    IN PUNICODE_STRING Arguments,
    IN ULONG Flags
    )
{
    NTSTATUS Status;
    CHAR DisplayBuffer[ MAXIMUM_FILENAME_LENGTH ];
    ANSI_STRING AnsiDisplayString;
    UNICODE_STRING DisplayString;
    UNICODE_STRING CmdLine;
    WCHAR CmdLineBuffer[ 2 * MAXIMUM_FILENAME_LENGTH ];

    BOOLEAN BootStatusDataSaved;
    BOOLEAN BootOkay;
    BOOLEAN ShutdownOkay;

    //
    // Query the system environment variable "osloadoptions" to determine
    // if SOS is specified.
    //

    if (SmpQueryRegistrySosOption() != FALSE) {
        SmpEnableDots = FALSE;
    }

    if (Flags & SMP_IMAGE_NOT_FOUND) {
        sprintf( DisplayBuffer,
                 "%wZ program not found - skipping AUTOFMT\n",
                 ImageFileName
               );

        RtlInitAnsiString( &AnsiDisplayString, DisplayBuffer );
        Status = RtlAnsiStringToUnicodeString( &DisplayString,
                                               &AnsiDisplayString,
                                               TRUE
                                             );
        if (NT_SUCCESS( Status )) {
            NtDisplayString( &DisplayString );
            RtlFreeUnicodeString( &DisplayString );
            }

        return( STATUS_SUCCESS );
        }

    BootStatusDataSaved = SmpSaveAndClearBootStatusData(&BootOkay,
                                                        &ShutdownOkay);

    CmdLine.Buffer = CmdLineBuffer;
    CmdLine.MaximumLength = sizeof( CmdLineBuffer );
    CmdLine.Length = 0;
    RtlAppendUnicodeStringToString( &CmdLine, ImageFileName );
    RtlAppendUnicodeToString( &CmdLine, L" " );
    RtlAppendUnicodeStringToString( &CmdLine, Arguments );

    SmpExecuteImage( ImageFileName,
                     CurrentDirectory,
                     &CmdLine,
                     0, //Console MuSessionId
                     Flags & ~SMP_AUTOFMT_FLAG,
                     NULL
                   );

    if(BootStatusDataSaved) {
        SmpRestoreBootStatusData(BootOkay, ShutdownOkay);
    }

    return( STATUS_SUCCESS );
}
#endif // defined(REMOTE_BOOT)


NTSTATUS
SmpLoadSubSystem(
    IN PUNICODE_STRING ImageFileName,
    IN PUNICODE_STRING CurrentDirectory,
    IN PUNICODE_STRING CommandLine,
    IN ULONG MuSessionId,
    OUT PULONG_PTR pWindowsSubSysProcessId,
    IN ULONG Flags
    )

/*++

Routine Description:

    This function loads and starts the specified system service
    emulation subsystem. The system freezes until the loaded subsystem
    completes the subsystem connection protocol by connecting to SM,
    and then accepting a connection from SM.

    For terminal server, the subsystem is started by csrss so that the
    correct session is used.

Arguments:

    CommandLine - Supplies the command line to execute the subsystem.

Return Value:

    TBD

--*/

{
    NTSTATUS Status;
    RTL_USER_PROCESS_INFORMATION ProcessInformation;
    PSMPKNOWNSUBSYS KnownSubSys = NULL;
    PSMPKNOWNSUBSYS TargetSubSys = NULL;
    PSMPKNOWNSUBSYS CreatorSubSys = NULL;
    LARGE_INTEGER Timeout;
    ULONG SubsysMuSessionId = MuSessionId;
    PVOID State;
    NTSTATUS AcquirePrivilegeStatus = STATUS_SUCCESS;

    if (Flags & SMP_IMAGE_NOT_FOUND) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to find subsystem - %wZ\n",
                   ImageFileName));

        return( STATUS_OBJECT_NAME_NOT_FOUND );
        }

    //
    // Check for single instance POSIX subsystem
    //
    if (Flags & SMP_POSIX_SI_FLAG) {
        // Run only one copy using the console Logon Id
        SubsysMuSessionId = 0;
    }

    //
    // There is a race condition on hydra loading subsystems. Two
    // requests can be received from the same MuSessionId to load
    // the same subsystem. There is a window in hydra since the
    // ImageType == 0xFFFFFFFF until the newly started subsystem connects
    // back. Non-hydra didn't have this problem since the optional
    // subsystem entry was destroyed once started. Hydra does not do this
    // since multiple sessions may want to start an optional subsystem.
    //
    // To close this window, on hydra this value is looked up based on
    // the MuSessionId to see if any subsystems are starting.
    // If so, we wait for the Active event. We can then
    // run our checks for the subsystem already being loaded. This has
    // the effect of serializing the startup of a subsystem on hydra
    // per MuSessionId, but not across the system. IE: Posix and
    // OS2 can't start at the same time, but will wait until
    // the other has started on a MuSessionId basis.
    //
    // We also use the SmpKnownSubSysLock to handle existing
    // race conditions since we have multiple SmpApiLoop() threads.
    //

    RtlEnterCriticalSection( &SmpKnownSubSysLock );

    do {

        TargetSubSys = SmpLocateKnownSubSysByType(
                           SubsysMuSessionId,
                           0xFFFFFFFF
                           );

        if( TargetSubSys ) {
            HANDLE hEvent = TargetSubSys->Active;
            RtlLeaveCriticalSection( &SmpKnownSubSysLock );
            Status = NtWaitForSingleObject( hEvent, FALSE, NULL );
            RtlEnterCriticalSection( &SmpKnownSubSysLock );
            SmpDeferenceKnownSubSys(TargetSubSys);
        }

    } while ( TargetSubSys != NULL );

    if (Flags & SMP_POSIX_FLAG) {
        TargetSubSys = SmpLocateKnownSubSysByType(
                           SubsysMuSessionId,
                           IMAGE_SUBSYSTEM_POSIX_CUI
                           );

        if( TargetSubSys ) {
            SmpDeferenceKnownSubSys(TargetSubSys);
            RtlLeaveCriticalSection( &SmpKnownSubSysLock );
            return( STATUS_SUCCESS );
        }
    }

    if (Flags & SMP_OS2_FLAG) {
        TargetSubSys = SmpLocateKnownSubSysByType(
                           SubsysMuSessionId,
                           IMAGE_SUBSYSTEM_OS2_CUI
                           );

        if( TargetSubSys ) {
            SmpDeferenceKnownSubSys(TargetSubSys);
            RtlLeaveCriticalSection( &SmpKnownSubSysLock );
            return( STATUS_SUCCESS );
        }
    }

    //
    // Create and register KnownSubSys entry before releasing the lock
    // so that other threads will see that we are starting a subsystem
    // on this MuSessionId.
    //
    KnownSubSys = RtlAllocateHeap( SmpHeap, MAKE_TAG( INIT_TAG ), sizeof( SMPKNOWNSUBSYS ) );
    if ( KnownSubSys == NULL ) {
        RtlLeaveCriticalSection( &SmpKnownSubSysLock );
        return( STATUS_NO_MEMORY );
    }


    KnownSubSys->Deleting = FALSE;
    KnownSubSys->Process = NULL;
    KnownSubSys->Active = NULL;
    KnownSubSys->MuSessionId = SubsysMuSessionId;
    KnownSubSys->ImageType = (ULONG)0xFFFFFFFF;
    KnownSubSys->SmApiCommunicationPort = (HANDLE) NULL;
    KnownSubSys->SbApiCommunicationPort = (HANDLE) NULL;
    KnownSubSys->RefCount = 1;

    Status = NtCreateEvent( &KnownSubSys->Active,
                            EVENT_ALL_ACCESS,
                            NULL,
                            NotificationEvent,
                            FALSE
                          );

    if( !NT_SUCCESS(Status) ) {
        RtlFreeHeap( SmpHeap, 0, KnownSubSys );
        RtlLeaveCriticalSection( &SmpKnownSubSysLock );
        return( STATUS_NO_MEMORY );
    }

    InsertHeadList( &SmpKnownSubSysHead, &KnownSubSys->Links );

    RtlLeaveCriticalSection( &SmpKnownSubSysLock );

    Flags |= SMP_DONT_START;

    if (((Flags & SMP_OS2_FLAG) || (Flags & SMP_POSIX_FLAG))) {

        SBAPIMSG m;
        PSBCREATEPROCESS args = &m.u.CreateProcess;

        //
        // Create it in csrss instead.
        //

        CreatorSubSys = SmpLocateKnownSubSysByType(SubsysMuSessionId,
                                                   IMAGE_SUBSYSTEM_WINDOWS_GUI);

        //
        // CSRSS must have been started.
        //

        if (CreatorSubSys == NULL) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: SmpLoadSubSystem - SmpLocateKnownSubSysByType Failed\n"));

            goto cleanup2;
        }

        args->i.ImageFileName = ImageFileName;
        args->i.CurrentDirectory = CurrentDirectory;
        args->i.CommandLine = CommandLine;
        args->i.DefaultLibPath = (SmpDefaultLibPath.Length == 0 ?
                                NULL : &SmpDefaultLibPath
                                );
        args->i.Flags = Flags;
        args->i.DefaultDebugFlags = SmpDebug;

        Status = SmpCallCsrCreateProcess(&m,
                                         sizeof(*args),
                                         CreatorSubSys->SbApiCommunicationPort
                                         );

        if (!NT_SUCCESS( Status )) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: SmpLoadSubSystem - SmpCallCsrCreateProcess Failed with  Status %lx\n",
                       Status));

            goto cleanup2;
        }

        //
        // Copy the output parameters to where smss expects them.
        //

        ProcessInformation.Process = args->o.Process;
        ProcessInformation.Thread = args->o.Thread;
        ProcessInformation.ClientId.UniqueProcess = args->o.ClientId.UniqueProcess;
        ProcessInformation.ClientId.UniqueThread = args->o.ClientId.UniqueThread;
        ProcessInformation.ImageInformation.SubSystemType = args->o.SubSystemType;

    } else {
        Status = SmpExecuteImage( ImageFileName,
                                  CurrentDirectory,
                                  CommandLine,
                                  SubsysMuSessionId,
                                  Flags,
                                  &ProcessInformation
                                  );
        if (!NT_SUCCESS( Status )) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: SmpLoadSubSystem - SmpExecuteImage Failed with  Status %lx\n",
                       Status));

            goto cleanup2;
        }
    }

    KnownSubSys->Process = ProcessInformation.Process;
    KnownSubSys->InitialClientId = ProcessInformation.ClientId;

    //
    // Now that we have the process all set, make sure that the
    // subsystem is either an NT native app, or an app type of
    // a previously loaded subsystem.
    //

    if (ProcessInformation.ImageInformation.SubSystemType !=
                IMAGE_SUBSYSTEM_NATIVE ) {
        SBAPIMSG SbApiMsg;
        PSBCREATESESSION args;
        ULONG SessionId;

        args = &SbApiMsg.u.CreateSession;

        args->ProcessInformation = ProcessInformation;
        args->DebugSession = 0;
        args->DebugUiClientId.UniqueProcess = NULL;
        args->DebugUiClientId.UniqueThread = NULL;

        TargetSubSys = SmpLocateKnownSubSysByType(
                      MuSessionId,
                      ProcessInformation.ImageInformation.SubSystemType
                      );
        if ( !TargetSubSys ) {
            Status = STATUS_NO_SUCH_PACKAGE;
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: SmpLoadSubSystem - SmpLocateKnownSubSysByType Failed with  Status %lx for sessionid %ld\n",
                       Status,
                       MuSessionId));

            goto cleanup;
            }
        //
        // Transfer the handles to the subsystem responsible for this
        // process.
        //

        Status = NtDuplicateObject( NtCurrentProcess(),
                                    ProcessInformation.Process,
                                    TargetSubSys->Process,
                                    &args->ProcessInformation.Process,
                                    PROCESS_ALL_ACCESS,
                                    0,
                                    0
                                  );
        if (!NT_SUCCESS( Status )) {
            KdPrintEx((DPFLTR_SETUP_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: SmpLoadSubSystem - NtDuplicateObject Failed with  Status %lx for sessionid %ld\n",
                       Status,
                       MuSessionId));

            goto cleanup;
            }

        Status = NtDuplicateObject( NtCurrentProcess(),
                                    ProcessInformation.Thread,
                                    TargetSubSys->Process,
                                    &args->ProcessInformation.Thread,
                                    THREAD_ALL_ACCESS,
                                    0,
                                    0
                                  );
        if (!NT_SUCCESS( Status )) {
            KdPrintEx((DPFLTR_SETUP_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: SmpLoadSubSystem - NtDuplicateObject Failed with  Status %lx for sessionid %ld\n",
                       Status,
                       MuSessionId));

            goto cleanup;
            }

        SessionId = SmpAllocateSessionId( TargetSubSys,
                                          NULL
                                        );

        args->SessionId = SessionId;

        SbApiMsg.ApiNumber = SbCreateSessionApi;
        SbApiMsg.h.u1.s1.DataLength = sizeof(*args) + 8;
        SbApiMsg.h.u1.s1.TotalLength = sizeof(SbApiMsg);
        SbApiMsg.h.u2.ZeroInit = 0L;

        Status = NtRequestWaitReplyPort(
                TargetSubSys->SbApiCommunicationPort,
                (PPORT_MESSAGE) &SbApiMsg,
                (PPORT_MESSAGE) &SbApiMsg
                );

        if (NT_SUCCESS( Status )) {
            Status = SbApiMsg.ReturnedStatus;
            }

        if (!NT_SUCCESS( Status )) {
            SmpDeleteSession( SessionId);
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: SmpLoadSubSystem - NtRequestWaitReplyPort Failed with  Status %lx for sessionid %ld\n",
                       Status,
                       MuSessionId));

            goto cleanup;
            }
        }
    else {
        if ( pWindowsSubSysProcessId ) {

            if ( *pWindowsSubSysProcessId == (ULONG_PTR)NULL ) {

                *pWindowsSubSysProcessId = (ULONG_PTR)
                    ProcessInformation.ClientId.UniqueProcess;
            }
        }
        if ( !MuSessionId ) { // Only for console
            SmpWindowsSubSysProcessId = (ULONG_PTR)
                ProcessInformation.ClientId.UniqueProcess;
            SmpWindowsSubSysProcess = ProcessInformation.Process;
        }
    }

    ASSERTMSG( "NtCreateEvent", NT_SUCCESS( Status ) );

    Status = NtResumeThread( ProcessInformation.Thread, NULL );

    if (!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: SmpLoadSubSystem - NtResumeThread failed Status %lx\n",
                   Status));

        goto cleanup;
    }


    if(MuSessionId != 0) {

        //
        // Wait a max of 60 seconds for the subsystem to connect.
        //

        Timeout = RtlEnlargedIntegerMultiply( 60000, -10000 );
        Status = NtWaitForSingleObject( KnownSubSys->Active, FALSE, &Timeout );
        if ( !SmpCheckDuplicateMuSessionId( MuSessionId ) ) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_INFO_LEVEL,
                       "SMSS: SmpLoadSubSystem - session deleted\n"));

            return( STATUS_DELETE_PENDING );
        }

        if (Status != STATUS_SUCCESS) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: SmpLoadSubSystem - Timeout waiting for subsystem connect with Status %lx for sessionid %ld \n",
                       Status,
                       MuSessionId));

            goto cleanup;
        }

    } else {

        NtWaitForSingleObject( KnownSubSys->Active, FALSE, NULL );

    }

    // Close this now since we never need it again
    NtClose( ProcessInformation.Thread );

    RtlEnterCriticalSection( &SmpKnownSubSysLock );
    if (KnownSubSys) {
        SmpDeferenceKnownSubSys(KnownSubSys);
    }
    if (TargetSubSys) {
        SmpDeferenceKnownSubSys(TargetSubSys);
    }
    if (CreatorSubSys) {
        SmpDeferenceKnownSubSys(CreatorSubSys);
    }
    RtlLeaveCriticalSection( &SmpKnownSubSysLock );

    return STATUS_SUCCESS;

cleanup:

    if ((AttachedSessionId != (-1))
        && !(Flags & SMP_POSIX_FLAG)
        && !(Flags & SMP_OS2_FLAG)
        && NT_SUCCESS(AcquirePrivilegeStatus = SmpAcquirePrivilege( SE_LOAD_DRIVER_PRIVILEGE, &State ))) {

        NTSTATUS St;
        //
        // If we are attached to a session space, leave it
        // so we can create a new one
        //

        if (NT_SUCCESS(St = NtSetSystemInformation(
                            SystemSessionDetach,
                            (PVOID)&AttachedSessionId,
                            sizeof(MuSessionId)
                            ))) {

            AttachedSessionId = (-1);

        } else {

            //
            // This has to succeed otherwise we will bugcheck while trying to
            // create another session
            //
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: SmpStartCsr, Couldn't Detach from Session Space. Status=%x\n",
                       St));

            ASSERT(NT_SUCCESS(St));
        }

        SmpReleasePrivilege( State );
    }
    else
    {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_INFO_LEVEL,
                   "SMSS: Did not detach from Session Space: SessionId=%x Flags=%x Status=%x\n",
                   AttachedSessionId,
                   Flags,
                   AcquirePrivilegeStatus));
    }


    // There is a lot of cleanup that must be done here
    NtTerminateProcess( ProcessInformation.Process, Status );
    NtClose( ProcessInformation.Thread );

cleanup2:

    RtlEnterCriticalSection( &SmpKnownSubSysLock );
    if (TargetSubSys) {
        SmpDeferenceKnownSubSys(TargetSubSys);
    }
    if (CreatorSubSys) {
        SmpDeferenceKnownSubSys(CreatorSubSys);
    }
    RemoveEntryList( &KnownSubSys->Links );
    NtSetEvent( KnownSubSys->Active, NULL );
    KnownSubSys->Deleting = TRUE;
    SmpDeferenceKnownSubSys(KnownSubSys);
    RtlLeaveCriticalSection( &SmpKnownSubSysLock );

    return( Status );

}


NTSTATUS
SmpExecuteInitialCommand(
    IN ULONG MuSessionId,
    IN PUNICODE_STRING InitialCommand,
    OUT PHANDLE InitialCommandProcess,
    OUT PULONG_PTR InitialCommandProcessId
    )
{
    NTSTATUS Status;
    RTL_USER_PROCESS_INFORMATION ProcessInformation;
    ULONG Flags;
    UNICODE_STRING ImageFileName;
    UNICODE_STRING CurrentDirectory;
    UNICODE_STRING Arguments;
    static HANDLE SmApiPort = NULL;

    if ( SmApiPort == NULL ) {
        Status = SmConnectToSm( NULL,
                            NULL,
                            0,
                            &SmApiPort
                          );
        if (!NT_SUCCESS( Status )) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Unable to connect to SM - Status == %lx\n",
                       Status));

            return( Status );
        }
    }

    Flags = 0;
    Status = SmpParseCommandLine( InitialCommand,
                                  &Flags,
                                  &ImageFileName,
                                  &CurrentDirectory,
                                  &Arguments
                                );
    if (Flags & SMP_IMAGE_NOT_FOUND) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Initial command image (%wZ) not found\n",
                   &ImageFileName));

        if (ImageFileName.Buffer)
            RtlFreeHeap( RtlProcessHeap(), 0, ImageFileName.Buffer );
        return( STATUS_OBJECT_NAME_NOT_FOUND );
        }

    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: SmpParseCommand( %wZ ) failed - Status == %lx\n",
                   InitialCommand,
                   Status));

        return( Status );
        }

    Status = SmpExecuteImage( &ImageFileName,
                              &CurrentDirectory,
                              InitialCommand,
                              MuSessionId,
                              SMP_DONT_START,
                              &ProcessInformation
                            );
    if (ImageFileName.Buffer) {
        RtlFreeHeap( RtlProcessHeap(), 0, ImageFileName.Buffer );
        if (CurrentDirectory.Buffer != NULL) {
            RtlFreeHeap( RtlProcessHeap(), 0, CurrentDirectory.Buffer );
            }
        }

    if (Arguments.Buffer) {
        RtlFreeHeap( RtlProcessHeap(), 0, Arguments.Buffer );
        }
    if (!NT_SUCCESS( Status )) {
        return( Status );
        }

    Status = NtDuplicateObject( NtCurrentProcess(),
                                ProcessInformation.Process,
                                NtCurrentProcess(),
                                InitialCommandProcess,
                                PROCESS_ALL_ACCESS,
                                0,
                                0
                              );

    if (!NT_SUCCESS(Status) ) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: DupObject Failed. Status == %lx\n",
                   Status));

        NtTerminateProcess( ProcessInformation.Process, Status );
        NtResumeThread( ProcessInformation.Thread, NULL );
        NtClose( ProcessInformation.Thread );
        NtClose( ProcessInformation.Process );
        return( Status );
        }

    if ( InitialCommandProcessId != NULL )
        *InitialCommandProcessId =
            (ULONG_PTR)ProcessInformation.ClientId.UniqueProcess;
    if ( !MuSessionId )
        SmpInitialCommandProcessId =
            (ULONG_PTR)ProcessInformation.ClientId.UniqueProcess;
    Status = SmExecPgm( SmApiPort,
                        &ProcessInformation,
                        FALSE
                      );

    if (!NT_SUCCESS( Status )) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: SmExecPgm Failed. Status == %lx\n",
                   Status));

        return( Status );
        }

    return( Status );
}


void
SmpDisplayString( char *s )
{
    ANSI_STRING AnsiString;
    UNICODE_STRING UnicodeString;

    RtlInitAnsiString( &AnsiString, s );

    RtlAnsiStringToUnicodeString( &UnicodeString, &AnsiString, TRUE );

    NtDisplayString( &UnicodeString );

    RtlFreeUnicodeString( &UnicodeString );
}

NTSTATUS
SmpLoadDeferedSubsystem(
    IN PSMAPIMSG SmApiMsg,
    IN PSMP_CLIENT_CONTEXT CallingClient,
    IN HANDLE CallPort
    )
{

    NTSTATUS Status;
    PLIST_ENTRY Head, Next;
    PSMP_REGISTRY_VALUE p;
    UNICODE_STRING DeferedName;
    PSMLOADDEFERED args;
    ULONG MuSessionId;
    ULONG Flags;

    args = &SmApiMsg->u.LoadDefered;

    DeferedName.Length = (USHORT)args->SubsystemNameLength;
    DeferedName.MaximumLength = (USHORT)args->SubsystemNameLength;
    DeferedName.Buffer = args->SubsystemName;

    Head = &SmpSubSystemsToDefer;

    //
    // Get the pointer to the client process's Terminal Server session.
    //

    SmpGetProcessMuSessionId( CallingClient->ClientProcessHandle, &MuSessionId );
    if ( !SmpCheckDuplicateMuSessionId( MuSessionId ) ) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Defered subsystem load ( %wZ ) for MuSessionId %u, status=0x%x\n",
                   &DeferedName,
                   MuSessionId,
                   STATUS_OBJECT_NAME_NOT_FOUND));

        return( STATUS_OBJECT_NAME_NOT_FOUND );
    }

    Next = Head->Flink;
    while (Next != Head ) {
        p = CONTAINING_RECORD( Next,
                               SMP_REGISTRY_VALUE,
                               Entry
                             );
        if ( RtlEqualUnicodeString(&DeferedName,&p->Name,TRUE)) {

            //
            // This is it. Load the subsystem...
            //
            // To keep from loading multiple subsystems, we must
            // flag the type so we can see if its running.
            // This is only a problem with "Optional" subsystems.
            // Other optional subsystems can still be added, but
            // they may have startup race conditions.
            //

            Flags = SMP_SUBSYSTEM_FLAG;

            if ( RtlEqualUnicodeString(&DeferedName,&PosixName,TRUE)) {
                Flags |= SMP_POSIX_FLAG;
            }

            if ( RtlEqualUnicodeString(&DeferedName,&Os2Name,TRUE)) {
                Flags |= SMP_OS2_FLAG;
            }

            if (RegPosixSingleInstance &&
                RtlEqualUnicodeString(&DeferedName,&PosixName,TRUE)) {
                Flags |= SMP_POSIX_SI_FLAG;
            }

            Status = SmpExecuteCommand( &p->Value, MuSessionId, NULL, Flags );

            return Status;

            }
        Next = Next->Flink;
        }

    return STATUS_OBJECT_NAME_NOT_FOUND;
}


NTSTATUS
SmpConfigureProtectionMode(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    )
/*++

Routine Description:

    This function is a dispatch routine for the QueryRegistry call
    (see SmpRegistryConfigurationTable[] earlier in this file).

    The purpose of this routine is to read the Base Object Protection
    Mode out of the registry.  This information is kept in

    Key Name: \\Hkey_Local_Machine\System\CurrentControlSet\SessionManager
    Value:    ProtectionMode [REG_DWORD]

    The value is a flag word, with the following flags defined:

        SMP_NO_PROTECTION  - No base object protection
        SMP_STANDARD_PROTECTION - Apply standard base
            object protection

    This information will be placed in the global variable
    SmpProtectionMode.

    No value, or an invalid value length or type results in no base
    object protection being applied.

Arguments:

    None.

Return Value:


--*/
{


#if SMP_SHOW_REGISTRY_DATA
    SmpDumpQuery( L"SMSS", "BaseObjectsProtection", ValueName, ValueType, ValueData, ValueLength );
#else
    UNREFERENCED_PARAMETER( ValueName );
    UNREFERENCED_PARAMETER( ValueType );
#endif



    if (ValueLength != sizeof(ULONG)) {

        //
        // Key value not valid. Run protected
        //

        SmpProtectionMode = SMP_STANDARD_PROTECTION;

    } else {


        SmpProtectionMode = (*((PULONG)(ValueData)));

        //
        // Change the security descriptors
        //

    }
    (VOID)SmpCreateSecurityDescriptors( FALSE );

    return( STATUS_SUCCESS );
}


NTSTATUS
SmpConfigureAllowProtectedRenames(
    IN PWSTR ValueName,
    IN ULONG ValueType,
    IN PVOID ValueData,
    IN ULONG ValueLength,
    IN PVOID Context,
    IN PVOID EntryContext
    )
{
    if (ValueLength != sizeof(ULONG)) {
        SmpAllowProtectedRenames = 0;
    } else {
        SmpAllowProtectedRenames = (*((PULONG)(ValueData)));
    }

    return( STATUS_SUCCESS );
}


NTSTATUS
SmpCreateSecurityDescriptors(
    IN BOOLEAN InitialCall
    )

/*++

Routine Description:

    This function allocates and initializes security descriptors
    used in SM.

    The security descriptors include:

        SmpPrimarySecurityDescriptor - (global variable) This is
            used to assign protection to objects created by
            SM that need to be accessed by others, but not modified.
            This descriptor grants the following access:

                    Grant:  World:   Execute | Read  (Inherit)
                    Grant:  Restricted:   Execute | Read (Inherit)
                    Grant:  Admin:   All Access      (Inherit)
                    Grant:  Owner:   All Access      (Inherit Only)

        SmpLiberalSecurityDescriptor = (globalVariable) This is used
            to assign protection objects created by SM that need
            to be modified by others (such as writing to a shared
            memory section).
            This descriptor grants the following access:

                    Grant:  World:   Execute | Read | Write (Inherit)
                    Grant:  Restricted: Execute | Read | Write (Inherit)
                    Grant:  Admin:   All Access             (Inherit)
                    Grant:  Owner:   All Access             (Inherit Only)

        SmpKnownDllsSecurityDescriptor = (globalVariable) This is used
            to assign protection to the \KnownDlls object directory.
            This descriptor grants the following access:

                    Grant:  World:   Execute                (No Inherit)
                    Grant:  Restricted: Execute             (No Inherit)
                    Grant:  Admin:   All Access             (Inherit)
                    Grant:  World:   Execute | Read | Write (Inherit Only)
                    Grant:  Restricted: Execute | Read | Write (Inherit Only)


        Note that System is an administrator, so granting Admin an
        access also grants System that access.

Arguments:

    InitialCall - Indicates whether this routine is being called for
        the first time, or is being called to change the security
        descriptors as a result of a protection mode change.

            TRUE - being called for first time.
            FALSE - being called a subsequent time.

    (global variables:  SmpBaseObjectsUnprotected)

Return Value:

    STATUS_SUCCESS - The security descriptor(s) have been allocated
        and initialized.

    STATUS_NO_MEMORY - couldn't allocate memory for a security
        descriptor.

--*/

{
    NTSTATUS
        Status;

    PSID
        WorldSid = NULL,
        AdminSid = NULL,
        LocalSystemSid = NULL,
        RestrictedSid = NULL,
        OwnerSid = NULL;

    SID_IDENTIFIER_AUTHORITY
        WorldAuthority = SECURITY_WORLD_SID_AUTHORITY,
        NtAuthority = SECURITY_NT_AUTHORITY,
        CreatorAuthority = SECURITY_CREATOR_SID_AUTHORITY;

    ACCESS_MASK
        AdminAccess = (GENERIC_ALL),
        WorldAccess  = (GENERIC_EXECUTE | GENERIC_READ),
        OwnerAccess  = (GENERIC_ALL),
        RestrictedAccess = (GENERIC_EXECUTE | GENERIC_READ);

    UCHAR
        InheritOnlyFlags = (OBJECT_INHERIT_ACE           |
                               CONTAINER_INHERIT_ACE     |
                               INHERIT_ONLY_ACE);

    ULONG
        AceIndex,
        AclLength;

    PACL
        Acl;

    PACE_HEADER
        Ace;

    BOOLEAN
        ProtectionRequired = FALSE;


    if (InitialCall) {

        //
        // Now init the security descriptors for no protection.
        // If told to, we will change these to have protection.
        //

        // Primary

        SmpPrimarySecurityDescriptor = &SmpPrimarySDBody;
        Status = RtlCreateSecurityDescriptor (
                    SmpPrimarySecurityDescriptor,
                    SECURITY_DESCRIPTOR_REVISION
                    );
        ASSERT( NT_SUCCESS(Status) );
#pragma prefast(suppress: 248, "Protection enabled via registry")
        Status = RtlSetDaclSecurityDescriptor (
                     SmpPrimarySecurityDescriptor,
                     TRUE,                  //DaclPresent,
                     NULL,                  //Dacl (no protection)
                     FALSE                  //DaclDefaulted OPTIONAL
                     );
        ASSERT( NT_SUCCESS(Status) );


        // Liberal

        SmpLiberalSecurityDescriptor = &SmpLiberalSDBody;
        Status = RtlCreateSecurityDescriptor (
                    SmpLiberalSecurityDescriptor,
                    SECURITY_DESCRIPTOR_REVISION
                    );
        ASSERT( NT_SUCCESS(Status) );
#pragma prefast(suppress: 248, "Protection enabled via registry")
        Status = RtlSetDaclSecurityDescriptor (
                     SmpLiberalSecurityDescriptor,
                     TRUE,                  //DaclPresent,
                     NULL,                  //Dacl (no protection)
                     FALSE                  //DaclDefaulted OPTIONAL
                     );
        ASSERT( NT_SUCCESS(Status) );

        // KnownDlls

        SmpKnownDllsSecurityDescriptor = &SmpKnownDllsSDBody;
        Status = RtlCreateSecurityDescriptor (
                    SmpKnownDllsSecurityDescriptor,
                    SECURITY_DESCRIPTOR_REVISION
                    );
        ASSERT( NT_SUCCESS(Status) );
#pragma prefast(suppress: 248, "Protection enabled via registry")
        Status = RtlSetDaclSecurityDescriptor (
                     SmpKnownDllsSecurityDescriptor,
                     TRUE,                  //DaclPresent,
                     NULL,                  //Dacl (no protection)
                     FALSE                  //DaclDefaulted OPTIONAL
                     );
        ASSERT( NT_SUCCESS(Status) );

        // ApiPort

        SmpApiPortSecurityDescriptor = &SmpApiPortSDBody;
        Status = RtlCreateSecurityDescriptor (
                    SmpApiPortSecurityDescriptor,
                    SECURITY_DESCRIPTOR_REVISION
                    );
        ASSERT( NT_SUCCESS(Status) );
#pragma prefast(suppress: 248, "Protection enabled via registry")
        Status = RtlSetDaclSecurityDescriptor (
                     SmpApiPortSecurityDescriptor,
                     TRUE,                  //DaclPresent,
                     NULL,                  //Dacl
                     FALSE                  //DaclDefaulted OPTIONAL
                     );
        ASSERT( NT_SUCCESS(Status) );
    }



    if ((SmpProtectionMode & SMP_PROTECTION_REQUIRED) != 0) {
        ProtectionRequired = TRUE;
    }

    if (!InitialCall && !ProtectionRequired) {
        return(STATUS_SUCCESS);
    }



    if (InitialCall || ProtectionRequired) {

        //
        // We need to set up the ApiPort protection, and maybe
        // others.
        //

        Status = RtlAllocateAndInitializeSid (&WorldAuthority,
                                              1,
                                              SECURITY_WORLD_RID,
                                              0, 0, 0, 0, 0, 0, 0,
                                              &WorldSid);

        if (!NT_SUCCESS (Status)) {
            WorldSid = NULL;
            goto exit_and_free;
        }

        Status = RtlAllocateAndInitializeSid (&NtAuthority,
                                              2,
                                              SECURITY_BUILTIN_DOMAIN_RID,
                                              DOMAIN_ALIAS_RID_ADMINS,
                                              0, 0, 0, 0, 0, 0,
                                              &AdminSid);

        if (!NT_SUCCESS (Status)) {
            AdminSid = NULL;
            goto exit_and_free;
        }


        Status = RtlAllocateAndInitializeSid (&CreatorAuthority,
                                              1,
                                              SECURITY_CREATOR_OWNER_RID,
                                              0, 0, 0, 0, 0, 0, 0,
                                              &OwnerSid);

        if (!NT_SUCCESS (Status)) {
            OwnerSid = NULL;
            goto exit_and_free;
        }

        Status = RtlAllocateAndInitializeSid (&NtAuthority,
                                              1,
                                              SECURITY_RESTRICTED_CODE_RID,
                                              0, 0, 0, 0, 0, 0, 0,
                                              &RestrictedSid);

        if (!NT_SUCCESS (Status)) {
            RestrictedSid = NULL;
            goto exit_and_free;
        }

        Status = RtlAllocateAndInitializeSid (&NtAuthority,
                                              1,
                                              SECURITY_LOCAL_SYSTEM_RID,
                                              0, 0, 0, 0, 0, 0, 0,
                                              &LocalSystemSid);

        if (!NT_SUCCESS (Status)) {
            LocalSystemSid = NULL;
            goto exit_and_free;
        }


        //
        // Build the ApiPort security descriptor only
        // if this is the initial call
        //

        if (InitialCall) {

            AdminAccess = GENERIC_ALL;

            AclLength = sizeof( ACL )                       +
                        2 * sizeof( ACCESS_ALLOWED_ACE )    +
                        RtlLengthSid( LocalSystemSid )      +
                        RtlLengthSid( AdminSid );

            Acl = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( INIT_TAG ), AclLength );

            if (Acl == NULL) {
                Status = STATUS_NO_MEMORY;
            }

            if (NT_SUCCESS(Status)) {

                //
                // Create the ACL, then add each ACE
                //

                Status = RtlCreateAcl (Acl, AclLength, ACL_REVISION2 );
                ASSERT( NT_SUCCESS(Status) );

                //
                // Only Non-inheritable ACEs in this ACL
                //      Admin
                //


                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, AdminAccess, AdminSid );
                ASSERT( NT_SUCCESS(Status) );

                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, AdminAccess, LocalSystemSid );
                ASSERT( NT_SUCCESS(Status) );


                Status = RtlSetDaclSecurityDescriptor (SmpApiPortSecurityDescriptor,
                                                       TRUE,                  //DaclPresent,
                                                       Acl,                   //Dacl
                                                       FALSE);                //DaclDefaulted OPTIONAL
                ASSERT( NT_SUCCESS(Status) );
            }

            //
            // Build the KnownDlls security descriptor
            //


            AdminAccess = GENERIC_ALL;

            AclLength = sizeof( ACL )                    +
                        6 * sizeof( ACCESS_ALLOWED_ACE ) +
                        (2*RtlLengthSid( WorldSid ))     +
                        (2*RtlLengthSid( RestrictedSid ))+
                        (2*RtlLengthSid( AdminSid ));

            Acl = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( INIT_TAG ), AclLength );

            if (Acl == NULL) {
                Status = STATUS_NO_MEMORY;
            }

            if (NT_SUCCESS(Status)) {

                //
                // Create the ACL
                //

                Status = RtlCreateAcl (Acl, AclLength, ACL_REVISION2 );
                ASSERT( NT_SUCCESS(Status) );

                //
                // Add the non-inheritable ACEs first
                //      World
                //      Restricted
                //      Admin
                //

                AceIndex = 0;
                WorldAccess  = GENERIC_EXECUTE;
                RestrictedAccess = GENERIC_EXECUTE;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, WorldAccess, WorldSid );
                ASSERT( NT_SUCCESS(Status) );

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, RestrictedAccess, RestrictedSid );
                ASSERT( NT_SUCCESS(Status) );

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, AdminAccess, AdminSid );
                ASSERT( NT_SUCCESS(Status) );

                //
                // Put the inherit only ACEs at at the end
                //      World
                //      Restricted
                //      Admin
                //

                AceIndex++;
                WorldAccess  = GENERIC_EXECUTE | GENERIC_READ | GENERIC_WRITE;
                RestrictedAccess = GENERIC_EXECUTE | GENERIC_READ | GENERIC_WRITE;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, WorldAccess, WorldSid );
                ASSERT( NT_SUCCESS(Status) );
                Status = RtlGetAce( Acl, AceIndex, (PVOID)&Ace );
                ASSERT( NT_SUCCESS(Status) );
                Ace->AceFlags = InheritOnlyFlags;

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, RestrictedAccess, RestrictedSid );
                ASSERT( NT_SUCCESS(Status) );
                Status = RtlGetAce( Acl, AceIndex, (PVOID)&Ace );
                ASSERT( NT_SUCCESS(Status) );
                Ace->AceFlags = InheritOnlyFlags;

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, AdminAccess, AdminSid );
                ASSERT( NT_SUCCESS(Status) );
                Status = RtlGetAce( Acl, AceIndex, (PVOID)&Ace );
                ASSERT( NT_SUCCESS(Status) );
                Ace->AceFlags = InheritOnlyFlags;


                //
                // Put the Acl in the security descriptor
                //

                Status = RtlSetDaclSecurityDescriptor (SmpKnownDllsSecurityDescriptor,
                                                       TRUE,                  //DaclPresent,
                                                       Acl,                   //Dacl
                                                       FALSE);                //DaclDefaulted OPTIONAL
                ASSERT( NT_SUCCESS(Status) );
            }


        }


        //
        // The remaining security descriptors are only
        // built if we are running with the correct in
        // protection mode set.  Notice that we only
        // put protection on if standard protection is
        // also specified.   Otherwise, there is no protection
        // on the objects, and nothing should fail.
        //

        if (SmpProtectionMode & SMP_STANDARD_PROTECTION) {

            //
            // Build the primary Security descriptor
            //

            WorldAccess  = GENERIC_EXECUTE | GENERIC_READ;
            RestrictedAccess = GENERIC_EXECUTE | GENERIC_READ;
            AdminAccess  = GENERIC_ALL;
            OwnerAccess  = GENERIC_ALL;

            AclLength = sizeof( ACL )                       +
                        7 * sizeof( ACCESS_ALLOWED_ACE )    +
                        (2*RtlLengthSid( WorldSid ))        +
                        (2*RtlLengthSid( RestrictedSid ))   +
                        (2*RtlLengthSid( AdminSid ))        +
                        RtlLengthSid( OwnerSid );

            Acl = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( INIT_TAG ), AclLength );

            if (Acl == NULL) {
                Status = STATUS_NO_MEMORY;
            }

            if (NT_SUCCESS(Status)) {

                //
                // Create the ACL, then add each ACE
                //

                Status = RtlCreateAcl (Acl, AclLength, ACL_REVISION2 );
                ASSERT( NT_SUCCESS(Status) );

                //
                // Non-inheritable ACEs first
                //      World
                //      Restricted
                //      Admin
                //

                AceIndex = 0;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, WorldAccess, WorldSid );
                ASSERT( NT_SUCCESS(Status) );

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, RestrictedAccess, RestrictedSid );
                ASSERT( NT_SUCCESS(Status) );

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, AdminAccess, AdminSid );
                ASSERT( NT_SUCCESS(Status) );

                //
                // Inheritable ACEs at end of ACE
                //      World
                //      Restricted
                //      Admin
                //      Owner

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, WorldAccess, WorldSid );
                ASSERT( NT_SUCCESS(Status) );
                Status = RtlGetAce( Acl, AceIndex, (PVOID)&Ace );
                ASSERT( NT_SUCCESS(Status) );
                Ace->AceFlags = InheritOnlyFlags;

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, RestrictedAccess, RestrictedSid );
                ASSERT( NT_SUCCESS(Status) );
                Status = RtlGetAce( Acl, AceIndex, (PVOID)&Ace );
                ASSERT( NT_SUCCESS(Status) );
                Ace->AceFlags = InheritOnlyFlags;

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, AdminAccess, AdminSid );
                ASSERT( NT_SUCCESS(Status) );
                Status = RtlGetAce( Acl, AceIndex, (PVOID)&Ace );
                ASSERT( NT_SUCCESS(Status) );
                Ace->AceFlags = InheritOnlyFlags;

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, OwnerAccess, OwnerSid );
                ASSERT( NT_SUCCESS(Status) );
                Status = RtlGetAce( Acl, AceIndex, (PVOID)&Ace );
                ASSERT( NT_SUCCESS(Status) );
                Ace->AceFlags = InheritOnlyFlags;



                Status = RtlSetDaclSecurityDescriptor (
                                             SmpPrimarySecurityDescriptor,
                                             TRUE,                  //DaclPresent,
                                             Acl,                   //Dacl
                                             FALSE                  //DaclDefaulted OPTIONAL
                                             );
                ASSERT( NT_SUCCESS(Status) );
            }

            //
            // Build the liberal security descriptor
            //


            AdminAccess = GENERIC_ALL;
            WorldAccess  = GENERIC_EXECUTE | GENERIC_READ | GENERIC_WRITE;
            RestrictedAccess = GENERIC_EXECUTE | GENERIC_READ | GENERIC_WRITE;

            AclLength = sizeof( ACL )                    +
                        7 * sizeof( ACCESS_ALLOWED_ACE ) +
                        (2*RtlLengthSid( WorldSid ))     +
                        (2*RtlLengthSid( RestrictedSid ))+
                        (2*RtlLengthSid( AdminSid ))     +
                        RtlLengthSid( OwnerSid );

            Acl = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( INIT_TAG ), AclLength );

            if (Acl == NULL) {
                Status = STATUS_NO_MEMORY;
            }

            if (NT_SUCCESS(Status)) {

                //
                // Create the ACL
                //

                Status = RtlCreateAcl (Acl, AclLength, ACL_REVISION2 );
                ASSERT( NT_SUCCESS(Status) );

                //
                // Add the non-inheritable ACEs first
                //      World
                //      Restricted
                //      Admin
                //

                AceIndex = 0;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, WorldAccess, WorldSid );
                ASSERT( NT_SUCCESS(Status) );

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, RestrictedAccess, RestrictedSid );
                ASSERT( NT_SUCCESS(Status) );

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, AdminAccess, AdminSid );
                ASSERT( NT_SUCCESS(Status) );

                //
                // Put the inherit only ACEs at at the end
                //      World
                //      Restricted
                //      Admin
                //      Owner
                //

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, WorldAccess, WorldSid );
                ASSERT( NT_SUCCESS(Status) );
                Status = RtlGetAce( Acl, AceIndex, (PVOID)&Ace );
                ASSERT( NT_SUCCESS(Status) );
                Ace->AceFlags = InheritOnlyFlags;

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, RestrictedAccess, RestrictedSid );
                ASSERT( NT_SUCCESS(Status) );
                Status = RtlGetAce( Acl, AceIndex, (PVOID)&Ace );
                ASSERT( NT_SUCCESS(Status) );
                Ace->AceFlags = InheritOnlyFlags;

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, AdminAccess, AdminSid );
                ASSERT( NT_SUCCESS(Status) );
                Status = RtlGetAce( Acl, AceIndex, (PVOID)&Ace );
                ASSERT( NT_SUCCESS(Status) );
                Ace->AceFlags = InheritOnlyFlags;

                AceIndex++;
                Status = RtlAddAccessAllowedAce ( Acl, ACL_REVISION2, OwnerAccess, OwnerSid );
                ASSERT( NT_SUCCESS(Status) );
                Status = RtlGetAce( Acl, AceIndex, (PVOID)&Ace );
                ASSERT( NT_SUCCESS(Status) );
                Ace->AceFlags = InheritOnlyFlags;


                //
                // Put the Acl in the security descriptor
                //

                Status = RtlSetDaclSecurityDescriptor (SmpLiberalSecurityDescriptor,
                                                       TRUE,                  //DaclPresent,
                                                       Acl,                   //Dacl
                                                       FALSE);                //DaclDefaulted OPTIONAL
                ASSERT( NT_SUCCESS(Status) );
            }
        }
    }

exit_and_free:

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

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

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

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

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

    return( Status );

}

VOID
SmpTranslateSystemPartitionInformation( VOID )

/*++

Routine Description:

    This routine translates the NT device path for the system partition (stored
    during IoInitSystem) into a DOS path, and stores the resulting REG_SZ 'BootDir'
    value under HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Setup

Arguments:

    None.

Return Value:

    None.

--*/

{
    NTSTATUS Status;
    UNICODE_STRING UnicodeString;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE Key;
    UCHAR ValueBuffer[ VALUE_BUFFER_SIZE ];
    ULONG ValueLength;
    UNICODE_STRING SystemPartitionString;
    POBJECT_DIRECTORY_INFORMATION DirInfo;
    UCHAR DirInfoBuffer[ sizeof(OBJECT_DIRECTORY_INFORMATION) + (256 + sizeof("SymbolicLink")) * sizeof(WCHAR) ];
    UNICODE_STRING LinkTypeName;
    BOOLEAN RestartScan;
    ULONG Context;
    HANDLE SymbolicLinkHandle;
    WCHAR UnicodeBuffer[ MAXIMUM_FILENAME_LENGTH ];
    UNICODE_STRING LinkTarget;


    //
    // Retrieve 'SystemPartition' value stored under HKLM\SYSTEM\Setup
    //

    RtlInitUnicodeString(&UnicodeString, L"\\Registry\\Machine\\System\\Setup");
    InitializeObjectAttributes(&ObjectAttributes,
                               &UnicodeString,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL
                              );

    Status = NtOpenKey(&Key, KEY_READ, &ObjectAttributes);
    if (!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: can't open system setup key for reading: 0x%x\n",
                   Status));

        return;
    }

    RtlInitUnicodeString(&UnicodeString, L"SystemPartition");
    Status = NtQueryValueKey(Key,
                             &UnicodeString,
                             KeyValuePartialInformation,
                             ValueBuffer,
                             sizeof(ValueBuffer),
                             &ValueLength
                            );

    NtClose(Key);

    if (!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: can't query SystemPartition value: 0x%x\n",
                   Status));

        return;
    }

    RtlInitUnicodeString(&SystemPartitionString,
                         (PWSTR)(((PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer)->Data)
                        );

    //
    // Next, examine objects in the DosDevices directory, looking for one that's a symbolic link
    // to the system partition.
    //

    LinkTarget.Buffer = UnicodeBuffer;

    DirInfo = (POBJECT_DIRECTORY_INFORMATION)DirInfoBuffer;
    RestartScan = TRUE;
    RtlInitUnicodeString(&LinkTypeName, L"SymbolicLink");


    while (TRUE) {

        Status = NtQueryDirectoryObject(SmpDosDevicesObjectDirectory,
                                        DirInfo,
                                        sizeof(DirInfoBuffer),
                                        TRUE,
                                        RestartScan,
                                        &Context,
                                        NULL
                                       );

        if (!NT_SUCCESS(Status)) {
            break;
        }

        if (RtlEqualUnicodeString(&DirInfo->TypeName, &LinkTypeName, TRUE) &&
            (DirInfo->Name.Length == 2 * sizeof(WCHAR)) &&
            (DirInfo->Name.Buffer[1] == L':')) {

            //
            // We have a drive letter--check the NT device name it's linked to.
            //

            InitializeObjectAttributes(&ObjectAttributes,
                                       &DirInfo->Name,
                                       OBJ_CASE_INSENSITIVE,
                                       SmpDosDevicesObjectDirectory,
                                       NULL
                                      );

            Status = NtOpenSymbolicLinkObject(&SymbolicLinkHandle,
                                              SYMBOLIC_LINK_ALL_ACCESS,
                                              &ObjectAttributes
                                             );

            if (NT_SUCCESS(Status)) {

                LinkTarget.Length = 0;
                LinkTarget.MaximumLength = sizeof(UnicodeBuffer);

                Status = NtQuerySymbolicLinkObject(SymbolicLinkHandle,
                                                   &LinkTarget,
                                                   NULL
                                                  );
                NtClose(SymbolicLinkHandle);

                //
                // The last part of the test below handles the remote boot case,
                // where the system partition is on a redirected drive.
                //

                if (NT_SUCCESS(Status) &&
                     ( RtlEqualUnicodeString(&SystemPartitionString, &LinkTarget, TRUE)
                        || (RtlPrefixUnicodeString(&SystemPartitionString, &LinkTarget, TRUE)
                             && (LinkTarget.Buffer[SystemPartitionString.Length / sizeof(WCHAR)] == L'\\')) )
                   ) {

                     //
                     // We've found the drive letter corresponding to the system partition.
                     //
                     break;
                }
            }
        }

        RestartScan = FALSE;
    }


    if (!NT_SUCCESS(Status)) {
#if defined (_WIN64)
        if (Status == STATUS_NO_MORE_ENTRIES) {
            DirInfo->Name.Buffer = (PWCHAR)(DirInfo+1);
            DirInfo->Name.Buffer[0] = USER_SHARED_DATA->NtSystemRoot[0];
            DirInfo->Name.Buffer[1] = USER_SHARED_DATA->NtSystemRoot[1];
        } else {
#endif
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: can't find drive letter for system partition\n"));        
        return;
#if defined (_WIN64)
        }
#endif
    }

    //
    // Now write out the DOS path for the system partition to
    // HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Setup
    //

    RtlInitUnicodeString(&UnicodeString, L"\\Registry\\Machine\\Software\\Microsoft\\Windows\\CurrentVersion\\Setup");
    InitializeObjectAttributes(&ObjectAttributes,
                               &UnicodeString,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL
                              );

    Status = NtOpenKey(&Key, KEY_ALL_ACCESS, &ObjectAttributes);
    if (!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: can't open software setup key for writing: 0x%x\n",
                   Status));

        return;
    }

    wcsncpy(UnicodeBuffer, DirInfo->Name.Buffer, 2);
    UnicodeBuffer[2] = L'\\';
    UnicodeBuffer[3] = L'\0';

    RtlInitUnicodeString(&UnicodeString, L"BootDir");

    Status = NtSetValueKey(Key,
                           &UnicodeString,
                           0,
                           REG_SZ,
                           UnicodeBuffer,
                           4 * sizeof(WCHAR)
                          );

    if (!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: couldn't write BootDir value: 0x%x\n",
                   Status));
    }

    NtClose(Key);
}

#if defined(REMOTE_BOOT)
NTSTATUS
SmpExecuteCommandLineArguments( VOID )

/*++

Routine Description:

    This routine processes any command line arguments that were passed to SMSS.exe.
    Currently the only valid ones are netboot commands.

Arguments:

    None.

Return Value:

    Success or not.

--*/

{
    UNICODE_STRING CfgFileName;
    UNICODE_STRING MbrName;
    UNICODE_STRING AutoFmtCmd;
    UNICODE_STRING UnicodeString;
    OBJECT_ATTRIBUTES ObjectAttributes;
    OBJECT_ATTRIBUTES KeyObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    HANDLE FileHandle;
    HANDLE SourceHandle;
    HANDLE TargetHandle;
    NTSTATUS Status;
    ULONG BootSerialNumber;
    ULONG DiskSignature;
    ULONG CmdFlags;
    ULONG Length;
    LARGE_INTEGER ByteOffset;
    PUCHAR AlignedBuffer;
    ON_DISK_MBR OnDiskMbr;
    BOOLEAN WasEnabled;
    HANDLE Key;
    WCHAR ValueBuffer[VALUE_BUFFER_SIZE];
    PKEY_VALUE_PARTIAL_INFORMATION KeyValueInfo;
    ULONG ValueLength;
    ULONG Repartition;
    ULONG Disk;
    ULONG Partition;
    ULONG CSCPartition;
    PWCHAR pWchar;

    if (!SmpNetboot || SmpNetbootDisconnected) {
        return STATUS_SUCCESS;
    }

    //
    // Open the remoteboot.cfg file
    //

    RtlInitUnicodeString(&UnicodeString, L"\\SystemRoot");

    InitializeObjectAttributes(
       &ObjectAttributes,
       &UnicodeString,
       OBJ_CASE_INSENSITIVE,
       NULL,
       NULL
       );

    Status = NtOpenSymbolicLinkObject(&FileHandle,
                                      (ACCESS_MASK)SYMBOLIC_LINK_QUERY,
                                      &ObjectAttributes
                                     );

    if (!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Could not open symbolic link (Status 0x%x) -- quitting.\n",
                   Status));

        Status = STATUS_SUCCESS;
        goto CleanUp;
    }

    UnicodeString.Length = 0;
    UnicodeString.MaximumLength = sizeof(TmpBuffer);
    UnicodeString.Buffer = (PWCHAR)TmpBuffer;
    Status = NtQuerySymbolicLinkObject(FileHandle,
                                       &UnicodeString,
                                       NULL
                                      );

    NtClose(FileHandle);
    FileHandle = NULL;

    if (!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Could not get symbolic link name (Status 0x%x) -- quitting.\n",
                   Status));

        Status = STATUS_SUCCESS;
        goto CleanUp;
    }

    ASSERT(((wcslen((PWCHAR)TmpBuffer) * sizeof(WCHAR)) - sizeof(L"BootDrive")) <
           (sizeof(wszRemoteBootCfgFile) - sizeof(REMOTE_BOOT_CFG_FILE))
          );

    wcscpy(wszRemoteBootCfgFile, (PWCHAR)TmpBuffer);

    pWchar = wcsstr(wszRemoteBootCfgFile, L"BootDrive");
    ASSERT(pWchar != NULL);
    *pWchar = UNICODE_NULL;

    wcscat(wszRemoteBootCfgFile, REMOTE_BOOT_CFG_FILE);

    CfgFileName.Length = wcslen(wszRemoteBootCfgFile) * sizeof(WCHAR);
    CfgFileName.MaximumLength = sizeof(wszRemoteBootCfgFile);
    CfgFileName.Buffer = wszRemoteBootCfgFile;

    InitializeObjectAttributes(
       &ObjectAttributes,
       &CfgFileName,
       OBJ_CASE_INSENSITIVE,
       NULL,
       NULL
       );

    Status = NtOpenFile( &FileHandle,
                         GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
                         &ObjectAttributes,
                         &IoStatusBlock,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_RANDOM_ACCESS
                       );

    //
    // If it does not exist, then set the flags for reformatting and repinning.
    //
    if (!NT_SUCCESS(Status)) {

        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Could not open file (status 0x%x) -- creating it.\n",
                   Status));

        //
        // Create the remoteboot.cfg in the system32\config directory if it does not exist.
        //

CreateFile:

        Status = NtCreateFile( &FileHandle,
                               GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
                               &ObjectAttributes,
                               &IoStatusBlock,
                               NULL,
                               FILE_ATTRIBUTE_HIDDEN,
                               FILE_SHARE_READ | FILE_SHARE_WRITE,
                               FILE_OVERWRITE_IF,
                               FILE_SYNCHRONOUS_IO_NONALERT | FILE_RANDOM_ACCESS,
                               NULL,
                               0
                             );

        if (!NT_SUCCESS(Status)) {
            //
            // Something is really wrong, we will just exit and hope all is good.
            // DEADISSUE, HISTORICAL CODE ONLY: This OK?
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Could not create file (Status 0x%x) -- quitting.\n",
                       Status));

            Status = STATUS_SUCCESS;
            goto CleanUp;
        }

        SmpAutoFormat = TRUE;
        BootSerialNumber = 1;

    } else {

        Status = NtReadFile( FileHandle,
                             NULL,
                             NULL,
                             NULL,
                             &IoStatusBlock,
                             &BootSerialNumber,
                             sizeof(ULONG),
                             NULL,
                             NULL
                           );

        if (!NT_SUCCESS(Status)) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Could not read file (Status 0x%x) -- creating it.\n",
                       Status));

            NtClose( FileHandle );
            goto CreateFile;
        }

        BootSerialNumber++;
    }



    //
    // Process each command
    //
    if (SmpAutoFormat) {

        //
        // Read from the registry if it is ok to reformat, or just leave the disk alone.
        //
        Repartition = 1;

        KeyValueInfo = (PKEY_VALUE_PARTIAL_INFORMATION)ValueBuffer;
        RtlInitUnicodeString(&UnicodeString,
                             L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\RemoteBoot");

        InitializeObjectAttributes(&KeyObjectAttributes,
                                   &UnicodeString,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);

        Status = NtOpenKey(&Key, KEY_READ, &KeyObjectAttributes);

        if (NT_SUCCESS(Status)) {

            //
            // Query the key value.
            //
            RtlInitUnicodeString(&UnicodeString, L"Repartition");
            Status = NtQueryValueKey(Key,
                                     &UnicodeString,
                                     KeyValuePartialInformation,
                                     (PVOID)KeyValueInfo,
                                     sizeof (ValueBuffer),
                                     &ValueLength);

            if (NT_SUCCESS(Status)) {
                ASSERT(ValueLength <= VALUE_BUFFER_SIZE);
                Repartition = *((PULONG)KeyValueInfo->Data);
            }

            NtClose(Key);
        }

        SmpGetHarddiskBootPartition(&Disk, &Partition);

        if (Repartition) {

            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_INFO_LEVEL,
                       "SMSS: Autoformatting local disk.\n"));

            NtClose(FileHandle);

            //
            // Repartition the disk.
            //
            SmpPartitionDisk(Disk, &Partition);

            //
            // Call autoformat on the partition
            //
            swprintf((PWSTR)TmpBuffer,
                     L"autoformat autofmt \\Device\\Harddisk%d\\Partition%d /Q /fs:ntfs",
                     Disk,
                     Partition
                    );
            AutoFmtCmd.Buffer = (PWSTR)TmpBuffer;
            AutoFmtCmd.MaximumLength = sizeof(TmpBuffer);
            AutoFmtCmd.Length = wcslen((PWSTR)TmpBuffer) * sizeof(WCHAR);
            CmdFlags = 0;

            Status = SmpExecuteCommand(&AutoFmtCmd, 0, NULL, CmdFlags);

            if (!NT_SUCCESS(Status)) {
                //
                // Big Trouble....
                // CSC is disabled if we get here, so just keep on booting.
                //
                Status = STATUS_SUCCESS;
                goto CleanUp;
            }

        } else {

            SmpFindCSCPartition(Disk, &CSCPartition);

            if (CSCPartition != 0) {
                //
                // Just blow away the CSC directory so we can refresh it
                //
                swprintf((PWSTR)TmpBuffer,
                         L"\\Device\\Harddisk%d\\Partition%d%ws",
                         Disk,
                         CSCPartition,
                         REMOTE_BOOT_IMIRROR_PATH_W REMOTE_BOOT_CSC_SUBDIR_W
                        );

                SmpEnumFilesRecursive(
                    (PWSTR)TmpBuffer,
                    SmpDelEnumFile,
                    &Status,
                    NULL
                    );

                if (!NT_SUCCESS(Status)) {
                    //
                    // Ignore this error, and hope that the next boot will fix.  Just keep booting this
                    // time and hope.
                    //
                    Status = STATUS_SUCCESS;
                    goto CleanUp;
                }

            }

        }

        //
        // Copy the NtLdr to the local disk
        //
        SourceHandle = SmpOpenDir( TRUE, TRUE, L"\\" );
        if (SourceHandle == NULL) {
            Status = STATUS_SUCCESS;
            goto CleanUp;
        }


        swprintf((PWSTR)TmpBuffer,
                 L"\\Device\\Harddisk%d\\Partition%d",
                 Disk,
                 Partition
                );

        RtlInitUnicodeString(&UnicodeString, (PWSTR)TmpBuffer);

        InitializeObjectAttributes(
            &ObjectAttributes,
            &UnicodeString,
            OBJ_CASE_INSENSITIVE,
            NULL,
            NULL
            );


        Status = NtCreateFile( &TargetHandle,
                               GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                               &ObjectAttributes,
                               &IoStatusBlock,
                               NULL,
                               FILE_ATTRIBUTE_NORMAL,
                               FILE_SHARE_READ | FILE_SHARE_WRITE,
                               FILE_OPEN,
                               FILE_SYNCHRONOUS_IO_NONALERT,
                               NULL,
                               0
                             );

        if (!NT_SUCCESS(Status)) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Unable to open a handle to the (%ws) directory - Status == %lx\n",
                       UnicodeString.Buffer,
                       Status));

            Status = STATUS_SUCCESS;
            NtClose(SourceHandle);
            goto CleanUp;
        }

        //
        // If any of the copies fail, there is nothing we can really do.
        //
        RtlInitUnicodeString(&UnicodeString, L"ntldr");
        Status = SmpCopyFile(SourceHandle, TargetHandle, &UnicodeString);

        RtlInitUnicodeString(&UnicodeString, L"boot.ini");
        Status = SmpCopyFile(SourceHandle, TargetHandle, &UnicodeString);

        RtlInitUnicodeString(&UnicodeString, L"bootfont.bin");
        Status = SmpCopyFile(SourceHandle, TargetHandle, &UnicodeString);

        RtlInitUnicodeString(&UnicodeString, L"ntdetect.com");
        Status = SmpCopyFile(SourceHandle, TargetHandle, &UnicodeString);

        NtClose(SourceHandle);
        NtClose(TargetHandle);

        //
        // Read Master Boot Record and get disk serial number.
        //

        swprintf((PWSTR)TmpBuffer,
                 L"\\Device\\Harddisk%d\\Partition0",
                 Disk
                );


        MbrName.Buffer = (PWSTR)TmpBuffer;
        MbrName.MaximumLength = (wcslen((PWSTR)TmpBuffer) + 1) * sizeof(WCHAR);
        MbrName.Length = MbrName.MaximumLength - sizeof(WCHAR);

        InitializeObjectAttributes(
           &ObjectAttributes,
           &MbrName,
           OBJ_CASE_INSENSITIVE,
           NULL,
           NULL
           );

        Status = NtCreateFile( &FileHandle,
                               GENERIC_READ | SYNCHRONIZE,
                               &ObjectAttributes,
                               &IoStatusBlock,
                               NULL,
                               FILE_ATTRIBUTE_NORMAL,
                               FILE_SHARE_READ,
                               FILE_OPEN,
                               FILE_SYNCHRONOUS_IO_NONALERT,
                               NULL,
                               0
                             );

        if (!NT_SUCCESS(Status)) {
            //
            // Something iswrong, but we are running w/o caching, so it should be ok.
            //
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Could not create file (Status 0x%x).\n",
                       Status));

            Status = STATUS_SUCCESS;
            goto CleanUp;
        }

        ASSERT(sizeof(ON_DISK_MBR) == 512);
        AlignedBuffer = ALIGN(TmpBuffer, 512);

        Status = NtReadFile( FileHandle,
                             NULL,
                             NULL,
                             NULL,
                             &IoStatusBlock,
                             AlignedBuffer,
                             sizeof(ON_DISK_MBR),
                             NULL,
                             NULL
                           );

        NtClose( FileHandle );

        if (!NT_SUCCESS(Status)) {
            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Could not read file (Status 0x%x) -- creating it.\n",
                       Status));

            goto CreateFile;
        }

        RtlCopyMemory(&OnDiskMbr,AlignedBuffer,sizeof(ON_DISK_MBR));

        ASSERT(U_USHORT(OnDiskMbr.AA55Signature) == 0xAA55);

        DiskSignature = U_ULONG(OnDiskMbr.NTFTSignature);

        InitializeObjectAttributes(
           &ObjectAttributes,
           &CfgFileName,
           OBJ_CASE_INSENSITIVE,
           NULL,
           NULL
           );

        Status = NtOpenFile( &FileHandle,
                             GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
                             &ObjectAttributes,
                             &IoStatusBlock,
                             FILE_SHARE_READ | FILE_SHARE_WRITE,
                             FILE_SYNCHRONOUS_IO_NONALERT | FILE_RANDOM_ACCESS
                           );

        if (!NT_SUCCESS(Status)) {
            //
            // Big Trouble....
            // CSC is disabled if we get here, so just keep on booting.
            //

            Status = STATUS_SUCCESS;
            goto CleanUp;
        }

    }


    //
    // Update the information
    //
    ByteOffset.LowPart = 0;
    ByteOffset.HighPart = 0;

    NtWriteFile( FileHandle,
                 NULL,
                 NULL,
                 NULL,
                 &IoStatusBlock,
                 &BootSerialNumber,
                 sizeof(ULONG),
                 &ByteOffset,
                 NULL
               );

    if (SmpAutoFormat) {
        ByteOffset.LowPart = sizeof(ULONG);

        NtWriteFile( FileHandle,
                     NULL,
                     NULL,
                     NULL,
                     &IoStatusBlock,
                     &DiskSignature,
                     sizeof(DiskSignature),
                     &ByteOffset,
                     NULL
                   );
    }

    ByteOffset.LowPart = sizeof(ULONG) + sizeof(ULONG);

    NtWriteFile( FileHandle,
                 NULL,
                 NULL,
                 NULL,
                 &IoStatusBlock,
                 SmpHalName,
                 sizeof(SmpHalName),
                 &ByteOffset,
                 NULL
               );

    NtClose(FileHandle);

    if (SmpAutoFormat) {

        //
        // Reboot the machine to start CSC
        //
        Status = RtlAdjustPrivilege( SE_SHUTDOWN_PRIVILEGE,
                                     (BOOLEAN)TRUE,
                                     TRUE,
                                     &WasEnabled
                                   );

        if (Status == STATUS_NO_TOKEN) {

            //
            // No thread token, use the process token
            //

            Status = RtlAdjustPrivilege( SE_SHUTDOWN_PRIVILEGE,
                                         (BOOLEAN)TRUE,
                                         FALSE,
                                         &WasEnabled
                                       );
            }
        NtShutdownSystem(ShutdownReboot);
    }

    Status = STATUS_SUCCESS;

CleanUp:

    return Status;
}


ENUMFILESRESULT
SmpEnumFilesRecursive (
    IN  PWSTR         DirName,
    IN  ENUMFILESPROC EnumFilesProc,
    OUT PULONG        ReturnData,
    IN  PVOID         p1    OPTIONAL
    )
{
    RECURSION_DATA RecursionData;

    RecursionData.OptionalPtr = p1;
    RecursionData.EnumProc    = EnumFilesProc;

    return SmpEnumFiles(
                DirName,
                SmppRecursiveEnumProc,
                ReturnData,
                &RecursionData
                );
}


BOOLEAN
SmppRecursiveEnumProc (
    IN  PWSTR                      DirName,
    IN  PFILE_BOTH_DIR_INFORMATION FileInfo,
    OUT PULONG                     ret,
    IN  PVOID                      Param
    )
{
    PWSTR           FullPath;
    PWSTR           temp;
    ULONG           Len;
    NTSTATUS        Status;
    ULONG           ReturnData;
    ENUMFILESRESULT EnumResult;
    BOOLEAN         b = FALSE;
    PRECURSION_DATA RecursionData;

    RecursionData = (PRECURSION_DATA) Param;

    //
    // Build the full file or dir path
    //

    temp = (PWSTR)(TmpBuffer + (sizeof(TmpBuffer)/2));
    Len = FileInfo->FileNameLength/sizeof(WCHAR);

    wcsncpy(temp, FileInfo->FileName, Len);
    temp[Len] = 0;

    wcscpy((PWSTR)TmpBuffer, DirName);
    SmpConcatenatePaths((PWSTR)TmpBuffer, temp);


    //
    // For directories, recurse
    //
    if(FileInfo->FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
        if( (wcscmp( temp, L"." ) == 0) ||
            (wcscmp( temp, L".." ) == 0) ) {
            //
            // Skip past . and .. directories
            //
            b = TRUE;

        } else {
            //
            // Recurse through subdirectory
            //

            FullPath = RtlAllocateHeap(RtlProcessHeap(),
                                       MAKE_TAG( INIT_TAG ),
                                       (wcslen((PWSTR)TmpBuffer)+1) * sizeof(WCHAR)
                                      );
            if (FullPath == NULL) {
                *ret = EnumFileError;
                return FALSE;
            }

            wcscpy(FullPath, (PWSTR)TmpBuffer);

            EnumResult = SmpEnumFilesRecursive (
                                FullPath,
                                RecursionData->EnumProc,
                                &ReturnData,
                                RecursionData->OptionalPtr
                                );

            RtlFreeHeap( RtlProcessHeap(), 0, FullPath );

            if (EnumResult != NormalReturn) {
                *ret = EnumResult;
                return FALSE;
            }
        }
    }

    //
    // Call normal enum proc for file or dir (except . or .. dirs)
    //

    if (!b) {
        b = RecursionData->EnumProc (
                                DirName,
                                FileInfo,
                                ret,
                                RecursionData->OptionalPtr
                                );
    }

    return b;
}


VOID
SmpConcatenatePaths(
    IN OUT LPWSTR  Path1,
    IN     LPCWSTR Path2
    )
{
    BOOLEAN NeedBackslash = TRUE;
    ULONG l = wcslen(Path1);

    //
    // Determine whether we need to stick a backslash
    // between the components.
    //
    if(l && (Path1[l-1] == L'\\')) {

        NeedBackslash = FALSE;
    }

    if(*Path2 == L'\\') {

        if(NeedBackslash) {
            NeedBackslash = FALSE;
        } else {
            //
            // Not only do we not need a backslash, but we
            // need to eliminate one before concatenating.
            //
            Path2++;
        }
    }

    if(NeedBackslash) {
        wcscat(Path1,L"\\");
    }
    wcscat(Path1,Path2);
}

BOOLEAN
SmpDelEnumFile(
    IN  PWSTR                      DirName,
    IN  PFILE_BOTH_DIR_INFORMATION FileInfo,
    OUT PULONG                     ret,
    IN  PVOID                      Pointer
    )
{
    PWSTR FileName;
    PWSTR p;
    UNICODE_STRING UnicodeString;

    //
    // Ignore subdirectories
    //
    if(FileInfo->FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
        return TRUE;    // continue processing
    }

    //
    // We have to make a copy of the filename, because the info struct
    // we get isn't NULL-terminated.
    //
    FileName = RtlAllocateHeap(RtlProcessHeap(),
                               MAKE_TAG( INIT_TAG ),
                               FileInfo->FileNameLength + sizeof(WCHAR)
                              );
    if (FileName == NULL) {
        *ret = EnumFileError;
        return TRUE;
    }

    wcsncpy(FileName, FileInfo->FileName, FileInfo->FileNameLength);

    FileName[FileInfo->FileNameLength / sizeof(WCHAR)] = UNICODE_NULL;

    //
    // Point to temporary buffer for pathname.
    //
    p = (PWSTR)TmpBuffer;

    //
    // Build up the full name of the file to delete.
    //
    wcscpy(p,DirName);
    SmpConcatenatePaths(p,FileName);

    //
    // Prepare to open the file.
    //
    RtlInitUnicodeString(&UnicodeString, p);

    //
    // Ignore return status of delete
    //
    SmpDeleteFile(&UnicodeString);

    RtlFreeHeap( RtlProcessHeap(), 0, FileName );

    return TRUE;    // continue processing
}

ENUMFILESRESULT
SmpEnumFiles(
    IN  PWSTR         DirName,
    IN  ENUMFILESPROC EnumFilesProc,
    OUT PULONG        ReturnData,
    IN  PVOID         p1    OPTIONAL
    )
/*++

Routine Description:

    This routine processes every file (and subdirectory) in the directory
    specified by 'DirName'. Each entry is sent to the callback function
    'EnumFilesProc' for processing.  If the callback returns TRUE, processing
    continues, otherwise processing terminates.

Arguments:

    DirName       - Supplies the directory name containing the files/subdirectories
                    to be processed.

    EnumFilesProc - Callback function to be called for each file/subdirectory.
                    The function must have the following prototype:

                    BOOLEAN EnumFilesProc(
                        IN  PWSTR,
                        IN  PFILE_BOTH_DIR_INFORMATION,
                        OUT PULONG
                        );

    ReturnData    - Pointer to the returned data.  The contents stored here
                    depend on the reason for termination (See below).

    p1 - Optional pointer, to be passed to the callback function.

Return Value:

    This function can return one of three values.  The data stored in
    'ReturnData' depends upon which value is returned:

        NormalReturn   - if the whole process completes uninterrupted
                         (ReturnData is not used)
        EnumFileError  - if an error occurs while enumerating files
                         (ReturnData contains the error code)
        CallbackReturn - if the callback returns FALSE, causing termination
                         (ReturnData contains data defined by the callback)

--*/
{
    HANDLE                     hFindFile;
    NTSTATUS                   Status;
    UNICODE_STRING             PathName;
    OBJECT_ATTRIBUTES          Obja;
    IO_STATUS_BLOCK            IoStatusBlock;
    PFILE_BOTH_DIR_INFORMATION DirectoryInfo;
    BOOLEAN                    bStartScan;
    ENUMFILESRESULT            ret;

    //
    // Prepare to open the directory
    //
    RtlInitUnicodeString(&PathName, DirName);
    InitializeObjectAttributes(
       &Obja,
       &PathName,
       OBJ_CASE_INSENSITIVE,
       NULL,
       NULL
       );


    //
    // Open the specified directory for list access
    //
    Status = NtOpenFile(
        &hFindFile,
        FILE_LIST_DIRECTORY | SYNCHRONIZE,
        &Obja,
        &IoStatusBlock,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_FOR_BACKUP_INTENT
        );

    if(!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to open directory %ws for list (%lx)\n",
                   DirName,
                   Status));

        *ReturnData = Status;
        return EnumFileError;
    }


    DirectoryInfo = RtlAllocateHeap(RtlProcessHeap(),
                                    MAKE_TAG( INIT_TAG ),
                                    DOS_MAX_PATH_LENGTH * 2 + sizeof(FILE_BOTH_DIR_INFORMATION)
                                   );
    if(!DirectoryInfo) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to allocate memory for SpEnumFiles()\n"));

        *ReturnData = STATUS_INSUFFICIENT_RESOURCES;
        return EnumFileError;
    }

    bStartScan = TRUE;
    while(TRUE) {
        Status = NtQueryDirectoryFile(
            hFindFile,
            NULL,
            NULL,
            NULL,
            &IoStatusBlock,
            DirectoryInfo,
            (DOS_MAX_PATH_LENGTH * 2 + sizeof(FILE_BOTH_DIR_INFORMATION)),
            FileBothDirectoryInformation,
            TRUE,
            NULL,
            bStartScan
            );

        if(Status == STATUS_NO_MORE_FILES) {

            ret = NormalReturn;
            break;

        } else if(!NT_SUCCESS(Status)) {

            KdPrintEx((DPFLTR_SMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "SMSS: Unable to query directory %ws (%lx)\n",
                       DirName,
                       Status));

            *ReturnData = Status;
            ret = EnumFileError;
            break;
        }

        if(bStartScan) {
            bStartScan = FALSE;
        }

        //
        // Now pass this entry off to our callback function for processing
        //
        if(!EnumFilesProc(DirName, DirectoryInfo, ReturnData, p1)) {

            ret = CallbackReturn;
            break;
        }
    }

    RtlFreeHeap( RtlProcessHeap(), 0, DirectoryInfo );
    NtClose(hFindFile);
    return ret;
}

#endif // defined(REMOTE_BOOT)


NTSTATUS
SmpDeleteFile(
    IN PUNICODE_STRING pFile
    )
{
    NTSTATUS Status;
    IO_STATUS_BLOCK IoStatusBlock;
    OBJECT_ATTRIBUTES Obja;
    HANDLE Handle;
    FILE_DISPOSITION_INFORMATION Disposition;
    FILE_BASIC_INFORMATION       BasicInfo;

    InitializeObjectAttributes(
       &Obja,
       pFile,
       OBJ_CASE_INSENSITIVE,
       NULL,
       NULL
       );


    //
    // Attempt to open the file.
    //
    Status = NtOpenFile(
                &Handle,
                (ACCESS_MASK)(DELETE | FILE_WRITE_ATTRIBUTES),
                &Obja,
                &IoStatusBlock,
                FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE ,
                FILE_NON_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT
              );

    if(!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to open %ws for delete (%lx)\n",
                   pFile->Buffer,
                   Status));

        return(Status);
    }

    //
    //  Change the file attribute to normal
    //

    RtlZeroMemory( &BasicInfo, sizeof( FILE_BASIC_INFORMATION ) );
    BasicInfo.FileAttributes = FILE_ATTRIBUTE_NORMAL;

    Status = NtSetInformationFile(Handle,
                                  &IoStatusBlock,
                                  &BasicInfo,
                                  sizeof(BasicInfo),
                                  FileBasicInformation
                                 );

    if(!NT_SUCCESS(Status)) {
        KdPrintEx((DPFLTR_SMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "SMSS: Unable to change attribute of %ls. Status = (%lx)\n",
                   pFile->Buffer,
                   Status));

        return(Status);
    }

    //
    // Set up for delete and call worker to do it.
    //
    #undef DeleteFile
    Disposition.DeleteFile = TRUE;

    Status = NtSetInformationFile(Handle,
                                  &IoStatusBlock,
                                  &Disposition,
                                  sizeof(Disposition),
                                  FileDispositionInformation
                                 );

    //
    // Clean up and return.
    //
    NtClose(Handle);
    return(Status);
}

NTSTATUS
SmpCallCsrCreateProcess(
    IN OUT PSBAPIMSG m,
    IN size_t ArgLength,
    IN HANDLE CommunicationPort
    )
/*++

Routine Description:

    This function sends a message to CSR telling to start a process

Arguments:

    m - message to send
    ArgLength - length of argument struct inside message
    CommunicationPort - LPC port to send to

Return Value:

    NTSTATUS

--*/
{
    NTSTATUS Status;

    m->h.u1.s1.DataLength = ArgLength + 8;
    m->h.u1.s1.TotalLength = sizeof(SBAPIMSG);
    m->h.u2.ZeroInit = 0L;

    m->ApiNumber = SbCreateProcessApi;

    Status = NtRequestWaitReplyPort(CommunicationPort,
                                    (PPORT_MESSAGE) m,
                                    (PPORT_MESSAGE) m
                                    );

    if (NT_SUCCESS( Status )) {
        Status = m->ReturnedStatus;
    }

    return Status;
}