Nachdem aus dem OTRS in der Nacht 25.000 E-Mails versand wurden, hatte uns unser Provider vorübergehend auf seinen Relay Servern blacklistet.
Um solche nächtliche Überraschungen künftig zu vermeiden, habe ich einen Policy Server für Postfix geschrieben. Dieser wird auf dem ausgehenden Mail Relay eingebunden und gibt nach 750 E-Mails pro Stunde dem Exchange DEFER zurück gibt, worauf dieser die Mails in seiner Queue behält.

Der Policy Server liest aus der Datei /tmp/postfix-counter den aktuellen Count und den Timestamp des letzten Counterreset. Ist der Timestamp älter als eine Stunde, wird der Counter auf 1 gesetzt, sonst um 1 erhöht und wieder in die Datei zurückgeschrieben.

Zur Überwachung habe ich einen einfachen Nagios Check geschrieben, welcher den Counter ausliest, die Anzahl Mails prüft und als Performancedaten ausgibt. Die enstandenen PNP Graphen sehen dann wie Sägezähne aus.

Im Postfix wird das Ganze in der main.cf eingebunden.

smtpd_recipient_restrictions = permit_mynetworks check_policy_service inet:127.0.0.1:8895 reject_unauth_destination

#! /usr/bin/perl -W
# based on sample from Postfix Page

use strict;
use Errno;
use IO::Select;
use IO::File;

my $fds;
my $flog;
my $conffile;
my %times = ();
my $maxcount = 750; # max mail per hour

sub init_sockets;

# initialize anything (database etc)
sub init() {
  $fds = IO::Select->new() or die "unable to create IO::Select object\n";
  init_sockets('inet:127.0.0.1:8895');
  use IO::File;
  $flog = IO::File->new("/tmp/smtpd-policy.log", 'a');
}

init();

sub request($;$) {
  my ($attr,$sock) = @_;
  my $act = 'DUNNO';
  my $now = time;

  open(FILE, "/tmp/postfix-counter");

  while(<FILE>){
    chomp($_);
    my ($key, $val) = split(/:/, $_);
      $times{$key} = $val;
    }

  close(FILE);  

  if ($times{'1htime'} + 3600 > $now){
    if ($times{'1hcount'} < $maxcount){
      my $tmp = $times{'1hcount'};
      $tmp = $tmp + 1;
      $times{'1hcount'} = $tmp;
      $act = 'OK';
      $times{'now'} = $now;
    }else{
      $act = 'DEFER to many mail';
      $times{'now'} = $now;
    }
  }else{
    $times{'1htime'} = $now;
    $times{'1hcount'} = 1;
    $act = 'OK';
    $times{'now'} = $now;
  }

  open(FILE, ">/tmp/postfix-counter");
  for my $key ( keys %times ) {
    my $value = $times{$key};
    print FILE "$key:$value\n";
  }

  close(FILE);

  if (defined $flog) {
    $flog->print("request:");
    $flog->print(" $_=$attr->{$_}") foreach keys %$attr;
    $flog->print(" action=$act\n");
    $flog->flush;
  }
  $act;
}

sub request_cb($) {
  my $s = shift;
  my $r = ${*$s}{attrs} || ( ${*$s}{attrs} = {} );
  for(;;) {
    $_ = $s->getline;
    unless (defined $_) {
      $fds->remove($s) unless $!{EAGAIN};
      return;
    }
    if (/^([a-zA-Z_]+)=([^\r\n]*)\r?\n$/) { $r->{$1} = $2; }
    elsif (/^\r?\n$/) { last; }
    else { $r->{error} = 1; }
  }
  ${*$s}{attrs} = undef;
  my $act;
  if ($r->{error}) { $act = 'ERROR unknown request line'; }
  elsif (!exists($r->{request}) ||
         $r->{request} ne 'smtpd_access_policy') {
    $act = 'ERROR required request attribute is not present';
  }
  else {
    $act = request($r);
    unless (defined $act) {
      $fds->remove($s);
      return;
    }
  }
  $s->print("action=$act\n\n") or $fds->remove($s);
}

sub accept_cb($) {
  my $ls = shift;
  my $s = $ls->accept;
  if ($s) {
    $s->blocking(0);
    ${*$s}{cb} = \&request_cb;
    $fds->add($s);
  }
}

sub init_sockets {
  foreach my $sock ( @_ ) {
    my $s;
    if ($sock =~ /^inet:([^:]+:.+)$/i) {
      use IO::Socket::INET;
      $s = IO::Socket::INET->new(
        LocalAddr => $1,
        Proto => 'tcp',
        Type => SOCK_STREAM,
        Listen => 5,
        ReuseAddr => 1,
      );
    }
    elsif ($sock =~ /^unix:(.+)$/) {
      use IO::Socket::UNIX;
      unlink $1;
      $s = IO::Socket::UNIX->new(
        Type => SOCK_STREAM,
        Local => $1,
        Listen => 5,
      );
    }
    else {
      die "invalid listening point specification: $sock\n";
    }
    die "unable to create listening socket for $sock: $!\n" unless $s;
    $s->blocking(0);
    ${*$s}{cb} = \&accept_cb;
    $fds->add($s);
  }
}

for(;;) {
  foreach my $s ( $fds->can_read() ) {
    &{${*$s}{cb}}($s);
  }
}

zur Statistischen Erfassung war auf dem alten Mailserver „mailgraph“ installiert. Das Problem für mich war, das ich die Daten nicht brauchbar ins Nagios bekommen habe (check_rrd etc).
Die Lösung: Das Maillog mit check_logfile parsen und das Ergebniss als Performance Daten für Nagios ausgeben.

Aufruf von check_logfile in der nrpe.cfg:
command[check_mailflow]=sudo /usr/lib/nagios/plugins/check_logfiles -f /etc/nagios-plugins/config/logfile.cfg
In der logfile.cfg sind die Parser für

• recive – Mail an den Exchange weitergeleitet
• bounce – allgemeine Bounces
• block – durch RBL geblocke Mails
• block-nouser – wegen ungültiger Benutzer geblockte Mail

our $sendcount = 0;
our $bouncecount = 0;
our $blockcount = 0;
our $nousercount = 0;

@searches = ({
tag => 'postfix',
logfile => '/var/log/mail.log',
rotation => 'loglogdate8gz',
options => 'supersmartscript,noprotocol,supersmartpostscript',
criticalpatterns => '.*',
script => sub {

if ( $ENV{CHECK_LOGFILES_SERVICEOUTPUT} =~ /\bstatus=sent\b/){
if ( $ENV{CHECK_LOGFILES_SERVICEOUTPUT} !~ /\brelay=[^\s\[]*\[127\.0\.0\.1\]/ ){
$sendcount++;
}
}

if ( $ENV{CHECK_LOGFILES_SERVICEOUTPUT} =~ /\bstatus=bounced\b/) {
$bouncecount++;

}

if ( $ENV{CHECK_LOGFILES_SERVICEOUTPUT} =~ /\b.*NOQUEUE: .*reject: .*: 554.* blocked using\b/) {
$blockcount++;

}

if ( $ENV{CHECK_LOGFILES_SERVICEOUTPUT} =~ /\b.*NOQUEUE: .*reject: .*: 550.* Recipient address rejected\b/) {
$nousercount++;

}

},

});
$options = 'supersmartpostscript';

$postscript = sub {
my $tic = $CHECK_LOGFILES_PRIVATESTATE->{postfix}->{lastruntime} || 0;
my $tac = time;
my $runtime = ($tac - $tic);

my $sendrate = 60 * ( $sendcount / $runtime );

printf "OK - recive: %.1f bounce: %.1f block: %.1f block-nouser: %.1f | recive=%.1f;bounce=%.1f;block=%.1f;block-nouser=%.1f\n", $sendra
te, $bouncecount, $blockcount, $nousercount, $sendrate, $bouncecount, $blockcount, $nousercount;

return 0;