archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
4.9 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/admin/wmi/wbem/tools/wmic/wmicmdln.cpp

2857 lines
82 KiB
Raw Blame History

/***************************************************************************
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"<RESULTS NODE=\"%s\">",
(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"<ERROR><DESCRIPTION>"
L"%s</DESCRIPTION>"
L"</ERROR>",
(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"</RESULTS>";
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"</COMMAND>";
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"</COMMAND>";
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"<COMMAND SEQUENCENUM=\"%d\" ISSUEDFROM=\"%s\" "
L"STARTTIME=\"%s\" EVERYCOUNT=\"%d\">",
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"<REQUEST>";
_bstr_t bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetCommandInput();
FindAndReplaceEntityReferences(bstrString);
strTemp.Format(L"<COMMANDLINE>%s</COMMANDLINE>",
(TCHAR*)bstrString);
bstrRequest += _bstr_t(strTemp);
FrameCommandLineComponents(bstrCommandComponent);
bstrRequest += bstrCommandComponent;
FrameContextInfoFragment(bstrContext);
bstrRequest += bstrContext;
bstrRequest += L"</REQUEST>";
}
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"<CONTEXT><NAMESPACE>%s</NAMESPACE><ROLE>%s</ROLE>"
L"<IMPLEVEL>%s</IMPLEVEL><AUTHLEVEL>%s</AUTHLEVEL>"
L"<LOCALE>%s</LOCALE><PRIVILEGES>%s</PRIVILEGES>"
L"<TRACE>%s</TRACE><RECORD>%s</RECORD>"
L"<INTERACTIVE>%s</INTERACTIVE>"
L"<FAILFAST>%s</FAILFAST><OUTPUT>%s</OUTPUT>"
L"<APPEND>%s</APPEND><USER>%s</USER>"
L"<AGGREGATE>%s</AGGREGATE></CONTEXT>",
(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"<COMMANDLINECOMPONENTS>";
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"<FRIENDLYNAME>%s</FRIENDLYNAME>",
(TCHAR*)bstrString);
bstrCommandComponent += _bstr_t(strTemp);
bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetAliasTarget();
if (!bstrString)
bstrString = L"N/A";
FindAndReplaceEntityReferences(bstrString);
strTemp.Format(L"<TARGET>%s</TARGET>",
(TCHAR*)bstrString);
bstrCommandComponent += _bstr_t(strTemp);
_bstr_t bstrClassName;
m_ParsedInfo.GetCmdSwitchesObject().GetClassOfAliasTarget(bstrClassName);
if (!bstrClassName)
bstrClassName = L"N/A";
bstrCommandComponent += L"<ALIASTARGET>";
bstrCommandComponent += bstrClassName;
bstrCommandComponent += L"</ALIASTARGET>";
bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetPWhereExpr();
if (!bstrString)
bstrString = L"N/A";
FindAndReplaceEntityReferences(bstrString);
strTemp.Format(L"<PWHERE>%s</PWHERE>",
(TCHAR*)bstrString);
bstrCommandComponent += _bstr_t(strTemp);
bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetAliasNamespace();
if (!bstrString)
bstrString = L"N/A";
FindAndReplaceEntityReferences(bstrString);
strTemp.Format(L"<NAMESPACE>%s</NAMESPACE>",
(TCHAR*)bstrString);
bstrCommandComponent += _bstr_t(strTemp);
bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetAliasDesc();
if (!bstrString)
bstrString = L"N/A";
FindAndReplaceEntityReferences(bstrString);
strTemp.Format(L"<DESCRIPTION>%s</DESCRIPTION>",
(TCHAR*)bstrString);
bstrCommandComponent += _bstr_t(strTemp);
bstrString = m_ParsedInfo.GetCmdSwitchesObject().GetFormedQuery();
if (!bstrString)
bstrString = L"N/A";
FindAndReplaceEntityReferences(bstrString);
strTemp.Format(L"<RESULTANTQUERY>%s</RESULTANTQUERY>",
(TCHAR*)bstrString);
bstrCommandComponent += _bstr_t(strTemp);
_bstr_t bstrFormats;
FrameFormats(bstrFormats);
bstrCommandComponent += bstrFormats;
_bstr_t bstrProperties;
FramePropertiesInfo(bstrProperties);
bstrCommandComponent += bstrProperties;
}
bstrCommandComponent += L"</COMMANDLINECOMPONENTS>";
}
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"<NODELIST>";
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"<NODE>%s</NODE>", (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"<NODE>%s</NODE>", (LPWSTR)bstrString);
bstrNodeList += _bstr_t(strTemp);
}
bstrNodeList += L"</NODELIST>";
}
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"<FORMATS>";
bstrFormats += L"<FORMAT>";
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"<NAME>%s</NAME>",
(_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"<PARAM><NAME>%s</NAME>",
(_TCHAR*)bstrString);
bstrFormats += _bstr_t(strTemp);
bstrString = _bstr_t((*theMapIterator).second);
FindAndReplaceEntityReferences(bstrString);
strTemp.Format(L"<VALUE>%s</VALUE>",
(_TCHAR*)bstrString);
bstrFormats += _bstr_t(strTemp);
bstrFormats += L"</PARAM>";
theMapIterator++;
}
theIterator++;
}
bstrFormats += L"</FORMAT>";
bstrFormats += L"</FORMATS>";
}
}
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"<PROPERTIES>";
theIterator = m_ParsedInfo.GetCmdSwitchesObject().
GetPropDetMap().begin();
theEndIterator = m_ParsedInfo.GetCmdSwitchesObject().
GetPropDetMap().end();
while (theIterator != theEndIterator)
{
bstrProperties += L"<PROPERTY>";
strTemp.Format(L"<NAME>%s</NAME>",
(_TCHAR*)(*theIterator).first);
bstrProperties += _bstr_t(strTemp);
strTemp.Format(L"<DERIVATION>%s</DERIVATION>",
(_TCHAR*)(*theIterator).second.Derivation);
bstrProperties += _bstr_t(strTemp);
bstrProperties += L"</PROPERTY>";
theIterator++;
}
bstrProperties += L"</PROPERTIES>";
}
}
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();
}