Context Navigation

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

Visit:

Last change on this file since 1350 was 1350, checked in by Bruno Cornec, 17 years ago
Better log file content in mondoarchive.log from the copy of the mindi log
Property svn:keywords set to `Rev Id`
File size: 113.9 KB

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

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

Download in other formats: