Context Navigation

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

Visit:

Last change on this file since 703 was 703, checked in by bcornec, 18 years ago
Some tabs for mindi
Property svn:keywords set to `Rev Id`
File size: 110.0 KB

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

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

Download in other formats: