#!/bin/sh
#
# bootsetup 					LST Boot-Manager
# Version: 0.8.8
# Last changed: 26.05.94
#
# Copyright (c) Ralf Flaxa, Linux Support Team Erlangen, 1994
#

# Environment:
# ------------

# Environment sensitive Variables:
# --------------------------------
CALLNAME=`basename $0`
TEXTCONSTANTS=/usr/lib/LST/libLSTstrings
LIBLSTDIALOG=/usr/lib/LST/libLSTdialog

# String Constants:
# -----------------
. $TEXTCONSTANTS
MBOOTHEAD="LST Bootmanager"
MPARTDISPLAY="Liste der Partitionen ausgeben"
MBOOTLEAVE="Bootmanager verlassen"
MBOOTLILOHD="LILO auf Festplatte installieren"
MBOOTLILOFD="LILO Bootdiskette erstellen"
MBOOTLILOMULTI="LILO Multi Boot Diskette erstellen"
MBOOTFD="Bootdiskette erstellen"
MBOOTREPAIR="alten Bootsektor restaurieren"

# Supported Constants:
# --------------------
VERSION="0.8.7"
VERBOSE=
DEBUG=
DOIT=
SIMULATE=
BOOTDEVICE=
ROOTDEVICE=
BOOTBASE=
BOOTOK=
TMPDIR=/tmp
MOUNTPOINT=/mnt
INSTROOT=/
LILO=/sbin/lilo
ACTIVATE=/sbin/activate
LILOBOOTB=/boot/boot.b
LILOMESSAGE=/boot/message
LILOCONF=/etc/lilo.conf
LILOCONFIN=/etc/lilo.conf.in
LILOCONFTMP=/etc/lilo.conf.tmp
FREESPACE=
# USEDIALOG=true

#
# Functions
#

. $LIBLSTDIALOG

#
# PrintUsage  
#
#       we have no man-page yet, so we give a little help here
#
PrintUsage() 
{
        echo $BEEPTONE
	echo "$CALLNAME: LST Bootmanager Version $VERSION"
        echo "Usage: $CALLNAME [OPTIONS] [ACTION] "
	echo "OPTIONS:"
	echo " -debug         displays debugging information"
	echo " -expert        allow expert functions"
	echo " -simulate      simulate dangerous actions"
	echo " -usedialog     use dialog for input/output"	
	echo " -verbose       run verbosely"
	echo "ACTION:"
	echo " -help          display this \"Usage:\" message" 
	echo " -version       display version information"
	echo " -floppy        install LILO or a bootable kernel on a floppy disk"
	echo " -harddisk      install LILO on a harddisk partition or master boot record"
	echo " -install       only used during system installation"
	echo "Example: $CALLNAME -help"
	echo
}

#
# PrintVersion 
#
#	displays Version information
#
PrintVersion()
{
	echo "Version is $VERSION"
}

#
# simulate ( on or off )
#
simulate()
{
        if [ "$1" = "off" ]; then
                DOIT=
        else
                DOIT=echo
        fi
}

Abort()
{
	echo
	echo "$REVON Rufen Sie $CALLNAME erneut auf $REVOFF" 
	echo
	exit 1
}


