Return to eventlog.c CVS log

Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / drwatson

Annotation of mstools/samples/sdktools/image/drwatson/eventlog.c, revision 1.1

1.1     ! root        1: /*++
        !             2: 
        !             3: Copyright (c) 1993  Microsoft Corporation
        !             4: 
        !             5: Module Name:
        !             6: 
        !             7:     ui.c
        !             8: 
        !             9: Abstract:
        !            10: 
        !            11:     This file contains all functions that access the application event log.
        !            12: 
        !            13: Author:
        !            14: 
        !            15:     Wesley Witt (wesw) 1-May-1993
        !            16: 
        !            17: Environment:
        !            18: 
        !            19:     User Mode
        !            20: 
        !            21: --*/
        !            22: 
        !            23: #include <windows.h>
        !            24: #include <stdlib.h>
        !            25: #include <stdio.h>
        !            26: #include <string.h>
        !            27: 
        !            28: #include "drwatson.h"
        !            29: #include "proto.h"
        !            30: #include "messages.h"
        !            31: 
        !            32: 
        !            33: char * AddString( char *p, char *s );
        !            34: char * AddNumber( char *p, char *f, DWORD dwNumber );
        !            35: char * GetDWORD( PDWORD pdwData, char *p );
        !            36: char * GetWORD( PWORD pwData, char *p );
        !            37: char * GetString( char *s, char *p );
        !            38: 
        !            39: 
        !            40: BOOL
        !            41: ElClearAllEvents( void )
        !            42: {
        !            43:     HANDLE           hEventLog;
        !            44:     char             szAppName[MAX_PATH];
        !            45: 
        !            46: 
        !            47:     GetAppName( szAppName, sizeof(szAppName) );
        !            48:     hEventLog = OpenEventLog( NULL, szAppName );
        !            49:     Assert( hEventLog != NULL );
        !            50:     ClearEventLog( hEventLog, NULL );
        !            51:     CloseEventLog( hEventLog );
        !            52: 
        !            53:     return TRUE;
        !            54: }
        !            55: 
        !            56: BOOL
        !            57: ElEnumCrashes( PCRASHINFO crashInfo, CRASHESENUMPROC lpEnumFunc )
        !            58: {
        !            59:     char             *p;
        !            60:     HANDLE           hEventLog;
        !            61:     char             *szEvBuf;
        !            62:     EVENTLOGRECORD   *pevlr;
        !            63:     DWORD            dwRead;
        !            64:     DWORD            dwNeeded;
        !            65:     DWORD            dwBufSize = 4096;
        !            66:     BOOL             rc;
        !            67:     BOOL             ec;
        !            68:     char             szAppName[MAX_PATH];
        !            69: 
        !            70: 
        !            71:     GetAppName( szAppName, sizeof(szAppName) );
        !            72:     hEventLog = OpenEventLog( NULL, szAppName );
        !            73:     if (hEventLog == NULL) {
        !            74:         return FALSE;
        !            75:     }
        !            76: 
        !            77:     szEvBuf = (char *) malloc( dwBufSize );
        !            78:     if (szEvBuf == NULL) {
        !            79:         return FALSE;
        !            80:     }
        !            81: 
        !            82:     while (TRUE) {
        !            83: try_again:
        !            84:         rc = ReadEventLog(hEventLog,
        !            85:                         EVENTLOG_FORWARDS_READ | EVENTLOG_SEQUENTIAL_READ,
        !            86:                         0,
        !            87:                         (EVENTLOGRECORD *) szEvBuf,
        !            88:                         dwBufSize,
        !            89:                         &dwRead,
        !            90:                         &dwNeeded);
        !            91: 
        !            92:         if (!rc) {
        !            93:             ec = GetLastError();
        !            94:             if (ec != ERROR_INSUFFICIENT_BUFFER) {
        !            95:                 goto exit;
        !            96:             }
        !            97: 
        !            98:             free( szEvBuf );
        !            99: 
        !           100:             dwBufSize = dwNeeded + 1024;
        !           101:             szEvBuf = (char *) malloc( dwBufSize );
        !           102:             if (szEvBuf == NULL) {
        !           103:                 return FALSE;
        !           104:             }
        !           105: 
        !           106:             goto try_again;
        !           107:         }
        !           108: 
        !           109:         if (dwRead == 0) {
        !           110:             break;
        !           111:         }
        !           112: 
        !           113:         GetAppName( szAppName, sizeof(szAppName) );
        !           114:         p = szEvBuf;
        !           115: 
        !           116:         do {
        !           117: 
        !           118:             pevlr = (EVENTLOGRECORD *) p;
        !           119: 
        !           120:             p += pevlr->StringOffset;
        !           121: 
        !           122:             p = GetString( crashInfo->crash.szAppName,           p );
        !           123:             p = GetWORD  ( &crashInfo->crash.time.wMonth,        p );
        !           124:             p = GetWORD  ( &crashInfo->crash.time.wDay,          p );
        !           125:             p = GetWORD  ( &crashInfo->crash.time.wYear,         p );
        !           126:             p = GetWORD  ( &crashInfo->crash.time.wHour,         p );
        !           127:             p = GetWORD  ( &crashInfo->crash.time.wMinute,       p );
        !           128:             p = GetWORD  ( &crashInfo->crash.time.wSecond,       p );
        !           129:             p = GetWORD  ( &crashInfo->crash.time.wMilliseconds, p );
        !           130:             p = GetDWORD ( &crashInfo->crash.dwExceptionCode,    p );
        !           131:             p = GetDWORD ( &crashInfo->crash.dwAddress,          p );
        !           132:             p = GetString( crashInfo->crash.szFunction,          p );
        !           133: 
        !           134:             p = (char *) ((DWORD)pevlr + sizeof(EVENTLOGRECORD));
        !           135: 
        !           136:             if (strcmp( p, szAppName) == 0) {
        !           137:                 crashInfo->dwCrashDataSize = pevlr->DataLength;
        !           138:                 crashInfo->pCrashData = (char *) ((DWORD)pevlr + pevlr->DataOffset);
        !           139: 
        !           140:                 if (!lpEnumFunc( crashInfo )) {
        !           141:                     goto exit;
        !           142:                 }
        !           143:             }
        !           144: 
        !           145:             //
        !           146:             // update the pointer & read count
        !           147:             //
        !           148:             dwRead -= pevlr->Length;
        !           149:             p = (char *) ((DWORD)pevlr + pevlr->Length);
        !           150: 
        !           151:         } while ( dwRead > 0 );
        !           152:     }
        !           153: 
        !           154: exit:
        !           155:     free( szEvBuf );
        !           156:     CloseEventLog( hEventLog );
        !           157:     return TRUE;
        !           158: }
        !           159: 
        !           160: BOOL
        !           161: ElSaveCrash( PCRASHES crash, DWORD dwMaxCrashes )
        !           162: {
        !           163:     char    szStrings[4096];
        !           164:     LPSTR   p = szStrings;
        !           165:     HANDLE  hEventSrc;
        !           166:     LPSTR   pp[20];
        !           167:     char    *pLogFileData;
        !           168:     DWORD   dwLogFileDataSize;
        !           169:     char    szAppName[MAX_PATH];
        !           170: 
        !           171: 
        !           172:     if (dwMaxCrashes > 0) {
        !           173:         if (RegGetNumCrashes() >= dwMaxCrashes) {
        !           174:             return FALSE;
        !           175:         }
        !           176:     }
        !           177: 
        !           178:     RegSetNumCrashes( RegGetNumCrashes()+1 );
        !           179: 
        !           180:     p = AddString( pp[0]  = p,         crash->szAppName           );
        !           181:     p = AddNumber( pp[1]  = p, "%2d",  crash->time.wMonth         );
        !           182:     p = AddNumber( pp[2]  = p, "%2d",  crash->time.wDay           );
        !           183:     p = AddNumber( pp[3]  = p, "%4d",  crash->time.wYear          );
        !           184:     p = AddNumber( pp[4]  = p, "%2d",  crash->time.wHour          );
        !           185:     p = AddNumber( pp[5]  = p, "%2d",  crash->time.wMinute        );
        !           186:     p = AddNumber( pp[6]  = p, "%2d",  crash->time.wSecond        );
        !           187:     p = AddNumber( pp[7]  = p, "%3d",  crash->time.wMilliseconds  );
        !           188:     p = AddNumber( pp[8]  = p, "%08x", crash->dwExceptionCode     );
        !           189:     p = AddNumber( pp[9]  = p, "%08x", crash->dwAddress           );
        !           190:     p = AddString( pp[10] = p,         crash->szFunction          );
        !           191: 
        !           192:     GetAppName( szAppName, sizeof(szAppName) );
        !           193: 
        !           194:     hEventSrc = RegisterEventSource( NULL, szAppName );
        !           195: 
        !           196:     if (hEventSrc == NULL) {
        !           197:         return FALSE;
        !           198:     }
        !           199: 
        !           200:     pLogFileData = GetLogFileData( &dwLogFileDataSize );
        !           201: 
        !           202:     ReportEvent( hEventSrc,
        !           203:                  EVENTLOG_INFORMATION_TYPE,
        !           204:                  0,
        !           205:                  MSG_CRASH,
        !           206:                  NULL,
        !           207:                  11,
        !           208:                  dwLogFileDataSize,
        !           209:                  pp,
        !           210:                  pLogFileData
        !           211:                );
        !           212: 
        !           213:     DeregisterEventSource( hEventSrc );
        !           214: 
        !           215:     free( pLogFileData );
        !           216: 
        !           217:     return TRUE;
        !           218: }
        !           219: 
        !           220: char *
        !           221: AddString( char *p, char *s )
        !           222: {
        !           223:     strcpy( p, s );
        !           224:     p += (strlen(s) + 1);
        !           225:     return p;
        !           226: }
        !           227: 
        !           228: char *
        !           229: AddNumber( char *p, char *f, DWORD dwNumber )
        !           230: {
        !           231:     char buf[20];
        !           232:     wsprintf( buf, f, dwNumber );
        !           233:     return AddString( p, buf );
        !           234: }
        !           235: 
        !           236: char *
        !           237: GetString( char *s, char *p )
        !           238: {
        !           239:     strcpy( s, p );
        !           240:     return p + strlen(p) + 1;
        !           241: }
        !           242: 
        !           243: char *
        !           244: GetDWORD( PDWORD pdwData, char *p )
        !           245: {
        !           246:     sscanf( p, "%x", pdwData );
        !           247:     return p + strlen(p) + 1;
        !           248: }
        !           249: 
        !           250: char *
        !           251: GetWORD( PWORD pwData, char *p )
        !           252: {
        !           253:     *pwData = atoi( p );
        !           254:     return p + strlen(p) + 1;
        !           255: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.