src/src/convert4r3.src

   1 #! PERL_COMMAND
   2
   3 # This is a Perl script that reads an Exim run-time configuration file and
   4 # checks for settings that were valid prior to release 3.00 but which were
   5 # obsoleted by that release. It writes a new file with suggested changes to
   6 # the standard output, and commentary about what it has done to stderr.
   7
   8 # It is assumed that the input is a valid Exim configuration file.
   9
  10 use warnings;
  11 BEGIN { pop @INC if $INC[-1] eq '.' };
  12
  13 use Getopt::Long;
  14 use File::Basename;
  15
  16 GetOptions(
  17     'version' => sub {
  18         print basename($0) . ": $0\n",
  19             "build: EXIM_RELEASE_VERSIONEXIM_VARIANT_VERSION\n",
  20             "perl(runtime): $^V\n";
  21             exit 0;
  22     },
  23 );
  24
  25 ##################################################
  26 #             Analyse one line                   #
  27 ##################################################
  28
  29 # This is called for the main and the driver sections, not for retry
  30 # or rewrite sections (which are unmodified).
  31
  32 sub checkline{
  33 my($line) = $_[0];
  34
  35 return "comment" if $line =~ /^\s*(#|$)/;
  36 return "end"     if $line =~ /^\s*end\s*$/;
  37
  38 # Macros are recognized only in the first section of the file.
  39
  40 return "macro" if $prefix eq "" && $line =~ /^\s*[A-Z]/;
  41
  42 # Pick out the name at the start and the rest of the line (into global
  43 # variables) and return whether the start of a driver or not.
  44
  45 ($i1,$name,$i2,$rest) = $line =~ /^(\s*)([a-z0-9_]+)(\s*)(.*?)\s*$/;
  46 return ($rest =~ /^:/)? "driver" : "option";
  47 }
  48
  49
  50
  51
  52 ##################################################
  53 #       Add transport setting to a director      #
  54 ##################################################
  55
  56 # This function adds a transport setting to an aliasfile or forwardfile
  57 # director if a global setting exists and a local one does not. If neither
  58 # exist, it adds file/pipe/reply, but not the directory ones.
  59
  60 sub add_transport{
  61 my($option) = @_;
  62
  63 my($key) = "$prefix$driver.${option}_transport";
  64 if (!exists $o{$key})
  65   {
  66   if (exists $o{"address_${option}_transport"})
  67     {
  68     print STDOUT "# >> Option added by convert4r3\n";
  69     printf STDOUT "${i1}${option}_transport = %s\n",
  70       $o{"address_${option}_transport"};
  71     printf STDERR
  72       "\n%03d ${option}_transport added to $driver director.\n",
  73       ++$count;
  74     }
  75   else
  76     {
  77     if ($option eq "pipe" || $option eq "file" || $option eq "reply")
  78       {
  79       print STDOUT "# >> Option added by convert4r3\n";
  80       printf STDOUT "${i1}${option}_transport = address_${option}\n";
  81       printf STDERR
  82         "\n%03d ${option}_transport added to $driver director.\n",
  83         ++$count;
  84       }
  85     }
  86   }
  87 }
  88
  89
  90
  91
  92 ##################################################
  93 #       Negate a list of things                  #
  94 ##################################################
  95
  96 sub negate {
  97 my($list) = $_[0];
  98
  99 return $list if ! defined $list;
 100
 101 ($list) = $list =~ /^"?(.*?)"?\s*$/s;
 102
 103 # Under Perl 5.005 we can split very nicely at colons, ignoring double
 104 # colons, like this:
 105 #
 106 # @split = split /\s*(?<!:):(?!:)\s*(?:\\\s*)?/s, $list;
 107 #
 108 # However, we'd better make this work under Perl 5.004, since there is
 109 # a lot of that about.
 110
 111 $list =~ s/::/>%%%%</g;
 112 @split = split /\s*:\s*(?:\\\s*)?/s, $list;
 113 foreach $item (@split)
 114   {
 115   $item =~ s/>%%%%</::/g;
 116   }
 117
 118 $" = " : \\\n    ! ";
 119 return "! @split";
 120 }
 121
 122
 123
 124
 125
 126 ##################################################
 127 #          Skip blank lines                      #
 128 ##################################################
 129
 130 # This function is called after we have generated no output for an option;
 131 # it skips subsequent blank lines if the previous line was blank.
 132
 133 sub skipblanks {
 134 my($i) = $_[0];
 135 if ($last_was_blank)
 136   {
 137   $i++ while $c[$i+1] =~ /^\s*$/;
 138   }
 139 return $i;
 140 }
 141
 142
 143
 144
 145
 146 ##################################################
 147 #       Get base name of data key                #
 148 ##################################################
 149
 150 sub base {
 151 return "$_[0]" if $_[0] !~ /^(?:d|r|t)\.[^.]+\.(.*)/;
 152 return $1;
 153 }
 154
 155
 156
 157 ##################################################
 158 #     Amalgamate accept/reject/reject_except     #
 159 ##################################################
 160
 161 # This function amalgamates the three previous kinds of
 162 # option into a single list, using negation for the middle one if
 163 # the final argument is "+", or for the outer two if the final
 164 # argument is "-".
 165
 166 sub amalgamate {
 167 my($accept,$reject,$reject_except,$name);
 168 my($last_was_negated) = 0;
 169 my($join) = "";
 170
 171 $accept = $o{$_[0]};
 172 $reject = $o{$_[1]};
 173 $reject_except = $o{$_[2]};
 174 $name = $_[3];
 175
 176 if ($_[4] eq "+")
 177   {
 178   ($accept) = $accept =~ /^"?(.*?)"?\s*$/s if defined $accept;
 179   $reject = &negate($reject) if defined $reject;
 180   ($reject_except) = $reject_except =~ /^"?(.*?)"?\s*$/s if defined $reject_except;
 181   }
 182 else
 183   {
 184   $accept = &negate($accept) if defined $accept;
 185   ($reject) = $reject =~ /^"?(.*?)"?\s*$/s if defined $reject;
 186   $reject_except = &negate($reject_except) if defined $reject_except;
 187   }
 188
 189 print STDOUT "# >> Option rewritten by convert4r3\n";
 190 print STDOUT "${i1}$name = \"";
 191
 192 if (defined $reject_except)
 193   {
 194   print STDOUT "$reject_except";
 195   $join = " : \\\n    ";
 196   $last_was_negated = ($_[4] ne "+");
 197   }
 198 if (defined $reject)
 199   {
 200   print STDOUT "$join$reject";
 201   $join = " : \\\n    ";
 202   $last_was_negated = ($_[4] eq "+");
 203   }
 204 if (defined $accept)
 205   {
 206   print STDOUT "$join$accept";
 207   $last_was_negated = ($_[4] ne "+");
 208   $join = " : \\\n    ";
 209   }
 210
 211 print STDOUT "$join*" if $last_was_negated;
 212
 213 print STDOUT "\"\n";
 214
 215 my($driver_name);
 216 my($driver_type) = "";
 217
 218 if ($_[0] =~ /^(d|r|t)\.([^.]+)\./ ||
 219     $_[1] =~ /^(d|r|t)\.([^.]+)\./ ||
 220     $_[2] =~ /^(d|r|t)\.([^.]+)\./)
 221   {
 222   $driver_type = ($1 eq 'd')? "director" : ($1 eq 'r')? "router" : "transport";
 223   $driver_name = $2;
 224   }
 225
 226 my($x) = ($driver_type ne "")? " in \"$driver_name\" $driver_type" : "";
 227
 228 my($l0) = &base($_[0]);
 229 my($l1) = &base($_[1]);
 230 my($l2) = &base($_[2]);
 231
 232
 233 if ($l2 eq "")
 234   {
 235   if ($l0 eq "")
 236     {
 237     printf STDERR "\n%03d $l1 converted to $name$x.\n", ++$count;
 238     }
 239   else
 240     {
 241     printf STDERR "\n%03d $l0 and $l1\n    amalgamated into $name$x.\n",
 242       ++$count;
 243     }
 244   }
 245 else
 246   {
 247   if ($l1 eq "")
 248     {
 249     printf STDERR "\n%03d $l0 and $l2\n    amalgamated into $name$x.\n",
 250       ++$count;
 251     }
 252   else
 253     {
 254     printf STDERR "\n%03d $l0, $l1 and $l2\n    amalgamated into " .
 255       "$name$x.\n", ++$count;
 256     }
 257   }
 258 }
 259
 260
 261
 262
 263 ##################################################
 264 #         Join two lists, if they exist          #
 265 ##################################################
 266
 267 sub pair{
 268 my($l1) = $o{"$_[0]"};
 269 my($l2) = $o{"$_[1]"};
 270
 271 return $l2 if (!defined $l1);
 272 return $l1 if (!defined $l2);
 273
 274 ($l1) = $l1 =~ /^"?(.*?)"?\s*$/s;
 275 ($l2) = $l2 =~ /^"?(.*?)"?\s*$/s;
 276
 277 return "$l1 : $l2";
 278 }
 279
 280
 281
 282
 283 ##################################################
 284 #  Amalgamate accept/reject/reject_except pairs  #
 285 ##################################################
 286
 287 # This is like amalgamate, but it combines pairs of arguments, and
 288 # doesn't output commentary (easier to write a generic one for the few
 289 # cases).
 290
 291 sub amalgamatepairs {
 292 my($accept) = &pair($_[0], $_[1]);
 293 my($reject) = &pair($_[2], $_[3]);
 294 my($reject_except) = &pair($_[4], $_[5]);
 295 my($last_was_negated) = 0;
 296 my($join) = "";
 297
 298 if ($_[7] eq "+")
 299   {
 300   ($accept) = $accept =~ /^"?(.*?)"?\s*$/s if defined $accept;
 301   $reject = &negate($reject) if defined $reject;
 302   ($reject_except) = $reject_except =~ /^"?(.*?)"?\s*$/s if defined $reject_except;
 303   }
 304 else
 305   {
 306   $accept = &negate($accept) if defined $accept;
 307   ($reject) = $reject =~ /^"?(.*?)"?$/s if defined $reject;
 308   $reject_except = &negate($reject_except) if defined $reject_except;
 309   }
 310
 311 print STDOUT "# >> Option rewritten by convert4r3\n";
 312 print STDOUT "${i1}$_[6] = \"";
 313
 314 if (defined $reject_except)
 315   {
 316   print STDOUT "$reject_except";
 317   $join = " : \\\n    ";
 318   $last_was_negated = ($_[7] ne "+");
 319   }
 320 if (defined $reject)
 321   {
 322   print STDOUT "$join$reject";
 323   $join = " : \\\n    ";
 324   $last_was_negated = ($_[7] eq "+");
 325   }
 326 if (defined $accept)
 327   {
 328   print STDOUT "$join$accept";
 329   $last_was_negated = ($_[7] ne "+");
 330   $join = " : \\\n    ";
 331   }
 332
 333 print STDOUT "$join*" if $last_was_negated;
 334 print STDOUT "\"\n";
 335 }
 336
 337
 338
 339 ##################################################
 340 #      Amalgamate boolean and exception list(s)  #
 341 ##################################################
 342
 343 sub amalgboolandlist {
 344 my($name,$bool,$e1,$e2) = @_;
 345
 346 print STDOUT "# >> Option rewritten by convert4r3\n";
 347 if ($bool eq "false")
 348   {
 349   printf STDOUT "$i1$name =\n";
 350   }
 351 else
 352   {
 353   printf STDOUT "$i1$name = ";
 354   my($n1) = &negate($o{$e1});
 355   my($n2) = &negate($o{$e2});
 356   if (!defined $n1 && !defined $n2)
 357     {
 358     print STDOUT "*\n";
 359     }
 360   elsif (!defined $n1)
 361     {
 362     print STDOUT "\"$n2 : \\\n    *\"\n";
 363     }
 364   elsif (!defined $n2)
 365     {
 366     print STDOUT "\"$n1 : \\\n    *\"\n";
 367     }
 368   else
 369     {
 370     print STDOUT "\"$n1 : \\\n    $n2 : \\\n    *\"\n";
 371     }
 372   }
 373 }
 374
 375
 376
 377 ##################################################
 378 #             Convert mask format                #
 379 ##################################################
 380
 381 # This function converts an address and mask in old-fashioned dotted-quad
 382 # format into an address plus a new format mask.
 383
 384 @byte_list = (0, 128, 192, 224, 240, 248, 252, 254, 255);
 385
 386 sub mask {
 387 my($address,$mask) = @_;
 388 my($length) = 0;
 389 my($i, $j);
 390
 391 my(@bytes) = split /\./, $mask;
 392
 393 for ($i = 0; $i < 4; $i++)
 394   {
 395   for ($j = 0; $j <= 8; $j++)
 396     {
 397     if ($bytes[$i] == $byte_list[$j])
 398       {
 399       $length += $j;
 400       if ($j != 8)
 401         {
 402         for ($i++; $i < 4; $i++)
 403           {
 404           $j = 9 if ($bytes[$i] != 0);
 405           }
 406         }
 407       last;
 408       }
 409     }
 410
 411   if ($j > 8)
 412     {
 413     print STDERR "*** IP mask $mask cannot be converted to /n format. ***\n";
 414     return "$address/$mask";
 415     }
 416   }
 417
 418 if (!defined $masks{$mask})
 419   {
 420   printf STDERR "\n%03d IP address mask $mask converted to /$length\n",
 421     ++$count, $mask, $length;
 422   $masks{$mask} = 1;
 423   }
 424
 425 return sprintf "$address/%d", $length;
 426 }
 427
 428
 429
 430
 431
 432 ##################################################
 433 #                  Main program                  #
 434 ##################################################
 435
 436 print STDERR "Exim pre-release 3.00 configuration file converter.\n";
 437
 438 $count = 0;
 439 $seen_helo_accept_junk = 0;
 440 $seen_hold_domains = 0;
 441 $seen_receiver_unqualified = 0;
 442 $seen_receiver_verify_except = 0;
 443 $seen_receiver_verify_senders = 0;
 444 $seen_rfc1413_except = 0;
 445 $seen_sender_accept = 0;
 446 $seen_sender_accept_recipients = 0;
 447 $seen_sender_host_accept = 0;
 448 $seen_sender_host_accept_recipients = 0;
 449 $seen_sender_host_accept_relay = 0;
 450 $seen_sender_unqualified = 0;
 451 $seen_sender_verify_except_hosts = 0;
 452 $seen_smtp_etrn = 0;
 453 $seen_smtp_expn = 0;
 454 $seen_smtp_reserve = 0;
 455 $semicomma = 0;
 456
 457 # Read the entire file into an array
 458
 459 chomp(@c = <STDIN>);
 460
 461 # First, go through the input and covert any net masks in the old dotted-quad
 462 # style into the new /n style.
 463
 464 for ($i = 0; $i < scalar(@c); $i++)
 465   {
 466   $c[$i] =~
 467     s"((?:\d{1,3}\.){3}\d{1,3})/((?:\d{1,3}\.){3}\d{1,3})"&mask($1,$2)"eg;
 468   }
 469
 470 # We now make two more passes over the input. In the first pass, we place all
 471 # the option values into an associative array. Main options are keyed by their
 472 # names; options for drivers are keyed by a driver type letter, the driver
 473 # name, and the option name, dot-separated. In the second pass we modify
 474 # the options if necessary, and write the output file.
 475
 476 for ($pass = 1; $pass < 3; $pass++)
 477   {
 478   $prefix = "";
 479   $driver = "";
 480   $last_was_blank = 0;
 481
 482   for ($i = 0; $i < scalar(@c); $i++)
 483     {
 484     # Everything after the router section is just copied in pass 2 and
 485     # ignored in pass 1.
 486
 487     if ($prefix eq "end")
 488       {
 489       print STDOUT "$c[$i]\n" if $pass == 2;
 490       next;
 491       }
 492
 493     # Analyze the line
 494
 495     $type = &checkline($c[$i]);
 496
 497     # Skip comments in pass 1; copy in pass 2
 498
 499     if ($type eq "comment")
 500       {
 501       $last_was_blank = ($c[$i] =~ /^\s*$/)? 1 : 0;
 502       print STDOUT "$c[$i]\n" if $pass == 2;
 503       next;
 504       }
 505
 506     # Skip/copy macro definitions, but must handle continuations
 507
 508     if ($type eq "macro")
 509       {
 510       print STDOUT "$c[$i]\n" if $pass == 2;
 511       while ($c[$i] =~ /\\\s*$/)
 512         {
 513         $i++;
 514         print STDOUT "$c[$i]\n" if $pass == 2;
 515         }
 516       $last_was_blank = 0;
 517       next;
 518       }
 519
 520     # Handle end of section
 521
 522     if ($type eq "end")
 523       {
 524       $prefix = "end"if $prefix eq "r.";
 525       $prefix = "r." if $prefix eq "d.";
 526       $prefix = "d." if $prefix eq "t.";
 527       $prefix = "t." if $prefix eq "";
 528       print STDOUT "$c[$i]\n" if $pass == 2;
 529       $last_was_blank = 0;
 530       next;
 531       }
 532
 533     # Handle start of a new driver
 534
 535     if ($type eq "driver")
 536       {
 537       $driver = $name;
 538       print STDOUT "$c[$i]\n" if $pass == 2;
 539       $last_was_blank = 0;
 540       $seen_domains = 0;
 541       $seen_local_parts = 0;
 542       $seen_senders = 0;
 543       $seen_mx_domains = 0;
 544       $seen_serialize = 0;
 545       next;
 546       }
 547
 548     # Handle definition of an option
 549
 550     if ($type eq "option")
 551       {
 552       # Handle continued strings
 553
 554       if ($rest =~ /^=\s*".*\\$/)
 555         {
 556         for (;;)
 557           {
 558           $rest .= "\n$c[++$i]";
 559           last unless $c[$i] =~ /(\\\s*$|^\s*#)/;
 560           }
 561         }
 562
 563       # Remove any terminating commas and semicolons in pass 2
 564
 565       if ($pass == 2 && $rest =~ /[;,]\s*$/)
 566         {
 567         $rest =~ s/\s*[;,]\s*$//;
 568         if (!$semicomma)
 569           {
 570           printf STDERR
 571             "\n%03d Terminating semicolons and commas removed from driver " .
 572             "options.\n", ++$count;
 573           $semicomma = 1;
 574           }
 575         }
 576
 577       # Convert all booleans to "x = true/false" format, but save the
 578       # original so that it can be reproduced unchanged for options that
 579       # are not of interest.
 580
 581       $origname = $name;
 582       $origrest = $rest;
 583
 584       if ($name =~ /^not?_(.*)/)
 585         {
 586         $name = $1;
 587         $rest = "= false";
 588         }
 589       elsif ($rest !~ /^=/)
 590         {
 591         $rest = "= true";
 592         }
 593
 594       # Set up the associative array key, and get rid of the = on the data
 595
 596       $key = ($prefix eq "")? "$name" : "$prefix$driver.$name";
 597       ($rest) = $rest =~ /^=\s*(.*)/s;
 598
 599       # Create the associative array of values in pass 1
 600
 601       if ($pass == 1)
 602         {
 603         $o{$key} = $rest;
 604         }
 605
 606       # In pass 2, test for interesting options and do the necessary; copy
 607       # all the rest.
 608
 609       else
 610         {
 611         ##########  Global configuration ##########
 612
 613         # These global options are abolished
 614
 615         if ($name eq "address_directory_transport" ||
 616             $name eq "address_directory2_transport" ||
 617             $name eq "address_file_transport" ||
 618             $name eq "address_pipe_transport" ||
 619             $name eq "address_reply_transport")
 620           {
 621           ($n2) = $name =~ /^address_(.*)/;
 622           printf STDERR "\n%03d $name option deleted.\n", ++$count;
 623           printf STDERR "    $n2 will be added to appropriate directors.\n";
 624           $i = &skipblanks($i);
 625           next;
 626           }
 627
 628         # This debugging option is abolished
 629
 630         elsif ($name eq "sender_verify_log_details")
 631           {
 632           printf STDERR "\n%03d $name option deleted.\n", ++$count;
 633           printf STDERR "    (Little used facility abolished.)\n";
 634           }
 635
 636         # This option has been renamed
 637
 638         elsif ($name eq "check_dns_names")
 639           {
 640           $origname =~ s/check_dns/dns_check/;
 641           print STDOUT "# >> Option rewritten by convert4r3\n";
 642           print STDOUT "$i1$origname$i2$origrest\n";
 643           printf STDERR "\n%03d check_dns_names renamed as dns_check_names.\n",
 644             ++$count;
 645           }
 646
 647         # helo_accept_junk_nets is abolished
 648
 649         elsif ($name eq "helo_accept_junk_nets" ||
 650                $name eq "helo_accept_junk_hosts")
 651           {
 652           if (!$seen_helo_accept_junk)
 653             {
 654             &amalgamate("helo_accept_junk_nets", "",
 655               "helo_accept_junk_hosts", "helo_accept_junk_hosts", "+");
 656             $seen_helo_accept_junk = 1;
 657             }
 658           else
 659             {
 660             $i = &skipblanks($i);
 661             next;
 662             }
 663           }
 664
 665         # helo_verify_except_{hosts,nets} are abolished, and helo_verify
 666         # is now a host list instead of a boolean.
 667
 668         elsif ($name eq "helo_verify")
 669           {
 670           &amalgboolandlist("helo_verify", $rest, "helo_verify_except_hosts",
 671             "helo_verify_except_nets");
 672           printf STDERR "\n%03d helo_verify converted to host list.\n",
 673             ++$count;
 674           }
 675         elsif ($name eq "helo_verify_except_hosts" ||
 676                $name eq "helo_verify_except_nets")
 677           {
 678           $i = &skipblanks($i);
 679           next;
 680           }
 681
 682         # helo_verify_nets was an old synonym for host_lookup_nets; only
 683         # one of them will be encountered. Change to a new name.
 684
 685         elsif ($name eq "helo_verify_nets" ||
 686                $name eq "host_lookup_nets")
 687           {
 688           print STDOUT "# >> Option rewritten by convert4r3\n";
 689           print STDOUT "${i1}host_lookup$i2$origrest\n";
 690           printf STDERR "\n%03d $name renamed as host_lookup.\n", ++$count;
 691           }
 692
 693         # hold_domains_except is abolished; add as negated items to
 694         # hold_domains.
 695
 696         elsif ($name eq "hold_domains_except" ||
 697                $name eq "hold_domains")
 698           {
 699           if ($seen_hold_domains)         # If already done with these
 700             {                             # omit, and following blanks.
 701             $i = &skipblanks($i);
 702             next;
 703             }
 704           $seen_hold_domains = 1;
 705
 706           if (exists $o{"hold_domains_except"})
 707             {
 708             &amalgamate("hold_domains", "hold_domains_except", "",
 709               "hold_domains", "+");
 710             }
 711           else
 712             {
 713             print STDOUT "$i1$origname$i2$origrest\n";
 714             }
 715           }
 716
 717         # ignore_fromline_nets is renamed as ignore_fromline_hosts
 718
 719         elsif ($name eq "ignore_fromline_nets")
 720           {
 721           $origname =~ s/_nets/_hosts/;
 722           print STDOUT "# >> Option rewritten by convert4r3\n";
 723           print STDOUT "$i1$origname$i2$origrest\n";
 724           printf STDERR
 725             "\n%03d ignore_fromline_nets renamed as ignore_fromline_hosts.\n",
 726             ++$count;
 727           }
 728
 729         # Output a warning for message filters with no transports set
 730
 731         elsif ($name eq "message_filter")
 732           {
 733           print STDOUT "$i1$origname$i2$origrest\n";
 734
 735           if (!exists $o{"message_filter_directory_transport"} &&
 736               !exists $o{"message_filter_directory2_transport"} &&
 737               !exists $o{"message_filter_file_transport"} &&
 738               !exists $o{"message_filter_pipe_transport"} &&
 739               !exists $o{"message_filter_reply_transport"})
 740             {
 741             printf STDERR
 742               "\n%03d message_filter is set, but no message_filter transports "
 743               . "are defined.\n"
 744               . "    If your filter generates file or pipe deliveries, or "
 745               . "auto-replies,\n"
 746               . "    you will need to define "
 747               . "message_filter_{file,pipe,reply}_transport\n"
 748               . "    options, as required.\n", ++$count;
 749             }
 750           }
 751
 752         # queue_remote_except is abolished, and queue_remote is replaced by
 753         # queue_remote_domains, which is a host list.
 754
 755         elsif ($name eq "queue_remote")
 756           {
 757           &amalgboolandlist("queue_remote_domains", $rest,
 758             "queue_remote_except", "");
 759           printf STDERR
 760             "\n%03d queue_remote converted to domain list queue_remote_domains.\n",
 761             ++$count;
 762           }
 763         elsif ($name eq "queue_remote_except")
 764           {
 765           $i = &skipblanks($i);
 766           next;
 767           }
 768
 769         # queue_smtp_except is abolished, and queue_smtp is replaced by
 770         # queue_smtp_domains, which is a host list.
 771
 772         elsif ($name eq "queue_smtp")
 773           {
 774           &amalgboolandlist("queue_smtp_domains", $rest,
 775             "queue_smtp_except", "");
 776           printf STDERR
 777             "\n%03d queue_smtp converted to domain list queue_smtp_domains.\n",
 778             ++$count;
 779           }
 780         elsif ($name eq "queue_smtp_except")
 781           {
 782           $i = &skipblanks($i);
 783           next;
 784           }
 785
 786         # rbl_except_nets is replaced by rbl_hosts
 787
 788         elsif ($name eq "rbl_except_nets")
 789           {
 790           &amalgamate("", "rbl_except_nets", "", "rbl_hosts", "+");
 791           }
 792
 793         # receiver_unqualified_nets is abolished
 794
 795         elsif ($name eq "receiver_unqualified_nets" ||
 796                $name eq "receiver_unqualified_hosts")
 797           {
 798           if (!$seen_receiver_unqualified)
 799             {
 800             &amalgamate("receiver_unqualified_nets", "",
 801               "receiver_unqualified_hosts", "receiver_unqualified_hosts", "+");
 802             $seen_receiver_unqualified = 1;
 803             }
 804           else
 805             {
 806             $i = &skipblanks($i);
 807             next;
 808             }
 809           }
 810
 811         # receiver_verify_except_{hosts,nets} are replaced by
 812         # receiver_verify_hosts.
 813
 814         elsif ($name eq "receiver_verify_except_hosts" ||
 815                $name eq "receiver_verify_except_nets")
 816           {
 817           if (!$seen_receiver_verify_except)
 818             {
 819             &amalgboolandlist("receiver_verify_hosts", "true",
 820               "receiver_verify_except_hosts", "receiver_verify_except_nets");
 821             printf STDERR
 822               "\n%03d receiver_verify_except_{hosts,nets} converted to " .
 823               "receiver_verify_hosts.\n",
 824               ++$count;
 825             $seen_receiver_verify_except = 1;
 826             }
 827           else
 828             {
 829             $i = &skipblanks($i);
 830             next;
 831             }
 832           }
 833
 834         # receiver_verify_senders_except is abolished
 835
 836         elsif ($name eq "receiver_verify_senders" ||
 837                $name eq "receiver_verify_senders_except")
 838           {
 839           if (defined $o{"receiver_verify_senders_except"})
 840             {
 841             if (!$seen_receiver_verify_senders)
 842               {
 843               &amalgamate("receiver_verify_senders",
 844                 "receiver_verify_senders_except", "",
 845                 "receiver_verify_senders", "+");
 846               $seen_receiver_verify_senders = 1;
 847               }
 848             else
 849               {
 850               $i = &skipblanks($i);
 851               next;
 852               }
 853             }
 854           else
 855             {
 856             print STDOUT "$i1$origname$i2$origrest\n";
 857             }
 858           }
 859
 860         # rfc1413_except_{hosts,nets} are replaced by rfc1413_hosts.
 861
 862         elsif ($name eq "rfc1413_except_hosts" ||
 863                $name eq "rfc1413_except_nets")
 864           {
 865           if (!$seen_rfc1413_except)
 866             {
 867             &amalgboolandlist("rfc1413_hosts", "true",
 868               "rfc1413_except_hosts", "rfc1413_except_nets");
 869             printf STDERR
 870               "\n%03d rfc1413_except_{hosts,nets} converted to rfc1413_hosts.\n",
 871               ++$count;
 872             $seen_rfc1413_except = 1;
 873             }
 874           else
 875             {
 876             $i = &skipblanks($i);
 877             next;
 878             }
 879           }
 880
 881         # sender_accept and sender_reject_except are abolished
 882
 883         elsif ($name eq "sender_accept" ||
 884                $name eq "sender_reject")
 885           {
 886           if (!$seen_sender_accept)
 887             {
 888             &amalgamate("sender_accept", "sender_reject",
 889               "sender_reject_except", "sender_reject", "-");
 890             $seen_sender_accept = 1;
 891             }
 892           else
 893             {
 894             $i = &skipblanks($i);
 895             next;
 896             }
 897           }
 898
 899         # sender_accept_recipients is also abolished; sender_reject_except
 900         # also used to apply to this, so we include it here as well.
 901
 902         elsif ($name eq "sender_accept_recipients" ||
 903                $name eq "sender_reject_recipients")
 904           {
 905           if (!$seen_sender_accept_recipients)
 906             {
 907             &amalgamate("sender_accept_recipients", "sender_reject_recipients",
 908               "sender_reject_except", "sender_reject_recipients", "-");
 909             $seen_sender_accept_recipients = 1;
 910             }
 911           else
 912             {
 913             $i = &skipblanks($i);
 914             next;
 915             }
 916           }
 917
 918         # sender_reject_except must be removed
 919
 920         elsif ($name eq "sender_reject_except")
 921           {
 922           $i = &skipblanks($i);
 923           next;
 924           }
 925
 926         # sender_{host,net}_{accept,reject}[_except] all collapse into
 927         # host_reject.
 928
 929         elsif ($name eq "sender_host_accept" ||
 930                $name eq "sender_net_accept" ||
 931                $name eq "sender_host_reject" ||
 932                $name eq "sender_net_reject")
 933           {
 934           if (!$seen_sender_host_accept)
 935             {
 936             &amalgamatepairs("sender_host_accept", "sender_net_accept",
 937               "sender_host_reject", "sender_net_reject",
 938               "sender_host_reject_except", "sender_net_reject_except",
 939               "host_reject", "-");
 940             printf STDERR "\n%03d sender_{host,net}_{accept,reject} and " .
 941               "sender_{host_net}_reject_except\n" .
 942               "    amalgamated into host_reject.\n", ++$count;
 943             $seen_sender_host_accept = 1;
 944             }
 945           else
 946             {
 947             $i = &skipblanks($i);
 948             next;
 949             }
 950           }
 951
 952         # sender_{host,net}_{accept,reject}_recipients all collapse into
 953         # host_reject_recipients.
 954
 955         elsif ($name eq "sender_host_accept_recipients" ||
 956                $name eq "sender_net_accept_recipients" ||
 957                $name eq "sender_host_reject_recipients" ||
 958                $name eq "sender_net_reject_recipients")
 959           {
 960           if (!$seen_sender_host_accept_recipients)
 961             {
 962             &amalgamatepairs("sender_host_accept_recipients",
 963               "sender_net_accept_recipients",
 964               "sender_host_reject_recipients",
 965               "sender_net_reject_recipients",
 966               "sender_host_reject_except", "sender_net_reject_except",
 967               "host_reject_recipients", "-");
 968             printf STDERR "\n%03d sender_{host,net}_{accept,reject}_recipients"
 969               . "\n    and sender_{host_net}_reject_except"
 970               . "\n    amalgamated into host_reject_recipients.\n", ++$count;
 971             $seen_sender_host_accept_recipients = 1;
 972             }
 973           else
 974             {
 975             $i = &skipblanks($i);
 976             next;
 977             }
 978           }
 979
 980         # sender_{host,net}_reject_except must be removed
 981
 982         elsif ($name eq "sender_host_reject_except" ||
 983                $name eq "sender_net_reject_except")
 984           {
 985           $i = &skipblanks($i);
 986           next;
 987           }
 988
 989         # sender_{host,net}_{accept,reject}_relay all collapse into
 990         # host_accept_relay.
 991
 992         elsif ($name eq "sender_host_accept_relay" ||
 993                $name eq "sender_net_accept_relay" ||
 994                $name eq "sender_host_reject_relay" ||
 995                $name eq "sender_net_reject_relay")
 996           {
 997           if (!$seen_sender_host_accept_relay)
 998             {
 999             &amalgamatepairs("sender_host_accept_relay",
1000               "sender_net_accept_relay",
1001               "sender_host_reject_relay",
1002               "sender_net_reject_relay",
1003               "sender_host_reject_relay_except",
1004               "sender_net_reject_relay_except",
1005               "host_accept_relay", "+");
1006             printf STDERR "\n%03d sender_{host,net}_{accept,reject}_relay"
1007               . "\n    and sender_{host_net}_reject_relay_except"
1008               . "\n    amalgamated into host_accept_relay.\n", ++$count;
1009             $seen_sender_host_accept_relay = 1;
1010             }
1011           else
1012             {
1013             $i = &skipblanks($i);
1014             next;
1015             }
1016           }
1017
1018         # sender_{host,net}_reject_relay_except must be removed
1019
1020         elsif ($name eq "sender_host_reject_relay_except" ||
1021                $name eq "sender_net_reject_relay_except")
1022           {
1023           $i = &skipblanks($i);
1024           next;
1025           }
1026
1027
1028         # sender_unqualified_nets is abolished
1029
1030         elsif ($name eq "sender_unqualified_nets" ||
1031                $name eq "sender_unqualified_hosts")
1032           {
1033           if (!$seen_sender_unqualified)
1034             {
1035             &amalgamate("sender_unqualified_nets", "",
1036               "sender_unqualified_hosts", "sender_unqualified_hosts", "+");
1037             $seen_sender_unqualified = 1;
1038             }
1039           else
1040             {
1041             $i = &skipblanks($i);
1042             next;
1043             }
1044           }
1045
1046         # sender_verify_except_{hosts,nets} are replaced by sender_verify_hosts.
1047
1048         elsif ($name eq "sender_verify_except_hosts" ||
1049                $name eq "sender_verify_except_nets")
1050           {
1051           if (!$seen_sender_verify_except_hosts)
1052             {
1053             &amalgboolandlist("sender_verify_hosts", "true",
1054               "sender_verify_except_hosts", "sender_verify_except_nets");
1055             printf STDERR
1056               "\n%03d sender_verify_except_{hosts,nets} converted to " .
1057               "sender_verify_hosts.\n",
1058               ++$count;
1059             $seen_sender_verify_except_hosts = 1;
1060             }
1061           else
1062             {
1063             $i = &skipblanks($i);
1064             next;
1065             }
1066           }
1067
1068         # smtp_etrn_nets is abolished
1069
1070         elsif ($name eq "smtp_etrn_nets" ||
1071                $name eq "smtp_etrn_hosts")
1072           {
1073           if (!$seen_smtp_etrn)
1074             {
1075             &amalgamate("smtp_etrn_nets", "",
1076               "smtp_etrn_hosts", "smtp_etrn_hosts", "+");
1077             $seen_smtp_etrn = 1;
1078             }
1079           else
1080             {
1081             $i = &skipblanks($i);
1082             next;
1083             }
1084           }
1085
1086         # smtp_expn_nets is abolished
1087
1088         elsif ($name eq "smtp_expn_nets" ||
1089                $name eq "smtp_expn_hosts")
1090           {
1091           if (!$seen_smtp_expn)
1092             {
1093             &amalgamate("smtp_expn_nets", "",
1094               "smtp_expn_hosts", "smtp_expn_hosts", "+");
1095             $seen_smtp_expn = 1;
1096             }
1097           else
1098             {
1099             $i = &skipblanks($i);
1100             next;
1101             }
1102           }
1103
1104         # This option has been renamed
1105
1106         elsif ($name eq "smtp_log_connections")
1107           {
1108           $origname =~ s/smtp_log/log_smtp/;
1109           print STDOUT "# >> Option rewritten by convert4r3\n";
1110           print STDOUT "$i1$origname$i2$origrest\n";
1111           printf STDERR "\n%03d smtp_log_connections renamed as " .
1112             "log_smtp_connections.\n",
1113             ++$count;
1114           }
1115
1116         # smtp_reserve_nets is abolished
1117
1118         elsif ($name eq "smtp_reserve_nets" ||
1119                $name eq "smtp_reserve_hosts")
1120           {
1121           if (!$seen_smtp_reserve)
1122             {
1123             &amalgamate("smtp_reserve_nets", "",
1124               "smtp_reserve_hosts", "smtp_reserve_hosts", "+");
1125             $seen_smtp_reserve = 1;
1126             }
1127           else
1128             {
1129             $i = &skipblanks($i);
1130             next;
1131             }
1132           }
1133
1134         ###########  Driver configurations  ##########
1135
1136         # For aliasfile and forwardfile directors, add file, pipe, and
1137         # reply transports - copying from the globals if they are set.
1138
1139         elsif ($name eq "driver")
1140           {
1141           $driver_type = $rest;
1142           print STDOUT "$i1$origname$i2$origrest\n";
1143           if ($rest eq "aliasfile" || $rest eq "forwardfile")
1144             {
1145             &add_transport("directory");
1146             &add_transport("directory2");
1147             &add_transport("file");
1148             &add_transport("pipe");
1149             &add_transport("reply") if $rest eq "forwardfile";
1150             }
1151           }
1152
1153         # except_domains is abolished; add as negated items to domains.
1154
1155         elsif ($name eq "except_domains" ||
1156                $name eq "domains")
1157           {
1158           if ($seen_domains)              # If already done with these
1159             {                             # omit, and following blanks.
1160             $i = &skipblanks($i);
1161             next;
1162             }
1163           $seen_domains = 1;
1164
1165           if (exists $o{"$prefix$driver.except_domains"})
1166             {
1167             &amalgamate("$prefix$driver.domains",
1168                          "$prefix$driver.except_domains", "",
1169               "domains", "+");
1170             }
1171           else
1172             {
1173             print STDOUT "$i1$origname$i2$origrest\n";
1174             }
1175           }
1176
1177         # except_local_parts is abolished; add as negated items to
1178         # local_parts.
1179
1180         elsif ($name eq "except_local_parts" ||
1181                $name eq "local_parts")
1182           {
1183           if ($seen_local_parts)              # If already done with these
1184             {                             # omit, and following blanks.
1185             $i = &skipblanks($i);
1186             next;
1187             }
1188           $seen_local_parts = 1;
1189
1190           if (exists $o{"$prefix$driver.except_local_parts"})
1191             {
1192             &amalgamate("$prefix$driver.local_parts",
1193                          "$prefix$driver.except_local_parts", "",
1194               "local_parts", "+");
1195             }
1196           else
1197             {
1198             print STDOUT "$i1$origname$i2$origrest\n";
1199             }
1200           }
1201
1202         # except_senders is abolished; add as negated items to senders
1203
1204         elsif ($name eq "except_senders" ||
1205                $name eq "senders")
1206           {
1207           if ($seen_senders)              # If already done with these
1208             {                             # omit, and following blanks.
1209             $i = &skipblanks($i);
1210             next;
1211             }
1212           $seen_senders = 1;
1213
1214           if (exists $o{"$prefix$driver.except_senders"})
1215             {
1216             &amalgamate("$prefix$driver.senders",
1217                          "$prefix$driver.except_senders", "",
1218               "senders", "+");
1219             }
1220           else
1221             {
1222             print STDOUT "$i1$origname$i2$origrest\n";
1223             }
1224           }
1225
1226         # This option has been renamed
1227
1228         elsif ($name eq "directory" && $driver_type eq "aliasfile")
1229           {
1230           $origname =~ s/directory/home_directory/;
1231           print STDOUT "# >> Option rewritten by convert4r3\n";
1232           print STDOUT "$i1$origname$i2$origrest\n";
1233           printf STDERR "\n%03d directory renamed as " .
1234             "home_directory in \"$driver\" director.\n",
1235             ++$count;
1236           }
1237
1238         # This option has been renamed
1239
1240         elsif ($name eq "directory" && $driver_type eq "forwardfile")
1241           {
1242           $origname =~ s/directory/file_directory/;
1243           print STDOUT "# >> Option rewritten by convert4r3\n";
1244           print STDOUT "$i1$origname$i2$origrest\n";
1245           printf STDERR "\n%03d directory renamed as " .
1246             "file_directory in \"$driver\" director.\n",
1247             ++$count;
1248           }
1249
1250         # This option has been renamed
1251
1252         elsif ($name eq "forbid_filter_log" && $driver_type eq "forwardfile")
1253           {
1254           $origname =~ s/log/logwrite/;
1255           print STDOUT "# >> Option rewritten by convert4r3\n";
1256           print STDOUT "$i1$origname$i2$origrest\n";
1257           printf STDERR "\n%03d forbid_filter_log renamed as " .
1258             "forbid_filter_logwrite in \"$driver\" director.\n",
1259             ++$count;
1260           }
1261
1262         # This option has been renamed
1263
1264         elsif ($name eq "directory" && $driver_type eq "localuser")
1265           {
1266           $origname =~ s/directory/match_directory/;
1267           print STDOUT "# >> Option rewritten by convert4r3\n";
1268           print STDOUT "$i1$origname$i2$origrest\n";
1269           printf STDERR "\n%03d directory renamed as " .
1270             "match_directory in \"$driver\" director.\n",
1271             ++$count;
1272           }
1273
1274         # mx_domains_except (and old synonym non_mx_domains) are abolished
1275         # (both lookuphost router and smtp transport)
1276
1277         elsif ($name eq "mx_domains" ||
1278                $name eq "mx_domains_except" ||
1279                $name eq "non_mx_domains")
1280           {
1281           if ($seen_mx_domains)              # If already done with these
1282             {                             # omit, and following blanks.
1283             $i = &skipblanks($i);
1284             next;
1285             }
1286           $seen_mx_domains = 1;
1287
1288           if (exists $o{"$prefix$driver.mx_domains_except"} ||
1289               exists $o{"$prefix$driver.non_mx_domains"})
1290             {
1291             $o{"$prefix$driver.mx_domains_except"} =
1292               &pair("$prefix$driver.mx_domains_except",
1293                     "$prefix$driver.non_mx_domains");
1294
1295             &amalgamate("$prefix$driver.mx_domains",
1296                         "$prefix$driver.mx_domains_except", "",
1297               "mx_domains", "+");
1298             }
1299           else
1300             {
1301             print STDOUT "$i1$origname$i2$origrest\n";
1302             }
1303           }
1304
1305         # This option has been renamed
1306
1307         elsif ($name eq "directory" && $driver_type eq "pipe")
1308           {
1309           $origname =~ s/directory/home_directory/;
1310           print STDOUT "# >> Option rewritten by convert4r3\n";
1311           print STDOUT "$i1$origname$i2$origrest\n";
1312           printf STDERR "\n%03d directory renamed as " .
1313             "home_directory in \"$driver\" director.\n",
1314             ++$count;
1315           }
1316
1317         # serialize_nets is abolished
1318
1319         elsif ($name eq "serialize_nets" ||
1320                $name eq "serialize_hosts")
1321           {
1322           if (!$seen_serialize)
1323             {
1324             &amalgamate("$prefix$driver.serialize_nets", "",
1325               "$prefix$driver.serialize_hosts", "serialize_hosts", "+");
1326             $seen_serialize = 1;
1327             }
1328           else
1329             {
1330             $i = &skipblanks($i);
1331             next;
1332             }
1333           }
1334
1335
1336         # Option not of interest; reproduce verbatim
1337
1338         else
1339           {
1340           print STDOUT "$i1$origname$i2$origrest\n";
1341           }
1342
1343
1344         $last_was_blank = 0;
1345         }
1346       }
1347     }
1348
1349   }
1350
1351 # Debugging: show the associative array
1352 # foreach $key (sort keys %o) { print STDERR "$key = $o{$key}\n"; }
1353
1354 print STDERR "\nEnd of configuration file conversion.\n";
1355 print STDERR "\n*******************************************************\n";
1356 print STDERR   "***** Please review the generated file carefully. *****\n";
1357 print STDERR   "*******************************************************\n\n";
1358
1359 print STDERR "In particular:\n\n";
1360
1361 print STDERR "(1) If you use regular expressions in any options that have\n";
1362 print STDERR "    been rewritten by this script, they might have been put\n";
1363 print STDERR "    inside quotes, when then were not previously quoted. This\n";
1364 print STDERR "    means that any backslashes in them must now be escaped.\n\n";
1365
1366 print STDERR "(2) If your configuration refers to any external files that\n";
1367 print STDERR "    contain lists of network addresses, check that the masks\n";
1368 print STDERR "    are specified as single numbers, e.g. /24 and NOT as dotted\n";
1369 print STDERR "    quads (e.g. 255.255.255.0) because Exim release 3.00 does\n";
1370 print STDERR "    not recognize the dotted quad form.\n\n";
1371
1372 print STDERR "(3) If your configuration uses macros for lists of domains or\n";
1373 print STDERR "    hosts or addresses, check to see if any of the references\n";
1374 print STDERR "    have been negated. If so, you will have to rework things,\n";
1375 print STDERR "    because the negation will apply only to the first item in\n";
1376 print STDERR "    the macro-generated list.\n\n";
1377
1378 print STDERR "(4) If you do not generate deliveries to pipes, files, or\n";
1379 print STDERR "    auto-replies in your aliasfile and forwardfile directors,\n";
1380 print STDERR "    you can remove the added transport settings.\n\n";
1381
1382 # End of convert4r3