Microsoft/WindowsXP-SP1
Microsoft/WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
WindowsXP-SP1/admin/cmdline/gpresult/loggingdata.cpp
Microsoft f7ca35dddd First commit
2020-09-30 16:53:49 +02:00

3062 lines
111 KiB
C++
Raw Permalink Blame History

/*********************************************************************************************
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 = -1;
// 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( stdout, GetResString( IDS_WARNING ) );
ShowMessage( stdout, GetResString( IDS_WARN_LOCAL ) );
ShowMessage( stdout, 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( 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( 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;
DWORD dwi = 0;
DWORD dwj = 0;
DWORD dwMutex = 0;
CHString strTemp;
CHString strNameSpace;
BSTR bstrTemp = NULL;
IWbemClassObject *pClass = NULL;
IWbemClassObject *pInClass = NULL;
IWbemClassObject *pInInst = NULL;
IWbemClassObject *pOutInst = NULL;
IWbemServices *pNameSpace = NULL;
IEnumWbemClassObject *pRsopClass = NULL;
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 );
hResult = PropertyPut( pInInst, CPV_FLAGS, FLAG_FORCE_CREATENAMESPACE );
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
lstrcat( szMutexName, L"_");
strTemp = pUserInfo->strUserName;
LONG lPos = strTemp.Find(TEXT_BACKSLASH);
if( lPos >= 0 && lPos <= strTemp.GetLength() )
{
strTemp.SetAt(lPos, L'_' );
}
lstrcat( szMutexName, strTemp );
if( FALSE == CreateRsopMutex( szMutexName ) )
{
ShowMessage(stdout, GetResString(IDS_INFO) );
SetLastError( ERROR_RETRY );
ShowLastError( stdout );
// release the interface pointers and exit
SAFEIRELEASE( pRsopClass );
SAFEIRELEASE( pClass );
SAFEIRELEASE( pInClass );
SAFEIRELEASE( pInInst );
SAFEIRELEASE( pOutInst );
return TRUE;
}
dwMutex = WAIT_FAILED;
if( NULL == m_hMutex )
{
PrintProgressMsg( m_hOutput, NULL, m_csbi );
ShowMessage(stdout, GetResString(IDS_INFO) );
SetLastError( ERROR_SINGLE_INSTANCE_APP );
ShowLastError( stdout );
// release the interface pointers and exit
SAFEIRELEASE( pRsopClass );
SAFEIRELEASE( pClass );
SAFEIRELEASE( pInClass );
SAFEIRELEASE( pInInst );
SAFEIRELEASE( pOutInst );
return TRUE;
}
if( m_hMutex != NULL )
{
dwMutex = WaitForSingleObject( m_hMutex, INFINITE );
if( dwMutex == WAIT_FAILED )
{
SaveLastError();
ShowMessage( stderr, GetResString(IDS_ERROR) );
ShowMessage( stderr, GetReason() );
}
}
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 );
//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 )
{
// 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 );
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( lstrcmp( strTemp, V_NOT_AVAILABLE ) == 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 );
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 = lstrlen( 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 );
// Display the heading for the Computer GPO's
ShowMessage( stdout, GetResString( IDS_GPO_DISPLAY ) );
ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) );
for( dwi = lstrlen( 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 = lstrlen( 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 );
// Display the heading for the User GPO's
ShowMessage( stdout, GetResString( IDS_GPO_DISPLAY ) );
ShowMessage( stdout, GetResString( IDS_NEWLINE_TAB ) );
for( dwi = lstrlen( 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( 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 );
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, strNameSpace, pRsopNameSpace );
}
// release the interface pointers and exit
SAFEIRELEASE( pRsopClass );
SAFEIRELEASE( pClass );
SAFEIRELEASE( pInClass );
SAFEIRELEASE( pInInst );
SAFEIRELEASE( pOutInst );
ReleaseMutex( m_hMutex );
return FALSE;
}
ReleaseMutex( m_hMutex );
// release the interface pointers and exit
SAFEIRELEASE( pRsopClass );
SAFEIRELEASE( pClass );
SAFEIRELEASE( pInClass );
SAFEIRELEASE( pInInst );
SAFEIRELEASE( pOutInst );
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
ZeroMemory( szTemp, MAX_STRING_LENGTH * sizeof( TCHAR ) );
ZeroMemory( szName, MAX_STRING_LENGTH * sizeof( TCHAR ) );
ZeroMemory( szServer, MAX_STRING_LENGTH * sizeof( TCHAR ) );
ZeroMemory( szDomain, MAX_STRING_LENGTH * sizeof( TCHAR ) );
ZeroMemory( 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 );
hResult = 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 = 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) );
SetLastError( ERROR_POLICY_OBJECT_NOT_FOUND );
ShowLastError( stdout );
// 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 )
{
lstrcpy( szServer, m_strServerName );
lstrcpy( szName, m_strUserName );
// 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
lstrcpy( szTemp, strTemp );
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 ), strTemp );
ShowMessage( stderr, GetResString( IDS_INFO ) );
ShowMessage( stderr, 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( lstrcmpi( szName, m_strUser ) != 0
|| ( lstrcmpi( szDomain, m_strDomainName ) != 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 ), strTemp );
ShowMessage( stderr, GetResString( IDS_INFO ) );
ShowMessage( stderr, 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.
lstrcat( szDomain, TEXT_BACKSLASH );
lstrcat( szDomain, pUserInfo->strUserName );
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 )
{
lstrcpy( szServer, m_strServerName );
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 )
{
lstrcpy( szServer, m_strServerName );
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 )
{
lstrcpy( szServer, m_strServerName );
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 );
lstrcpy( szServer, m_strADSIServer );
lstrcat( szServer, TEXT_DOLLAR );
// 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 ) )
{
ZeroMemory( szFQDN, MAX_STRING_LENGTH * sizeof( TCHAR ) );
dwBufSize = MAX_STRING_LENGTH;
lstrcpy( szName, pUserInfo->strUserName );
// get the FQDN from the Translate name call
TranslateName( szName, NameSamCompatible, NameFullyQualifiedDN,
szFQDN, &dwBufSize );
}
else
{
// Get the FQDN from ADSI directory services
lstrcpy( szName, pUserInfo->strUserName );
GetFQDNFromADSI( szFQDN, FALSE, szName );
}
// Store the FQDN into the structure.
pUserInfo->strUserFQDN = szFQDN;
// Now display the data
PrintProgressMsg( m_hOutput, GetResString( IDS_STARTED_RETRIEVAL ), m_csbi );
DisplayData( pUserInfo, pRsopNameSpace );
// Get the new output co-ordinates
if ( m_hOutput != NULL )
{
GetConsoleScreenBufferInfo( m_hOutput, &m_csbi );
}
// re-set the buffers and their sizes
ZeroMemory( szTemp, MAX_STRING_LENGTH * sizeof( TCHAR ) );
ZeroMemory( szName, MAX_STRING_LENGTH * sizeof( TCHAR ) );
ZeroMemory( szServer, MAX_STRING_LENGTH * sizeof( TCHAR ) );
ZeroMemory( 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 )
{
lstrcpy( szServer, m_strServerName );
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 ), strTemp );
ShowMessage( stderr, GetResString( IDS_INFO ) );
ShowMessage( stderr, 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 );
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
lstrcpy( szTemp, PATH );
lstrcat( szTemp, pUserInfo->strUserSid );
// 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;
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->strUserDomain,
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( lstrcmp( strTemp, V_NOT_AVAILABLE ) != 0 )
{
// this enumeration has the domain controller name...
// we have got the enumeration we need so get the other data
break;
}
}// while
}
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 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 == ERROR_SUCCESS )
{
// 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 ( lstrcmpi( szComputerName, lpszDomainName ) == 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 bW2KDomain = FALSE;
BOOL bLocalAccount = FALSE;
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
ZeroMemory( 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 ) );
wsprintf( szMsgBuffer, GetResString( IDS_CREATED_ON ), szDate, szTime );
ShowMessage( stdout, szMsgBuffer );
ShowMessage( stdout, NEW_LINE );
// Display the common information....Domain Info
wsprintf( szMsgBuffer, GetResString( IDS_GPO_TITLE ), pUserInfo->strUserName,
pUserInfo->strUserServer );
ShowMessage( stdout, szMsgBuffer );
dwLength = lstrlen( szMsgBuffer );
ShowMessage( stdout, NEW_LINE );
// Underline the above heading
for( ; dwLength > 0; dwLength-- )
{
ShowMessage( stdout, GetResString( IDS_DASH ) );
}
ShowMessage( stdout, NEW_LINE );
lstrcpy( szMsgBuffer, pUserInfo->strUserDomain );
if( lstrlen( szMsgBuffer ) != 0 )
{
lstrcpy( szMsgBuffer, _tcstok( szMsgBuffer, GetResString( IDS_LAST_CHAR ) ) );
lstrcpy( szMsgBuffer, _tcstok( NULL, GetResString( IDS_LAST_CHAR ) ) );
}
// 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 );
ShowMessage( stdout, NEW_LINE );
// Get the domain type information
GetDomainType (szMsgBuffer, &bW2KDomain, &bLocalAccount);
ShowMessage( stdout, GetResString( IDS_DOMAIN_NAME ) );
ShowMessage( stdout, szMsgBuffer );
ShowMessage( stdout, NEW_LINE );
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 ) );
}
}
// 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 ) );
ShowMessage( stdout, 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;
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
while( TRUE )
{
// Get the pointer to the next class
hResult = pRsopLinkClass->Next( WBEM_INFINITE, 1, &pRsopLinkObj, &ulReturn );
CHECK_HRESULT( hResult );
if( ulReturn == 0 )
{
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
// 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 = lstrlen( 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( lstrcmp( DynArrayItemAsString2( arrFilteredData, dwi, COL_FILTER ),
GetResString( IDS_WMI_DENIED ) ) == 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_HRESULT( hResult );
// 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 );
// destroy the dynamic arrays
DESTROY_ARRAY( arrAppliedData );
DESTROY_ARRAY( arrFilteredData );
return FALSE;
}
SAFEIRELEASE( pRsopLinkObj );
SAFEIRELEASE( pRsopLinkClass );
SAFEIRELEASE( pRsopObj );
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;
BOOL bDone = 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
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 );
CHECK_BRESULT( bResult );
// get the domain name information for later use
hResult = PropertyGet( pClass, CPV_DOMAIN, m_strADSIDomain );
CHECK_BRESULT( bResult );
// get the server name for future use by LDAP
hResult = 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( E_OUTOFMEMORY );
SaveLastError();
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
{
ZeroMemory( szTemp, sizeof( szTemp ) );
ZeroMemory( 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 = lstrlen( 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 = lstrlen( 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 = 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 );
}
for( ; lLBound <= lUBound; lLBound++ )
{
bResult = GetPropertyFromSafeArray( safeArray, lLBound, strTemp, vartype );
CHECK_BRESULT( bResult );
// Got a sid, now get it's coressponding name
// form the object path using the SID
wsprintf( szTemp, OBJECT_PATH, 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\\" ) );
}
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() );
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 bResult = FALSE;
BOOL bGotClass = FALSE;
BOOL bTemp = FALSE;
ULONG ulReturned = 0;
IWbemClassObject *pClass = NULL;
IEnumWbemClassObject *pEnumClass = NULL;
CHString strTemp;
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;
BOOL bGotClass = FALSE;
BOOL bGotDomainInfo = FALSE;
BOOL bUserSpecified = 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
ZeroMemory( szQueryString, MAX_QUERY_STRING * sizeof( TCHAR ));
ZeroMemory( szTemp, MAX_STRING_LENGTH * sizeof( TCHAR ) );
// Form the query string
lstrcpy( szTemp, QUERY_USER_NAME );
FORMAT_STRING( szQueryString, 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.
lstrcpy( szName, strTemp );
// 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.
lstrcpy( szDomain, strTemp );
}
}
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;
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 )
{
lstrcpy( szServer, m_strServerName );
lstrcpy( szName, m_strUserName );
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
lstrcpy( szServer , _T( "\\\\" ) );
lstrcat( szServer, m_strServerName );
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 ) );
wsprintf( szTemp, LAST_TIME_OP, szDate, 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 )
{
lstrcpy( szServer, m_strServerName );
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, -1 );
if( dwValue == -1 )
{
strTemp = DEFAULT_LINK_SPEED;
}
else
{
FORMAT_STRING( szTemp, _T( "%d kbps" ), dwValue );
strTemp = szTemp;
}
// Display the retrieved data
ShowMessage( stdout, GetResString( IDS_THRESHOLD_LINK_SPEED ) );
ShowMessage( stdout, strTemp );
ShowMessage( stdout, NEW_LINE );
}
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( E_OUTOFMEMORY );
SaveLastError();
ShowMessage( stderr, GetResString( IDS_ERROR ) );
ShowMessage( stderr, GetReason() );
}
// release the interface pointer
SAFEIRELEASE( pDefaultNameSpace );
return TRUE;
}
/*********************************************************************************************
Routine Description:
This function checks if the current locale is supported or not.
Arguments:
[in] bLocaleChanged
Return Value:
LCID of the current locale.
*********************************************************************************************/
LCID GetSupportedUserLocale( BOOL& bLocaleChanged )
{
// local variables
LCID lcid;
// get the current locale
lcid = GetUserDefaultLCID();
// check whether the current locale is supported by our tool or not
// if not change the locale to the english which is our default locale
bLocaleChanged = FALSE;
if ( PRIMARYLANGID( lcid ) == LANG_ARABIC || PRIMARYLANGID( lcid ) == LANG_HEBREW ||
PRIMARYLANGID( lcid ) == LANG_THAI || PRIMARYLANGID( lcid ) == LANG_HINDI ||
PRIMARYLANGID( lcid ) == LANG_TAMIL || PRIMARYLANGID( lcid ) == LANG_FARSI )
{
bLocaleChanged = TRUE;
lcid = MAKELCID( MAKELANGID( LANG_ENGLISH, SUBLANG_DEFAULT ), SORT_DEFAULT ); // 0x409;
}
// return the locale
return lcid;
}
/*********************************************************************************************
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;
// Create the dynamic array to hold the sorted data temporarily
arrSortedData = CreateDynamicArray( );
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( TRUE )
{
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
HRESULT hResult = S_OK;
HANDLE hDS = NULL;
DWORD dwReturn = 0;
DS_NAME_RESULT *pNameResult = NULL;
ZeroMemory( 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 != NO_ERROR )
{
return;
}
// store the retrieved FQDN
lstrcpy( szFQDN, pNameResult->rItems->pName );
// Free the handle to the ADSI directory services
DsUnBind( &hDS );
// Free the allocated memory
DsFreeNameResult( pNameResult );
return;
}
BOOL CGpResult::CreateRsopMutex( LPWSTR szMutexName )
{
BOOL bResult = FALSE;
SECURITY_ATTRIBUTES sa;
PSECURITY_DESCRIPTOR psd = NULL;
//
// first try to open the mutex object by its name
// if that fails it means the mutex is not yet created and
// so create it now
//
m_hMutex = OpenMutex( SYNCHRONIZE, FALSE, szMutexName );
if ( m_hMutex == NULL )
{
// check the error code why it failed to open
if ( GetLastError() == ERROR_FILE_NOT_FOUND )
{
// create the security descriptor -- just set the
// Dicretionary Access Control List (DACL)
// in order to provide security, we will deny WRITE_OWNER and WRITE_DAC
// permission to Everyone except to the owner
bResult = ConvertStringSecurityDescriptorToSecurityDescriptor(
L"D:(D;;WOWD;;;WD)(A;;GA;;;WD)", SDDL_REVISION_1, &psd, NULL );
if ( bResult == FALSE )
{
// we encountered error while creating a security descriptor
SaveLastError();
ShowMessage( stderr, GetResString(IDS_ERROR) );
ShowMessage( stderr, GetReason() );
return FALSE;
}
// initialize the SECURITY_ATTRIBUTES structure
SecureZeroMemory( &sa, sizeof( SECURITY_ATTRIBUTES ) );
sa.nLength = sizeof( SECURITY_ATTRIBUTES );
sa.lpSecurityDescriptor = psd;
sa.bInheritHandle = FALSE;
// mutex doesn't exist -- so we need to create it now
m_hMutex = CreateMutex( &sa, FALSE, szMutexName );
if (m_hMutex == NULL )
{
// we are not able to create the mutex
// cannot proceed furthur
SaveLastError();
ShowMessage( stderr, GetResString(IDS_ERROR) );
ShowMessage( stderr, GetReason() );
return FALSE;
}
LocalFree(psd);
}
else
{
// we encounter some error
// cannot proceed furthur
SaveLastError();
ShowMessage( stderr, GetResString(IDS_ERROR) );
ShowMessage( stderr, GetReason() );
return FALSE;
}
}
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink