windows-server-2003/sdktools/cmdline/systeminfo/wmi.cpp

/*********************************************************************************************

Copyright (c) Microsoft Corporation

Module Name:

    WMI.cpp

Abstract:

    Common functionlity for dealing with WMI.

Author:

    Wipro Technologies

Revision History:

    22-Dec-2000 : Created It.
    24-Apr-2001 : Closing the review comments given by client.

*********************************************************************************************/

#include "pch.h"
#include "wmi.h"
#include "resource.h"

//
// messages
//
#define INPUT_PASSWORD              GetResString( IDS_STR_INPUT_PASSWORD )
#define INPUT_PASSWORD_LEN          256
// error constants
#define E_SERVER_NOTFOUND           0x800706ba

//
// private function prototype(s)
//
BOOL IsValidUserEx( LPCWSTR pwszUser );
HRESULT GetSecurityArguments( IUnknown* pInterface,
                              DWORD& dwAuthorization, DWORD& dwAuthentication );
HRESULT SetInterfaceSecurity( IUnknown* pInterface,
                              LPCWSTR pwszUser,
                              LPCWSTR pwszPassword, COAUTHIDENTITY** ppAuthIdentity );
HRESULT WINAPI SetProxyBlanket( IUnknown* pInterface,
                                DWORD dwAuthnSvc, DWORD dwAuthzSvc,
                                LPWSTR pwszPrincipal, DWORD dwAuthLevel, DWORD dwImpLevel,
                                RPC_AUTH_IDENTITY_HANDLE pAuthInfo, DWORD dwCapabilities );
HRESULT WINAPI WbemAllocAuthIdentity( LPCWSTR pwszUser, LPCWSTR pwszPassword,
                                      LPCWSTR pwszDomain, COAUTHIDENTITY** ppAuthIdent );
HRESULT RegQueryValueWMI( IWbemServices* pWbemServices,
                          LPCWSTR pwszMethod, DWORD dwHDefKey,
                          LPCWSTR pwszSubKeyName, LPCWSTR pwszValueName, _variant_t& varValue );


BOOL
IsValidUserEx(
    LPCWSTR pwszUser
    )
/*++

Routine Description:

    Checks wether the User name is a valid one or not

Arguments:

    [in] LPCWSTR    :   String containing the user name

Return Value:

    TRUE on success
    FALSE on failure

--*/
{
    // local variables
    CHString strUser;
    LONG lPos = 0;

    if ( ( NULL == pwszUser ) || ( 0 == StringLength( pwszUser, 0 ) ) )
    {
        return TRUE;
    }

    try
    {
        // get user into local memory
        strUser = pwszUser;

        // user name should not be just '\'
        if ( strUser.CompareNoCase( L"\\" ) == 0 )
        {
            return FALSE;
        }

        // user name should not contain invalid characters
        if ( strUser.FindOneOf( L"/[]:|<>+=;,?*" ) != -1 )
        {
            return FALSE;
        }

        // SPECIAL CHECK
        // check for multiple '\' characters in the user name
        lPos = strUser.Find( L'\\' );
        if ( -1 != lPos )
        {
            // '\' character exists in the user name
            // strip off the user info upto first '\' character
            // check for one more '\' in the remaining string
            // if it exists, invalid user
            strUser = strUser.Mid( lPos + 1 );
            lPos = strUser.Find( L'\\' );
            if ( -1 != lPos )
            {
                return FALSE;
            }
        }
    }
    catch( CHeap_Exception )
    {
        WMISaveError( WBEM_E_OUT_OF_MEMORY );
        return FALSE;
    }

    // user name is valid
    return TRUE;
}


BOOL
IsValidServerEx(
    LPCWSTR pwszServer,
    BOOL& bLocalSystem
    )
/*++

Routine Description:

    Checks wether the Server name is a valid one or not

Arguments:

    [in]  LPCWSTR   :   String containing the user name
    [out] BOOL      :   Is set to TRUE if the local system is being queried.

Return Value:

    TRUE on success
    FALSE on failure

--*/
{
    // local variables
    CHString strTemp;

    // Validate input arguments.
    if ( ( NULL == pwszServer ) || ( 0 == StringLength( pwszServer, 0 ) ) )
    {
       bLocalSystem = TRUE;
       return TRUE;
    }

    try
    {
        // kick-off
        bLocalSystem = FALSE;

        if( IsNumeric( pwszServer, 10, FALSE ) == TRUE )
        {
            return FALSE;
        }

        // get a local copy
        strTemp = pwszServer;

        // remove the forward slashes (UNC) if exist in the begining of the server name
        if ( IsUNCFormat( strTemp ) == TRUE )
        {
            strTemp = strTemp.Mid( 2 );
            if ( strTemp.GetLength() == 0 )
            {
                return FALSE;
            }
        }

        if ( strTemp.FindOneOf( L"`~!@#$^&*()+=[]{}|\\<>,?/\"':;" ) != -1 )
        {
            return FALSE;
        }

        // now check if any '\' character appears in the server name. If so error
        if ( strTemp.Find( L'\\' ) != -1 )
        {
            return FALSE;
        }

        // now check if server name is '.' only which represent local system in WMI
        // else determine whether this is a local system or not
        if ( strTemp.CompareNoCase( L"." ) == 0 )
        {
            bLocalSystem = TRUE;
        }
        else
        {
            bLocalSystem = IsLocalSystem( strTemp );
        }
    }
    catch( CHeap_Exception )
    {
        WMISaveError( WBEM_E_OUT_OF_MEMORY );
        return FALSE;
    }

    // inform that server name is valid
    return TRUE;
}


BOOL
InitializeCom(
    IWbemLocator** ppLocator
    )
/*++
Routine Description:

    Initializes the COM library

Arguments:

    [in] IWbemLocator   :   pointer to the IWbemLocator

Return Value:

    TRUE on success
    FALSE on failure

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF FALSE IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

--*/
{
    // local variables
    HRESULT hr = S_OK;
    BOOL bResult = FALSE;

    try
    {
        // Validate input arguments.
        if( ( NULL == ppLocator ) ||
            ( NULL != *ppLocator ) )
        {
             _com_issue_error( WBEM_E_INVALID_PARAMETER );
        }




        // initialize the COM library
        SAFE_EXECUTE( CoInitializeEx( NULL, COINIT_MULTITHREADED ) );

        // initialize the security
        SAFE_EXECUTE( CoInitializeSecurity( NULL, -1, NULL, NULL,
            RPC_C_AUTHN_LEVEL_NONE, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, 0 ) );

        // create the locator and get the pointer to the interface of IWbemLocator
        SAFE_EXECUTE( CoCreateInstance( CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER,
            IID_IWbemLocator, ( LPVOID* ) ppLocator ) );

        // initialization successful
        bResult = TRUE;
    }
    catch( _com_error& e )
    {
        // save the WMI error
        WMISaveError( e );
        // Error is returned. Release any interface pointers.
        SAFE_RELEASE( *ppLocator );
    }

    // return the result;
    return bResult;
}


BOOL
ConnectWmi(
    IWbemLocator* pLocator,
    IWbemServices** ppServices,
    LPCWSTR pwszServer,
    LPCWSTR pwszUser,
    LPCWSTR pwszPassword,
    COAUTHIDENTITY** ppAuthIdentity,
    BOOL bCheckWithNullPwd,
    LPCWSTR pwszNamespace,
    HRESULT* phr,
    BOOL* pbLocalSystem,
    IWbemContext* pWbemContext
    )
