www.pudn.com > win2ksrc.rar > testwin.c, change:2000-07-26,size:19344b


/*++ 
 
Copyright (c) 1990  Microsoft Corporation 
 
Module Name: 
 
    TESTWIN.C 
 
Abstract: 
 
    Test program for the eventlog service. This program calls the Win 
    APIs to test out the operation of the service. 
 
Author: 
 
    Rajen Shah  (rajens) 05-Aug-1991 
 
Revision History: 
 
 
--*/ 
/*----------------------*/ 
/* INCLUDES             */ 
/*----------------------*/ 
#include <nt.h> 
#include <ntrtl.h> 
#include <nturtl.h> 
#include <stdio.h>      // printf 
#include <string.h>     // stricmp 
#include <stdlib.h> 
#include <windows.h> 
#include <netevent.h> 
 
// 
// Turn on NotifyChangeEventLog 
// 
#define     TEST_NOTIFY         1 
//#define     TEST_REMOTE         1 
 
#define     READ_BUFFER_SIZE        1024*2      // Use 2K buffer 
 
#define     SIZE_DATA_ARRAY         65 
 
// 
// Global buffer used to emulate "binary data" when writing an event 
// record. 
// 
    DWORD    Data[SIZE_DATA_ARRAY]; 
//    LPWSTR   ServerName=L"\\\\danl2"; 
    LPWSTR   ServerName=NULL; 
 
 
VOID 
Initialize ( 
    VOID 
    ) 
{ 
    DWORD   i; 
 
    // Initialize the values in the data buffer. 
    // 
    for (i=0; i< SIZE_DATA_ARRAY; i++) 
        Data[i] = i; 
 
} 
 
 
BOOL 
Usage ( 
    VOID 
    ) 
{ 
    printf( "usage: \n" ); 
    printf( "-b <filename>  Tests BackupEventLog API\n"); 
    printf( "-c             Tests ClearEventLog API\n"); 
    printf( "-n             Tests NotifyChangeEventlog\n"); 
    printf( "-rsb           Reads event log sequentially backwards\n"); 
    printf( "-rsf           Reads event log sequentially forwards\n"); 
    printf( "-rrb <record>  Reads event log from <record> backwards\n"); 
    printf( "-rrf <record>  Reads event log from <record> forwards\n"); 
    printf( "-w <count>     Tests ReportEvent API <count> times\n"); 
    return ERROR_INVALID_PARAMETER; 
 
} // Usage 
 
 
 
BOOL 
WriteLogEntry ( HANDLE LogHandle, DWORD EventID ) 
 
{ 
#define NUM_STRINGS     2 
 
    BOOL    Status; 
    WORD    EventType, i; 
    DWORD   DataSize; 
    PSID    pUserSid; 
 
    PWSTR   Strings[NUM_STRINGS] = {L"StringAOne", 
                                   L"StringATwo" 
                                  }; 
 
    EventType = EVENTLOG_INFORMATION_TYPE; 
    pUserSid   = NULL; 
    DataSize  = sizeof(DWORD) * SIZE_DATA_ARRAY; 
 
    for (i=0; i< SIZE_DATA_ARRAY; i++) 
        Data[i] += i; 
 
    Status = ReportEventW ( 
                    LogHandle, 
                    EventType, 
                    0,            // event category 
                    EventID, 
                    pUserSid, 
                    NUM_STRINGS, 
                    DataSize, 
                    Strings, 
                    (PVOID)Data 
                    ); 
 
    return (Status); 
} 
 
DWORD 
WriteLogEntryMsg ( HANDLE LogHandle, DWORD EventID ) 
/* 
    This function requires a registry entry in the Applications section 
    of the Eventlog for TESTWINAPP, it will use the netevent.dll message file. 
*/ 
 
{ 
#define NUM_STRINGS     2 
 
    WORD    EventType; 
    DWORD   DataSize; 
    PSID    pUserSid; 
 
    PWSTR   Strings[NUM_STRINGS]; 
 
    Strings[0] = L"This is a BOGUS message for TEST purposes Ignore this substitution text"; 
    Strings[1] = L"GHOST SERVICE in the long string format - I wanted a long string to pass into this function"; 
 
    EventType = EVENTLOG_INFORMATION_TYPE; 
    pUserSid   = NULL; 
    DataSize  = sizeof(DWORD) * SIZE_DATA_ARRAY; 
 
 
    if (!ReportEventW ( 
                    LogHandle, 
                    EventType, 
                    0,            // event category 
                    EVENT_SERVICE_START_FAILED_NONE, 
                    pUserSid, 
                    NUM_STRINGS, 
                    0,              // DataSize 
                    Strings, 
                    (PVOID)NULL     // Data 
                    )) { 
 
        printf("ReportEventW failed %d\n",GetLastError()); 
        return(GetLastError()); 
    } 
    return (NO_ERROR); 
} 
 
 
VOID 
DisplayEventRecords( PVOID Buffer, 
                     DWORD  BufSize, 
                     ULONG *NumRecords) 
 
{ 
    PEVENTLOGRECORD     pLogRecord; 
    ANSI_STRING         StringA; 
    UNICODE_STRING      StringU; 
    PWSTR               pwString; 
    DWORD               Count = 0; 
    DWORD               Offset = 0; 
    DWORD               i; 
 
    pLogRecord = (PEVENTLOGRECORD) Buffer; 
 
    while ((DWORD)Offset < BufSize) { 
 
        printf("\nRecord # %lu\n", ++Count); 
 
        printf("Length: 0x%lx TimeGenerated: 0x%lx  EventID: 0x%lx EventType: 0x%x\n", 
                pLogRecord->Length, pLogRecord->TimeGenerated, pLogRecord->EventID, 
                pLogRecord->EventType); 
 
        printf("NumStrings: 0x%x StringOffset: 0x%lx UserSidLength: 0x%lx TimeWritten: 0x%lx\n", 
                pLogRecord->NumStrings, pLogRecord->StringOffset, 
                pLogRecord->UserSidLength, pLogRecord->TimeWritten); 
 
        printf("UserSidOffset: 0x%lx    DataLength: 0x%lx    DataOffset:  0x%lx \n", 
                pLogRecord->UserSidOffset, pLogRecord->DataLength, 
                pLogRecord->DataOffset); 
 
        // 
        // Print out module name 
        // 
        pwString = (PWSTR)((DWORD)pLogRecord + sizeof(EVENTLOGRECORD)); 
        RtlInitUnicodeString (&StringU, pwString); 
        RtlUnicodeStringToAnsiString (&StringA, &StringU, TRUE); 
 
        printf("ModuleName:  %s ", StringA.Buffer); 
        RtlFreeAnsiString (&StringA); 
 
        // 
        // Display ComputerName 
        // 
        pwString = pwString + (wcslen(pwString) + 1); 
 
        RtlInitUnicodeString (&StringU, pwString); 
        RtlUnicodeStringToAnsiString (&StringA, &StringU, TRUE); 
 
        printf("ComputerName: %s\n",StringA.Buffer); 
        RtlFreeAnsiString (&StringA); 
 
        // 
        // Display strings 
        // 
        pwString = (PWSTR)((DWORD)Buffer + pLogRecord->StringOffset); 
 
        printf("\nStrings: \n"); 
        for (i=0; i<pLogRecord->NumStrings; i++) { 
 
            RtlInitUnicodeString (&StringU, pwString); 
            RtlUnicodeStringToAnsiString (&StringA, &StringU, TRUE); 
 
            printf("  %s  \n",StringA.Buffer); 
 
            RtlFreeAnsiString (&StringA); 
 
            pwString = (PWSTR)((DWORD)pwString + StringU.MaximumLength); 
        } 
 
        // Get next record 
        // 
        Offset += pLogRecord->Length; 
 
        pLogRecord = (PEVENTLOGRECORD)((DWORD)Buffer + Offset); 
 
    } 
    *NumRecords = Count; 
 
} 
 
 
BOOL 
ReadFromLog ( HANDLE LogHandle, 
             PVOID  Buffer, 
             ULONG *pBytesRead, 
             DWORD  ReadFlag, 
             DWORD  Record 
             ) 
{ 
    BOOL        Status; 
    DWORD       MinBytesNeeded; 
    DWORD       ErrorCode; 
 
    Status = ReadEventLogW ( 
                        LogHandle, 
                        ReadFlag, 
                        Record, 
                        Buffer, 
                        READ_BUFFER_SIZE, 
                        pBytesRead, 
                        &MinBytesNeeded 
                        ); 
 
 
    if (!Status) { 
         ErrorCode = GetLastError(); 
         if (ErrorCode == ERROR_HANDLE_EOF) { 
             Status = TRUE; 
         } 
         else if (ErrorCode == ERROR_NO_MORE_FILES) { 
            printf("Buffer too small. Need %lu bytes min\n", MinBytesNeeded); 
         } 
         else { 
             printf("Error from ReadEventLog %d \n", ErrorCode); 
         } 
 
    } 
 
    return (Status); 
} 
 
 
 
 
BOOL 
TestReadEventLog (DWORD Count, DWORD ReadFlag, DWORD Record) 
 
{ 
    BOOL    bStatus,IStatus; 
    DWORD   status; 
    HANDLE  LogHandle; 
    LPWSTR  ModuleName; 
    DWORD   NumRecords, BytesReturned; 
    PVOID   Buffer; 
    DWORD   RecordOffset; 
    DWORD   NumberOfRecords; 
    DWORD   OldestRecord; 
 
    printf("Testing ReadEventLog API to read %lu entries\n",Count); 
 
    Buffer = malloc (READ_BUFFER_SIZE); 
 
    // 
    // Initialize the strings 
    // 
    NumRecords = Count; 
    ModuleName = L"TESTWINAPP"; 
 
    // 
    // Open the log handle 
    // 
    printf("OpenEventLog - "); 
    LogHandle = OpenEventLogW ( 
                    ServerName, 
                    ModuleName 
                    ); 
 
    if (LogHandle == NULL) { 
         printf("Error - %d\n", GetLastError()); 
 
    } else { 
        printf("SUCCESS\n"); 
 
        // 
        // Get and print record information 
        // 
 
        bStatus = GetNumberOfEventLogRecords(LogHandle, & NumberOfRecords); 
        if (bStatus) { 
           bStatus = GetOldestEventLogRecord(LogHandle, & OldestRecord); 
        } 
 
        if (!bStatus) { 
           printf("Query of record information failed with %X", GetLastError()); 
           return(bStatus); 
        } 
 
        printf("\nThere are %d records in the file, %d is the oldest" 
         " record number\n", NumberOfRecords, OldestRecord); 
 
        RecordOffset = Record; 
 
        printf("Reading %u records\r", Count); 
 
        while (Count) { 
 
            // 
            // Read from the log 
            // 
            bStatus = ReadFromLog ( LogHandle, 
                                   Buffer, 
                                   &BytesReturned, 
                                   ReadFlag, 
                                   RecordOffset 
                                 ); 
            if (bStatus) { 
                printf("Bytes read = 0x%lx\n", BytesReturned); 
                printf("Read %u records\n", NumRecords); 
                DisplayEventRecords(Buffer, BytesReturned, &NumRecords); 
                Count -= NumRecords; 
                RecordOffset += NumRecords; 
            } else { 
                break; 
            } 
 
            if (BytesReturned == 0) 
                break; 
        } 
        printf("\n"); 
 
        if (!bStatus) { 
            printf ("ReadFromLog Error - %d. Remaining count %lu\n", GetLastError(), 
                Count); 
        } else { 
            printf ("SUCCESS\n"); 
        } 
 
        printf("Calling CloseEventLog\n"); 
        IStatus = CloseEventLog (LogHandle); 
    } 
 
    return (bStatus); 
} 
 
 
 
BOOL 
TestWriteEventLog (DWORD Count) 
 
{ 
    DWORD       Status=NO_ERROR; 
    BOOL        IStatus; 
    HANDLE      LogHandle; 
    LPWSTR      ModuleName; 
    DWORD       EventID = 99; 
    DWORD       WriteCount; 
    DWORD       DataNum=0; 
 
    printf("Testing ReportEvent API\n"); 
 
    // 
    // Initialize the strings 
    // 
    ModuleName = L"TESTWINAPP"; 
 
    printf("Calling RegisterEventSource for WRITE %lu times\n", Count); 
    while ((Count > 0) && (Status== NO_ERROR)) { 
        // 
        // Open the log handle 
        // 
        LogHandle = RegisterEventSourceW ( 
                        ServerName, 
                        ModuleName 
                        ); 
 
        if (LogHandle == NULL) { 
            Status = GetLastError(); 
            printf("RegisterEventSource Failure - %d\n", Status); 
            return(Status); 
 
        } else { 
            printf("Registered - "); 
            WriteCount = 5; 
            printf("Record # %u:  ", Count); 
 
            while ((WriteCount>0) && (Status==NO_ERROR)) { 
 
                // 
                // Write an entry into the log 
                // 
                Data[0] = DataNum;                     // Make data "unique" 
                EventID = (EventID + DataNum) % 100;   // Vary the eventids 
                Status = WriteLogEntryMsg( LogHandle, EventID ); 
                DataNum++; 
                WriteCount--; 
 
                if (Status != NO_ERROR) { 
                    printf ("WriteLogEntry Error - %d. Remaining count %lu\n",Status,Count); 
                } else { 
                    printf ("%d,",WriteCount); 
                } 
            } 
 
            IStatus = DeregisterEventSource (LogHandle); 
            printf(" - Deregistered\n"); 
        } 
        Count--; 
    } 
 
    printf("\n"); 
    return (Status); 
} 
 
 
 
BOOL 
TestClearLogFile () 
 
{ 
    BOOL        Status, IStatus; 
    HANDLE      LogHandle; 
    LPWSTR ModuleName, BackupName; 
 
    printf("Testing ClearLogFile API\n"); 
    // 
    // Initialize the strings 
    // 
    ModuleName = L"TESTWINAPP"; 
 
    // 
    // Open the log handle 
    // 
    printf("Calling OpenEventLog for CLEAR - "); 
    LogHandle = OpenEventLogW ( 
                    NULL, 
                    ModuleName 
                    ); 
 
    if (LogHandle == NULL) { 
         printf("OpenEventLog Error - %d\n", GetLastError()); 
 
    } else { 
        printf("SUCCESS\n"); 
 
        // 
        // Clear the log file and back it up to "view.log" 
        // 
 
        printf("Calling ClearEventLog backing up to view.log  "); 
        BackupName = L"\\\\danhi386\\roote\\view.log"; 
 
        Status = ClearEventLogW ( 
                        LogHandle, 
                        BackupName 
                        ); 
 
        if (!Status) { 
            printf ("ClearEventLog Error - %d\n", GetLastError()); 
        } else { 
            printf ("SUCCESS\n"); 
        } 
 
        // 
        // Now just clear the file without backing it up 
        // 
        printf("Calling ClearEventLog with no backup  "); 
        Status = ClearEventLogW ( 
                        LogHandle, 
                        NULL 
                        ); 
 
        if (!Status) { 
            printf ("ClearEventLogError - %d\n", GetLastError()); 
        } else { 
            printf ("SUCCESS\n"); 
        } 
 
        printf("Calling CloseEventLog\n"); 
        IStatus = CloseEventLog (LogHandle); 
    } 
 
    return(Status); 
} 
 
BOOL 
TestBackupLogFile (LPSTR BackupFileName) 
 
{ 
    BOOL        Status, IStatus; 
    HANDLE      LogHandle; 
    LPWSTR ModuleName; 
    ANSI_STRING AnsiString; 
    UNICODE_STRING UnicodeString; 
 
    printf("Testing BackupLogFile API\n"); 
    // 
    // Initialize the strings 
    // 
    ModuleName = L"TESTWINAPP"; 
 
    // 
    // Open the log handle 
    // 
    printf("Calling OpenEventLog for BACKUP - "); 
    LogHandle = OpenEventLogW ( 
                    NULL, 
                    ModuleName 
                    ); 
 
    if (LogHandle == NULL) { 
         printf("OpenEventLog Failure %d\n", GetLastError()); 
 
    } else { 
        printf("OpenEventLog SUCCESS\n"); 
 
        // 
        // Backup the log file to BackupFileName 
        // 
 
        printf("Calling BackupEventLog backing up to %s  ", BackupFileName); 
 
    RtlInitAnsiString(&AnsiString, BackupFileName); 
    RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, TRUE); 
 
    Status = BackupEventLogW (LogHandle, UnicodeString.Buffer); 
 
        if (!Status) { 
            printf ("BackupEventLog failure - %d\n", GetLastError()); 
        } else { 
            printf ("SUCCESS\n"); 
        } 
 
        printf("Calling CloseEventLog\n"); 
        IStatus = CloseEventLog (LogHandle); 
    } 
 
    return(Status); 
} 
 
VOID 
NotifyThread( 
    HANDLE  hEventLog) 
{ 
    Sleep(30000); 
    printf("NotifyThread: Writing an event...\n"); 
    if (!WriteLogEntryMsg(hEventLog,1)) { 
        printf("NotifyThread: WriteLogEntryMsg failed\n"); 
    } 
    else { 
        printf("Event was written\n"); 
    } 
    ExitThread(NO_ERROR); 
} 
 
VOID 
TestChangeNotify( 
    ) 
 
/*++ 
 
Routine Description: 
 
 
Arguments: 
 
 
Return Value: 
 
 
--*/ 
{ 
    HANDLE      hEvent; 
    HANDLE      hThread; 
    HANDLE      hEventLog; 
    DWORD       threadId; 
    DWORD       status; 
 
    hEvent = CreateEvent(NULL,FALSE,FALSE,NULL); 
    if (hEvent == NULL) { 
        printf("CreateEvent Failed %d\n",GetLastError()); 
        return; 
    } 
#ifdef TEST_REMOTE 
    hEventLog = RegisterEventSourceW(L"\\\\DANL2",L"TESTWINAPP"); 
#else 
    hEventLog = RegisterEventSourceW(NULL,L"TESTWINAPP"); 
#endif 
    if (hEventLog == NULL) { 
        printf("OpenEventLog failed %d\n",GetLastError()); 
    } 
 
#ifdef TEST_NOTIFY 
 
    if (!NotifyChangeEventLog(hEventLog,hEvent)) { 
        printf("NotifyChangeEventLog failed %d\n",GetLastError()); 
    } 
#endif  // TEST_NOTIFY 
 
    hThread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)NotifyThread,hEventLog,0,&threadId); 
    if (hThread == NULL) { 
        printf("CreateThread Failed %d\n",GetLastError()); 
        CloseHandle(hEvent); 
        return; 
    } 
 
    CloseHandle(hThread); 
 
    printf("Wait for event to become signaled\n"); 
    status = WaitForSingleObject(hEvent,INFINITE); 
    if (status == WAIT_OBJECT_0) { 
        printf("The Event was signaled\n"); 
    } 
    else { 
        printf("The Event was NOT signaled\n"); 
    } 
    return; 
} 
/****************************************************************************/ 
DWORD __cdecl 
main ( 
    IN SHORT argc, 
    IN PSZ argv[], 
    IN PSZ envp[] 
    ) 
/*++ 
* 
* Routine Description: 
* 
* 
* 
* Arguments: 
* 
* 
* 
* 
* Return Value: 
* 
* 
* 
--*/ 
/****************************************************************************/ 
{ 
 
    DWORD   ReadFlags; 
 
    Initialize();           // Init any data 
 
    if ( argc < 2 ) { 
        printf( "Not enough parameters\n" ); 
        return Usage( ); 
    } 
 
    if ( stricmp( argv[1], "-c" ) == 0 ) { 
 
        if ( argc < 3 ) { 
            return TestClearLogFile(); 
        } 
    } 
    else if ( stricmp( argv[1], "-b" ) == 0 ) { 
 
        if ( argc < 3 ) { 
            printf("You must supply a filename to backup to\n"); 
            return(FALSE); 
        } 
 
            return TestBackupLogFile(argv[2]); 
 
    } else if (stricmp ( argv[1], "-rsf" ) == 0 ) { 
 
        ReadFlags = EVENTLOG_SEQUENTIAL_READ | EVENTLOG_FORWARDS_READ; 
        if ( argc < 3 ) { 
            return TestReadEventLog(1,ReadFlags,0 ); 
        } else  { 
            return Usage(); 
        } 
    } else if (stricmp ( argv[1], "-rsb" ) == 0 ) { 
 
        ReadFlags = EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ; 
        if ( argc < 3 ) { 
            return TestReadEventLog(1,ReadFlags,0 ); 
        } else  { 
            return Usage(); 
        } 
    } else if (stricmp ( argv[1], "-n" ) == 0 ) { 
        TestChangeNotify(); 
 
    } else if (stricmp ( argv[1], "-rrf" ) == 0 ) { 
 
        ReadFlags = EVENTLOG_SEEK_READ | EVENTLOG_FORWARDS_READ; 
        if ( argc < 3 ) { 
            return TestReadEventLog(1,ReadFlags ,1); 
        } else if (argc == 3) { 
            return (TestReadEventLog (1, ReadFlags, atoi(argv[2]))); 
        } 
    } else if (stricmp ( argv[1], "-rrb" ) == 0 ) { 
 
        ReadFlags = EVENTLOG_SEEK_READ | EVENTLOG_BACKWARDS_READ; 
        if ( argc < 3 ) { 
            return TestReadEventLog(1,ReadFlags, 1); 
        } else if (argc == 3) { 
            return (TestReadEventLog (1, ReadFlags, atoi(argv[2]))); 
        } 
    } else if (stricmp ( argv[1], "-w" ) == 0 ) { 
 
        if ( argc < 3 ) { 
            return TestWriteEventLog(1); 
        } else if (argc == 3) { 
            return (TestWriteEventLog (atoi(argv[2]))); 
        } 
 
    } else { 
 
        return Usage(); 
    } 
 
    UNREFERENCED_PARAMETER(argc); 
    UNREFERENCED_PARAMETER(argv); 
    UNREFERENCED_PARAMETER(envp); 
 
 
}