[Cascavel-pm] (sem assunto)
Solli Moreira Honorio
shonorio em terra.com.br
Sexta Novembro 25 12:27:06 PST 2005
Pessoal,
Eu quero criar um código que efetue o processamento das mensagens do EventLog do Windows baseado em condições.
Na verdade eu quero dizer para o meu agente só mandar para o servidor sql o que realmente eu preciso.
Eu estava escrevendo (na verdade vou reescrever-o) um código como o abaixo, mas encontrei algumas condições que
considero como bug, e também estou achando que não é a maneira mais eficiente.
Então vamos ao problema :
1o. O Eventlog possui as seguintes propriedades :
Category,Computer,Data,EventID,EventType,RecordNumber,Source,Strings,TimeGenerated, Message e User;
2o. De posse destas propriedades eu quero efetuar o processamento de acordo com critérios aplicados a estas
propriedades. No programa que eu escrevi, eu deveria informar estas diretivas de processamento da seguinte maneira:
@{$Rule{ID}{Exclude}} = (7035,7036);
@{$Rule{Source}{Include}} = ('DCOM','Print');
@{$Rule{ID}{Include}} = (6005,6006,6009,6011);
Só que desta maneira, o meu sistema (se vocês derem uma olhada no código (se é que eu posso chamar isto de
código Perl), vai observar que ele processa ID primeiro do quê Source) vai processar todos os ‘events’ que
tenham ID 6005,6006,6009,6011, mesmo que não sejam source do tipo ‘DCOM’ ou ‘Print’. Ou senão, pode ocorrer
coisa pior, se eu não colocar a regra @{$Rule{ID}{Include}}, o cara vai excluir todos os ‘events’ 7035 e 7036,
mesmo não sendo do ‘DCOM’ ou ‘Print’. O ideal para mim é criar um mecanismo onde eu digo, exclua os ‘ID’ 7035
ou 7036 do ‘Source’ igual à ‘DCOM’ ou ‘Print’, etc.
3o. Você podem ver que eu estou utilizando um processo bem complexo para verificar as restrições que eu quero
processar, e depois eu crio uma expressão regular compilado com as condições. Sinceramente, acho que isto está
no mínimo deselegante, para não dizer de difícil leitura e muito bugs.
Consegui explicar o problema ? Tem como eu melhorar o processamento das restrições e simplificar o código ?
Abraços,
Solli M. Honório
<code>
my %Rule;
@{$Rule{Message}{Exclude}} = ('log.*iniciado','log.*finalizado');
@{$Rule{Source}{Include}} = ('DCOM');
@{$Rule{ID}{Exclude}} = (7035,7036);
@{$Rule{ID}{Include}} = (6005,6006,6009,6011);
GetEntries("",%Rule);
sub GetEntries
{
my ($Server, %Rules) = @_;
my %LogProperties;
GetLogProperties ($Server,\%LogProperties);
################################################################################
########### C H E C K I N G P R O C E S S ###########
################################################################################
# Verify if the source option it's ok to process without crash the system
if ( (ref($Rules{Log}) ne "ARRAY") or (! @{$Rules{Log}}[0]))
{
delete ($Rules{Log});
@{$Rules{Log}} = keys %LogProperties;
}
# Verify if the 'type' option it's ok to process without crash the system
if ( (ref($Rules{Type}) ne "ARRAY") or (! @{$Rules{Type}}[0]))
{
delete ($Rules{Type});
$Rules{Type} = EVENTLOG_ERROR_TYPE |
EVENTLOG_WARNING_TYPE |
EVENTLOG_INFORMATION_TYPE |
EVENTLOG_AUDIT_SUCCESS |
EVENTLOG_AUDIT_FAILURE;
}
else
{
my $TempType;
my %HashType = ( 'EVENTLOG_ERROR_TYPE' => EVENTLOG_ERROR_TYPE,
'EVENTLOG_WARNING_TYPE' => EVENTLOG_WARNING_TYPE,
'EVENTLOG_INFORMATION_TYPE' => EVENTLOG_INFORMATION_TYPE,
'EVENTLOG_AUDIT_SUCCESS' => EVENTLOG_AUDIT_SUCCESS,
'EVENTLOG_AUDIT_FAILURE' => EVENTLOG_AUDIT_FAILURE);
my $RegexType =
qr/EVENTLOG_ERROR_TYPE|EVENTLOG_WARNING_TYPE|EVENTLOG_INFORMATION_TYPE|EVENTLOG_AUDIT_SUCCESS|EVENTLOG_AUDIT_FAILURE/i;
map { $TempType |= $HashType{uc($_)} if ($_ =~ $RegexType)} @{$Rule{Type}};
delete ($Rules{Type});
if ( $TempType < 1 )
{
$Rules{Type} = EVENTLOG_ERROR_TYPE |
EVENTLOG_WARNING_TYPE |
EVENTLOG_INFORMATION_TYPE |
EVENTLOG_AUDIT_SUCCESS |
EVENTLOG_AUDIT_FAILURE;
}
else
{
$Rules{Type} = $TempType;
}
}
# Verify the event source e build a regular expressions compiled
if ( (ref($Rules{Source}{Exclude}) eq "ARRAY") and ( @{$Rules{Source}{Exclude}}[0]))
{
my $Regex = 'qr/';
map {$Regex .= "($_)|"} @{$Rules{Source}{Exclude}};
chop ($Regex); $Regex .= '/i';
delete $Rules{Source}{Exclude};
$Rules{'Source'}{'Exclude'} = eval $Regex; # compile the regex to check its validity
if ( $@ )
{
delete $Rules{Source}{Exclude};
NetDominus::Utilities::ReportMessage()
}
}
else
{
delete $Rules{Source}{Exclude};
}
if ( (ref($Rules{Source}{Include}) eq "ARRAY") and ( @{$Rules{Source}{Include}}[0]))
{
my $Regex = 'qr/';
map {$Regex .= "($_)|"} @{$Rules{Source}{Include}};
chop ($Regex); $Regex .= '/i';
delete $Rules{Source}{Include};
$Rules{'Source'}{'Include'} = eval $Regex; # compile the regex to check its validity
if ( $@ )
{
delete $Rules{Source}{Include};
NetDominus::Utilities::ReportMessage()
}
}
else
{
delete $Rules{Source}{Include};
}
# Verify if the 'ID' option it's ok to process without crash system
if ( (ref($Rules{ID}{Include}) ne "ARRAY") or (! @{$Rules{ID}{Include}}[0]))
{
delete $Rules{ID}{Include};
}
if ( (ref($Rules{ID}{Exclude}) ne "ARRAY") or (! @{$Rules{ID}{Exclude}}[0]))
{
delete $Rules{ID}{Exclude};
}
# Verify the message's rule to build a regular expressions compiled
if ( (ref($Rules{Message}{Exclude}) eq "ARRAY") and ( @{$Rules{Message}{Exclude}}[0]))
{
my $Regex = 'qr/';
map {$Regex .= "($_)|"} @{$Rules{Message}{Exclude}};
chop ($Regex); $Regex .= '/i';
delete $Rules{Message}{Exclude};
$Rules{'Message'}{'Exclude'} = eval $Regex; # compile the regex to check its validity
if ( $@ )
{
delete $Rules{Message}{Exclude};
NetDominus::Utilities::ReportMessage()
}
}
else
{
delete $Rules{Message}{Exclude};
}
if ( (ref($Rules{Message}{Include}) eq "ARRAY") and ( @{$Rules{Message}{Include}}[0]))
{
my $Regex = 'qr/';
map {$Regex .= "($_)|"} @{$Rules{Message}{Include}};
chop ($Regex); $Regex .= '/i';
delete $Rules{Message}{Include};
$Rules{'Message'}{'Include'} = eval $Regex; # compile the regex to check its validity
if ( $@ )
{
delete $Rules{Message}{Include};
NetDominus::Utilities::ReportMessage()
}
}
else
{
delete $Rules{Message}{Include};
}
################################################################################
########### E N D C H E C K I N G P R O C E S S ###########
################################################################################
foreach my $Source ( keys %LogProperties)
{
# Check if it's ok to process this source
next if ! ( grep (/^$Source$/i,@{$Rules{Log}}) );
my $Event = new Win32::EventLog ( $Source, "");
if ( $Event )
{
my ( $EvtEntry );
my ( $Pos, $Last ) = GetRange ($Event);
while ( $Event->Read( EVENTLOG_FORWARDS_READ |
EVENTLOG_SEEK_READ, $Pos, $EvtEntry)
&& $Pos <= $Last )
{
$Pos++;
# Checking if exist restriction to event type
next if ! ( $EvtEntry->{EventType} & $Rules{Type} );
# Checking if exist restriction to event id
$EvtEntry->{EventID} &= 0xffff;
next if ( grep( /^$EvtEntry->{EventID}$/, @{$Rules{ID}{Exclude}} ) );
if ( exists $Rules{'ID'}{'Include'} )
{ next if (! grep( /^$EvtEntry->{EventID}$/, @{$Rules{ID}{Include}}))}
# Checking if exist restriction to event source
if ( exists $Rules{'Source'}{'Exclude'} )
{ next if ( $EvtEntry->{Source} =~ /$Rules{'Source'}{'Exclude'}/ )}
next if !($EvtEntry->{Source} =~ /$Rules{'Source'}{'Include'}/ );
# Checking if exist restriction to message body
if ( exists $Rules{'Message'}{'Exclude'} )
{ next if ( $EvtEntry->{Message} =~ /$Rules{'Message'}{'Exclude'}/ )}
next if !($EvtEntry->{Message} =~ /$Rules{'Message'}{'Include'}/ );
}
$Event->Close();
}
}
}
</code>
Mais detalhes sobre a lista de discussão Cascavel-pm