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

Last change on this file since 948 was 948, checked in by Bruno Cornec, 14 years ago
  • mondoarchive does not backup acl+xattr by default anymore
  • Add -z option to mondoarchive to support acl+xattr backup
  • small mindi fix
  • this may break mondo compatibility so tests are required before distributing that version.
  • this is still incomplete as that aprameter should be passed for mondorestore to know what to do.
  • Property svn:keywords set to Rev Id
File size: 104.8 KB
Line 
1#!/bin/bash
2
3# $Id: mindi 948 2006-11-19 00:27:46Z 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}
1096
1097
1098MakeModuleLoadingScript() {
1099    local module fname params modpath kver outerloop i modpaths kver searchpath list_to_echo j
1100    tmpmodprobe_flag=$1
1101    outfile=$2
1102    > $outfile || Die "Cannot create empty $outfile"
1103    echo -en "#\041/bin/sh\n\n" >> $outfile
1104    echo "echo -en \"Loading your modules...\"" >> $outfile
1105    if [ "$YOUR_KERNEL_SUCKS" ] ; then
1106        kver=$FAILSAFE_KVER
1107        cd $MINDI_TMP
1108        searchpath=lib/modules/$kver
1109    else
1110###
1111### Sq-Modification ... Use kernelname for module search path if specified
1112###
1113        #kver=`uname -r`
1114        if [ "${kernelname}" != "" ]
1115        then
1116            kver=${kernelname}
1117        else
1118            kver=`uname -r`
1119        fi
1120###
1121### Sq-Modification end
1122###
1123        searchpath=/lib/modules/$kver
1124    fi
1125   
1126    echo -en "for outerloop in 1 2 3 4 5 ; do\necho -en \".\"\n" >> $outfile
1127    list_to_echo="`lsmod | sed -n '2,$s/ .*//p'`"
1128
1129    # Make temporary modprobe.conf file if we are told so
1130    if [ $tmpmodprobe_flag == "Y" ] ; then
1131        infile="$MINDI_TMP/modprobe.conf.mindi"
1132        find /etc/modprobe.d -maxdepth 1 -name "*" -xtype f -print0 | xargs -0 cat > $infile
1133    else
1134        infile="/etc/modules.conf"
1135    fi
1136    for module in $list_to_echo $EXTRA_MODS ; do
1137        params=`sed -n "s/^options \\+$module \\+//p" $infile`
1138        modpaths=`FindSpecificModuleInPath $searchpath $module`
1139        for i in $modpaths ; do
1140            echo "MyInsmod $i $params > /dev/null 2> /dev/null" \
1141                | tr '.' '#' \
1142                | sed s/#o#gz/#o/ \
1143                | sed s/#o#gz/#o/ \
1144                | sed s/#ko#gz/#ko/ \
1145                | sed s/#ko#gz/#ko/ \
1146                | tr '#' '.' >> $outfile
1147            echo -en "$i added to module list.\n" >> $LOGFILE
1148        done
1149    done
1150    echo -en "done\n" >> $outfile
1151    echo "echo \"Done.\"" >> $outfile
1152    chmod +x $outfile
1153    cd /
1154    # Remove temporary modprobe.conf file if we have created one
1155    if [ $tmpmodprobe_flag == "Y" ] ; then
1156        rm -f $infile
1157    fi
1158}
1159
1160
1161MakeMountlist() {
1162    local scratchdir mountlist all_partitions current_partition \
1163partition_size partition_format outstring partition_number \
1164partition_mountpt c_p lwm_info psz lvm_dev unofficial_outstring \
1165absolute_partition old_partition_fmt current_lvolume
1166
1167    echo "Your raw fstab file looks like this:-" >> $LOGFILE
1168    cat $MY_FSTAB >> $LOGFILE
1169    echo "Your mountlist will look like this:-"
1170
1171# scratchdir, mountlist(OUT)
1172    scratchdir=$MINDI_TMP
1173    mountlist=$1
1174
1175# NB: partition = device
1176# NB: mountpt = where the device is mounted
1177
1178    [ -e "$MY_FSTAB" ] || Die "Cannot find your fstab file ($MY_FSTAB)"
1179
1180    rm -f $mountlist
1181    mkdir -p $mountlist
1182    rm -Rf $mountlist
1183    > $mountlist
1184    echo -en "\rHang on...\r"
1185    all_partitions=""
1186   
1187    if [ $LVM != "false" ]; then
1188        echo -en "\rAnalyzing LVM...\r"
1189        all_partitions=`$MINDI_LIB/analyze-my-lvm | grep -F ">>>" | cut -d' ' -f2-32`
1190    fi
1191    all_partitions="$all_partitions `ListAllPartitions 2> /dev/null`"
1192#    echo "all partitions = $all_partitions" > /dev/stderr
1193    for i in $IMAGE_DEVS ; do
1194        mount | grep -F "$i " > /dev/null 2> /dev/null && Die "Sorry, $i is already mounted! CANNOT DO IMAGEDEV on it if it's mounted."
1195    done
1196    [ "$IMAGE_DEVS" != "" ] && all_partitions="`echo "$all_partitions $IMAGE_DEVS" | tr ' ' '\n' | sort -u | tr '\n ' ' '`"
1197    printf "        %-15s %-15s %-15s %-15s %-15s\n" DEVICE MOUNTPOINT FORMAT "SIZE (MB)" LABEL
1198    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"
1199    for c_p in $all_partitions ; do
1200        [ "`echo "$useless_dev" | grep -F "$c_p"`" != "" ] || [ "`echo "$c_p" | grep ":"`" != "" ] && continue
1201        [ "`echo "$c_p" | grep -x "/dev/cdroms.*"`" ] && continue
1202        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
1203            current_partition=`readlink -f $c_p`
1204            [ "`echo "$current_partition" | grep -F "/dev/mapper"`" != "" ] && current_partition="$c_p"
1205            [ "`echo "$useless_dev" | grep -F "$current_partition"`" ] && continue
1206        else
1207            current_partition="$c_p"
1208        fi
1209        [ "$c_p" = "none" ] && continue
1210        redhat_label=""
1211        absolute_partition=`readlink -f $c_p`
1212        partition_mountpt=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $2}' | head -n1`
1213
1214        # Detects noauto partitions not mounted and exclude them
1215        partition_option=`tr -s '\t' ' ' < $MY_FSTAB | /bin/grep -w "$current_partition" | /bin/grep -vx " *#.*" | $AWK '{print $4}' | head -n1`
1216        if [ "`echo "$partition_option" | grep -i noauto`" != "" ] && [ "`mount | grep -w "$partition_mountpt"`" =  "" ] ; then
1217            continue
1218        fi
1219
1220        # This part tries to retrieve the correct device from a LABEL line in /etc/fstab
1221        # current_partition contains only first column of /etc/fstab
1222        if [ "`echo "$current_partition" | /bin/grep -i "LABEL="`" != "" ]; then
1223            str_to_find_fmt_with=$current_partition
1224            redhat_label=`echo "$current_partition" | /bin/cut -d'=' -f2`
1225            actual_dev=""
1226
1227            # 1st try, findfs - the RHEL way of finding labels and their partitions
1228            if [ -x "/sbin/findfs" ]; then
1229                actual_dev=`/sbin/findfs LABEL=${redhat_label} 2> /dev/null`
1230            fi
1231   
1232            # 2nd try : blkid, the good way for all LABEL except swap
1233            if [ "x$actual_dev" = "x" -a -x "/sbin/blkid" ]; then
1234                actual_dev=`/sbin/blkid | /bin/grep "$redhat_label" | grep LABEL= | /bin/cut -d':' -f1`
1235                # For LVM FS it will give a /dev/dm-# which should then be converted
1236                if [ $LVM = "v2" ] && [ "`echo $actual_dev | grep '/dev/dm'`" ]; then
1237                    major=`/bin/ls -l $actual_dev | awk '{print $5}'`
1238                    minor=`/bin/ls -l $actual_dev | awk '{print $6}'`
1239                    for dev in `ls /dev/mapper/*`; do
1240                        major1=`/bin/ls -l $dev | awk '{print $5}'`
1241                        minor1=`/bin/ls -l $dev | awk '{print $6}'`
1242                        if [ $major1 = $major ] && [ $minor1 = $minor ]; then
1243                            actual_dev=`/bin/ls -l $dev | awk '{print $10}'`
1244                            break
1245                        fi
1246                    done
1247                fi
1248            fi
1249   
1250            # 3rd try, which works on a standard partition (ext2/3), but not on swap
1251            # For LVM gives a /dev/mapper entry
1252            if [ "x$actual_dev" = "x" ]; then
1253                actual_dev=`/bin/mount -l | /bin/grep "\[$redhat_label\]" | /bin/cut -d' ' -f1`
1254            fi
1255   
1256            # 4th try, with vol_id
1257            # SWAP only
1258            if [ "x$actual_dev" = "x" -a -x "/sbin/vol_id" ]; then
1259                list_swaps=`cat /proc/swaps | /bin/grep "/dev/" | /bin/awk '{ print $1 }' `
1260                for dev_swap in $list_swaps ; do
1261                    dev_exists=`/sbin/vol_id $dev_swap | /bin/grep "$redhat_label"`
1262                    if [ "x$dev_exists" != "x" ]; then
1263                        actual_dev=$dev_swap
1264                        break;
1265                    fi
1266                done
1267            fi
1268
1269            # 5th try : pre-formated LABEL. Format is : LABEL=SWAP-mydevice or SW-mydevice. e.g. : LABEL=SWAP-hda5
1270            # LABEL=SW-cciss/c0d0p3 (RDP)
1271            # or could be a string that isn't a complete device name (eg. LABEL =SWAP-cciss/c0d0p)
1272            # SWAP only
1273            if [ "x$actual_dev" = "x" -a  _"`echo $current_partition | /bin/grep -iE 'LABEL=SWAP|LABEL=SW-'`" != _"" ]; then
1274                    for try_dev in `tail +2 /proc/swaps | cut -d' ' -f1`
1275                    do
1276                        # Location of the swap label for kernel 2.6
1277                        try_dev_label=`dd bs=1 count=16 skip=1052 if=$try_dev 2> /dev/null`
1278                        if [ "x$try_dev_label" = "x$redhat_label" ]; then
1279                            actual_dev=$try_dev
1280                        fi
1281                    done
1282            fi
1283
1284            # Check if one of all those tries has known success
1285            if [ "x$actual_dev" != "x" ]; then
1286                current_partition=$actual_dev
1287            else
1288                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"
1289            fi
1290        else
1291            str_to_find_fmt_with=$current_partition
1292        fi
1293
1294        partition_format=`$AWK '$1 == "'"$str_to_find_fmt_with"'" {print $3}' $MY_FSTAB`
1295        # Some distributions such as Debian do not put /dev/<VG>/<LV> in fstab
1296        # for LVM partitions but use /dev/mapper/<VG>-<LV> instead. Fortunately,
1297        # the former is then a link to the latter, so we test whether
1298        # $current_partition is actually such a link or not and set
1299        # $current_lvolume accordingly. On Debian you may find more than one answer
1300        # so we remove the one corresponding to /dev/.static
1301        # On RedHat even if the device name is different (/dev/mapper/<VG><LV>), the
1302        # principle is the same and we need to find the link to it as well.
1303        # Note that $current_lvolume may well be an
1304        # ordinary device. It is just to make sure that we feed the right value
1305        # into any of the LVM tools if possible.
1306
1307        current_lvolume="$current_partition"
1308        if [ $LVM = "v2" ] && [ "`echo $current_partition | grep -E '^/dev/mapper/'`" ]; then
1309            # .static dir are a Debian specificity
1310            current_lvolume="`find /dev -lname "$current_partition" | grep -Ev '^/dev/\.static/'`"
1311            echo $current_lvolume | grep -q ' '
1312            if [ $? -eq 0 ]; then
1313                echo "WARNING: Multiple Logical Volumes found. Report to dev team" >> $LOGFILE 
1314            fi
1315        fi
1316        #
1317        # End of LVM device style variation code (other than $current_lvolume).
1318
1319        if [ $LVM != "false" ] && [ "`$LVMCMD lvdisplay $current_lvolume 2> /dev/null`" ]; then
1320            # Size computed via LVM not directly
1321            partition_size="lvm"
1322        else
1323            partition_size=`SizeOfPartition $current_partition`
1324            [ "`echo "$current_partition" | grep "[0-9]"`" = "" ] && continue
1325            [ "`echo "$current_partition" | grep -c "^/"`" -ne "1" ] && continue
1326            if [ "$partition_format" = "swap" ] || [ "$partition_mountpt" = "swap" ] ; then
1327                partition_size=`grep -Fv "Priority" /proc/swaps | tr -s '\t' ' ' | grep -F "$current_partition" | $AWK '{print $3}'`
1328                [ "$partition_mountpt" != "swap" ] && partition_mountpt="swap"
1329                [ "$partition_format" != "swap" ] && partition_format="swap"
1330                if [ "$partition_size" = "" ] ; then
1331                    totalsize=0
1332                    items=0
1333                    for i in `tr -s ' ' '\t' < /proc/swaps | grep -Fv "Filename" | cut -f3` ; do
1334                        totalsize=$(($totalsize+$i))
1335                        items=$(($items+1))
1336                    done
1337                    [ "$items" -gt "0" ] && partition_size=$(($totalsize/$items)) || partition_size=0
1338                    [ "$partition_size" -lt "125000" ] && partition_size=125000
1339                    echo "I'm guessing $c_p is $(($partition_size/1024))MB" >> $LOGFILE
1340                fi
1341            fi
1342        fi
1343        [ "$partition_mountpt" = "swap" ] && partition_format="swap"
1344        [ "$partition_format" = "swap" ] && partition_mountpt="swap"
1345        if [ "$partition_mountpt" = "" ] ; then
1346            if [ "`$LVMCMD pvdisplay $current_lvolume 2> /dev/null`" != "" ] ; then
1347                if  [ "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1348                    partition_mountpt="raid"
1349                    partition_format="raid"
1350                else
1351                    partition_mountpt="lvm"
1352                    partition_format="lvm"
1353                fi
1354            fi
1355        fi
1356        psz=$partition_size
1357        echo "Examining $current_partition (mount=$partition_mountpt fmt=$partition_format psz=$psz)" >> $LOGFILE
1358        [ "$psz" != "lvm" ] && psz=$(($psz/1024))
1359        if [ "`echo " $IMAGE_DEVS " | grep -F " $current_partition "`" != "" ] ; then
1360            partition_mountpt="image"
1361            old_partition_fmt=$partition_format
1362#           partition_format="`$FDISK -l 2>> $LOGFILE | tr -s '\t' ' ' | grep -w "$absolute_partition" | $AWK 'x=$(NF-1}'`"
1363            partition_format="`$FDISK -l 2>> $LOGFILE | tr '*' ' ' | tr '+' ' ' | tr -s ' ' '\t' | grep -w "$absolute_partition" | cut -f5`"
1364            echo "------- $FDISK -l log ------------" >> $LOGFILE
1365            cat $FDISKLOG >> $LOGFILE
1366            echo "------- $FDISK log end ------------" >> $LOGFILE
1367            partition_size=$(($partition_size+1)); # just in case
1368            if [ "$partition_format" = "Linux" ] ; then
1369                echo "Are you imaging a mounted swap partition? Silly..." >> $LOGFILE
1370                echo "Reverting format from $old_partition_fmt to $partition_format" >> $LOGFILE
1371                partition_format=$old_partition_fmt
1372            fi
1373        fi
1374        if [ "$EXCLUDE_DEVS" ] && [ "`echo " $EXCLUDE_DEVS " | grep -F " $current_partition "`" ] || [ "`echo " $EXCLUDE_DEVS " | grep " $current_partition "`" ] ; then
1375            echo "Excluding $current_partition from mountlist" >> $LOGFILE
1376            continue
1377        fi
1378        if [ ! "$partition_mountpt" ] ; then
1379            for qq in "" `find /dev/ida/c*d* ! -name '*p*'` ; do
1380                partition_format=`$FDISK -l $qq 2>> $LOGFILE | grep -w "$c_p" | sed 's/12/|/' | tr -s '\t' ' ' | cut -d'|' -f2 | cut -d' ' -f2-9`
1381                echo "------- $FDISK -l $qq log ------------" >> $LOGFILE
1382                cat $FDISKLOG >> $LOGFILE
1383                echo "------- $FDISK log end ------------" >> $LOGFILE
1384                [ "$partition_format" ] && break
1385            done
1386            if [ "$partition_format" = "Compaq diagnostics" ] ; then
1387                partition_format="compaq"
1388            elif [ ! "`grep -F device /etc/raidtab 2> /dev/null | grep -w $current_partition`" ] ; then
1389                LogIt "Unable to find mountpoint of $current_partition - ignoring\n"
1390                continue
1391            fi
1392        fi
1393        partition_format="`echo "$partition_format" | cut -d',' -f1`"; # in case user has ext3,ext2 or something dumb like that
1394        [ "$partition_format" = "auto" ] && partition_format="`mount | grep -w $current_partition | awk '{print$5;}'`"; # in case user uses 'auto' (dumb!)
1395        unofficial_outstring=`printf "\t%-15s %-15s %-15s %7s\n" $current_partition $partition_mountpt $partition_format $psz`
1396        if [ "$current_partition" = "" ] ; then
1397            echo "Unknown partition (outstring = $unofficial_outstring)" >> $LOGFILE
1398        elif [ "$partition_mountpt" = "" ] && [ -f "/etc/raidtab" ] ; then
1399            if [ "`grep -F device /etc/raidtab 2>/dev/null | grep -F $current_partition`" ] ; then
1400                partition_mountpt=raid
1401                partition_format=raid
1402                printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$redhat_label"
1403                printf "%s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$redhat_label" >> $mountlist
1404            else
1405                echo "Unknown mountpoint (outstring = $unofficial_outstring)" >> $LOGFILE
1406            fi
1407        elif [ "$partition_format" = "" ] ; then
1408            echo "Unknown format (outstring = $unofficial_outstring)" >> $LOGFILE
1409        elif [ "$partition_size" = "" ] ; then
1410            echo "Unknown partition size (outstring = $unofficial_outstring)" >> $LOGFILE
1411        elif [ "$partition_mountpt" = "/proc" ] || [ "$partition_mountpt" = "/dev/pts" ] ; then
1412            continue
1413        else
1414            if [ "$partition_format" = "dos" ] || [ "$partition_format" = "msdos" ] ; then
1415                echo "Stupid bastard..." >> $LOGFILE
1416                partition_format="vfat"
1417            fi
1418            printf "\t%-15s %-15s %-15s %7s %-15s\n" $current_partition $partition_mountpt $partition_format $psz "$redhat_label"
1419            printf "%s %s %s %s %s\n" $current_partition $partition_mountpt $partition_format $partition_size "$redhat_label" >> $mountlist
1420        fi
1421    done
1422}
1423
1424
1425MakeSureNumberIsInteger() {
1426    res=`echo "$1" | tr -s '\-[0-9]' ' '`
1427    if [ "$res" != " " ] && [ "$res" != "" ] ; then
1428    echo "result = '$res'"
1429        Die "$1 should be an integer"
1430    fi
1431}
1432
1433
1434MakeSyslinuxMessageFile() {
1435    mkdir -p $1
1436    rmdir $1
1437    echo -en "  " > $1
1438    if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
1439        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
1440    else
1441        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
1442    fi
1443    sed s/%r/"`uname -r`"/ $1.tmp | sed s/%t/"`hostname`"/ > $1
1444    rm -f $1.tmp
1445    if [ "$CDRECOVERY" != "yes" ] ; then
1446        if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1447            echo -en "Press <enter> to continue.\n" >> $1
1448        elif [ ! "$MINDI_TMP" ] ; then
1449            echo -en "FYI, this is _not_ a Mondo Rescue CD.\n" >> $1
1450            if [ -e "$MINDI_LIB/memtest.img" ] ; then
1451                echo -en "Type 'memtest' <Enter> to test your PC's memory intensively.\nJust press <Enter> to go to the main test menu.\n" >> $1
1452            fi
1453        else
1454            echo -en "$BOOT_MEDIA_MESSAGE" >> $1
1455        fi
1456    else
1457        echo -en " \
1458To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1459CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n" >> $1
1460    fi
1461}
1462
1463
1464MoveHyperlinkSensibly() {
1465    local filename minidir_root resides_on_diskno noof_disks old_diskno d old_pwd
1466    filename=$1
1467    minidir_root=$2
1468    resides_on_diskno=$3
1469    noof_disks=$4
1470
1471    [ -h "$minidir_root/$resides_on_diskno/$filename" ] || Die "$filename isn't a softlink (or doesn't exist): how can I move it sensibly?"
1472
1473    old_diskno=$resides_on_diskno
1474    d=1
1475    while [ "$d" -le "$noof_disks" ] ; do
1476        if [ "$d" -ne "$old_diskno" ] ; then
1477            old_pwd=`pwd`
1478            cd $minidir_root/$old_diskno
1479            cp --parents -Rdf $filename $minidir_root/$d/ || Die "Can't move $filename (sensibly) from $old_diskno to $d"
1480            rm -f $filename
1481            cd $old_pwd
1482        fi
1483# when the softlink is resolvable, our work here is done
1484        [ -e "$minidir_root/$d/$filename" ] && return 0
1485        old_diskno=$d
1486        d=$(($d+1))
1487    done
1488    return 1
1489}
1490
1491
1492
1493OfferToCopyImagesToDisks() {
1494    local imagesdir i imagename dev count boot_dev data_dev
1495    imagesdir=$1
1496    boot_dev=$2
1497    data_dev=$3
1498
1499    echo -en "Would you like to create boot+data floppy disks now (y/n) ?"
1500    read i
1501    [ "$i" != "y" ] && [ "$i" != "Y" ] && return
1502    mount | grep -F /dev/fd > /dev/null && Die "Please unmount your floppies first."
1503    echo "WARNING! THIS WILL ERASE YOUR FLOPPY DISKS."
1504    [ ! -e "$boot_dev" ] && Die "Cannot find $boot_dev - is your Linux distro broken?"
1505    [ ! -e "$data_dev" ] && Die "Cannot find $data_dev - is your Linux distro broken?"
1506    i=`find $imagesdir -type f | grep -F "/mindi-root.1" 2> /dev/null`
1507    j=`find $imagesdir -type f | grep -F "/mindi-boot" | grep -Ev '2880|5760'`
1508    if [ "$i" ] ; then
1509        CopyImageToDisk $j $data_dev "boot disk"
1510        CopyImageToDisk $i $data_dev "root disk"
1511    else
1512        CopyImageToDisk $j $boot_dev "boot/root disk"
1513    fi
1514    count=1
1515    for i in `find $imagesdir | grep -F mindi-data` ; do
1516        CopyImageToDisk $i $data_dev "data disk #$count"
1517        count=$(($count+1))
1518    done
1519}
1520
1521
1522OfferToMakeBootableISO() {
1523    local i old_pwd
1524    if [ "$PROMPT_MAKE_CD_IMAGE" = "yes" ] && [ ! "`DidMondoCallMe`" ] ; then
1525        echo -en "Shall I make a bootable CD image? (y/n) "
1526        read i
1527        [ "$i" != "y" ] && [ "$i" != "Y" ] && return 0
1528    fi
1529    if [ ! "$MINDI_TMP" ] ; then
1530        LogIt "NB: Mindi's bootable CD always uses isolinux.\n"
1531        LogIt "For a bootable CD w/LILO, please use Mondo.\n"
1532    fi
1533    rm -Rf $MINDI_TMP/iso
1534    mkdir -p $MINDI_TMP/iso/{images,archives,isolinux}
1535    cp -f $1/*.img $1/*.gz $MINDI_TMP/iso/images || LogIt "OfferToMakeBootableISO: Cannot copy $i to $MINDI_TMP/iso/images\n"
1536    old_pwd=`pwd`
1537    cd $MINDI_TMP/iso
1538    mkdir -p $MONDO_ROOT/iso/isolinux
1539    echo "mindi_lib = $MINDI_LIB" >> $LOGFILE
1540    cp $MINDI_LIB/mem{test,disk}* $MONDO_ROOT 2>> $LOGFILE
1541    for i in memdisk memtest.bin memtest.img ; do
1542    j=$MINDI_LIB/$i
1543    k=$MINDI_TMP/iso/isolinux
1544    if [ -e "$j" ] ; then
1545        LogIt "Copying $j to $k\n"
1546        cp -f $j $k || Die "Failed to copy $j to $k"
1547        cp -f $j $MINDI_TMP || Die "Failed to copy $j to $k"
1548    fi
1549    done
1550    MakeSyslinuxMessageFile $MINDI_TMP/iso/isolinux/message.txt
1551    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?"
1552    cp $MINDI_TMP/mindi.rdz $MINDI_TMP/iso/isolinux/initrd.img
1553    cp $MINDI_TMP/mindi.rdz $CACHE_LOC/initrd.img
1554    [ -e "$iso_cfg_file" ] || Die "FIXME - unable to find $iso_cfg_file - this should never occur"
1555    cd $MINDI_TMP/iso/isolinux
1556    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?"
1557    if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1558        mv isolinux.cfg isolinux.cfg.old
1559        sed s/interactive/iso/ isolinux.cfg.old > isolinux.cfg
1560    fi
1561    if [ "$ARCH" != "ia64" ] ; then
1562        cp $ISOLINUX isolinux.bin || Die "Cannot copy isolinux.bin ($ISOLINUX) to tmp_root - did you run out of disk space?"
1563        cp $ISOLINUX ../
1564    fi
1565    cd $MINDI_TMP/iso
1566    if [ "$ARCH" != "ia64" ] ; then
1567        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?"
1568    fi
1569    [ "$MONDO_SHARE" ] && cp -f $MONDO_SHARE/autorun .   
1570    if [ "$ARCH" != "ia64" ] ; then
1571        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
1572    else
1573        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
1574    fi
1575    if [ "$?" -ne "0" ] ; then
1576        echo "----------- mkisofs's errors --------------" >> $LOGFILE
1577        cat $MINDI_TMP/mkisofs.log >> $LOGFILE
1578        echo "mkisofs returned the following errors:-"
1579        cat $MINDI_TMP/mkisofs.log
1580        LogIt "Failed to create ISO image.\n"
1581    else
1582        echo "Created bootable ISO image at $CACHE_LOC/mindi.iso" >> $LOGFILE
1583    fi
1584    rm -f $MINDI_TMP/mkisofs.log
1585    cd $old_pwd
1586}
1587
1588
1589PluralOrNot() {
1590    [ "$1" -gt "1" ] && echo -en "s"
1591}
1592
1593
1594MakeMessageFile() {
1595    local disksize
1596    disksize=$1
1597    if [ "`grep -Fi "debian" /etc/issue.net 2> /dev/null`" ] ; then
1598        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`"/
1599    else
1600        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`/
1601    fi
1602    if [ "$disksize" -gt "2880" ] ; then
1603        if [ "`DidMondoCallMe`" ] ; then
1604            if [ "$CDRECOVERY" != "yes" ] ; then
1605                if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1606                    echo -en "Press <enter> to continue.\n"
1607                elif [ ! "$MINDI_TMP" ] ; then
1608                    echo -en "FYI, this is _not_ a Mondo Rescue CD.\n"
1609                else
1610                    echo -en "$BOOT_MEDIA_MESSAGE"
1611                fi
1612            fi
1613        fi
1614    fi
1615    if [ "$CDRECOVERY" = "yes" ] ; then
1616        echo -en "\
1617To restore your disk to factory defaults, type 'RESTORE' <enter>.\n\
1618CAUTION: THIS WILL ERASE YOUR WHOLE DISK !!!\n"
1619    fi
1620    echo -en "\n\n\n"
1621}
1622
1623
1624write_full_floppy_of_kernel() {
1625    local mtpt image old_pwd res disksize
1626
1627    res=0
1628    old_pwd=`pwd`
1629    KERN_DISK_MADE=1
1630    disksize=$3
1631    rand1=$RANDOM
1632    rand2=$RANDOM
1633    image=$MINDI_TMP/$rand1.$rand2.img
1634    mtpt=$MINDI_TMP/$rand1.$rand2.mtpt
1635    dd if=/dev/zero of=$image bs=1k count=$disksize
1636    mke2fs -N 26 -F $image > /dev/null
1637    mkdir -p $mtpt
1638    mount -o loop $image $mtpt
1639    cd $mtpt
1640    mkdir -p {dev,tmp,boot}
1641    cp -f $1 vmlinuz
1642    if [ "$?" -ne "0" ] ; then
1643        LogIt "Failed to copy $1 to ramdisk\n"
1644        cd $old_pwd
1645        umount $mtpt
1646        rmdir $mtpt
1647        rm $image
1648        return 1
1649    fi
1650
1651    rdev vmlinuz 2,0
1652    rdev -R vmlinuz 0
1653    rdev -r vmlinuz 49152
1654
1655    tar -zxf $MINDI_LIB/dev.tgz || LogIt "Cannot untar dev.tgz\n"
1656    losetup /dev/loop0 > /dev/null 2> /dev/null
1657    [ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary.\n"
1658    CopyBootBFile $mtpt/boot.b
1659
1660    MakeLiloConfFile $disksize >> bdlilo.conf
1661
1662    chmod 644 bdlilo.conf
1663    MakeMessageFile $disksize > message
1664    lilo -v -C bdlilo.conf -r $mtpt
1665    res=$?
1666
1667    cd $old_pwd
1668    umount $mtpt
1669    mv -f $image $2
1670    rmdir $mtpt
1671
1672    return $res
1673}
1674
1675
1676MakeLiloConfFile() {
1677    local disksize options i ooo
1678    disksize=$1
1679    options=""
1680
1681    if [ "$ARCH" != "ia64" ] ; then
1682        echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
1683    fi
1684    if [ "$disksize" -eq "2880" ] ; then
1685        echo -en "bios=0x00\nsectors=36\nheads=2\ncylinders=80\n"
1686    elif [ "$disksize" -eq "1722" ] ; then
1687        echo -en "bios=0x00\nsectors=21\nheads=2\ncylinders=82\n"
1688    elif [ "$disksize" -gt "2880" ] ; then
1689        /bin/true
1690    else
1691        echo -en "bios=0x00\nsectors=18\nheads=2\ncylinders=80\n"
1692    fi
1693    if [ "$ARCH" != "ia64" ] ; then
1694        echo -en "install=/boot.b\nmap=/boot.map\n"
1695    fi
1696    if [ "$CDRECOVERY" = "yes" ] ; then
1697        echo -en "default=RESTORE\n"
1698    elif [ "$disksize" -gt "2880" ] && [ "`DidMondoCallMe`" ] ; then
1699        if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1700            echo -en "default=iso\n"
1701        else
1702            echo -en "default=interactive\n"
1703        fi
1704    else
1705        echo -en "default=expert\n"
1706    fi
1707
1708    echo -en "prompt\n"
1709    if [ "$ARCH" != "ia64" ] ; then
1710        echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
1711    fi
1712    if [ "$CDRECOVERY" != "yes" ] ; then
1713        echo -en "timeout=300\n"
1714    fi
1715    echo -en "\n"
1716    if [ "$CDRECOVERY" = "yes" ] ; then
1717        options="RESTORE expert"
1718    elif [ "$disksize" -gt "2880" ] ; then
1719        if [ "`DidMondoCallMe`" ] ; then
1720            if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1721                options="iso"
1722            else
1723                options="interactive expert compare iso nuke isonuke"
1724# hda hdb hdc hdd"
1725            fi
1726        else
1727            options="expert"
1728        fi
1729    else
1730        options="expert"
1731    fi
1732    for i in $options ; do
1733        ooo=$i
1734        [ "$ooo" = "RESTORE" ] && ooo="nuke"
1735        if [ "$ARCH" = "ia64" ] ; then
1736            rootpart="root=/dev/ram0\n\t"
1737        else
1738            rootpart=""
1739        fi
1740        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"
1741   
1742        outstr=$outstr" $ooo_mode"
1743        outstr=$outstr"\"\n"
1744        if [ "$disksize" = "1440" ] ; then
1745            echo -en "$outstr" | sed s/initrd=.*// | grep -v root=
1746        else
1747            echo -en "$outstr"
1748        fi
1749    done
1750}
1751
1752
1753PrepareBootDiskImage_LILO() {
1754    local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
1755    imagesdir=$1
1756    disksize=$2
1757    kernelpath=$3
1758    ramdisksize=$4
1759
1760    retval=0
1761    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
1762    echo -en "Making "$disksize"KB boot disk..."
1763    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?"
1764    if [ "$ARCH" != "ia64" ] ; then
1765        [ "$disksize" != "1722" ] && [ "$disksize" != "2880" ] && [ "$disksize" != "5760" ] && Die "PDBI - disksize is $disksize - bad size"
1766    fi
1767    echo -en "..."
1768    imagefile=$imagesdir/mindi-bootroot.$disksize.img
1769    mountpoint=$MINDI_TMP/mountpoint.$$
1770    mkdir -p $mountpoint
1771    dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null || Die "Cannot dd blank file"
1772    if [ "$ARCH" = "ia64" ] ; then
1773        mkdosfs $imagefile > $MINDI_TMP/mke2fs.log 2>> $MINDI_TMP/mke2fs.log
1774    t=vfat
1775    else
1776        mke2fs -N 26 -m 0 -F $imagefile > $MINDI_TMP/mke2fs.log 2>> $MINDI_TMP/mke2fs.log
1777    t=ext2
1778    fi
1779    [ "$?" -ne "0" ] && cat $MINDI_TMP/mke2fs.log
1780    rm -f $MINDI_TMP/mke2fs.log
1781    mount -t $t -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)\n\n"
1782# copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
1783    mkdir -p $mountpoint/etc
1784    if [ "$ARCH" != "ia64" ] ; then
1785        liloconf=$mountpoint/etc/lilo.conf
1786    else
1787        liloconf=$mountpoint/elilo.conf
1788    fi
1789    old_pwd=`pwd`
1790    cd $mountpoint
1791    if [ "$ARCH" != "ia64" ] ; then
1792        tar -zxf $MINDI_LIB/dev.tgz || LogIt "Cannot untar dev.tgz\n"
1793    fi
1794    cd $old_pwd
1795    losetup /dev/loop0 > /dev/null 2> /dev/null
1796    [ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing   'losetup /dev/loop0 -d'.\nReboot if necessary.\n"
1797    CopyBootBFile $mountpoint/boot.b
1798
1799    MakeLiloConfFile $disksize > $liloconf
1800
1801    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
1802    cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
1803    if [ "$?" -ne "0" ] ; then
1804        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint\n"
1805        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
1806        LogIt "Please unload some of your modules and try again.\n"
1807        rm -f $MINDI_TMP/mtpt.$$
1808        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)\n"
1809        retval=$(($retval+1))
1810    fi
1811    MakeMessageFile $disksize > $mountpoint/message
1812
1813    mkdir -p $mountpoint/tmp
1814    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
1815    if [ -e "$MINDI_LIB/memtest.img" ] ; then
1816        echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
1817        echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
1818#        echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
1819    fi
1820
1821    # copy the kernel across
1822    rm -Rf $mountpoint/lost+found
1823    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
1824    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1825    cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
1826    if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
1827        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
1828        du -sk $mountpoint/* >> $LOGFILE
1829        echo "--- end of list of files ---" >> $LOGFILE
1830        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
1831Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
1832        rm -f $mountpoint/vmlinuz
1833        cd $old_pwd
1834        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1835        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)\n"
1836    #   losetup /dev/loop0 -d
1837        res=0
1838        write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
1839        res=$(($res+$?))
1840        cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img
1841        res=$(($res+$?))
1842        rm -f $imagefile
1843        if [ "$res" -ne "0" ]; then
1844            LogIt "Warning - failed to create 1.44MB boot/root floppies\n"
1845            rm -f $imagesdir/mindi-*.1440.img
1846        fi
1847        return $res
1848    fi
1849    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1850    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
1851    echo "Free space left on floppy = $free_space KB" >> $LOGFILE
1852    echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
1853# make it bootable
1854    rm -f $mountpoint/zero
1855    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint
1856    if [ "$disksize" -gt "2880" ] && [ ! "$KERN_DISK_MADE" ] ; then
1857        if [ "$ARCH" != "ia64" ] ; then
1858        $LILO_EXE $LILO_OPTIONS -r $mountpoint >> $LOGFILE 2>> $LOGFILE
1859        else
1860            /bin/true
1861        fi
1862    elif [ ! "$KERN_DISK_MADE" ] ; then
1863# 12/28/2001 - if 1.72MB floppy then don't use LILO's optimizations at all
1864        $LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
1865    else
1866        echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
1867    fi
1868
1869    # BERLIOS  does not test necessarily what it expects
1870    if [ $? -ne "0" ] ; then
1871        if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
1872            LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's.\n"
1873            LogIt "Please reboot your PC as a workaround.\n"
1874            Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ.\n"
1875        fi
1876        echo "$LILO_EXE -r $mountpoint ...failed."
1877        echo -en "Press ENTER to continue."; read line
1878        LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug.\n"
1879        retval=$(($retval+1))
1880    fi
1881    cp -f $liloconf $MINDI_TMP/lilo.conf
1882    if [ "$ARCH" = "ia64" ] ; then
1883        cp `dirname $kernelpath`/*.efi $mountpoint
1884    fi
1885    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1886    echo -en "..."
1887    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)\n"
1888    if [ "$retval" -eq "0" ] ; then
1889        echo -en "...$DONE\r"
1890        if [ "$KERN_DISK_MADE" ] ; then
1891            LogIt "... $disksize KB boot disks were created OK\r"
1892        fi
1893    else
1894        echo -en "...failed\r"
1895        LogIt $disksize"KB boot disk was NOT created\r"
1896        rm -f $imagefile
1897    fi
1898    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero\n"
1899    return $retval
1900}
1901
1902
1903PrepareBootDiskImage_SYSLINUX() {
1904    local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
1905    imagesdir=$1
1906    disksize=$2
1907    kernelpath=$3
1908    ramdisksize=$4
1909    do_boot_root_thingy=""
1910    local retval old_pwd
1911    retval=0
1912
1913    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
1914    echo -en "Making "$disksize"KB boot disk..."
1915    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?"
1916    [ "$disksize" != "1722" ] && [ "$disksize" != "2880" ] && [ "$disksize" != "5760" ] && Die "PDBI - disksize is $disksize - bad size"
1917    echo -en "..."
1918    imagefile=$imagesdir/mindi-bootroot.$disksize.img
1919    mountpoint=$MINDI_TMP/mountpoint.$$
1920    mkdir -p $mountpoint
1921# If I format a 1722KB data file & run syslinux on it, the resultant image
1922# won't boot. So, I have formatted a floppy, called syslinux on/to it, and
1923# used 'dd' to copy it to sys-disk.raw (zipped to sys-disk.raw.gz).
1924# If I extract it, mount it, copy my files to it, etc. then the resultant
1925# image _is_ bootable. I don't know why syslinux and/or mkfs.vfat won't
1926# play nicely and I don't care. :) I have worked around the problem. -Hugo, 06/27/2002
1927    if [ "$disksize" = "1722" ] ; then
1928        gzip -dc $MINDI_LIB/sys-disk.raw.gz > $imagefile || Die "Cannot dd blank file"
1929    else
1930        dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null || Die "Cannot dd blank file"
1931        mkfs.vfat $imagefile
1932        syslinux $imagefile
1933    fi
1934    mount -t vfat -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)\n\n"
1935
1936    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
1937    old_pwd=`pwd`
1938    MakeSyslinuxMessageFile $mountpoint/message.txt
1939    cd $mountpoint
1940    [ -e "$sys_cfg_file" ] || Die "Obi Wan, word up?"
1941    cat $sys_cfg_file | HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg || Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
1942    if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
1943        mv syslinux.cfg syslinux.cfg.orig
1944        sed s/interactive/iso/ syslinux.cfg.orig > syslinux.cfg
1945    fi
1946    cd $old_pwd
1947    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
1948    cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
1949    if [ "$?" -ne "0" ] ; then
1950        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint\n"
1951        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
1952        LogIt "Please unload some of your modules and try again.\n"
1953        rm -f $MINDI_TMP/mtpt.$$
1954        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)\n"
1955        retval=$(($retval+1))
1956    fi
1957
1958    mkdir -p $mountpoint/tmp
1959    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
1960
1961    # copy the kernel across
1962    rm -Rf $mountpoint/lost+found
1963    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
1964    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1965    cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
1966    if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
1967        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
1968        du -sk $mountpoint/* >> $LOGFILE
1969        echo "--- end of list of files ---" >> $LOGFILE
1970        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
1971Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
1972        rm -f $mountpoint/vmlinuz
1973        cd $old_pwd
1974        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1975        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)\n"
1976
1977        res=0
1978        write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
1979        res=$(($res+$?))
1980        cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img
1981        res=$(($res+$?))
1982        rm -f $imagefile
1983        if [ "$res" -ne "0" ]; then
1984            LogIt "Warning - failed to create 1.44MB boot/root floppies\n"
1985            rm -f $imagesdir/mindi-*.1440.img
1986        fi
1987        return $res
1988    fi
1989    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1990    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
1991    echo "Free space left on floppy = $free_space KB" >> $LOGFILE
1992    echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
1993
1994    # make it bootable
1995    rm -f $mountpoint/zero
1996    mkdir -p $mountpoint/etc
1997    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint
1998    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
1999    echo -en "..."
2000    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)\n"
2001
2002    if [ "$retval" -eq "0" ] ; then
2003        echo -en "...$DONE\r"
2004        if [ "$KERN_DISK_MADE" ] ; then
2005            rm -f $imagefile
2006            LogIt "... $disksize KB boot disks were created OK\r"
2007        fi
2008    else
2009        echo -en "...failed\r"
2010        LogIt $disksize"KB boot disk was NOT created\r"
2011        rm -f $imagefile
2012    fi
2013    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero\n"
2014    return $retval
2015}
2016
2017
2018PrepareDataDiskImages() {
2019    local needlist bigdir minidir_root tardir diskdir imagesdir res i j k old_pwd lines
2020
2021    imagesdir=$1
2022    rm -f $imagesdir/mindi-*.img $imagesdir/[0-9]*.tar.gz $imagesdir/mindi.iso
2023    needlist=$MINDI_TMP/what-we-need.txt
2024    bigdir=$MINDI_TMP/bigdir
2025    minidir_root=$MINDI_TMP/minidir
2026    mkdir -p $minidir_root
2027    mkdir -p $bigdir/usr/bin
2028    tardir=$MINDI_TMP/tardir
2029
2030    lines=`grep -vx " *#.*" $MINDI_CONF/deplist.txt | grep -vx "" | wc -l`
2031    cat $MINDI_CONF/deplist.txt | GenerateGiantDependencyList $needlist $lines
2032    res=$?
2033    if [ "$YOUR_KERNEL_SUCKS" ]; then
2034        pwd=`pwd`
2035        cd $MINDI_TMP
2036        for i in `ListKernelModulePaths | HackPathsToFailsafe` ; do
2037            cp --parents -pRdf ./$i $bigdir || Die "PDDI can't cp $i->$bigdir"
2038            if [ "`du -sk $i | cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
2039                cp --parents -pRdf $i $bigdir
2040            else
2041                ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
2042                BIGNO=$(($BIGNO+1))
2043            fi
2044        done
2045        for i in $EXTRA_MODS ; do
2046            j=`find lib/modules/$FAILSAFE_KVER -name $i.*o 2> /dev/null`
2047            [ ! "$j" ] && echo "Warning - cannot find failsafe module $i.o" >> $LOGFILE
2048            for k in $j ; do
2049                if [ "`du -sk $k | cut -f1`" -lt "$CHOPSIZE" ] ; then
2050                    cp --parents -pRdf $k $bigdir
2051                else
2052                    ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
2053                    BIGNO=$(($BIGNO+1))
2054                fi
2055                echo "Added failsafe module $k to ramdisk" >> $LOGFILE
2056            done
2057        done
2058        cd $pwd
2059    else
2060        ListKernelModulePaths >> $needlist
2061    fi
2062    if [ "$res" -ne "0" ] ; then
2063        Die "You have $res file`PluralOrNot $res` present in dependency list\nbut absent from filesystem."
2064    fi
2065    FindAndAddUserKeyboardMappingFile
2066    mkdir -p $bigdir/tmp
2067    if [ "`DidMondoCallMe`" ] ; then
2068        MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
2069        cp -f $MINDI_TMP/mondo-restore.cfg $bigdir/tmp &> /dev/null
2070    fi
2071    [ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
2072    DropOptimizedLibraries $needlist $bigdir
2073    echo -en "Assembling dependency files"
2074    CopyDependenciesToDirectory < $needlist $bigdir
2075
2076    # also copy io.sys and msdos.sys, if we can find them
2077    for i in `mount | cut -d' ' -f3` ; do
2078        for j in io.sys msdos.sys ; do
2079            [ -e "$i/$j" ] && cp -f $i/$j $bigdir
2080        done
2081    done
2082
2083    # master boot record, too
2084    i=`cat $MINDI_TMP/BOOTLOADER.DEVICE 2> /dev/null`
2085    if [ "$i" ] ; then
2086        LogIt "Backing up $i's MBR\n"
2087        dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
2088        sleep 1
2089        sync
2090        j=$i
2091        [ -h "$j" ] && j=`readlink -f $j`
2092        LogIt "Creating /dev/boot_device ($j)\n"
2093        mkdir -p $bigdir/dev
2094        cp -pRdf $j $bigdir/dev/boot_device || Die "Unable to create /dev/boot_device on ramdisk"
2095    fi
2096
2097    old_pwd=`pwd`
2098    cd $bigdir
2099
2100    [ -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'."
2101    cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE || LogIt "Warning - error occurred while unzipping aux-tools\n"
2102    if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
2103        tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE || LogIt "Warning - error occurred while unzipping x11-tools.tgz\n"
2104    fi
2105    if [ -e "$MONDO_SHARE/restore-scripts" ] ; then
2106        cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
2107        [ "$?" -ne "0" ] && [ "`DidMondoCallMe`" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
2108    fi
2109    [ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state .
2110    cd $old_pwd
2111    echo -e "$DONE"
2112    TOTAL_BIGDIR_SIZE=`du -sk $bigdir | cut -f1`
2113    SplitDirectoryIntoMinidirs $bigdir $minidir_root
2114    noof_disks=$?
2115    [ "$noof_disks" -eq "0" ] && Die "Too much stuff!"
2116#    if [ "$noof_disks" -ge "8" ] ; then
2117#        LogIt "You are putting a ludicrously large amount of data on these disks."
2118#        LogIt "I shall therefore double EXTRA_SPACE, just in case your ramdisk is too small."
2119#        EXTRA_SPACE=$(($EXTRA_SPACE*2))
2120#    fi
2121    MakeMountlist $MINDI_TMP/mountlist.txt
2122    mkdir -p $minidir_root/$noof_disks/tmp
2123    cp -f $MINDI_TMP/mountlist.txt $minidir_root/$noof_disks/tmp/mountlist.txt || Die "Cannot copy mountlist.txt from $MINDI_TMP to data disk"
2124    [ "`DidMondoCallMe`" ] && cp -f $minidir_root/$noof_disks/tmp/mountlist.txt $MINDI_TMP/.
2125    [ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $minidir_root/$noof_disks/tmp/i-want-my-lvm
2126    cat $minidir_root/$noof_disks/tmp/mountlist.txt >> $LOGFILE
2127    ZipMinidirsIntoTarballs $minidir_root $tardir $noof_disks
2128    CreateDataDiskImagesFromTarballs $tardir $imagesdir $noof_disks
2129    FRIENDLY_OUTSTRING="Boot and data disk images were created."
2130    # One 1.72MB boot disk, one 2.88MB boot disk and $noof_disks data disk images
2131    rmdir $tardir $bigdir
2132    rm -f $needlist
2133    return $noof_disks
2134}
2135
2136
2137ProcessLDD() {
2138    local main_fname incoming j i fname f newf
2139    main_fname=$1
2140    read incoming
2141    while [ "$incoming" != "" ] ; do
2142        # We take the full path name of the dyn. lib. we want
2143        incoming=`echo "$incoming" | sed '/[[:blank:]]*.*[[:blank:]]*=>[[:blank:]]*(.*/d ; s/[[:blank:]]*.*[[:blank:]]*=>[[:blank:]]*\(\/.*\)/\1/ ; s/[[:blank:]]*\(\/.*\)[[:blank:]]*(.*/\1/'`
2144        for f in `echo "$incoming"` ; do
2145            echo "$f `ReadAllLink $f`"
2146        done
2147        read incoming
2148    done
2149}
2150
2151
2152Prompt() {
2153    echo -en "$1"
2154    read line
2155}
2156
2157
2158ReadLine() {
2159    local i incoming
2160    read incoming
2161    i=0
2162    while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
2163        i=$(($i+1))
2164        read incoming
2165    done
2166    echo "$incoming"
2167}
2168
2169
2170RejigHyperlinks() {
2171    local minidir_root noof_disks fname path diskno old_pwd awk_loc gawk_loc dir i
2172    minidir_root=$1
2173    noof_disks=$2
2174
2175    old_pwd=`pwd`
2176    diskno=1
2177    while [ "$diskno" -le "$noof_disks" ] ; do
2178        mkdir -p $minidir_root/$diskno
2179        cd $minidir_root/$diskno
2180        for fname in `find -type d -o -print` ; do
2181            [ -h "$minidir_root/$diskno/$fname" ] && MoveHyperlinkSensibly $fname $minidir_root $diskno $noof_disks
2182        done
2183        diskno=$(($diskno+1))
2184    done
2185
2186    cd $old_pwd
2187    return
2188}
2189
2190
2191ReplaceIndividualLine() {
2192    local orig_file new_file lino newstring lines_total lines_remaining
2193
2194    orig_file=$1.orig
2195    mv -f $1 $orig_file || Die "Cannot move $1 to $orig_file"
2196    new_file=$1
2197    lino=$2
2198    newstring="$3"
2199    if [ "$lino" = "" ] || [ "$lino" -lt "1" ] ; then
2200        echo "Can't find string" >> $LOGFILE
2201        return 1
2202    fi
2203    lines_total=`wc -l $orig_file | gawk '{print $1;}'`
2204    lines_remaining=$(($lines_total-$lino))
2205    head -n$(($lino-1)) $orig_file > $new_file
2206    echo "$newstring" >> $new_file
2207    echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
2208    tail -n$lines_remaining $orig_file >> $new_file
2209    echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
2210    [ -x "$orig_file" ] && chmod +x $new_file
2211    rm -f $orig_file
2212    return 0
2213}
2214
2215
2216ScanCDandTape() {
2217    local i
2218
2219    for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
2220        dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
2221    done
2222}
2223
2224
2225SizeOfPartition() {
2226    local devpath drive res stub
2227    device=$1
2228    if [ "`echo "$device" | grep -F "/dev/md"`" != "" ] ; then
2229        res=`SizeOfRaidPartition $device`
2230        [ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
2231        echo "$res"
2232        return 0
2233    fi
2234    # patch from Bill <bill@iwizard.biz> - 2003/08/25
2235    res=`$FDISK -s $device`
2236    echo "------- $FDISK -l $device log ------------" >> $LOGFILE
2237    cat $FDISKLOG >> $LOGFILE
2238    echo "------- $FDISK log end ------------" >> $LOGFILE
2239    # end patch
2240    [ "$res" = "" ] && res=`df -k -P -x supermount | tr -s '\t' ' ' | grep -F "$device " | cut -d' ' -f2`
2241    [ "$res" = "" ] && res="-1"
2242    echo $res
2243    return 0
2244}
2245
2246
2247SizeOfRaidPartition() {
2248    local real_dev smallest_size silly tmp
2249
2250    silly=999999999
2251    smallest_size=$silly
2252
2253    for real_dev in `GetRaidDevMembers $1` ; do
2254        tmp=`SizeOfPartition $real_dev`
2255        [ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
2256    done
2257
2258    if [ "$smallest_size" = "$silly" ] ; then
2259        echo "-1"
2260        return 1
2261    else
2262        echo "$smallest_size"
2263        return 0
2264    fi
2265}
2266
2267
2268StripComments()
2269{
2270    local tempfile
2271
2272    tempfile=$MINDI_TMP/$$.strip.txt
2273    cp -f $1 $tempfile
2274    $AWK '{if (substr($0,0,1)!="#" || substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
2275    rm -f $tempfile
2276    echo "Stripped comments from $2" >> $LOGFILE
2277}
2278
2279
2280SplitDirectoryIntoMinidirs() {
2281    local bigdir minidir_root i noof_disks old_pwd res
2282
2283    bigdir=$1
2284    minidir_root=$2
2285    rm -Rf $minidir_root/*
2286
2287    TryToFitDataIntoSeveralDirs $bigdir $minidir_root
2288    noof_disks=$?
2289    if [ "$noof_disks" -eq "0" ] ; then
2290        echo "Failed to fit data into several dirs."
2291        return 0
2292    fi
2293    RejigHyperlinks $minidir_root $noof_disks
2294    rm -Rf $bigdir/*
2295    return $noof_disks
2296}
2297
2298
2299StripExecutable()
2300{
2301    local tmpfile
2302
2303    tmpfile=$MINDI_TMP/stripped.$$.dat
2304    [ -d "$1" ] || [ -h "$1" ] && return
2305    cp -f $1 $tmpfile
2306    strip $tmpfile 2> /dev/null
2307    if [ "$?" -eq "0" ] ; then
2308        cp -f $tmpfile $1
2309        echo "Stripped binary $2" >> $LOGFILE
2310    fi
2311    rm -f $tmpfile
2312}
2313
2314
2315TemporarilyCompressAllFiles() {
2316    local i orig_fname out_fname out_list
2317
2318    i=0
2319    out_list=$2/compressed/compressed.txt
2320    mkdir -p $2/compressed
2321    > $out_list
2322    for orig_fname in $1 ; do
2323        out_fname=$2/compressed/$orig_fname.gz
2324        mkdir -p $out_fname 2> /dev/null
2325        rmdir $out_fname 2> /dev/null
2326        gzip -c6 $orig_fname > $out_fname 2> /dev/null
2327        i=$(((($i+1))%15))
2328        [ "$i" -eq "0" ] && echo -en "."
2329        du -sk $out_fname >> $out_list
2330    done
2331}
2332
2333
2334TryToFindKernelPath() {
2335    local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
2336
2337    we_want_version=`uname -r`
2338    possible_kernels=""
2339    duff_kernels=""
2340   
2341    if [ "$ARCH" = "ia64" ] ; then
2342       root="/boot/efi/efi"
2343    else
2344       root="/"
2345    fi
2346    for fname in `find $root -maxdepth 2 -type f | grep -F lin | grep -Ev '^/proc/|^/net/'` ; do
2347        [ ! -e "$fname" ] && continue
2348        [ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
2349        file $fname | grep -q gzip
2350        if [ "$?" -eq "0" ] ; then
2351            # Used by ia64
2352            fkern_ver=`gzip -cd $fname | strings 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2353        else
2354            fkern_ver=`strings $fname 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2355        fi
2356        [ "$fkern_ver" = "" ] && continue
2357        [ "`echo "$fkern_ver" |grep -F "$we_want_version "`" = "" ] && continue
2358        [ -f "$fname" ] || continue
2359        [ -h "$fname" ] && continue
2360        kdate=`uname -v | $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' | $AWK '{print $NF;}'`
2361        file $fname | grep -q gzip
2362        if [ "$?" -eq "0" ] ; then
2363            # Used by ia64
2364            if [ "`gzip -cd $fname | strings 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2365                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it...\n"
2366                duff_kernels="$fname $duff_kernels"
2367            else
2368                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2369                possible_kernels="$fname $possible_kernels"
2370            fi
2371        else
2372            if [ "`strings $fname 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2373                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it...\n"
2374                duff_kernels="$fname $duff_kernels"
2375            else
2376                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2377                possible_kernels="$fname $possible_kernels"
2378            fi
2379        fi
2380    done
2381    if [ ! "$possible_kernels" ] && uname -a | grep Knoppix > /dev/null ; then
2382        possible_kernels=`find /boot/vmlinuz-2.* | tail -n1`
2383    fi
2384    if [ ! "$possible_kernels" ] ; then
2385        LogIt "No kernel matches exactly. Are there any duff kernels?\n"
2386        possible_kernels="$duff_kernels"
2387        if [ ! "$possible_kernels" ] ; then
2388            LogIt "Sorry, no duff kernels either\n"
2389        else
2390            LogIt "I bet you're running Debian or Gentoo, aren't you?\n"
2391            LogIt "Your kernel doesn't have a sane builddate. Oh well...\n"
2392        fi
2393    fi
2394    possible_kernels=`echo "$possible_kernels" | tr -s ' ' '\n' | sort -u | tr '\n' ' '`
2395    noof_kernels=`CountItemsIn "$possible_kernels"`
2396    if [ "$noof_kernels" -eq "0" ] ; then
2397        LogIt "Could not find your kernel.\n"
2398        if [ -e "/boot/vmlinuz" ] ; then
2399            LogIt "Using /boot/vmlinuz as a last resort.\n"
2400            output=/boot/vmlinuz
2401        else
2402            output=""
2403        fi
2404    elif [ "$noof_kernels" -eq "1" ] ; then
2405        kernelpath=`echo "$possible_kernels" | sed s/' '//`
2406        echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
2407        output="$kernelpath"
2408    else
2409        for i in $possible_kernels ; do
2410            if echo $i | grep "`uname -r`" ; then
2411                LogIt "OK, I used my initiative and found that "
2412                LogIt "$i is probably your kernel.\n "
2413                output="$i"
2414                return
2415            fi
2416        done
2417        if echo " $possible_kernels " | grep -F "/boot/vmlinuz " &> /dev/null ; then
2418            output=/boot/vmlinuz
2419            echo "Schlomo, this one's for you." >> $LOGFILE
2420        else
2421            LogIt "Two or more possible kernels found. You may specify any one of them and the \n"
2422            LogIt "boot disks will still work, probably. If one does not work, try another.\n"
2423            LogIt "$possible_kernels\n"
2424            echo ""
2425        fi
2426    fi
2427    echo "$output" | tr -s ' ' '\n' | sort -u | tr '\n' ' '
2428}
2429
2430
2431TryToFitDataIntoSeveralDirs() {
2432    local bigdir minidir_root noof_disks diskno list_of_files filename old_pwd progress
2433    local i retval noof_disks total_files list_of_devs
2434
2435    bigdir=$1
2436    minidir_root=$2
2437    BIG_CLUNKY_SIZE_COUNTER=0
2438    retval=0
2439    noof_disks=1
2440
2441    echo -en "\r                                                                            \rDividing data into several groups..."
2442    old_pwd=`pwd`
2443    cd $bigdir
2444    list_of_files=`GetFileSizeList . | sort -nr | cut -f2 | grep -Fv "/dev/"`
2445    progress=0
2446    total_files=`CountItemsIn "$list_of_files"`
2447    if [ "`echo "$filename" | grep -x "/dev/.*"`" ] ; then
2448        filesize=1
2449    fi
2450    mkdir -p $minidir_root/$noof_disks
2451    if [ -e "dev" ] ; then
2452        echo "Copying dev/* to $minidir_root/$noof_disks" >> $LOGFILE
2453        cp --parents -pRdf dev $minidir_root/$noof_disks
2454    fi
2455    TemporarilyCompressAllFiles "$list_of_files" $minidir_root
2456    for filename in $list_of_files ; do
2457        AddFileToDir $filename $minidir_root $noof_disks
2458        i=$?
2459        if [ "$i" -gt "$noof_disks" ] ; then
2460            noof_disks=$i
2461            echo -en "\r\t\t\t\t\t\t($noof_disks disks)"
2462        fi
2463        if [ "$i" -eq "0" ] ; then
2464            LogIt "Cannot add file $filename to minidir $minidir_root\n"
2465            retval=$(($retval+1))
2466        fi
2467        progress=$(($progress+1))
2468        echo -en "\r\t\t\t\t\t\t\t\t$(($progress*100/$total_files))% complete\r"
2469    done
2470    cd $old_pwd
2471    echo -en "\rThe files have been subdivided into $noof_disks directories.                                                            \r"
2472    rm -Rf $minidir_root/compressed
2473    if [ "$retval" -gt "0" ] ; then
2474        return 0
2475    else
2476        return $noof_disks
2477    fi
2478}
2479
2480
2481TurnTgzIntoRdz() {
2482    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
2483
2484    tgz_dir_fname=$1
2485    rdz_fname=$2
2486    ramdisksize=$3
2487    disksize=$4
2488    kernelsize=$5
2489    maxsize=$(($disksize-$kernelsize))
2490    maxsize=$(($maxsize*2)); # to allow for compression of 50%
2491    tempfile=$MINDI_TMP/temp.rd
2492    mountpoint=$MINDI_TMP/mnt1
2493    res=0
2494    echo -en "..."
2495    dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null || Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
2496    echo -en "..."
2497    mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE
2498
2499    [ "$?" -ne "0" ] && cat $MINDI_TMP/mke2fs.log
2500    rm -f $MINDI_TMP/mke2fs.log
2501    echo -en "..."
2502    mkdir -p $mountpoint
2503    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."
2504    echo -en "..."
2505    old_pwd=`pwd`
2506    cd $mountpoint
2507    cp -Rdf $tgz_dir_fname/* . 2>> $LOGFILE >> $LOGFILE
2508    tar -zxf symlinks.tgz || Die "Cannot untar symlinks.tgz"
2509    cd dev || Die "Can't cd to dev"
2510    tar -zxf dev-entries.tgz || Die "Cannot untar dev-entries.tgz"
2511    rm -f dev-entries.tgz
2512    cd ..
2513
2514    for w in insmod.static insmod.static.old ; do
2515        s=`which $w 2> /dev/null`
2516        if [ -e "$s" ] ; then
2517            cp --parents -af $s .
2518        fi
2519    done
2520
2521    mkdir -p tmp
2522    [ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
2523    for w in cdrom floppy groovy-stuff ; do
2524        mkdir -p mnt/$w
2525    done
2526    #if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
2527        #ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init | cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
2528    #fi
2529    if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
2530        ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init | cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
2531    fi
2532
2533    lsmod > tmp/original-lsmod.txt
2534   
2535    cp --parents -Rdf /dev/fd0*[1,2][4,7,8]* . 2> /dev/null
2536    cd $old_pwd
2537    echo -en "..."
2538    MakeModuleLoadingScript $TMPMODPROBE_FLAG $mountpoint/sbin/insert-all-my-modules
2539    echo -en "..."
2540    old_pwd=`pwd`
2541    if [ "$YOUR_KERNEL_SUCKS" ] ; then
2542        cd $MINDI_TMP
2543        floppy_modules_path=lib/modules/$FAILSAFE_KVER
2544    else
2545        cd /
2546###
2547### Sq-Modification... Use kernel name in module path if specified.
2548###
2549        #floppy_modules_path=lib/modules/`uname -r`
2550        if [ "${kernelname}" != "" ]
2551        then
2552            floppy_modules_path=lib/modules/${kernelname}
2553        else
2554            floppy_modules_path=lib/modules/`uname -r`
2555        fi
2556###
2557### Sq-Modification end
2558###
2559    fi
2560    floppy_modules=""
2561    if [ "$disksize" -lt "2880" ] ; then
2562        list_of_groovy_mods="$FLOPPY_MODS $IDE_MODS ide-scsi sr_mod cdrom isocd isofs `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2563    else
2564        list_of_groovy_mods="$CDROM_MODS `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2565    fi
2566    if [ -e "$MINDI_TMP/NFS-DEV" ] ; then
2567        # For PXE boot
2568        list_of_groovy_mods="$list_of_groovy_mods $NET_MODS"
2569    fi
2570    [ -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"
2571    for i in $list_of_groovy_mods ; do
2572        floppy_modules="$floppy_modules `FindSpecificModuleInPath $floppy_modules_path $i`"
2573    done
2574    for i in $floppy_modules ; do
2575        [ -e "$i" ] && s=`du -sk $i | cut -f1` || s=""
2576        [ "$YOUR_KERNEL_SUCKS" ] && i=$MINDI_TMP/$i
2577        echo "Adding $i ($s KB) to the rootfs" >> $LOGFILE
2578        cp -df $i $mountpoint/ || LogIt "Unable to copy $i to $mountpoint\n"
2579        [ "`echo "$i" | grep -F ".gz"`" ] && gunzip -f $mountpoint/`basename $i`
2580    done
2581    if [ ! -e "/sbin/devfsd" ] || [ "$disksize" -lt "2880" ] || [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] ; then
2582        echo "Deleting devfsd daemon from ramdisk" >> $LOGFILE
2583        [ ! -e "/sbin/devfsd" ] && echo "...because /sbin/devfsd not found" >> $LOGFILE
2584        [ "$disksize" -lt "2880" ] && echo "...because disksize = $disksize" >> $LOGFILE
2585        [ "$kernelpath" = "$MINDI_LIB/vmlinuz" ] && echo "...because kernel is failsafe" >> $LOGFILE
2586        rm -f $mountpoint/sbin/devfsd
2587    fi
2588    cd $old_pwd
2589    [ "$TAPEDEV" ] && echo -en "$TAPEDEV" > $mountpoint/tmp/TAPEDEV-LIVES-HERE
2590    dd if=/dev/zero of=$mountpoint/zero &> /dev/null
2591    rm -f $mountpoint/zero
2592    if [ "`DidMondoCallMe`" ] ; then
2593        MakeMondoConfigFile $mountpoint/tmp/mondo-restore.cfg
2594        cp -f $mountpoint/tmp/mondo-restore.cfg $MINDI_TMP &> /dev/null
2595        cp -f $MINDI_TMP/mountlist.txt $mountpoint/tmp/ || Die "Cannot copy mountlist to ramdisk"
2596        echo -en "$FILES_IN_FILELIST" > $mountpoint/tmp/FILES-IN-FILELIST
2597        echo -en "$LAST_FILELIST_NUMBER" > $mountpoint/tmp/LAST-FILELIST-NUMBER
2598        [ "$USE_LZO" = "yes" ] && echo -en "Pras 4 Pres 2004" >> $mountpoint/tmp/USING-LZO
2599        [ "$USE_COMP" = "yes" ] && echo -en "Compression, yep" >> $mountpoint/tmp/USING-COMP
2600        [ "$USE_STAR" = "yes" ] && echo -en "Using star. Hooray." >> $mountpoint/tmp/USING-STAR
2601    fi
2602    mkdir -p $mountpoint/tmp
2603    mkdir -p $mountpoint/proc
2604    echo "$disksize" > $mountpoint/tmp/$disksize.siz
2605    find $mountpoint -name CVS -exec rm -rf '{}' \;
2606    umount $mountpoint || Die "Cannot unmount $tempfile"
2607    dd if=$tempfile bs=1k 2> /dev/null | gzip -v9 > $rdz_fname 2> /dev/null
2608#    gzip -9 $tempfile
2609#    mv $tempfile.gz $rdz_fname
2610    if [ "$res" -eq "0" ] ; then
2611        echo -en "..."
2612    else
2613        echo -en "\rMade an rdz WITH ERRORS.           \n"
2614    fi
2615    return 0
2616}
2617
2618
2619WhichOfTheseModulesAreLoaded() {
2620    local modname loaded_modules
2621    loaded_modules=" `lsmod | tr -s ' ' '\t' | cut -f1 | grep -Fvx "Modules" | tr '\n' ' '` "
2622    for modname in $1 ; do
2623        [ "`echo "$loaded_modules" | grep -F " $modname "`" ] && echo "$modname"
2624    done
2625}
2626
2627
2628ZipMinidirsIntoTarballs() {
2629    local minidir_root tardir noof_disks diskno old_pwd i
2630    minidir_root=$1
2631    tardir=$2
2632    noof_disks=$3
2633
2634    echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
2635    mkdir -p $tardir
2636    mkdir -p $minidir_root/all
2637    old_pwd=`pwd`
2638    diskno=1
2639    while [ "$diskno" -le "$noof_disks" ] ; do
2640        cd $minidir_root/$diskno || LogIt "Warning - cannot cd to $minidir_root/$diskno\n"
2641        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."
2642        diskno=$(($diskno+1))
2643        echo -n "..."
2644        cp -pRdf * $minidir_root/all
2645    done
2646    mkdir -p $minidir_root/all/tmp
2647    cd $minidir_root/all
2648    size_of_all_tools=`du -sk . | cut -f1`
2649    if [ "`DidMondoCallMe`" ] ; then
2650        for q in filelist.full.gz biggielist.txt ; do
2651            [ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
2652            cp -pRdf $MINDI_TMP/$q tmp/
2653        done
2654        mkdir -p $minidir_root/all/tmp
2655        echo -en "$FILES_IN_FILELIST" > $minidir_root/all/tmp/FILES-IN-FILELIST 2> /dev/null
2656        echo -en "$LAST_FILELIST_NUMBER" > $minidir_root/all/tmp/LAST-FILELIST-NUMBER 2> /dev/null
2657    fi
2658    tar -b 4096 -cf - * 2> /dev/null | gzip -9 > $tardir/all.tar.gz
2659    dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
2660    [ "`du -sm $imagesdir/all.tar.gz | cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
2661    cd $old_pwd
2662    rm -Rf $minidir_root
2663    echo -e "$DONE"
2664}
2665
2666
2667##############################################################################
2668#----------------------------------- main -----------------------------------#
2669##############################################################################
2670
2671
2672> $LOGFILE
2673echo "mindi v$MINDI_VERSION" >> $LOGFILE
2674echo "$ARCH architecture detected" >> $LOGFILE
2675echo "mindi called with the following arguments:" >> $LOGFILE
2676echo "$@" >> $LOGFILE
2677echo "Start date : `date`" >> $LOGFILE
2678
2679if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
2680    LogIt "Warning - Ancient distro detected.\n" 1
2681    ln -sf /etc/conf.modules /etc/modules.conf
2682fi
2683[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
2684
2685FindHomeOfMindiAndMondo
2686trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
2687AbortIfYourDistroIsAPieceOfStercus
2688[ "`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"
2689# If we have a 2.6 kernel, the system uses module-init-tools which means that we
2690# may have the modprobe configuration spread out across multiple files in
2691# directory /etc/modprobe.d. If this is the case we concatenate these files into
2692# a temporary file for further processing. Otherwise we continue in the standard
2693# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
2694# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
2695# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
2696if [ -d "/etc/modprobe.d" ] && [ `uname -r | cut -c1-3` == "2.6" ] ; then
2697    TMPMODPROBE_FLAG="Y"
2698else
2699    TMPMODPROBE_FLAG="N"
2700    [ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
2701    [ ! -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..."
2702fi
2703FixPathIfBroken
2704[ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null | grep -E "2\.[46]" | cut -d' ' -f1`
2705AbortIfMkfsVfatMissing
2706### BERLIOS
2707### Fix as it's not mandatory on ia64
2708if [ "$ARCH" = "ia64" ] ; then
2709    FindELiloBinary
2710else
2711    FindIsolinuxBinary
2712    FindLiloBinary
2713fi
2714# BERLIOS: Remove as too dangerous and now useless
2715#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
2716trap "Aborted" SIGTERM
2717DONE="\r\t\t\t\t\t\t\t\tDone.         "
2718CHOPSIZE=240
2719BIGNO=0
2720MAX_COMPRESSED_SIZE=1300
2721kernelpath=""
2722MONDO_ROOT=$TMPMONDO/mondo-root
2723mkdir -p $MONDO_ROOT
2724
2725if [ -d "/proc/lvm" ]; then
2726    # LVM v1
2727    LVMCMD=""
2728    LVM="v1"
2729elif [ -d "/dev/mapper" ]; then
2730    # LVM v2
2731    LVMCMD="lvm"
2732    LVM="v2"
2733else
2734    LVM="false"
2735fi
2736
2737if [ "$#" -ge "2" ] ; then
2738    if [ "$1" = "--max-compressed-size" ] ; then
2739        MAX_COMPRESSED_SIZE=$2
2740        shift; shift
2741    fi
2742fi
2743
2744FLOPPY_WAS_MOUNTED=""
2745for mtpt in /media/floppy /mnt/floppy /floppy ; do
2746    if mount | grep -w $mtpt &> /dev/null ; then
2747        FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
2748        umount $mtpt
2749    fi
2750done
2751
2752if [ "$#" -ne "0" ] ; then
2753    if [ "$1" = "--findkernel" ] ; then
2754        res=`TryToFindKernelPath`
2755        if [ "$res" = "" ] ; then
2756            MindiExit -1
2757        else
2758            echo "$res"
2759            MindiExit 0
2760        fi
2761    elif [ "$1" = "--makemountlist" ] ; then
2762        [ ! "$2" ] && Die "Please specify the output file"
2763        MakeMountlist $2
2764        MindiExit $?
2765    elif [ "$1" = "-V" ] || [ "$1" = "-v" ] || [ "$1" = "--version" ] || [ "$1" = "-version" ] ; then
2766        echo "Mindi v$MINDI_VERSION"
2767        MindiExit 0
2768    elif [ "$#" -ge "9" ] && [ "$1" = "--custom" ] ; then
2769        MONDO_TMP=$2
2770        # Change MINDI_TMP for the one provided by mondo
2771        # So that it can get back the built files
2772        rm -rf $MINDI_TMP
2773        MINDI_TMP=$MONDO_TMP
2774        FDISKLOG=$MINDI_TMP/parted2fdisk.log
2775        CACHE_LOC=$3
2776        if [ _"$CACHE_LOC" != _"" ]; then
2777            mkdir -p $CACHE_LOC
2778        fi
2779        kernelpath=$4; [ "$kernelpath" = "(null)" ] && kernelpath=""
2780###
2781### Sq-Modification...
2782### Attempt to locate kernel specific module path
2783### if module path is found then use it other wise use uname -r to set it...
2784###
2785        kernelname=`echo $kernelpath | cut -d'-' -f2-`
2786        LogIt "kernelname = $kernelname\n"
2787        LogIt "kernelpath = $kernelpath\n"
2788        if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
2789        then
2790           LogIt "Module path for ${kernelpath} not found...\n"
2791           LogIt "using running kernel\'s modules.\n"
2792           kernelname=`uname -r`
2793        else
2794           LogIt "Using modules for kernel: ${kernelname}\n"
2795        fi
2796###
2797### end of Sq-Modification
2798###
2799        TAPEDEV=$5
2800        TAPESIZE=$6
2801        FILES_IN_FILELIST=$7
2802        USE_LZO=$8
2803        CDRECOVERY=$9
2804        if [ "${10}" = "(null)" ] || [ "${10}" = "" ] ; then
2805            IMAGE_DEVS=""
2806        else
2807            IMAGE_DEVS="`echo "${10}" | tr '|' ' '`"
2808        fi
2809        if [ "${11}" ] ; then
2810            LILO_OPTIONS=""
2811    #       LogIt "LILO will use conservative settings, to be compatible with older BIOSes."
2812        fi
2813        LAST_FILELIST_NUMBER=${12}
2814        ESTIMATED_TOTAL_NOOF_SLICES=${13}
2815        EXCLUDE_DEVS="${14}"
2816        USE_COMP="${15}"
2817        USE_LILO="${16}"
2818        USE_STAR="${17}"
2819        INTERNAL_TAPE_BLOCK_SIZE="${18}"
2820        DIFFERENTIAL="${19}"
2821        NOT_BOOT="${20}"
2822        [ "$USE_COMP" = "" ] && USE_COMP=yes
2823        [ "$NOT_BOOT" = "" ] && NOT_BOOT=no
2824        [ "$TAPEDEV" ] && LogIt "This is a tape-based backup. Fine.\n"
2825        [ "$kernelpath" = "" ] && kernelpath=`TryToFindKernelPath`
2826        kernelname=`echo $kernelpath | cut -d'-' -f2-`
2827        if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
2828        then
2829           LogIt "Module path for ${kernelpath} not found...\n"
2830           LogIt "using running kernel\'s modules.\n"
2831           kernelname=`uname -r`
2832        else
2833           LogIt "Using modules for kernel: ${kernelname}\n"
2834        fi
2835        [ "$CDRECOVERY" = "yes" ] && [ "$TAPEDEV" != "" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
2836        MONDO_ROOT=`echo $CACHE_LOC | sed 's/\(.*\)\/.*/\1/'`
2837        if [ _"$MONDO_ROOT" != _"" ]; then
2838            mkdir -p $MONDO_ROOT
2839        else
2840            Die "MONDO_ROOT is undefined"
2841        fi
2842    else
2843        echo "Syntax: mindi (--custom ....)" >> /dev/stderr
2844        MindiExit -1
2845    fi
2846fi
2847#ScanCDandTape
2848[ "$CDRECOVERY" = "yes" ] || CDRECOVERY=no
2849if [ "$CDRECOVERY" = "yes" ] ; then
2850    iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
2851    sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
2852else
2853    iso_cfg_file=$MINDI_LIB/isolinux.cfg
2854    sys_cfg_file=$MINDI_LIB/syslinux.cfg
2855fi
2856
2857
2858[ -e "$iso_cfg_file" ] || Die "Cannot find $iso_cfg_file"
2859if [ ! "`DidMondoCallMe`" ] ; then
2860    LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION\n"
2861    LogIt "Latest Mindi is available from http://www.mondorescue.org\n"
2862    LogIt "BusyBox sources are available from http://www.busybox.net\n"
2863    LogIt "------------------------------------------------------------------------------"
2864else
2865    echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> /var/log/mondo-archive.log
2866fi
2867
2868# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
2869insmod /lib/modules/`uname -r`/*/*/misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
2870for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
2871    insmod $i >> $LOGFILE 2>> $LOGFILE
2872done
2873
2874KERN_DISK_MADE=""
2875
2876echo "DIFFERENTIAL = $DIFFERENTIAL" >> $LOGFILE
2877echo "INTERNAL TAPE BLOCK SIZE = $INTERNAL_TAPE_BLOCK_SIZE" >> $LOGFILE
2878echo "NOT_BOOT = '$NOT_BOOT'" >> $LOGFILE
2879if [ "$NOT_BOOT" != "" ] && [ "$NOT_BOOT" != "0" ] && [ "$NOT_BOOT" != "no" ] ; then
2880    LogIt "Just creating mondo-restore.cfg and a small all.tar.gz for Mondo. Nothing else.\n"
2881    MakeMondoConfigFile $MINDI_TMP/mondo-restore.cfg
2882    MakeMountlist $MINDI_TMP/mountlist.txt
2883    mkdir -p $MINDI_TMP/small-all/tmp
2884    cd $MINDI_TMP/small-all
2885    cp -f $MINDI_TMP/{mountlist.txt,mondo-restore.cfg,filelist.full.gz,biggielist.txt} tmp || Die "Cannot copy small all.tar.gz"
2886    tar -cv tmp | gzip -9 > $MINDI_TMP/all.tar.gz || Die "Cannot make small all.tar.gz"
2887    sleep 2
2888    LogIt "Done. Exiting.\n"
2889    MindiExit 0
2890fi
2891
2892if [ "$kernelpath" = "" ] ; then
2893    [ "`DidMondoCallMe`" ] && Die "Please use -k <path> to specify kernel."
2894    if [ $USE_OWN_KERNEL != "yes" ]; then
2895        echo -en "Do you want to use your own kernel to build the boot disk (y/n) ?"
2896        read ch
2897        if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
2898            USE_OWN_KERNEL="yes"
2899        fi
2900    fi
2901    if [ "$USE_OWN_KERNEL" = "yes" ]; then
2902        YOUR_KERNEL_SUCKS=""
2903        kernelpath=`TryToFindKernelPath`
2904        if [ "$kernelpath" = "" ] ; then
2905            echo -n "Please enter kernel path : "
2906            read kernelpath
2907        fi
2908    else
2909        YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
2910    fi
2911fi
2912if [ ! "`DidMondoCallMe`" ] ; then
2913    echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/n) ?"
2914    read ch
2915    if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
2916        USE_LILO=yes
2917    else
2918        USE_LILO=no
2919    fi
2920fi
2921if [ "$YOUR_KERNEL_SUCKS" != "" ] || [ "$kernelpath" = "" ] || [ "$kernelpath" = "SUCKS" ] || [ "$kernelpath" = "FAILSAFE" ] ; then
2922    kernelpath=$MINDI_LIB/vmlinuz
2923    LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks.\n"
2924    LogIt "However, you are still running your kernel. If Mindi fails to create your\n"
2925    LogIt "disks then it may still be a result of a problem with your kernel.\n"
2926    pwd=`pwd`
2927    cd $MINDI_TMP
2928    bzip2 -dc $MINDI_LIB/lib.tar.bz2 | tar -x || Die "Cannot unzip lib.tar.bz2"
2929    cd $pwd
2930    YOUR_KERNEL_SUCKS="Your kernel sucks"
2931fi
2932echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$CACHE_LOC" >> $LOGFILE
2933[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty...\n"
2934
2935[ "$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."
2936
2937rm -f /root/images/mindi/{*img,*gz,*iso}
2938
2939PrepareDataDiskImages $CACHE_LOC
2940noof_disks=$?
2941ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
2942rds=$(($ramdisk_size-$((ramdisk_size%4096))))
2943ramdisk_size=$rds
2944
2945echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
2946if [ "$USE_LILO" = "yes" ] ; then
2947    if [ "$ARCH" = "ia64" ] ; then
2948        PrepareBootDiskImage_LILO $CACHE_LOC $IA64_BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create ia64 floppy disk image."
2949    else
2950        if ! PrepareBootDiskImage_LILO $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
2951            LogIt "Warning - failed to create 1.72MB boot image. Please reduce your kernel's size\n"
2952            LogIt "if you want to make a 1.72MB floppy disk.\n"
2953        fi
2954        if ! PrepareBootDiskImage_LILO $CACHE_LOC 2880 $kernelpath $ramdisk_size ;  then
2955            LogIt "Warning - failed to create 2.88MB floppy disk image.\n"
2956            LogIt "Please reduce your kernel's size\n"
2957            LogIt "if you want to make a 2.88MB floppy disk.\n"
2958            PrepareBootDiskImage_LILO $CACHE_LOC 5760 $kernelpath $ramdisk_size || Die "Failed to create 2.88MB floppy disk image."
2959        fi
2960    fi
2961else
2962    if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 1722 $kernelpath $ramdisk_size ; then
2963        LogIt "Warning - failed to create 1.72MB boot image. Please reduce your kernel's size\n"
2964        LogIt "if you want to make a 1.72MB floppy disk.\n"
2965        if ! PrepareBootDiskImage_SYSLINUX $CACHE_LOC 2880 $kernelpath $ramdisk_size ; then
2966            LogIt "Warning - failed to create 2.88MB floppy disk image.\n"
2967            LogIt "Please reduce your kernel's size\n"
2968            LogIt "if you want to make a 2.88MB floppy disk.\n"
2969            PrepareBootDiskImage_SYSLINUX $CACHE_LOC 5760 $kernelpath $ramdisk_size || Die "Failed to create 5.76MB floppy disk image."
2970        fi
2971    fi
2972fi
2973
2974[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
2975...Or type 'memtest' to test your PC's RAM thoroughly.\n"
2976
2977if [ ! "`DidMondoCallMe`" ] ; then
2978    ListImagesForUser $CACHE_LOC
2979    boot_dev=/dev/fd0u1722
2980    [ ! -e "$boot_dev" ] && mknod $boot_dev b 2 60
2981    [ ! -e "$boot_dev" ] && boot_dev=/dev/fd0H1722
2982    [ ! -e "$boot_dev" ] && Die "Oh Lord, will you PLEASE tell the vendor to create the 1.72MB devices in /dev?"
2983    if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
2984        OfferToCopyImagesToDisks $CACHE_LOC $boot_dev $FDDEVICE
2985    fi
2986    OfferToMakeBootableISO $CACHE_LOC
2987    LogIt "Finished.\n"
2988elif [ "$TAPEDEV" ] ; then
2989    mkdir -p /root/images/mindi
2990    rm -f /root/images/mindi/{*img,*gz,*iso}
2991    OfferToMakeBootableISO $CACHE_LOC
2992    if [ -e "$CACHE_LOC/all.tar.gz" ] ; then
2993        cp -f $CACHE_LOC/all.tar.gz $MINDI_TMP/
2994    else
2995        Die "Cannot find all.tar.gz, to be written to tape"
2996    fi
2997else
2998    OfferToMakeBootableISO $CACHE_LOC
2999fi
3000# cleanup
3001LogIt "$FRIENDLY_OUTSTRING\n"
3002for mtpt in $FLOPPY_WAS_MOUNTED ; do
3003    mount $mtpt
3004done
3005MindiExit 0
Note: See TracBrowser for help on using the repository browser.