able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/rras/netsh/shell/utils.c

2804 lines
65 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1998 Microsoft Corporation
Module Name:
routing\netsh\shell\utils.c
Abstract:
Utilities.
Revision History:
6/12/96 V Raman
--*/
#include "precomp.h"
#include <wincon.h>
#include <winbase.h>
#define STOP_EVENT L"NetshStopRefreshEvent"
extern HANDLE g_hModule;
BOOL
WINAPI
MatchCmdLine(
IN LPWSTR *ppwcArguments,
IN DWORD dwArgCount,
IN LPCWSTR pwszCmdToken,
OUT PDWORD pdwNumMatched
)
{
LPCWSTR pwcToken;
DWORD dwCount;
WCHAR wcszBuffer[256];
//
// Compare the two strings
//
dwCount = 0;
if (!ppwcArguments || !pwszCmdToken || !pdwNumMatched)
{
return FALSE;
}
*pdwNumMatched = 0; // init OUT parameter
if ( (wcslen(pwszCmdToken) + 1) > (sizeof(wcszBuffer)/sizeof(wcszBuffer[0])) )
{
// incoming command string is too large for processing
return FALSE;
}
// copy into a buffer which wcstok can munge
wcscpy(wcszBuffer, pwszCmdToken);
if((pwcToken = wcstok(wcszBuffer,
NETSH_CMD_DELIMITER)) != NULL)
{
do
{
if (dwCount < dwArgCount &&
(_wcsnicmp(ppwcArguments[dwCount],
pwcToken,
wcslen(ppwcArguments[dwCount])) == 0))
{
dwCount++;
}
else
{
return FALSE;
}
} while((pwcToken = wcstok((LPWSTR) NULL, NETSH_CMD_DELIMITER )) != NULL);
}
*pdwNumMatched = dwCount;
return TRUE;
}
#if 0
BOOL
WINAPI
MatchCmdTokenId(
IN HANDLE hModule,
IN LPCWSTR *ppwcArguments,
IN DWORD dwArgCount,
IN DWORD dwCmdId,
OUT PDWORD pdwNumMatched
)
/*++
Routine Description:
Tries to match a command in the given command line.
The function takes the id of the command of the command message.
A command message consists of command words separated by white space.
The function tokenises this messages into separate words and then
tries to match the first N arguments against the N separate tokens that
constitute the command.
e.g if the command is "add if neighbour" - the function will generate
3 tokens "add" "if" and "neighbour". It will then try and match the
all these to the given arg array.
Arguments:
ppwcArguments - Argument array
dwArgCount - Number of arguments
dwTokenId - Token Id of command
pdwNumMatched - Number of arguments matched in the array
Return Value:
TRUE if matched else FALSE
--*/
{
WCHAR pwszTemp[NETSH_MAX_CMD_TOKEN_LENGTH];
LPCWSTR pwcToken;
DWORD dwCount;
if(!LoadStringW(hModule,
dwCmdId,
pwszTemp,
NETSH_MAX_CMD_TOKEN_LENGTH) )
{
return FALSE;
}
//
// Compare the two strings
//
dwCount = 0;
if((pwcToken = wcstok(pwszTemp,
NETSH_CMD_DELIMITER)) != NULL)
{
do
{
if (dwCount < dwArgCount &&
(_wcsnicmp(ppwcArguments[dwCount],
pwcToken,
wcslen(ppwcArguments[dwCount])) == 0))
{
dwCount++;
}
else
{
*pdwNumMatched = 0;
return FALSE;
}
} while((pwcToken = wcstok((LPCWSTR) NULL, NETSH_CMD_DELIMITER )) != NULL);
}
*pdwNumMatched = dwCount;
return TRUE;
}
#endif
DWORD
WINAPI
MatchEnumTag(
IN HANDLE hModule,
IN LPCWSTR pwcArg,
IN DWORD dwNumArg,
IN CONST TOKEN_VALUE *pEnumTable,
OUT PDWORD pdwValue
)
/*++
Routine Description:
Used for options that take a specific set of values. Matches argument
with the set of values specified and returns corresponding value.
Arguments:
pwcArg - Argument
dwNumArg - Number of possible values.
Return Value:
NO_ERROR
ERROR_NOT_FOUND
--*/
{
DWORD i;
if ( (!pdwValue) || (!pEnumTable) )
{
return ERROR_INVALID_PARAMETER;
}
for (i = 0; i < dwNumArg; i++)
{
if (MatchToken(pwcArg,
pEnumTable[i].pwszToken))
{
*pdwValue = pEnumTable[i].dwValue;
return NO_ERROR;
}
}
return ERROR_NOT_FOUND;
}
DWORD
MatchTagsInCmdLine(
IN HANDLE hModule,
IN OUT LPWSTR *ppwcArguments,
IN DWORD dwCurrentIndex,
IN DWORD dwArgCount,
IN OUT PTAG_TYPE pttTagToken,
IN DWORD dwNumTags,
OUT PDWORD pdwOut
)
/*++
Routine Description:
Identifies each argument based on its tag.
It also removes tag= from each argument.
It also sets the bPresent flag in the tags present.
Arguments:
ppwcArguments - The argument array. Each argument has tag=value form
dwCurrentIndex - ppwcArguments[dwCurrentIndex] is first arg.
dwArgCount - ppwcArguments[dwArgCount - 1] is last arg.
pttTagToken - Array of tag token ids that are allowed in the args
dwNumTags - Size of pttTagToken
pdwOut - Array identifying the type of each argument, where
pdwOut[0] is for ppwcArguments[dwCurrentIndex]
Return Value:
NO_ERROR, ERROR_INVALID_PARAMETER, ERROR_INVALID_OPTION_TAG
--*/
{
DWORD i,j,len;
LPCWSTR pwcTag;
LPWSTR pwcTagVal, pwszArg;
BOOL bFound = FALSE;
//
// This function assumes that every argument has a tag
// It goes ahead and removes the tag.
//
for (i = dwCurrentIndex; i < dwArgCount; i++)
{
if (!wcspbrk(ppwcArguments[i], NETSH_ARG_DELIMITER))
{
pdwOut[i - dwCurrentIndex] = (DWORD) -2;
continue;
}
len = wcslen(ppwcArguments[i]);
if (len is 0)
{
//
// something wrong with arg
//
pdwOut[i - dwCurrentIndex] = (DWORD) -1;
continue;
}
pwszArg = HeapAlloc(GetProcessHeap(),0,(len + 1) * sizeof(WCHAR));
if (pwszArg is NULL)
{
PrintMessageFromModule(g_hModule, MSG_NOT_ENOUGH_MEMORY);
return ERROR_NOT_ENOUGH_MEMORY;
}
wcscpy(pwszArg, ppwcArguments[i]);
pwcTag = wcstok(pwszArg, NETSH_ARG_DELIMITER);
//
// Got the first part
// Now if next call returns NULL then there was no tag
//
pwcTagVal = wcstok((LPWSTR)NULL, NETSH_ARG_DELIMITER);
if (pwcTagVal is NULL)
{
PrintMessageFromModule(g_hModule, ERROR_NO_TAG, ppwcArguments[i]);
HeapFree(GetProcessHeap(),0,pwszArg);
return ERROR_INVALID_PARAMETER;
}
//
// Got the tag. Now try to match it
//
bFound = FALSE;
pdwOut[i - dwCurrentIndex] = (DWORD) -1;
for ( j = 0; j < dwNumTags; j++)
{
if (MatchToken(pwcTag, pttTagToken[j].pwszTag))
{
//
// Tag matched
//
if (pttTagToken[j].bPresent
&& !(pttTagToken[j].dwRequired & NS_REQ_ALLOW_MULTIPLE))
{
HeapFree(GetProcessHeap(),0,pwszArg);
PrintMessageFromModule(g_hModule, ERROR_TAG_ALREADY_PRESENT, pwcTag);
return ERROR_TAG_ALREADY_PRESENT;
}
bFound = TRUE;
pdwOut[i - dwCurrentIndex] = j;
pttTagToken[j].bPresent = TRUE;
break;
}
}
if (bFound)
{
//
// Remove tag from the argument
//
wcscpy(ppwcArguments[i], pwcTagVal);
}
else
{
PrintMessageFromModule(g_hModule, ERROR_INVALID_OPTION_TAG, pwcTag);
HeapFree(GetProcessHeap(),0,pwszArg);
return ERROR_INVALID_OPTION_TAG;
}
HeapFree(GetProcessHeap(),0,pwszArg);
}
// Now tag all untagged arguments
for (i = dwCurrentIndex; i < dwArgCount; i++)
{
if ( pdwOut[i - dwCurrentIndex] != -2)
{
continue;
}
bFound = FALSE;
for ( j = 0; j < dwNumTags; j++)
{
if (!pttTagToken[j].bPresent)
{
bFound = TRUE;
pdwOut[i - dwCurrentIndex] = j;
pttTagToken[j].bPresent = TRUE;
break;
}
}
if (!bFound)
{
pdwOut[i - dwCurrentIndex] = (DWORD) -1;
}
}
return NO_ERROR;
}
BOOL
WINAPI
MatchToken(
IN LPCWSTR pwszUserToken,
IN LPCWSTR pwszCmdToken
)
{
if ( (!pwszUserToken) || (!pwszCmdToken) )
{
return ERROR_INVALID_PARAMETER;
}
return !_wcsnicmp(pwszUserToken,
pwszCmdToken,
wcslen(pwszUserToken));
}
BOOL
WINAPI
MatchTokenId( // changed this name since I don't think anything will use it
IN HANDLE hModule,
IN LPCWSTR pwszToken,
IN DWORD dwTokenId
)
/*++
Routine Description:
Sees if the given string and the string corresponding to dwTokenId
are the same.
Arguments:
pwszToken - Token string
dwTokenId - Token Id
Return Value:
TRUE is matched else FALSE
--*/
{
WCHAR pwszTemp[NETSH_MAX_TOKEN_LENGTH];
if(!LoadStringW(hModule,
dwTokenId,
pwszTemp,
NETSH_MAX_TOKEN_LENGTH))
{
return FALSE;
}
return MatchToken(pwszToken, pwszTemp);
}
extern HANDLE g_hLogFile;
LPWSTR
OEMfgets(
OUT PDWORD pdwLen,
IN FILE *fp
)
{
LPWSTR pwszUnicode;
DWORD dwErr = NO_ERROR;
DWORD dwLen;
CHAR buff[MAX_CMD_LEN];
fflush(stdout);
if (fgets( buff, sizeof(buff), fp ) is NULL)
{
return NULL;
}
dwLen = MultiByteToWideChar( GetConsoleOutputCP(),
0,
buff,
-1,
NULL,
0 );
if (g_hLogFile)
{
DWORD dwWritten;
CHAR szCrLf[] = "\r\n";
if (0 == WriteFile( g_hLogFile, buff, dwLen-2, &dwWritten, NULL ))
{
CloseHandle(g_hLogFile);
g_hLogFile = NULL;
PrintError(NULL, GetLastError());
}
if (0 == WriteFile( g_hLogFile, szCrLf, 2, &dwWritten, NULL ))
{
CloseHandle(g_hLogFile);
g_hLogFile = NULL;
PrintError(NULL, GetLastError());
}
}
pwszUnicode = MALLOC(dwLen * sizeof(WCHAR));
if (pwszUnicode)
{
MultiByteToWideChar( GetConsoleOutputCP(),
0,
buff,
sizeof(buff),
pwszUnicode,
dwLen );
}
*pdwLen = dwLen;
return pwszUnicode;
}
VOID
OEMfprintf(
IN HANDLE hHandle,
IN LPCWSTR pwszUnicode
)
{
PCHAR achOem;
DWORD dwLen, dwWritten;
dwLen = WideCharToMultiByte( GetConsoleOutputCP(),
0,
pwszUnicode,
-1,
NULL,
0,
NULL,
NULL );
achOem = MALLOC(dwLen);
if (achOem)
{
WideCharToMultiByte( GetConsoleOutputCP(),
0,
pwszUnicode,
-1,
achOem,
dwLen,
NULL,
NULL );
WriteFile( hHandle, achOem, dwLen-1, &dwWritten, NULL );
if (g_hLogFile)
{
if (0 == WriteFile( g_hLogFile, achOem, dwLen-1, &dwWritten, NULL ))
{
CloseHandle(g_hLogFile);
g_hLogFile = NULL;
PrintError(NULL, GetLastError());
}
}
FREE(achOem);
}
}
#define OEMprintf(pwszUnicode) \
OEMfprintf( GetStdHandle(STD_OUTPUT_HANDLE), pwszUnicode)
LPWSTR
WINAPI
GetEnumString(
IN HANDLE hModule,
IN DWORD dwValue,
IN DWORD dwNumVal,
IN PTOKEN_VALUE pEnumTable
)
/*++
Routine Description:
This routine looks up the value specified, dwValue, in the Value table
pEnumTable and returns the string corresponding to the value
Arguments :
hModule - handle to current module
dwValue - Value whose display string is required
dwNumVal - Number of elements in pEnumTable
pEnumTable - Table of enumerated value and corresp. string IDs
Return Value :
NULL - Value not found in pEnumTable
Pointer to string on success
--*/
{
DWORD dwInd;
for ( dwInd = 0; dwInd < dwNumVal; dwInd++ )
{
if ( pEnumTable[ dwInd ].dwValue == dwValue )
{
// ISSUE: const_cast
return (LPWSTR)pEnumTable[ dwInd ].pwszToken;
}
}
return NULL;
}
LPWSTR
WINAPI
MakeString(
IN HANDLE hModule,
IN DWORD dwMsgId,
...
)
{
DWORD dwMsgLen;
LPWSTR pwszInput, pwszOutput = NULL;
va_list arglist;
do
{
va_start( arglist, dwMsgId );
pwszInput = HeapAlloc(GetProcessHeap(),
0,
MAX_MSG_LENGTH * sizeof(WCHAR) );
if ( pwszInput == NULL )
{
break;
}
if ( !LoadStringW(hModule,
dwMsgId,
pwszInput,
MAX_MSG_LENGTH) )
{
break;
}
FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
pwszInput,
0,
0L, // Default country ID.
(LPWSTR)&pwszOutput,
0,
&arglist);
} while ( FALSE );
if ( pwszInput ) { HeapFree( GetProcessHeap(), 0, pwszInput ); }
return pwszOutput;
}
VOID
WINAPI
FreeString(
IN LPWSTR pwszMadeString
)
/*++
Routine Description:
Frees string allocated by make string.
Arguments:
Return Value:
--*/
{
LocalFree( pwszMadeString );
}
LPWSTR
WINAPI
MakeQuotedString(
IN LPCWSTR pwszOrigString
)
{
LPWSTR pwszNewString;
pwszNewString = HeapAlloc(GetProcessHeap(),
0,
(wcslen(pwszOrigString) + 3) * sizeof(WCHAR));
if(pwszNewString == NULL)
{
return NULL;
}
wsprintfW(pwszNewString, L"\"%s\"",pwszOrigString);
pwszNewString[wcslen(pwszOrigString) + 2] = UNICODE_NULL;
return pwszNewString;
}
VOID
WINAPI
FreeQuotedString(
LPWSTR pwszString
)
{
HeapFree(GetProcessHeap(),
0,
pwszString);
}
DWORD
PrintError(
IN HANDLE hModule, OPTIONAL
IN DWORD dwErrId,
...
)
/*++
Routine Description:
Displays an error message.
We first search for the error code in the module specified by the caller
(if one is specified)
If no module is given, or the error code doesnt exist we look for MPR
errors, RAS errors and Win32 errors - in that order
Arguments:
hModule - Module to load the string from
dwMsgId - Message to be printed
... - Insert strings
Return Value:
Message length
--*/
{
DWORD dwMsgLen;
LPWSTR pwszOutput = NULL;
WCHAR rgwcInput[MAX_MSG_LENGTH + 1];
va_list arglist;
va_start(arglist, dwErrId);
if(hModule)
{
if(LoadStringW(hModule,
dwErrId,
rgwcInput,
MAX_MSG_LENGTH))
{
//
// Found the message in the callers module
//
dwMsgLen = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |FORMAT_MESSAGE_FROM_STRING,
rgwcInput,
0,
0L,
(LPWSTR)&pwszOutput,
0,
&arglist);
if(dwMsgLen == 0)
{
ASSERT(pwszOutput == NULL);
}
else
{
OEMprintf(pwszOutput);
LocalFree(pwszOutput);
return dwMsgLen;
}
}
else
{
return 0;
}
}
//
// Next try, local errors
//
if((dwErrId > NETSH_ERROR_BASE) &&
(dwErrId < NETSH_ERROR_END))
{
if(LoadStringW(g_hModule,
dwErrId,
rgwcInput,
MAX_MSG_LENGTH))
{
//
// Found the message in our module
//
dwMsgLen = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |FORMAT_MESSAGE_FROM_STRING,
rgwcInput,
0,
0L,
(LPWSTR)&pwszOutput,
0,
&arglist);
if(dwMsgLen == 0)
{
ASSERT(pwszOutput == NULL);
}
else
{
OEMprintf(pwszOutput);
LocalFree(pwszOutput);
return dwMsgLen;
}
}
}
//
// Next try MPR errors
//
if (MprAdminGetErrorString(dwErrId,
&pwszOutput) == NO_ERROR)
{
wcscpy(rgwcInput, pwszOutput);
LocalFree(pwszOutput);
wcscat(rgwcInput, L"\r\n");
OEMprintf(rgwcInput);
dwMsgLen = wcslen(rgwcInput);
return dwMsgLen;
}
//
// Next try RAS errors
//
if (RasGetErrorStringW(dwErrId,
rgwcInput,
MAX_MSG_LENGTH) == NO_ERROR)
{
wcscat(rgwcInput, L"\r\n");
OEMprintf(rgwcInput);
dwMsgLen = wcslen(rgwcInput);
return dwMsgLen;
}
//
// Finally try Win32
//
dwMsgLen = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
dwErrId,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPWSTR)&rgwcInput,
MAX_MSG_LENGTH,
&arglist);
if(dwMsgLen)
{
OEMprintf(rgwcInput);
return dwMsgLen;
}
return 0;
}
DWORD
DisplayMessageVA(
IN LPCWSTR pwszFormat,
IN va_list *parglist
)
{
DWORD dwMsgLen = 0;
LPWSTR pwszOutput = NULL;
do
{
dwMsgLen = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER
|FORMAT_MESSAGE_FROM_STRING,
pwszFormat,
0,
0L, // Default country ID.
(LPWSTR)&pwszOutput,
0,
parglist);
if(dwMsgLen == 0)
{
// ISSUE: Unlocalized string.
wprintf( L"Error %d in FormatMessageW()\n", GetLastError());
ASSERT(pwszOutput == NULL);
break;
}
OEMprintf( pwszOutput );
} while ( FALSE );
if ( pwszOutput) { LocalFree( pwszOutput ); }
return dwMsgLen;
}
DWORD
PrintMessage(
IN LPCWSTR rgwcInput,
...
)
{
DWORD dwMsgLen = 0;
LPCWSTR pwszOutput = NULL;
va_list arglist;
va_start(arglist, rgwcInput);
if (!rgwcInput)
{
return ERROR_INVALID_PARAMETER;
}
return DisplayMessageVA(rgwcInput, &arglist);
}
DWORD
PrintMessageFromModule(
IN HANDLE hModule,
IN DWORD dwMsgId,
...
)
{
WCHAR rgwcInput[MAX_MSG_LENGTH + 1];
va_list arglist;
if ( !LoadStringW(hModule,
dwMsgId,
rgwcInput,
MAX_MSG_LENGTH) )
{
return 0;
}
va_start(arglist, dwMsgId);
return DisplayMessageVA(rgwcInput, &arglist);
}
DWORD
DisplayMessageM(
IN HANDLE hModule,
IN DWORD dwMsgId,
...
)
{
DWORD dwMsgLen;
LPWSTR pwszOutput = NULL;
va_list arglist;
do
{
va_start(arglist, dwMsgId);
dwMsgLen = FormatMessageW(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_HMODULE,
hModule,
dwMsgId,
0L,
(LPWSTR)&pwszOutput,
0,
&arglist
);
if(dwMsgLen == 0)
{
DWORD dwErr;
dwErr = GetLastError();
ASSERT(pwszOutput == NULL);
break;
}
OEMprintf( pwszOutput );
} while ( FALSE );
if ( pwszOutput) { LocalFree( pwszOutput ); }
return dwMsgLen;
}
DWORD
DisplayMessageToConsole(
IN HANDLE hModule,
IN HANDLE hConsole,
IN DWORD dwMsgId,
...
)
{
DWORD dwMsgLen = 0;
LPWSTR pwszInput, pwszOutput = NULL;
va_list arglist;
DWORD dwNumWritten;
do
{
va_start(arglist, dwMsgId);
pwszInput = HeapAlloc(GetProcessHeap(),
0,
MAX_MSG_LENGTH * sizeof(WCHAR));
if ( pwszInput == (LPCWSTR) NULL )
{
break;
}
if ( !LoadStringW(hModule,
dwMsgId,
pwszInput,
MAX_MSG_LENGTH) )
{
break;
}
dwMsgLen = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
pwszInput,
0,
0L, // Default country ID.
(LPWSTR)&pwszOutput,
0,
&arglist);
if ( dwMsgLen == 0 )
{
break;
}
OEMfprintf( hConsole, pwszOutput );
fflush(stdout);
} while ( FALSE );
if ( pwszInput ) { HeapFree( GetProcessHeap(), 0, pwszInput ); }
if ( pwszOutput) { LocalFree( pwszOutput ); }
return dwMsgLen;
}
BOOL
WINAPI
HandlerRoutine(
DWORD dwCtrlType // control signal type
)
{
HANDLE hStop;
if (dwCtrlType == CTRL_C_EVENT)
{
hStop = OpenEvent(EVENT_ALL_ACCESS,
FALSE,
STOP_EVENT);
if (hStop isnot NULL)
{
SetEvent(hStop);
CloseHandle(hStop);
}
return TRUE;
}
else
{
// Need to handle the other events...
// CTRL_BREAK_EVENT
// CTRL_CLOSE_EVENT
// CTRL_LOGOFF_EVENT
// Need to clean up, free all the dll's we loaded.
//
FreeHelpers();
FreeDlls();
// Always need to return false for these events, otherwise the app will hang.
//
return FALSE;
}
};
void
cls(
IN HANDLE hConsole
)
{
COORD coordScreen = { 0, 0 };
BOOL bSuccess;
DWORD cCharsWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi;
DWORD dwConSize;
WORD wAttr;
bSuccess = GetConsoleScreenBufferInfo(hConsole, &csbi);
dwConSize = (WORD) csbi.dwSize.X * (WORD) csbi.dwSize.Y;
bSuccess = FillConsoleOutputCharacter(hConsole,
_TEXT(' '),
dwConSize,
coordScreen,
&cCharsWritten);
//
// get the current text attribute
//
bSuccess = GetConsoleScreenBufferInfo(hConsole, &csbi);
//
// Make the background and foreground the same
//
wAttr = (csbi.wAttributes & 0xFFF0) | ((csbi.wAttributes & 0x00F0) >> 4);
//
// now set the buffer's attributes accordingly
//
bSuccess = FillConsoleOutputAttribute(hConsole,
wAttr,
dwConSize,
coordScreen,
&cCharsWritten);
bSuccess = SetConsoleCursorPosition(hConsole, coordScreen);
return;
}
BOOL
WINAPI
InitializeConsole(
IN OUT PDWORD pdwRR,
OUT HANDLE *phMib,
OUT HANDLE *phConsole
)
{
HANDLE hMib, hStdOut, hConsole;
CONSOLE_SCREEN_BUFFER_INFO csbi;
hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
if (hStdOut is INVALID_HANDLE_VALUE)
{
return FALSE;
}
if (!*pdwRR)
{
//
// No refresh. Display to standard output
//
*phConsole = hStdOut;
*phMib = (HANDLE) NULL;
return TRUE;
}
do
{
hMib = CreateEvent( NULL, TRUE, FALSE, STOP_EVENT);
if (hMib == NULL)
{
*pdwRR = 0;
*phConsole = hStdOut;
*phMib = (HANDLE) NULL;
break;
}
*phMib = hMib;
hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
0, // NO sharing
NULL,
CONSOLE_TEXTMODE_BUFFER,
NULL);
if (hConsole is INVALID_HANDLE_VALUE)
{
//
// No refresh will be done
//
*pdwRR = 0;
*phConsole = hStdOut;
*phMib = (HANDLE) NULL;
break;
}
else
{
GetConsoleScreenBufferInfo(hStdOut, &csbi);
csbi.dwSize.X = 80;
SetConsoleScreenBufferSize(hConsole, csbi.dwSize);
SetConsoleActiveScreenBuffer(hConsole);
SetConsoleCtrlHandler(HandlerRoutine,TRUE);
*phConsole = hConsole;
}
}while (FALSE);
return TRUE;
}
DWORD
WINAPI
RefreshConsole(
IN HANDLE hMib,
IN HANDLE hConsole,
IN DWORD dwRR
)
{
COORD origin = {0,0};
if (dwRR)
{
SetConsoleCursorPosition(hConsole, origin);
if (WaitForSingleObject(hMib, dwRR) == WAIT_OBJECT_0)
{
//
// End of refresh
//
ResetEvent(hMib);
SetConsoleCtrlHandler(HandlerRoutine,FALSE);
CloseHandle(hMib);
CloseHandle(hConsole);
// SetConsoleActiveScreenBuffer(g_hStdOut);
return FALSE;
}
else
{
//
// Go in loop again
//
cls(hConsole);
return TRUE;
}
}
return FALSE;
}
#define HT_TOP 0
#define HT_CONTEXT 1
#define HT_GROUP 2
typedef struct {
HANDLE hModule;
LPCWSTR pwszContext;
DWORD dwType;
LPCWSTR pwszCommand;
DWORD dwDescr;
LPCWSTR pwszDescr;
LPCWSTR pwszGroup;
} help_t;
#define MAX_HELP_COMMANDS 100
help_t help[MAX_HELP_COMMANDS];
ULONG ulNumHelpCommands = 0;
DWORD
FindHelpCommand(
IN LPCWSTR pwszCommand
)
{
ULONG i;
for (i=0; i<ulNumHelpCommands; i++)
{
if (!wcscmp(pwszCommand, help[i].pwszCommand))
{
return i;
}
}
return -1;
}
DWORD
AddHelpCommand(
IN HANDLE hModule,
IN LPCWSTR pwszContext,
IN DWORD dwType,
IN LPCWSTR pwszCommand,
IN DWORD dwDescr,
IN LPCWSTR pwszDescr,
IN LPCWSTR pwszGroup
)
{
ULONG i;
ASSERT(ulNumHelpCommands < MAX_HELP_COMMANDS); // XXX
i = ulNumHelpCommands++;
help[i].hModule = hModule;
help[i].pwszContext = pwszContext;
help[i].dwType = dwType;
help[i].pwszCommand = pwszCommand;
help[i].dwDescr = dwDescr;
help[i].pwszDescr = pwszDescr;
help[i].pwszGroup = pwszGroup;
return NO_ERROR;
}
int
__cdecl
helpcmp(
const void *a,
const void *b
)
{
return _wcsicmp(((help_t*)a)->pwszCommand, ((help_t*)b)->pwszCommand);
}
DWORD
DisplayAllHelpCommands(
)
{
ULONG i;
// Sort
qsort( (void*)help, ulNumHelpCommands, sizeof(help_t), helpcmp );
for (i=0; i<ulNumHelpCommands; i++)
{
if ((HT_GROUP == help[i].dwType) && help[i].pwszGroup)
{
LPWSTR pwszGroupFullCmd = (LPWSTR)
MALLOC( ( wcslen(help[i].pwszGroup) +
wcslen(help[i].pwszCommand) +
2 // for blank and NULL characters
) * sizeof(WCHAR)
);
if (NULL == pwszGroupFullCmd)
{
PrintMessage( MSG_HELP_START, help[i].pwszCommand );
}
else
{
wcscpy(pwszGroupFullCmd, help[i].pwszGroup);
wcscat(pwszGroupFullCmd, L" ");
wcscat(pwszGroupFullCmd, help[i].pwszCommand);
PrintMessage( MSG_HELP_START, pwszGroupFullCmd );
FREE(pwszGroupFullCmd);
}
}
else
{
PrintMessage( MSG_HELP_START, help[i].pwszCommand );
}
if (!PrintMessageFromModule( help[i].hModule, help[i].dwDescr, help[i].pwszDescr,
help[i].pwszContext,
(help[i].pwszContext[0])? L" " : L"" ))
{
PrintMessage(MSG_NEWLINE);
}
}
// Delete all help commands
ulNumHelpCommands = 0;
return NO_ERROR;
}
VOID
DisplayContextsHere(
IN ULONG ulNumContexts,
IN PBYTE pByteContexts,
IN DWORD dwContextSize,
IN DWORD dwDisplayFlags
)
{
DWORD i;
PCNS_CONTEXT_ATTRIBUTES pContext;
if (!ulNumContexts)
{
return;
}
PrintMessageFromModule(g_hModule, MSG_SUBCONTEXT_LIST);
for (i = 0; i < ulNumContexts; i++)
{
pContext = (PCNS_CONTEXT_ATTRIBUTES)(pByteContexts + i*dwContextSize);
if (pContext->dwFlags & ~dwDisplayFlags)
{
continue;
}
if (!VerifyOsVersion(pContext->pfnOsVersionCheck))
{
continue;
}
PrintMessage(L" %1!s!", pContext->pwszContext);
}
PrintMessage(MSG_NEWLINE);
}
DWORD
DisplayContextHelp(
IN PCNS_CONTEXT_ATTRIBUTES pContext,
IN DWORD dwDisplayFlags,
IN DWORD dwCmdFlags,
IN DWORD dwArgsRemaining,
IN LPCWSTR pwszGroup
)
{
DWORD i, j, dwErr;
PNS_HELPER_TABLE_ENTRY pHelper;
ULONG ulNumContexts;
DWORD dwContextSize;
PBYTE pByteContexts;
PNS_DLL_TABLE_ENTRY pDll;
PCNS_CONTEXT_ATTRIBUTES pSubContext;
LPWSTR pwszFullContextName = NULL;
dwErr = GetHelperEntry(&pContext->guidHelper, &pHelper);
if (dwErr)
{
return dwErr;
}
dwErr = GetDllEntry( pHelper->dwDllIndex, &pDll );
if (dwErr)
{
return dwErr;
}
dwErr = AppendFullContextName(pContext, &pwszFullContextName);
ulNumContexts = pHelper->ulNumSubContexts;
dwContextSize = pHelper->ulSubContextSize;
pByteContexts = pHelper->pSubContextTable;
// First set up flags
if (dwCmdFlags & CMD_FLAG_INTERACTIVE)
{
dwDisplayFlags |= CMD_FLAG_INTERACTIVE;
}
if (dwCmdFlags & CMD_FLAG_ONLINE)
{
dwDisplayFlags |= CMD_FLAG_ONLINE;
}
if (dwCmdFlags & CMD_FLAG_LOCAL)
{
dwDisplayFlags |= CMD_FLAG_LOCAL;
}
if (IsImmediate(dwCmdFlags, dwArgsRemaining))
{
dwCmdFlags |= CMD_FLAG_IMMEDIATE;
}
// Turn on any flags not used to limit commands
// so they won't cause commands to not be displayed
dwDisplayFlags |= ~CMD_FLAG_LIMIT_MASK;
if (dwDisplayFlags & CMD_FLAG_PRIVATE)
{
PrintMessageFromModule(g_hModule, MSG_SHELL_CMD_HELP_HEADER);
}
// dwDisplayFlags has PRIVATE set *unless* this is called as a result of
// printing help in the parent context, and non-inheritable commands
// should not be printed.
//
// dwCmdFlags has IMMEDIATE set *unless* this is called from a parent
// context, in which case parent help should not be printed.
if ((!(dwDisplayFlags & CMD_FLAG_PRIVATE)
|| (dwCmdFlags & CMD_FLAG_IMMEDIATE)))
{
// Print help on inherited commands
PCNS_CONTEXT_ATTRIBUTES pParentContext;
dwErr = GetParentContext( pContext, &pParentContext );
if (dwErr is NO_ERROR)
{
dwErr = DisplayContextHelp( pParentContext,
dwDisplayFlags & ~CMD_FLAG_PRIVATE,
dwCmdFlags,
dwArgsRemaining,
pwszGroup );
}
}
for(i = 0; !pwszGroup && (i < pContext->ulNumTopCmds); i++)
{
if (((*pContext->pTopCmds)[i].dwCmdHlpToken == MSG_NULL)
|| ((*pContext->pTopCmds)[i].dwFlags & ~dwDisplayFlags))
{
continue;
}
if (!VerifyOsVersion((*pContext->pTopCmds)[i].pOsVersionCheck))
{
continue;
}
AddHelpCommand( pDll->hDll,
pwszFullContextName,
HT_TOP,
(*pContext->pTopCmds)[i].pwszCmdToken,
(*pContext->pTopCmds)[i].dwShortCmdHelpToken,
NULL, NULL );
}
for(i = 0; i < pContext->ulNumGroups; i++)
{
if (((*pContext->pCmdGroups)[i].dwShortCmdHelpToken == MSG_NULL)
|| ((*pContext->pCmdGroups)[i].dwFlags & ~dwDisplayFlags))
{
continue;
}
if (!(*pContext->pCmdGroups)[i].pwszCmdGroupToken[0])
{
continue;
}
if (pwszGroup)
{
if (_wcsicmp(pwszGroup, (*pContext->pCmdGroups)[i].pwszCmdGroupToken))
{
continue;
}
if (!VerifyOsVersion((*pContext->pCmdGroups)[i].pOsVersionCheck))
{
continue;
}
for (j = 0; j < (*pContext->pCmdGroups)[i].ulCmdGroupSize; j++)
{
if ((*pContext->pCmdGroups)[i].pCmdGroup[j].dwFlags & ~dwDisplayFlags)
{
continue;
}
if (!VerifyOsVersion((*pContext->pCmdGroups)[i].pCmdGroup[j].pOsVersionCheck))
{
continue;
}
AddHelpCommand( pDll->hDll,
pwszFullContextName,
HT_GROUP,
(*pContext->pCmdGroups)[i].pCmdGroup[j].pwszCmdToken,
(*pContext->pCmdGroups)[i].pCmdGroup[j].dwShortCmdHelpToken,
NULL,
pwszGroup);
}
}
else
{
if (!VerifyOsVersion((*pContext->pCmdGroups)[i].pOsVersionCheck))
{
continue;
}
AddHelpCommand( pDll->hDll,
pwszFullContextName,
HT_GROUP,
(*pContext->pCmdGroups)[i].pwszCmdGroupToken,
(*pContext->pCmdGroups)[i].dwShortCmdHelpToken,
NULL, NULL );
}
}
for (i = 0; !pwszGroup && (i < ulNumContexts); i++)
{
pSubContext = (PCNS_CONTEXT_ATTRIBUTES)(pByteContexts + i * dwContextSize);
if ((pSubContext->dwFlags & ~dwDisplayFlags))
{
continue;
}
if (!VerifyOsVersion(pSubContext->pfnOsVersionCheck))
{
continue;
}
AddHelpCommand( g_hModule,
pwszFullContextName,
HT_CONTEXT,
pSubContext->pwszContext,
MSG_HELPER_HELP,
pSubContext->pwszContext, NULL );
}
if (dwDisplayFlags & CMD_FLAG_PRIVATE)
{
// Add any ubiquitous commands that aren't already added
for(i = 0; !pwszGroup && (i < g_ulNumUbiqCmds); i++)
{
if ((g_UbiqCmds[i].dwCmdHlpToken == MSG_NULL)
|| (g_UbiqCmds[i].dwFlags & ~dwDisplayFlags))
{
continue;
}
if (FindHelpCommand(g_UbiqCmds[i].pwszCmdToken) isnot -1)
{
continue;
}
AddHelpCommand( g_hModule,
pwszFullContextName,
HT_TOP,
g_UbiqCmds[i].pwszCmdToken,
g_UbiqCmds[i].dwShortCmdHelpToken,
NULL, NULL );
}
}
if (ulNumHelpCommands > 0)
{
if (dwDisplayFlags & CMD_FLAG_PRIVATE)
{
PrintMessageFromModule( g_hModule, MSG_LOCAL_COMMANDS );
}
else if (help[0].pwszContext[0])
{
PrintMessageFromModule( g_hModule,
MSG_INHERITED_COMMANDS,
help[0].pwszContext );
}
else
{
PrintMessageFromModule( g_hModule, MSG_GLOBAL_COMMANDS );
}
DisplayAllHelpCommands();
}
// Once we've popped the stack back up to the original context
// in which the help command was run, display all the subcontexts
// available here.
if ((dwDisplayFlags & CMD_FLAG_PRIVATE) && !pwszGroup)
{
DisplayContextsHere( pHelper->ulNumSubContexts,
pHelper->pSubContextTable,
pHelper->ulSubContextSize,
dwDisplayFlags );
PrintMessageFromModule( g_hModule, MSG_HELP_FOOTER, CMD_HELP2 );
}
if (pwszFullContextName)
{
FREE(pwszFullContextName);
}
return NO_ERROR;
}
DWORD
WINAPI
DisplayHelp(
IN CONST GUID *pguidHelper,
IN LPCWSTR pwszContext,
IN DWORD dwDisplayFlags,
IN DWORD dwCmdFlags,
IN DWORD dwArgsRemaining,
IN LPCWSTR pwszGroup
)
{
DWORD i, j, dwErr;
PCNS_CONTEXT_ATTRIBUTES pContext;
PNS_HELPER_TABLE_ENTRY pHelper;
// Locate helper
dwErr = GetHelperEntry( pguidHelper, &pHelper );
// Locate context
dwErr = GetContextEntry( pHelper, pwszContext, &pContext );
if (dwErr)
{
return dwErr;
}
return DisplayContextHelp( pContext,
dwDisplayFlags,
dwCmdFlags,
dwArgsRemaining,
pwszGroup );
}
DWORD
WINAPI
PreprocessCommand(
IN HANDLE hModule,
IN OUT LPWSTR *ppwcArguments,
IN DWORD dwCurrentIndex,
IN DWORD dwArgCount,
IN OUT PTAG_TYPE pttTags,
IN DWORD dwTagCount,
IN DWORD dwMinArgs,
IN DWORD dwMaxArgs,
OUT DWORD *pdwTagType
)
/*++
Description:
Make sure the number of arguments is valid.
Make sure there are no duplicate or unrecognized tags.
Arguments:
ppwcArguments - Argument array
dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg
dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
pttTags - Legal tags
dwTagCount - Number of legal tags
dwMinArgs - minimum # of args required
dwMaxArgs - maximum # of args required
pdwTagType - Index into pttTags for each argument
--*/
{
DWORD dwNumArgs, i;
DWORD dwErr = NO_ERROR;
DWORD dwTagEnum;
if ( (!ppwcArguments) || (!pttTags) || (!pdwTagType) )
{
return ERROR_INVALID_PARAMETER;
}
for (dwTagEnum = 0; dwTagEnum < dwTagCount; dwTagEnum++)
{
pttTags->bPresent = FALSE;
}
#ifdef EXTRA_DEBUG
PRINT("PreHandleCommand:");
for( i = 0; i < dwArgCount; i++)
{
PRINT(ppwcArguments[i]);
}
#endif
dwNumArgs = dwArgCount - dwCurrentIndex;
if((dwNumArgs < dwMinArgs) or
(dwNumArgs > dwMaxArgs))
{
//
// Wrong number of arguments specified
//
return ERROR_INVALID_SYNTAX;
}
if ( dwNumArgs > 0 )
{
dwErr = MatchTagsInCmdLine(hModule,
ppwcArguments,
dwCurrentIndex,
dwArgCount,
pttTags,
dwTagCount,
pdwTagType);
if (dwErr isnot NO_ERROR)
{
if (dwErr is ERROR_INVALID_OPTION_TAG)
{
return ERROR_INVALID_SYNTAX;
}
return dwErr;
}
}
// Make sure we don't have duplicate or unrecognized tags
for(i = 0; i < dwNumArgs; i ++)
{
if ((int) pdwTagType[i] < 0 || pdwTagType[i] >= dwTagCount)
{
dwErr = ERROR_INVALID_SYNTAX;
break;
}
}
switch(dwErr)
{
case NO_ERROR:
{
break;
}
default:
{
return dwErr;
}
}
// Make sure every required tag is present
for(i = 0; i < dwTagCount; i++)
{
if ((pttTags[i].dwRequired & NS_REQ_PRESENT)
&& !pttTags[i].bPresent)
{
PrintMessageFromModule(g_hModule, ERROR_MISSING_OPTION);
return ERROR_INVALID_SYNTAX;
}
}
return NO_ERROR;
}
#define HISTORY_MASK (NS_EVENT_LAST_N | NS_EVENT_FROM_N | \
NS_EVENT_FROM_START | NS_EVENT_LAST_SECS)
DWORD
WINAPI
PrintEventLog(
IN LPCWSTR pwszLogName,
IN LPCWSTR pwszComponent,
IN LPCWSTR pwszSubComponent, OPTIONAL
IN DWORD fFlags,
IN LPCVOID pvHistoryInfo,
IN PNS_EVENT_FILTER pfnEventFilter, OPTIONAL
IN LPCVOID pvFilterContext
)
/*++
Routine Description:
Called by monitors and helpers to print events in the eventlog
It can either work in a refresh mode where it will loop till a CRTL-C
is entered, or will print only the history. The function looks up
the message file for the component by reading the REG_EXPAND_SZ value
in Services\Eventlog\pwszComponent\EventMessageFile.
It then loads the library, and gets the PNS_QUERY_SUBCOMPONENT function.
It calls the function to map the subcomponent to an array of eventids.
According to the flags given, the function seeks to the right position
in the event log file. It then prints out all logs that fall in the
component/subcomp from the seek pointer to the current time. If the user
specifies NS_EVENT_LOOP, then we set up a notification to the eventlog
and print messages as they get written
Arguments:
pwszLogName Event Log source (e.g L"System", L"Security")
pwszComponent Name of the component whose events are to be logged
dwComponentId Subcomponent. 0 means all
fFlags Flags that control printing and history
pvHistoryInfo Depends on flags -
NS_EVENT_LAST_N - this is the (DWORD) number of records
to go back
NS_EVENT_FROM_N - this is an event id (DWORD). We go back
to the latest instance of event id N
NS_EVENT_FROM_START - this is ignored. We go to event
6005, source EVENTLOG
NS_EVENT_LAST_SECS - this is the number of seconds (DWORD)
to go back
pfnEventFilter If specified, this is a callback function the caller
can specify for additional filtering
pvFilterContext Passed to pfnEventFilter
Return Value:
ERROR_INVALID_FLAGS
--*/
{
HANDLE hEventLog, hEvent, hStop, rghEvents[2];
HINSTANCE hInst;
HKEY hkRoot, hkKey;
LPWSTR pwszValueName;
ULONG ulLen, ulEventCount;
DWORD dwResult, dwType;
PDWORD pdwEventIds;
BOOL bDone;
WCHAR rgwcDll[MAX_PATH + 2], rgwcRealDll[MAX_PATH + 2];
EVENT_PRINT_INFO EventInfo;
PNS_GET_EVENT_IDS_FN pfnQueryEventIds;
//
// Validate the flags. User has to tell us atleast whether he wants
// history or looping
// Also the history flags (NS_EVENT_LAST_N, NS_EVENT_FROM_N,
// NS_EVENT_FROM_START and NS_EVENT_LAST_SECS) are all mutually exclusive
//
if((fFlags is 0) or
(((fFlags & NS_EVENT_LAST_N) and (fFlags & (HISTORY_MASK ^ NS_EVENT_LAST_N))) or
((fFlags & NS_EVENT_LAST_SECS) and (fFlags & (HISTORY_MASK ^ NS_EVENT_LAST_SECS))) or
((fFlags & NS_EVENT_FROM_N) and (fFlags & (HISTORY_MASK ^ NS_EVENT_FROM_N))) or
((fFlags & NS_EVENT_FROM_START) and (fFlags & (HISTORY_MASK ^ NS_EVENT_FROM_START)))))
{
return ERROR_INVALID_FLAGS;
}
//
// Create the value name
//
ulLen = wcslen(EVENT_MSG_KEY_W) + wcslen(pwszLogName) +
wcslen(L"\\") + wcslen(pwszComponent) + 1;
ulLen *= sizeof(WCHAR);
__try
{
pwszValueName = _alloca(ulLen);
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
return ERROR_NOT_ENOUGH_MEMORY;
}
//
// First query the registry to see what dll contains the messages
// for the component
//
dwResult = RegConnectRegistryW(g_pwszRouterName,
HKEY_LOCAL_MACHINE,
&hkRoot);
if(dwResult isnot NO_ERROR)
{
return dwResult;
}
RtlZeroMemory(pwszValueName, ulLen);
//
// Setup the key
//
wcscpy(pwszValueName,
EVENT_MSG_KEY_W);
wcscat(pwszValueName,
pwszLogName);
wcscat(pwszValueName,
L"\\");
wcscat(pwszValueName,
pwszComponent);
dwResult = RegOpenKeyExW(hkRoot,
pwszValueName,
0,
KEY_READ,
&hkKey);
//
// This is actually a very bad thing to do (calling RegCloseKey on a
// predefined handle
//
RegCloseKey(hkRoot);
if(dwResult isnot NO_ERROR)
{
return dwResult;
}
ulLen = sizeof(rgwcDll);
//
// Get the value of the message dll
//
dwResult = RegQueryValueExW(hkKey,
EVENT_MSG_FILE_VALUE_W,
NULL,
&dwType,
(PBYTE)rgwcDll,
&ulLen);
RegCloseKey(hkKey);
if(dwResult isnot NO_ERROR)
{
return dwResult;
}
if(dwType isnot REG_EXPAND_SZ)
{
return ERROR_DATATYPE_MISMATCH;
}
if(ulLen is 0)
{
return ERROR_REGISTRY_CORRUPT;
}
//
// Expand the type
//
ulLen = MAX_PATH + 2;
if(ExpandEnvironmentStringsW(rgwcDll,
rgwcRealDll,
ulLen) >= ulLen)
{
//
// Shouldnt be more than MAX_PATH
//
return ERROR_REGISTRY_CORRUPT;
}
//
// Now load the DLL and query its function ptr
// IMPORTANT - we read the remote registry but look for the DLL on the
// local machine
//
hInst = LoadLibraryW(rgwcRealDll);
if(hInst is NULL)
{
return GetLastError();
}
//
// Get the set of event ids
//
pdwEventIds = NULL;
if(pwszSubComponent is NULL)
{
//
// Means the caller wants all events generated by the component
// printed out. To do this we just set ulEventCount to 0
//
ulEventCount = 0;
}
else
{
//
// Get the procaddr of the function which will tell us the
// set
//
pfnQueryEventIds =
(PNS_GET_EVENT_IDS_FN) GetProcAddress((HMODULE)hInst,
NS_GET_EVENT_IDS_FN_NAME);
if(pfnQueryEventIds is NULL)
{
FreeLibrary((HMODULE)hInst);
return ERROR_PROC_NOT_FOUND;
}
//
// Now call the function to get an array of eventids
//
ulEventCount = 0;
dwResult = pfnQueryEventIds(pwszComponent,
pwszSubComponent,
NULL,
&ulEventCount);
if(dwResult is ERROR_INSUFFICIENT_BUFFER)
{
do
{
//
// Allocate the event table
//
__try
{
pdwEventIds = _alloca(ulEventCount * sizeof(DWORD));
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
dwResult = ERROR_NOT_ENOUGH_MEMORY;
break;
}
dwResult = pfnQueryEventIds(pwszComponent,
pwszSubComponent,
pdwEventIds,
&ulEventCount);
}while(FALSE);
}
if(dwResult isnot NO_ERROR)
{
FreeLibrary((HMODULE)hInst);
return dwResult;
}
}
//
// Open the eventlog and seek to the pointer depending on the history
// flags being passed
//
EventInfo.pwszLogName = pwszLogName;
EventInfo.pwszComponent = pwszComponent;
EventInfo.pwszSubComponent = pwszSubComponent;
EventInfo.fFlags = (fFlags & HISTORY_MASK);
EventInfo.dwHistoryContext = PtrToUlong(pvHistoryInfo);
EventInfo.ulEventCount = ulEventCount;
EventInfo.pdwEventIds = pdwEventIds;
EventInfo.pfnEventFilter = pfnEventFilter;
EventInfo.pvFilterContext = pvFilterContext;
dwResult = SetupEventLogSeekPtr(&hEventLog,
&EventInfo);
if(dwResult isnot NO_ERROR)
{
FreeLibrary((HMODULE)hInst);
return dwResult;
}
PrintHistory(hEventLog,
hInst,
&EventInfo);
if(!(fFlags & NS_EVENT_LOOP))
{
FreeLibrary((HMODULE)hInst);
CloseEventLog(hEventLog);
return NO_ERROR;
}
//
// The user wants to loop, printing events as they come
// Create the event that will notify us that a new event was written
//
hEvent = CreateEvent(NULL,
FALSE,
FALSE,
NULL);
if(hEvent is NULL)
{
FreeLibrary((HMODULE)hInst);
CloseEventLog(hEventLog);
return GetLastError();
}
//
// Create the event for the ctrl-c handler
//
hStop = CreateEvent(NULL,
FALSE,
FALSE,
STOP_EVENT);
if(hStop is NULL)
{
FreeLibrary((HMODULE)hInst);
CloseEventLog(hEventLog);
CloseHandle(hEvent);
return GetLastError();
}
//
// Register for event change notifications
//
if(!NotifyChangeEventLog(hEventLog,
hEvent))
{
FreeLibrary((HMODULE)hInst);
CloseEventLog(hEventLog);
CloseHandle(hEvent);
CloseHandle(hStop);
return GetLastError();
}
//
// Handler routine opens the named stop event and sets it
// when a ctrl-c is hit
//
SetConsoleCtrlHandler(HandlerRoutine,
TRUE);
rghEvents[0] = hEvent;
rghEvents[1] = hStop;
bDone = FALSE;
while(!bDone)
{
dwResult = WaitForMultipleObjectsEx(2,
rghEvents,
FALSE,
INFINITE,
TRUE);
switch((dwResult - WAIT_OBJECT_0))
{
case 0:
{
PrintHistory(hEventLog,
hInst,
&EventInfo);
break;
}
case 1:
{
bDone = TRUE;
break;
}
}
}
FreeLibrary((HMODULE)hInst);
CloseEventLog(hEventLog);
CloseHandle(hEvent);
CloseHandle(hStop);
return NO_ERROR;
}
DWORD
SetupEventLogSeekPtr(
OUT PHANDLE phEventLog,
IN PEVENT_PRINT_INFO pEventInfo
)
/*++
Routine Description:
This function opens a handle to the appropriate event log and "rewinds"
to the correct point as specified by the fflags. When the function returns
the eventlog handle is setup such that reading the log sequentially in a
forward direction will get the events the caller wants
Locks:
None
Arguments:
See above, args are passed pretty much the same
Return Value:
Win32
--*/
{
DWORD dwResult, dwRead, dwNeed, i, dwHistoryContext;
ULONGLONG Buffer[512]; // Huge buffer
DWORD_PTR pNextEvent;
BOOL bResult, bDone;
LPCWSTR pwszComponent;
EVENTLOGRECORD *pStartEvent;
dwResult = NO_ERROR;
//
// Open the event log
//
*phEventLog = OpenEventLogW(g_pwszRouterName,
pEventInfo->pwszLogName);
if(*phEventLog is NULL)
{
return GetLastError();
}
if(pEventInfo->fFlags is 0)
{
//
// If no history is being requested, just return. Our seek ptr
// will be already setup
//
return NO_ERROR;
}
if(pEventInfo->fFlags & NS_EVENT_FROM_START)
{
//
// We can use the same matching for this as we do for NS_EVENT_FROM_N
// by setting component to eventlog and dwHistoryContext to 6005
//
pwszComponent = L"eventlog";
dwHistoryContext = 6005;
}
else
{
pwszComponent = pEventInfo->pwszComponent;
dwHistoryContext = pEventInfo->dwHistoryContext;
}
//
// Okay so she wants history. Either way we read backwards
//
i = 0;
pStartEvent = NULL;
bDone = FALSE;
//
// Read the event log till we find a record to stop at
// This is signalled by the code setting bDone to TRUE
//
while(!bDone)
{
//
// Get a bunch of events
//
bResult = ReadEventLogW(
*phEventLog,
EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ,
0,
(PVOID)Buffer,
sizeof(Buffer),
&dwRead,
&dwNeed
);
if(bResult isnot TRUE)
{
dwResult = GetLastError();
if(dwResult is ERROR_HANDLE_EOF)
{
//
// If we have reached the end of the log, break out
//
bDone = TRUE;
break;
}
else
{
return dwResult;
}
}
//
// Start at the beginning of the buffer we just read
//
pNextEvent = (DWORD_PTR)Buffer;
//
// Read till we walk off the end of the buffer or find a record
//
// If we find the starting record, we set pStartEvent to one after that
// It may so happen that the starting record is the last one in
// the block that we have read. In that case, we set pStartEvent
// to NULL but bDone to TRUE
//
while((pNextEvent < (DWORD_PTR)Buffer + dwRead) and !bDone)
{
EVENTLOGRECORD *pCurrentEvent;
pCurrentEvent = (EVENTLOGRECORD *)pNextEvent;
pNextEvent += pCurrentEvent->Length;
switch(pEventInfo->fFlags)
{
case NS_EVENT_LAST_N:
case NS_EVENT_LAST_SECS:
{
//
// We are being asked to go back N (of our records)
// or go back N secs
//
if(!IsOurRecord(pCurrentEvent,
pEventInfo))
{
//
// Not one of ours
//
continue;
}
if(pEventInfo->fFlags is NS_EVENT_LAST_N)
{
//
// i is the count of events
//
i++;
}
else
{
time_t CurrentTime;
//
// i is the time difference in seconds
// = currentTime - eventTime
//
time(&CurrentTime);
//
// Subtract and truncate
//
i = (DWORD)(CurrentTime - pCurrentEvent->TimeGenerated);
}
if(i >= dwHistoryContext)
{
//
// Have gone back N (records or seconds)
//
if(pNextEvent < (DWORD_PTR)Buffer + dwRead)
{
//
// Have some more records in this buffer, so
// set pStartEvent to the next one
//
pStartEvent = (EVENTLOGRECORD *)pNextEvent;
}
else
{
pStartEvent = NULL;
}
//
// Done, break out of while(pNextEvent... and
// while(!bDone)
//
bDone = TRUE;
break;
}
break;
}
case NS_EVENT_FROM_N:
case NS_EVENT_FROM_START:
{
//
// We are being asked to go to the the most recent
// occurance of a certain event.
//
if(_wcsicmp((LPCWSTR)((DWORD_PTR)pCurrentEvent + sizeof(*pCurrentEvent)),
pwszComponent) == 0)
{
if(pCurrentEvent->EventID is dwHistoryContext)
{
if(pNextEvent < (DWORD_PTR)Buffer + dwRead)
{
pStartEvent = (EVENTLOGRECORD *)pNextEvent;
}
else
{
pStartEvent = NULL;
}
//
// Done, break out of while(pCurrent...
// and while(!bDone)
//
bDone = TRUE;
break;
}
}
}
default:
{
ASSERT(FALSE);
}
}
}
}
if(pStartEvent)
{
//
// So we found a record at which to start.
// API wants a buffer even if we set the size to 0
//
bResult = ReadEventLogW(*phEventLog,
EVENTLOG_SEEK_READ | EVENTLOG_FORWARDS_READ,
pStartEvent->RecordNumber,
(PVOID)Buffer,
0,
&dwRead,
&dwNeed);
if(dwNeed < sizeof(Buffer))
{
ReadEventLogW(*phEventLog,
EVENTLOG_SEEK_READ | EVENTLOG_FORWARDS_READ,
pStartEvent->RecordNumber,
(PVOID)Buffer,
dwNeed,
&dwRead,
&dwNeed);
}
}
return NO_ERROR;
}
VOID
PrintHistory(
IN HANDLE hEventLog,
IN HINSTANCE hInst,
IN PEVENT_PRINT_INFO pEventInfo
)
{
DWORD dwResult, dwRead, dwNeed;
ULONGLONG Buffer[512]; // Huge buffer
DWORD_PTR pCurrent;
LPCWSTR *pInsertArray;
LPWSTR pwszOutput;
BOOL bResult;
ULONG ulCurrentInserts;
dwResult = NO_ERROR;
pInsertArray = NULL;
ulCurrentInserts = 0;
while(TRUE)
{
//
// Get a bunch of logs
//
bResult = ReadEventLogW(hEventLog,
EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ,
0,
(PVOID)Buffer,
sizeof(Buffer),
&dwRead,
&dwNeed);
if((bResult isnot TRUE) or
(dwRead is 0))
{
dwResult = GetLastError();
return;
}
pCurrent = (DWORD_PTR)Buffer;
//
// Read till we walk off the end of the buffer
//
while(pCurrent < (DWORD_PTR)Buffer + dwRead)
{
EVENTLOGRECORD *pTemp;
LPCWSTR pInsertPtr;
DWORD i;
pTemp = (EVENTLOGRECORD *)pCurrent;
pCurrent += pTemp->Length;
if(!IsOurRecord(pTemp,
pEventInfo))
{
continue;
}
if(ulCurrentInserts < (ULONG)(pTemp->NumStrings + 1))
{
ulCurrentInserts = 2 * pTemp->NumStrings;
__try
{
pInsertArray = _alloca(ulCurrentInserts * sizeof(LPCWSTR));
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
continue;
}
}
#define _FM_FLAGS (FORMAT_MESSAGE_ALLOCATE_BUFFER | \
FORMAT_MESSAGE_FROM_HMODULE | \
FORMAT_MESSAGE_ARGUMENT_ARRAY | \
FORMAT_MESSAGE_MAX_WIDTH_MASK)
dwResult = FormatMessageW(_FM_FLAGS,
hInst,
pTemp->EventID,
0L,
(LPWSTR)&pwszOutput,
0,
(va_list *)pInsertArray);
#undef _FM_FLAGS
if(dwResult is 0)
{
continue;
}
else
{
WCHAR pwszTime[26];
time_t TimeGenerated = pTemp->TimeGenerated;
//
// ctime is 26 chars with time[24] and time[25] being
// \n\0. So we copy 24 and set the 25th to \0
//
CopyMemory(pwszTime,
_wctime(&TimeGenerated),
24 * sizeof(WCHAR));
pwszTime[24] = UNICODE_NULL;
printf("[%S] %S\n\n",
pwszTime,
pwszOutput);
LocalFree(pwszOutput);
}
}
}
return;
}
BOOL
IsOurRecord(
IN EVENTLOGRECORD *pRecord,
IN PEVENT_PRINT_INFO pEventInfo
)
{
BOOL bRet;
DWORD i;
if(_wcsicmp((LPCWSTR)((DWORD_PTR)pRecord + sizeof(*pRecord)),
pEventInfo->pwszComponent) isnot 0)
{
return FALSE;
}
bRet = TRUE;
//
// If ulEventCount is 0 means any event. So return TRUE
//
for(i = 0; i < pEventInfo->ulEventCount; i++)
{
bRet = (pRecord->EventID is pEventInfo->pdwEventIds[i]);
if(bRet)
{
break;
}
}
if(bRet)
{
if(pEventInfo->pfnEventFilter)
{
if(!(pEventInfo->pfnEventFilter)(pRecord,
pEventInfo->pwszLogName,
pEventInfo->pwszComponent,
pEventInfo->pwszSubComponent,
pEventInfo->pvFilterContext))
{
//
// It fell in our subcomp, but the caller doesnt
// consider it so
//
bRet = FALSE;
}
}
}
return bRet;
}
Reference in a new issue Copy permalink