Note that exim contains tracker-specific configuration
[mirror/dsa-puppet.git] / modules / exim / files / common / exim_surbl.pl
1 #
2 ## THIS FILE IS UNDER PUPPET CONTROL. DON'T EDIT IT HERE.
3 ## USE: git clone git+ssh://$USER@puppet.debian.org/srv/puppet.debian.org/git/dsa-puppet.git
4
5 #
6 # Copyright (c) 2006-2012 Erik Mugele.  All rights reserved.
7 #
8 # Redistribution and use in source and binary forms, with or without
9 # modification, are permitted provided that the following conditions
10 # are met:
11 # 1. Redistributions of source code must retain the above copyright
12 #    notice, this list of conditions and the following disclaimer.
13 # 2. Redistributions in binary form must reproduce the above copyright
14 #    notice, this list of conditions and the following disclaimer in the
15 #    documentation and/or other materials provided with the distribution.
16 #
17 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 # IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 # NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28 sub surblspamcheck
29 {
30
31 # Designed and written by Erik Mugele, 2004-2010,1http://www.teuton.org/~ejm
32 # Version 2.3-beta
33 #
34 # Please see the following website for details on usage of
35 # this script:  http://www.teuton.org/~ejm/exim_surbl
36
37     # The following variable is the full path to the file containing the 
38     # two-level top level domains (TLD).
39     # ---------------------------------------------------------------------
40     # THIS VARIABLE MUST BE SET TO THE FULL PATH AND NAME OF THE FILE 
41     # CONTAINING THE TWO LEVEL TLD!
42     # ---------------------------------------------------------------------
43     my $twotld_file = "/etc/exim4/two-level-tlds";    
44
45     # The following variable is the full path to the file containing the 
46     # three-level top level domains (TLD).
47     # ---------------------------------------------------------------------
48     # THIS VARIABLE MUST BE SET TO THE FULL PATH AND NAME OF THE FILE 
49     # CONTAINING THE THREE LEVEL TLD!
50     # ---------------------------------------------------------------------
51     my $threetld_file = "/etc/exim4/three-level-tlds";
52
53     # The following variable is the full path to the file containing
54     # whitelist entries.  
55     # ---------------------------------------------------------------------
56     # THIS VARIABLE MUST BE SET TO THE FULL PATH AND NAME OF THE FILE 
57     # CONTAINING THE WHITELIST DOMAINS!
58     # ---------------------------------------------------------------------
59     my $whitelist_file = "/etc/exim4/surbl_whitelist.txt";
60     
61     # This variable defines the maximum MIME file size that will be checked
62     # if this script is called by the MIME ACL.  This is primarily to
63     # keep the load down on the server.  Size is in bytes.
64     my $max_file_size = 50000;
65     
66     # The following variables enable or disable the SURBL, URIBL and DBL
67     # lookups.  Set to 1 to enable and 0 to disable.
68     my $surbl_enable = 1;
69     my $uribl_enable = 1;
70     my $dbl_enable = 1;
71
72     # Check to see if a decode MIME attachment is being checked or 
73     # just a plain old text message with no attachments
74     my $exim_body = "";
75     my $mime_filename = Exim::expand_string('$mime_decoded_filename');
76     if ($mime_filename) {
77         # DEBUG Statement
78         #warn ("MIME FILENAME: $mime_filename\n");
79         # If the MIME file is too large, skip it.
80         if (-s $mime_filename <= $max_file_size) {
81             open(fh,"<$mime_filename");
82             binmode(fh);
83             while (read(fh,$buff,1024)) {
84                 $exim_body .= $buff;
85             }
86             close (fh);
87         } else {
88             $exim_body = "";
89         }
90     } else {
91         $exim_body = Exim::expand_string('$message_body');
92     }
93     
94     sub surbllookup {
95         # This subroutine does the actual DNS lookup and builds and returns
96         # the return message for the SURBL lookup.
97         my @params = @_;
98         my $surbldomain = ".multi.surbl.org";
99         @dnsbladdr=gethostbyname($params[0].$surbldomain);
100         # If gethostbyname() returned anything, build a return message.
101         $return_string = "";
102         if (scalar(@dnsbladdr) != 0) {
103             $return_string = "Blacklisted URL in message. (".$params[0].") in";
104             @surblipaddr = unpack('C4',($dnsbladdr[4])[0]);
105             if ($surblipaddr[3] & 64) {
106                 $return_string .= " [jp]";
107             }
108             if ($surblipaddr[3] & 32) {
109                 $return_string .= " [ab]";
110             }
111             if ($surblipaddr[3] & 16) {
112                 $return_string .= " [ob]";
113             }
114             if ($surblipaddr[3] & 8) {
115                 $return_string .= " [ph]";
116             }
117             if ($surblipaddr[3] & 4) {
118                 $return_string .= " [ws]";
119             }
120             if ($surblipaddr[3] & 2) {
121                 $return_string .= " [sc]";
122             }
123             $return_string .= ". See http://www.surbl.org/lists.html.";
124         }
125         return $return_string;
126     }
127     
128     sub uribllookup {
129         # This subroutine does the actual DNS lookup and builds and returns
130         # the return message for the URIBL check.
131         my @params = @_;
132         my $uribldomain = ".black.uribl.com";
133         @dnsbladdr=gethostbyname($params[0].$uribldomain);
134         # If gethostbyname() returned anything, build a return message.
135         $return_string = "";
136         if (scalar(@dnsbladdr) != 0) {
137             $return_string = "Blacklisted URL in message. (".$params[0].") in";
138             @ipaddr = unpack('C4',($dnsbladdr[4])[0]);
139             if ($ipaddr[3] & 8) {
140                 $return_string .= " [red]";
141             }
142             if ($ipaddr[3] & 4) {
143                 $return_string .= " [grey]";
144             }
145             if ($ipaddr[3] & 2) {
146                 $return_string .= " [black]";
147             }
148             $return_string .= ". See http://lookup.uribl.com.";
149         }
150         return $return_string;
151     }
152
153     sub dbllookup {
154         # This subroutine does the actual DNS lookup and builds and returns
155         # the return message for the Spamhaus DBL check.
156         my @params = @_;
157         my $dbldomain = ".dbl.spamhaus.org";
158         @dnsbladdr=gethostbyname($params[0].$dbldomain);
159         # If gethostbyname() returned anything, build a return message.
160         $return_string = "";
161         if (scalar(@dnsbladdr) != 0) {
162             $return_string = "Blacklisted URL in message: ".$params[0];
163             $return_string .= ". See http://www.spamhaus.org/lookup.lasso?dnsbl=domain.";
164         }
165         return $return_string;
166     }
167
168     sub mkaddress {
169         # This subroutine takes a list of domain parts
170         # (e.g. ["www","example","com"]) and a number (e.g. 2) and returns a 
171         # the address of the given number of parts (e.g. example.com).
172         my $numparts = @_[-1];
173         pop(@_);
174         my @domain = @_;
175         my $address = $domain[-1];
176         for (my $i=2; $i<=$numparts; $i++) {
177             $address = $domain[-$i].".".$address;
178         }
179         return $address;
180     }
181     
182     sub converthex {
183         # This subroutine converts two hex characters to an ASCII character.
184         # It is called when ASCII obfuscation or Printed-Quatable characters
185         # are found (i.e. %AE or =AE).
186         # It should return a converted/plain address after splitting off
187         # everything that isn't part of the address portion of the URL.
188         my @ob_parts = @_;
189         my $address = $ob_parts[0];
190         for (my $j=1; $j < scalar(@ob_parts); $j++) {
191             $address .= chr(hex(substr($ob_parts[$j],0,2)));
192             $address .= substr($ob_parts[$j],2,);
193         }
194         $address = (split(/[^A-Za-z0-9._\-]/,$address))[0];
195         return $address
196     }
197
198     ################
199     # Main Program #
200     ################
201
202     if ($exim_body) {
203         # Find all the URLs in the message by finding the HTTP string
204         @parts = split(/[hH][tT][tT][pP](:|=3[aA])(\/|=2[Ff])(\/|=2[Ff])/,$exim_body);
205         if (scalar(@parts) > 1) {
206             # Read the entries from the two-level TLD file.
207             open (twotld_handle,$twotld_file) or die "Can't open $twotld_file.\n";
208             while (<twotld_handle>) {
209                 next if (/^#/ || /^$/ || /^\s$/);
210                 push(@twotlds,$_);
211             }
212             close (twotld_handle) or die "Close: $!\n";
213             # Read the entries from the three-level TLD file.
214             open (threetld_handle,$threetld_file) or die "Can't open $threetld_file.\n";
215             while (<threetld_handle>) {
216                 next if (/^#/ || /^$/ || /^\s$/);
217                 push(@threetlds,$_);
218             }
219             close (threetld_handle) or die "Close: $!\n";
220             # Read the entries from the whitelist file.
221             open (whitelist_handle,$whitelist_file) or die "Can't open $whitelist_file.\n";
222             while (<whitelist_handle>) {
223                 next if (/^#/ || /^$/ || /^\s$/);
224                 push(@whitelist,$_);
225             }
226             close (whitelist_handle) or die "Close: $!\n";
227
228             @surbl_list = ();
229             @uribl_list = ();
230             @dbl_list = ();
231
232             # Go through each of the HTTP parts that were found in the message
233             for ($i=1; $i < scalar(@parts); $i++) {
234                 # Special case of Quoted Printable EOL marker
235                 $parts[$i] =~ s/=\n//g;
236
237                 # Split the parts and find the address portion of the URL.
238                 # Address SHOULD be either a FQDN, IP address, or encoded address.
239                 $address = (split(/[^A-Za-z0-9\._\-%=]/,$parts[$i]))[0];
240
241                 # Check for an =.  If it exists, we assume the URL is doing 
242                 # Quoted-Printable.  Decode it and redefine $address
243                 if ($address =~ /=/) {
244                     @ob_parts = split(/=/,$address);
245                     $address = converthex(@ob_parts);
246                 }
247
248                 # Check for a %.  If it exists the URL is using % ASCII
249                 # obfuscation.  Decode it and redefine $address.
250                 if ($address =~ /%/) {
251                     @ob_parts = split(/%/,$address);
252                     $address = converthex(@ob_parts);
253                 }
254
255                 # Convert the address to lower case.
256                 $address = lc($address);
257
258                 # Split the the address into the elements separated by periods.
259                 @domain = split(/\./,$address);
260
261                 # Check the length of the domain name.  If less then two elements
262                 # at this point it is probably bogus or there is a bug in one of 
263                 # the decoding/converting routines above.
264                 if (scalar(@domain) >=2) {
265                     $spamcheckdomain = "";
266
267                     # DEBUG statement.
268                     #warn ("FOUND DOMAIN: ".mkaddress(@domain,scalar(@domain))."\n");
269
270                     # Domain has two or more than four elements.
271                     if ((scalar(@domain) == 2) || (scalar(@domain) >=5)) {
272                         # Add two elements of the domain to the list(s).
273                         $spamcheckdomain=mkaddress(@domain,2);
274                         # Check if $spamcheckdomain is not in the whitelist.
275                         if (! grep(/^$spamcheckdomain$/i,@whitelist)) {
276                             # If SURBL checks are enabled and the domain is
277                             # not in the SURBL list, add it.
278                             if (! grep(/^$spamcheckdomain$/i,@surbl_list) &&
279                                 ($surbl_enable == 1)) {
280                                 push(@surbl_list,$spamcheckdomain);
281                             }
282                             # If URIBL checks are enabled and the domain is
283                             # not in the URIBL list, add it.
284                             if (! grep(/^$spamcheckdomain$/i,@uribl_list) &&
285                                 ($uribl_enable == 1)) {
286                                 push(@uribl_list,$spamcheckdomain);
287                             }
288                             # If DBL checks are enabled and the domain is
289                             # not in the DBL list, add it.
290                             if (! grep(/^$spamcheckdomain$/i,@dbl_list) &&
291                                 ($dbl_enable == 1)) {
292                                 push(@dbl_list,$spamcheckdomain);
293                             }
294                         }
295                     }
296
297                     # Domain has three elements.
298                     if (scalar(@domain) == 3) {
299                         # Set $spamcheckdomain to two elements.
300                         $spamcheckdomain = mkaddress(@domain,2);
301                         $two_checkdomain = $spamcheckdomain;
302                         if (grep(/^$spamcheckdomain$/i,@twotlds)) {
303                             # $spamcheckdomain is in the two-level TLD list.
304                             # Reset $spamcheckdomain to three elements.
305                             $spamcheckdomain = mkaddress(@domain,3);
306                             # Check if $spamcheckdomain is not in the whitelist.
307                             if ((! grep(/^$spamcheckdomain$/i,@whitelist)) &&
308                                 (! grep(/^two_checkdomain$/i,@whitelist))) {
309                                 # If SURBL checks are enabled and the domain is
310                                 # not in the SURBL list, add it.
311                                 if (! grep(/^$spamcheckdomain$/i,@surbl_list) &&
312                                     ($surbl_enable == 1)) {
313                                     push(@surbl_list,$spamcheckdomain);
314                                 }
315                                 # If URIBL checks are enabled and the domain is
316                                 # not in the URIBL list, add it.
317                                 if (! grep(/^$spamcheckdomain$/i,@uribl_list) &&
318                                     ($uribl_enable == 1)) {
319                                     push(@uribl_list,$spamcheckdomain);
320                                 }
321                                 # If DBL checks are enabled and the domain is
322                                 # not in the DBL list, add it.
323                                 if (! grep(/^$spamcheckdomain$/i,@dbl_list) &&
324                                     ($dbl_enable == 1)) {
325                                     push(@dbl_list,$spamcheckdomain);
326                                 }
327                             }
328                         } else {
329                             # $spamcheckdomain is not in the two-level TLD list.
330                             # $spamcheckdomain is still two elements.
331                             # Check if $spamcheckdomain is not in the whitelist.
332                             if (! grep(/^$spamcheckdomain$/i,@whitelist)) {
333                                 # If SURBL checks are enabled and the domain is
334                                 # not in the SURBL list, add it.
335                                 if (! grep(/^$spamcheckdomain$/i,@surbl_list) &&
336                                     ($surbl_enable == 1)) {
337                                     push(@surbl_list,$spamcheckdomain);
338                                 }
339                                 # If URIBL checks are enabled and the domain is
340                                 # not in the URIBL list, add it.
341                                 if (! grep(/^$spamcheckdomain$/i,@uribl_list) &&
342                                     ($uribl_enable == 1)) {
343                                     push(@uribl_list,$spamcheckdomain);
344                                 }
345                                 # If DBL checks are enabled and the domain is
346                                 # not in the DBL list, add it.
347                                 if (! grep(/^$spamcheckdomain$/i,@dbl_list) &&
348                                     ($dbl_enable == 1)) {
349                                     push(@dbl_list,$spamcheckdomain);
350                                 }
351                             }
352                             # Reset $spamcheckdomain to three elements.
353                             $spamcheckdomain = mkaddress(@domain,3);
354                             # Check if $spamcheckdomain is not in the whitelist.
355                             if ((! grep(/^$spamcheckdomain$/i,@whitelist)) &&
356                                 (! grep(/^$two_checkdomain$/i,@whitelist))) {
357                                 # If URIBL checks are enabled and the domain is
358                                 # not in the URIBL list, add it.
359                                 if (! grep(/^$spamcheckdomain$/i,@uribl_list) &&
360                                     ($uribl_enable == 1)) {
361                                     push(@uribl_list,$spamcheckdomain);
362                                 }
363                                 # If DBL checks are enabled and the domain is
364                                 # not in the DBL list, add it.
365                                 if (! grep(/^$spamcheckdomain$/i,@dbl_list) &&
366                                     ($dbl_enable == 1)) {
367                                     push(@dbl_list,$spamcheckdomain);
368                                 }
369                             }
370                         }
371                     }
372
373                     # Domain has four elements.
374                     if (scalar(@domain) == 4) {
375                         if ($domain[-1] =~ /^(\d){1,3}$/) {
376                             # Domain is an IP address
377                             # Set $spamcheckdomain to the IP address in reverse.
378                             $spamcheckdomain = $domain[3].".".$domain[2].
379                                 ".".$domain[1].".".$domain[0];
380
381                             # Do NOT check IP addresses against the Spamhaus DBL list.
382
383                             # If SURBL checks are enabled and the IP is
384                             # not in the SURBL list, add it.
385                             if (! grep(/^$spamcheckdomain$/i,@surbl_list) &&
386                                 ($surbl_enable == 1)) {
387                                 push(@surbl_list,$spamcheckdomain);
388                             }
389                             # If URIBL checks are enabled and the IP is 
390                             # not in the URIBL list, add it.
391                             if (! grep(/^$spamcheckdomain$/i,@uribl_list) &&
392                                 ($uribl_enable == 1)) {
393                                 push(@uribl_list,$spamcheckdomain);
394                             }
395                         } else {
396                             # Domain is not an IP address.
397                             # Check if the last three elements of the domain are
398                             # in the three-level TLD list.
399                             $three_checkdomain = mkaddress(@domain,3);
400                             $two_checkdomain = mkaddress(@domain,2);
401                             if (grep(/^$three_checkdomain$/i,@threetlds)) {
402                                 # Set $spamcheckdomain to four elements.
403                                 $spamcheckdomain = mkaddress(@domain,4);
404                                 # Check if $spamcheckdomain is not in the whitelist.
405                                 if ((! grep(/^$spamcheckdomain$/i,@whitelist)) &&
406                                     (! grep(/^three_checkdomain$/i,@whitelist)) &&
407                                     (! grep(/^two_checkdomain$/i,@whitelist))) {
408                                     # If SURBL checks are enabled and the domain is
409                                     # not in the SURBL list, add it.
410                                     if (! grep(/^$spamcheckdomain$/i,@surbl_list) &&
411                                         ($surbl_enable == 1)) {
412                                         push(@surbl_list,$spamcheckdomain);
413                                     }
414                                     # If URIBL checks are enabled and the domain is
415                                     # not in the URIBL list, add it.
416                                     if (! grep(/^$spamcheckdomain$/i,@uribl_list) &&
417                                         ($uribl_enable == 1)) {
418                                         push(@uribl_list,$spamcheckdomain);
419                                     }
420                                     # If DBL checks are enabled and the domain is
421                                     # not in the DBL list, add it.
422                                     if (! grep(/^$spamcheckdomain$/i,@dbl_list) &&
423                                         ($dbl_enable == 1)) {
424                                         push(@dbl_list,$spamcheckdomain);
425                                     }
426                                 }
427                             }
428
429                             # Check if the last two elements of the domain are
430                             # in the two-level TLD list.
431                             elsif (grep(/^$two_checkdomain$/i,@twotlds)) {
432                                 # Reset $spamcheckdomain to three elements.
433                                 $spamcheckdomain = mkaddress(@domain,3);
434                                 # Check if $spamcheckdomain is not in the whitelist.
435                                 if ((! grep(/^$spamcheckdomain$/i,@whitelist)) &&
436                                     (! grep(/^two_checkdomain$/i,@whitelist))) {
437                                     # If SURBL checks are enabled and the domain is
438                                     # not in the SURBL list, add it.
439                                     if (! grep(/^$spamcheckdomain$/i,@surbl_list) &&
440                                         ($surbl_enable == 1)) {
441                                         push(@surbl_list,$spamcheckdomain);
442                                     }
443                                     # If URIBL checks are enabled and the domain is
444                                     # not in the URIBL list, add it.
445                                     if (! grep(/^$spamcheckdomain$/i,@uribl_list) &&
446                                         ($uribl_enable == 1)) {
447                                         push(@uribl_list,$spamcheckdomain);
448                                     }
449                                     # If DBL checks are enabled and the domain is
450                                     # not in the DBL list, add it.
451                                     if (! grep(/^$spamcheckdomain$/i,@dbl_list) &&
452                                         ($dbl_enable == 1)) {
453                                         push(@dbl_list,$spamcheckdomain);
454                                     }
455                                 }
456
457                                 # Reset $spamcheckdomain to four elements.
458                                 $spamcheckdomain = mkaddress(@domain,4);
459                                 # Check if $spamcheckdomain is not in the whitelist.
460                                 if ((! grep(/^$spamcheckdomain$/i,@whitelist)) &&
461                                     (! grep(/^three_checkdomain$/i,@whitelist)) &&
462                                     (! grep(/^two_checkdomain$/i,@whitelist))) {
463                                     # If SURBL checks are enabled and the domain is
464                                     # not in the SURBL list, add it.
465                                     if (! grep(/^$spamcheckdomain$/i,@surbl_list) &&
466                                         ($surbl_enable == 1)) {
467                                         push(@surbl_list,$spamcheckdomain);
468                                     }
469                                     # If URIBL checks are enabled and the domain is
470                                     # not in the URIBL list, add it.
471                                     if (! grep(/^$spamcheckdomain$/i,@uribl_list) &&
472                                         ($uribl_enable == 1)) {
473                                         push(@uribl_list,$spamcheckdomain);
474                                     }
475                                     # If DBL checks are enabled and the domain is
476                                     # not in the DBL list, add it.
477                                     if (! grep(/^$spamcheckdomain$/i,@dbl_list) &&
478                                         ($dbl_enable == 1)) {
479                                         push(@dbl_list,$spamcheckdomain);
480                                     }
481                                 }
482
483                             } else {
484                                 # Set $spamcheckdomain to two elements
485                                 $spamcheckdomain = mkaddress(@domain,2);
486                                 # Check if $spamcheckdomain is not in the whitelist.
487                                 if (! grep(/^$spamcheckdomain$/i,@whitelist)) {
488                                     # If SURBL checks are enabled and the domain is
489                                     # not in the SURBL list, add it.
490                                     if (! grep(/^$spamcheckdomain$/i,@surbl_list) &&
491                                         ($surbl_enable == 1)) {
492                                         push(@surbl_list,$spamcheckdomain);
493                                     }
494                                     # If URIBL checks are enabled and the domain is
495                                     # not in the URIBL list, add it.
496                                     if (! grep(/^$spamcheckdomain$/i,@uribl_list) &&
497                                         ($uribl_enable == 1)) {
498                                         push(@uribl_list,$spamcheckdomain);
499                                     }
500                                     # If DBL checks are enabled and the domain is
501                                     # not in the DBL list, add it.
502                                     if (! grep(/^$spamcheckdomain$/i,@dbl_list) &&
503                                         ($dbl_enable == 1)) {
504                                         push(@dbl_list,$spamcheckdomain);
505                                     }
506                                 }
507                                 # Reset $spamcheckdomain to three elements
508                                 $spamcheckdomain = mkaddress(@domain,3);
509                                 # Check if $spamcheckdomain is not in the whitelist.
510                                 if ((! grep(/^$spamcheckdomain$/i,@whitelist)) &&
511                                     (! grep(/^$two_checkdomain$/i,@whitelist))) {
512                                     # If URIBL checks are enabled and the domain is
513                                     # not in the URIBL list, add it.
514                                     if (! grep(/^$spamcheckdomain$/i,@uribl_list) &&
515                                         ($uribl_enable == 1)) {
516                                         push(@uribl_list,$spamcheckdomain);
517                                     }
518                                     # If DBL checks are enabled and the domain is
519                                     # not in the DBL list, add it.
520                                     if (! grep(/^$spamcheckdomain$/i,@dbl_list) &&
521                                         ($dbl_enable == 1)) {
522                                         push(@dbl_list,$spamcheckdomain);
523                                     }
524                                 }
525                                 # Set $spamcheckdomain to four elements
526                                 $spamcheckdomain = mkaddress(@domain,4);
527                                 # Check if $spamcheckdomain is not in the whitelist.
528                                 if ((! grep(/^$spamcheckdomain$/i,@whitelist)) &&
529                                     (! grep(/^$three_checkdomain$/i,@whitelist)) &&
530                                     (! grep(/^$two_checkdomain$/i,@whitelist))) {
531                                     # If URIBL checks are enabled and the domain is
532                                     # not in the URIBL list, add it.
533                                     if (! grep(/^$spamcheckdomain$/i,@uribl_list) &&
534                                         ($uribl_enable == 1)) {
535                                         push(@uribl_list,$spamcheckdomain);
536                                     }
537                                     # If DBL checks are enabled and the domain is
538                                     # not in the DBL list, add it.
539                                     if (! grep(/^$spamcheckdomain$/i,@dbl_list) &&
540                                         ($dbl_enable == 1)) {
541                                         push(@dbl_list,$spamcheckdomain);
542                                     }
543                                 }
544                             }
545                         } # End: if ($domain[-1] =~ /^(\d){1,3}$/)
546                     } # End: if (scalar(@domain) == 4)
547                 } # End: if (scalar(@domain) >=2)
548             } # End: for ($i=1; $i < scalar(@parts); $i++)
549
550             # If there are items in the SURBL list and the SURBL check
551             # is enabled then perform lookups on them.
552             if ((scalar(@surbl_list) > 0) && 
553                 ($surbl_enable == 1)) {
554                 foreach $i (@surbl_list) {
555                     # DEBUG statement.
556                     #warn ("CHECKING DOMAIN ($mime_filename): $i in SURBL list.\n");
557                     $return_result = surbllookup($i);
558                     if ($return_result ne "") {
559                         return $return_result;
560                     }
561                 }
562             }
563
564             # If there are items in the URIBL list and the URIBL check
565             # is enabled and the previous lookup did not return a result
566             # then perform lookups on them.
567             if ((scalar(@uribl_list) > 0) && 
568                 ($uribl_enable == 1) &&
569                 ($return_result eq "")) {
570                 foreach $i (@uribl_list) {
571                     # DEBUG statement.
572                     #warn ("CHECKING DOMAIN ($mime_filename): $i in URIBL list.\n");
573                     $return_result = uribllookup($i);
574                     if ($return_result ne "") {
575                         return $return_result;
576                     }
577                 }
578             }
579
580             # If there are items in the DBL list and the DBL check
581             # is enabled and the previous lookups did not return a result
582             # then perform lookups on them.
583             if ((scalar(@dbl_list) > 0) && 
584                 ($dbl_enable == 1) &&
585                 ($return_result eq "")) {
586                 foreach $i (@dbl_list) {
587                     # DEBUG statement.
588                     #warn ("CHECKING DOMAIN ($mime_filename): $i in DBL list.\n");
589                     $return_result = dbllookup($i);
590                     if ($return_result ne "") {
591                         return $return_result;
592                     }
593                 }
594             }
595         } # End: if (scalar(@parts) > 1)
596     } # End: if ($exim_body)
597
598     # No URLs were found or the URLs that were found were not
599     # listed in any list so return false.
600     return false;
601
602 } # End Main: - sub surblspamcheck