/*++

Routine Description:

    This function makes a connection to WMI.

Arguments:

    [in] IWbemLocator           :   pointer to the IWbemLocator
    [in] IWbemServices          :   pointer to the IWbemServices
    [in] LPCWSTR                :   string containing the server name
    [in] LPCWSTR                :   string containing the User name
    [in] LPCWSTR                :   string containing the password
    [in] COAUTHIDENTITY         :   pointer to AUTHIDENTITY structure
    [in] BOOL                   :   set to TRUE if we should try to connect with
                                    current credentials
    [in] LPCWSTR                :   string containing the namespace to connect to
    [out] HRESULT               :   the hResult value returned
    [out] BOOL                  :   set to TRUE if we are querying for the local system

Return Value:

    TRUE on success
    FALSE on failure

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF FALSE IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

--*/
{
    // local variables
    HRESULT hr = S_OK;
    BOOL bResult = FALSE;
    BOOL bLocalSystem = FALSE;
    _bstr_t bstrServer;
    _bstr_t bstrNamespace;
    _bstr_t bstrUser, bstrPassword;

    // clear the error
    SetLastError( WBEM_S_NO_ERROR );

    // check whether locator object exists or not
    // if not exists, return
    if ( ( NULL == pLocator ) ||
         ( NULL == ppServices ) ||
         ( NULL != *ppServices ) ||
         ( NULL == pwszNamespace ) )
    {
        if ( NULL != phr )
        {
            *phr = WBEM_E_INVALID_PARAMETER;
        }
        // return failure
        return FALSE;
    }

    // kick-off
    if ( NULL != pbLocalSystem )
    {
        *pbLocalSystem = FALSE;
    }

    // ...
    if ( NULL != phr )
    {
        *phr = WBEM_S_NO_ERROR;
    }

    try
    {

        // assume that connection to WMI namespace is failed
        bResult = FALSE;

        // validate the server name
        // NOTE: The error being raised in custom define for '0x800706ba' value
        //       The message that will be displayed in "The RPC server is unavailable."
        if ( IsValidServerEx( pwszServer, bLocalSystem ) == FALSE )
        {
            _com_issue_error( E_SERVER_NOTFOUND );
        }

        // validate the user name
        if ( IsValidUserEx( pwszUser ) == FALSE )
        {
            _com_issue_error( ERROR_NO_SUCH_USER );
        }

        // prepare namespace
        bstrNamespace = pwszNamespace;              // name space
        if ( ( NULL != pwszServer ) && ( FALSE == bLocalSystem ) )
        {
            // get the server name
            bstrServer = pwszServer;

            // prepare the namespace
            // NOTE: check for the UNC naming format of the server and do
            if ( IsUNCFormat( pwszServer ) == TRUE )
            {
                bstrNamespace = bstrServer + L"\\" + pwszNamespace;
            }
            else
            {
                bstrNamespace = L"\\\\" + bstrServer + L"\\" + pwszNamespace;
            }

            // user credentials
            if ( ( NULL != pwszUser ) && ( 0 != StringLength( pwszUser, 0 ) ) )
            {
                // copy the user name
                bstrUser = pwszUser;

                // if password is empty string and if we need to check with
                // null password, then do not set the password and try
                bstrPassword = pwszPassword;
                if ( ( TRUE == bCheckWithNullPwd ) && ( 0 == bstrPassword.length() ) )
                {
                    bstrPassword = (LPWSTR) NULL;
                }
            }
        }
        else
        {    // Display warning message, credentials not required for local system.
            if( ( TRUE == bLocalSystem ) && ( NULL != pwszUser ) &&
                ( 0 != StringLength( pwszUser, 0 ) ) )
            {
                 // got the credentials for the local system
                 if ( NULL != phr )
                 {
                     *phr = WBEM_E_LOCAL_CREDENTIALS;
                 }
            }
        }

        // connect to the remote system's WMI
        // there is a twist here ...
        // do not trap the ConnectServer function failure into exception
        // instead handle that action manually
        // by default try the ConnectServer function as the information which we have
        // in our hands at this point. If the ConnectServer is failed,
        // check whether password variable has any contents are not ... if no contents
        // check with "" (empty) password ... this might pass in this situation ..
        // if this call is also failed ... nothing is there that we can do ... throw the exception
        hr = pLocator->ConnectServer( bstrNamespace,
            bstrUser, bstrPassword, 0L, 0L, NULL, pWbemContext, ppServices );
        if ( FAILED( hr ) )
        {
            //
            // special case ...

            // check whether password exists or not
            // NOTE: do not check for 'WBEM_E_ACCESS_DENIED'
            //       this error code says that user with the current credentials is not
            //       having access permisions to the 'namespace'
            if ( hr == E_ACCESSDENIED )
            {
                // check if we tried to connect to the system using null password
                // if so, then try connecting to the remote system with empty string
                if ( bCheckWithNullPwd == TRUE &&
                     bstrUser.length() != 0 && bstrPassword.length() == 0 )
                {
                    // now invoke with ...
                    hr = pLocator->ConnectServer( bstrNamespace,
                        bstrUser, _bstr_t( L"" ), 0L, 0L, NULL, pWbemContext, ppServices );
                }
            }
            else
            {
                if ( WBEM_E_LOCAL_CREDENTIALS == hr )
                {
                    // credentials were passed to the local system.
                    // So ignore the credentials and try to reconnect
                    bLocalSystem = TRUE;
                    bstrUser = (LPWSTR) NULL;
                    bstrPassword = (LPWSTR) NULL;
                    bstrNamespace = pwszNamespace;              // name space
                    hr = pLocator->ConnectServer( bstrNamespace,
                        NULL, NULL, 0L, 0L, NULL, pWbemContext, ppServices );
                }
            }

            // now check the result again .. if failed .. ummmm..
            if ( FAILED( hr ) )
            {
                _com_issue_error( hr );
            }
            else
            {
                bstrPassword = L"";
            }
        }

        // set the security at the interface level also
        SAFE_EXECUTE( SetInterfaceSecurity( *ppServices,
            bstrUser, bstrPassword, ppAuthIdentity ) );

        // ...
        if ( NULL != pbLocalSystem )
        {
            *pbLocalSystem = bLocalSystem;
        }

        // connection to WMI is successful
        bResult = TRUE;
    }
    catch( _com_error& e )
    {
        // save the error
        WMISaveError( e );

        // save the hr value if needed by the caller
        if ( NULL != phr )
        {
            *phr = e.Error();
        }
        SAFE_RELEASE( *ppServices );
        bResult = FALSE;
    }

    // return the result
    return bResult;
}


BOOL
ConnectWmiEx(
    IWbemLocator* pLocator,
    IWbemServices** ppServices,
    LPCWSTR pwszServer,
    CHString& strUserName,
    CHString& strPassword,
    COAUTHIDENTITY** ppAuthIdentity,
    BOOL bNeedPassword,
    LPCWSTR pwszNamespace,
    BOOL* pbLocalSystem,
    DWORD dwPasswordLen,
    IWbemContext* pWbemContext
    )
/*++

Routine Description:

    This function is a wrapper function for the ConnectWmi function.

Arguments:

    [in] IWbemLocator           :   pointer to the IWbemLocator
    [in] IWbemServices          :   pointer to the IWbemServices
    [in] LPCWSTR                :   string containing the server name
    [in] LPCWSTR                :   string containing the User name
    [in] LPCWSTR                :   string containing the password
    [in] COAUTHIDENTITY         :   pointer to AUTHIDENTITY structure
    [in] BOOL                   :   set to TRUE if we should try to connect with
                                    current credentials
    [in] LPCWSTR                :   string containing the namespace to connect to
    [out] HRESULT               :   the hResult value returned
    [out] BOOL                  :   set to TRUE if we are querying for the local system
    [ in ] DWORD                :   Contains maximum password buffer length.

Return Value:

    TRUE on success
    FALSE on failure

NOTE: 'dwPasswordLen' WILL BE TAKEN AS 'MAX_STRING_LENGTH' IF NOT SPECIFIED.
      IT IS USER RESPOSIBILITY TO SET THIS PARAMETER TO LIMITING VALUE.

--*/
{
    // local variables
    HRESULT hr = S_OK;
    DWORD dwSize = 0;
    BOOL bResult = FALSE;
    LPWSTR pwszPassword = NULL;
    CHString strBuffer;

    // clear the error .. if any
    SetLastError( WBEM_S_NO_ERROR );

    try
    {
        // sometime users want the utility to prompt for the password
        // check what user wants the utility to do
        if ( ( TRUE == bNeedPassword ) &&
             ( 0 == strPassword.Compare( L"*" ) ) )
        {
            // user wants the utility to prompt for the password
            // so skip this part and let the flow directly jump the password acceptance part
        }
        else
        {
            // try to establish connection to the remote system with the credentials supplied
            if ( 0 == strUserName.GetLength() )
            {
                // user name is empty
                // so, it is obvious that password will also be empty
                // even if password is specified, we have to ignore that
                bResult = ConnectWmi( pLocator, ppServices,
                    pwszServer, NULL, NULL, ppAuthIdentity, FALSE, pwszNamespace, &hr, pbLocalSystem, pWbemContext );
            }
            else
            {
                // credentials were supplied
                // but password might not be specified ... so check and act accordingly
                LPCWSTR pwszTemp = NULL;
                BOOL bCheckWithNull = TRUE;
                if ( bNeedPassword == FALSE )
                {
                    pwszTemp = strPassword;
                    bCheckWithNull = FALSE;
                }

                // ...
                bResult = ConnectWmi( pLocator, ppServices, pwszServer,
                    strUserName, pwszTemp, ppAuthIdentity, bCheckWithNull, pwszNamespace, &hr, pbLocalSystem, pWbemContext );
            }

            SetLastError (hr);

            // check the result ... if successful in establishing connection ... return
            if ( TRUE == bResult )
            {
                return TRUE;
            }

            // now check the kind of error occurred
            switch( hr )
            {
            case E_ACCESSDENIED:
                SetLastError( hr );
                break;

            case WBEM_E_LOCAL_CREDENTIALS:
                SetLastError( hr );
                // needs to do special processing
                break;

            case WBEM_E_ACCESS_DENIED:
            default:
                // NOTE: do not check for 'WBEM_E_ACCESS_DENIED'
                //       this error code says that user with the current credentials is not
                //       having access permisions to the 'namespace'
                WMISaveError( hr );
                return FALSE;       // no use of accepting the password .. return failure
                break;
            }


            // if failed in establishing connection to the remote terminal
            // even if the password is specifed, then there is nothing to do ... simply return failure
            if ( bNeedPassword == FALSE )
            {
                return FALSE;
            }
        }

        // check whether user name is specified or not
        // if not, get the local system's current user name under whose credentials, the process
        // is running
        if ( 0 == strUserName.GetLength() )
        {
            // sub-local variables
            LPWSTR pwszUserName = NULL;
            DWORD dwUserLength = 0;    // Username buffer length.
            // Retrieve the buffer length need to store username.
            GetUserNameEx( NameSamCompatible, pwszUserName, &dwUserLength );

            // get the required buffer
            pwszUserName = strUserName.GetBufferSetLength( dwUserLength );

            if ( FALSE == GetUserNameEx( NameSamCompatible, pwszUserName, &dwUserLength ) )
            {
                // error occured while trying to get the current user info
                SaveLastError();
                return FALSE;
            }
            // No need to call 'ReleaseBuffer' since only sufficient memory is allocated.
        }

        // get the required buffer
        if( 0 == dwPasswordLen )
        {
             dwPasswordLen = INPUT_PASSWORD_LEN;
        }
        pwszPassword = strPassword.GetBufferSetLength( dwPasswordLen );

        // accept the password from the user
        strBuffer.Format( INPUT_PASSWORD, strUserName );
        WriteConsoleW( GetStdHandle( STD_OUTPUT_HANDLE ),
            strBuffer, strBuffer.GetLength(), &dwSize, NULL );

        bResult = GetPassword( pwszPassword, dwPasswordLen );
        if ( TRUE != bResult )
        {
            return FALSE;
        }

        // release the buffer allocated for password
        strPassword.ReleaseBuffer();

        // now again try to establish the connection using the currently
        // supplied credentials
        bResult = ConnectWmi( pLocator, ppServices, pwszServer,
            strUserName, strPassword, ppAuthIdentity, FALSE, pwszNamespace,
            NULL, pbLocalSystem, pWbemContext );
    }
    catch( CHeap_Exception )
    {
        WMISaveError( WBEM_E_OUT_OF_MEMORY );
        return FALSE;
    }

    // return the failure
    return bResult;
}


HRESULT
GetSecurityArguments(
    IUnknown* pInterface,
    DWORD& dwAuthorization,
    DWORD& dwAuthentication
    )
/*++

Routine Description:

    This function gets the values for the security services.

Arguments:

    [in] IUnknown   :   pointer to the IUnkown interface
    [out] DWORD     :   to hold the authentication service value
    [out] DWORD     :   to hold the authorization service value

Return Value:

    HRESULT

--*/
{
    // local variables
    HRESULT hr = S_OK;
    DWORD dwAuthnSvc = 0, dwAuthzSvc = 0;
    IClientSecurity* pClientSecurity = NULL;

    if ( NULL == pInterface )
    {
        return WBEM_E_INVALID_PARAMETER;
    }
    // try to get the client security services values if possible
    hr = pInterface->QueryInterface( IID_IClientSecurity, (void**) &pClientSecurity );
    if ( SUCCEEDED( hr ) )
    {
        // got the client security interface
        // now try to get the security services values
        hr = pClientSecurity->QueryBlanket( pInterface,
            &dwAuthnSvc, &dwAuthzSvc, NULL, NULL, NULL, NULL, NULL );
        if ( SUCCEEDED( hr ) )
        {
            // we've got the values from the interface
            dwAuthentication = dwAuthnSvc;
            dwAuthorization = dwAuthzSvc;
        }

        // release the client security interface
        SAFE_RELEASE( pClientSecurity );
    }

    // return always success
    return hr;
}


HRESULT
SetInterfaceSecurity(
    IUnknown* pInterface,
    LPCWSTR pwszUser,
    LPCWSTR pwszPassword,
    COAUTHIDENTITY** ppAuthIdentity
    )
/*++

Routine Description:

    This function sets the interface security parameters.

Arguments:

    [in] IUnknown           :   pointer to the IUnkown interface
    [in] LPCWSTR            :   string containing the User name
    [in] LPCWSTR            :   string containing the password
    [in] COAUTHIDENTITY     :   pointer to AUTHIDENTITY structure

Return Value:

    HRESULT

--*/
{
    // local variables
    HRESULT hr = S_OK;
    CHString strUser;
    CHString strDomain;
    LPCWSTR pwszUserArg = NULL;
    LPCWSTR pwszDomainArg = NULL;
    DWORD dwAuthorization = RPC_C_AUTHZ_NONE;
    DWORD dwAuthentication = RPC_C_AUTHN_WINNT;

    try
    {
        // check the interface
        if ( NULL == pInterface )
        {
            return WBEM_E_INVALID_PARAMETER;
        }

        // check the authentity strcuture ... if authentity structure is already ready
        // simply invoke the 2nd version of SetInterfaceSecurity
        if ( NULL != *ppAuthIdentity )
        {
            return SetInterfaceSecurity( pInterface, *ppAuthIdentity );
        }

        // If we are doing trivial case, just pass in a null authenication structure
        // for which the current logged in user's credentials will be considered
        if ( ( NULL == pwszUser ) &&
             ( NULL == pwszPassword ) )
        {
            // set the security
            hr = SetProxyBlanket( pInterface, dwAuthentication, dwAuthorization,
                NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY , RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE );

            // return the result
            return hr;
        }

        // if authority srtucture is NULL then no need to proceed
        if ( NULL == ppAuthIdentity )
        {
            return WBEM_E_INVALID_PARAMETER;
        }

        // check if authenication info is available or not ...
        // initialize the security authenication information ... UNICODE VERSION STRUCTURE
        if ( NULL == *ppAuthIdentity )
        {
            // parse and find out if the user name contains the domain name
            // if contains, extract the domain value from it
            LONG lPos = -1;
            strDomain = L"";
            strUser = pwszUser;
            if ( -1 != ( lPos = strUser.Find( L'\\' ) ) )
            {
                // user name contains domain name ... domain\user format
                strDomain = strUser.Left( lPos );
                strUser = strUser.Mid( lPos + 1 );
            }
            else
            {
                if ( -1 != ( lPos = strUser.Find( L'@' ) ) )
                {
                    // NEED TO IMPLEMENT THIS ... IF NEEDED
                    // This implementation needs to be done if WMI does not support
                    // UPN name formats directly and if we have to split the
                    // name(user@domain)
                }
                else
                {
                    // server itself is the domain
                    // NOTE: NEED TO DO SOME R & D ON BELOW COMMENTED LINE
                    // strDomain = pwszServer;
                }
             }

            // get the domain info if it exists only
            if ( 0 != strDomain.GetLength() )
            {
                pwszDomainArg = strDomain;
            }

            // get the user info if it exists only
            if ( 0 != strUser.GetLength() )
            {
                pwszUserArg = strUser;
            }

            hr = WbemAllocAuthIdentity( pwszUserArg, pwszPassword, pwszDomainArg, ppAuthIdentity );
            if ( FAILED(hr) )
            {
              return hr;
            }
        }

        // set the security information to the interface
        hr = SetProxyBlanket( pInterface, dwAuthentication, dwAuthorization, NULL,
            RPC_C_AUTHN_LEVEL_PKT_PRIVACY , RPC_C_IMP_LEVEL_IMPERSONATE, *ppAuthIdentity, EOAC_NONE );
    }
    catch( CHeap_Exception )
    {
        hr = WBEM_E_OUT_OF_MEMORY;
    }

    // return the result
    return hr;
}


HRESULT
SetInterfaceSecurity(
    IUnknown* pInterface,
    COAUTHIDENTITY* pAuthIdentity
    )
/*++

Routine Description:

    This function sets the interface security parameters.

Arguments:

    [in] IUnknown           :   pointer to the IUnkown interface
    [in] COAUTHIDENTITY     :   pointer to AUTHIDENTITY structure

Return Value:

    HRESULT

--*/
{
    // local variables
    HRESULT hr = S_OK;
    DWORD dwAuthorization = RPC_C_AUTHZ_NONE;
    DWORD dwAuthentication = RPC_C_AUTHN_WINNT;

    // check the interface
    // 'pAuthIdentity' can be NULL or not, so need to check.
    if ( NULL == pInterface )
    {
        return WBEM_E_INVALID_PARAMETER;
    }

    // get the current security argument value
    hr = GetSecurityArguments( pInterface, dwAuthorization, dwAuthentication );
    if ( FAILED( hr ) )
    {
        return hr;
    }

    // set the security information to the interface
    hr = SetProxyBlanket( pInterface, dwAuthentication, dwAuthorization, NULL,
        RPC_C_AUTHN_LEVEL_PKT_PRIVACY , RPC_C_IMP_LEVEL_IMPERSONATE, pAuthIdentity, EOAC_NONE );

    // return the result
    return hr;
}


HRESULT
WINAPI SetProxyBlanket(
    IUnknown* pInterface,
    DWORD dwAuthnSvc,
    DWORD dwAuthzSvc,
    LPWSTR pwszPrincipal,
    DWORD dwAuthLevel,
    DWORD dwImpLevel,
    RPC_AUTH_IDENTITY_HANDLE pAuthInfo,
    DWORD dwCapabilities
    )
/*++

Routine Description:

    This function sets the authentication information (the security blanket)
    that will be used to make calls.

Arguments:

    [in] IUnknown                       :   pointer to the IUnkown interface
    [in] DWORD                          :   contains the authentication service to use
    [in] DWORD                          :   contains the authorization service to use
    [in] LPWSTR                         :   the server principal name to use
    [in] DWORD                          :   contains the authentication level to use
    [in] DWORD                          :   contains the impersonation level to use
    [in] RPC_AUTH_IDENTITY_HANDLE       :   pointer to the identity of the client
    [in] DWORD                          :   contains the capability flags

Return Value:

    HRESULT

--*/
{
    // local variables
    HRESULT hr = S_OK;
    IUnknown * pUnknown = NULL;
    IClientSecurity * pClientSecurity = NULL;

    // Validate input arguments.
    //
    // Can't set pAuthInfo if cloaking requested, as cloaking implies
    // that the current proxy identity in the impersonated thread (rather
    // than the credentials supplied explicitly by the RPC_AUTH_IDENTITY_HANDLE)
    // is to be used.
    // See MSDN info on CoSetProxyBlanket for more details.
    //
    if( ( NULL == pInterface ) ||
        ( ( dwCapabilities & (EOAC_STATIC_CLOAKING | EOAC_DYNAMIC_CLOAKING) ) &&
          ( NULL != pAuthInfo ) )
      )
    {
        return( WBEM_E_INVALID_PARAMETER );
    }

    // get the IUnknown interface ... to check whether this is a valid interface or not
    hr = pInterface->QueryInterface( IID_IUnknown, (void **) &pUnknown );
    if ( FAILED(hr) )
    {
        return hr;
    }

    // now get the client security interface
    hr = pInterface->QueryInterface( IID_IClientSecurity, (void **) &pClientSecurity );
    if ( FAILED(hr) )
    {
        SAFE_RELEASE( pUnknown );
        return hr;
    }

    // now set the security
    hr = pClientSecurity->SetBlanket( pInterface, dwAuthnSvc, dwAuthzSvc, pwszPrincipal,
                                        dwAuthLevel, dwImpLevel, pAuthInfo, dwCapabilities );
    if( FAILED( hr ) )
    {
        SAFE_RELEASE( pUnknown );
        SAFE_RELEASE( pClientSecurity );
        return hr;
    }

    // release the security interface
    SAFE_RELEASE( pClientSecurity );

    // we should check the auth identity structure. if exists .. set for IUnknown also
    if ( NULL != pAuthInfo )
    {
        hr = pUnknown->QueryInterface( IID_IClientSecurity, (void **) &pClientSecurity );
        if ( SUCCEEDED(hr) )
        {
            // set security authentication
            hr = pClientSecurity->SetBlanket( pUnknown, dwAuthnSvc, dwAuthzSvc, pwszPrincipal,
                                                dwAuthLevel, dwImpLevel, pAuthInfo, dwCapabilities );

            // release
            SAFE_RELEASE( pClientSecurity );
        }
        else
        {
            if ( E_NOINTERFACE == hr )
            {
                hr = S_OK;      // ignore no interface errors
            }
        }
    }

    // release the IUnknown
    SAFE_RELEASE( pUnknown );

    // return the result
    return hr;
}


HRESULT
WINAPI WbemAllocAuthIdentity(
    LPCWSTR pwszUser,
    LPCWSTR pwszPassword,
    LPCWSTR pwszDomain,
    COAUTHIDENTITY** ppAuthIdent
    )
/*++

Routine Description:

    This function allocates memory for the AUTHIDENTITY structure.

Arguments:

    [in] LPCWSTR            :   string containing the user name
    [in] LPCWSTR            :   string containing the password
    [in] LPCWSTR            :   string containing the domain name
    [out] COAUTHIDENTITY    :   pointer to the pointer to AUTHIDENTITY structure

Return Value:

    HRESULT

NOTE: 'ppAuthIdent' should be freed by calling 'WbemFreeAuthIdentity' by the user after
      their work is done.

--*/
{
    // local variables
    COAUTHIDENTITY* pAuthIdent = NULL;

    // validate the input parameter
    if ( NULL == ppAuthIdent )
    {
        return WBEM_E_INVALID_PARAMETER;
    }

    // allocation thru COM API
    pAuthIdent = ( COAUTHIDENTITY* ) CoTaskMemAlloc( sizeof( COAUTHIDENTITY ) );
    if ( NULL == pAuthIdent )
    {
        return WBEM_E_OUT_OF_MEMORY;
    }

    // init with 0's
    SecureZeroMemory( ( void* ) pAuthIdent, sizeof( COAUTHIDENTITY ) );

    //
    // Allocate needed memory and copy in data.  Cleanup if anything goes wrong

    // user
    if ( NULL != pwszUser )
    {
        // allocate memory for user
        LONG lLength = StringLength( pwszUser, 0 );
        pAuthIdent->User = ( LPWSTR ) CoTaskMemAlloc( (lLength + 1) * sizeof( WCHAR ) );
        if ( NULL == pAuthIdent->User )
        {
            WbemFreeAuthIdentity( &pAuthIdent );
            return WBEM_E_OUT_OF_MEMORY;
        }

        // set the length and do copy contents
        pAuthIdent->UserLength = lLength;
        StringCopy( pAuthIdent->User, pwszUser, (lLength + 1) );
    }

    // domain
    if ( NULL != pwszDomain )
    {
        // allocate memory for domain
        LONG lLength = StringLength( pwszDomain, 0 );
        pAuthIdent->Domain = ( LPWSTR ) CoTaskMemAlloc( (lLength + 1) * sizeof( WCHAR ) );
        if ( NULL == pAuthIdent->Domain )
        {
            WbemFreeAuthIdentity( &pAuthIdent );
            return WBEM_E_OUT_OF_MEMORY;
        }

        // set the length and do copy contents
        pAuthIdent->DomainLength = lLength;
        StringCopy( pAuthIdent->Domain, pwszDomain, (lLength + 1) );
    }

    // passsord
    if ( NULL != pwszPassword )
    {
        // allocate memory for passsord
        LONG lLength = StringLength( pwszPassword, 0 );
        pAuthIdent->Password = ( LPWSTR ) CoTaskMemAlloc( (lLength + 1) * sizeof( WCHAR ) );
        if ( NULL == pAuthIdent->Password )
        {
            WbemFreeAuthIdentity( &pAuthIdent );
            return WBEM_E_OUT_OF_MEMORY;
        }

        // set the length and do copy contents
        pAuthIdent->PasswordLength = lLength;
        StringCopy( pAuthIdent->Password, pwszPassword, (lLength + 1) );
    }

    // type of the structure
    pAuthIdent->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;

    // final set the address to out parameter
    *ppAuthIdent = pAuthIdent;

    // return result
    return S_OK;
}


VOID
WINAPI WbemFreeAuthIdentity(
    COAUTHIDENTITY** ppAuthIdentity
    )
/*++

Routine Description:

    This function releases the memory allocated for the AUTHIDENTITY structure.

Arguments:

    [in] COAUTHIDENTITY     :   pointer to the pointer to AUTHIDENTITY structure

Return Value:

    None

--*/
{
    // make sure we have a pointer, then walk the structure members and  cleanup.
    if ( *ppAuthIdentity != NULL )
    {
        // free the memory allocated for user
        if ( NULL != (*ppAuthIdentity)->User )
        {
            CoTaskMemFree( (*ppAuthIdentity)->User );
            (*ppAuthIdentity)->User = NULL;
        }

        // free the memory allocated for password
        if ( NULL != (*ppAuthIdentity)->Password )
        {
            CoTaskMemFree( (*ppAuthIdentity)->Password );
            (*ppAuthIdentity)->Password = NULL;
        }

        // free the memory allocated for domain
        if ( NULL != (*ppAuthIdentity)->Domain )
        {
            CoTaskMemFree( (*ppAuthIdentity)->Domain );
            (*ppAuthIdentity)->Domain = NULL;
        }

        // final the structure
        CoTaskMemFree( *ppAuthIdentity );
        *ppAuthIdentity = NULL;
    }
}


VOID
WMISaveError(
    HRESULT hrError
    )
/*++

Routine Description:

    This function saves the description of the last error returned by WMI

Arguments:

    HRESULT     :   The last return value from WMI

Return Value:

    NONE

--*/
{
    // local variables
    HRESULT hr = S_OK;
    IWbemStatusCodeText* pWbemStatus = NULL;
    _bstr_t bstrErrorString;

    try
    {
        // Set error to different value.
        if ( E_ACCESSDENIED == hrError )
        {
            // change the error message to "Logon failure: unknown user name or bad password."
            hrError = ERROR_LOGON_FAILURE;
        }

        //Set the reason to incompatible os when no class is registered on remote mechine
        if( 0x80040154 == hrError )
        {
            bstrErrorString = _bstr_t( GetResString(IDS_ERROR_REMOTE_INCOMPATIBLE));
            SetReason( bstrErrorString );
            return;
        }
        else
        {   // Get error string.
            hr = CoCreateInstance( CLSID_WbemStatusCodeText,
                                   NULL, CLSCTX_INPROC_SERVER,
                                   IID_IWbemStatusCodeText,
                                   (LPVOID*) &pWbemStatus );
            if( SUCCEEDED( hr ) )
            {
                BSTR bstrString = NULL;
                // Get error string from error code.
                hr = pWbemStatus->GetErrorCodeText( hrError, 0, 0,
                                                    &bstrString );
                if( NULL != bstrString )
                {
                    bstrErrorString = _bstr_t( bstrString );
                    SysFreeString( bstrString );
                }
                if( FAILED( hr ) )
                {
                    _com_issue_error( hrError );
                }
            }
            else
            {
                _com_issue_error( hrError );
            }
        }
    }
    catch( _com_error& e )
    {   // We have got the error. Needs to handle carefully.
        LPWSTR lpwszGetString = NULL;
        try
        {   // ErrorMessage() can throw an exception.
            DWORD dwLength = StringLength( e.ErrorMessage(), 0 ) + 5 ;
            lpwszGetString = ( LPWSTR )AllocateMemory( dwLength * sizeof( WCHAR ) );
            if( NULL != lpwszGetString )
            {
                StringCopy( lpwszGetString, e.ErrorMessage(), dwLength );
                StringConcat( lpwszGetString, L"\n", dwLength );
                SetReason( ( LPCWSTR )lpwszGetString );
                FreeMemory( (LPVOID*) &lpwszGetString );
            }
            else
            {   // Failed to know the exact error occured
                // due to insufficient memory.
                SetLastError( ERROR_NOT_ENOUGH_MEMORY );
                SaveLastError();
            }
        }
        catch( ... )
        {
                SetLastError( ERROR_NOT_ENOUGH_MEMORY );
                SaveLastError();
        }
        return;
    }

    SetReason( (LPCWSTR) bstrErrorString );
    return;
}



HRESULT
PropertyGet(
    IWbemClassObject* pWmiObject,
    LPCWSTR pwszProperty,
    _variant_t& varValue
    )
/*++

Routine Description:

    Gets the value of the property from the WMI class object

Arguments:

    [in] IWbemClassObject       :   pointer to the WBEM class object
    [in] LPCWSTR                :   property name
    [out] _variant_t            :   value of the property

Return Value:

    HRESULT

--*/
{
    // local variables
    HRESULT hr = S_OK;
    VARIANT vtValue;

    // Validate input arguments.
    if ( ( NULL == pWmiObject ) ||
         ( NULL == pwszProperty ) )
    {
        return WBEM_E_INVALID_PARAMETER;
    }

    try
    {
        // initialize the variant and then get the value of the specified property
        VariantInit( &vtValue );
        // Call 'Get' method to retireve the value from WMI.
        hr = pWmiObject->Get( _bstr_t( pwszProperty ), 0, &vtValue, NULL, NULL );
        if ( FAILED( hr ) )
        {
            // Clear the variant variable
            VariantClear( &vtValue );
            // Return error.
            return hr;
        }

        // set the value
        varValue = vtValue;
    }
    catch( _com_error& e )
    {
        hr = e.Error();
    }

    // Clear the variables.
    VariantClear( &vtValue );
    // Return.
    return hr;
}


HRESULT PropertyGet(
                    IWbemClassObject* pWmiObject,
                    LPCWSTR pwszProperty,
                    VARIANT* pvarValue )
/*++
// Routine Description:
//      Gets the value of the property from the WMI class object
//
// Arguments:
//      [ in ] pWmiObject       : pointer to the WBEM class object
//      [ in ] szProperty       : property name
//      [ out ] varValue        : value of the property
//
// Return Value:
//      HRESULT - result of the operation
//
--*/
{
    // local variables
    HRESULT hr;

    // check with object and property passed to the function are valid or not
    // if not, return failure
    if ( pWmiObject == NULL || pwszProperty == NULL || pvarValue == NULL )
        return WBEM_E_INVALID_PARAMETER;

    try
    {
        // initialize the variant and then get the value of the specified property
        hr = pWmiObject->Get( _bstr_t( pwszProperty ), 0, pvarValue, NULL, NULL );
        if ( FAILED( hr ) )
        {
            // clear the variant variable
            VariantClear( pvarValue );

            // failed to get the value for the property
            return hr;
        }
    }
    catch( _com_error& e )
    {
        WMISaveError( e );
        return e.Error();
    }

    // inform success
    return S_OK;
}


BOOL PropertyGet(
                IWbemClassObject* pWmiObject,
                LPCWSTR pwszProperty,
                TARRAY arr )
/*++

Routine Description:

    Gets the value of the property from the WMI class object in string format

Arguments:

    [in] IWbemClassObject       :   pointer to the WBEM class object
    [in] LPCWSTR                :   property name
    [out] arr                   :   value of the property

Return Value:

    BOOL

--*/
{
    // local variables
    HRESULT hr;
    VARIANT vtValue;
    LONG lIndex = 0;
    LONG lLBound = 0;
    LONG lUBound = 0;
    VARTYPE vartype;
    SAFEARRAY* pSafeArray = NULL;

    // check the inputs
    if ( pWmiObject == NULL || pwszProperty == NULL || arr == NULL )
        return FALSE;

    // initialize the variant
    VariantInit( &vtValue );

    // now get the property value
    hr = PropertyGet( pWmiObject, pwszProperty, &vtValue );
    if ( FAILED( hr ) )
        return FALSE;

    if ( V_VT( &vtValue ) == VT_NULL )
        return TRUE;

        // confirm that the propety value is of array type .. if not return
    if ( ( V_VT( &vtValue ) & VT_ARRAY ) == 0 )
        return FALSE;

    // get the safearray value
    pSafeArray = V_ARRAY( &vtValue );

    // get the bounds of the array
    SafeArrayGetLBound( pSafeArray, 1, &lLBound );
    SafeArrayGetUBound( pSafeArray, 1, &lUBound );

    // get the type of the elements in the safe array
    vartype = (VARTYPE) (V_VT( &vtValue ) & ~VT_ARRAY);

    try
    {
        // traverse thru the values in the safe array and update into dynamic array
        for( lIndex = lLBound; lIndex <= lUBound; lIndex++ )
        {
            // sub-local variables
            VARIANT var;
            CHString strValue;

            // get the value
            V_VT( &var ) = vartype;
            SafeArrayGetElement( pSafeArray, &lIndex, &V_UI1( &var ) );

            // add the information to the dynamic array
            switch( vartype )
            {
            case VT_BSTR:
                strValue = V_BSTR( &var );
                DynArrayAppendString( arr, strValue, 0 );
                break;
            }
        }
    }
    catch( ... )
    {
        // clear the variant
        VariantClear( &vtValue );
        return FALSE;   // failure
    }

    // clear the variant
    VariantClear( &vtValue );

    // return
    return TRUE;
}


BOOL
PropertyGet(
    IWbemClassObject* pWmiObject,
    LPCWSTR pwszProperty,
    CHString& strValue,
    LPCWSTR pwszDefault
    )
/*++

Routine Description:

    Gets the value of the property from the WMI class object in string format

Arguments:

    [in] IWbemClassObject       :   pointer to the WBEM class object
    [in] LPCWSTR                :   the name of the property to retrieve
    [out] CHString              :   variable to hold the retrieved property
    [in] LPCWSTR                :   string containing the default value for the property

Return Value:

    TRUE on success
    FALSE on failure

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF FALSE IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

--*/
{
    // local variables
    HRESULT hr = S_OK;
    _variant_t var;

    // Clear any errors.
    SetLastError( WBEM_S_NO_ERROR );
    strValue.Empty();

    try
    {
        // first copy the default value
        strValue = pwszDefault;

        // Validate input arguments.
        if ( ( NULL == pWmiObject ) ||
             ( NULL == pwszProperty ) )
        {
            _com_issue_error( WBEM_E_INVALID_PARAMETER );
        }

        // get the property value
        hr = PropertyGet( pWmiObject, pwszProperty, var );
        if ( FAILED( hr ) )
        {
            _com_issue_error( hr );
        }

        // Get the value
        // If 'var' does not contain value of requested type
        // then default value is returned.
        if ( VT_BSTR == V_VT( &var ) )
        {
            strValue = (LPCWSTR) _bstr_t( var );
        }
    }
    catch( _com_error& e )
    {
        WMISaveError( e );
        return FALSE;
    }
    catch( CHeap_Exception )
    {
        WMISaveError( WBEM_E_OUT_OF_MEMORY );
        return FALSE;
    }

    // return
    return TRUE;
}


BOOL
PropertyGet(
    IWbemClassObject* pWmiObject,
    LPCWSTR pwszProperty,
    DWORD& dwValue,
    DWORD dwDefault
    )
/*++

Routine Description:

    Gets the value of the property from the WMI class object in dword format

Arguments:

    [in] IWbemClassObject       :   pointer to the WBEM class object
    [in] LPCWSTR                :   the name of the property to retrieve
    [out] DWORD                 :   variable to hold the retrieved property
    [in] DWORD                  :   dword containing the default value for the property

Return Value:

    TRUE on success
    FALSE on failure

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF FALSE IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

--*/
{
    // local variables
    HRESULT hr;
    _variant_t var;

    // first set the defaul value
    dwValue = dwDefault;

    // check with object and property passed to the function are valid or not
    // if not, return failure
    if ( pWmiObject == NULL || pwszProperty == NULL )
        return FALSE;

    // get the value of the property
    hr = PropertyGet( pWmiObject, pwszProperty, var );
    if ( FAILED( hr ) )
        return FALSE;

    // get the process id from the variant
    if ( var.vt != VT_NULL && var.vt != VT_EMPTY )
        dwValue = (LONG) var;

    // return
    return TRUE;
}


BOOL
PropertyGet(
    IWbemClassObject* pWmiObject,
    LPCWSTR pwszProperty,
    BOOL& bValue,
    BOOL bDefault
    )
/*++

Routine Description:

    Gets the value of the property from the WMI class object in bool format

Arguments:

    [in] IWbemClassObject       :   pointer to the WBEM class object
    [in] LPCWSTR                :   the name of the property to retrieve
    [out] BOOL                  :   variable to hold the retrieved property
    [in] BOOL                   :   bool containing the default value for the property

Return Value:

    TRUE on success
    FALSE on failure

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF FALSE IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

--*/
{
    // local variables
    HRESULT hr = S_OK;
    _variant_t var;

    // Clear any errors.
    SetLastError( WBEM_S_NO_ERROR );

    try
    {
        // first set the default value
        bValue = bDefault;

        // Validate input arguments.
        if ( ( NULL == pWmiObject ) ||
             ( NULL == pwszProperty ) )
        {
            _com_issue_error( WBEM_E_INVALID_PARAMETER );
        }

        // get the value of the property
        hr = PropertyGet( pWmiObject, pwszProperty, var );
        if ( FAILED( hr ) )
        {
            _com_issue_error( hr );
        }

        // Save value obtained.
        // If 'var' does not contain value of requested type
        // then default value is returned.
        if ( VT_BOOL == V_VT( &var ) )
        {
            bValue = var.boolVal;
        }
    }
    catch( _com_error& e )
    {
        WMISaveError( e );
        return FALSE;
    }

    // return
    return TRUE;
}


