]>
git.proxmox.com Git - pmg-api.git/blob - bin/pmgpolicy
6 use POSIX
qw(errno_h signal_h);
8 use Net
::Server
::PreForkSimple
;
9 use Net
::DNS
::Resolver
;
14 use Time
::HiRes
qw(gettimeofday);
25 use PMG
::ClusterConfig
;
27 use base
qw(Net::Server::PreForkSimple);
29 my $greylist_delay = 3*60; # greylist window
30 my $greylist_lifetime = 3600*24*2; # retry window
31 my $greylist_awlifetime = 3600*24*36; # expire window
33 my $opt_commandline = [$0, @ARGV];
34 my $opt_policy_port = 10022;
35 my $opt_max_dequeue = 1;
36 my $opt_dequeue_time = 60*2;
42 if (!GetOptions
('pidfile=s' => \
$opt_pidfile,
43 'testmode' => \
$opt_testmode,
44 'database=s' => \
$opt_database)) {
49 $opt_pidfile = "/var/run/pmgpolicy.pid" if !$opt_pidfile;
50 $opt_max_dequeue = 0 if $opt_testmode;
52 initlog
('pmgpolicy', 'mail');
58 my $pmg_cfg = PMG
::Config-
>new ();
59 my $demo = $pmg_cfg->get('admin', 'demo');
60 $max_servers = $pmg_cfg->get('mail', 'max_policy');
63 syslog
('info', 'demo mode detected - not starting server');
69 if (defined ($ENV{BOUND_SOCKETS
})) {
75 port
=> [ $opt_policy_port ],
77 max_servers
=> $max_servers,
78 max_dequeue
=> $opt_max_dequeue,
79 check_for_dequeue
=> $opt_dequeue_time,
81 pid_file
=> $opt_pidfile,
82 commandline
=> $opt_commandline,
83 no_close_by_child
=> 1,
88 if (defined($opt_database)) {
89 $database = $opt_database;
91 $database = "Proxmox_ruledb";
94 $SIG{'__WARN__'} = sub {
98 syslog
('warning', "WARNING: %s", $t);
105 $self->log(2, "starting greylist database maintainance");
107 my ($csec, $usec) = gettimeofday
();
109 my $cinfo = PVE
::INotify
::read_file
("cluster.conf");
110 my $lcid = $cinfo->{local}->{cid
};
111 my $role = $cinfo->{local}->{type
} // '-';
116 $dbh = PMG
::DBTools
::open_ruledb
($database);
121 $self->log(0, PMG
::Utils
::msgquote
("ERROR: $err"));
133 # we do not lock the table here to avoid delays
134 # but that is OK, because we only touch expired records
135 # which do not change nornmally
136 ## $dbh->do ("LOCK TABLE CGreylist IN ROW EXCLUSIVE MODE");
138 # move expired and undelivered records from Greylist to Statistic
142 $rntxt = "AND CID = 0";
144 if ($role eq 'master') {
145 # master is responsible for all non-cluster (deleted) nodes
146 foreach my $rcid (@{$cinfo->{remnodes
}}) {
147 $rntxt .= $rntxt ?
" AND CID != $rcid" : "AND (CID != $rcid";
149 $rntxt .= ")" if $rntxt;
151 $rntxt = "AND (CID = 0 OR CID = $lcid)";
158 my $sth = $dbh->prepare(
159 "SELECT distinct instance, sender FROM CGreylist " .
160 "WHERE passed = 0 AND extime < ? $rntxt");
162 $sth->execute ($now);
165 while (my $ref = $sth->fetchrow_hashref()) {
166 my $sth2 = $dbh->prepare(
167 "SELECT * FROM CGreylist WHERE instance = ? AND sender = ?");
168 $sth2->execute ($ref->{instance
}, $ref->{sender
});
173 while (my $ref2 = $sth2->fetchrow_hashref()) {
174 $rctime = $ref2->{rctime
} if !$rctime;
175 $bc += $ref2->{blocked
};
176 push @rcvrs, $ref2->{receiver
};
181 # hack: sometimes query sth2 does not return anything - maybe a
182 # postgres bug? We simply ignore (when rctime is undefined) it
186 $cmds .= "SELECT nextval ('cstatistic_id_seq');" .
187 "INSERT INTO CStatistic " .
188 "(CID, RID, ID, Time, Bytes, Direction, Spamlevel, VirusInfo, PTime, Sender) VALUES (" .
189 "$lcid, currval ('cstatistic_id_seq'), currval ('cstatistic_id_seq'), ";
191 my $sl = $bc >= 100000 ?
4 : 5;
192 $cmds .= $rctime . ", 0, '1', $sl, NULL, 0, ";
193 $cmds .= $dbh->quote ($ref->{sender
}) . ');';
195 foreach my $r (@rcvrs) {
196 my $tmp = $dbh->quote ($r);
197 $cmds .= "INSERT INTO CReceivers (CStatistic_CID, CStatistic_RID, Receiver, Blocked) ".
198 "VALUES ($lcid, currval ('cstatistic_id_seq'), $tmp, '1'); ";
202 if (length ($cmds) > 100000) {
209 # this produces too much log traffic
210 # my $targets = join (", ", @rcvrs);
211 #my $msg = "expire mail $ref->{instance} from $ref->{sender} to $targets";
212 #$self->log (0, PMG::Utils::msgquote ($msg));
215 $dbh->do ($cmds) if $cmds;
220 my $msg = "found $ecount expired mails in greylisting database";
221 $self->log (0, $msg);
224 $dbh->do ("DELETE FROM CGreylist WHERE extime < $now");
231 my ($csec_end, $usec_end) = gettimeofday
();
232 my $ptime = int (($csec_end-$csec)*1000 + ($usec_end - $usec)/1000);
235 $dbh->rollback if $dbh;
236 $self->log(0, PMG
::Utils
::msgquote
($err));
238 $self->log(2, "end greylist database maintainance ($ptime ms)");
241 $dbh->disconnect() if $dbh;
247 my $prop = $self->{server
};
249 $prop->{log_level
} = 3;
251 $self->log(0, "Policy daemon (re)started");
254 # reloading server configuration
255 if (defined $prop->{children
}) {
256 foreach my $pid (keys %{$prop->{children
}}) {
257 kill(10, $pid); # SIGUSR1 childs
262 my $sig_set = POSIX
::SigSet-
>new;
263 $sig_set->addset (&POSIX
::SIGHUP
);
264 $sig_set->addset (&POSIX
::SIGCHLD
);
265 my $old_sig_set = POSIX
::SigSet-
>new();
267 sigprocmask
(SIG_UNBLOCK
, $sig_set, $old_sig_set);
273 my $prop = $self->{server
};
275 if ($self->{ruledb
}) {
276 $self->log(0, "reloading configuration $database");
277 $self->{ruledb
}->close();
280 my $pmg_cfg = PMG
::Config-
>new ();
281 $self->{use_rbl
} = $pmg_cfg->get('mail', 'use_rbl');
282 $self->{use_spf
} = $pmg_cfg->get('mail', 'spf');
283 $self->{use_greylist
} = $pmg_cfg->get('mail', 'greylist');
285 my $nodename = PVE
::INotify
::nodename
();
286 my $resolv = PVE
::INotify
::read_file
('resolvconf');
287 my $domain = $resolv->{search
};
288 $self->{fqdn
} = "$nodename.$domain";
290 my $cinfo = PVE
::INotify
::read_file
("cluster.conf");
291 my $lcid = $cinfo->{local}->{cid
};
292 $self->{cinfo
} = $cinfo;
293 $self->{lcid
} = $lcid;
298 $dbh = PMG
::DBTools
::open_ruledb
($database);
299 $self->{ruledb
} = PMG
::RuleDB-
>new($dbh);
300 $self->{rulecache
} = PMG
::RuleCache-
>new($self->{ruledb
});
303 $self->log(0, PMG
::Utils
::msgquote
("ERROR: unable to load database : $err"));
306 $self->{reload_config
} = 0;
309 sub child_init_hook
{
312 my $prop = $self->{server
};
314 $0 = 'pmgpolicy child';
316 setup_fork_signal_mask
(0); # unblocking signals for children
319 $self->load_config();
321 $self->{mux
} = IO
::Multiplex-
>new();
322 $self->{mux
}->set_callback_object($self);
334 # $dnsargs{nameservers} = [ qw (213.129.232.1 213.129.226.2) ];
337 $self->{dns_resolver
} = Net
::DNS
::Resolver-
>new(%dnsargs);
339 $self->{spf_server
} = Mail
::SPF
::Server-
>new(
340 hostname
=> $self->{fqdn
}, dns_resolver
=> $self->{dns_resolver
});
343 $self->log(0, PMG
::Utils
::msgquote
($err));
344 $self->child_finish_hook;
349 $self->{reload_config
} = 1;
353 sub child_finish_hook
{
356 my $prop = $self->{server
};
358 $self->{ruledb
}->close() if $self->{ruledb
};
362 my ($self, $instance, $ip, $helo, $sender) = @_;
369 # we only use helo tests when we have no sender,
370 # helo is sometimes empty, so we cant use SPF helo tests
371 # in that case - strange
372 if ($helo && !$sender) {
375 if (defined ($self->{cache
}->{$instance}) &&
376 defined ($self->{cache
}->{$instance}->{spf_helo_result
})) {
378 $query = $self->{cache
}->{$instance}->{spf_helo_result
};
381 my $request = Mail
::SPF
::Request-
>new(
382 scope
=> 'helo', identity
=> $helo, ip_address
=> $ip);
384 $query = $self->{cache
}->{$instance}->{spf_helo_result
} =
385 $self->{spf_server
}->process ($request);
388 $result = $query->code;
389 $spf_header = $query->received_spf_header;
390 $local_expl = $query->local_explanation;
391 $auth_expl = $query->authority_explanation if $query->is_code('fail');
393 # return if we get a definitive result
394 if ($result eq 'pass' || $result eq 'fail' || $result eq 'temperror') {
395 return ($result, $spf_header, $local_expl, $auth_expl);
403 if (defined ($self->{cache
}->{$instance}) &&
404 defined ($self->{cache
}->{$instance}->{spf_mfrom_result
})) {
406 $query = $self->{cache
}->{$instance}->{spf_mfrom_result
};
410 my $request = Mail
::SPF
::Request-
>new(
411 scope
=> 'mfrom', identity
=> $sender,
412 ip_address
=> $ip, helo_identity
=> $helo);
414 $query = $self->{cache
}->{$instance}->{spf_mfrom_result
} =
415 $self->{spf_server
}->process($request);
418 $result = $query->code;
419 $spf_header = $query->received_spf_header;
420 $local_expl = $query->local_explanation;
421 $auth_expl = $query->authority_explanation if $query->is_code('fail');
423 return ($result, $spf_header, $local_expl, $auth_expl);
430 my ($self, $ip, $receiver) = @_;
432 my ($rdomain) = $receiver =~ /([^@]+)$/;
434 my $dkey = "BKMX:$rdomain";
436 if (defined ($self->{cache
}->{$dkey}) &&
437 ($self->{cache
}->{$dkey}->{status
} == 1)) {
438 return $self->{cache
}->{$dkey}->{$ip};
441 my $resolver = $self->{dns_resolver
};
443 if (my $mx = $resolver->send($rdomain, 'MX')) {
444 $self->{cache
}->{$dkey}->{status
} = 1;
445 my @mxa = grep { $_->type eq 'MX' } $mx->answer;
446 my @mxl = sort { $a->preference <=> $b->preference } @mxa;
447 # shift @mxl; # optionaly skip primary MX ?
448 foreach my $rr (@mxl) {
449 my $a = $resolver->send ($rr->exchange, 'A');
451 foreach my $rra ($a->answer) {
452 if ($rra->type eq 'A') {
453 $self->{cache
}->{$dkey}->{$rra->address} = 1;
459 $self->{cache
}->{$dkey}->{status
} = 0;
462 return $self->{cache
}->{$dkey}->{$ip};
466 my ($self, $ctime, $helo, $ip, $sender, $rcpt, $instance) = @_;
468 my $rulecache = $self->{rulecache
};
470 my $dbh = $self->{ruledb
}->{dbh
};
472 # try to reconnect if database connection is broken
474 $self->log(0, 'Database connection broken - trying to reconnect');
477 $dbh = PMG
::DBTools
::open_ruledb
($database);
481 $self->log(0, PMG
::Utils
::msgquote
("unable to reconnect to database server: $err"));
484 $self->{ruledb
} = PMG
::RuleDB-
>new($dbh);
487 # some sender substitutions
488 my ($user, $domain) = split('@', $sender, 2);
489 if (defined ($user) && defined ($domain)) {
490 # see http://cr.yp.to/proto/verp.txt
491 $user =~ s/\+.*//; # strip extensions (mailing-list VERP)
492 $user =~ s/\b\d+\b/#/g; #replace nubmers in VERP address
493 $sender = "$user\@$domain";
496 if ($self->is_backup_mx($ip, $rcpt)) {
497 $self->log(3, "accept mails from backup MX host - $ip");
501 # greylist exclusion (sender whitelist)
502 if ($rulecache->greylist_match ($sender, $ip)) {
503 $self->log(3, "accept mails from whitelist - $ip");
507 # greylist exclusion (receiver whitelist)
508 if ($rulecache->greylist_match_receiver ($rcpt)) {
509 $self->log(3, "accept mails to whitelist - <$rcpt>");
513 my ($net, $host) = $ip =~ m/(\d+\.\d+\.\d+)\.(\d+)/;
516 if ((!$opt_testmode && $self->{use_spf
}) ||
517 ($opt_testmode && ($rcpt =~ m/^testspf/))) {
526 my ($result, $smtp_comment, $header_comment);
529 $previous_alarm = alarm(10);
530 local $SIG{ALRM
} = sub { die "SPF timeout\n" };
532 ($result, $spf_header, $local_expl, $auth_expl) =
533 $self->get_spf_result($instance, $ip, $helo, $sender);
535 alarm(0); # avoid race condition
539 alarm($previous_alarm) if defined($previous_alarm);
542 $err = $err->text if UNIVERSAL
::isa
($err, 'Mail::SPF::Exception');
543 $self->log (0, PMG
::Utils
::msgquote
($err));
546 if ($result && $result eq 'pass') {
547 $self->log(3, "SPF says $result");
548 $spf_result = $spf_header ?
"prepend $spf_header" : 'dunno';
551 if ($result && $result eq 'fail') {
552 $self->log(3, "SPF says $result");
553 $spf_result = "reject ${auth_expl}";
559 # try to avoid locks everywhere - we use merge instead of insert
560 #$dbh->do ("LOCK TABLE CGreylist IN ROW EXCLUSIVE MODE");
562 # check if there is already a record in the GL database
563 my $sth = $dbh->prepare(
564 "SELECT * FROM CGreylist " .
565 "where IPNet = ? AND Sender = ? AND Receiver = ?");
567 $sth->execute($net, $sender, $rcpt);
568 my $ref = $sth->fetchrow_hashref();
571 # else add an entry to the GL Database with short
572 # expiration time. run_dequeue() moves those entries into the statistic
573 # table later. We set 'blocked' to 100000 to identify those entries.
575 if (!defined($ref->{rctime
})) {
577 $dbh->do("SELECT merge_greylist(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", undef,
578 $net, $host, $sender, $rcpt, $instance,
579 $ctime, $ctime + 10, 0, 100000, 0, $ctime, $self->{lcid
});
586 $self->log(0, PMG
::Utils
::msgquote
($err));
591 return $spf_result if $spf_result;
595 my $res = $spf_header ?
"prepend $spf_header" : 'dunno';
597 return $res if !$self->{use_greylist
};
599 my $defer_res = "defer_if_permit Service is unavailable (try later)";
603 # we dont use alarm here, because it does not work with DBI
607 # try to avoid locks everywhere - we use merge instead of insert
608 #$dbh->do ("LOCK TABLE CGreylist IN ROW EXCLUSIVE MODE");
610 my $sth = $dbh->prepare(
611 "SELECT * FROM CGreylist " .
612 "where IPNet = ? AND Sender = ? AND Receiver = ?");
614 $sth->execute($net, $sender, $rcpt);
616 my $ref = $sth->fetchrow_hashref();
620 if (!defined($ref->{rctime
})) {
622 $dbh->do ("SELECT merge_greylist(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", undef,
623 $net, $host, $sender, $rcpt, $instance,
624 $ctime, $ctime + $greylist_lifetime, 0, 1, 0, $ctime, $self->{lcid
});
627 $self->log(3, "defer greylisted mail");
629 my $age = $ctime - $ref->{rctime
};
631 if ($age < $greylist_delay) {
632 # defer (resent within greylist_delay window)
634 $self->log(3, "defer greylisted mail");
635 $dbh->do("UPDATE CGreylist " .
636 "SET Blocked = Blocked + 1, Host = ?, MTime = ? " .
637 "WHERE IPNet = ? AND Sender = ? AND Receiver = ?", undef,
638 $host, $ctime, $net, $sender, $rcpt);
640 if ($ctime < $ref->{extime
}) {
641 # accept (not expired)
642 my $lifetime = $sender eq "" ?
0 : $greylist_awlifetime;
643 my $delay = $ref->{passed
} ?
"" : "Delay = $age, ";
644 $dbh->do("UPDATE CGreylist " .
645 "SET Passed = Passed + 1, $delay Host = ?, ExTime = ?, MTime = ? " .
646 "WHERE IPNet = ? AND Sender = ? AND Receiver = ?", undef,
647 $host, $ctime + $lifetime, $ctime, $net, $sender, $rcpt);
649 # defer (record is expired)
651 $dbh->do("UPDATE CGreylist " .
652 "SET Host = ?, RCTime = ?, ExTime = ?, MTime = ?, Instance = ?, " .
653 "Blocked = 1, Passed = 0 " .
654 "WHERE IPNet = ? AND Sender = ? AND Receiver = ?", undef,
655 $host, $ctime, $ctime + $greylist_lifetime, $ctime, $instance,
656 $net, $sender, $rcpt);
665 $self->log (0, PMG
::Utils
::msgquote
($err));
671 # shutdown connections: we need this - else file handles are
672 # not closed and we run out of handles
674 my ($self, $mux, $fh) = @_;
676 $mux->shutdown($fh, 1);
680 my ($self, $mux, $fh, $dataref) = @_;
681 my $prop = $self->{server
};
686 $self->load_config() if $self->{reload_config
};
688 while ($$dataref =~ s/^([^\r\n]*)\r?\n//) {
690 next if !defined ($line);
692 if ($line =~ m/([^=]+)=(.*)/) {
693 $attribute->{substr($1, 0, 255)} = substr($2, 0, 255);
694 } elsif ($line eq '') {
699 die "undefined test time :ERROR" if !defined $attribute->{testtime
};
700 $ctime = $attribute->{testtime
};
703 if ($attribute->{instance
} && $attribute->{recipient
} &&
704 $attribute->{client_address
} && $attribute->{request
} &&
705 $attribute->{request
} eq 'smtpd_access_policy') {
709 $res = $self->greylist_value(
711 lc ($attribute->{helo_name
}),
712 lc ($attribute->{client_address
}),
713 lc ($attribute->{sender
}),
714 lc ($attribute->{recipient
}),
715 lc ($attribute->{instance
}));
718 $self->log(0, PMG
::Utils
::msgquote
($err));
722 print $fh "action=$res\n\n";
726 $self->log(0, "greylist policy protocol error - got '%s'", $line);
732 # remove remaining data, if any
733 if ($$dataref ne '') {
734 $self->log(0, "greylist policy protocol error - unused data '%s'", $$dataref);
738 $self->log(0, PMG
::Utils
::msgquote
($err)) if $err;
741 sub restart_close_hook
{
744 my $sig_set = POSIX
::SigSet-
>new;
745 $sig_set->addset(&POSIX
::SIGHUP
);
746 $sig_set->addset(&POSIX
::SIGCHLD
); # to avoid zombies
747 my $old_sig_set = POSIX
::SigSet-
>new();
749 sigprocmask
(SIG_BLOCK
, $sig_set, $old_sig_set);
752 sub pre_server_close_hook
{
755 my $prop = $self->{server
};
757 if (defined $prop->{_HUP
}) {
758 undef $prop->{pid_file_unlink
};
761 if (defined $prop->{children
}) {
762 foreach my $pid (keys %{$prop->{children
}}) {
763 kill(1, $pid); # HUP childs
767 # nicely shutdown childs (give them max 30 seconds to shut down)
768 my $previous_alarm = alarm(30);
770 local $SIG{ALRM
} = sub { die "Timed Out!\n" };
773 1 while ((($pid = waitpid(-1, 0)) > 0) || ($! == EINTR
));
775 alarm(0); # avoid race
777 alarm ($previous_alarm);
780 sub setup_fork_signal_mask
{
783 my $sig_set = POSIX
::SigSet-
>new;
784 $sig_set->addset(&POSIX
::SIGINT
);
785 $sig_set->addset(&POSIX
::SIGTERM
);
786 $sig_set->addset(&POSIX
::SIGQUIT
);
787 $sig_set->addset(&POSIX
::SIGHUP
);
788 my $old_sig_set = POSIX
::SigSet-
>new();
791 sigprocmask
(SIG_BLOCK
, $sig_set, $old_sig_set);
793 sigprocmask
(SIG_UNBLOCK
, $sig_set, $old_sig_set);
797 # subroutine to start up a specified number of children.
798 # We need to block signals until handlers are set up correctly.
799 # Else its possible that HUP occurs after fork, which triggers
800 # singal TERM at childs and calls server_close() instead of
801 # simply exit the child.
802 # Note: on server startup signals are setup to trigger
803 # asynchronously for a short period of time (in PreForkSimple]::loop,
804 # run_n_children is called before run_parent)
805 # Net::Server::PreFork does not have this problem, because it is using
806 # signal HUP stop children
810 my $prop = $self->{server
};
812 setup_fork_signal_mask
(1); # block signals
814 $self->SUPER::run_n_children
($n);
816 setup_fork_signal_mask
(0); # unblocking signals for parent
819 # test sig_hup with: for ((;;)) ;do kill -HUP `cat /var/run/pmgpolicy.pid`; done;
820 # wrapper to avoid multiple calls to sig_hup
824 my $prop = $self->{server
};
826 return if defined($prop->{_HUP
}); # do not call twice
828 $self->SUPER::sig_hup
();
831 ### child process which will accept on the port
835 my $prop = $self->{server
};
837 $self->log(4, "Child Preforked ($$)\n");
839 # set correct signal handlers before enabling signals again
840 $SIG{INT
} = $SIG{TERM
} = $SIG{QUIT
} = $SIG{HUP
} = sub {
841 $self->child_finish_hook;
845 delete $prop->{children
};
847 $self->child_init_hook;
851 my $sock = $prop->{sock
}->[0];
853 # make sure we got a good sock
854 if (!defined ($sock)){
855 $self->log(0, "ERROR: Received a bad socket");
859 # sometimes the socket is not usable, don't know why
860 my $flags = fcntl($sock, F_GETFL
, 0);
862 $self->log(0, PMG
::Utils
::msgquote
("socket not ready - $!"));
866 # cache is limited, because postfix does max. 100 queries
870 my $mux = $self->{mux
};
871 $mux->listen ($sock);
875 $self->log(0, PMG
::Utils
::msgquote
("ERROR: $err"));
878 $self->child_finish_hook;
892 my ($self, $level, $msg, @therest) = @_;
894 my $prop = $self->{server
};
896 return if $level =~ /^\d+$/ && $level > $prop->{log_level
};
898 $level = $syslog_map->{$level} || $level;
900 syslog
($level, $msg, @therest);
902 syslog
($level, $msg);
907 server
=> $server_attr,
910 $server->sig_chld(); # avoid zombies after restart
920 pmgpolicy - The Proxmox policy daemon
928 Documentation is available at www.proxmox.com