home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / EventLog.pm < prev    next >
Text File  |  2004-01-12  |  13KB  |  479 lines
  1. #
  2. # EventLog.pm
  3. #
  4. # Creates an object oriented interface to the Windows NT Evenlog
  5. # Written by Jesse Dougherty
  6. #
  7.  
  8. package Win32::EventLog;
  9.  
  10. use strict;
  11. use vars qw($VERSION $AUTOLOAD @ISA @EXPORT $GetMessageText);
  12. $VERSION = '0.073';
  13.  
  14. require Exporter;
  15. require DynaLoader;
  16. require Win32;
  17.  
  18. die "The Win32::Eventlog module works only on Windows NT"
  19.     unless Win32::IsWinNT();
  20.  
  21. @ISA= qw(Exporter DynaLoader);
  22. @EXPORT = qw(
  23.     EVENTLOG_AUDIT_FAILURE
  24.     EVENTLOG_AUDIT_SUCCESS
  25.     EVENTLOG_BACKWARDS_READ
  26.     EVENTLOG_END_ALL_PAIRED_EVENTS
  27.     EVENTLOG_END_PAIRED_EVENT
  28.     EVENTLOG_ERROR_TYPE
  29.     EVENTLOG_FORWARDS_READ
  30.     EVENTLOG_INFORMATION_TYPE
  31.     EVENTLOG_PAIRED_EVENT_ACTIVE
  32.     EVENTLOG_PAIRED_EVENT_INACTIVE
  33.     EVENTLOG_SEEK_READ
  34.     EVENTLOG_SEQUENTIAL_READ
  35.     EVENTLOG_START_PAIRED_EVENT
  36.     EVENTLOG_SUCCESS
  37.     EVENTLOG_WARNING_TYPE
  38. );
  39.  
  40. $GetMessageText=0;
  41.  
  42. sub AUTOLOAD {
  43.     my($constname);
  44.     ($constname = $AUTOLOAD) =~ s/.*:://;
  45.     # reset $! to zero to reset any current errors.
  46.     local $! = 0;
  47.     my $val = constant($constname, @_ ? $_[0] : 0);
  48.     if ($!) {
  49.     if ($! =~ /Invalid/) {
  50.         $AutoLoader::AUTOLOAD = $AUTOLOAD;
  51.         goto &AutoLoader::AUTOLOAD;
  52.     }
  53.     else {
  54.         my ($pack,$file,$line) = caller;
  55.         die "Unknown Win32::EventLog macro $constname, at $file line $line.\n";
  56.     }
  57.     }
  58.     eval "sub $AUTOLOAD { $val }";
  59.     goto &$AUTOLOAD;
  60. }
  61.  
  62. #
  63. # new()
  64. #
  65. #   Win32::EventLog->new("source name", "ServerName");
  66. #
  67. sub new {
  68.     die "usage: PACKAGE->new(SOURCENAME[, SERVERNAME])\n" unless @_ > 1;
  69.     my ($class,$source,$server) = @_;
  70.     my $handle;
  71.  
  72.     # Create new handle
  73.     if ($source !~ /\\/) {
  74.     OpenEventLog($handle, $server, $source);
  75.     }
  76.     else {
  77.     OpenBackupEventLog($handle, $server, $source);
  78.     }
  79.     return bless {handle   => $handle,
  80.                   Source   => $source,
  81.                   Computer => $server} => $class;
  82. }
  83.  
  84. sub DESTROY {shift->Close}
  85.  
  86. #
  87. # Open (the rather braindead old way)
  88. # A variable initialized to empty must be supplied as the first
  89. # arg, followed by whatever new() takes
  90. #
  91. sub Open {
  92.     $_[0] = Win32::EventLog->new($_[1],$_[2]);
  93. }
  94.  
  95. sub OpenBackup {
  96.     my ($class,$source,$server) = @_;
  97.     OpenBackupEventLog(my $handle, $server, $source);
  98.     return bless {handle   => $handle,
  99.           Source   => $source,
  100.           Computer => $server} => $class;
  101. }
  102.  
  103. sub Backup {
  104.     die " usage: OBJECT->Backup(FILENAME)\n" unless @_ == 2;
  105.     my ($self,$file) = @_;
  106.     return BackupEventLog($self->{handle}, $file);
  107. }
  108.  
  109. sub Close {
  110.     my $self = shift;
  111.     CloseEventLog($self->{handle});
  112.     $self->{handle} = 0;
  113. }
  114.  
  115. # Read
  116. # Note: the EventInfo arguement requires a hash reference.
  117. sub Read {
  118.     my $self = shift;
  119.  
  120.     die "usage: OBJECT->Read(FLAGS, RECORDOFFSET, HASHREF)\n" unless @_ == 3;
  121.  
  122.     my ($readflags,$recordoffset) = @_;
  123.  
  124.     # This is to get rid of a weird "Use of uninitialized value in subroutine
  125.     # entry" warning in Perl 5.6.
  126.     my ($header, $source, $computer, $sid, $data, $strings) =
  127.         map { "" } (1..6);
  128.  
  129.     # The following is stolen shamelessly from Wyt's tests for the registry.
  130.     my $result = ReadEventLog($self->{handle}, $readflags, $recordoffset,
  131.                   $header, $source, $computer, $sid, $data,
  132.                   $strings);
  133.     my ($length,
  134.     $reserved,
  135.     $recordnumber,
  136.     $timegenerated,
  137.     $timewritten,
  138.     $eventid,
  139.     $eventtype,
  140.     $numstrings,
  141.     $eventcategory,
  142.     $reservedflags,
  143.     $closingrecordnumber,
  144.     $stringoffset,
  145.     $usersidlength,
  146.     $usersidoffset,
  147.     $datalength,
  148.     $dataoffset) = unpack('l6s4l6', $header);
  149.  
  150.     # make a hash out of the values returned from ReadEventLog.
  151.     my %h = ( Source              => $source,
  152.               Computer            => $computer,
  153.               Length              => $datalength,
  154.               Category            => $eventcategory,
  155.               RecordNumber        => $recordnumber,
  156.               TimeGenerated       => $timegenerated,
  157.               Timewritten         => $timewritten,
  158.               EventID             => $eventid,
  159.               EventType           => $eventtype,
  160.               ClosingRecordNumber => $closingrecordnumber,
  161.               User                => $sid,
  162.               Strings             => $strings,
  163.               Data                => $data,
  164.             );
  165.  
  166.     # get the text message here
  167.     if ($result and $GetMessageText) {
  168.     GetEventLogText($source, $eventid, $strings, $numstrings, my $message);
  169.     $h{Message} = $message;
  170.     }
  171.  
  172.     if (ref($_[2]) eq 'HASH') {
  173.     %{$_[2]} = %h;        # this needed for Read(...,\%foo) case
  174.     }
  175.     else {
  176.     $_[2] = \%h;
  177.     }
  178.     return $result;
  179. }
  180.  
  181. sub GetMessageText {
  182.     my $self = shift;
  183.     local $^W;
  184.     GetEventLogText($self->{Source},
  185.             $self->{EventID},
  186.             $self->{Strings},
  187.             $self->{Strings} =~ tr/\0/\0/,
  188.             my $message);
  189.  
  190.     $self->{Message} = $message;
  191.     return $message;
  192. }
  193.  
  194. sub Report {
  195.     die "usage: OBJECT->Report( HASHREF )\n" unless @_ == 2;
  196.     my ($self,$EventInfo) = @_;
  197.  
  198.     die "Win32::EventLog::Report requires a hash reference as arg 2\n"
  199.     unless ref($EventInfo) eq "HASH";
  200.  
  201.     my $computer = $EventInfo->{Computer} ? $EventInfo->{Computer}
  202.                                           : $self->{Computer};
  203.     my $source   = exists($EventInfo->{Source}) ? $EventInfo->{Source}
  204.                                                 : $self->{Source};
  205.  
  206.     return WriteEventLog($computer, $source, $EventInfo->{EventType},
  207.              $EventInfo->{Category}, $EventInfo->{EventID}, 0,
  208.              $EventInfo->{Data}, split(/\0/, $EventInfo->{Strings}));
  209.  
  210. }
  211.  
  212. sub GetOldest {
  213.     my $self = shift;
  214.     die "usage: OBJECT->GetOldest( SCALAREF )\n" unless @_ == 1;
  215.     return GetOldestEventLogRecord($self->{handle},$_[0]);
  216. }
  217.  
  218. sub GetNumber {
  219.     my $self = shift;
  220.     die "usage: OBJECT->GetNumber( SCALARREF )\n" unless @_ == 1;
  221.     return GetNumberOfEventLogRecords($self->{handle}, $_[0]);
  222. }
  223.  
  224. sub Clear {
  225.     my ($self,$file) = @_;
  226.     die "usage: OBJECT->Clear( FILENAME )\n" unless @_ == 2;
  227.     return ClearEventLog($self->{handle}, $file);
  228. }
  229.  
  230. bootstrap Win32::EventLog;
  231.  
  232. 1;
  233. __END__
  234.  
  235. =head1 NAME
  236.  
  237. Win32::EventLog - Process Win32 Event Logs from Perl
  238.  
  239. =head1 SYNOPSIS
  240.  
  241.     use Win32::EventLog
  242.     $handle=Win32::EventLog->new("Application");
  243.  
  244. =head1 DESCRIPTION
  245.  
  246. This module implements most of the functionality available from the
  247. Win32 API for accessing and manipulating Win32 Event Logs. The access
  248. to the EventLog routines is divided into those that relate to an
  249. EventLog object and its associated methods and those that relate other
  250. EventLog tasks (like adding an EventLog record).
  251.  
  252. =head1 The EventLog Object and its Methods
  253.  
  254. The following methods are available to open, read, close and backup
  255. EventLogs.
  256.  
  257. =over 4
  258.  
  259. =item Win32::EventLog->new(SOURCENAME [,SERVERNAME]);
  260.  
  261. The new() method creates a new EventLog object and returns a handle
  262. to it. This hande is then used to call the methods below.
  263.  
  264. The method is overloaded in that if the supplied SOURCENAME
  265. argument contains one or more literal '\' characters (an illegal
  266. character in a SOURCENAME), it assumes that you are trying to open
  267. a backup eventlog and uses SOURCENAME as the backup eventlog to
  268. open. Note that when opening a backup eventlog, the SERVERNAME
  269. argument is ignored (as it is in the underlying Win32 API). For
  270. EventLogs on remote machines, the SOURCENAME parameter must
  271. therefore be specified as a UNC path.
  272.  
  273. =item $handle->Backup(FILENAME);
  274.  
  275. The Backup() method backs up the EventLog represented by $handle. It
  276. takes a single arguemt, FILENAME. When $handle represents an
  277. EventLog on a remote machine, FILENAME is filename on the remote
  278. machine and cannot be a UNC path (i.e you must use F<C:\TEMP\App.EVT>).
  279. The method will fail if the log file already exists.
  280.  
  281. =item $handle->Read(FLAGS, OFFSET, HASHREF);
  282.  
  283. The Read() method read an EventLog entry from the EventLog represented
  284. by $handle.
  285.  
  286. =item $handle->Close();
  287.  
  288. The Close() method closes the EventLog represented by $handle. After
  289. Close() has been called, any further attempt to use the EventLog
  290. represented by $handle will fail.
  291.  
  292. =item $handle->GetOldest(SCALARREF);
  293.  
  294. The GetOldest() method number of the the oldest EventLog record in
  295. the EventLog represented by $handle. This is required to correctly
  296. compute the OFFSET required by the Read() method.
  297.  
  298. =item $handle->GetNumber(SCALARREF);
  299.  
  300. The GetNumber() method returns the number of EventLog records in
  301. the EventLog represented by $handle. The number of the most recent
  302. record in the EventLog is therefore computed by
  303.  
  304.     $handle->GetOldest($oldest);
  305.     $handle->GetNumber($lastRec);
  306.     $lastRecOffset=$oldest+$lastRec;
  307.  
  308. =item $handle->Clear(FILENAME);
  309.  
  310. The Clear() method clears the EventLog represented by $handle.  If
  311. you provide a non-null FILENAME, the EventLog will be backed up
  312. into FILENAME before the EventLog is cleared. The method will fail
  313. if FILENAME is specified and the file refered to exists. Note also
  314. that FILENAME specifies a file local to the machine on which the
  315. EventLog resides and cannot be specified as a UNC name.
  316.  
  317. =item $handle->Report(HASHREF);
  318.  
  319. The Report() method generates an EventLog entry. The HASHREF should
  320. contain the following keys:
  321.  
  322. =over 4
  323.  
  324. =item C<Computer>
  325.  
  326. The C<Computer> field specfies which computer you want the EventLog
  327. entry recorded.  If this key doesn't exist, the server name used to
  328. create the $handle is used.
  329.  
  330. =item C<Source>
  331.  
  332. The C<Source> field specifies the source that generated the EventLog
  333. entry.  If this key doesn't exist, the source name used to create the
  334. $handle is used.
  335.  
  336. =item C<EventType>
  337.  
  338. The C<EventType> field should be one of the constants
  339.  
  340. =over 4
  341.  
  342. =item C<EVENTLOG_ERROR_TYPE>
  343.  
  344. An Error event is being logged.
  345.  
  346. =item C<EVENTLOG_WARNING_TYPE>
  347.  
  348. A Warning event is being logged.
  349.  
  350. =item C<EVENTLOG_INFORMATION_TYPE>
  351.  
  352. An Information event is being logged.
  353.  
  354. =item C<EVENTLOG_AUDIT_SUCCESS>
  355.  
  356. A Success Audit event is being logged (typically in the Security
  357. EventLog).
  358.  
  359. =item C<EVENTLOG_AUDIT_FAILURE>
  360.  
  361. A Failure Audit event is being logged (typically in the Security
  362. EventLog).
  363.  
  364. =back
  365.  
  366. These constants are exported into the main namespace by default.
  367.  
  368. =item C<Category>
  369.  
  370. The C<Category> field can have any value you want. It is specific to
  371. the particular Source.
  372.  
  373. =item C<EventID>
  374.  
  375. The C<EventID> field should contain the ID of the message that this
  376. event pertains too. This assumes that you have an associated message
  377. file (indirectly referenced by the field C<Source>).
  378.  
  379. =item C<Data>
  380.  
  381. The C<Data> field contains raw data associated with this event.
  382.  
  383. =item C<Strings>
  384.  
  385. The C<Strings> field contains the single string that itself contains
  386. NUL terminated sub-strings. This are used with the EventID to generate
  387. the message as seen from (for example) the Event Viewer application.
  388.  
  389. =back
  390.  
  391. =back
  392.  
  393. =head1 Other Win32::EventLog functions.
  394.  
  395. The following functions are part of the Win32::EventLog package but
  396. are not callable from an EventLog object.
  397.  
  398. =over 4
  399.  
  400. =item GetMessageText(HASHREF);
  401.  
  402. The GetMessageText() function assumes that HASHREF was obtained by
  403. a call to C<$handle-E<gt>Read()>. It returns the formatted string that
  404. represents the fully resolved text of the EventLog message (such as
  405. would be seen in the Windows NT Event Viewer). For convenience, the
  406. key 'Message' in the supplied HASHREF is also set to the return value
  407. of this function.
  408.  
  409. If you set the variable $Win32::EventLog::GetMessageText to 1 then
  410. each call to C<$handle-E<gt>Read()> will call this function automatically.
  411.  
  412. =back
  413.  
  414. =head1 Example 1
  415.  
  416. The following example illustrates the way in which the EventLog module
  417. can be used. It opens the System EventLog and reads through it from
  418. oldest to newest records. For each record from the B<Source> EventLog
  419. it extracts the full text of the Entry and prints the EventLog message
  420. text out.
  421.  
  422.  use Win32::EventLog;
  423.  
  424.  $handle=Win32::EventLog->new("System", $ENV{ComputerName})
  425.      or die "Can't open Application EventLog\n";
  426.  $handle->GetNumber($recs)
  427.      or die "Can't get number of EventLog records\n";
  428.  $handle->GetOldest($base)
  429.      or die "Can't get number of oldest EventLog record\n";
  430.  
  431.  while ($x < $recs) {
  432.      $handle->Read(EVENTLOG_FORWARDS_READ|EVENTLOG_SEEK_READ,
  433.                    $base+$x,
  434.                    $hashRef)
  435.          or die "Can't read EventLog entry #$x\n";
  436.      if ($hashRef->{Source} eq "EventLog") {
  437.          Win32::EventLog::GetMessageText($hashRef);
  438.          print "Entry $x: $hashRef->{Message}\n";
  439.      }
  440.      $x++;
  441.  }
  442.  
  443. =head1 Example 2
  444.  
  445. To backup and clear the EventLogs on a remote machine, do the following :-
  446.  
  447.  use Win32::EventLog;
  448.  
  449.  $myServer="\\\\my-server";    # your servername here.
  450.  my($date)=join("-", ((split(/\s+/, scalar(localtime)))[0,1,2,4]));
  451.  my($dest);
  452.  
  453.  for my $eventLog ("Application", "System", "Security") {
  454.      $handle=Win32::EventLog->new($eventLog, $myServer)
  455.          or die "Can't open Application EventLog on $myServer\n";
  456.  
  457.      $dest="C:\\BackupEventLogs\\$eventLog\\$date.evt";
  458.     $handle->Backup($dest)
  459.         or warn "Could not backup and clear the $eventLog EventLog on $myServer ($^E)\n";
  460.  
  461.     $handle->Close;
  462.  }
  463.  
  464. Note that only the Clear method is required. Note also that if the
  465. file $dest exists, the function will fail.
  466.  
  467. =head1 BUGS
  468.  
  469. None currently known.
  470.  
  471. The test script for 'make test' should be re-written to use the
  472. EventLog object.
  473.  
  474. =head1 AUTHOR
  475.  
  476. Original code by Jesse Dougherty for HiP Communications. Additional
  477. fixes and updates attributed to Martin Pauley
  478. <martin.pauley@ulsterbank.ltd.uk>) and Bret Giddings (bret@essex.ac.uk).
  479.