#!/bin/sh
#----------------------------------------------------------------------------
# list-packages - list packages
#
# Creation:     2001-11-04  fm
# Last Update:  $Id$
#
# Copyright (c) 2001-@@YEAR@@ the eisfair team, team(at)eisfair(dot)org
#
# 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.
#----------------------------------------------------------------------------
#
# Usage:
#
#    list-packages
# or list-packages all                - list all packages
#    list-packages <selected_section> - list only packages of specified category
#    list-packages invalid            - list packages with a non valid section
#    list-packages nolib              - list all packages,  but no lib
#    list-packages [--batch][--nosvn][--stableonly] upgradable - list upgradable
#                                       packages
#
# Valid sections are:
#    backup base chat communication contrib database devel drivers game lib
#    libdev mail misc multimedia netservices netutils news plang printer-file
#    security system utils web
#
# Deprecated sections from old section structure:
#    admin etc interpreter net
#----------------------------------------------------------------------------

# include eislib etc.
. /var/install/include/eislib
. /var/install/include/packagelib

# debug output
#debug_list_packages=true
if ${debug_list_packages:-false}
then
    exec 2>/tmp/$(basename ${0})-trace$$.log
    set -x
    ask_debug=true
    export ask_debug
fi

# check if console minium 80x24
check_screensize

case ${?} in
    0 )
        # nothing to do
        ;;
    * )
        exit 1
        ;;
esac

#----------------------------------------------------------------------------
# goto XY position
#----------------------------------------------------------------------------
gotoyx ()
{
    echo -e "\033[$1;$2H\c"
}

#----------------------------------------------------------------------------
# deinstall files
#----------------------------------------------------------------------------
del_file ()
{
  # rm -f ${index_txt_file}
    rm -f ${_parser_file}
    rm -f ${_update_package}
    rm -f ${_update_version}

    rm -f ${tmpfile}
}

#----------------------------------------------------------------------------
# write_header
#
# writes the header of the package-table dependent on $selected_section
#----------------------------------------------------------------------------
write_header ()
{
    case ${selected_section} in
        "all" )
            mecho --info "List all installed packages"
            ;;
        "nolib" )
            mecho --info "List all installed packages (but no libraries)"
            ;;
        "invalid" )
            mecho --info "List installed packages with invalid section name"
            ;;
        "upgradable" )

            if [ "${stable_check}" -eq 1 ]
            then
                if [ ${batchmode} -eq 0 ]
                then
                    mecho --info "List upgradable packages (with stable upgrades)"
                fi
            else
                if [ ${batchmode} -eq 0 ]
                then
                    mecho --info "List upgradable packages"
                else
                    echo "WARNING - Upgradable packages found (all${more_text})"
                fi
            fi
            ;;
        * )
            mecho --info "List installed ${selected_section}-packages"
            ;;
    esac

    if [ ${batchmode} -eq 0 ]
    then
        echo
    fi
    row=3
}

