#!/bin/sh
#
# bootcd2disk
#
# DISK=auto, we will build an boot partition with size defined in BOOTS
  
TODOY="-y"
TODO="" mm=0
IAHEAD="bootcd2disk"
ENV_IMAGEURL=""
VERBOSE=""
SCRIPT=""
CONFDIR="/etc/bootcd"
ONLYMOUNT=""
ONLYUNMOUNT=""
CHROOTDIR=""
COPYDEST="/mnt"
IGNORE=""
STDOUT=""
ROOT=""
ORIGINALDISKNAME=""

# function: usage
# get: $1 -- error string
usage()
{
  [ "$1" ] && echo  >&2 "$1"

  echo  >&2 " $(basename $0) copy a system running from bootcd to a disk."
  echo  >&2 " syntax:  -i           -- interactiv operation"
  echo  >&2 "          -v           -- be noisy"
  echo  >&2 "          -s           -- be silent and no interaction"
  echo  >&2 "          -c <confdir> -- use another configuration directory"
  echo  >&2 "          -url <url>   -- url from imageserver"
  echo  >&2 "                          (overwrite IMAGEURL and USEIMAGESERVER)"
  echo  >&2 "          -onlymount   -- only mount disks"
  echo  >&2 "          -onlyunmount -- only unmount disks"
  echo  >&2 "          -r <root>    -- debian root"
  echo  >&2 "          -o           -- use original disk names for only[un]mount"
  echo  >&2 "          -mkchroot <dir> -- bootcd will be copied to <dir>/chroot"
  echo  >&2 ""
  exit 1
}


domount()
{
  echo "--- mounting DISK ---" 
  eval "$MOUNT"
}

todo_domount()
{
  # use global TODO mm ...

  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  if [ "$SCRIPT" ]; then
    in_ignore $mm "^--- .* ---$"
  else
    in_stdout $mm "^--- .* ---$"
  fi
  TODO="$TODO \"domount # mount all partitions to /mnt\""
}

dounmount()
{
  echo "--- unmounting DISK ---"
  eval "$UMOUNT"
}

todo_dounmount()
{
  # use global TODO mm

  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  if [ "$SCRIPT" ]; then
    in_ignore $mm "^--- .* ---$"
  else
    in_stdout $mm "^--- .* ---$"
  fi

  TODO="$TODO \"dounmount\""
}

# get options
while [ "$1" ]; do
  case "$1" in
     "-h"|"--help")
        usage
        ;;
     "-i")
        TODOY=""
	shift
        ;;
   "-url")
        ENV_IMAGEURL="$2"
        shift 2
        ;;
     "-v")
        VERBOSE="$1"
	shift
        ;;
     "-c")
        CONFDIR="$2"
        shift 2
        ;;
     "-s")
        SCRIPT="$1"
	shift
        ;;
     "-onlymount")
        ONLYMOUNT="$1"
        shift
        ;;
     "-onlyunmount")
	ONLYUNMOUNT="$1"
	shift
	;;
     "-o")
	ORIGINALDISKNAME="$1"
	shift
        ;;
     "-r")
        ROOT="$2"
        BOOTCDMP="$ROOT/mnt" # This may change mount and unmount commands in bootcd2disk.conf
        shift 2
        ;;
     "-mkchroot")
        CHROOTDIR="$2"
	COPYDEST="$CHROOTDIR/chroot"
	shift 2
	;;
        *)
        usage "ERROR: option \"$1\" unknown!"
        ;;
  esac
done

# Read bootcd2disk.conf
CONFVARS="DISK0 SFDISK0 EXT2FS EXT3 SWAP MOUNT UMOUNT FSTAB LILO SSHHOSTKEY \
  UDEV_FIXNET USEIMAGESERVER ELILO TRYFIRST GRUB LVMGRP LVMVOL \
  GRUBBOOTDISK"
unset $CONFVARS
[ ! -f $ROOT/$CONFDIR/bootcd2disk.conf ] && err "No file $ROOT/$CONFDIR/bootcd2disk.conf"
. $ROOT/$CONFDIR/bootcd2disk.conf

for i in $CONFVARS; do
  [ "`set | grep ^$i=`" ] || err "$i is not set in $CONFDIR/bootcd2disk.conf"
done

# read bootcd-run.lib
if [ -f ./bootcd-run.lib ]; then
  echo "Using local ./bootcd-run.lib" >&2
  . ./bootcd-run.lib
elif [ -f $ROOT/usr/share/bootcd/bootcd-run.lib ]; then
  . $ROOT/usr/share/bootcd/bootcd-run.lib 
else
  echo "Error: Mandatory lib bootcd-run.lib not found! ABORT!"
  exit 1
fi

# read bootcd2disk.lib
BOOTCD2DISKLIB=./bootcd2disk.lib
if [ -f $BOOTCD2DISKLIB ]; then
  [ "$SCRIPT" ] || echo "Using local $BOOTCD2DISKLIB" >&2
  . $BOOTCD2DISKLIB $*
else
  BOOTCD2DISKLIB=$ROOT/usr/share/bootcd/bootcd2disk.lib
  if [ -f $BOOTCD2DISKLIB ];then
    . $BOOTCD2DISKLIB $*
  else
    echo "Error: Mandatory lib $BOOTCD2DISKLIB not found! ABORT!"
    exit 1
  fi
fi

# useoriginaldisk - sets DISK0,DISK1,... to ORIG_DISK0,ORIG_DISK1,...
useoriginaldisk()
{
  if [ "$ORIGINALDISKNAME" ]; then
    for i in $DISKVARS; do
      eval "DISK$i=\$ORIG_DISK$i"
    done
  fi
}

getdiskvars # sets DISKVARS
check_auto # Has to be checked before setting DISKS
check_DISK0  # sets DISKS found on booted system
useoriginaldisk # with -o: sets DISK0,DISK1,... to ORIG_DISK0,ORIG_DISK1,...
check_SWAP_MOUNT_UMOUNT_VFAT_OPT_FSTAB

if [  "$ONLYMOUNT" ]; then
  todo_domount
  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
  exit $?
elif [  "$ONLYUNMOUNT" ]; then
  todo_dounmount
  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
  exit $?
fi

# run functions from bootcd2disk.lib
read_thisboot
check_kern
check_SFDISK0
check_EXT2_EXT3
check_GRUB_LILO
check_OPT_LVM

DO_BEFORE_COPY=$(egrep "^[[:space:]]*(function)*[[:space:]]*before_copy" $CONFDIR/bootcd2disk.conf)
DO_AFTER_COPY=$(egrep "^[[:space:]]*(function)*[[:space:]]*after_copy" $CONFDIR/bootcd2disk.conf)

# getdata - print without empty lines and comments
getdata()
{
  echo "$*" | sed "s/#.*$//" | grep -v "^$"
}

### Main ###


excludemnt()
{
  #find mountpoints and exclude them, otherwise cpio might complain
  CPIOEXMOUNT="$(mount| awk '/ \/mnt\// {gsub(/\/mnt\//,"/");{print $3}}')"
  CPIOEXCLUDE=""
  if [ ! -z "$CPIOEXMOUNT" ];then
    for AEXCLUDE in $CPIOEXMOUNT; do
      CPIOEXCLUDE="$CPIOEXCLUDE -e '^$AEXCLUDE\$'"
    done
  fi
}

A=""
while [ "$A" != "y" -a "$A" != "n" -a "$SCRIPT" = "" ]
do
  if [ "$CHROOTDIR" ]; then
    echo "Directory $CHROOTDIR will be deleted and created again! " | tee -a $ERRLOG >&2
    [ "$DO_BEFORE_COPY" ] && echo "do_before_copy is defined." | tee -a $ERRLOG >&2
    [ "$DO_AFTER_COPY" ] && echo "do_after_copy is defined." | tee -a $ERRLOG >&2
    [ "$RESTORECMD" ] && echo "RESTORECMD is defined." | tee -a $ERRLOG >&2
  else
    for i in $DISKVARS; do
      echo "Harddisk $i ($(eval "echo \"\$DISK$i\"")) will be erased!!!" |
        tee -a $ERRLOG >&2
    done
    [ "$SWAP" ] && echo "Partition $SWAP will be newly created as SWAP !!!" | tee -a $ERRLOG >&2
    [ "$EXT2FS" ] && echo "Partition $EXT2FS will be newly created as $OPT !!!" | tee -a $ERRLOG >&2
    [ "$VFAT" ] && echo "Partition $VFAT will be newly created as vfat !!!" | tee -a $ERRLOG >&2
  fi
  echo "(y/n) " | tee -a $ERRLOG >&2
  if [ "$SCRIPT" ]; then
    A="y"
  else
    read A
  fi
  echo "$A" >> $ERRLOG >&2
