#!/bin/sh
<<@

LILO QUICK INSTALLATION
-----------------------

This installation script installs LILO and generates the configuration file
/etc/lilo/config. It uses safe defaults for most configuration options.
Please read the documentation (preferably the more complete LaTeX version,
doc.tex) before making changes to the configuration generated by QuickInst.

To run QuickInst, simply type

./QuickInst.old

If the normally used root partition is mounted below root (e.g. during
system installation), set the environment variable ROOT to the name of the
directory on which the root partition is mounted and run QuickInst, e.g.

ROOT=/root ./QuickInst.old

A subshell can be spawned at each prompt. Type  !  to get an interactive
shell that has to be left with  exit . Type  !command args ...  to execute
a command and immediately return to QuickInst.

QuickInst can only be used to install LILO on IDE (AT-BUS) or SCSI hard
disks. The LILO version must be 0.11 or later, the kernel should be 0.99pl12
or later. Owners of ST01/ST02 and Ultrastor SCSI adapters may have to create
a file /etc/lilo/disktab to describe the disk geometry.

WARNING: QuickInst may get confused if you're running it in a directory
	 that contains a mixture of old and new LILO distributions. To be
	 safe, always extract new LILO distributions in their own, new
	 directory.

------------- End of description. What follows is program code. -------------
@

CFG_SUFFIX=/etc/lilo
CFG_DIR=$ROOT$CFG_SUFFIX
CFG_FILE=$CFG_DIR/config
BOOT_SUFFIX=/etc/lilo
BOOT_DIR=$ROOT$BOOT_SUFFIX
SBIN_DIR=$ROOT/etc/lilo

locate()
{
    var=$1
    while shift && [ ! -z "$1" ]; do
	for p in `echo $PATH | sed 's/:/ /g'`; do
	    if [ -x $p/$1 ]; then
		eval $var=$p/$1
		return 0
	    fi
	done
    done
    return 1
}

probe()
{
    [ ! -z "`dd if=$1 bs=1 count=1 2>/dev/null | tr '\0' x`" ]
    return
}

bootflag()
{
    [ "XY" = "`(dd of=/dev/null bs=510 count=1; dd bs=2 count=1 |
      tr -c '\125\252' . | tr '\125\252' XY) <$1 2>/dev/null`" ]
    return
}

krnltype()
{
    if [ "YX" = "`(dd bs=2 count=1 | tr -c '\001\013' . | tr '\001\013' XY) \
      <$1 2>/dev/null`" ]; then
	echo compound
    else
	echo image
    fi
}

get()
{
    while true; do
	echo -n "$1 "
	if [ -z "$3" ]; then
	    echo -n "(no default) "
	else
	    echo -n "[$3] "
	fi
	read line
	line="`echo "$line" | sed 's/^ *\([^ ]\(\|.*[^ ]\)\) *$/\1/'`"
	if [ -z "$line" ]; then
	    if [ -z "$3" ]; then
		echo "No default, please specify a value."
		continue
	    fi
	    line=$3
	fi
	if [ "x$line" = "x!" ]; then
	    cat <<EOF

Starting a sub-shell. Type  exit  to return.

EOF
	    ${SHELL:-sh}
	    echo
	    continue
	fi
	if echo "$line" | grep -s '^!'; then
	    sh -c "`echo \"$line\" | sed 's/^!//'`"
	else
	    eval $2="$line"
	    break
	fi
    done
}

yesno()
{
    while true; do
	get "$1" line $2
	if echo "$line" | egrep -si '^y(|e(|s))$'; then
	    return 0
	fi
	if echo "$line" | egrep -si '^no?$'; then
	    return 1
	fi
	echo "YES or NO, please."
    done
}

echo
if [ $ROOT/etc/lilo = `pwd` ]; then
    cat <<EOF
You can't run QuickInst in /etc/lilo ! Please cd to the directory that
contains your LILO source files and try again.

EOF
    exit 1
fi

if id | grep -s 'uid=0('; then : ; else
    echo "You probably have to be root to install LILO."
    echo
    if yesno "Try to install LILO anyway ?" no; then : ; else
	echo
	exit 1
    fi
    echo
fi

badlib=""
if [ "`echo 'X(Y)' | sed 's/\(X\)(Y)/\1/'`" != "X" ]; then
    echo "Your sed doesn't behave like sed."
    badlib=y
