windows-server-2003/termsrv/regapi/query.c

/*************************************************************************
*
* query.c
*
* Query Register APIs
*
* Copyright (c) 1998 Microsoft Corporation
*
*
*************************************************************************/

/*
 *  Includes
 */
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>

#include <ntddkbd.h>
#include <ntddmou.h>
#include <winstaw.h>
#include <regapi.h>


/*
 *  Procedures defined
 */
VOID QueryWinStaCreate( HKEY, PWINSTATIONCREATE );
VOID QueryUserConfig( HKEY, PUSERCONFIG, PWINSTATIONNAMEW );
VOID QueryConfig( HKEY, PWINSTATIONCONFIG, PWINSTATIONNAMEW );
VOID QueryNetwork( HKEY, PNETWORKCONFIG );
VOID QueryNasi( HKEY, PNASICONFIG );
VOID QueryAsync( HKEY, PASYNCCONFIG );
VOID QueryOemTd( HKEY, POEMTDCONFIG );
VOID QueryFlow( HKEY, PFLOWCONTROLCONFIG );
VOID QueryConnect( HKEY, PCONNECTCONFIG );
VOID QueryCd( HKEY, PCDCONFIG );
VOID QueryWd( HKEY, PWDCONFIG );
VOID QueryPdConfig( HKEY, PPDCONFIG, PULONG );
VOID QueryPdConfig2( HKEY, PPDCONFIG2, ULONG );
VOID QueryPdConfig3( HKEY, PPDCONFIG3, ULONG );
VOID QueryPdParams( HKEY, SDCLASS, PPDPARAMS );
BOOLEAN WINAPI RegBuildNumberQuery( PULONG );
BOOLEAN RegQueryOEMId( PBYTE, ULONG );
BOOLEAN WINAPI RegGetCitrixVersion(WCHAR *, PULONG);

BOOLEAN IsWallPaperDisabled( HKEY );
BOOLEAN IsCursorBlinkDisabled( HKEY );

/*
 * procedures used
 */
DWORD GetNumValue( HKEY, LPWSTR, DWORD );
DWORD GetNumValueEx( HKEY, LPWSTR, DWORD, DWORD );
LONG GetStringValue( HKEY, LPWSTR, LPWSTR, LPWSTR, DWORD );
LONG GetStringValueEx( HKEY, LPWSTR, DWORD, LPWSTR, LPWSTR, DWORD );
VOID UnicodeToAnsi( CHAR *, ULONG, WCHAR * );
DWORD GetStringFromLSA( LPWSTR, LPWSTR, DWORD );

//
//From gpdata.cpp
//
BOOLEAN
GPGetStringValue( HKEY policyKey,
                LPWSTR ValueName,
                LPWSTR pValueData,
                DWORD MaxValueSize,
                BOOLEAN *pbValueExists);

/*******************************************************************************
 *
 *  QueryWinStaCreate
 *
 *     query WINSTATIONCREATE structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pCreate (output)
 *       address to return WINSTATIONCREATE structure
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryWinStaCreate( HKEY Handle,
                   PWINSTATIONCREATE pCreate )
{
    pCreate->fEnableWinStation = (BOOLEAN) GetNumValue( Handle,
                                                       WIN_ENABLEWINSTATION,
                                                       TRUE );
    pCreate->MaxInstanceCount = GetNumValue( Handle,
                                                                     WIN_MAXINSTANCECOUNT,
                                                                     1 );
}


/*******************************************************************************
 *
 *  QueryTSProfileAndHomePaths
 *
 *     query WFProfilePath and WFHomeDir from Machine settings
 *
 * ENTRY:
 *
 *    pUser (input)
 *       pointer to USERCONFIG structure
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/
VOID QueryTSProfileAndHomePaths(PUSERCONFIG pUser)
{
    HKEY hTSControlKey = NULL;	//handle to REG_CONTROL_TSERVER key	
    BOOLEAN bValueExists;

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, REG_CONTROL_TSERVER, 0, KEY_READ, &hTSControlKey) == ERROR_SUCCESS)
    {
        if (hTSControlKey )
        {
            pUser->fErrorInvalidProfile = !GPGetStringValue(hTSControlKey, WIN_WFPROFILEPATH,  
                pUser->WFProfilePath, DIRECTORY_LENGTH + 1, &bValueExists);

            GetStringValue(hTSControlKey, WIN_WFHOMEDIR, NULL, pUser->WFHomeDir, DIRECTORY_LENGTH + 1);
        }

        if (hTSControlKey)
            RegCloseKey(hTSControlKey);
    }
}

/*******************************************************************************
 *
 *  QueryUserConfig
 *
 *     query USERCONFIG structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pUser (input)
 *       pointer to USERCONFIG structure
 *    pwszWinStationName (input)
 *       winstation name (string) that we're querying the user config for
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryUserConfig( HKEY Handle,
                 PUSERCONFIG pUser,
                 PWINSTATIONNAMEW pwszWinStationName )
{
    UCHAR seed;
    UNICODE_STRING UnicodePassword;
    WCHAR          encPassword[ PASSWORD_LENGTH + 2 ];
    LPWSTR         pwszPasswordKeyName = NULL;
    DWORD          dwKeyNameLength;

    // set an empty password
    encPassword[0] = (WCHAR) NULL;

    pUser->fInheritAutoLogon =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITAUTOLOGON, TRUE );

    pUser->fInheritResetBroken =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITRESETBROKEN, TRUE );

    pUser->fInheritReconnectSame =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITRECONNECTSAME, TRUE );

    pUser->fInheritInitialProgram =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITINITIALPROGRAM, TRUE );

    pUser->fInheritCallback =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITCALLBACK, FALSE );

    pUser->fInheritCallbackNumber =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITCALLBACKNUMBER, TRUE );

    pUser->fInheritShadow =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITSHADOW, TRUE );

    pUser->fInheritMaxSessionTime =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITMAXSESSIONTIME, TRUE );

    pUser->fInheritMaxDisconnectionTime =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITMAXDISCONNECTIONTIME, TRUE );

    pUser->fInheritMaxIdleTime =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITMAXIDLETIME, TRUE );

    pUser->fInheritAutoClient =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITAUTOCLIENT, TRUE );

    pUser->fInheritSecurity =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITSECURITY, FALSE );

	//NA 2/23/01
    pUser->fInheritColorDepth =
       (BOOLEAN) GetNumValue( Handle, WIN_INHERITCOLORDEPTH, TRUE );

    pUser->fPromptForPassword =
       (BOOLEAN) GetNumValue( Handle, WIN_PROMPTFORPASSWORD, FALSE );

    pUser->fResetBroken =
       (BOOLEAN) GetNumValue( Handle, WIN_RESETBROKEN, FALSE );

    pUser->fReconnectSame =
       (BOOLEAN) GetNumValue( Handle, WIN_RECONNECTSAME, FALSE );

    pUser->fLogonDisabled =
       (BOOLEAN) GetNumValue( Handle, WIN_LOGONDISABLED, FALSE );

    pUser->fAutoClientDrives =
       (BOOLEAN) GetNumValue( Handle, WIN_AUTOCLIENTDRIVES, TRUE );

    pUser->fAutoClientLpts =
       (BOOLEAN) GetNumValue( Handle, WIN_AUTOCLIENTLPTS, TRUE );

    pUser->fForceClientLptDef =
       (BOOLEAN) GetNumValue( Handle, WIN_FORCECLIENTLPTDEF, TRUE );

    pUser->fDisableEncryption =
       (BOOLEAN) GetNumValue( Handle, WIN_DISABLEENCRYPTION, TRUE );

    pUser->fHomeDirectoryMapRoot =
       (BOOLEAN) GetNumValue( Handle, WIN_HOMEDIRECTORYMAPROOT, FALSE );

    pUser->fUseDefaultGina =
       (BOOLEAN) GetNumValue( Handle, WIN_USEDEFAULTGINA, FALSE );

    pUser->fDisableCpm =
       (BOOLEAN) GetNumValue( Handle, WIN_DISABLECPM, FALSE );

    pUser->fDisableCdm =
       (BOOLEAN) GetNumValue( Handle, WIN_DISABLECDM, FALSE );

    pUser->fDisableCcm =
       (BOOLEAN) GetNumValue( Handle, WIN_DISABLECCM, FALSE );

    pUser->fDisableLPT =
       (BOOLEAN) GetNumValue( Handle, WIN_DISABLELPT, FALSE );

    pUser->fDisableClip =
       (BOOLEAN) GetNumValue( Handle, WIN_DISABLECLIP, FALSE );

    pUser->fDisableExe =
       (BOOLEAN) GetNumValue( Handle, WIN_DISABLEEXE, FALSE );

    pUser->fDisableCam =
       (BOOLEAN) GetNumValue( Handle, WIN_DISABLECAM, FALSE );

    GetStringValue( Handle, WIN_USERNAME, NULL, pUser->UserName,
                    USERNAME_LENGTH + 1 );

    GetStringValue( Handle, WIN_DOMAIN, NULL, pUser->Domain,
                    DOMAIN_LENGTH + 1 );
 
    //
    //  pull encrypted password out of LSA and decrypt it
    //

    // Build key name by appending the Winstation Name to the static KeyName
    // A WinStation Name must be passed in to store password
    if (pwszWinStationName != NULL)
    {
        // Build key name by appending the Winstation Name to the static KeyName
        dwKeyNameLength = wcslen(LSA_PSWD_KEYNAME) + 
                          wcslen(pwszWinStationName) + 1;
        
        // Allocate heap memory for the password KEY
        pwszPasswordKeyName = (LPWSTR)LocalAlloc(LPTR, dwKeyNameLength * sizeof(WCHAR));
        // if we failed to allocate memory just skip password querying
        if (pwszPasswordKeyName != NULL)
        {
            wcscpy(pwszPasswordKeyName, LSA_PSWD_KEYNAME);
            wcscat(pwszPasswordKeyName, pwszWinStationName);
            pwszPasswordKeyName[dwKeyNameLength - 1] = L'\0';

            // Get the password from LSA, if it failed, it's ok can mean key
            // isn't there and encPassword is set to NULL just continue
            GetStringFromLSA(pwszPasswordKeyName, 
                             encPassword, 
                             PASSWORD_LENGTH + 2);

            // Free up the password key we allocated above from the heap
            LocalFree(pwszPasswordKeyName);
        }
    }
    
    //  check for password if there is one then decrypt it
    if ( wcslen( encPassword ) ) {
        //  generate unicode string
        RtlInitUnicodeString( &UnicodePassword, &encPassword[1] );

        //  decrypt password in place
        seed = (UCHAR) encPassword[0];
        RtlRunDecodeUnicodeString( seed, &UnicodePassword );

        //  pull clear text password
        RtlMoveMemory( pUser->Password, &encPassword[1], sizeof(pUser->Password) );
    }
    else {
        //  set to null
        pUser->Password[0] = (WCHAR) NULL;
    }


    GetStringValue( Handle, WIN_WORKDIRECTORY, NULL, pUser->WorkDirectory,
                    DIRECTORY_LENGTH + 1 );

    GetStringValue( Handle, WIN_INITIALPROGRAM, NULL, pUser->InitialProgram,
                    INITIALPROGRAM_LENGTH + 1 );

    GetStringValue( Handle, WIN_CALLBACKNUMBER, NULL, pUser->CallbackNumber,
                    CALLBACK_LENGTH + 1 );

    pUser->Callback = GetNumValue( Handle, WIN_CALLBACK, Callback_Disable );

    pUser->Shadow = GetNumValue( Handle, WIN_SHADOW, Shadow_EnableInputNotify );

    pUser->MaxConnectionTime = GetNumValue( Handle, WIN_MAXCONNECTIONTIME, 0 );

    pUser->MaxDisconnectionTime = GetNumValue( Handle,
                                               WIN_MAXDISCONNECTIONTIME, 0 );

    pUser->MaxIdleTime = GetNumValue( Handle, WIN_MAXIDLETIME, 0 );

    pUser->KeyboardLayout = GetNumValue( Handle, WIN_KEYBOARDLAYOUT, 0 );

    pUser->MinEncryptionLevel = (BYTE) GetNumValue( Handle, WIN_MINENCRYPTIONLEVEL, 1 );

    pUser->fWallPaperDisabled = (BOOLEAN) IsWallPaperDisabled( Handle );

    pUser->fCursorBlinkDisabled = IsCursorBlinkDisabled( Handle );

    GetStringValue( Handle, WIN_NWLOGONSERVER, NULL, pUser->NWLogonServer,
                    NASIFILESERVER_LENGTH + 1 );

    //These don't exist at this registry level. They are actually two levels
    //up at the machine policy level.
    //GetStringValue( Handle, WIN_WFPROFILEPATH, NULL, pUser->WFProfilePath,
    //                DIRECTORY_LENGTH + 1 );

    //GetStringValue( Handle, WIN_WFHOMEDIR, NULL, pUser->WFHomeDir,
    //                DIRECTORY_LENGTH + 1 );

    GetStringValue( Handle, WIN_WFHOMEDIRDRIVE, NULL, pUser->WFHomeDirDrive,
                    4 );

    pUser->ColorDepth = GetNumValue( Handle, POLICY_TS_COLOR_DEPTH, TS_8BPP_SUPPORT  );



}


/*******************************************************************************
 *
 *  QueryConfig
 *
 *     query WINSTATIONCONFIG structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pConfig (output)
 *       address to return WINSTATIONCONFIG structure
 *    pWinStationName (input)
 *       Name of winstation we are querying
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryConfig( HKEY Handle,
             PWINSTATIONCONFIG pConfig,
             PWINSTATIONNAMEW pWinStationName )
{
    GetStringValue( Handle, WIN_COMMENT, NULL, pConfig->Comment,
                    WINSTATIONCOMMENT_LENGTH + 1 );

    QueryUserConfig( Handle, &pConfig->User, pWinStationName);

    (void) RegQueryOEMId( pConfig->OEMId, sizeof(pConfig->OEMId) );
}


/*******************************************************************************
 *
 *  QueryNetwork
 *
 *     Query NETWORKCONFIG structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pNetwork (output)
 *       address to return NETWORKCONFIG structure
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryNetwork( HKEY Handle,
              PNETWORKCONFIG pNetwork )
{
    pNetwork->LanAdapter = GetNumValue( Handle, WIN_LANADAPTER, 0 );
}


/*******************************************************************************
 *
 *  QueryNasi
 *
 *     Query NASICONFIG structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pNasi (output)
 *       address to return NASICONFIG structure
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryNasi( HKEY Handle,
           PNASICONFIG pNasi )
{
    UCHAR seed;
    UNICODE_STRING UnicodePassword;
    WCHAR encPassword[ NASIPASSWORD_LENGTH + 2 ];

    //  pull encrypted password out of registry
    GetStringValue( Handle, WIN_NASIPASSWORD, NULL, encPassword,
                    NASIPASSWORD_LENGTH + 1 );

    //  check for password if there is one then decrypt it
    if ( wcslen( encPassword ) ) {

        //  generate unicode string
        RtlInitUnicodeString( &UnicodePassword, &encPassword[1] );

        //  decrypt password in place
        seed = (UCHAR) encPassword[0];
        RtlRunDecodeUnicodeString( seed, &UnicodePassword );

        //  pull clear text password
        RtlMoveMemory( pNasi->PassWord, &encPassword[1], sizeof(pNasi->PassWord) );
    }
    else {

        //  set to null
        pNasi->PassWord[0] = (WCHAR) NULL;
    }

    GetStringValue( Handle, WIN_NASISPECIFICNAME, NULL, pNasi->SpecificName,
                    NASISPECIFICNAME_LENGTH + 1 );
    GetStringValue( Handle, WIN_NASIUSERNAME, NULL, pNasi->UserName,
                    NASIUSERNAME_LENGTH + 1 );
    GetStringValue( Handle, WIN_NASISESSIONNAME, NULL, pNasi->SessionName,
                    NASISESSIONNAME_LENGTH + 1 );
    GetStringValue( Handle, WIN_NASIFILESERVER, NULL, pNasi->FileServer,
                    NASIFILESERVER_LENGTH + 1 );
    pNasi->GlobalSession = (BOOLEAN)GetNumValue( Handle, WIN_NASIGLOBALSESSION, 0 );
}


/*******************************************************************************
 *
 *  QueryAsync
 *
 *     query ASYNCCONFIG structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pAsync (output)
 *       address to return ASYNCCONFIG structure
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryAsync( HKEY Handle,
            PASYNCCONFIG pAsync )
{
    GetStringValue( Handle, WIN_DEVICENAME, NULL, pAsync->DeviceName,
                    DEVICENAME_LENGTH + 1 );

    GetStringValue( Handle, WIN_MODEMNAME, NULL, pAsync->ModemName,
                    MODEMNAME_LENGTH + 1 );

    pAsync->BaudRate = GetNumValue( Handle, WIN_BAUDRATE, 9600 );

    pAsync->Parity = GetNumValue( Handle, WIN_PARITY, NOPARITY );

    pAsync->StopBits = GetNumValue( Handle, WIN_STOPBITS, ONESTOPBIT );

    pAsync->ByteSize = GetNumValue( Handle, WIN_BYTESIZE, 8 );

    pAsync->fEnableDsrSensitivity = (BOOLEAN) GetNumValue( Handle,
                                                      WIN_ENABLEDSRSENSITIVITY,
                                                      FALSE );

    pAsync->fConnectionDriver = (BOOLEAN) GetNumValue( Handle,
                                                       WIN_CONNECTIONDRIVER,
                                                       FALSE );

    QueryFlow( Handle, &pAsync->FlowControl );

    QueryConnect( Handle, &pAsync->Connect );
}

/*******************************************************************************
 *
 *  QueryOemTd
 *
 *     Query OEMTDCONFIG structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pOemTd (output)
 *       address to return OEMTDCONFIG structure
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryOemTd( HKEY Handle,
            POEMTDCONFIG pOemTd )
{
    pOemTd->Adapter = GetNumValue( Handle, WIN_OEMTDADAPTER, 0 );

    GetStringValue( Handle, WIN_OEMTDDEVICENAME, NULL, pOemTd->DeviceName,
                    DEVICENAME_LENGTH + 1 );

    pOemTd->Flags = GetNumValue( Handle, WIN_OEMTDFLAGS, 0 );
}


/*******************************************************************************
 *
 *  QueryFlow
 *
 *     query FLOWCONTROLCONFIG structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pFlow (output)
 *       address to return FLOWCONTROLCONFIG structure
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryFlow( HKEY Handle,
           PFLOWCONTROLCONFIG pFlow )
{
    pFlow->fEnableSoftwareRx = (BOOLEAN) GetNumValue( Handle,
                                                      WIN_FLOWSOFTWARERX,
                                                      FALSE );

    pFlow->fEnableSoftwareTx = (BOOLEAN) GetNumValue( Handle,
                                                      WIN_FLOWSOFTWARETX,
                                                      TRUE );

    pFlow->fEnableDTR = (BOOLEAN) GetNumValue( Handle, WIN_ENABLEDTR, TRUE );

    pFlow->fEnableRTS = (BOOLEAN) GetNumValue( Handle, WIN_ENABLERTS, TRUE );

    pFlow->XonChar = (UCHAR) GetNumValue( Handle, WIN_XONCHAR, 0 );

    pFlow->XoffChar = (UCHAR) GetNumValue( Handle, WIN_XOFFCHAR, 0 );

    pFlow->Type = GetNumValue( Handle, WIN_FLOWTYPE, FlowControl_Hardware );

    pFlow->HardwareReceive = GetNumValue( Handle, WIN_FLOWHARDWARERX,
                                          ReceiveFlowControl_RTS );

    pFlow->HardwareTransmit = GetNumValue( Handle, WIN_FLOWHARDWARETX,
                                           TransmitFlowControl_CTS );
}


/*******************************************************************************
 *
 *  QueryConnect
 *
 *     query CONNECTCONFIG structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pConnect (output)
 *       address to return CONNECTCONFIG structure
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryConnect( HKEY Handle,
              PCONNECTCONFIG pConnect )
{
    pConnect->Type = GetNumValue( Handle, WIN_CONNECTTYPE, Connect_DSR );

    pConnect->fEnableBreakDisconnect = (BOOLEAN) GetNumValue( Handle,
                                                    WIN_ENABLEBREAKDISCONNECT,
                                                    FALSE );
}


/*******************************************************************************
 *
 *  QueryCd
 *
 *     query CDCONFIG structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pCdConfig (output)
 *       address to return CDCONFIG structure
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryCd( HKEY Handle,
         PCDCONFIG pCdConfig )
{
    pCdConfig->CdClass = GetNumValue( Handle, WIN_CDCLASS, CdNone );

    GetStringValue( Handle, WIN_CDNAME, NULL, pCdConfig->CdName,
                    CDNAME_LENGTH + 1 );

    GetStringValue( Handle, WIN_CDDLL, L"", pCdConfig->CdDLL,
                    DLLNAME_LENGTH + 1 );

    pCdConfig->CdFlag = GetNumValue( Handle, WIN_CDFLAG, 0 );
}


/*******************************************************************************
 *
 *  QueryWd
 *
 *     query WDCONFIG structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pWd (output)
 *       address to return WDCONFIG structure
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryWd( HKEY Handle,
         PWDCONFIG pWd )
{
    GetStringValue( Handle, WIN_WDNAME, NULL, pWd->WdName, WDNAME_LENGTH + 1 );
    GetStringValue( Handle, WIN_WDDLL, L"", pWd->WdDLL, DLLNAME_LENGTH + 1 );
    GetStringValue( Handle, WIN_WSXDLL, NULL, pWd->WsxDLL, DLLNAME_LENGTH + 1 );
    pWd->WdFlag = GetNumValue( Handle, WIN_WDFLAG, 0 );
    pWd->WdInputBufferLength = GetNumValue( Handle, WIN_INPUTBUFFERLENGTH, 2048 );
    GetStringValue( Handle, WIN_CFGDLL, NULL, pWd->CfgDLL, DLLNAME_LENGTH + 1 );
    GetStringValue( Handle, WIN_WDPREFIX, NULL, pWd->WdPrefix, WDPREFIX_LENGTH + 1 );
}


/*******************************************************************************
 *
 *  QueryPdConfig
 *
 *     query PDCONFIG structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pConfig (output)
 *       address to return array of PDCONFIG structures
 *    pCount (input/output)
 *       pointer to number of PDCONFIG array elements
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryPdConfig( HKEY Handle,
                PPDCONFIG pConfig,
                PULONG pCount )
{
    ULONG i;

    for ( i=0; i < *pCount; i++ ) {

        QueryPdConfig2( Handle, &pConfig[i].Create, i );

        QueryPdParams( Handle,
                        pConfig[i].Create.SdClass,
                        &pConfig[i].Params );
    }

    *pCount = MAX_PDCONFIG;
}


/*******************************************************************************
 *
 *  QueryPdConfig2
 *
 *     query PDCONFIG2 structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pPd2 (output)
 *       address to return PDCONFIG2 structure
 *    Index (input)
 *       Index (array index)
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryPdConfig2( HKEY Handle,
                PPDCONFIG2 pPd2,
                ULONG Index )
{
    GetStringValueEx( Handle, WIN_PDNAME, Index,
                      NULL, pPd2->PdName, PDNAME_LENGTH + 1 );

    pPd2->SdClass = GetNumValueEx( Handle, WIN_PDCLASS, Index, Index==0 ? SdAsync : SdNone );

    GetStringValueEx( Handle, WIN_PDDLL, Index,
                      NULL, pPd2->PdDLL, DLLNAME_LENGTH + 1 );

    pPd2->PdFlag = GetNumValueEx( Handle, WIN_PDFLAG, Index, 0 );

    /* 
     *  The following data is the same for all pds
     */
    pPd2->OutBufLength =  GetNumValue( Handle, WIN_OUTBUFLENGTH, 530 );

    pPd2->OutBufCount = GetNumValue( Handle, WIN_OUTBUFCOUNT, 10 );

    pPd2->OutBufDelay = GetNumValue( Handle, WIN_OUTBUFDELAY, 100 );

    pPd2->InteractiveDelay = GetNumValue( Handle, WIN_INTERACTIVEDELAY, 10 );

    pPd2->KeepAliveTimeout = GetNumValue( Handle, WIN_KEEPALIVETIMEOUT, 0 );

    pPd2->PortNumber = GetNumValue( Handle, WIN_PORTNUMBER, 0 );
}

