src/PMG/RuleDB/MatchFilename.pm

   1 package PMG::RuleDB::MatchFilename;
   2
   3 use strict;
   4 use warnings;
   5 use DBI;
   6 use Digest::SHA;
   7 use Encode qw(encode);
   8 use MIME::Words;
   9
  10 use PMG::Utils;
  11 use PMG::RuleDB::Object;
  12
  13 use base qw(PMG::RuleDB::Object);
  14
  15 sub otype {
  16     return 3004;
  17 }
  18
  19 sub oclass {
  20     return 'what';
  21 }
  22
  23 sub otype_text {
  24     return 'Match Filename';
  25 }
  26
  27 sub new {
  28     my ($type, $fname, $ogroup) = @_;
  29
  30     my $class = ref($type) || $type;
  31
  32     my $self = $class->SUPER::new($class->otype(), $ogroup);
  33
  34     $self->{fname} = $fname;
  35
  36     return $self;
  37 }
  38
  39 sub load_attr {
  40     my ($type, $ruledb, $id, $ogroup, $value) = @_;
  41
  42     my $class = ref($type) || $type;
  43
  44     defined($value) || die "undefined value: ERROR";;
  45     my $decvalue = PMG::Utils::try_decode_utf8($value);
  46
  47     my $obj = $class->new($decvalue, $ogroup);
  48     $obj->{id} = $id;
  49
  50     $obj->{digest} = Digest::SHA::sha1_hex($id, $value, $ogroup);
  51
  52     return $obj;
  53 }
  54
  55 sub save {
  56     my ($self, $ruledb) = @_;
  57
  58     defined($self->{ogroup}) || die "undefined ogroup: ERROR";
  59
  60     my $new_value = $self->{fname};
  61     $new_value =~ s/\\/\\\\/g;
  62     $new_value = encode('UTF-8', $new_value);
  63
  64     if (defined($self->{id})) {
  65         # update
  66
  67         $ruledb->{dbh}->do("UPDATE Object SET Value = ? WHERE ID = ?",
  68                            undef, $new_value, $self->{id});
  69
  70     } else {
  71         # insert
  72
  73         my $sth = $ruledb->{dbh}->prepare(
  74             "INSERT INTO Object (Objectgroup_ID, ObjectType, Value) " .
  75             "VALUES (?, ?, ?);");
  76
  77         $sth->execute($self->ogroup, $self->otype, $new_value);
  78
  79         $self->{id} = PMG::Utils::lastid($ruledb->{dbh}, 'object_id_seq');
  80     }
  81
  82     return $self->{id};
  83 }
  84
  85 sub parse_entity {
  86     my ($self, $entity) = @_;
  87
  88     my $res;
  89
  90     if (my $id = $entity->head->mime_attr('x-proxmox-tmp-aid')) {
  91         chomp $id;
  92
  93         if (my $value = PMG::Utils::extract_filename($entity->head)) {
  94             if ($value =~ m|^$self->{fname}$|i) {
  95                 push @$res, $id;
  96             }
  97         }
  98     }
  99
 100     foreach my $part ($entity->parts)  {
 101         if (my $match = $self->parse_entity ($part)) {
 102             push @$res, @$match;
 103         }
 104     }
 105
 106     return $res;
 107 }
 108
 109 sub what_match {
 110     my ($self, $queue, $entity, $msginfo) = @_;
 111
 112     return $self->parse_entity($entity);
 113 }
 114
 115 sub short_desc {
 116     my $self = shift;
 117
 118     return "filename=$self->{fname}";
 119 }
 120
 121 sub properties {
 122     my ($class) = @_;
 123
 124     return {
 125         filename => {
 126             description => "Filename filter",
 127             type => 'string',
 128             maxLength => 1024,
 129         },
 130     };
 131 }
 132
 133 sub get {
 134     my ($self) = @_;
 135
 136     return { filename => $self->{fname} };
 137 }
 138
 139 sub update {
 140     my ($self, $param) = @_;
 141
 142     $self->{fname} = $param->{filename};
 143 }
 144
 145 1;
 146 __END__
 147
 148 =head1 PMG::RuleDB::MatchFilename
 149
 150 Match Header Filename