#!/bin/bash
#
# Kanotix-Update-GUI
#
# written by Andreas Loibl (http://www.andreas-loibl.de)
#

VERSION="0.1.6-1 (02.07.2005)"
TITLE="Kanotix-Update-GUI by A.Loibl"
DIALOG="Xdialog"

if [ "$LANGUAGE" = "de" ]; then
. /usr/share/locale/de/kanotix-update-gui-lde
else
. /usr/share/locale/en/kanotix-update-gui-len
fi

NO_DOWNLOAD=""
PATH_SECTIONS_LIST=""
PATH_SOFTWARE_LIST=""
PATH_PACKAGE_LIST=""

if [ $(id -u) -ne 0 ]; then
    # Nicht als root gestartet
    
    # Bugfix: Der Eintrag "gtk-alternative-button-order = 1" in der Datei ~/.kde/share/config/gtkrc bringt einen Fehler bei Xdialog
    if (grep -e "^\s*gtk-alternative-button-order" ~/.kde/share/config/gtkrc) && ! [ -e ~/.kanotix-update-gui/gtk-dontask ]; then
        Xdialog --title "$TITLE" --yesno "Es wurde eine Fehlkonfiguration in der Datei ~/.kde/share/config/gtkrc gefunden:\n\n$(sed -n -e '/^\s*gtk-alternative-button-order/p' < ~/.kde/share/config/gtkrc)\n\nWollen Sie diesen Eintrag automatisch auskommentieren?\n(Wenn Sie dies nicht machen werden die Xdialog-Mens vielleicht nicht richtig funktionieren)" 0 0
        if [ $? -eq 0 ]; then
            cat ~/.kde/share/config/gtkrc | sed -e 's/^\(\s*gtk-alternative-button-order\)/# \1/g' > ~/.kde/share/config/gtkrc
        else
            Xdialog --title "$TITLE" --yesno "Sie haben ausgewhlt, dass Sie es nicht korrigieren wollen.\n\nWollen Sie die Abfrage dafr deaktivieren?\n(Ansonsten wird sie bei jedem Start von Kanotix-Update-GUI erscheinen)" 0 0
            [ $? -eq 0 ] && mkdir -p ~/.kanotix-update-gui && touch ~/.kanotix-update-gui/gtk-dontask
        fi
    fi

    if [ -e "/usr/bin/kanotix-su" ]; then
        kanotix-su "$0" $@
    else
        kdesu -- "$0" $@
    fi
    exit 0
fi

# gibt den Info-Dialog aus
function infoDialog()
{
dialogMsg "Kanotix-Update-GUI

Version: $VERSION
Autor: Andreas Loibl
(http://www.andreas-loibl.de)

$INFO_DIALOG"
}

# gibt den Hilfe-Dialog aus
function helpDialog()
{
dialogMsg "Hilfe-Text fehlt noch..."
}

function debug()
{
    echo "$1" 1>&2
}

# Erzeugt das InitScript
function createInitScript()
{
cat >/etc/init.d/kanotix-update-gui <<"EndOfInitScript"
#!/bin/bash
#
# Kanotix-Update-GUI
#

function kernelUpdate()
{
    # Das Script wird nach einem Kernelupdate ausgefhrt

    # Nur ausfhren wenn entweder kein Parameter oder der Parameter start bergeben wurde
    [ "$1" -a "$1" != "start" ] && return 1

    echo -e "\nKanotix-Update-GUI fhrt jetzt die notwendigen nderungen nach dem Kernelupdate aus, bitte warten...\n"

    TEMP_FILE="/tmp/temp.$RANDOM"

    while true
    do
        dialog --yesno "Kanotix-Update-GUI fhrt jetzt die notwendigen nderungen nach dem Kernelupdate aus.\n\nWollen Sie fortfahren?" 0 0
    
        if [ $? -ne 0 ]; then
            # Der User will nicht automatisch fortfahren
            dialog --default-item " " --no-cancel --menu "Was wollen Sie jetzt tun?" 0 0 7 " " "Zurck (vor. Men)" "1" "Konsole (init 3)" "2" "Grafische Oberflche" "3" "Computer neustarten" "4" "Computer ausschalten" 2>"$TEMP_FILE"
            SELECT=$(cat "$TEMP_FILE")
            case "$SELECT" in
            1)
                update-rc.d -f kanotix-update-gui remove # Das Script vom Bootprozess austragen
                rm "$TEMP_FILE" # die temporre Datei lschen
                echo "Drcken Sie Enter und sie knnen sich auf der Konsole einloggen..."
                exit 0
                ;;
            2)
                dialog --yesno "Hinweis: Die empfohlenen nderungen sind noch NICHT vorgenommen worden.\n\nWollen Sie wirklich schon auf die grafische Oberflche wechseln?" 0 0
                if [ $? -eq 0 ]; then
                    update-rc.d -f kanotix-update-gui remove # Das Script vom Bootprozess austragen
                    rm "$TEMP_FILE" # die temporre Datei lschen
                    init 5
                    exit 1
                fi
                ;;
            3)
                reboot
                ;;
            4)
                halt
                ;;
            esac
        else
            break
        fi
    done
    
    # Folgende Befehle mssen nach einem Update ausgefhrt werden
    # (steht so im Wiki; hier noch erweitert)
    update-modules                  # /etc/modules-$(uname -r) updaten
    fix-cdrom || fix-cdrom.bash     # fix-cdrom (oder fix-cdrom.bash auf alten Kanotixen)
    fix-fonts || fix-fonts.sh       # fix-fonts (oder fix-fonts.sh auf alten Kanotixen)
    /etc/init.d/autofs restart      # autofs neustarten
    alsaconf                        # Alsa-Karten neu erkennen und die Treiber laden
    detect-fc.bash                  # Fritz!Card erkennen
    update-modules                  # /etc/modules-$(uname -r) nochmal updaten (z.B. wegen alsaconf (???))

    # den Bootsplash wieder installieren
    if ( dpkg -L bootsplash 2>&1 >/dev/null ); then
        # Paket 'bootsplash' ist installiert
        dialog --defaultno --yesno "Wollen Sie den Bootsplash wieder in die Grub-Konfiguration eintragen? [experimentell]" 0 0
        if [ $? -eq 0 ]; then
            # Ja, der User will es installieren
            cat /boot/grub/menu.lst | sed -e 's/initrd\.img$/initrd\.splash/g; s/\(vmlinuz .*\)$/\1splash=silent/g' > /boot/grub/menu.lst
            dpkg-reconfigure bootsplash
        fi
    fi

    # Hier muss jetzt noch der Grafiktreiber installiert werden
    # (falls man die NVidia- oder ATI-3D-Beschleunigung will)
    dialog --menu "Wollen Sie die Grafikkartentreiber fr NVidia oder ATI-Karten installieren? " 0 0 0 1 "Nein" 2 "NVidia Treiber installieren" 3 "ATI-Treiber installieren" 2>"$TEMP_FILE"
    if [ $? -eq 0 -a "$(cat "$TEMP_FILE")" != "1" ]; then
        SELECT=$(cat "$TEMP_FILE")
        # Bugfix: erst auf Internet-Verbindung prfen und dann weitermachen
        while true
        do
            ping -c1 -W1 kanotix.com >/dev/null 2>&1 # kanotix.com anpingen
            if [ $? -ne 0 ]; then
                # Nicht im Internet
                dialog --menu "Es konnte keine Verbindung mit kanotix.com hergestellt werden (ping scheiterte)\n\nWas wollen Sie jetzt machen? " 0 0 0 1 "Nochmals versuchen" 2 "Fehler ignorieren und Installation starten" 3 "Befehl ausfhren (z.B. pon <profil>)" 4 "Doch keine Treiber installieren" 2>"$TEMP_FILE"
                SELECT_TODO=$(cat "$TEMP_FILE")
                case "$SELECT_TODO" in
                2)
                    break
                    ;;
                3)
                    [ -f "/etc/ppp/peers/provider" ] && PROFIL=provider
                    [ -f "/etc/ppp/peers/dsl-provider" ] && PROFIL=dsl-provider
                    [ -f "/etc/ppp/peers/eagle" ] && PROFIL=eagle
                    [ -f "/etc/ppp/peers/fcdsl" ] && PROFIL=isdn
                    [ -f "/etc/ppp/peers/capi-isdn" ] && PROFIL=capi-isdn
                    [ -f "/etc/ppp/peers/fcdsl" ] && PROFIL=fcdsl
                    dialog --inputbox "Geben Sie den Befehl ein" 0 0 "pon $PROFIL" 2>"$TEMP_FILE"
                    eval "$(cat "$TEMP_FILE")"
                    ;;
                4)
                    SELECT=0 # Auswahl des zu installierenden Scripts zurcksetzen und damit hernach keine Treiber installieren
                    break
                    ;;
                esac
            else
                break
            fi
        done

        case "$SELECT" in
        2)
            if [ $(ls /usr/local/bin/install-nvidia-* | wc -l) -gt 1 ]; then
                COMMAND="dialog --default-item \"install-nvidia-debian.sh\" --menu \"Bitte whlen:\" 0 0 0"
                for IT_DRIVER in $(ls /usr/local/bin/install-nvidia-*)
                do
                    IT_SHORT="$(basename "$IT_DRIVER")"
                    COMMAND="$COMMAND \"$IT_SHORT\" \"\""
                done
    
                eval "$COMMAND" 2>"$TEMP_FILE"
                SELECT=$(cat "$TEMP_FILE")
                [ "$SELECT" ] && eval "$SELECT"
            else
                install-nvidia-debian.sh
            fi
            ;;
        3)
            install-radeon-debian.sh
            ;;
        esac
    fi

    # Die temporren nderungen im Bootprozess rckgngig machen
    # > "$0" # den Inhalt des Scripts lschen
    update-rc.d -f kanotix-update-gui remove # Das Script vom Bootprozess austragen
    rm "$TEMP_FILE" # die temporre Datei lschen

    # Danach die grafische Oberflche starten
    init 5
}

function distUpgrade()
{
    # Nur ausfhren wenn entweder kein Parameter oder der Parameter stop bergeben wurde
    [ "$1" -a "$1" != "stop" ] && return 1
    
    chvt 7 || chvt -t 7

    echo -e "\n\nKanotix-Update-GUI fhrt jetzt das Dist-Upgrade aus, bitte warten...\n"
    
    dialog --yesno "Kanotix-Update-GUI fhrt jetzt das Dist-Upgrade aus.\n\nWollen Sie fortfahren?\n(Nein startet wieder die grafische Oberflche)" 0 0
    
    if [ $? -eq 0 ]; then
        # LOCALE setzen
        if [ -f /etc/sysconfig/i18n ]; then
            . /etc/sysconfig/i18n
            [ -n "$LANG" ] || LANG="de_DE@euro"
            export LANG
            [ -n "$LC_CTYPE" ] && export LC_CTYPE || unset LC_CTYPE
            [ -n "$LC_COLLATE" ] && export LC_COLLATE || unset LC_COLLATE
            [ -n "$LC_MESSAGES" ] && export LC_MESSAGES || unset LC_MESSAGES
            [ -n "$LC_NUMERIC" ] && export LC_NUMERIC || unset LC_NUMERIC
            [ -n "$LC_MONETARY" ] && export LC_MONETARY || unset LC_MONETARY
            [ -n "$LC_TIME" ] && export LC_TIME || unset LC_TIME
            [ -n "$LC_ALL" ] && export LC_ALL || unset LC_ALL
            [ -n "$LANGUAGE" ] && export LANGUAGE || unset LANGUAGE
            [ -n "$LINGUAS" ] && export LINGUAS || unset LINGUAS
            [ -n "$_XKB_CHARSET" ] && export _XKB_CHARSET || unset _XKB_CHARSET

            if [ -n "$SYSFONTACM" ]; then
                case $SYSFONTACM in
                    iso01*|iso02*|iso15*|koi*|latin2-ucw*)
                        if [ "$TERM" = "linux" ]; then
                            if ls -l /proc/$$/fd/0 2>/dev/null | grep -- '-> /dev/tty[0-9]*$' >/dev/null 2>&1; then
                                echo -n -e '\033(K' > /proc/$$/fd/0
                            fi
                        fi
                        ;;
                esac
            fi
            unset SYSFONTACM
        fi # <-- Ende LOCALE

        freeze-rc.d
        # Log-Dateien leeren
        # > /tmp/distUpgrade.error.log
        > /tmp/distUpgrade.log
        apt-get dist-upgrade 2>&1 | tee /tmp/distUpgrade.log
        if [ ${PIPESTATUS[0]} -ne 0 ]; then
            echo -e "\a" # Piepen
            echo -e "\n\n"
            echo "Es ist ein Fehler beim Dist-Upgrade aufgetreten, drcken Sie [Enter] um Kanotix-Update-GUI anzuzeigen."
            echo "Dort knnen Sie dann entscheiden, wie es weitergehen soll."
            read # auf Enter warten
            
            TEMP_FILE="/tmp/temp.$RANDOM" # temporre Datei anlegen (fr das Men)
            # Men anzeigen
            while true
            do
                dialog --no-cancel --menu "Es ist ein Fehler aufgetreten,\nwas wollen Sie jetzt tun?" 0 0 0 "1" "Log anzeigen" "2" "Reparieren mit 'apt-get -f install'" "3" "Konsole ffnen (in init 3)" "4" "Dist-Upgrade erneut starten" "5" "Nichts mehr" 2>"$TEMP_FILE"
                
                SELECT="$(cat "$TEMP_FILE")"
                case "$SELECT" in
                1)
#                     dialog --menu "Welches Log wollen Sie anzeigen?" 0 0 0 " " "Zurck" "1" "Fehler-Log" "2" "Installations-Log" 2>"$TEMP_FILE"
#                     [ $? -ne 0 ] && continue # wenn Abbrechen gedrckt dann weiter in der Schleife (vor. Men)
#                     
#                     SELECT="$(cat "$TEMP_FILE")"
#                     case "$SELECT" in
#                     1)
#                         less "/tmp/distUpgrade.error.log"
#                         ;;
#                     2)
#                         less "/tmp/distUpgrade.log"
#                         ;;
#                     esac
#                     ;;

                    less "/tmp/distUpgrade.log"
                    ;;
                2)
                    apt-get -f install
                    break
                    ;;
                3)
                    echo -e "\nDie Bash wird jetzt gestartet, zurck zum Kanotix-Update-GUI gelangen Sie wenn Sie [Strg]+[D] drcken oder exit eingeben."
                    bash
                    ;;
                4)
                    apt-get dist-upgrade
                    break;
                    ;;
                5)
                    dialog --yesno "Wollen Sie wirklich nichts mehr machen? Durch den Fehler wurde das Dist-Upgrade abgebrochen. Dadurch sind warscheinlich nicht alle Pakete installiert worden.\n\nWenn Sie noch nichts dagegen unternommen haben (Option 2, 3 oder 4), dann kann das jetzt Folgen haben." 0 0
                    [ $? -eq 0 ] && break
                    ;;
                esac
            done
            rm "$TEMP_FILE" # die temporre Datei lschen
        fi
        apt-get -f install
        unfreeze-rc.d

        sleep 1
    fi

    # Die temporren nderungen am Bootprozesses wieder lschen
    # > "$0" # das Script lscht seinen eigenen Inhalt
    update-rc.d -f kanotix-update-gui remove # Das Script vom Bootprozess austragen
    
    # Danach die grafische Oberflche starten
    init 5
}

EndOfInitScript

chmod +x /etc/init.d/kanotix-update-gui
# Bugfix: wenn freeze-rc.d gestartet wurde dann wird K-U-GUI nicht automatisch im RL 3 gestartet werden knnen
[ -e "/etc/frozen-rc.d" ] && unfreeze-rc.d # darum hier unfreeze-rc.d ausfhren
update-rc.d -f kanotix-update-gui remove
update-rc.d kanotix-update-gui stop 20 0 1 2 3 4 6 . start 20 5 .
echo "$1 \$1" >> /etc/init.d/kanotix-update-gui
}

# Zeigt ein Men an
function dialogMenu()
{
    MENUTEXT="$1"
    shift
    COMMAND="$DIALOG --title \"$TITLE\" --menubox \"$MENUTEXT\" 30 40 0"
    while [ $# -gt 0 ]
    do
        COMMAND="$COMMAND \"$1\""
        shift
    done
    COMMAND="$COMMAND 2>&1"
    OUTPUT=$(eval "$COMMAND")
    RETURNCODE=$?
    echo "$OUTPUT"
    return $RETURNCODE
}

# Zeigt eine MessageBox an
function dialogMsg()
{
    COMMAND="$DIALOG --title \"$TITLE\" --msgbox \"\n$1\n\" 0 0 2>&1"
    echo $(eval "$COMMAND")
}

# Zeigt eine Ja/Nein-Abfrage an
function dialogYesNo()
{
    COMMAND="$DIALOG --title \"$TITLE\" --yesno \"\n$1\n\" 0 0 2>&1"
    eval "$COMMAND"
    return $?
}

# Zeigt ein Eingabefeld an
function dialogInputBox()
{
    COMMAND="$DIALOG --title \"$TITLE\" --inputbox \"\n$1\n\" 0 0 \"$2\" 2>&1"
    OUTPUT=$(eval "$COMMAND")
    RETURNCODE=$?
    echo "$OUTPUT"
    return $RETURNCODE
}

# Zeigt eine Auswahlliste an
function dialogRadioList()
{
    MENUTEXT="$1"
    shift
    COMMAND="$DIALOG --title \"$TITLE\" --radiolist \"\n$MENUTEXT\n\" 0 0 3"
    while [ $# -gt 0 ]
    do
        COMMAND="$COMMAND \"$1\""
        shift
    done
    COMMAND="$COMMAND 2>&1"
    OUTPUT=$(eval "$COMMAND")
    RETURNCODE=$?
    echo "$OUTPUT"
    return $RETURNCODE
}

# Zeigt eine Auswahlliste an
function dialogCheckList()
{
    MENUTEXT="$1"
    shift
    COMMAND="$DIALOG --title \"$TITLE\" --separate-output --checklist \"\n$MENUTEXT\n\" 0 0 10"
    while [ $# -gt 0 ]
    do
        COMMAND="$COMMAND \"$1\""
        shift
    done
    COMMAND="$COMMAND 2>&1"
    OUTPUT=$(eval "$COMMAND")
    RETURNCODE=$?
    echo "$OUTPUT"
    return $RETURNCODE
}

# Zeigt eine LogBox an
function dialogLogBox()
{
    LOGFILE="/tmp/kupd-log.$RANDOM"
    echo "$1" > "$LOGFILE"
    COMMAND="$DIALOG --title \"$TITLE\" --logbox \"$LOGFILE\" 0 0 2>&1"
    echo $(eval "$COMMAND")
    rm -f "$LOGFILE"
}

# Ld eine Datei herunter und zeigt einen grafischen Fortschrittsbalken an
function downloadFile()
{
    LOCAL_FILENAME="$2"
    [ -z "$LOCAL_FILENAME" ] && LOCAL_FILENAME=$(basename "$1")
    CMD="wget -O\"$LOCAL_FILENAME\" \"$1\" 2>&1 | awk '{sub(\"200\",\"0%\"); sub(\"%\",\"\"); print \$7 | \"Xdialog --gauge \\\"$STATUS_DOWNLOAD_FILE\n\n$1\\\" 0 0 0\"; }'"
    eval "$CMD"
    echo $LOCAL_FILENAME
}

# Erzeugt eine temporre Datei
function createTempFile()
{
    TEMP_FILE="/tmp/kanotix-update-gui.$$.$RANDOM.tmp"
    touch "$TEMP_FILE"
    chmod +x "$TEMP_FILE"
    echo "$TEMP_FILE"
}

# Lscht eine temporre Datei
function removeTempFile()
{
    [ -f "$1" ] && rm -f "$1"
}

function executeInConsole()
{
    TEMP_FILE=$(createTempFile)
    echo "#!/bin/bash" >"$TEMP_FILE"
    while [ "$1" ]
    do
        echo "$1" >>"$TEMP_FILE"
        shift
    done
    konsole --caption "Kanotix-Update-GUI" -e $TEMP_FILE
    RETURNCODE=$?
    removeTempFile "$TEMP_FILE"
    return $RETURNCODE
}

# Macht das Kernel-Update
function kernelUpdate()
{
# Irgendetwas checken, steht so im Wiki, ich glaub das ist wichtig wenn man das Script auf einer "NichtKanotixInstallation" anwendet
MKIMAGE_CHECK=$(grep MKIMAGE /etc/mkinitrd/mkinitrd.conf) >/dev/null
if ! (echo $MKIMAGE_CHECK | grep "mkext2fs" >/dev/null); then
    # Abbrechen, da irgendetwas noch nicht richtig eingestellt ist
    dialogMsg "$KU_MKIMAGE_1

$MKIMAGE_CHECK

$KU_MKIMAGE_2"
    return 1 # Kernel-Update abbrechen
fi


# Erstmal fragen, ob die URLs manuell oder automatisch ermittelt werden sollen
dialogYesNo "$KU_DLG_AUTODL"
RET=$?
if [ $RET -eq 2 ]; then
    # Abbrechen gedrckt... also Schluss jetzt
    return 1
fi

if [ $RET -eq 1 ]; then
    # Nein gedrckt... also manuell weitermachen
    SELECTED_KERNEL_FILE=$(dialogInputBox "$KU_DLG_KERNELURL")
    [ $? -ne 0 ] && return 1
    SELECTED_DRIVER_FILE=$(dialogInputBox "$KU_DLG_DRIVERURL")
    DL_FILES_TO_DOWNLOAD="$SELECTED_KERNEL_FILE $SELECTED_DRIVER_FILE"
else

# Ja gedrckt, also los geht's...

# Erstmal die Seite runterladen, dann die Kommentare entfernen und nach (href)="driver..." und (href)="kernel..." suchen
LIST_KUPD_FILES=$(wget -q -O - "http://kanotix.com/files/kernel/" | sed -n -e '
/<!--/!bc
:a
/-->/!{
N
ba
}
:c
s:<!--.*-->::
s/^.*(kernel)?.*$/$1/g
s/^.*="\(\(kernel\|driver\)[^"]*\).*$/\1/p
s/<base href="\([^"]*\)">/\1/p
')


# Den aktuell installierten Kernel herausfinden (ob kanotix oder kanotix64)
AKTUELLER_KERNEL=$(uname -r)
AKTUELLER_KERNEL_TYP=$(uname -r | sed -n -e 's/^.*-\(.*\)-.*$/\1/p')

# Die kernel*-Dateien rausfiltern
LIST_KERNEL_FILES=$(echo -e "$LIST_KUPD_FILES" | egrep "^kernel")

# Die driver*-Dateien rausfiltern
LIST_DRIVER_FILES=$(echo -e "$LIST_KUPD_FILES" | egrep "^driver")

# Kernel-Auswahl-Dialog erstellen
KERNEL_AUSWAHL_DIALOG="dialogRadioList \"$KU_DLG_SELECT\""
for KERNEL in $LIST_KERNEL_FILES
do
    # Vorauswahl treffen (den Kernel, der den gleichen Typ hat wie der aktuell installierte Kernel)
    PRESEL="off"
    if ( echo "$KERNEL" | grep -e "-$AKTUELLER_KERNEL_TYP-" >/dev/null); then
        PRESEL="on"
    fi
    KERNEL_AUSWAHL_DIALOG="$KERNEL_AUSWAHL_DIALOG "$KERNEL" "$KERNEL" "$PRESEL"";
done
# Kernel-Auswahl-Dialog anzeigen
SELECTED_KERNEL_FILE=$(eval "$KERNEL_AUSWAHL_DIALOG")

if [ $? -ne 0 ]; then
    # Abbrechen gedrckt
    return 1
fi

# Driver-Auswahl-Dialog erstellen
DRIVER_AUSWAHL_DIALOG="dialogRadioList \"$KU_DLG_SELECT_DRIVER\""
for DRIVER in $LIST_DRIVER_FILES
do
    # Vorauswahl treffen (den Treiber, der den gleichen Typ hat wie der aktuell installierte Kernel)
    PRESEL="off"
    if ( echo "$DRIVER" | grep -e "-$AKTUELLER_KERNEL_TYP-" >/dev/null); then
        PRESEL="on"
    fi
    DRIVER_AUSWAHL_DIALOG="$DRIVER_AUSWAHL_DIALOG "$DRIVER" "$DRIVER" "$PRESEL"";
done
# Driver-Auswahl-Dialog anzeigen
SELECTED_DRIVER_FILE=$(eval "$DRIVER_AUSWAHL_DIALOG")

if [ $? -ne 0 ]; then
    # Abbrechen gedrckt, also keine zustzlichen Treiber
    SELECTED_DRIVER_FILE=""
fi

# Base-Directory fr den Download suchen
DL_BASEDIR=$(echo -e "$LIST_KUPD_FILES" | egrep "^http")

# Die runterzuladenden Dateien bestimmen
DL_FILES_TO_DOWNLOAD="$DL_BASEDIR$SELECTED_KERNEL_FILE"
[ $SELECTED_DRIVER_FILE ] && DL_FILES_TO_DOWNLOAD="$DL_FILES_TO_DOWNLOAD
$DL_BASEDIR$SELECTED_DRIVER_FILE"

fi # <-- noch von der Abfrage manuell oder automatisch

dialogYesNo "$KU_DLG_DLASK_1

$DL_FILES_TO_DOWNLOAD

$KU_DLG_DLASK_2
"

if [ $? -ne 0 ]; then
    # Abbrechen gedrckt, also keine zustzlichen Treiber
    return 1;
fi

# Download-Ordner bestimmen
KERNELNAME=$(basename "$SELECTED_KERNEL_FILE" ".zip")
DL_DIR="/usr/src/kernelupdate-$KERNELNAME"
mkdir -p "$DL_DIR"
cd "$DL_DIR"

# Jetzt die Dateien runterladen
for DL_FILE in $DL_FILES_TO_DOWNLOAD
do
    DL_PATH="$DL_DIR/$(basename $DL_FILE)"
    if [ ! -e "$DL_PATH" ]; then
        downloadFile "$DL_FILE" "$DL_PATH"
        unzip -o "$(basename $DL_FILE)" -d "$(basename $DL_FILE ".zip")"
    else
        unzip -o "$(basename $DL_FILE)" -d "$(basename $DL_FILE ".zip")"
    fi
done

dialogYesNo "$KU_DLG_CONTINUE" || return 1

cd "$KERNELNAME"
executeInConsole "./install-kernel-kanotix.sh"
cd ..

# Wenn zustzliche Treiber installiert werden mssen
if [ "$SELECTED_DRIVER_FILE" ]; then
    DRIVERNAME=$(basename "$SELECTED_DRIVER_FILE" ".zip")
    cd "$DRIVERNAME"
    executeInConsole "dpkg --force-all -i *deb"
fi

# Kano's Scripts updaten
update-scripts-kanotix.sh

dialogYesNo "$KU_TEXT__YOU_HAVE_TO_REBOOT"

[ $? -ne 0 ] && exit 0

# Automatisch fortfahren:
# touch /etc/init.d/bootmisc.kugui
# cp /etc/init.d/bootmisc.sh /etc/init.d/bootmisc.kugui
# echo "$0 kernelupdate #K-U-GUI#" >> /etc/init.d/bootmisc.sh
createInitScript "kernelUpdate"

dialogYesNo "$KU_TEXT__CHANGES_ARE_DONE_REBOOT_NOW"

[ $? -ne 0 ] && exit 0

reboot

exit 0
}

# Macht das dist-Upgrade
function distUpgrade()
{
dialogYesNo "$DU_TEXT__PREINFO"

[ $? -ne 0 ] && return 1

# Paketliste aktualisieren und neue Pakete runterladen
aptUpdate

if [ -z "$(apt-get -qq --print-uris dist-upgrade)" ]; then
    # Es sind keine Pakete upzudaten
    dialogMsg "$DU_DLG_NOTHINGTOUPDATE"
    return 0
fi

executeInConsole "apt-get dist-upgrade -d"
[ $? -ne 0 ] && dialogMsg "$ERR_DOWNLOAD" && return 1

dialogYesNo "$DU_TEXT__ASK_FOR_INIT3"

[ $? -ne 0 ] && exit 0

createInitScript "distUpgrade"
chvt 7 || chvt -t 7
init 3
/etc/init.d/kdm stop # Bugfix, wenn kdm bei init 3 nicht gestoppt wird (http://forum.kanotix.net/viewtopic.php?p=54322)
chvt 7 || chvt -t 7
}

function kanoUpdate()
{
    # Kano's Scripte updaten
    if [ ! -e /usr/local/bin/update-scripts-kanotix.sh ]  ; then
        dialogMsg "$DU_USK_NOT_INSTALLED"
    else
        executeInConsole "update-scripts-kanotix.sh"
    fi
}

function aptUpdate()
{
    # "apt-get update" ausfhren
    executeInConsole 'while [ "$NOCHMAL" != "n" ]' "do" "apt-get update && break" "echo -e \"\a\n$AU_ERROR\"" "read -n1 NOCHMAL" "done" "NOCHMAL="
}

function netUpdateMenu()
{
    # Netzwerk-Update Men anzeigen
    while true
    do
        TODO=$(dialogMenu "$MENU_NET_TITLE" \
"L" "$MENU_NET_ITEM_README" \
" " " " \
"S" "$MENU_NET_ITEM_SERVER" \
"C" "$MENU_NET_ITEM_CLIENT" \
" " " " \
"Z" "$MENU_NET_ITEM_BACK")
        [ $? -ne 0 ] && break; # Wenn Abbrechen gedrckt, dann beenden
        case "${TODO:0:1}" in
        "Z")
            break;
            ;;
        "L")
            netLiesmich
            ;;
        "S")
            netUpdateServer
            ;;
        "C")
            netUpdateClient
            ;;
        esac
    done
    return 0
}

function netLiesmich()
{
# Liesmich-Text fr Netzwerk-Update anzeigen
dialogMsg "$NU_TEXT__README"
}

function netUpdateServer()
{
    if ( exportfs -v | grep -i "/var/cache/apt" ) && [ -e "/var/cache/apt/archives/Packages" ]; then
        # Zur Zeit luft der Computer als Server
        dialogYesNo "$NU_TEXT__ALREADY_SERVER"
        if [ $? -eq 0 ]; then
            cat "/etc/exports" | sed -e '/#K-U-GUI#/d' > "/etc/exports"
            exportfs -ra
            rm "/var/cache/apt/archives/Packages"
            dialogMsg "$NU_DLG_SHAREDELETED"
            return 0
        else
            return 1
        fi
    fi

    dialogYesNo "$NU_EXPERIMENTAL_WARNING"
    [ $? -ne 0 ] && return 1
    
    cd "/var/cache/apt"
    rm "archives/Packages" # alte Packages-Datei lschen
    
    # Eine temporre Datei erzeugen, in die das Script gespeichert wird ...
    # ... welches spter von der Konsole ausgefhrt wird

    executeInConsole 'cd "/var/cache/apt"' 'dpkg-scanpackages archives /dev/null > archives/Packages'

    # NFS-Server starten
    /etc/init.d/nfs-kernel-server start
    
    # /var/cache/apt exportieren
    if ! ( exportfs -v | grep -i "/var/cache/apt" ); then
        echo "/var/cache/apt/ *(async,all_squash) #K-U-GUI#" >> "/etc/exports"
        exportfs -ra
    fi
    
    # IP-Adressen auflisten
    IP_ADRESSEN=$(ifconfig | grep "inet" | cut -d: -f2 | cut -d" " -f1 | sed -e '/127\.0\.0\.1/d;/^$/d')
    dialogMsg "$NU_SERVER_IP_1

$IP_ADRESSEN

$NU_SERVER_IP_2"
    #removeTempFile "$TEMP_FILE"
}

function netUpdateClient()
{
    # Beim Update als Client (Auswahl C) wird auf dem PC, auf dem das Script gestartet wurde,
    # nach der IP-Adresse des Servers gefragt. Danach wird das Verzeichnis /var/cache/apt per
    # NFS nach /mnt/apt gemountet. Dann wird die /etc/apt/sources.list gebackupt und in der
    # Originaldatei an den Anfang folgender Eintrag hinzugefgt:
    # 
    # deb file:/mnt/apt archives/
    # 
    # Dadurch wird beim anschlieenden Dist-Upgrade die bestehende NFS-Verbindung zum Server
    # genutzt. Whrend des Upgrades sollte der Server deshalb nicht ausgeschaltet oder vom
    # Netzwerk getrennt werden, da sonst versucht wird die fehlenden Dateien vom Internet
    # nachzuladen.
    
    if ( grep "#K-U-GUI#" "/etc/apt/sources.list" ); then
        dialogYesNo "$NU_TEXT__ALREADY_CLIENT"
        if [ $? -eq 0 ]; then
            cat "/etc/apt/sources.list" | sed -e '/#K-U-GUI#/d' > "/etc/apt/sources.list"
            ( mount | grep "/mnt/apt" ) && umount -f "/mnt/apt" # NFS-Share umounten wenn es noch gemountet ist
            [ -e "/mnt/apt" ] && rm -rf "/mnt/apt" # Wenn der Mountpoint noch existiert dann lschen
            dialogMsg "$NU_DLG_OPTIONDELETED"
            return 0
        else
            return 1
        fi
    fi

    dialogYesNo "$NU_EXPERIMENTAL_WARNING"
    [ $? -ne 0 ] && return 1

    HOST=$(dialogInputBox "$NU_ENTER_SERVER_IP")
    [ $? -ne 0 ] && return 1 # Abbrechen gedrckt

    # /var/cache/apt auf dem Server nach /mnt/apt mounten
    mkdir -p /mnt/apt
    # Bugfix: wenn der Portmap-Daemon nicht luft dauert das NFS-Mounten ewig, darum hier berprfen
    ( ps -A | grep portmap ) || /etc/init.d/portmap start
    # NFS mounten
    mount -t nfs $HOST:/var/cache/apt "/mnt/apt"
    if [ $? -ne 0 ]; then
        umount -f "/mnt/apt"
        rm -r "/mnt/apt"
        dialogMsg "$NU_MOUNT_ERROR"
        return 1
    fi
    
    # Die Quelle /mnt/apt/archives als Apt-Get Quelle hinzufgen
    TEMP_FILE_SOURCES=$(createTempFile)
    echo "deb file:/mnt/apt archives/ #K-U-GUI#" > "$TEMP_FILE_SOURCES"
    cat "/etc/apt/sources.list" >> "$TEMP_FILE_SOURCES"
    cat "$TEMP_FILE_SOURCES" > "/etc/apt/sources.list"
    rm "$TEMP_FILE_SOURCES"
    
    # Fertig gemountet, jetzt kann das Update durchgefhrt werden
    dialogYesNo "$NU_DONE_1 ($HOST) $NU_DONE_2"
    [ $? -eq 0 ] && distUpgrade
    return 0
}

