Context Navigation

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

Visit:

Last change on this file since 1050 was 1050, checked in by Bruno Cornec, 17 years ago
Quality tool improvement mindi had a dual NET_MODS line
Property svn:keywords set to `Rev Id`
File size: 107.2 KB

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

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

Download in other formats: