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

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

Remove useless functions
Solve some MINDI_TMP issues

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