Context Navigation

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

Visit:

Last change on this file since 748 was 748, checked in by Bruno Cornec, 18 years ago
Seems I got it for LVM and LABEL
Property svn:keywords set to `Rev Id`
File size: 111.1 KB

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

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

Download in other formats: