#!/bin/sh
#----------------------------------------------------------------------------
# /var/install/bin/mail-update - update or generate new mail configuration
#
# Copyright (c) 2001-2002 Frank Meyer <frank(at)eisfair(dot)org>
#
# Creation:     15.02.2003  jed
# Last Update:  $Id$
#
# Parameters:
#
#     mail-update [import]   - import pop3/imap users from csv file $read_pop3imap_users
#     mail-update [export]   - export pop3/imap users to csv file $read_pop3imap_users
#     mail-update [test]     - read $mailfile.new create test configuration file mk_mail.test
#     mail-update [update]   - read $mailfile.import and check/update configuration file
#
#     mail-update [basic]    - create basic configuration file
#     mail-update [advanced] - create advanced configuration file
#     mail-update [merge]    - merge $fullile and $basicfile configuration
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#----------------------------------------------------------------------------

#------------------------------------------------------------------------------
# return string of spaces
# $1  - name of variable
# $2  - length of string - length of variable ($1)
# ret - string of spaces
#------------------------------------------------------------------------------
spaces ()
{
    varname=$1
    varlen=${#varname}
    explen=$2
    if [ "$explen" = "" ]
    then
        # empty string
        explen=$varname
        varlen=0
    fi

    if [ $explen -gt $varlen ]
    then
        # string should be extended
        strlen=`expr $explen - $varlen`

        # fixed spaces string - 60 character long (fast method)
        spacestr="                                                            "
        echo "${spacestr:0:$strlen}"

        # variable spaces string loop (slow method)
#       idx=1
#       while [ $idx -le $strlen ]
#       do
#           echo -e " \c"
#           idx=`expr $idx + 1`
#       done
#       echo
    fi
}

#------------------------------------------------------------------------------
# return string with no spaces
# $1  - string to format
# $2  - action: left, right, both [ optional, default: both]
# ret - string with no leading, no trailing or no leading and no trailing spaces
#------------------------------------------------------------------------------
trim_spaces ()
{
    case $2 in
        left|l )
            echo "$1"|sed -e 's/^ *//'
            ;;
        right|r )
            echo "$1"|sed -e 's/ *$//'
            ;;
        all|a )
            echo "$1"|sed -e 's/ //g'
            ;;
        * ) # both | l
            echo "$1"|sed -e 's/^ *//' -e 's/ *$//'
            ;;
    esac
}

#------------------------------------------------------------------------------
# return random character from array
# ret - random character
#------------------------------------------------------------------------------
random_char ()
{
    # array of allowed characters
    # first character is a placebo and will never be used
    chars=(a a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9 \. \-)

    # initialize random number
    RANDOM=$$$(date +%s)

    nbr=$[ ( $RANDOM % 64 ) + 1 ]
    echo ${chars[$nbr]}
}

#------------------------------------------------------------------------------
# rename variables
#------------------------------------------------------------------------------
rename_variables ()
{
    renamed=0
    mecho -warn "renaming parameter(s) ..."
    
    # v1.1.2
    if [ ! -z "`grep ^SMTP_SMART_HOST $source_conf`" ]
    then
        echo "- SMTP_SMART_HOST -> SMTP_SMARTHOST_1_HOST"
        SMTP_SMARTHOST_1_HOST="$SMTP_SMART_HOST"
        renamed=1
    fi    
    
    if [ ! -z "`grep ^SMTP_SMART_HOST_AUTH $source_conf`" ]
    then
        echo "- SMTP_SMART_HOST_AUTH -> SMTP_SMARTHOST_1_AUTH_TYPE"
        SMTP_SMARTHOST_1_AUTH_TYPE="$SMTP_SMART_HOST_AUTH"
        renamed=1
    fi    

    if [ ! -z "`grep ^SMTP_SMART_HOST_USER $source_conf`" ]
    then
        echo "- SMTP_SMART_HOST_USER -> SMTP_SMARTHOST_1_USER"
        SMTP_SMARTHOST_1_USER="$SMTP_SMART_HOST_USER"
        renamed=1
    fi    

    if [ ! -z "`grep ^SMTP_SMART_HOST_PASS $source_conf`" ]
    then
        echo "- SMTP_SMART_HOST_PASS -> SMTP_SMARTHOST_1_PASS"
        SMTP_SMARTHOST_1_PASS="$SMTP_SMART_HOST_PASS"
        renamed=1
    fi    

    if [ ! -z "`grep ^SMTP_SMART_HOST_FORCE_AUTH $source_conf`" ]
    then
        echo "- SMTP_SMART_HOST_FORCE_AUTH -> SMTP_SMARTHOST_1_FORCE_AUTH"
        SMTP_SMARTHOST_1_FORCE_AUTH="$SMTP_SMART_HOST_FORCE_AUTH"
        renamed=1
    fi    

    if [ ! -z "`grep ^SMTP_SMART_HOST_FORCE_TLS $source_conf`" ]
    then
        echo "- SMTP_SMART_HOST_FORCE_TLS -> SMTP_SMARTHOST_1_FORCE_TLS"
        SMTP_SMARTHOST_1_FORCE_TLS="$SMTP_SMART_HOST_FORCE_TLS"
        renamed=1
    fi    

    # v.1.1.4
    if [ ! -z "`grep ^SMTP_ALIAS_N $source_conf`" ]
    then
        echo "- SMTP_ALIAS_N -> SMTP_ALIASES_1_ALIAS_N"
        SMTP_ALIASES_1_ALIAS_N="$SMTP_ALIAS_N"
        renamed=1
    fi    

    if [ $SMTP_ALIASES_1_ALIAS_N -eq 0 ]
    then
        imax=2
    else
        imax=$SMTP_ALIASES_1_ALIAS_N
    fi

    idx=1
    while [ $idx -le $imax ]
    do
        if [ ! -z "`grep ^SMTP_ALIAS_$idx $source_conf`" ]
        then
        eval alias_old='$SMTP_ALIAS_'$idx
        eval alias_new="SMTP_ALIASES_1_ALIAS_$idx"

            echo "- SMTP_ALIAS_$idx -> SMTP_ALIASES_1_ALIAS_$idx"
            eval "$alias_new=\"$alias_old\""
            renamed=1
        fi
        idx=`expr $idx + 1`
    done

    if [ ! -z "`grep ^EXISCAN_UNPACK_MIME $source_conf`" ]
    then
        echo "- EXISCAN_UNPACK_MIME -> EXISCAN_DEMIME_ENABLED"
        EXISCAN_DEMIME_ENABLED="$EXISCAN_UNPACK_MIME"
        renamed=1
    fi    

    if [ ! -z "`grep ^EXISCAN_SPAMD_TRESHOLD $source_conf`" ]
    then
        echo "- EXISCAN_SPAMD_TRESHOLD -> EXISCAN_SPAMD_THRESHOLD"
        EXISCAN_SPAMD_THRESHOLD="$EXISCAN_SPAMD_TRESHOLD"
        renamed=1
    fi    

    if [ $renamed = 1 ]
    then
        mecho -warn "... read documentation for renamed parameter(s)!"
        /var/install/bin/anykey
    else
        mecho -warn "... nothing to do."
    fi    
}

#------------------------------------------------------------------------------
# modify variables
#------------------------------------------------------------------------------
modify_variables ()
{
    modified=0
    mecho -warn "modifying parameter(s) ..."
    
    if [ "$FETCHMAIL_LIMIT" = "" ]
    then
        echo "- FETCHMAIL_LIMIT, '' -> will now be interpreted as 4096000 bytes!"
        modified=1
    fi

    salt_len=16
    if [ "$EXISCAN_CRYPT_SALT" = "" -o `echo $EXISCAN_CRYPT_SALT|wc -L` -lt $salt_len ]
    then
        # create random crypt salt and add mail hostname
        idx=1
        randsalt=""
        while [ $idx -le $salt_len ]
        do
            randsalt="$randsalt`random_char`"
            idx=`expr $idx + 1`
        done

        echo "- EXISCAN_CRYPT_SALT, '$EXISCAN_CRYPT_SALT' -> '$randsalt'"
        EXISCAN_CRYPT_SALT="$randsalt"
        modified=1
    fi

    if [ "$EXISCAN_SPAMD_ACTION" = "redirect spam" ]
    then
        echo "- EXISCAN_SPAMD_ACTION, 'redirect spam' -> 'redirect spam@$SMTP_QUALIFY_DOMAIN'"
        EXISCAN_SPAMD_ACTION="redirect spam@$SMTP_QUALIFY_DOMAIN"
        modified=1
    fi    

    if [ -f /tmp/mail-prev-ver-1.1.6 -a "$SMTP_AUTH_TYPE" = "user" -a "$POP3IMAP_USE_MAILONLY_PASSWORDS" = "yes" ]
    then
        # display message if previous version is older than v1.1.6
        rm -f /tmp/mail-prev-ver-1.1.6

        echo "- SMTP_AUTH_TYPE='user' and POP3IMAP_USE_MAILONLY_PASSWORDS='yes' have been set,"
        echo "  therefor the mail only passwords will now be taken instead of the system passwords"
        echo "  for SMTP authentication. Please make sure that you modify the mail client settings!"
        modified=1
    fi    

    # v1.1.8
    exi_str1=`grep ^EXISCAN_AV_DESCRIPTION $source_conf|cut -d'=' -f2|cut -d'#' -f1`
    exi_str1="`echo $exi_str1`"
    exi_str2="\'\(\.\*\)\'"

    if [ "$exi_str1" = "$exi_str2" ]
    then
        echo "- EXISCAN_AV_DESCRIPTION, \'\(\.\*\)\' -> \"'(.*)'\""
        EXISCAN_AV_DESCRIPTION="'(.*)'"
        modified=1
    fi

    # v1.1.10
    # rename exiscan parameter
    if [ "$EXISCAN_AV_SCANNER" = "clamav" ]
    then
        echo "- EXISCAN_AV_SCANNER, 'clamav' -> 'clamd'"
        EXISCAN_AV_SCANNER="clamd"
        modified=1
    fi    

    # check variables for value 'blackhole' and replace it
    for exi_var in EXISCAN_DEMIME_ACTION EXISCAN_AV_ACTION EXISCAN_EXTENSION_ACTION EXISCAN_REGEX_ACTION EXISCAN_SPAMD_ACTION
    do
        eval exi_val=\$$exi_var

        if [ "$exi_val" = "blackhole" ]
        then
            # replace 'blackhole' by 'discard'
            echo "- $exi_val, 'blackhole' -> 'discard'"
            eval ${exi_var}="discard"
            modified=1
        fi
    done

    # check variables for '|' sign and replace it
    echo "$EXISCAN_AV_OPTIONS"|grep \| > /dev/null

    if [ $? -eq 0 ]
    then
        exi_new="`echo "$EXISCAN_AV_OPTIONS"|sed -e 's/|/%%s/'`"
        echo "- EXISCAN_AV_OPTIONS, '$EXISCAN_AV_OPTIONS' -> '$exi_new'"
        EXISCAN_AV_OPTIONS="$exi_new"
        modified=1
    fi

    # check variables for '.' sign and replace it
    echo "$EXISCAN_SPAMD_THRESHOLD"|grep "\." > /dev/null

    if [ $? -ne 0 ]
    then
        exi_new="$EXISCAN_SPAMD_THRESHOLD.0"
        echo "- EXISCAN_SPAMD_THRESHOLD, '$EXISCAN_SPAMD_THRESHOLD' -> '$exi_new'"
        EXISCAN_SPAMD_THRESHOLD="$exi_new"
        modified=1
    fi

    if [ $modified = 1 ]
    then
        mecho -warn "... read documentation for modified parameter(s)!"
        /var/install/bin/anykey
    else    
        mecho -warn "... nothing to do."
    fi
}