# Fgt Apt-Sources der sources.list hinzu
function addAptSources()
{
    dialogYesNo "$AS_TEXT__PREINFO"
    [ $? -ne 0 ] && return 1
    
    SECTIONS_FILE="/tmp/sections.$RANDOM.list"; debug "sections.list: $SECTIONS_FILE"
    if [ "$NO_DOWNLOAD" ]; then
        cp "$PATH_SECTIONS_LIST" "$SECTIONS_FILE"
    else
        downloadFile "http://www.andreas-loibl.de/linux/sections.list" "$SECTIONS_FILE"
    fi
    
    LIST_OF_SECTIONS=$(cat "$SECTIONS_FILE" | sed -n -e 's/^<Section \(.*\)>$/\1/p')
    debug "$LIST_OF_SECTIONS"
    
    # Gibt den Inhalt der angegebenen Section aus
    function sectionInfo()
    {
        SECTION_ESCAPED="$1"
        SECTION_ESCAPED="${SECTION_ESCAPED//\//\\/}"
        COMMAND="cat \"$SECTIONS_FILE\" | sed -n -e '/<Section $SECTION_ESCAPED>/!bc"
        COMMAND="$COMMAND
:a
N
/<\/Section>/!ba
p
:c
d'
"
        eval "$COMMAND"
        debug "$COMMAND"
    }
    
    # Als Trennzeichen "Newline" verwenden
    IFS="
"
    for SECTION in $LIST_OF_SECTIONS
    do
        SOURCES_OF_SECTION=$(sectionInfo "$SECTION" | egrep ^\s*deb)
        for SOURCE in $SOURCES_OF_SECTION
        do
            SOURCE_EXPR=$(echo "$SOURCE" | sed -e 's/\(http:\/\/.*\)\/ /\1 /g; s/\(http:\/\/[^ ]*\)/\1[\/]?/g')
            if [ "$(egrep "^\s*$SOURCE_EXPR" /etc/apt/sources.list)" ]; then
                INSTALLED_SECTIONS="$INSTALLED_SECTIONS
$SECTION"
                break
            fi
        done
    done
    
    NOT_INSTALLED_SECTIONS="$( ( echo "$INSTALLED_SECTIONS"; echo "$LIST_OF_SECTIONS" ) | sort | uniq -u )"
    echo "$NOT_INSTALLED_SECTIONS"
    SECTION_AUSWAHL_DIALOG="dialogCheckList \"$AS_DLG_SECTIONS_AVAIL\""

    for SECTION in $NOT_INSTALLED_SECTIONS
    do
        SECTION_AUSWAHL_DIALOG="$SECTION_AUSWAHL_DIALOG \"$SECTION\" \"\" off"
    done
    SECTIONS_TO_ADD=$(eval "$SECTION_AUSWAHL_DIALOG 2>&1")

    [ $? -ne 0 ] && rm "$SECTIONS_FILE" && return 1 # Abbrechen gedrckt

    # "Output" erzeugen (das, was an die /etc/apt/sources.list angehngt wird)
    OUTPUT=""
    for SECTION in $SECTIONS_TO_ADD
    do
        OUTPUT="$OUTPUT
# $SECTION
"
        OUTPUT="${OUTPUT}$(sectionInfo "$SECTION" | sed -e '/^</d' )
"
    done

    dialogYesNo "$AS_DLG_ASK_CONTINUE"

    [ $? -ne 0 ] && rm "$SECTIONS_FILE" && return 1

    echo "$OUTPUT" >> /etc/apt/sources.list
    
    rm "$SECTIONS_FILE"
    
    dialogYesNo "$AS_DONE_DO_AU"

    [ $? -ne 0 ]  && return 1
    
    aptUpdate
}

function installSoftware()
{
    dialogYesNo "$IP_TEXT__PREINFO"
    [ $? -ne 0 ] && return 1;

    SOFTWARE_FILE="/tmp/software-list-$$"
    if [ "$NO_DOWNLOAD" ]; then
        cp "$PATH_SOFTWARE_LIST" "$SOFTWARE_FILE"
    else
        downloadFile "http://www.andreas-loibl.de/linux/software.list" "$SOFTWARE_FILE"
    fi

    LIST_OF_SOFTWARE=$(cat "$SOFTWARE_FILE" | sed -n -e 's/^<Software \(.*\)>$/\1/p')
    debug "$LIST_OF_SOFTWARE"
    
    # Gibt den Inhalt des angegebenen Software-Pakets aus
    function softwareInfo()
    {
        SOFTWARE_ESCAPED="$1"
        SOFTWARE_ESCAPED="${SOFTWARE_ESCAPED//\//\\/}"
        COMMAND="cat \"$SOFTWARE_FILE\" | sed -n -e '/<Software $SOFTWARE_ESCAPED>/!bc"
        COMMAND="$COMMAND
:a
N
/<\/Software>/!ba
p
:c
d'
"
        eval "$COMMAND"
    }
    
    # Als Trennzeichen "Newline" verwenden
    IFS="
"
    SOFTWARE_NOT_INSTALLED_TEMP=$(createTempFile)
    echo "$LIST_OF_SOFTWARE" > "$SOFTWARE_NOT_INSTALLED_TEMP"

    function softwareList()
    {
        SOFTWARE_NOT_INSTALLED="$(cat "$SOFTWARE_NOT_INSTALLED_TEMP")"
        MAX=$(echo "$LIST_OF_SOFTWARE" | wc -l)
        I=0
        for SOFTWARE in $LIST_OF_SOFTWARE
        do
            PACKAGES_OF_SOFTWARE=$(softwareInfo "$SOFTWARE" | sed -n -e 's/^[ ]*\([^<]*\)$/\1/p')

            for PACKAGE in $PACKAGES_OF_SOFTWARE
            do
                # berprfen, ob das Paket schon installiert ist
                if [ "$(dpkg --get-selections $PACKAGE 2>/dev/null)" ]; then
                    SOFTWARE_NOT_INSTALLED="$(echo "$SOFTWARE_NOT_INSTALLED" | sed -e "/^$SOFTWARE\$/d")"
                    debug "$PACKAGE: installiert, also ist \"$SOFTWARE\" bereits installiert"
                    break
                fi
                # Wenn nicht, dann auf die Liste der zu installierenden Pakete setzen
                debug "$PACKAGE: nicht installiert"
            done
            I=$[I+1]
            echo $(expr $I \* 100 / $MAX)
        done
        echo "$SOFTWARE_NOT_INSTALLED" > "$SOFTWARE_NOT_INSTALLED_TEMP"
        echo 101
    }
    
    softwareList | Xdialog --gauge "$STATUS_GENERATING_PACKAGE_LIST" 0 0 0

    SOFTWARE_NOT_INSTALLED="$(cat "$SOFTWARE_NOT_INSTALLED_TEMP")"
    removeTempFile "$SOFTWARE_NOT_INSTALLED_TEMP"

    debug "SOFTWARE_NOT_INSTALLED: $SOFTWARE_NOT_INSTALLED"
    
    if [ -z "$SOFTWARE_NOT_INSTALLED" ]; then
        #Alles ist bereits installiert
        dialogMsg "$IP_EVERYTHING_ALREADY_INSTALLED"
        return 1
    fi
    
    SOFTWARE_TO_INSTALL="dialogCheckList \"$IP_DLG_SOFTWARE_AVAIL\""
    
    for SOFTWARE in $SOFTWARE_NOT_INSTALLED
    do
        SOFTWARE_INFO=$(softwareInfo "$SOFTWARE")
        SOFTWARE_DESCRIPTION=$(echo "$SOFTWARE_INFO" | sed -n -e 's/^.*<Description>\(.*\)<\/Description>.*$/\1/p')
        SOFTWARE_TO_INSTALL="$SOFTWARE_TO_INSTALL \"$SOFTWARE\" \"$SOFTWARE_DESCRIPTION\" on"
    done

    SOFTWARE_TO_INSTALL=$(eval "$SOFTWARE_TO_INSTALL")
    [ $? -ne 0 ] && return 1
    
    for SOFTWARE in $SOFTWARE_TO_INSTALL
    do
        SOFTWARE_INFO=$(softwareInfo "$SOFTWARE")
        PACKAGES_LIST="$PACKAGES_LIST $( echo $( echo "$SOFTWARE_INFO" | sed -n -e 's/^[ ]*\([^<]*\)$/\1/p' ))"
        if ( echo "$SOFTWARE_INFO" | grep "<Section" ); then
            # Diese Software braucht einen speziellen Eintrag in die sources.list
            SECTION=$(echo "$SOFTWARE_INFO" | sed -n -e 's/^[ ]*<Section \(.*\)>$/\1/p')
            debug "$SECTION"
            APT_SECTIONS_NEEDED="$APT_SECTIONS_NEEDED
$SECTION"
        fi
    done
    
    # Fr die ausgewhlten Softwarepakete werden noch zustzliche Apt-Quellen gebraucht
    if [ "$APT_SECTIONS_NEEDED" ]; then
        for SECTION in $APT_SECTIONS_NEEDED
        do
            # (ich hab ein paar Probleme mit dem Escapen von dem Grep-Befehl....)
            GREP_CMD="${SECTION}"
            GREP_CMD="${GREP_CMD//(/\\(}"
            GREP_CMD="${GREP_CMD//)/\\)}"
            GREP_CMD="${GREP_CMD//+/\\+}"

            GREP_CMD="^[ ]*#[ ]*${GREP_CMD}[ ]*\$"
            GREP_CMD="egrep -i '$GREP_CMD' /etc/apt/sources.list"

            if ! ( eval "$GREP_CMD" ); then
                debug "$SECTION: muss noch installiert werden"
                APT_SECTIONS_TO_ADD="$APT_SECTIONS_TO_ADD
$SECTION"
            fi
        done
    fi
    
    rm "$SOFTWARE_FILE"
    
    # Wenn es Software gibt, die Apt-Quellen braucht, die NICHT in der sources.list stehen
    if [ "$APT_SECTIONS_TO_ADD" ]; then
        dialogYesNo "$IP_SOURCES_1

$APT_SECTIONS_TO_ADD

$IP_SOURCES_2"
        [ $? -ne 1 ] && return 1
    fi
    
    aptUpdate
    freeze-rc.d
    executeInConsole "apt-get install $PACKAGES_LIST"
    unfreeze-rc.d
}

# Kanotix-Update-GUI updaten
function kuguiUpdate()
{
    executeInConsole "apt-get update" "apt-get install kanotix-update-gui" "read -t2"
    kanotix-update-gui
    exit 0
}

# Parameter auswerten
while [ "$1" ]
do
    case "$1" in
    "nodownload"|"--nodownload")
        NO_DOWNLOAD=1
        PATH_SECTIONS_LIST=$(dialogInputBox "$LOCALE__PATH_TO sections.list:")
        PATH_SOFTWARE_LIST=$(dialogInputBox "$LOCALE__PATH_TO software.list:")
        PATH_PACKAGE_LIST=$( dialogInputBox "$LOCALE__PATH_TO kanotix-packages.html")
        [ -z "$PATH_SECTIONS_LIST$PATH_SOFTWARE_LIST$PATH_PACKAGE_LIST" ] && NO_DOWNLOAD=""
        ;;
    esac
    shift
done

# Hauptmen
while true
do
    TODO=$(dialogMenu "Kanotix-Update-GUI
by A.Loibl

$MENU_MAIN_TITLE" \
"I" "$MENU_MAIN_ITEM_INFO" \
" " " " \
"1" "$MENU_MAIN_ITEM_KERNELUPDATE" \
"2" "$MENU_MAIN_ITEM_DISTUPGRADE" \
"3" "$MENU_MAIN_ITEM_NETUPDATE" \
"4" "$MENU_MAIN_ITEM_KANOSCRIPTUPDATE" \
" " " " \
"5" "$MENU_MAIN_ITEM_APTUPDATE" \
"6" "$MENU_MAIN_ITEM_APTADDSOURCES" \
"7" "$MENU_MAIN_ITEM_INSTALLPACKAGES" \
"8" "$MENU_MAIN_ITEM_KUGUIUPDATE" \
" " " " \
"H" "$MENU_MAIN_ITEM_HELP" \
"E" "$MENU_MAIN_ITEM_END")

    if [ $? -ne 0 ]; then
        break; # Wenn Abbrechen gedrckt, dann beenden
    fi

    debug "Men Auswahl: $TODO"

    case "${TODO:0:1}" in
    "E")
        break # Ende ausgewhlt
        ;;
    "I")
        infoDialog
        ;;
    "H")
        helpDialog
        ;;
    "1")
        kernelUpdate
        ;;
    "2")
        distUpgrade
        ;;
    "3")
        netUpdateMenu
        ;;
    "4")
        kanoUpdate
        ;;
    "5")
        aptUpdate
        ;;
    "6")
        addAptSources
        ;;
    "7")
        installSoftware
        ;;
    "8")
        kuguiUpdate
        ;;
    esac
done

exit 0
