/********************************************************************************************* 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; }