#------------------------------------------------------------------------------
# add variables
#------------------------------------------------------------------------------
add_variables ()
{
    added=0
    mecho -warn "adding new parameter(s) ..."

    # v1.1.2
    if [ -z "`grep ^SMTP_ALLOW_EXIM_FILTERS $source_conf`" ]
    then
        echo "- SMTP_ALLOW_EXIM_FILTERS='no'"
        SMTP_ALLOW_EXIM_FILTERS='no'
        added=1
    fi    

    if [ -z "`grep ^SMTP_SMARTHOST_ONE_FOR_ALL $source_conf`" ]
    then
        echo "- SMTP_SMARTHOST_ONE_FOR_ALL='yes'"
        SMTP_SMARTHOST_ONE_FOR_ALL='yes'
        added=1
    fi

    if [ -z "`grep ^SMTP_SMARTHOST_DOMAINS $source_conf`" ]
    then
        echo "- SMTP_SMARTHOST_DOMAINS=''"
        SMTP_SMARTHOST_DOMAINS=''
        added=1
    fi    

    if [ -z "`grep ^SMTP_SMARTHOST_N $source_conf`" ]
    then
        if [ "$SMTP_SMARTHOST_1_HOST" != "" ]
        then
            echo "- SMTP_SMARTHOST_N='1'"
            SMTP_SMARTHOST_N='1'
        else
            echo "- SMTP_SMARTHOST_N='0'"
            SMTP_SMARTHOST_N='0'
        fi
        added=1
    fi

    if [ -z "`grep ^SMTP_SMARTHOST_1_ADDR $source_conf`" ]
    then
        echo "- SMTP_SMARTHOST_1_ADDR='user@local.lan'"
        SMTP_SMARTHOST_1_ADDR='user@local.lan'
        added=1
    fi

    if [ -z "`grep ^MAIL_CERTS_WARNING $source_conf`" ]
    then
        echo "- MAIL_CERTS_WARNING='yes'"
        MAIL_CERTS_WARNING='yes'
        added=1
    fi

    if [ -z "`grep ^MAIL_CERTS_WARNING_SUBJECT $source_conf`" ]
    then
        echo "- MAIL_CERTS_WARNING_SUBJECT='TLS certificates warning'"
        MAIL_CERTS_WARNING_SUBJECT='TLS certificates warning'
        added=1
    fi    

    if [ -z "`grep ^MAIL_CERTS_WARNING_CRON_SCHEDULE $source_conf`" ]
    then
        echo "- MAIL_CERTS_WARNING_CRON_SCHEDULE='3 1 1,16 * *'"
        MAIL_CERTS_WARNING_CRON_SCHEDULE='3 1 1,16 * *'
        added=1
    fi    

    if [ -z "`grep ^MAIL_STATISTICS_INFOMAIL $source_conf`" ]
    then
        echo "- MAIL_STATISTICS_INFOMAIL='no'"
        MAIL_STATISTICS_INFOMAIL='no'
        added=1
    fi

    if [ -z "`grep ^MAIL_STATISTICS_INFOMAIL_SUBJECT $source_conf`" ]
    then
        echo "- MAIL_STATISTICS_INFOMAIL_SUBJECT='Mail server statistics'"
        MAIL_STATISTICS_INFOMAIL_SUBJECT='Mail server statistics'
        added=1
    else
        MAIL_STATISTICS_INFOMAIL_SUBJECT="$MAIL_STATISTICS_INFOMAIL_SUBJECT"
    fi

    if [ -z "`grep ^MAIL_STATISTICS_INFOMAIL_CRON_SCHEDULE $source_conf`" ]
    then
        echo "- MAIL_STATISTICS_INFOMAIL_CRON_SCHEDULE='6 7 * * *'"
        MAIL_STATISTICS_INFOMAIL_CRON_SCHEDULE='6 7 * * *'
        added=1
    else
        MAIL_STATISTICS_INFOMAIL_CRON_SCHEDULE="$MAIL_STATISTICS_INFOMAIL_CRON_SCHEDULE"
    fi

    # v1.1.3
    if [ -z "`grep ^SMTP_CHECK_SPOOL_SPACE $source_conf`" ]
    then
        echo "- SMTP_CHECK_SPOOL_SPACE=''"
        SMTP_CHECK_SPOOL_SPACE=''
        added=1
    else
        SMTP_CHECK_SPOOL_SPACE="$SMTP_CHECK_SPOOL_SPACE"
    fi

    if [ -z "`grep ^SMTP_CHECK_SPOOL_INODES $source_conf`" ]
    then
        echo "- SMTP_CHECK_SPOOL_INODES=''"
        SMTP_CHECK_SPOOL_INODES=''
        added=1
    else
        SMTP_CHECK_SPOOL_INODES="$SMTP_CHECK_SPOOL_INODES"
    fi    

    # v1.1.4
    if [ -z "`grep ^SMTP_LIMIT $source_conf`" ]
    then
        echo "- SMTP_LIMIT=''"
        SMTP_LIMIT=''
        added=1
    fi

    if [ -z "`grep ^EXISCAN_CRYPT_SALT $source_conf`" ]
    then
        if [ "$EXISCAN_CRYPT_SALT" = "" ]
        then
            salt_len=16
            # create random crypt salt and add mail hostname
            idx=1
            randsalt=""
            while [ $idx -le $salt_len ]
            do
                randsalt="$randsalt`random_char`"
            done
            randsalt="$randsalt-$SMTP_HOSTNAME"

            echo "- EXISCAN_CRYPT_SALT='$randsalt'"
            EXISCAN_CRYPT_SALT="$randsalt"
        fi
        added=1
    fi

    if [ -z "`grep ^EXISCAN_DEMIME_ACTION $source_conf`" ]
    then
        echo "- EXISCAN_DEMIME_ACTION='pass'"
        EXISCAN_DEMIME_ACTION='pass'
        added=1
    fi

    if [ -z "`grep ^SMTP_ALIASES_N $source_conf`" ]
    then
        echo "- SMTP_ALIASES_N='1'"
        SMTP_ALIASES_N='1'
        added=1
    fi

    if [ -z "`grep ^SMTP_ALIASES_1_DOMAIN $source_conf`" ]
    then
        echo "- SMTP_ALIASES_1_DOMAIN=''"
        SMTP_ALIASES_1_DOMAIN=''
        added=1
    fi

    # v1.1.6
    if [ -z "`grep ^SMTP_REMOVE_RECEIPT_REQUEST $source_conf`" ]
    then
        echo "- SMTP_REMOVE_RECEIPT_REQUEST='no'"
        SMTP_REMOVE_RECEIPT_REQUEST='no'
        added=1
    fi

    if [ -z "`grep ^SMTP_SMARTHOST_ROUTE_TYPE $source_conf`" ]
    then
        echo "- SMTP_SMARTHOST_ROUTE_TYPE='addr'"
        SMTP_SMARTHOST_ROUTE_TYPE='addr'
        added=1
    fi

    #----------------------------------------------------------------

    if [ $SMTP_SMARTHOST_N -eq 0 ]
    then
        imax=1
    else
        imax=$SMTP_SMARTHOST_N
    fi

    idx=1
    while [ $idx -le $imax ]
    do
        # v1.1.6
        if [ -z "`grep '^SMTP_SMARTHOST_'$idx'_DOMAIN' $source_conf`" ]
        then
            echo "- SMTP_SMARTHOST_"$idx"_DOMAIN=''"
            eval "SMTP_SMARTHOST_"$idx"_DOMAIN=''"
            added=1
        fi

        # v1.1.7
        if [ -z "`grep '^SMTP_SMARTHOST_'$idx'_PORT' $source_conf`" ]
        then
            echo "- SMTP_SMARTHOST_"$idx"_PORT=''"
            eval "SMTP_SMARTHOST_"$idx"_PORT=''"
            added=1
        fi
        idx=`expr $idx + 1`
    done

    #----------------------------------------------------------------

    if [ $FETCHMAIL_N -eq 0 ]
    then
        imax=1
    else
        imax=$FETCHMAIL_N
    fi

    idx=1
    while [ $idx -le $imax ]
    do
        if [ -z "`grep '^FETCHMAIL_'$idx'_ENVELOPE' $source_conf`" ]
        then
            echo "- FETCHMAIL_"$idx"_ENVELOPE='no'"
            eval "FETCHMAIL_"$idx"_ENVELOPE='no'"
            added=1
        fi

        #- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

        if [ -z "`grep '^FETCHMAIL_'$idx'_SERVER_AKA_N' $source_conf`" ]
        then
            echo "- FETCHMAIL_"$idx"_SERVER_AKA_N='0'"
            eval "FETCHMAIL_"$idx"_SERVER_AKA_N='0'"
            added=1
        fi

        # v1.2.2
        if [ -z "`grep '^FETCHMAIL_'$idx'_MSG_LIMIT' $source_conf`" ]
        then
            echo "- FETCHMAIL_"$idx"_MSG_LIMIT='0'"
            eval "FETCHMAIL_"$idx"_MSG_LIMIT='0'"
            added=1
        fi

        # v1.1.7
        eval fm_server_aka_n='$FETCHMAIL_'$idx'_SERVER_AKA_N'

        if [ $fm_server_aka_n -eq 0 ]
        then
            jmax=1
        else
            jmax=$fm_server_aka_n
        fi

        jdx=1
        while [ $jdx -le $jmax ]
        do
            if [ -z "`grep '^FETCHMAIL_'$idx'_SERVER_AKA_'$jdx $source_conf`" ]
            then
                echo "- FETCHMAIL_"$idx"_SERVER_AKA_"$jdx"=''"
                eval "FETCHMAIL_"$idx"_SERVER_AKA_"$jdx"=''"
                added=1
            fi

            jdx=`expr $jdx + 1`
        done

        # v1.2.6
        if [ -z "`grep '^FETCHMAIL_'$idx'_ACTIVE' $source_conf`" ]
        then
            echo "- FETCHMAIL_"$idx"_ACTIVE='yes'"
            eval "FETCHMAIL_"$idx"_ACTIVE='yes'"
            added=1
        fi

        idx=`expr $idx + 1`
    done

    #----------------------------------------------------------------

    # v1.1.7
    if [ -z "`grep ^POP3IMAP_TRANSPORT $source_conf`" ]
    then
        echo "- POP3IMAP_TRANSPORT='default'"
        POP3IMAP_TRANSPORT='default'
        added=1
    fi

    # v1.2.6
    if [ $POP3IMAP_N -eq 0 ]
    then
        imax=1
    else
        imax=$POP3IMAP_N
    fi

    idx=1
    while [ $idx -le $imax ]
    do
        eval pop3imap_active='$POP3IMAP_'$idx'_ACTIVE'

        if [ "$pop3imap_active" = "" -a -z "`grep '^POP3IMAP_'$idx'_ACTIVE' $source_conf`" ]
        then
            echo "- POP3IMAP_"$idx"_ACTIVE='yes'"
            eval "POP3IMAP_"$idx"_ACTIVE='yes'"
            added=1
        fi

        idx=`expr $idx + 1`
    done

    #----------------------------------------------------------------

    # v1.1.7
    if [ -z "`grep ^SMTP_SERVER_TRANSPORT $source_conf`" ]
    then
        echo "- SMTP_SERVER_TRANSPORT='default'"
        SMTP_SERVER_TRANSPORT='default'
        added=1
    fi

    if [ -z "`grep ^SMTP_SERVER_TLS_ADVERTISE_HOSTS $source_conf`" ]
    then
        echo "- SMTP_SERVER_TLS_ADVERTISE_HOSTS=''"
        SMTP_SERVER_TLS_ADVERTISE_HOSTS=''
        added=1
    fi

    if [ -z "`grep ^SMTP_SERVER_TLS_VERIFY_HOSTS $source_conf`" ]
    then
        echo "- SMTP_SERVER_TLS_VERIFY_HOSTS=''"
        SMTP_SERVER_TLS_VERIFY_HOSTS=''
        added=1
    fi

    #----------------------------------------------------------------

    # v1.1.7
    if [ $IMAP_SHARED_FOLDER_N -eq 0 ]
    then
        imax=1
    else
        imax=$IMAP_SHARED_FOLDER_N
    fi

    idx=1
    while [ $idx -le $imax ]
    do
        # v1.1.7
        if [ -z "`grep '^IMAP_SHARED_FOLDER_'$idx'_USERGROUP' $source_conf`" ]
        then
            echo "- IMAP_SHARED_FOLDER_"$idx"_USERGROUP=''"
            eval "IMAP_SHARED_FOLDER_"$idx"_USERGROUP=''"
            added=1
        fi

        # v1.2.6
        if [ -z "`grep '^IMAP_SHARED_FOLDER_'$idx'_ACTIVE' $source_conf`" ]
        then
            echo "- IMAP_SHARED_FOLDER_"$idx"_ACTIVE='yes'"
            eval "IMAP_SHARED_FOLDER_"$idx"_ACTIVE='yes'"
            added=1
        fi

        idx=`expr $idx + 1`
    done

    #----------------------------------------------------------------

    # v1.1.7
    if [ $IMAP_PUBLIC_FOLDER_N -eq 0 ]
    then
        imax=1
    else
        imax=$IMAP_PUBLIC_FOLDER_N
    fi

    idx=1
    while [ $idx -le $imax ]
    do
        # v1.1.7
        if [ -z "`grep '^IMAP_PUBLIC_FOLDER_'$idx'_USERGROUP' $source_conf`" ]
        then
            echo "- IMAP_PUBLIC_FOLDER_"$idx"_USERGROUP=''"
            eval "IMAP_PUBLIC_FOLDER_"$idx"_USERGROUP=''"
            added=1
        fi

        # v1.2.6
        if [ -z "`grep '^IMAP_PUBLIC_FOLDER_'$idx'_ACTIVE' $source_conf`" ]
        then
            echo "- IMAP_PUBLIC_FOLDER_"$idx"_ACTIVE='yes'"
            eval "IMAP_PUBLIC_FOLDER_"$idx"_ACTIVE='yes'"
            added=1
        fi

        idx=`expr $idx + 1`
    done

    #----------------------------------------------------------------

    # v1.1.10
    # replace multiple variables by only one
    if [ -z "`grep ^EXISCAN_AV_SOCKET $source_conf`" ]
    then
        case $EXISCAN_AV_SCANNER
        in
             sophie )
                if [ ! -z "`grep ^EXISCAN_AV_SOPHIE_SOCKET $source_conf`" ]
                then
                    EXISCAN_AV_SOCKET="$EXISCAN_AV_SOPHIE_SOCKET"
                fi    
                ;;
             kavdaemon )
                if [ ! -z "`grep ^EXISCAN_AV_KAVDAEMON_SOCKET $source_conf`" ]
                then
                    EXISCAN_AV_SOCKET="$EXISCAN_AV_KAVDAEMON_SOCKET"
                fi    
                ;;
             clamav|clamd )
                if [ ! -z "`grep ^EXISCAN_AV_CLAMAV_SOCKET $source_conf`" ]
                then
                    EXISCAN_AV_SOCKET="$EXISCAN_AV_CLAMAV_SOCKET"
                elif [ ! -z "`grep ^EXISCAN_AV_CLAMAV_HOST $source_conf`" ]
                then
                    EXISCAN_AV_SOCKET="$EXISCAN_AV_CLAMAV_HOST $EXISCAN_AV_CLAMAV_PORT"
                fi    
                ;;
        esac     

        echo "- EXISCAN_AV_SOCKET='$EXISCAN_AV_SOCKET'"
        added=1
    fi

    if [ -z "`grep ^SMTP_UPDATE_IGNORE_HOSTS $source_conf`" ]
    then
        echo "- SMTP_UPDATE_IGNORE_HOSTS='no'"
        SMTP_UPDATE_IGNORE_HOSTS='no'
        added=1
    fi

    if [ -z "`grep ^SMTP_UPDATE_IGNORE_HOSTS_CRON_SCHEDULE $source_conf`" ]
    then
        echo "- SMTP_UPDATE_IGNORE_HOSTS_CRON_SCHEDULE='5 1 * * 0'"
        SMTP_UPDATE_IGNORE_HOSTS_CRON_SCHEDULE='5 1 * * 0'
        added=1
    fi

    # v1.2.3
    if [ -z "`grep ^EXISCAN_AV_SUBJECT_TAG $source_conf`" ]
    then
        echo "- EXISCAN_AV_SUBJECT_TAG=''"
        EXISCAN_AV_SUBJECT_TAG=''
        added=1
    fi

    if [ -z "`grep ^SMTP_SERVER_SSMTP $source_conf`" ]
    then
        echo "- SMTP_SERVER_SSMTP='no'"
        SMTP_SERVER_SSMTP='no'
        added=1
    fi

    if [ -z "`grep ^SMTP_SERVER_SSMTP_LISTEN_PORT $source_conf`" ]
    then
        echo "- SMTP_SERVER_SSMTP_LISTEN_PORT='ssmtp'"
        SMTP_SERVER_SSMTP_LISTEN_PORT='ssmtp'
        added=1
    fi

    if [ $added -eq 1 ]
    then
        mecho -warn "... read documentation for new parameter(s)!"
        /var/install/bin/anykey
    else
        mecho -warn "... nothing to do."
    fi
}

#------------------------------------------------------------------------------
# delete variables
#------------------------------------------------------------------------------
delete_variables ()
{
    deleted=0
    mecho -warn "deleting old parameters ..."

    # v1.1.2
    for varname in "EXISCAN_AV_CLAMAV_HOST EXISCAN_AV_CLAMAV_PORT"
    do
        if [ ! -z "`grep \"^$varname\" $source_conf`" ]
        then
            echo "- $varname"
            deleted=1
        fi
    done

    # v1.1.4
    for varname in "EXISCAN_AV_BUFFER_INIT_CHUNK EXISCAN_AV_BUFFER_MAX_CHUNKS EXISCAN_SPAMD_BUFFER_INIT_CHUNK EXISCAN_SPAMD_BUFFER_MAX_CHUNKS"
    do
        if [ ! -z "`grep \"^$varname\" $source_conf`" ]
        then
            echo "- $varname"
            deleted=1
        fi    
    done

    # v1.1.10
    if [ ! -z "`grep ^EXISCAN_AV_OPENAV_HOST $source_conf`" ]
    then
        echo "- Attention: OpenAV scanner is no longer supported by exiscan!"
        echo
    fi

    for varname in "EXISCAN_AV_SOPHIE_SOCKET EXISCAN_AV_KAVDAEMON_SOCKET EXISCAN_AV_CLAMAV_SOCKET EXISCAN_AV_OPENAV_HOST EXISCAN_AV_OPENAV_PORT EXISCAN_TIMEOUT"
    do
        if [ ! -z "`grep \"^$varname\" $source_conf`" ]
        then
            echo "- $varname"
            deleted=1
        fi
    done    

    if [ $deleted -eq 1 ]
    then
        /var/install/bin/anykey
    else
        mecho -warn "... nothing to do."
    fi
}

#------------------------------------------------------------------------------
# import pop3imap user and password list
#------------------------------------------------------------------------------
import_pop3imap_users ()
{
    if [ -f $read_pop3imap_users ]
    then
        mecho -warn "importing $read_pop3imap_users file ..."

        # convert to unix file format
        dtou $read_pop3imap_users

        OLDIFS=$IFS
        IFS=,
        # set offset
        idx=$POP3IMAP_N
        while read line
        do
            # delete leading spaces
            line=`trim_spaces "$line"`

            if [ "$line" != "" ]
            then
                # line not empty
                echo $line|grep "^#" > /dev/null

                if [ $? -eq 1 ]
                then
                    # no comment found - process line
                    # extract information and remove leading/trailing spaces
                    set $line
                    username=`trim_spaces "$1"`
                    password=`trim_spaces "$2"`
                    active=`trim_spaces "$3"`

                    # deactivate user by default if value not given
                    if [ "$active" = "" ]
                    then
                        active='no'
                    fi

                    # check if nick name already exists
                    jdx=1
                    foundflag=0
                    testuser1=`echo $username|tr 'A-Z' 'a-z'`
                    while [ $jdx -le $POP3IMAP_N ]
                    do
                        eval testuser2='$POP3IMAP_'$jdx'_USER'

                        testuser2=`trim_spaces "$testuser2"|tr 'A-Z' 'a-z'`

                        if [ "$testuser1" = "$testuser2" ]
                        then
                            foundflag=1
                            break
                        fi

                        jdx=`expr $jdx + 1`
                    done

                    if [ $foundflag -eq 0 ]
                    then
                        # add entry
                        idx=`expr $idx + 1`

                        eval 'POP3IMAP_'$idx'_USER'="$username"
                        eval 'POP3IMAP_'$idx'_PASS'="$password"
                        eval 'POP3IMAP_'$idx'_ACTIVE'="$active"

                        echo "- importing '$username' ..."
                    else
                        # skip entry
                        echo "- skipping '$username' - entry already exists ..."
                    fi
                fi    
            fi    
        done < $read_pop3imap_users

        # increment counter
        POP3IMAP_N=$idx

        IFS=$OLDIFS
    fi
}

