1117 lines
32 KiB
C++
1117 lines
32 KiB
C++
// *********************************************************************************
|
|
//
|
|
// Copyright (c) Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
//
|
|
// parse.cpp
|
|
//
|
|
// Abstract:
|
|
//
|
|
// This module implements the command-line parsing and validating the filters
|
|
//
|
|
// Author:
|
|
//
|
|
// Sunil G.V.N. Murali (murali.sunil@wipro.com) 26-Nov-2000
|
|
//
|
|
// Revision History:
|
|
//
|
|
// Sunil G.V.N. Murali (murali.sunil@wipro.com) 26-Nov-2000 : Created It.
|
|
//
|
|
// *********************************************************************************
|
|
|
|
#include "pch.h"
|
|
#include "taskkill.h"
|
|
|
|
//
|
|
// local function prototypes
|
|
//
|
|
BOOL ValidatePID( LPCWSTR pwszOption, LPCWSTR pwszValue, LPVOID pData );
|
|
BOOL TimeFieldsToElapsedTime( LPCWSTR pwszTime, LPCWSTR pwszToken, ULONG& ulElapsedTime );
|
|
DWORD FilterMemUsage( LPCWSTR pwszProperty, LPCWSTR pwszOperator,
|
|
LPCWSTR pwszValue, LPVOID pData, TARRAY arrRow );
|
|
DWORD FilterCPUTime( LPCWSTR pwszProperty, LPCWSTR pwszOperator,
|
|
LPCWSTR pwszValue, LPVOID pData, TARRAY arrRow );
|
|
DWORD FilterUserName( LPCWSTR pwszProperty, LPCWSTR pwszOperator,
|
|
LPCWSTR pwszValue, LPVOID pData, TARRAY arrRow );
|
|
DWORD FilterProcessId( LPCWSTR pwszProperty, LPCWSTR pwszOperator,
|
|
LPCWSTR pwszValue, LPVOID pData, TARRAY arrRow );
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// processes and validates the command line inputs
|
|
//
|
|
// Arguments:
|
|
// [ in ] argc : no. of input arguments specified
|
|
// [ in ] argv : input arguments specified at command prompt
|
|
//
|
|
// Return Value:
|
|
// TRUE : if inputs are valid
|
|
// FALSE : if inputs were errorneously specified
|
|
//
|
|
// ***************************************************************************
|
|
BOOL CTaskKill::ProcessOptions( DWORD argc, LPCWSTR argv[] )
|
|
{
|
|
// local variables
|
|
BOOL bResult = FALSE;
|
|
PTCMDPARSER pcmdOptions = NULL;
|
|
|
|
// temporary local variables
|
|
LPWSTR pwszServer = NULL;
|
|
LPWSTR pwszUserName = NULL;
|
|
LPWSTR pwszPassword = NULL;
|
|
PTCMDPARSER pOption = NULL;
|
|
PTCMDPARSER pOptionServer = NULL;
|
|
PTCMDPARSER pOptionUserName = NULL;
|
|
PTCMDPARSER pOptionPassword = NULL;
|
|
|
|
//
|
|
// prepare the command options
|
|
pcmdOptions = new TCMDPARSER[ MAX_OPTIONS ];
|
|
if ( pcmdOptions == NULL )
|
|
{
|
|
SetLastError( E_OUTOFMEMORY );
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
// ...
|
|
ZeroMemory( pcmdOptions, MAX_OPTIONS * sizeof( TCMDPARSER ) );
|
|
|
|
try
|
|
{
|
|
// get the pointers to the input bufers
|
|
pwszServer = m_strServer.GetBufferSetLength( MAX_STRING_LENGTH );
|
|
pwszUserName = m_strUserName.GetBufferSetLength( MAX_STRING_LENGTH );
|
|
pwszPassword = m_strPassword.GetBufferSetLength( MAX_STRING_LENGTH );
|
|
|
|
// init the password contents with '*'
|
|
lstrcpy( pwszPassword, L"*" );
|
|
}
|
|
catch( ... )
|
|
{
|
|
SetLastError( E_OUTOFMEMORY );
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
// -?
|
|
pOption = pcmdOptions + OI_USAGE;
|
|
pOption->dwCount = 1;
|
|
pOption->dwActuals = 0;
|
|
pOption->dwFlags = CP_USAGE;
|
|
pOption->pValue = &m_bUsage;
|
|
pOption->pFunction = NULL;
|
|
pOption->pFunctionData = NULL;
|
|
lstrcpy( pOption->szValues, NULL_STRING );
|
|
lstrcpy( pOption->szOption, OPTION_USAGE );
|
|
|
|
// -s
|
|
pOption = pcmdOptions + OI_SERVER;
|
|
pOption->dwCount = 1;
|
|
pOption->dwActuals = 0;
|
|
pOption->dwFlags = CP_TYPE_TEXT | CP_VALUE_MANDATORY;
|
|
pOption->pValue = pwszServer;
|
|
pOption->pFunction = NULL;
|
|
pOption->pFunctionData = NULL;
|
|
lstrcpy( pOption->szValues, NULL_STRING );
|
|
lstrcpy( pOption->szOption, OPTION_SERVER );
|
|
|
|
// -u
|
|
pOption = pcmdOptions + OI_USERNAME;
|
|
pOption->dwCount = 1;
|
|
pOption->dwActuals = 0;
|
|
pOption->dwFlags = CP_TYPE_TEXT | CP_VALUE_MANDATORY;
|
|
pOption->pValue = pwszUserName;
|
|
pOption->pFunction = NULL;
|
|
pOption->pFunctionData = NULL;
|
|
lstrcpy( pOption->szValues, NULL_STRING );
|
|
lstrcpy( pOption->szOption, OPTION_USERNAME );
|
|
|
|
// -p
|
|
pOption = pcmdOptions + OI_PASSWORD;
|
|
pOption->dwCount = 1;
|
|
pOption->dwActuals = 0;
|
|
pOption->dwFlags = CP_TYPE_TEXT | CP_VALUE_OPTIONAL;
|
|
pOption->pValue = pwszPassword;
|
|
pOption->pFunction = NULL;
|
|
pOption->pFunctionData = NULL;
|
|
lstrcpy( pOption->szValues, NULL_STRING );
|
|
lstrcpy( pOption->szOption, OPTION_PASSWORD );
|
|
|
|
// -f
|
|
pOption = pcmdOptions + OI_FORCE;
|
|
pOption->dwCount = 1;
|
|
pOption->dwActuals = 0;
|
|
pOption->dwFlags = 0;
|
|
pOption->pValue = &m_bForce;
|
|
pOption->pFunction = NULL;
|
|
pOption->pFunctionData = NULL;
|
|
lstrcpy( pOption->szValues, NULL_STRING );
|
|
lstrcpy( pOption->szOption, OPTION_FORCE );
|
|
|
|
// -tr
|
|
pOption = pcmdOptions + OI_TREE;
|
|
pOption->dwCount = 1;
|
|
pOption->dwActuals = 0;
|
|
pOption->dwFlags = 0;
|
|
pOption->pValue = &m_bTree;
|
|
pOption->pFunction = NULL;
|
|
pOption->pFunctionData = NULL;
|
|
lstrcpy( pOption->szValues, NULL_STRING );
|
|
lstrcpy( pOption->szOption, OPTION_TREE );
|
|
|
|
// -fi
|
|
pOption = pcmdOptions + OI_FILTER;
|
|
pOption->dwCount = 0;
|
|
pOption->dwActuals = 0;
|
|
pOption->dwFlags = CP_TYPE_TEXT | CP_VALUE_MANDATORY | CP_MODE_ARRAY;
|
|
pOption->pValue = &m_arrFilters;
|
|
pOption->pFunction = NULL;
|
|
pOption->pFunctionData = NULL;
|
|
lstrcpy( pOption->szValues, NULL_STRING );
|
|
lstrcpy( pOption->szOption, OPTION_FILTER );
|
|
|
|
// -pid
|
|
pOption = pcmdOptions + OI_PID;
|
|
pOption->dwCount = 0;
|
|
pOption->dwActuals = 0;
|
|
pOption->dwFlags = CP_TYPE_TEXT | CP_MODE_ARRAY | CP_VALUE_NODUPLICATES | CP_TYPE_CUSTOM | CP_VALUE_MANDATORY;
|
|
pOption->pValue = &m_arrTasksToKill;
|
|
pOption->pFunction = ValidatePID;
|
|
pOption->pFunctionData = m_arrTasksToKill;
|
|
lstrcpy( pOption->szValues, NULL_STRING );
|
|
lstrcpy( pOption->szOption, OPTION_PID );
|
|
|
|
// -im
|
|
pOption = pcmdOptions + OI_IMAGENAME;
|
|
pOption->dwCount = 0;
|
|
pOption->dwActuals = 0;
|
|
pOption->dwFlags = CP_TYPE_TEXT | CP_MODE_ARRAY | CP_VALUE_NODUPLICATES | CP_VALUE_MANDATORY;
|
|
pOption->pValue = &m_arrTasksToKill;
|
|
pOption->pFunction = NULL;
|
|
pOption->pFunctionData = NULL;
|
|
lstrcpy( pOption->szValues, NULL_STRING );
|
|
lstrcpy( pOption->szOption, OPTION_IMAGENAME );
|
|
|
|
//
|
|
// do the parsing
|
|
bResult = DoParseParam( argc, argv, MAX_OPTIONS, pcmdOptions );
|
|
|
|
// release the buffers
|
|
m_strServer.ReleaseBuffer();
|
|
m_strUserName.ReleaseBuffer();
|
|
m_strPassword.ReleaseBuffer();
|
|
|
|
// now check the result of parsing and decide
|
|
if ( bResult == FALSE )
|
|
{
|
|
delete [] pcmdOptions; // clear memory
|
|
pcmdOptions = NULL;
|
|
return FALSE; // invalid syntax
|
|
}
|
|
|
|
//
|
|
// now, check the mutually exclusive options
|
|
pOptionServer = pcmdOptions + OI_SERVER;
|
|
pOptionUserName = pcmdOptions + OI_USERNAME;
|
|
pOptionPassword = pcmdOptions + OI_PASSWORD;
|
|
|
|
// check the usage option
|
|
if ( m_bUsage && ( argc > 2 ) )
|
|
{
|
|
// no other options are accepted along with -? option
|
|
delete [] pcmdOptions; // clear memory
|
|
pcmdOptions = NULL;
|
|
SetLastError( MK_E_SYNTAX );
|
|
SetReason( ERROR_INVALID_USAGE_REQUEST );
|
|
return FALSE;
|
|
}
|
|
else if ( m_bUsage == TRUE )
|
|
{
|
|
// should not do the furthur validations
|
|
delete [] pcmdOptions; // clear memory
|
|
pcmdOptions = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
// "-u" should not be specified without machine names
|
|
if ( pOptionServer->dwActuals == 0 && pOptionUserName->dwActuals != 0 )
|
|
{
|
|
// invalid syntax
|
|
SetReason( ERROR_USERNAME_BUT_NOMACHINE );
|
|
delete [] pcmdOptions; // clear memory
|
|
pcmdOptions = NULL;
|
|
return FALSE; // indicate failure
|
|
}
|
|
|
|
// empty user is not valid
|
|
if ( pOptionUserName->dwActuals != 0 && m_strUserName.GetLength() == 0 )
|
|
{
|
|
SetReason( ERROR_USERNAME_EMPTY );
|
|
delete [] pcmdOptions; // clear memory
|
|
pcmdOptions = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
// empty server name is not valid
|
|
if ( pOptionServer->dwActuals != 0 && m_strServer.GetLength() == 0 )
|
|
{
|
|
SetReason( ERROR_SERVER_EMPTY );
|
|
delete [] pcmdOptions; // clear memory
|
|
pcmdOptions = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
// "-p" should not be specified without "-u"
|
|
if ( pOptionUserName->dwActuals == 0 && pOptionPassword->dwActuals != 0 )
|
|
{
|
|
// invalid syntax
|
|
SetReason( ERROR_PASSWORD_BUT_NOUSERNAME );
|
|
delete [] pcmdOptions; // clear memory
|
|
pcmdOptions = NULL;
|
|
return FALSE; // indicate failure
|
|
}
|
|
|
|
// 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 ( pOptionPassword->dwActuals != 0 && m_strPassword.Compare( L"*" ) == 0 )
|
|
{
|
|
// user wants the utility to prompt for the password before trying to connect
|
|
m_bNeedPassword = TRUE;
|
|
}
|
|
else if ( (pOptionPassword->dwActuals == 0 &&
|
|
(pOptionServer->dwActuals != 0 || pOptionUserName->dwActuals != 0)) )
|
|
{
|
|
// utility needs to try to connect first and if it fails then prompt for the password
|
|
m_bNeedPassword = TRUE;
|
|
m_strPassword.Empty();
|
|
}
|
|
|
|
// either -pid (or) -im are allowed but not both
|
|
if ( (pcmdOptions + OI_PID)->dwActuals != 0 && (pcmdOptions + OI_IMAGENAME)->dwActuals != 0 )
|
|
{
|
|
// invalid syntax
|
|
SetReason( ERROR_PID_OR_IM_ONLY );
|
|
delete [] pcmdOptions; // clear memory
|
|
pcmdOptions = NULL;
|
|
return FALSE; // indicate failure
|
|
}
|
|
else if ( DynArrayGetCount( m_arrTasksToKill ) == 0 )
|
|
{
|
|
// tasks were not specified .. but user might have specified filters
|
|
// check that and if user didn't filters error
|
|
if ( DynArrayGetCount( m_arrFilters ) == 0 )
|
|
{
|
|
// invalid syntax
|
|
SetReason( ERROR_NO_PID_AND_IM );
|
|
delete [] pcmdOptions; // clear memory
|
|
pcmdOptions = NULL;
|
|
return FALSE; // indicate failure
|
|
}
|
|
|
|
// user specified filters ... add '*' to the list of task to kill
|
|
DynArrayAppendString( m_arrTasksToKill, L"*", 0 );
|
|
}
|
|
|
|
// check if '*' is specified along with the filters or not
|
|
// if not specified along with the filters, error
|
|
if ( DynArrayGetCount( m_arrFilters ) == 0 )
|
|
{
|
|
// filters were not specified .. so '*' should not be specified
|
|
LONG lIndex = 0;
|
|
lIndex = DynArrayFindString( m_arrTasksToKill, L"*", TRUE, 0 );
|
|
if ( lIndex != -1 )
|
|
{
|
|
// error ... '*' is specified even if filters were not specified
|
|
SetReason( ERROR_WILDCARD_WITHOUT_FILTERS );
|
|
delete [] pcmdOptions; // clear memory
|
|
pcmdOptions = NULL;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// command-line parsing is successfull
|
|
delete [] pcmdOptions; // clear memory
|
|
pcmdOptions = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// validates the filter information specified with -filter option
|
|
//
|
|
// Arguments:
|
|
// NONE
|
|
//
|
|
// Return Value:
|
|
// TRUE : if filters are appropriately specified
|
|
// FALSE : if filters are errorneously specified
|
|
//
|
|
// ***************************************************************************
|
|
BOOL CTaskKill::ValidateFilters()
|
|
{
|
|
// local variables
|
|
LONG lIndex = -1;
|
|
BOOL bResult = FALSE;
|
|
PTFILTERCONFIG pConfig = NULL;
|
|
|
|
//
|
|
// prepare the filter structure
|
|
|
|
// status
|
|
pConfig = m_pfilterConfigs + FI_STATUS;
|
|
pConfig->dwColumn = TASK_STATUS;
|
|
pConfig->dwFlags = F_TYPE_TEXT | F_MODE_VALUES;
|
|
pConfig->pFunction = NULL;
|
|
pConfig->pFunctionData = NULL;
|
|
lstrcpy( pConfig->szOperators, OPERATORS_STRING );
|
|
lstrcpy( pConfig->szProperty, FILTER_STATUS );
|
|
lstrcpy( pConfig->szValues, FVALUES_STATUS );
|
|
|
|
// imagename
|
|
pConfig = m_pfilterConfigs + FI_IMAGENAME;
|
|
pConfig->dwColumn = TASK_IMAGENAME;
|
|
pConfig->dwFlags = F_TYPE_TEXT | F_MODE_PATTERN;
|
|
pConfig->pFunction = NULL;
|
|
pConfig->pFunctionData = NULL;
|
|
lstrcpy( pConfig->szOperators, OPERATORS_STRING );
|
|
lstrcpy( pConfig->szProperty, FILTER_IMAGENAME );
|
|
lstrcpy( pConfig->szValues, NULL_STRING );
|
|
|
|
// pid
|
|
pConfig = m_pfilterConfigs + FI_PID;
|
|
pConfig->dwColumn = TASK_PID;
|
|
pConfig->dwFlags = F_TYPE_CUSTOM;
|
|
pConfig->pFunction = FilterProcessId;
|
|
pConfig->pFunctionData = NULL;
|
|
lstrcpy( pConfig->szOperators, OPERATORS_NUMERIC );
|
|
lstrcpy( pConfig->szProperty, FILTER_PID );
|
|
lstrcpy( pConfig->szValues, NULL_STRING );
|
|
|
|
// session
|
|
pConfig = m_pfilterConfigs + FI_SESSION;
|
|
pConfig->dwColumn = TASK_SESSION;
|
|
pConfig->dwFlags = F_TYPE_UNUMERIC;
|
|
pConfig->pFunction = NULL;
|
|
pConfig->pFunctionData = NULL;
|
|
lstrcpy( pConfig->szOperators, OPERATORS_NUMERIC );
|
|
lstrcpy( pConfig->szProperty, FILTER_SESSION );
|
|
lstrcpy( pConfig->szValues, NULL_STRING );
|
|
|
|
// cputime
|
|
pConfig = m_pfilterConfigs + FI_CPUTIME;
|
|
pConfig->dwColumn = TASK_CPUTIME;
|
|
pConfig->dwFlags = F_TYPE_CUSTOM;
|
|
pConfig->pFunction = FilterCPUTime;
|
|
pConfig->pFunctionData = NULL;
|
|
lstrcpy( pConfig->szOperators, OPERATORS_NUMERIC );
|
|
lstrcpy( pConfig->szProperty, FILTER_CPUTIME );
|
|
lstrcpy( pConfig->szValues, NULL_STRING );
|
|
|
|
// memusage
|
|
pConfig = m_pfilterConfigs + FI_MEMUSAGE;
|
|
pConfig->dwColumn = TASK_MEMUSAGE;
|
|
pConfig->dwFlags = F_TYPE_UNUMERIC;
|
|
pConfig->pFunction = NULL;
|
|
pConfig->pFunctionData = NULL;
|
|
lstrcpy( pConfig->szOperators, OPERATORS_NUMERIC );
|
|
lstrcpy( pConfig->szProperty, FILTER_MEMUSAGE );
|
|
lstrcpy( pConfig->szValues, NULL_STRING );
|
|
|
|
// username
|
|
pConfig = m_pfilterConfigs + FI_USERNAME;
|
|
pConfig->dwColumn = TASK_USERNAME;
|
|
pConfig->dwFlags = F_TYPE_CUSTOM;
|
|
pConfig->pFunction = FilterUserName;
|
|
pConfig->pFunctionData = NULL;
|
|
lstrcpy( pConfig->szOperators, OPERATORS_STRING );
|
|
lstrcpy( pConfig->szProperty, FILTER_USERNAME );
|
|
lstrcpy( pConfig->szValues, NULL_STRING );
|
|
|
|
// services
|
|
pConfig = m_pfilterConfigs + FI_SERVICES;
|
|
pConfig->dwColumn = TASK_SERVICES;
|
|
pConfig->dwFlags = F_TYPE_TEXT | F_MODE_PATTERN | F_MODE_ARRAY;
|
|
pConfig->pFunction = NULL;
|
|
pConfig->pFunctionData = NULL;
|
|
lstrcpy( pConfig->szOperators, OPERATORS_STRING );
|
|
lstrcpy( pConfig->szProperty, FILTER_SERVICES );
|
|
lstrcpy( pConfig->szValues, NULL_STRING );
|
|
|
|
// windowtitle
|
|
pConfig = m_pfilterConfigs + FI_WINDOWTITLE;
|
|
pConfig->dwColumn = TASK_WINDOWTITLE;
|
|
pConfig->dwFlags = F_TYPE_TEXT | F_MODE_PATTERN;
|
|
pConfig->pFunction = NULL;
|
|
pConfig->pFunctionData = NULL;
|
|
lstrcpy( pConfig->szOperators, OPERATORS_STRING );
|
|
lstrcpy( pConfig->szProperty, FILTER_WINDOWTITLE );
|
|
lstrcpy( pConfig->szValues, NULL_STRING );
|
|
|
|
// modules
|
|
pConfig = m_pfilterConfigs + FI_MODULES;
|
|
pConfig->dwColumn = TASK_MODULES;
|
|
pConfig->dwFlags = F_TYPE_TEXT | F_MODE_PATTERN | F_MODE_ARRAY;
|
|
pConfig->pFunction = NULL;
|
|
pConfig->pFunctionData = NULL;
|
|
lstrcpy( pConfig->szOperators, OPERATORS_STRING );
|
|
lstrcpy( pConfig->szProperty, FILTER_MODULES );
|
|
lstrcpy( pConfig->szValues, NULL_STRING );
|
|
|
|
//
|
|
// validate the filter
|
|
bResult = ParseAndValidateFilter( MAX_FILTERS,
|
|
m_pfilterConfigs, m_arrFilters, &m_arrFiltersEx );
|
|
|
|
// check the filter validation result
|
|
if ( bResult == FALSE )
|
|
return FALSE;
|
|
|
|
// find out whether user has requested for the tasks to be filtered
|
|
// on user context and/or services are not ... if yes, set the appropriate flags
|
|
// this check is being done to increase the performance of the utility
|
|
// NOTE: we will be using the parsed filters info for doing this
|
|
|
|
// user context
|
|
if ( m_bNeedUserContextInfo == FALSE )
|
|
{
|
|
// find out if the filter property exists in this row
|
|
// NOTE:-
|
|
// filter property do exists in the seperate indexes only.
|
|
// refer to the logic of validating the filters in common functionality
|
|
lIndex = DynArrayFindStringEx( m_arrFiltersEx,
|
|
F_PARSED_INDEX_PROPERTY, FILTER_USERNAME, TRUE, 0 );
|
|
if ( lIndex != -1 )
|
|
m_bNeedUserContextInfo = TRUE;
|
|
}
|
|
|
|
// services info
|
|
if ( m_bNeedServicesInfo == FALSE )
|
|
{
|
|
// find out if the filter property exists in this row
|
|
// NOTE:-
|
|
// filter property do exists in the seperate indexes only.
|
|
// refer to the logic of validating the filters in common functionality
|
|
lIndex = DynArrayFindStringEx( m_arrFiltersEx,
|
|
F_PARSED_INDEX_PROPERTY, FILTER_SERVICES, TRUE, 0 );
|
|
if ( lIndex != -1 )
|
|
m_bNeedServicesInfo = TRUE;
|
|
}
|
|
|
|
// modules info
|
|
if ( m_bNeedModulesInfo == FALSE )
|
|
{
|
|
// find out if the filter property exists in this row
|
|
// NOTE:-
|
|
// filter property do exists in the seperate indexes only.
|
|
// refer to the logic of validating the filters in common functionality
|
|
lIndex = DynArrayFindStringEx( m_arrFiltersEx,
|
|
F_PARSED_INDEX_PROPERTY, FILTER_MODULES, TRUE, 0 );
|
|
if ( lIndex != -1 )
|
|
m_bNeedModulesInfo = TRUE;
|
|
}
|
|
|
|
//
|
|
// do the filter optimization by adding the wmi properties to the query
|
|
//
|
|
// NOTE: as the 'handle' property of the Win32_Process class is string type
|
|
// we cannot include that in the wmi query for optimization. So make use
|
|
// of the ProcessId property
|
|
|
|
// optimization should not be done if user requested for tree termination
|
|
if ( m_bTree == TRUE )
|
|
{
|
|
try
|
|
{
|
|
// default query
|
|
m_strQuery = WMI_PROCESS_QUERY;
|
|
}
|
|
catch( ... )
|
|
{
|
|
SetLastError( E_OUTOFMEMORY );
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
// modify the record filtering type for "memusage" filter from built-in type to custom type
|
|
( m_pfilterConfigs + FI_MEMUSAGE )->dwFlags = F_TYPE_CUSTOM;
|
|
( m_pfilterConfigs + FI_MEMUSAGE )->pFunctionData = NULL;
|
|
( m_pfilterConfigs + FI_MEMUSAGE )->pFunction = FilterMemUsage;
|
|
|
|
// modify the record filtering type for "pid" filter from custom to built-in type
|
|
( m_pfilterConfigs + FI_PID )->dwFlags = F_TYPE_UNUMERIC;
|
|
( m_pfilterConfigs + FI_PID )->pFunctionData = NULL;
|
|
( m_pfilterConfigs + FI_PID )->pFunction = NULL;
|
|
|
|
// simply return ... filter validation is complete
|
|
return TRUE;
|
|
}
|
|
|
|
// variables needed by optimization logic
|
|
LONG lCount = 0;
|
|
CHString strBuffer;
|
|
BOOL bOptimized = FALSE;
|
|
LPCWSTR pwszValue = NULL;
|
|
LPCWSTR pwszClause = NULL;
|
|
LPCWSTR pwszProperty = NULL;
|
|
LPCWSTR pwszOperator = NULL;
|
|
|
|
try
|
|
{
|
|
// first clause .. and init
|
|
m_strQuery = WMI_PROCESS_QUERY;
|
|
pwszClause = WMI_QUERY_FIRST_CLAUSE;
|
|
|
|
// get the no. of filters
|
|
lCount = DynArrayGetCount( m_arrFiltersEx );
|
|
|
|
// traverse thru all the filters and do the optimization
|
|
m_bFiltersOptimized = FALSE;
|
|
for( LONG i = 0; i < lCount; i++ )
|
|
{
|
|
// assume this filter will not be delete / not useful for optimization
|
|
bOptimized = FALSE;
|
|
|
|
// get the property, operator and value
|
|
pwszValue = DynArrayItemAsString2( m_arrFiltersEx, i, F_PARSED_INDEX_VALUE );
|
|
pwszProperty = DynArrayItemAsString2( m_arrFiltersEx, i, F_PARSED_INDEX_PROPERTY );
|
|
pwszOperator = DynArrayItemAsString2( m_arrFiltersEx, i, F_PARSED_INDEX_OPERATOR );
|
|
if ( pwszProperty == NULL || pwszOperator == NULL || pwszValue == NULL )
|
|
{
|
|
SetLastError( STG_E_UNKNOWN );
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// based on the property do optimization needed
|
|
|
|
// get the mathematically equivalent operator
|
|
pwszOperator = FindOperator( pwszOperator );
|
|
|
|
// process id
|
|
if ( StringCompare( FILTER_PID, pwszProperty, TRUE, 0 ) == 0 )
|
|
{
|
|
// convert the value into numeric
|
|
DWORD dwProcessId = AsLong( pwszValue, 10 );
|
|
strBuffer.Format( L" %s %s %s %d",
|
|
pwszClause, WIN32_PROCESS_PROPERTY_PROCESSID, pwszOperator, dwProcessId );
|
|
|
|
// need to be optimized
|
|
bOptimized = TRUE;
|
|
}
|
|
|
|
// session id
|
|
else if ( StringCompare( FILTER_SESSION, pwszProperty, TRUE, 0 ) == 0 )
|
|
{
|
|
// convert the value into numeric
|
|
DWORD dwSession = AsLong( pwszValue, 10 );
|
|
strBuffer.Format( L" %s %s %s %d",
|
|
pwszClause, WIN32_PROCESS_PROPERTY_SESSION, pwszOperator, dwSession );
|
|
|
|
// need to be optimized
|
|
bOptimized = TRUE;
|
|
}
|
|
|
|
// image name
|
|
else if ( StringCompare( FILTER_IMAGENAME, pwszProperty, TRUE, 0 ) == 0 )
|
|
{
|
|
// check if wild card is specified or not
|
|
// if wild card is specified, this filter cannot be optimized
|
|
if ( wcschr( pwszValue, L'*' ) == NULL )
|
|
{
|
|
// no conversions needed
|
|
strBuffer.Format( L" %s %s %s '%s'",
|
|
pwszClause, WIN32_PROCESS_PROPERTY_IMAGENAME, pwszOperator, pwszValue );
|
|
|
|
// need to be optimized
|
|
bOptimized = TRUE;
|
|
}
|
|
}
|
|
|
|
// status
|
|
else if ( StringCompare( FILTER_STATUS, pwszProperty, TRUE, 0 ) == 0 )
|
|
{
|
|
//
|
|
// do the value conversions
|
|
//
|
|
// if OPERATOR is =
|
|
// value: RUNNING means OPERATOR is > and VALUE is 0
|
|
// NOT RESPONDING means OPERATOR = and VALUE is 0
|
|
//
|
|
// if OPERATOR is !=
|
|
// value: RUNNING means OPERATOR is = and VALUE is 0
|
|
// NOT RESPONDING means OPERATOR is > and VALUE is 0
|
|
if ( StringCompare( pwszValue, VALUE_RUNNING, TRUE, 0 ) == 0 )
|
|
{
|
|
if ( StringCompare( pwszOperator, MATH_EQ, TRUE, 0 ) == 0 )
|
|
pwszOperator = MATH_GT;
|
|
else
|
|
pwszOperator = MATH_EQ;
|
|
}
|
|
else
|
|
{
|
|
if ( StringCompare( pwszOperator, MATH_EQ, TRUE, 0 ) == 0 )
|
|
pwszOperator = MATH_EQ;
|
|
else
|
|
pwszOperator = MATH_GT;
|
|
}
|
|
|
|
// finally the filter condition
|
|
strBuffer.Format( L" %s %s %s 0",
|
|
pwszClause, WIN32_PROCESS_PROPERTY_THREADS, pwszOperator );
|
|
|
|
// need to be optimized
|
|
bOptimized = TRUE;
|
|
}
|
|
|
|
// mem usage
|
|
else if ( StringCompare( FILTER_MEMUSAGE, pwszProperty, TRUE, 0 ) == 0 )
|
|
{
|
|
// convert the value into numeric
|
|
ULONG ulMemUsage = AsLong( pwszValue, 10 ) * 1024;
|
|
strBuffer.Format( L" %s %s %s %lu",
|
|
pwszClause, WIN32_PROCESS_PROPERTY_MEMUSAGE, pwszOperator, ulMemUsage );
|
|
|
|
// need to be optimized
|
|
bOptimized = TRUE;
|
|
}
|
|
|
|
// check if property is optimizable ... if yes ... remove
|
|
if ( bOptimized == TRUE )
|
|
{
|
|
// change the clause and append the current query
|
|
m_strQuery += strBuffer;
|
|
pwszClause = WMI_QUERY_SECOND_CLAUSE;
|
|
|
|
// remove property and update the iterator variables
|
|
m_bFiltersOptimized = TRUE;
|
|
DynArrayRemove( m_arrFiltersEx, i );
|
|
i--;
|
|
lCount--;
|
|
}
|
|
}
|
|
|
|
// final touch up to the query
|
|
if ( m_bFiltersOptimized == TRUE )
|
|
m_strQuery += L" )";
|
|
}
|
|
catch( ... )
|
|
{
|
|
SetLastError( E_OUTOFMEMORY );
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
// return the filter validation result
|
|
return TRUE;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
// ***************************************************************************
|
|
BOOL TimeFieldsToElapsedTime( LPCWSTR pwszTime, LPCWSTR pwszToken, ULONG& ulElapsedTime )
|
|
{
|
|
// local variables
|
|
ULONG ulValue = 0;
|
|
LPCWSTR pwszField = NULL;
|
|
__STRING_64 szTemp = NULL_STRING;
|
|
DWORD dwNext = 0, dwLength = 0, dwCount = 0;
|
|
|
|
// check the input
|
|
if ( pwszTime == NULL || pwszToken == NULL )
|
|
return FALSE;
|
|
|
|
// start parsing the time info
|
|
dwNext = 0;
|
|
dwCount = 0;
|
|
ulElapsedTime = 0;
|
|
do
|
|
{
|
|
// search for the needed token
|
|
pwszField = FindString( pwszTime, pwszToken, dwNext );
|
|
if ( pwszField == NULL )
|
|
{
|
|
// check whether some more text exists in the actual string or not
|
|
if ( (LONG) dwNext >= lstrlen( pwszTime ) )
|
|
break; // no more info found
|
|
|
|
// get the last info
|
|
lstrcpyn( szTemp, pwszTime + dwNext, SIZE_OF_ARRAY( szTemp ) );
|
|
dwLength = lstrlen( szTemp ); // update the length
|
|
}
|
|
else
|
|
{
|
|
// determine the length of numeric value and get the numeric value
|
|
dwLength = lstrlen( pwszTime ) - lstrlen( pwszField ) - dwNext;
|
|
|
|
// check the length info
|
|
if ( dwLength > SIZE_OF_ARRAY( szTemp ) )
|
|
return FALSE;
|
|
|
|
// get the current info
|
|
lstrcpyn( szTemp, pwszTime + dwNext, dwLength + 1 ); // +1 for NULL character
|
|
}
|
|
|
|
// update the count of fields we are getting
|
|
dwCount++;
|
|
|
|
// check whether this field is numeric or not
|
|
if ( lstrlen( szTemp ) == 0 || IsNumeric( szTemp, 10, FALSE ) == FALSE )
|
|
return FALSE;
|
|
|
|
// from second token onwards, values greater than 59 are not allowed
|
|
ulValue = AsLong( szTemp, 10 );
|
|
if ( dwCount > 1 && ulValue > 59 )
|
|
return FALSE;
|
|
|
|
// update the elapsed time
|
|
ulElapsedTime = ( ulElapsedTime + ulValue ) * (( dwCount < 3 ) ? 60 : 1);
|
|
|
|
// position to the next information start
|
|
dwNext += dwLength + lstrlen( pwszToken );
|
|
} while ( pwszField != NULL && dwCount < 3 );
|
|
|
|
// check the no. of time field we got .. we should have got 3 .. if not error
|
|
if ( pwszField != NULL || dwCount != 3 )
|
|
return FALSE;
|
|
|
|
// so everything went right ... return success
|
|
return TRUE;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
// ***************************************************************************
|
|
DWORD FilterCPUTime( LPCWSTR pwszProperty, LPCWSTR pwszOperator,
|
|
LPCWSTR pwszValue, LPVOID pData, TARRAY arrRow )
|
|
{
|
|
// local variables
|
|
ULONG ulCPUTime = 0;
|
|
ULONG ulElapsedTime = 0;
|
|
LPCWSTR pwszCPUTime = NULL;
|
|
|
|
// check the inputs
|
|
if ( pwszProperty == NULL || pwszOperator == NULL || pwszValue == NULL )
|
|
return F_FILTER_INVALID;
|
|
|
|
// if the arrRow parameter is NULL, we need to validate the filter
|
|
if ( arrRow == NULL )
|
|
{
|
|
// validate the filter value and return the result
|
|
if ( TimeFieldsToElapsedTime( pwszValue, L":", ulElapsedTime ) == FALSE )
|
|
return F_FILTER_INVALID;
|
|
else
|
|
return F_FILTER_VALID;
|
|
}
|
|
|
|
// get the filter value
|
|
TimeFieldsToElapsedTime( pwszValue, L":", ulElapsedTime );
|
|
|
|
// get the record value
|
|
pwszCPUTime = DynArrayItemAsString( arrRow, TASK_CPUTIME );
|
|
if ( pwszCPUTime == NULL )
|
|
return F_RESULT_REMOVE;
|
|
|
|
// convert the record value into elapsed time value
|
|
TimeFieldsToElapsedTime( pwszCPUTime, L":", ulCPUTime );
|
|
|
|
// return the result
|
|
if ( ulCPUTime == ulElapsedTime )
|
|
return MASK_EQ;
|
|
else if ( ulCPUTime < ulElapsedTime )
|
|
return MASK_LT;
|
|
else if ( ulCPUTime > ulElapsedTime )
|
|
return MASK_GT;
|
|
|
|
// no way flow coming here .. still
|
|
return F_RESULT_REMOVE;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
// ***************************************************************************
|
|
DWORD FilterMemUsage( LPCWSTR pwszProperty, LPCWSTR pwszOperator,
|
|
LPCWSTR pwszValue, LPVOID pData, TARRAY arrRow )
|
|
{
|
|
// local variables
|
|
DWORD dwLength = 0;
|
|
ULONGLONG ulValue = 0;
|
|
ULONGLONG ulMemUsage = 0;
|
|
LPCWSTR pwszMemUsage = NULL;
|
|
|
|
// check the inputs
|
|
if ( pwszProperty == NULL || pwszOperator == NULL || pwszValue == NULL )
|
|
return F_FILTER_INVALID;
|
|
|
|
// check the arrRow parameter
|
|
// because this function will not / should not be called except for filtering
|
|
if ( arrRow == NULL )
|
|
return F_FILTER_INVALID;
|
|
|
|
// check the inputs
|
|
if ( pwszValue == NULL )
|
|
return F_RESULT_REMOVE;
|
|
|
|
// get the memusage value
|
|
pwszMemUsage = DynArrayItemAsString( arrRow, TASK_MEMUSAGE );
|
|
if ( pwszMemUsage == NULL )
|
|
return F_RESULT_REMOVE;
|
|
|
|
// NOTE: as there is no conversion API as of today we use manual ULONGLONG value
|
|
// preparation from string value
|
|
ulMemUsage = 0;
|
|
dwLength = lstrlen( pwszMemUsage );
|
|
for( DWORD dw = 0; dw < dwLength; dw++ )
|
|
{
|
|
// validate the digit
|
|
if ( pwszMemUsage[ dw ] < L'0' || pwszMemUsage[ dw ] > '9' )
|
|
return F_RESULT_REMOVE;
|
|
|
|
// ...
|
|
ulMemUsage = ulMemUsage * 10 + ( pwszMemUsage[ dw ] - 48 );
|
|
}
|
|
|
|
// get the user specified value
|
|
ulValue = AsLong( pwszValue, 10 );
|
|
|
|
//
|
|
// now determine the result value
|
|
if ( ulMemUsage == ulValue )
|
|
return MASK_EQ;
|
|
else if ( ulMemUsage < ulValue )
|
|
return MASK_LT;
|
|
else if ( ulMemUsage > ulValue )
|
|
return MASK_GT;
|
|
|
|
// never come across this situation ... still
|
|
return F_RESULT_REMOVE;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
// ***************************************************************************
|
|
DWORD FilterUserName( LPCWSTR pwszProperty, LPCWSTR pwszOperator,
|
|
LPCWSTR pwszValue, LPVOID pData, TARRAY arrRow )
|
|
{
|
|
// local variables
|
|
LONG lResult = 0;
|
|
LONG lWildCardPos = 0;
|
|
LPCWSTR pwszTemp = NULL;
|
|
LPCWSTR pwszSearch = NULL;
|
|
BOOL bOnlyUserName = FALSE;
|
|
LPCWSTR pwszUserName = NULL;
|
|
|
|
// check the inputs
|
|
if ( pwszProperty == NULL || pwszOperator == NULL || pwszValue == NULL )
|
|
return F_FILTER_INVALID;
|
|
|
|
// if the arrRow parameter is NULL, we need to validate the filter
|
|
if ( arrRow == NULL )
|
|
{
|
|
// nothing is there to validate ... just check the length
|
|
// and ensure that so text is present and the value should not be just '*'
|
|
// NOTE: the common functionality will give the value after doing left and right trim
|
|
if ( lstrlen( pwszValue ) == 0 || StringCompare( pwszValue, L"*", TRUE, 0 ) == 0 )
|
|
return F_FILTER_INVALID;
|
|
|
|
// the wild card character is allowed only at the end
|
|
pwszTemp = _tcschr( pwszValue, L'*' );
|
|
if ( pwszTemp != NULL && lstrlen( pwszTemp + 1 ) != 0 )
|
|
return F_FILTER_INVALID;
|
|
|
|
// filter is valid
|
|
return F_FILTER_VALID;
|
|
}
|
|
|
|
// find the position of the wild card in the supplied user name
|
|
lWildCardPos = 0;
|
|
pwszTemp = _tcschr( pwszValue, L'*' );
|
|
if ( pwszTemp != NULL )
|
|
{
|
|
// determine the wild card position
|
|
lWildCardPos = lstrlen( pwszValue ) - lstrlen( pwszTemp );
|
|
|
|
// special case:
|
|
// if the pattern is just asterisk, which means that all the
|
|
// information needs to passed thru the filter but there is no chance for
|
|
// this situation as specifying only '*' is being treated as invalid filter
|
|
if ( lWildCardPos == 0 )
|
|
return F_FILTER_INVALID;
|
|
}
|
|
|
|
// search for the domain and user name seperator ...
|
|
// if domain name is not specified, comparision will be done only with the user name
|
|
bOnlyUserName = FALSE;
|
|
pwszTemp = _tcschr( pwszValue, L'\\' );
|
|
if ( pwszTemp == NULL )
|
|
bOnlyUserName = TRUE;
|
|
|
|
// get the user name from the info
|
|
pwszUserName = DynArrayItemAsString( arrRow, TASK_USERNAME );
|
|
if ( pwszUserName == NULL )
|
|
return F_RESULT_REMOVE;
|
|
|
|
// based the search criteria .. meaning whether to search along with the domain or
|
|
// only user name, the seach string will be decided
|
|
pwszSearch = pwszUserName;
|
|
if ( bOnlyUserName == TRUE )
|
|
{
|
|
// search for the domain and user name seperation character
|
|
pwszTemp = _tcschr( pwszUserName, L'\\' );
|
|
|
|
// position to the next character
|
|
if ( pwszTemp != NULL )
|
|
pwszSearch = pwszTemp + 1;
|
|
}
|
|
|
|
// validate the search string
|
|
if ( pwszSearch == NULL )
|
|
return F_RESULT_REMOVE;
|
|
|
|
// now do the comparision
|
|
lResult = StringCompare( pwszSearch, pwszValue, TRUE, lWildCardPos );
|
|
|
|
//
|
|
// now determine the result value
|
|
if ( lResult == 0 )
|
|
return MASK_EQ;
|
|
else if ( lResult < 0 )
|
|
return MASK_LT;
|
|
else if ( lResult > 0 )
|
|
return MASK_GT;
|
|
|
|
// never come across this situation ... still
|
|
return F_RESULT_REMOVE;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
// ***************************************************************************
|
|
DWORD FilterProcessId( LPCWSTR pwszProperty, LPCWSTR pwszOperator,
|
|
LPCWSTR pwszValue, LPVOID pData, TARRAY arrRow )
|
|
{
|
|
// local variables
|
|
LONG lIndex = 0;
|
|
LPWSTR pwsz = NULL;
|
|
|
|
// check the inputs
|
|
if ( pwszProperty == NULL || pwszOperator == NULL || pwszValue == NULL )
|
|
return F_FILTER_INVALID;
|
|
|
|
// check the arrRow parameter
|
|
// because this function will not / should not be called except for validation
|
|
if ( arrRow != NULL )
|
|
return F_RESULT_REMOVE;
|
|
|
|
// check the inputs ( only needed ones )
|
|
if ( pwszValue == NULL )
|
|
return F_FILTER_INVALID;
|
|
|
|
// NOTE: do not call the IsNumeric function. do the numeric validation in this module itself
|
|
// also do not check for the overflow (or) underflow.
|
|
// just check whether input is numeric or not
|
|
wcstoul( pwszValue, &pwsz, 10 );
|
|
if ( lstrlen( pwszValue ) == 0 || (pwsz != NULL && lstrlen( pwsz ) > 0 ))
|
|
return F_FILTER_INVALID;
|
|
|
|
// check if overflow (or) undeflow occured
|
|
if ( errno == ERANGE )
|
|
{
|
|
SetReason( ERROR_NO_PROCESSES );
|
|
return F_FILTER_INVALID;
|
|
}
|
|
|
|
// return
|
|
return F_FILTER_VALID;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
// ***************************************************************************
|
|
BOOL ValidatePID( LPCWSTR pwszOption, LPCWSTR pwszValue, LPVOID pData )
|
|
{
|
|
// local variable
|
|
LONG lIndex = 0;
|
|
LPWSTR pwsz = NULL;
|
|
TARRAY arrTasks = NULL;
|
|
|
|
// check the input values
|
|
if ( pwszOption == NULL || pwszValue == NULL || pData == NULL )
|
|
{
|
|
SetLastError( E_OUTOFMEMORY );
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
// NOTE: do not call the IsNumeric function. do the numeric validation in this module itself
|
|
// also do not check for the overflow (or) underflow.
|
|
// just check whether input is numeric or not
|
|
wcstoul( pwszValue, &pwsz, 10 );
|
|
if ( lstrlen( pwszValue ) == 0 || (pwsz != NULL && lstrlen( pwsz ) > 0 ))
|
|
{
|
|
SetReason( ERROR_STRING_FOR_PID );
|
|
return FALSE;
|
|
}
|
|
|
|
// check whether current value already exists in the list or not
|
|
arrTasks = (TARRAY) pData; // get the array reference
|
|
lIndex = DynArrayFindString( arrTasks, pwszValue, TRUE, 0 );
|
|
if ( lIndex == -1 && DynArrayAppendString( arrTasks, pwszValue, 0 ) == -1 )
|
|
{
|
|
SetLastError( E_OUTOFMEMORY );
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
// return the result
|
|
return TRUE;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This function fetches usage information from resource file and shows it
|
|
//
|
|
// Arguments:
|
|
// NONE
|
|
//
|
|
// Return Value:
|
|
// NONE
|
|
// ***************************************************************************
|
|
VOID CTaskKill::Usage()
|
|
{
|
|
// local variables
|
|
DWORD dw = 0;
|
|
|
|
// start displaying the usage
|
|
for( dw = ID_HELP_START; dw <= ID_HELP_END; dw++ )
|
|
ShowMessage( stdout, GetResString( dw ) );
|
|
}
|