Context Navigation

source: MondoRescue/branches/2.2.5/mindi/mindi@ 1854

Visit:

Last change on this file since 1854 was 1854, checked in by Bruno Cornec, 16 years ago
removal of locate usage completely from code to use findw!
Property svn:keywords set to `Rev Id`
File size: 125.5 KB

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

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

Download in other formats: