#!/bin/bash

#
# Builds Magellan Livecd's 0.3.6-r7
#

source /etc/sysconfig/rc
source $rc_functions

### setup ###
export LIVECDROOT=/mnt/mlivecdbuild-0.3.6-r7
export CDCHROOTDIR=${LIVECDROOT}/chroot
export CDISOROOT=${LIVECDROOT}/isoroot
export CDMAGEDIR=${LIVECDROOT}/files/mage-src
export CDMAGERC=${CDMAGEDIR}/mage.rc
export CDISONAME=magellan-livecd.iso
export CDHOSTNAME=magellan-live
export CDTOOLCHAIN=${LIVECDROOT}/files/magellan-toolchain-0.3-i486.tar.bz2
export CDLAYOUTDIR=${LIVECDROOT}/files/

export CDLAYOUTFILE=magellan_layout-i686-mage-0.3.99-r1-kernel26


# usbstick: vfat doesn't like CAPS and strings longer than 8 chars
export CDID=cdid
export VERSION=0.3.6-r7
export CDINITRD=${LIVECDROOT}/mntinitrd
export CDISOLOOP=${LIVECDROOT}/isoloop

# kernel 2.4.22 needs cloop-1.02, smaller or above will not work >:/ *grrr*
export CLOOPFILE=cloop-1.02-precompiled.tar.bz2
export CLOOPDIR=cloop-1.02

# busybox-0.60.3 is official stable
export BUSYBOXFILE=busybox-1.00-precompiled.tar.bz2
export BUSYBOXDIR=busybox-1.00

export SEDFILE=sed-4.0.9-static.tar.bz2
export SEDDIR=sed-4.0.9

#kernelname must be the same in the isolinux.cfg/syslinux.cfg
CDKERNELNAME=magelive
###############

#small fix: livecdkernel

#global settings#
#################


#user settings#
###############
CDMAGEPROFILE=mage040-26

#if you want use cloop
#CDCOMPRESS_METHOD=cloop

#if you want use squashfs
CDCOMPRESS_METHOD=squashfs

### functions ###

die() {
	DIE="yes"
}

secho() {
	local I
	I="$@"
	echo -e "\n${COLOREDSTAR}${I}"
}

mecho() {
	local I
	I="$@"
	echo -e "${COLMAGENTA}\t${I}${COLDEFAULT}"
}

showversion() {
	echo -en "Magellan LiveCD Generate v${VERSION} "
	echo -e  "-- Niels Rogalla (niro@magellan-linux.de)"
}

