Context Navigation

source: MondoRescue/branches/stable/mindi/mindi@ 998

Visit:

Last change on this file since 998 was 998, checked in by Bruno Cornec, 17 years ago
Attempt to solve #113
Property svn:keywords set to `Rev Id`
File size: 106.7 KB

Rev	Line
[747]	1	#!/bin/bash
	2
	3	# $Id: mindi 998 2006-12-07 01:01:34Z bruno $
	4	#
	5	#-----------------------------------------------------------------------------
	6	# mindi - mini-Linux distro based on the user's filesystem & distribution
	7	#
	8	# Mindi can create a multi-floppy boot/root kit. The first floppy is the boot
	9	# disk: it contains a kernel, a ramdisk etc. The second disk is data disk #1;
	10	# the third disk is data disk #2; and so it goes.
	11	#
	12	# See http://www.mondorescue.org for details.
	13	#-----------------------------------------------------------------------------
	14
	15	### Which arch are we on (useful for ia64 port)
[925]	16	ARCH=`/bin/arch`
[747]	17
	18	ADDITIONAL_BOOT_PARAMS="acpi=off apm=off devfs=nomount noresume selinux=0 barrier=off"
	19
[925]	20	#RUN_AFTER_INITIAL_BOOT_PHASE="echo \"Who lives in a pineapple under the sea?\" > /tmp/spongebob.squarepants.txt"
[747]	21	# after booting from floppy/CD image but before
	22	# accessing auxiliary data disks (or the rest of
	23	# the CD), the initscript will run the above command.
	24
	25	RUN_AFTER_BOOT_PHASE_COMPLETE="ide-opt"
	26	# after the emergency boot process is complete but
	27	# before the init script runs mondorestore, it will
	28	# run this command.
	29
	30	MINDI_REV=RRR
	31	MINDI_VER=VVV
	32
	33	MINDI_VERSION=${MINDI_VER}-r$MINDI_REV
	34	MINDI_PREFIX=XXX
	35	MINDI_CONF=YYY
	36	MINDI_SBIN=${MINDI_PREFIX}/sbin
[934]	37	MINDI_LIB=LLL
[747]	38
[925]	39	# Temporary directory for mindi
	40	TMPDIR=/tmp
	41
[747]	42	EXTRA_SPACE=24576 ; # increase if you run out of ramdisk space
	43	IA64_BOOT_SIZE=8192 ; # size of the ia64 boot disk
	44	WRITE_BOOT_FLOPPIES="yes" ; # do you want to be propted to write floppy images
	45	PROMPT_WRITE_BOOT_FLOPPIES="yes"
	46	# do you want to be prompted to write
	47	# floppy images out to floppy disks?
	48	# if 'no', images will not be written to floppies
	49
	50	PROMPT_MAKE_CD_IMAGE="yes"
	51	# Ask if you want to make a CD Image to be written?
	52	# if this is set to 'no', then the image will be created automatically
	53
[966]	54	USE_OWN_KERNEL="yes"
[747]	55	# If set to "no", you will be prompted for whether or not
	56	# you want to use your own kernel, or the supplied default.
	57	# If "yes" mindi will automatically use your own kernel.
[925]	58
[747]	59	MY_FSTAB=/etc/fstab
	60	FLOPPY_MODS="ide-floppy floppy"
	61	TAPE_MODS="ht st osst ide-tape ide_tape"
	62	SCSI_MODS="3w-xxxx 53c7,8xx a100u2w a320raid aacraid advansys aha152x aha1542 aha1740 aic79xx aic79xx_mod aic7xxx aic7xxx_mod aic7xxx_old AM53C974 atp870u BusLogic cciss cpqfc dmx3191d dpt_i2o dtc eata eata_dma eata_pio fdomain gdth g_NCR5380 i2o_block i2o_core ide-scsi ieee1394 imm in2000 initio ips iscsi isp megaraid mptbase mptscsih NCR53c406a ncr53c8xx nsp32 pas16 pci2000 pci2220i pcmcia ppa psi240i qla1280 qla2200 qla2300 qlogicfas qlogicfc qlogicisp raw1394 scsi_debug scsi_mod sd_mod seagate sg sim710 sr_mod sym53c416 sym53c8xx sym53c8xx_2 t128 tmscsim u14-34f ultrastor wd7000 vmhgfs"
	63
	64	# ide-probe-mod
[997]	65	IDE_MODS="ide ide-generic ide-detect ide-mod ide-disk ide-cd ide_cd ide-cs ide-core ide_core libata edd paride ata_piix libata via82cxxx generic nvidia"
[747]	66	PCMCIA_MODS="pcmcia_core ds yenta_socket"
[854]	67	USB_MODS="usb-storage usb-ohci usb-uhci usbcore usb_storage hid uhci_hcd ehci_hcd uhci-hcd ehci-hcd usbkbd usbhid"
[747]	68	CDROM_MODS="$TAPE_MODS $FLOPPY_MODS $IDE_MODS af_packet cdrom isocd isofs inflate_fs nls_iso8859-1 nls_cp437 sg sr_mod zlib_inflate $USB_MODS $PCMCIA_MODS"
[997]	69	NET_MODS="sunrpc nfs nfs_acl lockd loop mii 3c59x e100 bcm5700 bnx2 e1000 eepro100 ne2k-pci tg3 pcnet32 8139cp 8139too 8390 vmxnet vmnet"
[747]	70	EXTRA_MODS="$CDROM_MODS vfat fat loop md-mod linear raid0 raid1 xor raid5 lvm-mod dm-mod jfs xfs xfs_support pagebuf reiserfs ext2 ext3 minix nfs nfs_acl nfsd lockd sunrpc jbd"
[925]	71
[747]	72	LOGFILE=/var/log/mindi.log
	73	FDDEVICE=/dev/fd0 ; # 1.44MB floppy #0
[925]	74	CACHE_LOC=/var/cache/mindi
[747]	75	FORCE_DUAL_FLOPPIES=no
	76	BOOT_MEDIA_MESSAGE="\
	77	To format and restore all files automatically, type 'nuke' <enter>.\n\
	78	To restore some/all files interactively, type 'interactive' <enter>.\n\
	79	To compare the archives with your filesystem, type 'compare' <enter>.\n\
	80	To boot to a command-line prompt (expert mode), type 'expert' <enter>.\n\
	81	You may add one or more of the following parameters as well:-\n\n\
	82	donteject - mondorestore will not eject the CD; this is useful if, for\n\
	83	instance, your PC's case has a concealed CD-ROM drive\n\
	84	noresize - your mountlist will not be adjusted to use your unallocated\n\
	85	hard disk space\n\
	86	textonly - do not call any Newt library routines; this is unattractive\n\
	87	but valuable if you find your Newt library has bugs in it\n\n\
	88	e.g. Type 'nuke donteject textonly' if you have an unstable Newt library and \n\
	89	a PC whose CD-ROM drive tray would be damaged if it unexpectedly ejected.\n\
	90	"
[925]	91	FDISK=$MINDI_SBIN/parted2fdisk
[747]	92
[925]	93	# Using a config file allow to overwrite some values
	94	MINDI_CONFIG="$MINDI_CONF/mindi.conf"
	95	if [ -f $MINDI_CONFIG ]; then
	96	. $MINDI_CONFIG
	97	fi
	98
	99	# Now we can create what we nedd
