source: branches/stable/mindi/mindi @ 1408

Last change on this file since 1408 was 1408, checked in by bruno, 12 years ago
  • Fix a Debian packaging bug
  • Do not use mindi-boot.2880.img (which may not exist) anymore in mondorestore
  • Adds a debuging message for image_devs for mondo
  • Adds some useful log info for debugging at restore time in init
  • Debian stores its optimised libraries in /lib/i686/cmov now. (Andree Leidenfrost)
  • Fix a bug on lsmod | sed. (Andree Leidenfrost). As a consequence, lsmod is not used anymo

re in mindi (except for log). Replaced by /proc/modules. And the MODULES variable is now us
ed to avoid code duplication.

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