source: branches/2.2.2/mindi/mindi @ 1301

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

Attempt to fix a bug where losetup is called with only one parameter (Cf: #140)

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