|
|
/*********************************************************************************************
Copyright (c) Microsoft Corporation
Module Name:
LoggingData.cpp
Abstract:
Collects and displays all the data related with the logging option.
Author:
Wipro Technologies.
Revision History:
22-Feb-2001 : Created It.
*********************************************************************************************/
#include "pch.h"
#include "GpResult.h"
#include "WMI.h"
// Local function prototypes
BOOL GetDomainType( LPTSTR lpszDomainName, BOOL * pbW2K, BOOL *pbLocalAccount );BOOL RsopDeleteMethod( IWbemClassObject *pClass, CHString strNameSpace, IWbemServices *pNamespace );VOID DisplayLinkSpeed( IWbemServices *pNameSpace, COAUTHIDENTITY *pAuthIdentity );VOID SortAppliedData( TARRAY arrAppliedData );
/*********************************************************************************************
Routine Description:
This function is the main entry point for collecting and displaying the data for logging mode
Arguments:
None
Return Value:
TRUE on SUCCESS FALSE on ERROR*********************************************************************************************/BOOL CGpResult::GetLoggingData(){ // Local declarations
BOOL bResult = FALSE; BOOL bAllUsers = TRUE; DWORD dwBufferSize = MAX_STRING_LENGTH; DWORD dwPosition = 0xffffffff;
// Connect to wmi...connecting to 'cimv2' and saving the pointer in a member variable
bResult = ConnectWmiEx( m_pWbemLocator, &m_pWbemServices, m_strServerName, m_strUserName, m_strPassword, &m_pAuthIdentity, m_bNeedPassword, ROOT_NAME_SPACE, &m_bLocalSystem );
if( bResult == FALSE ) { ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() ); return FALSE; }
// check the remote system version and its compatiblity
if ( m_bLocalSystem == FALSE ) { // check the version compatibility
DWORD dwVersion = 0; dwVersion = GetTargetVersionEx( m_pWbemServices, m_pAuthIdentity );
// Check for the version W2K = 5000 and WindowsXP = 5001
if ( dwVersion <= VERSION_CHECK ) { // Display the appropriate error message
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, ERROR_OS_INCOMPATIBLE ); return FALSE; } }
// Set the password to the one got in the AUTHIDENTITY structure
if( m_pAuthIdentity != NULL ) { m_pwszPassword = m_pAuthIdentity->Password; }
// check if it is the local system and the user credentials are specified....
// if so display a warning message
if( ( m_bLocalSystem == TRUE ) && ( m_strUserName.GetLength() != 0 ) ) { ShowMessage( stderr, GetResString( IDS_WARNING ) ); ShowMessage( stderr, GetResString( IDS_WARN_LOCAL ) ); ShowMessage( stderr, NEW_LINE );
// set the user name and password to NULL
m_strUserName = L""; m_pwszPassword = NULL;
// Get the new screen co-ordinates
if ( m_hOutput != NULL ) { GetConsoleScreenBufferInfo( m_hOutput, &m_csbi ); } }
// Connection part is over...check wether the user,for whom the RSOP data
// has to be got has been specified.
if( m_strUser.GetLength() == 0 ) { // user is not specified....get the current logged on user
LPWSTR pwszUserName = NULL; try { pwszUserName = m_strUser.GetBufferSetLength( dwBufferSize ); } catch( ... ) { // display the error message
SetLastError((DWORD) E_OUTOFMEMORY ); SaveLastError(); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() ); }
if ( GetUserNameEx( NameSamCompatible, pwszUserName, &dwBufferSize ) == FALSE ) { // error occured while trying to get the current user info
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetResString( IDS_METHOD_FAILED ) );
return FALSE; }
// Release the buffer
m_strUser.ReleaseBuffer(); }
// Separating the domain name from the user name for whom the data has to be retrieved
if( m_strUser.Compare( TEXT_WILD_CARD ) != 0 ) { bAllUsers = FALSE; dwPosition = m_strUser.Find( SLASH ); try { if( dwPosition != -1 ) { m_strDomainName = m_strUser.Left( dwPosition ); m_strUser = m_strUser.Mid( ( dwPosition + 1 ), m_strUser.GetLength() ); } else { // Try for the name@domain format (UPN format)
dwPosition = m_strUser.Find( SEPARATOR_AT ); if( dwPosition != -1 ) { m_strDomainName = m_strUser.Mid( ( dwPosition + 1 ), m_strUser.GetLength() ); m_strUser = m_strUser.Left( dwPosition ); }
// Remove the unwanted things in the domain name
dwPosition = m_strDomainName.Find( SEPARATOR_DOT ); if( dwPosition != -1 ) { m_strDomainName = m_strDomainName.Left( dwPosition ); } } } catch( ... ) { // display the error message
SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() ); } }
PrintProgressMsg( m_hOutput, GetResString( IDS_USER_DATA ), m_csbi );
//
// Start the retrieval of information....
// Get the user information
if( GetUserData( bAllUsers ) == FALSE ) { return FALSE; }
return TRUE;}
/*********************************************************************************************
Routine Description:
This function displays the non verbose data
Arguments:
[in] USERINFO : pointer to the user information structure [in] IWBEMSERVICES : pointer to the namespace
Return Value:
TRUE on SUCCESS FALSE on FAILURE*********************************************************************************************/BOOL CGpResult::DisplayData( PUSERINFO pUserInfo, IWbemServices *pRsopNameSpace ){ // local variables
HRESULT hResult = S_OK;
BOOL bResult = FALSE; BOOL bCreatedRsop = FALSE;
ULONG ulReturn = 0; ULONG ulExtendedCode = 0; DWORD dwi = 0;
DWORD dwFlags = 0; DWORD dwMutex = 0;
CHString strTemp; CHString strNameSpace;
IWbemClassObject *pClass = NULL; IWbemClassObject *pInClass = NULL; IWbemClassObject *pInInst = NULL; IWbemClassObject *pOutInst = NULL; IWbemServices *pNameSpace = NULL; IEnumWbemClassObject *pRsopClass = NULL;
BOOL bW2KDomain = FALSE; BOOL bLocalAccount = FALSE; WCHAR szMsgBuffer[MAX_RES_STRING] = NULL_STRING; WCHAR szMutexName[512] = MUTEX_NAME;
try { if( pUserInfo == NULL || pRsopNameSpace == NULL ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
_com_issue_error( STG_E_UNKNOWN ); }
PrintProgressMsg( m_hOutput, GetResString( IDS_GET_PROVIDER ), m_csbi );
// Get the object for the RSOP diagnostic mode provider
hResult = pRsopNameSpace->GetObject( _bstr_t( CLS_DIAGNOSTIC_PROVIDER ), 0, NULL, &pClass, NULL ); CHECK_HRESULT_EX( hResult );
PrintProgressMsg( m_hOutput, GetResString( IDS_GET_METHOD ), m_csbi );
// get the reqd. method....create an rsop session
hResult = pClass->GetMethod( _bstr_t( FN_CREATE_RSOP ), 0, &pInClass, NULL ); CHECK_HRESULT_EX( hResult );
// spawn the instances....get a new instance of the provider
hResult = pInClass->SpawnInstance( 0, &pInInst ); CHECK_HRESULT_EX( hResult );
// Put the user SID...
PrintProgressMsg( m_hOutput, GetResString( IDS_PUT_SID ), m_csbi );
hResult = PropertyPut( pInInst, CPV_USER_SID, pUserInfo->strUserSid ); CHECK_HRESULT_EX( hResult );
dwFlags = FLAG_FORCE_CREATENAMESPACE; if ( m_dwScope == SCOPE_COMPUTER ) { dwFlags |= FLAG_NO_USER; } else if ( m_dwScope == SCOPE_USER ) { dwFlags |= FLAG_NO_COMPUTER; } hResult = PropertyPut( pInInst, CPV_FLAGS, dwFlags ); CHECK_HRESULT_EX( hResult );
PrintProgressMsg( m_hOutput, GetResString( IDS_WAIT ), m_csbi );
// We are ready to call the method to create a session
// Check on the mutex to see if the call can be executed
//create the mutex
StringConcat( szMutexName, L"_", SIZE_OF_ARRAY(szMutexName)); strTemp = pUserInfo->strUserName; LONG lPos = strTemp.Find(TEXT_BACKSLASH); if( lPos >= 0 && lPos <= strTemp.GetLength() ) { strTemp.SetAt(lPos, L'_' ); }
StringConcat( szMutexName, strTemp, SIZE_OF_ARRAY(szMutexName) ); if( FALSE == CreateRsopMutex( szMutexName ) ) { ShowMessage(stdout, GetResString(IDS_INFO) ); ShowMessage(stdout, GetResString(IDS_MUTEX_FAILED));
// release the interface pointers and exit
SAFEIRELEASE( pRsopClass ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pInClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pNameSpace );
return TRUE; } dwMutex = WAIT_FAILED; if( NULL == m_hMutex ) { PrintProgressMsg( m_hOutput, NULL, m_csbi );
ShowMessage(stdout, GetResString(IDS_INFO) ); ShowMessage(stdout, GetResString(IDS_ERROR_SESSION_CONFLICT));
// release the interface pointers and exit
SAFEIRELEASE( pRsopClass ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pInClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pNameSpace );
return TRUE; } if( m_hMutex != NULL ) { dwMutex = WaitForSingleObject( m_hMutex, INFINITE ); if( dwMutex == WAIT_FAILED ) { ShowLastErrorEx( stdout, SLE_TYPE_ERROR | SLE_SYSTEM ); } }
retry:
if( dwMutex != WAIT_FAILED ) { // Print the progress message
strTemp.Format( GetResString( IDS_CREATE_SESSION ), pUserInfo->strUserName ); PrintProgressMsg( m_hOutput, strTemp, m_csbi );
// All The required properties are set, so...execute method RSopCreateSession
hResult = pRsopNameSpace->ExecMethod( _bstr_t( CLS_DIAGNOSTIC_PROVIDER ), _bstr_t( FN_CREATE_RSOP ), 0, NULL, pInInst, &pOutInst, NULL); } if( pOutInst == NULL ) { hResult = E_FAIL; } if( FAILED( hResult ) ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
// display the error message
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetResString( IDS_METHOD_FAILED ) );
// release the interface pointers and exit
SAFEIRELEASE( pRsopClass ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pInClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pNameSpace );
// Release the object
ReleaseMutex( m_hMutex ); return FALSE; }
// Get the result value...
bResult = PropertyGet( pOutInst, FPR_RETURN_VALUE, ulReturn, 0 ); CHECK_BRESULT( bResult );
if( ulReturn != 0 ) { if ( ulReturn == WBEM_E_ACCESS_DENIED ) { // check the extended error code to see why this is failed
bResult = PropertyGet( pOutInst, CPV_EXTENDEDINFO, ulExtendedCode, 0 ); CHECK_BRESULT( bResult ); // ...
if ( ulExtendedCode == RSOP_COMPUTER_ACCESS_DENIED ) { if ( m_dwScope != SCOPE_COMPUTER ) { hResult = PropertyPut( pInInst, CPV_FLAGS, FLAG_FORCE_CREATENAMESPACE | FLAG_NO_COMPUTER ); CHECK_HRESULT_EX( hResult );
// change the scope parameter accordingly
m_dwScope = SCOPE_USER;
// retry the creation of namespace
goto retry; } } else if ( ulExtendedCode == RSOP_USER_ACCESS_DENIED ) { if ( m_dwScope != SCOPE_USER ) { hResult = PropertyPut( pInInst, CPV_FLAGS, FLAG_FORCE_CREATENAMESPACE | FLAG_NO_USER ); CHECK_HRESULT_EX( hResult ); // change the scope parameter accordingly
m_dwScope = SCOPE_COMPUTER;
// retry the creation of namespace
goto retry; } } }
// erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetResString( IDS_METHOD_FAILED ) );
// release the interface pointers and exit
SAFEIRELEASE( pRsopClass ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pInClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pNameSpace );
// Release the object
ReleaseMutex( m_hMutex ); return FALSE; }
// set the flag to indicate that the namespace has been created.
bCreatedRsop = TRUE;
// Get the resultant RSOP name space
bResult = PropertyGet( pOutInst, FPR_RSOP_NAME_SPACE, strTemp, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult ); // Check if we have got the output
if( StringCompare( strTemp, V_NOT_AVAILABLE, FALSE, 0 ) == 0 ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetResString( IDS_METHOD_FAILED ) );
// release the allocated variables
SAFEIRELEASE( pRsopClass ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pInClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pNameSpace );
// Release the object
ReleaseMutex( m_hMutex ); return FALSE; }
// Got the data so start displaying
// Display the information common to both scopes
DisplayCommonData( pUserInfo );
// Get the string starting with 'R'...as that's where the RSOP namespace starts
// This is done to remove the '\'s in the beginning of the string returned.
lPos = 0; strTemp.MakeLower(); lPos = strTemp.Find( START_NAMESPACE ); if ( lPos != -1 ) { strTemp = strTemp.Mid( lPos + 1 ); } else { _com_issue_error( STG_E_UNKNOWN ); }
// check if the computer information has to be displayed
if( (m_dwScope == SCOPE_COMPUTER) || (m_dwScope == SCOPE_ALL) ) { // connect to the resultant name space (computer)
strNameSpace = strTemp + TEXT_BACKSLASH + TEXT_SCOPE_COMPUTER;
ConnectWmi( m_pWbemLocator, &pNameSpace, m_strServerName, m_strUserName, m_pwszPassword, &m_pAuthIdentity, FALSE, strNameSpace, &hResult ); CHECK_HRESULT( hResult );
// get the link speed information
DisplayLinkSpeed( pNameSpace, m_pAuthIdentity );
// Display the heading for the scope Computer
ShowMessage( stdout, GetResString( IDS_GPO_COMPUTER ) ); ShowMessage( stdout, NEW_LINE ); for( dwi = StringLengthInBytes( GetResString( IDS_GPO_COMPUTER ) ); dwi > 1; dwi-- ) { ShowMessage( stdout, GetResString( IDS_DASH ) ); } ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) );
// Display the FQDN for the computer
ShowMessage( stdout, pUserInfo->strComputerFQDN ); ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) );
// Display the link speed threshold value for the computer
DisplayThresholdSpeedAndLastTimeInfo( TRUE );
/************this code is moved from common data to display domain name and domain type on 18-oct-2001*****************/
StringCopy( szMsgBuffer, pUserInfo->strComputerDomain, MAX_RES_STRING ); if( StringLengthW( szMsgBuffer,0 ) != 0 ) { StringCopy( szMsgBuffer, _tcstok( szMsgBuffer, GetResString( IDS_LAST_CHAR ) ), MAX_RES_STRING ); StringCopy( szMsgBuffer, _tcstok( NULL, GetResString( IDS_LAST_CHAR ) ), MAX_RES_STRING ); } // Get the domain type information
GetDomainType (szMsgBuffer, &bW2KDomain, &bLocalAccount);
ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) ); ShowMessage( stdout, GetResString( IDS_DOMAIN_NAME ) ); ShowMessage( stdout, szMsgBuffer ); ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) );
ShowMessage( stdout, GetResString( IDS_DOMAIN_TYPE ) );
// if it is a win2k domain type
if ( bW2KDomain ) { ShowMessage( stdout, GetResString( IDS_W2K_DOMAIN ) ); } else { if ( bLocalAccount ) // local account
{// ShowMessage( stdout, V_NOT_AVAILABLE );
ShowMessage( stdout, GetResString( IDS_LOCAL_COMP ) ); } else //win NT4
{ ShowMessage( stdout, GetResString( IDS_NT4_DOMAIN ) ); } } ShowMessage( stdout, GetResString( IDS_NEWLINE ) );/*************************************************************************************************/
// Display the heading for the Computer GPO's
ShowMessage( stdout, GetResString( IDS_GPO_DISPLAY ) ); ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) ); for( dwi = StringLengthInBytes( GetResString( IDS_GPO_DISPLAY ) ); dwi > 4; dwi-- ) { ShowMessage( stdout, GetResString( IDS_DASH ) ); } ShowMessage( stdout, GetResString( IDS_NEWLINE ) );
// Display the GPO data for computer
GpoDisplay( pNameSpace, TEXT_SCOPE_COMPUTER );
// Display the security groups for the system
DisplaySecurityGroups( pNameSpace, TRUE );
// check wether the verbose option is specified
if( m_bVerbose == TRUE || m_bSuperVerbose == TRUE ) { // display the verbose computer information
DisplayVerboseComputerData( pNameSpace ); }
// release the interface pointer
SAFEIRELEASE( pNameSpace ); }
// check for user...
if( (m_dwScope == SCOPE_USER) || (m_dwScope == SCOPE_ALL) ) { // connect to the resultant name space (user)
strNameSpace = strTemp + TEXT_BACKSLASH + TEXT_SCOPE_USER;
ConnectWmi( m_pWbemLocator, &pNameSpace, m_strServerName, m_strUserName, m_pwszPassword, &m_pAuthIdentity, FALSE, strNameSpace, &hResult ); CHECK_HRESULT( hResult );
// if only the user scope has been specified then the link speed
// information has not yet been displayed...display it
if( m_dwScope == SCOPE_USER ) { // Get the link speed information
DisplayLinkSpeed( pNameSpace, m_pAuthIdentity ); }
// Display the heading for the scope User
ShowMessage( stdout, GetResString( IDS_GPO_USER ) ); ShowMessage( stdout, NEW_LINE ); for( dwi = StringLengthInBytes( GetResString( IDS_GPO_USER ) ); dwi > 1; dwi-- ) { ShowMessage( stdout, GetResString( IDS_DASH ) ); } ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) );
// Display the FQDN for the computer
ShowMessage( stdout, pUserInfo->strUserFQDN ); ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) );
// Display the link speed threshold value for the user
DisplayThresholdSpeedAndLastTimeInfo( FALSE );
/******this code is added to display domain name and domain type for the user**************/
ShowMessage( stdout, GetResString(IDS_NEWLINE) ); StringCopy( szMsgBuffer, pUserInfo->strUserDomain, MAX_RES_STRING ); GetDomainType (szMsgBuffer, &bW2KDomain, &bLocalAccount);
ShowMessage( stdout, TAB_ONE ); ShowMessage( stdout, GetResString( IDS_USER_DOMAIN_NAME ) ); ShowMessage( stdout, szMsgBuffer ); ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) );
ShowMessage( stdout, GetResString( IDS_USER_DOMAIN_TYPE ) ); // if it is a win2k domain type
if ( bW2KDomain ) { ShowMessage( stdout, GetResString( IDS_W2K_DOMAIN ) ); } else { if ( bLocalAccount ) // local account
{// ShowMessage( stdout, V_NOT_AVAILABLE );
ShowMessage( stdout, GetResString( IDS_LOCAL_COMP ) ); } else //win NT4
{ ShowMessage( stdout, GetResString( IDS_NT4_DOMAIN ) ); } } ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) );
/*****************************************************************************************/
// Display the heading for the User GPO's
ShowMessage( stdout, GetResString( IDS_GPO_DISPLAY ) ); ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) ); for( dwi = StringLengthInBytes( GetResString( IDS_GPO_DISPLAY ) ); dwi > 4; dwi-- ) { ShowMessage( stdout, GetResString( IDS_DASH ) ); } ShowMessage( stdout, GetResString( IDS_NEWLINE ) );
// Display the GPO data for user
GpoDisplay( pNameSpace, TEXT_SCOPE_USER );
// Display the security groups for the user
DisplaySecurityGroups( pNameSpace, FALSE );
// check wether the verbose option is specified
if( m_bVerbose == TRUE || m_bSuperVerbose == TRUE ) { // display the verbose computer information
DisplayVerboseUserData( pUserInfo, pNameSpace ); }
// release the interface pointer
SAFEIRELEASE( pNameSpace ); }
// Delete the namespace created
if( RsopDeleteMethod( pClass, strTemp, pRsopNameSpace ) == FALSE ) { // release the allocated variables
SAFEIRELEASE( pRsopNameSpace ); SAFEIRELEASE( pRsopClass ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pInClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst );
// Release the object
ReleaseMutex( m_hMutex );
return FALSE; } } catch( _com_error & error ) { // display the error message
WMISaveError( error.Error() ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() );
// Delete the name space if it has been created.
if( bCreatedRsop == TRUE ) { RsopDeleteMethod( pClass, strTemp, pRsopNameSpace ); }
// release the interface pointers and exit
SAFEIRELEASE( pRsopClass ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pInClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pNameSpace );
// Release the object
ReleaseMutex( m_hMutex );
return FALSE; }
// release the interface pointers and exit
SAFEIRELEASE( pRsopClass ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pInClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pNameSpace );
// Release the object
ReleaseMutex( m_hMutex );
return TRUE;}
/*********************************************************************************************
Routine Description:
This function gets the user data and fills the structure with the same
Arguments:
[in] BOOL bAllUsers : Specifies that the Rsop data has to be retrieved for all the users.
Return Value:
TRUE on SUCCESS FALSE on FAILURE*********************************************************************************************/BOOL CGpResult::GetUserData( BOOL bAllUsers ){ // Local variables
HRESULT hResult = S_OK;
BOOL bResult = FALSE; BOOL bGotDomainInfo = FALSE; BOOL bConnFlag = TRUE;
TCHAR szTemp[ MAX_STRING_LENGTH ]; TCHAR szServer[ MAX_STRING_LENGTH ]; TCHAR szName[ MAX_STRING_LENGTH ]; TCHAR szDomain[ MAX_STRING_LENGTH ]; TCHAR szFQDN[ MAX_STRING_LENGTH ]; TCHAR szAdsiBuffer[ MAX_STRING_LENGTH ];
CHString strTemp = NULL_STRING; CHString strDisplay = NULL_STRING;
IEnumWbemClassObject *pEnumClass = NULL; IWbemServices *pRsopNameSpace = NULL; IWbemClassObject *pUserClass = NULL; IWbemClassObject *pInInst = NULL; IWbemClassObject *pOutInst = NULL;
ULONG ulReturn = 0; LONG lCount = 0; LONG lLBound = 0; LONG lUBound = 0;
DWORD dwName = MAX_STRING_LENGTH; DWORD dwDomain = MAX_STRING_LENGTH; DWORD dwBufSize = MAX_STRING_LENGTH;
USERINFO *pUserInfo = new USERINFO;
VARIANT vVarVerbose; VARTYPE vartype;
SAFEARRAY *safeArray = NULL;
PSID pSid = NULL; SID_NAME_USE *pSidNameUse = new SID_NAME_USE;
try { // set the strings to NULL
SecureZeroMemory( szTemp, MAX_STRING_LENGTH * sizeof( TCHAR ) ); SecureZeroMemory( szName, MAX_STRING_LENGTH * sizeof( TCHAR ) ); SecureZeroMemory( szServer, MAX_STRING_LENGTH * sizeof( TCHAR ) ); SecureZeroMemory( szDomain, MAX_STRING_LENGTH * sizeof( TCHAR ) ); SecureZeroMemory( szFQDN, MAX_STRING_LENGTH * sizeof( TCHAR ) );
PrintProgressMsg( m_hOutput, GetResString( IDS_CONNECT_RSOP ), m_csbi );
// connect to the RSOP namespace
ConnectWmi( m_pWbemLocator, &pRsopNameSpace, m_strServerName, m_strUserName, m_pwszPassword, &m_pAuthIdentity, FALSE, _bstr_t( ROOT_RSOP ), &hResult ); CHECK_HRESULT( hResult );
// Get the object for the RSOP diagnostic mode provider
hResult = pRsopNameSpace->GetObject( _bstr_t( CLS_DIAGNOSTIC_PROVIDER ), 0, NULL, &pUserClass, NULL ); CHECK_HRESULT( hResult );
PrintProgressMsg( m_hOutput, GetResString( IDS_GET_METHOD ), m_csbi );
// get the reqd. method....to enumerate the users
hResult = pUserClass->GetMethod( _bstr_t( FN_ENUM_USERS ), 0, &pInInst, NULL ); CHECK_HRESULT( hResult );
PrintProgressMsg( m_hOutput, GetResString( IDS_GET_SID ), m_csbi );
// Execute method RSopEnumerateUsers
hResult = pRsopNameSpace->ExecMethod( _bstr_t( CLS_DIAGNOSTIC_PROVIDER ), _bstr_t( FN_ENUM_USERS ), 0, NULL, pInInst, &pOutInst, NULL); if( pOutInst == NULL ) { hResult = E_FAIL; } if( FAILED( hResult ) ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetResString( IDS_METHOD_FAILED ) );
// release the interface pointers and exit
SAFEIRELEASE( pRsopNameSpace ); SAFEIRELEASE( pUserClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pEnumClass );
SAFE_DELETE( pUserInfo ); SAFE_DELETE( pSidNameUse );
return FALSE; }
// Get the result value...
bResult = PropertyGet( pOutInst, FPR_RETURN_VALUE, ulReturn, 0 ); CHECK_BRESULT( bResult );
if( ulReturn != 0 ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetResString( IDS_METHOD_FAILED ) );
// release the interface pointers and exit
SAFEIRELEASE( pRsopNameSpace ); SAFEIRELEASE( pUserClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pEnumClass );
SAFE_DELETE( pUserInfo ); SAFE_DELETE( pSidNameUse );
return FALSE; }
VariantInit( &vVarVerbose ); pOutInst->Get( _bstr_t( CPV_USER_SIDS ), 0, &vVarVerbose, 0, 0 ); CHECK_HRESULT_VAR( hResult, vVarVerbose ); if( vVarVerbose.vt != VT_NULL && vVarVerbose.vt != VT_EMPTY ) { // get the type of the elements in the safe array
vartype = (VARTYPE)(V_VT( &vVarVerbose ) & ~VT_ARRAY);
//get the array of strings in to the safe array from the variant
safeArray = (SAFEARRAY *)vVarVerbose.parray;
//get the number of elements (subkeys)
if( safeArray != NULL ) { hResult = SafeArrayGetLBound( safeArray, 1, &lLBound ); CHECK_HRESULT( hResult );
hResult = SafeArrayGetUBound( safeArray, 1, &lUBound ); CHECK_HRESULT( hResult ); if( lUBound == 0xffffffff ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
ShowMessage( stdout, GetResString( IDS_INFO) ); ShowMessageEx( stdout, 1, TRUE, GetResString( IDS_USER_NO_RSOP1) );
// release the interface pointers and exit
SAFEIRELEASE( pRsopNameSpace ); SAFEIRELEASE( pUserClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pEnumClass );
SAFE_DELETE( pUserInfo ); SAFE_DELETE( pSidNameUse );
return TRUE; } }
// If we have to get the information from a remote machine then...
// connect to the remote machine.
if ( m_bLocalSystem == FALSE ) { StringCopy( szServer, m_strServerName, MAX_STRING_LENGTH ); StringCopy( szName, m_strUserName, MAX_STRING_LENGTH );
// erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
bResult = EstablishConnection( szServer, szName, MAX_STRING_LENGTH, m_pwszPassword, MAX_STRING_LENGTH, FALSE ); if( bResult != TRUE ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() );
// release the interface pointers and exit
SAFEIRELEASE( pRsopNameSpace ); SAFEIRELEASE( pUserClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pEnumClass );
SAFE_DELETE( pUserInfo ); SAFE_DELETE( pSidNameUse );
return FALSE; } else { switch( GetLastError() ) { case I_NO_CLOSE_CONNECTION: bConnFlag = FALSE; break;
case E_LOCAL_CREDENTIALS: case ERROR_SESSION_CREDENTIAL_CONFLICT: bConnFlag = FALSE; break;
default: break; } }
// Get the new output co-ordinates
if ( m_hOutput != NULL ) { GetConsoleScreenBufferInfo( m_hOutput, &m_csbi ); } }
for( lCount = lLBound ; lLBound <= lUBound; lLBound++ ) { bResult = GetPropertyFromSafeArray( safeArray, lLBound, strTemp, vartype ); CHECK_BRESULT( bResult );
// Got the SID...save it in the structure
pUserInfo->strUserSid = strTemp;
PrintProgressMsg( m_hOutput, GetResString( IDS_GET_NAME ), m_csbi );
// Get the User Name
StringCopy( szTemp, strTemp, MAX_STRING_LENGTH ); ConvertStringSidToSid( szTemp, &pSid );
// Get the user name for the SID we have got
bResult = LookupAccountSid( szServer, pSid, szName, &dwName, szDomain, &dwDomain, pSidNameUse ); if( bResult == 0 ) { // Could not get the name from the API try to retrieve it from WMI
bResult = GetUserNameFromWMI( szTemp, szName, szDomain ); PrintProgressMsg( m_hOutput, NULL, m_csbi ); if( bResult == FALSE ) { // Increment the count
lCount++;
// If the user was not found then display a message stating the same
if( lCount > lUBound ) { strTemp = L""; if( bAllUsers == FALSE ) { // check if we need to append the domain name
if ( m_strDomainName.GetLength() != 0 ) { strTemp = m_strDomainName + _T( "\\" ) + m_strUser; } else { strTemp = m_strUser; } }
// Form the display string
strDisplay.Format( GetResString( IDS_USER_NO_RSOP ), _X( strTemp ) );
ShowMessage( stdout, GetResString( IDS_INFO ) ); ShowMessage( stdout, strDisplay ); }
// could not get a name for this SID, so continue with the next SID.
continue; } }
// Free the pSid
if( pSid != NULL ) { LocalFree( pSid ); pSid = NULL; }
// Check wether the Rsop data has to be retrieved for this user name.
if( bAllUsers == FALSE ) { if( StringCompare( szName, m_strUser, TRUE, 0 ) != 0 || ( StringCompare( szDomain, m_strDomainName, TRUE, 0 ) != 0 && m_strDomainName.GetLength() != 0 ) ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
// re-set the buffer sizes
dwName = MAX_STRING_LENGTH; dwDomain = MAX_STRING_LENGTH;
// Increment the count
lCount++;
// If the user was not found then display a message stating the same
if( lCount > lUBound ) { // check if we need to append the domain name
if ( m_strDomainName.GetLength() != 0 ) { strTemp = m_strDomainName + _T( "\\" ) + m_strUser; } else { strTemp = m_strUser; }
// Form the display string
strDisplay.Format( GetResString( IDS_USER_NO_RSOP ), _X( strTemp ) );
ShowMessage( stdout, GetResString( IDS_INFO ) ); ShowMessage( stdout, strDisplay ); }
// No need to get the data for this user
continue; } }
// Store the user name into the structure.
pUserInfo->strUserName = szName;
// Append the domain name to the user name.
StringConcat( szDomain, TEXT_BACKSLASH, MAX_STRING_LENGTH ); StringConcat( szDomain, pUserInfo->strUserName, MAX_STRING_LENGTH ); pUserInfo->strUserName = szDomain;
PrintProgressMsg( m_hOutput, GetResString( IDS_GET_PROFILE ), m_csbi );
// Get the user profile information
if( GetUserProfile( pUserInfo ) == FALSE ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
// Display the error message
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetResString( IDS_METHOD_FAILED ) );
// release the interface pointers and exit
SAFEIRELEASE( pRsopNameSpace ); SAFEIRELEASE( pUserClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pEnumClass );
SAFE_DELETE( pUserInfo ); SAFE_DELETE( pSidNameUse );
// if we have opened a connection then close the same.
if( m_bLocalSystem == FALSE && bConnFlag == TRUE ) { StringCopy( szServer, m_strServerName, MAX_STRING_LENGTH ); CloseConnection( szServer ); }
return FALSE; }
if( bGotDomainInfo == FALSE ) { PrintProgressMsg( m_hOutput, GetResString( IDS_GET_COMMON ), m_csbi );
// Get the domain name and other related information
if( GetDomainInfo( pUserInfo ) == FALSE ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
// Display the error message
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetResString( IDS_METHOD_FAILED ) );
// release the interface pointers and exit
SAFEIRELEASE( pRsopNameSpace ); SAFEIRELEASE( pUserClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pEnumClass );
SAFE_DELETE( pUserInfo ); SAFE_DELETE( pSidNameUse );
// if we have opened a connection then close the same.
if( m_bLocalSystem == FALSE && bConnFlag == TRUE ) { StringCopy( szServer, m_strServerName, MAX_STRING_LENGTH ); CloseConnection( szServer ); }
return FALSE; }
// Get the OS information
if( GetOsInfo( pUserInfo ) == FALSE ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
// Display the error message
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetResString( IDS_METHOD_FAILED ) );
// release the interface pointers and exit
SAFEIRELEASE( pRsopNameSpace ); SAFEIRELEASE( pUserClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pEnumClass );
SAFE_DELETE( pUserInfo ); SAFE_DELETE( pSidNameUse );
// if we have opened a connection then close the same.
if( m_bLocalSystem == FALSE && bConnFlag == TRUE ) { StringCopy( szServer, m_strServerName, MAX_STRING_LENGTH ); CloseConnection( szServer ); }
return FALSE; }
// Get the FQDN of the computer
// PrintProgressMsg( m_hOutput, GetResString( IDS_GET_FQDN ), m_csbi );
if( m_bLocalSystem == TRUE ) { // we have to get the FQDN for the local system
// use the GetComputerObjectName API
ulReturn = MAX_STRING_LENGTH; GetComputerObjectName( NameFullyQualifiedDN, szFQDN, &ulReturn); } else { // Get the local computers domain name
GetComputerNameEx( ComputerNameDnsDomain, szAdsiBuffer, &dwBufSize );
StringCopy( szServer, m_strADSIServer, MAX_STRING_LENGTH ); StringConcat( szServer, TEXT_DOLLAR, MAX_STRING_LENGTH );
// Check if the machine we are querying is in the same domain
if( m_strADSIDomain.CompareNoCase( szAdsiBuffer ) == 0 ) { // get the FQDN from the Translate name call
dwBufSize = MAX_STRING_LENGTH; TranslateName( szServer, NameDisplay, NameFullyQualifiedDN, szFQDN, &dwBufSize ); } else { // Get the FQDN from ADSI directory services
GetFQDNFromADSI( szFQDN, TRUE, szServer ); } }
// Store the FQDN into the structure.
pUserInfo->strComputerFQDN = szFQDN;
// Set the flag to TRUE so that this code is not executed again and again
bGotDomainInfo = TRUE; }
// Get the FQDN of the user
if( ( m_bLocalSystem == TRUE ) || ( m_strADSIDomain.CompareNoCase( szAdsiBuffer ) == 0 ) ) { SecureZeroMemory( szFQDN, MAX_STRING_LENGTH * sizeof( TCHAR ) ); dwBufSize = MAX_STRING_LENGTH; StringCopy( szName, pUserInfo->strUserName, MAX_STRING_LENGTH );
// get the FQDN from the Translate name call
TranslateName( szName, NameSamCompatible, NameFullyQualifiedDN, szFQDN, &dwBufSize ); } else { // Get the FQDN from ADSI directory services
StringCopy( szName, pUserInfo->strUserName, MAX_STRING_LENGTH ); GetFQDNFromADSI( szFQDN, FALSE, szName ); }
// Store the FQDN into the structure.
pUserInfo->strUserFQDN = szFQDN;
//get the terminal server mode
GetTerminalServerMode(pUserInfo);
// Now display the data
PrintProgressMsg( m_hOutput, GetResString( IDS_STARTED_RETRIEVAL ), m_csbi ); if( FALSE == DisplayData( pUserInfo, pRsopNameSpace ) ) { // release the interface pointers and exit
SAFEIRELEASE( pRsopNameSpace ); SAFEIRELEASE( pUserClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pEnumClass ); SAFE_DELETE( pUserInfo ); SAFE_DELETE( pSidNameUse ); return FALSE; }
// Get the new output co-ordinates
if ( m_hOutput != NULL ) { GetConsoleScreenBufferInfo( m_hOutput, &m_csbi ); }
// re-set the buffers and their sizes
SecureZeroMemory( szTemp, MAX_STRING_LENGTH * sizeof( TCHAR ) ); SecureZeroMemory( szName, MAX_STRING_LENGTH * sizeof( TCHAR ) ); SecureZeroMemory( szServer, MAX_STRING_LENGTH * sizeof( TCHAR ) ); SecureZeroMemory( szDomain, MAX_STRING_LENGTH * sizeof( TCHAR ) );
dwName = MAX_STRING_LENGTH; dwDomain = MAX_STRING_LENGTH; }// for
// if we have opened a connection then close the same.
if( m_bLocalSystem == FALSE && bConnFlag == TRUE ) { StringCopy( szServer, m_strServerName, MAX_STRING_LENGTH ); CloseConnection( szServer ); } } else { // No classes were retrieved....display msg
// erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
// check if we need to append the domain name
if ( m_strDomainName.GetLength() != 0 ) { strTemp = m_strDomainName + _T( "\\" ) + m_strUser; } else { strTemp = m_strUser; }
// Form the display string
strDisplay.Format( GetResString( IDS_USER_NO_RSOP ), _X( strTemp ) );
ShowMessage( stdout, GetResString( IDS_INFO ) ); ShowMessage( stdout, strDisplay ); }
VariantClear(&vVarVerbose); } catch( _com_error & error ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
// display the error msg
WMISaveError( error.Error() ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() );
// release the interface pointers and exit
SAFEIRELEASE( pRsopNameSpace ); SAFEIRELEASE( pUserClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pEnumClass );
SAFE_DELETE( pUserInfo ); SAFE_DELETE( pSidNameUse );
VariantClear(&vVarVerbose);
return FALSE; }
// release the interface pointers and exit
SAFEIRELEASE( pRsopNameSpace ); SAFEIRELEASE( pUserClass ); SAFEIRELEASE( pInInst ); SAFEIRELEASE( pOutInst ); SAFEIRELEASE( pEnumClass ); SAFE_DELETE( pUserInfo ); SAFE_DELETE( pSidNameUse ); VariantClear(&vVarVerbose);
return TRUE;}
/*********************************************************************************************
Routine Description:
This function gets the user profile data and fills the array with the same
Arguments:
[in] PUSERINFO pUserInfo : Structure containing the user information.
Return Value:
TRUE on SUCCESS FALSE on FAILURE*********************************************************************************************/BOOL CGpResult::GetUserProfile( PUSERINFO pUserInfo ){ // Local variables
HRESULT hResult = S_OK;
IWbemServices *pDefaultNameSpace = NULL;
TCHAR szTemp[ MAX_STRING_LENGTH ];
try { // connect to the default namespace
ConnectWmi( m_pWbemLocator, &pDefaultNameSpace, m_strServerName, m_strUserName, m_pwszPassword, &m_pAuthIdentity, FALSE, _bstr_t( ROOT_DEFAULT ), &hResult ); CHECK_HRESULT( hResult );
// Set the sub key name
StringCopy( szTemp, PATH, MAX_STRING_LENGTH ); StringConcat( szTemp, pUserInfo->strUserSid, MAX_STRING_LENGTH );
// Get the local profile
RegQueryValueWMI( pDefaultNameSpace, HKEY_DEF, szTemp, FPR_LOCAL_VALUE, pUserInfo->strLocalProfile, V_NOT_AVAILABLE );
// Get the roaming profile
RegQueryValueWMI( pDefaultNameSpace, HKEY_DEF, szTemp, FPR_ROAMING_VALUE, pUserInfo->strRoamingProfile, V_NOT_AVAILABLE ); } catch( _com_error & error ) { WMISaveError( error.Error() ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() );
// release the allocated variables
SAFEIRELEASE( pDefaultNameSpace );
return FALSE; }
// release the interface pointer
SAFEIRELEASE( pDefaultNameSpace );
return TRUE;}
/*********************************************************************************************
Routine Description:
This function gets the domain information and fills the array with the same
Arguments:
[in] PUSERINFO pUserInfo : Structure containing the user information.
Return Value:
TRUE on SUCCESS FALSE on FAILURE*********************************************************************************************/BOOL CGpResult::GetDomainInfo( PUSERINFO pUserInfo ){ // Local variables
HRESULT hResult = S_OK;
BOOL bResult = FALSE; BOOL bDone = FALSE;
IEnumWbemClassObject *pEnumClass = NULL; IWbemClassObject *pClass = NULL;
ULONG ulReturn = 0;
CHString strTemp; PSID psid = NULL; SID_NAME_USE sidNameUse; WCHAR szTemp[MAX_RES_STRING]=NULL_STRING; DWORD dwSize=MAX_RES_STRING; DWORD dwSidSize=0;
try { // print the progress message
PrintProgressMsg( m_hOutput, GetResString( IDS_GET_DOMAIN ), m_csbi );
// Enumerate the instances to get the domain and site names of the Win32 NT domain
hResult = m_pWbemServices->CreateInstanceEnum( _bstr_t( CLS_WIN32_SITE ), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumClass ); CHECK_HRESULT( hResult );
// Set the interface security
hResult = SetInterfaceSecurity( pEnumClass, m_pAuthIdentity ); CHECK_HRESULT( hResult );
// get the data
// since there may be more than one instance and we are looking for the instance
// with the domain controller and site name.....using a while loop and as soon as
// we get the instance we need break out of it
hResult = WBEM_S_NO_ERROR; while( hResult == WBEM_S_NO_ERROR ) { hResult = pEnumClass->Next( WBEM_INFINITE, 1, &pClass, &ulReturn ); CHECK_HRESULT( hResult );
if( ulReturn == 0 ) { // no more data so break out of the loop
break; }
// get the server name
if( bDone == FALSE ) { bDone = TRUE; bResult = PropertyGet( pClass, CPV_GPO_SERVER, pUserInfo->strUserServer, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult ); }
// get the domain name
bResult = PropertyGet( pClass, CPV_GPO_NAME, pUserInfo->strComputerDomain, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult );
PrintProgressMsg( m_hOutput, GetResString( IDS_GET_SITE ), m_csbi );
// get the site name
bResult = PropertyGet( pClass, CPV_SITE_NAME, pUserInfo->strUserSite, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult );
// get the domain controller name
bResult = PropertyGet( pClass, CPV_DC_NAME, strTemp, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult );
if( StringCompare( strTemp, V_NOT_AVAILABLE, FALSE, 0 ) != 0 ) { // this enumeration has the domain controller name...
// we have got the enumeration we need so get the other data
break; } }// while
/************this code is added to get the user domain on 19-oct-2001 **************/ psid = NULL; dwSidSize = 0; // get the actual size of SID
if ( FALSE == LookupAccountName( m_strServerName, pUserInfo->strUserName, psid, &dwSidSize, szTemp, &dwSize, &sidNameUse ) ) { if ( GetLastError() != ERROR_INSUFFICIENT_BUFFER ) { SaveLastError(); ShowLastErrorEx( stderr, SLE_TYPE_ERROR | SLE_INTERNAL ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pEnumClass ); return FALSE; } }
//Allocate memory for SID with the actual size of dwSidSize
psid = (PSID) AllocateMemory( dwSidSize ); if( NULL == psid ) { SaveLastError(); ShowLastErrorEx( stderr, SLE_TYPE_ERROR | SLE_INTERNAL ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pEnumClass ); return FALSE; }
// Get the account name
if( FALSE == LookupAccountName( m_strServerName, pUserInfo->strUserName, psid, &dwSidSize, szTemp, &dwSize, &sidNameUse ) ) { DISPLAY_MESSAGE( stderr, GetResString(IDS_ERROR) ); DISPLAY_MESSAGE( stderr, GetReason() ); FreeMemory((LPVOID*) &psid); SAFEIRELEASE( pClass ); SAFEIRELEASE( pEnumClass ); return FALSE; }
pUserInfo->strUserDomain = szTemp;
//release memory
FreeMemory((LPVOID*) &psid);
/**********************************************************************************/
} //try
catch( _com_error & error ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
WMISaveError( error.Error() ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() );
//release memory
FreeMemory((LPVOID*) &psid);
// release the allocated variables
SAFEIRELEASE( pEnumClass ); SAFEIRELEASE( pClass );
return FALSE; }
// release the interface pointers
SAFEIRELEASE( pEnumClass ); SAFEIRELEASE( pClass );
return TRUE;}
/*********************************************************************************************
Routine Description:
This function returns the domain type
Arguments:
[in] lpDomainName : domain name intends to view Rsop data. [out] pbW2K : contain whether the domain type in W2K. [out] pbLocalAccount : contain whether the account is local.
Return Value:
TRUE - if DC found/domain name is computer name FALSE - if DC not found*********************************************************************************************/BOOL GetDomainType( LPTSTR lpszDomainName, BOOL * pbW2K, BOOL *pbLocalAccount ){ PDOMAIN_CONTROLLER_INFO pDCI;
DWORD dwResult = 0; DWORD dwSize = 0;
TCHAR szComputerName[ MAX_PATH ];
// Check the incoming pointers
if( lpszDomainName == NULL || pbW2K == NULL || pbLocalAccount == NULL ) { return FALSE; }
// Check this domain for a Domain Controller
dwResult = DsGetDcName( NULL, lpszDomainName, NULL, NULL, DS_DIRECTORY_SERVICE_PREFERRED, &pDCI ); if ( dwResult == NO_ERROR ) { // Found a DC, does it have a DS ?
if ( pDCI->Flags & DS_DS_FLAG ) { *pbW2K = TRUE; }
NetApiBufferFree( pDCI );
return TRUE; }
// Check if the domain name is also the computer name (eg: local account)
dwSize = ARRAYSIZE( szComputerName ); if ( GetComputerName ( szComputerName, &dwSize ) != 0 ) { if ( StringCompare( szComputerName, lpszDomainName, TRUE, 0 ) == 0 ) { *pbLocalAccount = TRUE; return TRUE; } }
return FALSE;}
/*********************************************************************************************
Routine Description:
This function displays the data common to both scopes
Arguments:
[in] PUSERINFO pUserInfo : Structure containing the user information.
Return Value:
TRUE on SUCCESS FALSE on FAILURE*********************************************************************************************/BOOL CGpResult::DisplayCommonData( PUSERINFO pUserInfo ){ // Local variables
TCHAR szMsgBuffer[ MAX_RES_STRING ]; TCHAR szDate[ MAX_RES_STRING ]; TCHAR szTime[ MAX_RES_STRING ];
BOOL bLocaleChanged = FALSE;
DWORD dwLength = 0;
SYSTEMTIME systime;
LCID lcid;
// erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
// Clear the Msg buffer
SecureZeroMemory( szMsgBuffer, MAX_RES_STRING );
// Start displaying the output
ShowMessage( stdout, NEW_LINE );
// Print the leagal information
ShowMessage( stdout, GetResString( IDS_LEGAL_INFO1 ) ); ShowMessage( stdout, GetResString( IDS_LEGAL_INFO2 ) );
// Print the date and time this report is generated
GetLocalTime( &systime );
// verify whether console supports the current locale 100% or not
lcid = GetSupportedUserLocale( &bLocaleChanged );
// get the formatted date
GetDateFormat( lcid, 0, &systime, ((bLocaleChanged == TRUE) ? L"MM/dd/yyyy" : NULL), szDate, SIZE_OF_ARRAY( szDate ) );
// now format the date
GetTimeFormat( LOCALE_USER_DEFAULT, 0, &systime, ((bLocaleChanged == TRUE) ? L"HH:mm:ss" : NULL), szTime, SIZE_OF_ARRAY( szTime ) );
ShowMessageEx( stdout, 2, TRUE, GetResString( IDS_CREATED_ON ), _X(szDate), _X1(szTime) );
ShowMessage( stdout, NEW_LINE );
// Display the common information....Domain Info
ShowMessageEx( stdout, 2, TRUE, GetResString( IDS_GPO_TITLE ), _X( pUserInfo->strUserName ), _X2( pUserInfo->strUserServer ) ); ShowMessage( stdout, NEW_LINE );
StringCchPrintf( szMsgBuffer, SIZE_OF_ARRAY( szMsgBuffer ), GetResString( IDS_GPO_TITLE ), _X( pUserInfo->strUserName ), _X2( pUserInfo->strUserServer ) );
// Underline the above heading
dwLength = StringLengthInBytes( szMsgBuffer ); for( ; dwLength > 0; dwLength-- ) { ShowMessage( stdout, GetResString( IDS_DASH ) ); } ShowMessage( stdout, NEW_LINE );
StringCopy( szMsgBuffer, pUserInfo->strComputerDomain, MAX_RES_STRING ); if( StringLengthW( szMsgBuffer, 0 ) != 0 ) { StringCopy( szMsgBuffer, _tcstok( szMsgBuffer, GetResString( IDS_LAST_CHAR ) ), MAX_RES_STRING ); StringCopy( szMsgBuffer, _tcstok( NULL, GetResString( IDS_LAST_CHAR ) ), MAX_RES_STRING ); }
// Show the OS information
ShowMessage( stdout, GetResString( IDS_OS_TYPE ) ); ShowMessage( stdout, pUserInfo->strOsType );
ShowMessage( stdout, GetResString( IDS_OS_CONFIG ) ); ShowMessage( stdout, pUserInfo->strOsConfig );
ShowMessage( stdout, GetResString( IDS_OS_VERSION ) ); ShowMessage( stdout, pUserInfo->strOsVersion );
// This code is added on 4-sep-2001 to display Terminal server mode
ShowMessage( stdout, NEW_LINE ); ShowMessage( stdout, GetResString( IDS_TERMINAL_SERVER_MODE ) ); ShowMessage( stdout, pUserInfo->strTerminalServerMode );
// Display the Site name
ShowMessage( stdout, NEW_LINE ); ShowMessage( stdout, GetResString( IDS_SITE_NAME ) ); ShowMessage( stdout, pUserInfo->strUserSite );
// Display the roaming profile
ShowMessage( stdout, NEW_LINE ); ShowMessage( stdout, GetResString( IDS_ROAMING_PROFILE ) ); ShowMessage( stdout, pUserInfo->strRoamingProfile );
// Display the local profile
ShowMessage( stdout, NEW_LINE ); ShowMessage( stdout, GetResString( IDS_LOCAL_PROFILE ) ); DISPLAY_MESSAGE( stdout, _X((LPCWSTR)pUserInfo->strLocalProfile) ); ShowMessage( stdout, NEW_LINE );
return TRUE;}
/*********************************************************************************************
Routine Description: This function displays the GPO information from the rsop namespace created.
Arguments:
[in] IEnumWbemClassObject : pointer to the Enumeration class object [in] LPCTSTR : string containing the scope( USER or COMPUTER )
Return Value:
TRUE - if SUCCESS FALSE - if ERROR*********************************************************************************************/BOOL CGpResult::GpoDisplay( IWbemServices *pNameSpace, LPCTSTR pszScopeName ){ HRESULT hResult = WBEM_S_NO_ERROR;
BOOL bResult = FALSE; BOOL bFilterAllowed = FALSE; BOOL bLinkEnabled = FALSE; BOOL bGpoEnabled = FALSE; BOOL bAccessDenied = FALSE; BOOL bConnected = FALSE;
ULONG ulReturn = 0; ULONG ulAppliedOrder = 0; ULONG ulVersion = 0;
DWORD dwAppliedRow = 0; DWORD dwFilteredRow = 0;
CHString strTemp;
IEnumWbemClassObject *pRsopLinkClass = NULL; IWbemClassObject *pRsopLinkObj = NULL; IWbemClassObject *pRsopObj = NULL; IWbemClassObject *pSomFilter = NULL;
IWbemServices *pPolicyNameSpace = NULL;
TARRAY arrAppliedData = NULL; TARRAY arrFilteredData = NULL; BOOL bNobreak = TRUE;
try { if( pNameSpace == NULL || pszScopeName == NULL ) { _com_issue_error( STG_E_UNKNOWN ); }
// Create the Dynamic Arrays
arrAppliedData = CreateDynamicArray( ); arrFilteredData = CreateDynamicArray( );
// Check the memory allocations
if( arrAppliedData == NULL || arrFilteredData == NULL ) { _com_issue_error( E_OUTOFMEMORY ); }
// enumerate the instances of the RSOP GPLink class
hResult = pNameSpace->CreateInstanceEnum( _bstr_t( CLS_RSOP_GPOLINK ), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pRsopLinkClass ); CHECK_HRESULT( hResult );
// set the interface security
hResult = SetInterfaceSecurity( pRsopLinkClass, m_pAuthIdentity ); CHECK_HRESULT( hResult );
// Get the information from the enumerated classes
do { // Get the pointer to the next class
hResult = pRsopLinkClass->Next( WBEM_INFINITE, 1, &pRsopLinkObj, &ulReturn ); CHECK_HRESULT( hResult ); if( ulReturn == 0 ) { bNobreak = FALSE; break; }
// Get the applied order for the link
bResult = PropertyGet( pRsopLinkObj, CPV_APPLIED_ORDER, ulAppliedOrder, 0 ); CHECK_BRESULT( bResult );
// Get the link enabled property
bResult = PropertyGet( pRsopLinkObj, CPV_ENABLED, bLinkEnabled, FALSE ); CHECK_BRESULT( bResult );
// Get the reference to the GPO class
bResult = PropertyGet( pRsopLinkObj, CPV_GPO_REF, strTemp, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult );
// Check wether the link has a GPO class
if( strTemp.Find( GPO_REFERENCE ) != VAR_TRUE ) { // Get the object for the GPO reference got
hResult = pNameSpace->GetObject( _bstr_t( strTemp ), 0, NULL, &pRsopObj, NULL ); if( FAILED( hResult ) ) { if( hResult == WBEM_E_NOT_FOUND ) { continue; } _com_issue_error( hResult ); }
// Get the GPO name
bResult = PropertyGet( pRsopObj, CPV_GPO_NAME, strTemp, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult );
// Get the WMI filter status
bResult = PropertyGet( pRsopObj, CPV_GPO_FILTER_STATUS, bFilterAllowed, FALSE ); CHECK_BRESULT( bResult );
// Get the Gpo enabled information
bResult = PropertyGet( pRsopObj, CPV_ENABLED, bGpoEnabled, FALSE ); CHECK_BRESULT( bResult );
// Get the access denied information
bResult = PropertyGet( pRsopObj, CPV_ACCESS_DENIED, bAccessDenied, FALSE ); CHECK_BRESULT( bResult );
// Get the version
bResult = PropertyGet( pRsopObj, CPV_VERSION, ulVersion, 0 ); CHECK_BRESULT( bResult );
// If the applied order id not zero then this GPO is applied
if( ulAppliedOrder > 0 ) { // Populate the applied Gpo array
DynArrayAppendRow( arrAppliedData, COL_MAX ); DynArraySetString2( arrAppliedData, dwAppliedRow, COL_DATA, strTemp, 0 ); DynArraySetDWORD2( arrAppliedData, dwAppliedRow, COL_ORDER, ulAppliedOrder ); dwAppliedRow++; } else if( bLinkEnabled != VAR_TRUE ) { // if the link is disabled...populate the Filtered Array
DynArrayAppendRow( arrFilteredData, COL_MAX ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_DATA, strTemp, 0 ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_FILTER, GetResString( IDS_LINK_DISABLED ), 0 ); dwFilteredRow++; } else if( bGpoEnabled != VAR_TRUE ) { // if the GPO is disabled...populate the Filtered Array
DynArrayAppendRow( arrFilteredData, COL_MAX ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_DATA, strTemp, 0 ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_FILTER, GetResString( IDS_GPO_DISABLED ), 0 ); dwFilteredRow++; } else if( bAccessDenied == VAR_TRUE ) { // if the access is denied...populate the Filtered Array
DynArrayAppendRow( arrFilteredData, COL_MAX ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_DATA, strTemp, 0 ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_FILTER, GetResString( IDS_ACCESS_DENIED ), 0 ); dwFilteredRow++; } else if( bFilterAllowed != VAR_TRUE ) { // if the filter status is false...populate the Filtered Array
DynArrayAppendRow( arrFilteredData, COL_MAX_FILTER ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_DATA, strTemp, 0 ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_FILTER, GetResString( IDS_WMI_DENIED ), 0 );
// Get the filter ID
bResult = PropertyGet( pRsopObj, CPV_GPO_FILTER_ID, strTemp, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult );
// Store it in the array
DynArraySetString2( arrFilteredData, dwFilteredRow, COL_FILTER_ID, strTemp, 0 );
dwFilteredRow++; } else if( ulVersion == 0 ) { // if the version is zero...populate the Filtered Array
DynArrayAppendRow( arrFilteredData, COL_MAX ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_DATA, strTemp, 0 ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_FILTER, GetResString( IDS_VERSION_ZERO ), 0 ); dwFilteredRow++; } else { // the Gpo is not applied due to an unknown reason...
// populate the Filtered Array
DynArrayAppendRow( arrFilteredData, COL_MAX ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_DATA, strTemp, 0 ); DynArraySetString2( arrFilteredData, dwFilteredRow, COL_FILTER, GetResString( IDS_NOT_APPLIED ), 0 ); dwFilteredRow++; } }
}while( TRUE == bNobreak );// while
// Got the data...sort it
SortAppliedData( arrAppliedData );
// Display the applied data first
dwAppliedRow = DynArrayGetCount( arrAppliedData ); for( DWORD dwi = 0; dwi < dwAppliedRow; dwi++ ) { ShowMessage( stdout, TAB_TWO ); ShowMessage( stdout, DynArrayItemAsString2( arrAppliedData, dwi, COL_DATA ) ); ShowMessage( stdout, GetResString( IDS_NEWLINE ) ); }
// Check if there was any data displayed
if( dwAppliedRow <= 0 ) { ShowMessage( stdout, TAB_TWO ); ShowMessage( stdout, V_NOT_AVAILABLE ); ShowMessage( stdout, NEW_LINE ); }
// Display the filtered GPOs
// Display the header...if there are any GPO's filtered out
dwFilteredRow = DynArrayGetCount( arrFilteredData ); if( dwFilteredRow > 0 ) { ShowMessage( stdout, GetResString( IDS_GPO_FILTERED ) ); ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) ); for( dwi = StringLengthInBytes( GetResString( IDS_GPO_FILTERED ) ); dwi > 4; dwi-- ) { ShowMessage( stdout, GetResString( IDS_DASH ) ); } ShowMessage( stdout, GetResString( IDS_NEWLINE ) ); } else { // There are no filtered GPO's hence put a new line and continue
// displaying the rest of the output
ShowMessage( stdout, GetResString( IDS_NEWLINE ) ); }
// display the data
for( DWORD dwi = 0; dwi < dwFilteredRow; dwi++ ) { ShowMessage( stdout, TAB_TWO ); ShowMessage( stdout, DynArrayItemAsString2( arrFilteredData, dwi, COL_DATA ) ); ShowMessage( stdout, GetResString( IDS_FILTERING ) ); ShowMessage( stdout, DynArrayItemAsString2( arrFilteredData, dwi, COL_FILTER ) );
// Check if we have to display the filter id for the WMI filter that evaluated to false
if( StringCompare( DynArrayItemAsString2( arrFilteredData, dwi, COL_FILTER ), GetResString( IDS_WMI_DENIED ), TRUE, 0 ) == 0 ) { if( bConnected == FALSE ) { // we need to connect to Root\Policy
// connect to the default namespace
ConnectWmi( m_pWbemLocator, &pPolicyNameSpace, m_strServerName, m_strUserName, m_pwszPassword, &m_pAuthIdentity, FALSE, _bstr_t( ROOT_POLICY ), &hResult ); CHECK_HRESULT( hResult );
bConnected = TRUE; }
// Get the object
hResult = pPolicyNameSpace->GetObject( _bstr_t( DynArrayItemAsString2( arrFilteredData, dwi, COL_FILTER_ID ) ), 0, NULL, &pSomFilter, NULL );
// check whether we got the object or not -- if at all error occured
// ignore this and proceed
if ( FAILED( hResult ) ) { if ( WBEM_E_NOT_FOUND == hResult ) { // ignore this error -- proceed with the normal logic flow
}
// still ignore this error -- currently we are not trapping this error too
} else { // Get the name of the filter applied
bResult = PropertyGet( pSomFilter, CPV_NAME, strTemp, V_NOT_AVAILABLE );
// display the filter ID
ShowMessage( stdout, GetResString( IDS_GPO_FILTER_ID ) ); ShowMessage( stdout, strTemp ); ShowMessage( stdout, GetResString( IDS_NEWLINE ) ); } }
ShowMessage( stdout, GetResString( IDS_NEWLINE ) ); }
// destroy the dynamic arrays
DESTROY_ARRAY( arrAppliedData ); DESTROY_ARRAY( arrFilteredData ); } catch( _com_error & error ) { // display the error message
WMISaveError( error.Error() ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() );
SAFEIRELEASE( pRsopLinkObj ); SAFEIRELEASE( pRsopLinkClass ); SAFEIRELEASE( pRsopObj ); SAFEIRELEASE( pSomFilter ); SAFEIRELEASE( pPolicyNameSpace );
// destroy the dynamic arrays
DESTROY_ARRAY( arrAppliedData ); DESTROY_ARRAY( arrFilteredData );
return FALSE; }
SAFEIRELEASE( pRsopLinkObj ); SAFEIRELEASE( pRsopLinkClass ); SAFEIRELEASE( pRsopObj ); SAFEIRELEASE( pSomFilter ); SAFEIRELEASE( pPolicyNameSpace );
return TRUE;}
/*********************************************************************************************
Routine Description: This function Will delete the Rsop namespace created by method RsopCreateSession.
Arguments: [in] pClass : pointer to IWbemServices. [in] CHString : string containing the RsopNamespace. [in] pObject : pointer to IWbemClassObject.
Return Value: TRUE - if SUCCESS FALSE - if ERROR*********************************************************************************************/BOOL RsopDeleteMethod( IWbemClassObject *pClass, CHString strNameSpace, IWbemServices *pNamespace ){ HRESULT hResult = S_OK;
BOOL bResult = FALSE;
IWbemClassObject *pInClass = NULL; IWbemClassObject *pInInst = NULL; IWbemClassObject *pOutInst = NULL;
CHString strTemp; DWORD ulReturn=0;
try { // Check the input Parameters
if( pClass == NULL ) { _com_issue_error( STG_E_UNKNOWN ); }
//Delete the resultant RSOP namespace as the snap shot
//of RSOP has been obtained
hResult = pClass->GetMethod( _bstr_t( FN_DELETE_RSOP ), 0, &pInClass, NULL ); CHECK_HRESULT( hResult );
hResult = pInClass->SpawnInstance( 0, &pInInst ); CHECK_HRESULT( hResult );
//Put the input parameter
hResult = PropertyPut( pInInst, FPR_RSOP_NAMESPACE, strNameSpace ); CHECK_HRESULT( hResult );
// All The required properties are set so, execute method RsopDeleteSession
hResult = pNamespace->ExecMethod( _bstr_t( CLS_DIAGNOSTIC_PROVIDER ), _bstr_t( FN_DELETE_RSOP ), 0, NULL, pInInst, &pOutInst, NULL ); if(pOutInst == NULL) { hResult = E_FAIL; } if( FAILED( hResult ) ) { // display the error msg
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetResString( IDS_METHOD_FAILED ) );
// release the interface pointers and exit
SAFEIRELEASE(pInClass); SAFEIRELEASE(pInInst); SAFEIRELEASE(pOutInst);
return FALSE; } //Get returned paramter to check whether the method was successfull
bResult = PropertyGet( pOutInst, FPR_RETURN_VALUE, ulReturn, 0); CHECK_BRESULT( bResult );
// Returns some ERROR code.
if( ulReturn != 0 ) { // Show Error Message
ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetResString( IDS_METHOD_FAILED ) ); bResult = FALSE; } bResult = TRUE; } catch( _com_error & error ) { // display the error message and set the return value to FALSE
WMISaveError( error.Error() ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() ); bResult = FALSE; }
// release the interface pointers and exit
SAFEIRELEASE(pInClass); SAFEIRELEASE(pInInst); SAFEIRELEASE(pOutInst);
return bResult;}
/*********************************************************************************************
Routine Description:
This function gets the OS information and fills the array with the same
Arguments:
[in] PUSERINFO pUserInfo : Structure containing the user information.
Return Value:
TRUE on SUCCESS FALSE on FAILURE*********************************************************************************************/BOOL CGpResult::GetOsInfo( PUSERINFO pUserInfo ){ // Local variables
HRESULT hResult = S_OK;
BOOL bResult = FALSE;
IEnumWbemClassObject *pEnumClass = NULL; IWbemClassObject *pClass = NULL;
ULONG ulReturn = 0; DWORD dwDomainRole = 0;
CHString strTemp;
try { // print the progress message
PrintProgressMsg( m_hOutput, GetResString( IDS_GET_OSINFO ), m_csbi );
// Enumerate the instances to get the domain and site names of the Win32 NT domain
hResult = m_pWbemServices->CreateInstanceEnum( _bstr_t( CLS_WIN32_OS ), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumClass ); CHECK_HRESULT( hResult );
// Set the interface security
hResult = SetInterfaceSecurity( pEnumClass, m_pAuthIdentity ); CHECK_HRESULT( hResult );
// get the data
hResult = pEnumClass->Next( WBEM_INFINITE, 1, &pClass, &ulReturn ); CHECK_HRESULT( hResult );
// get the OS version
bResult = PropertyGet( pClass, CPV_OS_VERSION, pUserInfo->strOsVersion, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult );
// get the OS type
bResult = PropertyGet( pClass, CPV_OS_CAPTION, pUserInfo->strOsType, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult );
// enumerate the instances of Win32_ComputerSystem class
SAFE_RELEASE( pEnumClass ); hResult = m_pWbemServices->CreateInstanceEnum( _bstr_t( CLS_WIN32_CS ), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pEnumClass );
// check the result of enumeration
CHECK_HRESULT( hResult );
// set the security on the obtained interface
hResult = SetInterfaceSecurity( pEnumClass, m_pAuthIdentity ); CHECK_HRESULT( hResult );
// get the enumerated objects information
// NOTE: This needs to be traversed only one time.
hResult = pEnumClass->Next( WBEM_INFINITE, 1, &pClass, &ulReturn ); CHECK_HRESULT( hResult );
// get the OS config
bResult = PropertyGet( pClass, CPV_DOMAIN_ROLE, dwDomainRole, 0 ); CHECK_BRESULT( bResult );
// get the domain name information for later use
bResult = PropertyGet( pClass, CPV_DOMAIN, m_strADSIDomain ); CHECK_BRESULT( bResult );
// get the server name for future use by LDAP
bResult = PropertyGet( pClass, CPV_NAME, m_strADSIServer ); CHECK_BRESULT( bResult );
//
// Mapping information of Win32_ComputerSystem's DomainRole property
// NOTE: Refer to the _DSROLE_MACHINE_ROLE enumeration values in DsRole.h header file
switch( dwDomainRole ) { case DsRole_RoleStandaloneWorkstation: pUserInfo->strOsConfig = VALUE_STANDALONEWORKSTATION; break; case DsRole_RoleMemberWorkstation: pUserInfo->strOsConfig = VALUE_MEMBERWORKSTATION; break;
case DsRole_RoleStandaloneServer: pUserInfo->strOsConfig = VALUE_STANDALONESERVER; break;
case DsRole_RoleMemberServer: pUserInfo->strOsConfig = VALUE_MEMBERSERVER; break;
case DsRole_RoleBackupDomainController: pUserInfo->strOsConfig = VALUE_BACKUPDOMAINCONTROLLER; break;
case DsRole_RolePrimaryDomainController: pUserInfo->strOsConfig = VALUE_PRIMARYDOMAINCONTROLLER; break;
default: break; } } catch( _com_error & error ) { WMISaveError( error.Error() ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() ); // release the allocated variables
SAFEIRELEASE( pEnumClass ); SAFEIRELEASE( pClass ); return FALSE; } catch( CHeap_Exception ) { // display the error message
SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); SAFEIRELEASE( pEnumClass ); SAFEIRELEASE( pClass ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() ); }
// release the interface pointers
SAFEIRELEASE( pEnumClass ); SAFEIRELEASE( pClass );
return TRUE;}
/*********************************************************************************************
Routine Description:
This function displays the security groups for system and user
Arguments:
IWbemServices : pointer to the name space BOOL : set to TRUE if the system o/p is to be displayed
Return Value:
None*********************************************************************************************/VOID CGpResult::DisplaySecurityGroups( IWbemServices *pNameSpace, BOOL bComputer ){ HRESULT hResult = S_OK;
BOOL bResult = FALSE; BOOL bGotClass = FALSE;
ULONG ulReturned = 0; LONG lLBound = 0; LONG lUBound = 0;
DWORD dwLength = 0;
IWbemClassObject *pClass = NULL; IWbemClassObject *pName = NULL; IWbemClassObject *pDomain = NULL; IEnumWbemClassObject *pEnumClass = NULL; IEnumWbemClassObject *pEnumDomain = NULL;
VARIANT vVarVerbose; VARTYPE vartype;
TCHAR szTemp[ MAX_STRING_LENGTH ]; TCHAR szQueryString[ MAX_STRING_LENGTH ]; CHString strTemp; CHString strDomain;
SAFEARRAY *safeArray = NULL;
try { SecureZeroMemory( szTemp, sizeof( szTemp ) ); SecureZeroMemory( szQueryString, sizeof( szQueryString ) );
// Enumerate the classes for the user privelege rights
hResult = pNameSpace->CreateInstanceEnum( _bstr_t( CLS_RSOP_SESSION ), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumClass ); CHECK_HRESULT( hResult );
// Set the interface security
hResult = SetInterfaceSecurity( pEnumClass, m_pAuthIdentity ); CHECK_HRESULT( hResult );
hResult = WBEM_S_NO_ERROR; while( WBEM_S_NO_ERROR == hResult ) { // Get the next class
hResult = pEnumClass->Next( WBEM_INFINITE , 1, &pClass, &ulReturned ); CHECK_HRESULT( hResult );
if( ulReturned == 0 ) { // No more classes to enumerate
// Display N/A if there were no classes
if( bGotClass == FALSE ) { ShowMessage( stdout, GetResString( IDS_NEWLINETAB ) ); ShowMessage( stdout, V_NOT_AVAILABLE ); ShowMessage( stdout, NEW_LINE ); }
break; } bGotClass = TRUE;
// Get the security groups
if( bComputer == TRUE ) { ShowMessage( stdout, GetResString( IDS_SYS_SG ) ); ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) ); for( dwLength = StringLengthInBytes( GetResString( IDS_SYS_SG ) ); dwLength > 4; dwLength-- ) { ShowMessage( stdout, GetResString( IDS_DASH ) ); } ShowMessage( stdout, GetResString( IDS_NEWLINETAB ) ); } else { ShowMessage( stdout, GetResString( IDS_USER_SG ) ); ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) ); for( dwLength = StringLengthInBytes( GetResString( IDS_USER_SG ) ); dwLength > 4; dwLength-- ) { ShowMessage( stdout, GetResString( IDS_DASH ) ); } ShowMessage( stdout, GetResString( IDS_NEWLINETAB ) ); }
VariantInit( &vVarVerbose );
hResult = pClass->Get( _bstr_t(CPV_SEC_GRPS), 0, &vVarVerbose, 0, 0 ); CHECK_HRESULT_VAR( hResult, vVarVerbose );
if( vVarVerbose.vt != VT_NULL && vVarVerbose.vt != VT_EMPTY ) { // get the type of the elements in the safe array
vartype = (VARTYPE)(V_VT( &vVarVerbose ) & ~VT_ARRAY);
//get the array of strings in to the safe array from the variant
safeArray = (SAFEARRAY *)vVarVerbose.parray;
//get the number of elements (subkeys)
if( safeArray != NULL ) { hResult = SafeArrayGetLBound( safeArray, 1, &lLBound ); CHECK_HRESULT( hResult );
hResult = SafeArrayGetUBound( safeArray, 1, &lUBound ); CHECK_HRESULT( hResult ); }
if( FALSE == bComputer ) { //alllocate memory to store user groups
m_szUserGroups = (LPWSTR*) AllocateMemory( (lUBound+1)*sizeof(LPWSTR)); if( NULL == m_szUserGroups ) { VariantClear(&vVarVerbose); ShowLastErrorEx(stderr, SLE_TYPE_ERROR | SLE_INTERNAL ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pName ); SAFEIRELEASE( pDomain ); SAFEIRELEASE( pEnumClass ); SAFEIRELEASE( pEnumDomain ); return; } m_NoOfGroups = lUBound; } for( ; lLBound <= lUBound; lLBound++ ) { bResult = GetPropertyFromSafeArray( safeArray, lLBound, strTemp, vartype ); CHECK_BRESULT( bResult );
//place the user security groups
if( FALSE == bComputer ) { m_szUserGroups[lLBound] = (LPWSTR) AllocateMemory( (strTemp.GetLength()+10)*sizeof(WCHAR) ); if( NULL == m_szUserGroups[lLBound] ) { VariantClear(&vVarVerbose); ShowLastErrorEx( stderr, SLE_TYPE_ERROR | SLE_INTERNAL ); SAFEIRELEASE( pClass ); SAFEIRELEASE( pName ); SAFEIRELEASE( pDomain ); SAFEIRELEASE( pEnumClass ); SAFEIRELEASE( pEnumDomain ); return; } StringCopy( m_szUserGroups[lLBound], (LPCWSTR)strTemp, GetBufferSize(m_szUserGroups[lLBound])/sizeof(WCHAR) ); }
// Got a sid, now get it's coressponding name
// form the object path using the SID
//
//
// if( strTemp.Right(4) == L"-513" )
// continue;
//
//
StringCchPrintf( szTemp, MAX_STRING_LENGTH, OBJECT_PATH, (LPCWSTR)strTemp );
// Get the object
hResult = m_pWbemServices->GetObject( _bstr_t( szTemp ), 0, NULL, &pName, NULL ); CHECK_HRESULT( hResult );
// Get the Account name
bResult = PropertyGet( pName, CPV_ACCOUNT_NAME, strTemp, V_NOT_AVAILABLE );
// Append the appropriate prefix
if( strTemp.Compare( _T( "ANONYMOUS LOGON" ) ) == 0 || strTemp.Compare( _T( "BATCH" ) ) == 0 || strTemp.Compare( _T( "DIALUP" ) ) == 0 || strTemp.Compare( _T( "INTERACTIVE" ) ) == 0 || strTemp.Compare( _T( "SERVICE" ) ) == 0 || strTemp.Compare( _T( "SYSTEM" ) ) == 0 || strTemp.Compare( _T( "TERMINAL SERVICE USER" ) ) == 0 || strTemp.Compare( _T( "PROXY" ) ) == 0 || strTemp.Compare( _T( "NETWORK" ) ) == 0 || strTemp.Compare( _T( "ENTERPRISE DOMAIN CONTROLLERS" ) ) == 0 || strTemp.Compare( _T( "Authenticated Users" ) ) == 0 || strTemp.Compare( _T( "RESTRICTED" ) ) == 0 || strTemp.Compare( _T( "SELF" ) ) == 0 ) { ShowMessage( stdout, _T( "NT AUTHORITY\\" ) ); } else if( strTemp.Compare( _T( "Administrators" ) ) == 0 || strTemp.Compare( _T( "Backup Operators" ) ) == 0 || strTemp.Compare( _T( "Guests" ) ) == 0 || strTemp.Compare( _T( "Power Users" ) ) == 0 || strTemp.Compare( _T( "Replicator" ) ) == 0 || strTemp.Compare( _T( "Pre-Windows 2000 Compatible Access" ) ) == 0 || strTemp.Compare( _T( "Users" ) ) == 0 ) { ShowMessage( stdout, _T( "BUILTIN\\" ) ); } if( strTemp.Compare( _T("") ) != 0) { ShowMessage( stdout, strTemp ); ShowMessage( stdout, GetResString( IDS_NEWLINETAB ) ); } } } else { ShowMessage( stdout, V_NOT_AVAILABLE ); ShowMessage( stdout, NEW_LINE ); }
VariantClear(&vVarVerbose); } }
catch( _com_error & error ) { WMISaveError( error.Error() ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() ); SAFEIRELEASE(pEnumClass); SAFEIRELEASE(pEnumDomain); SAFEIRELEASE(pClass); SAFEIRELEASE(pName); SAFEIRELEASE(pDomain); VariantClear(&vVarVerbose); }
// release the interface pointers
SAFEIRELEASE(pEnumClass); SAFEIRELEASE(pEnumDomain); SAFEIRELEASE(pClass); SAFEIRELEASE(pName); SAFEIRELEASE(pDomain);
return;}
/*********************************************************************************************
Routine Description:
This function gets the link speed information
Arguments:
IWbemServices : pointer to the name space. COAUTHIDENTITY : pointer to the AuthIdentity structure.
Return Value:
None*********************************************************************************************/VOID DisplayLinkSpeed( IWbemServices *pNameSpace, COAUTHIDENTITY *pAuthIdentity ){ HRESULT hResult = S_OK;
BOOL bGotClass = FALSE; BOOL bTemp = FALSE;
ULONG ulReturned = 0;
IWbemClassObject *pClass = NULL; IEnumWbemClassObject *pEnumClass = NULL;
VARIANT vVarTemp;
try { // Get the pointer to ennumerate with
hResult = pNameSpace->CreateInstanceEnum( _bstr_t( CLS_RSOP_SESSION ), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumClass ); CHECK_HRESULT( hResult );
// Set the interface security
hResult = SetInterfaceSecurity( pEnumClass, pAuthIdentity ); CHECK_HRESULT( hResult );
// Enumerate the classes one by one and get the data
hResult = WBEM_S_NO_ERROR; while( WBEM_S_NO_ERROR == hResult ) { // Get the next class
hResult = pEnumClass->Next( WBEM_INFINITE , 1, &pClass, &ulReturned ); CHECK_HRESULT( hResult );
if( ulReturned == 0 ) { // No more classes to enumerate
// Display N/A if there were no classes
if( bGotClass == FALSE ) { ShowMessage( stdout, GetResString( IDS_NEWLINETAB ) ); ShowMessage( stdout, V_NOT_AVAILABLE ); ShowMessage( stdout, NEW_LINE ); }
break; } bGotClass = TRUE;
VariantInit( &vVarTemp ); hResult = pClass->Get( _bstr_t( CPV_SLOW_LINK ), 0, &vVarTemp, 0, 0 ); CHECK_HRESULT_VAR( hResult, vVarTemp );
ShowMessage( stdout, GetResString( IDS_LINK_SPEED ) ); if( vVarTemp.vt != VT_NULL ) { bTemp = vVarTemp.boolVal; if( bTemp == VAR_TRUE ) { ShowMessage( stdout, GetResString( IDS_YES ) ); } else { ShowMessage( stdout, GetResString( IDS_NO ) ); } } else { ShowMessage( stdout, V_NOT_AVAILABLE ); }
ShowMessage( stdout, NEW_LINE ); VariantClear( &vVarTemp ); }// while
} catch(_com_error & error) { WMISaveError( error.Error() ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() );
VariantClear( &vVarTemp ); }
// release the interface pointers
SAFEIRELEASE(pEnumClass); SAFEIRELEASE(pClass);
return;}
/*********************************************************************************************
Routine Description:
This function gets the User name and the domain name from WMI..
Arguments:
[in] szSid : string containing the SID [out] szName : string to hold the user name [out] szDomain : string to hold the domain name
Return Value:
TRUE on SUCCESS FALSE on FAILURE*********************************************************************************************/BOOL CGpResult::GetUserNameFromWMI( TCHAR szSid[], TCHAR szName[], TCHAR szDomain[] ){ // Local variables
HRESULT hResult = S_OK;
BOOL bResult = FALSE;
TCHAR szQueryString[ MAX_QUERY_STRING ]; TCHAR szTemp[ MAX_STRING_LENGTH ]; CHString strTemp = NULL_STRING;
IEnumWbemClassObject *pEnumClass = NULL; IWbemClassObject *pClass = NULL;
ULONG ulReturn = 0;
try { // set the strings to NULL
SecureZeroMemory( szQueryString, MAX_QUERY_STRING * sizeof( TCHAR )); SecureZeroMemory( szTemp, MAX_STRING_LENGTH * sizeof( TCHAR ) );
// Form the query string
StringCopy( szTemp, QUERY_USER_NAME, MAX_STRING_LENGTH ); StringCchPrintf( szQueryString, MAX_QUERY_STRING, szTemp, szSid );
// execute the respective query
hResult = m_pWbemServices->ExecQuery( _bstr_t( QUERY_LANGUAGE ), _bstr_t( szQueryString ), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumClass ); CHECK_HRESULT( hResult );
// set the security parameters
hResult = SetInterfaceSecurity( pEnumClass, m_pAuthIdentity ); CHECK_HRESULT( hResult );
// Get the user name
hResult = pEnumClass->Next( TIME_OUT_NEXT, 1, &pClass, &ulReturn ); CHECK_HRESULT( hResult );
// if there are no classes to enumerate break out of the loop
if( ulReturn == 0 ) { // No classes were retrieved....display msg
// release the interface pointers and exit
SAFEIRELEASE( pClass ); SAFEIRELEASE( pEnumClass );
return FALSE;
}
// Get the class property(Name)
bResult = PropertyGet( pClass, CPV_NAME, strTemp, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult );
// Got the name...Store it.
StringCopy( szName, (LPCWSTR)strTemp, MAX_STRING_LENGTH );
// Get and add the domain name if it exists
bResult = PropertyGet( pClass, CPV_DOMAIN, strTemp, V_NOT_AVAILABLE ); CHECK_BRESULT( bResult );
if( strTemp.Compare( V_NOT_AVAILABLE ) != 0 ) { // Got the domain name...Store it.
StringCopy( szDomain, (LPCWSTR)strTemp, MAX_STRING_LENGTH ); } } catch( _com_error & error ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
// display the error msg
WMISaveError( error.Error() ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() );
// release the interface pointers and exit
SAFEIRELEASE( pClass ); SAFEIRELEASE( pEnumClass );
return FALSE; }
// release the interface pointers and exit
SAFEIRELEASE( pClass ); SAFEIRELEASE( pEnumClass );
return TRUE;}/*********************************************************************************************
Routine Description:
This function gets the User name and the domain name from WMI..
Arguments:
[in] szSid : string containing the SID [out] szName : string to hold the user name [out] szDomain : string to hold the domain name
Return Value:
TRUE on SUCCESS FALSE on FAILURE*********************************************************************************************/BOOL CGpResult::GetTerminalServerMode( PUSERINFO pUserInfo ){ // Local variables
HRESULT hResult = S_OK;
BOOL bResult = FALSE;
TCHAR szQueryString[ MAX_QUERY_STRING ]; TCHAR szTemp[ MAX_STRING_LENGTH ]; DWORD dwTerminalServerMode;
IEnumWbemClassObject *pEnumClass = NULL; IWbemClassObject *pClass = NULL;
ULONG ulReturn = 0;
try { // set the strings to NULL
SecureZeroMemory( szQueryString, MAX_QUERY_STRING * sizeof( TCHAR )); SecureZeroMemory( szTemp, MAX_STRING_LENGTH * sizeof( TCHAR ) );
// Form the query string
StringCopy( szTemp, QUERY_TERMINAL_SERVER_MODE, MAX_STRING_LENGTH ); StringCchPrintf( szQueryString, MAX_QUERY_STRING, szTemp, pUserInfo->strUserServer);
// execute the respective query
hResult = m_pWbemServices->ExecQuery( _bstr_t( QUERY_LANGUAGE ), _bstr_t( szQueryString ), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumClass ); CHECK_HRESULT( hResult );
// set the security parameters
hResult = SetInterfaceSecurity( pEnumClass, m_pAuthIdentity ); CHECK_HRESULT( hResult );
// Get the Terminal server mode
hResult = pEnumClass->Next( TIME_OUT_NEXT, 1, &pClass, &ulReturn ); CHECK_HRESULT( hResult );
// if there are no classes to enumerate break out of the loop
if( ulReturn == 0 ) { // No classes were retrieved....display msg
// release the interface pointers and exit
SAFEIRELEASE( pClass ); SAFEIRELEASE( pEnumClass );
return FALSE;
}
// Get the class property(Name)
bResult = PropertyGet( pClass, CPV_TERMINAL_SERVER_MODE, dwTerminalServerMode, 0 ); CHECK_BRESULT( bResult );
// Got the terminal server mode ...Store it.
if( 1 == dwTerminalServerMode ) { pUserInfo->strTerminalServerMode=GetResString(IDS_TS_APPSERVER); } else if( 0 == dwTerminalServerMode ) { pUserInfo->strTerminalServerMode=GetResString(IDS_TS_REMOTEADMIN); } else { pUserInfo->strTerminalServerMode=GetResString(IDS_TS_REMOTEADMIN); } } catch( _com_error & error ) { // erase the last status message
PrintProgressMsg( m_hOutput, NULL, m_csbi );
// display the error msg
WMISaveError( error.Error() );// ShowMessage( stderr, GetResString( IDS_ERROR ) );
// ShowMessage( stderr, GetReason() );
// release the interface pointers and exit
SAFEIRELEASE( pClass ); SAFEIRELEASE( pEnumClass );
return FALSE; }
// release the interface pointers and exit
SAFEIRELEASE( pClass ); SAFEIRELEASE( pEnumClass );
return TRUE;}/*********************************************************************************************
Routine Description:
This function gets the threshold link speed information.
Arguments:
[in] BOOL : set to TRUE if the information is to be retrieved for the computer.
Return Value:
TRUE on SUCCESS FALSE on FAILURE*********************************************************************************************/BOOL CGpResult::DisplayThresholdSpeedAndLastTimeInfo( BOOL bComputer ){ // Local variables
HRESULT hResult = S_OK;
HKEY hKey = NULL; HKEY hRemoteKey = NULL;
IWbemServices *pDefaultNameSpace = NULL;
TCHAR szTemp[ MAX_STRING_LENGTH ]; TCHAR szServer[ MAX_STRING_LENGTH ]; TCHAR szName[ MAX_STRING_LENGTH ]; TCHAR szTime[ MAX_STRING_LENGTH ]; TCHAR szDate[ MAX_STRING_LENGTH ];
BOOL bResult = FALSE; BOOL bLocaleChanged = FALSE; BOOL bConnFlag = TRUE;
CHString strTemp;
DWORD dwHkey = 0; DWORD dwValue; DWORD dwResult = 0;
FILETIME ftWrite; FILETIME ftLocal;
SYSTEMTIME systime;
LCID lcid;
SecureZeroMemory( &ftWrite, sizeof(FILETIME) ); SecureZeroMemory( &ftLocal, sizeof(FILETIME) ); SecureZeroMemory( &systime, sizeof(SYSTEMTIME) );
try { // If we have to get the information from a remote machine then...
// connect to the remote machine for the last time execution information.
if ( m_bLocalSystem == FALSE ) { StringCopy( szServer, m_strServerName, MAX_STRING_LENGTH ); StringCopy( szName, m_strUserName, MAX_STRING_LENGTH );
bResult = EstablishConnection( szServer, szName, MAX_STRING_LENGTH, m_pwszPassword, MAX_STRING_LENGTH, FALSE ); if( bResult != TRUE ) { strTemp = V_NOT_AVAILABLE; } else { switch( GetLastError() ) { case I_NO_CLOSE_CONNECTION: bConnFlag = FALSE; break;
case E_LOCAL_CREDENTIALS: case ERROR_SESSION_CREDENTIAL_CONFLICT: bConnFlag = FALSE; break;
default: break; } }
// Connect to the remote registry
StringCopy( szServer , _T( "\\\\" ), MAX_STRING_LENGTH ); StringConcat( szServer, m_strServerName, MAX_STRING_LENGTH ); dwResult = RegConnectRegistry( szServer, bComputer ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER, &hRemoteKey ); if( dwResult != ERROR_SUCCESS ) { strTemp = V_NOT_AVAILABLE; } }
// Open the last time execution information key
dwResult = RegOpenKeyEx (bComputer ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER, GROUPPOLICY_PATH, 0, KEY_READ, &hKey);
if( dwResult != ERROR_SUCCESS ) { strTemp = V_NOT_AVAILABLE; }
// Get the last time execution information
dwResult = RegQueryInfoKey( hKey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &ftWrite );
if( dwResult == ERROR_SUCCESS ) { FileTimeToLocalFileTime( &ftWrite, &ftLocal ); FileTimeToSystemTime( &ftLocal, &systime );
// verify whether console supports the current locale 100% or not
lcid = GetSupportedUserLocale( &bLocaleChanged );
// get the formatted date
GetDateFormat( lcid, 0, &systime, ((bLocaleChanged == TRUE) ? L"MM/dd/yyyy" : NULL), szDate, SIZE_OF_ARRAY( szDate ) );
// now format the date
GetTimeFormat( LOCALE_USER_DEFAULT, 0, &systime, ((bLocaleChanged == TRUE) ? L"HH:mm:ss" : NULL), szTime, SIZE_OF_ARRAY( szTime ) );
StringCchPrintf( szTemp, SIZE_OF_ARRAY(szTemp), LAST_TIME_OP, _X( szDate ), _X2( szTime ) ); strTemp = szTemp; } else { strTemp = V_NOT_AVAILABLE; }
// Display the retrieved data
ShowMessage( stdout, GetResString( IDS_LAST_TIME ) ); ShowMessage( stdout, strTemp ); ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) );
// if we have opened a connection then close the same.
if( m_bLocalSystem == FALSE && bConnFlag == TRUE ) { StringCopy( szServer, m_strServerName, MAX_STRING_LENGTH ); CloseConnection( szServer ); }
// Close the registry keys
if( hKey != NULL ) { RegCloseKey( hKey ); } if( hRemoteKey != NULL ) { RegCloseKey( hRemoteKey ); }
// connect to the default namespace
ConnectWmi( m_pWbemLocator, &pDefaultNameSpace, m_strServerName, m_strUserName, m_pwszPassword, &m_pAuthIdentity, FALSE, _bstr_t( ROOT_DEFAULT ), &hResult ); CHECK_HRESULT( hResult );
// form the key
if( bComputer == TRUE ) { dwHkey = HKEY_DEF; } else { dwHkey = HKEY_CURRENT_USER_DEF; }
// Get the DC name from where the policy was applied last
RegQueryValueWMI( pDefaultNameSpace, dwHkey, APPLIED_PATH, FPR_APPLIED_FROM, strTemp, V_NOT_AVAILABLE );
// remove the forward slashes (UNC) if exist in the begining of the server name
if ( IsUNCFormat( strTemp ) == TRUE ) { strTemp = strTemp.Mid( 2 ); }
// Display the retrieved data
ShowMessage( stdout, GetResString( IDS_APPLIED_FROM ) ); ShowMessage( stdout, strTemp ); ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) );
// Get the threshold link speed information
RegQueryValueWMI( pDefaultNameSpace, dwHkey, GPRESULT_PATH, FPR_LINK_SPEED_VALUE, dwValue, (DWORD)-1 ); if( dwValue == (DWORD)-1 ) { strTemp = DEFAULT_LINK_SPEED; } else { StringCchPrintf( szTemp, MAX_STRING_LENGTH, _T( "%d kbps" ), dwValue ); strTemp = szTemp; }
// Display the retrieved data
ShowMessage( stdout, GetResString( IDS_THRESHOLD_LINK_SPEED ) ); ShowMessage( stdout, strTemp );
} catch( _com_error & error ) { WMISaveError( error.Error() ); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() );
// release the allocated variables
SAFEIRELEASE( pDefaultNameSpace );
return FALSE; } catch( CHeap_Exception ) { // display the error message
SetLastError( (DWORD)E_OUTOFMEMORY ); SaveLastError(); ShowMessage( stderr, GetResString( IDS_ERROR ) ); ShowMessage( stderr, GetReason() ); SAFEIRELEASE( pDefaultNameSpace ); return FALSE; }
// release the interface pointer
SAFEIRELEASE( pDefaultNameSpace );
return TRUE;}
/*********************************************************************************************
Routine Description:
This function sorts the applied Gpo data in the order applied.
Arguments:
[in/out] TARRAY : Array to be sorted
Return Value:
None*********************************************************************************************/VOID SortAppliedData( TARRAY arrAppliedData ){ // Local variables
TARRAY arrSortedData = NULL;
DWORD dwMax = 0; DWORD dwCount = 0; DWORD dwi = 0; DWORD dwOrder = 0; DWORD dwIndex = 0; BOOL bNobreak = TRUE;
// Create the dynamic array to hold the sorted data temporarily
arrSortedData = CreateDynamicArray( ); if( NULL == arrSortedData || NULL == arrAppliedData) { //simply return, at most it can print non sorted data, that's all
SetLastError((DWORD)E_OUTOFMEMORY ); return; }
dwCount = DynArrayGetCount( arrAppliedData );
// Get the max applied order in the array
for( dwi = 0; dwi < dwCount; dwi++ ) { dwOrder = DynArrayItemAsDWORD2( arrAppliedData, dwi, COL_ORDER ); if( dwOrder > dwMax ) { dwMax = dwOrder; } }
// Create the sorted array in the descending order of the applied order
for( dwi = 0; dwi < dwCount; dwi++ ) { // re-set the index variable
dwIndex = 0;
// Get the index of the row whose order = dwMax
while( bNobreak ) { dwOrder = DynArrayItemAsDWORD2( arrAppliedData, dwIndex, COL_ORDER ); if( dwOrder == dwMax ) { break; }
// increment the index
dwIndex++;
// Additional check...just in case the order does not exist
// avoid an AV
if( dwIndex == dwCount ) { break; } }
// Additional check...just in case the order does not exist
// avoid an AV
if( dwIndex == dwCount ) { // could not find the index
// decrement the max order
dwMax--;
continue; }
// Store the contents of the row
DynArrayAppendRow( arrSortedData, COL_MAX ); DynArraySetString2( arrSortedData, dwi, COL_DATA, DynArrayItemAsString2( arrAppliedData, dwIndex, COL_DATA ), 0 ); DynArraySetDWORD2( arrSortedData, dwi, COL_ORDER, dwOrder );
// decrement the max order
dwMax--; }
// copy the sorted data onto the applied data array
for( dwi = 0; dwi < dwCount; dwi++ ) { DynArraySetString2( arrAppliedData, dwi, COL_DATA, DynArrayItemAsString2( arrSortedData, dwi, COL_DATA ), 0 ); DynArraySetDWORD2( arrAppliedData, dwi, COL_ORDER, DynArrayItemAsDWORD2( arrSortedData, dwi, COL_ORDER ) ); }
// destroy the temporarily created dynamic array
DESTROY_ARRAY( arrSortedData );
return;}
/*********************************************************************************************
Routine Description:
This function retrieves the FQDN from ADSI
Arguments:
[out] TCHAR [] : Array to hold the FQDN [in] BOOL : flag to specify wether the FQDN is to be retrieved for the computer or the user [in] LPCTSTR : The name for whom the FQDN is to be retrieved
Return Value:
None*********************************************************************************************/VOID CGpResult::GetFQDNFromADSI( TCHAR szFQDN[], BOOL bComputer, LPCTSTR pszName ){ // Local variables
HANDLE hDS = NULL;
DWORD dwReturn = 0;
DS_NAME_RESULT *pNameResult = NULL;
SecureZeroMemory( szFQDN, MAX_STRING_LENGTH * sizeof( TCHAR ) );
// Bind to the ADSI directory service
dwReturn = DsBindWithCred( NULL, m_strADSIDomain, m_pAuthIdentity, &hDS ); if( dwReturn != NO_ERROR ) { return; }
// Get the FQDN information
dwReturn = DsCrackNames( hDS, DS_NAME_NO_FLAGS, bComputer ? DS_DISPLAY_NAME : DS_NT4_ACCOUNT_NAME, DS_FQDN_1779_NAME, 1, &pszName, &pNameResult ); if( dwReturn != DS_NAME_NO_ERROR ) { return; }
// store the retrieved FQDN
StringCopy( szFQDN, pNameResult->rItems->pName, MAX_STRING_LENGTH );
// Free the handle to the ADSI directory services
DsUnBind( &hDS );
// Free the allocated memory
DsFreeNameResult( pNameResult ); return;}
|
