1191 lines
36 KiB
C
1191 lines
36 KiB
C
// *********************************************************************************
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//
|
|
// Module Name:
|
|
//
|
|
// EventCreate.c
|
|
//
|
|
// Abstract:
|
|
//
|
|
// This modules implements creation of event in the user specified log / application
|
|
//
|
|
// Syntax:
|
|
// ------
|
|
// EventCreate [-s server [-u username [-p password]]]
|
|
// [-log name] [-source name] -id eventid -description description -type eventtype
|
|
//
|
|
// Author:
|
|
//
|
|
// Sunil G.V.N. Murali (murali.sunil@wipro.com) 24-Sep-2000
|
|
//
|
|
// Revision History:
|
|
//
|
|
// Sunil G.V.N. Murali (murali.sunil@wipro.com) 24-Sep-2000 : Created It.
|
|
//
|
|
// *********************************************************************************
|
|
|
|
#include "pch.h"
|
|
#include "EvcrtMsg.h"
|
|
#include "EventCreate.h"
|
|
|
|
//
|
|
// local type definitions
|
|
//
|
|
typedef TCHAR __OPTION_VALUE[ 256 ];
|
|
|
|
//
|
|
// constants / defines / enumerators
|
|
//
|
|
#define FULL_SUCCESS 0
|
|
#define PARTIALLY_SUCCESS 128
|
|
#define COMPLETELY_FAILED 255
|
|
|
|
#define MAX_KEY_LENGTH 256
|
|
#define EVENT_LOG_NAMES_LOCATION _T( "SYSTEM\\CurrentControlSet\\Services\\EventLog" )
|
|
|
|
// constants
|
|
const TCHAR g_szDefaultLog[] = _T( "Application" );
|
|
const TCHAR g_szDefaultSource[] = _T( "EventCreate" );
|
|
|
|
//
|
|
// function prototypes
|
|
//
|
|
VOID Usage();
|
|
BOOL AddEventSource( HKEY hLogsKey, LPCTSTR pszSource );
|
|
BOOL CheckExistence( LPCTSTR szServer,
|
|
LPCTSTR szLog, LPCTSTR szSource, PBOOL pbCustom );
|
|
BOOL CreateLogEvent( LPCTSTR szServer,
|
|
LPCTSTR szLog, LPCTSTR szSource,
|
|
WORD wType, DWORD dwEventID, LPCTSTR szDescription );
|
|
BOOL ProcessOptions( LONG argc,
|
|
LPCTSTR argv[],
|
|
PBOOL pbShowUsage,
|
|
PTARRAY parrServer, LPTSTR ppszUserName, LPTSTR ppszPassword,
|
|
LPTSTR ppszLogName, LPTSTR ppszLogSource, LPTSTR ppszLogType,
|
|
PDWORD pdwEventID, LPTSTR ppszDescription, PBOOL pbNeedPwd );
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This the entry point to this utility.
|
|
//
|
|
// Arguments:
|
|
// [ in ] argc : argument(s) count specified at the command prompt
|
|
// [ in ] argv : argument(s) specified at the command prompt
|
|
//
|
|
// Return Value:
|
|
// The below are actually not return values but are the exit values
|
|
// returned to the OS by this application
|
|
// 0 : utility successfully created the events
|
|
// 255 : utility completely failed in creating events
|
|
// 128 : utility has partially successfull in creating events
|
|
// ***************************************************************************
|
|
DWORD _cdecl _tmain( LONG argc, LPCTSTR argv[] )
|
|
{
|
|
// local variables
|
|
DWORD dw = 0;
|
|
WORD wEventType = 0;
|
|
BOOL bResult = FALSE;
|
|
LPCTSTR pszServer = NULL;
|
|
BOOL bNeedPassword = FALSE;
|
|
BOOL bCloseConnection = FALSE;
|
|
DWORD dwServers = 0, dwSuccess = 0;
|
|
__STRING_512 szBuffer = NULL_STRING;
|
|
|
|
// variables to hold the command line inputs
|
|
BOOL bUsage = FALSE; // usage
|
|
DWORD dwEventID = 0; // event id
|
|
TARRAY arrServers = NULL; // holds the list of server names
|
|
__OPTION_VALUE szLogName = NULL_STRING; // log file name
|
|
__OPTION_VALUE szSource = NULL_STRING; // source name
|
|
__OPTION_VALUE szType = NULL_STRING; // event type
|
|
__OPTION_VALUE szUserName = NULL_STRING; // user name
|
|
__OPTION_VALUE szPassword = NULL_STRING; // password
|
|
__OPTION_VALUE szDescription = NULL_STRING; // description of the event
|
|
|
|
// create a dynamic array
|
|
arrServers = CreateDynamicArray();
|
|
if ( arrServers == NULL )
|
|
{
|
|
SetLastError( E_OUTOFMEMORY );
|
|
ShowLastError( stderr );
|
|
EXIT_PROCESS( 1 );
|
|
}
|
|
|
|
// process the command-line options
|
|
bResult = ProcessOptions( argc, argv, &bUsage,
|
|
&arrServers, szUserName, szPassword, szLogName,
|
|
szSource, szType, &dwEventID, szDescription, &bNeedPassword );
|
|
|
|
// check the result of the parsing
|
|
if ( bResult == FALSE )
|
|
{
|
|
// invalid syntax
|
|
DISPLAY_MESSAGE2( stderr, szBuffer, _T( "%s %s" ), TAG_ERROR, GetReason() );
|
|
|
|
// release memory
|
|
DestroyDynamicArray( &arrServers );
|
|
|
|
// exit from program
|
|
EXIT_PROCESS( 1 );
|
|
}
|
|
|
|
// check whether usage has to be displayed or not
|
|
if ( bUsage == TRUE )
|
|
{
|
|
// show the usage of the utility
|
|
Usage();
|
|
|
|
// release memory
|
|
DestroyDynamicArray( &arrServers );
|
|
|
|
// finally exit from the program
|
|
EXIT_PROCESS( 0 );
|
|
}
|
|
|
|
// determine the actual event type
|
|
if ( StringCompare( szType, LOGTYPE_ERROR, TRUE, 0 ) == 0 )
|
|
wEventType = EVENTLOG_ERROR_TYPE;
|
|
else if ( StringCompare( szType, LOGTYPE_WARNING, TRUE, 0 ) == 0 )
|
|
wEventType = EVENTLOG_WARNING_TYPE;
|
|
else if ( StringCompare( szType, LOGTYPE_INFORMATION, TRUE, 0 ) == 0 )
|
|
wEventType = EVENTLOG_INFORMATION_TYPE;
|
|
|
|
// ******
|
|
// actual creation of events in respective log files will start from here
|
|
|
|
// get the no. of servers specified
|
|
dwServers = DynArrayGetCount( arrServers );
|
|
|
|
// now traverse thru the list of servers, and do the needed operations
|
|
dwSuccess = 0;
|
|
for( dw = 0; dw < dwServers; dw++ )
|
|
{
|
|
// get the system name
|
|
pszServer = DynArrayItemAsString( arrServers, dw );
|
|
if ( pszServer == NULL )
|
|
continue;
|
|
|
|
// try establishing connection to the required terminal
|
|
bCloseConnection = TRUE;
|
|
bResult = EstablishConnection(
|
|
pszServer, szUserName, SIZE_OF_ARRAY( szUserName ),
|
|
szPassword, SIZE_OF_ARRAY( szPassword ), bNeedPassword );
|
|
bNeedPassword = FALSE; // from next time onwards, we shouldn't prompt for passwd
|
|
if ( bResult == FALSE )
|
|
{
|
|
//
|
|
// failed in establishing n/w connection
|
|
SHOW_RESULT_MESSAGE( NULL, TAG_ERROR, GetReason() );
|
|
|
|
// try with next server
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
// though the connection is successfull, some conflict might have occured
|
|
switch( GetLastError() )
|
|
{
|
|
case I_NO_CLOSE_CONNECTION:
|
|
bCloseConnection = FALSE;
|
|
break;
|
|
|
|
case E_LOCAL_CREDENTIALS:
|
|
case ERROR_SESSION_CREDENTIAL_CONFLICT:
|
|
{
|
|
bCloseConnection = FALSE;
|
|
SHOW_RESULT_MESSAGE( NULL, TAG_WARNING, GetReason() );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// report the log message
|
|
bResult = CreateLogEvent( pszServer, szLogName,
|
|
szSource, wEventType, dwEventID, szDescription );
|
|
if ( bResult == TRUE )
|
|
{
|
|
// display the message depending on the mode of conncetivity
|
|
if ( lstrlen( szSource ) != 0 )
|
|
{
|
|
DISPLAY_MESSAGE( stdout, _T( "\n" ) );
|
|
DISPLAY_MESSAGE2(stdout, szBuffer, EVENTCREATE_SUCCESS, szType, szSource);
|
|
}
|
|
else
|
|
{
|
|
DISPLAY_MESSAGE( stdout, _T( "\n" ) );
|
|
DISPLAY_MESSAGE2(stdout, szBuffer, EVENTCREATE_SUCCESS, szType, szLogName);
|
|
}
|
|
|
|
// update the success count
|
|
dwSuccess++;
|
|
}
|
|
else
|
|
{
|
|
// display the message depending on the mode of conncetivity
|
|
// SHOW_RESULT_MESSAGE( pszServer, TAG_ERROR, GetReason() );
|
|
// ( we are temporarily displaying only the error message )
|
|
SHOW_RESULT_MESSAGE( NULL, TAG_ERROR, GetReason() );
|
|
}
|
|
|
|
// close the connection that was established by the utility
|
|
if ( bCloseConnection == TRUE )
|
|
CloseConnection( pszServer );
|
|
}
|
|
|
|
// destroy the dynamic array
|
|
DestroyDynamicArray( &arrServers );
|
|
|
|
// depending the success count, determine whether the exit value
|
|
// FULL SUCCESS / PARTIAL SUCCESS / COMPLETELY FAILED
|
|
return (dwSuccess == dwServers) ? FULL_SUCCESS :
|
|
((dwSuccess == 0) ? COMPLETELY_FAILED : PARTIALLY_SUCCESS);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This function connects to the specified server's event log (or) source
|
|
// and appropriately creates the needed event in it.
|
|
//
|
|
// Arguments:
|
|
// [ in ] szServer : server name on which event has to be created.
|
|
// null string has to be passed in order to create
|
|
// event on a local system.
|
|
// [ in ] szLog : Log name in which event has to be created.
|
|
// [ in ] szSource : Source name in which event has to be created.
|
|
// if log name is also specified, log name will be
|
|
// given priority and value in this variable is ignored.
|
|
// [ in ] wType : specifies type of the event that has to be created
|
|
// [ in ] dwEventID : event id for the event is being created
|
|
// [ in ] szDescription : description to the event
|
|
//
|
|
// Return Value:
|
|
// TRUE : if the event creation is successful
|
|
// FALSE : if failed in creating the event
|
|
// ***************************************************************************
|
|
BOOL CreateLogEvent( LPCTSTR szServer, LPCTSTR szLog, LPCTSTR szSource,
|
|
WORD wType, DWORD dwEventID, LPCTSTR szDescription )
|
|
{
|
|
// local variables
|
|
BOOL bReturn = 0; // return value
|
|
BOOL bCustom = FALSE;
|
|
DWORD dwSeverity = 0;
|
|
HANDLE hEventLog = NULL; // points to the event log
|
|
LPCTSTR lpszDescriptions[ 1 ] = { NULL }; // building descriptions
|
|
__MAX_SIZE_STRING szBuffer = NULL_STRING;
|
|
|
|
//
|
|
// start the process
|
|
|
|
// check whether the log / source exists in the registry or not
|
|
bCustom = FALSE;
|
|
if ( CheckExistence( szServer, szLog, szSource, &bCustom ) == FALSE )
|
|
return FALSE; // return failure
|
|
|
|
// check whether the source is custom create or pre-existing source
|
|
if ( bCustom == FALSE )
|
|
{
|
|
// we wont create events in a non-custom source
|
|
SetReason( ERROR_NONCUSTOM_SOURCE );
|
|
return FALSE;
|
|
}
|
|
|
|
// open the appropriate event log using the specified 'source' or 'log file'
|
|
// and check the result of the operation
|
|
// Note: At one time, we will make use of log name (or) source but not both
|
|
if ( lstrlen( szSource ) != 0 )
|
|
hEventLog = RegisterEventSource( szServer, szSource ); // open log using source name
|
|
else
|
|
hEventLog = OpenEventLog( szServer, szLog ); // open log
|
|
|
|
// check the log open/register result
|
|
if ( hEventLog == NULL )
|
|
{
|
|
// opening/registering is failed
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
// determine the severity code
|
|
dwSeverity = 0;
|
|
if ( wType == EVENTLOG_ERROR_TYPE )
|
|
dwSeverity = 3;
|
|
else if ( wType == EVENTLOG_WARNING_TYPE )
|
|
dwSeverity = 2;
|
|
else if ( wType == EVENTLOG_INFORMATION_TYPE )
|
|
dwSeverity = 1;
|
|
|
|
// report event
|
|
lpszDescriptions[ 0 ] = szDescription;
|
|
if ( bCustom == TRUE )
|
|
{
|
|
// validate the range of the event id specified
|
|
if ( dwEventID >= MSG_EVENTID_START && dwEventID <= MSG_EVENTID_END )
|
|
{
|
|
// valid event id
|
|
bReturn = ReportEvent( hEventLog, wType, 0, dwEventID, NULL, 1, 0, lpszDescriptions, NULL);
|
|
|
|
// check the result
|
|
if ( bReturn == FALSE )
|
|
SaveLastError(); // save the error info
|
|
}
|
|
else
|
|
{
|
|
// format the error message
|
|
bReturn = FALSE;
|
|
_stprintf( szBuffer, ERROR_ID_OUTOFRANGE, MSG_EVENTID_START, MSG_EVENTID_END - 1 );
|
|
SetReason( szBuffer );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// we are stopping from creating the events in a non-custom source
|
|
// ********************************************************************
|
|
// bReturn = ReportEvent( hEventLog, wType, 0,
|
|
// (((unsigned long)(dwSeverity)<<30) | ((unsigned long)(dwEventID))), NULL, 1, 0, lpszDescriptions, NULL);
|
|
|
|
// check the result
|
|
// if ( bReturn == FALSE )
|
|
// SaveLastError(); // save the error info
|
|
}
|
|
|
|
// close the event source
|
|
if ( lstrlen( szSource ) != 0 )
|
|
DeregisterEventSource( hEventLog );
|
|
else
|
|
CloseEventLog( hEventLog );
|
|
|
|
// return the result
|
|
return bReturn;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This function checks wether the log name or source name specified
|
|
// actually exists in the registry
|
|
//
|
|
// Arguments:
|
|
// [ in ] szServer - server name
|
|
// [ in ] szLog - log name
|
|
// [ in ] szSource - source name
|
|
//
|
|
// Return Value:
|
|
// TRUE : If log / source exists in the registry
|
|
// FALSE : if failed find the match
|
|
// ***************************************************************************
|
|
BOOL CheckExistence( LPCTSTR szServer, LPCTSTR szLog, LPCTSTR szSource, PBOOL pbCustom )
|
|
{
|
|
// local variables
|
|
DWORD dwSize = 0;
|
|
DWORD dwLogsIndex = 0;
|
|
DWORD dwDisposition = 0;
|
|
DWORD dwSourcesIndex = 0;
|
|
LONG lResult = 0L;
|
|
HKEY hKey = NULL;
|
|
HKEY hLogsKey = NULL;
|
|
HKEY hSourcesKey = NULL;
|
|
BOOL bFoundMatch = FALSE;
|
|
BOOL bDuplicating = FALSE;
|
|
FILETIME ftLastWriteTime; // variable that will hold the last write info
|
|
BOOL bErrorOccurred = FALSE;
|
|
BOOL bLog = FALSE, bLogMatched = FALSE;
|
|
BOOL bSource = FALSE, bSourceMatched = FALSE;
|
|
__MAX_SIZE_STRING szBuffer = NULL_STRING;
|
|
TCHAR szRLog[ MAX_KEY_LENGTH ] = NULL_STRING;
|
|
TCHAR szRSource[ MAX_KEY_LENGTH ] = NULL_STRING;
|
|
|
|
// prepare the server name into UNC format
|
|
lstrcpy( szBuffer, szServer );
|
|
if ( lstrlen( szServer ) != 0 && IsUNCFormat( szServer ) == FALSE )
|
|
{
|
|
// format the server name in UNC format
|
|
FORMAT_STRING( szBuffer, _T( "\\\\%s" ), szServer );
|
|
}
|
|
|
|
// Connect to the registry
|
|
lResult = RegConnectRegistry( szBuffer, HKEY_LOCAL_MACHINE, &hKey );
|
|
if ( lResult != ERROR_SUCCESS)
|
|
{
|
|
// save the error information and return FAILURE
|
|
SetLastError( lResult );
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
// open the "EventLogs" registry key for enumerating its sub-keys (which are log names)
|
|
lResult = RegOpenKeyEx( hKey, EVENT_LOG_NAMES_LOCATION, 0, KEY_READ, &hLogsKey );
|
|
if ( lResult != ERROR_SUCCESS )
|
|
{
|
|
switch( lResult )
|
|
{
|
|
case ERROR_FILE_NOT_FOUND:
|
|
SetLastError( ERROR_REGISTRY_CORRUPT );
|
|
break;
|
|
|
|
default:
|
|
// save the error information and return FAILURE
|
|
SetLastError( lResult );
|
|
break;
|
|
}
|
|
|
|
// close the key and return
|
|
SaveLastError();
|
|
RegCloseKey( hKey );
|
|
return FALSE;
|
|
}
|
|
|
|
// start enumerating the logs present
|
|
dwLogsIndex = 0; // initialize the logs index
|
|
bFoundMatch = FALSE; // assume neither log (or) source doesn't match
|
|
bErrorOccurred = FALSE; // assume error is not occured
|
|
dwSize = MAX_KEY_LENGTH; // max. size of the key buffer
|
|
bLogMatched = FALSE;
|
|
bSourceMatched = FALSE;
|
|
bDuplicating = FALSE;
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Logic:-
|
|
// 1. determine whether user has supplied the log name or not
|
|
// 2. determine whether user has supplied the source name or not
|
|
// 3. Start enumerating all the logs present in the system
|
|
// 4. check whether log is supplied or not, if yes, check whether
|
|
// the current log matches with user supplied one.
|
|
// 5. check whether source is supplied or not, if yes, enumerate the
|
|
// sources available under the current log
|
|
|
|
// determine whether searching has to be done of LOG (or) SOURCE
|
|
bLog = ( szLog != NULL && lstrlen( szLog ) != 0 ) ? TRUE : FALSE; // #1
|
|
bSource = ( szSource != NULL && lstrlen( szSource ) != 0 ) ? TRUE : FALSE; // #2
|
|
|
|
// initiate the enumeration of log present in the system -- #3
|
|
ZeroMemory( szRLog, MAX_KEY_LENGTH * sizeof( TCHAR ) ); // init to 0's - safe check
|
|
lResult = RegEnumKeyEx( hLogsKey, 0, szRLog, &dwSize, NULL, NULL, NULL, &ftLastWriteTime );
|
|
|
|
// traverse thru the sub-keys until there are no more items -- #3
|
|
do
|
|
{
|
|
// check the result
|
|
if ( lResult != ERROR_SUCCESS )
|
|
{
|
|
// save the error and break from the loop
|
|
bErrorOccurred = TRUE;
|
|
SetLastError( lResult );
|
|
SaveLastError();
|
|
break;
|
|
}
|
|
|
|
// if log name is passed, compare the current key value
|
|
// compare the log name with the current key -- #4
|
|
if ( bLog == TRUE && StringCompare( szLog, szRLog, TRUE, 0 ) == 0 )
|
|
bLogMatched = TRUE;
|
|
|
|
// if source name is passed ... -- #5
|
|
if ( bSource == TRUE && bSourceMatched == FALSE )
|
|
{
|
|
// open the current log name to enumerate the sources under this log
|
|
lResult = RegOpenKeyEx( hLogsKey, szRLog, 0, KEY_READ, &hSourcesKey );
|
|
if ( lResult != ERROR_SUCCESS )
|
|
{
|
|
// save the error and break from the loop
|
|
bErrorOccurred = TRUE;
|
|
SetLastError( lResult );
|
|
SaveLastError();
|
|
break;
|
|
}
|
|
|
|
// start enumerating the sources present
|
|
dwSourcesIndex = 0; // initialize the sources index
|
|
dwSize = MAX_KEY_LENGTH; // max. size of the key buffer
|
|
ZeroMemory( szRSource, MAX_KEY_LENGTH * sizeof( TCHAR ) );
|
|
lResult = RegEnumKeyEx( hSourcesKey, 0,
|
|
szRSource, &dwSize, NULL, NULL, NULL, &ftLastWriteTime );
|
|
|
|
// traverse thru the sub-keys until there are no more items
|
|
do
|
|
{
|
|
if ( lResult != ERROR_SUCCESS )
|
|
{
|
|
// save the error and break from the loop
|
|
bErrorOccurred = TRUE;
|
|
SetLastError( lResult );
|
|
SaveLastError();
|
|
break;
|
|
}
|
|
|
|
// check whether this key matches with the required source or not
|
|
if ( StringCompare( szSource, szRSource, TRUE, 0 ) == 0 )
|
|
{
|
|
// source matched
|
|
bSourceMatched = TRUE;
|
|
break; // break from the loop
|
|
}
|
|
|
|
// update the sources index and fetch the next source key
|
|
dwSourcesIndex += 1;
|
|
dwSize = MAX_KEY_LENGTH; // max. size of the key buffer
|
|
ZeroMemory( szRSource, MAX_KEY_LENGTH * sizeof( TCHAR ) );
|
|
lResult = RegEnumKeyEx( hSourcesKey, dwSourcesIndex, szRSource, &dwSize, NULL,
|
|
NULL, NULL, &ftLastWriteTime );
|
|
} while( lResult != ERROR_NO_MORE_ITEMS );
|
|
|
|
// close the sources registry key
|
|
RegCloseKey( hSourcesKey );
|
|
hSourcesKey = NULL; // clear the key value
|
|
|
|
// check how the loop ended
|
|
// 1. Source might have found
|
|
// Action:- we found required key .. exit from the main loop
|
|
// 2. Error might have occured
|
|
// Action:- ignore the error and continue fetching other log's sources
|
|
// 3. End of sources reached in this log
|
|
// Action:- check if log name is supplied or not.
|
|
// if log specified, then source if not found, break
|
|
// for cases 2 & 3, clear the contents of lResult for smooth processing
|
|
|
|
// Case #2 & #3
|
|
lResult = 0; // we are not much bothered abt the errors
|
|
bErrorOccurred = FALSE; // occured while traversing thru the source under logs
|
|
|
|
// Case #1
|
|
if ( bSourceMatched == TRUE )
|
|
{
|
|
// check whether log is specified or not
|
|
// if log is specified, it should have matched .. otherwise
|
|
// error ... because duplicate source should not be created
|
|
if ( bLog == FALSE || ( bLog && bLogMatched && lstrcmpi( szLog, szRLog ) == 0 ) )
|
|
{
|
|
// no problem ...
|
|
bFoundMatch = TRUE;
|
|
|
|
//
|
|
// determine whether this is custom created source or not
|
|
|
|
// mark this as custom source
|
|
if ( pbCustom != NULL )
|
|
*pbCustom = FALSE;
|
|
|
|
// open the source registry key
|
|
_stprintf( szBuffer, _T( "%s\\%s\\%s" ), EVENT_LOG_NAMES_LOCATION, szRLog, szRSource );
|
|
lResult = RegOpenKeyEx( hKey, szBuffer, 0, KEY_QUERY_VALUE, &hSourcesKey );
|
|
if ( lResult != ERROR_SUCCESS )
|
|
{
|
|
SetLastError( lResult );
|
|
SaveLastError();
|
|
bErrorOccurred = TRUE;
|
|
break;
|
|
}
|
|
|
|
// now query for the value
|
|
lResult = RegQueryValueEx( hSourcesKey, _T( "CustomSource" ), NULL, NULL, NULL, NULL );
|
|
if ( lResult != ERROR_SUCCESS && lResult != ERROR_FILE_NOT_FOUND )
|
|
{
|
|
RegCloseKey( hSourcesKey );
|
|
SetLastError( lResult );
|
|
SaveLastError();
|
|
bErrorOccurred = TRUE;
|
|
break;
|
|
}
|
|
|
|
// close the souces key
|
|
RegCloseKey( hSourcesKey );
|
|
|
|
// mark this as custom source
|
|
if ( pbCustom != NULL && lResult == ERROR_SUCCESS )
|
|
*pbCustom = TRUE;
|
|
|
|
// break from the loop
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// this should not be the case .. sources should not be duplicated
|
|
FORMAT_STRING( szBuffer, ERROR_SOURCE_DUPLICATING, szRLog );
|
|
SetReason( szBuffer );
|
|
bDuplicating = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else if ( bLogMatched == TRUE && bSource == FALSE )
|
|
{
|
|
// mark this as a custom event source
|
|
if ( pbCustom != NULL )
|
|
*pbCustom = TRUE;
|
|
|
|
// ...
|
|
bFoundMatch = TRUE;
|
|
break;
|
|
}
|
|
else if ( bLogMatched == TRUE && bDuplicating == TRUE )
|
|
{
|
|
bErrorOccurred = TRUE;
|
|
break;
|
|
}
|
|
|
|
// update the sources index and fetch the next log key
|
|
dwLogsIndex += 1;
|
|
dwSize = MAX_KEY_LENGTH; // max. size of the key buffer
|
|
ZeroMemory( szRLog, MAX_KEY_LENGTH * sizeof( TCHAR ) );
|
|
lResult = RegEnumKeyEx( hLogsKey, dwLogsIndex, szRLog, &dwSize, NULL,
|
|
NULL, NULL, &ftLastWriteTime );
|
|
} while( lResult != ERROR_NO_MORE_ITEMS );
|
|
|
|
// close the logs registry key
|
|
RegCloseKey( hLogsKey );
|
|
hLogsKey = NULL;
|
|
|
|
// check whether any error has occured or not in doing above tasks
|
|
if ( bErrorOccurred )
|
|
{
|
|
// close the still opened registry keys
|
|
RegCloseKey( hKey );
|
|
|
|
// return failure
|
|
return FALSE;
|
|
}
|
|
|
|
// now check whether location for creating the event is found or not
|
|
// if not, check for the possibilities to create the source at appropriate location
|
|
// NOTE:-
|
|
// we won't create the logs. also to create the source, user needs to specify
|
|
// the log name in which this source needs to be created.
|
|
if ( bFoundMatch == FALSE )
|
|
{
|
|
if ( bLog == TRUE && bLogMatched == FALSE )
|
|
{
|
|
// log itself was not found ... error message
|
|
FORMAT_STRING( szBuffer, ERROR_LOG_NOTEXISTS, szLog );
|
|
SetReason( szBuffer );
|
|
}
|
|
else if ( bLog && bSource && bLogMatched && bSourceMatched == FALSE )
|
|
{
|
|
//
|
|
// log name and source both were supplied but only log was found
|
|
// so create the source in it
|
|
|
|
// open the "EventLogs\{logname}" registry key for creating new source
|
|
FORMAT_STRING2( szBuffer, _T( "%s\\%s" ), EVENT_LOG_NAMES_LOCATION, szLog );
|
|
lResult = RegOpenKeyEx( hKey, szBuffer, 0, KEY_WRITE, &hLogsKey );
|
|
if ( lResult != ERROR_SUCCESS )
|
|
{
|
|
switch( lResult )
|
|
{
|
|
case ERROR_FILE_NOT_FOUND:
|
|
SetLastError( ERROR_REGISTRY_CORRUPT );
|
|
break;
|
|
|
|
default:
|
|
// save the error information and return FAILURE
|
|
SetLastError( lResult );
|
|
break;
|
|
}
|
|
|
|
// close the key and return
|
|
SaveLastError();
|
|
RegCloseKey( hKey );
|
|
return FALSE;
|
|
}
|
|
|
|
// now create the subkey with the source name given
|
|
if ( AddEventSource( hLogsKey, szSource ) == FALSE )
|
|
{
|
|
RegCloseKey( hKey );
|
|
RegCloseKey( hLogsKey );
|
|
return FALSE;
|
|
}
|
|
|
|
// creation of new source is successfull
|
|
bFoundMatch = TRUE;
|
|
RegCloseKey( hSourcesKey );
|
|
RegCloseKey( hLogsKey );
|
|
|
|
// mark this as a custom event source
|
|
if ( pbCustom != NULL )
|
|
*pbCustom = TRUE;
|
|
}
|
|
else if ( bLog == FALSE && bSource == TRUE && bSourceMatched == FALSE )
|
|
{
|
|
// else we need both log name and source in order to create the source
|
|
SetReason( ERROR_NEED_LOG_ALSO );
|
|
}
|
|
}
|
|
|
|
// close the currently open registry keys
|
|
RegCloseKey( hKey );
|
|
|
|
// return the result
|
|
return bFoundMatch;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This function adds a new source to under the specifie log
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Return Value:
|
|
// TRUE : on success
|
|
// FALSE : on failure
|
|
// ***************************************************************************
|
|
BOOL AddEventSource( HKEY hLogsKey, LPCTSTR pszSource )
|
|
{
|
|
// local variables
|
|
HKEY hSourcesKey;
|
|
LONG lResult = 0;
|
|
DWORD dwData = 0;
|
|
DWORD dwLength = 0;
|
|
DWORD dwDisposition = 0;
|
|
LPTSTR pszBuffer = NULL;
|
|
|
|
// validate the inputs
|
|
if ( hLogsKey == NULL || pszSource == NULL )
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
// create the custom source
|
|
lResult = RegCreateKeyEx( hLogsKey, pszSource, 0, _T( "" ),
|
|
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hSourcesKey, &dwDisposition );
|
|
if ( lResult != ERROR_SUCCESS )
|
|
{
|
|
SetLastError( lResult );
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
// set the name of the message file.
|
|
dwLength = lstrlen( _T( "%SystemRoot%\\System32\\EventCreate.exe" ) );
|
|
pszBuffer = calloc( dwLength + 1, sizeof( TCHAR ) );
|
|
if ( pszBuffer == NULL )
|
|
{
|
|
// set the error
|
|
SetLastError( E_OUTOFMEMORY );
|
|
SaveLastError();
|
|
|
|
// close the created registry key
|
|
RegCloseKey( hSourcesKey );
|
|
hSourcesKey = NULL;
|
|
|
|
// return
|
|
return FALSE;
|
|
}
|
|
|
|
// copy the required value into buffer
|
|
lstrcpy( pszBuffer, _T( "%SystemRoot%\\System32\\EventCreate.exe" ) );
|
|
|
|
// add the name to the EventMessageFile subkey.
|
|
lResult = RegSetValueEx( hSourcesKey,
|
|
_T( "EventMessageFile" ), 0, REG_EXPAND_SZ, (LPBYTE) pszBuffer, (dwLength + 1) * sizeof( TCHAR ) );
|
|
if ( lResult != ERROR_SUCCESS )
|
|
{
|
|
// save the error
|
|
SetLastError( lResult );
|
|
SaveLastError();
|
|
|
|
// release the memories allocated till this point
|
|
RegCloseKey( hSourcesKey );
|
|
hSourcesKey = NULL;
|
|
|
|
// free the allocated memory
|
|
if ( pszBuffer != NULL )
|
|
{
|
|
free( pszBuffer );
|
|
pszBuffer = NULL;
|
|
}
|
|
|
|
// return
|
|
return FALSE;
|
|
}
|
|
|
|
// set the supported event types in the TypesSupported subkey.
|
|
dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;
|
|
lResult = RegSetValueEx( hSourcesKey, _T( "TypesSupported" ), 0, REG_DWORD, (LPBYTE) &dwData, sizeof( DWORD ) );
|
|
if ( lResult != ERROR_SUCCESS )
|
|
{
|
|
// save the error
|
|
SetLastError( lResult );
|
|
SaveLastError();
|
|
|
|
// release the memories allocated till this point
|
|
RegCloseKey( hSourcesKey );
|
|
hSourcesKey = NULL;
|
|
|
|
// free the allocated memory
|
|
if ( pszBuffer != NULL )
|
|
{
|
|
free( pszBuffer );
|
|
pszBuffer = NULL;
|
|
}
|
|
|
|
// return
|
|
return FALSE;
|
|
}
|
|
|
|
// mark this source as custom created source
|
|
dwData = 1;
|
|
lResult = RegSetValueEx( hSourcesKey, _T( "CustomSource" ), 0, REG_DWORD, (LPBYTE) &dwData, sizeof( DWORD ) );
|
|
if ( lResult != ERROR_SUCCESS )
|
|
{
|
|
// save the error
|
|
SetLastError( lResult );
|
|
SaveLastError();
|
|
|
|
// release the memories allocated till this point
|
|
RegCloseKey( hSourcesKey );
|
|
hSourcesKey = NULL;
|
|
|
|
// free the allocated memory
|
|
if ( pszBuffer != NULL )
|
|
{
|
|
free( pszBuffer );
|
|
pszBuffer = NULL;
|
|
}
|
|
|
|
// return
|
|
return FALSE;
|
|
}
|
|
|
|
// close the key
|
|
RegCloseKey( hSourcesKey );
|
|
|
|
// free the allocated memory
|
|
if ( pszBuffer != NULL )
|
|
{
|
|
free( pszBuffer );
|
|
pszBuffer = NULL;
|
|
}
|
|
|
|
// return success
|
|
return TRUE;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This function parses the options specified at the command prompt
|
|
//
|
|
// Arguments:
|
|
// [ in ] argc : count of elements in argv
|
|
// [ in ] argv : command-line parameterd specified by the user
|
|
// [ out ] pbShowUsage : sets to TRUE if -? exists in 'argv'
|
|
// [ out ] parrServers : value(s) specified with -s ( server ) option in 'argv'
|
|
// [ out ] pszUserName : value of -u ( username ) option in 'argv'
|
|
// [ out ] pszPassword : value of -p ( password ) option in 'argv'
|
|
// [ out ] pszLogName : value of -log ( log name ) option in 'argv'
|
|
// [ out ] pszLogSource : value of -source ( source name ) option in 'argv'
|
|
// [ out ] pszLogType : value of -type ( log type ) option in 'argv'
|
|
// [ out ] pdwEventID : value of -id ( event id ) option in 'argv'
|
|
// [ out ] pszDescription : value of -description ( description ) option in 'argv'
|
|
// [ out ] pbNeedPwd : sets to TRUE if -s exists without -p in 'argv'
|
|
//
|
|
// Return Value:
|
|
// TRUE : the parsing is successful
|
|
// FALSE : errors occured in parsing
|
|
// ***************************************************************************
|
|
BOOL ProcessOptions( LONG argc,
|
|
LPCTSTR argv[],
|
|
PBOOL pbShowUsage,
|
|
PTARRAY parrServers, LPTSTR pszUserName, LPTSTR pszPassword,
|
|
LPTSTR pszLogName, LPTSTR pszLogSource, LPTSTR pszLogType,
|
|
PDWORD pdwEventID, LPTSTR pszDescription, PBOOL pbNeedPwd )
|
|
{
|
|
// local variables
|
|
LPTSTR pszDup = NULL;
|
|
LPCTSTR pszServer = NULL;
|
|
PTCMDPARSER pcmdOption = NULL;
|
|
TCMDPARSER cmdOptions[ MAX_OPTIONS ];
|
|
|
|
//
|
|
// prepare the command options
|
|
ZeroMemory( cmdOptions, sizeof( TCMDPARSER ) * MAX_OPTIONS );
|
|
|
|
// init the password with "*"
|
|
if ( pszPassword != NULL )
|
|
{
|
|
lstrcpy( pszPassword, _T( "*" ) );
|
|
}
|
|
|
|
// -?
|
|
pcmdOption = &cmdOptions[ OI_HELP ];
|
|
pcmdOption->dwCount = 1;
|
|
pcmdOption->dwActuals = 0;
|
|
pcmdOption->dwFlags = CP_USAGE;
|
|
pcmdOption->pValue = pbShowUsage;
|
|
pcmdOption->pFunction = NULL;
|
|
pcmdOption->pFunctionData = NULL;
|
|
lstrcpy( pcmdOption->szValues, NULL_STRING );
|
|
lstrcpy( pcmdOption->szOption, OPTION_HELP );
|
|
|
|
// -s
|
|
pcmdOption = &cmdOptions[ OI_SERVER ];
|
|
pcmdOption->dwCount = 1;
|
|
pcmdOption->dwActuals = 0;
|
|
pcmdOption->dwFlags =
|
|
CP_TYPE_TEXT | CP_VALUE_NODUPLICATES | CP_MODE_ARRAY | CP_VALUE_MANDATORY;
|
|
pcmdOption->pValue = parrServers;
|
|
pcmdOption->pFunction = NULL;
|
|
pcmdOption->pFunctionData = NULL;
|
|
lstrcpy( pcmdOption->szValues, NULL_STRING );
|
|
lstrcpy( pcmdOption->szOption, OPTION_SERVER );
|
|
|
|
// -u
|
|
pcmdOption = &cmdOptions[ OI_USERNAME ];
|
|
pcmdOption->dwCount = 1;
|
|
pcmdOption->dwActuals = 0;
|
|
pcmdOption->dwFlags = CP_TYPE_TEXT | CP_VALUE_MANDATORY;
|
|
pcmdOption->pValue = pszUserName;
|
|
pcmdOption->pFunction = NULL;
|
|
pcmdOption->pFunctionData = NULL;
|
|
lstrcpy( pcmdOption->szValues, NULL_STRING );
|
|
lstrcpy( pcmdOption->szOption, OPTION_USERNAME );
|
|
|
|
// -p
|
|
pcmdOption = &cmdOptions[ OI_PASSWORD ];
|
|
pcmdOption->dwCount = 1;
|
|
pcmdOption->dwActuals = 0;
|
|
pcmdOption->dwFlags = CP_TYPE_TEXT | CP_VALUE_OPTIONAL;
|
|
pcmdOption->pValue = pszPassword;
|
|
pcmdOption->pFunction = NULL;
|
|
pcmdOption->pFunctionData = NULL;
|
|
lstrcpy( pcmdOption->szValues, NULL_STRING );
|
|
lstrcpy( pcmdOption->szOption, OPTION_PASSWORD );
|
|
|
|
// -log
|
|
pcmdOption = &cmdOptions[ OI_LOG ];
|
|
pcmdOption->dwCount = 1;
|
|
pcmdOption->dwActuals = 0;
|
|
pcmdOption->dwFlags = CP_TYPE_TEXT | CP_VALUE_MANDATORY;
|
|
pcmdOption->pValue = pszLogName;
|
|
pcmdOption->pFunction = NULL;
|
|
pcmdOption->pFunctionData = NULL;
|
|
lstrcpy( pcmdOption->szValues, NULL_STRING );
|
|
lstrcpy( pcmdOption->szOption, OPTION_LOG );
|
|
|
|
// -type
|
|
pcmdOption = &cmdOptions[ OI_TYPE ];
|
|
pcmdOption->dwCount = 1;
|
|
pcmdOption->dwActuals = 0;
|
|
pcmdOption->dwFlags = CP_TYPE_TEXT | CP_VALUE_MANDATORY | CP_MODE_VALUES | CP_MANDATORY;
|
|
pcmdOption->pValue = pszLogType;
|
|
pcmdOption->pFunction = NULL;
|
|
pcmdOption->pFunctionData = NULL;
|
|
lstrcpy( pcmdOption->szValues, OVALUES_TYPE );
|
|
lstrcpy( pcmdOption->szOption, OPTION_TYPE );
|
|
|
|
// -source
|
|
pcmdOption = &cmdOptions[ OI_SOURCE ];
|
|
pcmdOption->dwCount = 1;
|
|
pcmdOption->dwActuals = 0;
|
|
pcmdOption->dwFlags = CP_TYPE_TEXT | CP_VALUE_MANDATORY;
|
|
pcmdOption->pValue = pszLogSource;
|
|
pcmdOption->pFunction = NULL;
|
|
pcmdOption->pFunctionData = NULL;
|
|
lstrcpy( pcmdOption->szValues, NULL_STRING );
|
|
lstrcpy( pcmdOption->szOption, OPTION_SOURCE );
|
|
|
|
// -id
|
|
pcmdOption = &cmdOptions[ OI_ID ];
|
|
pcmdOption->dwCount = 1;
|
|
pcmdOption->dwActuals = 0;
|
|
pcmdOption->dwFlags = CP_TYPE_UNUMERIC | CP_VALUE_MANDATORY | CP_MANDATORY;
|
|
pcmdOption->pValue = pdwEventID;
|
|
pcmdOption->pFunction = NULL;
|
|
pcmdOption->pFunctionData = NULL;
|
|
lstrcpy( pcmdOption->szValues, NULL_STRING );
|
|
lstrcpy( pcmdOption->szOption, OPTION_ID );
|
|
|
|
// -description
|
|
pcmdOption = &cmdOptions[ OI_DESCRIPTION ];
|
|
pcmdOption->dwCount = 1;
|
|
pcmdOption->dwActuals = 0;
|
|
pcmdOption->dwFlags = CP_TYPE_TEXT | CP_VALUE_MANDATORY | CP_MANDATORY;
|
|
pcmdOption->pValue = pszDescription;
|
|
pcmdOption->pFunction = NULL;
|
|
pcmdOption->pFunctionData = NULL;
|
|
lstrcpy( pcmdOption->szValues, NULL_STRING );
|
|
lstrcpy( pcmdOption->szOption, OPTION_DESCRIPTION );
|
|
|
|
//
|
|
// do the parsing
|
|
if ( DoParseParam( argc, argv, MAX_OPTIONS, cmdOptions ) == FALSE )
|
|
return FALSE; // invalid syntax
|
|
|
|
//
|
|
// now, check the mutually exclusive options
|
|
|
|
// check the usage option
|
|
if ( *pbShowUsage == TRUE )
|
|
{
|
|
if ( argc > 2 )
|
|
{
|
|
// no other options are accepted along with -? option
|
|
SetLastError( MK_E_SYNTAX );
|
|
SetReason( ERROR_INVALID_USAGE_REQUEST );
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
// no need of furthur checking of the values
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
// empty system is not valid
|
|
if ( cmdOptions[ OI_SERVER ].dwActuals != 0 )
|
|
{
|
|
// get the server name
|
|
pszServer = DynArrayItemAsString( *parrServers, 0 );
|
|
if ( pszServer != NULL )
|
|
{
|
|
// get the duplicate of this server name
|
|
// we need to trim the value and then check
|
|
pszDup = _tcsdup( pszServer );
|
|
if ( pszDup == NULL )
|
|
{
|
|
SetLastError( E_OUTOFMEMORY );
|
|
SaveLastError();
|
|
return FALSE;
|
|
}
|
|
|
|
// trim the string value
|
|
TrimString( pszDup, TRIM_ALL );
|
|
|
|
// check the length now
|
|
if ( lstrlen( pszDup ) == 0 )
|
|
{
|
|
// release the memory and return error
|
|
free( pszDup );
|
|
pszDup = NULL;
|
|
SetLastError( MK_E_SYNTAX );
|
|
SetReason( ERROR_SYSTEM_EMPTY );
|
|
return FALSE;
|
|
}
|
|
|
|
// release memory
|
|
free( pszDup );
|
|
pszDup = NULL;
|
|
}
|
|
}
|
|
|
|
// "-u" should not be specified without "-s"
|
|
if ( cmdOptions[ OI_SERVER ].dwActuals == 0 &&
|
|
cmdOptions[ OI_USERNAME ].dwActuals != 0 )
|
|
{
|
|
// invalid syntax
|
|
SetReason( ERROR_USERNAME_BUT_NOMACHINE );
|
|
return FALSE; // indicate failure
|
|
}
|
|
|
|
// empty user is not valid
|
|
TrimString( pszUserName, TRIM_ALL ); // trim the string
|
|
if ( cmdOptions[ OI_USERNAME ].dwActuals != 0 && lstrlen( pszUserName ) == 0 )
|
|
{
|
|
// invalid syntax
|
|
SetReason( ERROR_USERNAME_EMPTY );
|
|
return FALSE;
|
|
}
|
|
|
|
// "-p" should not be specified without "-u"
|
|
if ( cmdOptions[ OI_USERNAME ].dwActuals == 0 &&
|
|
cmdOptions[ OI_PASSWORD ].dwActuals != 0 )
|
|
{
|
|
// invalid syntax
|
|
SetReason( ERROR_PASSWORD_BUT_NOUSERNAME );
|
|
return FALSE; // indicate failure
|
|
}
|
|
|
|
// check whether caller should accept the password or not
|
|
// if -s ( server ) or -u ( username ) is specified
|
|
// but no "-p", then utility should accept password
|
|
// provided if establish connection is failed without the credentials information
|
|
if ( cmdOptions[ OI_PASSWORD ].dwActuals != 0 &&
|
|
pszPassword != NULL && lstrcmp( pszPassword, _T( "*" ) ) == 0 )
|
|
{
|
|
// user wants the utility to prompt for the password before trying to connect
|
|
*pbNeedPwd = TRUE;
|
|
}
|
|
else if ( cmdOptions[ OI_PASSWORD ].dwActuals == 0 &&
|
|
( cmdOptions[ OI_SERVER ].dwActuals != 0 || cmdOptions[ OI_USERNAME ].dwActuals != 0 ) )
|
|
{
|
|
// -s, -u is specified without password ...
|
|
// utility needs to try to connect first and if it fails then prompt for the password
|
|
*pbNeedPwd = TRUE;
|
|
if ( pszPassword != NULL )
|
|
{
|
|
lstrcpy( pszPassword, _T( "" ) );
|
|
}
|
|
}
|
|
|
|
// event id should be greater than 0 ( zero ) and less than 65536
|
|
if ( *pdwEventID <= 0 || *pdwEventID >= 65536 )
|
|
{
|
|
// invalid numeric value
|
|
SetReason( ERROR_INVALID_EVENT_ID );
|
|
return FALSE;
|
|
}
|
|
|
|
// description should not be empty
|
|
TrimString( pszDescription, TRIM_ALL ); // trim the string
|
|
if ( lstrlen( pszDescription ) == 0 )
|
|
{
|
|
// description is null
|
|
SetReason( ERROR_DESCRIPTION_IS_EMPTY );
|
|
return FALSE;
|
|
}
|
|
|
|
// either -source (or) -log must be specified ( both can also be specified )
|
|
if ( cmdOptions[ OI_SOURCE ].dwActuals == 0 && cmdOptions[ OI_LOG ].dwActuals == 0 )
|
|
{
|
|
// if log name and application were not specified, we will set to defaults
|
|
lstrcpy( pszLogName, g_szDefaultLog );
|
|
lstrcpy( pszLogSource, g_szDefaultSource );
|
|
}
|
|
|
|
// -source option value should not be empty ( if specified )
|
|
TrimString( pszLogSource, TRIM_ALL ); // trim the string
|
|
if ( cmdOptions[ OI_SOURCE ].dwActuals != 0 && lstrlen( pszLogSource ) == 0 )
|
|
{
|
|
// description is null
|
|
SetReason( ERROR_LOGSOURCE_IS_EMPTY );
|
|
return FALSE;
|
|
}
|
|
|
|
// -log option value should not be empty ( if specified )
|
|
TrimString( pszLogName, TRIM_ALL ); // trim the string
|
|
if ( cmdOptions[ OI_LOG ].dwActuals != 0 && lstrlen( pszLogName ) == 0 )
|
|
{
|
|
// description is null
|
|
SetReason( ERROR_LOGSOURCE_IS_EMPTY );
|
|
return FALSE;
|
|
}
|
|
|
|
// check whether atleast one -s is specified or not ... if not, add 'null string' to
|
|
// the servers array so that default it will work for local system
|
|
if ( cmdOptions[ OI_SERVER ].dwActuals == 0 )
|
|
DynArrayAppendString( *parrServers, NULL_STRING, 0 );
|
|
|
|
// command-line parsing is successfull
|
|
return TRUE;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
// Routine Description:
|
|
// This function fetches usage information from resource file and shows it
|
|
//
|
|
// Arguments:
|
|
// None
|
|
//
|
|
// Return Value:
|
|
// None
|
|
// ***************************************************************************
|
|
VOID Usage()
|
|
{
|
|
// local variables
|
|
DWORD dw = 0;
|
|
|
|
// start displaying the usage
|
|
for( dw = ID_USAGE_START; dw <= ID_USAGE_END; dw++ )
|
|
ShowMessage( stdout, GetResString( dw ) );
|
|
}
|