/*******************************************************************************
 *
 *  QueryPdConfig3
 *
 *     query PDCONFIG3 structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    pPd (output)
 *       address to return PDCONFIG3 structure
 *    Index (input)
 *       Index (array index)
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryPdConfig3( HKEY Handle,
                 PPDCONFIG3 pPd3,
                 ULONG Index )
{
    int i;
    ULONG Length;
    LPWSTR tmp;
    WCHAR PdName[ MAX_PDCONFIG * ( PDNAME_LENGTH + 1 ) + 1 ];
    ULONG ValueType;

    QueryPdConfig2( Handle, &pPd3->Data, Index );

    GetStringValue( Handle, WIN_SERVICENAME, NULL,
                    pPd3->ServiceName,
                    PDNAME_LENGTH + 1 );

    GetStringValue( Handle, WIN_CONFIGDLL, NULL,
                    pPd3->ConfigDLL,
                    DLLNAME_LENGTH + 1 );
    
    Length = sizeof(PdName);
    pPd3->RequiredPdCount = 0;
    if ( RegQueryValueEx( Handle, WIN_REQUIREDPDS, NULL, &ValueType,
                          (LPBYTE)PdName, &Length ) == ERROR_SUCCESS ) {
        tmp = PdName;
        i = 0;
        while ( *tmp != UNICODE_NULL ) {
            pPd3->RequiredPdCount++;
            wcscpy( pPd3->RequiredPds[i], tmp );
            i++;
            tmp += wcslen(tmp) + 1;
        }
    }
}

/*******************************************************************************
 *
 *  QueryPdParams
 *
 *     query PDPARAMS structure
 *
 * ENTRY:
 *
 *    Handle (input)
 *       registry handle
 *    SdClass (input)
 *       type of PD
 *    pParams (output)
 *       address to return PDPARAMS structure
 *
 * EXIT:
 *    nothing
 *
 ******************************************************************************/

VOID
QueryPdParams( HKEY Handle,
                SDCLASS SdClass,
                PPDPARAMS pParams )
{
    pParams->SdClass = SdClass;
    switch ( SdClass ) {
        case SdNetwork :
            QueryNetwork( Handle, &pParams->Network );
            break;
        case SdNasi :
            QueryNasi( Handle, &pParams->Nasi );
            break;
        case SdAsync :
            QueryAsync( Handle, &pParams->Async );
            break;
        case SdOemTransport :
            QueryOemTd( Handle, &pParams->OemTd );
            break;
    }
}

#define CONTROL_PANEL L"Control Panel"
#define DESKTOP       L"Desktop"
#define WALLPAPER     L"Wallpaper"
#define STRNONE       L"(None)"
#define CURSORBLINK   L"DisableCursorBlink"

/*******************************************************************************
 *
 *  IsWallPaperDisabled
 *
 *     Is the wall paper disabled?
 *
 * ENTRY:
 *    Handle (input)
 *       registry handle
 * EXIT:
 *    TRUE or FALSE (returns FALSE as default)
 *
 ******************************************************************************/
BOOLEAN IsWallPaperDisabled( HKEY Handle )
{
    HKEY Handle1;
    WCHAR KeyString[256];
    WCHAR KeyValue[256];
    DWORD KeyValueSize = sizeof(KeyValue);
    DWORD KeyValueType;
    DWORD Status;

    wcscpy( KeyString, WIN_USEROVERRIDE );
    wcscat( KeyString, L"\\" );
    wcscat( KeyString, CONTROL_PANEL );
    wcscat( KeyString, L"\\" );
    wcscat( KeyString, DESKTOP );

    if ( RegOpenKeyEx( Handle, KeyString, 0, KEY_READ,
                       &Handle1 ) != ERROR_SUCCESS )
        return FALSE;

    //
    // TS setup/REGAPI set WALLPAPER to NULL value or STRNONE to indicate
    // wallpaper is disabled and non-existance WALLPAPER to indicate
    // wallpaper is enabled; however, GetStringValue() treat NULL value
    // same as non-existance reg. value so we can't use GetStringValue().
    //
    ZeroMemory( KeyValue, KeyValueSize );
    Status = RegQueryValueEx( Handle1, WALLPAPER, NULL, &KeyValueType,
                              (LPBYTE) KeyValue, &KeyValueSize );

    RegCloseKey( Handle1 );

    if( ERROR_SUCCESS == Status && REG_SZ == KeyValueType ) {
        //
        // Valid value for WallPaper disable:
        // 1) TS setup sets WALLPAPER value to NULL value
        // 2) CreateUserConfig() sets WALLPAPER to STRNONE
        // 
        if( KeyValueSize == sizeof(UNICODE_NULL) || 
            _wcsicmp( STRNONE, KeyValue ) == 0 ) {

            return TRUE;
        }
    }

    return FALSE;
}



