Context Navigation

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

Visit:

Last change on this file since 882 was 882, checked in by Bruno Cornec, 18 years ago
Build process reviewed to fix again bug #79 MONDOTMP now used uniformaly across all scripts mandriva has its own set of variables svn2build should now generate directories in the right place
Property svn:keywords set to `Rev Id`
File size: 109.8 KB

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

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

Download in other formats: