#!/bin/sh

#{{{ Copyright
# Studioware package building script
# Copyright 2011 David Woodfall <dave@dawoodfall.net>
# All rights reserved.
#
# Redistribution and use of this script, with or without modification, is
# permitted provided that the following conditions are met:
#
# 1. Redistributions of this script must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR IMPLIED
# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#}}}
#{{{ Init
init()
{
    APPNAME="sepkg"
    MYVERSION="4.4.6"
    CWD=$(pwd)
    CONFDIR=/etc/$APPNAME
    mkdir -p $CONFDIR
    MAINURL="http://www.studioware.org"
    CONF=$CONFDIR/$APPNAME.conf
    touch $CONF
    source $CONF
    TMP=${TMP:-/tmp/se}
    OUTPUT=${OUTPUT:-/tmp}
    TMPROOT=$(mktemp -d -p $OUTPUT $APPNAME-XXXXXX) || exit
    trap "cleanupbad" HUP INT ABRT QUIT SEGV TERM KILL PIPE STOP TSTP
    QUEUE=$TMPROOT/queue
    TMPQ=$TMPROOT/tmp-queue
    PKGLIST=$TMPROOT/pkglist
    LOGFILE=/tmp/$APPNAME.log
    SUMMARY=$TMPROOT/$APPNAME.summary
    SUMDIV="============================="
    WGET="wget --progress=dot:mega --no-check-certificate"
    UP="upgradepkg --reinstall --install-new"
    TOOLURL="$MAINURL/files/tools/$APPNAME"
    SBSERVER="$MAINURL/files/slackbuilds/$SWVERSION"
    CACHEDIR=/var/cache/$APPNAME/$SWVERSION
    mkdir -p $CACHEDIR
    FILELIST=$CACHEDIR/SLACKBUILDS.TXT
    VERSIONLIST=$CACHEDIR/VERSIONINFO.TXT
    ERR="0"
    STUDIOKEY="Studioware <info@studioware.org>"
    GPG="gpg --verify"
    if [ -z "$CHECKGPG" ]; then
        echo "CHECKGPG not set in $CONF..."
        echo "Setting to ON. You can change this later by editing $CONF"
        echo "CHECKGPG=ON" >> $CONF
        CHECKGPG="ON"
        echo -n "Press enter to continue"
        read <&1
    fi
    YESNO=0
    NOGUI=0
    PKGSERVER="http://studioware.org"
}
#}}}
#{{{ Cleanup and exit
cleanup()
{
    if [ -r $SUMMARY ]; then
        cat $SUMMARY
    fi
    rm -rf $TMPROOT
    [[ -n "$LOGPID" ]] && kill $LOGPID
    exit 0
}
#}}}
#{{{ Cleanup and exit 1
cleanupbad()
{
    if [ -r $SUMMARY ]; then
        cat $SUMMARY
    fi

    rm -rf $TMPROOT
    [[ -n "$LOGPID" ]] && kill $LOGPID
    exit 1
}
#}}}
#{{{ Test if string $1 contains $2
contains()
{
    for opt in $1
    do
        [[ "$opt" = "$2" ]] && return 0
    done

    return 1
}
#}}}
#{{{ Flags
getflags()
{
    FLAGS="$*"

    contains "$FLAGS" -y && { YESNO=1; NOGUI=1; FLAGS=${FLAGS/-y}; }
    contains "$FLAGS" -n && { NOGUI=1; FLAGS=${FLAGS/-n}; }
    contains "$FLAGS" --yes && { YESNO=1; NOGUI=1; FLAGS=${FLAGS/--yes}; }
    contains "$FLAGS" --no-gui && { NOGUI=1; FLAGS=${FLAGS/--no-gui}; }
    contains "$FLAGS" --log && { LOG="tee -a $LOGFILE"; FLAGS=${FLAGS/--log}; }

    if [ -n "$LOG" ]; then
        echo -n > $LOGFILE
        tail -f $LOGFILE &
        LOGPID=$!
    fi


    CMD=$(echo $FLAGS | cut -d' ' -f1)
    ARG=$(echo $FLAGS | cut -d' ' -f2-)

    [[ "$ARG" = "$CMD" ]] && unset ARG

    contains "$CMD" --info          && { info $ARG; cleanup; }
    contains "$CMD" --update        && { update; cleanup; }
    contains "$CMD" --search        && { search $ARG; cleanup; }
    contains "$CMD" --build         && { INSTALL=0; set_queue "$ARG"; cleanup; }
    contains "$CMD" --install       && { INSTALL=1; set_queue "$ARG"; cleanup; }
    #contains "$CMD" --upgrade-all   && { INSTALL=1; upgrade_all; cleanup; }
    contains "$CMD" --new           && { INSTALL=1; new; cleanup; }
    contains "$CMD" --delete-cache  && { deletecache; cleanup; }
    contains "$CMD" --latest        && { latest; cleanup; }
    contains "$CMD" --read          && { readme $ARG; cleanup; }
    contains "$CMD" --queue         && { INSTALL=1; get_queue $ARG; cleanup; }
    contains "$CMD" --gpg           && { importgpg; cleanup; }
    contains "$CMD" --help && { usage; cleanup; }
    contains "$CMD" --version && { echo $APPNAME $MYVERSION; cleanup; }
    contains "$CMD" -f && { info $ARG; cleanup; }
    contains "$CMD" -u && { update; cleanup; }
    contains "$CMD" -s && { search $ARG; cleanup; }
    contains "$CMD" -b && { INSTALL=0; set_queue "$ARG"; cleanup; }
    contains "$CMD" -i && { INSTALL=1; set_queue "$ARG"; cleanup; }
    contains "$CMD" -l && { latest; cleanup; }
    contains "$CMD" -r && { readme $ARG; cleanup; }
    contains "$CMD" -q && { INSTALL=1; get_queue $ARG; cleanup; }
    contains "$CMD" -h && { usage; cleanup; }
    contains "$CMD" -v && { echo $APPNAME $MYVERSION; cleanup; }
    contains "$CMD" -g && { importgpg; cleanup; }

    usage
    echo
    echo "Unknown command: $CMD"
    cleanup
}
#}}}
#{{{ New
new()
{
    cd $CACHEDIR || { echo "No cache exists. Did you run --update?"; cleanup; }

    if [ ! -r $FILELIST ]; then { echo "No filelist. Did you run --update?"; \
        cleanup; } fi

    cd $TMPROOT || cleanup
    echo -n > $QUEUE
    echo "Looking for new packages..."

    while read LINE
    do
        PRGNAM=$(echo $LINE | awk '{print $1}')
        VERSION=$(echo $LINE | awk '{print $2}')
        BUILD=$(echo $LINE | awk '{print $3}')

        if [ ! $(ls /var/log/packages/$PRGNAM-* 2>/dev/null \
            | grep /$PRGNAM-[^-]*-[^-]*-[^-]*se$) ]; then
            echo $PRGNAM >> $QUEUE
        fi
    done < $VERSIONLIST

    if [ -z "$(cat $QUEUE)" ]; then
        echo "No new packages."
        cleanup
    fi

    listpkgs
    cleanup
}
#}}}
#{{{ Upgrade All
upgrade_all()
{
    cd $CACHEDIR || { echo "No cache exists. Did you run --update?"; cleanup; }

    if [ ! -r $FILELIST ]; then { echo "No filelist. Did you run --update?"; \
        cleanup; } fi

    cd $TMPROOT || cleanup
    echo -n > $QUEUE
    echo "Looking for packages to upgrade..."

    ls /var/log/packages/*se | cut -d/ -f5 | while read PKG
    do
        PRGNAM=$(echo $PKG | rev | cut -d- -f4- | rev)
        VERSION=$(echo $PKG | rev | cut -d- -f3 | rev)
        BUILD=$(echo $PKG | rev | cut -d- -f1 | rev | sed 's/se//')
        SERVER_VERSION=$(grep -i ^$PRGNAM[[:space:]] $VERSIONLIST | \
            awk '{print $2}')
        SERVER_BUILD=$(grep -i ^$PRGNAM[[:space:]] $VERSIONLIST | \
            awk '{print $3}')

        if [ "$VERSION$BUILD" != "$SERVER_VERSION$SERVER_BUILD" ]; then
            echo $PRGNAM >> $QUEUE
        fi
    done

    if [ -z "$(cat $QUEUE)" ]; then
        echo "No packages to upgrade."
        cleanup
    fi

    listpkgstoupgrade
    cleanup
}
#}}}
#{{{ Info
info()
{
    APP=$1

    if [ -z "$APP" ]; then
        echo "No application name specified!"
        cleanup
    fi

    if [ ! -r $FILELIST ]; then
        echo "No filelist found. Do you need to run sepkg -u?"
        cleanup
    fi

    CAT=$(grep -wi $APP $FILELIST | cut -d/ -f2)
    info="$(curl -s $SBSERVER/$CAT/$APP/$APP.info)"
    echo "$info"
}
#}}}
#{{{ Readme
readme()
{
    if [ -z "$1" ]; then
        echo "No application name specified!"
        cleanup
    fi

    file=$(grep -i $1.tar.gz $FILELIST | awk '{print $2}' | cut -d'/' -f1-3)/README
    shortname=$(echo $file | cut -d'/' -f5 | rev | cut -d- -f4- | rev)
    url=$SBSERVER/$file
    lynx -dump $url
    cleanup
}
#}}}
#{{{ Latest
latest()
{
    cd $TMPROOT

    wget -q $TOOLURL/LATEST || cleanup
    LATEST=$(cat LATEST)
    REMVERS=$(echo $LATEST | cut -db -f1)
    REMBUILD=$(echo $LATEST | cut -db -f2)

    echo "Installed version: $MYVERSION. Latest version: $LATEST."

    if [ "$MYVERSION" != "$LATEST" ]; then
        echo -n "Newer version available. Download it? (Y/n) "
        read REPLY

        case "$REPLY" in
            'y'|'Y'|'')
                PKG=$APPNAME-$REMVERS-noarch-1daw.txz
                ASC=$APPNAME-$REMVERS-noarch-1daw.txz.asc
                MD5=$APPNAME-$REMVERS-noarch-1daw.md5
                $WGET -q -O $PKG $TOOLURL/$PKG || cleanup
                $WGET -q -O $MD5 $TOOLURL/$MD5 || cleanup
                $WGET -q -O $ASC $TOOLURL/$ASC || cleanup

                echo "Package saved to $TMPROOT"
                echo "Checking md5... "

                md5sum -c $MD5

                if [ $? != 0 ]; then
                    cleanup
                fi

                if [ "$CHECKGPG" = "ON" ]; then
                    echo "Checking gpg..."
                    # try to surpress the authority warning...
                    GPGOUT=$($GPG $ASC $PKG 2>&1 | head -n2)

                    if [ -n "$(echo $GPGOUT | grep -i 'not found')" ]; then
                        echo "$GPGOUT"
                        echo "Did you import the Studioware key with 'sepkg -g|gpg'?"
                        cleanup
                    elif [ -n "$(echo $GPGOUT | grep -i 'bad signature')" ]; then
                            echo "$GPGOUT"
                            cleanup
                    else
                        echo "$GPGOUT"
                    fi
                fi


                echo
                echo -n "Upgrade now? (Y/n) "
                read UREPLY

                case "$UREPLY" in
                    'y'|'Y'|'')
                        $UP $PKG
                        ;;
                    *)
                        cleanup
                        ;;
                esac
                ;;
            *)
                cleanup
                ;;
        esac
    fi
}
# }}}
#{{{ Usage
usage()
{
cat << EOF
$APPNAME <command> [options]

$APPNAME --info, -f package1                    read info file
$APPNAME --build, -b package1, package2 ...     build packages
$APPNAME --delete-cache                         delete all cached files
$APPNAME --install, -i package1, package2 ...   build & install packages
$APPNAME --install, -i < <queuefile>            install packages from file
$APPNAME --new                                  checks for new packages
$APPNAME --latest, -l                           checks for newer version of $APPNAME
$APPNAME --read, -r <package>                   download and print readme (needs lynx)
$APPNAME --search, -s <name>                    search for package name or part name
$APPNAME --update, -u                           download filelists
$APPNAME --queue, -q                            download and install queue from file server
$APPNAME --help, -h                             help
$APPNAME --version, -v                          give version and exit

Extra options:

$APPNAME --log      create a sepkg.log build log in current directory
$APPNAME --no-gui   bypass dialog screen
$APPNAME --yes      auto-answer any questions (implies --no-gui)

Files:

/etc/$APPNAME/$APPNAME.conf

This file contains the slackware version SWVERSION.

EOF
}
#}}}
#{{{ Update
update()
{
    cd $CACHEDIR || cleanup
    $WGET -O SLACKBUILDS.TXT $SBSERVER/SLACKBUILDS.TXT
    $WGET -O VERSIONINFO.TXT $SBSERVER/VERSIONINFO.TXT
    cleanup
}
#}}}
#{{{ Get Queue
get_queue()
{
    cd $CACHEDIR || { echo "No cache exists. Did you run --update?"; cleanup; }

    if [ ! -r $FILELIST ]; then { echo "No filelist. Did you run --update?"; \
        cleanup; } fi

    cd $TMPROOT || cleanup

    case "$1" in
        'audio'|'video'|'photo'|'full')
            curl -fs $SBSERVER/queues/$1.sqf > $QUEUE
            ;;

        *)
            CAT=$(grep -i /$1.tar.gz$ $FILELIST | cut -d/ -f2-4)
            APP=$(grep -i /$1.tar.gz$ $FILELIST | cut -d/ -f4)
            curl -fs $SBSERVER/$CAT/$APP.sqf > $QUEUE

            if [ $? != 0 ]; then
                if [ ! -r $CWD/$1 ] && [ ! -r $1 ]; then
                    echo "Queue for $1 not found."
                    echo $1 > $QUEUE
                else
                    if [ -r "$CWD/$1" ]; then
                        cat $CWD/$1 > $QUEUE
                    else
                        cat $1 > $QUEUE
                    fi

                fi
            fi
            ;;
    esac

    listpkgs
}
#}}}
#{{{ Set Queue
set_queue()
{
    cd $CACHEDIR || { echo "No cache exists. Did you run --update?"; cleanup; }
    if [ ! -r $FILELIST ]; then { echo "No filelist. Did you run --update?"; \
        cleanup; } fi

    cd $TMPROOT || cleanup

    cl=$*

    if [ -z "$cl" ]; then
        cat /dev/stdin | sed 's/,/\n/g;/^$/d' > $QUEUE
    else
        echo $cl | sed 's/,/\n/g;/^$/d' > $QUEUE
    fi

    listpkgs
}
#}}}
#{{{ Make queue
make_queue()
{
    cd $TMPROOT
    let CNT=1

    while read line
    do
        TOP=$(head -n $((CNT-1)) $TMPQ)

        if [ -n "$TOP" ]; then
            echo "$TOP" > $TMPQ
        fi

        case "$line" in
            'audio'|'video'|'photo'|'full')
                $WGET -O $line.sqf $SBSERVER/queues/$line.sqf
                SWAP=$(cat $line.sqf)
                echo "$SWAP" >> $TMPQ
                let CNT=$(wc -l $TMPQ | awk '{print $1}')+1
                unset SWAP
                ;;

            *)
                # subqueue
                if [ -z "$(echo $line | cut -d@ -f1)" ] && [ -n "$line" ]; then
                    SUB=$(echo $line | cut -d@ -f2)

                    if [ -n "$SUB" ]; then
                        if [ ! -r $CWD/$SUB.sqf ] && [ ! -r $SUB.sqf ]; then
                            CAT=$(grep -i /$SUB.tar.gz$ $FILELIST | cut \
                            -d/ -f2-4)

                            if [ -n "$CAT" ]; then
                                $WGET -O $SUB.sqf $SBSERVER/$CAT/$SUB.sqf
                            else
                                $WGET -O $SUB.sqf $SBSERVER/queues/$SUB.sqf
                                if [ $? != 0 ]; then
                                    echo "$SUB.sqf not found."
                                    cleanup
                                fi
                            fi
                            if [ $? != 0 ]; then
                                echo "$SUB.sqf not found."
                                echo "Will try application directly."
                                line=${line/@/}
                                echo $line >> $TMPQ
                            fi
                        else
                            if [ -r $CWD/$SUB.sqf ]; then
                                cat $CWD/$SUB.sqf > $SUB.sqf
                            fi
                        fi

                        if [ -r $SUB.sqf ]; then
                            SWAP=$(cat $SUB.sqf)
                            echo "$SWAP" >> $TMPQ
                            let CNT=$(wc -l $TMPQ | awk '{print $1}')+1
                            unset SWAP
                        fi
                    fi
                else
                    echo $line >> $TMPQ
                    let CNT=$((CNT+1))
                fi
                ;;
        esac
    done < $1
}
#}}}
#{{{ Dialog
do_dialog()
{
    [[ -z "$LIST" ]] && cleanup
    let rows=$(stty size | cut -f1 -d' ')-4
    let cols=$(stty size | cut -f2 -d' ')
    let mrows=$((rows-6))

    if [ $NOGUI -eq 0 ] && [ -n "$(echo $TITLE | grep remove)" ]; then
        dialog --separate-output --title install --backtitle "$APPNAME $MYVERSION" \
            --checklist "$TITLE" \
            $rows $cols $mrows $LIST 2> $PKGLIST
        CHOICE=$?
    elif [ $NOGUI -eq 0 ] && [ -n "$(echo $TITLE | grep upgrade)" ]; then
        dialog --separate-output --title Install --backtitle "$APPNAME $MYVERSION" \
            --checklist "$TITLE" \
            $rows $cols $mrows $LIST 2>$PKGLIST
        CHOICE=$?
    elif [ $NOGUI -eq 0 ]; then
        dialog --separate-output --title Install --backtitle "$APPNAME $MYVERSION" \
            --help-button --help-label "Clear Inst'd" --help-status \
            --checklist "$TITLE" \
            $rows $cols $mrows $LIST 2>$PKGLIST
        CHOICE=$?
    else
        for P in $PKGS
        do
            echo $P | tr -d ' ' >> $PKGLIST
            echo $P
        done

        if [ $YESNO -eq 0 ]; then
            echo "Install? (Y/n)"
            read

            REPLY=$(echo $REPLY | tr 'a-z' 'A-Z')
            [[ "$REPLY" = "" ]] && REPLY="Y"
            [[ "$REPLY" = "Y" ]] && CHOICE=0 || cleanup
        else
            CHOICE=0
        fi
    fi
}
#}}}
#{{{ List Packages To Upgrade
listpkgstoupgrade()
{
    exec <&1
    unset pkgs
    unset LIST
    unset MISSING
    unset PKGS
    echo -n > $PKGLIST

    echo "Building queue..."

    while true
    do
        if [ -n "$(grep @ $QUEUE)" ]; then
            echo -n > $TMPQ
            make_queue $QUEUE
            cat $TMPQ > $QUEUE
        else
            break
        fi
    done

    echo -n > $TMPQ

    while read line
    do
        if [ ! $(grep -xi $line $TMPQ) ]; then
            echo $line >> $TMPQ
        fi
    done < $QUEUE

    cat $TMPQ > $QUEUE

    while read line
    do
        name=$(echo $line | awk '{print $1}')
        pkg=$(grep -i /$name.tar.gz $FILELIST | cut -d'/' -f5)

        if [ -n "$pkg" ]; then
            PKGS=$PKGS" "$pkg
        else
            MISSING=$name" "$MISSING
        fi
    done < $QUEUE

    if [ -n "$MISSING" ]; then
        echo "The following applications could not be found:"
        echo "$MISSING"
        cleanup
    fi

    for i in $PKGS
    do
        shortname=$(echo $i | cut -d'.' -f1)
        if [ -n "$i" ]; then
            LIST=$LIST" "$i" "$shortname" ""on "
        fi
    done

    if [ -z "$LIST" ]; then cleanup; fi

    TITLE="Choose packages to upgrade:"
    do_dialog

    if [ $CHOICE -eq 2 ] && $(sed -i 's%^HELP %%g' $PKGLIST); then
        clear_installed
        listpkgs
    fi

    if [ $CHOICE -ne 0 ]; then cleanup; fi
    if [ -z "$(cat $PKGLIST)" ]; then cleanup; fi

    installpkgs
}
#}}}
#{{{ List Packages
listpkgs()
{
    exec <&1
    unset pkgs
    unset LIST
    unset MISSING
    unset PKGS
    echo -n > $PKGLIST

    echo "Building queue..."

    while true
    do
        if [ -n "$(grep @ $QUEUE)" ]; then
            echo -n > $TMPQ
            make_queue $QUEUE
            cat $TMPQ > $QUEUE
        else
            break
        fi
    done

    echo -n > $TMPQ

    while read line
    do
        if [ ! $(grep -xi $line $TMPQ) ]; then
            echo $line >> $TMPQ
        fi
    done < $QUEUE

    cat $TMPQ > $QUEUE

    while read line
    do
        name=$(echo $line | awk '{print $1}')
        pkg=$(grep -i /$name.tar.gz $FILELIST | cut -d'/' -f5)

        if [ -n "$pkg" ]; then
            PKGS=$PKGS" "$pkg
        else
            MISSING=$name" "$MISSING
        fi
    done < $QUEUE

    if [ -n "$MISSING" ]; then
        echo "The following applications could not be found:"
        echo "$MISSING"
        cleanup
    fi

    for i in $PKGS
    do
        shortname=$(echo $i | cut -d'.' -f1)
        if [ -n "$i" ]; then
            LIST=$LIST" "$i" "$shortname" ""on "
        fi
    done

    if [ -z "$LIST" ]; then cleanup; fi

    TITLE="Choose packages to install:"
    do_dialog

    if [ $CHOICE -eq 2 ] && $(sed -i 's%^HELP %%g' $PKGLIST); then
        clear_installed
        listpkgs
    fi

    if [ $CHOICE -ne 0 ]; then cleanup; fi
    if [ -z "$(cat $PKGLIST)" ]; then cleanup; fi

    installpkgs
}
#}}}
#{{{ Clear Installed
clear_installed()
{
    while read newpkg
    do
        for o in $(ls /var/log/packages/$newpkg* 2>/dev/null)
        do
            oldpkg=$(echo $o | cut -d/ -f5 | rev | cut -d- -f4- | rev)

            if [ -n "$(echo $oldpkg | grep upgraded)" ]; then
                oldpkg="NULL"
            fi

            if [ "$newpkg" = "$oldpkg" ]; then
                sed -i "/$newpkg$/d" $QUEUE
            fi
        done

        if [ -z "$(ls /var/log/packages/$newpkg* 2>/dev/null)" ]; then
            echo $newpkg >> $QUEUE
        fi

    done < $QUEUE

    if [ $(wc -l $QUEUE | awk '{print $1}') = "0" ]; then
        echo "All packages are already installed."
        cleanup
    fi
}
#}}}
#{{{ Install Packages
installpkgs()
{
    cd $TMPROOT || cleanup
    unset pkgs
    echo $SUMDIV > $SUMMARY
    echo "Starting package list" >> $SUMMARY
    if [ -n "$LOG" ]; then
        echo "Logging to $LOGFILE" >> $SUMMARY
    fi
    echo $SUMDIV >> $SUMMARY

    for i in $(cat $PKGLIST)
    do
        pkgs=$pkgs" "$(grep -wie "\/.*\/$i" $FILELIST | awk '{print $2}')
    done

    for i in $pkgs
    do
        if [ -n "$i" ]; then
            b=$(basename $i .tar.gz)
            echo "Starting $b" >> $SUMMARY
            $WGET -c -O $b.tar.gz $SBSERVER/$i
            tar xf $b.tar.gz
            (
            cd $b
            source ./$b.info
            let loop=0
            MD5SUM=($MD5SUM)

            for D in $DOWNLOAD
            do
                LOCAL=$(basename $D)
                MD5=${MD5SUM[loop]}
                unset MD5MATCH

                while [ -z "$MD5MATCH" ]
                do
                    if [ ! -r $CACHEDIR/$LOCAL ]; then
                        $WGET -c -O $CACHEDIR/$LOCAL $D
                    fi

                    ln -sf $CACHEDIR/$LOCAL $LOCAL

                    if [ "$(md5sum $LOCAL | awk '{print $1}')" != "$MD5" ]; then
                        echo "Checksums don't match."
                        echo -n "(A)bort (C)ontinue (R)edownload "
                        echo "Bad MD5" >> $SUMMARY
                        read ANS
                        if [[ "$ANS" = [rR] ]]; then
                            rm -r $CACHEDIR/$LOCAL
                        elif [[ "$ANS" = [cC] ]]; then
                            break
                        else exit 1
                        fi
                    else
                        MD5MATCH=1
                        echo "Good MD5" >> $SUMMARY
                    fi
                done
                let loop=$loop+1
            done

            options=$(grep -x $b $QUEUE | cut -f2- | sed "s/$b//")
            echo -n "Starting $b SlackBuild " | $LOG
            [[ -n "$options" ]] && echo "with options:" | $LOG
            [[ -n "$options" ]] && echo -n "$options" | $LOG

            echo | $LOG
            echo | $LOG

            if [ -n "$LOG" ]; then
                exec 6<&1
                exec 1>>$LOGFILE 2>&1
                eval $options source ./$b.SlackBuild

                if [ $? -eq 0 ]; then
                    echo "Successful build" >> $SUMMARY
                else
                    echo "Problem with build" >> $SUMMARY
                fi

                if [ "$INSTALL" = "1" ]; then
                    $UP $OUTPUT/$PRGNAM-$VERSION-$ARCH-$BUILD$TAG.${PKGTYPE:-tgz}
                    if [ $? -eq 0 ]; then
                        echo "Successful install" >> $SUMMARY
                    else
                        echo "Problem with install" >> $SUMMARY
                    fi

                fi

                unset VERSION BUILD
                exec 1<&6 6<&-
            else
                eval $options source ./$b.SlackBuild

                if [ $? -eq 0 ]; then
                    echo "Successful build" >> $SUMMARY
                else
                    echo "Problem with build" >> $SUMMARY
                fi

                if [ "$INSTALL" = "1" ]; then
                    $UP $OUTPUT/$PRGNAM-$VERSION-$ARCH-$BUILD$TAG.${PKGTYPE:-tgz}

                    if [ $? -eq 0 ]; then
                        echo "Successful install" >> $SUMMARY
                    else
                        echo "Problem with install" >> $SUMMARY
                    fi
                fi
                unset VERSION BUILD
            fi
            )
            ERR=$?

            if [ "$ERR" != "0" ]; then
                echo "Error" >> $SUMMARY
                break
            fi

            echo $SUMDIV >> $SUMMARY
        fi
    done

    if [ "$ERR" != "0" ]; then
        cleanupbad
    fi

    echo "End of package list" >> $SUMMARY
    echo $SUMDIV >> $SUMMARY

    cleanup
}
#}}}
#{{{ Search
search()
{
    cd $CACHEDIR || { echo "No cache exists! Did you run update?"; cleanup; }
    if [ ! -r $FILELIST ]; then { echo "No filelist! Did you run update?"; \
        cleanup; } fi

    inrepo=$(grep -i $1 $FILELIST | awk '{print $2}')

    if [ -n "$inrepo" ]; then
        for g in $inrepo
        do
            shortname=$(echo $g | cut -d'/' -f4)
            dir=$(echo $g | cut -d'/' -f2)
            installed=$(ls /var/log/packages/$shortname-[0-9]* 2>/dev/null)

            if [ -e "$installed" ]; then
                version=$(echo $installed | cut -d'/' -f5 | rev | cut -d- -f3 \
                    | rev)
                echo "[Installed]	$dir/$(echo $installed | cut -d'/' -f5)"
            else echo "[Not Installed]	$dir/$shortname"
            fi
        done
    fi
}
#}}}
#{{{ Import gpg key
importgpg()
{
    # ripped from slackpkg
    if ! [ -e ~/.gnupg ]; then
        mkdir ~/.gnupg
    fi

    cd $TMPROOT || cleanup
    $WGET -O gpgkey ${PKGSERVER}/GPG-KEY || cleanup
    gpg --yes --batch --delete-key "$STUDIOKEY"
    gpg --import gpgkey
    echo "Studioware GPG key added"
    cleanup
}
#}}}
#{{{ Delete Cache !DANGER WILL ROBINSON!
deletecache()
{
    rm -r $CACHEDIR
    mkdir -p $CACHEDIR
    echo "Cache Deleted"
    cleanup
}
#}}}
init
getflags "$@"