create_chrootdirs() {
	# creating directories
	mkdir -p ${CDCHROOTDIR}/{bin,boot,dev/shm,etc,home,lib/dev-state,mnt,proc} \
		&>/dev/null || die
	mkdir -p ${CDCHROOTDIR}/etc/{opt,env.d} &>/dev/null || die
	mkdir -p ${CDCHROOTDIR}/mnt/{floppy,cdrom,magellan} &>/dev/null || die
	mkdir -p ${CDCHROOTDIR}/{root,sbin,tmp,usr/local,var,opt} &>/dev/null || die
	for dirname in ${CDCHROOTDIR}/usr ${CDCHROOTDIR}/usr/local
	do
		mkdir $dirname/{bin,etc,include,lib,sbin,share,src} &>/dev/null || die
		ln -s share/{man,doc,info} $dirname &>/dev/null || die
		mkdir $dirname/share/{dict,doc,info,locale,man} &>/dev/null || die
		mkdir $dirname/share/{nls,misc,terminfo,zoneinfo} &>/dev/null || die
		mkdir $dirname/share/man/man{1,2,3,4,5,6,7,8} &>/dev/null || die
	done
	mkdir ${CDCHROOTDIR}/var/{lock,log,mail,run,spool} &>/dev/null || die
	mkdir -p ${CDCHROOTDIR}/var/{tmp,opt,cache,lib/misc,local} &>/dev/null || die
	mkdir ${CDCHROOTDIR}/opt/{bin,doc,include,info} &>/dev/null || die
	mkdir -p ${CDCHROOTDIR}/opt/{lib,man/man{1,2,3,4,5,6,7,8}} &>/dev/null || die

	chmod 0750 ${CDCHROOTDIR}/root &> /dev/null || die
	chmod 1777 ${CDCHROOTDIR}/tmp &> /dev/null || die
	chmod 1777 ${CDCHROOTDIR}/var/tmp &> /dev/null || die

	## creating .keep files
	touch ${CDCHROOTDIR}/{bin,boot,dev/shm,etc,home,lib/dev-state,mnt,proc}/.keep \
		&>/dev/null || die
	touch ${CDCHROOTDIR}/etc/{opt,env.d}/.keep &>/dev/null || die
	touch ${CDCHROOTDIR}/mnt/{floppy,cdrom}/.keep &>/dev/null || die
	touch ${CDCHROOTDIR}/dev/.keep &>/dev/null || die
	touch ${CDCHROOTDIR}/etc/.keep &>/dev/null || die
	touch ${CDCHROOTDIR}/{root,sbin,tmp,usr/local,var,opt}/.keep &>/dev/null || die
	touch ${CDCHROOTDIR}/usr/.keep &>/dev/null || die
	for dirname in ${CDCHROOTDIR}/usr ${CDCHROOTDIR}/usr/local
	do
		touch $dirname/{bin,etc,include,lib,sbin,share,src}/.keep &>/dev/null || die
		touch $dirname/share/{dict,doc,info,locale,man}/.keep &>/dev/null || die
		touch $dirname/share/{nls,misc,terminfo,zoneinfo}/.keep &>/dev/null || die
		touch $dirname/share/man/man{1,2,3,4,5,6,7,8}/.keep &>/dev/null || die
	done
	touch ${CDCHROOTDIR}/var/.keep &>/dev/null || die
	touch ${CDCHROOTDIR}/var/{lock,log,mail,run,spool}/.keep &>/dev/null || die
	touch ${CDCHROOTDIR}/var/{tmp,opt,cache,lib/misc,local}/.keep &>/dev/null || die
	touch ${CDCHROOTDIR}/opt/.keep &>/dev/null || die
	touch ${CDCHROOTDIR}/opt/{bin,doc,include,info}/.keep &>/dev/null || die
	touch ${CDCHROOTDIR}/opt/{lib,man/man{1,2,3,4,5,6,7,8}}/.keep &>/dev/null || die
	touch ${CDCHROOTDIR}/opt/man/.keep &>/dev/null || die

	##Creating the bash and sh symlinks
	ln -s /tools/bin/{bash,cat,pwd,stty} ${CDCHROOTDIR}/bin &>/dev/null || die
	#ln -s /tools/bin/perl ${CDCHROOTDIR}/usr/bin &>/dev/null || die
	ln -s /tools/lib/libgcc_s.so.1 ${CDCHROOTDIR}/usr/lib &>/dev/null || die
	ln -s bash ${CDCHROOTDIR}/bin/sh &>/dev/null || die
	ln -s /tools/bin/{basename,cut,fgrep,grep} ${CDCHROOTDIR}/bin &>/dev/null || die
	ln -s /tools/bin/whoami ${CDCHROOTDIR}/usr/bin &>/dev/null || die
	ln -s /tools/bin/{date,ls,egrep,wc} ${CDCHROOTDIR}/bin &>/dev/null || die
	ln -s /tools/sbin/ldconfig ${CDCHROOTDIR}/sbin/ldconfig &>/dev/null || die
	ln -s /tools/bin/sed ${CDCHROOTDIR}/bin || die
	ln -s /tools/bin/dirname ${CDCHROOTDIR}/usr/bin || die

	## needed empty files (to prevent warnings only)
	touch ${CDCHROOTDIR}/etc/env.d/dummy || die
	touch ${CDCHROOTDIR}/etc/profile || die

	if [ -n "${DIE}" ]
	then
		return 1
	else
		return 0
	fi
}

chroot_generate() {
	secho Generating Chroot ...

	mecho Creating chroot directory ...
	mkdir -p ${CDCHROOTDIR} || die
	evaluate_retval

	mecho Unpacking toolchain ...
	if [ "${CDTOOLCHAIN##*.}" == "bz2" ]
	then
		tar xjpmf ${CDTOOLCHAIN} -C ${CDCHROOTDIR}
		evaluate_retval
	fi

	if [ "${CDTOOLCHAIN##*.}" == "gz" ]
	then
		tar xzpmf ${CDTOOLCHAIN} -C ${CDCHROOTDIR}
		evaluate_retval
	fi

	mecho Changing ownership of the toolchain ...
	chown -R 0:0 ${CDCHROOTDIR}/tools
	evaluate_retval

	mecho Creating directories and symlinks ...
	create_chrootdirs
	evaluate_retval

	mecho Creating needed devices for devfs/udev ...
	( mknod -m 611 ${CDCHROOTDIR}/dev/console c 5 1 &>/dev/null && \
		chgrp 4 ${CDCHROOTDIR}/dev/console &>/dev/null &&
		mknod -m 666 ${CDCHROOTDIR}/dev/null c 1 3 &>/dev/null )
	evaluate_retval

	mecho Creating basic passwd file ...
	cat > ${CDCHROOTDIR}/etc/passwd << "EOF"
root:x:0:0:root:/root:/bin/bash
EOF
	evaluate_retval

	mecho Creating basic groups file ...
cat > ${CDCHROOTDIR}/etc/group << "EOF"
root:x:0:
bin:x:1:
sys:x:2:
kmem:x:3:
tty:x:4:
tape:x:5:
daemon:x:6:
floppy:x:7:
disk:x:8:
lp:x:9:
dialout:x:10:
audio:x:11:
EOF
	evaluate_retval
}