BOOL
PropertyGet(
    IWbemClassObject* pWmiObject,
    LPCWSTR pwszProperty,
    ULONGLONG& ullValue
    )
/*++

Routine Description:

    Gets the value of the property from the WMI class object in ulongulong format

Arguments:

    [in] IWbemClassObject       :   pointer to the WBEM class object
    [in] LPCWSTR                :   the name of the property to retrieve
    [out] ULONGULONG            :   variable to hold the retrieved property

Return Value:

    TRUE on success
    FALSE on failure

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF FALSE IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

--*/

{
    // Local variables
    CHString str;

    // Clear any errors.
    SetLastError( WBEM_S_NO_ERROR );
    str.Empty();

    try
    {
        // first set the default value
        ullValue = 1;

        // Validate input arguments.
        if ( ( NULL == pWmiObject ) ||
             ( NULL == pwszProperty ) )
        {
            WMISaveError( WBEM_E_INVALID_PARAMETER );
            return FALSE;
        }

        // get the value of the property
        if ( FALSE == PropertyGet( pWmiObject, pwszProperty, str, _T( "0" ) ) )
        { // Error is already set in 'PropertyGet' function.
            return FALSE;
        }

        // get the 64-bit value
        ullValue = _wtoi64( str );

        // Check for error condition.
        if( 0 == ullValue )
        {
            ullValue = 1;
            WMISaveError( WBEM_E_INVALID_PARAMETER );
            return FALSE;
        }
    }
    catch( CHeap_Exception )
    {
        WMISaveError( WBEM_E_OUT_OF_MEMORY );
        return FALSE;
    }
    // return
    return TRUE;
}


BOOL
PropertyGet(
    IWbemClassObject* pWmiObject,
    LPCWSTR pwszProperty,
    WBEMTime& wbemtime )
/*++

Routine Description:

    Gets the value of the property from the WMI class object in wbemtime format

Arguments:

    [in] IWbemClassObject       :   pointer to the WBEM class object
    [in] LPCWSTR                :   the name of the property to retrieve
    [out] WBEMTime              :   variable to hold the retrieved property

Return Value:

    TRUE on success
    FALSE on failure

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF FALSE IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

--*/
{
    // local variables
    CHString str;

    // Clear any errors.
    SetLastError( WBEM_S_NO_ERROR );

    // Clear method sets the time in the WBEMTime object to an invalid time.
    wbemtime.Clear();
    try
    {
        // Validate input arguments.
        if ( ( NULL == pWmiObject ) ||
             ( NULL == pwszProperty ) )
        {
            WMISaveError( WBEM_E_INVALID_PARAMETER );
            return FALSE;
        }

        // get the value of the property
        if ( FALSE == PropertyGet( pWmiObject, pwszProperty, str, _T( "0" ) ) )
        {   // Error is already set in 'PropertyGet' function.
            return FALSE;
        }

        // convert into the time value
        wbemtime = _bstr_t( str );
    }
    catch( _com_error& e )
    {
        WMISaveError( e );
        return FALSE;
    }
    catch( CHeap_Exception )
    {
        WMISaveError( WBEM_E_OUT_OF_MEMORY );
        return FALSE;
    }

    // return
    return TRUE;
}


BOOL
PropertyGet(
    IWbemClassObject* pWmiObject,
    LPCWSTR pwszProperty,
    SYSTEMTIME& systime )
/*++

Routine Description:

    Gets the value of the property from the WMI class object in systemtime format

Arguments:

    [in] IWbemClassObject       :   pointer to the WBEM class object
    [in] LPCWSTR                :   the name of the property to retrieve
    [out] WBEMTime              :   variable to hold the retrieved property

Return Value:

    TRUE on success
    FALSE on failure

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF FALSE IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

--*/

{
    // local variables
    CHString strTime;

    // Validate input arguments.
    if ( ( NULL == pWmiObject ) ||
         ( NULL == pwszProperty ) )
    {
        WMISaveError( WBEM_E_INVALID_PARAMETER );
        return FALSE;
    }

    try
    {
        // get the value of the property
        // 16010101000000.000000+000 is the default time
        if ( FALSE == PropertyGet( pWmiObject, pwszProperty, strTime, _T( "16010101000000.000000+000" ) ) )
        {   // Error is already set.
            return FALSE;
        }

        // prepare the systemtime structure
        // yyyymmddHHMMSS.mmmmmmsUUU
        // NOTE: NO NEED CALL 'IsNumeric()' BEFORE 'AsLong'.
        // Left and MID methods can throw an exception.
        systime.wYear = (WORD) AsLong( strTime.Left( 4 ), 10 );
        systime.wMonth = (WORD) AsLong( strTime.Mid( 4, 2 ), 10 );
        systime.wDayOfWeek = 0;
        systime.wDay = (WORD) AsLong( strTime.Mid( 6, 2 ), 10 );
        systime.wHour = (WORD) AsLong( strTime.Mid( 8, 2 ), 10 );
        systime.wMinute = (WORD) AsLong( strTime.Mid( 10, 2 ), 10 );
        systime.wSecond = (WORD) AsLong( strTime.Mid( 12, 2 ), 10 );
        systime.wMilliseconds = (WORD) AsLong( strTime.Mid( 15, 6 ), 10 );
    }
    catch( _com_error& e )
    {
        WMISaveError( e );
        return FALSE;
    }
    catch( CHeap_Exception )
    {
        WMISaveError( WBEM_E_OUT_OF_MEMORY );
        return FALSE;
    }

    // return
    return TRUE;
}


HRESULT
PropertyPut(
    IWbemClassObject* pWmiObject,
    LPCWSTR pwszProperty,
    _variant_t& varValue
    )
/*++

Routine Description:

    Sets the value of the property to the WMI class object

Arguments:

    [in] IWbemClassObject       :   pointer to the WBEM class object
    [in] LPCWSTR                :   the name of the property to retrieve
    [in] WBEMTime               :   variable holding the property to set

Return Value:

    TRUE on success
    FALSE on failure

--*/
{
    // local variables
    VARIANT var;
    HRESULT hr = S_OK;

    // check the input value
    if ( ( NULL == pWmiObject ) ||
         ( NULL == pwszProperty ) )
    {
        return WBEM_E_INVALID_PARAMETER;
    }

    try
    {
        // put the value
        var = varValue;
        hr = pWmiObject->Put( _bstr_t( pwszProperty ), 0, &var, 0 );
    }
    catch( _com_error& e )
    {
        hr = e.Error();
    }

    // return the result
    return hr;
}


HRESULT
PropertyPut(
    IWbemClassObject* pWmiObject,
    LPCWSTR pwszProperty,
    LPCWSTR pwszValue
    )
/*++

Routine Description:

    Sets the string value of the property to the WMI class object

Arguments:

    [in] IWbemClassObject       :   pointer to the WBEM class object
    [in] LPCWSTR                :   the name of the property to retrieve
    [in] LPCWSTR                :   variable holding the property to set

Return Value:

    TRUE on success
    FALSE on failure

--*/
{
    // local variables
    _variant_t varValue;
    HRESULT hr = S_OK;

    // check the input value
    if ( ( NULL == pWmiObject ) ||
         ( NULL == pwszProperty ) ||
         ( NULL == pwszValue ) )
    {
        return WBEM_E_INVALID_PARAMETER;
    }

    try
    {
        varValue = pwszValue;
        SAFE_EXECUTE( PropertyPut( pWmiObject, pwszProperty, varValue ) );
    }
    catch( _com_error& e )
    {
        hr = e.Error();
    }

    // return
    return hr;
}


HRESULT
PropertyPut(
    IWbemClassObject* pWmiObject,
    LPCWSTR pwszProperty,
    DWORD dwValue
    )
/*++

Routine Description:

    Sets the dword value of the property to the WMI class object.

Arguments:

    [in] IWbemClassObject       :   pointer to the WBEM class object
    [in] LPCWSTR                :   the name of the property to retrieve
    [in] DWORD                  :   variable holding the property to set

Return Value:

    TRUE on success
    FALSE on failure

--*/
{
    // local variables
    _variant_t varValue;
    HRESULT hr = S_OK;

    // check the input value
    if ( ( NULL == pWmiObject ) ||
         ( NULL == pwszProperty ) )
    {
        return WBEM_E_INVALID_PARAMETER;
    }

    try
    {
        varValue = ( LONG )dwValue;
        SAFE_EXECUTE( PropertyPut( pWmiObject, pwszProperty, varValue ) );
    }
    catch( _com_error& e )
    {
        return e.Error();
    }

    // return
    return S_OK;
}


HRESULT
RegQueryValueWMI(
    IWbemServices* pWbemServices,
    LPCWSTR pwszMethod,
    DWORD dwHDefKey,
    LPCWSTR pwszSubKeyName,
    LPCWSTR pwszValueName,
    _variant_t& varValue
    )
/*++

Routine Description:

    This function retrieves the value of the property from the specified registry key.

Arguments:

    [in] IWbemServices          :   pointer to the IWbemServices object
    [in] LPCWSTR                :   the name of the method to execute
    [in] DWORD                  :   the key in the registry whose value has to be retrieved
    [in] LPCWSTR                :   the name of the subkey to retrieve
    [in] LPCWSTR                :   the name of the value to retrieve
    [in] _variant_t             :   variable holding the property value retrieved

Return Value:

    TRUE on success
    FALSE on failure

NOTE: Pass arguments of type mentioned in declaration of this function.
      EX: Don't pass 'CHString' argument if 'LPWSTR' is expected.
      Reason: 'CHString' can throw an exception of type 'CHEAP_EXCEPTION'
               which is not handled by this function.

--*/
{
    // local variables
    HRESULT hr = S_OK;
    BOOL bResult = FALSE;
    DWORD dwReturnValue = 0;
    IWbemClassObject* pClass = NULL;
    IWbemClassObject* pMethod = NULL;
    IWbemClassObject* pInParams = NULL;
    IWbemClassObject* pInParamsInstance = NULL;
    IWbemClassObject* pOutParamsInstance = NULL;

    // Clear any errors.
    SetLastError( WBEM_S_NO_ERROR );

    // check the input value
    if ( ( NULL == pWbemServices ) ||
         ( NULL == pwszMethod ) ||
         ( NULL == pwszSubKeyName ) ||
         ( NULL == pwszValueName ) )
    {
        return WBEM_E_INVALID_PARAMETER;
    }

    // NOTE: If SAFE_EXECUTE( pWbemServices->GetObject(
    //       _bstr_t( WMI_REGISTRY ), WBEM_FLAG_RETURN_WBEM_COMPLETE, NULL, &pClass, NULL ) );
    //       is executed then,
    //       NO NEED TO CHECK FOR ( PCLASS == NULL ) SINCE IN ALL CASES
    //       OF ERROR THIS VARIABLE WILL BE NULL.

    try
    {
        // get the registry class object
        SAFE_EXECUTE( pWbemServices->GetObject(
            _bstr_t( WMI_REGISTRY ), WBEM_FLAG_RETURN_WBEM_COMPLETE, NULL, &pClass, NULL ) );

        // get the method reference required
        SAFE_EXECUTE( pClass->GetMethod( pwszMethod, 0, &pInParams, NULL ) );

        // create the instance for the in parameters
        SAFE_EXECUTE( pInParams->SpawnInstance( 0, &pInParamsInstance ) );

        // set the input values
        SAFE_EXECUTE(PropertyPut( pInParamsInstance, _bstr_t( WMI_REGISTRY_IN_HDEFKEY ), dwHDefKey ) );
        SAFE_EXECUTE(PropertyPut( pInParamsInstance, _bstr_t( WMI_REGISTRY_IN_SUBKEY ), pwszSubKeyName ) );
        SAFE_EXECUTE(PropertyPut( pInParamsInstance, _bstr_t( WMI_REGISTRY_IN_VALUENAME ), pwszValueName ) );

        // now execute the method
        SAFE_EXECUTE( pWbemServices->ExecMethod( _bstr_t( WMI_REGISTRY ),
            _bstr_t( pwszMethod ), 0, NULL, pInParamsInstance, &pOutParamsInstance, NULL ) );
        if ( NULL == pOutParamsInstance )           // check the object .. safety sake
        {
            _com_issue_error( STG_E_UNKNOWN );
        }

        // now check the return value of the method from the output params object
        bResult = PropertyGet( pOutParamsInstance,
            _bstr_t( WMI_REGISTRY_OUT_RETURNVALUE ), dwReturnValue );
        if ( ( FALSE == bResult ) ||
             ( 0 != dwReturnValue ) )
        {
            _com_issue_error( STG_E_UNKNOWN );
        }

        // Comapre string and take appropriate action.
        if ( 0 == StringCompare( pwszMethod, WMI_REGISTRY_M_DWORDVALUE, TRUE, 0 ) )
        {
            SAFE_EXECUTE( PropertyGet( pOutParamsInstance,
                                       _bstr_t( WMI_REGISTRY_OUT_VALUE_DWORD ), varValue ) );
        }
        else
        {
            SAFE_EXECUTE( PropertyGet( pOutParamsInstance,
                                       _bstr_t( WMI_REGISTRY_OUT_VALUE ), varValue ) );
        }
    }
    catch( _com_error& e )
    {
        hr = e.Error();
    }

    // release the interfaces
    SAFE_RELEASE( pClass );
    SAFE_RELEASE( pMethod );
    SAFE_RELEASE( pInParams );
    SAFE_RELEASE( pInParamsInstance );
    SAFE_RELEASE( pOutParamsInstance );

    // return success
    return hr;
}


BOOL
RegQueryValueWMI(
    IWbemServices* pWbemServices,
    DWORD dwHDefKey,
    LPCWSTR pwszSubKeyName,
    LPCWSTR pwszValueName,
    CHString& strValue,
    LPCWSTR pwszDefault
    )
/*++

Routine Description:

    This function retrieves the string value of the property from the specified registry key.

Arguments:

    [in] IWbemServices          :   pointer to the IWbemServices object
    [in] DWORD                  :   the key in the registry whose value has to be retrieved
    [in] LPCWSTR                :   the name of the subkey to retrieve
    [in] LPCWSTR                :   the name of the value to retrieve
    [out] CHString              :   variable holding the property value retrieved
    [in] LPCWSTR                :   the default value for this property

Return Value:

    TRUE on success
    FALSE on failure

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF '0' IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

      This function won't return values if they are obtained as reference
      from WMI.
      EX: 'VARTYPE' recieved is of type 'VT_BSTR | VT_BYREF' then FALSE is
           returned.

--*/
{
    // local variables
    HRESULT hr = S_OK;
    _variant_t varValue;

    // Clear any errors.
    SetLastError( WBEM_S_NO_ERROR );

    // Check the input
    if ( ( NULL == pWbemServices ) ||
         ( NULL == pwszSubKeyName ) ||
         ( NULL == pwszValueName ) )
    {
        WMISaveError( WBEM_E_INVALID_PARAMETER );
        return FALSE;
    }

    try
    {
        // Set the default value
        if ( NULL != pwszDefault )
        {
            strValue = pwszDefault;
        }

        // Get the value
        hr = RegQueryValueWMI( pWbemServices,
            WMI_REGISTRY_M_STRINGVALUE, dwHDefKey, pwszSubKeyName, pwszValueName, varValue );
        if ( FAILED( hr ) )
        {
            WMISaveError( hr );
            return FALSE;
        }

        // Get the value from the variant
        // Get the value
        if ( VT_BSTR == V_VT( &varValue ) )
        {
            strValue = (LPCWSTR)_bstr_t( varValue );
        }
        else
        {
            // Requested type is not found.
            WMISaveError( WBEM_E_INVALID_PARAMETER );
            return FALSE;
        }
    }
    catch( _com_error& e )
    {   // Exception throw by '_variant_t'.
        WMISaveError( e );
        return FALSE;
    }

    // return success
    return TRUE;
}


BOOL
RegQueryValueWMI(
    IWbemServices* pWbemServices,
    DWORD dwHDefKey,
    LPCWSTR pwszSubKeyName,
    LPCWSTR pwszValueName,
    DWORD& dwValue,
    DWORD dwDefault
    )
/*++

Routine Description:

    This function retrieves the dword value of the property from the specified registry key.

Arguments:

    [in] IWbemServices          :   pointer to the IWbemServices object
    [in] DWORD                  :   the key in the registry whose value has to be retrieved
    [in] LPCWSTR                :   the name of the subkey to retrieve
    [in] LPCWSTR                :   the name of the value to retrieve
    [out] DWORD                 :   variable holding the property value retrieved
    [in] DWORD                  :   the default value for this property

Return Value:

    TRUE on success
    FALSE on failure

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF '0' IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

      This function won't return values if they are obtained as reference
      from WMI.
      EX: 'VARTYPE' recieved is of type 'VT_I4 | VT_BYREF' then FALSE is
           returned.

--*/
{
    // local variables
    HRESULT hr = S_OK;
    _variant_t varValue;

    // Clear any errors.
    SetLastError( WBEM_S_NO_ERROR );

    // Check the input.
    if ( ( NULL == pWbemServices ) ||
         ( NULL == pwszSubKeyName ) ||
         ( NULL == pwszValueName ) ||
         ( NULL == dwValue ) )
    {
        WMISaveError( WBEM_E_INVALID_PARAMETER );
        return FALSE;
    }

    try
    {
        // Set the default value.
        dwValue = dwDefault;

        // Get the value.
        hr = RegQueryValueWMI( pWbemServices, WMI_REGISTRY_M_DWORDVALUE, dwHDefKey,
                                pwszSubKeyName, pwszValueName, varValue );
        if ( FAILED( hr ) )
        {
            WMISaveError( hr );
            return FALSE;
        }

        // get the value from the variant
        switch( V_VT( &varValue ) )
        {
        case VT_I2:
            dwValue = V_I2( &varValue );
            break;
        case VT_I4:
            dwValue = V_I4( &varValue );
            break;
        case VT_UI2:
            dwValue = V_UI2( &varValue );
            break;
        case VT_UI4:
            dwValue = V_UI4( &varValue );
            break;
        case VT_INT:
            dwValue = V_INT( &varValue );
            break;
        case VT_UINT:
            dwValue = V_UINT( &varValue );
            break;
        default:
            // Requested type is not found.
            WMISaveError( WBEM_E_INVALID_PARAMETER );
            return FALSE;
        }
    }
    catch( _com_error& e )
    {   // Exception thrown by _variant_t
        WMISaveError( e );
        return FALSE;
    }

    // return success
    return TRUE;
}


