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