enter_chroot() {
	secho Entering Chroot ...
	mount proc ${CDCHROOTDIR}/proc -t proc
	# devfs is deprecated with kernel-2.6
	#mount devfs ${CDCHROOTDIR}/dev -t devfs
	mount -o bind /dev ${CDCHROOTDIR}/dev

	getstate
	if [ "${CDSTATE}" != "null" ]
	then
		chroot ${CDCHROOTDIR} /usr/bin/env -i \
			HOME=/root TERM=$TERM PS1='\u:\w\$ ' \
			PATH=/bin:/usr/bin:/sbin:/usr/sbin \
			/bin/bash -i
	else
		chroot ${CDCHROOTDIR} /tools/bin/env -i \
			HOME=/root TERM=$TERM PS1='\u:\w\$ ' \
			PATH=/bin:/usr/bin:/sbin:/usr/sbin:/tools/bin \
			/tools/bin/bash -i
	fi

	secho Unmounting Chroot filesystems ...
	( umount ${CDCHROOTDIR}/proc && \
		umount ${CDCHROOTDIR}/dev )
	evaluate_retval
}

install_mage_bashrc() {
	cat >> ${CDCHROOTDIR}/root/.bashrc << "EOF"
		mecho Updating MAGE tree ...
		mage update &> /dev/null
		evaluate_retval
EOF
}

install_cdlayout_bashrc() {
	cat >> ${CDCHROOTDIR}/root/.bashrc << "EOF"
		secho Installing CD Layout ...
		for package in $(cat /bootstrap/${CDLAYOUTFILE})
		do
			if [ -n "$package" ]
			then
				mecho Installing ${package}
				#unset CONFIG_PROTECT and install
				CONFIG_PROTECT="-*" /sbin/mage install ${package} #&> /dev/null
				#echo "debug: next"
				#read
				evaluate_retval
			fi
		done

		#needed for >=mage-0.3.6
		mecho Running etc-update ...
		etc-update
		evaluate_retval

		mecho Cleaning MAGE tree ...
		/sbin/mage clean &> /dev/null
		evaluate_retval

		secho CD Layout Installation complete.
EOF
}

import_functions_bashrc() {
	cat ${rc_functions} > ${CDCHROOTDIR}/root/.bashrc
	cat >> ${CDCHROOTDIR}/root/.bashrc << "EOF"
		die() {
			DIE="yes"
		}
		secho() {
			local I
			I="$@"
			echo -e "\n${COLOREDSTAR}${I}"
		}
		mecho() {
			local I
			I="$@"
			echo -e "${COLMAGENTA}\t${I}${COLDEFAULT}"
		}
EOF
	echo "export CDLAYOUTFILE=${CDLAYOUTFILE}" \
		>> ${CDCHROOTDIR}/root/.bashrc
	echo "export PATH=/bin:/usr/bin:/sbin:/usr/sbin:/tools/bin" \
		>> ${CDCHROOTDIR}/root/.bashrc
}

cleanup_chrootdir() {
	secho Cleaning up Chroot directory ...

	mecho Deleting bootstrap files ...
	rm -rf ${CDCHROOTDIR}/bootstrap
	evaluate_retval

	mecho Deleting toolchain ...
	rm -rf ${CDCHROOTDIR}/tools
	evaluate_retval

	mecho Deleting bootstrap scripts ...
	( rm -rf ${CDCHROOTDIR}/root/.bashrc
	  rm -rf ${CDCHROOTDIR}/root/.bash_history )
	evaluate_retval

	touch ${LIVECDROOT}/.chcleanedok
}

build_bootstrap() {
	secho Preparing Chroot ...
	mecho Copy MAGE files to Chroot ...
	( install -d ${CDCHROOTDIR}/bootstrap && \
	  cp -R ${CDMAGEDIR}/* ${CDCHROOTDIR}/bootstrap )
	evaluate_retval
	
	# installing mage to CDCHROOTDIR
	mecho Installing Mage ...
	( chmod 0755 ${CDCHROOTDIR}/bootstrap/setup_mage.sh && \
	  ${CDCHROOTDIR}/bootstrap/setup_mage.sh \
		${CDCHROOTDIR} ${CDCHROOTDIR}/bootstrap ${CDMAGERC} ${CDMAGEPROFILE} )
	evaluate_retval

	mecho Creating taskfile ...
	 ( import_functions_bashrc && \
	   install_mage_bashrc && \
	   install_cdlayout_bashrc && \
	   echo "exit" >> ${CDCHROOTDIR}/root/.bashrc )
	evaluate_retval

	mecho Copy CD layout files ...
	cp ${CDLAYOUTDIR}/${CDLAYOUTFILE} ${CDCHROOTDIR}/bootstrap
	evaluate_retval

	mecho Mounting Chroot filesystems ...
	( mount proc ${CDCHROOTDIR}/proc -t proc && \
	  mount -o bind /dev ${CDCHROOTDIR}/dev )
	evaluate_retval

	secho Starting bootstrap ...
	chroot ${CDCHROOTDIR} /tools/bin/env -i \
		HOME=/root TERM=$TERM PS1='\u:\w\$ ' \
		PATH=/bin:/usr/bin:/sbin:/usr/sbin:/tools/bin \
		/tools/bin/bash -i

	mecho Unmounting Chroot filesystems ...
	( umount ${CDCHROOTDIR}/proc && \
		umount ${CDCHROOTDIR}/dev )
	evaluate_retval

	touch ${LIVECDROOT}/.bootstrapok
}


build_initrd() {
	secho Building initrd ...

	if [ -e ${LIVECDROOT}/initrd ]
	then
		mecho Removing old initrd
		rm -f ${LIVECDROOT}/initrd
	fi

	if [ -e ${LIVECDROOT}/initrd.gz ]
	then
		mecho Removing old initrd.gz
		rm -f ${LIVECDROOT}/initrd.gz
	fi

	if [ -d ${LIVECDROOT}/tmp/${CLOOPDIR} ]
	then
		mecho Removing old cloop files
		rm -rf ${LIVECDROOT}/tmp/${CLOOPDIR}
	fi

	if [ -d ${LIVECDROOT}/tmp/${BUSYBOXDIR} ]
	then
		mecho Removing old busybox files
		rm -rf ${LIVECDROOT}/tmp/${BUSYBOXDIR}
	fi

	mecho Unpacking needed files ...
	( mkdir -p ${LIVECDROOT}/tmp && \
	  tar xjf ${CDLAYOUTDIR}/${CLOOPFILE} -C ${LIVECDROOT}/tmp && \
	  tar xjf ${CDLAYOUTDIR}/${BUSYBOXFILE} -C ${LIVECDROOT}/tmp )
	evaluate_retval

	mecho Creating Image file ...
	dd if=/dev/zero of=${LIVECDROOT}/initrd bs=1024 count=6144 \
		&> /dev/null
	evaluate_retval

	mecho Formating Image file ...
	mke2fs -m 0 -i 1024 -F ${LIVECDROOT}/initrd &> /dev/null
	evaluate_retval

	mecho Mounting Image file ...
	( mkdir -p ${CDINITRD} && \
	  mount -o loop ${LIVECDROOT}/initrd ${CDINITRD} )
	evaluate_retval

	mecho Creating basic filesystem ...
	( mkdir -p ${CDINITRD}/{bin,etc/conf.d,lib/modules/misc,dev/pts,proc,mnt,usr,sys} && \
                cat > ${CDINITRD}/etc/fstab << "EOF"
/dev/ram0       /             cramfs defaults
proc            /proc         proc   defaults  0 0
EOF
	#installing cloop
	  cp ${LIVECDROOT}/tmp/${CLOOPDIR}/cloop.o ${CDINITRD}/lib/modules/misc && \

	#installing busybox
	  cp ${LIVECDROOT}/tmp/${BUSYBOXDIR}/busybox ${CDINITRD}/bin && \
	  chmod 0755 ${CDINITRD}/bin/busybox && \
	  for i in '[' ash basename cat cut chroot clear cp dirname echo env false find \
		grep gunzip gzip insmod ln ls loadkmap losetup lsmod mkdir mknod modprobe more mount mv \
		pivot_root ps pwd rm rmdir rmmod sh sleep tar test touch true umount uname \
		xargs yes zcat chmod chown
	  do
                rm -f ${CDINITRD}/bin/$i
                ln ${CDINITRD}/bin/busybox ${CDINITRD}/bin/$i
          done && \
	  #symlink bin to sbin -> init & insmod resist normally in sbin
	  ln -s bin ${CDINITRD}/sbin && \
	  ln -s ../bin ${CDINITRD}/usr/bin && \
	  ln -s ../bin ${CDINITRD}/usr/sbin && \
	  bzcat ${CDLAYOUTDIR}/MAKEDEV-1.7.bz2 > \
	  	${CDCHROOTDIR}/dev/MAKEDEV && \
	  chmod 754 ${CDCHROOTDIR}/dev/MAKEDEV && \
	  cd ${CDCHROOTDIR}/dev && \
	  ./MAKEDEV -v generic-nopty &> /dev/null && \
	  cd ${LIVECDROOT} && \
	  mknod -m 600 ${CDINITRD}/dev/console c 5 1 && \
	  mknod -m 666 ${CDINITRD}/dev/null c 1 3
	  cp ${CDCHROOTDIR}/etc/conf.d/kernel ${CDINITRD}/etc/conf.d/kernel )
	evaluate_retval
	
	# need udev ?
	if [ -f ${CDCHROOTDIR}/sbin/udev.static ]
	then
		mecho Installing udev support ...
		( cp ${CDCHROOTDIR}/sbin/udev.static ${CDINITRD}/sbin/udev && \
		  cp ${CDCHROOTDIR}/sbin/udevd.static ${CDINITRD}/sbin/udevd && \
		  cp ${CDCHROOTDIR}/sbin/udevsend.static ${CDINITRD}/sbin/udevsend && \
		  cp ${CDCHROOTDIR}/sbin/wait_for_sysfs.static ${CDINITRD}/sbin/wait_for_sysfs && \
		  cp ${CDCHROOTDIR}/sbin/scsi_id.static ${CDINITRD}/sbin/scsi_id && \
		  cp ${CDCHROOTDIR}/sbin/udev_volume_id.static ${CDINITRD}/sbin/udev_volume_id && \
		  cp ${CDCHROOTDIR}/etc/scsi_id.config ${CDINITRD}/etc && \
		  mkdir -p ${CDINITRD}/etc/hotplug.d/default && \
		  ln -snf ../../../sbin/udevsend ${CDINITRD}/etc/hotplug.d/default/10-udev.hotplug && \
		  ln -snf ../../../sbin/wait_for_sysfs ${CDINITRD}/etc/hotplug.d/default/05-wait_for_sysfs.hotplug && \
		  ln -s /sbin/udev ${CDINITRD}/sbin/udevstart && \
		  cp -a ${CDCHROOTDIR}/etc/udev ${CDINITRD}/etc/ )
		evaluate_retval
	fi

	# install modules
	install -d ${CDINITRD}/modules
	source ${CDCHROOTDIR}/boot/kernelversion
	CDMODDIR=${CDCHROOTDIR}/lib/modules/${KRNLIB}/kernel

	if [ -e ${CDLAYOUTDIR}/mods_scsi ]
	then
		mecho "Installing scsi modules"
		install -d ${CDINITRD}/modules/scsi
		for i in $(< ${CDLAYOUTDIR}/mods_scsi)
		do
			find ${CDMODDIR} -type f -name ${i}* -exec cp -a '{}' ${CDINITRD}/modules/scsi ';'
		done
		cat ${CDLAYOUTDIR}/mods_scsi > ${CDINITRD}/mods_scsi
	fi

	if [ -e ${CDLAYOUTDIR}/mods_usb ]
	then
		mecho "Installing usb modules"
		install -d ${CDINITRD}/modules/usb
		for i in $(< ${CDLAYOUTDIR}/mods_usb)
		do
			find ${CDMODDIR} -type f -name ${i}* -exec cp -a '{}' ${CDINITRD}/modules/usb ';'
		done
		cat ${CDLAYOUTDIR}/mods_usb > ${CDINITRD}/mods_usb
	fi

	#install insmod
	cp -a ${CDCHROOTDIR}/sbin/insmod.static ${CDINITRD}/bin/insmod.static
	cp -a ${CDCHROOTDIR}/sbin/insmod.static.old ${CDINITRD}/bin/insmod.static.old

	#install passwd & group file
	install -d ${CDINITRD}/etc
	cat ${CDCHROOTDIR}/etc/passwd > ${CDINITRD}/etc/passwd
	cat ${CDCHROOTDIR}/etc/group > ${CDINITRD}/etc/group

	#install static sed
	install -d ${CDINITRD}/bin
	tar xjf ${CDLAYOUTDIR}/${SEDFILE} -C ${LIVECDROOT}/tmp
	cp ${LIVECDROOT}/tmp/${SEDDIR}/sed ${CDINITRD}/bin

	mecho Creating linuxrc ...
	( cat ${CDLAYOUTDIR}/linuxrc > ${CDINITRD}/linuxrc && \
	  chmod 0755 ${CDINITRD}/linuxrc )
	evaluate_retval

	mecho Unmounting Image file ...
	umount ${CDINITRD}
	evaluate_retval

	mecho Compressing Image file
	gzip -9 ${LIVECDROOT}/initrd
	evaluate_retval

	touch ${LIVECDROOT}/.initrdok
}


prepare_iso() {
	secho Preparing LiveCD ISO Image ...

	if [ -e ${LIVECDROOT}/${CDISONAME} ]
	then
		mecho Removing old cdimage
		rm -f ${LIVECDROOT}/${CDISONAME}
	fi

	#fixes some issues with xfree/xorg xkb
	if [ -L "${CDCHROOTDIR}/etc/X11/xkb" -a -d "/usr/X11R6/lib/X11/xkb" ]
	then
		mecho fixing xkb symlink
		rm ${CDCHROOTDIR}/etc/X11/xkb
		mv ${CDCHROOTDIR}/usr/X11R6/lib/X11/xkb ${CDCHROOTDIR}/etc/X11
		ln -s ../../../../etc/X11/xkb ${CDCHROOTDIR}/usr/X11R6/lib/X11/xkb
	fi

	mecho Creating missing devices ...
	( bzcat ${CDLAYOUTDIR}/MAKEDEV-1.7.bz2 > \
	  	${CDCHROOTDIR}/dev/MAKEDEV && \
	  chmod 754 ${CDCHROOTDIR}/dev/MAKEDEV && \
	  cd ${CDCHROOTDIR}/dev && \
	  ./MAKEDEV -v generic-nopty &> /dev/null && \
	  cd ${LIVECDROOT} )
	evaluate_retval

	mecho Creating LiveCD Config files ...
	( cat ${CDLAYOUTDIR}/inittab > \
		${CDCHROOTDIR}/etc/inittab && \
	  chmod 0644 ${CDCHROOTDIR}/etc/inittab && \
	  cat ${CDLAYOUTDIR}/fstab > \
		${CDCHROOTDIR}/etc/fstab && \
	  chmod 0644 ${CDCHROOTDIR}/etc/fstab && \
	  cat ${CDLAYOUTDIR}/motd > \
		${CDCHROOTDIR}/etc/motd && \
	  chmod 0644 ${CDCHROOTDIR}/etc/motd && \
	  cat ${CDLAYOUTDIR}/issue > \
		${CDCHROOTDIR}/etc/issue && \
	  chmod 0644 ${CDCHROOTDIR}/etc/issue && \
	  echo "HOSTNAME=\"${CDHOSTNAME}\"" > ${CDCHROOTDIR}/etc/hostname )
	evaluate_retval

	mecho Setting up services ...
	( cat >> ${CDCHROOTDIR}/root/.bashrc << "EOF"

	  #change mountfs with mountfslivecd
	  rc-config del mountfs
	  rc-config add mountfslivecd

	  #add hardware detection
	  rc-config add hwdetect

	  #del checkfs
	  rc-config del checkfs

	  #exit
	  exit
EOF
	  #run it
	  enter_chroot

	  #clean up
	  if [ -e ${CDCHROOTDIR}/root/.bashrc ]
	  then
		rm ${CDCHROOTDIR}/root/.bashrc
	  fi
	  if [ -e ${CDCHROOTDIR}/root/.bash_history ]
	  then
		rm  ${CDCHROOTDIR}/root/.bash_history
	  fi )
	evaluate_retval

	mecho Cleaning unwanted files ...
	( if [ -e ${CDCHROOTDIR}/etc/mtab ]
	  then
	  	rm ${CDCHROOTDIR}/etc/mtab
	  fi && \
	  touch ${CDCHROOTDIR}/etc/mtab
	)
	evaluate_retval

	# mingetty needs a passwordless user for autologin
	# so we unset the password for 'root'
	cat > ${CDCHROOTDIR}/root/.bashrc << "EOF"
	passwd -d root
	exit
EOF

	 #run it
	enter_chroot
	if [ -e ${CDCHROOTDIR}/root/.bashrc ]
	then
		rm -f ${CDCHROOTDIR}/root/.bashrc
	fi

	if [ -e ${CDLAYOUTDIR}/clean.sh ]
	then
		mecho Running User clean sript
		( chmod 0755 ${CDLAYOUTDIR}/clean.sh && \
		  ${CDLAYOUTDIR}/clean.sh )
		evaluate_retval
	fi

	touch ${LIVECDROOT}/.isoprepareok
}

generate_iso() {
	secho Creating LiveCD ISO Image ...

	if [ -f ${LIVECDROOT}/${CDISONAME} ]
	then
		mecho Removing old ISO image ...
		rm -f ${LIVECDROOT}/${CDISONAME}
		evaluate_retval
	fi

	if [ -f ${CDISOROOT}/$CDID ]
	then
		mecho Removing old CD ID ...
		rm -f ${CDISOROOT}/$CDID
		evaluate_retval
	fi

	#for loopback only
	if [ -f ${CDISOROOT}/livecdrootfs ]
	then
		if [ ! -e ${LIVECDROOT}/noloopcreate ]
		then
			mecho Removing old CD rootfs ...
			rm -f ${CDISOROOT}/livecdrootfs
			evaluate_retval
		fi
	fi

	#for cloop loopback only
	if [ -f ${CDISOROOT}/livecdrootfs.cloop ]
	then
		if [ ! -e ${LIVECDROOT}/noloopcreate ]
		then
			mecho Removing old CD rootfs ...
			rm -f ${CDISOROOT}/livecdrootfs.cloop
			evaluate_retval
		fi
	fi

	#for squashfs loopback only
	if [ -f ${CDISOROOT}/livecdrootfs.sqsh ]
	then
		if [ ! -e ${LIVECDROOT}/noloopcreate ]
		then
			mecho Removing old CD rootfs ...
			rm -f ${CDISOROOT}/livecdrootfs.sqsh
			evaluate_retval
		fi
	fi

	if [ -d ${CDISOROOT}/isolinux ]
	then
		mecho Removing old Bootloader ...
		rm -rf ${CDISOROOT}/isolinux
		evaluate_retval
	fi

	mecho Creating CD ID ...
	( mkdir -p ${CDISOROOT} && \
	  touch ${CDISOROOT}/$CDID )
	evaluate_retval

	mecho Installing Bootloader ...
	( mkdir -p ${CDISOROOT}/isolinux && \
	  tar xjf ${CDLAYOUTDIR}/syslinux-2.08.tar.bz2 \
		-C ${CDCHROOTDIR}/usr/src && \
	  cp ${CDCHROOTDIR}/usr/src/syslinux-2.08/isolinux.bin \
		${CDISOROOT}/isolinux && \
	  rm -rf ${CDCHROOTDIR}/usr/src/* && \
	  cp -R ${CDCHROOTDIR}/boot/* ${CDISOROOT}/isolinux && \
	  cp ${CDLAYOUTDIR}/isolinux.cfg ${CDISOROOT}/isolinux && \
	  cp ${CDLAYOUTDIR}/boot.lss ${CDISOROOT}/isolinux && \
	  cp ${CDLAYOUTDIR}/boot.msg ${CDISOROOT}/isolinux && \
	  cp ${CDLAYOUTDIR}/help.msg ${CDISOROOT}/isolinux && \
	  cp ${LIVECDROOT}/initrd.gz ${CDISOROOT}/isolinux && \
	  source ${CDISOROOT}/isolinux/kernelversion && \
	  cp ${CDISOROOT}/isolinux/${KRNIMG} \
	  	${CDISOROOT}/isolinux/${CDKERNELNAME} )
	evaluate_retval

	if [ ! -e ${LIVECDROOT}/noloopcreate ]
	then
		case ${CDCOMPRESS_METHOD} in
			cloop)
				mecho Generating rootfs loopfile ...
				( cd ${LIVECDROOT} && \
				  export CDISOLOOPSIZE="$(expr 20000 + $(du -Ds chroot|cut -d 'c' -f1))" && \
				  dd if=/dev/zero of=${LIVECDROOT}/livecdrootfs bs=1024 count=${CDISOLOOPSIZE} &> /dev/null )
				evaluate_retval

				mecho Formating rootfs loopfile ...
				mke2fs -m 0 -i 1024 -F ${LIVECDROOT}/livecdrootfs &> /dev/null
				evaluate_retval

				mecho Mounting Image file ...
				( mkdir -p ${CDISOLOOP} && \
				mount -o loop ${LIVECDROOT}/livecdrootfs ${CDISOLOOP} )
				evaluate_retval

				mecho Copying rootfs to loopfile ...
				cp -a ${CDCHROOTDIR}/* ${CDISOLOOP}
				evaluate_retval

				mecho Unmounting Image file ...
				umount ${CDISOLOOP}
				evaluate_retval

				mecho Compressing rootfs loopfile ...
				( cat ${LIVECDROOT}/livecdrootfs | ${LIVECDROOT}/tmp/${CLOOPDIR}/create_compressed_fs - 131072 > livecdrootfs.cloop ) >/dev/null 2>&1
				evaluate_retval

				mecho Moving rootfs loopfile to isoroot ...
				( rm -f ${LIVECDROOT}/livecdrootfs && \
		  		mv ${LIVECDROOT}/livecdrootfs.cloop ${CDISOROOT} )
				evaluate_retval
				;;

			squashfs)
				mecho Generating squashfs compressed rootfs loopfile ...
				mksquashfs ${CDCHROOTDIR} ${LIVECDROOT}/livecdrootfs.sqsh >/dev/null 2>&1
				evaluate_retval

				mecho Moving rootfs loopfile to isoroot ...
				mv ${LIVECDROOT}/livecdrootfs.sqsh ${CDISOROOT}
				evaluate_retval
				;;
		esac
	fi

	mecho Generating ISO Image ...
	( cd ${CDISOROOT} && \
	  mkisofs -R -l -L -D -o ${LIVECDROOT}/${CDISONAME} \
	  -b isolinux/isolinux.bin -c isolinux/boot.cat \
	  -no-emul-boot -boot-load-size 4 -boot-info-table -V "${CDID}" \
	  ${CDISOROOT} &> /dev/null && \
	  cd ${LIVECDROOT} )
	evaluate_retval

	touch ${LIVECDROOT}/.isoimageok
}

livecddelete() {
	secho Deleting *ALL* LiveCD generated files ...

	if [ -f ${LIVECDROOT}/.??* ]
	then
		mecho Deleting state files ..
		rm -f ${LIVECDROOT}/.??*
		evaluate_retval
	fi

	if [ -d ${LIVECDROOT}/chroot ]
	then
		mecho Deleting system dir ...
		rm -rf ${LIVECDROOT}/chroot
		evaluate_retval
	fi

	if [ -d ${LIVECDROOT}/mntinitrd ]
	then
		mecho Deleting initrd mount dir ...
		rm -rf ${LIVECDROOT}/mntinitrd
		evaluate_retval
	fi

	if [ -f ${LIVECDROOT}/initrd ]
	then
		mecho Deleting initrd
		rm -f ${LIVECDROOT}/initrd
		evaluate_retval
	fi

	if [ -f ${LIVECDROOT}/initrd.gz ]
	then
		mecho Deleting initrd.gz
		rm -f ${LIVECDROOT}/initrd.gz
		evaluate_retval
	fi

	if [ -f ${LIVECDROOT}/${CDISONAME} ]
	then
		mecho Deleting isoimage ...
		rm -f ${LIVECDROOT}/${CDISONAME}
		evaluate_retval
	fi
	
	if [ -d ${CDISOLOOP} ]
	then
		mecho Deleting looptemp ...
		rm -rf ${CDISOLOOP}
		evaluate_retval
	fi
	
	if [ -d ${CDISOROOT} ]
	then
		mecho Deleting isoroot ...
		rm -rf ${CDISOROOT}
		evaluate_retval
	fi
	
	if [ -d ${LIVECDROOT}/tmp ]
	then
		mecho Deleting tmp dir ...
		rm -rf ${LIVECDROOT}/tmp
		evaluate_retval
	fi
	
	if [ -e ${LIVECDROOT}/noloopcreate ]
	then
		rm -f ${LIVECDROOT}/noloopcreate
	fi
}


getstate() {
	CDSTATE=""
	for i in ${LIVECDROOT}/.??*
	do
		case ${i} in
			${LIVECDROOT}/.bootstrapok)
				CDSTATE="bootstrapok"
			;;
			${LIVECDROOT}/.chcleanedok)
				CDSTATE="chcleanedok"
			;;
			${LIVECDROOT}/.isoprepareok)
				CDSTATE="isoprepareok"
			;;
			${LIVECDROOT}/.initrdok)
				CDSTATE="initrdok"
			;;
			${LIVECDROOT}/.isoimageok)
				CDSTATE="isoimageok"
			;;
			*)
				CDSTATE="none"
			;;
		esac
	done
}


## running part ##

case "$1" in
	bootstrap)
		showversion
		getstate
		if [ "${CDSTATE}" == "none" ]
		then
			chroot_generate
			build_bootstrap
			echo -e "\nYou can run now 'cleanchroot' ..."
		else
			mecho Whipe out old system first
		fi
		;;
	cleanchroot)
		showversion
		getstate
		if [ "${CDSTATE}" == "bootstrapok" ]
		then
			cleanup_chrootdir
			rm -f ${LIVECDROOT}/.bootstrapok
			echo -e "\nYou can run now 'prepareiso' ..."
		else
			mecho You must run bootstrap first
		fi
		;;
	prepareiso)
		showversion
		getstate
		if [ "${CDSTATE}" == "chcleanedok" ]
		then
			prepare_iso
			rm -f ${LIVECDROOT}/.chcleanedok
			echo -e "\nYou can run now 'initrd' ..."
		else
			mecho Please clean chroot first
		fi
		;;
	initrd)
		showversion
		getstate
		if [ "${CDSTATE}" == "isoprepareok" ] || \
			[ "${CDSTATE}" == "isoimageok" ]
		then
			build_initrd
			if [ -e ${LIVECDROOT}/.isoprepareok ]
			then
				rm -f ${LIVECDROOT}/.isoprepareok
			fi
			if [ -e ${LIVECDROOT}/.isoimageok ]
			then
				rm -f ${LIVECDROOT}/.isoimageok
			fi
			echo -e "\nYou can run now 'isogen' ..."
		else
			mecho Please prepare your iso first
		fi
		;;
	isogen)
		showversion
		getstate
		if [ "${CDSTATE}" == "initrdok" ] || \
			[ "${CDSTATE}" == "isoimageok" ]
		then
			generate_iso
			rm -f ${LIVECDROOT}/.initrdok
		else
			mecho Please run initrd first
		fi
		;;
	enter)
		showversion
		getstate
		if [ "${CDSTATE}" != "none" ]
		then
			enter_chroot
		else
			mecho Please build a system first
		fi
		;;

	delete)
		showversion
		livecddelete
		;;
	makeall)
		showversion
		getstate
		if [ "${CDSTATE}" == "none" ]
		then
			chroot_generate
			build_bootstrap
			cleanup_chrootdir
			rm -f ${LIVECDROOT}/.bootstrapok
			prepare_iso
			rm -f ${LIVECDROOT}/.chcleanedok
			build_initrd
			rm -f ${LIVECDROOT}/.isoprepareok
			generate_iso
			rm -f ${LIVECDROOT}/.initrdok
		else
			mecho Please wipe out your old LiveCD first
		fi
		;;
	*)
		showversion
		echo -e "Usage: $0 [Option] ..."
		echo -e "\nBuilding Options:"
		echo -e "    bootstrap    -    builds cd system"
		echo -e "    cleanchroot  -    cleans chroot"
		echo -e "\nIso Prepare Options:"
		echo -e "    prepareiso   -    prepares files for isogen"
		echo -e "    initrd       -    builds initrd"
		echo -e "    isogen       -    creates isoimage"
		echo -e "\nOther Options:"
		echo -e "    enter        -    chroot cd system"
		echo -e "    delete       -    deletes all generated files"
		echo -e "    makeall      -    builds stright ahead the livecd\n"
		;;
esac