package Mail::SpamAssassin::Dns;
1;
package Mail::SpamAssassin::PerMsgStatus;
use Mail::SpamAssassin::Conf;
use Mail::SpamAssassin::PerMsgStatus;
use Mail::SpamAssassin::AsyncLoop;
use Mail::SpamAssassin::Constants qw(:ip);
use File::Spec;
use IO::Socket;
use POSIX ":sys_wait_h";
use strict;
use warnings;
use bytes;
use vars qw{
$KNOWN_BAD_DIALUP_RANGES @EXISTING_DOMAINS $IS_DNS_AVAILABLE $LAST_DNS_CHECK $VERSION
};
@EXISTING_DOMAINS = qw{
adelphia.net
akamai.com
apache.org
cingular.com
colorado.edu
comcast.net
doubleclick.com
ebay.com
gmx.net
google.com
intel.com
kernel.org
linux.org
mit.edu
motorola.com
msn.com
sourceforge.net
sun.com
w3.org
yahoo.com
};
$IS_DNS_AVAILABLE = undef;
$VERSION = 'bogus';
BEGIN {
no strict;
local ($^W) = 0;
eval {
require Net::DNS;
require Net::DNS::Resolver;
};
eval {
require MIME::Base64;
};
eval {
require IO::Socket::UNIX;
};
};
sub do_rbl_lookup {
my ($self, $rule, $set, $type, $server, $host, $subtest) = @_;
my $key = "dns:$type:$host";
my $existing = $self->{async}->get_lookup($key);
if (!$existing) {
dbg("dns: launching DNS $type query for $host in background");
my $ent = {
key => $key,
type => "DNSBL-".$type,
sets => [ ], rules => [ ], };
my $id = $self->{resolver}->bgsend($host, $type, undef, sub {
my $pkt = shift;
my $id = shift;
$self->process_dnsbl_result($ent, $pkt);
$self->{async}->report_id_complete($id);
});
$ent->{id} = $id; $existing = $self->{async}->start_lookup($ent);
}
push @{$existing->{sets}}, $set;
if (defined $subtest) {
$self->{dnspost}->{$set}->{$subtest} = $rule;
}
else {
push @{$existing->{rules}}, $rule;
}
$self->{rule_to_rblkey}->{$rule} = $key;
}
sub register_rbl_subtest {
my ($self, $rule, $set, $subtest) = @_;
$self->{dnspost}->{$set}->{$subtest} = $rule;
}
sub do_dns_lookup {
my ($self, $rule, $type, $host) = @_;
my $key = "dns:$type:$host";
return if $self->{async}->get_lookup($key);
dbg("dns: launching DNS $type query for $host in background");
my $ent = {
key => $key,
type => "DNSBL-".$type,
rules => [ $rule ],
};
my $id = $self->{resolver}->bgsend($host, $type, undef, sub {
my $pkt = shift;
my $id = shift;
$self->process_dnsbl_result($ent, $pkt);
$self->{async}->report_id_complete($id);
});
$ent->{id} = $id; $self->{async}->start_lookup($ent);
}
sub dnsbl_hit {
my ($self, $rule, $question, $answer) = @_;
my $log = "";
if (substr($rule, 0, 2) ne "__") {
if ($answer->type eq 'TXT') {
$log = $answer->rdatastr;
$log =~ s/^"(.*)"$/$1/;
$log =~ s/(http:\/\/\S+)/<$1>/g;
}
elsif ($question->string =~ m/^(\d+)\.(\d+)\.(\d+)\.(\d+)\.(\S+\w)/) {
$log = "$4.$3.$2.$1 listed in $5";
}
}
$self->{already_logged} ||= { };
if ($log && !$self->{already_logged}->{$log}) {
$self->test_log($log);
$self->{already_logged}->{$log} = 1;
}
if (!$self->{tests_already_hit}->{$rule}) {
$self->got_hit($rule, "RBL: ", ruletype => "dnsbl");
}
}
sub dnsbl_uri {
my ($self, $question, $answer) = @_;
my $qname = $question->qname;
my $rdatastr = $answer->rdatastr;
if (defined $qname && defined $rdatastr) {
my $qclass = $question->qclass;
my $qtype = $question->qtype;
my @vals;
push(@vals, "class=$qclass") if $qclass ne "IN";
push(@vals, "type=$qtype") if $qtype ne "A";
my $uri = "dns:$qname" . (@vals ? "?" . join(";", @vals) : "");
push @{ $self->{dnsuri}->{$uri} }, $rdatastr;
dbg ("dns: hit <$uri> $rdatastr");
}
}
sub process_dnsbl_result {
my ($self, $query, $packet) = @_;
my $question = ($packet->question)[0];
return if !defined $question;
my $sets = $query->{sets} || [];
my $rules = $query->{rules};
if ($self->{sender_host} &&
$question->qname eq $self->{sender_host} &&
$question->qtype =~ /^(?:A|MX)$/ &&
$packet->header->rcode =~ /^(?:NXDOMAIN|SERVFAIL)$/ &&
++$self->{sender_host_fail} == 2)
{
for my $rule (@{$rules}) {
$self->got_hit($rule, "DNS: ", ruletype => "dns");
}
}
foreach my $answer ($packet->answer) {
next if !defined $answer;
$self->dnsbl_uri($question, $answer);
next if ($answer->type ne 'A' && $answer->type ne 'TXT');
next if ($answer->type eq 'A' && $answer->rdatastr !~ /^127\./);
for my $rule (@{$rules}) {
$self->dnsbl_hit($rule, $question, $answer);
}
for my $set (@{$sets}) {
if ($self->{dnspost}->{$set}) {
$self->process_dnsbl_set($set, $question, $answer);
}
}
}
return 1;
}
sub process_dnsbl_set {
my ($self, $set, $question, $answer) = @_;
my $rdatastr = $answer->rdatastr;
while (my ($subtest, $rule) = each %{ $self->{dnspost}->{$set} }) {
next if $self->{tests_already_hit}->{$rule};
if ($subtest eq $rdatastr) {
$self->dnsbl_hit($rule, $question, $answer);
}
elsif ($subtest =~ s/^sb://) {
if ($self->{conf}->{user_defined_rules}->{$rule}) {
dbg("dns: skipping rule '$rule': not supported when user-defined");
next;
}
$rdatastr =~ s/^"?\d+-//;
$rdatastr =~ s/"$//;
my %sb = ($rdatastr =~ m/(?:^|\|)(\d+)=([^|]+)/g);
my $undef = 0;
while ($subtest =~ m/\bS(\d+)\b/g) {
if (!defined $sb{$1}) {
$undef = 1;
last;
}
$subtest =~ s/\bS(\d+)\b/\$sb{$1}/;
}
$subtest =~ /^(.*)$/;
my $untainted = $1;
$subtest = $untainted;
$self->got_hit($rule, "SenderBase: ", ruletype => "dnsbl") if !$undef && eval $subtest;
}
elsif ($subtest =~ /^\d+$/) {
if ($rdatastr =~ m/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/ &&
Mail::SpamAssassin::Util::my_inet_aton($rdatastr) & $subtest)
{
$self->dnsbl_hit($rule, $question, $answer);
}
}
else {
my $test = qr/$subtest/;
if ($rdatastr =~ /$test/) {
$self->dnsbl_hit($rule, $question, $answer);
}
}
}
}
sub harvest_until_rule_completes {
my ($self, $rule) = @_;
return if !defined $self->{async}->get_last_start_lookup_time();
my $deadline = $self->{conf}->{rbl_timeout} + $self->{async}->get_last_start_lookup_time();
my $now = time;
my @left = $self->{async}->get_pending_lookups();
my $total = scalar @left;
while (($now < $deadline) && !$self->{async}->complete_lookups(1))
{
if ($self->is_rule_complete($rule)) {
return 1;
}
$self->{main}->call_plugins ("check_tick", { permsgstatus => $self });
@left = $self->{async}->get_pending_lookups();
my $dynamic = (int($self->{conf}->{rbl_timeout}
* (1 - (($total - scalar @left) / $total) ** 2) + 0.5)
+ $self->{async}->get_last_start_lookup_time());
$deadline = $dynamic if ($dynamic < $deadline);
$now = time;
}
}
sub harvest_dnsbl_queries {
my ($self) = @_;
return if !defined $self->{async}->get_last_start_lookup_time();
my $deadline = $self->{conf}->{rbl_timeout} + $self->{async}->get_last_start_lookup_time();
my $now = time;
my @left = $self->{async}->get_pending_lookups();
my $total = scalar @left;
while (($now < $deadline) && !$self->{async}->complete_lookups(1))
{
$self->{main}->call_plugins ("check_tick", { permsgstatus => $self });
@left = $self->{async}->get_pending_lookups();
my $dynamic = (int($self->{conf}->{rbl_timeout}
* (1 - (($total - scalar @left) / $total) ** 2) + 0.5)
+ $self->{async}->get_last_start_lookup_time());
$deadline = $dynamic if ($dynamic < $deadline);
$now = time; }
dbg("dns: success for " . ($total - @left) . " of $total queries");
@left = $self->{async}->get_pending_lookups();
for my $query (@left) {
my $string = '';
if (defined @{$query->{sets}}) {
$string = join(",", grep defined, @{$query->{sets}});
}
elsif (defined @{$query->{rules}}) {
$string = join(",", grep defined, @{$query->{rules}});
}
my $delay = time - $self->{async}->get_last_start_lookup_time();
dbg("dns: timeout for $string after $delay seconds");
}
$self->{async}->abort_remaining_lookups();
$self->mark_all_async_rules_complete();
}
sub set_rbl_tag_data {
my ($self) = @_;
while (my ($dnsuri, $answers) = each %{ $self->{dnsuri} }) {
$self->{tag_data}->{RBL} .= "<$dnsuri>" .
" [" . join(", ", @{ $answers }) . "]\n";
}
chomp $self->{tag_data}->{RBL} if defined $self->{tag_data}->{RBL};
}
sub rbl_finish {
my ($self) = @_;
$self->set_rbl_tag_data();
delete $self->{dnscache};
delete $self->{dnspost};
delete $self->{dnsuri};
}
sub load_resolver {
my ($self) = @_;
$self->{resolver} = $self->{main}->{resolver};
return $self->{resolver}->load_resolver();
}
sub lookup_ns {
my ($self, $dom) = @_;
return unless $self->load_resolver();
return if ($self->server_failed_to_respond_for_domain ($dom));
my $nsrecords;
dbg("dns: looking up NS for '$dom'");
if (exists $self->{dnscache}->{NS}->{$dom}) {
$nsrecords = $self->{dnscache}->{NS}->{$dom};
} else {
eval {
my $query = $self->{resolver}->send($dom, 'NS');
my @nses = ();
if ($query) {
foreach my $rr ($query->answer) {
if ($rr->type eq "NS") { push (@nses, $rr->nsdname); }
}
}
$nsrecords = $self->{dnscache}->{NS}->{$dom} = [ @nses ];
};
if ($@) {
dbg("dns: NS lookup failed horribly, perhaps bad resolv.conf setting? ($@)");
return undef;
}
}
$nsrecords;
}
sub lookup_mx {
my ($self, $dom) = @_;
return unless $self->load_resolver();
return if ($self->server_failed_to_respond_for_domain ($dom));
my $mxrecords;
dbg("dns: looking up MX for '$dom'");
if (exists $self->{dnscache}->{MX}->{$dom}) {
$mxrecords = $self->{dnscache}->{MX}->{$dom};
} else {
eval {
my $query = $self->{resolver}->send($dom, 'MX');
my @ips = ();
if ($query) {
foreach my $rr ($query->answer) {
if ($rr->type eq "MX") { push (@ips, $rr->exchange); }
}
}
$mxrecords = $self->{dnscache}->{MX}->{$dom} = [ @ips ];
};
if ($@) {
dbg("dns: MX lookup failed horribly, perhaps bad resolv.conf setting? ($@)");
return undef;
}
}
$mxrecords;
}
sub lookup_mx_exists {
my ($self, $dom) = @_;
my $ret = 0;
my $recs = $self->lookup_mx ($dom);
if (!defined $recs) { return undef; }
if (scalar @{$recs}) { $ret = 1; }
dbg("dns: MX for '$dom' exists? $ret");
return $ret;
}
sub lookup_ptr {
my ($self, $dom) = @_;
return undef unless $self->load_resolver();
if ($self->{main}->{local_tests_only}) {
dbg("dns: local tests only, not looking up PTR");
return undef;
}
my $IP_PRIVATE = IP_PRIVATE;
if ($dom =~ /${IP_PRIVATE}/) {
dbg("dns: IP is private, not looking up PTR: $dom");
return undef;
}
return if ($self->server_failed_to_respond_for_domain ($dom));
dbg("dns: looking up PTR record for '$dom'");
my $name = '';
if (exists $self->{dnscache}->{PTR}->{$dom}) {
$name = $self->{dnscache}->{PTR}->{$dom};
} else {
eval {
my $query = $self->{resolver}->send($dom);
if ($query) {
foreach my $rr ($query->answer) {
if ($rr->type eq "PTR") {
$name = $rr->ptrdname; last;
}
}
}
$name = $self->{dnscache}->{PTR}->{$dom} = $name;
};
if ($@) {
dbg("dns: PTR lookup failed horribly, perhaps bad resolv.conf setting? ($@)");
return undef;
}
}
dbg("dns: PTR for '$dom': '$name'");
return $name;
}
sub lookup_a {
my ($self, $name) = @_;
return undef unless $self->load_resolver();
if ($self->{main}->{local_tests_only}) {
dbg("dns: local tests only, not looking up A records");
return undef;
}
return if ($self->server_failed_to_respond_for_domain ($name));
dbg("dns: looking up A records for '$name'");
my @addrs = ();
if (exists $self->{dnscache}->{A}->{$name}) {
my $addrptr = $self->{dnscache}->{A}->{$name};
@addrs = @{$addrptr};
} else {
eval {
my $query = $self->{resolver}->send($name);
if ($query) {
foreach my $rr ($query->answer) {
if ($rr->type eq "A") {
push (@addrs, $rr->address);
}
}
}
$self->{dnscache}->{A}->{$name} = [ @addrs ];
};
if ($@) {
dbg("dns: A lookup failed horribly, perhaps bad resolv.conf setting? ($@)");
return undef;
}
}
dbg("dns: A records for '$name': ".join (' ', @addrs));
return @addrs;
}
sub is_dns_available {
my ($self) = @_;
my $dnsopt = $self->{conf}->{dns_available};
my $dnsint = $self->{conf}->{dns_test_interval} || 600;
my @domains;
$LAST_DNS_CHECK ||= 0;
my $diff = time() - $LAST_DNS_CHECK;
if ($dnsopt eq "test" && $diff > $dnsint) {
$IS_DNS_AVAILABLE = undef;
dbg("dns: is_dns_available() last checked $diff seconds ago; re-checking");
}
return $IS_DNS_AVAILABLE if (defined $IS_DNS_AVAILABLE);
$LAST_DNS_CHECK = time();
$IS_DNS_AVAILABLE = 0;
if ($dnsopt eq "no") {
dbg("dns: dns_available set to no in config file, skipping test");
return $IS_DNS_AVAILABLE;
}
goto done if ($self->{main}->{local_tests_only});
if ($dnsopt eq "yes") {
$IS_DNS_AVAILABLE = 1;
dbg("dns: dns_available set to yes in config file, skipping test");
return $IS_DNS_AVAILABLE;
}
if (defined $Net::DNS::VERSION) {
if (Mail::SpamAssassin::Util::am_running_on_windows()) {
if ($Net::DNS::VERSION < 0.46) {
warn("dns: Net::DNS version is $Net::DNS::VERSION, but need 0.46 for Win32");
return $IS_DNS_AVAILABLE;
}
}
else {
if ($Net::DNS::VERSION < 0.34) {
warn("dns: Net::DNS version is $Net::DNS::VERSION, but need 0.34");
return $IS_DNS_AVAILABLE;
}
}
}
goto done unless $self->load_resolver();
if ($dnsopt =~ /test:\s+(.+)$/) {
my $servers=$1;
dbg("dns: servers: $servers");
@domains = split (/\s+/, $servers);
dbg("dns: looking up NS records for user specified servers: ".join(", ", @domains));
} else {
@domains = @EXISTING_DOMAINS;
}
my @nameservers = $self->{resolver}->nameservers();
dbg("dns: testing resolver nameservers: ".join(", ", @nameservers));
my $ns;
while( $ns = shift(@nameservers)) {
for(my $retry = 3; $retry > 0 and $ my $domain = splice(@domains, rand(@domains), 1);
dbg("dns: trying ($retry) $domain...");
my $result = $self->lookup_ns($domain);
if(defined $result) {
if (scalar @$result > 0) {
dbg("dns: NS lookup of $domain using $ns succeeded => DNS available (set dns_available to override)");
$IS_DNS_AVAILABLE = 1;
last;
}
else {
dbg("dns: NS lookup of $domain using $ns failed, no results found");
next;
}
}
else {
dbg("dns: NS lookup of $domain using $ns failed horribly, may not be a valid nameserver");
$IS_DNS_AVAILABLE = 0; last;
}
}
last if $IS_DNS_AVAILABLE;
dbg("dns: NS lookups failed, removing nameserver $ns from list");
$self->{resolver}->nameservers(@nameservers);
$self->{resolver}->connect_sock(); }
dbg("dns: all NS queries failed => DNS unavailable (set dns_available to override)") if ($IS_DNS_AVAILABLE == 0);
done:
dbg("dns: is DNS available? $IS_DNS_AVAILABLE");
return $IS_DNS_AVAILABLE;
}
sub server_failed_to_respond_for_domain {
my ($self, $dom) = @_;
if ($self->{dns_server_too_slow}->{$dom}) {
dbg("dns: server for '$dom' failed to reply previously, not asking again");
return 1;
}
return 0;
}
sub set_server_failed_to_respond_for_domain {
my ($self, $dom) = @_;
dbg("dns: server for '$dom' failed to reply, marking as bad");
$self->{dns_server_too_slow}->{$dom} = 1;
}
sub enter_helper_run_mode {
my ($self) = @_;
dbg("info: entering helper-app run mode");
$self->{old_slash} = $/; %{$self->{old_env}} = ();
if ( defined %ENV ) {
while (my ($key, $value) = each %ENV) {
$self->{old_env}->{$key} = $value if defined $value;
}
}
Mail::SpamAssassin::Util::clean_path_in_taint_mode();
my $newhome;
if ($self->{main}->{home_dir_for_helpers}) {
$newhome = $self->{main}->{home_dir_for_helpers};
} else {
$newhome = (Mail::SpamAssassin::Util::portable_getpwuid ($>))[7];
}
if ($newhome) {
$ENV{'HOME'} = Mail::SpamAssassin::Util::untaint_file_path ($newhome);
}
$self->{old_sigchld_handler} = $SIG{CHLD};
$SIG{CHLD} = 'DEFAULT';
}
sub leave_helper_run_mode {
my ($self) = @_;
dbg("info: leaving helper-app run mode");
$/ = $self->{old_slash};
%ENV = %{$self->{old_env}};
if (defined $self->{old_sigchld_handler}) {
$SIG{CHLD} = $self->{old_sigchld_handler};
} else {
$SIG{CHLD} = 'DEFAULT';
}
}
sub cleanup_kids {
my ($self, $pid) = @_;
if ($SIG{CHLD} && $SIG{CHLD} ne 'IGNORE') { waitpid ($pid, 0);
}
}
sub register_async_rule_start {
my ($self, $rule) = @_;
dbg ("dns: $rule lookup start");
$self->{rule_to_rblkey}->{$rule} = '*ASYNC_START';
}
sub register_async_rule_finish {
my ($self, $rule) = @_;
dbg ("dns: $rule lookup finished");
delete $self->{rule_to_rblkey}->{$rule};
}
sub mark_all_async_rules_complete {
my ($self) = @_;
$self->{rule_to_rblkey} = { };
}
sub is_rule_complete {
my ($self, $rule) = @_;
my $key = $self->{rule_to_rblkey}->{$rule};
if (!defined $key) {
return 1;
}
if ($key eq '*ASYNC_START') {
dbg("dns: $rule lookup not yet complete");
return 0; }
my $obj = $self->{async}->get_lookup($key);
if (!defined $obj) {
dbg("dns: $rule lookup complete, $key no longer pending");
return 1;
}
dbg("dns: $rule lookup not yet complete");
return 0; }
sub check_for_from_dns {
my ($self, $pms) = @_;
if (defined $pms->{sender_host_fail}) {
return ($pms->{sender_host_fail} == 2); }
}
1;