#!/static/sh
#
# KNOPPIX General Startup Script
# (C) Klaus Knopper <knoppix@knopper.net>
#
# Modified by Allied Data Sys / www.ads-lu.com
#
if [ -z "$FOUND_KNOPPIX" ]; then #linuxrc
#
# This script needs some of the builtin ash commands (if, test, ...)
# mount/umount, insmod/rmmod are also a builtin in ash-knoppix.
# Terminal-server needs extras (nfs-capable mount, pump, portmap)
#

# hardcoded configurable options
# Default maximum size of dynamic ramdisk in kilobytes
RAMSIZE=1000000
# End of options

# Don't allow interrupt signals
trap "" 1 2 3 15

# "Safe" SCSI modules in the right order for autoprobe
# Warning: The sym53c8xx.o and g_NCR* cause a kernel Oops if no such adapter
# is present.
#
# NB: It looks like that ncr53c8xx.o is more stable than 53c7,8xx.o for
# a ncr53c810 controller (at least on my installation box it's more
# immune to SCSI timeouts)
# Removed 53c7,8xx -> crashes if no device attached.
# Removed AM53C974 -> crashes tmscsim if adapter found
# Added initio.o on request (untested)
SCSI_MODULES="aic7xxx.o aic7xxx_old.o BusLogic.o \
ncr53c8xx.o NCR53c406a.o \
initio.o mptscsih.o \
advansys.o aha1740.o aha1542.o aha152x.o \
atp870u.o dtc.o eata.o fdomain.o gdth.o \
megaraid.o pas16.o pci2220i.o pci2000.o psi240i.o \
qlogicfas.o qlogicfc.o qlogicisp.o \
seagate.o t128.o tmscsim.o u14-34f.o ultrastor.o wd7000.o \
a100u2w.o 3w-xxxx.o"

# Misc functions

INSMOD="insmod"
[ -x /modules/insmod ] && INSMOD="/modules/insmod"

RMMOD="rmmod"
[ -x /modules/rmmod ] && RMMOD="/modules/rmmod"

showaccess(){
echo "${CRE} ${GREEN}Accessing $2 at ${MAGENTA}$1${GREEN}.${NORMAL}     "
}

showtryaccess(){
echo -n "${CRE} ${BLUE}Looking for $2 in: ${MAGENTA}$1${NORMAL}     "
}

mountnfs(){
[ -n "$NFSDIR" ] || return 1
showtryaccess $NFSDIR "CD"
if /static/mount -t nfs -o ro,rsize=8192,wsize=8192,hard,intr$SECURE \
   "${NFSDIR}" /cdrom > /dev/null 2>&1; then
 [ -d /cdrom/$KNOPPIXDIR ] && FOUND_KNOPPIX="$NFSDIR"
 return 0
fi
echo "${RED}Failed.${NORMAL}"
return 1
}

# Builin filesystems
BUILTIN_FS="iso9660 ext2 vfat"

mountit(){
# Usage: mountit src dst "options"
# Uses builtin mount of ash.knoppix
for fs in $BUILTIN_FS; do
test -b $1 && mount -t $fs $3 $1 $2 >/dev/null 2>&1 && return 0
done
return 1
}

FOUND_SCSI=""

# Clean input/output
exec >/dev/console </dev/console 2>&1

# Reset fb color mode
RESET="]R"
# ANSI COLORS
# Erase to end of line
CRE="
"
# Clear and reset Screen
CLEAR="c"
# Normal color
NORMAL=""
# RED: Failure or error message
RED=""
# GREEN: Success message
GREEN=""
# YELLOW: Descriptions
YELLOW=""
# BLUE: System mesages
BLUE=""
# MAGENTA: Found devices or drivers
MAGENTA=""
# CYAN: Questions
CYAN=""
# BOLD WHITE: Hint
WHITE=""

# Clear screen with colormode reset
# echo "$CLEAR$RESET"
# echo "$CLEAR"
# Just go to the top of the screen
# echo -n ""
echo ""
# Be verbose
echo "${WHITE}Welcome to the ${CYAN}K${MAGENTA}N${YELLOW}O${WHITE}P${RED}P${GREEN}I${BLUE}X${NORMAL}/${WHITE}A${YELLOW}D${RED}S${WHITE} live Linux-on-CD, see http://www.ads-lu.com/server !${NORMAL}"

# We only need the builtin commands and /static at this point
PATH=/static
export PATH

umask 022

# Mount /proc and /dev/pts
mount -t proc none /proc

# Disable kernel messages while probing modules in autodetect mode
echo "0" > /proc/sys/kernel/printk

mount -t devpts /dev/pts /dev/pts
# Kernel 2.6
mount -t sysfs /sys /sys >/dev/null 2>&1

split_dev(){
IFS="/"; set -- $1; unset IFS
[ -z "$1" ] && echo "/$2/$3"
}  

split_path(){
IFS="/"; set -- $1; unset IFS
[ -z "$1" ] && shift 3
while [ -n "$1" ]; do echo -n "$1"; [ -n "$2" ] && echo -n "/"; shift; done 
echo ""
}  

# Split cmdline, find variables
KNOPPIX="KNOPPIX"
KNOPPIXDIR="KNOPPIX"
KNOPPIXISO=""
NOSCSI=""
NOUSB=""
NOFIREWIRE=""
IDECD=""
NOIDERAID=""
SECURE=""
COPYTO=""
INTERACTIVE=""
CDSIZE=""
NODMA=""
HARDDISK=""
HARDDISKDEV=""
USB="usb-uhci.o usb-ohci.o"
# Read boot command line with builtin cat command (shell read function fails in Kernel 2.4.19-rc1)
for i in $(cat /proc/cmdline); do
case "$i" in
# Check if we are in interactive startup mode
BOOT_IMAGE=expert) INTERACTIVE="yes"; :>/interactive;;
modules-disk) INTERACTIVE="yes";;
# Does the user want to skip scsi detection?
noscsi|nobootscsi) NOSCSI="yes";;
nousb|nobootusb) NOUSB="yes";;
nofirewire|nobootfirewire) NOFIREWIRE="yes";;
fromhd) NOCD="yes";;
idecd|atapicd) IDECD="yes";;
noideraid) NOIDERAID="yes";;
hdimage) HARDDISK="KNOPPIX/hdimage";;
secure) SECURE=",nosuid";;
toram) COPYTO="ramdisk";;
nodma) NODMA="yes";;
usb2) USB="ehci-hcd.o $USB";;
tohd=*|nfsdir=*|NFSDIR=*|knoppix=*|KNOPPIX=*|knoppixdir=*|KNOPPIXDIR=*|\
knoppixofs=*|KNOPPIXOFS=*|knoppixdev=*|KNOPPIXDEV=*|harddisk=*|HARDDISK=*|\
HARDDISKDEV=*|cdsize=*|CDSIZE=*|knoppix_dir=*|knoppix_name=*|bootfrom=*|\
KNOPPIXISO=*|knoppixiso=*) eval $i;;
esac
done
[ -n "$tohd" ] && COPYTO="$tohd"
[ -n "$nfsdir" ] && NFSDIR="$nfsdir"
[ -n "$knoppix" ] && KNOPPIX="$knoppix"
[ -n "$knoppix_name" ] && KNOPPIX="$knoppix_name"
[ -n "$knoppixdir" ] && KNOPPIXDIR="$knoppixdir"
[ -n "$knoppix_dir" ] && KNOPPIXDIR="$knoppix_dir"
[ -n "$knoppixofs" ] && KNOPPIXOFS="$knoppixofs"
[ -n "$knoppixdev" ] && KNOPPIXDEV="$knoppixdev"
[ -n "$knoppixiso" ] && KNOPPIXISO="$knoppixiso"
[ -n "$bootfrom" ] && { 
 KNOPPIXDEV=$(split_dev $bootfrom); 
 KNOPPIXISO=$(split_path $bootfrom); 
}
[ -n "$harddisk" ] && HARDDISK="$harddisk"
[ -n "$HARDDISK" ] && {
 HARDDISKDEV=$(split_dev $HARDDISK); 
 HARDDISK=$(split_path $HARDDISK); 
}
[ -n "$cdsize" ] && CDSIZE="$cdsize"

# build disk device list
disk_list(){  
echo "$KNOPPIXDEV"
# Now that the right SCSI driver is (hopefully) loaded, try to find CDROM
[ -n "$FOUND_SCSI" -a -z "$1" ] && echo "/dev/scd? /dev/scd??"
# New: Also try parallel port CD-Roms [for Mike].
[ -z "$1" ] && echo "/dev/pcd?"
# New: also check HD partitions for a KNOPPIX/KNOPPIX image
for i in $(cd /proc/ide 2>/dev/null && echo hd[a-z] && [ -n "$FOUND_SCSI" ] && cd /dev && echo sd[a-z]); do
  echo "/dev/$i /dev/$i? /dev/$i??"
done
}
 
# Mount module disk
mountmodules(){
TYPE="$1"
echo -n "${CRE}${CYAN}Please insert ${TYPE} modules disk and hit Return. ${NORMAL}"
read a
echo -n "${CRE}${BLUE}Mounting ${TYPE} modules disk... ${NORMAL}"
# We always mount over /modules/scsi (because it's there ;-)
if mountit /dev/fd0 /modules/scsi "-o ro"; then
echo "${GREEN}OK.${NORMAL}"
return 0
fi
echo "${RED}NOT FOUND.${NORMAL}"
return 1
}

# Unmount module disk
umountmodules(){
echo -n "${CRE}${BLUE}Unmounting $1 modules disk... ${NORMAL}"
umount /modules/scsi 2>/dev/null
echo "${GREEN}DONE.${NORMAL}"
}

# Ask user for modules
askmodules(){
TYPE="$1"; shift
echo "${BLUE}${TYPE} modules available:${WHITE}"
c=""; for m in "$@"; do
if test -f "/modules/scsi/$m"; then
test -z "$c"  && { echo -n "	$m"; c="1"; } || { echo "		$m"; c=""; }
fi
done
[ -n "$c" ] && echo ""
echo "${CYAN}Load ${TYPE} Modules?${NORMAL}"
echo "${CYAN}[Enter full filename(s) (space-separated), Return for autoprobe, ${WHITE}n${CYAN} for none] ${NORMAL}"
echo -n "${CYAN}insmod module(s)> ${NORMAL}"
read MODULES
case "$MODULES" in n|N) MODULES=""; ;; y|"")  MODULES="$*"; ;; esac
}

insmodule(){
echo -n "${CRE}${BLUE}Probing $1... ${MAGENTA}$2${NORMAL}    "
if [ -f /modules/$3/$2 ] && $INSMOD -f /modules/$3/$2 >/dev/null 2>&1; then
case "$2" in
00_*);;
*) echo "${CRE} ${GREEN}Found $1 device(s) handled by ${MAGENTA}$2${GREEN}.${NORMAL}";;
esac
return 0
fi
return 1
}

# Try to load the given modules (full path or current directory)
loadmodules(){
TYPE="$1"; shift
test -n "$INTERACTIVE" && echo "6" > /proc/sys/kernel/printk
for i in "$@"; do
insmodule $TYPE $i scsi && case "$TYPE" in scsi|SCSI) FOUND_SCSI="yes";; esac
done
test -n "$INTERACTIVE" && echo "0" > /proc/sys/kernel/printk
echo -n "${CRE}"
}

# Use ide-cd for ATAPI-only CD-Rom(s)
MODULES="ide-cd.o"
# Check for IDE-SCSI capable CD-Rom(s) first
# WARNING: In Kernel 2.4.27, CD-Roms cease to work if both, ide-scsi and ide-cd, are loaded. :-(
[ -n "$IDECD" ] || MODULES="ide-scsi.o"
loadmodules IDECD $MODULES

# Check for SCSI, use modules on bootfloppy first
if test -n "$INTERACTIVE"; then
# Let the user select interactively
askmodules SCSI $(cd /modules/scsi; echo *.o)
else
# these are the autoprobe-safe modules
MODULES="$SCSI_MODULES"
fi
test -z "$NOSCSI" && test -n "$MODULES" && loadmodules SCSI $MODULES
# End of SCSI check

# Check for IDE-Raid devices
test -z "$NOIDERAID" && ( cd /modules/scsi; { $INSMOD ataraid.o >/dev/null 2>&1 && $INSMOD silraid.o >/dev/null 2>&1 ; } || $INSMOD medley.o >/dev/null 2>&1 || $INSMOD pdcraid.o >/dev/null 2>&1 )
# End of IDE-Raid check

