/*************************************************************************** Copyright information : Copyright (c) 1998-2002 Microsoft Corporation File Name : WMICommandLine.cpp Project Name : WMI Command Line Author Name : Ch. Sriramachandramurthy Date of Creation (dd/mm/yy) : 27th-September-2000 Version Number : 1.0 Brief Description : This class encapsulates the functionality needed for synchronization the funtionality of three functional components identified for the wmic.exe.Object of this class is created in the main program and used to handle functionality of Parsing Engine, Execution Engine,and Format Engine thorough class members. Global Functions : CompareTokens(_TCHAR* pszTok1, _TCHAR* pszTok2) Revision History : Last Modified By : Ch. Sriramachandramurthy Last Modified Date : 11th-April-2001 *****************************************************************************/ // WmiCmdLn.cpp : implementation file #include "Precomp.h" #include "CommandSwitches.h" #include "GlobalSwitches.h" #include "HelpInfo.h" #include "ErrorLog.h" #include "ParsedInfo.h" #include "CmdTokenizer.h" #include "CmdAlias.h" #include "ParserEngine.h" #include "ExecEngine.h" #include "ErrorInfo.h" #include "WmiCliXMLLog.h" #include "FormatEngine.h" #include "wmicmdln.h" #include "conio.h" ///////////////////////////////////////////////////////////////////////////// // CWMICommandLine /*------------------------------------------------------------------------ Name :CWMICommandLine Synopsis :This function initializes the member variables when an object of the class type is instantiated Type :Constructor Input parameters :None Output parameters :None Return Type :None Global Variables :None Calling Syntax :None Notes :None ------------------------------------------------------------------------*/ CWMICommandLine::CWMICommandLine() { m_uErrLevel = 0; m_pIWbemLocator = NULL; m_hKey = NULL; m_bBreakEvent = FALSE; m_bAccCmd = TRUE; //To come out of the program when registering mofs m_bDispRes = TRUE; m_bInitWinSock = FALSE; m_bCtrlHandlerError = FALSE; EmptyClipBoardBuffer(); // Set the console control handler if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE)) { m_bCtrlHandlerError = TRUE; m_ParsedInfo.GetCmdSwitchesObject(). SetErrataCode(SET_CONHNDLR_ROUTN_FAIL); } } /*------------------------------------------------------------------------ Name :~CWMICommandLine Synopsis :This function uninitializes the member variables when an object of the class type goes out of scope. Type :Destructor Input parameters :None Output parameters :None Return Type :None Global Variables :None Calling Syntax :None Notes :None ------------------------------------------------------------------------*/ CWMICommandLine::~CWMICommandLine() { SAFEIRELEASE(m_pIWbemLocator); } /*------------------------------------------------------------------------ Name :ScreenBuffer Synopsis :This function sets/resets screen buffer Type :Member Function Input parameters :BOOL bSet TRUE -> set buffer FALSE -> revert to previous Output parameters :None Return Type :BOOL Global Variables :None ------------------------------------------------------------------------*/ BOOL CWMICommandLine::ScreenBuffer( BOOL bSet ) { BOOL bResult = FALSE; if ( bSet ) { if ( GetScreenBuffer(m_nHeight, m_nWidth) ) { // Set the console scree buffer size. bResult = SetScreenBuffer(); } } else { if ( m_nHeight && m_nWidth ) { bResult = SetScreenBuffer(m_nHeight, m_nWidth); } } return bResult; } /*------------------------------------------------------------------------ Name :Uninitialize Synopsis :This function uninitializes the member variables when the execution of a command string issued on the command line is completed.It internally calls uninitialize for CParsedInfo,CExecEngine,ParserEngine and CFormatEngine . Type :Member Function Input parameters :None Output parameters :None Return Type :None Global Variables :None Calling Syntax :Uninitialize() Notes :None ------------------------------------------------------------------------*/ void CWMICommandLine::Uninitialize() { m_ParsedInfo.Uninitialize(TRUE); m_ExecEngine.Uninitialize(TRUE); m_ParserEngine.Uninitialize(TRUE); m_FormatEngine.Uninitialize(TRUE); SAFEIRELEASE(m_pIWbemLocator); if (m_hKey != NULL) { RegCloseKey(m_hKey); m_hKey = NULL; } // Uninitialize windows socket interface. if ( m_bInitWinSock == TRUE ) TermWinsock(); m_bmKeyWordtoFileName.clear(); } /*------------------------------------------------------------------------ Name :Initialize Synopsis :This function returns initializes the COM library and sets the process security, also it creates an instance of the IWbemLocator object Type :Member Function Input parameters :None Output parameters :None Return Type :BOOL Global Variables :None Calling Syntax :Initialize() Notes :None ------------------------------------------------------------------------*/ BOOL CWMICommandLine::Initialize() { HRESULT hr = S_OK; BOOL bRet = TRUE; m_bBreakEvent = FALSE; m_bAccCmd = TRUE; //To come out of the program when registering mofs try { // Initialize the security hr = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_NONE, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, 0); ONFAILTHROWERROR(hr); // Create an instance of the IWbemLocator interface. hr = CoCreateInstance(CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *) &m_pIWbemLocator); ONFAILTHROWERROR(hr); // Enable the security privileges hr = ModifyPrivileges(TRUE); ONFAILTHROWERROR(hr); try { hr = RegisterMofs(); ONFAILTHROWERROR(hr); // Initialize the Globalswitches and Commandswitches. m_ParsedInfo.GetGlblSwitchesObject().Initialize(); m_ParsedInfo.GetCmdSwitchesObject().Initialize(); } catch(WMICLIINT nVal) { if (nVal == OUT_OF_MEMORY) { m_ParsedInfo.GetCmdSwitchesObject(). SetErrataCode(OUT_OF_MEMORY); } // If mofcomp error if (nVal == MOFCOMP_ERROR) { m_ParsedInfo.GetCmdSwitchesObject(). SetErrataCode(MOFCOMP_ERROR); } SAFEIRELEASE(m_pIWbemLocator); bRet = FALSE; } catch(DWORD dwError) { // If Win32 Error DisplayString(IDS_E_REGMOF_FAILED, CP_OEMCP, NULL, TRUE, TRUE); ::SetLastError(dwError); DisplayWin32Error(); m_ParsedInfo.GetCmdSwitchesObject().SetErrataCode(dwError); SAFEIRELEASE(m_pIWbemLocator); bRet = FALSE; } if ( TRUE == bRet ) { GetFileNameMap(); } } catch (_com_error& e) { SAFEIRELEASE(m_pIWbemLocator); m_ParsedInfo.GetCmdSwitchesObject().SetCOMError(e); bRet = FALSE; } return bRet; } /*------------------------------------------------------------------------- Name :GetFormatObject Synopsis :This function returns a reference to the CFormatEngine Object Type :Member Function Input parameters :None Output parameters :None Return Type :CFormatEngine & Global Variables :None Calling Syntax :GetFormatObject() Notes :None -------------------------------------------------------------------------*/ CFormatEngine& CWMICommandLine::GetFormatObject() { return m_FormatEngine; } /*------------------------------------------------------------------------- Name :GetParsedInfoObject Synopsis :This function returns a reference to the CParsedInfo Object Type :Member Function Input parameters :None Output parameters :None Return Type :CParsedInfo & Global Variables :None Calling Syntax :GetParsedInfoObject() Notes :None -------------------------------------------------------------------------*/ CParsedInfo& CWMICommandLine::GetParsedInfoObject() { return m_ParsedInfo; } /*------------------------------------------------------------------------- Name :ProcessCommandAndDisplayResults Synopsis :It processes the given command string by giving the the command to CParsedInfo as input, initializing the CParserEngine,CExecEngine and CFormatEngine and synchronizes the operation between all the modules. Type :Member Function Input parameters : pszBuffer - input command string Output parameters :None Return Type :SESSIONRETCODE Global Variables :None Calling Syntax :ProcessCommandAndDisplayResults(pszBuffer) Notes :None -------------------------------------------------------------------------*/ SESSIONRETCODE CWMICommandLine::ProcessCommandAndDisplayResults( _TCHAR* pszBuffer) { SESSIONRETCODE ssnRetCode = SESSION_SUCCESS; try { // Initialize the local variables. ULONG ulRetTime = 0; RETCODE retCode = PARSER_EXECCOMMAND; BOOL bExecute = FALSE; BOOL bFirst = TRUE; _bstr_t bstrXML = L""; _bstr_t bstrAggregateXML = L""; _bstr_t bstrTempXML = L""; _bstr_t bstrHeader = L""; _bstr_t bstrRequest; // Reset the erratacode m_ParsedInfo.GetCmdSwitchesObject().SetErrataCode(0); m_ParsedInfo.SetNewCycleStatus(FALSE); m_ParsedInfo.SetNewCommandStatus(TRUE); //Store the starttime and increment the commandsequence // number to one. if (!m_ParsedInfo.GetGlblSwitchesObject().SetStartTime()) { m_ParsedInfo.GetCmdSwitchesObject().SetErrataCode(OUT_OF_MEMORY); ssnRetCode = SESSION_ERROR; } //Initialize the command input in CParsedInfo if(!m_ParsedInfo.GetCmdSwitchesObject().SetCommandInput(pszBuffer)) { m_ParsedInfo.GetCmdSwitchesObject().SetErrataCode(OUT_OF_MEMORY); ssnRetCode = SESSION_ERROR; } if(ssnRetCode != SESSION_ERROR) { //Tokenize the command string as per the pre-defined delimiters if (m_ParserEngine.GetCmdTokenizer().TokenizeCommand(pszBuffer)) { // Check whether the input indicates end of session. // i.e either QUIT or EXIT if(!IsSessionEnd()) { //Setting the IWbemLocator object . m_ParserEngine.SetLocatorObject(m_pIWbemLocator); // Initilaize ParsedInfo Object to release earlier messages m_ParsedInfo.Initialize(); //Call CParserEngine ProcessTokens to process the //tokenized commands . retCode = m_ParserEngine.ProcessTokens(m_ParsedInfo); //Checking if the return code indicates Command execution if (retCode == PARSER_EXECCOMMAND) { // Check whether user should be prompted for password CheckForPassword(); // Obtain the /EVERY interval value ulRetTime = m_ParsedInfo.GetCmdSwitchesObject() .GetRetrievalInterval(); // Set the execute flag to TRUE. bExecute = TRUE; CHARVECTOR cvNodesList = m_ParsedInfo.GetGlblSwitchesObject(). GetNodesList(); CHARVECTOR::iterator iNodesIterator; m_ParsedInfo.SetNewCommandStatus(TRUE); BOOL bXMLEncoding = FALSE; _TCHAR *pszVerbName = m_ParsedInfo. GetCmdSwitchesObject(). GetVerbName(); if(CompareTokens(pszVerbName, CLI_TOKEN_GET) || CompareTokens(pszVerbName, CLI_TOKEN_LIST) || CompareTokens(pszVerbName, CLI_TOKEN_ASSOC) || pszVerbName == NULL) { bXMLEncoding = TRUE; } BOOL bBreak = TRUE; BOOL bMsgFlag = FALSE; LONG lLoopCount = 0; ULONG ulRepeatCount = m_ParsedInfo.GetCmdSwitchesObject(). GetRepeatCount(); BOOL bFirstEvery = TRUE; OUTPUTSPEC opsOutOpt = m_ParsedInfo.GetGlblSwitchesObject(). GetOutputOrAppendOption(TRUE); while (TRUE) { m_ParsedInfo.SetNewCycleStatus(TRUE); if(bXMLEncoding) { bstrHeader = L""; } // Iterate thru the list of nodes for ( iNodesIterator = cvNodesList.begin(); iNodesIterator < cvNodesList.end(); iNodesIterator++ ) { if(bXMLEncoding) { bstrTempXML = L""; } // Reset the error and information code(s). m_ParsedInfo.GetCmdSwitchesObject(). SetInformationCode(0); m_ParsedInfo.GetCmdSwitchesObject(). SetErrataCode(0); if ( iNodesIterator == cvNodesList.begin() && cvNodesList.size() > 1 ) continue; if(!bXMLEncoding) { if ( cvNodesList.size() > 2 ) { _bstr_t bstrNode; WMIFormatMessage(IDS_I_NODENAME_MSG, 1, bstrNode, (LPWSTR)*iNodesIterator); DisplayMessage((LPWSTR)bstrNode, CP_OEMCP, FALSE, FALSE); } } else { CHString sBuffer; _bstr_t bstrRessultsNode = (*iNodesIterator); FindAndReplaceEntityReferences( bstrRessultsNode); sBuffer.Format(L"", (LPWSTR)bstrRessultsNode); bstrTempXML += _bstr_t(sBuffer); } // Setting the locator object . m_ExecEngine.SetLocatorObject(m_pIWbemLocator); m_ParsedInfo.GetGlblSwitchesObject(). SetNode(*iNodesIterator); //Call ExecEngine ExecuteCommand to execute the // tokenized command if (m_ExecEngine.ExecuteCommand(m_ParsedInfo)) { // Set the successflag to TRUE m_ParsedInfo.GetCmdSwitchesObject(). SetSuccessFlag(TRUE); if(bXMLEncoding) { // Append the XML result set obtained // to the aggregated output if (m_ParsedInfo.GetCmdSwitchesObject(). GetXMLResultSet()) { bstrTempXML += _bstr_t(m_ParsedInfo. GetCmdSwitchesObject(). GetXMLResultSet()); } // Free the XML result set. m_ParsedInfo.GetCmdSwitchesObject(). SetXMLResultSet(NULL); } else { bBreak = TRUE; if (!m_FormatEngine. DisplayResults(m_ParsedInfo)) { ssnRetCode = SESSION_ERROR; SetSessionErrorLevel(ssnRetCode); break; } m_ParsedInfo.SetNewCommandStatus(FALSE); m_ParsedInfo.SetNewCycleStatus(FALSE); } } else { //Set the sucess flag to FALSE m_ParsedInfo.GetCmdSwitchesObject(). SetSuccessFlag(FALSE); ssnRetCode = SESSION_ERROR; if(bXMLEncoding) { _bstr_t bstrNode, bstrError; UINT uErrorCode = 0; WMIFormatMessage(IDS_I_NODENAME_MSG, 1, bstrNode, (LPWSTR)*iNodesIterator); DisplayMessage((LPWSTR)bstrNode, CP_OEMCP, TRUE, FALSE); // Retrieve the error code uErrorCode = m_ParsedInfo. GetCmdSwitchesObject(). GetErrataCode() ; if ( uErrorCode != 0 ) { _bstr_t bstrTemp; CHString sBuffer; WMIFormatMessage(uErrorCode, 0, bstrTemp, NULL); sBuffer.Format(L"" L"%s" L"", (LPWSTR)(bstrTemp)); bstrError = _bstr_t(sBuffer); // Write the error to stderr DisplayMessage((LPWSTR)bstrTemp, CP_OEMCP, TRUE, FALSE); } else { m_FormatEngine. GetErrorInfoObject(). GetErrorFragment( m_ParsedInfo. GetCmdSwitchesObject(). GetCOMError()->Error(), bstrError); // Write the error to stderr m_FormatEngine.DisplayCOMError(m_ParsedInfo); } bstrTempXML += bstrError; } else { bBreak = TRUE; if (!m_FormatEngine. DisplayResults(m_ParsedInfo)) { // Set the session error level SetSessionErrorLevel(ssnRetCode); break; } m_ParsedInfo.SetNewCommandStatus(FALSE); } // Set the session error level SetSessionErrorLevel(ssnRetCode); } if(bXMLEncoding) bstrTempXML += L""; if(bXMLEncoding && bFirst) { bFirst = FALSE; FrameXMLHeader(bstrHeader, lLoopCount); if(lLoopCount == 0) FrameRequestNode(bstrRequest); bstrXML += bstrHeader; bstrXML += bstrRequest; } m_ExecEngine.Uninitialize(); m_FormatEngine.Uninitialize(); m_ParsedInfo.GetCmdSwitchesObject(). SetCredentialsFlag(FALSE); m_ParsedInfo.GetCmdSwitchesObject(). FreeCOMError(); m_ParsedInfo.GetCmdSwitchesObject(). SetSuccessFlag(TRUE); if(bXMLEncoding) { if(!m_ParsedInfo.GetGlblSwitchesObject(). GetAggregateFlag()) { _bstr_t bstrNodeResult = L""; bstrNodeResult += bstrXML; bstrNodeResult += bstrTempXML; bstrNodeResult += L""; m_ParsedInfo.GetCmdSwitchesObject(). SetXMLResultSet((LPWSTR) bstrNodeResult); if (!m_FormatEngine. DisplayResults(m_ParsedInfo)) { bBreak = TRUE; ssnRetCode = SESSION_ERROR; SetSessionErrorLevel(ssnRetCode); m_FormatEngine.Uninitialize(); break; } m_ParsedInfo.SetNewCommandStatus(FALSE); m_ParsedInfo.SetNewCycleStatus(FALSE); m_FormatEngine.Uninitialize(); } else { bstrAggregateXML += bstrTempXML; } } if (_kbhit()) { _getch(); bBreak = TRUE; break; } if (GetBreakEvent() == TRUE) { bBreak = TRUE; break; } } if(m_ParsedInfo.GetGlblSwitchesObject(). GetAggregateFlag() && bXMLEncoding) { bstrXML += bstrAggregateXML; bstrXML += L""; bFirst = TRUE; m_ParsedInfo.GetCmdSwitchesObject(). SetXMLResultSet((LPWSTR) bstrXML); if (!m_FormatEngine. DisplayResults(m_ParsedInfo)) { bBreak = TRUE; ssnRetCode = SESSION_ERROR; SetSessionErrorLevel(ssnRetCode); m_FormatEngine.Uninitialize(); break; } m_FormatEngine.Uninitialize(); bstrAggregateXML = L""; bstrXML = L""; m_ParsedInfo.SetNewCommandStatus(FALSE); } //Checking the Sucess flag and the retrievel time . if (m_ParsedInfo.GetCmdSwitchesObject(). GetSuccessFlag() == TRUE && m_ParsedInfo.GetCmdSwitchesObject(). GetEverySwitchFlag() == TRUE ) { CONSOLE_SCREEN_BUFFER_INFO csbiInfo; HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); if( INVALID_HANDLE_VALUE != hStdOut) { GetConsoleScreenBufferInfo(hStdOut, &csbiInfo); } bBreak = FALSE; lLoopCount++; if (!IsRedirection() && GetBreakEvent() == FALSE) { if ( opsOutOpt == STDOUT || bFirstEvery == TRUE) { DisplayString(IDS_I_HAKTBTC, CP_OEMCP, NULL, TRUE, TRUE); bMsgFlag = TRUE; bFirstEvery = FALSE; } } if ( ulRepeatCount != 0 ) { if ( lLoopCount >= ulRepeatCount ) { if (bMsgFlag && !IsRedirection()) EraseConsoleString(&csbiInfo); bBreak = TRUE; } } //No action till time out is no over // Or no key is hit. if(!bBreak) { SleepTillTimeoutOrKBhit(ulRetTime * 1000); if (bMsgFlag && !IsRedirection()) { if ( opsOutOpt == STDOUT ) { bMsgFlag = FALSE; EraseConsoleString(&csbiInfo); } } } if (_kbhit()) { _getch(); if (bMsgFlag && !IsRedirection()) EraseConsoleString(&csbiInfo); bBreak = TRUE; } if (GetBreakEvent() == TRUE) bBreak = TRUE; } else bBreak = TRUE; if (bBreak) break; } } else if ((retCode == PARSER_ERRMSG) || (retCode == PARSER_ERROR)) { // Set the success flag to FALSE m_ParsedInfo.GetCmdSwitchesObject(). SetSuccessFlag(FALSE); ssnRetCode = SESSION_ERROR; // Display the error message if (!m_FormatEngine.DisplayResults(m_ParsedInfo)) ssnRetCode = SESSION_ERROR; } else if (retCode == PARSER_OUTOFMEMORY) { ssnRetCode = SESSION_ERROR; } else { CheckForPassword(); // Set the success flag to TRUE m_ParsedInfo.GetCmdSwitchesObject(). SetSuccessFlag(TRUE); ssnRetCode = SESSION_SUCCESS; // Display the information if (!m_FormatEngine.DisplayResults(m_ParsedInfo)) ssnRetCode = SESSION_ERROR; } } else { ssnRetCode = SESSION_QUIT; } } else { m_ParsedInfo.GetCmdSwitchesObject(). SetErrataCode(OUT_OF_MEMORY); ssnRetCode = SESSION_ERROR; } } // Set the session error level to be returned. if (!bExecute) SetSessionErrorLevel(ssnRetCode); } catch(_com_error& e) { m_ParsedInfo.GetCmdSwitchesObject().SetCOMError(e); m_FormatEngine.DisplayResults(m_ParsedInfo); ssnRetCode = SESSION_ERROR; SetSessionErrorLevel(ssnRetCode); } catch(CHeap_Exception) { _com_error e(WBEM_E_OUT_OF_MEMORY); m_ParsedInfo.GetCmdSwitchesObject().SetCOMError(e); m_FormatEngine.DisplayResults(m_ParsedInfo); ssnRetCode = SESSION_ERROR; g_wmiCmd.SetSessionErrorLevel(ssnRetCode); } catch(DWORD dwError) { ::SetLastError(dwError); DisplayWin32Error(); ::SetLastError(dwError); ssnRetCode = SESSION_ERROR; g_wmiCmd.SetSessionErrorLevel(ssnRetCode); } catch(WMICLIINT nVal) { if (nVal == OUT_OF_MEMORY) { GetParsedInfoObject().GetCmdSwitchesObject().SetErrataCode(OUT_OF_MEMORY); GetParsedInfoObject().GetCmdSwitchesObject().SetSuccessFlag(FALSE); m_FormatEngine.DisplayResults(m_ParsedInfo); ssnRetCode = SESSION_ERROR; SetSessionErrorLevel(ssnRetCode); } else if (nVal == MULTIPLENODE_ERROR) { GetParsedInfoObject().GetCmdSwitchesObject().SetErrataCode(IDS_E_MULTIPLENODE_ERROR); GetParsedInfoObject().GetCmdSwitchesObject().SetSuccessFlag(FALSE); m_FormatEngine.DisplayResults(m_ParsedInfo); ssnRetCode = SESSION_ERROR; SetSessionErrorLevel(ssnRetCode); } } catch(...) { ssnRetCode = SESSION_ERROR; GetParsedInfoObject().GetCmdSwitchesObject(). SetErrataCode(UNKNOWN_ERROR); SetSessionErrorLevel(ssnRetCode); DisplayString(IDS_E_WMIC_UNKNOWN_ERROR, CP_OEMCP, NULL, TRUE, TRUE); } if(ssnRetCode != SESSION_QUIT) { //sets the help flag m_ParsedInfo.GetGlblSwitchesObject().SetHelpFlag(FALSE); m_ParsedInfo.GetGlblSwitchesObject().SetAskForPassFlag(FALSE); //Call Uninitialize on Parse Info m_ParsedInfo.Uninitialize(FALSE); //Call Uninitialize on Execution Engine m_ExecEngine.Uninitialize(); //Call Uninitialize on Format Engine m_FormatEngine.Uninitialize(); //Call Uninitialize Parser Engine m_ParserEngine.Uninitialize(); } m_ParsedInfo.SetNewCommandStatus(FALSE); return ssnRetCode; } /*------------------------------------------------------------------------- Name :PollForKBhit Synopsis :Polls for keyboard input Type :Member Function (Thread procedure) Input parameters :LPVOID lpParam Output parameters :None Return Type :void Global Variables :None Calling Syntax :PollForKBhit(lpParam) Notes :None -------------------------------------------------------------------------*/ DWORD WINAPI CWMICommandLine::PollForKBhit(LPVOID lpParam) { HANDLE hEvent = NULL; hEvent = *((HANDLE*) lpParam ); //Checks the console for keyboard input while (1 ) { if ( _kbhit() ) break; else if ( WaitForSingleObject(hEvent, 500) != WAIT_TIMEOUT ) break; } return(0); } /*------------------------------------------------------------------------- Name :SleepTillTimeoutOrKBhit Synopsis :It causes the process to enter a wait state by WaitForSingleObject . It creates a thread and executed PollForKBhit. Type :Member Function Input parameters : dwMilliSeconds - time-out interval in milliseconds Output parameters :None Return Type :void Global Variables :None Calling Syntax :SleepTillTimeoutOrKBhit( dwMilliSeconds) Notes :None -------------------------------------------------------------------------*/ void CWMICommandLine::SleepTillTimeoutOrKBhit(DWORD dwMilliSeconds) { DWORD dwThreadId = 0; HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); //Create thread and execute PollForKBhit. HANDLE hPollForKBhit = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)PollForKBhit, &hEvent, 0, &dwThreadId); //waits for the hPollForKBhit state or the time-out interval to elapse. DWORD dwWait = WaitForSingleObject(hPollForKBhit, dwMilliSeconds); if ( dwWait == WAIT_TIMEOUT ) { SetEvent( hEvent ); WaitForSingleObject(hPollForKBhit, INFINITE); } CloseHandle(hEvent); CloseHandle(hPollForKBhit); } /*------------------------------------------------------------------------- Name :IsSessionEnd Synopsis :It checks whether the keyed-in input indicates end of the session. i.e "quit" has been specified as the 1st token. Type :Member Function Input parameters :None Output parameters :None Return Type :BOOL Global Variables :None Calling Syntax :IsSessionEnd() Notes :None -------------------------------------------------------------------------*/ BOOL CWMICommandLine::IsSessionEnd() { // Obtain the token vector. CHARVECTOR cvTokens = m_ParserEngine.GetCmdTokenizer().GetTokenVector(); //the iterator to span throuh the vector variable CHARVECTOR::iterator theIterator; BOOL bRet=FALSE; // Check for the presence of tokens. Absence of tokens indicates // no command string is fed as input. if (cvTokens.size()) { // Obtain the pointer to the beginning of the token vector. theIterator = cvTokens.begin(); // Check for the presence of the keyword 'quit' if (CompareTokens(*theIterator, CLI_TOKEN_QUIT) || CompareTokens(*theIterator, CLI_TOKEN_EXIT)) { bRet=TRUE; } } return bRet; } /*------------------------------------------------------------------------- Name :SetSessionErrorLevel Synopsis :Set the session error level value Type :Member Function Input parameters : ssnRetCode - session return code Output parameters :None Return Type :None Global Variables :None Calling Syntax :SetSessionErrorLevel() -------------------------------------------------------------------------*/ //Set the session error value void CWMICommandLine::SetSessionErrorLevel(SESSIONRETCODE ssnRetCode) { try { if (ssnRetCode == SESSION_ERROR) { // If the COM error is not NULL , then display the error if (m_ParsedInfo.GetCmdSwitchesObject().GetCOMError()) { // Getting the _com_error data. _com_error* pComError = m_ParsedInfo.GetCmdSwitchesObject(). GetCOMError(); m_uErrLevel = pComError->Error(); } CHString chsMsg(_T("command: ")); chsMsg += m_ParsedInfo.GetCmdSwitchesObject().GetCommandInput(); DWORD dwThreadId = GetCurrentThreadId(); if (m_ParsedInfo.GetCmdSwitchesObject().GetErrataCode()) { m_uErrLevel = m_ParsedInfo.GetCmdSwitchesObject().GetErrataCode(); if (m_uErrLevel == OUT_OF_MEMORY) { DisplayString(IDS_E_MEMALLOCFAILED, CP_OEMCP, NULL, TRUE, TRUE); } if (m_uErrLevel == SET_CONHNDLR_ROUTN_FAIL) { DisplayString(IDS_E_CONCTRL_HNDLRSET, CP_OEMCP, NULL, TRUE, TRUE); } if ( m_uErrLevel == OUT_OF_MEMORY || m_uErrLevel == SET_CONHNDLR_ROUTN_FAIL ) { if (m_ParsedInfo.GetErrorLogObject().GetErrLogOption()) { chsMsg += _T(", Utility returned error ID."); // explicit error -1 to specify errata code. WMITRACEORERRORLOG(-1, __LINE__, __FILE__, (LPCWSTR)chsMsg, dwThreadId, m_ParsedInfo, FALSE, m_ParsedInfo.GetCmdSwitchesObject() .GetErrataCode()); } } if ( m_uErrLevel == ::GetLastError() ) { if (m_ParsedInfo.GetErrorLogObject().GetErrLogOption()) { WMITRACEORERRORLOG(-1, __LINE__, __FILE__, _T("Win32Error"), dwThreadId, m_ParsedInfo, FALSE, m_uErrLevel); } } if (m_uErrLevel == MOFCOMP_ERROR) { if (m_ParsedInfo.GetErrorLogObject().GetErrLogOption()) { WMITRACEORERRORLOG(-1, __LINE__, __FILE__, _T("MOF Compilation Error (the errorlevel " L"is utility specific)"), dwThreadId, m_ParsedInfo, FALSE, m_uErrLevel); } } } } else { // Set the error level to 0 m_uErrLevel = 0; } } catch(CHeap_Exception) { _com_issue_error(WBEM_E_OUT_OF_MEMORY); } } /*------------------------------------------------------------------------- Name :GetSessionErrorLevel Synopsis :Get the session error value Type :Member Function Input parameters :None Output parameters :None Return Type :WMICLIUINT Global Variables :None Calling Syntax :GetSessionErrorLevel() -------------------------------------------------------------------------*/ WMICLIUINT CWMICommandLine::GetSessionErrorLevel() { return m_uErrLevel; } /*------------------------------------------------------------------------- Name :CheckForPassword Synopsis :Prompt for user password, in case user is specified without password. Type :Member Function Input parameters :None Output parameters :None Return Type :None Global Variables :None Calling Syntax :CheckForPassword() -------------------------------------------------------------------------*/ void CWMICommandLine::CheckForPassword() { if ( m_ParsedInfo.GetGlblSwitchesObject().GetAskForPassFlag() == TRUE && m_ParsedInfo.GetGlblSwitchesObject().GetUser() != NULL ) { _TCHAR szPassword[BUFFER64] = NULL_STRING; DisplayString(IDS_I_PWD_PROMPT, CP_OEMCP, NULL, TRUE); AcceptPassword(szPassword); m_ParsedInfo.GetGlblSwitchesObject().SetPassword( szPassword); } } /*------------------------------------------------------------------------- Name :RegisterMofs Synopsis :Register the mof file(s) if not registered earlier. Type :Member Function Input parameters :None Output parameters : Return Type :HRESULT Global Variables :None Calling Syntax :RegisterMofs() -------------------------------------------------------------------------*/ HRESULT CWMICommandLine::RegisterMofs() { HRESULT hr = S_OK; IMofCompiler *pIMofCompiler = NULL; BOOL bCompile = FALSE; BOOL bFirst = FALSE; DWORD dwBufSize = BUFFER32; _TCHAR pszLocale[BUFFER32] = NULL_STRING; _TCHAR szKeyValue[BUFFER32] = NULL_STRING; _TCHAR* pszBuffer = NULL; WMICLIINT nError = 0; HRESULT hRes = S_OK; LONG lRetVal = 0; CONSOLE_SCREEN_BUFFER_INFO csbiInfo; // this structures check timestamps const WMICLIINT iMofCount = 3; LPCWSTR pMofTable [iMofCount] = { L"Cli.mof", L"CliEgAliases.mof", L"CliEgAliases.mfl" }; __int64 pFileTime [ iMofCount ] = { 0 } ; try { _bstr_t bstrMofPath, bstrNS; // Check|Create the registry entry. bFirst = IsFirstTime(); // Check whether the "mofcompstatus" key value is 0 if (!bFirst) { // Query the "mofcompstatus" mode lRetVal = RegQueryValueEx(m_hKey, L"mofcompstatus", NULL, NULL, (LPBYTE)szKeyValue, &dwBufSize); if (lRetVal == ERROR_SUCCESS) { // If the value is not "1", then set the bFirst to TRUE if (!CompareTokens(szKeyValue, CLI_TOKEN_ONE)) { bCompile = TRUE; } } else { ::SetLastError(lRetVal); throw (::GetLastError()); } } // If the WMIC is being used for the first time. if (bFirst) { HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); if( INVALID_HANDLE_VALUE == hStdOut || false == GetConsoleScreenBufferInfo(hStdOut, &csbiInfo)) { csbiInfo.srWindow.Bottom = csbiInfo.srWindow.Top = 0; } DisplayString(IDS_I_WMIC_INST, CP_OEMCP); } UINT nSize = 0; pszBuffer = new _TCHAR [MAX_PATH+1]; if(pszBuffer == NULL) throw OUT_OF_MEMORY; // Obtain the system directory path nSize = GetSystemDirectory(pszBuffer, MAX_PATH+1); if(nSize) { if (nSize > MAX_PATH) { SAFEDELETE(pszBuffer); pszBuffer = new _TCHAR [nSize + 1]; if(pszBuffer == NULL) { throw OUT_OF_MEMORY; } if (!GetSystemDirectory(pszBuffer, nSize+1)) { SAFEDELETE(pszBuffer); throw (::GetLastError()); } } } else { throw(::GetLastError()); } /* Frame the location of the mof file(s) %systemdir%\\wbem\\ */ bstrMofPath = _bstr_t(pszBuffer) + _bstr_t(L"\\wbem\\"); SAFEDELETE(pszBuffer); // Check whether file timestamps are equal if (!EqualTimeStamps(bstrMofPath, pMofTable, pFileTime, sizeof ( pMofTable ) / sizeof ( LPCWSTR ))) { if (!bFirst) { bCompile = TRUE; } } // If the WMIC is being updated !!! if ( bCompile ) { HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); if( INVALID_HANDLE_VALUE == hStdOut || false == GetConsoleScreenBufferInfo(hStdOut, &csbiInfo)) { csbiInfo.srWindow.Bottom = csbiInfo.srWindow.Top = 0; } DisplayString(IDS_I_WMIC_UPDATE, CP_OEMCP); } if (bFirst || bCompile) { // Create an instance of the IMofCompiler interface. hr = CoCreateInstance(CLSID_MofCompiler, NULL, CLSCTX_INPROC_SERVER, IID_IMofCompiler, (LPVOID *) &pIMofCompiler); ONFAILTHROWERROR(hr); for ( WMICLIINT iMofIndex = 0; iMofIndex < ( sizeof ( pMofTable ) / sizeof ( LPCWSTR ) ); iMofIndex++ ) { // Register the xxxxx.mof hr = CompileMOFFile(pIMofCompiler, bstrMofPath + _bstr_t(pMofTable[iMofIndex]), nError); if ( FAILED ( hr ) || nError ) { MofCompFailureCleanUp ( pMofTable, sizeof ( pMofTable ) / sizeof ( LPCWSTR ) ); } ONFAILTHROWERROR(hr); if (nError) throw MOFCOMP_ERROR; } SAFEIRELEASE(pIMofCompiler); // Set the filestamps SetTimeStamps ( pMofTable, pFileTime, sizeof ( pMofTable ) / sizeof ( LPCWSTR ) ); // Set the default value. lRetVal = RegSetValueEx(m_hKey, L"mofcompstatus", 0, REG_SZ, (LPBYTE) CLI_TOKEN_ONE, lstrlen(CLI_TOKEN_ONE) + 1); if (lRetVal != ERROR_SUCCESS) { ::SetLastError(lRetVal); // failed to set the default value throw (::GetLastError()); } } if (m_hKey != NULL) { RegCloseKey(m_hKey); m_hKey = NULL; } } catch(WMICLIINT nErr) { SAFEIRELEASE(pIMofCompiler); SAFEDELETE(pszBuffer); if (m_hKey != NULL) { RegCloseKey(m_hKey); m_hKey = NULL; } throw nErr; } catch(_com_error& e) { SAFEIRELEASE(pIMofCompiler); SAFEDELETE(pszBuffer); hr = e.Error(); if (m_hKey != NULL) { RegCloseKey(m_hKey); m_hKey = NULL; } } catch (DWORD dwError) { SAFEIRELEASE(pIMofCompiler); SAFEDELETE(pszBuffer); if (m_hKey != NULL) { RegCloseKey(m_hKey); m_hKey = NULL; } throw dwError; } if ( bFirst || bCompile ) { EraseConsoleString(&csbiInfo); } return hr; } void CWMICommandLine::MofCompFailureCleanUp( LPCWSTR mofs[], DWORD dw_mofs ) { // delete registry values for timestamps if it exists if ( m_hKey ) { DWORD dwSize = dw_mofs; for ( DWORD dwIndex = 0; dwIndex < dwSize; dwIndex++ ) { RegDeleteValueW ( m_hKey, mofs [ dwIndex ] ); } } // delete namespace to avoid inconsistency IWbemServices *pISvc = NULL; _bstr_t bstrNSRoot = L"\\\\.\\root"; HRESULT hr = m_pIWbemLocator->ConnectServer(bstrNSRoot, NULL, NULL, NULL, 0, NULL, NULL, &pISvc); // If the namespace does not exist. if (SUCCEEDED(hr)) { _bstr_t bstrNSPath = L"__Namespace.Name=\"cli\""; hr = pISvc->DeleteInstance(bstrNSPath, 0, NULL, NULL); } SAFEIRELEASE(pISvc); } BOOL CWMICommandLine::EqualTimeStamps( const _bstr_t& path, LPCWSTR mofs[], __int64* filestamps, DWORD dw_mofs ) { BOOL bRetVal = TRUE; DWORD dwSize = dw_mofs; HANDLE hFile = INVALID_HANDLE_VALUE; try { DWORD dwDataSize = 128 * sizeof ( WCHAR ); WCHAR pData[128] = NULL_STRING; FILETIME ftCreate; FILETIME ftAccess; FILETIME ftWrite; LARGE_INTEGER liMofcompTime; liMofcompTime.QuadPart = 0; FILETIME ft; for ( DWORD dwIndex = 0; dwIndex < dwSize; dwIndex++ ) { hFile = CreateFileW ( _bstr_t ( path + _bstr_t ( mofs [ dwIndex ] ) ), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); if ( hFile && hFile != INVALID_HANDLE_VALUE ) { if ( GetFileTime ( hFile, &ftCreate, &ftAccess, &ftWrite ) ) { dwDataSize = 128 * sizeof ( WCHAR ); if (bRetVal && RegQueryValueExW ( m_hKey, mofs [ dwIndex ], NULL, NULL, reinterpret_cast < LPBYTE > ( pData ), &dwDataSize ) == ERROR_SUCCESS ) { liMofcompTime.QuadPart = _wtoi64 ( pData ); ft.dwLowDateTime = liMofcompTime.LowPart; ft.dwHighDateTime = liMofcompTime.HighPart; if ( CompareFileTime ( &ftWrite, &ft ) != 0 ) { bRetVal = FALSE; } } else { bRetVal = FALSE; } liMofcompTime.LowPart = ftWrite.dwLowDateTime; liMofcompTime.HighPart = ftWrite.dwHighDateTime; filestamps[dwIndex] = liMofcompTime.QuadPart; } else { bRetVal = FALSE; } ::CloseHandle ( hFile ); hFile = INVALID_HANDLE_VALUE; } else { bRetVal = FALSE; } } } catch(WMICLIINT nErr) { if ( hFile != INVALID_HANDLE_VALUE ) { ::CloseHandle ( hFile ); hFile = INVALID_HANDLE_VALUE; } throw nErr; } catch (DWORD dwError) { if ( hFile != INVALID_HANDLE_VALUE ) { ::CloseHandle ( hFile ); hFile = INVALID_HANDLE_VALUE; } throw dwError; } return bRetVal; } BOOL CWMICommandLine::SetTimeStamps( LPCWSTR mofs[], const __int64* filestamps, DWORD dw_mofs ) { BOOL bRetVal = TRUE; DWORD dwSize = dw_mofs; try { WCHAR pData[128] = NULL_STRING; for ( DWORD dwIndex = 0; dwIndex < dwSize && bRetVal; dwIndex++ ) { _i64tow(filestamps[dwIndex], pData, 10); if ( RegSetValueExW ( m_hKey, mofs [ dwIndex ], NULL, REG_SZ, reinterpret_cast < LPBYTE > ( pData ), ( wcslen ( pData ) + 1 ) * sizeof ( WCHAR ) ) != ERROR_SUCCESS ) { bRetVal = FALSE; } } } catch(WMICLIINT nErr) { throw nErr; } catch (DWORD dwError) { throw dwError; } return bRetVal; } /*------------------------------------------------------------------------- Name :IsFirstTime Synopsis :Checks for the availability of the registry location "HKLM\SOFTWARE\Microsoft\Wbem\WMIC", creates one if does not exist. Type :Member Function Input parameters :None Output parameters : Return Type : BOOL: TRUE - registry entry created FALSE - registry entry already available. Global Variables :None Calling Syntax :IsFirstTime() -------------------------------------------------------------------------*/ BOOL CWMICommandLine::IsFirstTime() { BOOL bFirst = FALSE; DWORD dwDisposition = 0; TCHAR szKeyValue[BUFFER32] = NULL_STRING; LONG lRetVal = 0; // Open|Create the registry key lRetVal = RegCreateKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\\\Microsoft\\\\Wbem\\\\WMIC", 0, NULL_STRING, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &m_hKey, &dwDisposition); if (lRetVal == ERROR_SUCCESS) { // If the registry entry is not available if (dwDisposition == REG_CREATED_NEW_KEY) { bFirst = TRUE; lstrcpy(szKeyValue, _T("0")); // Set the default value i.e '0'. lRetVal = RegSetValueEx(m_hKey, L"mofcompstatus", 0, REG_SZ, (LPBYTE) szKeyValue, lstrlen(szKeyValue) + 1); if (lRetVal != ERROR_SUCCESS) { // failed to set the default value ::SetLastError(lRetVal); throw (::GetLastError()); } } } else { ::SetLastError(lRetVal); throw (::GetLastError()); } return bFirst; } /*------------------------------------------------------------------------- Name :IsNSAvailable Synopsis :Checks whether the namespace specified exists Type :Member Function Input parameters : bstrNS - namespace Output parameters :None Return Type : BOOL: TRUE - namespace exists FALSE - namespace does not exist Global Variables :None Calling Syntax :IsNSAvailable() -------------------------------------------------------------------------*/ BOOL CWMICommandLine::IsNSAvailable(const _bstr_t& bstrNS) { HRESULT hr = S_OK; IWbemServices *pISvc = NULL; BOOL bNSExist = TRUE; hr = m_pIWbemLocator->ConnectServer(bstrNS, NULL, NULL, NULL, 0, NULL, NULL, &pISvc); // If the namespace does not exist. if (FAILED(hr) && (hr == WBEM_E_INVALID_PARAMETER || hr == WBEM_E_INVALID_NAMESPACE)) { bNSExist = FALSE; } SAFEIRELEASE(pISvc); return bNSExist; } /*------------------------------------------------------------------------- Name :CompileMOFFile Synopsis :mofcomp's the file specified as input parameter thru bstrFile Type :Member Function Input parameters : pIMofComp - IMofCompiler interface pointer. bstrFile - filename. nError - parsing phase error. Output parameters :None Return Type :HRESULT Global Variables :None Calling Syntax :CompileMOFFile() -------------------------------------------------------------------------*/ HRESULT CWMICommandLine::CompileMOFFile(IMofCompiler* pIMofComp, const _bstr_t& bstrFile, WMICLIINT& nError) { HRESULT hr = S_OK; WBEM_COMPILE_STATUS_INFO wcsInfo; try { // Register the moffile hr = pIMofComp->CompileFile ( bstrFile, NULL, NULL, NULL, NULL, 0, WBEM_FLAG_UPDATE_FORCE_MODE, 0, &wcsInfo ); // If the compilation is not successful if (hr == WBEM_S_FALSE) { _TCHAR szPhaseErr[BUFFER32] = NULL_STRING, szComplErr[BUFFER32] = NULL_STRING; _bstr_t bstrMsg; _stprintf(szPhaseErr, _T("%d"), wcsInfo.lPhaseError); _stprintf(szComplErr, _T("0x%x"), wcsInfo.hRes); WMIFormatMessage(IDS_I_MOF_PARSE_ERROR, 3, bstrMsg, (WCHAR*) bstrFile, szPhaseErr, szComplErr); DisplayMessage((WCHAR*) bstrMsg, CP_OEMCP, TRUE, FALSE); nError = wcsInfo.lPhaseError; } } catch(_com_error& e) { hr = e.Error(); } return hr; } /*------------------------------------------------------------------------- Name :SetBreakEvent Synopsis :This function sets the CTRC+C (break) event flag Type :Member Function Input parameters : bFlag - TRUE or FALSE Output parameters :None Return Type :None Global Variables :None Calling Syntax :SetBreakEvent() -------------------------------------------------------------------------*/ void CWMICommandLine::SetBreakEvent(BOOL bFlag) { m_bBreakEvent = bFlag; } /*------------------------------------------------------------------------- Name :GetBreakEvent Synopsis :This function returns the break event status. Type :Member Function Input parameters :None Output parameters :None Return Type :BOOL Global Variables :None Calling Syntax :GetBreakEvent() -------------------------------------------------------------------------*/ BOOL CWMICommandLine::GetBreakEvent() { return m_bBreakEvent; } /*------------------------------------------------------------------------- Name :SetAcceptCommand Synopsis :This function sets the accept command flag Type :Member Function Input parameters : bFlag - TRUE or FALSE Output parameters :None Return Type :None Global Variables :None Calling Syntax :SetAcceptComamnd() -------------------------------------------------------------------------*/ void CWMICommandLine::SetAcceptCommand(BOOL bFlag) { m_bAccCmd = bFlag; } /*------------------------------------------------------------------------- Name :GetAcceptCommand Synopsis :This function returns accept command flag status. Type :Member Function Input parameters :None Output parameters :None Return Type :BOOL Global Variables :None Calling Syntax :GetAcceptCommand() -------------------------------------------------------------------------*/ BOOL CWMICommandLine::GetAcceptCommand() { return m_bAccCmd; } /*------------------------------------------------------------------------- Name :GetDisplayResultsFlag Synopsis :This function returns Display Results flag status. Type :Member Function Input parameters :None Output parameters :None Return Type :BOOL Global Variables :None Calling Syntax :GetDisplayResultsFlag() -------------------------------------------------------------------------*/ BOOL CWMICommandLine::GetDisplayResultsFlag() { return m_bDispRes; } /*------------------------------------------------------------------------- Name :SetDisplayResultsFlag Synopsis :This function sets the display results flag status Type :Member Function Input parameters : bFlag - TRUE or FALSE Output parameters :None Return Type :None Global Variables :None Calling Syntax :SetDisplayResultsFlag() -------------------------------------------------------------------------*/ void CWMICommandLine::SetDisplayResultsFlag(BOOL bFlag) { m_bDispRes = bFlag; } /*------------------------------------------------------------------------- Name :SetInitWinSock Synopsis :This function sets the windows socket library initialization status Type :Member Function Input parameters : bFlag - TRUE or FALSE Output parameters :None Return Type :None Global Variables :None Calling Syntax :SetInitWinSock() -------------------------------------------------------------------------*/ void CWMICommandLine::SetInitWinSock(BOOL bFlag) { m_bInitWinSock = bFlag; } /*------------------------------------------------------------------------- Name :GetInitWinSock Synopsis :This function returns the socket library initialization status Type :Member Function Input parameters :None Output parameters :None Return Type :BOOL Global Variables :None Calling Syntax :GetInitWinSock() -------------------------------------------------------------------------*/ BOOL CWMICommandLine::GetInitWinSock() { return m_bInitWinSock; } /*------------------------------------------------------------------------- Name :AddToClipBoardBuffer Synopsis :This function buffers the data to be added to the clip board. Type :Member Function Input parameters :pszOutput - string to be buffered Output parameters :None Return Type :void Global Variables :None Calling Syntax :AddToClipBoardBuffer(pszOutput) -------------------------------------------------------------------------*/ void CWMICommandLine::AddToClipBoardBuffer(LPCWSTR pszOutput) { try { if ( pszOutput != NULL ) { m_chsClipBoardBuffer += pszOutput; } } catch(CHeap_Exception) { _com_issue_error(WBEM_E_OUT_OF_MEMORY); } } /*------------------------------------------------------------------------- Name :GetClipBoardBuffer Synopsis :This function return the buffered data for the clipboard Type :Member Function Input parameters :None Output parameters :None Return Type :_bstr_t& Global Variables :None Calling Syntax :GetClipBoardBuffer() -------------------------------------------------------------------------*/ CHString& CWMICommandLine::GetClipBoardBuffer() { return m_chsClipBoardBuffer; } // Clear Clip Board Buffer. /*------------------------------------------------------------------------- Name :EmptyClipBoardBuffer Synopsis :This function clears the clipboard buffer. Type :Member Function Input parameters :None Output parameters :None Return Type :void Global Variables :None Calling Syntax :EmptyClipBoardBuffer() -------------------------------------------------------------------------*/ void CWMICommandLine::EmptyClipBoardBuffer() { m_chsClipBoardBuffer.Empty(); } /*------------------------------------------------------------------------- Name :ReadXMLOrBatchFile Synopsis :Check if the file is xml or batch file. If it is batch file then parse it, get commands and write the commands into batch file. Type :Member Function Input parameters : hInFile - Handle to XML or Batch file Output parameters :None Return Type :BOOL Global Variables :None Calling Syntax :ReadXMLOrBatchFile() -------------------------------------------------------------------------*/ BOOL CWMICommandLine::ReadXMLOrBatchFile(HANDLE hInFile) { // Check if the file is xml, if yes store its contents in buffer, parse // it and then store parsed info in another file, if not then copy all // contents in another file as it is. HRESULT hr = 0; BOOL bRetValue = TRUE; HANDLE hOutFile = NULL; IXMLDOMDocument *pIXMLDOMDocument = NULL; IXMLDOMElement *pIXMLDOMElement = NULL; IXMLDOMNode *pIXMLDOMNode = NULL; IXMLDOMNodeList *pIXMLDOMNodeList = NULL; BSTR bstrItemText = NULL; DWORD dwThreadId = GetCurrentThreadId(); // Get the TRACE status BOOL bTrace = m_ParsedInfo.GetGlblSwitchesObject().GetTraceStatus(); // Get the Logging mode (VERBOSE | ERRORONLY | NOLOGGING) ERRLOGOPT eloErrLogOpt = m_ParsedInfo.GetErrorLogObject().GetErrLogOption(); try { //Read all input bytes DWORD dwNumberOfBytes = 0; _bstr_t bstrInput; _TCHAR* pszBuffer = NULL; while(TRUE) { pszBuffer = new _TCHAR[MAX_BUFFER]; if (pszBuffer) { TCHAR *pBuf = NULL; pBuf = _fgetts(pszBuffer, MAX_BUFFER-1, stdin); // Indicates end of file if (pBuf == NULL) { SAFEDELETE(pszBuffer); break; } bstrInput += _bstr_t(pszBuffer) + _bstr_t("\n"); } else break; SAFEDELETE(pszBuffer); } //Create a file and returns the handle hOutFile = CreateFile(TEMP_BATCH_FILE, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hOutFile == INVALID_HANDLE_VALUE) { throw (::GetLastError());; } hr=CoCreateInstance(CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument2, (LPVOID*)&pIXMLDOMDocument); if (bTrace || eloErrLogOpt) { CHString chsMsg; chsMsg.Format(L"CoCreateInstance(CLSID_FreeThreadedDOMDocument, " L"NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument2," L" -)"); WMITRACEORERRORLOG(hr, __LINE__, __FILE__, (LPCWSTR)chsMsg, dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); VARIANT_BOOL bSuccess = VARIANT_FALSE; hr = pIXMLDOMDocument->loadXML(bstrInput,&bSuccess); if(FAILED(hr) || bSuccess == VARIANT_FALSE) { //writes data to a file if (!WriteFile(hOutFile, (LPSTR)bstrInput, bstrInput.length(), &dwNumberOfBytes, NULL)) { throw(::GetLastError()); } } else { // Traverse the XML node and get the content of COMMANDLINE nodes // Get the document element. hr = pIXMLDOMDocument->get_documentElement(&pIXMLDOMElement); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMDocument::get_documentElement(-)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); if (pIXMLDOMElement != NULL) { hr = pIXMLDOMElement->getElementsByTagName( _bstr_t(L"COMMANDLINE"), &pIXMLDOMNodeList); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMElement::getElementsByTagName" L"(L\"COMMANDLINE\", -)"),dwThreadId,m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); LONG value = 0; hr = pIXMLDOMNodeList->get_length(&value); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMNodeList::get_length(-)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); for(WMICLIINT i = 0; i < value; i++) { hr = pIXMLDOMNodeList->get_item(i, &pIXMLDOMNode); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMNodeList::get_item(-,-)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); if (pIXMLDOMNode == NULL) continue; hr = pIXMLDOMNode->get_text(&bstrItemText); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMNode::get_text(-)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); //write in the file _bstr_t bstrItem = _bstr_t(bstrItemText); BOOL bRetCode = WriteFile(hOutFile, (LPSTR)bstrItem, bstrItem.length(), &dwNumberOfBytes, NULL); if(bRetCode == 0) { throw (::GetLastError()); } bRetCode = WriteFile(hOutFile, "\n", 1, &dwNumberOfBytes, NULL); if(bRetCode == 0) { throw (::GetLastError()); } SAFEBSTRFREE(bstrItemText); SAFEIRELEASE(pIXMLDOMNode); } SAFEIRELEASE(pIXMLDOMNodeList); SAFEIRELEASE(pIXMLDOMElement); } SAFEIRELEASE(pIXMLDOMDocument); } if(hInFile) CloseHandle(hInFile); if(hOutFile) CloseHandle(hOutFile); _tfreopen(_T("CONIN$"),_T("r"),stdin); bRetValue=TRUE; } catch(_com_error& e) { SAFEIRELEASE(pIXMLDOMDocument); SAFEIRELEASE(pIXMLDOMElement); SAFEIRELEASE(pIXMLDOMNode); SAFEIRELEASE(pIXMLDOMNodeList); SAFEBSTRFREE(bstrItemText); if(hInFile) CloseHandle(hInFile); if(hOutFile) CloseHandle(hOutFile); m_ParsedInfo.GetCmdSwitchesObject().SetCOMError(e); bRetValue = FALSE; GetFormatObject().DisplayResults(m_ParsedInfo, CP_OEMCP); } catch(DWORD dwError) { SAFEIRELEASE(pIXMLDOMDocument); SAFEIRELEASE(pIXMLDOMElement); SAFEIRELEASE(pIXMLDOMNode); SAFEIRELEASE(pIXMLDOMNodeList); SAFEBSTRFREE(bstrItemText); if(hInFile) CloseHandle(hInFile); if(hOutFile) CloseHandle(hOutFile); ::SetLastError(dwError); DisplayWin32Error(); m_ParsedInfo.GetCmdSwitchesObject().SetErrataCode(dwError); ::SetLastError(dwError); bRetValue=FALSE; GetFormatObject().DisplayResults(m_ParsedInfo, CP_OEMCP); } catch(CHeap_Exception) { SAFEIRELEASE(pIXMLDOMDocument); SAFEIRELEASE(pIXMLDOMElement); SAFEIRELEASE(pIXMLDOMNode); SAFEIRELEASE(pIXMLDOMNodeList); SAFEBSTRFREE(bstrItemText); if(hInFile) CloseHandle(hInFile); if(hOutFile) CloseHandle(hOutFile); bRetValue=FALSE; _com_issue_error(WBEM_E_OUT_OF_MEMORY); } return bRetValue; } /*------------------------------------------------------------------------- Name :FrameXMLHeader Synopsis :Frames the XML header info Type :Member Function Input parameters : nIter - Every count Output parameters : bstrHeader - String to containg XML header info Return Type :void Global Variables :None Calling Syntax :FrameXMLHeader() -------------------------------------------------------------------------*/ void CWMICommandLine::FrameXMLHeader(_bstr_t& bstrHeader, WMICLIINT nIter) { try { CHString strTemp; _bstr_t bstrString = m_ParsedInfo.GetGlblSwitchesObject(). GetMgmtStationName(); FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"", m_ParsedInfo.GetGlblSwitchesObject().GetSequenceNumber(), (TCHAR*)bstrString, m_ParsedInfo.GetGlblSwitchesObject().GetStartTime(), nIter); bstrHeader = _bstr_t(strTemp); } catch(_com_error& e) { _com_issue_error(e.Error()); } //trap to catch CHeap_Exception catch(CHeap_Exception) { _com_issue_error(WBEM_E_OUT_OF_MEMORY); } } /*------------------------------------------------------------------------- Name :FrameRequestNode Synopsis :Frames the XML string for Request info Type :Member Function Input parameters :None Output parameters : bstrRequest - String to containg Request info in XML form Return Type :void Global Variables :None Calling Syntax :FrameRequestNode() -------------------------------------------------------------------------*/ void CWMICommandLine::FrameRequestNode(_bstr_t& bstrRequest) { try { CHString strTemp; _bstr_t bstrContext; _bstr_t bstrCommandComponent; bstrRequest = L""; _bstr_t bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetCommandInput(); FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (TCHAR*)bstrString); bstrRequest += _bstr_t(strTemp); FrameCommandLineComponents(bstrCommandComponent); bstrRequest += bstrCommandComponent; FrameContextInfoFragment(bstrContext); bstrRequest += bstrContext; bstrRequest += L""; } catch(_com_error& e) { _com_issue_error(e.Error()); } //trap to catch CHeap_Exception catch(CHeap_Exception) { _com_issue_error(WBEM_E_OUT_OF_MEMORY); } } /*------------------------------------------------------------------------- Name :FrameContextInfoFragment Synopsis :Frames the XML string for context info Type :Member Function Input parameters :None Output parameters : bstrContext - String to containg context info in XML form Return Type :void Global Variables :None Calling Syntax :FrameContextInfoFragment() -------------------------------------------------------------------------*/ void CWMICommandLine::FrameContextInfoFragment(_bstr_t& bstrContext) { try { _bstr_t bstrAuthLevel, bstrImpLevel, bstrPrivileges, bstrTrace, bstrRecordPath, bstrInteractive, bstrFailFast, bstrAppend, bstrOutput, bstrUser, bstrAggregate, bstrNamespace, bstrRole, bstrLocale; CHString strTemp; m_ParsedInfo.GetGlblSwitchesObject().GetImpLevelTextDesc(bstrImpLevel); m_ParsedInfo.GetGlblSwitchesObject().GetAuthLevelTextDesc(bstrAuthLevel); m_ParsedInfo.GetGlblSwitchesObject().GetPrivilegesTextDesc(bstrPrivileges); m_ParsedInfo.GetGlblSwitchesObject().GetTraceTextDesc(bstrTrace); m_ParsedInfo.GetGlblSwitchesObject().GetInteractiveTextDesc(bstrInteractive); m_ParsedInfo.GetGlblSwitchesObject().GetFailFastTextDesc(bstrFailFast); m_ParsedInfo.GetGlblSwitchesObject().GetAggregateTextDesc(bstrAggregate); m_ParsedInfo.GetGlblSwitchesObject().GetOutputOrAppendTextDesc(bstrOutput, TRUE); FindAndReplaceEntityReferences(bstrOutput); m_ParsedInfo.GetGlblSwitchesObject().GetOutputOrAppendTextDesc(bstrAppend, FALSE); FindAndReplaceEntityReferences(bstrAppend); m_ParsedInfo.GetGlblSwitchesObject().GetRecordPathDesc(bstrRecordPath); FindAndReplaceEntityReferences(bstrRecordPath); m_ParsedInfo.GetUserDesc(bstrUser); FindAndReplaceEntityReferences(bstrUser); bstrNamespace = m_ParsedInfo.GetGlblSwitchesObject().GetNameSpace(); FindAndReplaceEntityReferences(bstrNamespace); bstrRole = m_ParsedInfo.GetGlblSwitchesObject().GetRole(); FindAndReplaceEntityReferences(bstrRole); bstrLocale = m_ParsedInfo.GetGlblSwitchesObject().GetLocale(); FindAndReplaceEntityReferences(bstrLocale); strTemp.Format(L"%s%s" L"%s%s" L"%s%s" L"%s%s" L"%s" L"%s%s" L"%s%s" L"%s", (LPWSTR)bstrNamespace, (LPWSTR)bstrRole, (LPWSTR)bstrImpLevel, (LPWSTR) bstrAuthLevel, (LPWSTR)bstrLocale, (LPWSTR)bstrPrivileges, (LPWSTR)bstrTrace, (LPWSTR)bstrRecordPath, (LPWSTR) bstrInteractive, (LPWSTR)bstrFailFast, (LPWSTR) bstrOutput, (LPWSTR)bstrAppend, (LPWSTR) bstrUser, (LPWSTR)bstrAggregate); bstrContext = strTemp; } catch(_com_error& e) { _com_issue_error(e.Error()); } //trap to catch CHeap_Exception catch(CHeap_Exception) { _com_issue_error(WBEM_E_OUT_OF_MEMORY); } } /*------------------------------------------------------------------------- Name :FrameCommandLineComponents Synopsis :Frames the XML string for commandline info Type :Member Function Input parameters :None Output parameters : bstrContext - String to containg commandline info in XML form Return Type :void Global Variables :None Calling Syntax :FrameCommandLineComponents() -------------------------------------------------------------------------*/ void CWMICommandLine::FrameCommandLineComponents(_bstr_t& bstrCommandComponent) { try { CHString strTemp; _bstr_t bstrNodeList; bstrCommandComponent = L""; FrameNodeListFragment(bstrNodeList); bstrCommandComponent += bstrNodeList; _TCHAR *pszVerbName = m_ParsedInfo.GetCmdSwitchesObject(). GetVerbName(); if(CompareTokens(pszVerbName, CLI_TOKEN_LIST)) { _bstr_t bstrString = m_ParsedInfo.GetCmdSwitchesObject(). GetAliasName(); if (!bstrString) bstrString = L"N/A"; FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (TCHAR*)bstrString); bstrCommandComponent += _bstr_t(strTemp); bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetAliasTarget(); if (!bstrString) bstrString = L"N/A"; FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (TCHAR*)bstrString); bstrCommandComponent += _bstr_t(strTemp); _bstr_t bstrClassName; m_ParsedInfo.GetCmdSwitchesObject().GetClassOfAliasTarget(bstrClassName); if (!bstrClassName) bstrClassName = L"N/A"; bstrCommandComponent += L""; bstrCommandComponent += bstrClassName; bstrCommandComponent += L""; bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetPWhereExpr(); if (!bstrString) bstrString = L"N/A"; FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (TCHAR*)bstrString); bstrCommandComponent += _bstr_t(strTemp); bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetAliasNamespace(); if (!bstrString) bstrString = L"N/A"; FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (TCHAR*)bstrString); bstrCommandComponent += _bstr_t(strTemp); bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetAliasDesc(); if (!bstrString) bstrString = L"N/A"; FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (TCHAR*)bstrString); bstrCommandComponent += _bstr_t(strTemp); bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetFormedQuery(); if (!bstrString) bstrString = L"N/A"; FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (TCHAR*)bstrString); bstrCommandComponent += _bstr_t(strTemp); _bstr_t bstrFormats; FrameFormats(bstrFormats); bstrCommandComponent += bstrFormats; _bstr_t bstrProperties; FramePropertiesInfo(bstrProperties); bstrCommandComponent += bstrProperties; } bstrCommandComponent += L""; } catch(_com_error& e) { _com_issue_error(e.Error()); } //trap to catch CHeap_Exception catch(CHeap_Exception) { _com_issue_error(WBEM_E_OUT_OF_MEMORY); } } /*------------------------------------------------------------------------- Name :FrameNodeListFragment Synopsis :Frames the XML string for NodeList info Type :Member Function Input parameters :None Output parameters : bstrContext - String to containg NodeList info in XML form Return Type :void Global Variables :None Calling Syntax :FrameNodeListFragment() -------------------------------------------------------------------------*/ void CWMICommandLine::FrameNodeListFragment(_bstr_t& bstrNodeList) { try { CHString strTemp; CHARVECTOR::iterator itrStart, itrEnd; CHARVECTOR cvNodes; _bstr_t bstrString ; bstrNodeList = L""; cvNodes = m_ParsedInfo.GetGlblSwitchesObject().GetNodesList(); if (cvNodes.size() > 1) { itrStart = cvNodes.begin(); itrEnd = cvNodes.end(); // Move to next node itrStart++; while (itrStart != itrEnd) { bstrString = _bstr_t(*itrStart); if (!bstrString) bstrString = L"N/A"; FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (LPWSTR)bstrString); bstrNodeList += _bstr_t(strTemp); itrStart++; } } else { bstrString = _bstr_t(m_ParsedInfo.GetGlblSwitchesObject(). GetNode()); if (!bstrString) bstrString = L"N/A"; FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (LPWSTR)bstrString); bstrNodeList += _bstr_t(strTemp); } bstrNodeList += L""; } catch(_com_error& e) { _com_issue_error(e.Error()); } //trap to catch CHeap_Exception catch(CHeap_Exception) { _com_issue_error(WBEM_E_OUT_OF_MEMORY); } } /*------------------------------------------------------------------------- Name :FrameFormats Synopsis :Frames the XML string for formats info Type :Member Function Input parameters :None Output parameters : bstrContext - String to containg formats info in XML form Return Type :void Global Variables :None Calling Syntax :FrameFormats() -------------------------------------------------------------------------*/ void CWMICommandLine::FrameFormats(_bstr_t& bstrFormats) { try { CHString strTemp; XSLTDETVECTOR::iterator theIterator = NULL, theEndIterator = NULL; BSTRMAP::iterator theMapIterator = NULL, theMapEndIterator = NULL; _bstr_t bstrString; if(!m_ParsedInfo.GetCmdSwitchesObject().GetXSLTDetailsVector().empty()) { bstrFormats = L""; bstrFormats += L""; theIterator = m_ParsedInfo.GetCmdSwitchesObject(). GetXSLTDetailsVector().begin(); theEndIterator = m_ParsedInfo.GetCmdSwitchesObject(). GetXSLTDetailsVector().end(); while (theIterator != theEndIterator) { bstrString = _bstr_t((*theIterator).FileName); FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (_TCHAR*)bstrString); bstrFormats += _bstr_t(strTemp); theMapIterator = (*theIterator).ParamMap.begin(); theMapEndIterator = (*theIterator).ParamMap.end(); while (theMapIterator != theMapEndIterator) { bstrString = _bstr_t((*theMapIterator).first); FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (_TCHAR*)bstrString); bstrFormats += _bstr_t(strTemp); bstrString = _bstr_t((*theMapIterator).second); FindAndReplaceEntityReferences(bstrString); strTemp.Format(L"%s", (_TCHAR*)bstrString); bstrFormats += _bstr_t(strTemp); bstrFormats += L""; theMapIterator++; } theIterator++; } bstrFormats += L""; bstrFormats += L""; } } catch(_com_error& e) { _com_issue_error(e.Error()); } //trap to catch CHeap_Exception catch(CHeap_Exception) { _com_issue_error(WBEM_E_OUT_OF_MEMORY); } } /*------------------------------------------------------------------------- Name :FramePropertiesInfo Synopsis :Frames the XML string for properties info Type :Member Function Input parameters :None Output parameters : bstrContext - String to containg properties info in XML form Return Type :void Global Variables :None Calling Syntax :FramePropertiesInfo() -------------------------------------------------------------------------*/ void CWMICommandLine::FramePropertiesInfo(_bstr_t& bstrProperties) { try { CHString strTemp; PROPDETMAP::iterator theIterator = NULL, theEndIterator = NULL; if(!m_ParsedInfo.GetCmdSwitchesObject().GetPropDetMap().empty()) { bstrProperties = L""; theIterator = m_ParsedInfo.GetCmdSwitchesObject(). GetPropDetMap().begin(); theEndIterator = m_ParsedInfo.GetCmdSwitchesObject(). GetPropDetMap().end(); while (theIterator != theEndIterator) { bstrProperties += L""; strTemp.Format(L"%s", (_TCHAR*)(*theIterator).first); bstrProperties += _bstr_t(strTemp); strTemp.Format(L"%s", (_TCHAR*)(*theIterator).second.Derivation); bstrProperties += _bstr_t(strTemp); bstrProperties += L""; theIterator++; } bstrProperties += L""; } } catch(_com_error& e) { _com_issue_error(e.Error()); } //trap to catch CHeap_Exception catch(CHeap_Exception) { _com_issue_error(WBEM_E_OUT_OF_MEMORY); } } /*------------------------------------------------------------------------- Name :GetFileNameMap Synopsis :Frames the BSTR Map contains the key words and corresponding files from the XSL mapping file Type :Member Function Input parameters :None Output parameters :None Return Type :void Global Variables :None Calling Syntax :GetFileNameMap() -------------------------------------------------------------------------*/ void CWMICommandLine::GetFileNameMap() { _TCHAR* pszFilePath = new _TCHAR[MAX_PATH+1]; BSTRMAP::iterator theMapIterator = NULL; UINT nSize = 0; try { _bstr_t bstrFilePath; if(pszFilePath == NULL) throw OUT_OF_MEMORY; nSize = GetSystemDirectory(pszFilePath, MAX_PATH+1); if(nSize) { if(nSize > MAX_PATH) { SAFEDELETE(pszFilePath); pszFilePath = new _TCHAR[nSize + 1]; if(pszFilePath == NULL) { throw OUT_OF_MEMORY; } if(!GetSystemDirectory(pszFilePath, nSize+1)) { SAFEDELETE(pszFilePath); throw (::GetLastError()); } } bstrFilePath = _bstr_t(pszFilePath); bstrFilePath += _bstr_t(WBEM_LOCATION) + _bstr_t(CLI_XSLMAPPINGS_FILE); SAFEDELETE(pszFilePath); } else { SAFEDELETE(pszFilePath); throw (::GetLastError()); } GetXSLMappings(bstrFilePath); } catch(_com_error &e) { SAFEDELETE(pszFilePath); _com_issue_error(e.Error()); } catch(CHeap_Exception) { SAFEDELETE(pszFilePath); _com_issue_error(WBEM_E_OUT_OF_MEMORY); } } /*------------------------------------------------------------------------- Name :GetFileFromKey Synopsis :Gets the xslfile name corrsponding to the keyword passed from the BSTRMAP Type :Member Function Input parameters :bstrkeyName - key word Output parameters :bstrFileName - the xsl filename Return Type :BOOL Global Variables :None Calling Syntax :GetFileFromKey(bstrkeyName, bstrFileName) -------------------------------------------------------------------------*/ BOOL CWMICommandLine::GetFileFromKey(_bstr_t bstrkeyName, _bstr_t& bstrFileName) { BOOL bFound = TRUE; BSTRMAP::iterator theMapIterator = NULL; if (Find(m_bmKeyWordtoFileName,bstrkeyName,theMapIterator) == TRUE) bstrFileName = (*theMapIterator).second; else bFound = FALSE; return bFound; } /*------------------------------------------------------------------------- Name :GetXSLMappings Synopsis :Get the XSL file names for keywords Type :Member Function Input parameters : pszFilePath - XSL mappings file path Output parameters :None Return Type :void Global Variables :None Calling Syntax :GetXSLMappings(pszFilePath) -------------------------------------------------------------------------*/ void CWMICommandLine::GetXSLMappings(_TCHAR *pszFilePath) { HRESULT hr = 0; BOOL bContinue = TRUE; IXMLDOMDocument *pIXMLDOMDocument = NULL; IXMLDOMElement *pIXMLDOMElement = NULL; IXMLDOMNode *pIXMLDOMNode = NULL; IXMLDOMNodeList *pIXMLDOMNodeList = NULL; IXMLDOMNamedNodeMap *pIXMLDOMNamedNodeMap = NULL; IXMLDOMNode *pIXMLDOMNodeKeyName = NULL; DWORD dwThreadId = GetCurrentThreadId(); BSTR bstrItemText = NULL; VARIANT varValue, varObject; VariantInit(&varValue); VariantInit(&varObject); // Get the TRACE status BOOL bTrace = m_ParsedInfo.GetGlblSwitchesObject().GetTraceStatus(); // Get the Logging mode (VERBOSE | ERRORONLY | NOLOGGING) ERRLOGOPT eloErrLogOpt = m_ParsedInfo.GetErrorLogObject().GetErrLogOption(); try { hr=CoCreateInstance(CLSID_FreeThreadedDOMDocument, NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument2, (LPVOID*)&pIXMLDOMDocument); if (bTrace || eloErrLogOpt) { CHString chsMsg; chsMsg.Format(L"CoCreateInstance(CLSID_FreeThreadedDOMDocument, " L"NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument2," L" -)"); WMITRACEORERRORLOG(hr, __LINE__, __FILE__, (LPCWSTR)chsMsg, dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); VARIANT_BOOL bSuccess = VARIANT_FALSE; VariantInit(&varObject); varObject.vt = VT_BSTR; varObject.bstrVal = SysAllocString(pszFilePath); if (varObject.bstrVal == NULL) { //Reset the variant, it will be cleaned up by the catch... VariantInit(&varObject); throw CHeap_Exception(CHeap_Exception::E_ALLOCATION_ERROR); } hr = pIXMLDOMDocument->load(varObject,&bSuccess); if(FAILED(hr) || bSuccess == VARIANT_FALSE) { bContinue = FALSE; } if (bContinue) { // Traverse the XML node and get the text of nodes named XSLFORMAT // Get the document element. hr = pIXMLDOMDocument->get_documentElement(&pIXMLDOMElement); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMDocument::get_documentElement(-)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); if (pIXMLDOMElement != NULL) { hr = pIXMLDOMElement->getElementsByTagName( _bstr_t(L"XSLFORMAT"), &pIXMLDOMNodeList); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMElement::getElementsByTagName" L"(L\"XSLFORMAT\", -)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); LONG value = 0; hr = pIXMLDOMNodeList->get_length(&value); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMNodeList::get_length(-)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); for(WMICLIINT i = 0; i < value; i++) { hr = pIXMLDOMNodeList->get_item(i, &pIXMLDOMNode); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMNodeList::get_item(-,-)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); if(pIXMLDOMNode == NULL) continue; hr = pIXMLDOMNode->get_text(&bstrItemText); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMNode::get_text(-)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); hr = pIXMLDOMNode->get_attributes(&pIXMLDOMNamedNodeMap); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMNode::get_attributes(-)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); if(pIXMLDOMNamedNodeMap == NULL) { SAFEBSTRFREE(bstrItemText); SAFEIRELEASE(pIXMLDOMNode); continue; } hr = pIXMLDOMNamedNodeMap->getNamedItem( _bstr_t(L"KEYWORD"), &pIXMLDOMNodeKeyName); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMNamedNodeMap::getNamedItem(L\"KEYWORD\", -)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); if(pIXMLDOMNodeKeyName == NULL) { SAFEBSTRFREE(bstrItemText); SAFEIRELEASE(pIXMLDOMNode); SAFEIRELEASE(pIXMLDOMNamedNodeMap); continue; } VariantInit(&varValue); hr = pIXMLDOMNodeKeyName->get_nodeValue(&varValue); if (bTrace || eloErrLogOpt) { WMITRACEORERRORLOG(hr, __LINE__, __FILE__, _T("IXMLDOMNode::get_nodeValue(-)"), dwThreadId, m_ParsedInfo, bTrace); } ONFAILTHROWERROR(hr); if(varValue.vt == VT_NULL || varValue.vt == VT_EMPTY) { VARIANTCLEAR(varValue); SAFEBSTRFREE(bstrItemText); SAFEIRELEASE(pIXMLDOMNode); SAFEIRELEASE(pIXMLDOMNamedNodeMap); SAFEIRELEASE(pIXMLDOMNodeKeyName); continue; } //forming the BSTRMAP containing key words and filenames m_bmKeyWordtoFileName.insert(BSTRMAP::value_type( varValue.bstrVal, bstrItemText)); VARIANTCLEAR(varValue); SAFEBSTRFREE(bstrItemText); SAFEIRELEASE(pIXMLDOMNode); SAFEIRELEASE(pIXMLDOMNamedNodeMap); SAFEIRELEASE(pIXMLDOMNodeKeyName); } VARIANTCLEAR(varValue); SAFEIRELEASE(pIXMLDOMNodeList); SAFEIRELEASE(pIXMLDOMElement); } SAFEIRELEASE(pIXMLDOMDocument); } VARIANTCLEAR(varObject); } catch(_com_error) { VARIANTCLEAR(varValue); VARIANTCLEAR(varObject); SAFEIRELEASE(pIXMLDOMDocument); SAFEIRELEASE(pIXMLDOMElement); SAFEIRELEASE(pIXMLDOMNode); SAFEIRELEASE(pIXMLDOMNodeList); SAFEIRELEASE(pIXMLDOMNamedNodeMap); SAFEIRELEASE(pIXMLDOMNodeKeyName); SAFEBSTRFREE(bstrItemText); } catch(CHeap_Exception) { VARIANTCLEAR(varValue); VARIANTCLEAR(varObject); SAFEIRELEASE(pIXMLDOMDocument); SAFEIRELEASE(pIXMLDOMElement); SAFEIRELEASE(pIXMLDOMNode); SAFEIRELEASE(pIXMLDOMNodeList); SAFEIRELEASE(pIXMLDOMNamedNodeMap); SAFEIRELEASE(pIXMLDOMNodeKeyName); SAFEBSTRFREE(bstrItemText); _com_issue_error(WBEM_E_OUT_OF_MEMORY); } } /*------------------------------------------------------------------------ Name :GetTokenVector Synopsis :This function returns a reference to the token vector Type :Member Function Input parameter :None Output parameters :None Return Type :CHARVECTOR& Global Variables :None Calling Syntax :GetTokenVector() Notes :None ------------------------------------------------------------------------*/ CHARVECTOR& CWMICommandLine::GetTokenVector() { return m_ParserEngine.GetCmdTokenizer().GetTokenVector(); }