#------------------------------------------------------------------------------
# export pop3imap user and password list
#------------------------------------------------------------------------------
export_pop3imap_users ()
{
    if [ $POP3IMAP_N -gt 0 ]
    then
        {
            # target file does not exist - export data
            echo "#"
            echo "# file created by $0 on `date`"
            echo "#" 
            echo "#username,password,active"
        } > $read_pop3imap_users    

        idx=1
        while [ $idx -le $POP3IMAP_N ]
        do
            eval active='$POP3IMAP_'$idx'_ACTIVE'
            eval username='$POP3IMAP_'$idx'_USER'
            eval password='$POP3IMAP_'$idx'_PASS'

            echo "$username,$password,$active" >> $read_pop3imap_users
            echo "- exporting '$username' ..."

            idx=`expr $idx + 1`
        done
            
        echo "Pop3/imap users and passwords exported to $read_pop3imap_users."
    else
        echo "Error: Nothing to export because POP3IMAP_N='0' has been set, export aborted!"
    fi    
}

#------------------------------------------------------------------------------
# create new configuration
#------------------------------------------------------------------------------
create_config ()
{
    if [ "$1" = "basic" ]
    then
        config_level="basic"
        mecho -warn "preparing basic configuration ..."
    elif [ "$1" = "merge" ]
    then
        config_level="merge"
        mecho -warn "merging configuration ..."
    elif [ "$1" = "advanced" ]
    then
        config_level="advanced"
        mecho -warn "preparing advanced configuration ..."
    else
        config_level="advanced"
        mecho -warn "updating/creating configuration ..."
    fi

    {
        echo '#------------------------------------------------------------------------------'
        echo '# /etc/config.d/mail - configuration for mail services on EIS/FAIR'
        echo '#'
        echo '# Copyright (c) 2002 Frank Meyer <frank(at)eisfair(dot)org>'
        echo '#'
        echo '# Creation:     28.04.2002  fm'
        echo "# Last Update:  `date '+%d.%m.%Y'`  jed"
        echo '#'

        if [ "$config_level" = "basic" -o "$config_level" = "merge" ]
        then
            echo "# Config Level: basic"
        else
            echo "# Config Level: advanced"
        fi

        echo '#'
        echo '# This program is free software; you can redistribute it and/or modify'
        echo '# it under the terms of the GNU General Public License as published by'
        echo '# the Free Software Foundation; either version 2 of the License, or'
        echo '# (at your option) any later version.'
        echo '#------------------------------------------------------------------------------'
        echo

        dodebug=0
        if [ "$MAIL_DO_DEBUG" = "yes" ]
        then
            # debug active
            echo "  MAIL_DO_DEBUG='yes'                   # debug mode: yes or no"
            dodebug=1
        else
            # debug parameter exists but not active
            if [ -n "`grep MAIL_DO_DEBUG $source_conf`" ]
            then
                echo "# MAIL_DO_DEBUG='yes'                   # debug mode: yes or no"
                dodebug=1
            fi
        fi    

        if [ "$EXISCAN_DO_DEBUG" = "yes" ]
        then
            # debug active
            echo "  EXISCAN_DO_DEBUG='yes'                # debug mode: yes or no"
            dodebug=1
        else
            # debug parameter exists but not active
            if [ -n "`grep EXISCAN_DO_DEBUG $source_conf`" ]
            then
                echo "# EXISCAN_DO_DEBUG='yes'                # debug mode: yes or no"
                dodebug=1
            fi
        fi    

        if [ $dodebug -eq 1 ]
        then
            # add empty line
            echo
        fi

        echo '#------------------------------------------------------------------------------'
        echo '# pop3: general settings'
        echo '#------------------------------------------------------------------------------'
        echo
        echo "START_POP3='$START_POP3'`spaces \"$START_POP3\" 26` # start POP3 server: yes or no"
        echo "START_IMAP='$START_IMAP'`spaces \"$START_IMAP\" 26` # start IMAP server: yes or no"

        if [ "$config_level" != "basic" ]
        then
            echo
            echo "POP3IMAP_CREATE_MBX='$POP3IMAP_CREATE_MBX'`spaces \"$POP3IMAP_CREATE_MBX\" 17` # create mbx mailbox for imap"

            echo
            echo "POP3IMAP_USE_MAILONLY_PASSWORDS='$POP3IMAP_USE_MAILONLY_PASSWORDS'`spaces \"$POP3IMAP_USE_MAILONLY_PASSWORDS\" 5` # use seperate mail passwords: yes or no"
            echo "POP3IMAP_TRANSPORT='$POP3IMAP_TRANSPORT'`spaces \"$POP3IMAP_TRANSPORT\" 18` # transport to use: default, tls or both"

            echo
            echo '#------------------------------------------------------------------------------'
            echo '# pop3/imap: mail users and optional passwords'
            echo '#------------------------------------------------------------------------------'
            echo

            echo "POP3IMAP_N='$POP3IMAP_N'`spaces \"$POP3IMAP_N\" 26` # number of mail-accounts"

            if [ $POP3IMAP_N -eq 0 ]
            then
                imax=1
            else
                imax=$POP3IMAP_N
            fi    

            idx=1
            while [ $idx -le $imax ]
            do
                eval active='$POP3IMAP_'$idx'_ACTIVE'
                eval username='$POP3IMAP_'$idx'_USER'
                eval password='$POP3IMAP_'$idx'_PASS'

                echo "POP3IMAP_${idx}_ACTIVE='$active'`spaces \"$active\" 19` # $idx. activate account: yes or no"
                echo "POP3IMAP_${idx}_USER='$username'`spaces \"$username\" 21` #    username"
                echo "POP3IMAP_${idx}_PASS='$password'`spaces \"$password\" 21` #    optional mail only password"
                idx=`expr $idx + 1`
            done

            echo
            echo '#------------------------------------------------------------------------------'
            echo '# imap: shared and public folders'
            echo '#'
            echo '# Optional:'
            echo '#   Setup public or shared imap folders. This feature is not supported by'
            echo '#   some mail clients, but has succesfully tested with netscape messenger.'
            echo '#------------------------------------------------------------------------------'
            echo

            echo "IMAP_SHARED_PUBLIC_USERGROUP='$IMAP_SHARED_PUBLIC_USERGROUP'`spaces \"$IMAP_SHARED_PUBLIC_USERGROUP\" 10` # name of usergroup for shared and"
            echo '                                          # public folders - default: users'
            echo "IMAP_SHARED_FOLDER_N='$IMAP_SHARED_FOLDER_N'`spaces \"$IMAP_SHARED_FOLDER_N\" 18` # number of shared folders to create"

            if [ $IMAP_SHARED_FOLDER_N -eq 0 ]
            then
                imax=1
            else
                imax=$IMAP_SHARED_FOLDER_N
            fi    

            idx=1
            while [ $idx -le $imax ]
            do
                eval active='$IMAP_SHARED_FOLDER_'$idx'_ACTIVE'
                eval foldername='$IMAP_SHARED_FOLDER_'$idx'_NAME'
                eval usergroup='$IMAP_SHARED_FOLDER_'$idx'_USERGROUP'

                echo "IMAP_SHARED_FOLDER_"$idx"_ACTIVE='$active'`spaces \"$active\" 11` # $idx. activate folder: yes or no"
                echo "IMAP_SHARED_FOLDER_"$idx"_NAME='$foldername'`spaces \"$foldername\" 13` #    folder to create"
                echo "IMAP_SHARED_FOLDER_"$idx"_USERGROUP='$usergroup'`spaces \"$usergroup\" 8` #    individual usergroup for folder"
                idx=`expr $idx + 1`
            done

            echo
            echo "IMAP_PUBLIC_FOLDER_N='$IMAP_PUBLIC_FOLDER_N'`spaces \"$IMAP_PUBLIC_FOLDER_N\" 18` # number of public folders to create"

            if [ $IMAP_PUBLIC_FOLDER_N -eq 0 ]
            then
                imax=1
            else
                imax=$IMAP_PUBLIC_FOLDER_N
            fi    

            idx=1
            while [ $idx -le $imax ]
            do
                eval active='$IMAP_PUBLIC_FOLDER_'$idx'_ACTIVE'
                eval foldername='$IMAP_PUBLIC_FOLDER_'$idx'_NAME'
                eval usergroup='$IMAP_PUBLIC_FOLDER_'$idx'_USERGROUP'

                echo "IMAP_PUBLIC_FOLDER_"$idx"_ACTIVE='$active'`spaces \"$active\" 11` # $idx. activate folder: yes or no"
                echo "IMAP_PUBLIC_FOLDER_"$idx"_NAME='$foldername'`spaces \"$foldername\" 13` #    folder to create"
                echo "IMAP_PUBLIC_FOLDER_"$idx"_USERGROUP='$usergroup'`spaces \"$usergroup\" 8` #    individual usergroup for folder"
                idx=`expr $idx + 1`
            done
        fi

        echo
        echo '#------------------------------------------------------------------------------'
        echo '# fetchmail: general settings'
        echo '#------------------------------------------------------------------------------'
        echo
        echo "START_FETCHMAIL='$START_FETCHMAIL'`spaces \"$START_FETCHMAIL\" 23` # start FETCHMAIL client: yes or no"
        echo
        echo "FETCHMAIL_PROTOCOL='$FETCHMAIL_PROTOCOL'`spaces \"$FETCHMAIL_PROTOCOL\" 20` # protocol to use, normally pop3"
        echo "FETCHMAIL_LIMIT='$FETCHMAIL_LIMIT'`spaces \"$FETCHMAIL_LIMIT\" 23` # mail size limit. Default: 4 megabytes"
        echo "FETCHMAIL_WARNINGS='$FETCHMAIL_WARNINGS'`spaces \"$FETCHMAIL_WARNINGS\" 20` # send warnings once a day (in seconds)"
        echo "FETCHMAIL_DAEMON='$FETCHMAIL_DAEMON'`spaces \"$FETCHMAIL_DAEMON\" 22` # check every 30 minutes (in seconds)"
        echo "FETCHMAIL_TIMEOUT='$FETCHMAIL_TIMEOUT'`spaces \"$FETCHMAIL_TIMEOUT\" 21` # wait for server reply (in seconds)"
        echo
        echo '#------------------------------------------------------------------------------'
        echo '# fetchmail: accounts'
        echo '#------------------------------------------------------------------------------'
        echo
        echo "FETCHMAIL_N='$FETCHMAIL_N'`spaces \"$FETCHMAIL_N\" 27` # number of accounts to fetch"

        if [ $FETCHMAIL_N -eq 0 ]
        then
            imax=1
        else
            imax=$FETCHMAIL_N
        fi    

        idx=1
        while [ $idx -le $imax ]
        do
            eval fetchmail_active='$FETCHMAIL_'$idx'_ACTIVE'
            eval fetchmail_server='$FETCHMAIL_'$idx'_SERVER'
            eval fetchmail_server_aka_n='$FETCHMAIL_'$idx'_SERVER_AKA_N'
            eval fetchmail_user='$FETCHMAIL_'$idx'_USER'
            eval fetchmail_password='$FETCHMAIL_'$idx'_PASS'
            eval fetchmail_forward='$FETCHMAIL_'$idx'_FORWARD'
            eval fetchmail_smtphost='$FETCHMAIL_'$idx'_SMTPHOST'
            eval fetchmail_domain='$FETCHMAIL_'$idx'_DOMAIN'
            eval fetchmail_envelope='$FETCHMAIL_'$idx'_ENVELOPE'
            eval fetchmail_localdomain_n='$FETCHMAIL_'$idx'_LOCALDOMAIN_N'
            eval fetchmail_protocol='$FETCHMAIL_'$idx'_PROTOCOL'
            eval fetchmail_port='$FETCHMAIL_'$idx'_PORT'
            eval fetchmail_auth='$FETCHMAIL_'$idx'_AUTH_TYPE'
            eval fetchmail_keep='$FETCHMAIL_'$idx'_KEEP'
            eval fetchmail_fetchall='$FETCHMAIL_'$idx'_FETCHALL'
            eval fetchmail_msg_limit='$FETCHMAIL_'$idx'_MSG_LIMIT'
            eval fetchmail_ssl_protocol='$FETCHMAIL_'$idx'_SSL_PROTOCOL'
            eval fetchmail_ssl_transport='$FETCHMAIL_'$idx'_SSL_TRANSPORT'
            eval fetchmail_ssl_fingerprint='$FETCHMAIL_'$idx'_SSL_FINGERPRINT'

            echo "FETCHMAIL_"$idx"_ACTIVE='$fetchmail_active'`spaces \"$fetchmail_active\" 20` # ${idx}. activate fetchmail entry: yes or no"
            echo "FETCHMAIL_"$idx"_SERVER='$fetchmail_server'`spaces \"$fetchmail_server\" 20` #    mail server to poll"
            echo "FETCHMAIL_"$idx"_USER='$fetchmail_user'`spaces \"$fetchmail_user\" 22` #    username and"
            echo "FETCHMAIL_"$idx"_PASS='$fetchmail_password'`spaces \"$fetchmail_password\" 22` #    password for this server"
            echo "FETCHMAIL_"$idx"_FORWARD='$fetchmail_forward'`spaces \"$fetchmail_forward\" 19` #    local account to forward to"

            if [ "$config_level" != "basic" ]
            then
                echo "FETCHMAIL_"$idx"_SMTPHOST='$fetchmail_smtphost'`spaces \"$fetchmail_smtphost\" 18` #    smtp host to forward to,"
                echo "                                          #    default is 'localhost'"
                echo "FETCHMAIL_"$idx"_DOMAIN='$fetchmail_domain'`spaces \"$fetchmail_domain\" 20` #    if yes fetchmail gets mail for"
                echo "                                          #    a whole domain."
                echo "FETCHMAIL_"$idx"_ENVELOPE='$fetchmail_envelope'`spaces \"$fetchmail_envelope\" 18` #    if yes, lookup envelope addresses"
                echo "FETCHMAIL_"$idx"_SERVER_AKA_N='$fetchmail_server_aka_n'`spaces \"$fetchmail_server_aka_n\" 14` #    number of dns aliases, default is '0'"

                if [ $fetchmail_server_aka_n -eq 0 ]
                then
                    jmax=1
                else
                    jmax=$fetchmail_server_aka_n
                fi    

                jdx=1
                while [ $jdx -le $jmax ]
                do
                    eval fetchmail_server_aka='$FETCHMAIL_'$idx'_SERVER_AKA_'$jdx

                    echo "FETCHMAIL_"$idx"_SERVER_AKA_"$jdx"='$fetchmail_server_aka'`spaces \"$fetchmail_server_aka\" 14` #    $jdx. dns alias"
                    jdx=`expr $jdx + 1`
                done

                echo "FETCHMAIL_"$idx"_LOCALDOMAIN_N='$fetchmail_localdomain_n'`spaces \"$fetchmail_localdomain_n\" 13` #    number of local domains, default is '0'"

                if [ $fetchmail_localdomain_n -eq 0 ]
                then
                    jmax=2
                else
                    jmax=$fetchmail_localdomain_n
                fi    

                jdx=1
                while [ $jdx -le $jmax ]
                do
                    eval fetchmail_localdomain='$FETCHMAIL_'$idx'_LOCALDOMAIN_'$jdx

                    echo "FETCHMAIL_"$idx"_LOCALDOMAIN_"$jdx"='$fetchmail_localdomain'`spaces \"$fetchmail_localdomain\" 13` #    $jdx. local domain"
                    jdx=`expr $jdx + 1`
                done

                echo "FETCHMAIL_"$idx"_PROTOCOL='$fetchmail_protocol'`spaces \"$fetchmail_protocol\" 18` #    set a different protocol"
                echo '                                          #    default is FETCHMAIL_PROTOCOL'
                echo "FETCHMAIL_"$idx"_PORT='$fetchmail_port'`spaces \"$fetchmail_port\" 22` #    set a different ip port, default is 'pop3'"
                echo "FETCHMAIL_"$idx"_AUTH_TYPE='$fetchmail_auth'`spaces \"$fetchmail_auth\" 17` #    set a different authentication type"
                echo "                                          #    default is 'any'"
            fi

            echo "FETCHMAIL_"$idx"_KEEP='$fetchmail_keep'`spaces \"$fetchmail_keep\" 22` #    if yes mail is left on the server"
            echo "FETCHMAIL_"$idx"_FETCHALL='$fetchmail_fetchall'`spaces \"$fetchmail_fetchall\" 18` #    if yes all mail is fetched from the server"

            if [ "$config_level" != "basic" ]
            then
                echo "FETCHMAIL_"$idx"_MSG_LIMIT='$fetchmail_msg_limit'`spaces \"$fetchmail_msg_limit\" 17` #    number of messages per session, default '0'"
                echo "FETCHMAIL_"$idx"_SSL_PROTOCOL='$fetchmail_ssl_protocol'`spaces \"$fetchmail_ssl_protocol\" 14` #    ssl protocol: none, ssl2, ssl3 or tls1"
                echo "FETCHMAIL_"$idx"_SSL_TRANSPORT='$fetchmail_ssl_transport'`spaces \"$fetchmail_ssl_transport\" 13` #    enable ssl transport"
                echo "FETCHMAIL_"$idx"_SSL_FINGERPRINT='$fetchmail_ssl_fingerprint'`spaces \"$fetchmail_ssl_fingerprint\" 11` #    ssl fingerprint"
            fi    

            if [  $idx -le `expr $imax - 1` ]
            then
                echo "#------------------------------------------------------------------------------"
            fi    
            idx=`expr $idx + 1`
        done

        echo
        echo '#------------------------------------------------------------------------------'
        echo '# smtp: general settings'
        echo '#------------------------------------------------------------------------------'
        echo
        echo "START_SMTP='$START_SMTP'`spaces \"$START_SMTP\" 25` # start SMTP server: yes or no"
        echo "SMTP_QUALIFY_DOMAIN='$SMTP_QUALIFY_DOMAIN'`spaces \"$SMTP_QUALIFY_DOMAIN\" 16` # domain to be added to all unqualified"
        echo '                                       # addresses'
        echo "SMTP_HOSTNAME='$SMTP_HOSTNAME'`spaces \"$SMTP_HOSTNAME\" 22` # canonical hostname of eisfair server"
        echo "SMTP_QUEUE_INTERVAL='$SMTP_QUEUE_INTERVAL'`spaces \"$SMTP_QUEUE_INTERVAL\" 16` # queueing interval in minutes, usually 30"
        echo "SMTP_QUEUE_OUTBOUND_MAIL='$SMTP_QUEUE_OUTBOUND_MAIL'`spaces \"$SMTP_QUEUE_OUTBOUND_MAIL\" 11` # set to yes if you are using a dialup ISP"
        echo '                                       # and you want to queue outbound mail until'
        echo '                                       # next queue run which must be initiated'
        echo '                                       # manually or cron-job'
        echo "SMTP_LISTEN_PORT='$SMTP_LISTEN_PORT'`spaces \"$SMTP_LISTEN_PORT\" 19` # port on which Exim is listening for"
        echo "                                       # inbound traffic, default is 'smtp'"

        if [ "$config_level" != "basic" ]
        then
            echo "SMTP_MAIL_TO_UNKNOWN_USERS='$SMTP_MAIL_TO_UNKNOWN_USERS'`spaces \"$SMTP_MAIL_TO_UNKNOWN_USERS\" 9` # how to handle mail to unknown mail users:"
            echo '                                       # bounce, copy or forward'
            echo "                                       # default is 'bounce'"
            echo "SMTP_ALLOW_EXIM_FILTERS='$SMTP_ALLOW_EXIM_FILTERS'`spaces \"$SMTP_ALLOW_EXIM_FILTERS\" 12` # allow exim filters in .forward file: yes or no"
            echo
            echo "SMTP_CHECK_SPOOL_SPACE='$SMTP_CHECK_SPOOL_SPACE'`spaces \"$SMTP_CHECK_SPOOL_SPACE\" 13` # check if enough disk space for spool directory"
            echo '                                       # is available. Default is being set to 10Mb'
            echo "SMTP_CHECK_SPOOL_INODES='$SMTP_CHECK_SPOOL_INODES'`spaces \"$SMTP_CHECK_SPOOL_INODES\" 12` # check if enough inodes for spool directory"
            echo '                                       # are available. Default is being set to 100'
            echo
            echo "SMTP_LIMIT='$SMTP_LIMIT'`spaces \"$SMTP_LIMIT\" 25` # mail size limit. Default is being set to 50Mb"
            echo
            echo "SMTP_REMOVE_RECEIPT_REQUEST='$SMTP_REMOVE_RECEIPT_REQUEST'`spaces \"$SMTP_REMOVE_RECEIPT_REQUEST\" 8` # remove external receipt request: yes or no"
            echo
            echo "SMTP_SERVER_TRANSPORT='$SMTP_SERVER_TRANSPORT'`spaces \"$SMTP_SERVER_TRANSPORT\" 14` # transport to use: default, tls or both"
            echo "SMTP_SERVER_TLS_ADVERTISE_HOSTS='$SMTP_SERVER_TLS_ADVERTISE_HOSTS'`spaces \"$SMTP_SERVER_TLS_ADVERTISE_HOSTS\" 4` # advertise STARTLS to these hosts, to disable"
            echo "                                       # this feature set to '' (required for tls!)"
            echo "SMTP_SERVER_TLS_VERIFY_HOSTS='$SMTP_SERVER_TLS_VERIFY_HOSTS'`spaces \"$SMTP_SERVER_TLS_VERIFY_HOSTS\" 7` # verify tls certs of these hosts, to diasble"
            echo "                                       # this feature set to ''"
            echo
            echo "SMTP_SERVER_SSMTP='$SMTP_SERVER_SSMTP'`spaces \"$SMTP_SERVER_SSMTP\" 18` # start SSMTP server: yes or no"
            echo "SMTP_SERVER_SSMTP_LISTEN_PORT='$SMTP_SERVER_SSMTP_LISTEN_PORT'`spaces \"$SMTP_SERVER_SSMTP_LISTEN_PORT\" 6` # port on which Exim is listening for"
            echo "                                       # inbound traffic, default is 'ssmtp'"
        fi

        echo
        echo '#------------------------------------------------------------------------------'
        echo '# smtp: local domains'
        echo '#------------------------------------------------------------------------------'
        echo
        echo "SMTP_LOCAL_DOMAIN_N='$SMTP_LOCAL_DOMAIN_N'`spaces \"$SMTP_LOCAL_DOMAIN_N\" 16` # number of local domains"
        
        if [ $SMTP_LOCAL_DOMAIN_N -eq 0 ]
        then
            imax=3
        else
            imax=$SMTP_LOCAL_DOMAIN_N
        fi    

        idx=1
        while [ $idx -le $imax ]
        do
            eval local_domain='$SMTP_LOCAL_DOMAIN_'$idx

            echo -e "SMTP_LOCAL_DOMAIN_"$idx"='$local_domain'`spaces \"$local_domain\" 16` # $idx. local domain\c"
            
            if [ $idx -eq 1 ]
            then
                echo ", @ means SMTP_HOSTNAME"
            else
                echo
            fi

            idx=`expr $idx + 1`
        done    

        echo
        echo '#------------------------------------------------------------------------------'
        echo '# smtp: relay to domains'
        echo '#'
        echo '# Optional:'
        echo '#   The folllowing setting specify domains for which your host is an incoming'
        echo '#   relay. If you are not doing any relaying, you should leave the list empty.'
        echo '#   However, if your host is an MX backup or gateway of some kind for some'
        echo '#   domains, you must set SMTP_RELAY_TO_DOMAIN_x to match those domains.'
        echo '#------------------------------------------------------------------------------'
        echo
        echo "SMTP_RELAY_TO_DOMAIN_N='$SMTP_RELAY_TO_DOMAIN_N'`spaces \"$SMTP_RELAY_TO_DOMAIN_N\" 13` # domains for which we are incoming relay"

        if [ $SMTP_RELAY_TO_DOMAIN_N -eq 0 ]
        then
            imax=1
        else
            imax=$SMTP_RELAY_TO_DOMAIN_N
        fi    

        idx=1
        while [ $idx -le $imax ]
        do
            eval relay_to_domain='$SMTP_RELAY_TO_DOMAIN_'$idx

            echo "SMTP_RELAY_TO_DOMAIN_"$idx"='$relay_to_domain'"
            idx=`expr $idx + 1`
        done

        echo
        echo '#------------------------------------------------------------------------------'
        echo '# smtp: relay from hosts'
        echo '#'
        echo '# The following settings specify hosts that can use your host as an'
        echo '# outgoing relay to any other host on the Internet. Such a setting'
        echo '# commonly refers to a complete local network as well as the localhost.'
        echo '#------------------------------------------------------------------------------'
        echo
        echo "SMTP_RELAY_FROM_HOST_N='$SMTP_RELAY_FROM_HOST_N'`spaces \"$SMTP_RELAY_FROM_HOST_N\" 13` # hosts/nets from we accept outgoing mails"

        if [ $SMTP_RELAY_FROM_HOST_N -eq 0 ]
        then
            imax=2
        else
            imax=$SMTP_RELAY_FROM_HOST_N
        fi    

        idx=1
        while [ $idx -le $imax ]
        do
            eval relay_from_host='$SMTP_RELAY_FROM_HOST_'$idx

            echo "SMTP_RELAY_FROM_HOST_"$idx"='$relay_from_host'"
            idx=`expr $idx + 1`
        done

        echo
        echo '#------------------------------------------------------------------------------'
        echo '# smtp: server authentication'
        echo '#'
        echo '# Optional:'
        echo '#   Set the type of server authentication.'
        echo '#   none   - no authentication'
        echo '#   user   - each user authenticates himself by his username/password'
        echo '#   server - all users authenticate themself by sending a global user/pass'
        echo '#------------------------------------------------------------------------------'
        echo
        echo "SMTP_AUTH_TYPE='$SMTP_AUTH_TYPE'`spaces \"$SMTP_AUTH_TYPE\" 21` # authentication: none, user, server,"
        echo "                                       # user_light or server_light"
        echo "SMTP_AUTH_USER='$SMTP_AUTH_USER'`spaces \"$SMTP_AUTH_USER\" 21` # if server: global username, else empty"
        echo "SMTP_AUTH_PASS='$SMTP_AUTH_PASS'`spaces \"$SMTP_AUTH_PASS\" 21` # if server: global password, else empty"
        echo
        echo '#------------------------------------------------------------------------------'
        echo '# smtp: smarthosts'
        echo '#'
        echo '# Optional:'
        echo '#   Send all outgoing messages to a smarthost (e.g. mail server of your isp).'
        echo '#------------------------------------------------------------------------------'
        echo
        echo "SMTP_SMARTHOST_ONE_FOR_ALL='$SMTP_SMARTHOST_ONE_FOR_ALL'`spaces \"$SMTP_SMARTHOST_ONE_FOR_ALL\" 9` # use one smarthost for all accounts:"
        echo "                                       # if 'yes', the first entry will be read"
        echo "                                       # if 'no', user specific entries will be used"

        if [ "$config_level" != "basic" ]
        then
            echo "SMTP_SMARTHOST_DOMAINS='$SMTP_SMARTHOST_DOMAINS'`spaces \"$SMTP_SMARTHOST_DOMAINS\" 13` # if SMTP_SMARTHOST_ONE_FOR_ALL='yes' then"
            echo "                                       # use it only for these domains (separated by ':')"
            echo "SMTP_SMARTHOST_ROUTE_TYPE='$SMTP_SMARTHOST_ROUTE_TYPE'`spaces \"$SMTP_SMARTHOST_ROUTE_TYPE\" 10` # if SMTP_SMARTHOST_ONE_FOR_ALL='no' then how to select"
            echo "                                       # smart host: by sender mail 'addr'ess or destination 'domain'"
        fi

        echo
        echo "SMTP_SMARTHOST_N='$SMTP_SMARTHOST_N'`spaces \"$SMTP_SMARTHOST_N\" 19` # number of smarthost entries"

        if [ $SMTP_SMARTHOST_N -eq 0 ]
        then
            imax=1
        else
            imax=$SMTP_SMARTHOST_N
        fi    

        idx=1
        while [ $idx -le $imax ]
        do
            eval sh_host='$SMTP_SMARTHOST_'$idx'_HOST'
            eval sh_auth='$SMTP_SMARTHOST_'$idx'_AUTH_TYPE'
            eval sh_addr='$SMTP_SMARTHOST_'$idx'_ADDR'
            eval sh_domain='$SMTP_SMARTHOST_'$idx'_DOMAIN'
            eval sh_user='$SMTP_SMARTHOST_'$idx'_USER'
            eval sh_pass='$SMTP_SMARTHOST_'$idx'_PASS'
            eval sh_fauth='$SMTP_SMARTHOST_'$idx'_FORCE_AUTH'
            eval sh_ftls='$SMTP_SMARTHOST_'$idx'_FORCE_TLS'
            eval sh_port='$SMTP_SMARTHOST_'$idx'_PORT'

            echo "SMTP_SMARTHOST_"$idx"_HOST='$sh_host'`spaces \"$sh_host\" 14` # ${idx}. smart host to send mail to, e.g. mail.gmx.net"
            echo "SMTP_SMARTHOST_"$idx"_AUTH_TYPE='$sh_auth'`spaces \"$sh_auth\" 9` #    'none', 'plain', 'login', 'md5' or 'msn'"

            if [ "$config_level" != "basic" ]
            then
                echo "SMTP_SMARTHOST_"$idx"_ADDR='$sh_addr'`spaces \"$sh_addr\" 14` #    if SMTP_SMARTHOST_ROUTE_TYPE='addr': sender mail address"
                echo "SMTP_SMARTHOST_"$idx"_DOMAIN='$sh_domain'`spaces \"$sh_domain\" 12` #    if SMTP_SMARTHOST_ROUTE_TYPE='domain': destination domain"
            fi

            echo "SMTP_SMARTHOST_"$idx"_USER='$sh_user'`spaces \"$sh_user\" 14` #    if authentication required: username"
            echo "SMTP_SMARTHOST_"$idx"_PASS='$sh_pass'`spaces \"$sh_pass\" 14` #    if authentication required: password"

            if [ "$config_level" != "basic" ]
            then
                echo "SMTP_SMARTHOST_"$idx"_FORCE_AUTH='$sh_fauth'`spaces \"$sh_fauth\" 8` #    set to 'yes' to allow only authenticated connections"
                echo "SMTP_SMARTHOST_"$idx"_FORCE_TLS='$sh_ftls'`spaces \"$sh_ftls\" 9` #    set to 'yes' to allow only secure connections"
                echo "SMTP_SMARTHOST_"$idx"_PORT='$sh_port'`spaces \"$sh_port\" 14` #    port to use for outgoing connections, default is 'smtp'"
            fi    

            if [  $idx -le `expr $imax - 1` ]
            then
                echo "#------------------------------------------------------------------------------"
            fi    
            idx=`expr $idx + 1`
        done

        if [ "$config_level" != "basic" ]
        then
            echo
            echo '#------------------------------------------------------------------------------'
            echo '# smtp: update ignore hosts file'
            echo '#------------------------------------------------------------------------------'
            echo
            echo "SMTP_UPDATE_IGNORE_HOSTS='$SMTP_UPDATE_IGNORE_HOSTS'`spaces \"$SMTP_UPDATE_IGNORE_HOSTS\" 25`# update ignore hosts: yes or no"
            echo "SMTP_UPDATE_IGNORE_HOSTS_CRON_SCHEDULE='$SMTP_UPDATE_IGNORE_HOSTS_CRON_SCHEDULE'`spaces \"$SMTP_UPDATE_IGNORE_HOSTS_CRON_SCHEDULE\" 10` # cron configuration string"
        fi

        echo
        echo '#------------------------------------------------------------------------------'
        echo '# smtp: aliases'
        echo '#'
        echo '# Here you can specify aliases'
        echo '#'
        echo '# General format:'
        echo "#   SMTP_ALIASES_x_ALIAS_y='name: user1[,user2,...]"
        echo '#'
        echo '# Example:'
        echo "#   SMTP_ALIASES_N='2'"
        echo '#   ...'
        echo "#   SMTP_ALIASES_2_DOMAIN='2nd.local.lan'"
        echo "#   SMTP_ALIASES_2_ALIAS_N='1'"
        echo "#   SMTP_ALIASES_2_ALIAS_1='frank: fm,foo@otherwhere.com'"
        echo '#'
        echo '# Mails to frank@domain.de will be delivered to local user fm and to'
        echo '# user foo@otherwhere.com.'
        echo '#------------------------------------------------------------------------------'
        echo

        if [ "$config_level" != "basic" ]
        then
            echo "SMTP_ALIASES_N='$SMTP_ALIASES_N'`spaces \"$SMTP_ALIASES_N\" 21` # number of domains: default: 1"
        fi

        if [ $SMTP_ALIASES_N -eq 0 ]
        then
            imax=1
        else
            imax=$SMTP_ALIASES_N
        fi    

        idx=1
        while [ $idx -le $imax ]
        do
            eval aliases_domain='$SMTP_ALIASES_'$idx'_DOMAIN'
            eval aliases_entry_nbr='$SMTP_ALIASES_'$idx'_ALIAS_N'

            if [ "$config_level" != "basic" ]
            then
                echo "SMTP_ALIASES_"$idx"_DOMAIN='$aliases_domain'`spaces \"$aliases_domain\" 14` # ${idx}. domain name: will only be read if SMTP_ALIASES_N > 1"
                echo '                                       #    and not SMTP_ALIASES_1_DOMAIN'
            fi

            echo "SMTP_ALIASES_"$idx"_ALIAS_N='$aliases_entry_nbr'`spaces \"$aliases_entry_nbr\" 13` #    number of aliases"

            if [ $aliases_entry_nbr -eq 0 ]
            then
                jmax=2
            else
                jmax=$aliases_entry_nbr
            fi    

            jdx=1
            while [ $jdx -le $jmax ]
            do
                eval aliases_entry='$SMTP_ALIASES_'$idx'_ALIAS_'$jdx

                echo -e "SMTP_ALIASES_"$idx"_ALIAS_"$jdx"='$aliases_entry'`spaces \"$aliases_entry\" 13` #    ${jdx}. alias \c"

                if [ $jdx -eq 1 ]
                then
                    echo "must be for user 'root'!"
                else    
                    echo
                fi    
                jdx=`expr $jdx + 1`
            done

            idx=`expr $idx + 1`
        done

        echo
        echo '#------------------------------------------------------------------------------'
        echo '# smtp: outgoing addresses'
        echo '#'
        echo '# Here you can specify an address translation table which is only available'
        echo '# if SMTP_SMARTHOST_N has been set to a value greater than 0.'
        echo '#'
        echo '# General format:'
        echo "#   SMTP_OUTGOING_ADDRESSES_x='name: email address'"
        echo '#'
        echo '# Example:'
        echo "#   SMTP_OUTGOING_ADDRESSES_1='fm: frank@domain.de'"
        echo '#'
        echo "#   Mail from local user 'fm' will be delivered by using sender address"
        echo "#   'frank@domain.de'."
        echo '#------------------------------------------------------------------------------'
        echo
        echo "SMTP_OUTGOING_ADDRESSES_N='$SMTP_OUTGOING_ADDRESSES_N'"

        if [ $SMTP_OUTGOING_ADDRESSES_N -eq 0 ]
        then
            imax=1
        else
            imax=$SMTP_OUTGOING_ADDRESSES_N
        fi    

        idx=1
        while [ $idx -le $imax ]
        do
            eval address='$SMTP_OUTGOING_ADDRESSES_'$idx

            echo "SMTP_OUTGOING_ADDRESSES_"$idx"='$address'"
            idx=`expr $idx + 1`
        done

        echo
        echo '#------------------------------------------------------------------------------'
        echo '# smtp: incoming addresses'
        echo '#'
        echo '# Example:'
        echo "#   SMTP_HEADER_REWRITE_1_SOURCE='*@home.lan'"
        echo "#   SMTP_HEADER_REWRITE_1_DESTINATION='\$1@domain.de'"
        echo "#   SMTP_HEADER_REWRITE_1_FLAGS='sF'"
        echo '#'
        echo '#   The envelope from address and the sender of an incoming smtp mail from'
        echo "#   user 'frank@home.lan' will be rewritten to 'frank@domain.de'"
        echo '#------------------------------------------------------------------------------'
        echo
        echo "SMTP_HEADER_REWRITE_N='$SMTP_HEADER_REWRITE_N'`spaces \"$SMTP_HEADER_REWRITE_N\" 29` # number of rewrite rules"

        if [ $SMTP_HEADER_REWRITE_N -eq 0 ]
        then
            imax=1
        else
            imax=$SMTP_HEADER_REWRITE_N
        fi    

        idx=1
        while [ $idx -le $imax ]
        do
            eval header_source='$SMTP_HEADER_REWRITE_'$idx'_SOURCE'
            eval header_destination='$SMTP_HEADER_REWRITE_'$idx'_DESTINATION'
            eval header_flags='$SMTP_HEADER_REWRITE_'$idx'_FLAGS'

            echo "SMTP_HEADER_REWRITE_"$idx"_SOURCE='$header_source'`spaces \"$header_source\" 22` # ${idx}. search mask"
            echo "SMTP_HEADER_REWRITE_"$idx"_DESTINATION='$header_destination'`spaces \"$header_destination\" 17` #    replace string"
            echo "SMTP_HEADER_REWRITE_"$idx"_FLAGS='$header_flags'`spaces \"$header_flags\" 23` #    what to rewrite"
            idx=`expr $idx + 1`
        done

        echo
        echo '#------------------------------------------------------------------------------'
        echo '# smtp: mailing lists'
        echo '#'
        echo '# Here you can specify simple mailing lists'
        echo '#'
        echo '# Explanation of example below:'
        echo '#'
        echo "# A mail to 'eisfair@domain.de' will be delivered to all members in the list."
        echo "# The reply address will be changed to 'eisfair@domain.de'!"
        echo '#------------------------------------------------------------------------------'
        echo
        echo "SMTP_LIST_DOMAIN='$SMTP_LIST_DOMAIN'`spaces \"$SMTP_LIST_DOMAIN\" 23` # domain part of mailing list addrs"
        echo "SMTP_LIST_ERRORS='$SMTP_LIST_ERRORS'`spaces \"$SMTP_LIST_ERRORS\" 23` # send errors to this address"
        echo
        echo "SMTP_LIST_N='$SMTP_LIST_N'`spaces \"$SMTP_LIST_N\" 28` # number of mailing lists, change here!"

        if [ $SMTP_LIST_N -eq 0 ]
        then
            imax=2
        else
            imax=$SMTP_LIST_N
        fi    

        idx=1
        while [ $idx -le $imax ]
        do
            eval list_name='$SMTP_LIST_'$idx'_NAME'
            eval list_user_n='$SMTP_LIST_'$idx'_USER_N'

            # make sure that parameter hasn't been set to an empty string
            if [ "$list_user_n" = "" ]
            then
                list_user_n=0
            fi

            echo "SMTP_LIST_"$idx"_NAME='$list_name'`spaces \"$list_name\" 23` # ${idx}. name of list"

            echo "SMTP_LIST_"$idx"_USER_N='$list_user_n'`spaces \"$list_user_n\" 21` #    number of list members"

            if [ $list_user_n -eq 0 ]
            then
                jmax=2
            else
                jmax=$list_user_n
            fi    

            jdx=1
            while [ $jdx -le $jmax ]
            do
                eval user='$SMTP_LIST_'$idx'_USER_'$jdx

                echo "SMTP_LIST_"$idx"_USER_$jdx='$user'`spaces \"$user\" 21` #    ${jdx}. member"
                jdx=`expr $jdx + 1`
            done

            if [  $idx -le `expr $imax - 1` ]
            then
                echo "#------------------------------------------------------------------------------"
            fi    
            idx=`expr $idx + 1`
        done

        echo
        echo '#------------------------------------------------------------------------------'
        echo '# exiscan: virus scanning'
        echo '#'
        echo '# Here you can specify an additinal antivirus scanner Please make sure'
        echo '# that you have installed a antivirus software prior you enable these feature.'
        echo '#------------------------------------------------------------------------------'
        echo
        echo "START_EXISCAN='$START_EXISCAN'`spaces \"$START_EXISCAN\" 26` # start EXISCAN: yes or no"
        echo
        echo "EXISCAN_CRYPT_SALT='$EXISCAN_CRYPT_SALT'`spaces \"$EXISCAN_CRYPT_SALT\" 21` # crypt salt - \`must' be set to a unique"
        echo "                                           # character string!"

        echo "EXISCAN_DEMIME_ENABLED='$EXISCAN_DEMIME_ENABLED'`spaces \"$EXISCAN_DEMIME_ENABLED\" 17` # unpack mime containers: yes or no"
        echo "EXISCAN_DEMIME_ACTION='$EXISCAN_DEMIME_ACTION'`spaces \"$EXISCAN_DEMIME_ACTION\" 18` # action on mime exploiis: pass, reject,"
        echo '                                           # discard, freeze, redirect <address>'
        echo "EXISCAN_AV_ENABLED='$EXISCAN_AV_ENABLED'`spaces \"$EXISCAN_AV_ENABLED\" 21` # use viruscanner: yes or no"
        echo "EXISCAN_AV_ACTION='$EXISCAN_AV_ACTION'`spaces \"$EXISCAN_AV_ACTION\" 22` # action on virus: pass, reject, discard,"
        echo '                                           # freeze, redirect <address>'
        echo "EXISCAN_AV_SUBJECT_TAG='$EXISCAN_AV_SUBJECT_TAG'`spaces \"$EXISCAN_AV_SUBJECT_TAG\" 17` # mark subject with tag, only usefull if"
        echo "                                           # EXISCAN_AV_ACTION has been set to 'pass'"
        echo "EXISCAN_AV_SCANNER='$EXISCAN_AV_SCANNER'`spaces \"$EXISCAN_AV_SCANNER\" 21` # scanner: auto, cmdline, sophie, kavdaemon,"
        echo '                                           # clamd, drweb, mksd'
        echo "EXISCAN_AV_PATH='$EXISCAN_AV_PATH'`spaces \"$EXISCAN_AV_PATH\" 24` # path to antivirus scanner"
        echo "EXISCAN_AV_OPTIONS='$EXISCAN_AV_OPTIONS'`spaces \"$EXISCAN_AV_OPTIONS\" 21` # cmdline option for scanner incl. '%s'"
        echo "EXISCAN_AV_TRIGGER='$EXISCAN_AV_TRIGGER'`spaces \"$EXISCAN_AV_TRIGGER\" 21` # regexp string if virus has been found"
        echo "EXISCAN_AV_DESCRIPTION=\"$EXISCAN_AV_DESCRIPTION\"`spaces \"$EXISCAN_AV_DESCRIPTION\" 17` # grep virus name from regexp description"
        echo "EXISCAN_AV_SOCKET='$EXISCAN_AV_SOCKET'`spaces \"$EXISCAN_AV_SOCKET\" 22` # socket for sophie, kavdaemon, clamav ..."
        echo
        echo "EXISCAN_EXTENSION_ENABLED='$EXISCAN_EXTENSION_ENABLED'`spaces \"$EXISCAN_EXTENSION_ENABLED\" 14` # use extension checking: yes or no"
        echo "EXISCAN_EXTENSION_ACTION='$EXISCAN_EXTENSION_ACTION'`spaces \"$EXISCAN_EXTENSION_ACTION\" 15` # action on extension: pass, reject, discard,"
        echo '                                           # freeze, redirect <address>'
        echo "EXISCAN_EXTENSION_DATA='$EXISCAN_EXTENSION_DATA'`spaces \"$EXISCAN_EXTENSION_DATA\" 17` # filter 'exe', 'com' and 'vbs' extensions"
        echo
        echo "EXISCAN_REGEX_ENABLED='$EXISCAN_REGEX_ENABLED'`spaces \"$EXISCAN_REGEX_ENABLED\" 18` # use regex checking: yes or no"
        echo "EXISCAN_REGEX_ACTION='$EXISCAN_REGEX_ACTION'`spaces \"$EXISCAN_REGEX_ACTION\" 19` # action on regex: pass, reject, discard,"
        echo '                                           # freeze, redirect <address>'
        echo "EXISCAN_REGEX_DATA='$EXISCAN_REGEX_DATA'`spaces \"$EXISCAN_REGEX_DATA\" 21` # filter '[Mm]ortage' and 'make money' strings"
        echo
        echo "EXISCAN_SPAMD_ENABLED='$EXISCAN_SPAMD_ENABLED'`spaces \"$EXISCAN_SPAMD_ENABLED\" 18` # use spamd checking: yes or no"
        echo "EXISCAN_SPAMD_ACTION='$EXISCAN_SPAMD_ACTION'`spaces \"$EXISCAN_SPAMD_ACTION\" 19` # action on spamd: pass, reject, discard,"
        echo '                                           # freeze, redirect <address>'
        echo "EXISCAN_SPAMD_HEADER_STYLE='$EXISCAN_SPAMD_HEADER_STYLE'`spaces \"$EXISCAN_SPAMD_HEADER_STYLE\" 13` # type of X-header: none, single, flag, full"
        echo "EXISCAN_SPAMD_SUBJECT_TAG='$EXISCAN_SPAMD_SUBJECT_TAG'`spaces \"$EXISCAN_SPAMD_SUBJECT_TAG\" 14` # mark subject with tag, only usefull if"
        echo "                                           # EXISCAN_SPAMD_ACTION has been set to 'pass'"
        echo "EXISCAN_SPAMD_THRESHOLD='$EXISCAN_SPAMD_THRESHOLD'`spaces \"$EXISCAN_SPAMD_THRESHOLD\" 16` # spamd score threshold"
        echo "EXISCAN_SPAMD_ADDRESS='$EXISCAN_SPAMD_ADDRESS'`spaces \"$EXISCAN_SPAMD_ADDRESS\" 18` # address on which spamd is listening"
        echo

        if [ "$config_level" != "basic" ]
        then
            echo '#------------------------------------------------------------------------------'
            echo '# mail: send warning if TLS certificates will become invalid'
            echo '#------------------------------------------------------------------------------'
            echo
            echo "MAIL_CERTS_WARNING='$MAIL_CERTS_WARNING'`spaces \"$MAIL_CERTS_WARNING\" 36` # send certs warning: yes or no"
            echo "MAIL_CERTS_WARNING_SUBJECT='$MAIL_CERTS_WARNING_SUBJECT'`spaces \"$MAIL_CERTS_WARNING_SUBJECT\" 28` # subject of warning mail"
            echo "MAIL_CERTS_WARNING_CRON_SCHEDULE='$MAIL_CERTS_WARNING_CRON_SCHEDULE'`spaces \"$MAIL_CERTS_WARNING_CRON_SCHEDULE\" 22` # cron configuration string"
            echo
            echo '#------------------------------------------------------------------------------'
            echo '# mail: send exim statistics'
            echo '#------------------------------------------------------------------------------'
            echo
            echo "MAIL_STATISTICS_INFOMAIL='$MAIL_STATISTICS_INFOMAIL'`spaces \"$MAIL_STATISTICS_INFOMAIL\" 30` # send statistics infomail: yes or no"
            echo "MAIL_STATISTICS_INFOMAIL_SUBJECT='$MAIL_STATISTICS_INFOMAIL_SUBJECT'`spaces \"$MAIL_STATISTICS_INFOMAIL_SUBJECT\" 22` # subject of infomail"
            echo "MAIL_STATISTICS_INFOMAIL_CRON_SCHEDULE='$MAIL_STATISTICS_INFOMAIL_CRON_SCHEDULE'`spaces \"$MAIL_STATISTICS_INFOMAIL_CRON_SCHEDULE\" 16` # cron configuration string"
            echo
        fi

        echo '#------------------------------------------------------------------------------'
        echo '# mail: log handling'
        echo '#'
        echo '# Here you can specify how many logs should be saved and in with interval.'
        echo '#'
        echo '# Example:'
        echo "#   MAIL_LOG_COUNT='10' - save the last 10 log files"
        echo "#   MAIL_LOG_INTERVAL='daily' - save one log file per day"
        echo '#------------------------------------------------------------------------------'
        echo
        echo "MAIL_LOG_COUNT='$MAIL_LOG_COUNT'`spaces \"$MAIL_LOG_COUNT\" 25` # number of log files to save"
        echo "MAIL_LOG_INTERVAL='$MAIL_LOG_INTERVAL'`spaces \"$MAIL_LOG_INTERVAL\" 22` # interval: daily, weekly, monthly"
        echo
        echo '#------------------------------------------------------------------------------'
        echo '# End'
        echo '#------------------------------------------------------------------------------'
    } > $generate_conf
    mecho -warn "... finished."
}

#==============================================================================
# main
#==============================================================================

# set variables
#testroot=/soft/jedmail
 testroot=''

mailfile=$testroot/etc/config.d/mail
installfile=$testroot/var/run/mail.install
basicfile=$mailfile.basic
advancedfile=$mailfile.advanced
fullfile=$mailfile.full
conf_tmpdir=/var/spool/exim
read_pop3imap_users=$testroot/var/spool/exim/pop3imap.csv

# setting defaults
source_conf=$installfile
generate_conf=$mailfile

goflag=0

case "$1"
in
    update)
        # update configuration
        goflag=1
        ;;
    import)
        # import pop3imap user list
        if [ -f $read_pop3imap_users ]
        then
            /var/install/bin/backup-file -quiet $mailfile

            source_conf=$conf_tmpdir/`basename $mailfile`.tmp
            mv $mailfile $source_conf

          # generate_conf=$testroot/etc/config.d/mk_mail.test        # test
            goflag=1
        fi    
        ;;
    export)
        # export pop3imap user list
        if [ -f $read_pop3imap_users ]
        then
            mv -v $read_pop3imap_users $read_pop3imap_users.backup
        fi    

        source_conf=$mailfile
        . $source_conf

        export_pop3imap_users
        goflag=0
        ;;
    basic)
        # create basic configuration
        source_conf=$mailfile
        generate_conf=$basicfile
        goflag=2
        ;;
    advanced)
        # create advanced configuration
        source_conf=$mailfile
        generate_conf=$advancedfile
        goflag=3
        ;;
    merge)
        # merge basic configuration
        cp $mailfile $fullfile

        source_conf=$mailfile                                     # .full will be added later
        generate_conf=$mailfile
        goflag=4
        ;;
    test)
    #   source_conf=$mailfile.new
    #   source_conf=$mailfile.new.v1.1.1
    #   source_conf=$mailfile.new.v1.1.2
    #   source_conf=$mailfile.new.v1.1.3
    #   source_conf=$mailfile.new.v1.1.5
        source_conf=$mailfile
    #   source_conf=$conf_tmpdir/mail

        generate_conf=$conf_tmpdir/mk_mail.test
        goflag=1
        ;;
    *)
        echo
        echo "Use one of the following options:"
        echo
        echo "  mail-update [import] - the pop3/imap users from the file $read_pop3imap_users"
        echo "                         will be imported in the mail configuration file."
        echo
        echo "  mail-update [export] - the pop3/imap users from  mail configuration file will"
        echo "                         will be exported to the file $read_pop3imap_users"
        echo
        echo "  mail-update [update] - the file $mailfile.import will be read, the configuration will"
        echo "                         be checked and an updated mail configuration file will be written."
        echo
        goflag=0
esac

case $goflag 
in
    1)
        # update configuration
        if [ -f $source_conf ]
        then
            # previous configuration file exists
            . $source_conf

            import_pop3imap_users

            rename_variables
            modify_variables
            add_variables
            delete_variables

            create_config

            /var/install/bin/anykey

            # remove tmp file
            rm -f $conf_tmpdir/`basename $mailfile`.tmp
        else    
            mecho -error "no configuration $source_conf found - exiting."
        fi    
        ;;
    2)
        # create basic configuration
        if [ -f $source_conf ]
        then
            # previous configuration file exists
            . $source_conf

            create_config basic
        fi
        ;;
    3)
        # create advanced configuration
        if [ -f $source_conf ]
        then
            # previous configuration file exists
            . $source_conf

            create_config advanced
        fi    
        ;;
    4)
        # merge basic configuration
        if [ -f $fullfile ]
        then
            # full  configuration file exists
            . $fullfile

            if [ -f $basicfile ]
            then
                # basic configuration file exists
                . $basicfile
            fi

            create_config merge

            # remove temporary file
            rm -f $fullfile
            rm -f $basicfile
        fi
        ;;
esac

#==============================================================================
# end
#==============================================================================