src/PMG/RuleDB/MatchField.pm

   1 package PMG::RuleDB::MatchField;
   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 PVE::SafeSyslog;
  11
  12 use PMG::Utils;
  13 use PMG::RuleDB::Object;
  14
  15 use base qw(PMG::RuleDB::Object);
  16
  17 sub otype {
  18     return 3002;
  19 }
  20
  21 sub oclass {
  22     return 'what';
  23 }
  24
  25 sub otype_text {
  26     return 'Match Field';
  27 }
  28
  29 sub new {
  30     my ($type, $field, $field_value, $ogroup) = @_;
  31
  32     my $class = ref($type) || $type;
  33
  34     my $self = $class->SUPER::new($class->otype(), $ogroup);
  35
  36     $self->{field} = $field;
  37     $self->{field_value} = $field_value;
  38
  39     return $self;
  40 }
  41
  42 sub load_attr {
  43     my ($type, $ruledb, $id, $ogroup, $value) = @_;
  44
  45     my $class = ref($type) || $type;
  46
  47     defined($value) || die "undefined value: ERROR";;
  48
  49     my ($field, $field_value) = $value =~ m/^([^:]*)\:(.*)$/;
  50
  51     defined($field) || die "undefined object attribute: ERROR";
  52     defined($field_value) || die "undefined object attribute: ERROR";
  53
  54     my $decoded_field_value = PMG::Utils::try_decode_utf8($field_value);
  55     # use known constructor, bless afterwards (because sub class can have constructor
  56     # with other parameter signature).
  57     my $obj =  PMG::RuleDB::MatchField->new($field, $decoded_field_value, $ogroup);
  58     bless $obj, $class;
  59
  60     $obj->{id} = $id;
  61
  62     $obj->{digest} = Digest::SHA::sha1_hex($id, $field, $field_value, $ogroup);
  63
  64     return $obj;
  65 }
  66
  67 sub save {
  68     my ($self, $ruledb) = @_;
  69
  70     defined($self->{ogroup}) || die "undefined ogroup: ERROR";
  71
  72     my $new_value = "$self->{field}:$self->{field_value}";
  73     $new_value =~ s/\\/\\\\/g;
  74     $new_value = encode('UTF-8', $new_value);
  75
  76     if (defined ($self->{id})) {
  77         # update
  78
  79         $ruledb->{dbh}->do(
  80             "UPDATE Object SET Value = ? WHERE ID = ?",
  81             undef, $new_value, $self->{id});
  82
  83     } else {
  84         # insert
  85
  86         my $sth = $ruledb->{dbh}->prepare(
  87             "INSERT INTO Object (Objectgroup_ID, ObjectType, Value) " .
  88             "VALUES (?, ?, ?);");
  89
  90         $sth->execute($self->ogroup, $self->otype, $new_value);
  91
  92         $self->{id} = PMG::Utils::lastid($ruledb->{dbh}, 'object_id_seq');
  93     }
  94
  95     return $self->{id};
  96 }
  97
  98 sub parse_entity {
  99     my ($self, $entity) = @_;
 100
 101     return undef if !$self->{field};
 102
 103     my $res;
 104
 105     if (my $id = $entity->head->mime_attr ('x-proxmox-tmp-aid')) {
 106         chomp $id;
 107
 108         for my $value ($entity->head->get_all($self->{field})) {
 109             chomp $value;
 110
 111             my $decvalue = PMG::Utils::decode_rfc1522($value);
 112             $decvalue = PMG::Utils::try_decode_utf8($decvalue);
 113
 114             if ($decvalue =~ m|$self->{field_value}|i) {
 115                 push @$res, $id;
 116             }
 117         }
 118     }
 119
 120     foreach my $part ($entity->parts)  {
 121         if (my $match = $self->parse_entity($part)) {
 122             push @$res, @$match;
 123         }
 124     }
 125
 126     return $res;
 127 }
 128
 129 sub what_match {
 130     my ($self, $queue, $entity, $msginfo) = @_;
 131
 132     return $self->parse_entity ($entity);
 133 }
 134
 135 sub short_desc {
 136     my $self = shift;
 137
 138     return "$self->{field}=$self->{field_value}";
 139 }
 140
 141 sub properties {
 142     my ($class) = @_;
 143
 144     return {
 145         field => {
 146             description => "The Field",
 147             type => 'string',
 148             pattern => '[0-9a-zA-Z\/\\\[\]\+\-\.\*\_]+',
 149             maxLength => 1024,
 150         },
 151         value => {
 152             description => "The Value",
 153             type => 'string',
 154             maxLength => 1024,
 155         },
 156     };
 157 }
 158
 159 sub get {
 160     my ($self) = @_;
 161
 162     return {
 163         field => $self->{field},
 164         value => $self->{field_value},
 165     };
 166 }
 167
 168 sub update {
 169     my ($self, $param) = @_;
 170
 171     $self->{field_value} = $param->{value};
 172     $self->{field} = $param->{field};
 173 }
 174
 175 1;
 176
 177 __END__
 178
 179 =head1 PMG::RuleDB::MatchField
 180
 181 Match Header Fields