[940]	100	MINDI_TMP=`mktemp -d $TMPDIR/mindi.XXXXXXXXXX`
	101	mkdir -p $MINDI_TMP
	102
	103	# Purge from potential old run
	104	rm -rf $CACHE_LOC/* 2> /dev/null
[925]	105	mkdir -p $CACHE_LOC
[747]	106	# ----------------------------------------------------------------------------
	107
	108
	109	AbortHere() {
	110	[ "$mountpoint" ] && umount $mountpoint 2>> $LOGFILE
	111	Die "Program is terminating in response to signal received from OS/user"
	112	}
	113
	114
	115	HackSyslinuxFile() {
	116	local incoming
	117	incoming=`ReadLine`
	118	while [ "$incoming" ] ; do
	119	echo -en "$incoming" \| sed s/24000/$1/
	120	if [ "`echo "$incoming" \| grep append`" ] ; then
	121	echo -en " $ADDITIONAL_BOOT_PARAMS"
	122	fi
	123	echo -en "\n"
	124	incoming=`ReadLine`
	125	done
	126	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	127	echo -en "label memtest\n kernel memdisk\n append initrd=memtest.img\n\n"
	128	fi
	129	}
	130
	131
	132	AbortIfYourDistroIsAPieceOfStercus() {
	133	which which > /dev/null 2> /dev/null \|\| Die "Please install 'which'."
	134	which strings > /dev/null 2> /dev/null \|\| Die "Please install binutils and libbinutils; you have no 'strings' executable."
	135	which gawk > /dev/null 2> /dev/null \|\| Die "Gawk is missing from your computer. Please install gawk. You may find the package on Debian's website. How did I know you're running Debian? Because only Debian would be stupid enough not to include gawk in your distribution."
	136	which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` \|\| AWK="`which awk 2>/dev/null`"
	137	if which awk &> /dev/null ; then
[925]	138	if ! which gawk &> /dev/null ; then
	139	LogIt "You have awk but not gawk.\nPlease note that mindi works fine with a _sane_ awk binary.\nIf your awk binary misbehaves then please contact your vendor\nor distribution's mailing list for technical support.\n"
	140	fi
[747]	141	fi
	142	which mke2fs > /dev/null 2> /dev/null \|\| Die "Please put mke2fs in system path"
	143	[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
	144	}
	145
	146
	147	AbortIfMkfsVfatMissing() {
	148	#if grep -F "vfat" /etc/fstab &> /dev/null ; then
	149	if ! which mkfs.vfat &> /dev/null ; then
	150	Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
	151	fi
	152	#fi
	153	}
	154
	155
	156	Aborted() {
	157	trap SIGHUP SIGTERM SIGTRAP SIGINT
[925]	158	[ "$CACHE_LOC" != "" ] && rm -f $CACHE_LOC/mindiimg $CACHE_LOC/gz $CACHE_LOC/mindi.iso
[747]	159	[ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
	160	Die "User abort."
	161	}
	162
	163
	164	AddFileToCfgIfExists() {
	165	[ -e "$1" ] && echo -en "$2 `cat $1`\n" >> $3
	166	}
	167
	168
	169	AddFileToDir() {
	170	local filename minidir_root noof_disks diskno res filesize disksize would_occupy zipsize complevel cutoff compressed_fname siz
	171	filename=$1
	172	minidir_root=$2
	173	noof_disks=$3
	174
	175	diskno=$noof_disks
	176	mkdir -p $minidir_root/$diskno
	177	[ "$LAST_COMPRESSED_SIZE" = "" ] && LAST_COMPRESSED_SIZE=0
	178	if [ ! -e "$filename" ] ; then
[925]	179	if [ -h "$filename" ] ; then
[963]	180	cp --parents -pRdf $filename $minidir_root/$diskno 2>> $LOGFILE
[925]	181	return $noof_disks
	182	else
	183	Die "AddFileToDir asked me to add $filename, which does not exist. Oops! Did you run out of disk space or is your Linux distro severely broken?"
	184	fi
[747]	185	fi
[925]	186
	187	# move to the disk that has room on it (or end up using the last, if all full)
[747]	188	while [ "$diskno" -lt "40" ] ; do
[925]	189	mkdir -p $minidir_root/$diskno
[747]	190	filesize=`du -sk $filename \| cut -f1`
[963]	191	cp --parents -Rdf $filename $minidir_root/$diskno 2>> $LOGFILE
[747]	192	if [ "$filesize" -le "4" ] ; then
	193	siz=$filesize
	194	elif [ ! -f "$filename" ] ; then
	195	siz=0
	196	else
	197	siz=`grep -m 1 "$filename.gz$" $minidir_root/compressed/compressed.txt \| cut -f1`
	198	[ "$siz" = "" ] && Die "FIXME - can't find $filename's size."
	199	siz=$(($siz-2));# to allow for sectors & the fact that they round up
	200	fi
[925]	201	[ ! "$siz" ] && siz=4
	202	[ "$siz" -lt "0" ] && siz=0
[747]	203	LAST_COMPRESSED_SIZE=$(($LAST_COMPRESSED_SIZE+$siz))
[925]	204	[ "$LAST_COMPRESSED_SIZE" -le "$MAX_COMPRESSED_SIZE" ] &&return $diskno
	205	echo "disk=$diskno siz=$LAST_COMPRESSED_SIZE" >> $LOGFILE
	206	LAST_COMPRESSED_SIZE=0
	207	rm -f $minidir_root/$diskno/$filename
[747]	208	diskno=$(($diskno+1))
	209	done
	210	return 0 ; # failed
	211	}
	212
	213
	214	AddKeyboardMappingFile() {
	215	local mappath r included_list included_item i res ii sss
	216	mappath=$1
	217	KBDEPTH=$(($KBDEPTH+1))
	218	[ "$KBDEPTH" -gt "128" ] && Die "Edit $MINDI_SBIN/mindi and disable FindAndAddUserKeyboardMappingFile (line 2160, approx.)"
	219	if [ -e "$bigdir/$mappath" ] ; then
	220	echo "$mappath already added" >> $LOGFILE
	221	return
	222	elif [ -d "$bigdir/$mappath" ] ; then
	223	echo "Cannot add $mappath: it's a directory. Sorry."
	224	return
	225	fi
	226	echo "Added kbd map $mappath" >> $LOGFILE
	227	if [ ! -e "$mappath" ] ; then
	228	mappath=`find $KEYDIR/keymaps \| grep "i[3-8]86" \| grep "$locale[^r][^/]" \| grep -vx " #."`
	229	if [ ! -e "$mappath" ] ; then
[963]	230	LogIt "Cannot add $mappath: kbd map file not found"
[747]	231	return
	232	fi
	233	else
	234	echo -en "`basename $mappath \| tr '.' '#' \| sed s/#kmap#gz// \| sed s/#inc#gz//` " \| tr '#' '.'
	235	fi
	236
	237	mkdir -p $bigdir/etc
[963]	238	cp --parents -pRdf $mappath $bigdir 2>> $LOGFILE \|\| LogIt "AKMF -- Could not copy $mappath to $bigdir"
[747]	239	if [ "`echo $mappath \| grep -F ".gz"`" ] ; then
	240	included_list=`gzip -dc $mappath \| grep -Fi include \| sed s/'"'// \| sed s/'"'// \| cut -d' ' -f2`
	241	else
	242	included_list=`grep -Fi include $mappath \| sed s/'"'// \| sed s/'"'// \| cut -d' ' -f2`
	243	fi
	244	for included_item in $included_list ; do
[925]	245	if [ ! -e "$included_item" ] ; then
[747]	246	sss=`find $KEYDIR/keymaps \| grep -F "${included_item}.inc"`
[925]	247	[ "$sss" = "" ] && sss=`find $KEYDIR/keymaps \| grep -F "$included_item"`
	248	for ii in $sss ; do
[747]	249	[ -e "$ii" ] && AddKeyboardMappingFile $ii
[925]	250	done
	251	else
	252	AddKeyboardMappingFile $included_item
	253	fi
[747]	254	done
	255	}
	256
	257
	258	ChopUpAndCopyFile() {
	259	local filename slicesize outdir res biggienumber filesize sliceno noof_slices testfile scratchfile
	260	filename=$1
	261	outdir=$2
	262	slicesize=$3
	263	biggienumber=$4
	264
	265	[ -d "$filename" ] && Die "Cannot chop up $filename: it's a directory. Please amend deplist.txt accordingly."
	266	mkdir -p $outdir
	267
	268	sliceno=0
[940]	269	scratchfile=$MINDI_TMP/blah.$$.dat
[963]	270	cp -f $filename $scratchfile 2>> $LOGFILE \|\| Die "CUACF -- cannot copy $filename to $scratchfile - did you run out of disk space?"
[747]	271	[ "`head $scratchfile -n1 \| grep -F "bin/sh"`" != "" ] && StripComments $scratchfile "-$filename-"
	272	[ "`echo "$filename" \| grep -F "etc/termcap"`" != "" ] && StripComments $scratchfile "-$filename-"
	273	if [ "`echo "$filename" \| grep -F "lib/modules/" \| grep "\.*o\.gz"`" != "" ] ; then
[925]	274	mv $scratchfile $scratchfile.gz
[963]	275	gunzip -f $scratchfile \|\| LogIt "Cannot gunzip $scratchfile.gz"
[925]	276	filename=`echo "$filename" \| tr '.' '#' \| sed s/#o#gz/#o/ \| sed s/#ko#gz/#ko/ \| tr '#' '.'`
[747]	277	fi
	278	filesize=`du -sk $scratchfile \| cut -f1`
	279	noof_slices=$(($filesize/$slicesize))
	280	echo "$filename" > $outdir/slice-$biggienumber.name
	281	echo "$filesize" > $outdir/slice-$biggienumber.size
	282	[ -x "$scratchfile" ] && StripExecutable $scratchfile "-$filename-"
	283	while [ "$sliceno" -le "$noof_slices" ] ; do
[963]	284	dd if=$scratchfile skip=$(($sliceno*$slicesize)) of=$outdir/slice-$biggienumber.`printf "%03d" $sliceno` bs=1k count=$slicesize &> /dev/null
[747]	285	sliceno=$(($sliceno+1))
	286	done
	287	rm -f $scratchfile
	288	}
	289
	290
	291	CopyBootBFile() {
	292	local copy_to copy_from possible_locations liloc
	293	copy_to=$1
	294	copy_from=/boot/boot.b
	295	liloc=`which lilo.real 2>/dev/null`
	296	[ $liloc ] \|\| liloc=`which lilo 2>/dev/null`
	297	if [ $liloc ]; then
	298	if ! [ `strings $liloc \| grep "boot\.b"` ]; then
[963]	299	LogIt "boot.b files built into lilo; I'll create a dummy."
[747]	300	> $copy_to
	301	return 0
	302	fi
	303	fi
	304	if [ ! -f "$copy_from" ] ; then
	305	LogIt "OK, you don't have a /boot/boot.b file, which is odd because\n most _good_ Linux distributions come with one, even if it's only a softlink"
	306	copy_from=`grep install= /etc/lilo.conf \| grep "\.b" \| cut -d'=' -f2`
	307	if [ ! -f "$copy_from" ] ; then
[963]	308	LogIt "Nor can I find it from your /etc/lilo.conf file. This is very odd."
[747]	309	copy_from=`FindSensibleBootBFile`
[963]	310	LogIt "I'm going to use '$copy_from'"
[747]	311	fi
	312	fi
[963]	313	cp -f $copy_from $copy_to 2>> $LOGFILE \|\| LogIt "CBBF -- warning -- cannot find your boot.b file. That's it, I quit... (j/k)"
[747]	314	}
	315
	316
	317	CopyDependenciesToDirectory() {
	318	local outdir incoming fname filesize counter
	319	outdir=$1
	320	mkdir -p $outdir
	321	incoming=`ReadLine`
	322	counter=0
	323	while [ "$incoming" != "" ] ; do
[925]	324	if [ -d "$incoming" ] ; then
[747]	325	find $incoming/* -maxdepth 0 2> /dev/null \| CopyDependenciesToDirectory $outdir
	326	elif [ -e "$incoming" ] ; then
	327	filesize=`du -sk $incoming \| cut -f1`
	328	if [ "$filesize" -gt "$(($CHOPSIZE*2))" ] && [ ! -h "$incoming" ] ; then
	329	ChopUpAndCopyFile $incoming $outdir $CHOPSIZE $BIGNO
	330	BIGNO=$(($BIGNO+1))
	331	else
[953]	332	cp --parents -Rdf $incoming $outdir 2> /dev/null \|\| Die "Cannot copy $incoming to $outdir - did you run out of disk space?"
[925]	333	if [ "`echo "$incoming" \| grep "lib/modules/.\..o\.gz"`" != "" ] ; then
[963]	334	gunzip -f $outdir/$incoming \|\| LogIt "Cannot gunzip $outdir/$incoming"
[925]	335	fi
	336	[ -x "$outdir" ] && StripExecutable $outdir "-$filename-"
	337	fi
	338	counter=$(($counter+1))
	339	if [ "$counter" -ge "5" ] ; then
	340	counter=0
	341	echo -en "."
	342	fi
[747]	343	fi
	344	incoming=`ReadLine`
	345	done
	346	}
	347
	348
	349	CopyImageToDisk() {
	350	local image dev procno res comment
	351	image=$1
	352	dev=$2
	353	comment=$3
	354	[ ! -f "$image" ] && [ ! -b "$image" ] && Die "Image $image does not exist. Did you run out of disk space?"
	355	Prompt "About to write $comment. Please press ENTER."
	356	echo -en "Formatting disk..."
	357	if which fdformat > /dev/null ; then
[925]	358	fdformat -n $dev > /dev/null 2> /dev/null \|\| Die "Cannot format $dev - is your Linux distro broken?"
[747]	359	elif which superformat > /dev/null ; then
[925]	360	superformat $dev > /dev/null 2> /dev/null \|\| Die "Cannot format $dev - is your Linux distro broken?"
[747]	361	else
[925]	362	Die "Please install either fdformat or superformat."
[747]	363	fi
	364	echo -en "\rWriting $comment"
	365	if echo $image \| grep "mindi-[r\|b]oot\.1440" &> /dev/null ; then
[925]	366	cat $image > $dev &
[747]	367	else
[925]	368	dd if=$image of=$dev &> /dev/null &
[747]	369	fi
	370	procno=$!
	371	ps $procno > /dev/null 2> /dev/null
	372	while [ "$?" -eq "0" ] ; do
	373	sleep 3
	374	echo -en "."
	375	ps $procno > /dev/null 2> /dev/null
	376	done
	377	echo -e "$DONE"
[963]	378	LogIt "$comment has been written."
[747]	379	}
	380
	381
	382	CountItemsIn() {
	383	local r
	384	r=0
	385	for q in $1 ; do
	386	r=$(($r+1))
	387	done
	388	echo $r
	389	}
	390
	391
	392	CreateDataDiskImagesFromTarballs() {
	393	local tardir outdir diskno noof_disks kp
	394	tardir=$1
	395	outdir=$2
	396	noof_disks=$3
	397
	398	mkdir -p $outdir
	399	diskno=1
	400	echo -en "Creating data disk "
	401	while [ "$diskno" -le "$noof_disks" ] ; do
[925]	402	echo -en "#$diskno..."
[963]	403	cp -f $tardir/$diskno.tar.gz $outdir 2>> $LOGFILE \|\| LogIt "[line 424] Cannot copy $tardir/$diskno.tar.gz to $outdir"
[747]	404	CreateOneDataDiskImage $tardir/$diskno.tar.gz $outdir/mindi-data-$diskno.img $diskno $noof_disks
	405	diskno=$(($diskno+1))
	406	done
	407	mv -f $tardir/all.tar.gz $outdir
	408	du -sk $outdir/*gz >> $LOGFILE
	409	echo -e "$DONE"
	410	}
	411
	412
	413
	414	CreateOneDataDiskImage() {
	415	local tarball imagefile dev diskno noof_disks mountpoint
	416	tarball=$1
	417	imagefile=$2
	418	diskno=$3
	419	noof_disks=$4
	420
[940]	421	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	422	mkdir -p $mountpoint
[963]	423	dd if=/dev/zero of=$imagefile bs=1k count=1440 &> /dev/null \|\| LogIt "Cannot dd (CODI)"
[964]	424	mke2fs -N 12 -F $imagefile >> $LOGFILE 2>> $LOGFILE
[747]	425	mount -t ext2 -o loop $imagefile $mountpoint \|\| Die "Can't loopmount $imagefile to $mountpoint! The reason may be missing support for loopfs or ext2 (or both) in the running kernel."
	426	mv $tarball $mountpoint/
	427	if [ "$?" -ne "0" ] ; then
[925]	428	umount $mountpoint
	429	Die "Tarball $tarball is too big for disk! (CODI)\nTell Dev Team to adjust MAX_COMPRESSED_SIZE"
[747]	430	fi
	431	[ "$diskno" -eq "$noof_disks" ] && echo "This is the last disk ($diskno=$noof_disks)" >> $mountpoint/LAST-DISK
[963]	432	umount $mountpoint \|\| LogIt "Cannot umount (CODI)"
	433	rmdir $mountpoint \|\| LogIt "Cannot rmdir (CODI)"
[747]	434	}
	435
	436
	437	DidMondoCallMe() {
	438	local res
	439
	440	res=0
	441	[ "`ps ax \| grep -F "mondoarchive" \| grep -v "grep"`" ] && res=$(($res+1))
	442	[ -f "/var/run/monitas-mondo.pid" ] && res=$(($res+1))
	443	[ "$res" -gt "1" ] && echo "yes"
	444	}
	445
[925]	446	# Last function called before exiting
	447	# Parameter is exit code value
[931]	448	MindiExit() {
[925]	449	local my_partitions
[747]	450
[925]	451	echo "Mindi $MINDI_VERSION is exiting" >> $LOGFILE
	452	echo "End date : `date`" >> $LOGFILE
[747]	453
[925]	454	sync
	455	cd /
[747]	456
[925]	457	# Unmount whtat could remain mounted
	458	my_partitions=`mount \| grep -F $$ \| cut -f1 -d' '`
	459	[ "$my_partitions" != "" ] && umount $my_partitions
[940]	460	# Clean temporary files only when standalone mindi
[948]	461	if [ _"$MINDI_TMP" != _"$MONDO_TMP" ]; then
[940]	462	rm -Rf $MINDI_TMP
	463	fi
[925]	464	exit $1
	465	}
	466
[747]	467	Die() {
[925]	468	local i
[747]	469	if [ "$1" = "" ] ; then
[963]	470	LogIt "FATAL ERROR"
[747]	471	else
[963]	472	LogIt "FATAL ERROR. $1"
[747]	473	fi
	474
[925]	475	# Creates a tar file containing all required files
[941]	476	for i in /etc/fstab /etc/lilo.conf /etc/raidtab $LOGFILE /var/log/mondo-archive.log ; do
[963]	477	[ -e "$i" ] && cp -f $i $MINDI_TMP 2>> $LOGFILE
[747]	478	done
[925]	479	rm -f $TMPDIR/mindi.err.*.tgz
[940]	480	tar -cf - $MINDI_TMP \| gzip -9 > $TMPDIR/mindi.err.$$.tgz
[963]	481	LogIt "Please e-mail a copy of $TMPDIR/mindi.err.$$.tgz to the mailing list."
	482	LogIt "See http://www.mondorescue.org for more information."
[747]	483	LogIt "WE CANNOT HELP unless you enclose that file.\n"
[925]	484	MindiExit -1
[747]	485	}
	486
	487
	488	DropOptimizedLibraries() {
	489	local outdir filelist list_of_optimized_libraries optimized_lib_name vanilla_lib_name reason msg resolved res
	490	filelist=$1
	491	outdir=$2
	492
	493	list_of_optimized_libraries=`grep "lib/i[5-7]86/" $filelist`
	494	if [ "$list_of_optimized_libraries" = "" ] ; then
[859]	495	return 0
[747]	496	fi
	497	echo -en "Dropping i686-optimized libraries if appropriate"
	498	for optimized_lib_name in $list_of_optimized_libraries ; do
[859]	499	echo -en "."
	500	reason=""
	501	vanilla_lib_name=`echo "$optimized_lib_name" \| sed s/i[5-7]86// \| tr -s '/' '/'`
	502	echo "$vanilla_lib_name" >> $filelist
	503	resolved=$vanilla_lib_name
[747]	504	echo "Adding $resolved to filelist" >> $LOGFILE
[861]	505	resolved=`ReadAllLink $resolved`
	506	echo "Adding $resolved to filelist" >> $LOGFILE
[859]	507	mkdir -p $outdir$optimized_lib_name > /dev/null 2> /dev/null
	508	rmdir $outdir$optimized_lib_name > /dev/null 2> /dev/null
	509	ln -sf $vanilla_lib_name $outdir$optimized_lib_name
	510	echo "Excluding $optimized_lib_name" >> $LOGFILE
[935]	511	grep -Fvx "$optimized_lib_name" "$filelist" > $filelist.tmp
[859]	512	echo "Replacing it with $vanilla_lib_name" >> $LOGFILE
	513	echo "$vanilla_lib_name" >> $filelist.tmp
	514	mv -f $filelist.tmp $filelist
[747]	515	done
[925]	516	$AWK '{ print $1; }' $filelist \| sort -u > $filelist.tmp
[747]	517	mv -f $filelist.tmp $filelist
	518	echo -e "$DONE"
	519	}
	520
	521
	522	FindAndAddUserKeyboardMappingFile() {
	523	local r res mapfile mappath included_item included_list keyfile mp locale
[963]	524	LogIt "Analyzing your keyboard's configuration."
[747]	525	KEYDIR=/lib/kbd
	526	[ ! -e "$KEYDIR" ] && KEYDIR=/usr/share/kbd # Slackware
	527	[ ! -e "$KEYDIR" ] && KEYDIR=/usr/lib/kbd
	528	[ ! -e "$KEYDIR" ] && KEYDIR=/usr/share
	529	if [ ! -e "$KEYDIR" ] ; then
[963]	530	LogIt "Keyboard mapping directory not found. I shall use default map at boot-time."
[747]	531	return 0
	532	fi
	533	if [ -e "/etc/sysconfig/keyboard" ] ; then
	534	echo "Red Hat-style config detected." >> $LOGFILE
	535	keyfile=/etc/sysconfig/keyboard
	536	elif [ -e "/etc/rc.d/rc.keymap" ] ; then
	537	echo "Slackware-style config detected." >> $LOGFILE
	538	keyfile=/etc/rc.d/rc.keymap
	539	elif [ -e "/etc/rc.config" ] ; then
	540	echo "Debian-style config detected." >> $LOGFILE
	541	keyfile=/etc/rc.config
	542	elif [ -e "/etc/console/boottime.kmap.gz" ] ; then
	543	echo "Debian-style config detected." >> $LOGFILE
	544	echo -en "Adding the following keyboard mapping tables: "
	545	mkdir -p $bigdir/tmp
	546	echo "/etc/console/boottime.kmap.gz" > $bigdir/tmp/KEYMAP-LIVES-HERE
	547	KBDEPTH=0
	548	mkdir -p $bigdir/etc/console
[963]	549	cp /etc/console/boottime.kmap.gz $bigdir/etc/console 2>> $LOGFILE
[747]	550	echo -e "$DONE"
	551	return 0
	552	else
	553	echo -en "Searching for rc.config ..."
	554	keyfile=`find /etc -name rc.config \| head -n1`
	555	if [ "$keyfile" = "" ] \|\| [ ! -e "$keyfile" ] ; then
[963]	556	LogIt "Unknown config detected. Default keyboard map will be used."
[747]	557	return
	558	else
	559	echo "Found $keyfile" >> $LOGFILE
	560	fi
	561	fi
	562	if [ ! -e "$KEYDIR/keymaps" ] ; then
[963]	563	LogIt "Keyboard mapping directory not found. Default keyboard map will be used."
[747]	564	return
	565	fi
	566	echo "keyfile=$keyfile" >> $LOGFILE
	567	locale=`grep -F KEYTABLE "$keyfile" \| tr -d '"' \|cut -d'=' -f2`
	568	[ ! "$locale" ] && locale=`grep '.map$' "$keyfile" \| sed 's/^.* //'` # Slackware
	569	echo "locale=$locale" >> $LOGFILE
	570	mp=`find $KEYDIR/keymaps \| grep "i[3-8]86" \| grep -F "/${locale}." \| grep -vx " #."`
	571	[ ! "$mp" ] && mp=`find $KEYDIR/keymaps \| grep "i[3-8]86" \| grep "$locale[^r][^/]" \| grep -vx " #."`
	572	# If we have multiple keymaps then log it !!
	573	echo "$mp" \| grep -q " "
	574	if [ $? -eq 0 ]; then
	575	echo "WARNING: Multiple keymaps found: $mp" \| tee -a $LOGFILE
	576	echo "The following one will be used" >> $LOGFILE
	577	fi
	578	for i in $mp ; do
	579	mappath=$i
	580	[ -e "$i" ] && [ ! -d "$i" ] && break
	581	done
	582	if [ ! -e "$mappath" ] \|\| [ -d "$mappath" ] ; then
	583	mappath=$(locate /kbd/keymaps//$locale)
	584	fi
	585	echo "mappath = $mappath" >> $LOGFILE
	586	if [ ! -e "$mappath" ] \|\| [ -d "$mappath" ] ; then
[963]	587	LogIt "Keyboard mapping file not found. Default keyboard map will be used."
[747]	588	return
	589	fi
	590	echo -en "Adding the following keyboard mapping tables: "
	591	mkdir -p $bigdir/tmp
	592	echo "$mappath" > $bigdir/tmp/KEYMAP-LIVES-HERE
	593	KBDEPTH=0
	594	AddKeyboardMappingFile $mappath
	595	echo -e "$DONE"
	596	return 0
	597	}
	598
	599
	600	FindHomeOfMindiAndMondo() {
	601	[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
	602	echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
	603	echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
	604	[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
	605	echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
	606	echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
	607	}
	608
	609
	610	FindIsolinuxBinary() {
	611	ISOLINUX=/usr/lib/isolinux.bin
	612	[ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/lib/syslinux/isolinux.bin
	613	[ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/share/syslinux/isolinux.bin
	614	[ ! -e "$ISOLINUX" ] && ISOLINUX=/usr/share/lib/syslinux/isolinux.bin
	615	[ ! -e "$ISOLINUX" ] && ISOLINUX=`locate isolinux.bin \| grep -x "/.*/isolinux.bin"`
	616	[ ! -e "$ISOLINUX" ] && Die "Please install isolinux first. If your syslinux RPM doesn't include isolinux, you may download an isolinux RPM from Mondo's website - go to http://www.mondorescue.com and click on 'Download'"
	617	echo "Found isolinux.bin at $ISOLINUX" >> $LOGFILE
	618	}
	619
	620
	621	FindLiloBinary() {
	622	if which lilo &> /dev/null ; then
[925]	623	if which lilo.real > /dev/null 2> /dev/null ; then
	624	LILO_EXE=lilo.real
[963]	625	LogIt "lilo.real found; will be used instead of lilo (grumble mutter)"
[925]	626	else
	627	LILO_EXE=lilo
	628	fi
	629	$LILO_EXE -V \| grep -F "21.6" > /dev/null && Die "Please upgrade LILO. Your version has a serious bug. If you're not _using_ LILO, fine, uninstall it. :)"
[747]	630	else
[925]	631	LILO_EXE=`which false`
[747]	632	fi
	633	}
	634
[925]	635
[747]	636	FindELiloBinary() {
	637	if which elilo &> /dev/null ; then
[925]	638	LILO_EXE=elilo
[747]	639	else
[925]	640	LILO_EXE=`which false`
[747]	641	fi
	642	}
	643
	644
	645	FixPathIfBroken() {
[925]	646	if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
[747]	647	PATH=$PATH:/sbin:/usr/sbin
	648	export PATH
	649	echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
	650	echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
	651	echo "You might like to call 'su -' instead of 'su', for example." >> $LOGFILE
	652	fi
	653	}
	654
	655
	656	FindSensibleBootBFile() {
	657	local i out last
	658	out=""
	659	last=""
	660	for i in `find /boot -type f \| grep -v chain \| grep -v os2 \| sort -u` ; do
	661	if [ "`strings $i 2> /dev/null \| head -n1`" = "LILO" ] ; then
	662	out="$out $i"
[925]	663	last="$i"
[747]	664	fi
	665	done
	666	echo "$last"
	667	}
	668
	669
	670	FindSpecificModuleInPath() {
	671	local modpaths pwd line
	672	pwd=`pwd`
	673	if [ "$YOUR_KERNEL_SUCKS" ] ; then
[940]	674	cd $MINDI_TMP
[747]	675	else
	676	cd /
	677	fi
	678	if [ ! -e "$1" ] ; then
[963]	679	LogIt "WARNING - cannot search specific path '$1'"
[747]	680	return 1
	681	fi
	682	modpaths=`find $1 -name $2.*o -type f`
	683	[ "$?" -ne "0" ] && Die "find $1 -name $2.o -type f --- failed"
	684	[ "$modpaths" = "" ] && modpaths=`find $1 -name $2.o.gz -type f`
	685	[ "$modpaths" = "" ] && modpaths=`find $1 -name $2.ko.gz -type f`
	686	[ "$modpaths" = "" ] && modpaths=`find $1 -name $2 -type f`
	687	echo "$modpaths"
	688	cd $pwd
	689	}
	690
	691
	692	GenerateGiantDependencyList() {
	693	local incoming loc fname list_of_files i tempfile outfile progress filelist res r mapfile mappath included_list included_item old_pwd tempdepfile modres noof_lines lvmversion lvmresolved
	694
	695	echo -en "Analyzing dependency requirements"
	696	outfile=$1
[940]	697	tempfile=$MINDI_TMP/$$.txt
[747]	698	incoming=`ReadLine`
	699
	700	> $tempfile
	701	progress=0
	702	res=0
	703	noof_lines=$2
	704	while [ "$incoming" != "" ] ; do
[861]	705	if echo "$incoming" \| grep -x " #." &> /dev/null ; then
	706	incoming=`ReadLine`
	707	continue
	708	fi
	709	if [ "$incoming" = "LVMFILES:" ] ; then
	710	break
	711	fi
[747]	712	filelist=`GenerateListForFile "$incoming"`
	713	r=$?
[963]	714	[ "$r" -ne "0" ] && LogIt "$incoming not found"
[747]	715	res=$(($res+$r))
[861]	716	# echo "'$incoming' generates filelist '$filelist'" >> $LOGFILE
[747]	717	for fname in $filelist ; do
[861]	718	[ "$fname" != "" ] && echo "$fname" >> $tempfile
[747]	719	done
	720	progress=$(($progress+1))
	721	echo -en "\r\t\t\t\t\t\t\t\t"
	722	i=$(($progress*100))
	723	i=$(($i/$noof_lines))
	724	echo -en "$i"
	725	echo -en "%"
	726	modres=$(($progress%4))
	727	[ "$modres" -eq "0" ] && echo -en "\t/"
	728	[ "$modres" -eq "1" ] && echo -en "\t-"
	729	[ "$modres" -eq "2" ] && echo -en "\t\\"
	730	[ "$modres" -eq "3" ] && echo -en "\t\|"
	731	incoming=`ReadLine`
	732	done
[861]	733	if [ "$incoming" = "LVMFILES:" ] ; then
	734	incoming=`ReadLine`
	735	lvmversion=""
	736	while [ "$incoming" != "" ] ; do
	737	if echo "$incoming" \| grep -x " #." &> /dev/null ; then
	738	incoming=`ReadLine`
	739	continue
	740	fi
	741	filelist=`GenerateListForFile "$incoming"`
	742	for tool in $filelist ; do
	743	lvmresolved=`readlink -f $tool`
	744	if [ "$tool" == "$lvmresolved" ]; then
	745	echo "$tool" >> $tempfile
	746	elif echo "$lvmresolved" \| grep "lvmiopversion" &> /dev/null ; then
	747	if [ "$lvmversion" = "" ] ; then
	748	lvmversion=`$lvmresolved`
	749	echo "$lvmresolved" >> $tempfile
	750	fi
	751	toolstripped=`echo $tool \| $AWK -F / '{print $NF;}'`
	752	if [ "$lvmversion" == "200" ]; then
	753	# pvdata and lvmcreate_initrd don't exist in LVM2
	754	case "$toolstripped" in
	755	"pvdata")
	756	continue
	757	;;
	758	"lvmcreate_initrd")
	759	continue
	760	;;
	761	esac
	762	fi
	763	toolpath="/sbin/lvm-"$lvmversion"/"$toolstripped
	764	if [ -e "$toolpath" ] ; then
	765	echo "$toolpath" >> $tempfile
	766	echo "$tool" >> $tempfile
	767	else
	768	toolpath="/lib/lvm-"$lvmversion"/"$toolstripped
	769	fi
	770	if [ -e "$toolpath" ] ; then
	771	echo "$toolpath" >> $tempfile
	772	echo "$tool" >> $tempfile
	773	else
	774	echo "Where are your LVM-Tools? Couldn't find $tool"
	775	fi
	776	else
	777	echo "$tool" >> $tempfile
	778	fi
	779	done
	780	progress=$(($progress+1))
	781	echo -en "\r\t\t\t\t\t\t\t\t"
	782	i=$(($progress*100))
	783	i=$(($i/$noof_lines))
	784	echo -en "$i"
	785	echo -en "%"
	786	modres=$(($progress%4))
	787	[ "$modres" -eq "0" ] && echo -en "\t/"
	788	[ "$modres" -eq "1" ] && echo -en "\t-"
	789	[ "$modres" -eq "2" ] && echo -en "\t\\"
	790	[ "$modres" -eq "3" ] && echo -en "\t\|"
	791	incoming=`ReadLine`
	792	done
