windows-nt-4.0/private/os2/server/srvname.c

/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    srvname.c

Abstract:

    This is the name space module for the OS/2 Subsystem Server

Author:

    Steve Wood (stevewo) 22-Aug-1989

Environment:

    User Mode Only

Revision History:

   Yaron Shamir (yarons) 4-Apr-91: Added Os2ComputeValidDrives, to
        fix initialization and computation of valid drives, to cope
        with new SM initialization and with redirected drives .
   Yaron Shamir (yarons) 6-May-91: changed the way we get at default
        and boot drives (matches Dos now).
   Yaron Shamir (yarons) 6-Aug-91: support named pipes.
   Yaron Shamir (yarons) 26-Aug-91: support UNC names.
   Beni Lavi (benil) 3-Mar-92: support mailslots
   Michael Jarus (mjaruss) 31-Mar-93: Remove Os2ComputeValidDrives
   Patrick Questembert (PatrickQ) 19-Mar-1995: Add COM10-16

--*/

#include "os2srv.h"
#include "os2win.h"

char * __cdecl getenv(char *varname);

PSECURITY_DESCRIPTOR securityDescriptor;

struct _INITIAL_OBJDIRS {
    PWSTR Name;
    PHANDLE Handle;
} InitialObjectDirectories[] = {
    {L"DEVICES", &Os2DevicesDirectory},
    {L"QUEUES", NULL},
    {L"SHAREMEM", NULL},
    {L"SEMAPHORES", NULL},
    {NULL, NULL}
};


struct _INITIAL_OBJDIRS Os2Drives =
        {L"DRIVES", &Os2DrivesDirectory};

HANDLE Os2NamedPipesDirectory;
HANDLE Os2UNCDirectory;
HANDLE Os2MailslotDirectory;
HANDLE Os2RegistryDirectory;

struct _INITIAL_RMT_OBJDIRS {
    PWSTR Name;
    PHANDLE Handle;
    PWSTR TargetName;
}  InitialRmtObjectDirectories[] = {
        {L"PIPE",     &Os2NamedPipesDirectory, L"\\DosDevices\\PIPE" },
        {L"UNC",      &Os2UNCDirectory,        L"\\DosDevices\\UNC" },
        {L"MAILSLOT", &Os2MailslotDirectory,   L"\\DosDevices\\MAILSLOT" },
        {NULL,       NULL,                    NULL}
};

//
// The InitialDevices table contains the values of symbolic links for
// special OS/2 files (devices).
// The first character of the Target field is used to specifiy the type
// of the device so that Od2Canonicalize() (in client\dllname.c) can
// determine and return it. Following characters are the value of the
// symbolic link which Od2Canonicalize returns as the canonicalized
// file name.
//
// Current defined types (first character of the Target field) are:
//
// @       FILE_TYPE_PSDEV
// #       FILE_TYPE_COM
// (space) FILE_TYPE_DEV
//

struct _INITIAL_DEVICES {
    PWSTR Name;
    PWSTR Target;
} InitialDevices[] = {
    {L"NUL"      , L"@@0"},
    {L"CON"      , L"@@1"},
    {L"AUX"      , L"#\\DosDevices\\COM1"},
    {L"COM1"     , L"#\\DosDevices\\COM1"},
    {L"COM2"     , L"#\\DosDevices\\COM2"},
    {L"COM3"     , L"#\\DosDevices\\COM3"},
    {L"COM4"     , L"#\\DosDevices\\COM4"},
    {L"COM5"     , L"#\\DosDevices\\COM5"},
    {L"COM6"     , L"#\\DosDevices\\COM6"},
    {L"COM7"     , L"#\\DosDevices\\COM7"},
    {L"COM8"     , L"#\\DosDevices\\COM8"},
    {L"COM9"     , L"#\\DosDevices\\COM9"},
    {L"COM10"     , L"#\\DosDevices\\COM10"},
    {L"COM11"     , L"#\\DosDevices\\COM11"},
    {L"COM12"     , L"#\\DosDevices\\COM12"},
    {L"COM13"     , L"#\\DosDevices\\COM13"},
    {L"COM14"     , L"#\\DosDevices\\COM14"},
    {L"COM15"     , L"#\\DosDevices\\COM15"},
    {L"COM16"     , L"#\\DosDevices\\COM16"},
    {L"PRN"      , L" \\DosDevices\\LPT1"},
    {L"LPT1"     , L" \\DosDevices\\LPT1"},
    {L"LPT2"     , L" \\DosDevices\\LPT2"},
    {L"LPT3"     , L" \\DosDevices\\LPT3"},
    {L"LPT4"     , L" \\DosDevices\\LPT4"},
    {L"LPT5"     , L" \\DosDevices\\LPT5"},
    {L"LPT6"     , L" \\DosDevices\\LPT6"},
    {L"LPT7"     , L" \\DosDevices\\LPT7"},
    {L"LPT8"     , L" \\DosDevices\\LPT8"},
    {L"LPT9"     , L" \\DosDevices\\LPT9"},
    {L"KBD$"     , L"@@4"},
    {L"MOUSE$"   , L"@@5"},
    {L"CLOCK$"   , L"@@6"},
    {L"SCREEN$"  , L"@@7"},
    {L"POINTER$" , L"@@8"},
    {NULL, NULL}
};

CHAR DeviceDirectoryName[] = "\\Device\\";
CHAR DeviceNameStr[] = "DEVICENAME";

//
// Information relevant for config.sys processing by the server
//
static WCHAR ConfigSysRegDir[] =
L"\\REGISTRY\\MACHINE\\SOFTWARE\\Microsoft\\OS/2 Subsystem for NT\\1.0\\config.sys";
static WCHAR ConfigSysValue[] = L"Config.Sys";

// BUGBUG - Beni, move those to GetNextDeviceNameFromConfigDotSys
static BOOLEAN ConfigDotSysWasRead = FALSE;
static ULONG FileSize = 0;
static ULONG CurrentOffset = 0;
static ANSI_STRING ConfigSysValueData_A = {0, 0, NULL};

//
// Process the config.sys file
// Returns TRUE if a line of the form:
//
// DEVICENAME=xxx [yyy]
//
// was detected in config.sys
// The string 'xxx' is returned in DeviceName
// If string 'yyy' is present its value is returned in TargetName
// Otherwise, a NUL string is returned in TargetName
//
// This routine may be called multiple time. Each time it returns the next
// DEVICENAME value string. When there are no more such values, the routine
// returns FALSE.
//
// The information read from the registry is of type REG_MULTI_SZ
// It used to be REG_SZ with CR-LF separating the lines. Therefore,
// the code accepts both lines that terminate with CR-LF and lined
// that terminate with NUL.
//
BOOLEAN
GetNextDeviceNameFromConfigDotSys(
    PSZ DeviceName,
    PSZ TargetName
    )
{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES Obja;
    PSZ Name;
    PSZ TName;
    CHAR ch;
    UNICODE_STRING ConfigSysRegDir_U;
    UNICODE_STRING ConfigSysValue_U;
    UNICODE_STRING ConfigSysValueData_U;
    HANDLE ConfigSysKeyHandle;
    ULONG ResultLength;
    KEY_VALUE_PARTIAL_INFORMATION KeyValuePartialInfo;
    PKEY_VALUE_PARTIAL_INFORMATION pInfo;

    if (!ConfigDotSysWasRead)
    {
        //
        // Copy the config.sys image from the registry to memory
        //
        RtlInitUnicodeString(&ConfigSysRegDir_U, ConfigSysRegDir);
        InitializeObjectAttributes(&Obja,
                                   &ConfigSysRegDir_U,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);

        Status = NtOpenKey(&ConfigSysKeyHandle,
                           KEY_READ,
                           &Obja
                          );
        if (!NT_SUCCESS(Status))
        {
#if DBG
            IF_OS2_DEBUG(CLEANUP)
            {
                KdPrint(("OS2SRV: FAILED - NtOpenKey() of config.sys %lx\n",
                    Status));
            }
#endif
            return (FALSE);
        }
        RtlInitUnicodeString(&ConfigSysValue_U, ConfigSysValue);
        Status = NtQueryValueKey(ConfigSysKeyHandle,
                                 &ConfigSysValue_U,
                                 KeyValuePartialInformation,
                                 &KeyValuePartialInfo,
                                 sizeof(KeyValuePartialInfo),
                                 &ResultLength
                                );
        if (!NT_SUCCESS(Status) && (Status != STATUS_BUFFER_OVERFLOW))
        {
#if DBG
            IF_OS2_DEBUG(CLEANUP) {
                KdPrint(("OS2SRV: FAILED - NtQueryValueKey-1 %lx\n",
                    Status));
            }
#endif
            return (FALSE);
        }

        pInfo = (PKEY_VALUE_PARTIAL_INFORMATION)RtlAllocateHeap(Os2Heap, 0, ResultLength);
        if (pInfo == NULL)
        {
#if DBG
            IF_OS2_DEBUG(CLEANUP)
            {
                KdPrint(("OS2SRV: FAILED - RtlAllocateHeap\n"));
            }
#endif
            return (FALSE);
        }

        Status = NtQueryValueKey(ConfigSysKeyHandle,
                                 &ConfigSysValue_U,
                                 KeyValuePartialInformation,
                                 pInfo,
                                 ResultLength,
                                 &ResultLength
                                );
        NtClose(ConfigSysKeyHandle);
        if (!NT_SUCCESS(Status))
        {
#if DBG
            IF_OS2_DEBUG(CLEANUP)
            {
                KdPrint(("OS2SRV: FAILED - NtQueryValueKey %lx\n",
                    Status));
            }
#endif
            RtlFreeHeap(Os2Heap, 0, pInfo);
            return (FALSE);
        }

        //
        // The information in the registry is Unicode.
        // Convert it to ANSI. Initialize explicity the UNICODE_STRING
        // structure since the data in the registry is of type REG_MULTI_SZ
        // and hence contains embedded NULs.
        //

        ConfigSysValueData_U.Buffer = (PWSTR)pInfo->Data;
        ConfigSysValueData_U.Length = (USHORT)pInfo->DataLength - 2;
        ConfigSysValueData_U.MaximumLength = (USHORT)pInfo->DataLength;

        Status = RtlUnicodeStringToAnsiString(&ConfigSysValueData_A,
                                &ConfigSysValueData_U, TRUE);
        RtlFreeHeap(Os2Heap, 0, pInfo);
        if (!NT_SUCCESS(Status))
        {
#if DBG
            IF_OS2_DEBUG(CLEANUP)
            {
                KdPrint(("OS2SRV: FAILED - RtlUnicodeStringToAnsiString %lx\n",
                    Status));
            }
#endif
            return (FALSE);
        }

        FileSize = ConfigSysValueData_A.Length;
        CurrentOffset = 0;
        ConfigDotSysWasRead = TRUE;
    }

    while (CurrentOffset < FileSize)
    {
        // skip leading blanks
        while ((ConfigSysValueData_A.Buffer[CurrentOffset] == ' ') ||
               (ConfigSysValueData_A.Buffer[CurrentOffset] == '\t'))
        {
            CurrentOffset++;
            if (CurrentOffset >= FileSize)
            {
                RtlFreeAnsiString(&ConfigSysValueData_A);
                return (FALSE);
            }
        }
        if ((CurrentOffset + sizeof(DeviceNameStr) - 1) >= FileSize)
        {
            RtlFreeAnsiString(&ConfigSysValueData_A);
            return (FALSE);
        }
        // check if the first name in the line is DEVICENAME
        if (_strnicmp(&ConfigSysValueData_A.Buffer[CurrentOffset], DeviceNameStr, sizeof(DeviceNameStr)-1)) {
            while ((ConfigSysValueData_A.Buffer[CurrentOffset] != '\n') &&
                   (ConfigSysValueData_A.Buffer[CurrentOffset] != '\0'))
            {
                CurrentOffset++;
                if (CurrentOffset >= FileSize)
                {
                    RtlFreeAnsiString(&ConfigSysValueData_A);
                    return (FALSE);
                }
            }
            CurrentOffset++;
            continue;
        }
        CurrentOffset += sizeof(DeviceNameStr)-1;
        // skip possible blanks between DEVICENAME and =
        while ((ConfigSysValueData_A.Buffer[CurrentOffset] == ' ') ||
               (ConfigSysValueData_A.Buffer[CurrentOffset] == '\t'))
        {
            CurrentOffset++;
            if (CurrentOffset >= FileSize)
            {
                RtlFreeAnsiString(&ConfigSysValueData_A);
                return (FALSE);
            }
        }
        // verify that there is an = after the DEVICENAME
        if (ConfigSysValueData_A.Buffer[CurrentOffset] != '=')
        {
            while ((ConfigSysValueData_A.Buffer[CurrentOffset] != '\n') &&
                   (ConfigSysValueData_A.Buffer[CurrentOffset] != '\0'))
            {
                CurrentOffset++;
                if (CurrentOffset >= FileSize)
                {
                    RtlFreeAnsiString(&ConfigSysValueData_A);
                    return (FALSE);
                }
            }
            CurrentOffset++;
            continue;
        }
        else
        {
            CurrentOffset++; // skip the '='
            if (CurrentOffset >= FileSize)
            {
                RtlFreeAnsiString(&ConfigSysValueData_A);
                return (FALSE);
            }
        }
        // skip possible blanks between = and the device name
        while ((ConfigSysValueData_A.Buffer[CurrentOffset] == ' ') ||
               (ConfigSysValueData_A.Buffer[CurrentOffset] == '\t'))
        {
            CurrentOffset++;
            if (CurrentOffset >= FileSize)
            {
                RtlFreeAnsiString(&ConfigSysValueData_A);
                return (FALSE);
            }
        }
        // process the device name

        Name = DeviceName;
        while (((ch = ConfigSysValueData_A.Buffer[CurrentOffset]) != '\r') &&
               (ch != '\n') &&
               (ch != ' ') &&
               (ch != '\t') &&
               (ch != '\0')
            )
        {
            *Name++ = ch;
            CurrentOffset++;
            if (CurrentOffset >= FileSize)
            {
                *Name = '\0';
                return (TRUE);
            }
        }
        *Name = '\0';
        if (*DeviceName == '\0')
        {
            //
            // Null device name, return false
            //
            RtlFreeAnsiString(&ConfigSysValueData_A);
            return (FALSE);
        }
        // skip possible blanks and commas between the Device name and the Target name
        while ((ConfigSysValueData_A.Buffer[CurrentOffset] == ' ') ||
               (ConfigSysValueData_A.Buffer[CurrentOffset] == ',') ||
               (ConfigSysValueData_A.Buffer[CurrentOffset] == '\t'))
        {
            CurrentOffset++;
            if (CurrentOffset >= FileSize)
            {
                RtlFreeAnsiString(&ConfigSysValueData_A);
                return (FALSE);
            }
        }
        // process the device target name
        TName = TargetName;
        // first put a blank to match the rest of the devices
        *TName++ = ' ';
        while (((ch = ConfigSysValueData_A.Buffer[CurrentOffset]) != '\r') &&
               (ch != '\n') &&
               (ch != ' ') &&
               (ch != '\t') &&
               (ch != '\0')
            )
        {
            *TName++ = ch;
            CurrentOffset++;
            if (CurrentOffset >= FileSize)
            {
                *TName = '\0';
                return (TRUE);
            }
        }
        *TName = '\0';
        // did we have a target name?
        if (TName == (TargetName+1))
        {
           // No - it's only the space we had put - nullify
           *TargetName = '\0';
        }

        while ((ConfigSysValueData_A.Buffer[CurrentOffset] != '\n') &&
               (ConfigSysValueData_A.Buffer[CurrentOffset] != '\0'))
        {
            CurrentOffset++;
            if (CurrentOffset >= FileSize)
            {
                return (TRUE);
            }
        }
        CurrentOffset++;
        return (TRUE);
    }

    RtlFreeAnsiString(&ConfigSysValueData_A);
    return (FALSE);
}


NTSTATUS
Os2InitializeNameSpace( VOID )
{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING DirectoryName_U;
    HANDLE DirectoryHandle;
    PHANDLE Directory;
    UNICODE_STRING LinkTarget_U, LinkName_U;
    HANDLE LinkHandle;
    CHAR localSecurityDescriptor[SECURITY_DESCRIPTOR_MIN_LENGTH];
    ULONG i;
    ANSI_STRING DeviceName_A;
    ANSI_STRING TargetDeviceName_A;
    CHAR DeviceName[32];
    CHAR TargetDeviceName[48];

    //
    // Create a root directory in the object name space that will be used
    // to contain all of the named objects created by the OS/2 Emulation
    // subsystem.
    //

    RtlInitUnicodeString( &DirectoryName_U, OS2_SS_ROOT_OBJECT_DIRECTORY );

    Status = RtlCreateSecurityDescriptor( (PSECURITY_DESCRIPTOR)
                                          &localSecurityDescriptor,
                                          SECURITY_DESCRIPTOR_REVISION );
    ASSERT( NT_SUCCESS( Status ) );
    if (! NT_SUCCESS( Status )) {
        return Status;
    }

    Status = RtlSetDaclSecurityDescriptor( (PSECURITY_DESCRIPTOR)
                                           &localSecurityDescriptor,
                                           (BOOLEAN)TRUE,
                                           (PACL) NULL,
                                           (BOOLEAN)FALSE );
    ASSERT (NT_SUCCESS(Status));
    if (! NT_SUCCESS( Status )) {
        return Status;
    }

    securityDescriptor = (PSECURITY_DESCRIPTOR) &localSecurityDescriptor;

    InitializeObjectAttributes(
                    &ObjectAttributes,
                    &DirectoryName_U,
                    OBJ_CASE_INSENSITIVE,
//                  OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
                    NULL,
                    securityDescriptor
                    );

    Status = NtOpenDirectoryObject( &Os2RootDirectory,
                                      DIRECTORY_ALL_ACCESS,
                                      &ObjectAttributes
                                    );

    if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
    {
       ULONG i = 100;   // 10 seconds

#if DBG
        KdPrint(("OS2SRV: wait for os2ss to initialize\n"));
#endif
       while (Status == STATUS_OBJECT_NAME_NOT_FOUND && i > 0)
       {
            //
            // Wait 0.1 sec  for os2ss to complete initialization
            //
            Sleep (100L);
#if DBG
            KdPrint(("."));
#endif
            Status = NtOpenDirectoryObject( &Os2RootDirectory,
                                              DIRECTORY_ALL_ACCESS,
                                              &ObjectAttributes
                                            );
            i--;
       }
    }
    if (! NT_SUCCESS( Status ))
    {
#if DBG
        KdPrint(("OS2SRV: SubSystem = Can't open \\os2ss directory object\n"));
#endif
        return Status;
    }

    //
    // Make the Drives directory a symbolic link
    // of \DosDevices
    //
    RtlInitUnicodeString( &DirectoryName_U, Os2Drives.Name );
    RtlInitUnicodeString( &LinkTarget_U, L"\\DosDevices" );

    InitializeObjectAttributes( &ObjectAttributes,
                                    &DirectoryName_U,
                    //                OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
                                    OBJ_CASE_INSENSITIVE,
                                    Os2RootDirectory,
                                    securityDescriptor
                                  );
    Status = NtCreateSymbolicLinkObject( Os2Drives.Handle,
                                         SYMBOLIC_LINK_ALL_ACCESS,
                                         &ObjectAttributes,
                                         &LinkTarget_U
                                         );
    if (Status == STATUS_OBJECT_NAME_COLLISION) {
                //
                // An os2srv is already present, print out and exit
                //
#if DBG
        KdPrint(( "OS2SRV: Unable to initialize server.  An instance of OS2SRV already runs. Status == %X\n",
                  Status
                ));
#endif

        NtTerminateProcess( NtCurrentProcess(), Status );
    }

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

    for (i=0; InitialObjectDirectories[ i ].Name; i++) {
        RtlInitUnicodeString( &DirectoryName_U, InitialObjectDirectories[ i ].Name );
        Directory = InitialObjectDirectories[ i ].Handle;
        if (Directory == NULL) {
            Directory = &DirectoryHandle;
        }

        InitializeObjectAttributes( &ObjectAttributes,
                                    &DirectoryName_U,
                    //                OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
                                    OBJ_CASE_INSENSITIVE,
                                    Os2RootDirectory,
                                    securityDescriptor
                                  );
        Status = NtCreateDirectoryObject( Directory,
                                          DIRECTORY_ALL_ACCESS,
                                          &ObjectAttributes
                                        );
        ASSERT( NT_SUCCESS( Status ) );
        if (! NT_SUCCESS( Status )) {
            KdPrint(("OS2SRV: FAILED - NtCreateDirectoryObject stts= %lx\n",
                    Status));
            return Status;
        }

        if (Directory == &DirectoryHandle) {
            NtClose( DirectoryHandle );
        }
    }

    for (i=0; InitialDevices[ i ].Name; i++) {
        RtlInitUnicodeString( &LinkName_U, InitialDevices[ i ].Name );
        RtlInitUnicodeString( &LinkTarget_U, InitialDevices[ i ].Target );

        InitializeObjectAttributes( &ObjectAttributes,
                                    &LinkName_U,
                                    // OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
                                    OBJ_CASE_INSENSITIVE,
                                    Os2DevicesDirectory,
                                    securityDescriptor
                                  );
        Status = NtCreateSymbolicLinkObject( &LinkHandle,
                                             SYMBOLIC_LINK_ALL_ACCESS,
                                             &ObjectAttributes,
                                             &LinkTarget_U
                                           );
        ASSERT( NT_SUCCESS( Status ) );
        if (! NT_SUCCESS( Status )) {
            return Status;
        }

//        NtClose( LinkHandle );
    }

    //
    // Make the remote directories a symbolic link of \DosDevices\*
    //
    for (i =0; InitialRmtObjectDirectories[i].Name != NULL; i++) {
        RtlInitUnicodeString( &DirectoryName_U, InitialRmtObjectDirectories[i].Name );
        RtlInitUnicodeString( &LinkTarget_U, InitialRmtObjectDirectories[i].TargetName);

        InitializeObjectAttributes( &ObjectAttributes,
                                    &DirectoryName_U,
                                    OBJ_CASE_INSENSITIVE,
                                    // OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
                                    Os2RootDirectory,
                                    securityDescriptor
                                  );
        Status = NtCreateSymbolicLinkObject( InitialRmtObjectDirectories[i].Handle,
                                             SYMBOLIC_LINK_ALL_ACCESS,
                                             &ObjectAttributes,
                                             &LinkTarget_U
                                             );
        ASSERT( NT_SUCCESS( Status ) );
        if (! NT_SUCCESS( Status )) {
            return Status;
        }
    }

    //
    // Process config.sys for the DEVICENAME= definitions
    //

    while (GetNextDeviceNameFromConfigDotSys(DeviceName, TargetDeviceName))
    {
#if DBG
        if (TargetDeviceName[0] == '\0') {
            KdPrint(("OS2SRV: Read DEVICENAME=%s from config.sys\n", DeviceName));
        }
        else {
            KdPrint(("OS2SRV: Read DEVICENAME=%s %s from config.sys\n",
                     DeviceName, TargetDeviceName));
        }
#endif
        RtlInitAnsiString(&DeviceName_A, DeviceName);
        RtlAnsiStringToUnicodeString( &LinkName_U, &DeviceName_A, (BOOLEAN)TRUE );
        if (TargetDeviceName[0] == '\0') {
            strcpy(TargetDeviceName, DeviceDirectoryName);
            strcat(TargetDeviceName, DeviceName);
        }
        RtlInitAnsiString(&TargetDeviceName_A, TargetDeviceName);
        RtlAnsiStringToUnicodeString( &LinkTarget_U, &TargetDeviceName_A, (BOOLEAN)TRUE );

        InitializeObjectAttributes( &ObjectAttributes,
                                    &LinkName_U,
                                    OBJ_CASE_INSENSITIVE,
                                    Os2DevicesDirectory,
                                    securityDescriptor
                                  );
        Status = NtCreateSymbolicLinkObject( &LinkHandle,
                                             SYMBOLIC_LINK_ALL_ACCESS,
                                             &ObjectAttributes,
                                             &LinkTarget_U
                                           );
        RtlFreeUnicodeString(&LinkName_U);
        RtlFreeUnicodeString(&LinkTarget_U);

        if (! NT_SUCCESS( Status )) {
#if DBG
            KdPrint(("OS2SRV: Could not Link Device '%s' to target devices\n", DeviceName));
#endif
        }
    }

    return( Os2InitializeDriveLetters() );
}


BOOLEAN
Os2CheckValidCDrives(VOID)
{
    NTSTATUS Status;
    HANDLE LinkHandle;
    UNICODE_STRING DriveName_U;
    WCHAR DriveString[15] = L"\\DosDevices\\C:";
    OBJECT_ATTRIBUTES Attributes;

        //
        // compute the valid drives from scratch, since
        // redirected drives appear and disappear dynamically
        //

    RtlInitUnicodeString(&DriveName_U, DriveString);

    InitializeObjectAttributes(
                &Attributes,
                &DriveName_U,
                OBJ_CASE_INSENSITIVE,
                NULL,
                NULL);
    Status = NtOpenSymbolicLinkObject( &LinkHandle,
                                       SYMBOLIC_LINK_QUERY,
                                       &Attributes
                                 );
    if (Status != STATUS_OBJECT_NAME_NOT_FOUND) {

        NtClose( LinkHandle );
        return(TRUE);
    }
    return (FALSE);
}


NTSTATUS
Os2InitializeDriveLetters( VOID )
{
    //
    // Set the SystemDrive number from the environment
    //

    SystemRootValuePtr = getenv("SYSTEMROOT");
    if (SystemRootValuePtr == NULL) {
        SystemRootValuePtr = "C:\\";
    }
    Os2DefaultDrive = (ULONG)(RtlUpperChar(*SystemRootValuePtr) - 'A');

    Os2BootDrive = 2; // C:

    //
    // check if not C:
    //

    if (!Os2CheckValidCDrives()) {
        Os2BootDrive = 0; // A:
        if (Os2DefaultDrive == 2) {
             Os2DefaultDrive = 0; // A:
        }
    }
    return STATUS_SUCCESS;
}


NTSTATUS
Os2GetClientId( VOID )
{
    NTSTATUS Status;
    HANDLE LinkHandle;
    OBJECT_ATTRIBUTES Attributes;
    UNICODE_STRING DebugClientId_U;
    UNICODE_STRING ClientIdString_U;

        Os2DebugUserClientId.UniqueProcess = NULL;

        RtlInitUnicodeString(&DebugClientId_U, L"DebugClientId");
        InitializeObjectAttributes(
                    &Attributes,
                    &DebugClientId_U,
                    OBJ_CASE_INSENSITIVE,
                    Os2RootDirectory,
                    NULL);
        Status = NtOpenSymbolicLinkObject( &LinkHandle,
                                           SYMBOLIC_LINK_QUERY,
                                           &Attributes
                                     );

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

        ClientIdString_U.Buffer = (PWSTR)&Os2DebugUserClientId;
        ClientIdString_U.Length = 0;
        ClientIdString_U.MaximumLength = sizeof( Os2DebugUserClientId );
        Status = NtQuerySymbolicLinkObject( LinkHandle,
                                            &ClientIdString_U,
                                            NULL
                                          );

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

        return Status;
}