path: root/comms/mgetty+sendfax/pkg-install

#!/usr/bin/perl

exit 0 if $ARGV[1] ne "POST-INSTALL";

print STDERR "\n\n\n =========== mgetty+sendfax configuration ================\n\n";
$prefix = $ENV{'PKG_PREFIX'};
$sep = "~";

&read_config ("$prefix/etc/mgetty+sendfax/mgetty.config");
foreach (keys(%var)) {
    $var_m{$_} = $var{$_};
    delete $var{$_};
}
&read_config ("$prefix/etc/mgetty+sendfax/sendfax.config");
foreach (keys(%var)) {
    $var_f{$_} = $var{$_};
}

$a = 1;
$devices = $var{'ports'} ? $var{'ports'} : "cuaa1";
while ($a) {
    $devices = &ask ("list of devices", $devices);

    $_ = $devices;
    $w = 0;
    foreach (split) {
    if (! -c "/dev/$_" ) {
        print STDERR "warning: device file /dev/$_ does not exist!\n";
        $w++;
    }
    }   
    if ($w) {
    $a = 0 if (&yesno ("are you sure?" , "n") eq "y");
    } else {
    $a = 0;
    }
}

open (TMP1, ">/tmp/mgetty.config.$$") || die "$!\n";
open (TMP2, ">/tmp/sendfax.config.$$") || die "$!\n";
$_ = join (":", $devices);
print TMP2 "fax-devices $_\n\n";

$_ = $devices;

foreach $port (split) {
    print STDERR "\n\n   *** Configuring for port $port ***\n\n";
    print TMP1 "\nport $port\n";
    print TMP2 "\nport $port\n";
    &setdef ($port);
again:
    &inq_m;
    $settings_m = $settings;
    &inq_f;
    $settings_f = "fax-id modem-type switchbd $settings";
    goto again if (&confirm ($port) ne "y");
    &write_tmp;
}

close (TMP1);
close (TMP2);
if ( -e "$prefix/etc/mgetty+sendfax/mgetty.config") {
    system ("mv -f $prefix/etc/mgetty+sendfax/mgetty.config $prefix/etc/mgetty+sendfax/mgetty.config.old");
    system ("rm -f $prefix/etc/mgetty+sendfax/mgetty.config");
}
if ( -e "$prefix/etc/mgetty+sendfax/sendfax.config") {
    system ("mv -f $prefix/etc/mgetty+sendfax/sendfax.config $prefix/etc/mgetty+sendfax/sendfax.config.old");
    system ("rm -f $prefix/etc/mgetty+sendfax/sendfax.config");
}
system ("mv -f /tmp/mgetty.config.$$ $prefix/etc/mgetty+sendfax/mgetty.config");
system ("mv -f /tmp/sendfax.config.$$ $prefix/etc/mgetty+sendfax/sendfax.config");

open (F, ">$prefix/etc/mgetty+sendfax/faxheader");
print F "\n      FAX  FROM:  **not configured** $def{fax-id}     TO: \@T\@    PAGE: \@P\@ OF \@M\@ \n";
close (F);


print STDERR "\n\nediting /etc/ttys...\n";

open (F, "/etc/ttys");
@ttys = <F>;
close (F);

foreach $tty (@ttys) {
    $_ = $devices;
    foreach $port (split) {
    if ($tty =~ /^\s*$port/) {
        print STDERR "replacing line $tty";
        $tty = "$port\t\"$prefix/sbin/mgetty\"\tunknown on insecure\n";
        $replaced{$port} = 1;
    }
    }
}
$_ = $devices;
foreach $port (split) {
    if (!$replaced{$port}) {
    print STDERR "adding port $port\n";
    push (@ttys, "$port\t\"$prefix/sbin/mgetty\"\tunknown on insecure\n");
    }
}
system ("mv -f /etc/ttys /etc/ttys.old");
open (F, ">/etc/ttys");
print F @ttys;
close (F);


exit 0;

sub confirm {
    $_ = shift;
    print STDERR "\n\n\tSettings for port $_\n\t------------------------\n";
    $_ = $settings_m;
    foreach (split) {
    print STDERR "\t$_ $def{$_}\n" if ($def{$_});
    }
    $_ = $settings_f;
    foreach (split) {
    print STDERR "\t$_ $def_f{$_}\n" if ($def_f{$_});
    }
    return &yesno ("OK?", "y");
}
    
sub write_tmp {
    $_ = $settings_m;
    foreach (split) {
    print TMP1 "$_ $def{$_}\n" if ($def{$_});
    }
    $_ = $settings_f;
    foreach (split) {
    print TMP2 "$_ $def_f{$_}\n" if ($def_f{$_});
    }
}

sub inq_m {
    $settings = "debug";
    $def{'debug'} = 4 if !$def{'debug'};
    $def{'debug'} = &ask ("   - `debug (mgetty)' 
     This sets the amount of logging `mgetty' will do. A good value is
     4, more details are seen with `5', and `9' is really noisy.  Try
     it! The log data is written to the file `/tmp/log_mg.cuaxx'.", 
              $def{'debug'});

    $settings .= " fax-id";
    $def{'fax-id'} = "00 00 000000" if ! $def{'fax-id'};
    $def{'fax-id'} = &ask ("   - `fax-id'
     This sets the fax station ID used in fax mode to identify your
     site to the caller (usually this is simply your fax phone number).
     ", $def{'fax-id'}) ;
    $def_f{'fax-id'} = $def{'fax-id'} ;

    $settings .= " speed";
    $def{'speed'} = 38400 if !$def{'speed'};
    $def{'speed'} = &ask ("   - `speed'
     Specify, as integer value, the port speed to use. Default is
     38400. If the given speed is not valid, `mgetty' complains loudly 
     and exits.", $def{'speed'});

    $settings .= " switchbd";
    $def{'switchbd'} = 0 if !$def{'switchbd'};
    $def{'switchbd'} = &ask ("   - `switchbd'
     Some modems, mainly Rockwell chipsets, switch to 19200 bps when
     entering fax mode. Others may need other speed switches (but I
     know none).  If your modem is Rockwell based, try `switchbd 19200'
     if fax reception doesn't work. (*Warning:* if this is set wrongly,
     fax reception will definitely fail. For most sane modems, you do
     *not need* this.). Set speed or `0'", $def{'switchbd'});
    $def_f{'switchbd'} = $def{'switchbd'};

    $settings .= " direct";
    $def{'direct'} = "NO" if !$def{'direct'};
    $def{'direct'} = &ask ("   - `direct' 
     Tells mgetty that it is running on a direct line. Mgetty won't try
     to initialize any modem, nor will it wait for `RING'. It will just
     wait for any character, and then output the issue file and login
     prompt. This option is used if you want to connect to machines via
     nullmodem cable.",  $def{'direct'});

    $settings .= " blocking";
    $def{'blocking'} = "NO" if !$def{'blocking'};
    $def{'blocking'} = &ask ("   - `blocking' 
     Tells mgetty to open the device in `blocking' mode, that is, the
     `open()' system call won't succeed until carrier detect is set.
     This is set if `mgetty' is called as `getty'. I'm not sure whether
     it's very useful, but I include it for completeness", $def{'blocking'});

    $settings .= " port-owner";
    $def{'port-owner'} = "uucp" if !$def{'port-owner'};
    $def{'port-owner'} =  &ask ("   - `port-owner'
     If set, mgetty will `chown' the tty line to the given username (you
     can specify a string or an integer uid, but the integer must be
     valid).  This is highly recommended for security purposes: only
     give port access to those users you trust not to misuse your modem
     lines!",   $def{'port-owner'});

    $settings .= " port-group";
    $def{'port-group'} = "uucp" if !$def{'port-group'};
    $def{'port-group'} = &ask ("   - `port-group' 
     If set, mgetty will `chgrp' the tty line to this group id (which
     can be given as group name, or as integer gid). If it's not given,
     or not valid, the primary group id of `port-owner' 
     will be used.", $def{'port-group'});

    $settings .= " port-mode";
    $def{'port-mode'} = "0660" if !$def{'port-mode'};
    $def{'port-mode'} = &ask ("   - `port-mode'
     Specifies the permissions to `chmod' the device to. 
     *Never* make a modem device world-accessible, better use `0660'
     or even `0600'.", $def{'port-mode'} );
   
    $settings .= " toggle-dtr";
    $def{'toggle-dtr'} = "YES" if !$def{'toggle-dtr'};
    $def{'toggle-dtr'} = &ask ("   - `toggle-dtr'
     Tells mgetty whether it should lower the DTR line upon startup to
     reset modem. Default is `yes', but some (few) modems react
     allergic to that and crash.", $def{'toggle-dtr'});

    $settings .= " toggle-dtr-waittime";
    $def{'toggle-dtr-waittime'} = 500 if !$def{'toggle-dtr-waittime'};
    $def{'toggle-dtr-waittime'} = &ask ("   - `toggle-dtr-waittime'
     Specifies the time (in ms) to hold the DTR line low.", $def{'toggle-dtr-waittime'} );

    $settings .= " data-only";
    $def{'data-only'} = "NO" if !$def{'data-only'};
    $def{'data-only'} =&ask ("   - `data-only'
     Tells `mgetty' to forget about faxing and only use the data part of
     the modem. Default is `false'. You need this if your modem can't
     distinguish incoming fax and data calls.", $def{'data-only'} );

    $settings .= " fax-only";
    $def{'fax-only'} = "NO" if !$def{'fax-only'};
    $def{'fax-only'} = &ask ("   - `fax-only'
     Tells `mgetty' to put the modem in fax-only mode. You need this if
     your modem can't distinguish incoming fax and data calls, but you
     need fax more important than data; and you need it if you want to
     disable data calls for security reasons (this could be achieved
     via `login.config' as well)", $def{'fax-only'});

    $settings .= " modem-type";
    $def{'modem-type'} = "auto" if ! $def{'modem-type'};
    $def{'modem-type'} = &ask ("   - `modem-type'
     Specifies the kind of modem connected to the port. Valid options are:
        * auto
          Mgetty will detect the modem type itself (which may occasionally
           be not desirable, or it may fail on old modem equipment).
        * c2.0
          Modem is a CLASS 2.0 fax mode. Works better than class 2, if
          both are available, because its better standardized. Known to
          work with USR and ZyXEL.
        * cls2
          Modem is a CLASS 2 fax modem, mgetty will not try class 2.0.
        * data
          Do not try fax initialization
     There is no way (yet) to tell mgetty to use *only* fax mode and
     refuse data calls with this option, use the `fax-only true'
     statement for that.", $def{'modem-type'});
    $def_f{'modem-type'} = $def{'modem-type'};

    $settings .= " init-chat";
    $def{'init-chat'} = '"" ATS0=0Q0&D3&C1 OK' if ! $def{'init-chat'};
    $def{'init-chat'} = &ask ("   - `init-chat' 
     Tells mgetty the chat sequence to use for initializing the modem.
     *Warning*: the sequence starts with *expect*, which will in most
     cases be `\"\"' (nothing). This ordering was chosen because UUCP
     does it this way, and I wanted to avoid confusion here.

     Example:

         \"\" \\d\\d\\d+++\\d\\d\\dATQ0E1V1H0 OK ATL0M0S0=0 OK AT&K3 OK
    init sequence", $def{'init-chat'});     

    $settings .= " force-init-chat";
    $def{'force-init-chat'} = "" if !$def{'force-init-chat'};
    $def{'force-init-chat'} = &ask ("   - `force-init-chat'
     In some cases, the modem can get stuck in a mode where it won't
     react to a simple `AT' command. Usually this happens because the
     modem is set to ignore a DTR drop and still has a data connection
     to the other side. If you use a voice modem, it could be stuck in
     voice mode.

     In these situations, the normal `init-chat' will time out, because
     the modem won't send the proper responses back.

     To get the modem back into a sane state, you can use the
     `force-init-chat' chat sequence. The default setup will send the
     DLE ETX characters, to get voice modems back to life, and then the
     `(pause)+++(pause)ATH0' sequence to get the modem back from data
     mode to command mode.

     You could prepend this sequence to `init-chat' (it wouldn't harm),
     but especially the pauses around the +++ sequence makes this
     undesirable slow.", $def{'force-init-chat'});

    $settings .= " modem-check-time";
    $def{'modem-check-time'} = 3600 if ! $def{'modem-check-time'};
    $def{'modem-check-time'} = &ask ("   - `modem-check-time'
     Some modems have the nasty tendency to crash silently. With this
     option, you tell `mgetty' to check every SECONDS seconds with a
     simple `AT...OK' sequence whether the modem still reacts. If not,
     `mgetty' will restart itself and do a full modem reset.", $def{'modem-check-time'});

    $settings .= " rings";
    $def{'rings'} = 1 if !$def{'rings'};
    $def{'rings'} = &ask ("   - `rings' 
     Sets the number of `RING' messages to wait for, before mgetty
     picks up the phone. *Warning:* if your modem  auto-answers, for 
     whatever reason, set this to something  *different* than the 
     value set with `ATS0=mmm', otherwise the  modems autoanswer and 
     mgettys manual answer will collide (most  modems hang up if a 
     command is received during auto-answer)", $def{'rings'});

  
    $settings .= " answer-chat";
    $def{'answer-chat'} = '"" ATA CONNECT \c \r' if !$def{'answer-chat'};
    $def{'answer-chat'} =&ask ("   - `answer-chat'
     This is the command sequence that is used to answer a phone call.
     Usually you can leave it at the default ` \"\" ATA CONNECT \\c \\r ',
     but for some modems you need `ATS0=1' in place of `ATA' (ATA not
     allowed). The extra `\\r' expect string is needed that the code can
     grab the full CONNECT XYZ\\R string. It will work without the \\r,
     but then the logging information will be less detailed. *Right now,
     \\r won't work at all, it's not implemented yet. Don't use it.*
     ", $def{'answer-chat'} );

    $settings .= " answer-chat-timeout";
    $def{'answer-chat-timeout'} = 80 if !$def{'answer-chat-timeout'};
    $def{'answer-chat-timeout'} = &ask ("   - `answer-chat-timeout' 
     During the ANSWER-CHAT, each \"expect\" string must be seen in the
     time specified here. Default is 80 seconds. This time should be at
     least some 5 seconds longer than the time set with the `ATS7=...'
     modem setup command.", $def{'answer-chat-timeout'});

    $settings .= " autobauding";
    $def{'autobauding'} = "NO" if !$def{'autobauding'};
    $def{'autobauding'} = &ask ("  - `autobauding'
     Some modems switch their DTE line speed to the communication line
     speed after connecting, e.g., after sending `CONNECT 2400', the
     modem switches to 2400 bps. Newer modems usually have a switch to
     \"lock\" a DTE baud rate, which is strongly recommended. If your
     modem insists on doing this speed switch, setting `autobauding' to
     YES will make mgetty behave accordingly.", $def{'autobauding'});

    $settings .= " ringback";
    $def{'ringback'} = "NO" if !$def{'ringback'} ;
    $def{'ringback'} = &ask ("   - `ringback'
     If you have to put your modem and your telephone on the same phone
     line, you can switch on \"ringback\" or \"ring-twice\". This means,
     mgetty won't answer the phone on the first call, but remember the
     call, and pick up on the second call (if it comes in the time
     specified by `ringback-time').", $def{'ringback'} );

    $settings .= " ringback-time";
    $def{'ringback-time'} = "30" if !$def{'ringback-time'} ;
    $def{'ringback-time'} = &ask ("  - `ringback-time'
     This setting specifies how much time may pass between the first
     and the second call if \"ringback\" is active.", $def{'ringback-time'});

    $settings .= " ignore-carrier";
    $def{'ignore-carrier'} = "false" if !$def{'ignore-carrier'} ;
    $def{'ignore-carrier'} = &ask ("   - `ignore-carrier'

     If your Modem does not assert the DCD (carrier detect) line, or the
     serial port or cable or serial driver is broken, it is possible
     that `mgetty' or `login' will block after a successful CONNECT
     (that means: everything seems to work, but suddenly nothing is sent
     to the port anymore. Depending on the operating system used, this
     can be before printing the `/etc/issue' file or not before printing
     the `password:' prompt.

     To work around this, you can switch off the carrier detection in
     software: set `ignore-carrier true'. Default is `false'.

     *WARNING:* If you use this, your system won't be able to detect
     when a caller just hangs up instead of cleanly logging out. This
     may result in hanging modems, etc.", $def{'ignore-carrier'});

    $settings .= " issue-file";
    $def{'issue-file'} = "/etc/issue" if !$def{'issue-file'} ;
    $def{'issue-file'} = &ask ("   - `issue-file'
     This is the file printed before the login prompt.", $def{'issue-file'});

    $settings .= " prompt-waittime";
    $def{'prompt-waittime'} = "500" if !$def{'prompt-waittime'} ;
    $def{'prompt-waittime'} = &ask ("   - `prompt-waittime'
     This specifies how long `mgetty' will wait for modem and line to
     settle down (in ms) before printing issue file and login prompt",
                    $def{'prompt-waittime'});

    $settings .= " login-prompt";
    $def{'login-prompt'} = "@!login: " if !$def{'login-prompt'} ;
    $def{'login-prompt'} =  &ask("   - `login-prompt'
     This specifies the login prompt that mgetty will output. Some
     special characters in this string (and in the issue file, btw) are
     recognized and replaced by something else:
        * @ system name
        * \\n newline
        * \\r carriage return
        * \\g bell
        * \\b backspace (ascii 010)
        * \\f form feed (ascii 013)
        * \\t TAB
        * \\P (and \\L) port name (e.g. ttyS0)
        * \\C date and time, in \"ctime()\" format
        * \\I Connection string (e.g. 2400/REL)
        * \\N (and \\U) number of users currently logged in
        * \\S Port speed (e.g. 38400)
        * \\D current date in dd/mm/yy format
        * \\T current time in hh:mm:ss format
        * \\DIGIT character with the specified octal code

     The maximum lenght of the login prompt is limited to 140
     characters (after expansion).", $def{'login-prompt'});

    $settings .= " login-time";
    $def{'login-time'} = 240 if !$def{'login-time'};
    $def{'login-time'} = &ask ("   - `login-time'
     This specifies the maximum time the user can take to log in. If no
     login has occured after that time, `mgetty' will hang up.", 
                   $def{'login-time'});

    $settings .= " fax-server-file";
    $def{'fax-server-file'} = &ask ("   - `fax-server-file'
     Specifies the fax file(s) that is to be sent if someone else calls
     your modem in *fax polling mode*, that is, the caller *receives* a
     document.

     Normally, the file given is a text file, containing the list of G3
     files to send to the calling machine, one file per line. Comment
     lines (starting with \"#\") are ignored. For backward compatibility,
     `mgetty' does check whether the named file is a G3 file itself, in
     which case this file is sent directly (but then, you can only send
     one page).

     Not all modems support fax poll *server* mode, I know that the
     ZyXEL and MultiTech do.", $def{'fax-server-file'});

    $settings .= " diskspace";
    $def{'diskspace'} = 1024 if !$def{'diskspace'};
    $def{'diskspace'} = &ask ("   - `diskspace'
     This setting tells mgetty the minimum amount of disk space (in KB) that
     has to be available in the fax spool directory for fax reception
     to be allowed.",  $def{'diskspace'});

    $settings .= " notify";
    $def{'notify'} = "faxadmin" if !$def{'notify'};
    $def{'notify'} = &ask ("   - `notify'
     This is the address that will get mails if a fax is received. Not
     fully tested.", $def{'notify'});

    $settings .= " fax-owner";
    $def{'fax-owner'} = "uucp" if !$def{'fax-owner'};
    $def{'fax-owner'} =  &ask ("   - `fax-owner'
     If set, mgetty will `chown' the received files to the given username 
     (you can specify a string or an integer uid, but the integer must be
     valid).",  $def{'fax-owner'});

    $settings .= " fax-group";
    $def{'fax-group'} = "modem" if !$def{'fax-group'};
    $def{'fax-group'} = &ask ("   - `fax-group' 
     If set, mgetty will `chgrp' the received files to this group id
     (which  can be given as group name, or as integer gid).", $def{'fax-group'});

    $settings .= " fax-mode";
    $def{'fax-mode'} = "0660" if !$def{'fax-mode'};
    $def{'fax-mode'} = &ask ("   - `fax-mode'
     Specifies the permissions to `chmod' the received files.", $def{'fax-mode'});
}
sub inq_f {
    $settings = "debug";
    $def_f{'debug'} = 4 if !$def_f{'debug'};
    $def_f{'debug'} = &ask ("   - `debug (sendfax)' 
     controls the amount of information written into the fax log file.
     `0' means \"totally silent\" (not even  errors are written), `9' 
     is really noisy. I usually use `3' or `4' in normal use, and `6' 
     for debugging.", $def_f{'debug'});

    $settings .= " modem-init";
    $def{'modem-init'} = &ask ("   - `modem-init' 
     Specifies an `AT...' command that is to be sent to the modem right
     at the *beginning* of all modem talk (even before setting the modem
     into fax mode, so this could be an `ATZ' if you want to reset the
     modem).", "");

    $settings .= " modem-handshake";
    $def_f{'modem-handshake'} = "AT&H3" if !$def_f{'modem-handshake'};
    $def_f{'modem-handshake'} = &ask ("   - `modem-handshake'
     Specifies an `AT...' command that will be sent to the modem at the
     *end* of the modem initialization, right before dialing. *Do not
     use ATZ or such here*, since resetting the modem will switch off
     fax mode.", $def_f{'modem-handshake'});

    $settings .= " max-tries";
    $def_f{'max-tries'} = 3 if !$def_f{'max-tries'};
    $def_f{'max-tries'} = &ask ("   - `max-tries'
     Specify the maximum number of tries per page if the receiving end
     reports reception errors. If NNN tries do not suffice to
     successfully transmit a page, `sendfax' will give up or simply go
     on, depending on the setting of `max-tries-continue' (see below).
     If this is set to `0', `sendfax' will ignore retransmission
     requests and simply go on.",  $def_f{'max-tries'});

    $settings .= " max-tries-continue";
    $def_f{'max-tries-continue'} = "YES" if !$def_f{'max-tries-continue'};
    $def_f{'max-tries-continue'} = &ask ("   - `max-tries-continue' 
     After the maximum number of tries for one page are reached,
     `sendfax' can report an error and abort (`max-tries-continue NO'),
     or go on with the next page (YES).

     For \"mission critical\" faxes, I'd set it to NO, but since the page
     quality is most often quite good even if reported as \"page bad\",
     the default is YES.", $def_f{'max-tries-continue'});

    $settings .= " speed (fax)";
    $def_f{'speed'} = 38400 if ! $def_f{'speed'};
    $def_f{'speed'} = &ask ("   - `speed'
     Set the port speed to use for fax send operations. Usually,
     `38400' is a good choice, but a few dumb modems (for example, some
     based on rockwell chipsets) need `19200' or even `9600'. A few
     modems can go higher, but `sendfax' may not support it, and it may
     not always work.",  $def_f{'speed'});

    $settings .= " dial-prefix";
    $def_f{'dial-prefix'} = "ATD" if !$def_f{'dial-prefix'};
    $def_f{'dial-prefix'} = &ask ("   - `dial-prefix'
     This is the command used for dialing out. Usually this will be
     something simple, as `ATD' or `ATDP', but if you have an unusual
     setup, it could also be something like `ATX0DP0;X4DT' (meaning:
     switch off dial-tone detection, pulse-dial `0', back to command
     mode, switch on dial-tone detection, and go ahead dialing with
     touch tones). The phone number will be sent right after the
     `dial-prefix'.", $def_f{'dial-prefix'});

    $settings .= " poll-dir";
    $def_f{'poll-dir'} = "./" if !$def_f{'poll-dir'};
    $def_f{'poll-dir'} = &ask ("   - `poll-dir'
     This is used to specify a directory where polled faxes (wheather
     maps and such) are to be saved into. Default is the current
     directory.", $def_f{'poll-dir'});

    $settings .= " normal-res";
    $def_f{'normal-res'} = "NO" if !$def_f{'normal-res'};
    $def_f{'normal-res'} = &ask ("   - `normal-res'
     If set to `yes' or `true' (boolean), `sendfax' won't attempt to
     make a fax connection in \"fine resolution\" mode. Normally you
     won't need to use that option, since `faxrunq' will set the `-n'
     switch if needed.", $def_f{'normal-res'});

    $settings .= " verbose";
    $def_f{'verbose'} = "NO" if !$def_f{'verbose'};
    $def_f{'verbose'} = &ask ("   - `verbose' 
     If set to `yes' or `true', `sendfax' will output progress reports
     on stdout, if set to `no', `sendfax' will only print error and
     warning messages.", $def_f{'verbose'});
}
sub setdef {
    local ($p, $l);
    $p = shift;
    $l = length ($p) + 1;
    foreach (keys(%var_m)) {
    $def{$_} = substr ($var_m{$_}, $l) if ($var_m{$_} =~ /^$p/);
    }
    foreach (keys(%var_m)) {
    $def{$_} = substr ($var_m{$_}, 1) if (!$def{$_} && $var_m{$_} =~ /^$sep/);
    }
    foreach (keys(%var_f)) {
    $def_f{$_} = substr ($var_f{$_}, $l) if ($var_f{$_} =~ /^$p/);
    }
    foreach (keys(%var_m)) {
    $def_f{$_} = substr ($var_f{$_}, 1) if (!$def_f{$_} && $var_f{$_} =~ /^$sep/);
    }
}
sub ask {
    ($info, $default, $x) = @_;
    print STDERR "\n$info: ";
    print STDERR "[$default] " if ($default);
    $_ = <STDIN>;
    s/^\s*//;
    chop;
    if ($_ eq "") {
    return $default;
    }
    return $_;
}
sub read_config {
    local ($conf, $port, $a, $b);

    $conf = shift;
    $port = $sep;
    if ( -f $conf) {
    open (F, $conf) || die "$!\n";
    while (<F>) {
        chop;
        s/^\s*//;
        next if /^#/;
        next if /^$/;
        ($a, $b) = split (/[ \t\n]+/, $_, 2);
        if ($a eq "port") {
        $port = $b;
        $var{'ports'} .= "$port ";
        } else {
        $var{$a} = "$port $b";
        }
    }
    close F;
    }
}

sub yesno {
    print STDERR "$_[0]: ";
    print STDERR "[$_[1]] " if ($_[1]);
    $_ = <STDIN>;
    chop;
    $_ = $_[1] if ! $_;
    return "y" if /^[Yy].*/;
    return "n";
}