/*******************************************************************************
 *
 *  IsCursorBlinkDisabled
 *
 *     Is the cursor blink disabled?
 *
 * ENTRY:
 *    Handle (input)
 *       registry handle
 * EXIT:
 *    TRUE or FALSE (returns TRUE as default)
 *
 ******************************************************************************/
BOOLEAN IsCursorBlinkDisabled( HKEY Handle )
{
    HKEY Handle1;
    WCHAR KeyString[256];
    BOOLEAN ret;

    wcscpy( KeyString, WIN_USEROVERRIDE );
    wcscat( KeyString, L"\\" );
    wcscat( KeyString, CONTROL_PANEL );
    wcscat( KeyString, L"\\" );
    wcscat( KeyString, DESKTOP );

    if ( RegOpenKeyEx( Handle, KeyString, 0, KEY_READ,
                       &Handle1 ) != ERROR_SUCCESS )
        return FALSE;

    ret = (BOOLEAN) GetNumValue( Handle1, CURSORBLINK, 0 );
    RegCloseKey( Handle1 );

    return ret;
}

/*****************************************************************************
 *
 *  RegBuildNumberQuery
 *
 *   Query the current build number from the registry.
 *
 *   HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\Current Version\
 *       CurrentBuildNumber:REG_SZ:129
 *
 * ENTRY:
 *   Param1 (input/output)
 *     Comments
 *
 * EXIT:
 *   STATUS_SUCCESS - no error
 *
 ****************************************************************************/

BOOLEAN WINAPI
RegBuildNumberQuery(
    PULONG pBuildNum
    )
{
    ULONG  Result, Value;
    HKEY   hKey;
    WCHAR  Buf[256];

    Result = RegOpenKeyEx(
                 HKEY_LOCAL_MACHINE,
                 BUILD_NUMBER_KEY,
                 0, // Reserved
                 KEY_READ,
                 &hKey
                 );

    if( Result != ERROR_SUCCESS ) {
#if DBG
        DbgPrint("RegBuildNumberQuery: Failed to open key %ws\n",BUILD_NUMBER_KEY);
#endif
        return( FALSE );
    }

    Result = GetStringValue(
                 hKey,
                 BUILD_NUMBER_VALUE,
                 L"0",
                 Buf,
                 sizeof(Buf)
                 );

    if( Result != ERROR_SUCCESS ) {
#if DBG
        DbgPrint("RegBuildNumberQuery: Failed to query value %ws\n",BUILD_NUMBER_VALUE);
#endif
        RegCloseKey( hKey );
        return( FALSE );
    }

    RegCloseKey( hKey );

    //
    // Now must convert it into a number
    //
    Value = 0;
    swscanf( Buf, L"%d", &Value );

    *pBuildNum = Value;

    return( TRUE );
}


/*******************************************************************************
 *
 *  RegQueryOEMId
 *
 *    query oem id
 *
 * ENTRY:
 *
 *    pOEMId (output)
 *       pointer to buffer to return oem id
 *    Length (input)
 *       length of buffer
 *
 * EXIT:
 *
 *    TRUE  -- The operation succeeded.
 *
 *    FALSE -- The operation failed.  Extended error status is available
 *             using GetLastError.
 *
 ******************************************************************************/

BOOLEAN
RegQueryOEMId( PBYTE pOEMId, ULONG Length )
{
    HKEY Handle2;
    WCHAR OEMIdW[10];

    /*
     *  Open registry (LOCAL_MACHINE\....\Terminal Server)
     */
    if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE, REG_CONTROL_TSERVER, 0,
                       KEY_READ, &Handle2 ) == ERROR_SUCCESS ) {
        
        GetStringValue( Handle2, REG_CITRIX_OEMID, NULL, OEMIdW, 10 );
        UnicodeToAnsi( pOEMId, Length, OEMIdW );
        pOEMId[3] = '\0';

        RegCloseKey( Handle2 );
    }

    return( TRUE );
}


/*******************************************************************************
 *
 *  RegGetTServerVersion (UNICODE)
 *
 *    Get the Terminal Server version number from the specified server.
 *
 *    This version number is changed by Microsoft, and not OEM's.
 *
 * ENTRY:
 *    pServerName (input)
 *       Points to string of server to check.
 *
 * EXIT:
 *    TRUE if Hydra Terminal Server; FALSE otherwise
 *
 ******************************************************************************/

BOOLEAN WINAPI
RegGetTServerVersion(
    WCHAR * pServerName,
    PULONG  pVersionNumber
    )
{
    LONG Error;
    HKEY ServerHandle, UserHandle;
    ULONG Value;

    /*
     * Connect to registry of specified server.
     */
    if ( (Error = RegConnectRegistry( pServerName,
                                      HKEY_LOCAL_MACHINE,
                                      &ServerHandle )) != ERROR_SUCCESS )
        return( FALSE );

    /*
     * Open the Terminal Server key and get the Version value.
     */
    if ( (Error = RegOpenKeyEx( ServerHandle, REG_CONTROL_TSERVER, 0,
                                KEY_READ, &UserHandle )) != ERROR_SUCCESS ) {

        RegCloseKey( ServerHandle );
        return( FALSE );
    }

    Value = GetNumValue(
                UserHandle,
                REG_CITRIX_VERSION,
                0 );

    /*
     *  Close registry handles.
     */
    RegCloseKey( UserHandle );
    RegCloseKey( ServerHandle );

    *pVersionNumber = Value;

    return( TRUE );
}


/*******************************************************************************
 *
 *  RegQueryUtilityCommandList (UNICODE)
 *
 *    Allocate and build an array of PROGRAMCALL structures for the specified
 *    MultiUser utility.
 *
 * ENTRY:
 *    pUtilityKey (input)
 *       Points to string containing the utility's command registry key.
 *    ppProgramCall (output)
 *       Points to a PPROGRAMCALL variable that will be set to the API-allocated
 *       array of PROGRAMCALL structures, containing n elements, where n = 
 *       number of commands supported by the utility (as specified in the 
 *       registry).  The pFirst item of array element 0 will point to the 
 *       first command (sorted alphabetically by command name).  The pNext items
 *       are then used to walk the list, till pNext is NULL.
 *
 * EXIT:
 *      ERROR_SUCCESS if all goes well;
 *      An error code is returned if failure.
 *
 *      If success, the caller must call RegFreeUtilityCommandList with the
 *      ppProgramCall variable to free the PROGRAMCALL structure array when
 *      finished using the array.
 *
 *  The format of the REG_MULTI_SZ command item in the registry is as follows:
 *
 *      string 1: "0" or "1" (required)
 *
 *                  0 specifies that the command is a normal command which will
 *                  be presented as an option by the utility USAGE help.  1
 *                  indicates a command alias (hidden option), which won't 
 *                  appear in USAGE help.
 *
 *      string 2: "number" (required)
 *
 *                  Specifies the minimum number of characters that must be
 *                  typed for the command to be recognized (base 10).
 *
 *      string 3: "command" (required)
 *
 *                  This is the actual command that will be recognized and
 *                  displayed in the USAGE help (if not an aliased command).
 *
 *      string 4: "program" (required)
 *
 *                  The file name of the program that will be executed.  This
 *                  should be a standard name.extension filename, and can 
 *                  include a full path, although this is not necessary since
 *                  the utilities will normally reside in the standard SYSTEM32
 *                  directory, which is a part of the standard PATH.
 *
 *      string 5: "extra args" (optional)
 *
 *                  If specified, this string will be passed along to the
 *                  utilsub.lib ExecProgram API to specify additional
 *                  hard-coded arguments that will be used, in addition to any
 *                  other arguments that were specified by the user on the
 *                  command line.
 *
 *  Note: If the command item is not a REG_MULTI_SZ value, or the command item 
 *        is a REG_MULTI_SZ item but there is an error in its format, that 
 *        command will be omitted from the command list.  The return value 
 *        from this function will still be ERROR_SUCCESS, but the command in 
 *        error will be ignored by the utilities.
 *
 ******************************************************************************/

