#!/bin/sh
#
# sysinstall/sysupdate		                 Package Administration Utility
# Version: 1.8.6
# Last changed: 12.05.94
#
# Copyright (c) Ralf Flaxa, Linux Support Team Erlangen,  1993, 1994
#
# sysinstall handles the administration of packages (gzipped tar archives)
#
# It currently supports installation, removal, update, information,
# pre- and afterscripts and extensive logging with history. 
#
# Support for dependencies, diagnostics is under development
#
# Currently we support 3 "magic files", that have the following meaning:
#
# /install/dobefore.sh		Script, that will be executed before the 
#				installation of the package
# 				if the script returns a non zero value, the
#				installation of the package will be aborted
# /install/doafter.sh		Script, that will be executed after the 
#				installation of the package
# /install/doinst.sh		same as /install/doafter.sh. For compatibility
#				reasons still supported
#
# requires:  zcat/gzip, tar, sed, basename, filesize, cp, rm, mv, mount/umount.
#
# History:
# 11. Aug 93 : Starting with the SLS sysinstall. Some Bugfixes for LST 1.3
# 10. Nov 93 : Some other bugfixes and additions for LST 1.5
# 21. Nov 93 : Completely rewritten for LST 1.6
# 14. Dez 93 : Some changes for LST 1.7
# 28. Feb 94 : Added update Support 
# 09. Mrz 94 : Added preselect Support
# 20. Mrz 94 : Completely rewritten for LST 1.8
# 09. Apr 94 : Code stop for release of Update LST 1.8
# 19. Apr 94 : Some small changes to make the infoline look nicer and the
#              warnings less severe
# 30. Apr 94 : Final fixes for the baseversion LST 1.8
# 06. Mai 94 : Dialog support added
# 12. Mai 94 : Dialog support part two
#
# Sorry, but we don't have a manpage yet ... Some volunteers to write one ?
# Have a look at the code and the "Usage" Output ( Option -? )
#

# Environment:
# ------------
export PATH="$PATH:/sbin:/root/bin:/root/sbin:/root/usr/bin:/root/usr/sbin:/root/usr/local/bin:."
umask 022

# String Constants:
# -----------------
YES=j
NO=n
CLEAR='c'
REVON='[7m'
REVOFF='[27m'
BEEPTONE=''
# ein erster Versuch fr Multi-Language Support ...
# nur partiell verwirklicht
MUNKNOWNVERSION="unbekannte Version"
MWRONGDISK="falsche Diskette"
MNOINDEX="keinen Index gefunden"
MERROR="Fehler"
MWARNING="Warnung"
MINPUT="Eingabe"
MPATH="Pfad"
MPLEASE="Bitte"
MDOINPUT="eingeben"
MNOTEXIST="existiert nicht"
MINVALID="ungltig"
MUNDOCFEATURE="Sie benutzen eine undokumentierte Funktion"
MOWNRISK="Benutzung auf eigene Gefahr"
MASKPROCEED="Wollen Sie fortfahren"
MASKKNOWIT="Wissen Sie wirklich, was Sie tun"
MASKEXPERT="Sind Sie Experte"
MKEYPRESS="Bitte Eingabetaste <return> drcken"

# Supported Constants:
# --------------------
PAGER=more
EXPART=/dev/hda1
TMPLOG=/tmp/tmplog
MSG=/tmp/.message
ERRMSG=/tmp/.error
NULLDEVICE=/dev/null
MOUNTTYPE=minix
COMPR=gzip
INDEXIDX=idx
MNTDIR=/mnt
INSTSCRIPT=doinst.sh
BEFORESCRIPT=dobefore.sh
AFTERSCRIPT=doafter.sh
# USEDIALOG=true
ALL=true	# by default, we install all. Will be unset by -minimum or -recommended
PKGLIST=			# bumped to /tmp/pkgs.lst
DISKLIST=			# bumped to /tmp/disks.lst
SERIESLIST=			# bumped to /tmp/series.lst
SPACESERIES=0			# bumped to /tmp/SERIESNAME.use
SPACEALL=0			# bumped to /tmp/all.use
PKGNUMBER=0			# bumped to /tmp/all.num
SPACEDISK=0
SPACESEL=0
UNCOMPBYTES=0

# Supported flags, affected variables and their defaults:
# -------------------------------------------------------
# Each block has the following contents:
# 1st line: # Explanation (affected variables) -flag
# 2nd line: VARIABLE=defaultvalue	# {possible values}
#
# Preload PKGLIST,DISKLIST,SERIESLIST,SPACEALL (PRELOAD=true)	-preload
PRELOAD=		# (empty),true
#
# Set verbose mode (VERBOSE=true)				-verbose
VERBOSE=		# (empty),true
#
# Set simulate mode (DOIT=echo)					-simulate
DOIT=			# (empty),echo
# 
# Debug script (VERBOSE=true and SIMULATE=true)			-debug
DEBUG=			# (empty),true
#
# Expert mode, be verbose and less strict (EXPERT=true)		-expert
EXPERT=			# (empty),true
#
# Install only the default packages (MINIMUM=true ALL=)		-minimum
MINIMUM=		# (empty),true
#
# Install also the recommended packages (RECOMMENDED=true ALL=)	-recommended
RECOMMENDED=		# (empty),true
#
# Prompt user before installation of a package (DOPROMPT=true)	-doprompt
DOPROMPT=		# (empty),true
#
# Preselect packages before installation (PRESELECT=true)	-preselect
PRESELECT=		# (empty),true
#
# Don't write logging information (DOLOG= )			-nolog
DOLOG=true		# (empty),true
#
# Do not save files before overwriting (SAVEOLD= )		-nosave
SAVEOLD=true		# (empty),true
#
# Ask for deletion of obsolete files and packages (DELOLD=true)	-delold
DELOLD=			# (empty),true
#
# Remove *.tgz packages after installation (REMOVEAFTER=true)	-removeafter
REMOVEAFTER=		# (empty),true


# Supported Parameters:
# ---------------------
# Each block has the following contents:
# 1st line: # Explanation      -parameter AFFECTED_VARIABLE
# 2nd line: VARIABLE=defaultvalue
#
# Directory to act as root-point ( "/" )		-instroot INSTROOT
INSTROOT=/		# for first install often /root
#
# Default device for packages (will be mounted on /mnt)	-instdev INSTDEV
INSTDEV=/dev/fd0 	# means install from floppy
#
# Path to the *.tgz packages				-instsrc INSTSRC
INSTSRC=""		# will be ignored for floppy
#
# Unconvential Package Extension			-extension ZEXT
ZEXT=tgz
#
# SLS/Slackware style indextype	(diskDISKNAME)		-indextype INDEXTYPE
INDEXTYPE=LST		# use SLS for SLS/Slackware
#
# List of Preselections instead of default		-selectlist SELECTLIST
SELECTLIST=
#
# List of Packages to extract from tape			-extractlist EXTRACTLIST
EXTRACTLIST=
#
# Update to the specified Version (important for log)	-update VERSION
VERSION=1.8
#
# Undocumented feature ;-)
# Fake the baseversion. 			        -baseversion BASEVERSION
# BASEVERSION will be overwritted by contents of 
# /install/BASEVERSION (if it exists) and again by
# the commandlineoption -baseversion
BASEVERSION=1.8
# 
# Undocumented feature ;-)
# Use FULLINDEX instead of current INDEX. 		-fullindex FULLINDEX
FULLINDEX=
#
# Undocumented feature ;-)
# Use Database instead of current package Information	-database DATABASE
DATABASE=
#
# Undocumented feature ;-)
# Use Configfile to configure sysinstall at run time	-config CONFIGFILE
CONFIGFILE=

# Supported Actions:
# ------------------
# List all installed packages				-list
# View contents of a certain package			-view
# Install package					-install PACKAGE.EXT
# Install all packages on a disk [with index]		-disk [DISKNAME]
# Install disc series xyz				-series SERIES
# Uninstall package 					-remove PACKAGE
# Uninstall series 					-removeseries SERIES
# Pack package with all the files specified in PACKAGE	-makepackage PACKAGE

#
# Supported log structure:
# ------------------------
# /							INSTROOT
# /install						LOGTOPDIR
# /install	installed				LOGPKGS
#		scripts					LOGSCRIPTS
#		disks					LOGDISKS
#		catalog					LOGINDEXES
#		database				LOGDATA
#		log					LOGLOG
#		log	/history			LOGHIST
#		update/VERSION				UPTOPLOGDIR
#               (wenn VERSION=BASISVERSION, dann zeigt UPTOPLOGDIR
#		auf /install und damit auch der folgende Logbaum)
#		update/VERSION/	installed		UPINST
#				scripts			UPSCRI
#				disks			UPDISK
#				catalog			UPCATA
#				database		UPDATA
#				contents		UPCONT
#				conflicts		UPCONF
#				saved			UPSAVE
#				replaced		UPREPL
#				deleted			UPDELE
#				modified		UPMODI
#				log			UPLOG
#				log	/history	UPHIST
#

#
# Functions
#

#
# PrintUsage () 
#
#	we have no man-page yet, so we give a little help here
#
PrintUsage() 
{
	echo
	echo "sysinstall/sysupdate		      Package Administration Utility"
	echo "Version: 1.8.6"
	echo "Last changed: 12.05.94"
	echo "Copyright (c) Ralf Flaxa, Linux Support Team Erlangen,  1993, 1994"
	echo
	echo "usage: sysinstall [FLAGS] [PARAMETERS] [ACTION] "
	echo 
	echo "FLAGS: change standard behaviour"
	echo "  -preload             allow preloading of LISTS for preselectmode"
	echo "  -verbose             tell verbosely what happens"
	echo "  -simulate            only simulate critical actions, do nothing"
	echo "  -debug               debug script, implies -verbose -simulate"
	echo "  -expert              allow special features and be less strict"
	echo "  -usedialog           use dialog for to display infos"
	echo "  -minimum             install only a minimal system"
	echo "  -recommended         install also the recommended packages"
	echo "  -doprompt            prompt user before installing each package"
	echo "  -preselect           preselect packages before installation"
	echo "  -nolog               don't write logging information"
	echo "  -nosave              do not save files before overwriting"
	echo "  -delold              query-delete obsolete files and packages"
	echo "  -removeafter         remove *.tgz packages after installation (for tape)"
	echo "PARAMETERS: change default parameters"
	echo "  -instroot ROOTDIR    directory to use as \"/\""
	echo "  -instdev DEVICE      install from device DEVICE"
	echo "  -instsrc PATH        path, where the *.tgz packages can be found"
	echo "  -extension ZEXT      packages have an extension ZEXT instead of tgz"
	echo "  -indextype INDEXTYPE accept non LST indextypes"
	echo "                       (for SLS/Slackware use -indextype SLS)"
	echo "  -selectlist FILE     FILE with list of preselections instead of default" 
	echo "  -extractlist FILE    FILE with list of packages to extract from tape"
	echo "  -version VERSION     install package from update to version VERSION"
	echo "                       (not needed, if using with or updating to LST 1.8)"	
	echo "ACTION: do one of the following actions"
	echo "  -list                list installed packages"
	echo "  -view PACKAGE        view contents of a package PACKAGE"
	echo "  -install PACKAGE.tgz install PACKAGE.tgz (or other extension if defined)"
	echo "  -disk [DISKNAME]     install all packages from disk [DISKNAME]"
	echo "                       (DISKNAME has to contain an index)"
	echo "  -series SERIES       install disc series SERIES"
	echo "  -remove PACKAGE      uninstall package PACKAGE"
	echo "  -removeseries SERIES uninstall series SERIES"
	echo "  -makepackage PACKAGE pack a new package with files specified in file PACKAGE"
}

#
# panic 
#
#	Someone interrupted the shellscript. Log that critical event.
panic()
{
	echo
	echo "It's no fun to be interrupted !"
	echo "This may cause an inconsistant state !"
	echo "I hope you know, what you are doing ..."
	echo "panic: sysinstall interrupted at `date`" >> $LOGHIST
	exit
}

#
# LogMsg ( text_saved_for_postponed_display )
#
#	Collect Text for postponed display
#
LogMsg()
{
	echo "$@" >> $MSG
}

#
# LogErr ( error_message_saved_for_postponed_display )
#
#	Collect Error Message for postponed display
#
LogErr()
{
	echo "$@" >> $ERRMSG
}

#
# debug ( text_shown_for_debugging )
#
#	Just for debugging purposes
#
debug()
{
	if [ "$DEBUG" = "true" -o "$VERBOSE" = "true" ]; then
		echo -n "debug: "
		echo $@
	fi
}

#
# Simulate ( on or off )
#
#	Just simulate dangerous actions
#
Simulate()
{
	if [ "$1" = "off" ]; then
		DOIT=
		NULLDEVICE=/dev/null
		TMPLOG=/tmp/tmplog
	else
		DOIT="echo simulate: "
		NULLDEVICE=/dev/tty
		TMPLOG=/dev/tty
		UPHIST=/dev/tty
	fi
}

#
# Seen ()
#
#	Just prompt for a keypress to make sure, he has seen that
Seen()
{
        echo
        echo -n "$MKEYPRESS"
        read dummy
}

#
#  Askyesno()
# 
#	Just ask a yes/no question (j/n)
Askyesno()
{
	export ANSWER=""
	echo -n " ($YES/$NO): " >> $MSG
	while [ 0 ]; do
		if [ "$USEDIALOG" = "true" ]; then
			dialog --yesno "`cat $MSG | cut -c 1-70`" 20 75
			if [ $? = 0 ]; then
				ANSWER=$YES
			else
				ANSWER=$NO
			fi
		else
			echo $CLEAR
			cat $MSG	
			read ANSWER
		fi
		if [ "$ANSWER" = "$YES" -o "$ANSWER" = "$NO" ]; then
			export ANSWER
			return 0
		fi
		Warning "$MINPUT $MINVALID"
	done
	# We should never reach this point ...
	return 1
}

#
#   Askstring()
#
#	Just ask for a non-null string
Askstring()
{
	export STRING=""
	echo -n "$MINPUT: " >> $MSG
	while [ 0 ]; do
		if [ "$USEDIALOG" = "true" ]; then
			dialog --inputbox "`cat $MSG | cut -c 1-70`" 20 75 2> /tmp/ANSWER
			STRING="`cat /tmp/ANSWER`" 
		else
			echo $CLEAR
			cat $MSG	
			read STRING
		fi
		if [ "$STRING" != "" ]; then
			return 0
		fi
		Warning "$MINPUT $MINVALID"
	done
	# We should never reach this point ...
	return 1
}

Message()
{
	if [ ! -f $MSG ]; then
		touch $MSG
	fi
	if [ "$USEDIALOG" = "true" ]; then
		dialog --infobox "`cat $MSG | cut -c 1-70 `" 20 75
	else
		echo $CLEAR
		cat $MSG
	fi
	rm -f $MSG
}
	 
#
# Error ( Errorstring )
#
#	Beep and output an error message
Error()
{
	echo $BEEPTONE $REVON
	echo -n "$MERROR "
	echo '!!!'
	echo -n "$@"
	echo $REVOFF
	Seen
}

#
# Warning ( Warningmessage )
#
#	Beep and output a warning message
Warning()
{
	echo $BEEPTONE $REVON
	echo -n "$MWARNING"
	echo '!!!'
	echo -n "$@"
	echo $REVOFF
}

#
# Checkinstsrc()
#
#	INSTSRC prfen
Checkinstsrc()
{
	while [ ! -d $INSTSRC ]; do
		Error "-instsrc: $MPATH $INSTSRC $MNOTEXIST"
		echo -n "$MPLEASE $MPATH $MDOINPUT"
		Askstring
		export INSTSRC="$STRING"
	done
}

#
# Checkinstroot()
#	
# 	INSTROOT prfen
Checkinstroot()
{
	while [ ! -d $INSTROOT ]; do
		Error "-instroot: $MPATH $INSTROOT $MNOTEXIST"
		echo -n "$MPLEASE $MPATH $MDOINPUT"
		Askstring
		export INSTROOT="$STRING"
	done
}	

#
# Checkbaseversion()
#
#	Check for the Baseversion
Checkbaseversion()
{
	if [ -f $LOGTOPDIR/BASEVERSION ]; then
		BASEVERSION=`cat $LOGTOPDIR/BASEVERSION`
	fi
	# Just because we are paranoid not to have a valid BASEVERSION
	if [ "$BASEVERSION" = "" ]; then
		BASEVERSION=1.7
	fi
	export BASEVERSION
}

#
# Checkupdateversion( VERSION )
#
#	Check for a valid updateversion
Checkupdateversion()
{
	if [ ! $# -gt 0 ]; then
		Error "interner Fehler: Checkupdateversion: missing argument"
		exit
	fi
	# We want to provide incremental update support
	if [ "$1" != "1.8" -a "$1" != "1.7" ]; then
		Warning "$MUNKNOWNVERSION !"
		echo "momentan sind nur 1.7 und 1.8 gltige Versionen"
		# This is dirty, but will protect newbie BETA Testers ...
		if [ "$EXPERT" = "true" ]; then
			Warning "$MOWNRISK !"
			echo "$MASKKNOWIT ?"
			echo -n "$MASKPROCEED ?"
			Askyesno
			if [ "$ANSWER" != "j" ]; then
				exit 1
			else
				return 0
			fi
		else
			exit 1
		fi
	fi
}

#
# LogAction ( LOGFILE string_to_log )
#
#	Log string in $LOGFILE
#
LogAction()
{
	LOGFILE=$1
	shift 1
	if [ "$DOLOG" = "true" ]; then
		if [ "$DOIT" = "" ]; then
			echo "$@" >> $LOGFILE
		else
			echo "echo $@ >> $LOGFILE"
		fi
	fi
}

#
# MountDisk ( diskname )
#
#	Mount a disk with name "diskname"
#	return: 0=erfolgreich, 1=skip
#	        2=quit 
#
MountDisk() 
{
	MountStat=0
	if [ "$INSTSRC" != "" ]; then
		test -d $INSTSRC;
		MountStat=$?
		return $MountStat;
	fi
	while [ 1 ]; do
		echo
		echo "Legen Sie Diskette $1 ein und drcken Sie return"
		echo "oder \"s\" zum berspringen dieser Diskette"
		echo -n "oder \"q\" zum verlassen der Serie: "
		read ans;
		if [ "$ans" = "s" ]; then
			return 1
		elif [ "$ans" = "q" ]; then
			return 2
		fi
		MountStat=0
		for k in $MOUNTTYPE msdos minix ext2; do
			if [ $MountStat = 0 -o $k != $MOUNTTYPE ]; then
				$DOIT mount -r -t $k $INSTDEV $MNTDIR  > $NULLDEVICE 2>&1
				MountStat=$?
				if [ $MountStat = 0 ]; then
					MOUNTTYPE=$k
					return $MountStat
				fi
			fi
		done
	done
}


#
# UnmountDisk ()
#
#	Unmount $INSTDEV
#
UnmountDisk()
{
	if [ "$INSTSRC" = "" ]; then
		$DOIT umount $INSTDEV > $NULLDEVICE 2>&1
	fi
}


#
# FindIndex ( Diskname )
#
#	Sucht nach LST und SLS/Slackware Indexdateien 
#
FindIndex()
{
	HASINDEX="false"
	INDEX=""
	INDEXTYPE="unknown"
	DISKNAME=$1

	if [ -f $SRCDIR/*.$INDEXIDX -o -f $SRCDIR/disk* ]; then
		HASINDEX="true"
	fi
 
	if [ -f $SRCDIR/$1.$INDEXIDX ]; then
		INDEXTYPE="LST"
		INDEX=$SRCDIR/$1.$INDEXIDX
	elif [ -f $SRCDIR/disk$1 ]; then
		INDEXTYPE="SLS"
		INDEX=$SRCDIR/disk$1
	else 
		if [ "$1" = "Disk" ]; then
			Warning "$MNOINDEX"
		elif [ "$HASINDEX" = "true" -a "$INDEX" = "" ]; then
			Error "$MWRONGDISK"
			echo "Bitte legen Sie die Diskette $1 ein"
		elif [ "$HASINDEX" = "false" ]; then
			Warning "$MNOINDEX ! $MWRONGDISK ?"
		fi
		echo
		echo "Hatten Sie wirklich die falsche Diskette eingelegt, "
		echo "so legen Sie die richtige Diskette ein und"
		echo "antworten Sie mit \"j\". "
		echo "Wenn es die richtige Diskette ist, diese aber keine"
		echo "Indexdatei $1.$INDEXIDX oder disk$1 enthlt, "
		echo "so antworten Sie mit \"o\". Wollen Sie keine weitere"
		echo "Diskette dieser Serie installieren, so antworten Sie"
		echo "mit \"q\". "
		echo
		echo "Nochmal versuchen (j), Diskette ohne index (o) "
		echo -n "berspringen (s) oder der Ende Serie (q) ? : "
		read ans;
		if [ "$ans" = "" -o "$ans" = "j" ]; then
			return 3
		elif [ "$ans" = "s" ]; then
			UnmountDisk > $NULLDEVICE 2>&1  
			return 1
		elif [ "$ans" = "q" ]; then
			return 2
		elif [ "$ans" = "o" ]; then
			INDEXTYPE="none"
		fi	
	fi
}


#
# GetPkgInfo ( package_with_full_path , extension ) [DATABASE] [FULLINDEX]
#
#
GetPkgInfo()
{
	PACKAGE=`basename $1 .$2`
	INFO=
	DATA=
	WHICHLST=
	UNCOMPBYTES=
	EFFECTON=
	DEPENDON=
	PRIORITY=
	SHORTPRIO=
	SELECTION=

	
	# INFO aus FULLINDEX ermitteln, falls angegeben und vorhanden
	if [ "$FULLINDEX" != "" ]; then
		# Get Info from FULLINDEX
		debug "Ermittle INFO fr Package $PACKAGE aus FULLINDEX $FULLINDEX"
		INFO=` fgrep ":$PACKAGE:" $FULLINDEX `
		debug "Info aus FULLINDEX = $INFO"
	fi
	# falls kein FULLINDEX vorhanden oder darin nicht gefunden
	if [ "$INFO" = "" ]; then
		debug "Ermittle INFO fr Package $PACKAGE aus lokalem INDEX $INDEX "
		# Get Info from INDEX
		if [ "$INDEXTYPE" != "none" -a "$INDEX" != "" ]; then
			INFO=` fgrep "$PACKAGE:" $INDEX `
			debug "Info aus INDEX = $INFO"
		fi
	fi
	export INFO

	DATA=""
	# DATEN aus DATABASE ermitteln, falls angegeben und vorhanden
	if [ "$DATABASE" != "" ]; then
		# Daten aus DATABASE ermitteln
		debug "Ermittle Daten fr Package $PACKAGE aus DATABASE $DATABASE"
		DATA=`cat $DATABASE | fgrep ":$PACKAGE:" `
		debug "Daten aus Database = $DATA"
		# not fully implemented yet
		DEPENDON=`echo $DATA | cut -s -d':' -f 1`
		SELECTION=`echo $DATA | cut -d':' -f 3`
		SHORTPRIO=`echo $DATA | cut -d':' -f 4`
		UNCOMPBYTES=`echo "$DATA" | cut -d':' -f 5`
		WHICHDISK=`echo $DATA | cut -d':' -f 6`
		PKGSIZE=`echo $DATA | cut -s -d':' -f 7`
		WHICHLST=`echo $DATA | cut -s -d':' -f 8`

		# not fully implemented yet
		EFFECTON=`echo $DATA | cut -s -d':' -f 9`

		if [ "$SHORTPRIO" = "D" ]; then
			PRIORITY="notwendig"
			if [ "$MINIMUM" = "true" -o "$RECOMMENDED" = "true" ]; then
				SELECTION="j"
			fi
		elif [ "$SHORTPRIO" = "R" ]; then
			PRIORITY="empfohlen"
			if [ "$RECOMMENDED" = "true" ]; then
				SELECTION="j"
			fi
		elif [ "$SHORTPRIO" = "O" ]; then
			PRIORITY="optional"
		elif [ "$SHORTPRIO" = "A" ]; then
			PRIORITY="alternativ"
		else
			SHORTPRIO="U"
			PRIORITY="unbekannt"
		fi
		if [ "$SELECTLIST" != "" ]; then
			dummy=`( sed 's/^/X/' | sed 's/$/ /' ) < $SELECTLIST | fgrep "X$1 " `
			if [ "$dummy" != "" ]; then
				SELECTION="j"
			else
				SELECTION="n"
			fi
		fi

	fi

	if [ "$DATA" = "" ]; then
		# Daten aus current INDEX ermitteln
		debug "Ermittle Daten fr Package $PACKAGE aus $INDEX und direkt"
		# Selection ermitteln
		if [ "$SELECTLIST" != "" ]; then
			dummy=`( sed 's/^/X/' | sed 's/$/ /' ) < $SELECTLIST | fgrep "X$1 " `
			if [ "$dummy" != "" ]; then
				SELECTION="j"
			else
				SELECTION="n"
			fi
		else
			SELECTION="n"
		fi
		# Prioritt ermitteln
		if [ "$INDEXTYPE" != "none" -a "$INDEX" != "" ]; then
			if fgrep "$PACKAGE:" $INDEX | fgrep '[d]' > $NULLDEVICE 2>&1 ; then
				SHORTPRIO="D"
				PRIORITY="notwendig"
				if [ "$MINIMUM" = "true" -o "$RECOMMENDED" = "true" ]; then	
					SELECTION="j"
				fi
			elif fgrep "$PACKAGE:" $INDEX | fgrep '[a]' > $NULLDEVICE 2>&1 ; then
				SHORTPRIO="A"
				PRIORITY="alternativ"
			elif fgrep "$PACKAGE:" $INDEX | fgrep '[r]' > $NULLDEVICE 2>&1 ; then
				SHORTPRIO="R"
				PRIORITY="empfohlen"
				if [ "$RECOMMENDED" = "true" ]; then
					SELECTION="j"
				fi
			elif fgrep "$PACKAGE:" $INDEX | fgrep '[o]' > $NULLDEVICE 2>&1 ; then
				SHORTPRIO="O"
				PRIORITY="optional"
			else
				SHORTPRIO="U" 
				PRIORITY="unbekannt"
			fi
		else
			PRIORITY="unbekannt"
		fi
		# Paketgre ermitteln
		UNCOMPBYTES="`gzip -l $1 | sed -n '$ p' | cut -b10-19`"
		WHICHDISK="$DISKNAME"
		PKGSIZE=`filesize $1` # falsch !
		echo " "
	fi
	if [ "$SELECTLIST" != "" ]; then
		debug "Looking for $PACKAGE in selectlist $SELECTLIST ..."
		dummy=`( sed 's/^/X/' | sed 's/$/ /' ) < $SELECTLIST | fgrep "X$PACKAGE " `
		debug "Result from fgrep : /$dummy/ "
		if [ "$dummy" != "" ]; then
			debug "found ! "
			SELECTION="j"
		else
			debug "not found ! "
			SELECTION="n"
		fi
	fi
	if [ "$UNCOMPBYTES" = "" ]; then
		UNCOMPBYTES=0
	fi
	if [ "$WHICHLST" = "" ]; then
		WHICHLST="unbekannt"
	else
		WHICHLST="LST $WHICHLST"
	fi
	if [ "$WHICHDISK" = "" ]; then
		WHICHDISK="unbekannt"
	fi
	if [ "$PKGSIZE" = "" ]; then
		PKGSIZE=0
	else
		debug "PKGSIZE ist $PKGSIZE Bytes"
	fi
	debug "Daraus ergeben sich folgende Daten:"
	debug "$DEPENDON:$PACKAGE:$SELECTION:$SHORTPRIO:$UNCOMPBYTES:$WHICHDISK:$PKGSIZE:$WHICHVERSION:$EFFECTON"
	export SELECTION SHORTPRIO PRIORITY UNCOMPBYTES WHICHDISK PKGSIZE WHICHVERSION DEPENDON EFFECTON
}


#
# ShowPkgInfo ( PACKAGE )
#
#	Zeigt alle verfgbaren Infos ber ein Paket an
#
ShowPkgInfo()
{
	# das knnte man viel schner formatieren ;-)
	SPACEDISK=" `df $INSTROOT | fgrep "/" | cut -c 37-45 ` "
	SELKB="` expr $SPACESEL / 1024 `"
	SERIESKB="` expr $SPACESERIES / 1024 `"
	rm -f $MSG
	echo "                 >>>>>> $PACKAGE <<<<<<" > $MSG
	if  [ "$INFO" = "" ]; then
		debug "Sorry, keine nheren Informationen vorhanden"
	else
		echo "====================================================================" >> $MSG
		echo "$INFO" | sed 's/\[[oadrDRUOA]\]//' | cut -c 12-  >> $MSG
		echo "====================================================================" >> $MSG
	fi
	if [ "$UNCOMPBYTES" = "" ]; then
		Error "UNCOMPBYTES was undefined 3 ! "
	fi
	echo "Das Paket >>$PACKAGE<< belegt komprimiert ` expr $PKGSIZE / 1024 ` KB auf Diskette $WHICHDISK" >> $MSG
	echo -n "Bereits installiert: $PKGNUMBER " >> $MSG
	if [ "$PKGNUMBER" = 1 ]; then
		echo -n "Paket " >> $MSG
	else
		echo -n "Pakete " >> $MSG
	fi
	echo "mit gesamt $SELKB KB" >> $MSG
	echo -n "Prioritt: $PRIORITY " >> $MSG
	if [ "$SELECTION" = "j" ]; then
		echo "  ( vorselektiert )" >> $MSG
	else
		echo " " >> $MSG
	fi
	echo "Platzbedarf: `expr $UNCOMPBYTES / 1024 ` KB" >> $MSG
	if [ "$PRESELECT" != "" ]; then
		echo "Voraussichtlicher Festplattenplatz: ` expr $SPACEDISK - $SELKB ` / $SPACEDISK KB." >> $MSG
	else
		echo "Aktueller Festplattenplatz: $SPACEDISK KB" >> $MSG
	fi
}

#
# SkipInstall ()
#
#	Dummy Function just for preselect-logging
#
SkipInstall()
{
	if [ "$PRESELECT" != "" ]; then
		echo "Preselect Modus. Vermerke nur die Auswahl ..." >> $MSG
		echo "$DEPENDON:$PACKAGE:n:$SHORTPRIO:$UNCOMPBYTES:$WHICHDISK:$PKGSIZE:$WHICHVERSION:$EFFECTON" >> /tmp/$DISKNAME.dat
		echo >> $MSG
		echo "$PACKAGE bersprungen, da nicht selektiert ..." >> $MSG
		Message
		debug "$DEPENDON:$PACKAGE:n:$SHORTPRIO:$UNCOMPBYTES:$WHICHDISK:$PKGSIZE:$WHICHVERSION:$EFFECTON" 
		debug "Summe der Selektionen: $SPACESEL in $PKGNUMBER Paketen"
	fi
}

#
# DoInstall ( packagename_with_extension , extension )
#
#	Rohe Installation eines Paketes
#
DoInstall()
{
	if echo "$PKGLIST" | fgrep $PACKAGE > /dev/null ; then
		echo
		Warning "$PACKAGE war bereits in der Liste der selektierten Pakete"
	else
		debug "PKGLIST:"
		debug "$PKGLIST"
		PKGLIST=" $PKGLIST $PACKAGE "
		# Summe der Selektionen dieser Serie berechnen
		if [ "$SPACESERIES" = "" ]; then
			Warning "SPACESERIES was undefined !"
			SPACESERIES=0
		fi
		if [ "$SPACESEL" = "" ]; then
			Warning "SPACESEL was undefined !"
			SPACESEL=0
		fi
		if [ "$UNCOMPBYTES" = "" ]; then
			Warning "UNCOMPBYTES was undefined !"
			UNCOMPBYTES=0
		fi
		if [ "$PKGNUMBER" = "" ]; then
			Warning "PKGNUMBER was undefined !" 
			PKGNUMBER=0
		fi
		SPACESERIES=` expr $SPACESERIES + $UNCOMPBYTES `
		PKGNUMBER=` expr $PKGNUMBER + 1 `
		SPACESEL=` expr $SPACESEL + $UNCOMPBYTES `
		debug "Summe der Selektionen: $SPACESEL in $PKGNUMBER Paketen"
		echo "$DEPENDON:$PACKAGE:j:$SHORTPRIO:$UNCOMPBYTES:$WHICHDISK:$PKGSIZE:$WHICHVERSION:$EFFECTON" >> /tmp/$DISKNAME.dat
		echo "$PACKAGE" >> /tmp/$DISKNAME.sel
		echo "$PACKAGE" >> /tmp/.selections
	fi
	if [ "$PRESELECT" != "" ]; then
		echo "Preselect Modus. Vermerke nur die Auswahl ..." >> $MSG
		return 0
	fi
	CONTENTS=/tmp/U
	CONFLICTS=/tmp/K
	debug "Checking for reinstall"
	if [ -f $UPINST/$PACKAGE ]; then
		Warning "Das Paket wurde bereits schon einmal installiert"
	fi
	debug "Forcing a clean state"
	rm -f $CONTENTS $CONFLICTS
	for dummy in $UPINST $UPSCRI $UPCONT $UPCONF $UPSAVE $UPREPL $UPDELE $UPMODI ; do
		rm -f $dummy/$PACKAGE
	done
	debug "DoInstall $1 called"
	if [ -f $1 ]; then
		PACKAGE=`basename $1 .$2`
		debug "install $PACKAGE"
		LogAction $UPHIST "`date` $PACKAGE installed"
		for dummy in "$BEFORESCRIPT" "$INSTSCRIPT" "$AFTERSCRIPT" ; do
			if [ -f $LOGTOPDIR/$dummy ]; then
				debug "removing leftover $dummy  magic script"
				$DOIT rm $LOGTOPDIR/$dummy
			fi
		done
		debug "looking in the archive (tar -ztvf)"
		( cd $INSTROOT; tar -ztvf - ) < $1 > $TMPLOG
		if [ "$DOLOG" = "true" ]; then
			$DOIT cp -a $TMPLOG $UPCONT/$PACKAGE
		fi
		debug "checking for dobefore script"
		if fgrep "$BEFORESCRIPT" $TMPLOG > $NULLDEVICE ; then
			debug "extracting dobefore script"
			( $DOIT cd $INSTROOT; $DOIT tar -zxvf - install/$BEFORESCRIPT ) < $1 > $NULLDEVICE
			if [ -f $LOGTOPDIR/$BEFORESCRIPT ]; then
				debug "executing dobefore script"
				( $DOIT cd $INSTROOT; $DOIT sh $LOGTOPDIR/$BEFORESCRIPT -install )
				if [ $? != 0 ]; then
					Warning "Voraussetzungen zur Installation dieses Paketes treffen nicht zu"
					echo "berspringe deshalb dieses Paket ..." >> $MSG
					LogAction $UPHIST "`date` $PACKAGE not installed (dobefore exit status != 0)"
					return 1
				fi
				debug "saving dobefore script"
				$DOIT mv $LOGTOPDIR/$BEFORESCRIPT $UPSCRI/$PACKAGE.$BEFORESCRIPT
			fi
		fi
		debug "building set of Updatefiles"
		cut -c 50- $TMPLOG | sed '/\/$/d' >> $CONTENTS
		debug "checking for conflicts"
		for dummy in `cat $CONTENTS`; do
			if [ -f $INSTROOT/$dummy ]; then
				debug "Konflikt: $dummy existiert"
				LogAction $UPCONF/$PACKAGE "$dummy"
				if [ "$SAVEOLD" = "true" ]; then
					debug "saving $INSTROOT/$dummy as $INSTROOT/$dummy.before.$VERSION"
					LogAction $UPSAVE/$PACKAGE "$dummy.before.$VERSION"
					LogAction $UPHIST "`date` $dummy saved as $dummy.before.$VERSION"
					debug "removing old $INSTROOT/$dummy"
					$DOIT ln -f $INSTROOT/$dummy $INSTROOT/$dummy.before.$VERSION
					$DOIT rm -f $INSTROOT/$dummy
					LogAction $UPREPL/$PACKAGE "$dummy"
					LogAction $UPHIST "`date` $dummy replaced"
				fi
			fi
		done
		debug "extracting archive (tar -zxvlpf)"
		( $DOIT cd $INSTROOT; $DOIT tar -zxvlpf - | sed "/\/$/d" ) < $1 > $TMPLOG
		if [ "$DOLOG" = "true" ]; then
			$DOIT cp -a $TMPLOG $UPINST/$PACKAGE
		fi
		if [ -f $LOGTOPDIR/$INSTSCRIPT ]; then
			debug "executing doinst script"
			LogAction $UPHIST "`date` $PACKAGE executing doinst.sh" 
			( $DOIT cd $INSTROOT; $DOIT sh $LOGTOPDIR/$INSTSCRIPT -install )
			$DOIT mv $LOGTOPDIR/$INSTSCRIPT $UPSCRI/$PACKAGE.$INSTSCRIPT
		fi
		if [ -f $LOGTOPDIR/$AFTERSCRIPT ]; then
			debug "executing doafter script"
			LogAction $UPHIST "`date` $PACKAGE executing doafter.sh" 
			( $DOIT cd $INSTROOT; $DOIT sh $LOGTOPDIR/$AFTERSCRIPT -install )
			$DOIT mv $LOGTOPDIR/$AFTERSCRIPT $UPSCRI/$PACKAGE.$AFTERSCRIPT
		fi
		if [ "$DELOLD" = "true" -a -f $UPSAVE/$PACKAGE ]; then
			echo
			echo "Files to delete :"
			echo "-----------------"
			cat $UPSAVE/$PACKAGE
			echo -n "Alle (a), einzelne (e), oder keine (k) lschen ? (a/e/k) : "
			read ans
			if [ "$ans" = "a" ]; then
				debug "deleting all files, that package $PACKAGE had saved"
				LogAction $UPHIST "`date` deleting all files, that package $PACKAGE had saved"
				( $DOIT cd $INSTROOT; $DOIT rm -f `cat $UPSAVE/$PACKAGE` )
				$DOIT mv $UPSAVE/$PACKAGE $UPDELE/$PACKAGE
			elif [ "$ans" = "e" ]; then
				debug "asking for every file for confirmation to delete"
				for dummy in `cat $UPSAVE/$PACKAGE` ; do
					echo -n "Delete $dummy"
					Askyesno
					if [ "$ANSWER" = "j" ]; then
						debug "deleting file $dummy, that package $PACKAGE had saved"
						$DOIT echo "$dummy" >> $UPDELE/$PACKAGE
						LogAction $UPHIST "`date` deleting file $dummy, that package $PACKAGE had saved"
						$DOIT rm -f $INSTROOT/$dummy
						rm -f $UPSAVE/$PACKAGE.tmp
						for dummy2 in `cat $UPSAVE/$PACKAGE` ; do
							if [ -f $UPDELE/$PACKAGE ]; then
								fgrep "$dummy2" $UPDELE/$PACKAGE > $NULLDEVICE || echo "$dummy2" >> $UPSAVE/$PACKAGE.tmp
							fi
						done
						$DOIT mv $UPSAVE/$PACKAGE.tmp $UPSAVE/$PACKAGE
					fi
				done
			fi
		fi
		if [ "$REMOVEAFTER" = "true" ]; then
			debug "Lsche $1 ..."
			LogAction $UPHIST "`date` $1 removed"
			$DOIT rm $1
		fi			
		$DOIT rm -f $LOGTOPDIR/$BEFORESCRIPT
		$DOIT hash -r
		# echo "fertig"
	else
		echo "$1 nicht gefunden"
	fi
}


#
# QueryInstall ( packagename_with_extension , extension )
#
#	Ask for confirmation before installing a package
#
QueryInstall()
{
	PACKAGE=`basename $1 .$2`
	SkipDisk="false"
	while [ 0 ]; do
		cat << EOF >> $MSG
Sie haben nun mehrere Mglichkeiten:
Mit "j" knnen Sie das Paket $PACKAGE installieren.
Mit "n" knnen Sie die Installation des Paketes berspringen.
Mit "q" knnen Sie den Rest der Diskette berspringen.
Mit "v" knnen Sie sich zuerst den Inhalt des Paketes anzeigen lassen.
Mit "f" knnen Sie sich zuerst den freien Plattenplatz anzeigen lassen.
EOF
		Askstring
		rm $MSG
		if [ "$STRING" = "f" ]; then
			$DOIT df > $MSG
			Message
			continue
		fi
		if [ "$STRING" = "v" ]; then
			PagePackage $1
			continue
		fi
		if [ "$STRING" = "n" ]; then
			SkipInstall
			return 0
		fi
		if [ "$STRING" = "q" ]; then
			SkipDisk="true"
			echo "berspringe Rest der Diskette ..." >> $MSG
			Message
			return 0
		fi
		if [ "$STRING" = "j" ]; then
			echo "Installation von $PACKAGE ..." >> $MSG
			Message
			DoInstall $1 $2
			return 0
		fi
	done
}


#
# AutoInstall ( packagename_with_extension , extension )
#
#	Automatic installation of a package
#
AutoInstall()
{
	echo >> $MSG
	echo "Automatische Installation von $PACKAGE ..." >> $MSG
	Message
	DoInstall $1 $2
}


#
# PkgInstall ( packagename_with_extension , extension )
#
#	Installiert ein Paket abhngig von SELECTLIST, -doprompt
#	und -preselect
#
PkgInstall()
{
	export PACKAGE=`basename $1 .$2`

	debug "Calling GetpkgInfo ..."
	GetPkgInfo $1 $2

	if [ "$SELECTLIST" != "" ]; then
		if [ "$SELECTION" = "j" ]; then
			debug "Package $PACKAGE in Vorauswahlliste gefunden"
		fi
	fi
	ShowPkgInfo $PACKAGE
	
	debug "SELECTION = /$SELECTION/"

	# Vorauswahl mit SELECTLIST
	if [ "$SELECTLIST" != "" ]; then
		if [ "$SELECTION" = "j" ]; then
			# if someone really wants to know, what he has selected
			if [ "$DOPROMPT" = "true" ]; then
				debug "Installmode: query, da in SELECTLIST, aber er will trotzdem nachfragen"
				debug "prompt the selected files from the SELECTLIST"
				QueryInstall $1 $2
			else
				debug "Installmode: auto, habe Selectlist ohne Nachfragen !"
				debug "Paket installiert wegen SELECTLIST = $SELECTLIST"
				AutoInstall $1 $2
			fi
		else
			debug "Installmode: skip, da nicht in SELECTLIST"
			SkipInstall
		fi
	else
		# er hat vorselektiert
		if  [ "$SELECTION" = "j" ]; then
			debug "Installmode: auto, Ist in minimum (1) oder empfohlen (2)"
			debug "Paket installiert wegen SELECTION=j"
			AutoInstall $1 $2
		else
			# alles automatisch
			if [ "$ALL" = "true" -a "$DOPROMPT" = "" ]; then
				debug "Installmode: auto, Alles automatisch (3)"
				debug "Paket installiert wegen ALL=true DOPROMPT= SELECTION=n"
				AutoInstall $1 $2
			# xxx automatisch, rest mit nachfragen
			elif [ "$DOPROMPT" = "true" ]; then
				debug "Installmode: query, da xxx automatisch aber Rest mit Nachfragen (2/5)"
				debug "Paket nachfragen wegen SELECTION=n aber DOPROMPT=true"
				QueryInstall $1 $2
			else
				debug "Installmode: skip, da nicht selektiert, nicht Nachfragen und nicht Alles"
				SkipInstall
			fi
		fi
	fi
}


#
# DiskInstall ( diskname )
#
#	Installiert alle Pakete der Diskette "diskname"
#
DiskInstall()
{
	Status=""
	PKGSIZE=0
	MountDisk $1
	MountStat=$?


	if [ $MountStat != 0 ]; then
		return $MountStat
	fi

	> /tmp/$DISKNAME.dat
	> /tmp/$DISKNAME.sel

	if [ "$INSTSRC" = "" ]; then
		SRCDIR=$MNTDIR
	else
		SRCDIR=$INSTSRC/$1
	fi

	FindIndex $1

	DiskStat=$?
	
	if [ "$INDEXTYPE" != "unknown" -o $1 = "Disk" ]; then
		if [ "$INDEXTYPE" != "none" -a -f "$INDEX" ]; then
			$DOIT cat $INDEX > $UPCATA/$DISKNAME
		fi
		for FileExt in $ZEXT taz tpz tar ; do
			for FileZ in $SRCDIR/*.$FileExt; do
				if [ "$FileZ" = "$SRCDIR/*.$FileExt" ]; then
					continue;
				fi

				PACKAGE=`basename $FileZ .$FileExt` 
				PKGSIZE=`filesize $PACKAGE`;

				PRIORITY="NotFound"

				PkgInstall $FileZ $FileExt

				if [ "$SkipDisk" = "true" ]; then
					break 
				fi	
				if [ $1 != Disk -a "$DOLOG" != "" ]; then
					$DOIT echo "$PACKAGE.$FileExt	$PKGSIZE" >> $UPDISK/$DISKNAME
				fi
			done
			if [ "$SkipDisk" = "true" ]; then
				break 
			fi
			( echo "$DISKLIST" | fgrep "$DISKNAME" ) > /dev/null 2>&1 && continue
			DISKLIST=" $DISKLIST $DISKNAME "
		done
		if [ -f $SRCDIR/install.end ]; then
			LogAction $UPHIST "`date` Processing of series $SERIES done"
			DiskStat=2
		else
			DiskStat=0
		fi
		UnmountDisk 2>&1 > $NULLDEVICE
		return $DiskStat 
	fi
	UnmountDisk 2>&1 > $NULLDEVICE
	return $DiskStat
}


#
# SeriesInstall ( seriesname )
#
#	Installiert eine Serie mit Namen "seriesname"
#
SeriesInstall()
{
	export SERIES=$1
	Counter=1
# 	Since baseversion LST 1.8 uses the Gold Boot/Rootdisk, we start with
# 	Disk 1 in the basis-series ...
#	if [ "$1" = "basis" ]; then
#		Counter=2
#	else
#		Counter=1
#	fi

	while [ 0 ]; do
		export DISKNAME=$SERIES$Counter
		DiskInstall $DISKNAME
		DiskStat=$?


		if [ $DiskStat = 1 ]; then
			echo "Ueberspringe Diskette $DISKNAME ..."
		elif [ $DiskStat = 2 ]; then
			if [ "$SPACEALL" = "" ]; then
				Warning "SPACEALL was undefined !"
				SPACEALL=0
			fi
			if [ "$SPACESERIES" = "" ]; then
				Warning "SPACESERIES was undefined !"
				SPACESERIES=0
			fi
			SPACEALL=` expr $SPACEALL + $SPACESERIES `
			SERIESLIST=" $SERIESLIST $SERIES "
			# And we do extensive logging ...
			echo "$SPACESERIES" > /tmp/$SERIES.use
			echo "$SPACEALL" > /tmp/all.use
			echo "$PKGNUMBER" > /tmp/all.num
			echo "$SERIESLIST" > /tmp/series.lst
			return $DiskStat
		elif [ $DiskStat = 3 ]; then
			continue
		fi
		Counter=`expr $Counter + 1 `
	done

}

#
# RemovePkg ( packagename_without_extension )
#
#	Deinstalliert ein Paket
#
RemovePkg()
{
	if [ -f $UPINST/$1 ]; then
		if [ -f $UPSCRI/$1 ]; then
			$DOIT rm $UPSCRI/$1
		fi
		( $DOIT cd $INSTROOT; $DOIT xargs /bin/rm -f ) < $UPINST/$1 
		$DOIT rm $UPINST/$1
	elif [ -f $LOGPKGS/$1 ]; then
		if [ -f $LOGSCRIPTS/$1 ]; then
			$DOIT rm $LOGSCRIPTS/$1
		fi
		( $DOIT cd $INSTROOT; $DOIT xargs /bin/rm -f ) < $LOGPKGS/$1 
		$DOIT rm $LOGPKGS/$1
	else
		echo "Fehler: unbekanntes Paket $1"
	fi
}


#
# ShowInstalled ()
#
#	Zeigt alle zur Zeit installierten Pakete an
#
ShowInstalled()
{
	echo $revon
	echo "============= Installierte Pakete ============="
	echo $revoff
	echo "Basisversion: $BASEVERSION"
	echo "-----------------"
	cd $LOGPKGS
	ls -F *
	echo
	for i in $LOGTOPDIR/update/* ; do
		echo "Update: `basename $i`"
		echo "-----------"
		cd $LOGTOPDIR/update/`basename $i`/installed
		ls -F *
		echo
	done
	echo
}


#
# ShowPackage ( PACKAGE )
#
#	Zeigt den Inhalt eines Paketes an
#
ShowPackage()
{
	echo $revon
	echo "============= Inhalt von $1 =============" 
	echo $revoff
	zcat $1 | tar tvf - 
	echo
}


#
# PageInstalled ()
#
#	Zeigt alle zur Zeit installierten Pakete ber PAGER
#
PageInstalled()
{
	ShowInstalled | $PAGER
}


#
# PagePackage ( PACKAGE )
#
#	Zeigt den Inhalt eines Paketes an ber PAGER
#
PagePackage()
{
	ShowPackage $1 | $PAGER
}


#
# DoExtract ()
#
#	Packe ein Paket nach der Beschreibung in /install/installed
#
DoExtract()
{
	( $DOIT cd $INSTROOT; $DOIT tar -clpf - -T $LOGPKGS/$2  | $COMPR -9 ) > $2.$ZEXT
}

#
# DoPack ( PACKAGE )
#
#	Packe ein Paket nach der Beschreibung in ./PACKAGE
#
DoPack()
{
	if [ $# -gt 0 -a -f ./$1 ]; then
		( $DOIT cd $INSTROOT; $DOIT tar -clpf - -T ./$1  | $COMPR -9 ) > $1.$ZEXT
	else
		Error "Keine Paketbeschreibung $1 im aktuellen Verzeichnis gefunden !"
	fi
}

#
# Preloadlists
#
#	Initialisiert die Preselectlisten mit Listen aus /tmp
#
Preloadlists()
{
	if [ "$PRELOAD" != "" -a -f /tmp/all.use ]; then
		SPACEALL="`cat /tmp/all.use ` "
		SPACESEL=$SPACEALL
	else
		> /tmp/all.use
		SPACEALL=0
		SPACESEL=0
	fi
	if [ "$PRELOAD" != "" -a -f /tmp/all.num ]; then
		PKGNUMBER="`cat /tmp/all.num ` "
	else
		> /tmp/all.num
		PKGNUMBER=0
	fi
	if [ "$PRELOAD" != "" -a -f /tmp/pkgs.lst ]; then
		PKGLIST="`cat /tmp/pkgs.lst ` "
	else
		> /tmp/pkgs.lst
		PKGLIST=""
	fi
	if [ "$PRELOAD" != "" -a -f /tmp/disks.lst ]; then
		DISKLIST="`cat /tmp/disks.lst ` "
	else
		> /tmp/disks.lst
		DISKLIST=""
	fi
	if [ "$PRELOAD" != "" -a -f /tmp/series.lst ]; then
		SERIESLIST="`cat /tmp/series.lst ` "
	else
		> /tmp/series.lst
		SERIESLIST=""
	fi
	export SPACEALL SPACESEL PKGNUMBER PKGLIST DISKLIST SERIESLIST
}
	


#
# Main 
#


# trap panic 1 2 9 15

# save whole command line for logging in history
commandline="$0 $@"

debug "commandline was: $commandline"


# first we test for a configfile
if [ $# -gt 1 -a "$1" = "-config" ]; then
	. $2
	shift 2
fi

# then we test for the preload lists
if [ $# -gt 0 -a "$1" = "-preload" ]; then
	PRELOAD=true
	shift 1
else
	PRELOAD=
fi

Preloadlists

# parse flags and parameters
while [ 0 ]; do
	# First we test for the flags
        if [ $# -gt 0 -a "$1" = "-verbose" ]; then
                VERBOSE=true
                shift 1
                continue;
        elif [ $# -gt 0 -a "$1" = "-simulate" ]; then
                Simulate on
                shift 1
                continue;
	elif [ $# -gt 0 -a "$1" = "-debug" ]; then
		Simulate on
		DEBUG=true
		shift 1
		continue;
	elif [ $# -gt 0 -a "$1" = "-expert" ]; then
		EXPERT=true
		shift 1
		continue;
	elif [ $# -gt 0 -a "$1" = "-usedialog" ]; then
		USEDIALOG=true
		shift 1
		continue;
	elif [ $# -gt 0 -a "$1" = "-minimum" ]; then
		MINIMUM=true
		ALL=
		shift 1
		continue;
	elif [ $# -gt 0 -a "$1" = "-recommended" ]; then
		MINIMUM=true
		RECOMMENDED=true
		ALL=
		shift 1
		continue;
	elif [ $# -gt 0 -a "$1" = "-doprompt" ]; then
		DOPROMPT=true
		shift 1
		continue;
	elif [ $# -gt 0 -a "$1" = "-preselect" ]; then
		PRESELECT=true
		shift 1
		continue;
	elif [ $# -gt 0 -a "$1" = "-nolog" ]; then
		DOLOG=
		shift 1
		continue;
	elif [ $# -gt 0 -a "$1" = "-nosave" ]; then
		SAVEOLD=
		shift 1
		continue;
	elif [ $# -gt 0 -a "$1" = "-delold" ]; then
		DELOLD=true
		shift 1
		continue;
	elif [ $# -gt 0 -a "$1" = "-removeafter" ]; then
		REMOVEAFTER=true
		shift 1
		continue;
	# Then we test for Parameters
	elif [ $# -gt 1 -a "$1" = "-instroot" ]; then
		INSTROOT=$2
		shift 2
		continue;
	elif [ $# -gt 1 -a "$1" = "-instdev" ]; then
		INSTDEV=$2
		shift 2
		continue;
	elif [ $# -gt 1 -a "$1" = "-instsrc" ]; then
		INSTSRC=$2
		shift 2
 		continue;
	elif [ $# -gt 1 -a "$1" = "-extension" ]; then
		ZEXT=$2
		shift 2
 		continue;
	elif [ $# -gt 1 -a "$1" = "-indextype" ]; then
		INDEXTYPE=$2
		shift 2
 		continue;
	elif [ $# -gt 1 -a "$1" = "-selectlist" ]; then
		SELECTLIST=$2
		shift 2
 		continue;
	elif [ $# -gt 1 -a "$1" = "-extractlist" ]; then
		EXTRACTLIST=$2
		shift 2
 		continue;
        elif [ $# -gt 1 -a "$1" = "-update" ]; then
                VERSION=$2
		shift 2
                continue;
	# Undocumented feature ;-)
        elif [ $# -gt 1 -a "$1" = "-baseversion" ]; then
                BASEVERSION=$2
		shift 2
                continue;
	# Undocumented feature ;-)
        elif [ $# -gt 1 -a "$1" = "-fullindex" ]; then
                FULLINDEX=$2
		shift 2
                continue;
	# Undocumented feature ;-)
        elif [ $# -gt 1 -a "$1" = "-database" ]; then
                DATABASE=$2
		shift 2
                continue;
	# Undocumented feature ;-)
        elif [ $# -gt 1 -a "$1" = "-packagelist" ]; then
		PKGLIST=" `cat $2 ` "
		shift 2
                continue;
	# Undocumented feature ;-)
        elif [ $# -gt 1 -a "$1" = "-disklist" ]; then
		DISKLIST=" `cat $2 ` "
		shift 2
                continue;
	# Undocumented feature ;-)
        elif [ $# -gt 1 -a "$1" = "-serieslist" ]; then
                SERIESLIST=" `cat $2 `"
		shift 2
                continue;
	# Undocumented feature ;-)
        elif [ $# -gt 1 -a "$1" = "-setused" ]; then
		SPACEALL=" `cat $2 ` "
		SPACESEL=$SPACEALL
		shift 2
                continue;
	else
		break;
	fi
done;

#
# semantic checks
#
Checkinstsrc
Checkinstroot
Checkbaseversion
Checkupdateversion $VERSION

debug "BASEVERSION = $BASEVERSION"
debug "VERSION = $VERSION"


# Define log structure. Static, but relocatable by $INSTROOT and $VERSION 
LOGTOPDIR=$INSTROOT/install
LOGPKGS=$LOGTOPDIR/installed
LOGSCRIPTS=$LOGTOPDIR/scripts
LOGINDEXES=$LOGTOPDIR/catalog
LOGDISKS=$LOGTOPDIR/disks
LOGDATA=$LOGTOPDIR/database
LOGLOG=$LOGTOPDIR/log
LOGHIST=$LOGLOG/history

# The following creates separat log-trees for updates or uses /install for
# the baseversion
if [ "$VERSION" = "$BASEVERSION" ]; then
	UPLOGTOPDIR=$LOGTOPDIR
else
	UPLOGTOPDIR=$LOGTOPDIR/update/$VERSION
fi
UPINST=$UPLOGTOPDIR/installed
UPSCRI=$UPLOGTOPDIR/scripts
UPDISK=$UPLOGTOPDIR/disks
UPCATA=$UPLOGTOPDIR/catalog
UPCONT=$UPLOGTOPDIR/contents
UPCONF=$UPLOGTOPDIR/conflicts
UPSAVE=$UPLOGTOPDIR/saved
UPREPL=$UPLOGTOPDIR/replaced
UPDELE=$UPLOGTOPDIR/deleted
UPMODI=$UPLOGTOPDIR/modified
UPLOG=$UPLOGTOPDIR/log
UPHIST=$UPLOG/history

for logdir in $LOGTOPDIR $LOGPKGS $LOGDISKS $LOGINDEXES $LOGDATA $LOGLOG ; do
	mkdir -p $logdir
done

for logdir in $UPINST $UPSCRI $UPDISK $UPCATA $UPDATA $UPCONT $UPCONF $UPSAVE $UPREPL $UPDELE $UPMODI $UPLOG ; do
	mkdir -p $logdir
done

debug "LOGTOPDIR = $LOGTOPDIR"
debug "UPLOGTOPDIR = $UPLOGTOPDIR"

# parse actions

if [ $# = 0 ]; then
	echo "No action specified !"
	echo "Use sysinstall -help"
elif [ "$1" = "-?" -o "$1" = "-help" ]; then
	PrintUsage
elif [ "$1" = "-list" ]; then 
	PageInstalled 
elif [ "$1" = "-view" -a $# = 2 ]; then 
	PagePackage $2 
elif [ "$1" = "-install" -a $# -gt 1 ]; then
	shift 1
	DISKNAME=unknown
	while [ $# -gt 0 ]; do
		LogAction $UPHIST "`date` $commandline : Processing $1 ..."
		export SELECTION="j"
		if [ "`basename $1 .$ZEXT`" != "`basename $1`" ]; then
			PkgInstall $1 $ZEXT
		else
			PkgInstall $1 tar
		fi
		shift 1
	done
elif [ "$1" = "-disk" ]; then
	LogAction $UPHIST "`date` $commandline"
	export SELECTION="j"
	if [ $# = 1 ] ; then
		DiskInstall Disk
	else
		DiskInstall $2
	fi
elif [ "$1" = "-remove" -a $# = 2 ]; then
	LogAction $UPHIST "`date` $commandline"
	RemovePkg $2
elif [ "$1" = "-removeseries" -a $# = 2 ]; then
	LogAction $UPHIST "`date` $commandline"
	Eror "-removeseries wird in der BETA Version leider noch nicht untersttzt !"
	exit 1
elif [ "$1" = "-extract" -a $# = 2 -o $1 = "-extracttar"  -a $# = 2 ]; then
	LogAction $UPHIST "`date` $commandline"
	echo -e "\007"
	echo "-extract und -extracttar werden nicht mehr akzeptiert !"
	echo "bitte benutzen Sie dafr -makepackage"
	echo "die Beschreibungsdatei mu dazu im aktuellen Verzeichnis stehen !"
	echo
	exit 1
	if [ -f $UPINST/$2 ]; then
		if [ -f $UPSCRI/$2 ]; then
			cp $UPSCRI/$2 $LOGTOPDIR/$INSTSCRIPT
			(cd $INSTROOT; sh $UPSCRI/$2 -extract;)
			if [ $1 = "-extract" ]; then
				( cd $INSTROOT; tar -clpPf - -T $UPINST/$2 | $COMPR ) > $2.$ZEXT
			else
				DoExtract $1 $2
			fi
			( cd $INSTROOT; sh $UPSCRI/$2 -retract;)
			rm $LOGTOPDIR/$INSTSCRIPT
		else
			if [ $1 = "-extract" ]; then
				( cd $INSTROOT; tar -clpPf - -T $UPINST/$2 | $COMPR ) > $2.$ZEXT
			else
				DoExtract $1 $2
			fi
		fi
	else
		echo "$UPINST/$2 nicht gefunden";
	fi;
elif [ "$1" = "-series" -a $# -gt 1 ]; then
	shift 1
	while [ $# -gt 0 ]; do
		LogAction $UPHIST "`date` $commandline : Processing $1 ..."
		SeriesInstall $1
		shift 1
	done
elif [ "$1" = "-makepackage" -a $# = 2 ]; then
	LogAction $UPHIST "`date` $commandline"
	DoPack $2
#
# dirty dirty. We will remove that soon ...
#
elif [ "$1" = "-basis" ]; then
	LogAction $UPHIST "`date` $commandline"
	SeriesInstall basis;
elif [ "$1" = "-tinyx" ]; then
	LogAction $UPHIST "`date` $commandline"
	SeriesInstall basis;
	SeriesInstall tinyx;
elif [ "$1" = "-basisX11" ]; then
	LogAction $UPHIST "`date` $commandline"
	SeriesInstall basis;
	SeriesInstall xbasis;
else
	PrintUsage;
fi

# dump the selections ...
echo "$PKGLIST" > /tmp/pkgs.lst
echo "$DISKLIST" > /tmp/disks.lst
echo "$SERIESLIST" > /tmp/series.lst
echo "$SPACESEL" > /tmp/all.use
echo "$PKGNUMBER" > /tmp/all.num

exit

