1194 lines
44 KiB
C++
1194 lines
44 KiB
C++
/*****************************************************************************
|
|
|
|
Copyright (c) Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
ETQuery.CPP
|
|
|
|
Abstract:
|
|
|
|
This module is intended to have the functionality for EVENTTRIGGERS.EXE
|
|
with -query parameter.
|
|
|
|
This will Query WMI and shows presently available Event Triggers.
|
|
|
|
Author:
|
|
Akhil Gokhale 03-Oct.-2000 (Created it)
|
|
|
|
Revision History:
|
|
|
|
******************************************************************************/
|
|
#include "pch.h"
|
|
#include "ETCommon.h"
|
|
#include "resource.h"
|
|
#include "ShowError.h"
|
|
#include "ETQuery.h"
|
|
#include "WMI.h"
|
|
#define DEFAULT_USER L"NT AUTHORITY\\SYSTEM"
|
|
#define DBL_SLASH L"\\\\";
|
|
// Defines local to this file
|
|
|
|
#define SHOW_WQL_QUERY L"select * from __instancecreationevent where"
|
|
#define QUERY_STRING_AND L"select * from __instancecreationevent where \
|
|
targetinstance isa \"win32_ntlogevent\" AND"
|
|
#define BLANK_LINE L"\n"
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Class default constructor.
|
|
//
|
|
// Arguments:
|
|
// None
|
|
// Return Value:
|
|
// None
|
|
//
|
|
//***************************************************************************
|
|
|
|
CETQuery::CETQuery()
|
|
{
|
|
// init to defaults
|
|
m_bNeedDisconnect = FALSE;
|
|
|
|
m_pszServerName = NULL;
|
|
m_pszUserName = NULL;
|
|
m_pszPassword = NULL;
|
|
m_pszFormat = NULL;
|
|
m_bVerbose = FALSE;
|
|
m_bNoHeader = FALSE;
|
|
m_pszEventDesc = NULL;
|
|
m_pszTask = NULL;
|
|
|
|
|
|
m_bNeedPassword = FALSE;
|
|
m_bUsage = FALSE;
|
|
m_bQuery = FALSE;
|
|
|
|
m_pWbemLocator = NULL;
|
|
m_pWbemServices = NULL;
|
|
m_pAuthIdentity = NULL;
|
|
m_pObj = NULL;
|
|
m_pTriggerEventConsumer = NULL;
|
|
m_pEventFilter = NULL;
|
|
m_arrColData = NULL;
|
|
m_pszBuffer = NULL;
|
|
m_pszEventQuery = NULL;
|
|
m_pszTaskUserName = NULL;
|
|
m_bIsCOMInitialize = FALSE;
|
|
|
|
m_hStdHandle = NULL;
|
|
|
|
m_pClass = NULL;
|
|
m_pInClass = NULL;
|
|
m_pInInst = NULL;
|
|
m_pOutInst = NULL;
|
|
|
|
m_lHostNameColWidth = WIDTH_HOSTNAME;
|
|
m_lTriggerIDColWidth = WIDTH_TRIGGER_ID;
|
|
m_lETNameColWidth = WIDTH_TRIGGER_NAME;
|
|
m_lTaskColWidth = WIDTH_TASK;
|
|
m_lQueryColWidth = WIDTH_EVENT_QUERY;
|
|
m_lDescriptionColWidth = WIDTH_DESCRIPTION;
|
|
m_lWQLColWidth = 0;
|
|
m_lTaskUserName = WIDTH_TASK_USERNAME;
|
|
}
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Class constructor.
|
|
//
|
|
// Arguments:
|
|
// None
|
|
// Return Value:
|
|
// None
|
|
//
|
|
//***************************************************************************
|
|
|
|
CETQuery::CETQuery(LONG lMinMemoryReq,BOOL bNeedPassword)
|
|
{
|
|
// init to defaults
|
|
m_bNeedDisconnect = FALSE;
|
|
|
|
m_pszServerName = NULL;
|
|
m_pszUserName = NULL;
|
|
m_pszPassword = NULL;
|
|
m_pszFormat = NULL;
|
|
m_bVerbose = FALSE;
|
|
m_bNoHeader = FALSE;
|
|
m_pszEventDesc = NULL;
|
|
m_pszTask = NULL;
|
|
m_bIsCOMInitialize = FALSE;
|
|
|
|
m_hStdHandle = NULL;
|
|
|
|
m_bNeedPassword = bNeedPassword;
|
|
m_bUsage = FALSE;
|
|
m_bQuery = FALSE;
|
|
m_lMinMemoryReq = lMinMemoryReq;
|
|
|
|
m_pClass = NULL;
|
|
m_pInClass = NULL;
|
|
m_pInInst = NULL;
|
|
m_pOutInst = NULL;
|
|
|
|
m_pWbemLocator = NULL;
|
|
m_pWbemServices = NULL;
|
|
m_pAuthIdentity = NULL;
|
|
m_arrColData = NULL;
|
|
m_pszBuffer = NULL;
|
|
m_pObj = NULL;
|
|
m_pTriggerEventConsumer = NULL;
|
|
m_pEventFilter = NULL;
|
|
m_pszTaskUserName = NULL;
|
|
|
|
m_pszEventQuery = NULL;
|
|
m_lHostNameColWidth = WIDTH_HOSTNAME;
|
|
m_lTriggerIDColWidth = WIDTH_TRIGGER_ID;
|
|
m_lETNameColWidth = WIDTH_TRIGGER_NAME;
|
|
m_lTaskColWidth = WIDTH_TASK;
|
|
m_lQueryColWidth = WIDTH_EVENT_QUERY;
|
|
m_lDescriptionColWidth = WIDTH_DESCRIPTION;
|
|
m_lWQLColWidth = 0;
|
|
m_lTaskUserName = WIDTH_TASK_USERNAME;
|
|
}
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Class desctructor. It frees memory which is allocated during instance
|
|
// creation.
|
|
//
|
|
// Arguments:
|
|
// None
|
|
// Return Value:
|
|
// None
|
|
//
|
|
//***************************************************************************
|
|
|
|
CETQuery::~CETQuery()
|
|
{
|
|
RELEASE_MEMORY_EX(m_pszServerName);
|
|
RELEASE_MEMORY_EX(m_pszUserName);
|
|
RELEASE_MEMORY_EX(m_pszPassword);
|
|
RELEASE_MEMORY_EX(m_pszFormat);
|
|
RELEASE_MEMORY_EX(m_pszBuffer);
|
|
RELEASE_MEMORY_EX(m_pszEventDesc);
|
|
RELEASE_MEMORY_EX(m_pszTask);
|
|
RELEASE_MEMORY_EX(m_pszTaskUserName);
|
|
DESTROY_ARRAY(m_arrColData);
|
|
|
|
|
|
SAFE_RELEASE_INTERFACE(m_pWbemLocator);
|
|
SAFE_RELEASE_INTERFACE(m_pWbemServices);
|
|
SAFE_RELEASE_INTERFACE(m_pObj);
|
|
SAFE_RELEASE_INTERFACE(m_pTriggerEventConsumer);
|
|
SAFE_RELEASE_INTERFACE(m_pEventFilter);
|
|
|
|
SAFE_RELEASE_INTERFACE(m_pClass);
|
|
SAFE_RELEASE_INTERFACE(m_pInClass);
|
|
SAFE_RELEASE_INTERFACE(m_pInInst);
|
|
SAFE_RELEASE_INTERFACE(m_pOutInst);
|
|
|
|
RELEASE_MEMORY_EX(m_pszEventQuery);
|
|
|
|
// Uninitialize COM only when it is initialized.
|
|
if(m_bIsCOMInitialize == TRUE)
|
|
{
|
|
CoUninitialize();
|
|
}
|
|
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This function will prepare column structure for DoParseParam Function.
|
|
//
|
|
// Arguments:
|
|
// none
|
|
// Return Value:
|
|
// none
|
|
// ***************************************************************************
|
|
|
|
void CETQuery::PrepareCMDStruct()
|
|
{
|
|
// -delete
|
|
lstrcpy(cmdOptions[ ID_Q_QUERY ].szOption,OPTION_QUERY);
|
|
cmdOptions[ ID_Q_QUERY ].dwFlags = CP_MAIN_OPTION;
|
|
cmdOptions[ ID_Q_QUERY ].dwCount = 1;
|
|
cmdOptions[ ID_Q_QUERY ].dwActuals = 0;
|
|
cmdOptions[ ID_Q_QUERY ].pValue = &m_bQuery;
|
|
lstrcpy(cmdOptions[ ID_Q_QUERY ].szValues,NULL_STRING);
|
|
cmdOptions[ ID_Q_QUERY ].pFunction = NULL;
|
|
cmdOptions[ ID_Q_QUERY ].pFunctionData = NULL;
|
|
cmdOptions[ ID_Q_QUERY ].pFunctionData = NULL;
|
|
|
|
// -s (servername)
|
|
lstrcpy(cmdOptions[ ID_Q_SERVER ].szOption,OPTION_SERVER);
|
|
cmdOptions[ ID_Q_SERVER ].dwFlags = CP_TYPE_TEXT|CP_VALUE_MANDATORY;
|
|
cmdOptions[ ID_Q_SERVER ].dwCount = 1;
|
|
cmdOptions[ ID_Q_SERVER ].dwActuals = 0;
|
|
cmdOptions[ ID_Q_SERVER ].pValue = m_pszServerName;
|
|
lstrcpy(cmdOptions[ ID_Q_SERVER ].szValues,NULL_STRING);
|
|
cmdOptions[ ID_Q_SERVER ].pFunction = NULL;
|
|
cmdOptions[ ID_Q_SERVER ].pFunctionData = NULL;
|
|
|
|
// -u (username)
|
|
lstrcpy(cmdOptions[ ID_Q_USERNAME ].szOption,OPTION_USERNAME);
|
|
cmdOptions[ ID_Q_USERNAME ].dwFlags = CP_TYPE_TEXT|CP_VALUE_MANDATORY;
|
|
cmdOptions[ ID_Q_USERNAME ].dwCount = 1;
|
|
cmdOptions[ ID_Q_USERNAME ].dwActuals = 0;
|
|
cmdOptions[ ID_Q_USERNAME ].pValue = m_pszUserName;
|
|
lstrcpy(cmdOptions[ ID_Q_USERNAME ].szValues,NULL_STRING);
|
|
cmdOptions[ ID_Q_USERNAME ].pFunction = NULL;
|
|
cmdOptions[ ID_Q_USERNAME ].pFunctionData = NULL;
|
|
|
|
// -p (password)
|
|
lstrcpy(cmdOptions[ ID_Q_PASSWORD ].szOption,OPTION_PASSWORD);
|
|
cmdOptions[ ID_Q_PASSWORD ].dwFlags = CP_TYPE_TEXT|CP_VALUE_OPTIONAL;
|
|
cmdOptions[ ID_Q_PASSWORD ].dwCount = 1;
|
|
cmdOptions[ ID_Q_PASSWORD ].dwActuals = 0;
|
|
cmdOptions[ ID_Q_PASSWORD ].pValue = m_pszPassword;
|
|
lstrcpy(cmdOptions[ ID_Q_PASSWORD ].szValues,NULL_STRING);
|
|
cmdOptions[ ID_Q_PASSWORD ].pFunction = NULL;
|
|
cmdOptions[ ID_Q_PASSWORD ].pFunctionData = NULL;
|
|
|
|
// -fo
|
|
lstrcpy(cmdOptions[ ID_Q_FORMAT].szOption,OPTION_FORMAT);
|
|
cmdOptions[ ID_Q_FORMAT].dwFlags = CP_TYPE_TEXT|CP_VALUE_MANDATORY|
|
|
CP_MODE_VALUES;
|
|
cmdOptions[ ID_Q_FORMAT].dwCount = 1;
|
|
cmdOptions[ ID_Q_FORMAT].dwActuals = 0;
|
|
cmdOptions[ ID_Q_FORMAT].pValue = m_pszFormat;
|
|
lstrcpy(cmdOptions[ID_Q_FORMAT].szValues,GetResString(IDS_FORMAT_OPTIONS));
|
|
cmdOptions[ ID_Q_FORMAT].pFunction = NULL;
|
|
cmdOptions[ ID_Q_FORMAT].pFunctionData = NULL;
|
|
|
|
// -nh
|
|
lstrcpy(cmdOptions[ ID_Q_NOHEADER].szOption,OPTION_NOHEADER);
|
|
cmdOptions[ ID_Q_NOHEADER].dwFlags = 0;
|
|
cmdOptions[ ID_Q_NOHEADER].dwCount = 1;
|
|
cmdOptions[ ID_Q_NOHEADER].dwActuals = 0;
|
|
cmdOptions[ ID_Q_NOHEADER].pValue = &m_bNoHeader;
|
|
lstrcpy(cmdOptions[ ID_Q_NOHEADER].szValues,NULL_STRING);
|
|
cmdOptions[ ID_Q_NOHEADER].pFunction = NULL;
|
|
cmdOptions[ ID_Q_NOHEADER].pFunctionData = NULL;
|
|
|
|
// verbose
|
|
lstrcpy(cmdOptions[ ID_Q_VERBOSE].szOption,OPTION_VERBOSE);
|
|
cmdOptions[ ID_Q_VERBOSE ].dwFlags = 0;
|
|
cmdOptions[ ID_Q_VERBOSE ].dwCount = 1;
|
|
cmdOptions[ ID_Q_VERBOSE ].dwActuals = 0;
|
|
cmdOptions[ ID_Q_VERBOSE ].pValue = &m_bVerbose;
|
|
cmdOptions[ ID_Q_VERBOSE ].pFunction = NULL;
|
|
cmdOptions[ ID_Q_VERBOSE ].pFunctionData = NULL;
|
|
}
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This function will process/parce the command line options.
|
|
//
|
|
// Arguments:
|
|
// [ in ] argc : argument(s) count specified at the command prompt
|
|
// [ in ] argv : argument(s) specified at the command prompt
|
|
//
|
|
// Return Value:
|
|
// TRUE : On Successful
|
|
// FALSE : On Error
|
|
//
|
|
// ***************************************************************************
|
|
|
|
void
|
|
CETQuery::ProcessOption(DWORD argc, LPCTSTR argv[])
|
|
{
|
|
// local variable
|
|
BOOL bReturn = TRUE;
|
|
CHString szTempString;
|
|
|
|
PrepareCMDStruct ();
|
|
|
|
// init the password variable with '*'
|
|
if ( m_pszPassword != NULL )
|
|
lstrcpy( m_pszPassword, _T( "*" ) );
|
|
|
|
// do the actual parsing of the command line arguments and check the result
|
|
bReturn = DoParseParam( argc, argv, MAX_COMMANDLINE_Q_OPTION, cmdOptions );
|
|
|
|
if(bReturn==FALSE)
|
|
throw CShowError(MK_E_SYNTAX);
|
|
// empty Server is not valid
|
|
szTempString = m_pszServerName;
|
|
szTempString.TrimRight();
|
|
lstrcpy(m_pszServerName,(LPCWSTR)szTempString);
|
|
if ( (cmdOptions[ID_Q_SERVER].dwActuals != 0) &&
|
|
(lstrlen( m_pszServerName) == 0 ))
|
|
{
|
|
throw CShowError(IDS_ERROR_SERVERNAME_EMPTY);
|
|
}
|
|
|
|
// "-u" should not be specified without "-s"
|
|
if ( cmdOptions[ ID_Q_SERVER ].dwActuals == 0 &&
|
|
cmdOptions[ ID_Q_USERNAME ].dwActuals != 0 )
|
|
{
|
|
throw CShowError(IDS_ERROR_USERNAME_BUT_NOMACHINE);
|
|
}
|
|
// empty user is not valid
|
|
szTempString = m_pszUserName;
|
|
szTempString.TrimRight();
|
|
lstrcpy(m_pszUserName,(LPCWSTR)szTempString);
|
|
if ( (cmdOptions[ID_Q_USERNAME].dwActuals != 0) &&
|
|
(lstrlen( m_pszUserName) == 0 ))
|
|
{
|
|
throw CShowError(IDS_ERROR_USERNAME_EMPTY);
|
|
}
|
|
// "-p" should not be specified without -u
|
|
if ( (cmdOptions[ID_Q_USERNAME].dwActuals == 0) &&
|
|
(cmdOptions[ID_Q_PASSWORD].dwActuals != 0 ))
|
|
{
|
|
// invalid syntax
|
|
throw CShowError(IDS_USERNAME_REQUIRED);
|
|
}
|
|
|
|
// check whether caller should accept the password or not
|
|
// if user has specified -s (or) -u and no "-p", then utility should accept
|
|
// password the user will be prompter for the password only if establish
|
|
// connection is failed without the credentials information
|
|
if ( cmdOptions[ ID_Q_PASSWORD ].dwActuals != 0 &&
|
|
m_pszPassword != NULL && lstrcmp( m_pszPassword, _T( "*" ) ) == 0 )
|
|
{
|
|
// user wants the utility to prompt for the password before trying to connect
|
|
m_bNeedPassword = TRUE;
|
|
}
|
|
else if ( cmdOptions[ ID_Q_PASSWORD ].dwActuals == 0 &&
|
|
( cmdOptions[ ID_Q_SERVER ].dwActuals != 0 || cmdOptions[ ID_Q_USERNAME ].dwActuals != 0 ) )
|
|
{
|
|
// -s, -u is specified without password ...
|
|
// utility needs to try to connect first and if it fails then prompt for the password
|
|
m_bNeedPassword = TRUE;
|
|
if ( m_pszPassword != NULL )
|
|
{
|
|
lstrcpy( m_pszPassword, _T( "" ) );
|
|
}
|
|
}
|
|
|
|
if((m_bNoHeader == TRUE) &&
|
|
((lstrcmpi(m_pszFormat,GetResString(IDS_STRING_LIST))==0)))
|
|
{
|
|
throw CShowError(IDS_HEADER_NOT_ALLOWED);
|
|
}
|
|
}
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This function will allocate memory to variables and also checks it and
|
|
// fills variable with value ZERO.
|
|
//
|
|
// Arguments:
|
|
// None
|
|
// Return Value:
|
|
// None
|
|
//
|
|
//***************************************************************************
|
|
|
|
void
|
|
CETQuery::Initialize()
|
|
{
|
|
// local variable
|
|
LONG lTemp = 0;
|
|
// if at all any occurs, we know that is 'coz of the
|
|
// failure in memory allocation ... so set the error
|
|
SetLastError( E_OUTOFMEMORY );
|
|
SaveLastError();
|
|
|
|
// allocate memory at least MAX_COMPUTER_NAME_LENGTH+1 (its windows )
|
|
// constant
|
|
lTemp = (m_lMinMemoryReq>MAX_COMPUTERNAME_LENGTH)?
|
|
m_lMinMemoryReq:MAX_COMPUTERNAME_LENGTH+1;
|
|
m_pszServerName = new TCHAR[lTemp+1];
|
|
CheckAndSetMemoryAllocation (m_pszServerName,lTemp);
|
|
|
|
// allocate memory at least MAX_USERNAME_LENGTH+1 (its windows )
|
|
// constant
|
|
lTemp = (m_lMinMemoryReq>MAX_USERNAME_LENGTH)?
|
|
m_lMinMemoryReq:MAX_USERNAME_LENGTH+1;
|
|
m_pszUserName = new TCHAR[lTemp+1];
|
|
CheckAndSetMemoryAllocation (m_pszUserName,lTemp);
|
|
|
|
// Allocate memory for Run As Username
|
|
m_pszTaskUserName = new TCHAR[MAX_RES_STRING+1];
|
|
CheckAndSetMemoryAllocation(m_pszTaskUserName,MAX_RES_STRING);
|
|
|
|
|
|
// allocate memory at least MAX_PASSWORD_LENGTH+1 (its windows )
|
|
// constant
|
|
lTemp = (m_lMinMemoryReq>MAX_PASSWORD_LENGTH)?
|
|
m_lMinMemoryReq:MAX_PASSWORD_LENGTH+1;
|
|
m_pszPassword = new TCHAR[lTemp+1];
|
|
CheckAndSetMemoryAllocation (m_pszPassword,lTemp);
|
|
|
|
m_pszFormat = new TCHAR[MAX_RES_STRING+1];
|
|
CheckAndSetMemoryAllocation (m_pszFormat,MAX_RES_STRING);
|
|
|
|
m_pszBuffer = new TCHAR[(MAX_RES_STRING*4)+1];
|
|
CheckAndSetMemoryAllocation (m_pszBuffer,(MAX_RES_STRING*4));
|
|
|
|
m_pszEventDesc = new TCHAR[(m_lDescriptionColWidth)+1];
|
|
CheckAndSetMemoryAllocation (m_pszEventDesc,(m_lDescriptionColWidth));
|
|
|
|
m_pszEventQuery = new TCHAR[(m_lQueryColWidth)+1];
|
|
CheckAndSetMemoryAllocation (m_pszEventQuery,(m_lQueryColWidth));
|
|
|
|
m_pszTask = new TCHAR[(m_lTaskColWidth)+1];
|
|
CheckAndSetMemoryAllocation (m_pszTask,(m_lTaskColWidth));
|
|
|
|
|
|
m_arrColData = CreateDynamicArray();
|
|
if(m_arrColData==NULL)
|
|
{
|
|
throw CShowError(E_OUTOFMEMORY);
|
|
}
|
|
// initialization is successful
|
|
SetLastError( NOERROR ); // clear the error
|
|
SetReason( NULL_STRING ); // clear the reason
|
|
|
|
}
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// Function will allocate memory to a string
|
|
//
|
|
// Arguments:
|
|
// [in][out] pszStr : String variable to which memory to be allocated
|
|
// [in] : Number of bytes to be allocated.
|
|
// Return Value:
|
|
// NONE
|
|
//
|
|
//***************************************************************************
|
|
|
|
void CETQuery::CheckAndSetMemoryAllocation(LPTSTR pszStr, LONG lSize)
|
|
{
|
|
if(pszStr == NULL)
|
|
{
|
|
throw CShowError(E_OUTOFMEMORY);
|
|
}
|
|
// init to ZERO's
|
|
ZeroMemory( pszStr, lSize * sizeof( TCHAR ) );
|
|
return;
|
|
|
|
}
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This function will execute query. This will enumerate classes from WMI
|
|
// to get required data.
|
|
//
|
|
// Arguments:
|
|
// None
|
|
// Return Value:
|
|
// None
|
|
//
|
|
//***************************************************************************
|
|
BOOL
|
|
CETQuery::ExecuteQuery()
|
|
{
|
|
// Local variables
|
|
HRESULT hr = S_OK; // Holds values returned by COM functions
|
|
BOOL bReturn = TRUE; // status of Return value of this function.
|
|
BOOL bSearchNTEventLogConsumer = FALSE;//status whether searching in all
|
|
//instances of NTEventLogConsumer is
|
|
//successful or not
|
|
BOOL bSearchEventFilter = FALSE;// status whether searching in all
|
|
// instances of EventFilter is successful
|
|
//or not
|
|
DWORD dwFormatType; // stores FORMAT status values to show results
|
|
// COM related pointer variable. their usage is well understood by their
|
|
//names.
|
|
IEnumWbemClassObject *pEnumFilterToConsumerBinding = NULL;
|
|
IWbemServices *pLocatorTriggerEventConsumer = NULL;
|
|
VARIANT vVariant; // variable used to get values from COM functions
|
|
// Variables to store query results....
|
|
TCHAR szHostName[MAX_RES_STRING+1];
|
|
TCHAR szEventTriggerName[MAX_RES_STRING+1];
|
|
DWORD dwEventId = 0;
|
|
DWORD dwRowCount = 0; // store Row number.
|
|
BOOL bAtLeastOneEvent = FALSE;
|
|
LPTSTR pstrTemp1 = NULL;
|
|
|
|
BSTR bstrConsumer = NULL;
|
|
BSTR bstrFilter = NULL;
|
|
BSTR bstrCmdTrigger = NULL;
|
|
|
|
LONG lTemp = 0;
|
|
|
|
|
|
|
|
try
|
|
{
|
|
m_hStdHandle = GetStdHandle(STD_ERROR_HANDLE);
|
|
if(m_hStdHandle!=NULL)
|
|
{
|
|
GetConsoleScreenBufferInfo(m_hStdHandle,&m_ScreenBufferInfo);
|
|
}
|
|
|
|
InitializeCom(&m_pWbemLocator);
|
|
m_bIsCOMInitialize = TRUE;
|
|
{
|
|
CHString szTempUser = m_pszUserName; // Temp. variabe to store user
|
|
// name.
|
|
CHString szTempPassword = m_pszPassword;// Temp. variable to store
|
|
// password.
|
|
m_bLocalSystem = TRUE;
|
|
// Connect remote / local WMI.
|
|
BOOL bResult = ConnectWmiEx( m_pWbemLocator,
|
|
&m_pWbemServices,
|
|
m_pszServerName,
|
|
szTempUser,
|
|
szTempPassword,
|
|
&m_pAuthIdentity,
|
|
m_bNeedPassword,
|
|
WMI_NAMESPACE_CIMV2,
|
|
&m_bLocalSystem);
|
|
if(bResult == FALSE)
|
|
{
|
|
TCHAR szErrorMsg[MAX_RES_STRING+1];
|
|
DISPLAY_MESSAGE2( stderr, szErrorMsg, L"%s %s", TAG_ERROR,
|
|
GetReason());
|
|
return FALSE;
|
|
}
|
|
// check the remote system version and its compatiblity
|
|
if ( m_bLocalSystem == FALSE )
|
|
{
|
|
DWORD dwVersion = 0;
|
|
dwVersion = GetTargetVersionEx( m_pWbemServices, m_pAuthIdentity );
|
|
if ( dwVersion <= 5000 ) // to block win2k versions
|
|
{
|
|
TCHAR szErrorMsg[MAX_RES_STRING+1];
|
|
SetReason( ERROR_OS_INCOMPATIBLE );
|
|
DISPLAY_MESSAGE2( stderr, szErrorMsg, L"%s %s", TAG_ERROR,
|
|
GetReason());
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// check the local credentials and if need display warning
|
|
if ( m_bLocalSystem && (lstrlen(m_pszUserName)!=0) )
|
|
{
|
|
CHString str;
|
|
WMISaveError( WBEM_E_LOCAL_CREDENTIALS );
|
|
str.Format( L"%s %s", TAG_WARNING, GetReason() );
|
|
ShowMessage( stdout, str );
|
|
}
|
|
|
|
|
|
}
|
|
// Show wait message...............
|
|
m_hStdHandle = GetStdHandle(STD_ERROR_HANDLE);
|
|
if(m_hStdHandle!=NULL)
|
|
{
|
|
GetConsoleScreenBufferInfo(m_hStdHandle,&m_ScreenBufferInfo);
|
|
}
|
|
PrintProgressMsg(m_hStdHandle,GetResString(IDS_MSG_EVTRIG_Q),m_ScreenBufferInfo);
|
|
|
|
//Following method will creates an enumerator that returns the
|
|
// instances of a specified __FilterToConsumerBinding class
|
|
bstrConsumer = SysAllocString(CLS_FILTER_TO_CONSUMERBINDING);
|
|
hr = m_pWbemServices->
|
|
CreateInstanceEnum(bstrConsumer,
|
|
WBEM_FLAG_SHALLOW,
|
|
NULL,
|
|
&pEnumFilterToConsumerBinding);
|
|
SAFE_RELEASE_BSTR(bstrConsumer);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
hr = SetInterfaceSecurity( pEnumFilterToConsumerBinding,
|
|
m_pAuthIdentity );
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
|
|
// retrieves CmdTriggerConsumer class
|
|
bstrCmdTrigger = SysAllocString(CLS_TRIGGER_EVENT_CONSUMER);
|
|
hr = m_pWbemServices->GetObject(bstrCmdTrigger,
|
|
0, NULL, &m_pClass, NULL);
|
|
RELEASE_BSTR(bstrCmdTrigger);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
// Gets information about the "QueryETrigger( " method of
|
|
// "cmdTriggerConsumer" class
|
|
bstrCmdTrigger = SysAllocString(FN_QUERY_ETRIGGER);
|
|
hr = m_pClass->GetMethod(bstrCmdTrigger,
|
|
0, &m_pInClass, NULL);
|
|
RELEASE_BSTR(bstrCmdTrigger);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
// create a new instance of a class "TriggerEventConsumer ".
|
|
hr = m_pInClass->SpawnInstance(0, &m_pInInst);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
while(1)
|
|
{
|
|
ULONG uReturned = 0; // holds no. of object returns from Next
|
|
//mathod
|
|
|
|
BSTR bstrTemp = NULL;
|
|
CHString strTemp;
|
|
// set the security at the interface level also
|
|
|
|
hr = SetInterfaceSecurity( pEnumFilterToConsumerBinding,
|
|
m_pAuthIdentity );
|
|
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
// Get one object starting at the current position in an
|
|
//enumeration
|
|
hr = pEnumFilterToConsumerBinding->Next(WBEM_INFINITE,
|
|
1,&m_pObj,&uReturned);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
if(uReturned == 0)
|
|
{
|
|
SAFE_RELEASE_INTERFACE(m_pObj);
|
|
break;
|
|
}
|
|
VariantInit(&vVariant);
|
|
SAFE_RELEASE_BSTR(bstrTemp);
|
|
bstrTemp = SysAllocString(L"Consumer");
|
|
hr = m_pObj->Get(bstrTemp, 0, &vVariant, 0, 0);
|
|
SAFE_RELEASE_BSTR(bstrTemp);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
bstrConsumer =SysAllocString( vVariant.bstrVal);
|
|
hr = VariantClear(&vVariant);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
// Search for trggereventconsumer string as we are interested to
|
|
// get object from this class only
|
|
strTemp = bstrConsumer;
|
|
if(strTemp.Find(CLS_TRIGGER_EVENT_CONSUMER)==-1)
|
|
continue;
|
|
hr = SetInterfaceSecurity( m_pWbemServices,
|
|
m_pAuthIdentity );
|
|
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
hr = m_pWbemServices->GetObject(bstrConsumer,
|
|
0,
|
|
NULL,
|
|
&m_pTriggerEventConsumer,
|
|
NULL);
|
|
SAFE_RELEASE_BSTR(bstrConsumer);
|
|
if(FAILED(hr))
|
|
{
|
|
if(hr==WBEM_E_NOT_FOUND)
|
|
continue;
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
}
|
|
bstrTemp = SysAllocString(L"Filter");
|
|
hr = m_pObj->Get(bstrTemp, 0, &vVariant, 0, 0);
|
|
SAFE_RELEASE_BSTR(bstrTemp);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
bstrFilter = SysAllocString(vVariant.bstrVal);
|
|
hr = VariantClear(&vVariant);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
hr = m_pWbemServices->GetObject(
|
|
bstrFilter,
|
|
0,
|
|
NULL,
|
|
&m_pEventFilter,
|
|
NULL);
|
|
SAFE_RELEASE_BSTR(bstrFilter);
|
|
if(FAILED(hr))
|
|
{
|
|
if(hr==WBEM_E_NOT_FOUND)
|
|
continue;
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
}
|
|
|
|
//retrieves the 'TriggerID' value if exits
|
|
bstrTemp = SysAllocString(FPR_TRIGGER_ID);
|
|
hr = m_pTriggerEventConsumer->Get(bstrTemp,
|
|
0, &vVariant, 0, 0);
|
|
if(FAILED(hr))
|
|
{
|
|
if(hr==WBEM_E_NOT_FOUND)
|
|
continue;
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
}
|
|
SAFE_RELEASE_BSTR(bstrTemp);
|
|
dwEventId = vVariant.lVal ;
|
|
hr = VariantClear(&vVariant);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
//retrieves the 'Action' value if exits
|
|
bstrTemp = SysAllocString(L"Action");
|
|
hr = m_pTriggerEventConsumer->Get(bstrTemp, 0, &vVariant, 0, 0);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
SAFE_RELEASE_BSTR(bstrTemp);
|
|
|
|
lstrcpy(m_pszBuffer,(_TCHAR*)_bstr_t(vVariant.bstrVal));
|
|
lTemp = lstrlen(m_pszBuffer);
|
|
lTemp += 4; // for the safer size for allocation of memory.
|
|
|
|
// allocates memory only if new task length is greate than previous one.
|
|
if(lTemp > m_lTaskColWidth)
|
|
{
|
|
// first free it (if previously allocated)
|
|
RELEASE_MEMORY_EX(m_pszTask);
|
|
m_pszTask = new TCHAR[lTemp+1];
|
|
CheckAndSetMemoryAllocation(m_pszTask,lTemp);
|
|
}
|
|
lstrcpy(m_pszTask,m_pszBuffer);
|
|
hr = VariantClear(&vVariant);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
//retrieves the 'TriggerDesc' value if exits
|
|
bstrTemp = SysAllocString(FPR_TRIGGER_DESC);
|
|
hr = m_pTriggerEventConsumer->Get(bstrTemp, 0, &vVariant, 0, 0);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
SAFE_RELEASE_BSTR(bstrTemp);
|
|
|
|
lstrcpy(m_pszBuffer,(_TCHAR*)_bstr_t(vVariant.bstrVal));
|
|
lTemp = lstrlen(m_pszBuffer);
|
|
if(lTemp == 0)// Means description is not available make it N/A.
|
|
{
|
|
lstrcpy(m_pszBuffer,GetResString(IDS_ID_NA));
|
|
lTemp = lstrlen(m_pszBuffer);
|
|
}
|
|
lTemp += 4; // for the safer size for allocation of memory.
|
|
|
|
// allocates memory only if new Description length is greate than
|
|
// previous one.
|
|
if(lTemp > m_lDescriptionColWidth)
|
|
{
|
|
// first free it (if previously allocated)
|
|
RELEASE_MEMORY_EX(m_pszEventDesc);
|
|
m_pszEventDesc = new TCHAR[lTemp+1];
|
|
CheckAndSetMemoryAllocation(m_pszEventDesc,lTemp);
|
|
}
|
|
lstrcpy(m_pszEventDesc,m_pszBuffer);
|
|
hr = VariantClear(&vVariant);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
// TriggerName
|
|
//retrieves the 'TriggerName' value if exits
|
|
bstrTemp = SysAllocString(FPR_TRIGGER_NAME);
|
|
hr = m_pTriggerEventConsumer->Get(bstrTemp, 0, &vVariant, 0, 0);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
SAFE_RELEASE_BSTR(bstrTemp);
|
|
wsprintf(szEventTriggerName,_T("%s"),vVariant.bstrVal);
|
|
hr = VariantClear(&vVariant);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
// Host Name
|
|
//retrieves the '__SERVER' value if exits
|
|
bstrTemp = SysAllocString(L"__SERVER");
|
|
hr = m_pTriggerEventConsumer->Get(bstrTemp, 0, &vVariant, 0, 0);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
SAFE_RELEASE_BSTR(bstrTemp);
|
|
wsprintf(szHostName,_T("%s"),vVariant.bstrVal);
|
|
|
|
hr = VariantClear(&vVariant);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
bstrTemp = SysAllocString(L"Query");
|
|
hr = m_pEventFilter->Get(bstrTemp, 0, &vVariant, 0, 0);
|
|
SAFE_RELEASE_BSTR(bstrTemp);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
lstrcpy(m_pszBuffer,(_TCHAR*)_bstr_t(vVariant.bstrVal));
|
|
hr = VariantClear(&vVariant);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
FindAndReplace(&m_pszBuffer,QUERY_STRING_AND,SHOW_WQL_QUERY);
|
|
FindAndReplace(&m_pszBuffer,L"targetinstance.LogFile",L"Log");
|
|
FindAndReplace(&m_pszBuffer,L"targetinstance.Type",L"Type");
|
|
FindAndReplace(&m_pszBuffer,L"targetinstance.EventCode",L"Id");
|
|
FindAndReplace(&m_pszBuffer,
|
|
L"targetinstance.SourceName",L"Source");
|
|
FindAndReplace(&m_pszBuffer,L" ",L" ");//to remove extra spaces
|
|
FindAndReplace(&m_pszBuffer,L" ",L" ");//to remove extra spaces
|
|
|
|
lTemp = lstrlen(m_pszBuffer);
|
|
lTemp += 4; // for the safer size for allocation of memory.
|
|
// allocates memory only if new WQL is greate than previous one.
|
|
if(lTemp > m_lWQLColWidth)
|
|
{
|
|
// first free it (if previously allocated)
|
|
RELEASE_MEMORY_EX(m_pszEventQuery);
|
|
m_pszEventQuery = new TCHAR[lTemp+1];
|
|
CheckAndSetMemoryAllocation(m_pszEventQuery,lTemp);
|
|
}
|
|
lTemp = m_lWQLColWidth;
|
|
CalcColWidth(lTemp,&m_lWQLColWidth,m_pszBuffer);
|
|
// Now manipulate the WQL string to get EventQuery....
|
|
FindAndReplace(&m_pszBuffer,SHOW_WQL_QUERY,
|
|
GetResString(IDS_EVENTS_WITH));
|
|
FindAndReplace(&m_pszBuffer,L" ",L" ");//to remove extra spaces
|
|
FindAndReplace(&m_pszBuffer,L" ",L" ");//to remove extra spaces
|
|
lstrcpy(m_pszEventQuery,m_pszBuffer);
|
|
|
|
// Retrieves the "TaskScheduler" information
|
|
bstrTemp = SysAllocString(L"ScheduledTaskName");
|
|
hr = m_pTriggerEventConsumer->Get(bstrTemp, 0, &vVariant, 0, 0);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
SAFE_RELEASE_BSTR(bstrTemp);
|
|
GetRunAsUserName((LPCWSTR)_bstr_t(vVariant.bstrVal));
|
|
hr = VariantClear(&vVariant);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
//////////////////////////////////////////
|
|
|
|
// Now Shows the results on screen
|
|
// Appends for in m_arrColData array
|
|
dwRowCount = DynArrayAppendRow( m_arrColData, NO_OF_COLUMNS );
|
|
// Fills Results in m_arrColData data structure
|
|
DynArraySetString2(m_arrColData,dwRowCount,HOST_NAME,szHostName,0);
|
|
DynArraySetDWORD2(m_arrColData ,dwRowCount,TRIGGER_ID,dwEventId);
|
|
DynArraySetString2(m_arrColData,dwRowCount,TRIGGER_NAME,szEventTriggerName,0);
|
|
DynArraySetString2(m_arrColData,dwRowCount,TASK,m_pszTask,0);
|
|
DynArraySetString2(m_arrColData,dwRowCount,EVENT_QUERY,m_pszEventQuery,0);
|
|
DynArraySetString2(m_arrColData,dwRowCount,EVENT_DESCRIPTION,m_pszEventDesc,0);
|
|
DynArraySetString2(m_arrColData,dwRowCount,TASK_USERNAME,m_pszTaskUserName,0);
|
|
bAtLeastOneEvent = TRUE;
|
|
|
|
// Calculatate new column width for each column
|
|
lTemp = m_lHostNameColWidth;
|
|
CalcColWidth(lTemp,&m_lHostNameColWidth,szHostName);
|
|
|
|
lTemp = m_lETNameColWidth;
|
|
CalcColWidth(lTemp,&m_lETNameColWidth,szEventTriggerName);
|
|
|
|
lTemp = m_lTaskColWidth;
|
|
CalcColWidth(lTemp,&m_lTaskColWidth,m_pszTask);
|
|
|
|
lTemp = m_lQueryColWidth;
|
|
CalcColWidth(lTemp,&m_lQueryColWidth,m_pszEventQuery);
|
|
|
|
lTemp = m_lDescriptionColWidth;
|
|
CalcColWidth(lTemp,&m_lDescriptionColWidth,m_pszEventDesc);
|
|
// Resets current containts..if any
|
|
lstrcpy((szHostName),NULL_STRING);
|
|
dwEventId = 0;
|
|
lstrcpy((szEventTriggerName),NULL_STRING);
|
|
lstrcpy((m_pszTask),NULL_STRING);
|
|
lstrcpy((m_pszEventQuery),NULL_STRING);
|
|
lstrcpy((m_pszEventDesc),NULL_STRING);
|
|
SAFE_RELEASE_INTERFACE(m_pObj);
|
|
SAFE_RELEASE_INTERFACE(m_pTriggerEventConsumer);
|
|
SAFE_RELEASE_INTERFACE(m_pEventFilter);
|
|
} // End of while
|
|
if(StringCompare(m_pszFormat,GetResString(IDS_STRING_TABLE),TRUE,5)==0)
|
|
{
|
|
dwFormatType = SR_FORMAT_TABLE;
|
|
}
|
|
else if (StringCompare(m_pszFormat,GetResString(IDS_STRING_LIST),
|
|
TRUE,4)==0)
|
|
{
|
|
dwFormatType = SR_FORMAT_LIST;
|
|
}
|
|
else if (StringCompare(m_pszFormat,GetResString(IDS_STRING_CSV),
|
|
TRUE,3)==0)
|
|
{
|
|
dwFormatType = SR_FORMAT_CSV;
|
|
}
|
|
else // Default
|
|
{
|
|
dwFormatType = SR_FORMAT_TABLE;
|
|
}
|
|
if(m_bNoHeader == TRUE)
|
|
{
|
|
dwFormatType |=SR_NOHEADER;
|
|
}
|
|
PrintProgressMsg(m_hStdHandle,NULL_STRING,m_ScreenBufferInfo);
|
|
if(bAtLeastOneEvent==TRUE)
|
|
{
|
|
// Show Final Query Results on screen
|
|
PrepareColumns ();
|
|
|
|
ShowMessage(stdout,BLANK_LINE);
|
|
ShowResults(NO_OF_COLUMNS,mainCols,dwFormatType,m_arrColData);
|
|
}
|
|
else
|
|
{
|
|
// Show Message
|
|
ShowMessage(stdout,GetResString(IDS_NO_EVENT_FOUNT));
|
|
}
|
|
}
|
|
catch(_com_error &e)
|
|
{
|
|
TCHAR szErrorMsg[MAX_RES_STRING+1];
|
|
PrintProgressMsg(m_hStdHandle,NULL_STRING,m_ScreenBufferInfo);
|
|
if(hr == 0x80041002)// WMI returns string for this hr value is
|
|
// "Not Found." which is not user friendly. So
|
|
// changing the message text.
|
|
{
|
|
ShowMessage( stderr,GetResString(IDS_CLASS_NOT_REG));
|
|
}
|
|
else
|
|
{
|
|
DISPLAY_MESSAGE2( stderr, szErrorMsg, L"%s %s" , TAG_ERROR,
|
|
GetReason() );
|
|
}
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This function will prepare/fill structure which will be used to show
|
|
// output data.
|
|
//
|
|
// Arguments:
|
|
// None
|
|
// Return Value:
|
|
// None
|
|
//
|
|
//***************************************************************************
|
|
void
|
|
CETQuery::PrepareColumns()
|
|
{
|
|
|
|
// local variable
|
|
|
|
// If non verbose output, some column should be hide.
|
|
DWORD dwMask = m_bVerbose?0:SR_HIDECOLUMN;
|
|
|
|
// For non verbose mode output, column width is predefined else
|
|
// use dynamically calculated column width.
|
|
m_lETNameColWidth = m_bVerbose?m_lETNameColWidth:V_WIDTH_TRIG_NAME;
|
|
m_lTaskColWidth = m_bVerbose?m_lTaskColWidth:V_WIDTH_TASK;
|
|
m_lTriggerIDColWidth = m_bVerbose?m_lTriggerIDColWidth:V_WIDTH_TRIG_ID;
|
|
|
|
|
|
lstrcpy(mainCols[HOST_NAME].szColumn,COL_HOSTNAME);
|
|
mainCols[HOST_NAME].dwWidth = m_lHostNameColWidth;
|
|
if(m_bVerbose==TRUE)
|
|
mainCols[HOST_NAME].dwFlags = SR_TYPE_STRING;
|
|
else
|
|
mainCols[HOST_NAME].dwFlags = SR_HIDECOLUMN|SR_TYPE_STRING;
|
|
|
|
lstrcpy(mainCols[HOST_NAME].szFormat,L"%s");
|
|
mainCols[HOST_NAME].pFunction = NULL;
|
|
mainCols[HOST_NAME].pFunctionData = NULL;
|
|
|
|
lstrcpy(mainCols[TRIGGER_ID].szColumn,COL_TRIGGER_ID);
|
|
mainCols[TRIGGER_ID].dwWidth = m_lTriggerIDColWidth;
|
|
mainCols[TRIGGER_ID].dwFlags = SR_TYPE_NUMERIC;
|
|
lstrcpy(mainCols[TRIGGER_ID].szFormat,L"%d");
|
|
mainCols[TRIGGER_ID].pFunction = NULL;
|
|
mainCols[TRIGGER_ID].pFunctionData = NULL;
|
|
|
|
lstrcpy(mainCols[TRIGGER_NAME].szColumn,COL_TRIGGER_NAME);
|
|
mainCols[TRIGGER_NAME].dwWidth = m_lETNameColWidth;
|
|
mainCols[TRIGGER_NAME].dwFlags = SR_TYPE_STRING;
|
|
lstrcpy(mainCols[TRIGGER_NAME].szFormat,L"%s");
|
|
mainCols[TRIGGER_NAME].pFunction = NULL;
|
|
mainCols[TRIGGER_NAME].pFunctionData = NULL;
|
|
|
|
lstrcpy(mainCols[TASK].szColumn,COL_TASK);
|
|
mainCols[TASK].dwWidth = m_lTaskColWidth;
|
|
|
|
mainCols[TASK].dwFlags = SR_TYPE_STRING;
|
|
lstrcpy(mainCols[TASK].szFormat,L"%s");
|
|
mainCols[TASK].pFunction = NULL;
|
|
mainCols[TASK].pFunctionData = NULL;
|
|
|
|
lstrcpy(mainCols[EVENT_QUERY].szColumn,COL_EVENT_QUERY);
|
|
mainCols[EVENT_QUERY].dwWidth = m_lQueryColWidth;
|
|
if(m_bVerbose==TRUE)
|
|
mainCols[EVENT_QUERY].dwFlags = SR_TYPE_STRING;
|
|
else
|
|
mainCols[EVENT_QUERY].dwFlags = SR_HIDECOLUMN|SR_TYPE_STRING;
|
|
|
|
lstrcpy(mainCols[EVENT_QUERY].szFormat,L"%s");
|
|
mainCols[EVENT_QUERY].pFunction = NULL;
|
|
mainCols[EVENT_QUERY].pFunctionData = NULL;
|
|
|
|
lstrcpy(mainCols[EVENT_DESCRIPTION].szColumn,COL_DESCRIPTION);
|
|
mainCols[EVENT_DESCRIPTION].dwWidth = m_lDescriptionColWidth;
|
|
if(m_bVerbose == TRUE)
|
|
mainCols[EVENT_DESCRIPTION].dwFlags = SR_TYPE_STRING;
|
|
else
|
|
mainCols[EVENT_DESCRIPTION].dwFlags = SR_HIDECOLUMN|SR_TYPE_STRING;
|
|
|
|
// Task Username
|
|
lstrcpy(mainCols[TASK_USERNAME].szFormat,L"%s");
|
|
mainCols[TASK_USERNAME].pFunction = NULL;
|
|
mainCols[TASK_USERNAME].pFunctionData = NULL;
|
|
|
|
lstrcpy(mainCols[TASK_USERNAME].szColumn,COL_TASK_USERNAME);
|
|
mainCols[TASK_USERNAME].dwWidth = m_lTaskUserName;
|
|
if(m_bVerbose == TRUE)
|
|
mainCols[TASK_USERNAME].dwFlags = SR_TYPE_STRING;
|
|
else
|
|
mainCols[TASK_USERNAME].dwFlags = SR_HIDECOLUMN|SR_TYPE_STRING;
|
|
|
|
lstrcpy(mainCols[TASK_USERNAME].szFormat,L"%s");
|
|
mainCols[TASK_USERNAME].pFunction = NULL;
|
|
mainCols[TASK_USERNAME].pFunctionData = NULL;
|
|
|
|
|
|
}
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This function Will Find a string (lpszFind) in source string (lpszSource)
|
|
and replace it with replace string (lpszReplace) for all occurences.
|
|
|
|
Arguments:
|
|
|
|
[in/out] lpszSource : String on which Find-Replace operation to be
|
|
performed
|
|
[in] lpszFind : String to be find
|
|
[in] lpszReplace : String to be replaced.
|
|
Return Value:
|
|
0 - if Unsucessful
|
|
else returns length of lpszSource.
|
|
|
|
******************************************************************************/
|
|
LONG
|
|
CETQuery::FindAndReplace(LPTSTR *lpszSource, LPCTSTR lpszFind,
|
|
LPCTSTR lpszReplace)
|
|
{
|
|
LONG lSourceLen = lstrlen(lpszFind);
|
|
LONG lReplacementLen = lstrlen(lpszReplace);
|
|
LONG lMainLength = lstrlen(*lpszSource);
|
|
LPTSTR pszMainSafe= new TCHAR[lstrlen(*lpszSource)+1];
|
|
// loop once to figure out the size of the result string
|
|
LONG nCount = 0;
|
|
LPTSTR lpszStart = NULL;
|
|
lpszStart = *lpszSource;
|
|
LPTSTR lpszEnd = NULL;
|
|
lpszEnd = lpszStart + lMainLength;
|
|
LPTSTR lpszTarget=NULL;
|
|
if ((lSourceLen == 0)||(pszMainSafe==NULL))
|
|
{
|
|
RELEASE_MEMORY_EX(pszMainSafe);
|
|
return 0;
|
|
}
|
|
while (lpszStart < lpszEnd)
|
|
{
|
|
while ((lpszTarget = _tcsstr(lpszStart, lpszFind)) != NULL)
|
|
{
|
|
nCount++;
|
|
lpszStart = lpszTarget + lSourceLen;
|
|
}
|
|
lpszStart += lstrlen(lpszStart) + 1;
|
|
}
|
|
|
|
// if any changes were made, make them
|
|
if (nCount > 0)
|
|
{
|
|
lstrcpy(pszMainSafe,*lpszSource);
|
|
LONG lOldLength = lMainLength;
|
|
// if the buffer is too small, just
|
|
// allocate a new buffer (slow but sure)
|
|
int nNewLength = lMainLength + (lReplacementLen-lSourceLen)*nCount;
|
|
if(lMainLength < nNewLength)
|
|
{
|
|
|
|
if(*lpszSource!=NULL)
|
|
{
|
|
delete *lpszSource;
|
|
}
|
|
*lpszSource = new TCHAR[ (nNewLength*sizeof(TCHAR))+sizeof(TCHAR)];
|
|
if( *lpszSource == NULL )
|
|
{
|
|
RELEASE_MEMORY_EX(pszMainSafe);
|
|
return 0;
|
|
}
|
|
memcpy((LPTSTR)*lpszSource,pszMainSafe, lMainLength*sizeof(TCHAR));
|
|
}
|
|
|
|
// else, we just do it in-place
|
|
lpszStart= *lpszSource;
|
|
lpszEnd = lpszStart +lstrlen(*lpszSource);
|
|
// loop again to actually do the work
|
|
while (lpszStart < lpszEnd)
|
|
{
|
|
while ( (lpszTarget = _tcsstr(lpszStart, lpszFind)) != NULL)
|
|
{
|
|
#ifdef _WIN64
|
|
__int64 lBalance ;
|
|
#else
|
|
LONG lBalance;
|
|
#endif
|
|
lBalance = lOldLength - (lpszTarget - lpszStart + lSourceLen);
|
|
memmove(lpszTarget + lReplacementLen, lpszTarget + lSourceLen,
|
|
(size_t) lBalance * sizeof(TCHAR));
|
|
memcpy(lpszTarget, lpszReplace, lReplacementLen*sizeof(TCHAR));
|
|
lpszStart = lpszTarget + lReplacementLen;
|
|
lpszStart[lBalance] = NULL_CHAR;
|
|
lOldLength += (lReplacementLen - lSourceLen);
|
|
|
|
}
|
|
lpszStart += lstrlen(lpszStart) + 1;
|
|
}
|
|
}
|
|
RELEASE_MEMORY_EX(pszMainSafe);
|
|
return lstrlen(*lpszSource);
|
|
}
|
|
/******************************************************************************
|
|
Routine Description:
|
|
Calculates the width required for column
|
|
Arguments:
|
|
|
|
[in] lOldLength : Previous length
|
|
[out] plNewLength : New Length
|
|
[in] pszString : String .
|
|
|
|
Return Value:
|
|
none
|
|
|
|
******************************************************************************/
|
|
|
|
void
|
|
CETQuery::CalcColWidth(LONG lOldLength,LONG *plNewLength,LPTSTR pszString)
|
|
{
|
|
LONG lStrLength = lstrlen(pszString)+2;
|
|
//Any way column width should not be greater than MAX_COL_LENGTH
|
|
// Stores the maximum of WQL length.
|
|
if(lStrLength > lOldLength)
|
|
*plNewLength = lStrLength;
|
|
else
|
|
*plNewLength = lOldLength;
|
|
|
|
}
|
|
/******************************************************************************
|
|
Routine Description:
|
|
Get User Name from Task Scheduler
|
|
Arguments:
|
|
|
|
[in] pszTaskName : Task Name
|
|
|
|
Return Value:
|
|
HRESULT
|
|
|
|
******************************************************************************/
|
|
|
|
HRESULT
|
|
CETQuery::GetRunAsUserName(LPCWSTR pszScheduleTaskName)
|
|
{
|
|
|
|
// if pszSheduleTaskName is null or 0 length just return N/A.
|
|
HRESULT hr = S_OK;
|
|
BSTR bstrTemp = NULL;
|
|
VARIANT vVariant;
|
|
|
|
|
|
if(lstrlen(pszScheduleTaskName)==0)
|
|
{
|
|
lstrcpy(m_pszTaskUserName,DEFAULT_USER);
|
|
return S_OK;
|
|
}
|
|
lstrcpy(m_pszTaskUserName,GetResString(IDS_ID_NA));
|
|
// Put input parameter for QueryETrigger method
|
|
hr = PropertyPut(m_pInInst,FPR_TASK_SCHEDULER,_bstr_t(pszScheduleTaskName));
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
// All The required properties sets, so
|
|
// executes DeleteETrigger method to delete eventtrigger
|
|
hr = m_pWbemServices->ExecMethod(_bstr_t(CLS_TRIGGER_EVENT_CONSUMER),
|
|
_bstr_t(FN_QUERY_ETRIGGER),
|
|
0, NULL, m_pInInst,&m_pOutInst,NULL);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
bstrTemp = SysAllocString(FPR_RUN_AS_USER);
|
|
VariantInit(&vVariant);
|
|
hr = m_pOutInst->Get(bstrTemp, 0, &vVariant, 0, 0);
|
|
SAFE_RELEASE_BSTR(bstrTemp);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
|
|
wsprintf(m_pszTaskUserName,_T("%s"),vVariant.bstrVal);
|
|
hr = VariantClear(&vVariant);
|
|
ON_ERROR_THROW_EXCEPTION(hr);
|
|
if(lstrlen(m_pszTaskUserName)==0)
|
|
{
|
|
lstrcpy(m_pszTaskUserName,GetResString(IDS_ID_NA));
|
|
}
|
|
return S_OK;
|
|
}
|
|
|