DWORD
GetTargetVersionEx(
    IWbemServices* pWbemServices,
    COAUTHIDENTITY* pAuthIdentity
    )
/*++

Routine Description:

    This function gets the version of the system from which we are trying to retrieve
    information from.

Arguments:

    [in] IWbemServices      :   pointer to the IWbemServices object
    [in] COAUTHIDENTITY     :   pointer to the pointer to AUTHIDENTITY structure

Return Value:

    DWORD   -   Target version of the machine if found else 0.

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF '0' IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

--*/

{
    // local variables
    HRESULT hr = S_OK;
    LONG lPos = 0;
    DWORD dwMajor = 0;
    DWORD dwMinor = 0;
    DWORD dwVersion = 0;
    ULONG ulReturned = 0;
    CHString strVersion;
    IWbemClassObject* pWbemObject = NULL;
    IEnumWbemClassObject* pWbemInstances = NULL;

    // Clear any errors.
    SetLastError( WBEM_S_NO_ERROR );

    // Check the input value
    if ( NULL == pWbemServices )
    {
        WMISaveError( WBEM_E_INVALID_PARAMETER );
        return 0;
    }

    try
    {
        // get the OS information
        SAFE_EXECUTE( pWbemServices->CreateInstanceEnum(
            _bstr_t( CLASS_CIMV2_Win32_OperatingSystem ),
            WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pWbemInstances ) );

        // set the security on the enumerated object
        SAFE_EXECUTE( SetInterfaceSecurity( pWbemInstances, pAuthIdentity ) );

        // get the enumerated objects information
        // NOTE: This needs to be traversed only one time.
        SAFE_EXECUTE( pWbemInstances->Next( WBEM_INFINITE, 1, &pWbemObject, &ulReturned ) );

        // to be on safer side ... check the count of objects returned
        if ( 0 == ulReturned )
        {
            // release the interfaces
            WMISaveError( WBEM_S_FALSE );
            SAFE_RELEASE( pWbemObject );
            SAFE_RELEASE( pWbemInstances );
            return 0;
        }

        // now get the os version value
        if ( FALSE == PropertyGet( pWbemObject, L"Version", strVersion ) )
        {
            // release the interfaces
            // Error is already set in the called function.
            SAFE_RELEASE( pWbemObject );
            SAFE_RELEASE( pWbemInstances );
            return 0;
        }

        // release the interfaces .. we dont need them furthur
        SAFE_RELEASE( pWbemObject );
        SAFE_RELEASE( pWbemInstances );

        //
        // now determine the os version
        dwMajor = dwMinor = 0;

        // Get the major version
        lPos = strVersion.Find( L'.' );
        if ( -1 == lPos )
        {
            // The version string itself is version ... THIS WILL NEVER HAPPEN
            if( FALSE == IsNumeric( strVersion, 10, FALSE ) )
            {
                return 0;
            }
            dwMajor = AsLong( strVersion, 10 );
        }
        else
        {
            // major version
            if( FALSE == IsNumeric( strVersion.Mid( 0, lPos ), 10, FALSE ) )
            {
                return 0;
            }
            dwMajor = AsLong( strVersion.Mid( 0, lPos ), 10 );

            // get the minor version
            strVersion = strVersion.Mid( lPos + 1 );
            lPos = strVersion.Find( L'.' );
            if ( -1 == lPos)
            {
                if( FALSE == IsNumeric( strVersion, 10, FALSE ) )
                {
                    return 0;
                }
                dwMinor = AsLong( strVersion, 10 );
            }
            else
            {
                if( FALSE == IsNumeric( strVersion.Mid( 0, lPos ), 10, FALSE ) )
                {
                    return 0;
                }
                dwMinor = AsLong( strVersion.Mid( 0, lPos ), 10 );
            }
        }

        // mix the version info
        dwVersion = dwMajor * 1000 + dwMinor;
    }
    catch( _com_error& e )
    {
        WMISaveError( e );
        SAFE_RELEASE( pWbemObject );
        SAFE_RELEASE( pWbemInstances );
        return 0;
    }
    catch( CHeap_Exception )
    {
        WMISaveError( WBEM_E_OUT_OF_MEMORY );
        SAFE_RELEASE( pWbemObject );
        SAFE_RELEASE( pWbemInstances );
        return 0;
    }

    // If successful then 'pWbemObject' and 'pWbemInstances' are already released.
    // return
    return dwVersion;
}


BOOL
GetPropertyFromSafeArray(
    SAFEARRAY *pSafeArray,
    LONG lIndex,
    CHString& strValue,
    VARTYPE vartype
    )
/*++

Routine Description:

    This function retrieves a property from the safe array.

Arguments:

    [in] SAFEARRAY          :   pointer to the array of elements
    [in] LONG               :   index to retrieve the data from
    [out] CHString          :   variable to hold the return value
    [in] VARTYPE            :   The type of variable to retrieve from the array

Return Value:

    TRUE on success
    FALSE on failure

NOTE: THIS FUNCTION SAVES LAST ERROR OCCURED. IF FALSE IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

--*/
{
    // Local variables.
    VARIANT var;
    HRESULT hRes = S_OK;

     // Clear any errors.
     SetLastError( WBEM_S_NO_ERROR );

    // Check the inputs.
    if ( NULL == pSafeArray )
    {
        WMISaveError( WBEM_E_INVALID_PARAMETER );
        return FALSE;
    }

    // Initialize variant.
    VariantInit( &var );

    try
    {
        // get the value
        V_VT( &var ) = vartype;
        hRes = SafeArrayGetElement( pSafeArray, &lIndex, &V_UI1( &var ) );
        if( FAILED( hRes ) )
        {   // Set error occured.
            WMISaveError( hRes );
            VariantClear( &var );
            return FALSE;
        }

        // Store requested information in
        switch( vartype )
        {
        case VT_BSTR:
            strValue = (LPCWSTR)_bstr_t( var );
            break;
        default:
            WMISaveError( WBEM_E_INVALID_PARAMETER );
            VariantClear( &var );
            return FALSE;
        }
    }
    catch( CHeap_Exception )
    {   // Exception thrown from 'strValue'.
        WMISaveError( WBEM_E_OUT_OF_MEMORY );
        VariantClear( &var );
        return FALSE;   // failure
    }

    // Clean-Up and return.
    VariantClear( &var );
    return TRUE;
}


BOOL
GetPropertyFromSafeArray(
    SAFEARRAY *pSafeArray,
    LONG lIndex,
    IWbemClassObject **pScriptObject,
    VARTYPE vartype
    )
/*++
Routine Description:

    This function retrieves a property from the safe array.

Arguments:

    [in] SAFEARRAY          :   pointer to the array of elements
    [in] LONG               :   index to retrieve the data from
    [out] IWbemClassObject  :   variable to hold the return value
    [in] VARTYPE            :   The type of variable to retrieve from the array

Return Value:

    TRUE on success
    FALSE on failure

NOTE: CALLED FUNCTION HAS TO MAKE SURE THAT '*pScriptObject' DOES NOT CONTAIN ANY
      VALUE WHICH MAY CAUSE MEMORY LEAK.
      THIS FUNCTION SAVES LAST ERROR OCCURED. IF FALSE IS RETURNED THEN ERROR
      OCCURED STRING CAN BE RETRIEVED BY CALLING 'GetReason()'.

NOTE: If TRUE is returned then 'VariantClear' is not called over 'var' since if
      a call is made to 'Variantcler' we will loose Interface pointer. Not calling
      'VariantClear' will free 'var' when its out of scope and leaving
      the interface pointer in memory which can be used by the called function.
      IT IS CALLING FUNCTION RESPONSIBILITY TO RELEASE THE INTERFACE POINTER.

--*/
{
    // Local variables.
    VARIANT var;
    HRESULT hRes = S_OK;

     // Clear any errors.
     SetLastError( WBEM_S_NO_ERROR );

    // Validate the inputs
    if ( ( NULL == pSafeArray ) ||
         ( NULL == pScriptObject ) )
    {
        WMISaveError( WBEM_E_INVALID_PARAMETER );
        return FALSE;
    }

    // Initialize variant.
    VariantInit( &var );

    // Set type of value expected.
    V_VT( &var ) = vartype;

    hRes = SafeArrayGetElement( pSafeArray, &lIndex, &V_UI1( &var ) );
    // check for return value.
    if( FAILED( hRes ) )
    {   // Set error occured.
        WMISaveError( hRes );
        VariantClear( &var );
        return FALSE;
    }
    // Store information requested.
    switch( vartype )
    {
    case VT_UNKNOWN:
        *pScriptObject = (IWbemClassObject *) var.punkVal;
        break;
    default:
        WMISaveError( WBEM_E_INVALID_PARAMETER );
        VariantClear( &var );
        return FALSE;
    }

    // return
    return TRUE;
}