#!/bin/sh
#
# Make BootDisk
#
# May 2004, Aleksey Barabanov <alekseybb@mail.ru>
#
# ##################################################### setup defaults

VER="ver. 1.0.0"
DEBUG=""
NOCLEAN=""
DRYRUN=""

# image file
INAME=disk.iso

# root for temporary dirs and files
TROOT=/tmp

# initial disk size
SIZE=1440
DSECT=18

# devices
DEV=/dev/loop
NULL=/dev/null
ZERO=/dev/zero

# kernel list
KLIST="/boot/vmlinuz /boot/initrd"

# reserved for lilo map
DPAD=20480

# iso identifications
ANAME="Aleksey_Barabanov"
AMAIL="alekseybb@mail.ru"
ATITLE="Rescue"
VNAME="BOOT"

#
ROOT=""
APPEND=""
KERNEL=""
INITRD=""
MEMTEST="/boot/memtest.bin"

# ##################################################### get options
usage()
{
cat <<EOT

Make BootDisk $VER

Usage: `basename $0` [options]

Options:
  --noclean
    Dont remove temporary files
  --compile
    Make command list insted executing
  --iso <filename>
    Set output filename
  --tmp <dirname>
    Set root directory for temporary files
  --root <rootdev>
    Set root device for boot configuration
  --append <option list>
    Set option list for kernel

EOT
}

while [ $# -gt 0 ] ; do
  case $1 in
    --noclean)
      NOCLEAN="1"
      ;;
    --compile)
      DRYRUN="1"
      ;;
    --append)
      shift
      APPEND=$1
      ;;
    --root)
      shift
      ROOT=$1
      ;;
    --iso)
      shift
      INAME=$1
      ;;
    --tmp)
      shift
      TROOT=$1
      ;;
    *)
      echo "Bad options."
      usage
      exit 1
      ;;
  esac
  shift
done

# temporary dirs and files
DNAME=$TROOT/mkbootdisk-disk.img-$$
DMOUNT=$TROOT/mkbootdisk-$$

# ##################################################### setup environment

# Readlink is not present on some older distributions: emulate it.
do_readlink()
{
  local path=$1 ll
  ll="$(LC_ALL=C ls -l "$path" 2>&1)"
  echo "${ll/* -> }"
}
RLINK=`which readlink`|| RLINK=do_readlink

do_realpath()
{
  i=`dirname $1`
  j=`$RLINK $1`
  if [ "$j" == "" ] ; then
    echo $1
  else
    if echo $j | $GREP -e "^\/" >$NULL ; then
      echo "$j"
    else
      echo "$i/$j"
    fi
  fi
}

# utilities
ERRMES=""
DD=`which dd`         || ERRMES=dd
LO=`which losetup`    || ERRMES=losetup
E2FS=`which mke2fs`   || ERRMES=mke2fs
T2FS=`which tune2fs`  || ERRMES=tune2fs
GREP=`which grep`     || ERRMES=grep
HEAD=`which head`     || ERRMES=head
AWK=`which awk`       || ERRMES=awk
STAT=`which stat`     || ERRMES=stat
LILO=`which lilo`     || ERRMES=lilo
ECHO=`which echo`     || ERRMES=echo
MOUNT=`which mount`   || ERRMES=mount
UMOUNT=`which umount` || ERRMES=umount
MKDIR=`which mkdir`   || ERRMES=mkdir
MKISO=`which mkisofs` || ERRMES=mkisofs
CP=`which cp`         || ERRMES=cp
CAT=`which cat`       || ERRMES=cat
RM=`which rm`         || ERRMES=rm
KILL=`which kill`     || ERRMES=kill

if [ "$ERRMES" != "" ]; then
  echo -e "Not found \"$ERRMES\". Abort"
  exit 1
fi

# ##################################################### get local parameters

# get root device fron original lilo.conf
OLILO=/etc/lilo.conf
if [ ! -r $OLILO ]; then
  $ECHO -e "Not found \"$OLILO\". Abort"
  exit 1
fi

# looking for default section in lilo.conf
LILOIMG=""
LILOLABEL=""
LILORD=""
LILOAPP=""
LILOROOT=""
DEFLILO=""
while read i ; do
  if $ECHO $i | $GREP -v ^# | $GREP -e "=" >$NULL ; then
    op=`$ECHO $i | $AWK -F= '{print $1}'`
    op=`$ECHO $op`
    case $op in
      default)
        DEFLILO=`$ECHO $i | $AWK -F= '{print $2}'`
	DEFLILO=`$ECHO $DEFLILO`
	;;
      label)
        LILOLABEL=`$ECHO $i | $AWK -F= '{print $2}'`
	LILOLABEL=`$ECHO $LILOLABEL`
	;;
      root)
        LILOROOT=`$ECHO $i | $AWK -F= '{print $2}'`
	LILOROOT=`$ECHO $LILOROOT`
	;;
      initrd)
        LILORD=`$ECHO $i | $AWK -F= '{print $2}'`
	LILORD=`$ECHO $LILORD`
	;;
      append)
        LILOAPP=`$ECHO $i | $AWK -F\" '{print $2}'`
	LILOAPP=`$ECHO $LILOAPP`
	;;
      image)
        if [ "$LILOLABEL" != "$DEFLILO" ] ; then
          LILOIMG=`$ECHO $i | $AWK -F= '{print $2}'`
	  LILOIMG=`$ECHO $LILOIMG`
	else
	  break
	fi
        ;;
    esac
  fi
done < $OLILO

( [ "$LILOIMG" == "" ] || [ "$LILOROOT" == "" ] ) && { $ECHO "Error: cant found default in $OLILO"; exit 1;}
[ "$ROOT"   == "" ] && ROOT=$LILOROOT
[ "$KERNEL" == "" ] && KERNEL=$LILOIMG
[ "$INITRD" == "" ] && INITRD=$LILORD
[ "$APPEND" == "" ] && APPEND=$LILOAPP

SERIAL=""
[ "$APPEND" != "" ] && {
  SERIAL=`$ECHO $APPEND | $AWK 'BEGIN{FS="console=ttyS"}{print $2}' | $AWK '{print $1}'`
  }

[ -h $KERNEL ] && KERNEL=`do_realpath $KERNEL`
[ -h $INITRD ] && INITRD=`do_realpath $INITRD`
KLIST="$KERNEL $INITRD"

[ "$MEMTEST" != "" ] && [ -r $MEMTEST ] && KLIST="$KLIST $MEMTEST"

# calc space
n=0
for i in $KLIST ; do
  k=`$STAT -c "%s" $i`
  n=`expr $n + $k`
done
n=`expr \( $n + $DPAD \) / 1024`

# choose disk size
if [ $n -gt $SIZE ]; then
  SIZE=1680
  DSECT=21
  if [ $n -gt $SIZE ]; then
    SIZE=2880
    DSECT=36
    if [ $n -gt $SIZE ]; then
      $ECHO -e "Kernel too big \"$n\". Abort"
      exit 1
    fi
  fi
fi

# choose loop device
n=0
while [ "`$MOUNT | $GREP ${DEV}${n}`" != "" ] ; do
  n=`expr $n + 1`
done
DEV="${DEV}${n}"

# ##################################################### setup compiler

do_cat()
{
  T=$1
  [ ! -t 0 ] && {
    if [ -n "$DRYRUN" ] ; then
      ## compile
      echo "cat >>$T <<EOT"
      cat
      echo EOT
    else
      ## instant
      cat >>$T
    fi
    }
}
SCAT=do_cat

do_echo()
{
  T=$1
  shift
  if [ -n "$DRYRUN" ] ; then
    ## compile
    echo "echo $* >>$T"
  else
    ## instant
    $ECHO $* >>$T
  fi
}
SECHO=do_echo

[ -n "$DRYRUN" ] && {
  echo "#!/bin/sh"
  echo "# make bootdisk $VER"
  echo "# compiled at `date`"
  echo "#-----------------------"
  DD="echo $DD"
  LO="echo $LO"
  E2FS="echo $E2FS"
  T2FS="echo $T2FS"
  MKDIR="echo $MKDIR"
  MOUNT="echo $MOUNT"
  CP="echo $CP"
  ECHO="echo $ECHO"
  CAT="echo $CAT"
  LILO="echo $LILO"
  UMOUNT="echo $UMOUNT"
  MKISO="echo $MKISO"
  RM="echo $RM"
  }

# ##################################################### make boot disk

# build zero image
$DD if=$ZERO of=$DNAME bs=1024 count=$SIZE || { echo "Error: cant make zero image"; exit 1;}