hotplug_device(){
 FOUND=""
 if [ -f /modules/scsi/$2 ]; then
   echo -n "${CRE}${BLUE}Checking for $1...${NORMAL}"
   $INSMOD /modules/scsi/$2 >/dev/null 2>&1
   for i in $3; do
     echo -n "${CRE}${BLUE}Loading $i...${NORMAL}"
     [ -f /modules/scsi/$i ] && $INSMOD /modules/scsi/$i >/dev/null 2>&1 && FOUND="yes"
   done
   if [ -n "$FOUND" ]; then
     while [ -n "$4" ]; do
       $INSMOD /modules/scsi/$4 >/dev/null 2>&1
       shift
     done
   fi
   echo -n "${CRE}"
 fi
 [ -n "$FOUND" ] && return 0;
 return 1
}

# Check for USB, use modules on bootfloppy first
[ -z "$NOUSB" ] && hotplug_device USB \
usbcore.o "$USB" "usb-storage.o" && FOUNDUSB="yes"

# Check for Firewire, use modules on bootfloppy first
[ -z "$NOFIREWIRE" ] && hotplug_device Firewire \
ieee1394.o "ohci1394.o" "sbp2.o sbp2_serialize_io=1" && FOUNDFIREWIRE="yes"

# Unfortunately, hotpluggable devices tend to need some time in order to register
if test -n "$FOUNDUSB" -o -n "$FOUNDFIREWIRE"; then
echo -n "${CRE}${BLUE}Scanning for USB/Firewire devices... ${NORMAL}"
if test -n "$FOUNDFIREWIRE"; then
# Wait for driver to register
sleep 2
# Kernel 2.6 does this automatically
case "$(cat /proc/version 2>/dev/null)" in *version\ 2.6.*) ;; *) for host in 0 1 2 3 4 5 6 7; do for channel in 0 1; do for id in 0 1 2 3 4 5 6 7; do echo "scsi add-single-device $host $channel $id 0" >/proc/scsi/scsi 2>/dev/null; done; done; done ;; esac
fi
sleep 6
echo "${BLUE}Done.${NORMAL}"
fi

# Check for misc modules in expert mode
if test -n "$INTERACTIVE"; then
another=""; answer=""
while test "$answer" != "n" -a "$answer" != "N"; do
echo -n "${CYAN}Do you want to load additional modules from$another floppy disk? [${WHITE}Y${CYAN}/n] ${NORMAL}"
another=" another"
read answer
case "$answer" in n*|N*) break; ;; esac
if mountmodules new; then
askmodules new $(cd /modules/scsi; echo *.o)
test -n "$MODULES" && loadmodules new $MODULES
umountmodules current
fi
done
fi
# All interactively requested modules should be loaded now.

# Check for ide-scsi supported CD-Roms et al.
test -f /proc/scsi/scsi && FOUND_SCSI="yes"

# Disable kernel messages again
echo "0" > /proc/sys/kernel/printk

# We now enable DMA right here, for faster reading/writing from/to IDE devices
# in FROMHD or TORAM mode
if [ -z "$NODMA" ]; then
for d in $(cd /proc/ide 2>/dev/null && echo hd[a-z]); do
if test -d /proc/ide/$d; then
MODEL="$(cat /proc/ide/$d/model 2>/dev/null)"
test -z "$MODEL" && MODEL="[GENERIC IDE DEVICE]"
echo "${BLUE}Enabling DMA acceleration for: ${MAGENTA}$d        ${YELLOW}[${MODEL}]${NORMAL}"
echo "using_dma:1" >/proc/ide/$d/settings
fi
done
fi

if [ -f /static/pump ]; then
 ifconfig lo 127.0.0.1 up
 NFSMODULES="af_packet.o sunrpc.o lockd.o nfs.o"
 for i in $NFSMODULES; do $INSMOD /modules/net/$i 2>/dev/null; done
 for i in $(cd /modules/net; echo *.o); do
  case "$NFSMODULES" in
  *$i*) ;;
  *) insmodule network $i net;;
  esac
 done
 DHCP=""; for i in 1 2 3 4 5; do
  echo -n "${CRE}${BLUE}DHCP Broadcasting for IP address ($i)... ${NORMAL}"
  pump -v && DHCP="true" && break
  echo "${RED}No answer from network.${NORMAL}"
 done
 if [ -n "$DHCP" ];then
  pump -s | while read x ip; do case "$x" in IP:) echo -n "${YELLOW}${ip}${NORMAL}"; break;; esac; done
  portmap && echo "${BLUE}, Portmapper started.${NORMAL}"
# can't mount NFSDIR? ask pump for the second server or the dhcp server
  mountnfs || {
   for i in [Nn]ext Boot boot; do
    pump -s | while read next server ip; do
     case "$next $server" in 
     $i\ [Ss]erver) [ "$ip" != "0.0.0.0" ] && NFSROOT="$ip" && break 2;;
     esac
    done
   done
# still nothing? try the default or ask user
   [ -z "$NFSROOT" ] && NFSROOT=192.168.0.1
   for i in knoppix cdrom 2 1 0; do
    case "$i" in
    ?) echo -n "${CYAN}Please enter NFS path ($NFSDIR): $NORMAL"; read NFSDIR;;
    *) NFSDIR="${NFSROOT}:/$i";;
    esac
    mountnfs && break
   done
  }
 fi
fi
if [ -z "$FOUND_KNOPPIX" ]; then
 for i in $(disk_list "$NOCD"); do
  showtryaccess $i CDROM
  if mountit $i /cdrom "-o ro$SECURE" >/dev/null 2>&1; then
   [ -d /cdrom/$KNOPPIXDIR ] && FOUND_KNOPPIX="$i" && break
   umount /cdrom
  fi
 done
fi
if [ -n "$FOUND_KNOPPIX" ]; then
 showaccess $FOUND_KNOPPIX "$KNOPPIXDIR CDROM"
 [ -f /cdrom/$KNOPPIXDIR/linuxrc ] && . /cdrom/$KNOPPIXDIR/linuxrc
fi
else
 echo "${CRE} ${GREEN}Running ${KNOPPIXDIR}/linuxrc from ${MAGENTA}$FOUND_KNOPPIX${GREEN}...${NORMAL}"
fi	#linuxrc

mount_cloop() {
 if [ -r $1 ]; then
  $INSMOD -f /modules/cloop.o file=$1 $2
  CLOOP_FILE=$1
  mountit /dev/cloop /KNOPPIX "-o ro$SECURE"
 fi
 /KNOPPIX/bin/ln -s /cdrom/KNOPPIX/* /KNOPPIX 2> /dev/null
 [ -x /KNOPPIX/bin/ls ] || FOUND_KNOPPIX=""
}

if test -n "$FOUND_KNOPPIX"; then
 if [ -n "$KNOPPIXISO" -a -x /static/isopos ]; then
   KNOPPIXOFS="offset=$(/static/isopos /cdrom/$KNOPPIXISO $KNOPPIXDIR/$KNOPPIX; echo $?)"
   mount_cloop /cdrom/$KNOPPIXISO $KNOPPIXOFS
 else  
   [ -n "$KNOPPIXOFS" ] && KNOPPIXOFS="offset=$KNOPPIXOFS"
   mount_cloop /cdrom/$KNOPPIXDIR/$KNOPPIX $KNOPPIXOFS
 fi  
fi

# copy library cache 
cat /KNOPPIX/etc/ld.so.cache > /etc/ld.so.cache 2> /dev/null

# Now tell kernel where the real modprobe lives
echo "/sbin/modprobe" > /proc/sys/kernel/modprobe

# Copy the whole cdrom to ram/hd ?
if [ -n "$COPYTO" -a -n "$FOUND_KNOPPIX" ]; then
  /bin/mkdir /cdrom2
  echo "${CRE} ${GREEN}Copying ${KNOPPIXDIR} CDROM to ${MAGENTA}$COPYTO${GREEN}... Please be patient. ${NORMAL}"
  ERRMSG="${MAGENTA}${COPYTO}${RED} is not mountable."
  FILES="/cdrom/$KNOPPIXDIR/"
  [ -z "$NOCD" ] && FILES="/cdrom/"
  if [ -z "CDSIZE" ]; then
    CDSIZE="$(/usr/bin/du -s $FILES | /usr/bin/gawk '{print int($1*1.1)}')"
    test -n "$CDSIZE" || CDSIZE="800000"
  fi
  if [ "$COPYTO" = "ramdisk" ]; then
    /bin/mount -t tmpfs -o size=${CDSIZE}k /dev/shm /cdrom2 || COPYTO=""
  else
    /bin/mount $COPYTO /cdrom2 >/dev/null 2>&1 || COPYTO=""
  fi
  if [ -n "$COPYTO" ]; then
    ERRMSG="Not enough free space on ${MAGENTA}${COPYTO}${RED}"
    CDFREE="$(/bin/df -k /cdrom2 | /usr/bin/tail -1 | /usr/bin/gawk '{ print $4 }')"
    COLOR="$BLUE"
    [ $CDFREE -lt $CDSIZE ] && COLOR="$RED" && COPYTO=""
    echo "${CRE} ${COLOR}Free space found: ${MAGENTA}${CDFREE}k${COLOR} Need: ${MAGENTA}${CDSIZE}k${COLOR} ${NORMAL}"
  fi
  if [ -n "$COPYTO" ]; then
    ERRMSG="Is ${MAGENTA}${COPYTO}${RED} full ?"
    if [ -x /usr/bin/rsync ]; then
      /usr/bin/rsync -a --progress /cdrom/$KNOPPIXDIR/$KNOPPIX /cdrom2 || COPYTO=""
      /usr/bin/rsync -aH $FILES /cdrom2 || COPYTO=""
    else
      /bin/cp -a $FILES /cdrom2 || COPYTO=""
    fi
  fi
  if [ -n "$COPYTO" ]; then
    umount /KNOPPIX
    echo "$RMMOD cloop" | /static/ash # release CD - ash crashes with parts of libc in memory -- FF
    umount /cdrom
    mount_cloop /cdrom2/$KNOPPIXDIR/$KNOPPIX
  else  
    echo "${CRE} ${RED}Copying ${KNOPPIXDIR} CDROM failed. $ERRMSG${NORMAL}"
  fi
fi 
 
# Final test if everything succeeded.
if test -n "$FOUND_KNOPPIX"
then

# Enable kernel messages
echo "6" > /proc/sys/kernel/printk

# Set paths
echo -n "${CRE}${BLUE}Setting paths...${NORMAL}"
PATH="/sbin:/bin:/usr/sbin:/usr/bin:/usr/X11R6/bin:."
export PATH

# Debian weirdness
/bin/cp -a /KNOPPIX/etc/alternatives /etc/ 2>/dev/null

# Replace /sbin ( /KNOPPIX/lib was a link to /static/lib/ )
/KNOPPIX/bin/rm -f /sbin
/KNOPPIX/bin/ln -sf /KNOPPIX/sbin /sbin

# From here, we should have all essential commands available.
hash -r

#/bin/mount -o remount,rw /cdrom
#exec >/cdrom/KNOPPIX/linuxrc.log </cdrom/KNOPPIX/linuxrc.log 2>&1
#set -x

echo "/dev/ram1 / ext2 rw 0 0" > /etc/mtab
egrep " /KNOPPIX | /cdrom " /proc/mounts | sed 's|/dev/cloop \(.*\) 0 0|'$CLOOP_FILE' \1,loop=/dev/cloop 0 0|g' >> /etc/mtab

# Did we copy from ram/hd ? 
if  test -n "$COPYTO"; 
then 
  rmdir /cdrom 
  ln -s /cdrom2 /cdrom # make a symlink and go on to normal boot 
  /bin/mount -o remount,ro /cdrom2
fi

[ -n "$FAKE" -a -n "$KNOPPIXOFS" ] && /bin/mount -o loop,ro /cdrom/$KNOPPIXDIR/$KNOPPIX /cdrom
[ -n "$KNOPPIXISO" ] && /bin/mount -o loop,ro /cdrom/$KNOPPIXISO /cdrom

# Clean up /
rm -rf /modules /static

BUILTDATE=$(stat /KNOPPIX | grep "^Access: 2" | cut -d ' ' -f2)
echo "${CRE}${BLUE}Built on ${GREEN}${BUILTDATE}${BLUE} with kernel ${GREEN}$(uname -r -v)${NORMAL}"

cpln(){ while [ -n "$1" ]; do rm -rf $1; cp -a /KNOPPIX/$1 $1; shift; done }

echo -n "${CRE}${BLUE}Creating directories and symlinks on /etc...${NORMAL}"
# Create common WRITABLE (empty) dirs
mkdir -p /mnt/cdrom /mnt/floppy /mnt/hd /mnt/test \
	 /root /etc/sysconfig /etc/X11 /etc/cups /etc/dhcpc /etc/ntp
cp -aus /dev/capi /dev/ 2>/dev/null
ln -s /KNOPPIX/dev/*/ /dev/ 2>/dev/null
cp -a /KNOPPIX/dev/* /dev/ 2>/dev/null
rm -f /etc/resolv.conf 2>/dev/null
ln -s /KNOPPIX/etc/skel /KNOPPIX/etc/nessus /etc/dhcpc/resolv.conf \
      /etc/ 2>/dev/null
cp -aus /KNOPPIX/etc/* /etc/ 2>/dev/null
# Make SURE that these are files, not links!
cpln /etc/ftpusers /etc/passwd /etc/*shadow /etc/group /etc/cups/*.conf \
     /etc/ppp /etc/isdn /etc/ssh /etc/inittab /etc/network /etc/sudoers \
     /etc/init /etc/dhcpc /etc/samba/smbpasswd /etc/adjtime \
     /etc/localtime 2> /dev/null
if [ -n "$SECURE" -a -f /etc/inittab.secure ]; then
rm -f /etc/inittab
mv -f /etc/inittab.secure /etc/inittab
fi
# Extremely important, init crashes on shutdown if this is only a link
rm -rf /etc/ioctl.save /etc/pnm2ppa.conf
:> /etc/ioctl.save
:> /etc/pnm2ppa.conf

# New in Kernel 2.4.x: tempfs with variable ramdisk size.
# We check for available memory anyways and limit the ramdisks
# to a reasonable size.
FOUNDMEM="$(awk '/MemTotal/{print $2}' /proc/meminfo)"
TOTALMEM="$(awk 'BEGIN{m=0};/MemFree|Cached/{m+=$2};END{print m}' /proc/meminfo)"
 
# Be verbose
echo "${CRE}${BLUE}Total memory found: ${YELLOW}${FOUNDMEM}${BLUE} kB${NORMAL}"

# Now we need to use a little intuition for finding a ramdisk size
# that keeps us from running out of space, but still doesn't crash the
# machine due to lack of Ram

# Minimum size of additional ram partitions
MINSIZE=2000
# At least this much memory minus 30% should remain when home and var are full.
MINLEFT=16000
# Maximum ramdisk size
MAXSIZE="$(expr $TOTALMEM - $MINLEFT)"
# Default ramdisk size for ramdisk
RAMSIZE="$(expr $TOTALMEM / 5)"

trymount() {
CMD="/bin/mount -t auto -o rw"; [ -b "$1" ] || CMD="$CMD,loop"
$CMD "$1" "$2" && return 0
echo "${CYAN}Filesystem not autodetected, trying to mount $1 with AES256 encryption${NORMAL}"
a="y"
while [ "$a" != "n" -a "$a" != "N" ]; do
 $CMD,encryption=AES256 "$1" "$2" && return 0
 echo -n "${RED}Mount failed, retry? [Y/n] ${NORMAL}"
 read a
done
return 1   
}

mountlp() {
  /bin/mount $1 -o remount,rw
  trymount /$1/$HARDDISK /harddisk || return 1
  showaccess "$2" "disk image ${MAGENTA}$HARDDISK${GREEN}"
  return 0
}

if [ -n "$HARDDISKDEV$HARDDISK" ]; then
mkdir /harddisk
if [ -z "$HARDDISK" ]; then
 showaccess $HARDDISKDEV "disk"
 trymount $HARDDISKDEV /harddisk || rmdir /harddisk
else   
 if [ -f /cdrom/$HARDDISK ] && mountlp /cdrom /cdrom; then
 else
   echo "0" > /proc/sys/kernel/printk
   for i in $(echo $HARDDISKDEV; disk_list "NOCD"); do
     mkdir /disk
     showtryaccess $i "disk image $HARDDISK"
     if /bin/mount -o ro $i /disk >/dev/null 2>&1; then
       test -r /disk/$HARDDISK && mountlp /disk "$i" && break
     fi
     /bin/umount /disk 2> /dev/null
     rmdir /disk
   done
   [ -d /disk ] || rmdir /harddisk
 fi  
fi
echo "6" > /proc/sys/kernel/printk
fi
[ -d /var ] && mv /var /root	# /var/run/pump.sock
if [ -d /harddisk ]; then
mkdir -p /harddisk/home /harddisk/var && ln -s /harddisk/home /harddisk/var /
[ -f /harddisk/swapfile ] && swapon /harddisk/swapfile
else
# Check for sufficient memory to mount extra ramdisk for /home + /var
if test -n "$TOTALMEM" -a "$TOTALMEM" -gt "$MINLEFT"; then
test -z "$RAMSIZE" && RAMSIZE=1000000
mkdir -p /ramdisk
# tmpfs/varsize version, can use swap
RAMSIZE=$(expr $RAMSIZE \* 4)
echo -n "${CRE}${BLUE}Creating ${YELLOW}/ramdisk${BLUE} (dynamic size=${RAMSIZE}k) on ${MAGENTA}shared memory${BLUE}...${NORMAL}"
# We need /bin/mount here for the -o size= option
/bin/mount -t tmpfs -o "size=${RAMSIZE}k" /ramdisk /ramdisk && mkdir -p /ramdisk/home /ramdisk/var && ln -s /ramdisk/home /ramdisk/var /
echo "${BLUE}Done.${NORMAL}"
else
mkdir -p /home /var
fi
fi

if [ ! -d /var/run ]; then
echo -n "${CRE}${BLUE}Creating directories and symlinks on ramdisk...${NORMAL}"
mkdir -p /var/run /var/backups /var/cache/apache /var/local /var/lock/news \
         /var/nis /var/preserve /var/state/misc /var/tmp /var/lib \
	 /var/spool/cups/tmp /var/lib/samba \
         /home/knoppix/partage
chown knoppix.knoppix /home/knoppix /home/knoppix/partage
# Create empty utmp and wtmp
:> /var/run/utmp
:> /var/run/wtmp
# All files in here should be size zero after Knoppix.clean was run
cp -a /KNOPPIX/var/local /KNOPPIX/var/games /KNOPPIX/var/log \
      /KNOPPIX/var/spool /var/ 2>/dev/null
cp -a /KNOPPIX/var/lib/games /KNOPPIX/var/lib/wine \
      /KNOPPIX/var/lib/nfs /KNOPPIX/var/lib/xkb /KNOPPIX/var/lib/isdn \
      /KNOPPIX/var/lib/kdm /KNOPPIX/var/lib/pcmcia \
      /KNOPPIX/var/lib/dhcp* \
      /var/lib/ 2>/dev/null
# Problematic directories in /var/lib (lots and lots of inodes)
ln -s /KNOPPIX/var/lib/dpkg /KNOPPIX/var/lib/apt /KNOPPIX/var/lib/doc-base \
      /KNOPPIX/var/lib/gnome /KNOPPIX/var/lib/kde \
      /KNOPPIX/var/lib/scrollkeeper /KNOPPIX/var/lib/texmf \
      /var/lib/ 2>/dev/null
# Debian-apt
ln -s /KNOPPIX/var/cache/apt /var/cache/ 2>/dev/null
# Index files can be HUGE, so better replace cache/man tree by links later
# cp -a /KNOPPIX/var/cache/man /var/cache/ 2>/dev/null
# Create links from CDROM for UNWRITABLE (remaining) files
cp -aus /KNOPPIX/var/* /var/ 2>/dev/null
# Must exist for samba to work
[ -d /var/lib/samba ] && :> /var/lib/samba/unexpected.tdb
echo "${BLUE}Done.${NORMAL}"
fi

\rm -R /tmp/.[Xs]* 2> /dev/null
\rm /var/lock/LCK* /var/spool/uucp/LCK* /tmp/LCK* /var/run/*.pid 2> /dev/null

[ -n "$NFSDIR" ] && pump -v # get nameserver

# Change root device from /dev/fd0 to /dev/ram0
echo "0x100" > /proc/sys/kernel/real-root-dev

# Give control to the init process.
echo -n "${CRE}${BLUE}Starting init process.${NORMAL} "
#rm -f /linuxrc
mv /linuxrc /tmp/.linuxrc
exit 0

else
echo "${CRE}${RED}Can't find ${KNOPPIXDIR} filesystem, sorry.${NORMAL}"
echo "${RED}Dropping you to a (very limited) shell.${NORMAL}"
echo "${RED}Press reset button to quit.${NORMAL}"
echo ""
echo "Additional builtin commands avaliable:"
echo "	cat        mount     umount"
echo "	insmod     rmmod     lsmod"
echo ""
PS1="knoppix# "
export PS1
echo "6" > /proc/sys/kernel/printk
# Allow signals
trap 1 2 3 15
echo "Modules loaded:" ; cat /proc/modules
exec /static/ash
fi