source: branches/2.2.5/mindi/mindi @ 1831

Last change on this file since 1831 was 1831, checked in by bruno, 12 years ago

Fix a label bug where the variable label should also be re-initialized at each loop

  • Property svn:keywords set to Rev Id
File size: 125.3 KB
Line 
1#!/bin/bash
2
3# $Id: mindi 1831 2007-12-02 00:36:04Z 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)
16ARCH=`/bin/uname -m`
17
18ADDITIONAL_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
25RUN_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
30MINDI_REV=PBREV
31MINDI_VER=PBVER
32
33MINDI_VERSION=${MINDI_VER}-r$MINDI_REV
34MINDI_PREFIX=XXX
35MINDI_CONF=YYY
36MINDI_SBIN=${MINDI_PREFIX}/sbin
37MINDI_LIB=LLL
38
39# Temporary directory for mindi
40TMPDIR=/tmp
41
42EXTRA_SPACE=32768       # increase if you run out of ramdisk space
43BOOT_SIZE=16384         # size of the boot disk
44MAX_DISKS=99
45WRITE_BOOT_FLOPPIES="yes"   # do you want to be propted to write floppy images
46PROMPT_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
51PROMPT_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
55PROMPT_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
59USE_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
64MY_FSTAB=/etc/fstab
65FLOPPY_MODS="ide-floppy floppy"
66TAPE_MODS="ht st osst ide-tape ide_tape"
67SCSI_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
70IDE_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"
71PCMCIA_MODS="pcmcia_core ds yenta_socket"
72USB_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"
73CDROM_MODS="$TAPE_MODS $FLOPPY_MODS $IDE_MODS af_packet cdrom isocd isofs inflate_fs nls_iso8859-1 nls_cp437 sg sr_mod zlib_inflate $USB_MODS $PCMCIA_MODS"
74NET_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"
75EXTRA_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"
78DENY_MODS="kqemu"
79# Force some modules to be included
80FORCE_MODS=""
81
82LOGFILE=/var/log/mindi.log
83FDDEVICE=/dev/fd0             ; # 1.44MB floppy #0
84CACHE_LOC=/var/cache/mindi
85FORCE_DUAL_FLOPPIES=no
86BOOT_MEDIA_MESSAGE="\
87To format and restore all files automatically, type 'nuke' <enter>.\n\
88To restore some/all files interactively, type 'interactive' <enter>.\n\
89To compare the archives with your filesystem, type 'compare' <enter>.\n\
90To boot to a command-line prompt (expert mode), type 'expert' <enter>.\n\
91You 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\
98e.g. Type 'nuke donteject textonly' if you have an unstable Newt library and \n\
99a PC whose CD-ROM drive tray would be damaged if it unexpectedly ejected.\n\
100"
101FDISK=$MINDI_SBIN/parted2fdisk
102
103# Using a config file allow to overwrite some values
104MINDI_CONFIG="$MINDI_CONF/mindi.conf"
105if [ -f $MINDI_CONFIG ]; then
106    . $MINDI_CONFIG
107fi
108
109# Now we can create what we need
110export MINDI_TMP=`mktemp -d $TMPDIR/mindi.XXXXXXXXXX`
111mkdir -p $MINDI_TMP
112
113# Purge from potential old run
114rm -rf $CACHE_LOC/* 2> /dev/null
115mkdir -p $CACHE_LOC
116# ----------------------------------------------------------------------------
117
118
119AbortHere() {
120    [ "$mountpoint" ] && umount $mountpoint 2>> $LOGFILE
121    Die "Program is terminating in response to signal received from OS/user"
122}
123
124
125HackSyslinuxFile() {
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
142Aborted() {
143    trap SIGHUP SIGTERM SIGTRAP SIGINT
144    [ "$CACHE_LOC" != "" ] && rm -f $CACHE_LOC/mindi*img $CACHE_LOC/*gz $CACHE_LOC/mindi.iso
145    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
146    Die "User abort."
147}
148
149
150AddFileToCfgIfExists() {
151    [ -e "$1" ] && echo -en "$2 `cat $1`\n" >> $3
152}
153
154
155AddFileToDir() {
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
200AddKeyboardMappingFile() {
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
244ChopUpAndCopyFile() {
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
277CopyBootBFile() {
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
303CopyDependenciesToDirectory() {
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
348CopyImageToDisk() {
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
381CountItemsIn() {
382    local r
383    r=0
384    for q in $1 ; do
385        r=$(($r+1))
386    done
387    echo $r
388}
389
390
391CreateDataDiskImagesFromTarballs() {
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
413CreateOneDataDiskImage() {
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
439MindiExit() {
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
463Die() {
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
478DropOptimizedLibraries() {
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
512FindAndAddUserKeyboardMappingFile() {
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=$(locate */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
612FindIsolinuxBinary() {
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=`locate 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
625FindLiloBinary() {
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
640FindSensibleBootBFile() {
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
654FindSpecificModuleInPath() {
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
676GenerateGiantDependencyList() {
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
835GenerateListForFile() {
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
850GetAllRaidMembers() {
851    $AWK "/^[[:space:]]*#/ {next} /^[[:space:]]*device/ if(\$2) {print \$2}" < /etc/raidtab
852}
853
854
855GetFileSizeList() {
856    local i
857    for i in `find $1 -type d -o -print` ; do
858        du -sk $i
859    done
860}
861
862
863GetHomeDir() {
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
875GetInitrdFilesystemToUse() {
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)
937GetParentRaidDev() {
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...)
944GetRaidDevMembers() {
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
949HackPathsToFailsafe() {
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
967ListAllPartitions() {
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
980ListImagesForUser() {
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
991ListKernelModulePaths() {
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#
1027LocateDeps() {
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
1052ReadAllLink() {
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
1074LocateFile() {
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
1105LogIt() {
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
1116MakeMondoConfigFile() {
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
1159MakeModuleLoadingScript() {
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
1228MakeMountlist() {
1229    local scratchdir mountlist all_partitions current_partition \
1230partition_size partition_format outstring partition_number \
1231partition_mountpt c_p lwm_info psz lvm_dev unofficial_outstring \
1232absolute_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/c*d* ! -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
1558MakeSureNumberIsInteger() {
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
1567MakeSyslinuxMessageFile() {
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 " \
1591To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1592CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n" >> $1
1593    fi
1594}
1595
1596
1597MoveHyperlinkSensibly() {
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
1626OfferToCopyImagesToDisks() {
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
1655OfferToMakeBootableISO() {
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
1722OfferToMakeBootableUSB() {
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
1758d
1759d
1760d
1761d
1762n
1763p
17641
1765
1766
1767t
1768b
1769a
17701
1771w
1772EOF
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
1848PluralOrNot() {
1849    [ "$1" -gt "1" ] && echo -en "s"
1850}
1851
1852
1853MakeMessageFile() {
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 "\
1876To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1877CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n"
1878    fi
1879    echo -en "\n\n\n"
1880}
1881
1882
1883write_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
1936MakeLiloConfFile() {
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
2013PrepareBootDiskImage_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\
2110Sorry, 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
2182PrepareBootDiskImage_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\
2250Sorry, 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
2297PrepareDataDiskImages() {
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
2416ProcessLDD() {
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
2446Prompt() {
2447    echo -en "$1"
2448    read line
2449}
2450
2451
2452ReadLine() {
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
2464RejigHyperlinks() {
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
2485ReplaceIndividualLine() {
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
2510ScanCDandTape() {
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
2519SizeOfPartition() {
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
2538SizeOfRaidPartition() {
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
2559StripComments()
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
2571SplitDirectoryIntoMinidirs() {
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
2590StripExecutable()
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
2606TemporarilyCompressAllFiles() {
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
2625TryToFindKernelPath() {
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
2722TryToFitDataIntoSeveralDirs() {
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
2772TurnTgzIntoRdz() {
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
3039WhichOfTheseModulesAreLoaded() {
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
3048ZipMinidirsIntoTarballs() {
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
3093echo "mindi v$MINDI_VERSION" >> $LOGFILE
3094echo "$ARCH architecture detected" >> $LOGFILE
3095echo "mindi called with the following arguments:" >> $LOGFILE
3096echo "$@" >> $LOGFILE
3097echo "Start date : `date`" >> $LOGFILE
3098echo "-----------------------------" >> $LOGFILE
3099
3100if [ -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
3103fi
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."
3108echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
3109echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
3110[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
3111echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
3112echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
3113
3114trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
3115
3116# Sanity checks
3117which which > /dev/null 2> /dev/null || Die "Please install 'which'."
3118which strings > /dev/null 2> /dev/null || Die "Please install binutils and libbinutils; you have no 'strings' executable."
3119which 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."
3120which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` || AWK="`which awk 2>/dev/null`"
3121if 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
3125fi
3126which 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.
3137if [ -d "/etc/modprobe.d" ] && [ "`uname -r | cut -c1-3`" = "2.6" ] ; then
3138    TMPMODPROBE_FLAG="Y"
3139else
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..."
3143fi
3144
3145# Update the PATH variable if incomplete
3146if [ -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
3152fi
3153
3154[ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null | grep -E "2\.[46]" | cut -d' ' -f1`
3155
3156if ! 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?"
3158fi
3159
3160### BERLIOS
3161### Fix as it's not mandatory on ia64
3162if [ "$ARCH" = "ia64" ] ; then
3163    if which elilo &> /dev/null ; then
3164        LILO_EXE=elilo
3165    else
3166        LILO_EXE=`which false`
3167    fi
3168else
3169    FindIsolinuxBinary
3170    FindLiloBinary
3171fi
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
3174trap "Aborted" SIGTERM
3175DONE="\r\t\t\t\t\t\t\t\tDone.         "
3176CHOPSIZE=240
3177BIGNO=0
3178MAX_COMPRESSED_SIZE=1300
3179kernelpath=""
3180MONDO_ROOT=/var/cache/mondo
3181mkdir -p $MONDO_ROOT
3182
3183if [ -d "/proc/lvm" ]; then
3184    # LVM v1
3185    LVMCMD=""
3186    LVM="v1"
3187elif [ -d "/dev/mapper" ]; then
3188    # LVM v2
3189    LVMCMD="lvm"
3190    LVM="v2"
3191else
3192    LVM="false"
3193fi
3194echo "LVM set to $LVM" >> $LOGFILE
3195echo "----------" >> $LOGFILE
3196echo "mount result:" >> $LOGFILE
3197echo "-------------" >> $LOGFILE
3198mount >> $LOGFILE
3199echo "-------------" >> $LOGFILE
3200if [ -e /etc/raidtab ]; then
3201    echo "-------------" >> $LOGFILE
3202    echo "/etc/raidtab content:" >> $LOGFILE
3203    echo "-------------" >> $LOGFILE
3204    cat /etc/raidtab >> $LOGFILE
3205fi
3206echo "-------------" >> $LOGFILE
3207echo "cat /proc/cmdline:" >> $LOGFILE
3208echo "-------------" >> $LOGFILE
3209cat /proc/cmdline >> $LOGFILE
3210echo "-------------" >> $LOGFILE
3211echo "lsmod result:" >> $LOGFILE
3212echo "-------------" >> $LOGFILE
3213lsmod >> $LOGFILE
3214MODULES="`cat /proc/modules | awk '{print $1}'`"
3215if [ -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}'`"
3223fi
3224echo "-------------" >> $LOGFILE
3225echo "df result:" >> $LOGFILE
3226echo "----------" >> $LOGFILE
3227df -T >> $LOGFILE
3228echo "-------------" >> $LOGFILE
3229echo "Liste of extra modules is:" >> $LOGFILE
3230echo "$EXTRA_MODS" >> $LOGFILE
3231echo "-------------" >> $LOGFILE
3232
3233# Compute libata version
3234laver=`modinfo libata | grep -Ei '^Version:' | cut -d: -f2 | cut -d. -f1 | sed 's/  *//g' 2> /dev/null`
3235# If libata v2 is used then remove ide-generic as it will perturbate boot
3236if [ "`echo $MODULES | grep libata`" ]; then
3237    if [ "$laver" = "2" ]; then
3238        DENY_MODS="$DENY_MODS ide-generic"
3239        echo "ide-generic removed from module list as your system uses libata v2+" >> $LOGFILE
3240        echo "-------------" >> $LOGFILE
3241    fi
3242fi
3243
3244if [ "$#" -ge "2" ] ; then
3245    if [ "$1" = "--max-compressed-size" ] ; then
3246        MAX_COMPRESSED_SIZE=$2
3247        shift; shift
3248    fi
3249fi
3250
3251FLOPPY_WAS_MOUNTED=""
3252for mtpt in /media/floppy /mnt/floppy /floppy ; do
3253    if mount | grep -w $mtpt &> /dev/null ; then
3254        FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
3255        umount $mtpt
3256    fi
3257done
3258
3259#
3260# If we have a USB device we need to store info
3261# and remove it from the parameters line
3262#
3263if [ "$#" -ne "0" ] ; then
3264    if [ "$1" = "--usb" ] ; then
3265        shift
3266        USBDEVICE=$1
3267        if [ _"$USBDEVICE" = _"" ]; then
3268            Die "No USB device specified"
3269        fi
3270        shift
3271    fi
3272fi
3273
3274if [ "$#" -ne "0" ] ; then
3275    if [ "$1" = "--findkernel" ] ; then
3276        res=`TryToFindKernelPath`
3277        # Avoids logfile content for mondo
3278        export MONDO_SHARE=""
3279        if [ "$res" = "" ] ; then
3280            MindiExit -1
3281        else
3282            echo "$res"
3283            MindiExit 0
3284        fi
3285    elif [ "$1" = "--locatedeps" ] ; then
3286        [ ! "$2" ] && Die "Please specify the binary to look at"
3287        LocateDeps $2
3288        # Avoids logfile content for mondo
3289        export MONDO_SHARE=""
3290        MindiExit $?
3291    elif [ "$1" = "--readalllink" ] ; then
3292        [ ! "$2" ] && Die "Please specify the binary to look at"
3293        ReadAllLink $2
3294        # Avoids logfile content for mondo
3295        export MONDO_SHARE=""
3296        MindiExit $?
3297    elif [ "$1" = "--makemountlist" ] ; then
3298        [ ! "$2" ] && Die "Please specify the output file"
3299        MakeMountlist $2
3300        # Avoids logfile content for mondo
3301        export MONDO_SHARE=""
3302        MindiExit $?
3303    elif [ "$1" = "-V" ] || [ "$1" = "-v" ] || [ "$1" = "--version" ] || [ "$1" = "-version" ] ; then
3304        echo "Mindi v$MINDI_VERSION"
3305        # Avoids logfile content for mondo
3306        export MONDO_SHARE=""
3307        MindiExit 0
3308    elif [ "$#" -ge "9" ] && [ "$1" = "--custom" ] ; then
3309        MONDO_TMP=$2
3310        # Change MINDI_TMP for the one provided by mondo
3311        # So that it can get back the built files
3312        mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
3313        rmdir $MINDI_TMP
3314        export MINDI_TMP=$MONDO_TMP
3315        mkdir -p $MINDI_TMP
3316        # This is the scratch dir in mondo - subdir images
3317        CACHE_LOC=$3
3318        if [ _"$CACHE_LOC" != _"" ]; then
3319            mkdir -p $CACHE_LOC
3320        fi
3321        kernelpath=$4; [ "$kernelpath" = "(null)" ] && kernelpath=""
3322###
3323### Sq-Modification...
3324### Attempt to locate kernel specific module path
3325### if module path is found then use it other wise use uname -r to set it...
3326###
3327        kernelname=`echo $kernelpath | cut -d'-' -f2-`
3328        LogIt "kernelname = $kernelname"
3329        LogIt "kernelpath = $kernelpath"
3330        if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
3331        then
3332           LogIt "Module path for ${kernelpath} not found..."
3333           LogIt "using running kernel\'s modules."
3334           kernelname=`uname -r`
3335        else
3336           LogIt "Using modules for kernel: ${kernelname}"
3337        fi
3338###
3339### end of Sq-Modification
3340###
3341        TAPEDEV=$5
3342        TAPESIZE=$6
3343        FILES_IN_FILELIST=$7
3344        USE_LZO=$8
3345        CDRECOVERY=$9
3346        if [ "${10}" = "(null)" ] || [ "${10}" = "" ] ; then
3347            IMAGE_DEVS=""
3348        else
3349            IMAGE_DEVS="`echo "${10}" | tr '|' ' '`"
3350        fi
3351        if [ "${11}" ] ; then
3352            LILO_OPTIONS=""
3353    #       LogIt "LILO will use conservative settings, to be compatible with older BIOSes."
3354        fi
3355        LAST_FILELIST_NUMBER=${12}
3356        ESTIMATED_TOTAL_NOOF_SLICES=${13}
3357        EXCLUDE_DEVS="${14}"
3358        USE_COMP="${15}"
3359        USE_LILO="${16}"
3360        USE_STAR="${17}"
3361        INTERNAL_TAPE_BLOCK_SIZE="${18}"
3362        DIFFERENTIAL="${19}"
3363        USE_GZIP="${20}"
3364        NOT_BOOT="${21}"
3365        [ "$USE_COMP" = "" ] && USE_COMP=yes
3366        [ "$USE_GZIP" = "" ] && USE_GZIP=no
3367        [ "$NOT_BOOT" = "" ] && NOT_BOOT=no
3368        [ "$TAPEDEV" ] && LogIt "This is a tape-based backup. Fine."
3369        [ "$kernelpath" = "" ] && kernelpath=`TryToFindKernelPath`
3370        kernelname=`echo $kernelpath | cut -d'-' -f2-`
3371        if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
3372        then
3373           LogIt "Module path for ${kernelpath} not found..."
3374           LogIt "using running kernel\'s modules."
3375           kernelname=`uname -r`
3376        else
3377           LogIt "Using modules for kernel: ${kernelname}"
3378        fi
3379        [ "$CDRECOVERY" = "yes" ] && [ "$TAPEDEV" != "" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
3380        # MONDO_ROOT is the real scratchdir
3381        MONDO_ROOT=`echo $CACHE_LOC | sed 's/\(.*\)\/.*/\1/'`
3382        if [ _"$MONDO_ROOT" != _"" ]; then
3383            mkdir -p $MONDO_ROOT
3384        else
3385            Die "MONDO_ROOT is undefined"
3386        fi
3387    else
3388        echo "Syntax: mindi (--custom ....)" >> /dev/stderr
3389        MindiExit -1
3390    fi
3391fi
3392#ScanCDandTape
3393[ "$CDRECOVERY" = "yes" ] || CDRECOVERY=no
3394if [ "$CDRECOVERY" = "yes" ] ; then
3395    iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
3396    sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
3397else
3398    iso_cfg_file=$MINDI_LIB/isolinux.cfg
3399    sys_cfg_file=$MINDI_LIB/syslinux.cfg
3400fi
3401
3402[ -e "$iso_cfg_file" ] || Die "Cannot find $iso_cfg_file"
3403if [ _"$MONDO_SHARE" = _"" ]; then
3404    LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
3405    LogIt "Latest Mindi is available from http://www.mondorescue.org"
3406    LogIt "BusyBox sources are available from http://www.busybox.net"
3407    LogIt "------------------------------------------------------------------------------"
3408else
3409    echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> $LOGFILE
3410fi
3411if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
3412    LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 | head -1`"
3413else
3414    LogIt "Unable to find mindi-busybox, please install it"
3415    MindiExit -1
3416fi
3417
3418# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
3419insmod /lib/modules/`uname -r`/*/*/misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
3420for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
3421    insmod $i >> $LOGFILE 2>> $LOGFILE
3422done
3423
3424KERN_DISK_MADE=""
3425
3426echo "DIFFERENTIAL = $DIFFERENTIAL" >> $LOGFILE
3427echo "INTERNAL TAPE BLOCK SIZE = $INTERNAL_TAPE_BLOCK_SIZE" >> $LOGFILE
3428echo "NOT_BOOT = '$NOT_BOOT'" >> $LOGFILE
3429if [ "$NOT_BOOT" != "" ] && [ "$NOT_BOOT" != "0" ] && [ "$NOT_BOOT" != "no" ] ; then
3430    LogIt "Just creating mondo-restore.cfg and a small all.tar.gz for Mondo. Nothing else."
3431    MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
3432    MakeMountlist $MINDI_TMP/mountlist.txt
3433    mkdir -p $MINDI_TMP/small-all/tmp
3434    cd $MINDI_TMP/small-all
3435    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"
3436    tar -cv tmp | gzip -9 > $MINDI_TMP/all.tar.gz || Die "Cannot make small all.tar.gz"
3437    sleep 2
3438    LogIt "Done. Exiting."
3439    MindiExit 0
3440fi
3441
3442if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
3443    LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
3444fi
3445
3446if [ "$kernelpath" = "" ] ; then
3447    [ _"$MONDO_SHARE" != _"" ] && Die "Please use -k <path> to specify kernel."
3448    echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
3449    read ch
3450    if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
3451        USE_OWN_KERNEL="yes"
3452    else
3453        USE_OWN_KERNEL="no"
3454    fi
3455    if [ "$USE_OWN_KERNEL" = "yes" ]; then
3456        YOUR_KERNEL_SUCKS=""
3457        kernelpath=`TryToFindKernelPath`
3458        if [ "$kernelpath" = "" ] ; then
3459            echo -n "Please enter kernel path : "
3460            read kernelpath
3461        fi
3462    else
3463        YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
3464    fi
3465fi
3466if [ _"$MONDO_SHARE" = _"" ] && [ "$ARCH" != "ia64" ]; then
3467    echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/[n]) ?"
3468    read ch
3469    if [ "$ch" != "y" ] && [ "$ch" != "Y" ] ; then
3470        USE_LILO=no
3471    else
3472        USE_LILO=yes
3473    fi
3474fi
3475if [ "$YOUR_KERNEL_SUCKS" != "" ] || [ "$kernelpath" = "" ] || [ "$kernelpath" = "SUCKS" ] || [ "$kernelpath" = "FAILSAFE" ] ; then
3476    kernelpath=$MINDI_LIB/vmlinuz
3477    LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
3478    LogIt "However, you are still running your kernel. If Mindi fails to create your"
3479    LogIt "disks then it may still be a result of a problem with your kernel."
3480    pwd=`pwd`
3481    cd $MINDI_TMP
3482    bzip2 -dc $MINDI_LIB/lib.tar.bz2 | tar -x || Die "Cannot unzip lib.tar.bz2"
3483    cd $pwd
3484    YOUR_KERNEL_SUCKS="Your kernel sucks"
3485fi
3486echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$CACHE_LOC" >> $LOGFILE
3487[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
3488
3489[ "$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."
3490
3491PrepareDataDiskImages $CACHE_LOC
3492noof_disks=$?
3493ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
3494rds=$(($ramdisk_size-$((ramdisk_size%4096))))
3495ramdisk_size=$rds
3496
3497echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
3498if [ "$ARCH" = "ia64" ] ; then
3499    PrepareBootDiskImage_LILO $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create ia64 floppy disk image."
3500else
3501    if [ "$USE_LILO" = "yes" ] ; then
3502        if ! PrepareBootDiskImage_LILO $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
3503            LogIt "WARNING - failed to create 1.72MB boot image."
3504            LogIt "Please reduce your kernel's size if you want to make a 1.72MB floppy disk."
3505        fi
3506        if ! PrepareBootDiskImage_LILO $CACHE_LOC 2880 $kernelpath $ramdisk_size ;  then
3507            LogIt "WARNING - failed to create 2.88MB floppy disk image."
3508            LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3509            PrepareBootDiskImage_LILO $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create 2.88MB floppy disk image."
3510        fi
3511    else
3512        if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
3513            LogIt "WARNING - failed to create 1.72MB boot image."
3514            LogIt "Please reduce your kernel's size if you want to make a 1.72MB floppy disk."
3515            if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 2880 $kernelpath $ramdisk_size ; then
3516                LogIt "WARNING - failed to create 2.88MB floppy disk image."
3517                LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3518                PrepareBootDiskImage_SYSLINUX $CACHE_LOC $BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create $BOOT_SIZE kB floppy disk image."
3519            fi
3520        fi
3521    fi
3522fi
3523
3524[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
3525...Or type 'memtest' to test your PC's RAM thoroughly.\n"
3526
3527if [ _"$MONDO_SHARE" = _"" ]; then
3528    ListImagesForUser $CACHE_LOC
3529    boot_dev=/dev/fd0u1722
3530    [ ! -e "$boot_dev" ] && mknod $boot_dev b 2 60
3531    [ ! -e "$boot_dev" ] && boot_dev=/dev/fd0H1722
3532    [ ! -e "$boot_dev" ] && Die "Oh Lord, will you PLEASE tell the vendor to create the 1.72MB devices in /dev?"
3533    if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
3534        OfferToCopyImagesToDisks $CACHE_LOC $boot_dev $FDDEVICE
3535    fi
3536    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3537        OfferToMakeBootableUSB $CACHE_LOC
3538    fi
3539    OfferToMakeBootableISO $CACHE_LOC
3540    LogIt "Finished."
3541elif [ "$TAPEDEV" ] ; then
3542    OfferToMakeBootableISO $CACHE_LOC
3543    if [ -e "$CACHE_LOC/all.tar.gz" ] ; then
3544        cp -f $CACHE_LOC/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
3545    else
3546        Die "Cannot find all.tar.gz, to be written to tape"
3547    fi
3548elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ] && [ "$USBDEVICE" != "" ]; then
3549    OfferToMakeBootableUSB $CACHE_LOC
3550else
3551    OfferToMakeBootableISO $CACHE_LOC
3552fi
3553# cleanup
3554LogIt "$FRIENDLY_OUTSTRING"
3555for mtpt in $FLOPPY_WAS_MOUNTED ; do
3556    mount $mtpt
3557done
3558MindiExit 0
Note: See TracBrowser for help on using the repository browser.