LONG WINAPI
RegQueryUtilityCommandList(
    LPWSTR pUtilityKey,
    PPROGRAMCALL * ppProgramCall
    )
{
    HKEY Handle = NULL;
    LONG status = ERROR_SUCCESS;
    DWORD iValue, cValues, ccValueName, cbValueData,
          ccTmpValueName, cbTmpValueData, dwType;
    LPWSTR pValueName = NULL, pValueData = NULL, pString;
    PPROGRAMCALL pProg = NULL, pProgNext, pProgPrev;
    ULONG ulCommandLen;
    PWCHAR pEndptr;
    int iCompare;

    *ppProgramCall = NULL;

    /*
     * Open specified utility key and determine number of values and maximum
     * value name and data length.
     */
    if ( status = RegOpenKeyEx( HKEY_LOCAL_MACHINE, 
                                pUtilityKey, 
                                0,
                                    KEY_READ, 
                                &Handle ) != ERROR_SUCCESS ) {
#if DBG
        DbgPrint("RegQueryUtilityCommandList: Can't open command list utility key %ws; error = %d\n", pUtilityKey, status);
#endif
        goto error;
    }

    if ( status = RegQueryInfoKey( Handle, 
                                   NULL,            // lpClass
                                   NULL,            // lpcbClass
                                   NULL,            // lpReserved
                                   NULL,            // lpcSubKeys
                                   NULL,            // lpcbMaxSubKeyLen
                                   NULL,            // lpcbMaxClassLen
                                   &cValues,        // lpcValues
                                   &ccValueName,    // lpcbMaxValueNameLen
                                   &cbValueData,    // lpcbMaxValueLen
                                   NULL,            // lpcbSecurityDescriptor
                                   NULL             // lpftLastWriteTime
                                   ) != ERROR_SUCCESS ) {
#if DBG
        DbgPrint("RegQueryUtilityCommandList: Can't query info for utility %ws; error = %d\n", pUtilityKey, status);
#endif
        goto error;
    }

    /*
     * Allocate space for #values + 1 PROGRAMCALL elements and value name and
     * data buffers.
     */
    if ( ((*ppProgramCall = (PPROGRAMCALL)LocalAlloc( LPTR, (sizeof(PROGRAMCALL) * (cValues+1)) )) == NULL) ||
         ((pValueName = (LPWSTR)LocalAlloc( LPTR, (int)(++ccValueName * sizeof(WCHAR)) )) == NULL) ||
         ((pValueData = (LPWSTR)LocalAlloc( LPTR, (int)cbValueData )) == NULL) ) {

        status = GetLastError();
#if DBG
        DbgPrint("RegQueryUtilityCommandList: Can't allocate memory buffer(s) for utility %ws; error = %d\n", pUtilityKey, status);
#endif
        goto error;
    }

    /*
     * Enumerate and parse each value into the PROGRAMCALL components.
     */
    for ( iValue = 0, pProg = *ppProgramCall; 
          iValue < cValues; 
          iValue++, pProg++ ) {

        ccTmpValueName = ccValueName;
        cbTmpValueData = cbValueData;
        if ( (status = RegEnumValue( Handle,
                                     iValue,
                                     pValueName,
                                     &ccTmpValueName,
                                     NULL,
                                     &dwType,
                                     (LPBYTE)pValueData,
                                     &cbTmpValueData )) != ERROR_SUCCESS ) {
#if DBG
            DbgPrint("RegQueryUtilityCommandList: Can't enumerate command (index = %d) for utility %ws; error = %d\n", iValue, pUtilityKey, status);
#endif

            goto error;
        }

        /*
         * If the data is not REG_MULTI_SZ, ignore it.
         */
        if ( dwType != REG_MULTI_SZ )
            goto CommandInError;

        /*
         * Allocate data storage for this command, then parse and assign 
         * to the PROGRAMCALL structure items.
         */
        if ( (pProg->pRegistryMultiString = LocalAlloc(LPTR, cbTmpValueData)) == NULL ) {

            status = GetLastError();
#if DBG
            DbgPrint("RegQueryUtilityCommandList: Can't allocate memory buffer for utility %ws; error = %d\n", pUtilityKey, status);
#endif
            goto error;
        }

        memcpy(pProg->pRegistryMultiString, pValueData, cbTmpValueData);
        pString = pProg->pRegistryMultiString;

        /*
         * Parse alias flag.
         */
        if ( !wcscmp(pString, L"1") )
            pProg->fAlias = TRUE;
        else if ( !wcscmp(pString, L"0") )
            pProg->fAlias = FALSE;
        else
            goto CommandInError;
        pString += (wcslen(pString) + 1);

        /*
         * Parse command length.
         */
        if ( *pString == L'\0' )
            goto CommandInError;
        ulCommandLen = wcstoul(pString, &pEndptr, 10);
        if ( *pEndptr != L'\0' )
            goto CommandInError;
        pProg->CommandLen = (USHORT)ulCommandLen;
        pString += (wcslen(pString) + 1);

        /*
         * Parse command string.
         */
        if ( *pString == L'\0' )
            goto CommandInError;
        pProg->Command = pString;
        pString += (wcslen(pString) + 1);

        /*
         * Parse program string.
         */
        if ( *pString == L'\0' )
            goto CommandInError;
        pProg->Program = pString;
        pString += (wcslen(pString) + 1);

        /*
         * Parse (optional) Args string.
         */
        if ( *pString != L'\0' )
            pProg->Args = pString;

        /*
         * Walk the command list to link this item in it's proper
         * sorted place.
         */
        if ( pProg == *ppProgramCall ) {

            pProg->pFirst = pProg;  // first item in the list

        } else for ( pProgPrev = pProgNext = (*ppProgramCall)->pFirst; ; ) {

            if ( (iCompare = _wcsicmp(pProg->Command, pProgNext->Command)) < 0 ) {

                pProg->pNext = pProgNext;       // point to next

                if ( pProgNext == (*ppProgramCall)->pFirst )
                    (*ppProgramCall)->pFirst = pProg;  // first item
                else
                    pProgPrev->pNext = pProg;   // link after previous

                break;

            } else if ( iCompare == 0 ) {

                goto CommandInError;    // duplicate command - ignore
            }

            if ( pProgNext->pNext == NULL ) {

                pProgNext->pNext = pProg;   // link at end of list
                break;

            } else {

                pProgPrev = pProgNext;
                pProgNext = pProgNext->pNext;
            }
        }

        continue;

CommandInError:
        /*
         * The command format is in error - ignore it.
         */
        if ( pProg->pRegistryMultiString )
            LocalFree(pProg->pRegistryMultiString);
        memset(pProg, 0, sizeof(PROGRAMCALL));
        pProg--;
    }

error:
    if ( Handle != NULL )
        RegCloseKey(Handle);

    if ( pValueName )
        LocalFree(pValueName);

    if ( pValueData )
        LocalFree(pValueData);

    if ( status != ERROR_SUCCESS ) {

        if ( *ppProgramCall ) {
            RegFreeUtilityCommandList(*ppProgramCall);
            *ppProgramCall = NULL;
        }
    }

    return( status );
}


/*******************************************************************************
 *
 *  RegFreeUtilityCommandList (UNICODE)
 *
 *    Free the specified array of PROGRAMCALL structures.
 *
 * ENTRY:
 *    pProgramCall (input)
 *       Points PROGRAMCALL array to free.
 *
 * EXIT:
 *      ERROR_SUCCESS if all goes well; error code if failure
 *
 ******************************************************************************/

LONG WINAPI
RegFreeUtilityCommandList(
    PPROGRAMCALL pProgramCall
    )
{
    PPROGRAMCALL pProg;
    LONG status = ERROR_SUCCESS;

    if ( pProgramCall ) {

        for ( pProg = pProgramCall->pFirst; pProg != NULL; pProg = pProg->pNext ) {

            if ( LocalFree( pProg->pRegistryMultiString ) != NULL ) {

                status = GetLastError();
#if DBG
                DbgPrint("RegFreeUtilityCommandList: Failed to free command list element for %ws; error = %d\n", pProg->Program, status);
#endif
            }
        }

        if ( LocalFree( pProgramCall ) != NULL ) {

            status = GetLastError();
#if DBG
            DbgPrint("RegFreeUtilityCommandList: Failed to free command list array; error = %d\n", status);
#endif
        }
    }

    return( status );
}