[747]	793	fi
	794	echo -en "$DONE\nMaking complete dependency list"
	795
	796	tr -s '/' '/' < $tempfile \| sort -u > $tempfile.new
	797	mv -f $tempfile.new $tempfile
	798	> $outfile.pre
	799	progress=0
	800	noof_lines=`cat $tempfile \| wc -l`
	801	for fname in `cat $tempfile` ; do
[925]	802	echo "$fname" >> $outfile.pre
	803	LocateDeps $fname >> $outfile.pre
	804	progress=$(($progress+1))
[747]	805	echo -en "\r\t\t\t\t\t\t\t\t"
	806	i=$(($progress*100))
	807	i=$(($i/$noof_lines))
	808	echo -en "$i"
	809	echo -en "%"
[925]	810	modres=$(($progress%4))
[747]	811	[ "$modres" -eq "0" ] && echo -en "\t/"
	812	[ "$modres" -eq "1" ] && echo -en "\t-"
	813	[ "$modres" -eq "2" ] && echo -en "\t\\"
	814	[ "$modres" -eq "3" ] && echo -en "\t\|"
	815	done
	816	if [ "`DidMondoCallMe`" ] ; then
[925]	817	mkdir -p $bigdir/tmp
	818	mkdir -p $bigdir/sbin
	819	mkdir -p $bigdir/bin
[940]	820	if [ -e "$MINDI_TMP/post-nuke.tgz" ] ; then
[963]	821	LogIt "\nIncorporating post-nuke tarball"
[925]	822	old_pwd=`pwd`
	823	cd $bigdir
[963]	824	tar -zxf $MINDI_TMP/post-nuke.tgz \|\| LogIt "Error occurred when untarring post-nuke tarball"
[925]	825	cd $old_pwd
[747]	826	fi
[963]	827	if cp -f $MINDI_TMP/mondo*restore $bigdir/usr/bin 2>> $LOGFILE ; then
[925]	828	LocateDeps $bigdir/usr/bin/mondo*restore >> $outfile.pre
	829	else
[963]	830	LogIt "Cannot find mondo*restore in mondo's tempdir, $MINDI_TMP"
	831	LogIt "I bet you've got a spare copy of Mondo or Mindi floating around on your system."
[925]	832	LogIt "If Mindi was called by Mondo then send me a bug report.\n It not, type 'ps ax' to see which Mondo-related process is still running;\n then kill it. :-)\n Finally, run Mindi again."
	833	Die "Odd."
	834	fi
[963]	835	cp -f $MINDI_TMP/BOOTLOADER.* $bigdir 2> /dev/null \|\| LogIt "\nMondo v1.2x defaults to LILO as the bootloader, BTW."
[940]	836	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[963]	837	LogIt "Incorporating NFS-related settings"
[925]	838	for r in NFS-* ISO-PREFIX ; do
[963]	839	cp -f $MINDI_TMP/$r $bigdir/tmp 2>> $LOGFILE \|\| Die "Cannot copy $r - did you run out of disk space?"
[925]	840	echo "Copying $r to ramdisk" >> $LOGFILE
	841	done
	842	fi
[747]	843	fi
[925]	844	tr ' ' '\n' < $outfile.pre \| tr -s '/' '/' \| grep -Fvx "" \| sort -u \| grep -Ev "/libX11\|/libXext\|/libXi\|/libgtk\|/libgdk" > $outfile
[747]	845	rm -f $tempfile $outfile.pre
	846	[ "$res" -eq "0" ] && echo -e "\r\t\t\t\t\t\t\t\t$DONE" \|\| echo "\nFailed."
	847	return $res
	848	}
	849
	850
	851	GenerateListForFile() {
	852	local files_found loc fname incoming i res
	853	incoming="$1"
	854	files_found=""
	855	res=0
	856
	857	for fname in $incoming ; do
	858	files_found="$files_found `LocateFile $fname`"
	859	done
	860
	861	echo "$files_found" \| tr ' ' '\n' \| sort -u \| tr '\n' ' '
	862	}
	863
	864
	865	# Returns all disk devices which are part of a raid array
	866	GetAllRaidMembers() {
	867	$AWK "/^[[:space:]]#/ {next} /^[[:space:]]device/ if(\$2) {print \$2}" < /etc/raidtab
	868	}
	869
	870
	871	GetFileSizeList() {
	872	local i
	873	for i in `find $1 -type d -o -print` ; do
	874	du -sk $i
	875	done
	876	}
	877
	878
	879	GetHomeDir() {
	880	local res loc
	881	loc=`which $1 2>/dev/null`
	882	res=`file $loc \| $AWK '{print $NF;}'`
	883	dirname $res
	884	}
	885
	886
	887	# Searches parent raid device of given disk device
	888	# $1: disk device (i.e. /dev/hda1)
	889	GetParentRaidDev() {
	890	$AWK "/^[[:space:]]#/ {next} /^[[:space:]]raiddev/ {dev=\$2} /^[[:space:]]*device/ {if(\$2==\"$1\") {print dev; exit}}" < /etc/raidtab
	891	}
	892
	893
	894	# Searches members of raid device
	895	# $1: raid device (/dev/md...)
	896	GetRaidDevMembers() {
	897	$AWK "/^[[:space:]]#/ {next} /^[[:space:]]raiddev/ {if(dev) exit; if(\$2 == \"$1\") dev=\$2} /^[[:space:]]*device/ {if(dev) {print \$2}}" < /etc/raidtab
	898	}
	899
	900
	901	HackPathsToFailsafe() {
	902	local incoming newpath kver stub i pwd
	903	kver=`uname -r`
	904	incoming=`ReadLine`
	905	pwd=`pwd`
[940]	906	cd $MINDI_TMP
[747]	907	while [ "$incoming" != "" ] ; do
[925]	908	stub=`basename $incoming`
	909	newpath=`FindSpecificModuleInPath lib/modules/$FAILSAFE_KVER $stub`
	910	for i in $newpath ; do
	911	echo "$i"
	912	done
	913	read incoming
[747]	914	done
	915	cd $pwd
	916	}
	917
	918
	919	ListAllPartitions() {
	920	local res currline partition all_partitions ap_orig remaining i j
	921
[957]	922	grep -vx " #." $MY_FSTAB \| grep -vx " none." \| $AWK '/^\/dev\/[imhs]d\|\|^LABEL\=\/\|^UUID=/ && !/fdd\|cdr\|zip\|floppy/ {print $1}'
[747]	923	[ -e "/etc/raidtab" ] && $AWK '/^ *device/ {print $2}' /etc/raidtab
	924	return
	925	}
	926
	927
	928	ListImagesForUser() {
	929	local path fname
	930	path=$1
	931	echo -en "In the directory '$path' you will find the images:-\n"
	932	for fname in `ls $path \| grep -F mindi-` ; do
	933	printf "%19s " $fname
	934	done
	935	echo " "
	936	}
	937
	938
	939	ListKernelModulePaths() {
	940	local module_list module fname oss r kern
	941	oss="/root/oss/modules"
	942	module_list="`lsmod \| sed -n '2,$s/ .*//p'`"
	943	###
	944	### Sq-Modification ... Use kernelname for module search path if specified
	945	###
	946	# kern="`uname -r`"
	947	if [ "${kernelname}" != "" -a "${kernelname}" != "FAILSAFE" ]
	948	then
	949	kern=${kernelname}
	950	else
	951	kern="`uname -r`"
	952	fi
	953	###
	954	### Sq-Mod End
	955	###
	956	for module in $module_list $EXTRA_MODS ; do
	957	r=`find /lib/modules/$kern -type f \| grep "/${module}\..*o" \| tail -n1`
	958	echo "module $module --> $r" >> $LOGFILE
	959	[ "$r" ] && echo "$r"
	960	[ -f "$oss" ] && find $oss \| grep -F $module
	961	done
	962	find /lib/modules/$kern/modules.* -type f 2> /dev/null
	963	[ -f "$oss" ] && find $oss.* 2> /dev/null
	964	}
	965
	966
	967	LocateDeps() {
	968	local incoming fname deps
	969	incoming="$1"
	970	for fname in $incoming ; do
	971	if [ ! -e "$fname" ] ; then
[963]	972	echo "WARNING - $fname does not exist; cannot be LDD'd." >> $LOGFILE
[747]	973	if echo $fname \| grep lvm &> /dev/null ; then
	974	echo "This warning only affects you if you are using LVM." >> $LOGFILE
	975	if lsmod \| grep lvm &> /dev/null ; then
	976	echo "I think you are, so please take heed!" >> $LOGFILE
	977	# LogIt "Where is liblvm? You need it."
	978	else
	979	echo "I don't think you are, so don't worry about it." >> $LOGFILE
	980	fi
	981	fi
	982	elif [ -h "$fname" ] && [ -x "$fname" ] ; then
	983	echo "$fname is softlink" >> $LOGFILE
	984	else
	985	ldd $fname 2> /dev/null \| ProcessLDD $fname
	986	fi
	987	done
	988	}
	989
[925]	990
[860]	991	# Give all symlinks recursively of a full path name
	992	ReadAllLink() {
	993	file="$1"
[747]	994
[860]	995	if [ ! -h $file ]; then
	996	echo "$file"
	997	return 0
	998	fi
[747]	999
[860]	1000	link=`readlink $file`
[862]	1001	d=`dirname $file`
	1002	if [ ! -e "$link" -a ! -e "$d/$link" ]; then
	1003	echo "Problem with dead link on $file -> $link" >> $LOGFILE
	1004	fi
	1005	if [ "`echo $link \| cut -c1`" = "/" ]; then
[860]	1006	echo "$link `ReadAllLink $link`"
	1007	else
[861]	1008	d=`dirname $file`
	1009	echo "$link `ReadAllLink $d/$link`"
[860]	1010	fi
	1011	}
	1012
[925]	1013
[747]	1014	LocateFile() {
	1015	local i path fname_to_find location output resolved tmp stub cache_id loclist
	1016	fname_to_find="$1"
	1017	if echo "$fname_to_find" \| grep -x "/.*" ; then
[859]	1018	output="$fname_to_find"
[860]	1019	if [ -h "$output" ] ; then
	1020	output="`ReadAllLink $output` $output"
	1021	fi
[859]	1022	echo "$output"
	1023	return 0
[747]	1024	fi
	1025	output=""
[884]	1026	#for path in /etc /usr /usr/bin /usr/sbin /bin /usr/X11R6/bin /sbin /usr/local/bin /usr/local/sbin /usr/lib /usr/lib64 /lib /lib64 /usr/local/lib /usr/local/lib64 /usr/X11R6/lib /usr/X11R6/lib64 `find /usr/lib64 /lib64 /usr/local/lib64 /usr/X11R6/lib64 -type d` ; do
	1027	for path in /etc /usr /usr/bin /usr/sbin /bin /usr/X11R6/bin /sbin /usr/local/bin /usr/local/sbin /usr/lib /usr/lib64 /usr/lib64/* /lib /lib64 /lib64/* /usr/local/lib /usr/local/lib64 /usr/local/lib64/* /usr/X11R6/lib /usr/X11R6/lib64 /usr/X11R6/lib64/* ; do
	1028	[ ! -d "$path" ] && continue
[860]	1029	for location in "$path/$fname_to_find" ; do
[859]	1030	[ ! -e "$location" ] && continue
	1031	output="$location $output"
[860]	1032	if [ -h "$location" ] ; then
[861]	1033	output="`ReadAllLink $location` $output"
[860]	1034	fi
[859]	1035	done
[747]	1036	done
	1037	if [ "$output" = "" ] ; then
[860]	1038	return 1
[747]	1039	fi
	1040	echo "$output"
	1041	return 0
	1042	}
	1043
	1044
	1045	LogIt() {
	1046	if [ -e /dev/stderr ] ; then
[925]	1047	echo -e "$1" >> /dev/stderr
[747]	1048	elif [ -e /usr/bin/logger ] ; then
[925]	1049	/usr/bin/logger -s $1
[747]	1050	fi
[965]	1051	echo -e "$1" >> $LOGFILE
[747]	1052	}
	1053
	1054
	1055	# Called by TurnTgzIntoRdz, to make /tmp/mondo-restore.cfg
	1056	MakeMondoConfigFile() {
	1057	local outfile use_lzo use_comp use_star
	1058	outfile=$1
	1059	> $outfile
	1060	[ "$TAPESIZE" ] && echo "media-size $TAPESIZE" >> $outfile
	1061	[ "$TAPEDEV" ] && echo "media-dev $TAPEDEV" >> $outfile
	1062	[ "$FILES_IN_FILELIST" ] && echo "files-in-filelist $FILES_IN_FILELIST" >> $outfile
	1063	[ "$LAST_FILELIST_NUMBER" ] && echo "last-filelist-number $LAST_FILELIST_NUMBER" >> $outfile
	1064	[ "$INTERNAL_TAPE_BLOCK_SIZE" ] && echo "internal-tape-block-size $INTERNAL_TAPE_BLOCK_SIZE" >> $outfile
	1065	use_lzo=$USE_LZO; [ "$use_lzo" = "" ] && use_lzo="no"
[998]	1066	use_gzip=$USE_GZIP; [ "$use_gzip" = "" ] && use_gzip="no"
[747]	1067	use_comp=$USE_COMP; [ "$use_comp" = "" ] && use_comp="yes"
	1068	use_star=$USE_STAR; [ "$use_star" = "" ] && use_star="no"
	1069	echo "use-lzo $use_lzo" >> $outfile
[998]	1070	echo "use-gzip $use_gzip" >> $outfile
[747]	1071	echo "use-star $use_star" >> $outfile
	1072	echo "use-comp $use_comp" >> $outfile
	1073	echo "datestamp `date`" >> $outfile
	1074	[ "$ESTIMATED_TOTAL_NOOF_SLICES" ] && echo "total-slices $ESTIMATED_TOTAL_NOOF_SLICES" >> $outfile
[940]	1075	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-IPADDR nfs-client-ipaddr $outfile
	1076	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-NETMASK nfs-client-netmask $outfile
	1077	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-BROADCAST nfs-client-broadcast $outfile
	1078	AddFileToCfgIfExists $MINDI_TMP/NFS-CLIENT-DEFGW nfs-client-defgw $outfile
	1079	AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-MOUNT nfs-server-mount $outfile
	1080	AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-PATH nfs-server-path $outfile
	1081	AddFileToCfgIfExists $MINDI_TMP/NFS-DEV nfs-dev $outfile
	1082	AddFileToCfgIfExists $MINDI_TMP/NFS-SERVER-IPADDR nfs-server-ipaddr $outfile
	1083	AddFileToCfgIfExists $MINDI_TMP/ISO-DEV iso-dev $outfile
	1084	AddFileToCfgIfExists $MINDI_TMP/ISO-MNT iso-mnt $outfile
	1085	AddFileToCfgIfExists $MINDI_TMP/ISO-PREFIX iso-prefix $outfile
	1086	AddFileToCfgIfExists $MINDI_TMP/ISODIR isodir $outfile
	1087	AddFileToCfgIfExists $MINDI_TMP/BOOTLOADER.DEVICE bootloader.device $outfile
	1088	AddFileToCfgIfExists $MINDI_TMP/BOOTLOADER.NAME bootloader.name $outfile
	1089	AddFileToCfgIfExists $MINDI_TMP/KEYMAP-LIVES-HERE keymap-lives-here $outfile
	1090	AddFileToCfgIfExists $MINDI_TMP/TAPEDEV-HAS-DATA-DISKS tapedev-has-data-disks $outfile
	1091	AddFileToCfgIfExists $MINDI_TMP/BACKUP-MEDIA-TYPE backup-media-type $outfile
	1092	AddFileToCfgIfExists $MINDI_TMP/DIFFERENTIAL differential $outfile
[949]	1093	AddFileToCfgIfExists $MINDI_TMP/ACL acl $outfile
	1094	AddFileToCfgIfExists $MINDI_TMP/XATTR xattr $outfile
[747]	1095	}
	1096
	1097
	1098	MakeModuleLoadingScript() {
	1099	local module fname params modpath kver outerloop i modpaths kver searchpath list_to_echo j
	1100	tmpmodprobe_flag=$1
	1101	outfile=$2
	1102	> $outfile \|\| Die "Cannot create empty $outfile"
	1103	echo -en "#\041/bin/sh\n\n" >> $outfile
	1104	echo "echo -en \"Loading your modules...\"" >> $outfile
	1105	if [ "$YOUR_KERNEL_SUCKS" ] ; then
	1106	kver=$FAILSAFE_KVER
[940]	1107	cd $MINDI_TMP
[747]	1108	searchpath=lib/modules/$kver
	1109	else
	1110	###
	1111	### Sq-Modification ... Use kernelname for module search path if specified
	1112	###
	1113	#kver=`uname -r`
	1114	if [ "${kernelname}" != "" ]
	1115	then
[925]	1116	kver=${kernelname}
[747]	1117	else
[925]	1118	kver=`uname -r`
[747]	1119	fi
	1120	###
	1121	### Sq-Modification end
	1122	###
	1123	searchpath=/lib/modules/$kver
	1124	fi
	1125
	1126	echo -en "for outerloop in 1 2 3 4 5 ; do\necho -en \".\"\n" >> $outfile
	1127	list_to_echo="`lsmod \| sed -n '2,$s/ .*//p'`"
[925]	1128
[747]	1129	# Make temporary modprobe.conf file if we are told so
	1130	if [ $tmpmodprobe_flag == "Y" ] ; then
[940]	1131	infile="$MINDI_TMP/modprobe.conf.mindi"
[747]	1132	find /etc/modprobe.d -maxdepth 1 -name "*" -xtype f -print0 \| xargs -0 cat > $infile
	1133	else
	1134	infile="/etc/modules.conf"
	1135	fi
	1136	for module in $list_to_echo $EXTRA_MODS ; do
	1137	params=`sed -n "s/^options \\+$module \\+//p" $infile`
	1138	modpaths=`FindSpecificModuleInPath $searchpath $module`
	1139	for i in $modpaths ; do
	1140	echo "MyInsmod $i $params > /dev/null 2> /dev/null" \
	1141	\| tr '.' '#' \
	1142	\| sed s/#o#gz/#o/ \
	1143	\| sed s/#o#gz/#o/ \
	1144	\| sed s/#ko#gz/#ko/ \
	1145	\| sed s/#ko#gz/#ko/ \
	1146	\| tr '#' '.' >> $outfile
	1147	echo -en "$i added to module list.\n" >> $LOGFILE
	1148	done
	1149	done
	1150	echo -en "done\n" >> $outfile
	1151	echo "echo \"Done.\"" >> $outfile
	1152	chmod +x $outfile
	1153	cd /
	1154	# Remove temporary modprobe.conf file if we have created one
	1155	if [ $tmpmodprobe_flag == "Y" ] ; then
	1156	rm -f $infile
	1157	fi
	1158	}
	1159
	1160
	1161	MakeMountlist() {
	1162	local scratchdir mountlist all_partitions current_partition \
	1163	partition_size partition_format outstring partition_number \
	1164	partition_mountpt c_p lwm_info psz lvm_dev unofficial_outstring \
	1165	absolute_partition old_partition_fmt current_lvolume
	1166
[967]	1167	echo "Your raw fstab file looks like this:" >> $LOGFILE
	1168	echo "------------------------------------" >> $LOGFILE
[747]	1169	cat $MY_FSTAB >> $LOGFILE
[967]	1170	echo "Your mountlist will look like this:" \| tee -a $LOGFILE
	1171	echo "-----------------------------------" >> $LOGFILE
[747]	1172
	1173	# scratchdir, mountlist(OUT)
[940]	1174	scratchdir=$MINDI_TMP
[747]	1175	mountlist=$1
	1176
	1177	# NB: partition = device
	1178	# NB: mountpt = where the device is mounted
	1179
	1180	[ -e "$MY_FSTAB" ] \|\| Die "Cannot find your fstab file ($MY_FSTAB)"
	1181
	1182	rm -f $mountlist
	1183	mkdir -p $mountlist
	1184	rm -Rf $mountlist
	1185	> $mountlist
	1186	echo -en "\rHang on...\r"
	1187	all_partitions=""
	1188
	1189	if [ $LVM != "false" ]; then
	1190	echo -en "\rAnalyzing LVM...\r"
[968]	1191	$MINDI_LIB/analyze-my-lvm > $MINDI_TMP/lvm.res
[971]	1192	if [ $? -ne 0 ]; then
[963]	1193	LVM="false"
	1194	fi
[968]	1195	all_partitions=`cat $MINDI_TMP/lvm.res \| grep -F ">>>" \| cut -d' ' -f2-32`
[747]	1196	fi
	1197	all_partitions="$all_partitions `ListAllPartitions 2> /dev/null`"
	1198	# echo "all partitions = $all_partitions" > /dev/stderr
	1199	for i in $IMAGE_DEVS ; do
	1200	mount \| grep -F "$i " > /dev/null 2> /dev/null && Die "Sorry, $i is already mounted! CANNOT DO IMAGEDEV on it if it's mounted."
	1201	done
	1202	[ "$IMAGE_DEVS" != "" ] && all_partitions="`echo "$all_partitions $IMAGE_DEVS" \| tr ' ' '\n' \| sort -u \| tr '\n ' ' '`"
[976]	1203	printf " %-15s %-15s %-15s %-15s %-15s %-15s\n" DEVICE MOUNTPOINT FORMAT "SIZE (MB)" LABEL UUID \| tee -a $LOGFILE
[747]	1204	useless_dev="/dev/floppy /dev/fd0h1440 /dev/fd0H1440 /dev/cdrom /dev/cdrom/cdrom /dev/cdrom/cdrom1 /dev/cdrom/cdrom2 /dev/cdrom0 /dev/cdrom1 /dev/cdrom2 /dev/cdrom3 /dev/cdrw /dev/scd /dev/ram :/ /dev/sr0 /dev/sr1 /dev/cdrom1"
	1205	for c_p in $all_partitions ; do
	1206	[ "`echo "$useless_dev" \| grep -F "$c_p"`" != "" ] \|\| [ "`echo "$c_p" \| grep ":"`" != "" ] && continue
	1207	[ "`echo "$c_p" \| grep -x "/dev/cdroms.*"`" ] && continue
	1208	if [ -h "$c_p" ] && [ "`echo "$c_p" \| grep -F "/dev/hd"`" = "" ] && [ "`echo "$c_p" \| grep -F "/dev/sd"`" = "" ] && [ "`echo "$c_p" \| grep -F "/dev/md"`" = "" ] ; then
[861]	1209	current_partition=`readlink -f $c_p`
[747]	1210	[ "`echo "$current_partition" \| grep -F "/dev/mapper"`" != "" ] && current_partition="$c_p"
	1211	[ "`echo "$useless_dev" \| grep -F "$current_partition"`" ] && continue
	1212	else
	1213	current_partition="$c_p"
	1214	fi
	1215	[ "$c_p" = "none" ] && continue
	1216	redhat_label=""
[957]	1217	uuid=""
[861]	1218	absolute_partition=`readlink -f $c_p`
[747]	1219	partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB \| /bin/grep -w "$current_partition" \| /bin/grep -vx " #." \| $AWK '{print $2}' \| head -n1`
	1220
	1221	# Detects noauto partitions not mounted and exclude them
	1222	partition_option=`tr -s '\t' ' ' < $MY_FSTAB \| /bin/grep -w "$current_partition" \| /bin/grep -vx " #." \| $AWK '{print $4}' \| head -n1`
	1223	if [ "`echo "$partition_option" \| grep -i noauto`" != "" ] && [ "`mount \| grep -w "$partition_mountpt"`" = "" ] ; then
	1224	continue
	1225	fi
	1226
	1227	# This part tries to retrieve the correct device from a LABEL line in /etc/fstab
	1228	# current_partition contains only first column of /etc/fstab
	1229	if [ "`echo "$current_partition" \| /bin/grep -i "LABEL="`" != "" ]; then
	1230	str_to_find_fmt_with=$current_partition
[980]	1231	redhat_label=`echo "$current_partition" \| cut -d'=' -f2`
[747]	1232	actual_dev=""
[853]	1233
	1234	# 1st try, findfs - the RHEL way of finding labels and their partitions
	1235	if [ -x "/sbin/findfs" ]; then
[855]	1236	actual_dev=`/sbin/findfs LABEL=${redhat_label} 2> /dev/null`
[853]	1237	fi
[747]	1238
[853]	1239	# 2nd try : blkid, the good way for all LABEL except swap
	1240	if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
[980]	1241	actual_dev=`/sbin/blkid \| /bin/grep "$redhat_label" \| grep LABEL= \| cut -d':' -f1`
[747]	1242	# For LVM FS it will give a /dev/dm-# which should then be converted
[748]	1243	if [ $LVM = "v2" ] && [ "`echo $actual_dev \| grep '/dev/dm'`" ]; then
[963]	1244	major=`/bin/ls -l $actual_dev \| $AWK '{print $5}'`
	1245	minor=`/bin/ls -l $actual_dev \| $AWK '{print $6}'`
[747]	1246	for dev in `ls /dev/mapper/*`; do
[963]	1247	major1=`/bin/ls -l $dev \| $AWK '{print $5}'`
	1248	minor1=`/bin/ls -l $dev \| $AWK '{print $6}'`
[747]	1249	if [ $major1 = $major ] && [ $minor1 = $minor ]; then
[963]	1250	actual_dev=`/bin/ls -l $dev \| $AWK '{print $10}'`
[747]	1251	break
	1252	fi
	1253	done
	1254	fi
	1255	fi
	1256
[853]	1257	# 3rd try, which works on a standard partition (ext2/3), but not on swap
[747]	1258	# For LVM gives a /dev/mapper entry
	1259	if [ "x$actual_dev" = "x" ]; then
[980]	1260	actual_dev=`/bin/mount -l \| /bin/grep "\[$redhat_label\]" \| cut -d' ' -f1`
[747]	1261	fi
	1262
[853]	1263	# 4th try, with vol_id
[747]	1264	# SWAP only
	1265	if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
[963]	1266	list_swaps=`cat /proc/swaps \| /bin/grep "/dev/" \| $AWK '{ print $1 }' `
[747]	1267	for dev_swap in $list_swaps ; do
	1268	dev_exists=`/sbin/vol_id $dev_swap \| /bin/grep "$redhat_label"`
	1269	if [ "x$dev_exists" != "x" ]; then
	1270	actual_dev=$dev_swap
	1271	break;
	1272	fi
	1273	done
	1274	fi
	1275
[853]	1276	# 5th try : pre-formated LABEL. Format is : LABEL=SWAP-mydevice or SW-mydevice. e.g. : LABEL=SWAP-hda5
[789]	1277	# LABEL=SW-cciss/c0d0p3 (RDP)
[853]	1278	# or could be a string that isn't a complete device name (eg. LABEL =SWAP-cciss/c0d0p)
[747]	1279	# SWAP only
[789]	1280	if [ "x$actual_dev" = "x" -a _"`echo $current_partition \| /bin/grep -iE 'LABEL=SWAP\|LABEL=SW-'`" != _"" ]; then
[853]	1281	for try_dev in `tail +2 /proc/swaps \| cut -d' ' -f1`
	1282	do
	1283	# Location of the swap label for kernel 2.6
[963]	1284	try_dev_label=`dd bs=1 count=16 skip=1052 if=$try_dev &> /dev/null`
[853]	1285	if [ "x$try_dev_label" = "x$redhat_label" ]; then
[855]	1286	actual_dev=$try_dev
[853]	1287	fi
	1288	done
[747]	1289	fi
[958]	1290	fi
[747]	1291
[957]	1292	# This part tries to retrieve the correct device from a UUID line in /etc/fstab
	1293	# current_partition contains only first column of /etc/fstab
	1294	if [ "`echo "$current_partition" \| /bin/grep -i "UUID="`" != "" ]; then
	1295	str_to_find_fmt_with=$current_partition
[980]	1296	uuid=`echo "$current_partition" \| cut -d'=' -f2`
[957]	1297	actual_dev=""
	1298
	1299	# 1st try, findfs - the RHEL way of finding labels and their partitions
	1300	if [ -x "/sbin/findfs" ]; then
	1301	actual_dev=`/sbin/findfs UUID=${uuid} 2> /dev/null`
	1302	fi
	1303
	1304	# 2nd try : blkid, the good way for all LABEL except swap
	1305	if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
[980]	1306	actual_dev=`/sbin/blkid \| /bin/grep "$uuid" \| grep UUID= \| cut -d':' -f1`
[957]	1307	# For LVM FS it will give a /dev/dm-# which should then be converted
	1308	if [ $LVM = "v2" ] && [ "`echo $actual_dev \| grep '/dev/dm'`" ]; then
[963]	1309	major=`/bin/ls -l $actual_dev \| $AWK '{print $5}'`
	1310	minor=`/bin/ls -l $actual_dev \| $AWK '{print $6}'`
[957]	1311	for dev in `ls /dev/mapper/*`; do
[963]	1312	major1=`/bin/ls -l $dev \| $AWK '{print $5}'`
	1313	minor1=`/bin/ls -l $dev \| $AWK '{print $6}'`
[957]	1314	if [ $major1 = $major ] && [ $minor1 = $minor ]; then
[963]	1315	actual_dev=`/bin/ls -l $dev \| $AWK '{print $10}'`
[957]	1316	break
	1317	fi
	1318	done
	1319	fi
	1320	fi
	1321
	1322	# 3th try, with vol_id
	1323	if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
[963]	1324	list_dev=`mount \| /bin/grep -E '^/' \| $AWK '{ print $1 }' `
[957]	1325	for dev in $list_dev ; do
	1326	dev_exists=`/sbin/vol_id $dev \| /bin/grep "$uuid"`
	1327	if [ "x$dev_exists" != "x" ]; then
	1328	actual_dev=$dev
	1329	break;
	1330	fi
	1331	done
	1332	fi
	1333
[747]	1334	# Check if one of all those tries has known success
	1335	if [ "x$actual_dev" != "x" ]; then
	1336	current_partition=$actual_dev
	1337	else
[963]	1338	Die "Your system uses a UUID partition ($current_partition), but you lack the tool to support it.\nPlease replace labels with their correct devices in /etc/fstab or install findfs\|blkid\|vol_id"
[747]	1339	fi
	1340	else
	1341	str_to_find_fmt_with=$current_partition
	1342	fi
	1343
	1344	partition_format=`$AWK '$1 == "'"$str_to_find_fmt_with"'" {print $3}' $MY_FSTAB`
	1345	# Some distributions such as Debian do not put /dev/<VG>/<LV> in fstab
	1346	# for LVM partitions but use /dev/mapper/<VG>-<LV> instead. Fortunately,
	1347	# the former is then a link to the latter, so we test whether
	1348	# $current_partition is actually such a link or not and set
[755]	1349	# $current_lvolume accordingly. On Debian you may find more than one answer
	1350	# so we remove the one corresponding to /dev/.static
	1351	# On RedHat even if the device name is different (/dev/mapper/<VG><LV>), the
	1352	# principle is the same and we need to find the link to it as well.
	1353	# Note that $current_lvolume may well be an
[747]	1354	# ordinary device. It is just to make sure that we feed the right value
	1355	# into any of the LVM tools if possible.
	1356
	1357	current_lvolume="$current_partition"
[763]	1358	if [ $LVM = "v2" ] && [ "`echo $current_partition \| grep -E '^/dev/mapper/'`" ]; then
[755]	1359	# .static dir are a Debian specificity
[763]	1360	current_lvolume="`find /dev -lname "$current_partition" \| grep -Ev '^/dev/\.static/'`"
[755]	1361	echo $current_lvolume \| grep -q ' '
[784]	1362	if [ $? -eq 0 ]; then
[755]	1363	echo "WARNING: Multiple Logical Volumes found. Report to dev team" >> $LOGFILE
	1364	fi
[747]	1365	fi
	1366	#
	1367	# End of LVM device style variation code (other than $current_lvolume).
	1368
[745]	1369	if [ $LVM != "false" ] && [ "`$LVMCMD lvdisplay $current_lvolume 2> /dev/null`" ]; then
	1370	# Size computed via LVM not directly
[747]	1371	partition_size="lvm"
	1372	else
	1373	partition_size=`SizeOfPartition $current_partition`
	1374	[ "`echo "$current_partition" \| grep "[0-9]"`" = "" ] && continue
	1375	[ "`echo "$current_partition" \| grep -c "^/"`" -ne "1" ] && continue
	1376	if [ "$partition_format" = "swap" ] \|\| [ "$partition_mountpt" = "swap" ] ; then
	1377	partition_size=`grep -Fv "Priority" /proc/swaps \| tr -s '\t' ' ' \| grep -F "$current_partition" \| $AWK '{print $3}'`
	1378	[ "$partition_mountpt" != "swap" ] && partition_mountpt="swap"
	1379	[ "$partition_format" != "swap" ] && partition_format="swap"
	1380	if [ "$partition_size" = "" ] ; then
	1381	totalsize=0
	1382	items=0
	1383	for i in `tr -s ' ' '\t' < /proc/swaps \| grep -Fv "Filename" \| cut -f3` ; do
	1384	totalsize=$(($totalsize+$i))
	1385	items=$(($items+1))
	1386	done
	1387	[ "$items" -gt "0" ] && partition_size=$(($totalsize/$items)) \|\| partition_size=0
	1388	[ "$partition_size" -lt "125000" ] && partition_size=125000
	1389	echo "I'm guessing $c_p is $(($partition_size/1024))MB" >> $LOGFILE
	1390	fi
	1391	fi
	1392	fi
	1393	[ "$partition_mountpt" = "swap" ] && partition_format="swap"
	1394	[ "$partition_format" = "swap" ] && partition_mountpt="swap"
	1395	if [ "$partition_mountpt" = "" ] ; then
	1396	if [ "`$LVMCMD pvdisplay $current_lvolume 2> /dev/null`" != "" ] ; then
	1397	if [ "`grep -F device /etc/raidtab 2> /dev/null \| grep -w $current_partition`" ] ; then
	1398	partition_mountpt="raid"
	1399	partition_format="raid"
	1400	else
	1401	partition_mountpt="lvm"
	1402	partition_format="lvm"
	1403	fi
	1404	fi
	1405	fi
	1406	psz=$partition_size
	1407	echo "Examining $current_partition (mount=$partition_mountpt fmt=$partition_format psz=$psz)" >> $LOGFILE
	1408	[ "$psz" != "lvm" ] && psz=$(($psz/1024))
	1409	if [ "`echo " $IMAGE_DEVS " \| grep -F " $current_partition "`" != "" ] ; then
	1410	partition_mountpt="image"
	1411	old_partition_fmt=$partition_format
	1412	partition_format="`$FDISK -l 2>> $LOGFILE \| tr '*' ' ' \| tr '+' ' ' \| tr -s ' ' '\t' \| grep -w "$absolute_partition" \| cut -f5`"
	1413	partition_size=$(($partition_size+1)); # just in case
	1414	if [ "$partition_format" = "Linux" ] ; then
	1415	echo "Are you imaging a mounted swap partition? Silly..." >> $LOGFILE
	1416	echo "Reverting format from $old_partition_fmt to $partition_format" >> $LOGFILE
	1417	partition_format=$old_partition_fmt
	1418	fi
	1419	fi
	1420	if [ "$EXCLUDE_DEVS" ] && [ "`echo " $EXCLUDE_DEVS " \| grep -F " $current_partition "`" ] \|\| [ "`echo " $EXCLUDE_DEVS " \| grep " $current_partition "`" ] ; then
	1421	echo "Excluding $current_partition from mountlist" >> $LOGFILE
	1422	continue
	1423	fi
	1424	if [ ! "$partition_mountpt" ] ; then
[965]	1425	echo "------- $FDISK -l $qq log ------------" >> $LOGFILE
[747]	1426	for qq in "" `find /dev/ida/cd ! -name 'p'` ; do
	1427	partition_format=`$FDISK -l $qq 2>> $LOGFILE \| grep -w "$c_p" \| sed 's/12/\|/' \| tr -s '\t' ' ' \| cut -d'\|' -f2 \| cut -d' ' -f2-9`
	1428	[ "$partition_format" ] && break
	1429	done
[965]	1430	echo "------- $FDISK log end ------------" >> $LOGFILE
[747]	1431	if [ "$partition_format" = "Compaq diagnostics" ] ; then
	1432	partition_format="compaq"
	1433	elif [ ! "`grep -F device /etc/raidtab 2> /dev/null \| grep -w $current_partition`" ] ; then
[963]	1434	LogIt "Unable to find mountpoint of $current_partition - ignoring"
[747]	1435	continue
	1436	fi
	1437	fi
	1438	partition_format="`echo "$partition_format" \| cut -d',' -f1`"; # in case user has ext3,ext2 or something dumb like that
[963]	1439	[ "$partition_format" = "auto" ] && partition_format="`mount \| grep -w $current_partition \| $AWK '{print$5;}'`"; # in case user uses 'auto' (dumb!)
[976]	1440	unofficial_outstring=`printf "\t%-15s %-15s %-15s %7s %-15s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$redhat_label" $uuid`
[747]	1441	if [ "$current_partition" = "" ] ; then
	1442	echo "Unknown partition (outstring = $unofficial_outstring)" >> $LOGFILE
	1443	elif [ "$partition_mountpt" = "" ] && [ -f "/etc/raidtab" ] ; then
	1444	if [ "`grep -F device /etc/raidtab 2>/dev/null \| grep -F $current_partition`" ] ; then
	1445	partition_mountpt=raid
	1446	partition_format=raid
[976]	1447	printf "\t%-15s %-15s %-15s %7s %-15s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$redhat_label" $uuid \| tee -a $LOGFILE
	1448	printf "%s %s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$redhat_label" $uuid >> $mountlist
[747]	1449	else
	1450	echo "Unknown mountpoint (outstring = $unofficial_outstring)" >> $LOGFILE
	1451	fi
	1452	elif [ "$partition_format" = "" ] ; then
	1453	echo "Unknown format (outstring = $unofficial_outstring)" >> $LOGFILE
	1454	elif [ "$partition_size" = "" ] ; then
	1455	echo "Unknown partition size (outstring = $unofficial_outstring)" >> $LOGFILE
	1456	elif [ "$partition_mountpt" = "/proc" ] \|\| [ "$partition_mountpt" = "/dev/pts" ] ; then
	1457	continue
	1458	else
	1459	if [ "$partition_format" = "dos" ] \|\| [ "$partition_format" = "msdos" ] ; then
	1460	echo "Stupid bastard..." >> $LOGFILE
	1461	partition_format="vfat"
	1462	fi
[976]	1463	printf "\t%-15s %-15s %-15s %7s %-15s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$redhat_label" $uuid \| tee -a $LOGFILE
	1464	printf "%s %s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$redhat_label" $uuid >> $mountlist
[747]	1465	fi
	1466	done
	1467	}
	1468
	1469
	1470	MakeSureNumberIsInteger() {
	1471	res=`echo "$1" \| tr -s '\-[0-9]' ' '`
	1472	if [ "$res" != " " ] && [ "$res" != "" ] ; then
	1473	echo "result = '$res'"
	1474	Die "$1 should be an integer"
	1475	fi
	1476	}
	1477
	1478
	1479	MakeSyslinuxMessageFile() {
	1480	mkdir -p $1
	1481	rmdir $1
	1482	echo -en " " > $1
	1483	if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
	1484	sed s/ZZZZZ/$MINDI_VERSION/ $MINDI_LIB/msg-txt \| sed s/YYYYY/"Mondo Rescue"/ \| sed s/XXXXX/"a cousin of"/ \| sed s%DDDDD%"Debian GNU\/`uname -s` `cut -d ' ' -f 3 /etc/issue.net` `hostname`"% \| sed s/KKKKK/"Kernel `uname -r` on a `uname -m`"/ \| sed s/TTTTT/"`LC_TIME=C date`"/ >> $1.tmp
	1485	else
	1486	sed s/ZZZZZ/$MINDI_VERSION/ $MINDI_LIB/msg-txt \| sed s/YYYYY/"Mondo Rescue"/ \| sed s/XXXXX/"a cousin of"/ \| sed s/DDDDD/"`grep -i "linux" /etc/issue.net \| head -n1 \| tr -s ' ' ' '`"/ \| sed s/KKKKK/"`grep -i "kernel" /etc/issue.net \| head -n1 \| tr -s ' ' ' '`"/ \| sed s/TTTTT/"`LC_TIME=C date`"/ \| sed s/' '\\r' 'on' 'an' '\/' '`uname -r`' 'on' 'an' '`uname -m`/ >> $1.tmp
	1487	fi
	1488	sed s/%r/"`uname -r`"/ $1.tmp \| sed s/%t/"`hostname`"/ > $1
	1489	rm -f $1.tmp
	1490	if [ "$CDRECOVERY" != "yes" ] ; then
[940]	1491	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1492	echo -en "Press <enter> to continue.\n" >> $1
[940]	1493	elif [ ! "$MINDI_TMP" ] ; then
[747]	1494	echo -en "FYI, this is _not_ a Mondo Rescue CD.\n" >> $1
	1495	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	1496	echo -en "Type 'memtest' <Enter> to test your PC's memory intensively.\nJust press <Enter> to go to the main test menu.\n" >> $1
	1497	fi
	1498	else
	1499	echo -en "$BOOT_MEDIA_MESSAGE" >> $1
	1500	fi
	1501	else
	1502	echo -en " \
	1503	To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
	1504	CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n" >> $1
	1505	fi
	1506	}
	1507
	1508
	1509	MoveHyperlinkSensibly() {
	1510	local filename minidir_root resides_on_diskno noof_disks old_diskno d old_pwd
	1511	filename=$1
	1512	minidir_root=$2
	1513	resides_on_diskno=$3
	1514	noof_disks=$4
	1515
	1516	[ -h "$minidir_root/$resides_on_diskno/$filename" ] \|\| Die "$filename isn't a softlink (or doesn't exist): how can I move it sensibly?"
	1517
	1518	old_diskno=$resides_on_diskno
	1519	d=1
	1520	while [ "$d" -le "$noof_disks" ] ; do
	1521	if [ "$d" -ne "$old_diskno" ] ; then
	1522	old_pwd=`pwd`
	1523	cd $minidir_root/$old_diskno
[963]	1524	cp --parents -Rdf $filename $minidir_root/$d/ 2>> $LOGFILE \|\| Die "Can't move $filename (sensibly) from $old_diskno to $d"
[747]	1525	rm -f $filename
	1526	cd $old_pwd
	1527	fi
	1528	# when the softlink is resolvable, our work here is done
	1529	[ -e "$minidir_root/$d/$filename" ] && return 0
	1530	old_diskno=$d
	1531	d=$(($d+1))
	1532	done
	1533	return 1
	1534	}
	1535
	1536
	1537
	1538	OfferToCopyImagesToDisks() {
	1539	local imagesdir i imagename dev count boot_dev data_dev
	1540	imagesdir=$1
	1541	boot_dev=$2
	1542	data_dev=$3
[925]	1543
[966]	1544	echo -en "Would you like to create boot+data floppy disks now (y/[n]) ?"
[747]	1545	read i
	1546	[ "$i" != "y" ] && [ "$i" != "Y" ] && return
	1547	mount \| grep -F /dev/fd > /dev/null && Die "Please unmount your floppies first."
	1548	echo "WARNING! THIS WILL ERASE YOUR FLOPPY DISKS."
	1549	[ ! -e "$boot_dev" ] && Die "Cannot find $boot_dev - is your Linux distro broken?"
	1550	[ ! -e "$data_dev" ] && Die "Cannot find $data_dev - is your Linux distro broken?"
	1551	i=`find $imagesdir -type f \| grep -F "/mindi-root.1" 2> /dev/null`
	1552	j=`find $imagesdir -type f \| grep -F "/mindi-boot" \| grep -Ev '2880\|5760'`
	1553	if [ "$i" ] ; then
	1554	CopyImageToDisk $j $data_dev "boot disk"
	1555	CopyImageToDisk $i $data_dev "root disk"
	1556	else
	1557	CopyImageToDisk $j $boot_dev "boot/root disk"
	1558	fi
	1559	count=1
	1560	for i in `find $imagesdir \| grep -F mindi-data` ; do
	1561	CopyImageToDisk $i $data_dev "data disk #$count"
	1562	count=$(($count+1))
	1563	done
	1564	}
	1565
	1566
	1567	OfferToMakeBootableISO() {
	1568	local i old_pwd
	1569	if [ "$PROMPT_MAKE_CD_IMAGE" = "yes" ] && [ ! "`DidMondoCallMe`" ] ; then
[966]	1570	echo -en "Shall I make a bootable CD image? (y/[n]) "
[747]	1571	read i
	1572	[ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
	1573	fi
[940]	1574	if [ ! "$MINDI_TMP" ] ; then
[963]	1575	LogIt "NB: Mindi's bootable CD always uses isolinux."
	1576	LogIt "For a bootable CD w/LILO, please use Mondo."
[747]	1577	fi
[940]	1578	rm -Rf $MINDI_TMP/iso
	1579	mkdir -p $MINDI_TMP/iso/{images,archives,isolinux}
[963]	1580	cp -f $1/.img $1/.gz $MINDI_TMP/iso/images 2>> $LOGFILE \|\| LogIt "OfferToMakeBootableISO: Cannot copy $i to $MINDI_TMP/iso/images"
[747]	1581	old_pwd=`pwd`
[940]	1582	cd $MINDI_TMP/iso
[747]	1583	mkdir -p $MONDO_ROOT/iso/isolinux
	1584	echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
	1585	for i in memdisk memtest.bin memtest.img ; do
[953]	1586	j=$MINDI_LIB/$i
	1587	k=$MINDI_TMP/iso/isolinux
	1588	if [ -e "$j" ] ; then
[963]	1589	LogIt "Copying $j to $k"
[953]	1590	cp -f $j $k 2> /dev/null \|\| Die "Failed to copy $j to $k"
	1591	cp -f $j $MINDI_TMP 2> /dev/null \|\| Die "Failed to copy $j to $MINDI_TMP"
	1592	cp -f $j $MONDO_ROOT 2>> $LOGFILE \|\| Die "Failed to copy $j to $MONDO_ROOT"
	1593	fi
[747]	1594	done
[940]	1595	MakeSyslinuxMessageFile $MINDI_TMP/iso/isolinux/message.txt
[953]	1596	cp $kernelpath $MINDI_TMP/iso/isolinux/vmlinuz 2> /dev/null \|\| Die "Cannot copy vmlinuz ($kernelpath) to mondo root ($MONDO_ROOT/isolinux/vmlinuz). Did you run out of disk space?"
[963]	1597	cp $MINDI_TMP/mindi.rdz $MINDI_TMP/iso/isolinux/initrd.img 2>> $LOGFILE
	1598	cp $MINDI_TMP/mindi.rdz $CACHE_LOC/initrd.img 2>> $LOGFILE
[747]	1599	[ -e "$iso_cfg_file" ] \|\| Die "FIXME - unable to find $iso_cfg_file - this should never occur"
[940]	1600	cd $MINDI_TMP/iso/isolinux
	1601	cat $iso_cfg_file \| HackSyslinuxFile $ramdisk_size $MINDI_TMP/iso > isolinux.cfg \|\| Die "Cannot copy isolinux.cfg from mindi_home to tmp_root - did you run out of disk space?"
	1602	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1603	mv isolinux.cfg isolinux.cfg.old
	1604	sed s/interactive/iso/ isolinux.cfg.old > isolinux.cfg
	1605	fi
	1606	if [ "$ARCH" != "ia64" ] ; then
[953]	1607	cp $ISOLINUX isolinux.bin 2> /dev/null \|\| Die "Cannot copy isolinux.bin ($ISOLINUX) to tmp_root - did you run out of disk space?"
[963]	1608	cp $ISOLINUX ../ 2>> $LOGFILE
[747]	1609	fi
[940]	1610	cd $MINDI_TMP/iso
[747]	1611	if [ "$ARCH" != "ia64" ] ; then
[953]	1612	cp -f $MINDI_TMP/iso/isolinux/{isolinux.cfg,initrd.img,vmlinuz,isolinux.bin,message.txt} $MONDO_ROOT 2> /dev/null \|\| Die "Cannot copy core files to ramdisk for boot disk. Did you run out of disk space?"
[747]	1613	fi
[963]	1614	[ "$MONDO_SHARE" ] && cp -f $MONDO_SHARE/autorun . 2>> $LOGFILE
[747]	1615	if [ "$ARCH" != "ia64" ] ; then
[940]	1616	mkisofs -U -J -r -o $CACHE_LOC/mindi.iso -b isolinux/isolinux.bin -c isolinux/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table . > /dev/null 2> $MINDI_TMP/mkisofs.log
[747]	1617	else
[940]	1618	mkisofs -J -r -o $CACHE_LOC/mindi.iso -b images/mindi-bootroot.$IA64_BOOT_SIZE.img -c isolinux/boot.cat -no-emul-boot . > /dev/null 2> $MINDI_TMP/mkisofs.log
[747]	1619	fi
	1620	if [ "$?" -ne "0" ] ; then
[925]	1621	echo "----------- mkisofs's errors --------------" >> $LOGFILE
[940]	1622	cat $MINDI_TMP/mkisofs.log >> $LOGFILE
[925]	1623	echo "mkisofs returned the following errors:-"
[940]	1624	cat $MINDI_TMP/mkisofs.log
[963]	1625	LogIt "Failed to create ISO image."
[747]	1626	else
[925]	1627	echo "Created bootable ISO image at $CACHE_LOC/mindi.iso" >> $LOGFILE
[747]	1628	fi
[940]	1629	rm -f $MINDI_TMP/mkisofs.log
[747]	1630	cd $old_pwd
	1631	}
	1632
	1633
	1634	PluralOrNot() {
	1635	[ "$1" -gt "1" ] && echo -en "s"
	1636	}
	1637
	1638
	1639	MakeMessageFile() {
	1640	local disksize
	1641	disksize=$1
	1642	if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
	1643	sed s/ZZZZZ/$MINDI_VERSION/ $MINDI_LIB/msg-txt \| sed s/YYYYY/"Mondo Rescue"/ \| sed s/XXXXX/"a cousin of"/ \| sed s%DDDDD%"Debian GNU\/`uname -s` `cut -d ' ' -f 3 /etc/issue.net` `hostname`"% \| sed s/KKKKK/"Kernel `uname -r` on a `uname -m`"/ \| sed s/TTTTT/"`LC_TIME=C date`"/
	1644	else
	1645	sed s/ZZZZZ/$MINDI_VERSION/ $MINDI_LIB/msg-txt \| sed s/YYYYY/"Mondo Rescue"/ \| sed s/XXXXX/"a cousin of"/ \| sed s/DDDDD/"`grep -i "linux" /etc/issue.net \| head -n1 \| tr -s ' ' ' '`"/ \| sed s/KKKKK/"`grep -i "kernel" /etc/issue.net \| head -n1 \| tr -s ' ' ' '`"/ \| sed s/TTTTT/"`LC_TIME=C date`"/ \| sed s/' 'r' 'on' 'an' 'm/' '`uname -r`' 'on' 'an' '`uname -m`/
	1646	fi
	1647	if [ "$disksize" -gt "2880" ] ; then
[925]	1648	if [ "`DidMondoCallMe`" ] ; then
	1649	if [ "$CDRECOVERY" != "yes" ] ; then
[940]	1650	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[925]	1651	echo -en "Press <enter> to continue.\n"
[940]	1652	elif [ ! "$MINDI_TMP" ] ; then
[925]	1653	echo -en "FYI, this is _not_ a Mondo Rescue CD.\n"
	1654	else
	1655	echo -en "$BOOT_MEDIA_MESSAGE"
	1656	fi
[747]	1657	fi
	1658	fi
	1659	fi
	1660	if [ "$CDRECOVERY" = "yes" ] ; then
	1661	echo -en "\
	1662	To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
	1663	CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n"
	1664	fi
	1665	echo -en "\n\n\n"
	1666	}
	1667
	1668
	1669	write_full_floppy_of_kernel() {
	1670	local mtpt image old_pwd res disksize
	1671
	1672	res=0
	1673	old_pwd=`pwd`
	1674	KERN_DISK_MADE=1
	1675	disksize=$3
	1676	rand1=$RANDOM
	1677	rand2=$RANDOM
[940]	1678	image=$MINDI_TMP/$rand1.$rand2.img
	1679	mtpt=$MINDI_TMP/$rand1.$rand2.mtpt
[963]	1680	dd if=/dev/zero of=$image bs=1k count=$disksize &> /dev/null
[964]	1681	mke2fs -N 26 -F $image &> /dev/null
[747]	1682	mkdir -p $mtpt
	1683	mount -o loop $image $mtpt
	1684	cd $mtpt
	1685	mkdir -p {dev,tmp,boot}
[963]	1686	cp -f $1 vmlinuz 2>> $LOGFILE
[747]	1687	if [ "$?" -ne "0" ] ; then
[963]	1688	LogIt "Failed to copy $1 to ramdisk"
[747]	1689	cd $old_pwd
	1690	umount $mtpt
	1691	rmdir $mtpt
	1692	rm $image
	1693	return 1
	1694	fi
	1695
	1696	rdev vmlinuz 2,0
	1697	rdev -R vmlinuz 0
	1698	rdev -r vmlinuz 49152
	1699
[963]	1700	tar -zxf $MINDI_LIB/dev.tgz \|\| LogIt "Cannot untar dev.tgz"
[747]	1701	losetup /dev/loop0 > /dev/null 2> /dev/null
[963]	1702	[ "$?" -eq "0" ] \|\| losetup /dev/loop0 -d \|\| Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
[747]	1703	CopyBootBFile $mtpt/boot.b
	1704
	1705	MakeLiloConfFile $disksize >> bdlilo.conf
	1706
	1707	chmod 644 bdlilo.conf
	1708	MakeMessageFile $disksize > message
	1709	lilo -v -C bdlilo.conf -r $mtpt
	1710	res=$?
	1711
	1712	cd $old_pwd
	1713	umount $mtpt
	1714	mv -f $image $2
	1715	rmdir $mtpt
	1716
	1717	return $res
	1718	}
	1719
	1720
	1721	MakeLiloConfFile() {
	1722	local disksize options i ooo
	1723	disksize=$1
	1724	options=""
[925]	1725
	1726	if [ "$ARCH" != "ia64" ] ; then
	1727	echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
	1728	fi
	1729	if [ "$disksize" -eq "2880" ] ; then
	1730	echo -en "bios=0x00\nsectors=36\nheads=2\ncylinders=80\n"
	1731	elif [ "$disksize" -eq "1722" ] ; then
	1732	echo -en "bios=0x00\nsectors=21\nheads=2\ncylinders=82\n"
	1733	elif [ "$disksize" -gt "2880" ] ; then
	1734	/bin/true
	1735	else
	1736	echo -en "bios=0x00\nsectors=18\nheads=2\ncylinders=80\n"
	1737	fi
	1738	if [ "$ARCH" != "ia64" ] ; then
	1739	echo -en "install=/boot.b\nmap=/boot.map\n"
	1740	fi
[747]	1741	if [ "$CDRECOVERY" = "yes" ] ; then
	1742	echo -en "default=RESTORE\n"
	1743	elif [ "$disksize" -gt "2880" ] && [ "`DidMondoCallMe`" ] ; then
[940]	1744	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1745	echo -en "default=iso\n"
	1746	else
	1747	echo -en "default=interactive\n"
	1748	fi
	1749	else
	1750	echo -en "default=expert\n"
	1751	fi
	1752
	1753	echo -en "prompt\n"
	1754	if [ "$ARCH" != "ia64" ] ; then
	1755	echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
	1756	fi
	1757	if [ "$CDRECOVERY" != "yes" ] ; then
[925]	1758	echo -en "timeout=300\n"
[747]	1759	fi
	1760	echo -en "\n"
	1761	if [ "$CDRECOVERY" = "yes" ] ; then
[925]	1762	options="RESTORE expert"
[747]	1763	elif [ "$disksize" -gt "2880" ] ; then
	1764	if [ "`DidMondoCallMe`" ] ; then
[940]	1765	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1766	options="iso"
	1767	else
	1768	options="interactive expert compare iso nuke isonuke"
	1769	# hda hdb hdc hdd"
	1770	fi
	1771	else
	1772	options="expert"
[925]	1773	fi
[747]	1774	else
	1775	options="expert"
	1776	fi
	1777	for i in $options ; do
[925]	1778	ooo=$i
	1779	[ "$ooo" = "RESTORE" ] && ooo="nuke"
	1780	if [ "$ARCH" = "ia64" ] ; then
	1781	rootpart="root=/dev/ram0\n\t"
	1782	else
	1783	rootpart=""
	1784	fi
	1785	outstr="image=vmlinuz\n\tlabel=$i\n\tinitrd=/mindi.rdz\n\t${rootpart}append=\" rw ramdisk=$ramdisksize ramdisk_size=$ramdisksize maxcpus=1 $ooo_mode $ADDITIONAL_BOOT_PARAMS"
[747]	1786
[925]	1787	outstr=$outstr" $ooo_mode"
	1788	outstr=$outstr"\"\n"
	1789	if [ "$disksize" = "1440" ] ; then
	1790	echo -en "$outstr" \| sed s/initrd=.*// \| grep -v root=
	1791	else
	1792	echo -en "$outstr"
	1793	fi
[747]	1794	done
	1795	}
	1796
	1797
	1798	PrepareBootDiskImage_LILO() {
	1799	local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
	1800	imagesdir=$1
	1801	disksize=$2
	1802	kernelpath=$3
	1803	ramdisksize=$4
	1804
	1805	retval=0
	1806	[ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
	1807	echo -en "Making "$disksize"KB boot disk..."
[940]	1808	TurnTgzIntoRdz $MINDI_LIB/rootfs $MINDI_TMP/mindi.rdz $ramdisksize $disksize `du -sk $kernelpath \| cut -f1` \|\| Die "Could not turn rootfs into mindi.rdz; are you SURE your kernel supports loopfs?"
[747]	1809	if [ "$ARCH" != "ia64" ] ; then
	1810	[ "$disksize" != "1722" ] && [ "$disksize" != "2880" ] && [ "$disksize" != "5760" ] && Die "PDBI - disksize is $disksize - bad size"
	1811	fi
	1812	echo -en "..."
	1813	imagefile=$imagesdir/mindi-bootroot.$disksize.img
[940]	1814	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	1815	mkdir -p $mountpoint
	1816	dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null \|\| Die "Cannot dd blank file"
	1817	if [ "$ARCH" = "ia64" ] ; then
[964]	1818	mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
	1819	t=vfat
[747]	1820	else
[964]	1821	mke2fs -N 26 -m 0 -F $imagefile >> $LOGFILE 2>> $LOGFILE
	1822	t=ext2
[747]	1823	fi
[963]	1824	mount -t $t -o loop $imagefile $mountpoint \|\| LogIt "Cannot mount (PBDI)"
[964]	1825	# copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
[747]	1826	mkdir -p $mountpoint/etc
	1827	if [ "$ARCH" != "ia64" ] ; then
	1828	liloconf=$mountpoint/etc/lilo.conf
	1829	else
[925]	1830	liloconf=$mountpoint/elilo.conf
[747]	1831	fi
	1832	old_pwd=`pwd`
	1833	cd $mountpoint
	1834	if [ "$ARCH" != "ia64" ] ; then
[963]	1835	tar -zxf $MINDI_LIB/dev.tgz \|\| LogIt "Cannot untar dev.tgz"
[747]	1836	fi
	1837	cd $old_pwd
	1838	losetup /dev/loop0 > /dev/null 2> /dev/null
[963]	1839	[ "$?" -eq "0" ] \|\| losetup /dev/loop0 -d \|\| Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
[747]	1840	CopyBootBFile $mountpoint/boot.b
	1841
	1842	MakeLiloConfFile $disksize > $liloconf
	1843
[940]	1844	echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
	1845	cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
[747]	1846	if [ "$?" -ne "0" ] ; then
[963]	1847	LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
[940]	1848	cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
[963]	1849	LogIt "Please unload some of your modules and try again."
[940]	1850	rm -f $MINDI_TMP/mtpt.$$
[963]	1851	LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
[747]	1852	retval=$(($retval+1))
	1853	fi
	1854	MakeMessageFile $disksize > $mountpoint/message
	1855
	1856	mkdir -p $mountpoint/tmp
[940]	1857	cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
[747]	1858	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	1859	echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
	1860	echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
	1861	# echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
	1862	fi
	1863
[925]	1864	# copy the kernel across
[747]	1865	rm -Rf $mountpoint/lost+found
	1866	dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
	1867	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	1868	cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
	1869	if [ "$?" -ne "0" ] \|\| [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
[925]	1870	echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
	1871	du -sk $mountpoint/* >> $LOGFILE
	1872	echo "--- end of list of files ---" >> $LOGFILE
	1873	echo -en "Kernel size = `du -sk $kernelpath \| cut -f1` K\nRamdisk free = $free_space K\n\
[747]	1874	Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
	1875	rm -f $mountpoint/vmlinuz
[925]	1876	cd $old_pwd
[747]	1877	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
[963]	1878	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[925]	1879	# losetup /dev/loop0 -d
	1880	res=0
[747]	1881	write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
[925]	1882	res=$(($res+$?))
[963]	1883	cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
[925]	1884	res=$(($res+$?))
	1885	rm -f $imagefile
	1886	if [ "$res" -ne "0" ]; then
[963]	1887	LogIt "WARNING - failed to create 1.44MB boot/root floppies"
[925]	1888	rm -f $imagesdir/mindi-*.1440.img
	1889	fi
	1890	return $res
[747]	1891	fi
	1892	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	1893	max_kernel_size=$(($free_space+`du -sk $kernelpath \| cut -f1`))
	1894	echo "Free space left on floppy = $free_space KB" >> $LOGFILE
	1895	echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
	1896	# make it bootable
	1897	rm -f $mountpoint/zero
[963]	1898	[ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
[747]	1899	if [ "$disksize" -gt "2880" ] && [ ! "$KERN_DISK_MADE" ] ; then
	1900	if [ "$ARCH" != "ia64" ] ; then
	1901	$LILO_EXE $LILO_OPTIONS -r $mountpoint >> $LOGFILE 2>> $LOGFILE
	1902	else
	1903	/bin/true
	1904	fi
	1905	elif [ ! "$KERN_DISK_MADE" ] ; then
	1906	# 12/28/2001 - if 1.72MB floppy then don't use LILO's optimizations at all
[925]	1907	$LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
[747]	1908	else
[925]	1909	echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
[747]	1910	fi
[925]	1911
	1912	# BERLIOS does not test necessarily what it expects
[747]	1913	if [ $? -ne "0" ] ; then
[925]	1914	if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
[963]	1915	LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
	1916	LogIt "Please reboot your PC as a workaround."
	1917	Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
[925]	1918	fi
	1919	echo "$LILO_EXE -r $mountpoint ...failed."
	1920	echo -en "Press ENTER to continue."; read line
[963]	1921	LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
[925]	1922	retval=$(($retval+1))
[747]	1923	fi
[963]	1924	cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
[747]	1925	if [ "$ARCH" = "ia64" ] ; then
[963]	1926	cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
[747]	1927	fi
	1928	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
	1929	echo -en "..."
[963]	1930	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	1931	if [ "$retval" -eq "0" ] ; then
	1932	echo -en "...$DONE\r"
	1933	if [ "$KERN_DISK_MADE" ] ; then
	1934	LogIt "... $disksize KB boot disks were created OK\r"
	1935	fi
	1936	else
	1937	echo -en "...failed\r"
	1938	LogIt $disksize"KB boot disk was NOT created\r"
	1939	rm -f $imagefile
	1940	fi
[963]	1941	[ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
[747]	1942	return $retval
	1943	}
	1944
	1945
	1946	PrepareBootDiskImage_SYSLINUX() {
	1947	local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
	1948	imagesdir=$1
	1949	disksize=$2
	1950	kernelpath=$3
	1951	ramdisksize=$4
	1952	do_boot_root_thingy=""
	1953	local retval old_pwd
	1954	retval=0
[925]	1955
[747]	1956	[ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
	1957	echo -en "Making "$disksize"KB boot disk..."
[940]	1958	TurnTgzIntoRdz $MINDI_LIB/rootfs $MINDI_TMP/mindi.rdz $ramdisksize $disksize `du -sk $kernelpath \| cut -f1` \|\| Die "Could not turn rootfs into mindi.rdz; are you SURE your kernel supports loopfs?"
[747]	1959	[ "$disksize" != "1722" ] && [ "$disksize" != "2880" ] && [ "$disksize" != "5760" ] && Die "PDBI - disksize is $disksize - bad size"
	1960	echo -en "..."
	1961	imagefile=$imagesdir/mindi-bootroot.$disksize.img
[940]	1962	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	1963	mkdir -p $mountpoint
	1964	# If I format a 1722KB data file & run syslinux on it, the resultant image
	1965	# won't boot. So, I have formatted a floppy, called syslinux on/to it, and
	1966	# used 'dd' to copy it to sys-disk.raw (zipped to sys-disk.raw.gz).
	1967	# If I extract it, mount it, copy my files to it, etc. then the resultant
	1968	# image _is_ bootable. I don't know why syslinux and/or mkfs.vfat won't
	1969	# play nicely and I don't care. :) I have worked around the problem. -Hugo, 06/27/2002
	1970	if [ "$disksize" = "1722" ] ; then
	1971	gzip -dc $MINDI_LIB/sys-disk.raw.gz > $imagefile \|\| Die "Cannot dd blank file"
	1972	else
	1973	dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null \|\| Die "Cannot dd blank file"
[964]	1974	mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
	1975	syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
[747]	1976	fi
[963]	1977	mount -t vfat -o loop $imagefile $mountpoint \|\| LogIt "Cannot mount (PBDI)"
[925]	1978
	1979	# copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
[747]	1980	old_pwd=`pwd`
	1981	MakeSyslinuxMessageFile $mountpoint/message.txt
	1982	cd $mountpoint
	1983	[ -e "$sys_cfg_file" ] \|\| Die "Obi Wan, word up?"
	1984	cat $sys_cfg_file \| HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg \|\| Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
[940]	1985	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	1986	mv syslinux.cfg syslinux.cfg.orig
	1987	sed s/interactive/iso/ syslinux.cfg.orig > syslinux.cfg
	1988	fi
	1989	cd $old_pwd
[940]	1990	echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
	1991	cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
[747]	1992	if [ "$?" -ne "0" ] ; then
[963]	1993	LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
[940]	1994	cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
[963]	1995	LogIt "Please unload some of your modules and try again."
[940]	1996	rm -f $MINDI_TMP/mtpt.$$
[963]	1997	LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
[747]	1998	retval=$(($retval+1))
	1999	fi
	2000
	2001	mkdir -p $mountpoint/tmp
[940]	2002	cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
[747]	2003
[925]	2004	# copy the kernel across
[747]	2005	rm -Rf $mountpoint/lost+found
	2006	dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
	2007	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	2008	cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
	2009	if [ "$?" -ne "0" ] \|\| [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
	2010	echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
	2011	du -sk $mountpoint/* >> $LOGFILE
	2012	echo "--- end of list of files ---" >> $LOGFILE
	2013	echo -en "Kernel size = `du -sk $kernelpath \| cut -f1` K\nRamdisk free = $free_space K\n\
	2014	Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
	2015	rm -f $mountpoint/vmlinuz
	2016	cd $old_pwd
	2017	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
[963]	2018	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	2019
	2020	res=0
	2021	write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
	2022	res=$(($res+$?))
[963]	2023	cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
[747]	2024	res=$(($res+$?))
	2025	rm -f $imagefile
	2026	if [ "$res" -ne "0" ]; then
[963]	2027	LogIt "WARNING - failed to create 1.44MB boot/root floppies"
[747]	2028	rm -f $imagesdir/mindi-*.1440.img
	2029	fi
	2030	return $res
	2031	fi
	2032	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	2033	max_kernel_size=$(($free_space+`du -sk $kernelpath \| cut -f1`))
	2034	echo "Free space left on floppy = $free_space KB" >> $LOGFILE
	2035	echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
[925]	2036
	2037	# make it bootable
[747]	2038	rm -f $mountpoint/zero
	2039	mkdir -p $mountpoint/etc
[963]	2040	[ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
[747]	2041	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
	2042	echo -en "..."
[963]	2043	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	2044
	2045	if [ "$retval" -eq "0" ] ; then
	2046	echo -en "...$DONE\r"
	2047	if [ "$KERN_DISK_MADE" ] ; then
	2048	rm -f $imagefile
	2049	LogIt "... $disksize KB boot disks were created OK\r"
	2050	fi
	2051	else
	2052	echo -en "...failed\r"
	2053	LogIt $disksize"KB boot disk was NOT created\r"
	2054	rm -f $imagefile
	2055	fi
[963]	2056	[ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
[747]	2057	return $retval
	2058	}
	2059
	2060
	2061	PrepareDataDiskImages() {
	2062	local needlist bigdir minidir_root tardir diskdir imagesdir res i j k old_pwd lines
	2063
	2064	imagesdir=$1
	2065	rm -f $imagesdir/mindi-.img $imagesdir/[0-9].tar.gz $imagesdir/mindi.iso
[940]	2066	needlist=$MINDI_TMP/what-we-need.txt
	2067	bigdir=$MINDI_TMP/bigdir
	2068	minidir_root=$MINDI_TMP/minidir
[747]	2069	mkdir -p $minidir_root
	2070	mkdir -p $bigdir/usr/bin
[940]	2071	tardir=$MINDI_TMP/tardir
[747]	2072
	2073	lines=`grep -vx " #." $MINDI_CONF/deplist.txt \| grep -vx "" \| wc -l`
	2074	cat $MINDI_CONF/deplist.txt \| GenerateGiantDependencyList $needlist $lines
	2075	res=$?
	2076	if [ "$YOUR_KERNEL_SUCKS" ]; then
[925]	2077	pwd=`pwd`
[940]	2078	cd $MINDI_TMP
[747]	2079	for i in `ListKernelModulePaths \| HackPathsToFailsafe` ; do
[963]	2080	cp --parents -pRdf ./$i $bigdir 2>> $LOGFILE \|\| Die "PDDI can't cp $i->$bigdir"
[925]	2081	if [ "`du -sk $i \| cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
[963]	2082	cp --parents -pRdf $i $bigdir 2>> $LOGFILE
[925]	2083	else
	2084	ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
	2085	BIGNO=$(($BIGNO+1))
	2086	fi
[747]	2087	done
[925]	2088	for i in $EXTRA_MODS ; do
	2089	j=`find lib/modules/$FAILSAFE_KVER -name $i.*o 2> /dev/null`
[963]	2090	[ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o" >> $LOGFILE
[925]	2091	for k in $j ; do
	2092	if [ "`du -sk $k \| cut -f1`" -lt "$CHOPSIZE" ] ; then
[963]	2093	cp --parents -pRdf $k $bigdir 2>> $LOGFILE
[925]	2094	else
	2095	ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
	2096	BIGNO=$(($BIGNO+1))
	2097	fi
	2098	echo "Added failsafe module $k to ramdisk" >> $LOGFILE
	2099	done
	2100	done
	2101	cd $pwd
[747]	2102	else
[925]	2103	ListKernelModulePaths >> $needlist
[747]	2104	fi
	2105	if [ "$res" -ne "0" ] ; then
	2106	Die "You have $res file`PluralOrNot $res` present in dependency list\nbut absent from filesystem."
	2107	fi
	2108	FindAndAddUserKeyboardMappingFile
	2109	mkdir -p $bigdir/tmp
	2110	if [ "`DidMondoCallMe`" ] ; then
[940]	2111	MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
	2112	cp -f $MINDI_TMP/mondo-restore.cfg $bigdir/tmp &> /dev/null
[747]	2113	fi
	2114	[ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
	2115	DropOptimizedLibraries $needlist $bigdir
	2116	echo -en "Assembling dependency files"
	2117	CopyDependenciesToDirectory < $needlist $bigdir
	2118
[925]	2119	# also copy io.sys and msdos.sys, if we can find them
[747]	2120	for i in `mount \| cut -d' ' -f3` ; do
[925]	2121	for j in io.sys msdos.sys ; do
[963]	2122	[ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
[925]	2123	done
[747]	2124	done
	2125
[925]	2126	# master boot record, too
[940]	2127	i=`cat $MINDI_TMP/BOOTLOADER.DEVICE 2> /dev/null`
[747]	2128	if [ "$i" ] ; then
[963]	2129	LogIt "Backing up $i's MBR"
[925]	2130	dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
	2131	sleep 1
	2132	sync
	2133	j=$i
	2134	[ -h "$j" ] && j=`readlink -f $j`
[963]	2135	LogIt "Creating /dev/boot_device ($j)"
[925]	2136	mkdir -p $bigdir/dev
[953]	2137	cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null \|\| Die "Unable to create /dev/boot_device on ramdisk"
[747]	2138	fi
	2139
	2140	old_pwd=`pwd`
	2141	cd $bigdir
	2142
	2143	[ -e "$MINDI_LIB/aux-tools" ] \|\| Die "aux-tools not found in Mindi's home dir. Do you have multiple copies of Mindi lying around? Please delete them. No, don't e-mail me and ask how. ;) Use 'rm'."
[963]	2144	cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE \|\| LogIt "WARNING - error occurred while unzipping aux-tools"
[747]	2145	if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
[963]	2146	tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE \|\| LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
[747]	2147	fi
	2148	if [ -e "$MONDO_SHARE/restore-scripts" ] ; then
	2149	cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
	2150	[ "$?" -ne "0" ] && [ "`DidMondoCallMe`" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
	2151	fi
[963]	2152	[ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
[747]	2153	cd $old_pwd
	2154	echo -e "$DONE"
	2155	TOTAL_BIGDIR_SIZE=`du -sk $bigdir \| cut -f1`
	2156	SplitDirectoryIntoMinidirs $bigdir $minidir_root
	2157	noof_disks=$?
	2158	[ "$noof_disks" -eq "0" ] && Die "Too much stuff!"
	2159	# if [ "$noof_disks" -ge "8" ] ; then
	2160	# LogIt "You are putting a ludicrously large amount of data on these disks."
	2161	# LogIt "I shall therefore double EXTRA_SPACE, just in case your ramdisk is too small."
	2162	# EXTRA_SPACE=$(($EXTRA_SPACE*2))
	2163	# fi
[940]	2164	MakeMountlist $MINDI_TMP/mountlist.txt
[747]	2165	mkdir -p $minidir_root/$noof_disks/tmp
[953]	2166	cp -f $MINDI_TMP/mountlist.txt $minidir_root/$noof_disks/tmp/mountlist.txt 2> /dev/null \|\| Die "Cannot copy mountlist.txt from $MINDI_TMP to data disk"
[963]	2167	[ "`DidMondoCallMe`" ] && cp -f $minidir_root/$noof_disks/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
[964]	2168	[ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $minidir_root/$noof_disks/tmp/i-want-my-lvm \|\| LVM="false"
[747]	2169	cat $minidir_root/$noof_disks/tmp/mountlist.txt >> $LOGFILE
	2170	ZipMinidirsIntoTarballs $minidir_root $tardir $noof_disks
	2171	CreateDataDiskImagesFromTarballs $tardir $imagesdir $noof_disks
	2172	FRIENDLY_OUTSTRING="Boot and data disk images were created."
[925]	2173	# One 1.72MB boot disk, one 2.88MB boot disk and $noof_disks data disk images
[747]	2174	rmdir $tardir $bigdir
	2175	rm -f $needlist
	2176	return $noof_disks
	2177	}
	2178
	2179
	2180	ProcessLDD() {
	2181	local main_fname incoming j i fname f newf
	2182	main_fname=$1
	2183	read incoming
	2184	while [ "$incoming" != "" ] ; do
[859]	2185	# We take the full path name of the dyn. lib. we want
	2186	incoming=`echo "$incoming" \| sed '/[[:blank:]].[[:blank:]]=>[[:blank:]](./d ; s/[[:blank:]].[[:blank:]]=>[[:blank:]]\(\/.\)/\1/ ; s/[[:blank:]]\(\/.\)[[:blank:]](./\1/'`
	2187	for f in `echo "$incoming"` ; do
[862]	2188	echo "$f `ReadAllLink $f`"
[747]	2189	done
	2190	read incoming
	2191	done
	2192	}
	2193
	2194
	2195	Prompt() {
	2196	echo -en "$1"
	2197	read line
	2198	}
	2199
	2200
	2201	ReadLine() {
	2202	local i incoming
	2203	read incoming
	2204	i=0
	2205	while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
[925]	2206	i=$(($i+1))
	2207	read incoming
[747]	2208	done
	2209	echo "$incoming"
	2210	}
	2211
	2212
	2213	RejigHyperlinks() {
	2214	local minidir_root noof_disks fname path diskno old_pwd awk_loc gawk_loc dir i
	2215	minidir_root=$1
	2216	noof_disks=$2
	2217
	2218	old_pwd=`pwd`
	2219	diskno=1
	2220	while [ "$diskno" -le "$noof_disks" ] ; do
[859]	2221	mkdir -p $minidir_root/$diskno
[747]	2222	cd $minidir_root/$diskno
	2223	for fname in `find -type d -o -print` ; do
	2224	[ -h "$minidir_root/$diskno/$fname" ] && MoveHyperlinkSensibly $fname $minidir_root $diskno $noof_disks
	2225	done
[925]	2226	diskno=$(($diskno+1))
[747]	2227	done
	2228
	2229	cd $old_pwd
	2230	return
	2231	}
	2232
	2233
	2234	ReplaceIndividualLine() {
	2235	local orig_file new_file lino newstring lines_total lines_remaining
[925]	2236
[747]	2237	orig_file=$1.orig
	2238	mv -f $1 $orig_file \|\| Die "Cannot move $1 to $orig_file"
	2239	new_file=$1
	2240	lino=$2
	2241	newstring="$3"
	2242	if [ "$lino" = "" ] \|\| [ "$lino" -lt "1" ] ; then
[925]	2243	echo "Can't find string" >> $LOGFILE
	2244	return 1
[747]	2245	fi
[963]	2246	lines_total=`wc -l $orig_file \| $AWK '{print $1;}'`
[747]	2247	lines_remaining=$(($lines_total-$lino))
	2248	head -n$(($lino-1)) $orig_file > $new_file
	2249	echo "$newstring" >> $new_file
	2250	echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
	2251	tail -n$lines_remaining $orig_file >> $new_file
	2252	echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
	2253	[ -x "$orig_file" ] && chmod +x $new_file
	2254	rm -f $orig_file
	2255	return 0
	2256	}
	2257
	2258
	2259	ScanCDandTape() {
	2260	local i
	2261
	2262	for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
	2263	dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
	2264	done
	2265	}
	2266
	2267
	2268	SizeOfPartition() {
	2269	local devpath drive res stub
	2270	device=$1
	2271	if [ "`echo "$device" \| grep -F "/dev/md"`" != "" ] ; then
[925]	2272	res=`SizeOfRaidPartition $device`
	2273	[ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
	2274	echo "$res"
	2275	return 0
[747]	2276	fi
[925]	2277	# patch from Bill <bill@iwizard.biz> - 2003/08/25
[960]	2278	res=`$FDISK -s $device 2>> $LOGFILE`
[925]	2279	# end patch
[747]	2280	[ "$res" = "" ] && res=`df -k -P -x supermount \| tr -s '\t' ' ' \| grep -F "$device " \| cut -d' ' -f2`
	2281	[ "$res" = "" ] && res="-1"
	2282	echo $res
	2283	return 0
	2284	}
	2285
	2286
	2287	SizeOfRaidPartition() {
	2288	local real_dev smallest_size silly tmp
	2289
	2290	silly=999999999
	2291	smallest_size=$silly
	2292
	2293	for real_dev in `GetRaidDevMembers $1` ; do
[925]	2294	tmp=`SizeOfPartition $real_dev`
	2295	[ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
[747]	2296	done
	2297
	2298	if [ "$smallest_size" = "$silly" ] ; then
[925]	2299	echo "-1"
	2300	return 1
[747]	2301	else
[925]	2302	echo "$smallest_size"
	2303	return 0
[747]	2304	fi
	2305	}
	2306
	2307
	2308	StripComments()
	2309	{
	2310	local tempfile
[925]	2311
[940]	2312	tempfile=$MINDI_TMP/$$.strip.txt
[963]	2313	cp -f $1 $tempfile 2>> $LOGFILE
[747]	2314	$AWK '{if (substr($0,0,1)!="#" \|\| substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
	2315	rm -f $tempfile
	2316	echo "Stripped comments from $2" >> $LOGFILE
	2317	}
	2318
	2319
	2320	SplitDirectoryIntoMinidirs() {
	2321	local bigdir minidir_root i noof_disks old_pwd res
[925]	2322
[747]	2323	bigdir=$1
	2324	minidir_root=$2
	2325	rm -Rf $minidir_root/*
	2326
	2327	TryToFitDataIntoSeveralDirs $bigdir $minidir_root
	2328	noof_disks=$?
	2329	if [ "$noof_disks" -eq "0" ] ; then
[925]	2330	echo "Failed to fit data into several dirs."
[747]	2331	return 0
	2332	fi
	2333	RejigHyperlinks $minidir_root $noof_disks
	2334	rm -Rf $bigdir/*
[925]	2335	return $noof_disks
[747]	2336	}
	2337
	2338
	2339	StripExecutable()
	2340	{
	2341	local tmpfile
[925]	2342
[940]	2343	tmpfile=$MINDI_TMP/stripped.$$.dat
[747]	2344	[ -d "$1" ] \|\| [ -h "$1" ] && return
[963]	2345	cp -f $1 $tmpfile 2>> $LOGFILE
[747]	2346	strip $tmpfile 2> /dev/null
	2347	if [ "$?" -eq "0" ] ; then
[963]	2348	cp -f $tmpfile $1 2>> $LOGFILE
[925]	2349	echo "Stripped binary $2" >> $LOGFILE
[747]	2350	fi
	2351	rm -f $tmpfile
	2352	}
	2353
	2354
	2355	TemporarilyCompressAllFiles() {
	2356	local i orig_fname out_fname out_list
	2357
	2358	i=0
	2359	out_list=$2/compressed/compressed.txt
	2360	mkdir -p $2/compressed
	2361	> $out_list
	2362	for orig_fname in $1 ; do
	2363	out_fname=$2/compressed/$orig_fname.gz
	2364	mkdir -p $out_fname 2> /dev/null
	2365	rmdir $out_fname 2> /dev/null
	2366	gzip -c6 $orig_fname > $out_fname 2> /dev/null
	2367	i=$(((($i+1))%15))
	2368	[ "$i" -eq "0" ] && echo -en "."
	2369	du -sk $out_fname >> $out_list
	2370	done
	2371	}
	2372
	2373
	2374	TryToFindKernelPath() {
	2375	local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
[925]	2376
[747]	2377	we_want_version=`uname -r`
	2378	possible_kernels=""
	2379	duff_kernels=""
	2380
	2381	if [ "$ARCH" = "ia64" ] ; then
	2382	root="/boot/efi/efi"
	2383	else
	2384	root="/"
	2385	fi
	2386	for fname in `find $root -maxdepth 2 -type f \| grep -F lin \| grep -Ev '^/proc/\|^/net/'` ; do
[925]	2387	[ ! -e "$fname" ] && continue
[747]	2388	[ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
[925]	2389	file $fname \| grep -q gzip
	2390	if [ "$?" -eq "0" ] ; then
	2391	# Used by ia64
[747]	2392	fkern_ver=`gzip -cd $fname \| strings 2> /dev/null \| grep "[2-9]+[.][0-9]+[.][0-9]+[^\@]@"`
[925]	2393	else
[747]	2394	fkern_ver=`strings $fname 2> /dev/null \| grep "[2-9]+[.][0-9]+[.][0-9]+[^\@]@"`
[925]	2395	fi
[747]	2396	[ "$fkern_ver" = "" ] && continue
	2397	[ "`echo "$fkern_ver" \|grep -F "$we_want_version "`" = "" ] && continue
[925]	2398	[ -f "$fname" ] \|\| continue
	2399	[ -h "$fname" ] && continue
	2400	kdate=`uname -v \| $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' \| $AWK '{print $NF;}'`
	2401	file $fname \| grep -q gzip
	2402	if [ "$?" -eq "0" ] ; then
	2403	# Used by ia64
	2404	if [ "`gzip -cd $fname \| strings 2> /dev/null \| grep -F "$kdate"`" = "" ] ; then
[963]	2405	LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
[925]	2406	duff_kernels="$fname $duff_kernels"
	2407	else
[747]	2408	[ "`echo "$fname" \| grep -F "vmlinux"`" ] && continue
	2409	possible_kernels="$fname $possible_kernels"
[925]	2410	fi
[747]	2411	else
[925]	2412	if [ "`strings $fname 2> /dev/null \| grep -F "$kdate"`" = "" ] ; then
[963]	2413	LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
[925]	2414	duff_kernels="$fname $duff_kernels"
	2415	else
[747]	2416	[ "`echo "$fname" \| grep -F "vmlinux"`" ] && continue
	2417	possible_kernels="$fname $possible_kernels"
[925]	2418	fi
[747]	2419	fi
	2420	done
	2421	if [ ! "$possible_kernels" ] && uname -a \| grep Knoppix > /dev/null ; then
[925]	2422	possible_kernels=`find /boot/vmlinuz-2.* \| tail -n1`
[747]	2423	fi
	2424	if [ ! "$possible_kernels" ] ; then
[963]	2425	LogIt "No kernel matches exactly. Are there any duff kernels?"
[747]	2426	possible_kernels="$duff_kernels"
	2427	if [ ! "$possible_kernels" ] ; then
[963]	2428	LogIt "Sorry, no duff kernels either"
[747]	2429	else
[963]	2430	LogIt "I bet you're running Debian or Gentoo, aren't you?"
	2431	LogIt "Your kernel doesn't have a sane builddate. Oh well..."
[747]	2432	fi
	2433	fi
	2434	possible_kernels=`echo "$possible_kernels" \| tr -s ' ' '\n' \| sort -u \| tr '\n' ' '`
	2435	noof_kernels=`CountItemsIn "$possible_kernels"`
	2436	if [ "$noof_kernels" -eq "0" ] ; then
[963]	2437	LogIt "Could not find your kernel."
[925]	2438	if [ -e "/boot/vmlinuz" ] ; then
[963]	2439	LogIt "Using /boot/vmlinuz as a last resort."
[925]	2440	output=/boot/vmlinuz
[747]	2441	else
[925]	2442	output=""
	2443	fi
[747]	2444	elif [ "$noof_kernels" -eq "1" ] ; then
	2445	kernelpath=`echo "$possible_kernels" \| sed s/' '//`
	2446	echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
	2447	output="$kernelpath"
	2448	else
	2449	for i in $possible_kernels ; do
	2450	if echo $i \| grep "`uname -r`" ; then
[925]	2451	LogIt "OK, I used my initiative and found that "
[963]	2452	LogIt "$i is probably your kernel. "
[925]	2453	output="$i"
	2454	return
	2455	fi
[747]	2456	done
[925]	2457	if echo " $possible_kernels " \| grep -F "/boot/vmlinuz " &> /dev/null ; then
	2458	output=/boot/vmlinuz
	2459	echo "Schlomo, this one's for you." >> $LOGFILE
	2460	else
[963]	2461	LogIt "Two or more possible kernels found. You may specify any one of them and the "
	2462	LogIt "boot disks will still work, probably. If one does not work, try another."
	2463	LogIt "$possible_kernels"
[747]	2464	echo ""
[925]	2465	fi
[747]	2466	fi
	2467	echo "$output" \| tr -s ' ' '\n' \| sort -u \| tr '\n' ' '
	2468	}
	2469
	2470
	2471	TryToFitDataIntoSeveralDirs() {
	2472	local bigdir minidir_root noof_disks diskno list_of_files filename old_pwd progress
	2473	local i retval noof_disks total_files list_of_devs
[925]	2474
[747]	2475	bigdir=$1
	2476	minidir_root=$2
	2477	BIG_CLUNKY_SIZE_COUNTER=0
	2478	retval=0
	2479	noof_disks=1
	2480
	2481	echo -en "\r \rDividing data into several groups..."
	2482	old_pwd=`pwd`
	2483	cd $bigdir
	2484	list_of_files=`GetFileSizeList . \| sort -nr \| cut -f2 \| grep -Fv "/dev/"`
	2485	progress=0
	2486	total_files=`CountItemsIn "$list_of_files"`
	2487	if [ "`echo "$filename" \| grep -x "/dev/.*"`" ] ; then
	2488	filesize=1
	2489	fi
	2490	mkdir -p $minidir_root/$noof_disks
	2491	if [ -e "dev" ] ; then
	2492	echo "Copying dev/* to $minidir_root/$noof_disks" >> $LOGFILE
[963]	2493	cp --parents -pRdf dev $minidir_root/$noof_disks 2>> $LOGFILE
[747]	2494	fi
	2495	TemporarilyCompressAllFiles "$list_of_files" $minidir_root
	2496	for filename in $list_of_files ; do
	2497	AddFileToDir $filename $minidir_root $noof_disks
[925]	2498	i=$?
	2499	if [ "$i" -gt "$noof_disks" ] ; then
	2500	noof_disks=$i
	2501	echo -en "\r\t\t\t\t\t\t($noof_disks disks)"
	2502	fi
	2503	if [ "$i" -eq "0" ] ; then
[963]	2504	LogIt "Cannot add file $filename to minidir $minidir_root"
[925]	2505	retval=$(($retval+1))
	2506	fi
[747]	2507	progress=$(($progress+1))
[925]	2508	echo -en "\r\t\t\t\t\t\t\t\t$(($progress*100/$total_files))% complete\r"
[747]	2509	done
	2510	cd $old_pwd
	2511	echo -en "\rThe files have been subdivided into $noof_disks directories. \r"
	2512	rm -Rf $minidir_root/compressed
	2513	if [ "$retval" -gt "0" ] ; then
[925]	2514	return 0
[747]	2515	else
[925]	2516	return $noof_disks
[747]	2517	fi
	2518	}
	2519
	2520
	2521	TurnTgzIntoRdz() {
	2522	local tgz_dir_fname rdz_fname ramdisksize tempfile mountpoint old_pwd nodes disksize kernelsize maxsize res currsize not_copied j k floppy_modules s w
[925]	2523
[747]	2524	tgz_dir_fname=$1
	2525	rdz_fname=$2
	2526	ramdisksize=$3
	2527	disksize=$4
	2528	kernelsize=$5
	2529	maxsize=$(($disksize-$kernelsize))
	2530	maxsize=$(($maxsize*2)); # to allow for compression of 50%
[940]	2531	tempfile=$MINDI_TMP/temp.rd
	2532	mountpoint=$MINDI_TMP/mnt1
[747]	2533	res=0
	2534	echo -en "..."
	2535	dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null \|\| Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
	2536	echo -en "..."
	2537	mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE
	2538	echo -en "..."
	2539	mkdir -p $mountpoint
	2540	mount -t ext2 -o loop $tempfile $mountpoint \|\| Die "Cannot loopmount $tempfile to $mountpoint! The reason may be missing support for loopfs or ext2 (or both) in the running kernel."
	2541	echo -en "..."
	2542	old_pwd=`pwd`
	2543	cd $mountpoint
[959]	2544	cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
[747]	2545	tar -zxf symlinks.tgz \|\| Die "Cannot untar symlinks.tgz"
	2546	cd dev \|\| Die "Can't cd to dev"
	2547	tar -zxf dev-entries.tgz \|\| Die "Cannot untar dev-entries.tgz"
	2548	rm -f dev-entries.tgz
	2549	cd ..
	2550
	2551	for w in insmod.static insmod.static.old ; do
[925]	2552	s=`which $w 2> /dev/null`
	2553	if [ -e "$s" ] ; then
[963]	2554	cp --parents -af $s . 2>> $LOGFILE
[925]	2555	fi
[747]	2556	done
	2557
	2558	mkdir -p tmp
	2559	[ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
	2560	for w in cdrom floppy groovy-stuff ; do
	2561	mkdir -p mnt/$w
	2562	done
[925]	2563	#if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
	2564	#ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init \| cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
	2565	#fi
[747]	2566	if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
[925]	2567	ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init \| cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
[747]	2568	fi
	2569
	2570	lsmod > tmp/original-lsmod.txt
	2571
	2572	cp --parents -Rdf /dev/fd0[1,2][4,7,8] . 2> /dev/null
	2573	cd $old_pwd
	2574	echo -en "..."
	2575	MakeModuleLoadingScript $TMPMODPROBE_FLAG $mountpoint/sbin/insert-all-my-modules
	2576	echo -en "..."
	2577	old_pwd=`pwd`
	2578	if [ "$YOUR_KERNEL_SUCKS" ] ; then
[940]	2579	cd $MINDI_TMP
[747]	2580	floppy_modules_path=lib/modules/$FAILSAFE_KVER
	2581	else
	2582	cd /
	2583	###
	2584	### Sq-Modification... Use kernel name in module path if specified.
	2585	###
	2586	#floppy_modules_path=lib/modules/`uname -r`
	2587	if [ "${kernelname}" != "" ]
	2588	then
	2589	floppy_modules_path=lib/modules/${kernelname}
	2590	else
	2591	floppy_modules_path=lib/modules/`uname -r`
	2592	fi
	2593	###
	2594	### Sq-Modification end
	2595	###
	2596	fi
	2597	floppy_modules=""
	2598	if [ "$disksize" -lt "2880" ] ; then
	2599	list_of_groovy_mods="$FLOPPY_MODS $IDE_MODS ide-scsi sr_mod cdrom isocd isofs `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
	2600	else
	2601	list_of_groovy_mods="$CDROM_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
	2602	fi
[940]	2603	if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
[747]	2604	# For PXE boot
	2605	list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
	2606	fi
[963]	2607	[ -e "$floppy_modules_path" ] \|\| LogIt "path $floppy_modules_path does not exist.\n If you're not using a modular kernel then you're NUTS."
[747]	2608	for i in $list_of_groovy_mods ; do
	2609	floppy_modules="$floppy_modules `FindSpecificModuleInPath $floppy_modules_path $i`"
	2610	done
	2611	for i in $floppy_modules ; do
	2612	[ -e "$i" ] && s=`du -sk $i \| cut -f1` \|\| s=""
[940]	2613	[ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
[747]	2614	echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
[963]	2615	cp -df $i $mountpoint/ 2>/dev/null \|\| LogIt "Unable to copy $i to $mountpoint"
[747]	2616	[ "`echo "$i" \| grep -F ".gz"`" ] && gunzip -f $mountpoint/`basename $i`
	2617	done
	2618	if [ ! -e "/sbin/devfsd" ] \|\| [ "$disksize" -lt "2880" ] \|\| [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
	2619	echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
	2620	[ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
	2621	[ "$disksize" -lt "2880" ] && echo "...because disksize = $disksize" >> $LOGFILE
	2622	[ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
	2623	rm -f $mountpoint/sbin/devfsd
	2624	fi
	2625	cd $old_pwd
	2626	[ "$TAPEDEV" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
	2627	dd if=/dev/zero of=$mountpoint/zero &> /dev/null
	2628	rm -f $mountpoint/zero
	2629	if [ "`DidMondoCallMe`" ] ; then
	2630	MakeMondoConfigFile $mountpoint/tmp/mondo-restore.cfg
[940]	2631	cp -f $mountpoint/tmp/mondo-restore.cfg $MINDI_TMP &> /dev/null
[953]	2632	cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null \|\| Die "Cannot copy mountlist to ramdisk"
[747]	2633	echo -en "$FILES_IN_FILELIST" > $mountpoint/tmp/FILES-IN-FILELIST
	2634	echo -en "$LAST_FILELIST_NUMBER" > $mountpoint/tmp/LAST-FILELIST-NUMBER
	2635	[ "$USE_LZO" = "yes" ] && echo -en "Pras 4 Pres 2004" >> $mountpoint/tmp/USING-LZO
[998]	2636	[ "$USE_GZIP" = "yes" ] && echo -en "YES" >> $mountpoint/tmp/USING-GZIP
[747]	2637	[ "$USE_COMP" = "yes" ] && echo -en "Compression, yep" >> $mountpoint/tmp/USING-COMP
	2638	[ "$USE_STAR" = "yes" ] && echo -en "Using star. Hooray." >> $mountpoint/tmp/USING-STAR
	2639	fi
	2640	mkdir -p $mountpoint/tmp
	2641	mkdir -p $mountpoint/proc
	2642	echo "$disksize" > $mountpoint/tmp/$disksize.siz
	2643	find $mountpoint -name CVS -exec rm -rf '{}' \;
	2644	umount $mountpoint \|\| Die "Cannot unmount $tempfile"
	2645	dd if=$tempfile bs=1k 2> /dev/null \| gzip -v9 > $rdz_fname 2> /dev/null
	2646	# gzip -9 $tempfile
	2647	# mv $tempfile.gz $rdz_fname
	2648	if [ "$res" -eq "0" ] ; then
	2649	echo -en "..."
	2650	else
	2651	echo -en "\rMade an rdz WITH ERRORS. \n"
	2652	fi
	2653	return 0
	2654	}
	2655
	2656
	2657	WhichOfTheseModulesAreLoaded() {
	2658	local modname loaded_modules
	2659	loaded_modules=" `lsmod \| tr -s ' ' '\t' \| cut -f1 \| grep -Fvx "Modules" \| tr '\n' ' '` "
	2660	for modname in $1 ; do
[925]	2661	[ "`echo "$loaded_modules" \| grep -F " $modname "`" ] && echo "$modname"
[747]	2662	done
	2663	}
	2664
	2665
	2666	ZipMinidirsIntoTarballs() {
	2667	local minidir_root tardir noof_disks diskno old_pwd i
	2668	minidir_root=$1
	2669	tardir=$2
	2670	noof_disks=$3
	2671
	2672	echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
	2673	mkdir -p $tardir
	2674	mkdir -p $minidir_root/all
	2675	old_pwd=`pwd`
	2676	diskno=1
	2677	while [ "$diskno" -le "$noof_disks" ] ; do
[963]	2678	cd $minidir_root/$diskno \|\| LogIt "WARNING - cannot cd to $minidir_root/$diskno"
[747]	2679	tar -cf - . 2>> $LOGFILE \| gzip -9 > $tardir/$diskno.tar.gz \|\| Die "Can't tar/gzip disk#$diskno; please tell Dev Team -exactly- what the errors where."
	2680	diskno=$(($diskno+1))
	2681	echo -n "..."
[963]	2682	cp -pRdf * $minidir_root/all 2>> $LOGFILE
[747]	2683	done
	2684	mkdir -p $minidir_root/all/tmp
	2685	cd $minidir_root/all
	2686	size_of_all_tools=`du -sk . \| cut -f1`
	2687	if [ "`DidMondoCallMe`" ] ; then
	2688	for q in filelist.full.gz biggielist.txt ; do
[940]	2689	[ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
[963]	2690	cp -pRdf $MINDI_TMP/$q tmp/ 2>> $LOGFILE
[747]	2691	done
	2692	mkdir -p $minidir_root/all/tmp
	2693	echo -en "$FILES_IN_FILELIST" > $minidir_root/all/tmp/FILES-IN-FILELIST 2> /dev/null
	2694	echo -en "$LAST_FILELIST_NUMBER" > $minidir_root/all/tmp/LAST-FILELIST-NUMBER 2> /dev/null
	2695	fi
	2696	tar -b 4096 -cf - * 2> /dev/null \| gzip -9 > $tardir/all.tar.gz
	2697	dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
	2698	[ "`du -sm $imagesdir/all.tar.gz \| cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
	2699	cd $old_pwd
	2700	rm -Rf $minidir_root
	2701	echo -e "$DONE"
	2702	}
	2703
	2704
	2705	##############################################################################
	2706	#----------------------------------- main -----------------------------------#
	2707	##############################################################################
	2708
	2709
	2710	> $LOGFILE
	2711	echo "mindi v$MINDI_VERSION" >> $LOGFILE
	2712	echo "$ARCH architecture detected" >> $LOGFILE
	2713	echo "mindi called with the following arguments:" >> $LOGFILE
	2714	echo "$@" >> $LOGFILE
[800]	2715	echo "Start date : `date`" >> $LOGFILE
[747]	2716
	2717	if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
[963]	2718	LogIt "WARNING - Ancient distro detected." 1
[747]	2719	ln -sf /etc/conf.modules /etc/modules.conf
	2720	fi
	2721	[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
	2722
	2723	FindHomeOfMindiAndMondo
	2724	trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
	2725	AbortIfYourDistroIsAPieceOfStercus
	2726	[ "`uname -r \| grep "2.4.[0-6]" \| grep -v "2.4.[0-9][0-9]"`" != "" ] && echo "WARNING! Your kernel may have buggy loopfs code. Consider upgrading to 2.4.7"
	2727	# If we have a 2.6 kernel, the system uses module-init-tools which means that we
	2728	# may have the modprobe configuration spread out across multiple files in
	2729	# directory /etc/modprobe.d. If this is the case we concatenate these files into
	2730	# a temporary file for further processing. Otherwise we continue in the standard
	2731	# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
	2732	# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
	2733	# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
	2734	if [ -d "/etc/modprobe.d" ] && [ `uname -r \| cut -c1-3` == "2.6" ] ; then
[925]	2735	TMPMODPROBE_FLAG="Y"
[747]	2736	else
[925]	2737	TMPMODPROBE_FLAG="N"
	2738	[ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
	2739	[ ! -e "/etc/modules.conf" ] && Die "/etc/modules.conf not found; you may have to create a softlink from /etc/conf.modules to /etc/modules.conf; of course, all good distros use modules.conf anyway..."
[747]	2740	fi
	2741	FixPathIfBroken
	2742	[ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null \| grep -E "2\.[46]" \| cut -d' ' -f1`
	2743	AbortIfMkfsVfatMissing
[925]	2744	### BERLIOS
[747]	2745	### Fix as it's not mandatory on ia64
	2746	if [ "$ARCH" = "ia64" ] ; then
	2747	FindELiloBinary
	2748	else
	2749	FindIsolinuxBinary
	2750	FindLiloBinary
	2751	fi
[925]	2752	# BERLIOS: Remove as too dangerous and now useless
[940]	2753	#grep -F " $MINDI_TMP " /proc/mounts \| grep -F tmpfs > /dev/null 2> /dev/null && MINDI_TMP=/home/tmpmondo && mkdir -p $MINDI_TMP && LogIt "Changing MINDI_TMP to $MINDI_TMP because you're using tmpfs for /tmp\n" ; # tmpfs doesn't like Mindi and /tmp, for some reason
[747]	2754	trap "Aborted" SIGTERM
	2755	DONE="\r\t\t\t\t\t\t\t\tDone. "
	2756	CHOPSIZE=240
	2757	BIGNO=0
	2758	MAX_COMPRESSED_SIZE=1300
	2759	kernelpath=""
[925]	2760	MONDO_ROOT=$TMPMONDO/mondo-root
[747]	2761	mkdir -p $MONDO_ROOT
	2762
	2763	if [ -d "/proc/lvm" ]; then
	2764	# LVM v1
	2765	LVMCMD=""
	2766	LVM="v1"
	2767	elif [ -d "/dev/mapper" ]; then
	2768	# LVM v2
	2769	LVMCMD="lvm"
	2770	LVM="v2"
	2771	else
	2772	LVM="false"
	2773	fi
	2774
	2775	if [ "$#" -ge "2" ] ; then
	2776	if [ "$1" = "--max-compressed-size" ] ; then
	2777	MAX_COMPRESSED_SIZE=$2
	2778	shift; shift
	2779	fi
	2780	fi
	2781
	2782	FLOPPY_WAS_MOUNTED=""
	2783	for mtpt in /media/floppy /mnt/floppy /floppy ; do
	2784	if mount \| grep -w $mtpt &> /dev/null ; then
	2785	FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
	2786	umount $mtpt
	2787	fi
	2788	done
	2789
	2790	if [ "$#" -ne "0" ] ; then
	2791	if [ "$1" = "--findkernel" ] ; then
	2792	res=`TryToFindKernelPath`
	2793	if [ "$res" = "" ] ; then
[925]	2794	MindiExit -1
[747]	2795	else
	2796	echo "$res"
[925]	2797	MindiExit 0
[747]	2798	fi
	2799	elif [ "$1" = "--makemountlist" ] ; then
	2800	[ ! "$2" ] && Die "Please specify the output file"
	2801	MakeMountlist $2
[925]	2802	MindiExit $?
	2803	elif [ "$1" = "-V" ] \|\| [ "$1" = "-v" ] \|\| [ "$1" = "--version" ] \|\| [ "$1" = "-version" ] ; then
	2804	echo "Mindi v$MINDI_VERSION"
	2805	MindiExit 0
[747]	2806	elif [ "$#" -ge "9" ] && [ "$1" = "--custom" ] ; then
[940]	2807	MONDO_TMP=$2
	2808	# Change MINDI_TMP for the one provided by mondo
	2809	# So that it can get back the built files
	2810	rm -rf $MINDI_TMP
	2811	MINDI_TMP=$MONDO_TMP
[953]	2812	mkdir -p $MINDI_TMP
[938]	2813	CACHE_LOC=$3
	2814	if [ _"$CACHE_LOC" != _"" ]; then
	2815	mkdir -p $CACHE_LOC
	2816	fi
[925]	2817	kernelpath=$4; [ "$kernelpath" = "(null)" ] && kernelpath=""
[747]	2818	###
	2819	### Sq-Modification...
	2820	### Attempt to locate kernel specific module path
	2821	### if module path is found then use it other wise use uname -r to set it...
	2822	###
	2823	kernelname=`echo $kernelpath \| cut -d'-' -f2-`
[963]	2824	LogIt "kernelname = $kernelname"
	2825	LogIt "kernelpath = $kernelpath"
[747]	2826	if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
	2827	then
[963]	2828	LogIt "Module path for ${kernelpath} not found..."
	2829	LogIt "using running kernel\'s modules."
[747]	2830	kernelname=`uname -r`
	2831	else
[963]	2832	LogIt "Using modules for kernel: ${kernelname}"
[747]	2833	fi
	2834	###
	2835	### end of Sq-Modification
	2836	###
[925]	2837	TAPEDEV=$5
	2838	TAPESIZE=$6
	2839	FILES_IN_FILELIST=$7
	2840	USE_LZO=$8
	2841	CDRECOVERY=$9
[747]	2842	if [ "${10}" = "(null)" ] \|\| [ "${10}" = "" ] ; then
	2843	IMAGE_DEVS=""
	2844	else
	2845	IMAGE_DEVS="`echo "${10}" \| tr '\|' ' '`"
	2846	fi
[925]	2847	if [ "${11}" ] ; then
	2848	LILO_OPTIONS=""
	2849	# LogIt "LILO will use conservative settings, to be compatible with older BIOSes."
	2850	fi
	2851	LAST_FILELIST_NUMBER=${12}
[747]	2852	ESTIMATED_TOTAL_NOOF_SLICES=${13}
	2853	EXCLUDE_DEVS="${14}"
	2854	USE_COMP="${15}"
	2855	USE_LILO="${16}"
[925]	2856	USE_STAR="${17}"
	2857	INTERNAL_TAPE_BLOCK_SIZE="${18}"
[747]	2858	DIFFERENTIAL="${19}"
[998]	2859	USE_GZIP="${20}"
	2860	NOT_BOOT="${21}"
[747]	2861	[ "$USE_COMP" = "" ] && USE_COMP=yes
[998]	2862	[ "$USE_GZIP" = "" ] && USE_GZIP=no
[747]	2863	[ "$NOT_BOOT" = "" ] && NOT_BOOT=no
[963]	2864	[ "$TAPEDEV" ] && LogIt "This is a tape-based backup. Fine."
[925]	2865	[ "$kernelpath" = "" ] && kernelpath=`TryToFindKernelPath`
[747]	2866	kernelname=`echo $kernelpath \| cut -d'-' -f2-`
	2867	if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
	2868	then
[963]	2869	LogIt "Module path for ${kernelpath} not found..."
	2870	LogIt "using running kernel\'s modules."
[747]	2871	kernelname=`uname -r`
	2872	else
[963]	2873	LogIt "Using modules for kernel: ${kernelname}"
[747]	2874	fi
[925]	2875	[ "$CDRECOVERY" = "yes" ] && [ "$TAPEDEV" != "" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
	2876	MONDO_ROOT=`echo $CACHE_LOC \| sed 's/\(.\)\/./\1/'`
[938]	2877	if [ _"$MONDO_ROOT" != _"" ]; then
	2878	mkdir -p $MONDO_ROOT
	2879	else
	2880	Die "MONDO_ROOT is undefined"
	2881	fi
[747]	2882	else
[925]	2883	echo "Syntax: mindi (--custom ....)" >> /dev/stderr
	2884	MindiExit -1
[747]	2885	fi
	2886	fi
	2887	#ScanCDandTape
	2888	[ "$CDRECOVERY" = "yes" ] \|\| CDRECOVERY=no
	2889	if [ "$CDRECOVERY" = "yes" ] ; then
	2890	iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
	2891	sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
	2892	else
	2893	iso_cfg_file=$MINDI_LIB/isolinux.cfg
	2894	sys_cfg_file=$MINDI_LIB/syslinux.cfg
	2895	fi
	2896
	2897	[ -e "$iso_cfg_file" ] \|\| Die "Cannot find $iso_cfg_file"
	2898	if [ ! "`DidMondoCallMe`" ] ; then
[963]	2899	LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
	2900	LogIt "Latest Mindi is available from http://www.mondorescue.org"
	2901	LogIt "BusyBox sources are available from http://www.busybox.net"
[747]	2902	LogIt "------------------------------------------------------------------------------"
	2903	else
	2904	echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> /var/log/mondo-archive.log
	2905	fi
	2906
	2907	# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
	2908	insmod /lib/modules/`uname -r`///misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
	2909	for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
	2910	insmod $i >> $LOGFILE 2>> $LOGFILE
	2911	done
	2912
	2913	KERN_DISK_MADE=""
	2914
	2915	echo "DIFFERENTIAL = $DIFFERENTIAL" >> $LOGFILE
	2916	echo "INTERNAL TAPE BLOCK SIZE = $INTERNAL_TAPE_BLOCK_SIZE" >> $LOGFILE
	2917	echo "NOT_BOOT = '$NOT_BOOT'" >> $LOGFILE
	2918	if [ "$NOT_BOOT" != "" ] && [ "$NOT_BOOT" != "0" ] && [ "$NOT_BOOT" != "no" ] ; then
[963]	2919	LogIt "Just creating mondo-restore.cfg and a small all.tar.gz for Mondo. Nothing else."
[940]	2920	MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
	2921	MakeMountlist $MINDI_TMP/mountlist.txt
	2922	mkdir -p $MINDI_TMP/small-all/tmp
	2923	cd $MINDI_TMP/small-all
[953]	2924	cp -f $MINDI_TMP/{mountlist.txt,mondo-restore.cfg,filelist.full.gz,biggielist.txt} tmp 2>/dev/null \|\| Die "Cannot copy small all.tar.gz"
[940]	2925	tar -cv tmp \| gzip -9 > $MINDI_TMP/all.tar.gz \|\| Die "Cannot make small all.tar.gz"
[747]	2926	sleep 2
[963]	2927	LogIt "Done. Exiting."
[925]	2928	MindiExit 0
[747]	2929	fi
	2930
	2931	if [ "$kernelpath" = "" ] ; then
	2932	[ "`DidMondoCallMe`" ] && Die "Please use -k <path> to specify kernel."
[966]	2933	echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
	2934	read ch
	2935	if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
	2936	USE_OWN_KERNEL="yes"
[747]	2937	fi
	2938	if [ "$USE_OWN_KERNEL" = "yes" ]; then
[925]	2939	YOUR_KERNEL_SUCKS=""
	2940	kernelpath=`TryToFindKernelPath`
	2941	if [ "$kernelpath" = "" ] ; then
	2942	echo -n "Please enter kernel path : "
	2943	read kernelpath
	2944	fi
[747]	2945	else
[925]	2946	YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
[747]	2947	fi
	2948	fi
	2949	if [ ! "`DidMondoCallMe`" ] ; then
[966]	2950	echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/[n]) ?"
[747]	2951	read ch
[966]	2952	if [ "$ch" != "y" ] && [ "$ch" != "Y" ] ; then
	2953	USE_LILO=no
	2954	else
[747]	2955	USE_LILO=yes
	2956	fi
	2957	fi
	2958	if [ "$YOUR_KERNEL_SUCKS" != "" ] \|\| [ "$kernelpath" = "" ] \|\| [ "$kernelpath" = "SUCKS" ] \|\| [ "$kernelpath" = "FAILSAFE" ] ; then
	2959	kernelpath=$MINDI_LIB/vmlinuz
[963]	2960	LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
	2961	LogIt "However, you are still running your kernel. If Mindi fails to create your"
	2962	LogIt "disks then it may still be a result of a problem with your kernel."
[747]	2963	pwd=`pwd`
[940]	2964	cd $MINDI_TMP
[747]	2965	bzip2 -dc $MINDI_LIB/lib.tar.bz2 \| tar -x \|\| Die "Cannot unzip lib.tar.bz2"
	2966	cd $pwd
	2967	YOUR_KERNEL_SUCKS="Your kernel sucks"
	2968	fi
[940]	2969	echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$CACHE_LOC" >> $LOGFILE
[963]	2970	[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
[747]	2971
[965]	2972	[ "$YOUR_KERNEL_SUCKS" ] && [ ! "$FAILSAFE_KVER" ] && Die "Please install mindi-kernel package. You need it.\nGo to http://www.mondorescue.org and download it, then install it."
[747]	2973
	2974	rm -f /root/images/mindi/{img,gz,*iso}
	2975
[925]	2976	PrepareDataDiskImages $CACHE_LOC
[747]	2977	noof_disks=$?
	2978	ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
	2979	rds=$(($ramdisk_size-$((ramdisk_size%4096))))
	2980	ramdisk_size=$rds
	2981
	2982	echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
	2983	if [ "$USE_LILO" = "yes" ] ; then
	2984	if [ "$ARCH" = "ia64" ] ; then
[925]	2985	PrepareBootDiskImage_LILO $CACHE_LOC $IA64_BOOT_SIZE $kernelpath $ramdisk_size \|\| Die "Failed to create ia64 floppy disk image."
[747]	2986	else
[925]	2987	if ! PrepareBootDiskImage_LILO $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
[964]	2988	LogIt "WARNING - failed to create 1.72MB boot image."
	2989	LogIt "Please reduce your kernel's size if you want to make a 1.72MB floppy disk."
[747]	2990	fi
[925]	2991	if ! PrepareBootDiskImage_LILO $CACHE_LOC 2880 $kernelpath $ramdisk_size ; then
[963]	2992	LogIt "WARNING - failed to create 2.88MB floppy disk image."
[964]	2993	LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
[925]	2994	PrepareBootDiskImage_LILO $CACHE_LOC 5760 $kernelpath $ramdisk_size \|\| Die "Failed to create 2.88MB floppy disk image."
[747]	2995	fi
	2996	fi
	2997	else
[925]	2998	if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
[964]	2999	LogIt "WARNING - failed to create 1.72MB boot image."
	3000	LogIt "Please reduce your kernel's size if you want to make a 1.72MB floppy disk."
[925]	3001	if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 2880 $kernelpath $ramdisk_size ; then
[963]	3002	LogIt "WARNING - failed to create 2.88MB floppy disk image."
[964]	3003	LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
[925]	3004	PrepareBootDiskImage_SYSLINUX $CACHE_LOC 5760 $kernelpath $ramdisk_size \|\| Die "Failed to create 5.76MB floppy disk image."
[747]	3005	fi
	3006	fi
	3007	fi
	3008
	3009	[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
	3010	...Or type 'memtest' to test your PC's RAM thoroughly.\n"
	3011
	3012	if [ ! "`DidMondoCallMe`" ] ; then
[925]	3013	ListImagesForUser $CACHE_LOC
[747]	3014	boot_dev=/dev/fd0u1722
	3015	[ ! -e "$boot_dev" ] && mknod $boot_dev b 2 60
	3016	[ ! -e "$boot_dev" ] && boot_dev=/dev/fd0H1722
	3017	[ ! -e "$boot_dev" ] && Die "Oh Lord, will you PLEASE tell the vendor to create the 1.72MB devices in /dev?"
	3018	if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
[925]	3019	OfferToCopyImagesToDisks $CACHE_LOC $boot_dev $FDDEVICE
[747]	3020	fi
[925]	3021	OfferToMakeBootableISO $CACHE_LOC
[963]	3022	LogIt "Finished."
[747]	3023	elif [ "$TAPEDEV" ] ; then
	3024	mkdir -p /root/images/mindi
	3025	rm -f /root/images/mindi/{img,gz,*iso}
[925]	3026	OfferToMakeBootableISO $CACHE_LOC
	3027	if [ -e "$CACHE_LOC/all.tar.gz" ] ; then
[963]	3028	cp -f $CACHE_LOC/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
[747]	3029	else
[925]	3030	Die "Cannot find all.tar.gz, to be written to tape"
[747]	3031	fi
	3032	else
[925]	3033	OfferToMakeBootableISO $CACHE_LOC
[747]	3034	fi
	3035	# cleanup
[963]	3036	LogIt "$FRIENDLY_OUTSTRING"
[747]	3037	for mtpt in $FLOPPY_WAS_MOUNTED ; do
	3038	mount $mtpt
	3039	done
[925]	3040	MindiExit 0

Note: See TracBrowser for help on using the repository browser.

Download in other formats: