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