#
# Partdisplay 
#
#	Displays all Partitions
#
Partdisplay()
{
	if [ $# = 0 ]; then
		echo "Liste der Partitionen ------------------------------------------------------"
		fdisk -l 2>&1 | fgrep '/dev/' | sed '/Disk/d' | sed '/Using/d' 
		return 0
	fi
} 

PrepareDisk()
{
	while [ 1 ]; do
		cat << EOF > $MSG

Lege Dateisystem auf Diskette an.

      Bitte warten Sie ...

EOF
		Message
		mkfs /dev/fd0H1440 1440 > /dev/null
		if [ $? != 0 ]; then
			cat << EOF > /tmp/.error
Dateisystem kann nicht geschrieben werden !
Ist die Diskette vielleicht nicht formatiert ?
EOF
			Error

			LogMsg "Wollen Sie die Diskette formatieren ? "
			Askyesno -default "j"
			if [ "$ANSWER" = "j" ]; then
				cat << EOF > $MSG
Formatiere die Diskette

  bitte warten Sie ...

EOF
				Message
				fdformat /dev/fd0H1440 > /dev/null 2>&1
				if [ $? != 0 ]; then
					cat << EOF > /tmp/.error

Problem ! Kann Diskette nicht formatieren.

Bitte suchen Sie eine andere Diskette.

EOF
					Error
				fi
				continue
			else
				Abort
			fi
		else
			break
		fi
	done
}

GenericConfig()
{
cat << EOF > $MOUNTPOINT$LILOCONF	
boot = $BOOTDEVICE
prompt
message = $LILOMESSAGE
image = /vmlinuz.norm
	label = normal
image = /vmlinuz.net
	label = net
image = /vmlinuz.tape
	label = tapecd
image = /vmlinuz.full
	label = full
EOF
}

GenericMessage()
{
cat << EOF > $MOUNTPOINT$LILOMESSAGE	

      _/       _/_/_/_/ _/_/_/_/_/   Linux Support Team Erlangen Distribution
     _/       _/           _/                            
    _/       _/_/_/_/     _/                     Version 1.8       
   _/             _/     _/                 
  _/_/_/_/ _/_/_/_/     _/                 LILO Boot Manager Men          
_______________________________________________________________________________

      Eine bersicht der Bootmglichkeiten erhalten Sie mit <TAB>.

Bei Problemen knnen Sie Linux zustzlich folgende Parameter bergeben:

ether=IRQ,I/O-Adr,ShmemStart,ShmemEnd,Dev  xd=Typ,IRQ,I/O-Adr,DMA  root=/dev/..
aha152x=I/O-Adr,IRQ,SCSI_Id,Reconnect(0/1) tmc8xx=I/O-Adr,IRQ  t128=I/O-Adr,IRQ
hd=Zyl,Kpfe,Sekt xd=Typ,IRQ,I/O-Adr,DMA   st0x=I/O-Adr,IRQ    bmouse=IRQ
sbpcd=Typ(Lasermate/Soundblaster),I/O-Adr  mcd=I/O-Adr,IRQ     sound=0xaabbbcd
generic_NCR5380=I/O-Adr,IRQ,DMA       reserve=Startadr1,Endadr1,Start2,End2,...

(hd=BIOS Parameter,xd=XT Kontroller, root=Rootpartition, sbpcd=CD an Soundkarte
aha152x=Adaptec AHA-1520/22, generic_NCR5380=NCR 5380, t128=Trantor T128(F)/228
st0x=Seagate ST01/02, tmc8xx=Future Domain TMC-8xx/950, reserve=reserv.Speicher
ether=Ethernet, mcd=Mitsumi CD, bmouse=Bus Mouse, sound mit aa=Typ und 01=Adlib
02=Soundblaster,  03=ProAudioSpectrum,  04=Gravis Ultrasound, 05=Roland MPU-401
06=Soundblaster 16,  07=Soundblaster 16 MPU-401  und bbb=I/O-Adr, c=IRQ, d=DMA)

EOF
}

		
MountGoldenboot()
{
	while [ 1 ]; do
		# Vorbereitungen zum Mounten
		umount $BOOTDEVICE > /dev/null 2>&1
		umount $MOUNTPOINT > /dev/null 2>&1
		if mount | fgrep "on $MOUNTPOINT " > /dev/null ; then
		cat << EOF > /tmp/.error
Kann $MOUNTPOINT nicht unmounten.
Stehen Sie noch in einer anderen Konsole innerhalb des Teibaumes
unter $MOUNTPOINT ?
Bitte verlassen Sie den Teilbaum $MOUNTPOINT
EOF
			Error
			continue
		fi
		cat << EOF > $MSG
Legen Sie nun die Golden Bootdisk in Ihr Laufwerk A ein.
Achten Sie dabei darauf, da der SCHREIBSCHUTZ der Diskette
aktiviert ist !!!

Es werden nun die Bootkernel der Golden Bootdisk auf Ihre
knftige Rootpartition kopiert und fr Ihr System angepat.

Auerdem wird eine Multibootdisk mit diesen Kernels fr
Ihr System erstellt (hnlich der Golden Bootdisk).
Dadurch haben Sie spter die Mglichkeit, den Linux Kernel
auszuwhlen, der fr die jeweilige Aufgabe am besten geeignet
ist. (Solange Sie sich noch keinen eigenen Kernel gebaut haben)

Drcken Sie dann die Eingabetaste
EOF
		Message
		read dummy

		# Golden Bootdisk readonly mounten
		mount -r -t minix $BOOTDEVICE $MOUNTPOINT 2>&1 > /dev/null 
		if [ ! -f $MOUNTPOINT/vmlinuz.norm ]; then
			cat <<- EOF > /tmp/.error
			Mounten der Golden Bootdisk hat nicht geklappt.
			Hatten Sie die falsche Diskette eingelegt ? 
			EOF
			Error
			echo -n "Nochmal versuchen "
			Askyesno -default "j"
			if [ "$ANSWER" = "n" ]; then
				return 1
			else
				continue
			fi
		else
			LogMsg "Golden Bootdisk gemountet. "
			Message
			break
		fi
	done
}

GetGoldenkernel()
{
	#
	# Kernel von Golden Bootdisk kopieren
	#
	cat << EOF > $MSG
Die Kernel der Golden Bootdisk werden auf Ihre Festplatte kopiert.

                Bitte warten Sie ...

EOF
	Message
	mkdir -p $INSTROOT/boot
	for i in norm tape net full ; do
		debug "Kopiere vmlinuz.$i nach $INSTROOT/vmlinuz.$i ..."
		cp -a /mnt/vmlinuz.$i $INSTROOT/vmlinuz.$i
		cat << EOF > $MSG
Kopiere und konfiguriere vmlinuz.$i fr Ihr System ...
EOF
		Message
		rdev $INSTROOT/vmlinuz.$i $ROOTDEVICE
		rdev -R $INSTROOT/vmlinuz.$i 1
		rdev -r $INSTROOT/vmlinuz.$i 0
		rdev -v $INSTROOT/vmlinuz.$i -1
		debug "Kopiere WHATSIN.$i nach $INSTROOT/boot/WHATSIN.$i ..."
		cp -a /mnt/etc/WHATSIN.$i $INSTROOT/boot/WHATSIN.$i
	done
}

Lilosetup()
{
	BOOTBASE=`echo $BOOTDEVICE | cut -c1-8`;
	GetBootparams || return 1
	GetBootkernel
	if [ "$BOOTKERNEL" = "" ]; then
		return 1
	fi
	SetBootparams $BOOTKERNEL
	if [ ! -f $INSTROOT$LILOBOOTB ]; then
		cp -a $LILOBOOTB $INSTROOT$LILOBOOTB
	fi
	if [ ! -f $INSTROOT$LILOMESSAGE ]; then
		cp -a $LILOMESSAGE $INSTROOT$LILOMESSAGE
	fi
	if [ ! -x $LILO ]; then
		auspack lilo
		if [ $? != 0 ]; then
			LogErr -n "Kann LILO nicht auspacken"
			Warning
			debug "kein Platz mehr in der Ramdisk"
			debug "Versuche es mit remauspack lilo ..."
			mkdir -p $INSTROOT/sbin
			mkdir -p $INSTROOT/boot
			remauspack $INSTROOT lilo 
		fi
	fi
	# Generiere lilo.conf.tmp
	cat << EOF > $INSTROOT$LILOCONFTMP
boot = $BOOTDEVICE
compact
install = /boot/boot.b
message = /boot/message
prompt
image = $BOOTKERNEL
        label = linux
EOF
	if [ "$DOSDEVICE" != "" ]; then
		cat << EOF > $MSG
Wollen Sie im Bootmen auch die Mglichkeit haben, alternativ
von Ihrer DOS Partition $DOSDEVICE booten zu knnen ?
EOF
		Askyesno -default "j"
		if [ "$ANSWER" = "j" ]; then
			echo "other = $DOSDEVICE" >> $INSTROOT$LILOCONFTMP
			echo "table = `echo $DOSDEVICE | cut -c 1-8` " >> $INSTROOT$LILOCONFTMP
			echo "label = dos" >> $INSTROOT$LILOCONFTMP
		fi
	fi
	cat << EOF > $MSG

Ihre LILO Konfiguration sieht nun wie folgt aus:
------------------------------------------------
EOF
	cat $INSTROOT$LILOCONFTMP >> $MSG
	cat << EOF >> $MSG

Sind Sie mit dieser Konfiguration einverstanden ?
EOF
	Askyesno
	if [ "$ANSWER" != "j" ]; then
		# Nicht einverstanden
		return 1
	else
		# Einverstanden
		if [ "$BOOTMODE" = "unknown" ]; then
			return 1
		fi
		LogMsg -d "LILO wird auf $BOOTDEVICE installiert. "
		if [ "$BOOTMODE" = "Floppy" ]; then
			cat << EOF >> $MSG
Bitte legen Sie die Diskette ein, die Ihre knftige
LILO Bootdiskette werden soll.
Diese Diskette mu formatiert sein und der Schreibschutz
mu entfernt sein

Drcken Sie dann die Eingabetaste
EOF
			Seen
		else
			# BOOTMODE ist Harddisk, ALternate oder Master
			BOOTSECT=`echo $BOOTDEVICE | cut -c6-10`
			cat << EOF >> $MSG
Das Script legt ein Sicherheitskopie des Bootsektor von $BOOTDEVICE an.
Um diesen Bootsektor wieder zu restaurieren, knnen Sie unter Linux
den Befehl "dd if=/boot/bootsect.$BOOTSECT of=$BOOTDEVICE" benutzen
EOF
			Seen
			if [ "$BOOTMODE" = "Master" ]; then
				LogMsg 'oder unter DOS den Befehl "FDISK /MBR", wobei dieser DOS Befehl'
				LogMsg 'nur im letzten Notfall benutzt werden sollte. '
			fi
			dd if=$BOOTDEVICE of=/boot/bootsect.$BOOTSECT bs=512 count=1 &> /dev/null
		fi
		LogMsg "Installiere LILO auf $BOOTDEVICE ..."
		ShowInfo
		if [ "$INSTROOT" = "" ]; then
			$LILO -C $LILOCONFTMP > /dev/null 2>&1
		else
			$LILO -C $LILOCONFTMP -r $INSTROOT > /dev/null 2>&1
		fi
		if [ "$BOOTMODE" = "Harddisk" -o "$BOOTMODE" = "Alternate" ]; then
			# aktiviere die entsprechende Partition 
			# zum Booten
			# Geht das auch mit OS/2 Bootmanager gut ?
			PARTITION="`echo $BOOTDEVICE | cut -c 9`"
			DoLog -d "Setze Partition $PARTITION auf $BOOTBASE als bootbare Partition ..."
			ShowInfo
			$ACTIVATE $BOOTBASE $PARTITION
		fi
		if [ "$BOOTMODE" = "Harddisk" ]; then
			DoLog -d "Die Festplatte ist nun zum Booten konfiguriert"
		elif [ "$BOOTMODE" = "Floppy" ]; then
			DoLog -d "Die Floppy ist nun zum Booten konfiguriert"
		fi
		Seen
	fi
}
	
Bootdisksetup()
{
	GetBootparams || return 1
	GetBootkernel
	if [ "$BOOTKERNEL" = "" ]; then
		return 1
	fi
	SetBootparams $BOOTKERNEL || return 1
	while [ 1 ]; do
		umount /mnt > /dev/null 2>&1
		cat << EOF > $MSG

Wir bentigen nun zum Erstellen einer Bootdiskette eine leere und
formatierte Diskette. Legen Sie diese in Ihr Boot-Laufwerk.
Sollten Sie nur eine unformatierte Diskette zur Hand haben, so geben
Sie \"format\" ein, sonst einfach nur die Eingabetaste drcken.
Wollen Sie keine Bootdisk erstellen, so geben Sie \"n\" ein.

Eingabe:
EOF
		Askstring -emptyvalid
	
		if [ "$STRING" = "n" ]; then
			INSTALLCOMPLETE=nobootdisk
			return 0
		fi
		if [ "$STRING" != "" ]; then
			# Low level formatieren
			LogMsg "Formatiere Diskette. Bitte warten ..."
			Message
			if [ "$BOOTDEVICE" = "/dev/fd0" ]; then
				BOOTDEVICE=/dev/fd0H1440
			fi
			if [ -f /sbin/fdformat.gz ]; then
				gzip -d /sbin/fdformat.gz
			fi
			fdformat $BOOTDEVICE
			if [ $? != 0 ]; then
				echo "Probleme beim Erstellen der Bootdiskette !" > /tmp/.error
				Error
				continue 
			fi
		fi
		if [ -f /bin/dd.gz ]; then
			gzip -d /bin/dd.gz
		fi
		LogMsg "Kopiere $BOOTKERNEL nach $BOOTDEVICE. Bitte warten ..."
		Message
		dd if=$BOOTKERNEL of=$BOOTDEVICE
		if [ $? != 0 ]; then 
			echo "Probleme beim Erstellen der Bootdiskette !" > /tmp/.error
			Error
			continue 
		fi
		break
	done
	return 0
}

GetBootkernel()
{
	# Choose the right Bootkernel
	while [ 1 ]; do
		echo $CLEAR
		cat << EOF > $MSG

           Auswahl des Bootkernels 

  1   normal (Minimum an Treibern, aber sicherste Lsung)
  2   tapecd (TAPE und CD Untersttzung)
  3   net    (Netzwerk Untersttzung)
  4   full   (Alle Treiber. Langsam aber vollstndig)
  e   eigener Bootkernel (z.B. /usr/src/linux/zImage)
  i1  Informationen zum Bootkernel normal
  i2  Informationen zum Bootkernel tapecd
  i3  Informationen zum Bootkernel net
  i4  Informationen zum Bootkernel full

  0   keinen Bootkernel auswhlen

EOF
		DoLog "Bitte whlen Sie (1/2/3/4/e/i1/i2/i3/i4) "
		Askstring
		case $STRING in
		0)
			BOOTKERNEL=""
			return 1;;
		1)
			BOOTKERNEL=/vmlinuz.norm
			;;
		2)
			BOOTKERNEL=/vmlinuz.tape
			;;
		3)
			BOOTKERNEL=/vmlinuz.net
			;;
		4)
			BOOTKERNEL=/vmlinuz.full
			;;
		e)
			USEGOLGEN=false
			cat << EOF > $MSG

Bitte geben Sie Ihren Bootkernel an (mit vollstndigem Pfad)

Ihr Kernel:

EOF
			Askstring
			BOOTKERNEL=$STRING
			;;
		i1)
			cat /boot/WHATSIN.norm | PAGER
			Seen
			continue
			;;
		i2)
			cat /boot/WHATSIN.tape | $PAGER
			Seen
			continue
			;;
		i3)
			cat /boot/WHATSIN.net | $PAGER
			Seen
			continue
			;;
		i4)
			cat /boot/WHATSIN.full | $PAGER
			Seen
			continue
			;;
		*)
			echo "falsche Eingabe !" > $ERRMSG
			Error
			continue
			;;
		esac
		if [ -f $BOOTKERNEL ]; then
			export BOOTKERNEL
			break
		else
			echo "Habe keinen Bootkernel $BOOTKERNEL gefunden !" > $ERRMSG
			Error
		fi
	done
	# Der Rest ist alt, deshalb springen wir hier zurck ...
	return 0
	
	# Wir suchen nach Platz fr die Kopie ...
	SPACEPATH=/tmp
	while [ 1 ]; do
		if [ ! -d $SPACEPATH ]; then
			echo "ungltiger Pfad !"
		else	
			TESTSPACE=" `df $SPACEPATH | fgrep "/" | cut -c 38-45 ` "
			TESTSPACE=" ` expr $TESTSPACE \* 1024 ` "
			debug "Gre des gewhlten Kernel $BOOTKERNEL : `filesize $BOOTKERNEL` "
			debug "Freier Platz in $SPACEPATH : $TESTSPACE"
			if [ " $TESTSPACE " -gt " `filesize $BOOTKERNEL` " ]; then
				debug "ok, kopiere nach $SPACEPATH/vmlinuz.tmp"
				cp -a $BOOTKERNEL $SPACEPATH/vmlinuz.tmp
				export BOOTKERNEL=$SPACEPATH/vmlinuz.tmp
				SetBootparams $BOOTKERNEL
				return 0
			else
				debug "zu wenig Platz :-( "
			fi	
			if [ "$SPACEPATH" = "/tmp" -a "$INSTROOT" != "/" -a "$INSTROOT" != "" ]; then
				SPACEPATH=$INSTROOT/tmp
				continue
			fi
		fi
		echo
		echo "Wohin kann ich eine temporre Kopie schreiben ?"
		echo
		echo "Geben Sie den Pfad an"
		echo "oder \"#\", wenn keine Kopie erzeugt werden soll"
		echo "oder nur die Eingabetaste zum abbrechen"
		read SPACEPATH
		if [ "$SPACEPATH" = "" ]; then
			return 1
		elif [ "$SPACEPATH" = "#" ]; then
			SPACEPATH=""
			break
		fi
	done
}

