Context Navigation

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

Visit:

Last change on this file since 1193 was 1193, checked in by Bruno Cornec, 17 years ago
Remove some useless \r in code Remove center_string usage as it's now broiken for dynamically created strings
Property svn:keywords set to `Rev Id`
File size: 112.9 KB

Rev	Line
[747]	1	#!/bin/bash
	2
	3	# $Id: mindi 1193 2007-02-20 11:24:22Z 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
	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
	85	IA64_BOOT_SIZE=$mindi_ia64_boot_size
	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"
[925]	112
[1047]	113	BOOT_MEDIA_MESSAGE="$mindi_boot_msg"
[925]	114	FDISK=$MINDI_SBIN/parted2fdisk
[940]	115	MINDI_TMP=`mktemp -d $TMPDIR/mindi.XXXXXXXXXX`
	116
[747]	117	# ----------------------------------------------------------------------------
	118
	119
	120	AbortHere() {
	121	[ "$mountpoint" ] && umount $mountpoint 2>> $LOGFILE
	122	Die "Program is terminating in response to signal received from OS/user"
	123	}
	124
	125
	126	HackSyslinuxFile() {
	127	local incoming
	128	incoming=`ReadLine`
	129	while [ "$incoming" ] ; do
	130	echo -en "$incoming" \| sed s/24000/$1/
	131	if [ "`echo "$incoming" \| grep append`" ] ; then
	132	echo -en " $ADDITIONAL_BOOT_PARAMS"
	133	fi
	134	echo -en "\n"
	135	incoming=`ReadLine`
	136	done
	137	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	138	echo -en "label memtest\n kernel memdisk\n append initrd=memtest.img\n\n"
	139	fi
	140	}
	141
	142
	143	Aborted() {
	144	trap SIGHUP SIGTERM SIGTRAP SIGINT
[1087]	145	[ "$MINDI_CACHE" != "" ] && rm -f $MINDI_CACHE/mindiimg $MINDI_CACHE/gz $MINDI_CACHE/mindi.iso
[747]	146	[ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
	147	Die "User abort."
	148	}
	149
	150
	151	AddFileToDir() {
	152	local filename minidir_root noof_disks diskno res filesize disksize would_occupy zipsize complevel cutoff compressed_fname siz
	153	filename=$1
	154	minidir_root=$2
	155	noof_disks=$3
	156
	157	diskno=$noof_disks
	158	mkdir -p $minidir_root/$diskno
	159	[ "$LAST_COMPRESSED_SIZE" = "" ] && LAST_COMPRESSED_SIZE=0
	160	if [ ! -e "$filename" ] ; then
[925]	161	if [ -h "$filename" ] ; then
[963]	162	cp --parents -pRdf $filename $minidir_root/$diskno 2>> $LOGFILE
[925]	163	return $noof_disks
	164	else
	165	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?"
	166	fi
[747]	167	fi
[925]	168
	169	# move to the disk that has room on it (or end up using the last, if all full)
[747]	170	while [ "$diskno" -lt "40" ] ; do
[925]	171	mkdir -p $minidir_root/$diskno
[747]	172	filesize=`du -sk $filename \| cut -f1`
[963]	173	cp --parents -Rdf $filename $minidir_root/$diskno 2>> $LOGFILE
[747]	174	if [ "$filesize" -le "4" ] ; then
	175	siz=$filesize
	176	elif [ ! -f "$filename" ] ; then
	177	siz=0
	178	else
	179	siz=`grep -m 1 "$filename.gz$" $minidir_root/compressed/compressed.txt \| cut -f1`
	180	[ "$siz" = "" ] && Die "FIXME - can't find $filename's size."
	181	siz=$(($siz-2));# to allow for sectors & the fact that they round up
	182	fi
[925]	183	[ ! "$siz" ] && siz=4
	184	[ "$siz" -lt "0" ] && siz=0
[747]	185	LAST_COMPRESSED_SIZE=$(($LAST_COMPRESSED_SIZE+$siz))
[925]	186	[ "$LAST_COMPRESSED_SIZE" -le "$MAX_COMPRESSED_SIZE" ] &&return $diskno
	187	echo "disk=$diskno siz=$LAST_COMPRESSED_SIZE" >> $LOGFILE
	188	LAST_COMPRESSED_SIZE=0
	189	rm -f $minidir_root/$diskno/$filename
[747]	190	diskno=$(($diskno+1))
	191	done
	192	return 0 ; # failed
	193	}
	194
	195
	196	AddKeyboardMappingFile() {
	197	local mappath r included_list included_item i res ii sss
	198	mappath=$1
	199	KBDEPTH=$(($KBDEPTH+1))
	200	[ "$KBDEPTH" -gt "128" ] && Die "Edit $MINDI_SBIN/mindi and disable FindAndAddUserKeyboardMappingFile (line 2160, approx.)"
	201	if [ -e "$bigdir/$mappath" ] ; then
	202	echo "$mappath already added" >> $LOGFILE
	203	return
	204	elif [ -d "$bigdir/$mappath" ] ; then
	205	echo "Cannot add $mappath: it's a directory. Sorry."
	206	return
	207	fi
	208	echo "Added kbd map $mappath" >> $LOGFILE
	209	if [ ! -e "$mappath" ] ; then
[1075]	210	mappath=`grep "i[3-8]86" $MINDI_TMP/keymaps.find \| grep "$locale[^r][^/]" \| grep -vx " #."`
[747]	211	if [ ! -e "$mappath" ] ; then
[963]	212	LogIt "Cannot add $mappath: kbd map file not found"
[747]	213	return
	214	fi
	215	else
	216	echo -en "`basename $mappath \| tr '.' '#' \| sed s/#kmap#gz// \| sed s/#inc#gz//` " \| tr '#' '.'
	217	fi
	218
	219	mkdir -p $bigdir/etc
[963]	220	cp --parents -pRdf $mappath $bigdir 2>> $LOGFILE \|\| LogIt "AKMF -- Could not copy $mappath to $bigdir"
[747]	221	if [ "`echo $mappath \| grep -F ".gz"`" ] ; then
	222	included_list=`gzip -dc $mappath \| grep -Fi include \| sed s/'"'// \| sed s/'"'// \| cut -d' ' -f2`
	223	else
	224	included_list=`grep -Fi include $mappath \| sed s/'"'// \| sed s/'"'// \| cut -d' ' -f2`
	225	fi
	226	for included_item in $included_list ; do
[925]	227	if [ ! -e "$included_item" ] ; then
[1075]	228	sss=`grep -F "${included_item}.inc" $MINDI_TMP/keymaps.find`
	229	[ "$sss" = "" ] && sss=`grep -F "$included_item" $MINDI_TMP/keymaps.find`
[925]	230	for ii in $sss ; do
[747]	231	[ -e "$ii" ] && AddKeyboardMappingFile $ii
[925]	232	done
	233	else
	234	AddKeyboardMappingFile $included_item
	235	fi
[747]	236	done
	237	}
	238
	239
	240	ChopUpAndCopyFile() {
	241	local filename slicesize outdir res biggienumber filesize sliceno noof_slices testfile scratchfile
	242	filename=$1
	243	outdir=$2
	244	slicesize=$3
	245	biggienumber=$4
	246
[1060]	247	[ -d "$filename" ] && Die "Cannot chop up $filename: it's a directory. Please amend $DEPLIST_FILE accordingly."
[747]	248	mkdir -p $outdir
	249
	250	sliceno=0
[940]	251	scratchfile=$MINDI_TMP/blah.$$.dat
[963]	252	cp -f $filename $scratchfile 2>> $LOGFILE \|\| Die "CUACF -- cannot copy $filename to $scratchfile - did you run out of disk space?"
[747]	253	[ "`head $scratchfile -n1 \| grep -F "bin/sh"`" != "" ] && StripComments $scratchfile "-$filename-"
	254	[ "`echo "$filename" \| grep -F "etc/termcap"`" != "" ] && StripComments $scratchfile "-$filename-"
	255	if [ "`echo "$filename" \| grep -F "lib/modules/" \| grep "\.*o\.gz"`" != "" ] ; then
[925]	256	mv $scratchfile $scratchfile.gz
[963]	257	gunzip -f $scratchfile \|\| LogIt "Cannot gunzip $scratchfile.gz"
[925]	258	filename=`echo "$filename" \| tr '.' '#' \| sed s/#o#gz/#o/ \| sed s/#ko#gz/#ko/ \| tr '#' '.'`
[747]	259	fi
	260	filesize=`du -sk $scratchfile \| cut -f1`
	261	noof_slices=$(($filesize/$slicesize))
	262	echo "$filename" > $outdir/slice-$biggienumber.name
	263	echo "$filesize" > $outdir/slice-$biggienumber.size
	264	[ -x "$scratchfile" ] && StripExecutable $scratchfile "-$filename-"
	265	while [ "$sliceno" -le "$noof_slices" ] ; do
[963]	266	dd if=$scratchfile skip=$(($sliceno*$slicesize)) of=$outdir/slice-$biggienumber.`printf "%03d" $sliceno` bs=1k count=$slicesize &> /dev/null
[747]	267	sliceno=$(($sliceno+1))
	268	done
	269	rm -f $scratchfile
	270	}
	271
	272
	273	CopyBootBFile() {
	274	local copy_to copy_from possible_locations liloc
	275	copy_to=$1
	276	copy_from=/boot/boot.b
	277	liloc=`which lilo.real 2>/dev/null`
	278	[ $liloc ] \|\| liloc=`which lilo 2>/dev/null`
	279	if [ $liloc ]; then
	280	if ! [ `strings $liloc \| grep "boot\.b"` ]; then
[963]	281	LogIt "boot.b files built into lilo; I'll create a dummy."
[747]	282	> $copy_to
	283	return 0
	284	fi
	285	fi
	286	if [ ! -f "$copy_from" ] ; then
	287	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"
	288	copy_from=`grep install= /etc/lilo.conf \| grep "\.b" \| cut -d'=' -f2`
	289	if [ ! -f "$copy_from" ] ; then
[963]	290	LogIt "Nor can I find it from your /etc/lilo.conf file. This is very odd."
[747]	291	copy_from=`FindSensibleBootBFile`
[963]	292	LogIt "I'm going to use '$copy_from'"
[747]	293	fi
	294	fi
[963]	295	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]	296	}
	297
	298
	299	CopyDependenciesToDirectory() {
	300	local outdir incoming fname filesize counter
	301	outdir=$1
	302	mkdir -p $outdir
	303	incoming=`ReadLine`
	304	counter=0
	305	while [ "$incoming" != "" ] ; do
[925]	306	if [ -d "$incoming" ] ; then
[747]	307	find $incoming/* -maxdepth 0 2> /dev/null \| CopyDependenciesToDirectory $outdir
	308	elif [ -e "$incoming" ] ; then
	309	filesize=`du -sk $incoming \| cut -f1`
	310	if [ "$filesize" -gt "$(($CHOPSIZE*2))" ] && [ ! -h "$incoming" ] ; then
	311	ChopUpAndCopyFile $incoming $outdir $CHOPSIZE $BIGNO
	312	BIGNO=$(($BIGNO+1))
	313	else
[953]	314	cp --parents -Rdf $incoming $outdir 2> /dev/null \|\| Die "Cannot copy $incoming to $outdir - did you run out of disk space?"
[925]	315	if [ "`echo "$incoming" \| grep "lib/modules/.\..o\.gz"`" != "" ] ; then
[963]	316	gunzip -f $outdir/$incoming \|\| LogIt "Cannot gunzip $outdir/$incoming"
[925]	317	fi
	318	[ -x "$outdir" ] && StripExecutable $outdir "-$filename-"
	319	fi
	320	counter=$(($counter+1))
	321	if [ "$counter" -ge "5" ] ; then
	322	counter=0
	323	echo -en "."
	324	fi
[747]	325	fi
	326	incoming=`ReadLine`
	327	done
	328	}
	329
	330
	331	CopyImageToDisk() {
	332	local image dev procno res comment
	333	image=$1
	334	dev=$2
	335	comment=$3
	336	[ ! -f "$image" ] && [ ! -b "$image" ] && Die "Image $image does not exist. Did you run out of disk space?"
	337	Prompt "About to write $comment. Please press ENTER."
	338	echo -en "Formatting disk..."
	339	if which fdformat > /dev/null ; then
[925]	340	fdformat -n $dev > /dev/null 2> /dev/null \|\| Die "Cannot format $dev - is your Linux distro broken?"
[747]	341	elif which superformat > /dev/null ; then
[925]	342	superformat $dev > /dev/null 2> /dev/null \|\| Die "Cannot format $dev - is your Linux distro broken?"
[747]	343	else
[925]	344	Die "Please install either fdformat or superformat."
[747]	345	fi
[1193]	346	echo -en "\nWriting $comment"
[747]	347	if echo $image \| grep "mindi-[r\|b]oot\.1440" &> /dev/null ; then
[925]	348	cat $image > $dev &
[747]	349	else
[925]	350	dd if=$image of=$dev &> /dev/null &
[747]	351	fi
	352	procno=$!
	353	ps $procno > /dev/null 2> /dev/null
	354	while [ "$?" -eq "0" ] ; do
	355	sleep 3
	356	echo -en "."
	357	ps $procno > /dev/null 2> /dev/null
	358	done
	359	echo -e "$DONE"
[963]	360	LogIt "$comment has been written."
[747]	361	}
	362
	363
	364	CountItemsIn() {
	365	local r
	366	r=0
	367	for q in $1 ; do
	368	r=$(($r+1))
	369	done
	370	echo $r
	371	}
	372
	373
	374	CreateDataDiskImagesFromTarballs() {
	375	local tardir outdir diskno noof_disks kp
	376	tardir=$1
	377	outdir=$2
	378	noof_disks=$3
	379
	380	mkdir -p $outdir
	381	diskno=1
	382	echo -en "Creating data disk "
	383	while [ "$diskno" -le "$noof_disks" ] ; do
[925]	384	echo -en "#$diskno..."
[963]	385	cp -f $tardir/$diskno.tar.gz $outdir 2>> $LOGFILE \|\| LogIt "[line 424] Cannot copy $tardir/$diskno.tar.gz to $outdir"
[747]	386	CreateOneDataDiskImage $tardir/$diskno.tar.gz $outdir/mindi-data-$diskno.img $diskno $noof_disks
	387	diskno=$(($diskno+1))
	388	done
	389	mv -f $tardir/all.tar.gz $outdir
	390	du -sk $outdir/*gz >> $LOGFILE
	391	echo -e "$DONE"
	392	}
	393
	394
	395
	396	CreateOneDataDiskImage() {
	397	local tarball imagefile dev diskno noof_disks mountpoint
	398	tarball=$1
	399	imagefile=$2
	400	diskno=$3
	401	noof_disks=$4
	402
[940]	403	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	404	mkdir -p $mountpoint
[963]	405	dd if=/dev/zero of=$imagefile bs=1k count=1440 &> /dev/null \|\| LogIt "Cannot dd (CODI)"
[1075]	406	echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
[964]	407	mke2fs -N 12 -F $imagefile >> $LOGFILE 2>> $LOGFILE
[747]	408	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."
	409	mv $tarball $mountpoint/
	410	if [ "$?" -ne "0" ] ; then
[925]	411	umount $mountpoint
[1087]	412	rmdir $mountpoint
[1060]	413	Die "Tarball $tarball is too big for disk! (CODI)\nAdjust mindi_max_compressed_size in your $MINDI_CONFIG"
[747]	414	fi
	415	[ "$diskno" -eq "$noof_disks" ] && echo "This is the last disk ($diskno=$noof_disks)" >> $mountpoint/LAST-DISK
[963]	416	umount $mountpoint \|\| LogIt "Cannot umount (CODI)"
	417	rmdir $mountpoint \|\| LogIt "Cannot rmdir (CODI)"
[747]	418	}
	419
[925]	420	# Last function called before exiting
	421	# Parameter is exit code value
[931]	422	MindiExit() {
[925]	423	local my_partitions
[747]	424
[925]	425	echo "Mindi $MINDI_VERSION is exiting" >> $LOGFILE
	426	echo "End date : `date`" >> $LOGFILE
[747]	427
[925]	428	sync
	429	cd /
[747]	430
[925]	431	# Unmount whtat could remain mounted
	432	my_partitions=`mount \| grep -F $$ \| cut -f1 -d' '`
	433	[ "$my_partitions" != "" ] && umount $my_partitions
[940]	434	# Clean temporary files only when standalone mindi
[948]	435	if [ _"$MINDI_TMP" != _"$MONDO_TMP" ]; then
[940]	436	rm -Rf $MINDI_TMP
	437	fi
[925]	438	exit $1
	439	}
	440
[747]	441	Die() {
[925]	442	local i
[747]	443	if [ "$1" = "" ] ; then
[963]	444	LogIt "FATAL ERROR"
[747]	445	else
[963]	446	LogIt "FATAL ERROR. $1"
[747]	447	fi
	448
[925]	449	# Creates a tar file containing all required files
[1060]	450	for i in $MY_FSTAB /etc/lilo.conf /etc/raidtab $LOGFILE /var/log/mondo-archive.log ; do
[963]	451	[ -e "$i" ] && cp -f $i $MINDI_TMP 2>> $LOGFILE
[747]	452	done
[925]	453	rm -f $TMPDIR/mindi.err.*.tgz
[940]	454	tar -cf - $MINDI_TMP \| gzip -9 > $TMPDIR/mindi.err.$$.tgz
[963]	455	LogIt "Please e-mail a copy of $TMPDIR/mindi.err.$$.tgz to the mailing list."
	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`
	694	if [ "$tool" == "$lvmresolved" ]; then
	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;}'`
	702	if [ "$lvmversion" == "200" ]; then
	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
	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
	1118	if [ $tmpmodprobe_flag == "Y" ] ; then
	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`
	1517	j=`grep -F "/mindi-boot" $MINDI_TMP/imagesdir.files \| grep -Ev '2880\|5760'`
[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
[1087]	1587	mkisofs -J -r -o $MINDI_CACHE/mindi.iso -b images/mindi-bootroot.$IA64_BOOT_SIZE.img -c isolinux/boot.cat -no-emul-boot . > /dev/null 2> $MINDI_TMP/mkisofs.log
[747]	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
[964]	1794	mke2fs -N 26 -F $image &> /dev/null
[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"
[747]	1814	losetup /dev/loop0 > /dev/null 2> /dev/null
[963]	1815	[ "$?" -eq "0" ] \|\| losetup /dev/loop0 -d \|\| Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
[747]	1816	CopyBootBFile $mtpt/boot.b
	1817
	1818	MakeLiloConfFile $disksize >> bdlilo.conf
	1819
	1820	chmod 644 bdlilo.conf
	1821	MakeMessageFile $disksize > message
	1822	lilo -v -C bdlilo.conf -r $mtpt
	1823	res=$?
	1824
	1825	cd $old_pwd
	1826	umount $mtpt
	1827	mv -f $image $2
	1828	rmdir $mtpt
	1829
	1830	return $res
	1831	}
	1832
	1833
	1834	MakeLiloConfFile() {
	1835	local disksize options i ooo
	1836	disksize=$1
	1837	options=""
[925]	1838
	1839	if [ "$ARCH" != "ia64" ] ; then
	1840	echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
	1841	fi
	1842	if [ "$disksize" -eq "2880" ] ; then
	1843	echo -en "bios=0x00\nsectors=36\nheads=2\ncylinders=80\n"
	1844	elif [ "$disksize" -gt "2880" ] ; then
	1845	/bin/true
	1846	else
	1847	echo -en "bios=0x00\nsectors=18\nheads=2\ncylinders=80\n"
	1848	fi
	1849	if [ "$ARCH" != "ia64" ] ; then
	1850	echo -en "install=/boot.b\nmap=/boot.map\n"
	1851	fi
[747]	1852	if [ "$CDRECOVERY" = "yes" ] ; then
	1853	echo -en "default=RESTORE\n"
[1063]	1854	elif [ "$disksize" -gt "2880" ] && [ _"$MONDO_SHARE" != _"" ]; then
[1087]	1855	if [ "$NFS_DEV" != "" ] ; then
[747]	1856	echo -en "default=iso\n"
	1857	else
	1858	echo -en "default=interactive\n"
	1859	fi
	1860	else
	1861	echo -en "default=expert\n"
	1862	fi
	1863
	1864	echo -en "prompt\n"
	1865	if [ "$ARCH" != "ia64" ] ; then
	1866	echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
	1867	fi
	1868	if [ "$CDRECOVERY" != "yes" ] ; then
[925]	1869	echo -en "timeout=300\n"
[747]	1870	fi
	1871	echo -en "\n"
	1872	if [ "$CDRECOVERY" = "yes" ] ; then
[925]	1873	options="RESTORE expert"
[747]	1874	elif [ "$disksize" -gt "2880" ] ; then
[1063]	1875	if [ _"$MONDO_SHARE" != _"" ]; then
[1087]	1876	if [ "$NFS_DEV" != "" ] ; then
[747]	1877	options="iso"
	1878	else
	1879	options="interactive expert compare iso nuke isonuke"
	1880	# hda hdb hdc hdd"
	1881	fi
	1882	else
	1883	options="expert"
[925]	1884	fi
[747]	1885	else
	1886	options="expert"
	1887	fi
	1888	for i in $options ; do
[925]	1889	ooo=$i
	1890	[ "$ooo" = "RESTORE" ] && ooo="nuke"
	1891	if [ "$ARCH" = "ia64" ] ; then
	1892	rootpart="root=/dev/ram0\n\t"
	1893	else
	1894	rootpart=""
	1895	fi
[1072]	1896	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]	1897
[925]	1898	outstr=$outstr" $ooo_mode"
	1899	outstr=$outstr"\"\n"
	1900	if [ "$disksize" = "1440" ] ; then
	1901	echo -en "$outstr" \| sed s/initrd=.*// \| grep -v root=
	1902	else
	1903	echo -en "$outstr"
	1904	fi
[747]	1905	done
	1906	}
	1907
	1908
	1909	PrepareBootDiskImage_LILO() {
	1910	local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
	1911	imagesdir=$1
	1912	disksize=$2
	1913	kernelpath=$3
	1914	ramdisksize=$4
	1915
	1916	retval=0
	1917	[ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
	1918	echo -en "Making "$disksize"KB boot disk..."
[940]	1919	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]	1920	if [ "$ARCH" != "ia64" ] ; then
[1121]	1921	[ "$disksize" != "2880" ] && [ "$disksize" != "5760" ] && Die "PDBI - disksize is $disksize - bad size"
[747]	1922	fi
	1923	echo -en "..."
	1924	imagefile=$imagesdir/mindi-bootroot.$disksize.img
[940]	1925	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	1926	mkdir -p $mountpoint
	1927	dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null \|\| Die "Cannot dd blank file"
	1928	if [ "$ARCH" = "ia64" ] ; then
[964]	1929	mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
	1930	t=vfat
[747]	1931	else
[1075]	1932	echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
[964]	1933	mke2fs -N 26 -m 0 -F $imagefile >> $LOGFILE 2>> $LOGFILE
	1934	t=ext2
[747]	1935	fi
[963]	1936	mount -t $t -o loop $imagefile $mountpoint \|\| LogIt "Cannot mount (PBDI)"
[964]	1937	# copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
[747]	1938	mkdir -p $mountpoint/etc
	1939	if [ "$ARCH" != "ia64" ] ; then
	1940	liloconf=$mountpoint/etc/lilo.conf
	1941	else
[925]	1942	liloconf=$mountpoint/elilo.conf
[747]	1943	fi
	1944	old_pwd=`pwd`
	1945	cd $mountpoint
	1946	if [ "$ARCH" != "ia64" ] ; then
[963]	1947	tar -zxf $MINDI_LIB/dev.tgz \|\| LogIt "Cannot untar dev.tgz"
[747]	1948	fi
	1949	cd $old_pwd
	1950	losetup /dev/loop0 > /dev/null 2> /dev/null
[963]	1951	[ "$?" -eq "0" ] \|\| losetup /dev/loop0 -d \|\| Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
[747]	1952	CopyBootBFile $mountpoint/boot.b
	1953
	1954	MakeLiloConfFile $disksize > $liloconf
	1955
[1072]	1956	# Copy it so that CD-ROM menu entry is satisfied
	1957	if [ "$ARCH" = "ia64" ] ; then
	1958	mountefi=0
	1959	df -T \| grep /boot/efi \| grep -q vfat
	1960	if [ $? -ne 0 ]; then
	1961	mount /boot/efi
	1962	if [ $? -ne 0 ]; then
	1963	echo "You have to mount your EFI partition when using mindi"
	1964	MindiExit -1
	1965	fi
	1966	mountefi=1
	1967	fi
	1968	cp /boot/efi/elilo.efi $mountpoint
	1969	cp $liloconf $mountpoint/elilo.efi $mountpoint/efi/boot
	1970	if [ $mountefi -eq 1 ]; then
	1971	umount /boot/efi 2>&1 > /dev/null
	1972	fi
	1973	fi
	1974
[940]	1975	echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
	1976	cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
[747]	1977	if [ "$?" -ne "0" ] ; then
[963]	1978	LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
[940]	1979	cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
[963]	1980	LogIt "Please unload some of your modules and try again."
[940]	1981	rm -f $MINDI_TMP/mtpt.$$
[963]	1982	LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
[747]	1983	retval=$(($retval+1))
	1984	fi
	1985	MakeMessageFile $disksize > $mountpoint/message
	1986
	1987	mkdir -p $mountpoint/tmp
[940]	1988	cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
[747]	1989	if [ -e "$MINDI_LIB/memtest.img" ] ; then
	1990	echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
	1991	echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
	1992	# echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
	1993	fi
	1994
[925]	1995	# copy the kernel across
[1087]	1996	[ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
[747]	1997	dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
	1998	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	1999	cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
	2000	if [ "$?" -ne "0" ] \|\| [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
[925]	2001	echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
	2002	du -sk $mountpoint/* >> $LOGFILE
	2003	echo "--- end of list of files ---" >> $LOGFILE
	2004	echo -en "Kernel size = `du -sk $kernelpath \| cut -f1` K\nRamdisk free = $free_space K\n\
[747]	2005	Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
	2006	rm -f $mountpoint/vmlinuz
[925]	2007	cd $old_pwd
[747]	2008	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
[963]	2009	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[925]	2010	# losetup /dev/loop0 -d
	2011	res=0
[747]	2012	write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
[925]	2013	res=$(($res+$?))
[963]	2014	cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
[925]	2015	res=$(($res+$?))
	2016	rm -f $imagefile
	2017	if [ "$res" -ne "0" ]; then
[963]	2018	LogIt "WARNING - failed to create 1.44MB boot/root floppies"
[925]	2019	rm -f $imagesdir/mindi-*.1440.img
	2020	fi
	2021	return $res
[747]	2022	fi
	2023	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	2024	max_kernel_size=$(($free_space+`du -sk $kernelpath \| cut -f1`))
	2025	echo "Free space left on floppy = $free_space KB" >> $LOGFILE
	2026	echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
	2027	# make it bootable
	2028	rm -f $mountpoint/zero
[963]	2029	[ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
[747]	2030	if [ "$disksize" -gt "2880" ] && [ ! "$KERN_DISK_MADE" ] ; then
	2031	if [ "$ARCH" != "ia64" ] ; then
[1087]	2032	$LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
[747]	2033	else
	2034	/bin/true
	2035	fi
	2036	elif [ ! "$KERN_DISK_MADE" ] ; then
	2037	# 12/28/2001 - if 1.72MB floppy then don't use LILO's optimizations at all
[925]	2038	$LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
[747]	2039	else
[925]	2040	echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
[747]	2041	fi
[925]	2042
	2043	# BERLIOS does not test necessarily what it expects
[747]	2044	if [ $? -ne "0" ] ; then
[925]	2045	if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
[963]	2046	LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
	2047	LogIt "Please reboot your PC as a workaround."
	2048	Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
[925]	2049	fi
	2050	echo "$LILO_EXE -r $mountpoint ...failed."
	2051	echo -en "Press ENTER to continue."; read line
[963]	2052	LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
[925]	2053	retval=$(($retval+1))
[747]	2054	fi
[963]	2055	cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
[747]	2056	if [ "$ARCH" = "ia64" ] ; then
[963]	2057	cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
[747]	2058	fi
	2059	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
	2060	echo -en "..."
[963]	2061	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	2062	if [ "$retval" -eq "0" ] ; then
[1193]	2063	echo -en "...$DONE\n"
[747]	2064	if [ "$KERN_DISK_MADE" ] ; then
[1193]	2065	LogIt "$disksize KB boot disks were created OK\n"
[747]	2066	fi
	2067	else
[1193]	2068	echo -en "...failed\n"
	2069	LogIt $disksize"KB boot disk was NOT created\n"
[747]	2070	rm -f $imagefile
	2071	fi
[963]	2072	[ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
[747]	2073	return $retval
	2074	}
	2075
	2076
	2077	PrepareBootDiskImage_SYSLINUX() {
	2078	local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
	2079	imagesdir=$1
	2080	disksize=$2
	2081	kernelpath=$3
	2082	ramdisksize=$4
	2083	do_boot_root_thingy=""
	2084	local retval old_pwd
	2085	retval=0
[925]	2086
[747]	2087	[ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
	2088	echo -en "Making "$disksize"KB boot disk..."
[940]	2089	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?"
[1121]	2090	[ "$disksize" != "2880" ] && [ "$disksize" != "5760" ] && Die "PDBI - disksize is $disksize - bad size"
[747]	2091	echo -en "..."
	2092	imagefile=$imagesdir/mindi-bootroot.$disksize.img
[940]	2093	mountpoint=$MINDI_TMP/mountpoint.$$
[747]	2094	mkdir -p $mountpoint
[1121]	2095	dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null \|\| Die "Cannot dd blank file"
	2096	echo "Creating vfat filesystem on $imagefile" >> $LOGFILE
	2097	mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
	2098	syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
	2099
[963]	2100	mount -t vfat -o loop $imagefile $mountpoint \|\| LogIt "Cannot mount (PBDI)"
[925]	2101
	2102	# copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
[747]	2103	old_pwd=`pwd`
	2104	MakeSyslinuxMessageFile $mountpoint/message.txt
	2105	cd $mountpoint
	2106	[ -e "$sys_cfg_file" ] \|\| Die "Obi Wan, word up?"
	2107	cat $sys_cfg_file \| HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg \|\| Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
[1087]	2108	if [ "$NFS_DEV" != "" ] ; then
[1063]	2109	perl -pi -e 's/interactive/iso/' syslinux.cfg
[747]	2110	fi
	2111	cd $old_pwd
[940]	2112	echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
	2113	cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
[747]	2114	if [ "$?" -ne "0" ] ; then
[963]	2115	LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
[940]	2116	cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
[963]	2117	LogIt "Please unload some of your modules and try again."
[940]	2118	rm -f $MINDI_TMP/mtpt.$$
[963]	2119	LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
[747]	2120	retval=$(($retval+1))
	2121	fi
	2122
	2123	mkdir -p $mountpoint/tmp
[940]	2124	cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
[747]	2125
[925]	2126	# copy the kernel across
[1087]	2127	[ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
[747]	2128	dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
	2129	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	2130	cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
	2131	if [ "$?" -ne "0" ] \|\| [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
	2132	echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
	2133	du -sk $mountpoint/* >> $LOGFILE
	2134	echo "--- end of list of files ---" >> $LOGFILE
	2135	echo -en "Kernel size = `du -sk $kernelpath \| cut -f1` K\nRamdisk free = $free_space K\n\
	2136	Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
	2137	rm -f $mountpoint/vmlinuz
	2138	cd $old_pwd
	2139	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
[963]	2140	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	2141
	2142	res=0
	2143	write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
	2144	res=$(($res+$?))
[963]	2145	cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
[747]	2146	res=$(($res+$?))
	2147	rm -f $imagefile
	2148	if [ "$res" -ne "0" ]; then
[963]	2149	LogIt "WARNING - failed to create 1.44MB boot/root floppies"
[747]	2150	rm -f $imagesdir/mindi-*.1440.img
	2151	fi
	2152	return $res
	2153	fi
	2154	free_space=`df -k -P $mountpoint \| tail -n1 \| tr -s ' ' '\t' \| cut -f4`
	2155	max_kernel_size=$(($free_space+`du -sk $kernelpath \| cut -f1`))
	2156	echo "Free space left on floppy = $free_space KB" >> $LOGFILE
	2157	echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
[925]	2158
	2159	# make it bootable
[747]	2160	rm -f $mountpoint/zero
	2161	mkdir -p $mountpoint/etc
[963]	2162	[ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
[747]	2163	umount $mountpoint \|\| Die "Cannot unmount mountpoint ($mountpoint)"
	2164	echo -en "..."
[963]	2165	rmdir $mountpoint \|\| LogIt "Cannot rmdir (PBDI)"
[747]	2166
	2167	if [ "$retval" -eq "0" ] ; then
[1193]	2168	echo -en "...$DONE\n"
[747]	2169	if [ "$KERN_DISK_MADE" ] ; then
	2170	rm -f $imagefile
[1193]	2171	LogIt "$disksize KB boot disks were created OK\n"
[747]	2172	fi
	2173	else
[1193]	2174	echo -en "...failed\n"
	2175	LogIt $disksize"KB boot disk was NOT created\n"
[747]	2176	rm -f $imagefile
	2177	fi
[963]	2178	[ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
[747]	2179	return $retval
	2180	}
	2181
	2182
	2183	PrepareDataDiskImages() {
[1060]	2184	local needlist bigdir minidir_root tardir diskdir imagesdir res i j k old_pwd lines lfiles
[747]	2185
	2186	imagesdir=$1
	2187	rm -f $imagesdir/mindi-.img $imagesdir/[0-9].tar.gz $imagesdir/mindi.iso
[940]	2188	needlist=$MINDI_TMP/what-we-need.txt
	2189	bigdir=$MINDI_TMP/bigdir
	2190	minidir_root=$MINDI_TMP/minidir
[747]	2191	mkdir -p $minidir_root
	2192	mkdir -p $bigdir/usr/bin
[940]	2193	tardir=$MINDI_TMP/tardir
[747]	2194
[1060]	2195	if [ -e "$DEPLIST_FILE" ]; then
	2196	lfiles="$DEPLIST_FILE $DEPLIST_DIR/*"
	2197	else
	2198	lfiles="$DEPLIST_DIR/*"
	2199	fi
	2200	lines=`grep -vx " #." $lfiles \| grep -vx "" \| wc -l`
	2201	cat $lfiles \| GenerateGiantDependencyList $needlist $lines
[747]	2202	res=$?
	2203	if [ "$YOUR_KERNEL_SUCKS" ]; then
[925]	2204	pwd=`pwd`
[940]	2205	cd $MINDI_TMP
[747]	2206	for i in `ListKernelModulePaths \| HackPathsToFailsafe` ; do
[963]	2207	cp --parents -pRdf ./$i $bigdir 2>> $LOGFILE \|\| Die "PDDI can't cp $i->$bigdir"
[925]	2208	if [ "`du -sk $i \| cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
[963]	2209	cp --parents -pRdf $i $bigdir 2>> $LOGFILE
[925]	2210	else
	2211	ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
	2212	BIGNO=$(($BIGNO+1))
	2213	fi
[747]	2214	done
[925]	2215	for i in $EXTRA_MODS ; do
	2216	j=`find lib/modules/$FAILSAFE_KVER -name $i.*o 2> /dev/null`
[963]	2217	[ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o" >> $LOGFILE
[925]	2218	for k in $j ; do
	2219	if [ "`du -sk $k \| cut -f1`" -lt "$CHOPSIZE" ] ; then
[963]	2220	cp --parents -pRdf $k $bigdir 2>> $LOGFILE
[925]	2221	else
	2222	ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
	2223	BIGNO=$(($BIGNO+1))
	2224	fi
	2225	echo "Added failsafe module $k to ramdisk" >> $LOGFILE
	2226	done
	2227	done
	2228	cd $pwd
[747]	2229	else
[925]	2230	ListKernelModulePaths >> $needlist
[747]	2231	fi
	2232	if [ "$res" -ne "0" ] ; then
	2233	Die "You have $res file`PluralOrNot $res` present in dependency list\nbut absent from filesystem."
	2234	fi
	2235	FindAndAddUserKeyboardMappingFile
	2236	mkdir -p $bigdir/tmp
[1063]	2237	if [ _"$MONDO_SHARE" != _"" ]; then
[1163]	2238	cp -f $MONDORESTORECFG $bigdir/tmp &> /dev/null
[747]	2239	fi
	2240	[ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
	2241	DropOptimizedLibraries $needlist $bigdir
	2242	echo -en "Assembling dependency files"
	2243	CopyDependenciesToDirectory < $needlist $bigdir
	2244
[925]	2245	# also copy io.sys and msdos.sys, if we can find them
[747]	2246	for i in `mount \| cut -d' ' -f3` ; do
[925]	2247	for j in io.sys msdos.sys ; do
[963]	2248	[ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
[925]	2249	done
[747]	2250	done
	2251
[925]	2252	# master boot record, too
[1141]	2253	if [ _"$MONDORESTORECFG" != _"" ]; then
[1158]	2254	i=`grep bootloader.device $MONDORESTORECFG \| cut -d'=' -f2 2> /dev/null`
[1141]	2255	if [ "$i" ] ; then
	2256	LogIt "Backing up $i's MBR"
	2257	dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
	2258	sleep 1
	2259	sync
	2260	j=$i
	2261	[ -h "$j" ] && j=`readlink -f $j`
	2262	LogIt "Creating /dev/boot_device ($j)"
	2263	mkdir -p $bigdir/dev
	2264	cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null \|\| Die "Unable to create /dev/boot_device on ramdisk"
	2265	fi
[747]	2266	fi
	2267
	2268	old_pwd=`pwd`
	2269	cd $bigdir
	2270
	2271	[ -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]	2272	cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE \|\| LogIt "WARNING - error occurred while unzipping aux-tools"
[747]	2273	if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
[963]	2274	tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE \|\| LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
[747]	2275	fi
[1063]	2276	if [ -e "$MONDO_SHARE/restore-scripts" ]; then
[747]	2277	cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
[1060]	2278	[ "$?" -ne "0" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
[747]	2279	fi
[963]	2280	[ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
[747]	2281	cd $old_pwd
	2282	echo -e "$DONE"
	2283	TOTAL_BIGDIR_SIZE=`du -sk $bigdir \| cut -f1`
	2284	SplitDirectoryIntoMinidirs $bigdir $minidir_root
	2285	noof_disks=$?
	2286	[ "$noof_disks" -eq "0" ] && Die "Too much stuff!"
[940]	2287	MakeMountlist $MINDI_TMP/mountlist.txt
[747]	2288	mkdir -p $minidir_root/$noof_disks/tmp
[953]	2289	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]	2290	if [ _"$MONDO_SHARE" != _"" ]; then
	2291	cp -f $minidir_root/$noof_disks/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
	2292	fi
[964]	2293	[ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $minidir_root/$noof_disks/tmp/i-want-my-lvm \|\| LVM="false"
[747]	2294	cat $minidir_root/$noof_disks/tmp/mountlist.txt >> $LOGFILE
	2295	ZipMinidirsIntoTarballs $minidir_root $tardir $noof_disks
	2296	CreateDataDiskImagesFromTarballs $tardir $imagesdir $noof_disks
	2297	FRIENDLY_OUTSTRING="Boot and data disk images were created."
[925]	2298	# One 1.72MB boot disk, one 2.88MB boot disk and $noof_disks data disk images
[747]	2299	rmdir $tardir $bigdir
	2300	rm -f $needlist
	2301	return $noof_disks
	2302	}
	2303
	2304
	2305	ProcessLDD() {
	2306	local main_fname incoming j i fname f newf
	2307	main_fname=$1
	2308	read incoming
	2309	while [ "$incoming" != "" ] ; do
[859]	2310	# We take the full path name of the dyn. lib. we want
	2311	incoming=`echo "$incoming" \| sed '/[[:blank:]].[[:blank:]]=>[[:blank:]](./d ; s/[[:blank:]].[[:blank:]]=>[[:blank:]]\(\/.\)/\1/ ; s/[[:blank:]]\(\/.\)[[:blank:]](./\1/'`
	2312	for f in `echo "$incoming"` ; do
[862]	2313	echo "$f `ReadAllLink $f`"
[747]	2314	done
	2315	read incoming
	2316	done
	2317	}
	2318
	2319
	2320	Prompt() {
	2321	echo -en "$1"
	2322	read line
	2323	}
	2324
	2325
	2326	ReadLine() {
	2327	local i incoming
	2328	read incoming
	2329	i=0
	2330	while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
[925]	2331	i=$(($i+1))
	2332	read incoming
[747]	2333	done
	2334	echo "$incoming"
	2335	}
	2336
	2337
	2338	RejigHyperlinks() {
	2339	local minidir_root noof_disks fname path diskno old_pwd awk_loc gawk_loc dir i
	2340	minidir_root=$1
	2341	noof_disks=$2
	2342
	2343	old_pwd=`pwd`
	2344	diskno=1
	2345	while [ "$diskno" -le "$noof_disks" ] ; do
[859]	2346	mkdir -p $minidir_root/$diskno
[747]	2347	cd $minidir_root/$diskno
	2348	for fname in `find -type d -o -print` ; do
	2349	[ -h "$minidir_root/$diskno/$fname" ] && MoveHyperlinkSensibly $fname $minidir_root $diskno $noof_disks
	2350	done
[925]	2351	diskno=$(($diskno+1))
[747]	2352	done
	2353
	2354	cd $old_pwd
	2355	return
	2356	}
	2357
	2358
	2359	ReplaceIndividualLine() {
	2360	local orig_file new_file lino newstring lines_total lines_remaining
[925]	2361
[747]	2362	orig_file=$1.orig
	2363	mv -f $1 $orig_file \|\| Die "Cannot move $1 to $orig_file"
	2364	new_file=$1
	2365	lino=$2
	2366	newstring="$3"
	2367	if [ "$lino" = "" ] \|\| [ "$lino" -lt "1" ] ; then
[925]	2368	echo "Can't find string" >> $LOGFILE
	2369	return 1
[747]	2370	fi
[963]	2371	lines_total=`wc -l $orig_file \| $AWK '{print $1;}'`
[747]	2372	lines_remaining=$(($lines_total-$lino))
	2373	head -n$(($lino-1)) $orig_file > $new_file
	2374	echo "$newstring" >> $new_file
	2375	echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
	2376	tail -n$lines_remaining $orig_file >> $new_file
	2377	echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
	2378	[ -x "$orig_file" ] && chmod +x $new_file
	2379	rm -f $orig_file
	2380	return 0
	2381	}
	2382
	2383
	2384	ScanCDandTape() {
	2385	local i
	2386
	2387	for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
	2388	dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
	2389	done
	2390	}
	2391
	2392
	2393	SizeOfPartition() {
	2394	local devpath drive res stub
	2395	device=$1
	2396	if [ "`echo "$device" \| grep -F "/dev/md"`" != "" ] ; then
[925]	2397	res=`SizeOfRaidPartition $device`
	2398	[ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
	2399	echo "$res"
	2400	return 0
[747]	2401	fi
[925]	2402	# patch from Bill <bill@iwizard.biz> - 2003/08/25
[960]	2403	res=`$FDISK -s $device 2>> $LOGFILE`
[925]	2404	# end patch
[747]	2405	[ "$res" = "" ] && res=`df -k -P -x supermount \| tr -s '\t' ' ' \| grep -F "$device " \| cut -d' ' -f2`
	2406	[ "$res" = "" ] && res="-1"
	2407	echo $res
	2408	return 0
	2409	}
	2410
	2411
	2412	SizeOfRaidPartition() {
	2413	local real_dev smallest_size silly tmp
	2414
	2415	silly=999999999
	2416	smallest_size=$silly
	2417
	2418	for real_dev in `GetRaidDevMembers $1` ; do
[925]	2419	tmp=`SizeOfPartition $real_dev`
	2420	[ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
[747]	2421	done
	2422
	2423	if [ "$smallest_size" = "$silly" ] ; then
[925]	2424	echo "-1"
	2425	return 1
[747]	2426	else
[925]	2427	echo "$smallest_size"
	2428	return 0
[747]	2429	fi
	2430	}
	2431
	2432
	2433	StripComments()
	2434	{
	2435	local tempfile
[925]	2436
[940]	2437	tempfile=$MINDI_TMP/$$.strip.txt
[963]	2438	cp -f $1 $tempfile 2>> $LOGFILE
[747]	2439	$AWK '{if (substr($0,0,1)!="#" \|\| substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
	2440	rm -f $tempfile
	2441	echo "Stripped comments from $2" >> $LOGFILE
	2442	}
	2443
	2444
	2445	SplitDirectoryIntoMinidirs() {
	2446	local bigdir minidir_root i noof_disks old_pwd res
[925]	2447
[747]	2448	bigdir=$1
	2449	minidir_root=$2
[1087]	2450	[ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
[747]	2451
	2452	TryToFitDataIntoSeveralDirs $bigdir $minidir_root
	2453	noof_disks=$?
	2454	if [ "$noof_disks" -eq "0" ] ; then
[925]	2455	echo "Failed to fit data into several dirs."
[747]	2456	return 0
	2457	fi
	2458	RejigHyperlinks $minidir_root $noof_disks
[1087]	2459	[ "$bigdir" != "" ] && rm -Rf $bigdir/*
[925]	2460	return $noof_disks
[747]	2461	}
	2462
	2463
	2464	StripExecutable()
	2465	{
	2466	local tmpfile
[925]	2467
[940]	2468	tmpfile=$MINDI_TMP/stripped.$$.dat
[747]	2469	[ -d "$1" ] \|\| [ -h "$1" ] && return
[963]	2470	cp -f $1 $tmpfile 2>> $LOGFILE
[747]	2471	strip $tmpfile 2> /dev/null
	2472	if [ "$?" -eq "0" ] ; then
[963]	2473	cp -f $tmpfile $1 2>> $LOGFILE
[925]	2474	echo "Stripped binary $2" >> $LOGFILE
[747]	2475	fi
	2476	rm -f $tmpfile
	2477	}
	2478
	2479
	2480	TemporarilyCompressAllFiles() {
	2481	local i orig_fname out_fname out_list
	2482
	2483	i=0
	2484	out_list=$2/compressed/compressed.txt
	2485	mkdir -p $2/compressed
	2486	> $out_list
	2487	for orig_fname in $1 ; do
	2488	out_fname=$2/compressed/$orig_fname.gz
	2489	mkdir -p $out_fname 2> /dev/null
	2490	rmdir $out_fname 2> /dev/null
	2491	gzip -c6 $orig_fname > $out_fname 2> /dev/null
	2492	i=$(((($i+1))%15))
	2493	[ "$i" -eq "0" ] && echo -en "."
	2494	du -sk $out_fname >> $out_list
	2495	done
	2496	}
	2497
	2498
	2499	TryToFindKernelPath() {
	2500	local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
[925]	2501
[747]	2502	we_want_version=`uname -r`
	2503	possible_kernels=""
	2504	duff_kernels=""
	2505
	2506	if [ "$ARCH" = "ia64" ] ; then
	2507	root="/boot/efi/efi"
	2508	else
	2509	root="/"
	2510	fi
	2511	for fname in `find $root -maxdepth 2 -type f \| grep -F lin \| grep -Ev '^/proc/\|^/net/'` ; do
[925]	2512	[ ! -e "$fname" ] && continue
[747]	2513	[ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
[925]	2514	file $fname \| grep -q gzip
	2515	if [ "$?" -eq "0" ] ; then
	2516	# Used by ia64
[747]	2517	fkern_ver=`gzip -cd $fname \| strings 2> /dev/null \| grep "[2-9]+[.][0-9]+[.][0-9]+[^\@]@"`
[925]	2518	else
[747]	2519	fkern_ver=`strings $fname 2> /dev/null \| grep "[2-9]+[.][0-9]+[.][0-9]+[^\@]@"`
[925]	2520	fi
[747]	2521	[ "$fkern_ver" = "" ] && continue
	2522	[ "`echo "$fkern_ver" \|grep -F "$we_want_version "`" = "" ] && continue
[925]	2523	[ -f "$fname" ] \|\| continue
	2524	[ -h "$fname" ] && continue
	2525	kdate=`uname -v \| $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' \| $AWK '{print $NF;}'`
	2526	file $fname \| grep -q gzip
	2527	if [ "$?" -eq "0" ] ; then
	2528	# Used by ia64
	2529	if [ "`gzip -cd $fname \| strings 2> /dev/null \| grep -F "$kdate"`" = "" ] ; then
[963]	2530	LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
[925]	2531	duff_kernels="$fname $duff_kernels"
	2532	else
[747]	2533	[ "`echo "$fname" \| grep -F "vmlinux"`" ] && continue
	2534	possible_kernels="$fname $possible_kernels"
[925]	2535	fi
[747]	2536	else
[925]	2537	if [ "`strings $fname 2> /dev/null \| grep -F "$kdate"`" = "" ] ; then
[963]	2538	LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
[925]	2539	duff_kernels="$fname $duff_kernels"
	2540	else
[747]	2541	[ "`echo "$fname" \| grep -F "vmlinux"`" ] && continue
	2542	possible_kernels="$fname $possible_kernels"
[925]	2543	fi
[747]	2544	fi
	2545	done
	2546	if [ ! "$possible_kernels" ] && uname -a \| grep Knoppix > /dev/null ; then
[925]	2547	possible_kernels=`find /boot/vmlinuz-2.* \| tail -n1`
[747]	2548	fi
	2549	if [ ! "$possible_kernels" ] ; then
[963]	2550	LogIt "No kernel matches exactly. Are there any duff kernels?"
[747]	2551	possible_kernels="$duff_kernels"
	2552	if [ ! "$possible_kernels" ] ; then
[963]	2553	LogIt "Sorry, no duff kernels either"
[747]	2554	else
[963]	2555	LogIt "I bet you're running Debian or Gentoo, aren't you?"
	2556	LogIt "Your kernel doesn't have a sane builddate. Oh well..."
[747]	2557	fi
	2558	fi
	2559	possible_kernels=`echo "$possible_kernels" \| tr -s ' ' '\n' \| sort -u \| tr '\n' ' '`
	2560	noof_kernels=`CountItemsIn "$possible_kernels"`
	2561	if [ "$noof_kernels" -eq "0" ] ; then
[963]	2562	LogIt "Could not find your kernel."
[925]	2563	if [ -e "/boot/vmlinuz" ] ; then
[963]	2564	LogIt "Using /boot/vmlinuz as a last resort."
[925]	2565	output=/boot/vmlinuz
[747]	2566	else
[925]	2567	output=""
	2568	fi
[747]	2569	elif [ "$noof_kernels" -eq "1" ] ; then
	2570	kernelpath=`echo "$possible_kernels" \| sed s/' '//`
	2571	echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
	2572	output="$kernelpath"
	2573	else
	2574	for i in $possible_kernels ; do
	2575	if echo $i \| grep "`uname -r`" ; then
[925]	2576	LogIt "OK, I used my initiative and found that "
[963]	2577	LogIt "$i is probably your kernel. "
[925]	2578	output="$i"
	2579	return
	2580	fi
[747]	2581	done
[925]	2582	if echo " $possible_kernels " \| grep -F "/boot/vmlinuz " &> /dev/null ; then
	2583	output=/boot/vmlinuz
	2584	echo "Schlomo, this one's for you." >> $LOGFILE
	2585	else
[963]	2586	LogIt "Two or more possible kernels found. You may specify any one of them and the "
	2587	LogIt "boot disks will still work, probably. If one does not work, try another."
	2588	LogIt "$possible_kernels"
[747]	2589	echo ""
[925]	2590	fi
[747]	2591	fi
	2592	echo "$output" \| tr -s ' ' '\n' \| sort -u \| tr '\n' ' '
	2593	}
	2594
	2595
	2596	TryToFitDataIntoSeveralDirs() {
	2597	local bigdir minidir_root noof_disks diskno list_of_files filename old_pwd progress
	2598	local i retval noof_disks total_files list_of_devs
[925]	2599
[747]	2600	bigdir=$1
	2601	minidir_root=$2
	2602	BIG_CLUNKY_SIZE_COUNTER=0
	2603	retval=0
	2604	noof_disks=1
	2605
	2606	echo -en "\r \rDividing data into several groups..."
	2607	old_pwd=`pwd`
	2608	cd $bigdir
	2609	list_of_files=`GetFileSizeList . \| sort -nr \| cut -f2 \| grep -Fv "/dev/"`
	2610	progress=0
	2611	total_files=`CountItemsIn "$list_of_files"`
	2612	if [ "`echo "$filename" \| grep -x "/dev/.*"`" ] ; then
	2613	filesize=1
	2614	fi
	2615	mkdir -p $minidir_root/$noof_disks
	2616	if [ -e "dev" ] ; then
	2617	echo "Copying dev/* to $minidir_root/$noof_disks" >> $LOGFILE
[963]	2618	cp --parents -pRdf dev $minidir_root/$noof_disks 2>> $LOGFILE
[747]	2619	fi
	2620	TemporarilyCompressAllFiles "$list_of_files" $minidir_root
	2621	for filename in $list_of_files ; do
	2622	AddFileToDir $filename $minidir_root $noof_disks
[925]	2623	i=$?
	2624	if [ "$i" -gt "$noof_disks" ] ; then
	2625	noof_disks=$i
	2626	echo -en "\r\t\t\t\t\t\t($noof_disks disks)"
	2627	fi
	2628	if [ "$i" -eq "0" ] ; then
[963]	2629	LogIt "Cannot add file $filename to minidir $minidir_root"
[925]	2630	retval=$(($retval+1))
	2631	fi
[747]	2632	progress=$(($progress+1))
[925]	2633	echo -en "\r\t\t\t\t\t\t\t\t$(($progress*100/$total_files))% complete\r"
[747]	2634	done
	2635	cd $old_pwd
	2636	echo -en "\rThe files have been subdivided into $noof_disks directories. \r"
[1087]	2637	[ "$minidir_root" != "" ] && rm -Rf $minidir_root/compressed
[747]	2638	if [ "$retval" -gt "0" ] ; then
[925]	2639	return 0
[747]	2640	else
[925]	2641	return $noof_disks
[747]	2642	fi
	2643	}
	2644
	2645
	2646	TurnTgzIntoRdz() {
	2647	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]	2648
[747]	2649	tgz_dir_fname=$1
	2650	rdz_fname=$2
	2651	ramdisksize=$3
	2652	disksize=$4
	2653	kernelsize=$5
	2654	maxsize=$(($disksize-$kernelsize))
	2655	maxsize=$(($maxsize*2)); # to allow for compression of 50%
[940]	2656	tempfile=$MINDI_TMP/temp.rd
	2657	mountpoint=$MINDI_TMP/mnt1
[747]	2658	res=0
	2659	echo -en "..."
	2660	dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null \|\| Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
	2661	echo -en "..."
[1075]	2662	echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
[747]	2663	mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE
	2664	echo -en "..."
	2665	mkdir -p $mountpoint
	2666	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."
	2667	echo -en "..."
	2668	old_pwd=`pwd`
	2669	cd $mountpoint
[959]	2670	cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
[747]	2671	tar -zxf symlinks.tgz \|\| Die "Cannot untar symlinks.tgz"
	2672	cd dev \|\| Die "Can't cd to dev"
	2673	tar -zxf dev-entries.tgz \|\| Die "Cannot untar dev-entries.tgz"
	2674	rm -f dev-entries.tgz
	2675	cd ..
	2676
	2677	for w in insmod.static insmod.static.old ; do
[925]	2678	s=`which $w 2> /dev/null`
	2679	if [ -e "$s" ] ; then
[963]	2680	cp --parents -af $s . 2>> $LOGFILE
[925]	2681	fi
[747]	2682	done
	2683
	2684	mkdir -p tmp
	2685	[ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
	2686	for w in cdrom floppy groovy-stuff ; do
	2687	mkdir -p mnt/$w
	2688	done
[925]	2689	#if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
	2690	#ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init \| cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
	2691	#fi
[747]	2692	if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
[925]	2693	ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init \| cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
[747]	2694	fi
	2695
	2696	lsmod > tmp/original-lsmod.txt
	2697
	2698	cp --parents -Rdf /dev/fd0[1,2][4,7,8] . 2> /dev/null
	2699	cd $old_pwd
	2700	echo -en "..."
	2701	MakeModuleLoadingScript $TMPMODPROBE_FLAG $mountpoint/sbin/insert-all-my-modules
	2702	echo -en "..."
	2703	old_pwd=`pwd`
	2704	if [ "$YOUR_KERNEL_SUCKS" ] ; then
[940]	2705	cd $MINDI_TMP
[747]	2706	floppy_modules_path=lib/modules/$FAILSAFE_KVER
	2707	else
	2708	cd /
	2709	###
	2710	### Sq-Modification... Use kernel name in module path if specified.
	2711	###
	2712	#floppy_modules_path=lib/modules/`uname -r`
	2713	if [ "${kernelname}" != "" ]
	2714	then
	2715	floppy_modules_path=lib/modules/${kernelname}
	2716	else
	2717	floppy_modules_path=lib/modules/`uname -r`
	2718	fi
	2719	###
	2720	### Sq-Modification end
	2721	###
	2722	fi
	2723	floppy_modules=""
	2724	if [ "$disksize" -lt "2880" ] ; then
	2725	list_of_groovy_mods="$FLOPPY_MODS $IDE_MODS ide-scsi sr_mod cdrom isocd isofs `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
	2726	else
	2727	list_of_groovy_mods="$CDROM_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
	2728	fi
[1087]	2729	if [ "$NFS_DEV" != "" ] ; then
[747]	2730	# For PXE boot
	2731	list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
	2732	fi
[963]	2733	[ -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]	2734	for i in $list_of_groovy_mods ; do
	2735	floppy_modules="$floppy_modules `FindSpecificModuleInPath $floppy_modules_path $i`"
	2736	done
	2737	for i in $floppy_modules ; do
	2738	[ -e "$i" ] && s=`du -sk $i \| cut -f1` \|\| s=""
[940]	2739	[ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
[747]	2740	echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
[963]	2741	cp -df $i $mountpoint/ 2>/dev/null \|\| LogIt "Unable to copy $i to $mountpoint"
[747]	2742	[ "`echo "$i" \| grep -F ".gz"`" ] && gunzip -f $mountpoint/`basename $i`
	2743	done
	2744	if [ ! -e "/sbin/devfsd" ] \|\| [ "$disksize" -lt "2880" ] \|\| [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
	2745	echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
	2746	[ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
	2747	[ "$disksize" -lt "2880" ] && echo "...because disksize = $disksize" >> $LOGFILE
	2748	[ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
	2749	rm -f $mountpoint/sbin/devfsd
	2750	fi
	2751	cd $old_pwd
[1087]	2752	[ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
[747]	2753	dd if=/dev/zero of=$mountpoint/zero &> /dev/null
	2754	rm -f $mountpoint/zero
[1087]	2755	mkdir -p $mountpoint/tmp
[1063]	2756	if [ _"$MONDO_SHARE" != _"" ]; then
[1087]	2757	cp -f $MONDO_CACHE/mondo-restore.cfg $mountpoint/tmp &> /dev/null \|\| Die "Cannot copy mondo-restore.cfg to ramdisk"
[953]	2758	cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ 2>/dev/null \|\| Die "Cannot copy mountlist to ramdisk"
[747]	2759	fi
	2760	mkdir -p $mountpoint/proc
	2761	echo "$disksize" > $mountpoint/tmp/$disksize.siz
	2762	find $mountpoint -name CVS -exec rm -rf '{}' \;
[1099]	2763	# Determine what filesystem to use for initrd image
[1142]	2764	echo "Call GetInitrdFilesystemToUse() with parameter ${kernelpath} to get filesystem to use for initrd." >> $LOGFILE
[1099]	2765	gvFileSystem=`GetInitrdFilesystemToUse ${kernelpath}`
	2766	[ -z gvFileSystem ] && Die "GetFilesystemToUse() failed. Terminating."
	2767	case "$gvFileSystem" in
	2768	"ext2fs")
	2769	# say what will be used
[1142]	2770	echo "Creating an ext2 initrd image..." >> $LOGFILE
[1099]	2771	# kernel expects linuxrc in ext2 filesystem
[1142]	2772	( cd $mountpoint && ln -sf sbin/init linuxrc )
[1099]	2773	# unmount loop filesystem and create image file using the standard approach
	2774	umount $mountpoint \|\| Die "Cannot unmount $tempfile"
	2775	dd if=$tempfile bs=1k 2> /dev/null \| gzip -v9 > $rdz_fname 2> /dev/null
	2776	# log that we are done
[1142]	2777	echo "...done." >> $LOGFILE
[1099]	2778	;;
	2779	"initramfs")
	2780	# say what will be used
[1142]	2781	echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
[1099]	2782	# make sure that cpio is there
	2783	which cpio &> /dev/null; [ $? -eq 0 ] \|\| Die "cpio not found. Please install package cpio and try again."
	2784	# go into filesystem
	2785	cd $mountpoint
	2786	# kernel expects init in cpio filesystem
[1142]	2787	ln -sf sbin/init init
[1099]	2788	# create cpio image file and unmount loop filesystem
	2789	find . -print \| cpio -o -H newc \| gzip -9 > $old_pwd/$rdz_fname 2> /dev/null
	2790	cd $old_pwd
	2791	umount $mountpoint \|\| Die "Cannot unmount $tempfile"
	2792	# log that we are done
[1142]	2793	echo "...done." >> $LOGFILE
[1099]	2794	;;
	2795	*)
	2796	Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
	2797	;;
	2798	esac
[747]	2799	if [ "$res" -eq "0" ] ; then
	2800	echo -en "..."
	2801	else
	2802	echo -en "\rMade an rdz WITH ERRORS. \n"
	2803	fi
	2804	return 0
	2805	}
	2806
	2807
	2808	WhichOfTheseModulesAreLoaded() {
	2809	local modname loaded_modules
	2810	loaded_modules=" `lsmod \| tr -s ' ' '\t' \| cut -f1 \| grep -Fvx "Modules" \| tr '\n' ' '` "
	2811	for modname in $1 ; do
[925]	2812	[ "`echo "$loaded_modules" \| grep -F " $modname "`" ] && echo "$modname"
[747]	2813	done
	2814	}
	2815
	2816
	2817	ZipMinidirsIntoTarballs() {
	2818	local minidir_root tardir noof_disks diskno old_pwd i
	2819	minidir_root=$1
	2820	tardir=$2
	2821	noof_disks=$3
	2822
	2823	echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
	2824	mkdir -p $tardir
	2825	mkdir -p $minidir_root/all
	2826	old_pwd=`pwd`
	2827	diskno=1
	2828	while [ "$diskno" -le "$noof_disks" ] ; do
[963]	2829	cd $minidir_root/$diskno \|\| LogIt "WARNING - cannot cd to $minidir_root/$diskno"
[747]	2830	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."
	2831	diskno=$(($diskno+1))
	2832	echo -n "..."
[963]	2833	cp -pRdf * $minidir_root/all 2>> $LOGFILE
[747]	2834	done
	2835	mkdir -p $minidir_root/all/tmp
	2836	cd $minidir_root/all
	2837	size_of_all_tools=`du -sk . \| cut -f1`
[1063]	2838	if [ _"$MONDO_SHARE" != _"" ]; then
[747]	2839	for q in filelist.full.gz biggielist.txt ; do
[940]	2840	[ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
[963]	2841	cp -pRdf $MINDI_TMP/$q tmp/ 2>> $LOGFILE
[747]	2842	done
	2843	mkdir -p $minidir_root/all/tmp
	2844	fi
	2845	tar -b 4096 -cf - * 2> /dev/null \| gzip -9 > $tardir/all.tar.gz
	2846	dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
	2847	[ "`du -sm $imagesdir/all.tar.gz \| cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
	2848	cd $old_pwd
[1087]	2849	[ "$minidir_root" != "" ] && rm -Rf $minidir_root
[747]	2850	echo -e "$DONE"
	2851	}
	2852
	2853
	2854	##############################################################################
[1020]	2855	#----------------------------------- Main -----------------------------------#
[747]	2856	##############################################################################
	2857
[1087]	2858	# Now we can create what we nedd
	2859	mkdir -p $MINDI_TMP
[747]	2860
[1087]	2861	# Purge from potential old run
	2862	if [ _"$MINDI_CACHE" = _"" ]; then
	2863	Die "MINDI_CACHE undefined"
	2864	fi
	2865	rm -rf $MINDI_CACHE 2> /dev/null
	2866	mkdir -p $MINDI_CACHE
	2867
	2868
[1063]	2869	if [ "$1" = "--printvar" ] ; then
[1047]	2870	shift
	2871	if [ _"$1" != _"" ] ; then
	2872	set \| egrep "^$1" \| cut -d= -f2
	2873	fi
[1063]	2874	MindiExit 0
[1047]	2875	fi
	2876
[747]	2877	> $LOGFILE
	2878	echo "mindi v$MINDI_VERSION" >> $LOGFILE
	2879	echo "$ARCH architecture detected" >> $LOGFILE
	2880	echo "mindi called with the following arguments:" >> $LOGFILE
	2881	echo "$@" >> $LOGFILE
[800]	2882	echo "Start date : `date`" >> $LOGFILE
[1087]	2883	echo "-----------------------------" >> $LOGFILE
[747]	2884
	2885	if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
[963]	2886	LogIt "WARNING - Ancient distro detected." 1
[747]	2887	ln -sf /etc/conf.modules /etc/modules.conf
	2888	fi
	2889	[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
	2890
[1010]	2891	# Log some capital variables
	2892	[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
[1087]	2893	echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
[1010]	2894	echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
	2895	echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
	2896	[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
	2897	echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
[1087]	2898	if [ -f $MINDI_CONF ]; then
	2899	echo "-----------------------------" >> $LOGFILE
	2900	echo " Mindi configuration file " >> $LOGFILE
	2901	echo "-----------------------------" >> $LOGFILE
	2902	cat $MINDI_CONF >> $LOGFILE
	2903	echo "-----------------------------" >> $LOGFILE
	2904	fi
[1010]	2905
[1087]	2906
[747]	2907	trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
[1010]	2908
	2909	# Sanity checks
	2910	which which > /dev/null 2> /dev/null \|\| Die "Please install 'which'."
	2911	which strings > /dev/null 2> /dev/null \|\| Die "Please install binutils and libbinutils; you have no 'strings' executable."
	2912	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."
	2913	which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` \|\| AWK="`which awk 2>/dev/null`"
	2914	if which awk &> /dev/null ; then
	2915	if ! which gawk &> /dev/null ; then
	2916	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"
	2917	fi
	2918	fi
	2919	which mke2fs > /dev/null 2> /dev/null \|\| Die "Please put mke2fs in system path"
	2920	[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
	2921
[747]	2922	[ "`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"
	2923	# If we have a 2.6 kernel, the system uses module-init-tools which means that we
	2924	# may have the modprobe configuration spread out across multiple files in
	2925	# directory /etc/modprobe.d. If this is the case we concatenate these files into
	2926	# a temporary file for further processing. Otherwise we continue in the standard
	2927	# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
	2928	# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
	2929	# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
	2930	if [ -d "/etc/modprobe.d" ] && [ `uname -r \| cut -c1-3` == "2.6" ] ; then
[925]	2931	TMPMODPROBE_FLAG="Y"
[747]	2932	else
[925]	2933	TMPMODPROBE_FLAG="N"
	2934	[ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
	2935	[ ! -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]	2936	fi
[1010]	2937
	2938	# Update the PATH variable if incomplete
	2939	if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
	2940	PATH=$PATH:/sbin:/usr/sbin
	2941	export PATH
	2942	echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
	2943	echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
	2944	echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
	2945	fi
	2946
[1062]	2947	# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
	2948	if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ] && [ "$kernelpath" = "FAILSAFE" ]; then
	2949	source $MINDI_LIB/FindDistroFailsafe
	2950	# Log kernel image
	2951	LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
	2952	else
	2953	[ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null \| grep -E "2\.[46]" \| cut -d' ' -f1`
	2954	fi
[1010]	2955
	2956	if ! which mkfs.vfat &> /dev/null ; then
	2957	Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
	2958	fi
	2959
[925]	2960	### BERLIOS
[747]	2961	### Fix as it's not mandatory on ia64
	2962	if [ "$ARCH" = "ia64" ] ; then
[1010]	2963	if which elilo &> /dev/null ; then
	2964	LILO_EXE=elilo
	2965	else
	2966	LILO_EXE=`which false`
	2967	fi
[747]	2968	else
	2969	FindIsolinuxBinary
	2970	FindLiloBinary
	2971	fi
	2972	trap "Aborted" SIGTERM
	2973	DONE="\r\t\t\t\t\t\t\t\tDone. "
	2974	CHOPSIZE=240
	2975	BIGNO=0
[1060]	2976	MAX_COMPRESSED_SIZE="$mindi_max_compressed_size"
[1087]	2977
	2978	#
	2979	# Kernel management: Attempt to locate kernel specific module path
	2980	# if module path is found then use it other wise use uname -r to set it...
	2981	#
	2982	#
[1060]	2983	kernelpath="$mindi_kernel"
	2984	if [ "$kernelpath" = "NATIVE" ]; then
	2985	kernelpath=""
	2986	fi
[1087]	2987	if [ "$kernelpath" = "" ]; then
	2988	kernelpath=`TryToFindKernelPath`
	2989	fi
	2990	kernelname=`echo $kernelpath \| cut -d'-' -f2-`
[1097]	2991	echo "kernelname = $kernelname" >> $LOGFILE
	2992	echo "kernelpath = $kernelpath" >> $LOGFILE
[1087]	2993	if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
	2994	then
[1097]	2995	echo "Module path for ${kernelpath} not found..." >> $LOGFILE
	2996	echo "using running kernel\'s modules." >> $LOGFILE
[1087]	2997	kernelname=`uname -r`
[1073]	2998	else
[1097]	2999	echo "Using modules for kernel: ${kernelname}" >> $LOGFILE
[1073]	3000	fi
[747]	3001
	3002	if [ -d "/proc/lvm" ]; then
	3003	# LVM v1
	3004	LVMCMD=""
	3005	LVM="v1"
	3006	elif [ -d "/dev/mapper" ]; then
	3007	# LVM v2
	3008	LVMCMD="lvm"
	3009	LVM="v2"
	3010	else
	3011	LVM="false"
	3012	fi
[1020]	3013	echo "LVM set to $LVM" >> $LOGFILE
	3014	echo "----------" >> $LOGFILE
	3015	echo "df result:" >> $LOGFILE
	3016	echo "----------" >> $LOGFILE
[1036]	3017	df -T >> $LOGFILE
[1020]	3018	echo "-------------" >> $LOGFILE
[1124]	3019	echo "mount result:" >> $LOGFILE
	3020	echo "-------------" >> $LOGFILE
	3021	mount >> $LOGFILE
	3022	echo "-------------" >> $LOGFILE
[1020]	3023	echo "lsmod result:" >> $LOGFILE
	3024	echo "-------------" >> $LOGFILE
	3025	lsmod >> $LOGFILE
	3026	echo "-------------" >> $LOGFILE
[1060]	3027	echo "Liste of extra modules is:" >> $LOGFILE
	3028	echo "$EXTRA_MODS" >> $LOGFILE
	3029	echo "-------------" >> $LOGFILE
[747]	3030
	3031
	3032	FLOPPY_WAS_MOUNTED=""
	3033	for mtpt in /media/floppy /mnt/floppy /floppy ; do
	3034	if mount \| grep -w $mtpt &> /dev/null ; then
	3035	FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
	3036	umount $mtpt
	3037	fi
	3038	done
	3039
[1075]	3040	#
	3041	# If we have a USB device we need to store info
	3042	# and remove it from the parameters line
	3043	#
[747]	3044	if [ "$#" -ne "0" ] ; then
[1075]	3045	if [ "$1" = "--usb" ] ; then
	3046	shift
[1087]	3047	USBDEVICE=$1
	3048	if [ _"$USBDEVICE" = _"" ]; then
[1075]	3049	Die "No USB device specified"
	3050	fi
	3051	shift
	3052	fi
	3053	fi
	3054
	3055	#
[1087]	3056	# Default value for parameters coming from mondo potentially
	3057	#
	3058	if [ "$ARCH" = "ia64" ] ; then
	3059	USE_LILO=yes
	3060	else
	3061	USE_LILO=no
	3062	fi
	3063
	3064	#
	3065	# These variables are normaly only significant in a mondo environment
	3066	# Not enforced yet
	3067	#
	3068	CDRECOVERY="no"
	3069	NOT_BOOT="no"
	3070	EXCLUDE_DEVS=""
	3071	IMAGE_DEVS=""
	3072	NFS_DEV=""
	3073
	3074	#
[1075]	3075	# Deal with parameters
	3076	#
	3077	if [ "$#" -ne "0" ] ; then
[747]	3078	if [ "$1" = "--findkernel" ] ; then
	3079	res=`TryToFindKernelPath`
	3080	if [ "$res" = "" ] ; then
[925]	3081	MindiExit -1
[747]	3082	else
	3083	echo "$res"
[925]	3084	MindiExit 0
[747]	3085	fi
	3086	elif [ "$1" = "--makemountlist" ] ; then
	3087	[ ! "$2" ] && Die "Please specify the output file"
	3088	MakeMountlist $2
[925]	3089	MindiExit $?
	3090	elif [ "$1" = "-V" ] \|\| [ "$1" = "-v" ] \|\| [ "$1" = "--version" ] \|\| [ "$1" = "-version" ] ; then
	3091	echo "Mindi v$MINDI_VERSION"
	3092	MindiExit 0
[1087]	3093	elif [ "$1" = "--custom" ] ; then
[1063]	3094	if [ _"$MONDO_SHARE" = _"" ]; then
	3095	Die "--custom is reserved for mondoarchive calls"
	3096	fi
[940]	3097	MONDO_TMP=$2
	3098	# Change MINDI_TMP for the one provided by mondo
	3099	# So that it can get back the built files
[1010]	3100	mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
	3101	rmdir $MINDI_TMP
[940]	3102	MINDI_TMP=$MONDO_TMP
[953]	3103	mkdir -p $MINDI_TMP
[1010]	3104	# This is the scratch dir in mondo
[1087]	3105	MINDI_CACHE=$3
	3106	if [ _"$MINDI_CACHE" != _"" ]; then
	3107	mkdir -p $MINDI_CACHE
[938]	3108	fi
[1087]	3109
	3110	if [ ! -e "$MONDORESTORECFG" ]; then
	3111	Die "MONDORESTORECFG undefined. Use an uptodate mondoarchive version"
[1075]	3112	fi
[1087]	3113
	3114	if [ ! -e "$MONDO_CACHE" ]; then
	3115	Die "MONDO_CACHE undefined. Use an uptodate mondoarchive version"
[747]	3116	else
[1087]	3117	#
	3118	# Get from mondo our additional configuration
	3119	#
	3120	echo "Using $MONDO_CACHE/mindi.conf as additional config file"
	3121	if [ -f $MONDO_CACHE/mindi.conf ]; then
	3122	. $MONDO_CACHE/mindi.conf
	3123	echo "-----------------------------" >> $LOGFILE
	3124	echo " Mondo configuration file " >> $LOGFILE
	3125	echo "-----------------------------" >> $LOGFILE
	3126	cat $MONDO_CACHE/mindi.conf >> $LOGFILE
	3127	echo "-----------------------------" >> $LOGFILE
	3128	else
	3129	Die "No mindi.conf file created by mondo. Aborting"
	3130	fi
[747]	3131	fi
[1087]	3132
[1143]	3133	echo "Here is your $MONDORESTORECFG file:" >> $LOGFILE
[1087]	3134	echo "------------------------------------" >> $LOGFILE
	3135	cat $MONDORESTORECFG >> $LOGFILE
	3136	echo "-----------------------------------" >> $LOGFILE
	3137
[1158]	3138	CDRECOVERY=`grep use-cdrecovery $MONDORESTORECFG \| cut -d'=' -f2`
	3139	NOT_BOOT=`grep non-bootable $MONDORESTORECFG \| cut -d'=' -f2`
	3140	USE_LILO=`grep use-lilo $MONDORESTORECFG \| cut -d'=' -f2`
	3141	EXCLUDE_DEVS=`grep excluded-devs $MONDORESTORECFG \| cut -d'=' -f2`
	3142	NFS_DEV=`grep nfs-dev $MONDORESTORECFG \| cut -d'=' -f2`
	3143	VALUE=`grep image-devs $MONDORESTORECFG \| cut -d'=' -f2`
[1087]	3144	if [ "$VALUE" = "(null)" ] \|\| [ "$VALUE" = "" ] ; then
[747]	3145	IMAGE_DEVS=""
	3146	else
[1087]	3147	IMAGE_DEVS="`echo "$VALUE" \| tr '\|' ' '`"
[747]	3148	fi
[1087]	3149	[ "$CDRECOVERY" = "yes" ] && [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
	3150	MONDO_ROOT=`echo $MINDI_CACHE \| sed 's/\(.\)\/./\1/'`
[938]	3151	if [ _"$MONDO_ROOT" != _"" ]; then
	3152	mkdir -p $MONDO_ROOT
	3153	else
	3154	Die "MONDO_ROOT is undefined"
	3155	fi
[747]	3156	else
[925]	3157	echo "Syntax: mindi (--custom ....)" >> /dev/stderr
	3158	MindiExit -1
[747]	3159	fi
	3160	fi
	3161	#ScanCDandTape
	3162	[ "$CDRECOVERY" = "yes" ] \|\| CDRECOVERY=no
	3163	if [ "$CDRECOVERY" = "yes" ] ; then
	3164	iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
	3165	sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
	3166	else
	3167	iso_cfg_file=$MINDI_LIB/isolinux.cfg
	3168	sys_cfg_file=$MINDI_LIB/syslinux.cfg
	3169	fi
	3170
	3171	[ -e "$iso_cfg_file" ] \|\| Die "Cannot find $iso_cfg_file"
[1063]	3172	if [ _"$MONDO_SHARE" = _"" ]; then
[963]	3173	LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
	3174	LogIt "Latest Mindi is available from http://www.mondorescue.org"
	3175	LogIt "BusyBox sources are available from http://www.busybox.net"
[747]	3176	else
	3177	echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> /var/log/mondo-archive.log
	3178	fi
[1005]	3179	if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
	3180	LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 \| head -1`"
	3181	else
	3182	LogIt "Unable to find mindi-busybox, please install it"
	3183	MindiExit -1
	3184	fi
[747]	3185
	3186	# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
	3187	insmod /lib/modules/`uname -r`///misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
	3188	for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
	3189	insmod $i >> $LOGFILE 2>> $LOGFILE
	3190	done
	3191
	3192	KERN_DISK_MADE=""
	3193
[1087]	3194	if [ "$NOT_BOOT" = "yes" ]; then
	3195	LogIt "Just creating a small all.tar.gz for Mondo. Nothing else."
[940]	3196	mkdir -p $MINDI_TMP/small-all/tmp
[1087]	3197	MakeMountlist $MINDI_TMP/small-all/tmp/mountlist.txt
	3198	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]	3199	cd $MINDI_TMP/small-all
[1087]	3200	tar -cv tmp \| gzip -9 > $MINDI_CACHE/all.tar.gz \|\| Die "Cannot make small all.tar.gz"
	3201	sync
[963]	3202	LogIt "Done. Exiting."
[925]	3203	MindiExit 0
[747]	3204	fi
	3205
[1087]	3206	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
	3207	LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
[1075]	3208	fi
[747]	3209	if [ "$kernelpath" = "" ] ; then
[1063]	3210	if [ _"$MONDO_SHARE" != _"" ]; then
	3211	Die "Please use -k <path> to specify kernel."
[747]	3212	fi
[1063]	3213	if [ $INTERACTIVE == "yes" ]; then
	3214	echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
	3215	read ch
	3216	if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
	3217	USE_OWN_KERNEL="yes"
	3218	fi
	3219	fi
[747]	3220	if [ "$USE_OWN_KERNEL" = "yes" ]; then
[925]	3221	YOUR_KERNEL_SUCKS=""
	3222	kernelpath=`TryToFindKernelPath`
	3223	if [ "$kernelpath" = "" ] ; then
	3224	echo -n "Please enter kernel path : "
	3225	read kernelpath
	3226	fi
[747]	3227	else
[925]	3228	YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
[747]	3229	fi
	3230	fi
[1073]	3231	if [ _"$MONDO_SHARE" = _"" ] && [ $INTERACTIVE = "yes" ] && [ "$ARCH" != "ia64" ] ; then
[966]	3232	echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/[n]) ?"
[747]	3233	read ch
[1060]	3234	if [ "$ch" = "y" ] \|\| [ "$ch" = "Y" ] ; then
[747]	3235	USE_LILO=yes
	3236	fi
	3237	fi
	3238	if [ "$YOUR_KERNEL_SUCKS" != "" ] \|\| [ "$kernelpath" = "" ] \|\| [ "$kernelpath" = "SUCKS" ] \|\| [ "$kernelpath" = "FAILSAFE" ] ; then
[1062]	3239	# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
	3240	if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ]; then
	3241	source $MINDI_LIB/FindDistroFailsafe
	3242	# Log kernel image
	3243	LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
	3244	kernelpath="$FAILSAFE_KBIN"
	3245	LogIt "I shall include a failsafe kernel, not your kernel, in the boot disks.\n"
	3246	LogIt "The failsafe kernel is $kernelpath.\n"
	3247	LogIt "However, you are still running your kernel. If Mindi fails to create your\n"
	3248	LogIt "disks then it may still be a result of a problem with your kernel.\n"
	3249	pwd=`pwd`
[1163]	3250	cd $MINDI_TMP
[1062]	3251	mkdir -p lib/modules
	3252	cp -a "/lib/modules/$FAILSAFE_KVER" "lib/modules/$FAILSAFE_KVER" \|\| Die "Cannot copy kernel modules."
	3253	cd $pwd
	3254	else
	3255	kernelpath=$MINDI_LIB/vmlinuz
	3256	LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
	3257	LogIt "However, you are still running your kernel. If Mindi fails to create your"
	3258	LogIt "disks then it may still be a result of a problem with your kernel."
	3259	pwd=`pwd`
	3260	cd $MINDI_TMP
	3261	bzip2 -dc $MINDI_LIB/lib.tar.bz2 \| tar -x \|\| Die "Cannot unzip lib.tar.bz2"
	3262	cd $pwd
	3263	fi
[747]	3264	YOUR_KERNEL_SUCKS="Your kernel sucks"
	3265	fi
[1087]	3266	echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$MINDI_CACHE" >> $LOGFILE
[963]	3267	[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
[747]	3268
[965]	3269	[ "$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]	3270
[1087]	3271	rm -f $MINDI_CACHE/{img,gz,*iso}
[747]	3272
[1087]	3273	PrepareDataDiskImages $MINDI_CACHE
[747]	3274	noof_disks=$?
	3275	ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
	3276	rds=$(($ramdisk_size-$((ramdisk_size%4096))))
	3277	ramdisk_size=$rds
	3278
	3279	echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
	3280	if [ "$USE_LILO" = "yes" ] ; then
	3281	if [ "$ARCH" = "ia64" ] ; then
[1087]	3282	PrepareBootDiskImage_LILO $MINDI_CACHE $IA64_BOOT_SIZE $kernelpath $ramdisk_size \|\| Die "Failed to create ia64 floppy disk image."
[747]	3283	else
[1087]	3284	if ! PrepareBootDiskImage_LILO $MINDI_CACHE 2880 $kernelpath $ramdisk_size ; then
[963]	3285	LogIt "WARNING - failed to create 2.88MB floppy disk image."
[964]	3286	LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
[1087]	3287	PrepareBootDiskImage_LILO $MINDI_CACHE 5760 $kernelpath $ramdisk_size \|\| Die "Failed to create 2.88MB floppy disk image."
[747]	3288	fi
	3289	fi
	3290	else
[1121]	3291	if ! PrepareBootDiskImage_SYSLINUX $MINDI_CACHE 2880 $kernelpath $ramdisk_size ; then
	3292	LogIt "WARNING - failed to create 2.88MB floppy disk image."
	3293	LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
	3294	PrepareBootDiskImage_SYSLINUX $MINDI_CACHE 5760 $kernelpath $ramdisk_size \|\| Die "Failed to create 5.76MB floppy disk image."
[747]	3295	fi
	3296	fi
	3297
	3298	[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
	3299	...Or type 'memtest' to test your PC's RAM thoroughly.\n"
	3300
[1063]	3301	if [ _"$MONDO_SHARE" = _"" ]; then
[1087]	3302	ListImagesForUser $MINDI_CACHE
[747]	3303	if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
[1087]	3304	OfferToCopyImagesToDisks $MINDI_CACHE $boot_dev $FDDEVICE
[747]	3305	fi
[1087]	3306	OfferToMakeBootableISO $MINDI_CACHE
	3307	if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
	3308	OfferToMakeBootableUSB $MINDI_CACHE
[1063]	3309	fi
[963]	3310	LogIt "Finished."
[1087]	3311	elif [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] ; then
	3312	rm -f $MINDI_CACHE/{img,gz,*iso}
	3313	OfferToMakeBootableISO $MINDI_CACHE
	3314	if [ -e "$MINDI_CACHE/all.tar.gz" ] ; then
	3315	cp -f $MINDI_CACHE/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
[747]	3316	else
[925]	3317	Die "Cannot find all.tar.gz, to be written to tape"
[747]	3318	fi
[1087]	3319	elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
	3320	OfferToMakeBootableUSB $MINDI_CACHE
[747]	3321	else
[1087]	3322	OfferToMakeBootableISO $MINDI_CACHE
[747]	3323	fi
	3324	# cleanup
[963]	3325	LogIt "$FRIENDLY_OUTSTRING"
[747]	3326	for mtpt in $FLOPPY_WAS_MOUNTED ; do
	3327	mount $mtpt
	3328	done
[925]	3329	MindiExit 0

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

Download in other formats: