// ********************************************************************************* // // Copyright (c) Microsoft Corporation // // Module Name: // // DriverQuery.cpp // // Abstract: // // This modules Queries the information of the various drivers present in the // system . // // Syntax: // ------ // DriverQuery [-s server ] [-u [domain\]username [-p password]] // [-fo format ] [-n|noheader ] [-v] // // Author: // // J.S.Vasu (vasu.julakanti@wipro.com) // // Revision History: // // Created on 31-0ct-2000 by J.S.Vasu // Modified on 9-Dec-2000 by Santhosh Brahmappa Added a new function IsWin64() // // // ********************************************************************************* // #include "pch.h" #include "Resource.h" #include "DriverQuery.h" #include "LOCALE.H" #include "shlwapi.h" #ifndef _WIN64 BOOL IsWin64(void); #define countof(x) (sizeof(x) / sizeof((x)[0])) #endif // function prototypes LCID GetSupportedUserLocale( BOOL& bLocaleChanged ); // *************************************************************************** // Routine Description: // This the entry point to this utility. // // Arguments: // [ in ] argc : argument(s) count specified at the command prompt // [ in ] argv : argument(s) specified at the command prompt // // Return Value: // 0 : If the utility successfully displayed the driver information. // 1 : If the utility completely failed to display the driver information // // *************************************************************************** DWORD _cdecl _tmain(DWORD argc,LPCTSTR argv[]) { BOOL bResult = FALSE ; BOOL bNeedPassword = FALSE ; BOOL bUsage = FALSE ; BOOL bHeader= FALSE ; LPTSTR szUserName = NULL ; LPTSTR szPassword = NULL ; LPTSTR szServer = NULL ; LPTSTR szTmpUserName = NULL ; LPTSTR szTmpPassword = NULL ; LPTSTR szTmpServer = NULL ; __MAX_SIZE_STRING szFormat = NULL_STRING ; DWORD dwSystemType = 0; HRESULT hQueryResult = S_OK ; DWORD dwExitCode = 0; DWORD dwErrCode = 0; BOOL bLocalFlag = TRUE ; BOOL bLocalSystem = TRUE; BOOL bVerbose = FALSE ; BOOL bComInitFlag = FALSE ; IWbemLocator* pIWbemLocator = NULL ; IWbemServices* pIWbemServReg = NULL ; LPCTSTR szToken = NULL ; COAUTHIDENTITY *pAuthIdentity = NULL; BOOL bFlag = FALSE ; BOOL bSigned = FALSE ; _tsetlocale( LC_ALL, _T("")); szServer = (LPTSTR) malloc ((MAX_STRING_LENGTH) * sizeof(TCHAR)); szUserName = (LPTSTR) malloc ((MAX_STRING_LENGTH) * sizeof(TCHAR)); szPassword = (LPTSTR) malloc ((MAX_STRING_LENGTH) * sizeof(TCHAR)); szTmpUserName = szUserName ; szTmpPassword = szPassword ; szTmpServer = szServer ; if ((szServer == NULL)||(szUserName == NULL)||(szPassword == NULL)) { SetLastError(ERROR_NOT_ENOUGH_MEMORY); DISPLAY_MESSAGE( stderr, ERROR_TAG); ShowLastError(stderr); dwExitCode = 1; SAFEFREE(szTmpServer); SAFEFREE(szTmpUserName); SAFEFREE(szTmpPassword); ReleaseGlobals(); return(dwExitCode); } memset(szServer,0,MAX_STRING_LENGTH*sizeof(TCHAR)); memset(szUserName,0,MAX_STRING_LENGTH*sizeof(TCHAR)); memset(szPassword,0,MAX_STRING_LENGTH*sizeof(TCHAR)); bResult = ProcessOptions(argc,argv,&bUsage,&szServer,&szUserName,&szPassword,szFormat, &bHeader,&bNeedPassword,&bVerbose,&bSigned); if(bResult == FALSE) { ShowMessage(stderr,GetReason()); dwExitCode = 1; SAFEFREE(szTmpServer); SAFEFREE(szTmpUserName); SAFEFREE(szTmpPassword); ReleaseGlobals(); return(dwExitCode); } // check if the help option has been specified. if(bUsage==TRUE) { ShowUsage() ; ReleaseGlobals(); SAFEFREE(szTmpServer); SAFEFREE(szTmpUserName); SAFEFREE(szTmpPassword); return(dwExitCode); } if( ( IsLocalSystem( szServer ) == TRUE )&&(lstrlen(szUserName)!=0) ) { DISPLAY_MESSAGE(stdout,GetResString(IDS_IGNORE_LOCAL_CRED)); } bComInitFlag = InitialiseCom(&pIWbemLocator); if(bComInitFlag == FALSE ) { dwExitCode = 1; CloseConnection(szServer); ReleaseGlobals(); SAFEFREE(szTmpServer); SAFEFREE(szTmpUserName); SAFEFREE(szTmpPassword); return(dwExitCode); } CHString strUserName = NULL_STRING; CHString strPassword = NULL_STRING; CHString strMachineName = NULL_STRING; try { strUserName = szUserName ; strPassword = szPassword ; strMachineName = szServer ; bFlag = ConnectWmiEx( pIWbemLocator, &pIWbemServReg, strMachineName, strUserName, strPassword, &pAuthIdentity, bNeedPassword, DEFAULT_NAMESPACE, &bLocalSystem ); //if unable to connect to wmi exit failure if( bFlag == FALSE ) { SAFEIRELEASE( pIWbemLocator); SAFEIRELEASE( pIWbemServReg ); CoUninitialize(); ReleaseGlobals(); SAFEFREE(szTmpServer); SAFEFREE(szTmpUserName); SAFEFREE(szTmpPassword); return( EXIT_FAILURE ); } szUserName = strUserName.GetBuffer(strUserName.GetLength()); szPassword = strPassword.GetBuffer(strPassword.GetLength()) ; szServer = strMachineName.GetBuffer(strPassword.GetLength()); } catch(CHeap_Exception) { DISPLAY_MESSAGE( stderr, ERROR_TAG ); SetLastError( E_OUTOFMEMORY ); ShowLastError( stderr ); SAFEIRELEASE( pIWbemLocator); SAFEIRELEASE( pIWbemServReg ); CoUninitialize(); ReleaseGlobals(); SAFEFREE(szTmpServer); SAFEFREE(szTmpUserName); SAFEFREE(szTmpPassword); return( EXIT_FAILURE ); } // establish connection to remote system by using win32api function if ( bLocalSystem == FALSE ) { LPCWSTR pwszUser = NULL; LPCWSTR pwszPassword = NULL; // identify the password to connect to the remote system if ( pAuthIdentity != NULL ) { pwszPassword = pAuthIdentity->Password; if ( strUserName.GetLength() != 0 ) pwszUser = strUserName; } DWORD dwConnect = 0 ; dwConnect = ConnectServer( strMachineName, pwszUser, pwszPassword ); if(dwConnect !=NO_ERROR ) { dwErrCode = GetLastError(); if(dwErrCode == ERROR_SESSION_CREDENTIAL_CONFLICT) { DISPLAY_MESSAGE(stdout,GetResString(IDS_WARNING_TAG)); ShowLastError(stdout); } else if( dwConnect == ERROR_EXTENDED_ERROR ) { DISPLAY_MESSAGE( stderr, ERROR_TAG ); DISPLAY_MESSAGE( stderr, GetReason() ); SAFEIRELEASE( pIWbemLocator ); SAFEIRELEASE( pIWbemServReg ); CoUninitialize(); ReleaseGlobals(); SAFEFREE(szTmpServer); SAFEFREE(szTmpUserName); SAFEFREE(szTmpPassword); return( EXIT_FAILURE ); } else { SetLastError( dwConnect ); DISPLAY_MESSAGE( stderr, ERROR_TAG ); ShowLastError( stderr ); SAFEIRELEASE( pIWbemLocator ); SAFEIRELEASE( pIWbemServReg ); CoUninitialize(); ReleaseGlobals(); SAFEFREE(szTmpServer); SAFEFREE(szTmpUserName); SAFEFREE(szTmpPassword); return( EXIT_FAILURE ); } } else { bLocalFlag = FALSE ; } } else { lstrcpy( szServer, _T( "" ) ); } hQueryResult = QueryDriverInfo(szServer, szUserName,szPassword,szFormat,bHeader,bVerbose,pIWbemLocator,pAuthIdentity,pIWbemServReg,bSigned); if(hQueryResult == FAILURE) { // close connection to the specified system and exit with failure. if (bLocalFlag == FALSE ) { CloseConnection(szServer); } dwExitCode = 1; ReleaseGlobals(); SAFEFREE(szTmpServer); SAFEFREE(szTmpUserName); SAFEFREE(szTmpPassword); return(dwExitCode); } // close connection to the specified system and exit if (bLocalFlag == FALSE ) { CloseConnection(szServer); } SAFEFREE(szTmpServer); SAFEFREE(szTmpUserName); SAFEFREE(szTmpPassword); ReleaseGlobals(); return (dwExitCode); } // *************************************************************************** // Routine Description: // This function fetches usage information from resource file and displays it // // Arguments: // None // // Return Value: // None // *************************************************************************** void ShowUsage() { DWORD dwIndex = ID_USAGE_BEGIN; for(;dwIndex<=ID_USAGE_ENDING; dwIndex++) { DISPLAY_MESSAGE(stdout,GetResString( dwIndex )); } } // *************************************************************************** // Routine Description: // This function queries the driverinfo of the specified system by connecting to WMI // // Arguments: // [ in ] szServer : server name on which DriverInformation has to be queried. // [ in ] szUserName : User name for whom DriverInformation has to be queried. // [ in ] szPassword : Password for the user // [ in ] szFormat : Format in which the results are to be displayed. // [ in ] bHeader : Boolean indicating if the header is required. // // Return Value: // SUCCESS : if the function is successful in querying // FAILURE : if the function is unsuccessful in querying. // *************************************************************************** DWORD QueryDriverInfo(LPTSTR szServer,LPTSTR szUserName,LPTSTR szPassword,LPTSTR szFormat,BOOL bHeader,BOOL bVerbose,IWbemLocator* pIWbemLocator,COAUTHIDENTITY* pAuthIdentity,IWbemServices* pIWbemServReg,BOOL bSigned ) { HRESULT hRes = S_OK ; HRESULT hConnect = S_OK; _bstr_t bstrUserName ; _bstr_t bstrPassword ; _bstr_t bstrNamespace ; _bstr_t bstrServer ; try { bstrNamespace = CIMV2_NAMESPACE ; bstrServer = szServer ; } catch(...) { DISPLAY_MESSAGE( stderr,ERROR_RETREIVE_INFO); CoUninitialize(); return FAILURE; } DWORD dwProcessResult = 0; DWORD dwSystemType = 0 ; LPTSTR lpMsgBuf = NULL; //Create a pointer to IWbemServices,IWbemLocator interfaces IWbemServices *pIWbemServices = NULL; IEnumWbemClassObject *pSystemSet = NULL; HRESULT hISecurity = S_FALSE; if ( IsLocalSystem( szServer ) == FALSE ) { try { //appending UNC paths to form the complete path. bstrNamespace = TOKEN_BACKSLASH2 + _bstr_t( szServer ) + TOKEN_BACKSLASH + CIMV2_NAMESPACE; // if user name is specified then only take user name and password if ( lstrlen( szUserName ) != 0 ) { bstrUserName = szUserName; if (lstrlen(szPassword)==0) { bstrPassword = L""; } else { bstrPassword = szPassword ; } } } catch(...) { DISPLAY_MESSAGE( stderr,ERROR_RETREIVE_INFO); CoUninitialize(); return FAILURE; } } /* TCHAR szHost[256] = _T(""); _tcscpy(szHost,szServer); if( IsValidIPAddress( szHost ) == TRUE ) { //if( GetHostByIPAddr( szHost, szServer, FALSE ) == FALSE ) GetHostByIPAddr( szHost, szServer, FALSE ); //return FAILURE; } */ dwSystemType = GetSystemType(pAuthIdentity,pIWbemServReg); if (dwSystemType == ERROR_WMI_VALUES) { DISPLAY_MESSAGE( stderr,ERROR_RETREIVE_INFO); CoUninitialize(); return FAILURE; } // Connect to the Root\Cimv2 namespace of the specified system with the current user. // If no system is specified then connect to the local system. // To pass the appropriate Username to connectserver // depending upon whether the user has entered domain\user or only username at the command prompt. // connect to the server with the credentials supplied. hConnect = pIWbemLocator->ConnectServer(bstrNamespace, bstrUserName, bstrPassword, 0L, 0L, NULL, NULL, &pIWbemServices ); if((lstrlen(szUserName)!=0) && FAILED(hConnect) && (hConnect == E_ACCESSDENIED)) { hConnect = pIWbemLocator->ConnectServer(bstrNamespace, bstrUserName, NULL, 0L, 0L, NULL, NULL, &pIWbemServices ); } if(hConnect == WBEM_S_NO_ERROR) { // Set the proxy so that impersonation of the client occurs. hISecurity = SetInterfaceSecurity(pIWbemServices,pAuthIdentity); if(FAILED(hISecurity)) { GetWbemErrorText(hISecurity); DISPLAY_MESSAGE(stderr,ERROR_TAG); DISPLAY_MESSAGE(stderr,GetReason()); SAFEIRELEASE(pIWbemServices); CoUninitialize(); return FAILURE ; } // Use the IWbemServices pointer to make requests of WMI. // Create enumeration of Win32_ComputerSystem class if(bSigned == FALSE) { hRes = pIWbemServices->CreateInstanceEnum(_bstr_t(CLASS_SYSTEMDRIVER), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pSystemSet); } else { hRes = pIWbemServices->ExecQuery(_bstr_t(LANGUAGE_WQL),_bstr_t(WQL_QUERY),WBEM_FLAG_RETURN_IMMEDIATELY| WBEM_FLAG_FORWARD_ONLY,NULL,&pSystemSet); } //if ( hRes == S_OK) if ( SUCCEEDED(hRes )) { hISecurity = SetInterfaceSecurity(pSystemSet,pAuthIdentity); if(FAILED(hISecurity)) { GetWbemErrorText(hISecurity); DISPLAY_MESSAGE(stderr,ERROR_TAG); DISPLAY_MESSAGE(stderr,GetReason()); SAFEIRELEASE(pSystemSet); CoUninitialize(); return FAILURE ; } if(bSigned == FALSE) { dwProcessResult = ProcessCompSysEnum(szServer,pSystemSet,szFormat,bHeader,dwSystemType,bVerbose); } else { dwProcessResult = ProcessSignedDriverInfo(szServer,pSystemSet,szFormat,bHeader,dwSystemType,bVerbose); } switch(dwProcessResult) { case FAILURE: SAFEIRELEASE(pSystemSet); SAFEIRELEASE(pIWbemServices); SAFEIRELEASE(pIWbemLocator); CoUninitialize(); return FAILURE ; case EXIT_FAILURE_MALLOC : SetLastError(ERROR_NOT_ENOUGH_MEMORY); DISPLAY_MESSAGE( stderr, ERROR_TAG); ShowLastError(stderr); SAFEIRELEASE(pSystemSet); SAFEIRELEASE(pIWbemServices); SAFEIRELEASE(pIWbemLocator); CoUninitialize(); return FAILURE ; case EXIT_FAILURE_FORMAT: DISPLAY_MESSAGE(stderr, ERROR_ENUMERATE_INSTANCE); SAFEIRELEASE(pSystemSet); SAFEIRELEASE(pIWbemServices); SAFEIRELEASE(pIWbemLocator); CoUninitialize(); return FAILURE ; case EXIT_SUCCESSFUL: SAFEIRELEASE(pSystemSet); SAFEIRELEASE(pIWbemServices); SAFEIRELEASE(pIWbemLocator); CoUninitialize(); return SUCCESS ; break ; case EXIT_FAILURE_RESULTS: DISPLAY_MESSAGE(stdout,GetResString(IDS_NO_DRIVERS_FOUND)); SAFEIRELEASE(pSystemSet); SAFEIRELEASE(pIWbemServices); SAFEIRELEASE(pIWbemLocator); CoUninitialize(); return SUCCESS ; break ; } } else { DISPLAY_MESSAGE( stderr, ERROR_ENUMERATE_INSTANCE); SAFEIRELEASE(pIWbemServices); SAFEIRELEASE(pIWbemLocator); CoUninitialize(); return FAILURE; } } else { //display the error if connect server fails //unauthorized user if(hRes == WBEM_E_ACCESS_DENIED) { DISPLAY_MESSAGE( stderr, ERROR_AUTHENTICATION_FAILURE); } //local system credentials else if(hRes == WBEM_E_LOCAL_CREDENTIALS) { DISPLAY_MESSAGE( stderr, ERROR_LOCAL_CREDENTIALS); } //some error else { DISPLAY_MESSAGE( stderr, ERROR_WMI_FAILURE ); } SAFEIRELEASE(pIWbemLocator); CoUninitialize(); return (FAILURE); } // Release pIWbemLocator object SAFEIRELEASE(pIWbemLocator); // Close COM library, unload DLLs and free all resources held by // current thread CoUninitialize(); return (hRes); } // *************************************************************************** // Routine Description: // Processes enumeration of Win32_ComputerSystem instances // // Arguments: // [ in ] szHost : HostName to connect to // [ in ] pSystemSet : pointer to the structure containing system properties. // [ in ] szFormat : specifies the format // [ in ] bHeader : specifies if the header is required or not. // // Return Value: // 0 no error // 1 error occured while allocating memory. // // *************************************************************************** DWORD ProcessCompSysEnum(CHString szHost, IEnumWbemClassObject *pSystemSet,LPTSTR szFormat,BOOL bHeader,DWORD dwSystemType,BOOL bVerbose) { HRESULT hRes = S_OK; ULONG ulReturned = 1; // declare variant type variables VARIANT vtPathName; //declaration of normal variables CHString szPathName ; DWORD dwLength = 0; LPCTSTR szPath = NULL; LPTSTR szHostName = NULL ; CHString szAcceptPauseVal ; CHString szAcceptStopVal ; LPTSTR szSysManfact = NULL; TARRAY arrResults = NULL ; TCHAR szPrintPath[MAX_STRING_LENGTH+1] =TOKEN_EMPTYSTRING ; DWORD dwRow = 0 ; BOOL bValue = FALSE ; DWORD dwValue = 0 ; TCHAR szDelimiter[MAX_RES_STRING+1] = NULL_STRING ; DWORD dwPosn1 = 0; DWORD dwStrlen = 0; DWORD dwFormatType = SR_FORMAT_TABLE ; MODULE_DATA Current ; BOOL bResult = FALSE ; NUMBERFMT *pNumberFmt = NULL; TCOLUMNS ResultHeader[ MAX_COLUMNS ]; IWbemClassObject *pSystem = NULL; LPTSTR szCodeSize = NULL; LPTSTR szInitSize = NULL; LPTSTR szBssSize = NULL ; LPTSTR szAcceptStop = NULL ; int iLen = 0; LPTSTR szAcceptPause = NULL; LPTSTR szPagedSize = NULL ; TCHAR szDriverTypeVal[MAX_RES_STRING+1] = NULL_STRING; DWORD dwLocale = 0 ; WCHAR wszStrVal[MAX_RES_STRING+1] = NULL_STRING; CHString szValue ; CHString szSysName ; CHString szStartMode ; CHString szDispName ; CHString szDescription ; CHString szStatus ; CHString szState ; CHString szDriverType ; BOOL bBlankLine = FALSE; BOOL bFirstTime = TRUE; //get the paged pool acc to the Locale BOOL bFValue = FALSE ; // Fill up the NUMBERFMT structure acc to the locale specific information LPTSTR szGroupSep = NULL; LPTSTR szDecimalSep = NULL ; LPTSTR szGroupThousSep = NULL ; pNumberFmt = (NUMBERFMT *) malloc(sizeof(NUMBERFMT)); if(pNumberFmt == NULL) { return EXIT_FAILURE_MALLOC ; } // Initialise the structure to Zero. ZeroMemory(&Current,sizeof(Current)); // assign the appropriate format type to the dwFormattype flag if( StringCompare(szFormat,TABLE_FORMAT, TRUE,sizeof(TABLE_FORMAT)) == 0 ) { dwFormatType = SR_FORMAT_TABLE; } else if( StringCompare(szFormat,LIST_FORMAT, TRUE,sizeof(LIST_FORMAT)) == 0 ) { dwFormatType = SR_FORMAT_LIST; } else if( StringCompare(szFormat,CSV_FORMAT, TRUE,sizeof(CSV_FORMAT)) == 0 ) { dwFormatType = SR_FORMAT_CSV; } // formulate the Column headers and show results appropriately FormHeader(dwFormatType,bHeader,ResultHeader,bVerbose); // loop till there are results. bFirstTime = TRUE; while ( ulReturned == 1 ) { // Create new Dynamic Array to hold the result arrResults = CreateDynamicArray(); if(arrResults == NULL) { SAFEFREE(pNumberFmt); return EXIT_FAILURE_MALLOC ; } // Enumerate through the resultset. hRes = pSystemSet->Next(WBEM_INFINITE, 1, // return just one system &pSystem, // pointer to system &ulReturned ); // number obtained: one or zero if ( SUCCEEDED( hRes ) && (ulReturned == 1) ) { // initialise the variant variables to empty VariantInit(&vtPathName); szValue = NO_DATA_AVAILABLE; szSysName = NO_DATA_AVAILABLE ; szStartMode = NO_DATA_AVAILABLE ; szDispName = NO_DATA_AVAILABLE ; szDescription = NO_DATA_AVAILABLE ; szStatus = NO_DATA_AVAILABLE ; szState = NO_DATA_AVAILABLE ; szDriverType = NO_DATA_AVAILABLE ; try { hRes = PropertyGet(pSystem,PROPERTY_NAME,szValue); ONFAILTHROWERROR(hRes); hRes = PropertyGet(pSystem,PROPERTY_SYSTEMNAME,szSysName); ONFAILTHROWERROR(hRes); hRes = PropertyGet(pSystem,PROPERTY_STARTMODE,szStartMode); ONFAILTHROWERROR(hRes); hRes = PropertyGet(pSystem,PROPERTY_DISPLAYNAME,szDispName); ONFAILTHROWERROR(hRes); hRes = PropertyGet(pSystem,PROPERTY_DESCRIPTION,szDescription); ONFAILTHROWERROR(hRes); hRes = PropertyGet(pSystem,PROPERTY_STATUS,szStatus); ONFAILTHROWERROR(hRes); hRes = PropertyGet(pSystem,PROPERTY_STATE,szState); ONFAILTHROWERROR(hRes); hRes = PropertyGet(pSystem,PROPERTY_ACCEPTPAUSE,szAcceptPauseVal); ONFAILTHROWERROR(hRes); hRes = PropertyGet(pSystem,PROPERTY_ACCEPTSTOP,szAcceptStopVal); ONFAILTHROWERROR(hRes); hRes = PropertyGet(pSystem,PROPERTY_SERVICETYPE,szDriverType); ONFAILTHROWERROR(hRes); } catch(_com_error) { DISPLAY_MESSAGE(stderr,ERROR_GET_VALUE); SAFEIRELEASE(pSystem); DestroyDynamicArray(&arrResults); SAFEFREE(pNumberFmt); return FAILURE; } // retreive the PathName property szPath = NULL; try { hRes = pSystem->Get( PROPERTY_PATHNAME, 0,&vtPathName,0,NULL ); if (( hRes == WBEM_S_NO_ERROR) && (vtPathName.vt != VT_NULL) && (vtPathName.vt != VT_EMPTY)) { szPathName = ( LPWSTR ) _bstr_t(vtPathName); szSysManfact = (LPTSTR) malloc ((MAX_RES_STRING) * sizeof(TCHAR)); if (szSysManfact == NULL) { SAFEIRELEASE(pSystem); DestroyDynamicArray(&arrResults); SAFEFREE(pNumberFmt); return EXIT_FAILURE_MALLOC; } dwLength = wcslen(szPathName); GetCompatibleStringFromUnicode( szPathName, szSysManfact, dwLength+2 ); szPath = szSysManfact ; // Initialise the structure to Zero. ZeroMemory(&Current,sizeof(Current)); // convert the szHost variable (containing hostname) into LPCTSTR and pass it to the GETAPI function szHostName = (LPTSTR) malloc ((MAX_RES_STRING) * (sizeof(TCHAR))); if (szHostName == NULL) { SAFEIRELEASE(pSystem); DestroyDynamicArray(&arrResults); SAFEFREE(pNumberFmt); SAFEFREE(szSysManfact); return EXIT_FAILURE_MALLOC; } GetCompatibleStringFromUnicode( szHost, szHostName,dwLength+2 ); _tcscpy(szPrintPath,szPath); BOOL bApiInfo = GetApiInfo(szHostName,szPath,&Current, dwSystemType); if(bApiInfo == FAILURE) { DestroyDynamicArray(&arrResults); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); continue ; } } else { DestroyDynamicArray(&arrResults); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); continue ; // ignore exception } } catch(...) { // If the path is empty then ignore the present continue with next iteration DestroyDynamicArray(&arrResults); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); continue ; // ignore exception } //create a new empty row with required no of columns dwRow = DynArrayAppendRow(arrResults,MAX_COLUMNS) ; // Insert the results into the Dynamic Array DynArraySetString2( arrResults,dwRow,COL0,szSysName,0 ); DynArraySetString2( arrResults,dwRow,COL1,szValue,0 ); DynArraySetString2( arrResults,dwRow,COL2,szDispName,0 ); DynArraySetString2( arrResults,dwRow,COL3,szDescription,0 ); // strip off the word Driver from the display. dwLength = wcslen(szDriverType) ; GetCompatibleStringFromUnicode( szDriverType, szDriverTypeVal,dwLength+2 ); _tcscpy(szDelimiter,DRIVER_TAG); dwPosn1 = _tcslen(szDelimiter); dwStrlen = _tcslen(szDriverTypeVal); szDriverTypeVal[dwStrlen-dwPosn1] = _T('\0'); DynArraySetString2( arrResults,dwRow,COL4,szDriverTypeVal,0 ); DynArraySetString2( arrResults,dwRow,COL5,szStartMode,0 ); DynArraySetString2( arrResults,dwRow,COL6,szState,0 ); DynArraySetString2( arrResults,dwRow,COL7,szStatus,0 ); iLen = wcslen(szAcceptStopVal); szAcceptStop = (LPTSTR) malloc ((MAX_RES_STRING) * (sizeof(TCHAR ))); if (szAcceptStop == NULL) { SAFEIRELEASE(pSystem); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); DestroyDynamicArray(&arrResults); return EXIT_FAILURE_MALLOC; } GetCompatibleStringFromUnicode(szAcceptStopVal,szAcceptStop,iLen + 2 ); szAcceptStop[iLen] = '\0'; if (lstrcmp(szAcceptStop,_T("0"))==0) { lstrcpy(szAcceptStop,FALSE_VALUE); } else { lstrcpy(szAcceptStop,TRUE_VALUE); } DynArraySetString2( arrResults,dwRow,COL8,szAcceptStop,0 ); iLen = wcslen(szAcceptPauseVal); szAcceptPause = (LPTSTR) malloc ((MAX_RES_STRING) * (sizeof(TCHAR ))); if (szAcceptPause == NULL) { SAFEIRELEASE(pSystem); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); SAFEFREE(szAcceptStop); DestroyDynamicArray(&arrResults); return EXIT_FAILURE_MALLOC; } GetCompatibleStringFromUnicode(szAcceptPauseVal,szAcceptPause,iLen + 2 ); szAcceptPause[iLen] = '\0'; if (lstrcmp(szAcceptPause,_T("0"))==0) { lstrcpy(szAcceptPause,FALSE_VALUE); } else { lstrcpy(szAcceptPause,TRUE_VALUE); } DynArraySetString2( arrResults,dwRow,COL9,szAcceptPause,0 ); bFValue = FormatAccToLocale(pNumberFmt, &szGroupSep,&szDecimalSep,&szGroupThousSep); if (bFValue == FALSE) { SAFEIRELEASE(pSystem); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); SAFEFREE(szAcceptStop); SAFEFREE(szAcceptPause); SAFEFREE(szGroupThousSep); SAFEFREE(szDecimalSep); SAFEFREE(szGroupSep); DestroyDynamicArray(&arrResults); return EXIT_FAILURE_FORMAT ; } szPagedSize = (LPTSTR) malloc ((MAX_RES_STRING) * (sizeof(TCHAR ))); if (szPagedSize == NULL) { SAFEIRELEASE(pSystem); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); SAFEFREE(szAcceptStop); SAFEFREE(szAcceptPause); SAFEFREE(szGroupThousSep); SAFEFREE(szDecimalSep); SAFEFREE(szGroupSep); DestroyDynamicArray(&arrResults); return EXIT_FAILURE_MALLOC; } _ltow(Current.ulPagedSize, wszStrVal,10); dwLocale = GetNumberFormat(LOCALE_USER_DEFAULT,0,wszStrVal,pNumberFmt, szPagedSize,(MAX_RES_STRING + 1)); if(dwLocale == 0) { SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); SAFEFREE(szAcceptStop); SAFEFREE(szAcceptPause); SAFEFREE(szPagedSize); SAFEFREE(szGroupThousSep); SAFEFREE(szDecimalSep); SAFEFREE(szGroupSep); DestroyDynamicArray(&arrResults); return EXIT_FAILURE_FORMAT; } DynArraySetString2( arrResults,dwRow,COL10, szPagedSize,0 ); // get the CodeSize info acc to the locale szCodeSize = (LPTSTR) malloc ((MAX_RES_STRING) * (sizeof(TCHAR ))); if (szCodeSize == NULL) { SAFEIRELEASE(pSystem); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); SAFEFREE(szAcceptStop); SAFEFREE(szAcceptPause); SAFEFREE(szPagedSize); SAFEFREE(szGroupThousSep); SAFEFREE(szDecimalSep); SAFEFREE(szGroupSep); DestroyDynamicArray(&arrResults); return EXIT_FAILURE_MALLOC; } _ltow(Current.ulCodeSize, wszStrVal,10); dwLocale = GetNumberFormat(LOCALE_USER_DEFAULT,0,wszStrVal,pNumberFmt,szCodeSize,(MAX_RES_STRING + 1)); if(dwLocale == 0) { SAFEIRELEASE(pSystem); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); SAFEFREE(szAcceptStop); SAFEFREE(szAcceptPause); SAFEFREE(szCodeSize); SAFEFREE(szGroupThousSep); SAFEFREE(szDecimalSep); SAFEFREE(szGroupSep); DestroyDynamicArray(&arrResults); return EXIT_FAILURE_FORMAT ; } DynArraySetString2( arrResults,dwRow,COL11, szCodeSize,0 ); // retreive the bss info acc to the locale szBssSize = (LPTSTR) malloc ((MAX_RES_STRING) * (sizeof(TCHAR ))); if (szBssSize == NULL) { SAFEIRELEASE(pSystem); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); SAFEFREE(szAcceptStop); SAFEFREE(szAcceptPause); SAFEFREE(szCodeSize); SAFEFREE(szGroupThousSep); SAFEFREE(szDecimalSep); SAFEFREE(szGroupSep); DestroyDynamicArray(&arrResults); return EXIT_FAILURE_MALLOC ; } _ltow(Current.ulBssSize, wszStrVal,10); dwLocale = GetNumberFormat(LOCALE_USER_DEFAULT,0,wszStrVal,pNumberFmt, szBssSize,(MAX_RES_STRING + 1)); if(dwLocale == 0) { SAFEIRELEASE(pSystem); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); SAFEFREE(szAcceptStop); SAFEFREE(szAcceptPause); SAFEFREE(szCodeSize); SAFEFREE(szBssSize); SAFEFREE(szGroupThousSep); SAFEFREE(szDecimalSep); SAFEFREE(szGroupSep); DestroyDynamicArray(&arrResults); return EXIT_FAILURE_FORMAT ; } DynArraySetString2( arrResults,dwRow,COL12, szBssSize,0 ); //link date DynArraySetString2(arrResults,dwRow,COL13,(LPTSTR)(Current.szTimeDateStamp),0); //Path of the File if(szPath != NULL) { DynArraySetString2(arrResults,dwRow,COL14,(LPTSTR)szPrintPath,0); // } else { szPath= NO_DATA_AVAILABLE; DynArraySetString2(arrResults,dwRow,COL14,(LPTSTR)szPath,0); // } // get the initsize info acc to the locale szInitSize = (LPTSTR) malloc ((MAX_RES_STRING) * (sizeof(TCHAR ))); if (szInitSize == NULL) { SAFEIRELEASE(pSystem); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); SAFEFREE(szAcceptStop); SAFEFREE(szAcceptPause); SAFEFREE(szCodeSize); SAFEFREE(szBssSize); SAFEFREE(szGroupThousSep); SAFEFREE(szDecimalSep); SAFEFREE(szGroupSep); DestroyDynamicArray(&arrResults); return EXIT_FAILURE_MALLOC ; } _ltow(Current.ulInitSize, wszStrVal,10); dwLocale = GetNumberFormat(LOCALE_USER_DEFAULT,0,wszStrVal,pNumberFmt, szInitSize,(MAX_RES_STRING + 1)); if(dwLocale == 0) { SAFEIRELEASE(pSystem); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szSysManfact); SAFEFREE(szAcceptStop); SAFEFREE(szAcceptPause); SAFEFREE(szCodeSize); SAFEFREE(szBssSize);; SAFEFREE(szInitSize); SAFEFREE(szGroupThousSep); SAFEFREE(szDecimalSep); SAFEFREE(szGroupSep); DestroyDynamicArray(&arrResults); return EXIT_FAILURE_FORMAT ; } DynArraySetString2( arrResults,dwRow,COL15, szInitSize,0 ); if ( bBlankLine == TRUE && (dwFormatType & SR_FORMAT_MASK) == SR_FORMAT_LIST ) ShowMessage( stdout, _T( "\n" ) ); if ( bFirstTime == TRUE ) { ShowMessage( stdout, _T( "\n" ) ); bFirstTime = FALSE; } if(bHeader) { ShowResults(MAX_COLUMNS, ResultHeader, dwFormatType|SR_NOHEADER,arrResults ) ; } else { ShowResults(MAX_COLUMNS, ResultHeader, dwFormatType,arrResults ) ; } //set the header flag to true bHeader = TRUE ; bBlankLine = TRUE; //set the bResult to true indicating that driver information has been displyed. bResult = TRUE ; // free the allocated memory SAFEFREE(szSysManfact); SAFEFREE(pNumberFmt); SAFEFREE(szHostName); SAFEFREE(szAcceptStop); SAFEFREE(szAcceptPause); SAFEFREE(szPagedSize); SAFEFREE(szBssSize); SAFEFREE(szInitSize); SAFEFREE(szCodeSize); SAFEFREE(szGroupThousSep); SAFEFREE(szDecimalSep); SAFEFREE(szGroupSep); SAFEIRELEASE(pSystem); } // If System Succeeded // Destroy the Dynamic arrays DestroyDynamicArray(&arrResults); }// While SystemSet returning objects // return the error value or success value if (bResult == TRUE) { return SUCCESS ; } else { return EXIT_FAILURE_RESULTS ; } } // *************************************************************************** // Routine Description: // This function queries the system properties using API's . // // Arguments: // [ in ] szHostName : HostName to connect to // [ in ] pszPath : pointer to the string containing the Path of the file. // [ out] Mod : pointer to the structure containing system properties. // // Return Value: // SUCCESS : If successful in getting the information using API's. // FAILURE : If unable to get the information using API's. // *************************************************************************** BOOL GetApiInfo(LPTSTR szHostName,LPCTSTR pszPath,PMODULE_DATA Mod,DWORD dwSystemType) { HANDLE hMappedFile = NULL; PIMAGE_DOS_HEADER DosHeader; LOADED_IMAGE LoadedImage; ULONG ulSectionAlignment = 0; PIMAGE_SECTION_HEADER Section; DWORD dwI = 0; ULONG ulSize = 0; TCHAR szTmpServer[ MAX_STRING_LENGTH + 1 ] = NULL_STRING; HANDLE hFile = NULL ; PTCHAR pszToken = NULL; lstrcpy(szTmpServer,TOKEN_BACKSLASH2); TCHAR szFinalPath[MAX_STRING_LENGTH+1] =TOKEN_EMPTYSTRING ; PTCHAR pdest = NULL ; #ifndef _WIN64 BOOL bIsWin64; #endif //copy the path into a variable _tcscpy(szFinalPath,pszPath); //get the token upto the delimiter ":" pszToken = _tcstok(szFinalPath, COLON_SYMBOL ); //form the string for getting the absolute path in the required format if it is a remote system. if(_tcslen(szHostName) != 0) { pdest = _tcsstr(pszPath,COLON_SYMBOL); if(pdest== NULL) { return FAILURE ; } _tcsnset(pdest,TOKEN_DOLLAR,1); _tcscat(szTmpServer,szHostName); _tcscat(szTmpServer,TOKEN_BACKSLASH); _tcscat(szTmpServer,pszToken); _tcscat(szTmpServer,pdest); } else { _tcscpy(szTmpServer,pszPath) ; } #ifndef _WIN64 bIsWin64 = IsWin64(); if(bIsWin64) Wow64DisableFilesystemRedirector((LPCTSTR)szTmpServer); #endif // create a file on the specified system and return a handle to it. hFile = CreateFile(szTmpServer, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); //if the filehandle is invalid then return a error if(hFile == INVALID_HANDLE_VALUE) { return FAILURE ; } #ifndef _WIN64 if(bIsWin64) Wow64EnableFilesystemRedirector(); #endif // create a mapping to the specified file hMappedFile = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL); if (hMappedFile == NULL) { CloseHandle(hFile); return FAILURE ; } LoadedImage.MappedAddress = (PUCHAR)MapViewOfFile(hMappedFile, FILE_MAP_READ, 0, 0, 0); // close the opened file handles CloseHandle(hMappedFile); CloseHandle(hFile); if ( !LoadedImage.MappedAddress ) { return FAILURE ; } // check the image and find nt image headers DosHeader = (PIMAGE_DOS_HEADER)LoadedImage.MappedAddress; //exit if the DOS header does not match if ( DosHeader->e_magic != IMAGE_DOS_SIGNATURE ) { UnmapViewOfFile(LoadedImage.MappedAddress); return FAILURE ; } LoadedImage.FileHeader = (PIMAGE_NT_HEADERS)((ULONG_PTR)DosHeader + DosHeader->e_lfanew); if ( LoadedImage.FileHeader->Signature != IMAGE_NT_SIGNATURE ) { UnmapViewOfFile(LoadedImage.MappedAddress); return FAILURE ; } //get the number of sections present LoadedImage.NumberOfSections = LoadedImage.FileHeader->FileHeader.NumberOfSections; if(dwSystemType == SYSTEM_64_BIT ) { LoadedImage.Sections = (PIMAGE_SECTION_HEADER)((ULONG_PTR)LoadedImage.FileHeader + sizeof(IMAGE_NT_HEADERS64)); } else { LoadedImage.Sections = (PIMAGE_SECTION_HEADER)((ULONG_PTR)LoadedImage.FileHeader + sizeof(IMAGE_NT_HEADERS32)); } LoadedImage.LastRvaSection = LoadedImage.Sections; // Walk through the sections and tally the dater ulSectionAlignment = LoadedImage.FileHeader->OptionalHeader.SectionAlignment; for(Section = LoadedImage.Sections,dwI=0;dwI < LoadedImage.NumberOfSections; dwI++,Section++) { ulSize = Section->Misc.VirtualSize; if (ulSize == 0) { ulSize = Section->SizeOfRawData; } ulSize = (ulSize + ulSectionAlignment - 1) & ~(ulSectionAlignment - 1); if (!_strnicmp((char *)(Section->Name),EXTN_PAGE, 4 )) { Mod->ulPagedSize += ulSize; } else if (!_stricmp((char *)(Section->Name),EXTN_INIT )) { Mod->ulInitSize += ulSize; } else if(!_stricmp((char *)(Section->Name),EXTN_BSS)) { Mod->ulBssSize = ulSize; } else if (!_stricmp((char *)(Section->Name),EXTN_EDATA)) { Mod->ulExportDataSize = ulSize ; } else if (!_stricmp((char *)(Section->Name),EXTN_IDATA )) { Mod->ulImportDataSize = ulSize; } else if (!_stricmp((char *)(Section->Name),EXTN_RSRC)) { Mod->ulResourceDataSize = ulSize; } else if (Section->Characteristics & IMAGE_SCN_MEM_EXECUTE) { Mod->ulCodeSize += ulSize; } else if (Section->Characteristics & IMAGE_SCN_MEM_WRITE) { Mod->ulDataSize += ulSize; } else { Mod->ulDataSize += ulSize; } } #ifndef _WIN64 LONG lTimeVal ; #else LONG64 lTimeVal; #endif lTimeVal = LoadedImage.FileHeader->FileHeader.TimeDateStamp ; struct tm *tmVal = NULL; tmVal = localtime(&lTimeVal); // proceed furthur only if we successfully got the localtime if ( tmVal != NULL ) { LCID lcid; SYSTEMTIME systime; __STRING_64 szBuffer; BOOL bLocaleChanged = FALSE; systime.wYear = (WORD) (DWORD_PTR)( tmVal->tm_year + 1900 ); // tm -> Year - 1900 SYSTEMTIME -> Year = Year systime.wMonth = (WORD) (DWORD_PTR) tmVal->tm_mon + 1; // tm -> Jan = 0 SYSTEMTIME -> Jan = 1 systime.wDayOfWeek = (WORD) (DWORD_PTR) tmVal->tm_wday; systime.wDay = (WORD) (DWORD_PTR) tmVal->tm_mday; systime.wHour = (WORD) (DWORD_PTR) tmVal->tm_hour; systime.wMinute = (WORD) (DWORD_PTR) tmVal->tm_min; systime.wSecond = (WORD) (DWORD_PTR) tmVal->tm_sec; systime.wMilliseconds = 0; // 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), szBuffer, SIZE_OF_ARRAY( szBuffer ) ); // copy the date info lstrcpy( Mod->szTimeDateStamp, szBuffer ); // now format the date GetTimeFormat( LOCALE_USER_DEFAULT, 0, &systime, ((bLocaleChanged == TRUE) ? L"HH:mm:ss" : NULL), szBuffer, SIZE_OF_ARRAY( szBuffer ) ); // now copy time info lstrcat( Mod->szTimeDateStamp, _T( " " ) ); lstrcat( Mod->szTimeDateStamp, szBuffer ); } UnmapViewOfFile(LoadedImage.MappedAddress); return SUCCESS; } // *************************************************************************** // Routine Description: // This function parses the options specified at the command prompt // // Arguments: // [ in ] argc : count of elements in argv // [ in ] argv : command-line parameterd specified by the user // [ out ] pbShowUsage : set to TRUE if -? exists in 'argv' // [ out ] pszServer : value(s) specified with -s ( server ) option in 'argv' // [ out ] pszUserName : value of -u ( username ) option in 'argv' // [ out ] pszPassword : value of -p ( password ) option in 'argv' // [ out ] pszFormat : Display format // [ out ] bHeader : specifies whether to display a header or not. // [ in ] bNeedPassword : specifies if the password is required or not. // // Return Value: // TRUE : if the parsing is successful // FALSE : if errors occured in parsing // *************************************************************************** BOOL ProcessOptions(LONG argc,LPCTSTR argv[],PBOOL pbShowUsage,LPTSTR *pszServer,LPTSTR *pszUserName,LPTSTR *pszPassword,LPTSTR pszFormat,PBOOL pbHeader, PBOOL bNeedPassword,PBOOL pbVerbose,PBOOL pbSigned) { PTCMDPARSER pcmdOption = NULL; //pointer to the structure TCMDPARSER cmdOptions[MAX_OPTIONS] ; BOOL bval = TRUE ; LPCTSTR szToken = NULL ; // init the password if ( pszPassword != NULL && *pszPassword != NULL ) { lstrcpy( *pszPassword, _T( "*" ) ); } // help option pcmdOption = &cmdOptions[OI_HELP] ; pcmdOption->dwCount = 1 ; pcmdOption->dwActuals = 0; pcmdOption->dwFlags = CP_USAGE ; pcmdOption->pValue = pbShowUsage ; pcmdOption->pFunction = NULL ; pcmdOption->pFunctionData = NULL ; lstrcpy(pcmdOption->szValues,NULL_STRING); lstrcpy(pcmdOption->szOption,OPTION_HELP); // _T("?") //server name option pcmdOption = &cmdOptions[OI_SERVER] ; pcmdOption->dwCount = 1 ; pcmdOption->dwActuals = 0; pcmdOption->dwFlags = CP_TYPE_TEXT|CP_VALUE_MANDATORY ; pcmdOption->pValue = *pszServer ; pcmdOption->pFunction = NULL ; pcmdOption->pFunctionData = NULL ; lstrcpy(pcmdOption->szValues,NULL_STRING); lstrcpy(pcmdOption->szOption,OPTION_SERVER); // _T("s") //domain\user option pcmdOption = &cmdOptions[OI_USERNAME] ; pcmdOption->dwCount = 1 ; pcmdOption->dwActuals = 0; pcmdOption->dwFlags = CP_TYPE_TEXT|CP_VALUE_MANDATORY ; pcmdOption->pValue = *pszUserName ; pcmdOption->pFunction = NULL ; pcmdOption->pFunctionData = NULL ; lstrcpy(pcmdOption->szValues,NULL_STRING); lstrcpy(pcmdOption->szOption,OPTION_USERNAME); // _T("u") //password option pcmdOption = &cmdOptions[OI_PASSWORD] ; pcmdOption->dwCount = 1 ; pcmdOption->dwActuals = 0; pcmdOption->dwFlags = CP_TYPE_TEXT|CP_VALUE_OPTIONAL; pcmdOption->pValue = *pszPassword ; pcmdOption->pFunction = NULL ; pcmdOption->pFunctionData = NULL ; lstrcpy(pcmdOption->szValues,NULL_STRING); lstrcpy(pcmdOption->szOption,OPTION_PASSWORD); // _T("p") //format option. pcmdOption = &cmdOptions[OI_FORMAT] ; pcmdOption->dwCount = 1 ; pcmdOption->dwActuals = 0; pcmdOption->dwFlags = CP_TYPE_TEXT|CP_VALUE_MANDATORY|CP_MODE_VALUES ; pcmdOption->pValue = pszFormat ; pcmdOption->pFunction = NULL ; pcmdOption->pFunctionData = NULL ; lstrcpy(pcmdOption->szValues,FORMAT_VALUES); lstrcpy(pcmdOption->szOption,OPTION_FORMAT); // _T("fo") //no header option pcmdOption = &cmdOptions[OI_HEADER] ; pcmdOption->dwCount = 1 ; pcmdOption->dwActuals = 0; pcmdOption->dwFlags = 0; pcmdOption->pValue = pbHeader; pcmdOption->pFunction = NULL ; pcmdOption->pFunctionData = NULL ; lstrcpy(pcmdOption->szValues,NULL_STRING); lstrcpy(pcmdOption->szOption,OPTION_HEADER); // _T("nh") //verbose option.. pcmdOption = &cmdOptions[OI_VERBOSE] ; pcmdOption->dwCount = 1 ; pcmdOption->dwActuals = 0; pcmdOption->dwFlags = 0 ; pcmdOption->pValue = pbVerbose; pcmdOption->pFunction = NULL ; pcmdOption->pFunctionData = NULL ; lstrcpy(pcmdOption->szValues,NULL_STRING); lstrcpy(pcmdOption->szOption,OPTION_VERBOSE); // _T("v") pcmdOption = &cmdOptions[OI_SIGNED] ; pcmdOption->dwCount = 1 ; pcmdOption->dwActuals = 0; pcmdOption->dwFlags = 0 ; pcmdOption->pValue = pbSigned; pcmdOption->pFunction = NULL ; pcmdOption->pFunctionData = NULL ; lstrcpy(pcmdOption->szValues,NULL_STRING); lstrcpy(pcmdOption->szOption,OPTION_SIGNED); // _T("di") bval = DoParseParam(argc,argv,MAX_OPTIONS,cmdOptions) ; if( bval== FALSE) { DISPLAY_MESSAGE(stderr,ERROR_TAG); return FALSE ; } if((*pbShowUsage == TRUE)&&(argc > 2)) { SetReason(ERROR_SYNTAX); return FALSE ; } // checking if -u is specified when -s options is not specified and display error msg . if ((cmdOptions[OI_SERVER].dwActuals == 0) && (cmdOptions[OI_USERNAME].dwActuals !=0 )) { SetReason(ERROR_USERNAME_BUT_NOMACHINE); return FALSE ; } // checking if -u is specified when -p options is not specified and display error msg . if ((cmdOptions[OI_USERNAME].dwActuals == 0) && (cmdOptions[OI_PASSWORD].dwActuals !=0 )) { SetReason(ERROR_PASSWORD_BUT_NOUSERNAME); return FALSE ; } // checking if -p is specified when -u options is not specified and display error msg . if ((cmdOptions[OI_SERVER].dwActuals != 0) && (lstrlen(*pszServer)==0 )) { SetReason(ERROR_INVALID_SERVER); return FALSE ; } // checking if -p is specified when -u options is not specified and display error msg . if ((cmdOptions[OI_USERNAME].dwActuals != 0) && (lstrlen(*pszUserName)==0 )) { SetReason(ERROR_INVALID_USER); return FALSE ; } if((cmdOptions[OI_FORMAT].dwActuals != 0)&&(lstrcmpi((LPCTSTR)cmdOptions[OI_FORMAT].pValue,LIST_FORMAT) == 0)&&(cmdOptions[OI_HEADER].dwActuals != 0)) { SetReason(ERROR_NO_HEADERS); return FALSE ; } if((cmdOptions[OI_SIGNED].dwActuals != 0)&&(cmdOptions[OI_VERBOSE].dwActuals != 0)) { SetReason(INVALID_SIGNED_SYNTAX); return FALSE ; } if(StrCmpN(*pszServer,TOKEN_BACKSLASH2,2)==0) { if(!StrCmpN(*pszServer,TOKEN_BACKSLASH3,3)==0) { szToken = _tcstok(*pszServer,TOKEN_BACKSLASH2); lstrcpy(*pszServer,szToken); } } if(IsLocalSystem( *pszServer ) == FALSE ) { // set the bNeedPassword to True or False . if ( cmdOptions[ OI_PASSWORD ].dwActuals != 0 && pszPassword != NULL && *pszPassword != NULL && lstrcmp( *pszPassword, _T( "*" ) ) == 0 ) { // user wants the utility to prompt for the password before trying to connect *bNeedPassword = TRUE; } else if ( cmdOptions[ OI_PASSWORD ].dwActuals == 0 && ( cmdOptions[ OI_SERVER ].dwActuals != 0 || cmdOptions[ OI_USERNAME ].dwActuals != 0 ) ) { // -s, -u is specified without password ... // utility needs to try to connect first and if it fails then prompt for the password *bNeedPassword = TRUE; if ( pszPassword != NULL && *pszPassword != NULL ) { lstrcpy( *pszPassword, _T( "" ) ); } } } return TRUE ; } // *************************************************************************** // Routine Description: // This function is used to build the header and also display the // result in the required format as specified by the user. // // Arguments: // [ in ] arrResults : argument(s) count specified at the command prompt // [ in ] dwFormatType : format flags // [ in ] bHeader : Boolean for specifying if the header is required or not. // // Return Value: // none // // *************************************************************************** VOID FormHeader(DWORD dwFormatType,BOOL bHeader,TCOLUMNS *ResultHeader,BOOL bVerbose) { // host name ResultHeader[COL0].dwWidth = COL_HOSTNAME_WIDTH; ResultHeader[COL0].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN; ResultHeader[COL0].pFunction = NULL; ResultHeader[COL0].pFunctionData = NULL; lstrcpy( ResultHeader[COL0].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL0].szColumn,COL_HOSTNAME ); //File Name header ResultHeader[COL1].dwWidth = COL_FILENAME_WIDTH ; ResultHeader[COL1].dwFlags = SR_TYPE_STRING; ResultHeader[COL1].pFunction = NULL; ResultHeader[COL1].pFunctionData = NULL; lstrcpy( ResultHeader[COL1].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL1].szColumn,COL_FILENAME ); // Forming the DisplayName header Column ResultHeader[COL2].dwWidth = COL_DISPLAYNAME_WIDTH ; ResultHeader[COL2].dwFlags = SR_TYPE_STRING; ResultHeader[COL2].pFunction = NULL; ResultHeader[COL2].pFunctionData = NULL; lstrcpy( ResultHeader[COL2].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL2].szColumn,COL_DISPLAYNAME ); // Forming the Description header Column ResultHeader[COL3].dwWidth = COL_DESCRIPTION_WIDTH; if(!bVerbose) { ResultHeader[COL3].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN; } else { ResultHeader[COL3].dwFlags = SR_TYPE_STRING; } ResultHeader[COL3].pFunction = NULL; ResultHeader[COL3].pFunctionData = NULL; lstrcpy( ResultHeader[COL3].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL3].szColumn,COL_DESCRIPTION ); // Forming the Drivertype header Column ResultHeader[COL4].dwWidth = COL_DRIVERTYPE_WIDTH ; ResultHeader[COL4].dwFlags = SR_TYPE_STRING; ResultHeader[COL4].pFunction = NULL; ResultHeader[COL4].pFunctionData = NULL; lstrcpy( ResultHeader[COL4].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL4].szColumn,COL_DRIVERTYPE ); // Forming the StartMode header Column ResultHeader[COL5].dwWidth = COL_STARTMODE_WIDTH; if(!bVerbose) { ResultHeader[COL5].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN; } else { ResultHeader[COL5].dwFlags = SR_TYPE_STRING; } ResultHeader[COL5].pFunction = NULL; ResultHeader[COL5].pFunctionData = NULL; lstrcpy( ResultHeader[COL5].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL5].szColumn,COL_STARTMODE ); // Forming the State header Column ResultHeader[COL6].dwWidth = COL_STATE_WIDTH ; if(!bVerbose) { ResultHeader[COL6].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN; } else { ResultHeader[COL6].dwFlags = SR_TYPE_STRING; } ResultHeader[COL6].pFunction = NULL; ResultHeader[COL6].pFunctionData = NULL; lstrcpy( ResultHeader[COL6].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL6].szColumn,COL_STATE ); // Forming the Status header Column ResultHeader[COL7].dwWidth = COL_STATUS_WIDTH; if(!bVerbose) { ResultHeader[COL7].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN; } else { ResultHeader[COL7].dwFlags = SR_TYPE_STRING; } ResultHeader[COL7].pFunction = NULL; ResultHeader[COL7].pFunctionData = NULL; lstrcpy( ResultHeader[COL7].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL7].szColumn,COL_STATUS ); // Forming the AcceptStop header Column ResultHeader[COL8].dwWidth = COL_ACCEPTSTOP_WIDTH ; if(!bVerbose) { ResultHeader[COL8].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN; } else { ResultHeader[COL8].dwFlags = SR_TYPE_STRING; } ResultHeader[COL8].pFunction = NULL; ResultHeader[COL8].pFunctionData = NULL; lstrcpy( ResultHeader[COL8].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL8].szColumn,COL_ACCEPTSTOP ); // Forming the AcceptPause header Column ResultHeader[COL9].dwWidth = COL_ACCEPTPAUSE_WIDTH; if(!bVerbose) { ResultHeader[COL9].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN; } else { ResultHeader[COL9].dwFlags = SR_TYPE_STRING; } ResultHeader[COL9].pFunction = NULL; ResultHeader[COL9].pFunctionData = NULL; lstrcpy( ResultHeader[COL9].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL9].szColumn,COL_ACCEPTPAUSE ); // Forming the PagedPool header Column ResultHeader[COL10].dwWidth = COL_PAGEDPOOL_WIDTH ; if(!bVerbose) { ResultHeader[COL10].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN ; } else { ResultHeader[COL10].dwFlags = SR_TYPE_STRING; } ResultHeader[COL10].pFunction = NULL; ResultHeader[COL10].pFunctionData = NULL; lstrcpy( ResultHeader[COL10].szFormat, NULL_STRING ); lstrcpy(ResultHeader[COL10].szColumn,COL_PAGEDPOOL) ; // Forming the Executable Code header Column ResultHeader[COL11].dwWidth = COL_EXECCODE_WIDTH ; if(!bVerbose) { ResultHeader[COL11].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN ; } else { ResultHeader[COL11].dwFlags = SR_TYPE_STRING; } ResultHeader[COL11].pFunction = NULL; ResultHeader[COL11].pFunctionData = NULL; lstrcpy( ResultHeader[COL11].szFormat, NULL_STRING ); lstrcpy(ResultHeader[COL11].szColumn ,COL_EXECCODE) ; // Forming the BlockStorage Segment header Column ResultHeader[COL12].dwWidth = COL_BSS_WIDTH ; if(!bVerbose) { ResultHeader[COL12].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN; } else { ResultHeader[COL12].dwFlags = SR_TYPE_STRING ; } ResultHeader[COL12].pFunction = NULL; ResultHeader[COL12].pFunctionData = NULL; lstrcpy( ResultHeader[COL12].szFormat, NULL_STRING ); lstrcpy(ResultHeader[COL12].szColumn ,COL_BSS ); // Forming the LinkDate header Column ResultHeader[COL13].dwWidth = COL_LINKDATE_WIDTH; ResultHeader[COL13].dwFlags = SR_TYPE_STRING; ResultHeader[COL13].pFunction = NULL; ResultHeader[COL13].pFunctionData = NULL; lstrcpy( ResultHeader[COL13].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL13].szColumn,COL_LINKDATE ); // Forming the Location header Column ResultHeader[COL14].dwWidth = COL_LOCATION_WIDTH ; if(!bVerbose) { ResultHeader[COL14].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN; } else { ResultHeader[COL14].dwFlags = SR_TYPE_STRING; } ResultHeader[COL14].pFunction = NULL; ResultHeader[COL14].pFunctionData = NULL; _tcscpy( ResultHeader[COL14].szFormat, NULL_STRING ); _tcscpy(ResultHeader[COL14].szColumn,COL_LOCATION); // Forming the Init Code header Column ResultHeader[COL15].dwWidth = COL_INITSIZE_WIDTH ; if(!bVerbose) { ResultHeader[COL15].dwFlags = SR_TYPE_STRING|SR_HIDECOLUMN; } else { ResultHeader[COL15].dwFlags = SR_TYPE_STRING; } ResultHeader[COL15].pFunction = NULL; ResultHeader[COL15].pFunctionData = NULL; _tcscpy( ResultHeader[COL15].szFormat, NULL_STRING ); _tcscpy(ResultHeader[COL15].szColumn,COL_INITSIZE); } #ifndef _WIN64 /*-------------------------------------------------------------------------* // IsWin64 // // Arguments : // none // Returns true if we're running on Win64, false otherwise. *--------------------------------------------------------------------------*/ BOOL IsWin64(void) { #ifdef UNICODE // get a pointer to kernel32!GetSystemWow64Directory HMODULE hmod = GetModuleHandle (_T("kernel32.dll")); if (hmod == NULL) return (FALSE); UINT (WINAPI* pfnGetSystemWow64Directory)(LPTSTR, UINT); (FARPROC&)pfnGetSystemWow64Directory = GetProcAddress (hmod, "GetSystemWow64DirectoryW"); if (pfnGetSystemWow64Directory == NULL) return (FALSE); /* * if GetSystemWow64Directory fails and sets the last error to * ERROR_CALL_NOT_IMPLEMENTED, we're on a 32-bit OS */ TCHAR szWow64Dir[MAX_PATH]; if (((pfnGetSystemWow64Directory)(szWow64Dir, countof(szWow64Dir)) == 0) && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) { return (FALSE); } // we're on Win64 return (TRUE); #else // non-Unicode platforms cannot be Win64 return (FALSE); #endif // UNICODE } #endif // _WIN64 /*------------------------------------------------------------------- Routine Description: Formats the Number to the locale with thousands position Arguments: NUMBERFMT *pNumberFmt[in] - NUMBERFMT Structure to be filled with . Return Value: VOID --------------------------------------------------------------------*/ BOOL FormatAccToLocale( NUMBERFMT *pNumberFmt,LPTSTR* pszGroupSep,LPTSTR* pszDecimalSep,LPTSTR* pszGroupThousSep) { TCHAR szFormatedString[MAX_RES_STRING + 1] = NULL_STRING; HRESULT hResult = 0; DWORD dwLocale = 0; if( GetInfo( LOCALE_SGROUPING, pszGroupSep ) == FALSE) { pNumberFmt = NULL; return FALSE ; } if( GetInfo( LOCALE_SDECIMAL, pszDecimalSep ) == FALSE) { pNumberFmt = NULL; return FALSE ; } if( GetInfo( LOCALE_STHOUSAND, pszGroupThousSep ) == FALSE) { pNumberFmt = NULL; return FALSE ; } if(pNumberFmt != NULL) { pNumberFmt->LeadingZero = 0; pNumberFmt->NegativeOrder = 0; pNumberFmt->NumDigits = 0; if(lstrcmp(*pszGroupSep, GROUP_FORMAT_32) == 0) { pNumberFmt->Grouping = GROUP_32_VALUE; } else { pNumberFmt->Grouping = UINT( _ttoi( *pszGroupSep ) ); } pNumberFmt->lpDecimalSep = *pszDecimalSep; pNumberFmt->lpThousandSep = *pszGroupThousSep; } return TRUE ; } /*------------------------------------------------------------------- // //Routine Description: // //Gets the Locale information // //Arguments: // // LCTYPE lctype [in] -- Locale Information to get // LPTSTR* pszData [out] -- Locale value corresponding to the given // information // // Return Value: // BOOL //--------------------------------------------------------------------*/ BOOL GetInfo( LCTYPE lctype, LPTSTR* pszData ) { LONG lSize = 0; // get the locale specific info lSize = GetLocaleInfo( LOCALE_USER_DEFAULT, lctype, NULL, 0 ); if ( lSize != 0 ) { *pszData = (LPTSTR)malloc((lSize + 1)*sizeof(TCHAR)); if ( *pszData != NULL ) { // get the locale specific time seperator GetLocaleInfo( LOCALE_USER_DEFAULT, lctype, *pszData, lSize ); return TRUE; } } return FALSE; }//end of GetInfo /*------------------------------------------------------------------- // //Routine Description: // //Gets the type os the specified System ( 32 bit or 64 bit) // //Arguments: // // IWbemLocator *pLocator[in] -- Pointer to the locator interface. // _bstr_t bstrServer[in] -- Server Name // _bstr_t bstrUserName[in] -- User Name // _bstr_t bstrPassword [in] -- Password // information // // Return Value: // DWORD : SYSTEM_32_BIT -- If the system is 32 bit system. // SYSTEM_64_BIT -- If the system is 32 bit system. // ERROR_WMI_VALUES -- If error occured while retreiving values from WMI. //--------------------------------------------------------------------*/ DWORD GetSystemType(COAUTHIDENTITY* pAuthIdentity,IWbemServices* pIWbemServReg) { IWbemClassObject * pInClass = NULL; IWbemClassObject * pClass = NULL; IWbemClassObject * pOutInst = NULL; IWbemClassObject * pInInst = NULL; VARIANT varConnectName; VARIANT varSvalue ; VARIANT varHkey; VARIANT varVaue ; VARIANT varRetVal ; HRESULT hRes = S_OK; LPTSTR szSysName = NULL ; CHString szSystemName ; DWORD dwSysType = 0 ; VariantInit(&varConnectName) ; VariantInit(&varSvalue) ; VariantInit(&varHkey) ; VariantInit(&varVaue) ; VariantInit(&varRetVal) ; try { hRes = pIWbemServReg->GetObject(bstr_t(STD_REG_CLASS), 0, NULL, &pClass, NULL); ONFAILTHROWERROR(hRes); if(hRes != WBEM_S_NO_ERROR) { hRes = FreeMemory(pInClass,pClass,pOutInst,pInInst,pIWbemServReg,varConnectName,varSvalue,varHkey,varRetVal,varVaue,szSysName ); return (ERROR_WMI_VALUES); } // Get the input argument and set the property hRes = pClass->GetMethod(_bstr_t(PROPERTY_GETSTRINGVAL), 0, &pInClass, NULL); ONFAILTHROWERROR(hRes); if(hRes != WBEM_S_NO_ERROR) { FreeMemory(pInClass,pClass,pOutInst,pInInst,pIWbemServReg,varConnectName,varSvalue,varHkey,varRetVal,varVaue,szSysName ); return (ERROR_WMI_VALUES); } hRes = pInClass->SpawnInstance(0, &pInInst); ONFAILTHROWERROR(hRes); if(hRes != WBEM_S_NO_ERROR) { FreeMemory(pInClass,pClass,pOutInst,pInInst,pIWbemServReg,varConnectName,varSvalue,varHkey,varRetVal,varVaue,szSysName ); return (ERROR_WMI_VALUES); } //the registry path to get the connection name varConnectName.vt = VT_BSTR; varConnectName.bstrVal= SysAllocString(REG_PATH); hRes = pInInst->Put(REG_SUB_KEY_VALUE, 0, &varConnectName, 0); ONFAILTHROWERROR(hRes); //set the svalue name varSvalue.vt = VT_BSTR; varSvalue.bstrVal= SysAllocString(REG_SVALUE); hRes = pInInst->Put(REG_VALUE_NAME, 0, &varSvalue, 0); ONFAILTHROWERROR(hRes); varHkey.vt = VT_I4 ; varHkey.lVal = HEF_KEY_VALUE; hRes = pInInst->Put(HKEY_VALUE, 0, &varHkey, 0); ONFAILTHROWERROR(hRes); // Call the method hRes = pIWbemServReg->ExecMethod(_bstr_t(STD_REG_CLASS), _bstr_t(REG_METHOD), 0, NULL, pInInst, &pOutInst, NULL); ONFAILTHROWERROR(hRes); if(pOutInst == NULL) { FreeMemory(pInClass,pClass,pOutInst,pInInst,pIWbemServReg,varConnectName,varSvalue,varHkey,varRetVal,varVaue,szSysName ); return (ERROR_WMI_VALUES); } hRes = pOutInst->Get(PROPERTY_RETURNVAL,0,&varRetVal,NULL,NULL); ONFAILTHROWERROR(hRes); if(varRetVal.lVal != 0) { FreeMemory(pInClass,pClass,pOutInst,pInInst,pIWbemServReg,varConnectName,varSvalue,varHkey,varRetVal,varVaue,szSysName ); return (ERROR_WMI_VALUES); } hRes = pOutInst->Get(REG_RETURN_VALUE,0,&varVaue,NULL,NULL); ONFAILTHROWERROR(hRes); if(hRes != WBEM_S_NO_ERROR) { FreeMemory(pInClass,pClass,pOutInst,pInInst,pIWbemServReg,varConnectName,varSvalue,varHkey,varRetVal,varVaue,szSysName ); return (ERROR_WMI_VALUES); } } catch(_com_error) { DISPLAY_MESSAGE(stderr,ERROR_GET_VALUE); FreeMemory(pInClass,pClass,pOutInst,pInInst,pIWbemServReg,varConnectName,varSvalue,varHkey,varRetVal,varVaue,szSysName ); return (ERROR_WMI_VALUES); } szSystemName = V_BSTR(&varVaue); szSysName = (LPTSTR)malloc((MAX_RES_STRING)*sizeof(TCHAR)); if(szSysName == NULL) { FreeMemory(pInClass,pClass,pOutInst,pInInst,pIWbemServReg,varConnectName,varSvalue,varHkey,varRetVal,varVaue,szSysName ); return (ERROR_WMI_VALUES); } GetCompatibleStringFromUnicode( szSystemName, szSysName, wcslen( szSystemName )+2 ); dwSysType = _tcsstr(szSysName,X86_MACHINE) ? SYSTEM_32_BIT:SYSTEM_64_BIT ; FreeMemory(pInClass,pClass,pOutInst,pInInst,pIWbemServReg,varConnectName,varSvalue,varHkey,varRetVal,varVaue,szSysName ); return (dwSysType); } /*------------------------------------------------------------------- // //Routine Description: // //Gets the type os the specified System ( 32 bit or 64 bit) // //Arguments: // // IWbemLocator** pLocator[in] -- Pointer to the locator interface. // // // // information // // Return Value: // BOOL : TRUE on Successfully initialising COM. // FALSE on Failure to initialise COM. // // // //--------------------------------------------------------------------*/ BOOL InitialiseCom(IWbemLocator** ppIWbemLocator) { HRESULT hRes = S_OK ; try { // To initialize the COM library. hRes = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED ); ONFAILTHROWERROR(hRes); // Initialize COM security for DCOM services, Adjust security to // allow client impersonation hRes = CoInitializeSecurity( NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_NONE, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, 0 ); ONFAILTHROWERROR(hRes); // get a pointer to the Interface IWbemLocator hRes = CoCreateInstance(CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *) ppIWbemLocator); ONFAILTHROWERROR(hRes); } catch(_com_error& e ) { GetWbemErrorText( e.Error() ); DISPLAY_MESSAGE( stderr, ERROR_TAG ); DISPLAY_MESSAGE( stderr, GetReason() ); return( FALSE ); } // if successfully initialised COM then return true return TRUE ; } /*------------------------------------------------------------------- // //Routine Description: // // To perform the Get . // //Arguments: // // IWbemClassObject** pWmiObject[in] -- Pointer to the locator interface. // LPCTSTR pszInputVal[in] -- Input string containing the desired value. // CHString szOutPutVal[out]-- String containing the retreived value. // // information // // Return Value: // BOOL : TRUE on Successfully initialising COM. // FALSE on Failure to initialise COM. // // // //--------------------------------------------------------------------*/ HRESULT PropertyGet(IWbemClassObject* pWmiObject,LPCTSTR pszInputVal,CHString &szOutPutVal) { HRESULT hRes = S_FALSE ; VARIANT vtValue ; VariantInit(&vtValue); hRes = pWmiObject->Get(pszInputVal,0,&vtValue,NULL,NULL); if (hRes != WBEM_S_NO_ERROR) { hRes = VariantClear(&vtValue); return (hRes); } if ((hRes == WBEM_S_NO_ERROR)&&(vtValue.vt != VT_NULL) && (vtValue.vt != VT_EMPTY)) { szOutPutVal = (LPCWSTR)_bstr_t(vtValue); } hRes = VariantClear(&vtValue); if(hRes != S_OK) { return hRes ; } return TRUE ; } // *************************************************************************** // Routine Description: // This function frees the memory allocated in the function. // // Arguments: // IWbemClassObject *pInClass - Interface ptr pointing to the IWbemClassObject interface // IWbemClassObject * pClass - Interface ptr pointing to the IWbemClassObject interface // IWbemClassObject * pOutInst - Interface ptr pointing to the IWbemClassObject interface // IWbemClassObject * pInInst - Interface ptr pointing to the IWbemClassObject interface // IWbemServices *pIWbemServReg - Interface ptr pointing to the IWbemServices interface // VARIANT varConnectName - variant // VARIANT varSvalue - variant // VARIANT varHkey - variant // VARIANT varRetVal - variant // VARIANT varVaue - variant // LPTSTR szSysName - LPTSTR varaible containing the system name. // Return Value: // None // *************************************************************************** HRESULT FreeMemory(IWbemClassObject *pInClass,IWbemClassObject * pClass,IWbemClassObject * pOutInst , IWbemClassObject * pInInst,IWbemServices *pIWbemServReg,VARIANT varConnectName,VARIANT varSvalue,VARIANT varHkey,VARIANT varRetVal,VARIANT varVaue,LPTSTR szSysName ) { HRESULT hRes = S_OK ; SAFEIRELEASE(pInInst); SAFEIRELEASE(pInClass); SAFEIRELEASE(pClass); SAFEIRELEASE(pIWbemServReg); SAFEFREE(szSysName); hRes = VariantClear(&varConnectName); if(hRes != S_OK) { return hRes ; } hRes = VariantClear(&varSvalue); if(hRes != S_OK) { return hRes ; } hRes = VariantClear(&varHkey); if(hRes != S_OK) { return hRes ; } hRes = VariantClear(&varVaue); if(hRes != S_OK) { return hRes ; } hRes = VariantClear(&varRetVal); if(hRes != S_OK) { return hRes ; } return S_OK ; } // *************************************************************************** // Routine Description: // Processes enumeration of Win32_PnpSignedDriver instances // // Arguments: // [ in ] szHost : HostName to connect to // [ in ] pSystemSet : pointer to the structure containing system properties. // [ in ] szFormat : specifies the format // [ in ] bHeader : specifies if the header is required or not. // // Return Value: // 0 no error // 1 error occured while allocating memory. // // *************************************************************************** DWORD ProcessSignedDriverInfo(CHString szHost, IEnumWbemClassObject *pSystemSet,LPTSTR szFormat,BOOL bHeader,DWORD dwSystemType,BOOL bVerbose) { HRESULT hRes = S_OK; ULONG ulReturned = 1; //declaration of normal variables IWbemClassObject *pSystem = NULL; CHString szPnpDeviceName ; CHString szPnpInfName ; CHString szPnpMfg ; CHString szSigned ; BOOL bIsSigned = FALSE; TCOLUMNS ResultHeader[ MAX_COLUMNS ]; TARRAY arrResults = NULL; DWORD dwRow = 0; DWORD dwFormatType = SR_FORMAT_TABLE ; BOOL bVersion = FALSE ; // Create new Dynamic Array to hold the result arrResults = CreateDynamicArray(); if(arrResults == NULL) { return EXIT_FAILURE_MALLOC ; } if( StringCompare(szFormat,TABLE_FORMAT, TRUE,sizeof(TABLE_FORMAT)) == 0 ) { dwFormatType = SR_FORMAT_TABLE; } else if( StringCompare(szFormat,LIST_FORMAT, TRUE,sizeof(LIST_FORMAT)) == 0 ) { dwFormatType = SR_FORMAT_LIST; } else if( StringCompare(szFormat,CSV_FORMAT, TRUE,sizeof(CSV_FORMAT)) == 0 ) { dwFormatType = SR_FORMAT_CSV; } FormSignedHeader(dwFormatType,bHeader,ResultHeader); // loop till there are results. while ( ulReturned == 1 ) { szPnpDeviceName = NO_DATA_AVAILABLE; szPnpInfName = NO_DATA_AVAILABLE; szSigned = NO_DATA_AVAILABLE ; szPnpMfg = NO_DATA_AVAILABLE ; // Enumerate through the resultset. hRes = pSystemSet->Next(WBEM_INFINITE, 1, // return just one system &pSystem, // pointer to system &ulReturned ); // number obtained: one or zero if ( SUCCEEDED( hRes ) && (ulReturned == 1) ) { // initialise the variant variables to empty //create a new empty row with required no of columns dwRow = DynArrayAppendRow(arrResults,MAX_COLUMNS) ; try { hRes = PropertyGet(pSystem,PROPERTY_PNP_DEVICENAME,szPnpDeviceName); ONFAILTHROWERROR(hRes); hRes = PropertyGet(pSystem,PROPERTY_PNP_INFNAME,szPnpInfName); ONFAILTHROWERROR(hRes); hRes = PropertyGet_Bool(pSystem,PROPERTY_PNP_ISSIGNED,&bIsSigned); ONFAILTHROWERROR(hRes); hRes = PropertyGet(pSystem,PROPERTY_PNP_MFG,szPnpMfg); ONFAILTHROWERROR(hRes); } catch(_com_error) { DISPLAY_MESSAGE(stderr,ERROR_GET_VALUE); SAFEIRELEASE(pSystem); return FAILURE; } // free the allocated memory SAFEIRELEASE(pSystem); if(bIsSigned) szSigned = TRUE_VALUE; else szSigned = FALSE_VALUE; DynArraySetString2( arrResults,dwRow,COL0,szPnpDeviceName,0 ); DynArraySetString2( arrResults,dwRow,COL1,szPnpInfName,0 ); DynArraySetString2( arrResults,dwRow,COL2,szSigned,0 ); DynArraySetString2( arrResults,dwRow,COL3,szPnpMfg,0 ); //this flag is to check if there are any results //else display an error message. bVersion = TRUE ; } // If System Succeeded }// While SystemSet returning objects if (bVersion == FALSE) { // // To display custom message in case the remote system is Win2k // System. if( hRes == -2147217392) { DISPLAY_MESSAGE(stderr,GetResString(IDS_VERSION_MISMATCH_ERROR)); DestroyDynamicArray(&arrResults); // free the allocated memory SAFEIRELEASE(pSystem); return FAILURE ; } //display a error message GetWbemErrorText(hRes); DISPLAY_MESSAGE(stderr,ERROR_TAG); DISPLAY_MESSAGE(stderr,GetReason()); SAFEIRELEASE(pSystem); return FAILURE; } ShowMessage( stdout, _T( "\n" ) ); if(bHeader) { ShowResults(MAX_SIGNED_COLUMNS, ResultHeader, dwFormatType|SR_NOHEADER,arrResults ) ; } else { ShowResults(MAX_SIGNED_COLUMNS, ResultHeader, dwFormatType,arrResults ) ; } DestroyDynamicArray(&arrResults); // free the allocated memory SAFEIRELEASE(pSystem); return SUCCESS ; } /*------------------------------------------------------------------- // //Routine Description: // // To perform the Get . // //Arguments: // // IWbemClassObject** pWmiObject[in] -- Pointer to the locator interface. // LPCTSTR pszInputVal[in] -- Input string containing the desired value. // PBOOL pIsSigned[out]-- String containing the retreived value. // // information // // Return Value: // HRESULT : hRes on Successfully retreiving the value. // S_FALSE on Failure in retreiving the value. // // // //--------------------------------------------------------------------*/ HRESULT PropertyGet_Bool(IWbemClassObject* pWmiObject, LPCTSTR pszInputVal, PBOOL pIsSigned) { HRESULT hRes = S_FALSE ; VARIANT vtValue ; VariantInit(&vtValue); hRes = pWmiObject->Get(pszInputVal,0,&vtValue,NULL,NULL); if (hRes != WBEM_S_NO_ERROR) { hRes = VariantClear(&vtValue); return (hRes); } if ((hRes == WBEM_S_NO_ERROR)&&(vtValue.vt != VT_NULL) && (vtValue.vt != VT_EMPTY)) { if(vtValue.vt == VT_BOOL) if(vtValue.boolVal == -1) *pIsSigned = 1; else *pIsSigned = 0; hRes = VariantClear(&vtValue); if(hRes != S_OK) { return hRes ; } return TRUE ; } hRes = VariantClear(&vtValue); return S_FALSE ; } // *************************************************************************** // Routine Description: // This function is used to build the header and also display the // result in the required format as specified by the user. // // Arguments: // [ in ] arrResults : argument(s) count specified at the command prompt // [ in ] dwFormatType : format flags // [ in ] bHeader : Boolean for specifying if the header is required or not. // // Return Value: // none // // *************************************************************************** VOID FormSignedHeader(DWORD dwFormatType,BOOL bHeader,TCOLUMNS *ResultHeader) { // Device name ResultHeader[COL0].dwWidth = COL_DEVICE_WIDTH ; ResultHeader[COL0].dwFlags = SR_TYPE_STRING; ResultHeader[COL0].pFunction = NULL; ResultHeader[COL0].pFunctionData = NULL; lstrcpy( ResultHeader[COL0].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL0].szColumn,COL_DEVICENAME ); //Inf header ResultHeader[COL1].dwWidth = COL_INF_WIDTH ; ResultHeader[COL1].dwFlags = SR_TYPE_STRING; ResultHeader[COL1].pFunction = NULL; ResultHeader[COL1].pFunctionData = NULL; lstrcpy( ResultHeader[COL1].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL1].szColumn,COL_INF_NAME ); // Forming the IsSigned header Column ResultHeader[COL2].dwWidth = COL_ISSIGNED_WIDTH ; ResultHeader[COL2].dwFlags = SR_TYPE_STRING; ResultHeader[COL2].pFunction = NULL; ResultHeader[COL2].pFunctionData = NULL; lstrcpy( ResultHeader[COL2].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL2].szColumn,COL_ISSIGNED ); // Forming the Manufacturer header Column ResultHeader[COL3].dwWidth = COL_MANUFACTURER_WIDTH ; ResultHeader[COL3].dwFlags = SR_TYPE_STRING; ResultHeader[COL3].pFunction = NULL; ResultHeader[COL3].pFunctionData = NULL; lstrcpy( ResultHeader[COL3].szFormat, NULL_STRING ); lstrcpy( ResultHeader[COL3].szColumn,COL_MANUFACTURER); } // *************************************************************************** // Routine Description: This function checks if the current locale is supported or not. // // Arguments: [input] 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; }