SetBootparams()
{
	if [ $# = 0 ]; then
		echo "Kein Kernel an SetBootparams bergeben !" > /tmp/.error
		Error
	fi
	# Bootparameter anpassen
	rdev $1 $ROOTDEVICE
	rdev -R $1 1
	rdev -r $1 0
	rdev -v $1 -1

	if [ "$EXPERT" != "" ]; then
		DoLog -d "Wollen Sie den Video-Modus voreingestellt haben "
		Askyesno
		if [ "$ANSWER" = "j" ]; then
			cat << EOF > $MSG

Wenn Sie die mitgelieferte Installationsanleitung
befolgt haben, sollten Sie sich die fr Ihre
Grafikkarte mglichen Videomodi nach dem booten
notiert haben. Geben Sie nun die gewnschte
Schlsselzahl ein. Bei et4000 Karten empfehlen
wir \"3\". Wollen Sie jedesmal beim booten die
Auswahlmglichkeit haben, so whlen Sie \"-3\".
Sind Sie unsicher, so whlen Sie \"-1\", was
Standard 80x25 bedeutet und sicher funktioniert.

Welche Schlsselzahl 

EOF
			Askstring
			VGAMODE=$STRING;
			DoLog -d "Zur Sicherheit: Ist $VGAMODE als Video-Modus richtig ? "
			Askyesno -default j
			if [ "$ANSWER" = "j" ]; then
				rdev -v $1 $VGAMODE
				break
			fi
		else
			rdev -v $1 -3
			return 0
		fi
	fi
}

TestPrimary()
{
	# test if $1 is a primary partition
	dummy=`echo $1 | cut -c 9-10 `
	if [ $dummy -lt 5 ]; then
		# test if not an extended Partition ...
		dummy=`fdisk -l 2>&1 | fgrep "$1" | cut -c 49-50`
		if [ "$dummy" != " 5" -a "$dummy" != "5" ]; then
			export PRIMPART=true
			return 0
		fi
	fi
	export PRIMPART=false
	return 1
}

GetBootdevice()
{
	if [ "$BOOTMODE" = "Floppy" ]; then
		# knnte man das eventuell automatisch ermitteln ?
		while [ 1 ]; do
			cat << EOF > $MSG

Bitte geben Sie an, von welchem Typ Ihr 1. Floppylaufwerk ist
 1  - bei 1.44 MB
 2  - bei 1.2 MB

Welcher Typ (1/2)

EOF
			Askstring
			FLOPPYA=$STRING
			if [ "$FLOPPYA" = "1" ]; then
				FLOPPYA="/dev/fd0H1440"
				BOOTDEVICE=$FLOPPYA
				return 0
			elif [ "$FLOPPYA" = "2" ]; then
				FLOPPYA="/dev/fd0h1200"
				BOOTDEVICE=$FLOPPYA
				return 0
			else
				LogErr -new "falsche Eingabe !"
				Error
				continue
			fi
		done
	else
		# BOOTMODE="Harddisk"
		# nicht Floppy, also Festplatte ;-)
		# LILO normalerweise auf der Rootpartition installieren
		BOOTDEVICE=$ROOTDEVICE
		BOOTBASE=`echo $BOOTDEVICE | cut -c 1-8`

		# We try to check for a valid Bootpartition
		cat << EOF > $MSG

LILO wird normalerweise im Bootsektor Ihrer Rootpartition installiert.
Dies funktioniert aber nur, wenn die Rootpartition auf Ihrer ersten
Festplatte $FIRSTDISK liegt.

EOF
		if [ "$BOOTBASE" = "$FIRSTDISK" ]; then
			DoLog "Diese Bedingung ist erfllt."
			TestPrimary $BOOTDEVICE
			if [ $? = 0 ]; then
				BOOTMODE="Harddisk"
				BOOTBASE=$FIRSTDISK
				return 0
			else
				DoLog "Aber $BOOTDEVICE ist keine Primary-Partition, sondern liegt in"
				DoLog "einer Extended-Partition."
			fi
		else
			DoLog "Ihre Rootpartition $ROOTDEVICE liegt aber nicht auf der ersten Festplatte !"
		fi
		cat << EOF >> $MSG
Trotzdem besteht noch die Mglichkeit, LILO auf Festplatte zu installieren:
- LILO auf dem Master Boot Record der ersten Festplatte installieren.
EOF
		# test if there is a Linux Partition on the first disk
		rm -f /tmp/candidats
		fdisk -l 2>&1 | fgrep "$FIRSTDISK" | fgrep "Linux native" | cut -c 1-10 > /tmp/candidats
		dummy=`cat /tmp/candidats`
		if [ "$dummy" != "" ]; then
			rm -f /tmp/candidatsok
			for i in `cat /tmp/candidats` ; do
				# test if these are primary partitions
				TestPrimary $i
				if [ $? = 0 ]; then
					DoLog -n "- LILO im Bootsektor der Linuxpartition $i installieren."
					echo "$i" >> /tmp/candidatsok
				fi
			done
			mv /tmp/candidatsok /tmp/candidats
			for i in `cat /tmp/candidats` ; do
				fdisk -l 2>&1 | fgrep "$i" >> $MSG
				
				DoLog "Mchten Sie LILO im Bootsektor der Partition $i installieren "
				Askyesno
				if [ "$ANSWER" = "j" ]; then
					rm -f /tmp/candidats
					BOOTMODE="Alternate"
					BOOTDEVICE=$i
					BOOTBASE=$FIRSTDISK
					return 0
				fi
			done
		fi
		DoLog "Mchten Sie LILO im Master Boot Record (MBR) von Ihrer"
		DoLog "ersten Festplatte $FIRSTDISK installieren ?"
		Askyesno
		if [ "$ANSWER" = "j" ]; then
			BOOTMODE="Master"
			BOOTDEVICE=$FIRSTDISK
			BOOTBASE=$FIRSTDISK
			return 0
		fi
	fi
	LogErr "Dann kann LILO leider nicht auf Festplatte installiert werden ..."
	Error
	return 1
}

GetBootparams()
{
	# Get the needed bootparams
	while [ 1 ]; do
		Partdisplay > $MSG
		cat << EOF >> $MSG

Auswahl der Rootpartition
-------------------------

EOF
		DoLog "Geben Sie den Devicenamen Ihrer Rootpartition an "
		Askstring -default $CURRDEVICE
		# Sorry, but we don't check that yet
		ROOTDEVICE=$STRING

		# Try to figure out the appriopriate bootdevice
		GetBootdevice || return 1

		# alle ntigen Angaben vorhanden
		DoLog "Ist boot=$BOOTDEVICE, root=$ROOTDEVICE korrekt "
		Askyesno
		if [ "$ANSWER" = "j" ]; then
			export BOOTDEVICE ROOTDEVICE
			return 0
		fi
	done
}

Bootsetup()
{
	while [ 1 ]; do
		echo $CLEAR
		cat << EOF > $MSG

           $MBOOTHEAD 

  1   $MPARTDISPLAY
  2   $MBOOTLILOHD
  3   $MBOOTLILOFD
  4   $MBOOTLILOMULTI
  5   $MBOOTFD
  6   $MBOOTREPAIR

  0   $MBOOTLEAVE

EOF
		DoLog "Whlen Sie (0/1/2/3/4/5/6): "
		Askstring
		echo $CLEAR
		case $STRING in
			0)
				return 0;;
			1)
				Partdisplay > $MSG
				Seen;;
			2)
				BOOTMODE="Harddisk"
				Lilosetup;;
			3)
				BOOTMODE="Floppy"
				BOOTDEVICE=/dev/fd0H1440
				Lilosetup;;
			4)
				BOOTMODE="Floppy"
				BOOTDEVICE=/dev/fd0H1440
				Firstsetup;;
			5)
				BOOTMODE="Floppy"
				BOOTDEVICE=/dev/fd0H1440
				Bootdisksetup;;
			6)
				LogMsg "nicht in der Beta-Version verfgbar ..." 
				Seen;;
			*)
				LogErr "falsche Eingabe !" 
				Error;;
		esac
	done
}

Firstsetup()
{
	while [ 1 ]; do
		BOOTDEVICE=/dev/fd0H1440
		# Golden Bootdisk mounten
		#
		MountGoldenboot || return 1
		GetGoldenkernel || return 1
		#
		umount /mnt

		cat << EOF > $MSG

Bitte nehmen Sie die Golden Bootdisk aus Ihrem Laufwerk
und legen Sie dann die Diskette ein, die Ihre knftige 
Bootdiskette werden soll.

Diese Diskette darf NICHT schreibgeschtzt sein !

Drcken Sie dann die Eingabetaste

EOF
		Message
		read dummy

		PrepareDisk
	
cat << EOF > $MSG	

Mounte Diskette 

EOF
		Message
		mount -t minix $BOOTDEVICE $MOUNTPOINT 2>&1 > /dev/null 
		if [ $? != 0 ]; then
			echo "Fehler beim Mounten der Diskette." > /tmp/.error
			Error
			continue
		fi

		echo "Kopiere die Kernel auf die Multibootdisk" > $MSG
		echo " " >> $MSG
		echo "           Bitte warten Sie ...  "  >> $MSG
		Message

	
		# Kernel auf Diskette kopieren
		for i in vmlinuz.norm vmlinuz.tape vmlinuz.net vmlinuz.full ; do
			cp -a $INSTROOT/$i $MOUNTPOINT
		done
	
		mkdir -p $MOUNTPOINT/boot
		mkdir -p $MOUNTPOINT/etc
		mkdir -p $MOUNTPOINT/etc/lilo
		mkdir -p $MOUNTPOINT/dev
		
		mknod -m 666 $MOUNTPOINT/dev/fd0 b 2 0
		mknod -m 666 $MOUNTPOINT/dev/fd0H1440 b 2 28
		mknod -m 666 $MOUNTPOINT/dev/fd0h1200 b 2 8
		cp -a $LILOBOOTB $MOUNTPOINT/$LILOBOOTB
	
		GenericConfig
		GenericMessage
	
		sync
		cat << EOF > $MSG

Installiere LILO auf Diskette

     Bitte warten Sie ...

EOF
		Message
	
		$LILO -C $LILOCONF -r $MOUNTPOINT > /dev/null 2>&1
		if [ $? != 0 ]; then
			echo "Probleme bei der Installation von LILO." > /tmp/.error
			Error
			continue
		fi
		sync
		umount $MOUNTPOINT
echo $CLEAR
cat << EOF > $MSG
Glckwunsch ! Ihre Bootdiskette wurde erfolgreich konfiguriert.
Bitte notieren Sie sich die nun folgenden Erklrungen !
Entnehmen Sie die Bootdiskette und aktivieren Sie den Schreibschutz.
Danach mssen Sie die Diskette wieder einlegen, bevor Sie neu booten.
Beim Booten (genauer gesagt beim LILO Bootprompt) werden Ihnen die
mglichen Bootparameter aufgelistet (siehe Installationsanleitung)
und wenn Sie die <TAB> Taste drcken, werden Ihnen die folgenden
Kernel zur Auswahl gegeben:
normal enthlt nur die ntigsten Treiber und sollte immer bootbar sein
net    = normal + Treiber fr alle Netzwerkkarten + nfs-Dateisystem
tapecd = normal + Treiber fr CD-ROM u. Streamer + iso9660 Dateisystem
full   enthlt alle Treiber und ist sehr gro und langsam.
Falls es Probleme gibt, knnen Sie eventuell noch einen oder mehrere
der Bootparameter nach dem Kernelnamen zustzlich bergeben.
Beispiel: net ether=12,0x300,0,0,eth0 
Im Normalfall bentigen Sie die zustzlichen Parameter nicht.
Drcken Sie nun die Eingabetaste
EOF
		Message
		read dummy
		break
	done
}
	

#
# Main
#

#
# Parsing Options
#

while [ 0 ]; do
        if [ $# -gt 0 -a "$1" = "-debug" ]; then
                DEBUG="true"
                shift 1
                continue
        elif [ $# -gt 0 -a "$1" = "-expert" ]; then
                EXPERT="true"
                shift 1
                continue
        elif [ $# -gt 0 -a "$1" = "-simulate" ]; then
                SIMULATE="true"
                shift 1
                continue
        elif [ $# -gt 0 -a "$1" = "-usedialog" ]; then
                USEDIALOG="true"
                shift 1
                continue
        elif [ $# -gt 0 -a "$1" = "-verbose" ]; then
                VERBOSE="true"
                shift 1
                continue
        elif [ $# -gt 1 -a "$1" = "-bootdev" ]; then
                BOOTDEVICE=$2
                shift 2
                continue
        elif [ $# -gt 1 -a "$1" = "-rootdev" ]; then
                ROOTDEVICE=$2
                shift 2
                continue
        elif [ $# -gt 1 -a "$1" = "-instroot" ]; then
                INSTROOT=$2
                shift 2
                continue
	else
		break;
	fi
done

# 
# Some consistency checks
#

# Voraussetzungen prfen
FREESPACE=`df "$INSTROOT" | fgrep '/dev/' | cut -c 37-45`
if [ 1440 -gt $FREESPACE ]; then
	LogMsg -new "Warnung ! Zu wenig Platz auf $INSTROOT !"
	Message
fi
if [ -f /sbin/lilo -a -f /boot/boot.b ]; then
	# Use the new LILO
	LILO=/sbin/lilo
	LILOBOOTB=/boot/boot.b
elif [ -f /etc/lilo/lilo -a -f /etc/lilo/boot.b ]; then
	# Use the old LILO
	LILO=/etc/lilo/lilo
	LILOBOOTB=/etc/lilo/boot.b
else
	remauspack $INSTROOT lilo
	LILO=$INSTROOT/sbin/lilo

#	cat << EOF > /tmp/.error
# Problem
# Habe LILO weder in /sbin/lilo noch in /etc/lilo/lilo gefunden.
#Sie benutzen keine LST Version
#Gebe auf !
#
#EOF		
#	Error
#	Abort
#	exit 1
fi

# Is there a partition mounted on $INSTROOT (if specified) ?
#
if [ "$INSTROOT" != "" ]; then
	mount | fgrep "on $INSTROOT " > /dev/null 2>&1
	if [ $? != 0 ]; then
		LogErr "An $INSTROOT ist keine Partition gemountet "
		Error
		Abort
		exit 1
	fi
fi

# Do we have a DOS Partition ?
#
DOSDEVICE=
dosdrives=`fdisk -l 2>&1 | fgrep -c 'DOS' `
if [ "$dosdrives" -gt 0 ]; then
	fdisk -l 2>&1 | fgrep 'DOS' > $INSTROOT/dosdrives
	read dummy < $INSTROOT/dosdrives
	rm $INSTROOT/dosdrives
	DOSDEVICE=`echo "$dummy" | cut -d' ' -f 1 `
fi

# What is our current root device ?
#
CURRDEVICE=`rdev | cut -d' ' -f 1 `

# What is our first harddisk ?
FIRSTDISK=
# How many harddisks do we have ?
dummy=`fdisk -l 2>&1 | fgrep -c 'Disk' `
if [ "$dummy" = 1 ]; then
	# only one harddisk 
	FIRSTDISK=`fdisk -l 2>&1 | fgrep 'Disk' | cut -c 6-13 `
else
	# found two or more harddisks
	dummy=`fdisk -l 2>&1 | fgrep 'Disk' | fgrep "/dev/hda" `
	if [ $? = 0 ]; then
		# first disk ist AT-Bus, MFM oder ESDI
		FIRSTDISK=/dev/hda
	else
		dummy=`fdisk -l 2>&1 | fgrep 'Disk' | fgrep "/dev/sda" `
		if [ $? = 0 ]; then
			# a SCSI-only User. Happy man ! ;-)
			FIRSTDISK=/dev/sda
		else
			# should never reach this point. Use /dev/hda as default
			debug "FIRSTDISK konnte nicht automatisch ermittelt werden"
			debug "Whle FIRSTDISK=/dev/sda"
			FIRSTDISK=/dev/hda
		fi
	fi
fi

# First try to guess our new root device
#
if [ "$ROOTDEVICE" = "" ]; then
	if [ "$INSTROOT" != "" ]; then
		ROOTDEVICE=` mount | fgrep "on $INSTROOT " | cut -d' ' -f 1 `
	else
		ROOTDEVICE=$CURRDEVICE
	fi
fi

# Then try to guess our new boot device 
#
if [ "$BOOTDEVICE" = "" ]; then
	BOOTDEVICE=$ROOTDEVICE
fi

#
# Parsing Actions
#
BOOTMODE="unknown"
if [ $# = 0 ]; then
	Bootsetup && export BOOTOK=true
elif [ "$1" = '-help' ]; then
       	PrintUsage
	exit 1
elif [ "$1" = "-version" ]; then
	PrintVersion
	exit 0
elif [ "$1" = "-floppy" ]; then
	BOOTMODE="Floppy"
	Bootsetup && export BOOTOK=true
elif [ "$1" = "-harddisk" ]; then
	BOOTMODE="Harddisk"
	Lilosetup && export BOOTOK=true
elif [ "$1" = "-install" ]; then
	BOOTMODE="Floppy"
	Firstsetup && export BOOTOK=true
else
	PrintUsage
	exit 1
fi