#----------------------------------------------------------------------------
# write_row
#
# writes the rows of the package-table dependent on
# $selected_section and $section_invalid
#----------------------------------------------------------------------------
write_row ()
{
    if [ ${vcheck} -eq 1 ]
    then
        # internet access available
        if "${check_update}"
        then
            vret=$( check_for_updates ${package} )
        fi

        case $vret in
            0 )
                level='--warn'
                read update < ${_update_version}
                rm -f ${_update_version}
                 #  update='update'
                ;;

            1 )
                level=''
                update='no update'
                ;;
            2 )
                level='--error'
                update='not found'
                ;;
            3 )
                level='--info'
                update='included'
                ;;
        esac
    else
        # no internet access available
        level=''
        update=''
    fi

    section=''
    version=''
    date=''
    _svn=''

    eval section='$_'${_n}'_PACKAGE_SECTION'
    eval version='$_'${_n}'_PACKAGE_VERSION'
    eval    date='$_'${_n}'_PACKAGE_DATE'

    # split version and set svn-date in date token, if given
    # put svn to version token
    if `echo "${version}" | grep -qE "svn|cvs"`
    then
        _svn="`echo "${version}" | sed 's/[-0-9.:]//g'`"
        date="`echo "${version}" | sed 's/^.*[cvs|svn]//'`"
        version="`echo "${version}" | sed 's/[cvs|svn].*$//'`${_svn}"
    fi

    [ "$show_progress" = 1 ] && mecho -n '            \b\b\b\b\b\b\b\b\b\b\b\b'

    if [ "$selected_section" = "all" ]     ||
       [ "$selected_section" = "nolib" ]   ||
       [ "$selected_section" = "upgradable" ]
    then
        if [ ${batchmode} -eq 1 ]
        then
            # batch mode
            svnflag=0
            if [ ${skipsvn} -eq 1 ]
            then
                echo "${update}" | grep -q "svn"

                if [ $? -eq 0 ]
                then
                    svnflag=1
                fi
            fi

            if [ ${svnflag} -eq 0 ]
            then
                batchoutput=1
                techo --file --row "$package" --warn "$section" "$version" $level "$update" "$date" >> ${tmpfile}
            fi
        else
            if "$section_invalid"
            then
                techo --row "${_n}." "$package" --warn "$section" "$version" $level "$update" "$date"
            else
                techo --row "${_n}." "$package"       "$section" "$version" $level "$update" "$date"
            fi
        fi
    else
        if "$section_invalid"
        then
            techo --row "${_n}." "$package" --warn "$section" "$version" $level "$update" "$date"
        else
            techo --row "${_n}." "$package"       ""         "$version" $level "$update" "$date"
        fi
    fi

    if [ "${vret:-1}" -eq 0 ]
    then
        update=update
    fi

    check_update=true
}

#----------------------------------------------------------------------------
# check_section
#
# check if the section is valid an writes the result to $section_invalid
#----------------------------------------------------------------------------
check_section ()
{
    section_invalid="true"

    if echo "${valid_sections}" | grep -q "^${section}$"
    then
        section_invalid="false"
    fi
}

#----------------------------------------------------------------------------
# function list_package
#
# check if the package shall be listed dependent on $selected_section
#----------------------------------------------------------------------------
list_package ()
{
    ret=1
    eval section='$_'$m'_PACKAGE_SECTION'
    check_section

    if [ "$selected_section" = "all" ]      ||
       [ "$selected_section" = "$section" ] ||
       [ "$selected_section" = "invalid" -a "$section_invalid" = "true" ]
    then
        ret=0
    fi

    if [ "$selected_section" = "nolib" ]    &&
       [ "$section" != "lib" ]
    then
        ret=0
    fi

    if [ "$selected_section" = "upgradable" ]
    then
        vret=`check_for_updates ${package}`

        if [ ${vret} -eq 0 ]
        then
            ret=0
            check_update=false
        fi
    fi

    return $ret
}

#----------------------------------------------------------------------------
# function get_indextxt
#
# get name of index.txt
# output:  1 - found name
#          0 - no index.txt defined
#----------------------------------------------------------------------------
get_indextxt ()
{
    _clear=''
    if [ ! -f /tmp/index ]
    then
        _clear="--clear"
    fi

    /var/install/bin/get-index ${_clear}
    _index_ret=${?}

    if [ ${_index_ret} -eq 0 ]
    then
        return 1
    else
        return 0
    fi
}

#----------------------------------------------------------------------------
# check for package updates
#
# input:  $1 - package name
# output:  0 - update available
#          1 - no update available
#          2 - package not found
#----------------------------------------------------------------------------
check_for_updates ()
{
    pname="$1"
    vrtc=1

    if [ -f ${index_txt_file} -a -s ${index_txt_file} ]
    then
        pnames=`grep "^${pname} " ${index_txt_file}`

        if [ -n "${pnames}" ]
        then
            # package found
            echo "${pnames}" |
            while read line
            do
                set -- ${line}

                if [ "${stable_check}" = "1" -a "${3}" != "stable" ]
                then
                    continue
                fi

                ver_check=`/var/install/bin/check-version ${pname} ${2}`

                if [ "${ver_check}" = "new" ]
                then
                    # fetch info file
                    # check for system version
                    base_packfile=`basename "${4}"`
                    rm -f ${base_packfile}

                    case ${4} in
                        *:* ) ${wget} -q ${4}                ;;
                        * )   ${wget} -q ${index_path}/${4}  ;;
                    esac

                    /usr/local/bin/dtou ${base_packfile}

                    # check for system version
                    display_system="`grep "<system>" ${base_packfile} |
                                     sed 's#</*system>##g; s/ /-/'`"

                    if [ -z "${display_system}" ]
                    then
                        display_system="eisfair-1"
                    fi

                    if ! `echo "${display_system}" | grep -q "${_system_work}$"`
                    then
                        rm -f ${base_packfile}
                        continue
                    else
                        index_package_version="`grep "<version>" ${base_packfile} |
                                                sed 's#</*version>##g'`"

                        rm -f ${base_packfile}
                        if [ `/var/install/bin/check-version ${pname} ${index_package_version}` = new ]
                        then
                            # new package found
                            echo datetime >/tmp/new_package_found
                            echo "${pname}|${index_package_version}" \
                                  >>${_update_package}
                            echo "${index_package_version}" >${_update_version}
                            break
                        fi
                    fi
                # end if [ "${ver_check}" = "new" ]
                fi
            done
        else
            case  "${pname}" in
                perl_* )
                    vrtc=3
                    ;;
                * )
                    # package not found
                    vrtc=2
                    ;;
            esac
          # end if [ -n "${pnames}" ]
        fi
      # end if [ -f ${index_txt_file} -a -s ${index_txt_file} ]
    fi

    if [ "${base_packfile}" != '' ]
    then
        rm -f ${base_packfile}
    fi

    if [ -f /tmp/new_package_found ]
    then
        vrtc=0
        rm -f /tmp/new_package_found
    fi

    echo ${vrtc}
}

#----------------------------------------------------------------------------
# show available updates
#
# input:  $1 - package name
#----------------------------------------------------------------------------
show_updates ()
{
    pname="$1"

    if [ -f $index_txt_file -a -s $index_txt_file ]
    then
        pnames=`grep "^$pname " $index_txt_file`

        if [ -n "${pnames}" ]
        then
            # package found
            # write eis-list header
            {
                echo "#<comment> Temporary package list for ${pname} packages"
                echo "#<comment> Copyright (c) 2001-`date +%Y` the eisfair team, team(at)eisfair(dot)org"
                echo "#<index> index.txt"
                echo "#<empty>"
                echo "#<message> Available packages:"
            } > $eislist_txt_file


            echo "${pnames}" |
            while read line
            do
                set -- ${line}

                if [ "${stable_check}" = "1" -a "${3}" != "stable" ]
                then
                    continue
                fi

                case ${4} in
                    *:* ) pfile_name=${4}               ;;
                    * )   pfile_name=${index_path}/${4} ;;
                esac

                case ${1} in
                    base )
                        # write eis-list entry, for base without version
                        echo "#<info> ${pfile_name}" >> $eislist_txt_file
                        ;;
                    * )
                        # write eis-list entry
                        echo "#<info ${_req_base}> ${pfile_name}" >> $eislist_txt_file
                        ;;
                esac
            done
        fi
    fi
}

#----------------------------------------------------------------------------
# search for packages with no section tag
#----------------------------------------------------------------------------
get_package_with_no_section ()
{
    files_in_folder=0
    files_in_section=0
    files_in_folder=`ls ${_package_path} | wc -l`
    files_in_section=`grep -r "<section>" ${_package_path} | wc -l`

    if [ ${files_in_folder} -gt ${files_in_section} ]
    then
        grep -r "<section>" ${_package_path} |
        sed 's#:.*$##' >/var/tmp/_search_section

        installed_packages=`ls -F ${_package_path} |
                            grep -vE "~|/$"        |
                            sed 's#*##'`

        for pa in ${installed_packages}
        do
            if ! `grep -q ${pa} /var/tmp/_search_section`
            then
                search_packages=`echo "${search_packages}";echo "${pa}"`
            fi
        done
        rm -f /var/tmp/_search_section
    fi
}

#----------------------------------------------------------------------------
# show package info
#----------------------------------------------------------------------------
show_package_info ()
{
  # set -x
  # eval package='$package_'"$a"
    eval package='$_'$a'_PACKAGE_NAME'
    eval status='$package_status_'"$a"
    eval section='$_'$a'_PACKAGE_SECTION'
    eval version='$_'$a'_PACKAGE_VERSION'
    eval    date='$_'$a'_PACKAGE_DATE'
    eval section='$_'$a'_PACKAGE_SECTION'
    eval  author='$_'$a'_PACKAGE_AUTHOR'
    eval  description='$_'$a'_PACKAGE_SHORT'
  # set | grep "_10_PACKAGE_"
  # set +x
  # clrhome

    mecho --info "Package information"
    echo; echo; echo;
    techo --begin '4 14 62'
    techo --row "" "Package:"     "$package"
    echo
    techo --row "" "Description:" "$description"
    echo

    # if true
    if "$section_invalid"
    then
        techo --row "" "Section:" --warn "$section"
    else
        techo --row "" "Section:"       "$section"
    fi

    echo
    techo --row "" "Version:"     "$version"
    echo
    techo --row "" "Date:"        "$date"
    echo
    techo --row "" "Author:"      "$author"
    techo --end
    echo; echo; echo; echo

    if  [ "$status" = "update" ]
    then
        refresh_screensize
        # update available
        gotoyx `expr "${_EISLIB_SCREENSIZE_Y}" - 2` 1
        echo
        /var/install/bin/ask "Select" "" "s=Show updates" "^$=Return" "0=Exit" > /tmp/ask.$$
        rc=$?
        a=`cat /tmp/ask.$$`
        rm -f /tmp/ask.$$
        if [ $rc = 255 ]
        then
            del_file
            exit 1
        fi

        case $a in
            s|S )
                show_updates $package

                /var/install/bin/install-package "file://${eislist_txt_file}"

                retval=${?}

                if [ -f ${_update_package} ]
                then
                    _is_line=$( grep -c . ${_update_package} )
                    case ${_is_line} in
                    1)
                        _u_all=''
                        rm -f ${_update_package}
                        ;;
                    esac
                fi

                if [ -f ${eislist_txt_file} ]
                then
                    rm -f ${eislist_txt_file}
                fi

                # if 0=EXIT from install-packages
                if [ ${retval} -ne 0 ]
                then
                    del_file
                    exit 127
                fi
                ;;
            0 )
                del_file
                exit 127
                ;;
        esac
    else
        refresh_screensize
        # no update available
        gotoyx `expr "${_EISLIB_SCREENSIZE_Y}" - 2` 1
        echo
        /var/install/bin/ask "Select" "" "^$=Return" "0=Exit" > /tmp/ask.$$
        rc=$?
        a=`cat /tmp/ask.$$`
        rm -f /tmp/ask.$$
        if [ $rc = 255 ]
        then
            del_file
            exit 1
        fi

        if [ "$a" = "0" ]
        then
            del_file
            exit 127
        fi
    fi
}

#----------------------------------------------------------------------------
# force package update
#----------------------------------------------------------------------------
force_package_update()
{
    if [ -f ${_update_package} ]
    then

        package_list=$( cat ${_update_package} )

        for line in ${package_list}
        do
            _u_package=$( echo "${line}" | awk -F'|' '{print $1}' )
            _u_version=$( echo "${line}" | awk -F'|' '{print $2}' )

            upackage=$( /var/install/bin/check-version \
                            ${_u_package} ${_u_version} )

            case ${upackage} in
            new )
                /var/install/bin/install-package \
                    -y -p ${_u_package} -v ${_u_version}
                ;;
            esac
        done

        rm -f ${_update_package}
    fi
}

#----------------------------------------------------------------------------
# print base update message
#----------------------------------------------------------------------------
print_base_update()
{
    echo
    mecho --warn "Please update your system, base version, first."
    echo
    del_file
    anykey
    exit 1
}

#----------------------------------------------------------------------------
# show this help
#----------------------------------------------------------------------------
show_help()
{
    echo
    echo 'Usage:'
    echo '    list-packages'
    echo ' or'
    echo '    list-packages all                - list all packages'
    echo '    list-packages <selected_section> - list only packages of specified category'
    echo '    list-packages invalid            - list packages with a non valid section'
    echo '    list-packages nolib              - list all packages,  but no lib'
    echo '    list-packages [--batch][--nosvn][--stableonly] upgradable - list upgradable packages'
    echo
    echo 'Valid sections are:'
    echo '    backup base chat communication contrib database devel drivers game lib'
    echo '    libdev mail misc multimedia netservices netutils news plang printer-file'
    echo '    security system utils web'
    echo
    echo 'Deprecated sections from old section structure:'
    echo '    admin etc interpreter net'
}

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

index_txt_file="/tmp/index.txt"
eislist_txt_file="/var/tmp/list-packages-list.txt"
wget="/usr/local/bin/wget.sh"
_default_base='1.6.1'
_parser_file="/var/tmp/list-packages-value"
_package_path='/var/install/packages'
_update_package='/tmp/__update_package'
_update_version='/tmp/__update_version'

datestamp="`date +'%d.%m.%Y %H:%Mh'`"
tmpfile=`/bin/mktemp -t list-packages-XXXXXXXXXX`

# define some constants
show_progress=1

# Define list of valid sections
valid_sections="backup
base
chat
communication
contrib
database
devel
drivers
game
lib
libdev
mail
misc
multimedia
netservices
netutils
news
plang
printer-file
security
system
utils
web"

# read command line switches
batchmode=0
skipsvn=0
stableonly=0
if [ $# -gt 0 ]
then
    # read parameter(s)
    while [ $# -gt 0 ]
    do
        case $1 in
            -help|--help|-?|--?|/? )
                show_help
                exit 1
                ;;

            --batch )
                batchmode=1
                show_progress=0
                shift
                ;;

            --nosvn )
                skipsvn=1
                shift
                ;;

            --stableonly )
                stableonly=1
                shift
                ;;
            -* )
                # skip unknown parameters
                shift
                ;;

            * )
                selected_section=$1
                shift
                ;;
        esac
    done
fi

if [ -z "$selected_section" ]
then
    selected_section="all"
fi
shift

# check for EISFAIR_SYSTEM is set, or check it once
if [ -z "${EISFAIR_SYSTEM}" ]
then
    # get eisfair system-type
    . /var/install/include/check-eisfair-version

    # set eisfair system-type
    _system_work=${EISFAIR_SYSTEM}
else
    # set eisfair system-type
    _system_work=${EISFAIR_SYSTEM}
fi

if [ ${batchmode} -eq 0 ]
then
    # interactive mode
    if `grep -qE "^MENU=['\"]/var/install/bin/show-menu.cui['\"]" /etc/config.d/setup`
    then
        ### CURSES MODE ###

        # execute cui package list application if curses menu is active
        case "${selected_section}" in
            "all" )
                /var/install/bin/list-packages.cui        \
                    --system=${_system_work}              \
                    --upgradable                          \
                    --helpfile=/var/install/help/packages \
                    --helpname=PACKAGELIST                \
                    -l                                    \
                    --installcmd='/var/install/bin/install-package -y -l %s/index.txt -i %s'
                    ;;
            "nolib" )
                /var/install/bin/list-packages.cui        \
                    --system=${_system_work}              \
                    --nolib                               \
                    --upgradable                          \
                    --helpfile=/var/install/help/packages \
                    --helpname=PACKAGEUPGRADE             \
                    -l                                    \
                    --installcmd='/var/install/bin/install-package -y -l %s/index.txt -i %s'
                    ;;
            "upgradable" )
                /var/install/bin/list-packages.cui        \
                    --system=${_system_work}              \
                    -t "List of upgradable packages"      \
                    --onlyupgradable                      \
                    --helpfile=/var/install/help/packages \
                    --helpname=PACKAGEUPGRADEONLY         \
                    -l                                    \
                    --installcmd='/var/install/bin/install-package -y -l %s/index.txt -i %s'
                    ;;
            * )
                /var/install/bin/list-packages.cui                             \
                    --system=${_system_work}                                   \
                    -t "Installed packages of section \"${selected_section}\"" \
                    --section=${selected_section}                              \
                    --helpfile=/var/install/help/packages                      \
                    --helpname=PACKAGELIST
                    ;;
        esac

       del_file
       exit 0
    fi
fi

# get the required base version from index.txt, or set the default
_req_base=`awk '/^# required_base/ {print $3}' ${index_txt_file} 2>/dev/null`

if [ -z "${_req_base}" ]
then
    _req_base=${_default_base}
fi

# check for installed base version
installed_base=`/var/install/bin/check-version base ${_req_base}`

case ${installed_base} in
    not-installed|new )
        _inst_base=false
        ;;
    * )
        _inst_base=true
        ;;
esac

# try to get file index.txt
get_indextxt
indextxt_found=$?

check_update=true
stable_check=0

if [ ${batchmode} -eq 0 ]
then
    ### ASCII MODE (interactive) ###
    clrhome
    write_header
fi

vcheck=0
if [ "$indextxt_found" = 1 ]
then
    if [ "$selected_section" != "upgradable" ]
    then
        ### ASCII MODE (interactive) ###
        echo
        /var/install/bin/ask "Do you want to look for new package versions" 'n' > /tmp/ask.$$
        rc=$?
        yesno=`cat /tmp/ask.$$`
        rm -f /tmp/ask.$$
        if [ $rc = 255 ]
        then
            del_file
            exit 1
        fi

        if [ "$yesno" = "yes" ]
        then
            # check if selected section != base
            if [ "${selected_section}" != "base" ]
            then
                # check for installed base
                if ! ${_inst_base}
                then
                    print_base_update
                fi
            fi
            vcheck=1
        else
            del_file
        fi
    fi
fi

if [ "$selected_section" = "upgradable" ]
then
    vcheck=1
    if [ "$indextxt_found" = 0 ]
    then
        mecho --error 'no index file available, can not look for new package versions'
        anykey
        exit 1
    fi
fi

if [ "$vcheck" = 1 ]
then
    if [ ${batchmode} -eq 1 ]
    then
        # batch mode
        if [ ${stableonly} -eq 1 ]
        then
            yesno='yes'
        else
            yesno='no'
        fi
    else
        ### ASCII MODE (interactive) ###
        echo
        /var/install/bin/ask "Do you want to look only for stable package versions" 'n' > /tmp/ask.$$
        rc=$?
        yesno=`cat /tmp/ask.$$`
        rm -f /tmp/ask.$$
        if [ $rc = 255 ]
        then
            del_file
            exit 1
        fi
    fi

    # check if selected section != base
    if [ "${selected_section}" != "base" ]
    then
        # check for installed base
        if ! ${_inst_base}
        then
            print_base_update
        fi
    fi

    if [ "$yesno" = "yes" ]
    then
        stable_check=1
    else
        stable_check=0
    fi
fi

while [ 1 ]
do
    if [ ${batchmode} -eq 1 ]
    then
        # batch mode
        write_header
        techo --file --begin '21 15 11 20 11'
    else
        ### ASCII MODE (interactive) ###
        clrhome
        write_header
        techo --begin '6r 28* 10* 11 12 11'
    fi

    a=''
    search_packages=''

    # do it a little bit faster with grep first
    case ${selected_section} in
        all|upgradable )
            search_packages=$( ls -F ${_package_path} |
                sed 's#:.*$##; s#*##' | grep -vE '~|/$' |
                sort )
            ;;

        nolib )
            search_packages=$( grep -r "<section>" ${_package_path} |
                grep -v "section>lib"  | sed 's#:.*$##; s#^.*/##; s#*##' |
                grep -vE '~|/$' )

            get_package_with_no_section
            search_packages=$( echo "${search_packages}" | sort )
            ;;

        invalid )
            unlist_sections=$( echo "${valid_sections}" | sed 's# #|#g' )

            search_packages=$( grep -r "<section>" ${_package_path} |
                grep -v -Ew "<section>${unlist_sections}</section>$" |
                sed 's#:.*$##; s#^.*/##; s#*##' | grep -v '~|/$' )

            get_package_with_no_section
            search_packages=$( echo "${search_packages}" | sort )
            ;;

        * )
            search_packages=$( grep -r "<section>${selected_section}" \
                ${_package_path} | sed 's#:.*$##; s#^.*/##; s#*##' |
                grep -vE '~|/$' | sort )
            ;;
    esac

    _n=0

    # touch parser file
    echo "#" > ${_parser_file}

    batchoutput=0
    for j in ${search_packages}
    do
        [ ${show_progress} -eq 1 ] && mecho -n 'searching...\b\b\b\b\b\b\b\b\b\b\b\b'

        j=`basename $j`
        m=`expr ${_n} + 1`
        #  parse_infofile  -i , --info     infofile
        #                  -v , --varpref  [variable-prefix]
        #                  -o , --outfile  /var/tmp/[outfile]
        parse_infofile -i ${_package_path}/${j} -v _${m} -o ${_parser_file}
        # include parser file
        . ${_parser_file}
        eval package='$_'$m'_PACKAGE_NAME'

        if list_package
        then
            _n=`expr ${_n} + 1`

            write_row

            row=`expr ${row} + 1`

            eval package_${_n}='"$j"'
            eval package_status_${_n}='"$update"'
        fi
    done

    [ ${show_progress} -eq 1 ] && mecho -n '            '

    if [ ${_n} -eq 0 ]
    then
        if [ ${batchmode} -eq 1 ]
        then
            # batch mode
            echo "OK - No packages updates in category '${selected_section}' found."
            echo "Last check: ${datestamp}"
        else
            techo --begin '2 70'
            echo
            echo
            techo --row "" --warn "No ${selected_section}-packages found"
            echo
            echo
            row=`expr ${row} + 5`
            anykey
            techo --end
        fi

        del_file
        exit 0
    fi

    if [ ${batchmode} -eq 1 ]
    then
        # batch mode
        more_text=''
        if [ ${skipsvn} -eq 1 ]
        then
            more_text=', except SVN'
        fi

        if [ ${batchoutput} -eq 1 ]
        then
            if [ ${stable_check} -eq 1 ]
            then
                echo "WARNING - Upgradable packages found (stable only${more_text})"
            else
                echo "WARNING - Upgradable packages found (all${more_text})"
            fi

            echo "Last check: ${datestamp}"

            # update packages found, show list
            cat ${tmpfile}
        else
            echo "OK - No packages updates found."
            echo "Last check: ${datestamp}"
        fi

        del_file
        exit 0
    else
        techo --end

        if [ -z "${a}" ]
        then
            refresh_screensize
            echo
            echo
            echo
            echo
            techo --end
            gotoyx `expr "${_EISLIB_SCREENSIZE_Y}" - 3` 1
            echo
            # set info line to screen is $row  + 6 -gt $LINES
            if [ ${_EISLIB_SCREENSIZE_Y} -lt `expr "${row}" + 6` ]
            then
                mecho --info "Use SHIFT + PAGE-UP to scroll up"
            else
                echo
            fi

            if [ -f ${_update_package} ]
            then
                _is_line=$( grep -c . ${_update_package} )
                case ${_is_line} in
                    1 )
                        _u_all="a=Update-force"
                        ;;
                    * )
                        _u_all="a=Update-all-force"
                        ;;
                esac
            else
                _u_all=''
            fi

            /var/install/bin/ask "Select" "" "1-${_n}" ${_u_all} "^$=Return" "0=Exit" >/tmp/ask.$$
            rc=$?
            a=`cat /tmp/ask.$$`
            rm -f /tmp/ask.$$
            if [ $rc = 255 ]
            then
                del_file
                exit 1
            fi
        fi

        case ${a} in
            '' )
                del_file
                exit 0
                ;;
            0 )
                del_file
                exit 127
                ;;
            a|A )
                force_package_update
                ;;
            * )
                show_package_info
                ;;
        esac
    fi
done

del_file
exit 0

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