# cleaning up temporary resources
cleanup()
{
  [ "$NOCLEAN" != "" ] || {
    if [ -n "$DRYRUN" ] ; then
      #$UMOUNT $DMOUNT
      $RM -rf $DMOUNT
      $LO -d $DEV
      $RM -rf $DNAME
    else
      $ECHO "Cleaning up."
      $MOUNT | $GREP ^$DEV >$NULL && { $ECHO "Unmount image"; $UMOUNT $DMOUNT; }
      [ -d $DMOUNT ] && { $ECHO "Remove mount dir"; $RM -rf $DMOUNT; }
      $LO $DEV | $GREP ^$DEV >$NULL && { $ECHO "Detach loop"; $LO -d $DEV; }
      [ -r $DNAME ] && { $ECHO "Remove disk image"; $RM -rf $DNAME; }
    fi
    }
}

# make tarp for clean
after_error()
{
  cleanup
  $ECHO "Abort."
  exit 1
}
[ -n "$DRYRUN" ] || trap after_error 1 2 3 15

#
$LO $DEV $DNAME || { $ECHO "Error: cant bind loop";  $KILL -INT $$;}
$E2FS $DEV || { $ECHO "Error: cant make ext2"; $KILL -INT $$;}
$T2FS -i 0 -c 0 $DEV || { $ECHO "Error: cant tune ext2"; $KILL -INT $$;}
$MKDIR $DMOUNT || { $ECHO -e "Error: cant make \"$DMOUNT\""; $KILL -INT $$;}
$MOUNT -t ext2 $DEV $DMOUNT || { $ECHO "Error: cant mount \"$DEV\""; $KILL -INT $$;}

# copy files
for i in $KLIST ; do
  j=`basename $i`
  $CP -va $i $DMOUNT/$j || { $ECHO "Error: cant copy \"$i\""; $KILL -INT $$;}
done

# make bootstrap config
[ "$SERIAL" != "" ] && $SECHO $DMOUNT/lilo.conf "serial = $SERIAL"
$SCAT $DMOUNT/lilo.conf <<EOT
boot = $DEV
disk = $DEV
  bios = 0x00
  sectors = $DSECT
  heads = 2
  cylinders = 80
map = $DMOUNT/map
read-only
compact
vga = normal
menu-scheme = Wg:kw:Wg:Wg
prompt
timeout	= 80
default = linux
image  = $DMOUNT/`basename $KERNEL`
initrd = $DMOUNT/`basename $INITRD`
root   = $ROOT
label  = linux
EOT
[ "$APPEND" != "" ] && {
  $SCAT $DMOUNT/lilo.conf <<EOT
append = "$APPEND"
EOT
  }

# init-shell section
APPEND="$APPEND init=/bin/sh"
$SCAT $DMOUNT/lilo.conf <<EOT
image  = $DMOUNT/`basename $KERNEL`
initrd = $DMOUNT/`basename $INITRD`
root   = $ROOT
label  = shell
append = "$APPEND"
EOT

# memtest section
[ "$MEMTEST" != "" ] && {
  $SCAT $DMOUNT/lilo.conf <<EOT
image  = $DMOUNT/`basename $MEMTEST`
label  = memtest
EOT
  }

[ -n "$DRYRUN" ] || {
  [ -r $DMOUNT/lilo.conf ] || { $ECHO "Error: cant write lilo.conf"; $KILL -INT $$;}
  }

# make boot record and map
$LILO -v -C $DMOUNT/lilo.conf || { echo "Error: lilo failure"; kill -INT $$;}
$UMOUNT $DMOUNT || { echo "Error: cant unmount"; kill -INT $$;}

# ##################################################### make iso image

# make iso root
$CP $DNAME $DMOUNT/boot.img || { echo -e "Error: cant copy \"$DNAME\""; kill -INT $$;}
$SCAT $DMOUNT/readme <<EOT
Linux Emergency BootDisk

Root FS $ROOT
Kernel parameters "$APPEND"
Build at `date`

$ANAME
$AMAIL
EOT

# make iso
$MKISO  -o $INAME \
	-b boot.img \
	-c boot.cat \
	-J -r \
	-p "$AMAIL" \
	-P "$ANAME" \
	-A "$ATITLE" \
	-V "$VNAME" \
	$DMOUNT || { echo "Error: cant make iso" ; kill -INT $$; }

[ -n "$DRYRUN" ] || trap 1 2 3 15
cleanup
$ECHO "Done."
exit
# ##################################################### done
# #####################################################