PMG/RuleDB.pm

   1 package PMG::RuleDB;
   2
   3 use strict;
   4 use warnings;
   5 use DBI;
   6 use HTML::Entities;
   7 use Data::Dumper;
   8
   9 use PVE::SafeSyslog;
  10
  11 use PMG::Utils;
  12 use PMG::DBTools;
  13
  14 use PMG::RuleDB::Group;
  15
  16 #use Proxmox::Statistic;
  17 use PMG::RuleDB::Object;
  18 use PMG::RuleDB::WhoRegex;
  19 use PMG::RuleDB::ReceiverRegex;
  20 use PMG::RuleDB::EMail;
  21 use PMG::RuleDB::Receiver;
  22 use PMG::RuleDB::IPAddress;
  23 use PMG::RuleDB::IPNet;
  24 use PMG::RuleDB::Domain;
  25 use PMG::RuleDB::ReceiverDomain;
  26 # fixme:
  27 #use Proxmox::RuleDB::LDAP;
  28 #use Proxmox::RuleDB::LDAPUser;
  29 use PMG::RuleDB::TimeFrame;
  30 use PMG::RuleDB::Spam;
  31 use PMG::RuleDB::ReportSpam;
  32 use PMG::RuleDB::Virus;
  33 use PMG::RuleDB::Accept;
  34 use PMG::RuleDB::Remove;
  35 use PMG::RuleDB::ModField;
  36 use PMG::RuleDB::MatchField;
  37 use PMG::RuleDB::MatchFilename;
  38 use PMG::RuleDB::Attach;
  39 use PMG::RuleDB::Disclaimer;
  40 use PMG::RuleDB::BCC;
  41 use PMG::RuleDB::Quarantine;
  42 use PMG::RuleDB::Block;
  43 use PMG::RuleDB::Counter;
  44 use PMG::RuleDB::Notify;
  45 use PMG::RuleDB::Rule;
  46 use PMG::RuleDB::ContentTypeFilter;
  47 use PMG::RuleDB::ArchiveFilter;
  48
  49 sub new {
  50     my ($type, $dbh) = @_;
  51
  52     $dbh = PMG::DBTools::open_ruledb("Proxmox_ruledb")  if !defined ($dbh);
  53
  54     my $self = bless { dbh => $dbh }, $type;
  55
  56     return $self;
  57 }
  58
  59 sub close {
  60     my ($self) = @_;
  61
  62     $self->{dbh}->disconnect();
  63 }
  64
  65 sub create_group_with_obj {
  66     my ($self, $obj, $name, $info) = @_;
  67
  68     my $og;
  69     my $id;
  70
  71     defined($obj) || die "proxmox: undefined object";
  72
  73     $name //= '';
  74     $info //= '';
  75
  76     eval {
  77
  78         $self->{dbh}->begin_work;
  79
  80         $self->{dbh}->do("INSERT INTO Objectgroup (Name, Info, Class) " .
  81                          "VALUES (?, ?, ?)", undef,
  82                          $name, $info, $obj->oclass());
  83
  84         my $lid = PMG::Utils::lastid($self->{dbh}, 'objectgroup_id_seq');
  85
  86         $og = PMG::RuleDB::Group->new($name, $info, $obj->oclass());
  87         $og->{id} = $lid;
  88
  89         $obj->{ogroup} = $lid;
  90         $id = $obj->save($self, 1);
  91         $obj->{id} = $id; # just to be sure
  92
  93         $self->{dbh}->commit;
  94     };
  95     if (my $err = $@) {
  96         $self->{dbh}->rollback;
  97         die $err;
  98     }
  99     return $og;
 100 }
 101
 102 sub load_groups {
 103     my ($self, $rule) = @_;
 104
 105     defined($rule->{id}) || die "undefined rule id: ERROR";
 106
 107     my $sth = $self->{dbh}->prepare(
 108         "SELECT RuleGroup.Grouptype, Objectgroup.ID, " .
 109         "Objectgroup.Name, Objectgroup.Info " .
 110         "FROM Rulegroup, Objectgroup " .
 111         "WHERE Rulegroup.Rule_ID = ? and " .
 112         "Rulegroup.Objectgroup_ID = Objectgroup.ID " .
 113         "ORDER BY RuleGroup.Grouptype");
 114
 115     my $groups = ();
 116
 117     $sth->execute($rule->{id});
 118
 119     my ($from, $to, $when, $what, $action) = ((), (), (), (), ());
 120
 121     while (my $ref = $sth->fetchrow_hashref()) {
 122         my $og = PMG::RuleDB::Group->new($ref->{name}, $ref->{info});
 123         $og->{id} = $ref->{id};
 124
 125         if ($ref->{'grouptype'} == 0) {      #from
 126             push @$from, $og;
 127         } elsif ($ref->{'grouptype'} == 1) { # to
 128             push @$to, $og;
 129         } elsif ($ref->{'grouptype'} == 2) { # when
 130             push @$when, $og;
 131         } elsif ($ref->{'grouptype'} == 3) { # what
 132             push @$what, $og;
 133         } elsif ($ref->{'grouptype'} == 4) { # action
 134             my $objects = $self->load_group_objects($og->{id});
 135             my $obj = @$objects[0];
 136             defined($obj) || die "undefined action object: ERROR";
 137             $og->{action} = $obj;
 138             push @$action, $og;
 139         }
 140     }
 141
 142     $sth->finish();
 143
 144     return ($from, $to, $when, $what, $action);
 145 }
 146
 147 sub save_group {
 148     my ($self, $og) = @_;
 149
 150     defined($og->{name}) ||
 151         die "undefined group attribute - name: ERROR";
 152     defined($og->{info}) ||
 153         die "undefined group attribute - info: ERROR";
 154     defined($og->{class}) ||
 155         die "undefined group attribute - class: ERROR";
 156
 157     if (defined($og->{id})) {
 158
 159         $self->{dbh}->do("UPDATE Objectgroup " .
 160                          "SET Name = ?, Info = ? " .
 161                          "WHERE ID = ?", undef,
 162                          $og->{name}, $og->{info}, $og->{id});
 163
 164         return $og->{id};
 165
 166     } else {
 167         my $sth = $self->{dbh}->prepare(
 168             "INSERT INTO Objectgroup (Name, Info, Class) " .
 169             "VALUES (?, ?, ?);");
 170
 171         $sth->execute($og->name, $og->info, $og->class);
 172
 173         return $og->{id} = PMG::Utils::lastid($self->{dbh}, 'objectgroup_id_seq');
 174     }
 175
 176     return undef;
 177 }
 178
 179 sub delete_group {
 180     my ($self, $groupid) = @_;
 181
 182     defined($groupid) || die "undefined group id: ERROR";
 183
 184     eval {
 185
 186         $self->{dbh}->begin_work;
 187
 188         # test if group is used in rules
 189         $self->{dbh}->do("LOCK TABLE RuleGroup IN EXCLUSIVE MODE");
 190
 191         my $sth = $self->{dbh}->prepare(
 192             "SELECT Rule.Name as rulename, ObjectGroup.Name as groupname " .
 193             "FROM RuleGroup, Rule, ObjectGroup WHERE " .
 194             "ObjectGroup.ID = ? AND Objectgroup_ID = ObjectGroup.ID AND " .
 195             "Rule_ID = Rule.ID");
 196
 197         $sth->execute($groupid);
 198
 199         if (my $ref = $sth->fetchrow_hashref()) {
 200             die "Group '$ref->{groupname}' is used by rule '$ref->{rulename}' - unable to delete\n";
 201         }
 202
 203         $sth->finish();
 204
 205         $self->{dbh}->do("DELETE FROM ObjectGroup " .
 206                          "WHERE ID = ?", undef, $groupid);
 207
 208         $self->{dbh}->do("DELETE FROM RuleGroup " .
 209                          "WHERE Objectgroup_ID = ?", undef, $groupid);
 210
 211         $sth = $self->{dbh}->prepare("SELECT * FROM Object " .
 212                                       "where Objectgroup_ID = ?");
 213         $sth->execute($groupid);
 214
 215         while (my $ref = $sth->fetchrow_hashref()) {
 216             $self->{dbh}->do("DELETE FROM Attribut " .
 217                              "WHERE Object_ID = ?", undef, $ref->{id});
 218         }
 219
 220         $sth->finish();
 221
 222         $self->{dbh}->do("DELETE FROM Object " .
 223                          "WHERE Objectgroup_ID = ?", undef, $groupid);
 224
 225         $self->{dbh}->commit;
 226     };
 227     if (my $err = $@) {
 228         $self->{dbh}->rollback;
 229         die $err;
 230     }
 231
 232     return undef;
 233 }
 234
 235 sub load_objectgroups {
 236     my ($self, $class, $id) = @_;
 237
 238     my $sth;
 239
 240     defined($class) || die "undefined object class";
 241
 242     if (!(defined($id))) {
 243         $sth = $self->{dbh}->prepare(
 244             "SELECT * FROM Objectgroup where Class = ? ORDER BY name");
 245         $sth->execute($class);
 246
 247     } else {
 248         $sth = $self->{dbh}->prepare(
 249             "SELECT * FROM Objectgroup where Class like ? and id = ? " .
 250             "order by name");
 251         $sth->execute($class,$id);
 252     }
 253
 254     my $arr_og = ();
 255     while (my $ref = $sth->fetchrow_hashref()) {
 256         my $og = PMG::RuleDB::Group->new($ref->{name}, $ref->{info},
 257                                          $ref->{class});
 258         $og->{id} = $ref->{id};
 259
 260         if ($class eq 'action') {
 261             my $objects = $self->load_group_objects($og->{id});
 262             my $obj = @$objects[0];
 263             defined($obj) || die "undefined action object: ERROR";
 264             $og->{action} = $obj;
 265         }
 266         push @$arr_og, $og;
 267     }
 268
 269     $sth->finish();
 270
 271     return $arr_og;
 272 }
 273
 274 sub get_object {
 275     my ($self, $otype) = @_;
 276
 277      my $obj;
 278
 279     # WHO OBJECTS
 280     if ($otype == PMG::RuleDB::Domain::otype()) {
 281         $obj = PMG::RuleDB::Domain->new();
 282     }
 283     elsif ($otype == PMG::RuleDB::ReceiverDomain::otype) {
 284         $obj = PMG::RuleDB::ReceiverDomain->new();
 285     }
 286     elsif ($otype == PMG::RuleDB::WhoRegex::otype) {
 287         $obj = PMG::RuleDB::WhoRegex->new();
 288     }
 289     elsif ($otype == PMG::RuleDB::ReceiverRegex::otype) {
 290         $obj = PMG::RuleDB::ReceiverRegex->new();
 291     }
 292     elsif ($otype == PMG::RuleDB::EMail::otype) {
 293         $obj = PMG::RuleDB::EMail->new();
 294     }
 295     elsif ($otype == PMG::RuleDB::Receiver::otype) {
 296         $obj = PMG::RuleDB::Receiver->new();
 297     }
 298     elsif ($otype == PMG::RuleDB::IPAddress::otype) {
 299         $obj = PMG::RuleDB::IPAddress->new();
 300     }
 301     elsif ($otype == PMG::RuleDB::IPNet::otype) {
 302         $obj = PMG::RuleDB::IPNet->new();
 303     }
 304 # fixme
 305 #    elsif ($otype == Proxmox::RuleDB::LDAP::otype) {
 306 #       $obj = Proxmox::RuleDB::LDAP->new();
 307 #    }
 308 #    elsif ($otype == Proxmox::RuleDB::LDAPUser::otype) {
 309 #       $obj = Proxmox::RuleDB::LDAPUser->new();
 310 #    }
 311     # WHEN OBJECTS
 312     elsif ($otype == PMG::RuleDB::TimeFrame::otype) {
 313         $obj = PMG::RuleDB::TimeFrame->new();
 314     }
 315     # WHAT OBJECTS
 316     elsif ($otype == PMG::RuleDB::Spam::otype) {
 317         $obj = PMG::RuleDB::Spam->new();
 318     }
 319     elsif ($otype == PMG::RuleDB::Virus::otype) {
 320         $obj = PMG::RuleDB::Virus->new();
 321     }
 322     elsif ($otype == PMG::RuleDB::MatchField::otype) {
 323         $obj = PMG::RuleDB::MatchField->new();
 324     }
 325     elsif ($otype == PMG::RuleDB::MatchFilename::otype) {
 326         $obj = PMG::RuleDB::MatchFilename->new();
 327     }
 328     elsif ($otype == PMG::RuleDB::ContentTypeFilter::otype) {
 329         $obj = PMG::RuleDB::ContentTypeFilter->new();
 330     }
 331     elsif ($otype == PMG::RuleDB::ArchiveFilter::otype) {
 332         $obj = PMG::RuleDB::ArchiveFilter->new();
 333     }
 334     # ACTION OBJECTS
 335     elsif ($otype == PMG::RuleDB::ModField::otype) {
 336         $obj = PMG::RuleDB::ModField->new();
 337     }
 338     elsif ($otype == PMG::RuleDB::Accept::otype()) {
 339         $obj = PMG::RuleDB::Accept->new();
 340     }
 341     elsif ($otype == PMG::RuleDB::ReportSpam::otype()) {
 342         $obj = PMG::RuleDB::ReportSpam->new();
 343     }
 344     elsif ($otype == PMG::RuleDB::Attach::otype) {
 345         $obj = PMG::RuleDB::Attach->new();
 346     }
 347     elsif ($otype == PMG::RuleDB::Disclaimer::otype) {
 348         $obj = PMG::RuleDB::Disclaimer->new();
 349     }
 350     elsif ($otype == PMG::RuleDB::BCC::otype) {
 351         $obj = PMG::RuleDB::BCC->new();
 352     }
 353     elsif ($otype == PMG::RuleDB::Quarantine::otype) {
 354         $obj = PMG::RuleDB::Quarantine->new();
 355     }
 356     elsif ($otype == PMG::RuleDB::Block::otype) {
 357         $obj = PMG::RuleDB::Block->new();
 358     }
 359     elsif ($otype == PMG::RuleDB::Counter::otype) {
 360         $obj = PMG::RuleDB::Counter->new();
 361     }
 362     elsif ($otype == PMG::RuleDB::Remove::otype) {
 363         $obj = PMG::RuleDB::Remove->new();
 364     }
 365     elsif ($otype == PMG::RuleDB::Notify::otype) {
 366         $obj = PMG::RuleDB::Notify->new();
 367     }
 368     else {
 369             die "proxmox: unknown object type: ERROR";
 370     }
 371
 372     return $obj;
 373 }
 374
 375 sub load_counters_data {
 376     my ($self) = @_;
 377
 378     my $sth = $self->{dbh}->prepare(
 379         "SELECT Object.id, Objectgroup.name, Object.Value, Objectgroup.info " .
 380         "FROM Object, Objectgroup " .
 381         "WHERE objectgroup.id = object.objectgroup_id and ObjectType = ? " .
 382         "order by Objectgroup.name, Value");
 383
 384     my @data;
 385
 386     $sth->execute(PMG::RuleDB::Counter->otype());
 387
 388     while (my $ref = $sth->fetchrow_hashref()) {
 389         my $tmp = [$ref->{id},$ref->{name},$ref->{value},$ref->{info}];
 390         push (@data, $tmp);
 391     }
 392
 393     $sth->finish();
 394
 395     return @data;
 396 }
 397
 398 sub load_object {
 399     my ($self, $objid) = @_;
 400
 401     my $value = '';
 402
 403     defined($objid) || die "undefined object id";
 404
 405     my $sth = $self->{dbh}->prepare("SELECT * FROM Object where ID = ?");
 406     $sth->execute($objid);
 407
 408     my $ref = $sth->fetchrow_hashref();
 409
 410     $sth->finish();
 411
 412     if (defined($ref->{'value'})) {
 413         $value = $ref->{'value'};
 414     }
 415
 416     if (!(defined($ref->{'objecttype'}) &&
 417           defined($ref->{'objectgroup_id'}))) {
 418         return undef;
 419     }
 420
 421     my $ogroup = $ref->{'objectgroup_id'};
 422
 423     my $otype = $ref->{'objecttype'};
 424     my $obj = $self->get_object($otype);
 425
 426     $obj->load_attr($self, $objid, $ogroup, $value);
 427 }
 428
 429 sub load_object_full {
 430     my ($self, $id, $gid, $exp_otype) = @_;
 431
 432     my $obj = $self->load_object($id);
 433     die "object '$id' does not exists\n" if !defined($obj);
 434
 435     my $otype = $obj->otype();
 436     die "wrong object type ($otype != $exp_otype)\n"
 437         if defined($exp_otype) && $otype != $exp_otype;
 438
 439     die "wrong object group ($obj->{ogroup} != $gid)\n"
 440         if $obj->{ogroup} != $gid;
 441
 442     return $obj;
 443 }
 444
 445 sub load_group_by_name {
 446     my ($self, $name) = @_;
 447
 448     my $sth = $self->{dbh}->prepare("SELECT * FROM Objectgroup " .
 449                                     "WHERE name = ?");
 450
 451     $sth->execute($name);
 452
 453     while (my $ref = $sth->fetchrow_hashref()) {
 454         my $og = PMG::RuleDB::Group->new($ref->{name}, $ref->{info},
 455                                          $ref->{class});
 456         $og->{id} = $ref->{id};
 457
 458         $sth->finish();
 459
 460         if ($ref->{'class'} eq 'action') {
 461             my $objects = $self->load_group_objects($og->{id});
 462             my $obj = @$objects[0];
 463             defined($obj) || die "undefined action object: ERROR";
 464             $og->{action} = $obj;
 465         }
 466
 467         return $og;
 468     }
 469
 470     $sth->finish();
 471
 472     return undef;
 473 }
 474
 475 sub greylistexclusion_groupid {
 476     my ($self) = @_;
 477
 478     my $sth = $self->{dbh}->prepare(
 479         "select id from objectgroup where class='greylist' limit 1;");
 480
 481     $sth->execute();
 482
 483     my $ref = $sth->fetchrow_hashref();
 484
 485     return $ref->{id};
 486 }
 487
 488 sub load_group_objects {
 489     my ($self, $ogid) = @_;
 490
 491     defined($ogid) || die "undefined group id: ERROR";
 492
 493     my $sth = $self->{dbh}->prepare(
 494         "SELECT * FROM Object " .
 495         "WHERE Objectgroup_ID = ? order by ObjectType,Value");
 496
 497     my $objects = ();
 498
 499     $sth->execute($ogid);
 500
 501     while (my $ref = $sth->fetchrow_hashref()) {
 502         my $obj = $self->load_object($ref->{id});
 503         push @$objects, $obj;
 504     }
 505
 506     $sth->finish();
 507
 508     return $objects;
 509 }
 510
 511
 512 sub save_object {
 513     my ($self, $obj) = @_;
 514
 515     $obj->save($self);
 516
 517     return $obj->{id};
 518 }
 519
 520 sub group_add_object {
 521     my ($self, $group, $obj) = @_;
 522
 523     ($obj->oclass() eq $group->{class}) ||
 524         die "wrong object class: ERROR";
 525
 526     $obj->{ogroup} = $group->{id};
 527
 528     $self->save_object($obj);
 529 }
 530
 531 sub delete_object {
 532     my ($self, $obj) = @_;
 533
 534     defined($obj->{id}) || die "undefined object id";
 535
 536     eval {
 537
 538         $self->{dbh}->begin_work;
 539
 540         $self->{dbh}->do("DELETE FROM Attribut " .
 541                           "WHERE Object_ID = ?", undef, $obj->{id});
 542
 543         $self->{dbh}->do("DELETE FROM Object " .
 544                           "WHERE ID = ?",
 545                           undef, $obj->{id});
 546
 547         $self->{dbh}->commit;
 548     };
 549     if (my $err = $@) {
 550         $self->{dbh}->rollback;
 551         syslog('err', $err);
 552         return undef;
 553     }
 554
 555     $obj->{id} = undef;
 556
 557     return 1;
 558 }
 559
 560 sub save_rule {
 561     my ($self, $rule) = @_;
 562
 563     defined($rule->{name}) ||
 564         die "undefined rule attribute - name: ERROR";
 565     defined($rule->{priority}) ||
 566         die "undefined rule attribute - priority: ERROR";
 567     defined($rule->{active}) ||
 568         die "undefined rule attribute - active: ERROR";
 569     defined($rule->{direction}) ||
 570         die "undefined rule attribute - direction: ERROR";
 571
 572     if (defined($rule->{id})) {
 573
 574         $self->{dbh}->do(
 575             "UPDATE Rule " .
 576             "SET Name = ?, Priority = ?, Active = ?, Direction = ? " .
 577             "WHERE ID = ?", undef,
 578             $rule->{name}, $rule->{priority}, $rule->{active},
 579             $rule->{direction}, $rule->{id});
 580
 581         return $rule->{id};
 582
 583     } else {
 584         my $sth = $self->{dbh}->prepare(
 585             "INSERT INTO Rule (Name, Priority, Active, Direction) " .
 586             "VALUES (?, ?, ?, ?);");
 587
 588         $sth->execute($rule->name, $rule->priority, $rule->active,
 589                       $rule->direction);
 590
 591         return $rule->{id} = PMG::Utils::lastid($self->{dbh}, 'rule_id_seq');
 592     }
 593
 594     return undef;
 595 }
 596
 597 sub delete_rule {
 598     my ($self, $ruleid) = @_;
 599
 600     defined($ruleid) || die "undefined rule id: ERROR";
 601
 602     eval {
 603         $self->{dbh}->begin_work;
 604
 605         $self->{dbh}->do("DELETE FROM Rule " .
 606                          "WHERE ID = ?", undef, $ruleid);
 607         $self->{dbh}->do("DELETE FROM RuleGroup " .
 608                          "WHERE Rule_ID = ?", undef, $ruleid);
 609
 610         $self->{dbh}->commit;
 611     };
 612     if (my $err = $@) {
 613         $self->{dbh}->rollback;
 614         syslog('err', $err);
 615         return undef;
 616     }
 617
 618     return 1;
 619 }
 620
 621 sub delete_testrules {
 622     my ($self) = @_;
 623
 624     eval {
 625         $self->{dbh}->begin_work;
 626
 627         my $sth = $self->{dbh}->prepare("Select id FROM Rule " .
 628                                         "WHERE name = 'testrule'");
 629         $sth->execute();
 630
 631         while(my $ref = $sth->fetchrow_hashref()) {
 632             $self->{dbh}->do("DELETE FROM Rule " .
 633                              "WHERE ID = ?", undef, $ref->{id});
 634             $self->{dbh}->do("DELETE FROM RuleGroup " .
 635                              "WHERE Rule_ID = ?", undef, $ref->{id});
 636         }
 637         $sth->finish();
 638
 639         $self->{dbh}->commit;
 640     };
 641     if (my $err = $@) {
 642         $self->{dbh}->rollback;
 643         die $err;
 644     }
 645
 646     return 1;
 647 }
 648
 649 sub rule_add_group {
 650     my ($self, $ruleid, $groupid, $gtype) = @_;
 651
 652     defined($ruleid) || die "undefined rule id: ERROR";
 653     defined($groupid) || die "undefined group id: ERROR";
 654     defined($gtype) || die "undefined group type: ERROR";
 655
 656     $self->{dbh}->do("INSERT INTO RuleGroup " .
 657                      "(Objectgroup_ID, Rule_ID, Grouptype) " .
 658                      "VALUES (?, ?, ?)", undef,
 659                      $groupid, $ruleid, $gtype);
 660     return 1;
 661 }
 662
 663 sub rule_add_from_group {
 664     my ($self, $rule, $group) = @_;
 665
 666     $self->rule_add_group($rule->{id}, $group->{id}, 0);
 667 }
 668
 669 sub rule_add_to_group {
 670     my ($self, $rule, $group) = @_;
 671
 672     $self->rule_add_group($rule->{id}, $group->{id}, 1);
 673 }
 674
 675 sub rule_add_when_group {
 676     my ($self, $rule, $group) = @_;
 677
 678     $self->rule_add_group($rule->{id}, $group->{id}, 2);
 679 }
 680
 681 sub rule_add_what_group {
 682     my ($self, $rule, $group) = @_;
 683
 684     $self->rule_add_group($rule->{id}, $group->{id}, 3);
 685 }
 686
 687 sub rule_add_action {
 688     my ($self, $rule, $group) = @_;
 689
 690     $self->rule_add_group($rule->{id}, $group->{id}, 4);
 691 }
 692
 693 sub rule_remove_group {
 694     my ($self, $ruleid, $groupid, $gtype) = @_;
 695
 696     defined($ruleid) || die "undefined rule id: ERROR";
 697     defined($groupid) || die "undefined group id: ERROR";
 698     defined($gtype) || die "undefined group type: ERROR";
 699
 700     $self->{dbh}->do("DELETE FROM RuleGroup WHERE " .
 701                      "Objectgroup_ID = ? and Rule_ID = ? and Grouptype = ?",
 702                      undef, $groupid, $ruleid, $gtype);
 703     return 1;
 704 }
 705
 706 sub load_rule {
 707     my ($self, $id) = @_;
 708
 709     defined($id) || die "undefined id: ERROR";
 710
 711     my $sth = $self->{dbh}->prepare(
 712         "SELECT * FROM Rule where id = ? ORDER BY Priority DESC");
 713
 714     my $rules = ();
 715
 716     $sth->execute($id);
 717
 718     my $ref = $sth->fetchrow_hashref();
 719     die "rule '$id' does not exist\n" if !defined($ref);
 720
 721     my $rule = PMG::RuleDB::Rule->new($ref->{name}, $ref->{priority},
 722                                       $ref->{active}, $ref->{direction});
 723     $rule->{id} = $ref->{id};
 724
 725     return $rule;
 726 }
 727
 728 sub load_rules {
 729     my ($self) = @_;
 730
 731     my $sth = $self->{dbh}->prepare(
 732         "SELECT * FROM Rule ORDER BY Priority DESC");
 733
 734     my $rules = ();
 735
 736     $sth->execute();
 737
 738     while (my $ref = $sth->fetchrow_hashref()) {
 739         my $rule = PMG::RuleDB::Rule->new($ref->{name}, $ref->{priority},
 740                                           $ref->{active}, $ref->{direction});
 741         $rule->{id} = $ref->{id};
 742         push @$rules, $rule;
 743     }
 744
 745     $sth->finish();
 746
 747     return $rules;
 748 }
 749
 750
 751
 752 1;
 753
 754 __END__
 755
 756 =head1 PMG::RuleDB
 757
 758 The RuleDB Object manages the database connection and provides an interface to manipulate the database without SQL. A typical application first create a RuleDB object:
 759
 760     use PMG::RuleDB;
 761
 762     $ruledb = PMG::RuleDB->new();
 763
 764 =head2 Database Overview
 765
 766 =head3 Rules
 767
 768 Rules contains sets of Groups, grouped by classes (FROM, TO, WHEN, WHAT and ACTION). Each rule has an associated priority and and active/inactive marker.
 769
 770 =head3 Groups
 771
 772 A Group is a set of Objects.
 773
 774 =head3 Objects
 775
 776 Objects contains the filter data.
 777
 778 =head3 Rule Semantics
 779
 780 The classes have 'and' semantics. A rule matches if the checks in FROM, TO, WHEN and WHAT classes returns TRUE.
 781
 782 Within a class the objects are or'ed together.
 783
 784 =head2 Managing Rules
 785
 786 =head3 $ruledb->load_rules()
 787
 788     Returns an array of Rules containing all rules in the database.
 789
 790 =head3 $ruledb->save_rule ($rule)
 791
 792 One can use the following code to add a new rule to the database:
 793
 794     my $rule = PMG::RuleDB::Rule->new ($name, $priority, $active);
 795     $ruledb->save_rule ($rule);
 796
 797 You can also use save_rule() to commit changes back to the database.
 798
 799 =head3 $ruledb->delete_rule ($ruleid)
 800
 801 Removes the rule from the database.
 802
 803 =head3  $ruledb->rule_add_group ($rule, $og, $gtype)
 804
 805 Add an object group to the rule.
 806
 807 Possible values for $gtype are:
 808
 809     0 = FROM, 1 = TO, 2 = WHEN, 3 = WHAT, 4 = ACTION
 810
 811 =head3  $ruledb->rule_remove_group ($rule, $og, $gtype)
 812
 813 Removes an object group from the rule.
 814
 815 =head2 Managing Objects and Groups
 816
 817 =head3 $ruledb->load_groups ($rule)
 818
 819 Return all object groups belonging to a rule. Data is divided into separate arrays:
 820
 821     my ($from, $to, $when, $what, $action) =
 822         $ruledb->load_groups($rule);
 823
 824 =head3 $ruledb->save_group ($og)
 825
 826 This can be used to add or modify an Group. This code segemnt creates
 827 a new object group:
 828
 829     $og = PMG::RuleDB::Group->new ($name, $desc);
 830     $ruledb->save_group ($og);
 831
 832
 833 =head3 $ruledb->delete_group ($groupid)
 834
 835 Deletes the object group, all reference to the group and all objects
 836 belonging to this group from the Database.
 837
 838 =head3 $ruledb->group_add_object ($og, $obj)
 839
 840 Attach an object to an object group.
 841
 842 =head3 $ruledb->save_object ($obj)
 843
 844 Save or update an object. This can be used to add new objects
 845 to the database (although group_add_object() is the prefered way):
 846
 847     $obj =  PMG::RuleDB::EMail->new ('.*@mydomain.com');
 848     # we need to set the object group manually
 849     $obj->ogroup ($group->id);
 850     $ruledb->save_object ($obj);
 851
 852
 853 =head3 $ruledb->delete_object ($obj)
 854
 855 Deletes the object, all references to the object  and all object
 856 attributes from the database.