done
if [ "$A" = "n" ]; then
  exit 1
fi

trap cleanup 2

# zerodsk <dev1> [<dev2> ...]
zerodsk()
{
  local DELPV="$@"
  local dsk

  echo "--- Destroy old disk infos $DELPV ---"
  for dsk in $DELPV; do
    dd if=/dev/zero of=\$dsk bs=1k count=1
  done
}

lvmreset()
{
  local IAHEAD="$IAHEAD/lvmreset"
  local TODO="" mm=0

  if [ "$LVMGRP" -a "$LVMVOL" ]; then

    # delete all pvdisplay | grep "PV Name"
    ALLPV="$(pvdisplay -c 2>/dev/null | 
      sed -n "s|[[:blank:]]*\(/dev/[^:]*\):.*|\1|p")"

    echo "All physical Volumes ALLPV=<$ALLPV>" >>$ERRLOG

    for i in $DISKVARS; do
      # Search for old Partitions on reused disks
      DELPV="$(echo "$ALLPV" | grep "^$(eval "echo \"\$DISK$i\"")")"
      # All on one line
      DELPV="$(echo $DELPV|awk '{printf("%s ",$0)}')"

      if [ "$(echo "$DELPV" | grep "[[:alnum:]]")" ]; then
        # Try to use pvremove first (ignore anything, only write to log)
        mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
        in_ignore $mm ".*"
        TODO="$TODO \"pvremove -ff -y $DELPV\""
      fi

      # Add the disk itself
      DELPV="$DELPV $(eval "echo \"\$DISK$i\"")"

      mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
      in_stdout $mm "^--- .* ---$"
      in_ignore $mm "1+0 records in"
      in_ignore $mm "1+0 records out"
      in_ignore $mm "1024 bytes.*copied.*seconds"
      TODO="$TODO \"zerodsk $DELPV\""
    done
  fi
  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
}
if [ \( ! "$CHROOTDIR" \) -a "$LVMGRP" -a "$LVMVOL" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_norun $mm 
  TODO="$TODO \"lvmreset # deactivate lvm, delete lvm info on disk\""
fi

partdisk()
{
  local d s o i

  for i in $DISKVARS; do
    d=$(eval "echo \"\$DISK$i\"")
    s=$(eval "echo \"\$SFDISK$i\"")
    o=$(eval "echo \"\$SFDISKOPTS$i\"")
    echo "--- Partitioning DISK$i ($d) ---"
    echo "$s" | sfdisk $o -qL -uM $d >/dev/null
  done
}

if [ ! "$CHROOTDIR" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_stdout $mm "^--- .* ---$"
  in_ignore $mm "unrecognized partition table type"
  in_ignore $mm "^sfdisk: ERROR: sector .* does not have an msdos signature"
  in_ignore $mm "^No partitions found"
  TODO="$TODO \"partdisk # partition disks $(for i in $DISKVARS; do echo -n "$(eval "echo \"\$DISK$i\"") "; done; echo "")\""
fi

lvm_pvcreate()
{
  local IAHEAD="$IAHEAD/lvm_pvcreate"
  local TODO="" mm=0

  echo "--- pvcreate ---" | tee -a $ERRLOG >&2

  # while ... gives a subshell, to set vars we have to eval the set commands
  eval "$(
    getdata "$LVMGRP" | sed "s/vgcreate.*//" |
    while read grp dsks; do
      for dsk in $dsks; do

        # After Disk Partitioning, there could be new places with old
        # LVM Info, so we delete it before running pvcreate
        cat <<'END'
mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
in_ignore $mm "WARNING: Forcing physical volume creation on .* of volume group \".*\""
in_ignore $mm "^[[:digit:]]\++[[:digit:]]\+ records in$"
in_ignore $mm "^[[:digit:]]\++[[:digit:]]\+ records out$"
in_ignore $mm "^[[:digit:]]\+ bytes\>.*\<copied\>.*\<seconds\>.*"
END
        echo "TODO=\"\$TODO \\\"dd if=/dev/zero of=$dsk bs=1k count=1\\\"\""

        cat <<'END'
mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
in_ignore $mm "WARNING: Forcing physical volume creation on .* of volume group \".*\""
in_ignore $mm "Physical volume \".*\" successfully created"
END
        echo "TODO=\"\$TODO \\\"pvcreate --quiet -d -ff -y $dsk\\\"\""

      done
    done
  )"

  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
}
if [ \( ! "$CHROOTDIR" \) -a "$LVMGRP" -a "$LVMVOL" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_norun $mm 
  TODO="$TODO \"lvm_pvcreate\""
fi


lvm_vgcreate()
{
  local IAHEAD="$IAHEAD/lvm_vgcreate"
  local TODO="" mm=0

  echo "--- vgcreate ---" | tee -a $ERRLOG >&2

  # while ... gives a subshell, to set vars we have to eval the set commands
  eval "$(
    getdata "$LVMGRP" |
    while read grp dsks; do
      cmd="$(echo "$dsks"|sed "s/.*\(vgcreate.*\)/\1/"|grep vgcreate)"
        cat <<'END'
mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
in_ignore $mm "Volume group \".*\" successfully created"
END
      if [ "$cmd" ]; then
        echo "TODO=\"\$TODO \\\"$cmd\\\"\""
      else
        echo "TODO=\"\$TODO \\\"vgcreate --quiet $grp $dsks\\\"\""
      fi
        cat <<'END'
mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
in_ignore $mm "0 logical volume(s) in volume group \".*\" now active"
END
      echo "TODO=\"\$TODO \\\"vgchange --quiet -aey $grp\\\"\""
    done
  )"

  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
}
if [ \( ! "$CHROOTDIR" \) -a "$LVMGRP" -a "$LVMVOL" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_norun $mm 
  TODO="$TODO \"lvm_vgcreate\""
fi

lvm_lvcreate()
{
  local IAHEAD="$IAHEAD/lvm_lvcreate"
  local TODO="" mm=0

  echo "--- lvcreate ---" | tee -a $ERRLOG >&2

  # while ... gives a subshell, to set vars we have to eval the set commands
  eval "$(
    getdata "$LVMVOL" |
    while read vol s grp cmd; do
      cat <<'END'
mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
in_ignore $mm "Logical volume \".*\" created"
in_stdout $mm "Rounding up size to full physical extent"
END
      if [ "$cmd" ]; then
        echo "TODO=\"\$TODO \\\"$cmd\\\"\""
      else
        echo "TODO=\"\$TODO \\\"lvcreate -n $vol -L $s $grp\\\"\""
      fi
    done
  )"

  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
}
if [ \( ! "$CHROOTDIR" \) -a "$LVMGRP" -a "$LVMVOL" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_norun $mm 
  TODO="$TODO \"lvm_lvcreate\""
fi

lvm_vgchange()
{
  local IAHEAD="$IAHEAD/lvm_vgchange"
  local TODO="" mm=0

  echo "--- Activate LVM ---" | tee -a $ERRLOG >&2

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  in_ignore $mm "Reading all physical volumes.  This may take a while..."
  in_ignore $mm "Found volume group \".*\" using metadata type lvm2"
  TODO="$TODO \"vgscan --quiet\""

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  in_ignore $mm "[1-9][0-9]* logical volume(s) in volume group \".*\" now active"
  TODO="$TODO \"vgchange --quiet -ay\""

  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
}
if [ \( ! "$CHROOTDIR" \) -a "$LVMGRP" -a "$LVMVOL" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_norun $mm 
  TODO="$TODO \"lvm_vgchange\""
fi

vfat()
{
  local IAHEAD="$IAHEAD/vfat"
  local TODO="" mm=0

  for i in $VFAT; do
    echo "--- Building Filesystem $i with mkdosfs ---" | tee -a $ERRLOG >&2

    mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
    in_stdout $mm "^mkdosfs "
    TODO="$TODO \"mkdosfs $i\""
  done

  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
}
if [ \( ! "$CHROOTDIR" \) -a "$VFAT" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_norun $mm 
  TODO="$TODO \"vfat # mkdosfs $VFAT\""
fi


extfs()
{
  local IAHEAD="$IAHEAD/extfs"
  local TODO="" mm=0

  OPT=""
  [ "$EXT3" = "yes" ] && OPT="-j"
  for i in $EXT2FS; do
    echo "--- Building Filesystem $i with mke2fs $OPT ---" | tee -a $ERRLOG >&2
    mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
    in_stdout $mm "^mke2fs "
    TODO="$TODO \"mke2fs $OPT -q $i\""
  done

  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
}
if [ \( ! "$CHROOTDIR" \) -a "$EXT2FS" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_norun $mm 
  TODO="$TODO \"extfs # mke2fs $EXT2FS\""
fi

swap()
{
  local IAHEAD="$IAHEAD/swap"
  local TODO="" mm=0

  for i in $SWAP; do
    echo "--- making SWAP $i ---" | tee -a $ERRLOG >&2
    mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
    in_stdout $mm "^Setting up swapspace"
    in_stdout $mm "^no label, "
    TODO="$TODO \"mkswap $i\""
  done

  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
}
if [ \( ! "$CHROOTDIR" \) -a "$SWAP" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_norun $mm 
  TODO="$TODO \"swap # mkswap $SWAP\""

  todo_domount
fi

mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
in_norun $mm # you can not set global variables with run
TODO="$TODO \"excludemnt\""

if [ "$CHROOTDIR" -a "$CHROOTDIR" != "/" -a "$CHROOTDIR" != "." ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  TODO="$TODO \"rm -rf $CHROOTDIR\""

  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  TODO="$TODO \"mkdir -p $COPYDEST\""
fi

# remove all interfaces from udev persistent rules file
# needed if you install on other machines
udev_fixnet()
{
  [ -e "/etc/udev/rules.d/z25_persistent-net.rules" ] && sed -i -ne "/^#.*/p" /etc/udev/rules.d/z25_persistent-net.rules
}

if [ "$UDEV_FIXNET" = "yes" ]; then 
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  TODO="$TODO udev_fixnet"
fi

# use image from a image server and copy it to the later swap-partion
# the partition must be large enough to hold the whole disk image
copyfromserver_before()
{
  # timeout for dns-query and connection timeout (seconds)
  local timeout=30
  local IAHEAD="$IAHEAD/copyfromserver_before"
  local TODO="" mm=0

  echo "--- copying image from image server ---" | tee -a $ERRLOG >&2

  # commandline overwrite the bootcd2disk.conf option!
  [ "$ENV_IMAGEURL" ] && local url=$ENV_IMAGEURL || local url=$IMAGEURL
 
  if [ ! "$url" ]; then
    echo "No parameter -url given and IMAGEURL not set!"| tee -a $ERRLOG >&2
    exit 2
  fi

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  in_stdout $mm "^mke2fs "
  TODO="$TODO \"mke2fs -q $SWAP\""

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"mkdir -p /tmp/swapfs\""

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"mount $SWAP /tmp/swapfs\""

  if [ "$(echo "$url" | grep "^file://")" ]; then
    url="$(echo "$url" | sed "s|^file://\(.*\)$|\1|")"
    if [ -b "$url" ]; then
      mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
      TODO="$TODO \"dd if=$url of=/tmp/swapfs/cdimage.iso\""
    elif [ -f "$url" ]; then
        mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
        TODO="$TODO \"cp $url /tmp/swapfs/cdimage.iso\""
    else
      echo "No file <$url>" | tee -a $ERRLOG >&2
      exit 3
    fi
  else
    mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
    in_stdout $mm "^--[[:digit:]:]*--.*"
    in_stdout $mm "^[[:space:]]*=> .*"
    in_stdout $mm "^Resolving .*"
    in_stdout $mm "^Connecting .*"
    in_stdout $mm "^Logging .*"
    in_stdout $mm "^==> SYST .*"
    in_stdout $mm "^==> TYPE .*"
    in_stdout $mm "^==> PASV .*"
    in_stdout $mm "^Length: .*"
    in_stdout $mm "^[[:space:]]*OK.*"
    in_stdout $mm "^Length .*"
    in_stdout $mm "^$"
    in_stdout $mm "^[[:digit:]:]* .*"
    in_stdout $mm "^[:space:]*[[:digit:]:K]* .*"
    in_stdout $mm "^HTTP request sent, .* 200 OK[[:space:]]*$"
    in_stdout $mm "^==> SIZE "
    TODO="$TODO \"wget --no-check-certificate --dns-timeout=$timeout --connect-timeout=$timeout -O /tmp/swapfs/cdimage.iso $url\""
  fi

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"mkdir -p /tmp/isoloopback\""

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"mount -o loop /tmp/swapfs/cdimage.iso /tmp/isoloopback\""

  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
}

if [ "$USEIMAGESERVER" = "yes" -o "$ENV_IMAGEURL" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_norun $mm
  TODO="$TODO copyfromserver_before"
fi

do_before_copy()
{
  echo "--- do function before_copy ---" | tee -a $ERRLOG >&2
  before_copy
}

# only call the function, if it is defined
if [ "$DO_BEFORE_COPY" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  TODO="$TODO \"do_before_copy # run function before_copy defined in bootcd2disk.conf\""
fi

delete_not_to_ram_symlinks()
{
  NOT_TO_RAM_RO=$(find /ram1 /ram2 -xdev -type l | xargs /bin/ls -l | grep -e " -> /etc.ro/" -e " -> /home.ro/" -e " -> /root.ro/" | awk '{ print $(NF) }')
  for i in $NOT_TO_RAM_RO; do     # exp: i=/etc.ro/X11
    j=$(echo $i | sed "s/\.ro//") #   => j=/etc/X11
    rm -f $COPYDEST/$j        #   => $COPYDEST/etc/X11 -> /etc.ro/X11
    [ -e $i ] && cp -a $i $COPYDEST/$j
  done
}

copycdram()
{
  local IAHEAD="$IAHEAD/copycdram"
  local TODO="" mm=0

  echo "--- copying CD and RAM to $COPYDEST ---" | tee -a $ERRLOG >&2

  # Normally there is no /tmp/isoloopback after booting from CD. But it could be
  # created in function before_copy.
  if [ -d /tmp/isoloopback ]; then
    mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
    TODO="$TODO \"cd /tmp/isoloopback; find . -mount | sed 's|^./|/|g' | grep -v -e '^/var.ro\>' -e '^/var\>' $CPIOEXCLUDE | sed 's|^/|./|g' |cpio --quiet -pdum $COPYDEST\""

  else
    mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
    TODO="$TODO \"find / -mount|grep -v -e '^/var.ro\>' -e '^/var\>' $CPIOEXCLUDE |cpio --quiet -pdum $COPYDEST\""
  fi
  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"cd /var.ro; find . -mount | cpio --quiet -pdum $COPYDEST/var\""

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"find $COPYDEST/etc $COPYDEST/tmp $COPYDEST/dev $COPYDEST/home $COPYDEST/root -type l | xargs -r rm\""

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"rm -r $COPYDEST/etc.ro $COPYDEST/tmp.ro $COPYDEST/dev.ro $COPYDEST/home.ro $COPYDEST/root.ro\""

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"cp -a -x /ram1/etc /ram1/tmp /ram1/home /ram1/root $COPYDEST\""

  if [ -d /dev/.static/dev -a -x /etc/init.d/udev ]; then
    echo "--- handling udev ---" 
    # -- udev --
    # The filesystem has static device files in /dev.
    # But tmpfs is mounted over /dev and hides the static device files.
    # The static device files are mounted again in /dev/.static/dev/.
    # This means bootcd has only to copy /dev/.static/dev.
    mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
    TODO="$TODO \"cp -a -x /ram1/dev/.static/dev $COPYDEST\""

    mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
    TODO="$TODO \"mkdir -p $COPYDEST/dev/.static\""

    mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
    TODO="$TODO \"chown root:root $COPYDEST/dev/.static\""

    mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
    TODO="$TODO \"chmod 700 $COPYDEST/dev/.static\""
  else
    mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
    TODO="$TODO \"cp -a -x /ram1/dev $COPYDEST\""
  fi

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"rm -f $COPYDEST/fastboot $COPYDEST/cdboot.catalog $COPYDEST/cdboot.img $COPYDEST/ram1.cpio.gz $COPYDEST/ram2.cpio.gz\""

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"rm -rf $COPYDEST/rr_moved/ $COPYDEST/isolinux/\""

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"rm $COPYDEST/etc/rcS.d/S12bootcdram.sh \
    $COPYDEST/etc/rcS.d/S13bootcdflop.sh \
    $COPYDEST/usr/bin/bootcd2disk \
    $COPYDEST/usr/bin/bootcdflopcp \
    $COPYDEST/etc/bootcd/bootcd2disk.conf \
    $COPYDEST/etc/bootcd/thisbootcd.conf\""

  # files that do not always exist
  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"rm -f $COPYDEST/usr/bin/bootcdmk2diskconf\""

  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"rm -rf $COPYDEST/ram1 $COPYDEST/ram2\""

  echo "--- deleting NOT_TO_RAM symlinks ---" 
  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"delete_not_to_ram_symlinks\""

  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
}
if [ ! "$RESTORECMD" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_norun $mm 
  TODO="$TODO \"copycdram # copy cd and ram to $COPYDEST, delete unneeded stuff\""
fi

# configure the swap-partition back to swap
copyfromserver_after()
{
  # timeout for dns-query and connection timeout (seconds)
  local timeout=30
  local IAHEAD="$IAHEAD/copyfromserver_after"
  local TODO="" mm=0

  echo "--- copying image from image server ---" | tee -a $ERRLOG >&2

  # cleanup again
  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"umount -d /tmp/isoloopback\""

  # free loopdevice
#  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
#  TODO="$TODO \"losetup -d /dev/loop0\""

  # cleanup again
  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  TODO="$TODO \"umount /tmp/swapfs\""

  # rebuild swap
  mm=$(($mm+1)); eval local IGNORE${mm}=\"\"; eval local STDOUT${mm}=\"\"
  in_norun $mm  
  TODO="$TODO \"swap\""

  eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"
}
if [ ! "$RESTORECMD" ]; then
  if [ "$USEIMAGESERVER" = "yes" -o "$ENV_IMAGEURL" ]; then
    mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
    in_norun $mm
    TODO="$TODO copyfromserver_after"
  fi
fi

if [ "$RESTORECMD" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  TODO="$TODO \"$RESTORECMD\""
fi

do_after_copy()
{
  echo "--- do function after_copy ---"
  after_copy
}
# only call the function, if it is defined
if [ ! -z "$DO_AFTER_COPY" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_stdout $mm "^--- .* ---$"
  TODO="$TODO \"do_after_copy # run function after_copy defined in bootcd2disk.conf\""
fi

do_fstab()
{
  if [ "$FSTAB" = "unchanged" ]; then
    echo "--- Will let fstab unchanged ---"
  else
    echo "--- Building fstab ---"
    echo "$FSTAB" > $COPYDEST/etc/fstab

    echo "--- Resetting mtab ---"
    rm -f $COPYDEST/etc/mtab
  fi
}
mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
in_stdout $mm "^--- .* ---$"
TODO="$TODO \"do_fstab # create $COPYDEST/etc/fstab\""

bootloadercfg()
{
  local IAHEAD="$IAHEAD/bootloadercfg"
  local TODO="" mm=0

  if [ "$GRUB" = "unchanged" ]; then
    echo "--- Will let grub/menu.lst unchanged ---" | tee -a $ERRLOG >&2
  elif [ "$GRUB" ]; then
    echo "--- Building grub/menu.lst ---" | tee -a $ERRLOG >&2
    mkdir -p $COPYDEST/boot/grub
    echo "$GRUB" > $COPYDEST/boot/grub/menu.lst
  fi

  if [ "$LILO" = "unchanged" ]; then
    echo "--- Will let lilo.conf unchanged ---" | tee -a $ERRLOG >&2
  elif [ "$LILO" ]; then
    echo "--- Building lilo.conf ---" | tee -a $ERRLOG >&2
    echo "$LILO" > $COPYDEST/etc/lilo.conf
  fi

  if [ "$ELILO" = "unchanged" ]; then
    echo "--- Will let elilo.conf unchanged ---" | tee -a $ERRLOG >&2
  elif [ "$ELILO" ]; then
    echo "--- Building elilo.conf ---" | tee -a $ERRLOG >&2
    echo "$ELILO" > $COPYDEST/etc/elilo.conf
  fi
}
mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
in_stdout $mm "^--- .* ---$"
TODO="$TODO bootloadercfg"

createsshkeys()
{
  if [ "$SSHHOSTKEY" = "unchanged" ]; then
    echo "--- Will let ssh keys unchanged ---" | tee -a $ERRLOG >&2
  elif [ "$SSHHOSTKEY" = "yes" ]; then
    # each installed PC gets a unique hostkey (only if hostkey already existed)
    TODO="$TODO \"create_host_keys $COPYDEST/etc/ssh\""
  elif [ "$SSHHOSTKEY" != "no" ]; then
    echo 'SSHHOSTKEY is not defined as "yes" or "no".' \
         'It will be treated as "no".'
  fi
}
mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
in_stdout $mm "^--- .* ---$"
TODO="$TODO createsshkeys"

enablecron()
{
  echo "--- Enabling turned off stuff ---" | tee -a $ERRLOG >&2
  for f in $DISABLE_CRON; do
    if [ -f $COPYDEST/$f.no_run_on_bootcd ]; then 
      rm $COPYDEST/$f
      mv $COPYDEST/$f.no_run_on_bootcd $COPYDEST/$f
    fi
  done
}
if [ ! "$RESTORECMD" ]; then
  if [ "$DISABLE_CRON" ]; then
    mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
    in_stdout $mm "^--- .* ---$"
    TODO="$TODO enablecron"
  fi
fi

dogrub()
{
  [ -z "$GRUBBOOTDIR" ] && GRUBBOOTDIR=0
  [ -z "$GRUBBOOTDISK" ] && GRUBBOOTDISK="hd0"
  echo "--- Running grub-install ---" | tee -a $ERRLOG >&2
  grub-install --no-floppy --root-directory=$COPYDEST $GRUBBOOTDISK

  if [ $? -eq 0 ]; then
    return 0
  fi
  echo "--- grub-install did not work trying option --recheck ---" | tee -a $ERRLOG >&2
  grub-install --recheck --no-floppy --root-directory=$COPYDEST $GRUBBOOTDISK

  if [ $? -eq 0 ]; then
    return 0
  fi
  echo "--- grub-install did not work trying grub ---" | tee -a $ERRLOG >&2
echo "root ($GRUBBOOTDISK,$GRUBBOOTDIR)
setup ($GRUBBOOTDISK)
quit
" | grub --no-floppy --batch
}
if [ \( ! "$CHROOTDIR" \) -a "$GRUB" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  # To many text
  in_stdout $mm ".*"
  TODO="$TODO \"dogrub # run grub-install --root-directory=$COPYDEST $GRUBBOOTDISK\""
fi

dolilo()
{
  echo "--- Running lilo ---" | tee -a $ERRLOG >&2
  chroot $COPYDEST mount /proc
  chroot $COPYDEST lilo -w
  chroot $COPYDEST umount /proc
}
if [ \( ! "$CHROOTDIR" \) -a "$LILO" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_stdout $mm "^Added "
  in_stdout $mm "^--- .* ---$"
  TODO="$TODO dolilo"
fi

doelilo()
{
  echo "--- Running elilo ---" | tee -a $ERRLOG >&2
  chroot $COPYDEST elilo
}
if [ \( ! "$CHROOTDIR" \) -a "$ELILO" ]; then
  mm=$(($mm+1)); eval IGNORE${mm}=\"\"; eval STDOUT${mm}=\"\"
  in_stdout $mm "^--- .* ---$"
  TODO="$TODO doelilo"
fi

if [ ! "$CHROOTDIR" ]; then
  todo_dounmount
fi

eval "interactive $TODOY -r -h \"=== \$IAHEAD ===\" $TODO"

echo "Please Reboot now !" | tee -a $ERRLOG >&2