source: branches/stable/mindi/mindi @ 949

Last change on this file since 949 was 949, checked in by Bruno Cornec, 13 years ago

Should fix #63, , and add the required interface in mondorestore to handle the new way of dealing with ACLs and XATTRs

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