fi
if [ "`echo 'X(Y)' | grep '^X(Y)'`" != "X(Y)" ]; then
    echo "Your grep doesn't behave like grep."
    badlib=y
fi
if [ "`echo 'X(Y)' | egrep '^(X)\(Y\)'`" != "X(Y)" ]; then
    echo "Your egrep doesn't behave like egrep."
    badlib=y
fi
if [ ! -z "$badlib" ]; then
    echo "Your libraries might be broken."
    echo
    exit 1
fi

cat <<EOF
QuickInst configures LILO and installs it on your hard disk. It should only be
used for first-time installations, _not_ to update or modify an existing
installation of LILO. It will _not_ generate a valid installation with versions
of LILO below 0.11.

The installation procedure can be interrupted by pressing ^C at any time. When
at a prompt, a sub-shell can be invoked with the exclamation mark.

EOF
if yesno "Continue ?" yes; then : ; else
    echo
    exit 0
fi
echo

replace=""
if [ -d $BOOT_DIR -a \( -f boot.b -o -f first.S \) ]; then
    cat <<EOF
A directory $BOOT_SUFFIX already exists. If you're installing a new version of
LILO now, QuickInst has to replace the old files with the new ones.

EOF
    if yesno "Replace old files ?" yes; then
	replace=y
    fi
    echo
fi

if [ -f $ROOT/etc/lilo/install -a ! -L $ROOT/etc/lilo/install -a \
  "$replace" != "y" ]; then
    cat <<EOF
/etc/lilo/install is a regular file and not a symbolic link. Unless some
special actions are necessary when updating maps, /etc/lilo/install should
be a link to /etc/lilo/lilo (see INCOMPAT for details).

EOF
    if yesno "Replace install by a link ?" yes; then
	ln -sf lilo $ROOT/etc/lilo/install
    fi
    echo
fi

echo
if [ ! -f $BOOT_DIR/boot.b -o ! -z "$replace" ]; then
    if [ ! -f boot.b ]; then
	if [ ! -f first.S ]; then
	    cat <<EOF
LILO is not installed and I don't know how to make it. Please cd to the
directory where your LILO source lives and try again.

EOF
	    exit 1
	fi
	if [ ! -f /usr/include/linux/config.h ]; then
	    cat <<EOF
The kernel header files appear to be missing. Please install them, then try
QuickInst again.

EOF
	    exit 1
	fi
	if [ ! -f /usr/include/linux/autoconf.h ]; then
	    cat <<EOF
(Creating dummy /usr/include/linux/autoconf.h)

EOF
	    touch /usr/include/linux/autoconf.h
	fi
	cat <<EOF
Making LILO ...

EOF
	if make -f Makefile.old; then : ; else exit; fi
	echo
    fi
    cat <<EOF
Installing LILO ...

EOF
    if make -f Makefile.old install; then : ; else exit; fi
    echo
fi

if [ ! -x $SBIN_DIR/lilo ]; then
    cat <<EOF
$SBIN_DIR/lilo is missing. Don't know how to proceed ...

EOF
    exit 1
fi

version="`$SBIN_DIR/lilo -V 2>/dev/null | sed 's/LILO version 0\.//'`"
if [ -z "$version" ]; then
    cat <<EOF
Incompatible version of LILO. Expecting 0.13 (or later), found 0.10 or older.

EOF
    exit 1
fi
if [ "$version" -lt 11 ]; then
    cat <<EOF
Incompatible version of LILO. Expecting 0.13 (or later), found 0.$version

EOF
    exit 1
fi

if [ ! -x ./activate ]; then
    cat <<EOF
activate  is not in the current directory. Please cd to your LILO source
directory and run QuickInst again.
EOF
fi

if [ ! -e $ROOT/etc/lilo/install ]; then
    ln -s lilo $ROOT/etc/lilo/install
fi

dev="`find /dev -type b -name '[hs]da' | sed 's,/[hs]da$,,;1q'`"
if [ -z "$dev" ]; then
    cat <<EOF
(Can't locate hda or sda device in /dev or in a subdirectory or it.
 Assuming disk devices live in /dev)
EOF
    dev="/dev"
else
    echo "(Disk devices live in $dev)"
fi
echo

echo "Generating $CFG_SUFFIX/config ..."

if [ -L $dev/hda ]; then
    cat <<EOF

$dev/hda is a symbolic link. Assuming your first disk is $dev/sda

EOF
    first=$dev/sda
else
    if probe $dev/hda; then
	first=$dev/hda
    else
	if probe $dev/sda; then
	    first=$dev/sda
	else
	    cat <<EOF

Unable to determine what your first disk is. (Tried $dev/hda
and $dev/sda, but none of them appears to exist.)
Sorry, this is a fatal error.

EOF
	    exit 1
	fi
    fi
fi
root=""
if locate path rootdev rdev setroot; then
    root=`$path | awk '{ print $1 }'`
    echo
    echo "(/ is mounted on $root)"
fi
boot=""
if echo $root | grep -s "^${first}[1-4]*\$"; then
    boot=$root
fi

cat <<EOF

Please specify the name of the device where the LILO boot sector should be
stored. (Suggested locations are the Linux root partition or the MBR of your
first drive).

EOF
while true; do
    get "Device name" inp $boot
    if echo "$inp" | egrep -s "^${first}\$|^${first}[1-4]\$"; then
	if probe "$inp"; then
	    boot=$inp
	    break
	else
	    cat <<EOF
No such device exists. Type  !ls $first[1-4]  for a list of
possible names.
EOF
	fi
    else
	cat <<EOF
This is not a valid device name. Try names like $first or
${first}1
EOF
    fi
done

if [ "$boot" = "$first" ]; then
    cat <<EOF

You are about to install LILO on your MBR. If there are other operating
systems on your hard disk, LILO will act as a boot manager for them. You
have to specify each operating system in your LILO configuration. (More
about this later.)
EOF
else
    if [ "`dd if=$first bs=1 count=4 skip=2 2>/dev/null | \
      tr -c 'LIO' '?'`" = "LILO" ]; then

	cat <<EOF

There appears to be a LILO boot sector on $first. Because you're
installing LILO's boot sector on a regular partition now, it is very
likely that the old boot sector will no longer start correctly. Unless
you're very sure of what you're doing, you should therefore replace it by
a "standard" MBR before attempting to boot from the hard disk. (E.g. use
MS-DOS 5.0's FDISK /MBR.)
EOF
    fi
fi

disk=`echo $boot | sed 's/[1-4]$//'`
oldboot=`./activate $disk 2>/dev/null`
newboot=""
if [ $boot != "$oldboot" -a ! -z "`echo "$boot" | sed 's|'$dev'/[sh]d.||'`" ];
  then
    echo
    echo "Currently active partition of $disk is $oldboot"
    if yesno "Change it to $boot ?"; then
	newboot=`echo $boot | sed 's,'$dev'/[sh]da,,'`
	cat <<EOF

Partition $newboot of $disk will be made active as soon as the LILO
installation is complete.
EOF
    else
	cat <<EOF

Please don't forget to configure the boot manager you are using to boot LILO
from $boot.
EOF
    fi
fi

kernel=""
for n in /vmlinuz /vmlinux /linux /Image /etc/Image; do
    if [ -f $ROOT/$n ]; then
	kernel=$n
	break
    fi
done

cat <<EOF

Please specify the name of the kernel image file you want to boot by default.

EOF
while true; do
    get "Default kernel" inp $kernel
    if [ -f "$ROOT$inp" ]; then
	if echo "$inp" | grep -s '^/'; then
	    kernel=$inp
	    break
	else
	    echo "Use only absolute path names, e.g. /linux"
	fi
    else
	echo "No such file."
    fi
done

cat <<EOF >$CFG_FILE.tmp
# LILO configuration created by QuickInst 0.14  `date | tr -s x ' '`

boot = $boot
compact
delay = 5	# optional, for systems that boot very quickly
vga = normal	# force sane state
ramdisk = 0	# paranoia setting
root = current	# use "current" root
`krnltype $kernel` = $kernel
EOF
if [ "`echo $kernel | sed 's,/\([^/]*\)$,\1,'`" != "linux" ]; then
    echo "  label = linux" >>$CFG_FILE.tmp
fi

echo
if yesno "Define additional kernels ?"; then
    default=""
    for n in $kernel.old /vmlinux.old /linux.old /Image.old /etc/Image.old; do
	if [ -f $ROOT/$n ]; then
	    default=$n
	    break
	fi
    done
    cat <<EOF

Specify the names of additional kernels now. Use "done" (without the quotes)
to stop adding kernels.

EOF
    while true; do
	get "Kernel" inp $default
	if [ done = "$inp" ]; then
	    break
	fi
	if echo "$inp" | grep -s '^/'; then
	    echo "`krnltype $inp` = $inp" >>$CFG_FILE.tmp
	    if [ ! -f $ROOT$inp ]; then
		echo "File doesn't exist now. - Making entry optional."
		echo "  optional" >>$CFG_FILE.tmp
	    fi
	else
	    echo "Use only absolute path names, e.g. /linux"
	fi
	default="done"
    done
fi

if [ "$boot" = "$first" ]; then
    cat <<EOF

If you want to boot other operating systems than Linux from your hard disk,
you should configure them now. LILO will take over the entire boot process,
so any currently installed partition switchers or boot managers will stop
to work. (If this scares you, just hit ^C and read the manual.)
EOF
fi

echo
if yesno "Define additional operating systems (e.g. MS-DOS) ?"; then
    cat <<EOF

Specify the names of devices that contain boot sectors of additional operating
systems now. You might want to run  fdisk  or  efdisk  to list the partition
table(s) of your hard disk(s) in order to obtain the device names. Use "done"
(without the quotes) to stop adding operating systems.

EOF
    default=""
    default_lbl=dos
    while true; do
	get "Device name" inp $default
	if [ done = "$inp" ]; then
	    break
	fi
	if echo "$inp" | grep -s '^'$dev'/[hs]d[ab][1-4]$'; then
	    if probe "$inp"; then
		if bootflag $inp; then
		    boot=$inp
		    (
			echo "other = $inp"
			echo -n "  table = "
			echo $inp | sed 's/[1-4]$//'
		    ) >>CFG_FILE.tmp
		    get "Label" inp $default_lbl
		    default_lbl=""
		    default="done"
		    echo "  label = $inp" >>$CFG_FILE.tmp
		else
		    echo "$inp does not have a valid boot signature."
		fi
	    else
		cat <<EOF
No such device exists. Type  !ls $dev/[hs]d[ab][1-4]  for a list of
possible names.
EOF
	    fi
	else
	    echo "Expecting names like $dev/hda1, $dev/sda3, etc."
	fi
    done
    if [ -z "$default_lbl" ]; then
	cat <<EOF

In order to choose the desired kernel or operating system, hold down a shift
key at boot time, when LILO displays "LILO", until the prompt "boot:" appears.
Then enter the label name. You can get a list of available names by pressing
[Tab] (at the boot prompt).
EOF
    fi
fi

if [ -f $CFG_FILE ]; then
    mv $CFG_FILE $CFG_FILE.old
fi
mv $CFG_FILE.tmp $CFG_FILE

cat <<EOF

Ready to install LILO's boot sector on your hard disk.
Type  !cat $CFG_FILE  if you want to check the configuration file.

EOF
if yesno "Install LILO now ?" yes; then
    echo
    outfile=${TMPDIR:-/tmp}/out$$
    errflag=${TMPDIR:-/tmp}/err$$
    if [ -f $errflag ]; then
	rm $errflag
    fi
    (
	if
	    $SBIN_DIR/lilo 2>&1
	then : ; else
	    touch $errflag
	fi
    ) | tee $outfile
    if [ -f $errflag ]; then
	rm $errflag
	if egrep -s 'geo_query_dev HDIO_|: Got bad geometry' <$outfile; then
	    cat <<EOF

LILO is unable to obtain geometry information for your SCSI disk. Please
create an $CFG_DIR/disktab file in which the necessary parameters are
described. See also section "Disk" parameter table" in the documentation.

EOF
	    exit
	fi
	cat <<EOF

Something went wrong. Verify your input and try to minimize the complexity of
the settings, e.g. by omitting additional kernels and operating systems.

EOF
	exit
    fi
    rm $outfile
    if [ ! -z "$newboot" ]; then
	./activate $disk $newboot
    fi
fi
echo
echo "Done."
echo
