source: branches/2.2.3/mindi/mindi @ 1349

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

Better log file content in mondoarchive.log from the copy of the mindi log

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