source: branches/stable/mindi/mindi @ 1193

Last change on this file since 1193 was 1193, checked in by bruno, 12 years ago

Remove some useless \r in code
Remove center_string usage as it's now broiken for dynamically created strings

  • Property svn:keywords set to Rev Id
File size: 112.9 KB
Line 
1#!/bin/bash
2
3# $Id: mindi 1193 2007-02-20 11:24:22Z bruno $
4#
5#-----------------------------------------------------------------------------
6# mindi - mini-Linux distro based on the user's filesystem & distribution
7#
8# Mindi can create a multi-floppy boot/root kit. The first floppy is the boot
9# disk: it contains a kernel, a ramdisk etc. The second disk is data disk #1;
10# the third disk is data disk #2; and so it goes.
11#
12# See http://www.mondorescue.org for details.
13#-----------------------------------------------------------------------------
14
15### Which arch are we on (useful for ia64 port)
16ARCH=`/bin/arch`
17
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
85IA64_BOOT_SIZE=$mindi_ia64_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"
112
113BOOT_MEDIA_MESSAGE="$mindi_boot_msg"
114FDISK=$MINDI_SBIN/parted2fdisk
115MINDI_TMP=`mktemp -d $TMPDIR/mindi.XXXXXXXXXX`
116
117# ----------------------------------------------------------------------------
118
119
120AbortHere() {
121    [ "$mountpoint" ] && umount $mountpoint 2>> $LOGFILE
122    Die "Program is terminating in response to signal received from OS/user"
123}
124
125
126HackSyslinuxFile() {
127    local incoming
128    incoming=`ReadLine`
129    while [ "$incoming" ] ; do
130        echo -en "$incoming" | sed s/24000/$1/
131        if [ "`echo "$incoming" | grep append`" ] ; then
132            echo -en " $ADDITIONAL_BOOT_PARAMS"
133        fi
134        echo -en "\n"
135        incoming=`ReadLine`
136    done
137    if [ -e "$MINDI_LIB/memtest.img" ] ; then
138        echo -en "label memtest\n  kernel memdisk\n  append initrd=memtest.img\n\n"
139    fi
140}
141
142
143Aborted() {
144    trap SIGHUP SIGTERM SIGTRAP SIGINT
145    [ "$MINDI_CACHE" != "" ] && rm -f $MINDI_CACHE/mindi*img $MINDI_CACHE/*gz $MINDI_CACHE/mindi.iso
146    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
147    Die "User abort."
148}
149
150
151AddFileToDir() {
152    local filename minidir_root noof_disks diskno res filesize disksize would_occupy zipsize complevel cutoff compressed_fname siz
153    filename=$1
154    minidir_root=$2
155    noof_disks=$3
156
157    diskno=$noof_disks
158    mkdir -p $minidir_root/$diskno
159    [ "$LAST_COMPRESSED_SIZE" = "" ] && LAST_COMPRESSED_SIZE=0
160    if [ ! -e "$filename" ] ; then
161        if [ -h "$filename" ] ; then
162            cp --parents -pRdf $filename $minidir_root/$diskno 2>> $LOGFILE
163            return $noof_disks
164        else
165            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?"
166        fi
167    fi
168
169    # move to the disk that has room on it (or end up using the last, if all full)
170    while [ "$diskno" -lt "40" ] ; do
171        mkdir -p $minidir_root/$diskno
172        filesize=`du -sk $filename | cut -f1`
173        cp --parents -Rdf $filename $minidir_root/$diskno 2>> $LOGFILE
174        if [ "$filesize" -le "4" ] ; then
175            siz=$filesize
176        elif [ ! -f "$filename" ] ; then
177            siz=0
178        else
179            siz=`grep -m 1 "$filename.gz$" $minidir_root/compressed/compressed.txt | cut -f1`
180            [ "$siz" = "" ] && Die "FIXME - can't find $filename's size."
181            siz=$(($siz-2));# to allow for sectors & the fact that they round up
182        fi
183        [ ! "$siz" ] && siz=4
184        [ "$siz" -lt "0" ] && siz=0
185        LAST_COMPRESSED_SIZE=$(($LAST_COMPRESSED_SIZE+$siz))
186        [ "$LAST_COMPRESSED_SIZE" -le "$MAX_COMPRESSED_SIZE" ] &&return $diskno
187        echo "disk=$diskno siz=$LAST_COMPRESSED_SIZE" >> $LOGFILE
188        LAST_COMPRESSED_SIZE=0
189        rm -f $minidir_root/$diskno/$filename
190        diskno=$(($diskno+1))
191    done
192    return 0 ; # failed
193}
194
195
196AddKeyboardMappingFile() {
197    local mappath r included_list included_item i res ii sss
198    mappath=$1
199    KBDEPTH=$(($KBDEPTH+1))
200    [ "$KBDEPTH" -gt "128" ] && Die "Edit $MINDI_SBIN/mindi and disable FindAndAddUserKeyboardMappingFile (line 2160, approx.)"
201    if [ -e "$bigdir/$mappath" ] ; then
202        echo "$mappath already added" >> $LOGFILE
203        return
204    elif [ -d "$bigdir/$mappath" ] ; then
205        echo "Cannot add $mappath: it's a directory. Sorry."
206        return
207    fi
208    echo "Added kbd map $mappath" >> $LOGFILE
209    if [ ! -e "$mappath" ] ; then
210            mappath=`grep "i[3-8]86" $MINDI_TMP/keymaps.find | grep "$locale[^r][^/]" | grep -vx " *#.*"`
211        if [ ! -e "$mappath" ] ; then
212            LogIt "Cannot add $mappath: kbd map file not found"
213            return
214        fi
215    else
216        echo -en "`basename $mappath | tr '.' '#' | sed s/#kmap#gz// | sed s/#inc#gz//` " | tr '#' '.'
217    fi
218
219    mkdir -p $bigdir/etc
220    cp --parents -pRdf $mappath $bigdir 2>> $LOGFILE || LogIt "AKMF -- Could not copy $mappath to $bigdir"
221    if [ "`echo $mappath | grep -F ".gz"`" ] ; then
222        included_list=`gzip -dc $mappath | grep -Fi include | sed s/'"'// | sed s/'"'// | cut -d' ' -f2`
223    else
224        included_list=`grep -Fi include $mappath | sed s/'"'// | sed s/'"'// | cut -d' ' -f2`
225    fi
226    for included_item in $included_list ; do
227        if [ ! -e "$included_item" ] ; then
228                sss=`grep -F "${included_item}.inc" $MINDI_TMP/keymaps.find`
229            [ "$sss" = "" ] && sss=`grep -F "$included_item" $MINDI_TMP/keymaps.find`
230            for ii in $sss ; do
231                [ -e "$ii" ] && AddKeyboardMappingFile $ii
232            done
233        else
234            AddKeyboardMappingFile $included_item
235        fi
236    done
237}
238
239
240ChopUpAndCopyFile() {
241    local filename slicesize outdir res biggienumber filesize sliceno noof_slices testfile scratchfile
242    filename=$1
243    outdir=$2
244    slicesize=$3
245    biggienumber=$4
246
247    [ -d "$filename" ] && Die "Cannot chop up $filename: it's a directory. Please amend $DEPLIST_FILE accordingly."
248    mkdir -p $outdir
249
250    sliceno=0
251    scratchfile=$MINDI_TMP/blah.$$.dat
252    cp -f $filename $scratchfile 2>> $LOGFILE || Die "CUACF -- cannot copy $filename to $scratchfile - did you run out of disk space?"
253    [ "`head $scratchfile -n1 | grep -F "bin/sh"`" != "" ] && StripComments $scratchfile "-$filename-"
254    [ "`echo "$filename" | grep -F "etc/termcap"`" != "" ] && StripComments $scratchfile "-$filename-"
255    if [ "`echo "$filename" | grep -F "lib/modules/" | grep "\.*o\.gz"`" != "" ] ; then
256        mv $scratchfile $scratchfile.gz
257        gunzip -f $scratchfile || LogIt "Cannot gunzip $scratchfile.gz"
258        filename=`echo "$filename" | tr '.' '#' | sed s/#o#gz/#o/ | sed s/#ko#gz/#ko/ | tr '#' '.'`
259    fi
260    filesize=`du -sk $scratchfile | cut -f1`
261    noof_slices=$(($filesize/$slicesize))
262    echo "$filename" > $outdir/slice-$biggienumber.name
263    echo "$filesize" > $outdir/slice-$biggienumber.size
264    [ -x "$scratchfile" ] && StripExecutable $scratchfile "-$filename-"
265    while [ "$sliceno" -le "$noof_slices" ] ; do
266        dd if=$scratchfile skip=$(($sliceno*$slicesize)) of=$outdir/slice-$biggienumber.`printf "%03d" $sliceno` bs=1k count=$slicesize &> /dev/null
267        sliceno=$(($sliceno+1))
268    done
269    rm -f $scratchfile
270}
271
272
273CopyBootBFile() {
274    local copy_to copy_from possible_locations liloc
275    copy_to=$1
276    copy_from=/boot/boot.b
277    liloc=`which lilo.real 2>/dev/null`
278    [ $liloc ] || liloc=`which lilo 2>/dev/null`
279    if [ $liloc ]; then
280        if ! [ `strings $liloc | grep "boot\.b"` ]; then
281            LogIt "boot.b files built into lilo; I'll create a dummy."
282            > $copy_to
283            return 0
284        fi
285    fi
286    if [ ! -f "$copy_from" ] ; then
287        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"
288        copy_from=`grep install= /etc/lilo.conf | grep "\.b" | cut -d'=' -f2`
289        if [ ! -f "$copy_from" ] ; then
290            LogIt "Nor can I find it from your /etc/lilo.conf file. This is very odd."
291            copy_from=`FindSensibleBootBFile`
292            LogIt "I'm going to use '$copy_from'"
293        fi
294    fi
295    cp -f $copy_from $copy_to 2>> $LOGFILE || LogIt "CBBF -- warning -- cannot find your boot.b file. That's it, I quit... (j/k)"
296}
297
298
299CopyDependenciesToDirectory() {
300    local outdir incoming fname filesize counter
301    outdir=$1
302    mkdir -p $outdir
303    incoming=`ReadLine`
304    counter=0
305    while [ "$incoming" != "" ] ; do
306        if [ -d "$incoming" ] ; then
307            find $incoming/* -maxdepth 0 2> /dev/null | CopyDependenciesToDirectory $outdir
308        elif [ -e "$incoming" ] ; then
309            filesize=`du -sk $incoming | cut -f1`
310            if [ "$filesize" -gt "$(($CHOPSIZE*2))" ] && [ ! -h "$incoming" ] ; then
311                ChopUpAndCopyFile $incoming $outdir $CHOPSIZE $BIGNO
312                BIGNO=$(($BIGNO+1))
313            else
314                cp --parents -Rdf $incoming $outdir 2> /dev/null || Die "Cannot copy $incoming to $outdir - did you run out of disk space?"
315                if [ "`echo "$incoming" | grep "lib/modules/.*\..*o\.gz"`" != "" ] ; then
316                    gunzip -f $outdir/$incoming || LogIt "Cannot gunzip $outdir/$incoming"
317                fi
318                [ -x "$outdir" ] && StripExecutable $outdir "-$filename-"
319            fi
320            counter=$(($counter+1))
321            if [ "$counter" -ge "5" ] ; then
322                counter=0
323                echo -en "."
324            fi
325        fi
326        incoming=`ReadLine`
327    done
328}
329
330
331CopyImageToDisk() {
332    local image dev procno res comment
333    image=$1
334    dev=$2
335    comment=$3
336    [ ! -f "$image" ] && [ ! -b "$image" ] && Die "Image $image does not exist. Did you run out of disk space?"
337    Prompt "About to write $comment. Please press ENTER."
338    echo -en "Formatting disk..."
339    if which fdformat > /dev/null ; then
340        fdformat -n $dev > /dev/null 2> /dev/null || Die "Cannot format $dev - is your Linux distro broken?"
341    elif which superformat > /dev/null ; then
342        superformat $dev > /dev/null 2> /dev/null || Die "Cannot format $dev - is your Linux distro broken?"
343    else
344        Die "Please install either fdformat or superformat."
345    fi
346    echo -en "\nWriting $comment"
347    if echo $image | grep "mindi-[r|b]oot\.1440" &> /dev/null ; then
348        cat $image > $dev &
349    else
350        dd if=$image of=$dev &> /dev/null &
351    fi
352    procno=$!
353    ps $procno > /dev/null 2> /dev/null
354    while [ "$?" -eq "0" ] ; do
355        sleep 3
356        echo -en "."
357        ps $procno > /dev/null 2> /dev/null
358    done
359    echo -e "$DONE"
360    LogIt "$comment has been written."
361}
362
363
364CountItemsIn() {
365    local r
366    r=0
367    for q in $1 ; do
368        r=$(($r+1))
369    done
370    echo $r
371}
372
373
374CreateDataDiskImagesFromTarballs() {
375    local tardir outdir diskno noof_disks kp
376    tardir=$1
377    outdir=$2
378    noof_disks=$3
379
380    mkdir -p $outdir
381    diskno=1
382    echo -en "Creating data disk "
383    while [ "$diskno" -le "$noof_disks" ] ; do
384        echo -en "#$diskno..."
385        cp -f $tardir/$diskno.tar.gz $outdir 2>> $LOGFILE || LogIt "[line 424] Cannot copy $tardir/$diskno.tar.gz to $outdir"
386        CreateOneDataDiskImage $tardir/$diskno.tar.gz $outdir/mindi-data-$diskno.img $diskno $noof_disks
387        diskno=$(($diskno+1))
388    done
389    mv -f $tardir/all.tar.gz $outdir
390    du -sk $outdir/*gz >> $LOGFILE
391    echo -e "$DONE"
392}
393
394
395
396CreateOneDataDiskImage() {
397    local tarball imagefile dev diskno noof_disks mountpoint
398    tarball=$1
399    imagefile=$2
400    diskno=$3
401    noof_disks=$4
402
403    mountpoint=$MINDI_TMP/mountpoint.$$
404    mkdir -p $mountpoint
405    dd if=/dev/zero of=$imagefile bs=1k count=1440 &> /dev/null || LogIt "Cannot dd (CODI)"
406    echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
407    mke2fs -N 12 -F $imagefile >> $LOGFILE 2>> $LOGFILE
408    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."
409    mv $tarball $mountpoint/
410    if [ "$?" -ne "0" ] ; then
411        umount $mountpoint
412        rmdir $mountpoint
413        Die "Tarball $tarball is too big for disk! (CODI)\nAdjust mindi_max_compressed_size in your $MINDI_CONFIG"
414    fi
415    [ "$diskno" -eq "$noof_disks" ] && echo "This is the last disk ($diskno=$noof_disks)" >> $mountpoint/LAST-DISK
416    umount $mountpoint || LogIt "Cannot umount (CODI)"
417    rmdir $mountpoint || LogIt "Cannot rmdir (CODI)"
418}
419
420# Last function called before exiting
421# Parameter is exit code value
422MindiExit() {
423    local my_partitions
424
425    echo "Mindi $MINDI_VERSION is exiting" >> $LOGFILE
426    echo "End date : `date`" >> $LOGFILE
427
428    sync
429    cd /
430
431    # Unmount whtat could remain mounted
432    my_partitions=`mount | grep -F $$ | cut -f1 -d' '`
433    [ "$my_partitions" != "" ] && umount $my_partitions
434    # Clean temporary files only when standalone mindi
435    if [ _"$MINDI_TMP" != _"$MONDO_TMP" ]; then
436        rm -Rf $MINDI_TMP
437    fi
438    exit $1
439}
440
441Die() {
442    local i
443    if [ "$1" = "" ] ; then
444        LogIt "FATAL ERROR"
445    else
446        LogIt "FATAL ERROR. $1"
447    fi
448
449    # Creates a tar file containing all required files
450    for i in $MY_FSTAB /etc/lilo.conf /etc/raidtab $LOGFILE /var/log/mondo-archive.log ; do
451        [ -e "$i" ] && cp -f $i $MINDI_TMP 2>> $LOGFILE
452    done
453    rm -f $TMPDIR/mindi.err.*.tgz
454    tar -cf - $MINDI_TMP | gzip -9 > $TMPDIR/mindi.err.$$.tgz
455    LogIt "Please e-mail a copy of $TMPDIR/mindi.err.$$.tgz 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 s/i[5-7]86// | 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="`lsmod | sed -n '2,$s/ .*//'`"
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 lsmod | 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="`lsmod | sed -n '2,$s/ .*//'`"
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|5760'`
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.$IA64_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
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    losetup /dev/loop0 > /dev/null 2> /dev/null
1815    [ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing 'losetup /dev/loop0 -d'.\nReboot if necessary."
1816    CopyBootBFile $mtpt/boot.b
1817
1818    MakeLiloConfFile $disksize >> bdlilo.conf
1819
1820    chmod 644 bdlilo.conf
1821    MakeMessageFile $disksize > message
1822    lilo -v -C bdlilo.conf -r $mtpt
1823    res=$?
1824
1825    cd $old_pwd
1826    umount $mtpt
1827    mv -f $image $2
1828    rmdir $mtpt
1829
1830    return $res
1831}
1832
1833
1834MakeLiloConfFile() {
1835    local disksize options i ooo
1836    disksize=$1
1837    options=""
1838
1839    if [ "$ARCH" != "ia64" ] ; then
1840        echo -en "boot=/dev/loop0\ndisk=/dev/loop0\n"
1841    fi
1842    if [ "$disksize" -eq "2880" ] ; then
1843        echo -en "bios=0x00\nsectors=36\nheads=2\ncylinders=80\n"
1844    elif [ "$disksize" -gt "2880" ] ; then
1845        /bin/true
1846    else
1847        echo -en "bios=0x00\nsectors=18\nheads=2\ncylinders=80\n"
1848    fi
1849    if [ "$ARCH" != "ia64" ] ; then
1850        echo -en "install=/boot.b\nmap=/boot.map\n"
1851    fi
1852    if [ "$CDRECOVERY" = "yes" ] ; then
1853        echo -en "default=RESTORE\n"
1854    elif [ "$disksize" -gt "2880" ] && [ _"$MONDO_SHARE" != _"" ]; then
1855        if [ "$NFS_DEV" != "" ] ; then
1856            echo -en "default=iso\n"
1857        else
1858            echo -en "default=interactive\n"
1859        fi
1860    else
1861        echo -en "default=expert\n"
1862    fi
1863
1864    echo -en "prompt\n"
1865    if [ "$ARCH" != "ia64" ] ; then
1866        echo -en "vga=normal\nbackup=/dev/null\nmessage=/message\n"
1867    fi
1868    if [ "$CDRECOVERY" != "yes" ] ; then
1869        echo -en "timeout=300\n"
1870    fi
1871    echo -en "\n"
1872    if [ "$CDRECOVERY" = "yes" ] ; then
1873        options="RESTORE expert"
1874    elif [ "$disksize" -gt "2880" ] ; then
1875        if [ _"$MONDO_SHARE" != _"" ]; then
1876            if [ "$NFS_DEV" != "" ] ; then
1877                options="iso"
1878            else
1879                options="interactive expert compare iso nuke isonuke"
1880# hda hdb hdc hdd"
1881            fi
1882        else
1883            options="expert"
1884        fi
1885    else
1886        options="expert"
1887    fi
1888    for i in $options ; do
1889        ooo=$i
1890        [ "$ooo" = "RESTORE" ] && ooo="nuke"
1891        if [ "$ARCH" = "ia64" ] ; then
1892            rootpart="root=/dev/ram0\n\t"
1893        else
1894            rootpart=""
1895        fi
1896        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"
1897   
1898        outstr=$outstr" $ooo_mode"
1899        outstr=$outstr"\"\n"
1900        if [ "$disksize" = "1440" ] ; then
1901            echo -en "$outstr" | sed s/initrd=.*// | grep -v root=
1902        else
1903            echo -en "$outstr"
1904        fi
1905    done
1906}
1907
1908
1909PrepareBootDiskImage_LILO() {
1910    local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size liloconf
1911    imagesdir=$1
1912    disksize=$2
1913    kernelpath=$3
1914    ramdisksize=$4
1915
1916    retval=0
1917    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
1918    echo -en "Making "$disksize"KB boot disk..."
1919    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?"
1920    if [ "$ARCH" != "ia64" ] ; then
1921        [ "$disksize" != "2880" ] && [ "$disksize" != "5760" ] && Die "PDBI - disksize is $disksize - bad size"
1922    fi
1923    echo -en "..."
1924    imagefile=$imagesdir/mindi-bootroot.$disksize.img
1925    mountpoint=$MINDI_TMP/mountpoint.$$
1926    mkdir -p $mountpoint
1927    dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null || Die "Cannot dd blank file"
1928    if [ "$ARCH" = "ia64" ] ; then
1929        mkdosfs $imagefile >> $LOGFILE 2>> $LOGFILE
1930        t=vfat
1931    else
1932        echo "Creating ext2 filesystem on $imagefile" >> $LOGFILE
1933        mke2fs -N 26 -m 0 -F $imagefile >> $LOGFILE 2>> $LOGFILE
1934        t=ext2
1935    fi
1936    mount -t $t -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
1937    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
1938    mkdir -p $mountpoint/etc
1939    if [ "$ARCH" != "ia64" ] ; then
1940        liloconf=$mountpoint/etc/lilo.conf
1941    else
1942        liloconf=$mountpoint/elilo.conf
1943    fi
1944    old_pwd=`pwd`
1945    cd $mountpoint
1946    if [ "$ARCH" != "ia64" ] ; then
1947        tar -zxf $MINDI_LIB/dev.tgz || LogIt "Cannot untar dev.tgz"
1948    fi
1949    cd $old_pwd
1950    losetup /dev/loop0 > /dev/null 2> /dev/null
1951    [ "$?" -eq "0" ] || losetup /dev/loop0 -d || Die "Please free up /dev/loop0 by typing   'losetup /dev/loop0 -d'.\nReboot if necessary."
1952    CopyBootBFile $mountpoint/boot.b
1953
1954    MakeLiloConfFile $disksize > $liloconf
1955
1956    # Copy it so that CD-ROM menu entry is satisfied
1957    if [ "$ARCH" = "ia64" ] ; then
1958        mountefi=0
1959        df -T | grep /boot/efi | grep -q vfat
1960        if [ $? -ne 0 ]; then
1961            mount /boot/efi
1962            if [ $? -ne 0 ]; then
1963                echo "You have to mount your EFI partition when using mindi"
1964                MindiExit -1
1965            fi
1966            mountefi=1
1967        fi
1968        cp /boot/efi/elilo.efi $mountpoint
1969        cp $liloconf $mountpoint/elilo.efi $mountpoint/efi/boot
1970        if [ $mountefi -eq 1 ]; then
1971            umount /boot/efi 2>&1 > /dev/null
1972        fi
1973    fi
1974
1975    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint..." >> $LOGFILE
1976    cp -f $MINDI_TMP/mindi.rdz $mountpoint 2>> $LOGFILE
1977    if [ "$?" -ne "0" ] ; then
1978        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
1979        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
1980        LogIt "Please unload some of your modules and try again."
1981        rm -f $MINDI_TMP/mtpt.$$
1982        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
1983        retval=$(($retval+1))
1984    fi
1985    MakeMessageFile $disksize > $mountpoint/message
1986
1987    mkdir -p $mountpoint/tmp
1988    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
1989    if [ -e "$MINDI_LIB/memtest.img" ] ; then
1990        echo -en "image=/memtest.bin\nlabel=memtest\nn" >> $liloconf
1991        echo -en "image=/memdisk\nlabel=memtest\nappend=\"initrd=memtest.img\"\n" >> $liloconf
1992#        echo "Yep, this is a multi-function CD" > $mountpoint/MULTIFUNC
1993    fi
1994
1995    # copy the kernel across
1996    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
1997    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
1998    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
1999    cp -f $kernelpath $mountpoint/vmlinuz > /dev/null 2> /dev/null
2000    if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
2001        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
2002        du -sk $mountpoint/* >> $LOGFILE
2003        echo "--- end of list of files ---" >> $LOGFILE
2004        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
2005Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
2006        rm -f $mountpoint/vmlinuz
2007        cd $old_pwd
2008        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2009        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2010    #   losetup /dev/loop0 -d
2011        res=0
2012        write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
2013        res=$(($res+$?))
2014        cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
2015        res=$(($res+$?))
2016        rm -f $imagefile
2017        if [ "$res" -ne "0" ]; then
2018            LogIt "WARNING - failed to create 1.44MB boot/root floppies"
2019            rm -f $imagesdir/mindi-*.1440.img
2020        fi
2021        return $res
2022    fi
2023    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2024    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
2025    echo "Free space left on floppy = $free_space KB" >> $LOGFILE
2026    echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
2027# make it bootable
2028    rm -f $mountpoint/zero
2029    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
2030    if [ "$disksize" -gt "2880" ] && [ ! "$KERN_DISK_MADE" ] ; then
2031        if [ "$ARCH" != "ia64" ] ; then
2032        $LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
2033        else
2034            /bin/true
2035        fi
2036    elif [ ! "$KERN_DISK_MADE" ] ; then
2037# 12/28/2001 - if 1.72MB floppy then don't use LILO's optimizations at all
2038        $LILO_EXE -r $mountpoint >> $LOGFILE 2>> $LOGFILE
2039    else
2040        echo "Not running LILO. It's not that kind of disk." >> $LOGFILE
2041    fi
2042
2043    # BERLIOS  does not test necessarily what it expects
2044    if [ $? -ne "0" ] ; then
2045        if [ "`grep -F "/tmp/dev.0" $LOGFILE`" ] ; then
2046            LogIt "The '/tmp/dev.0' error is NOT Mindi's fault. It is LILO's."
2047            LogIt "Please reboot your PC as a workaround."
2048            Die "LILO sneezed and Mindi caught a cold. Please read the README / FAQ."
2049        fi
2050        echo "$LILO_EXE -r $mountpoint ...failed."
2051        echo -en "Press ENTER to continue."; read line
2052        LogIt "Cannot run lilo on $mountpoint\nPlease upgrade/downgrade your version of LILO. It has a bug."
2053        retval=$(($retval+1))
2054    fi
2055    cp -f $liloconf $MINDI_TMP/lilo.conf 2>> $LOGFILE
2056    if [ "$ARCH" = "ia64" ] ; then
2057        cp `dirname $kernelpath`/*.efi $mountpoint 2>> $LOGFILE
2058    fi
2059    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2060    echo -en "..."
2061    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2062    if [ "$retval" -eq "0" ] ; then
2063        echo -en "...$DONE\n"
2064        if [ "$KERN_DISK_MADE" ] ; then
2065            LogIt "$disksize KB boot disks were created OK\n"
2066        fi
2067    else
2068        echo -en "...failed\n"
2069        LogIt $disksize"KB boot disk was NOT created\n"
2070        rm -f $imagefile
2071    fi
2072    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2073    return $retval
2074}
2075
2076
2077PrepareBootDiskImage_SYSLINUX() {
2078    local disksize imagesdir dev imagefile mountpoint fname i kernelpath ramdisksize cfg_file testpath options retval outstr old_pwd ooo max_kernel_size bootimage
2079    imagesdir=$1
2080    disksize=$2
2081    kernelpath=$3
2082    ramdisksize=$4
2083    do_boot_root_thingy=""
2084    local retval old_pwd
2085    retval=0
2086
2087    [ ! -e "$kernelpath" ] && Die "PBDI - cannot find $kernelpath kernel"
2088    echo -en "Making "$disksize"KB boot disk..."
2089    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?"
2090    [ "$disksize" != "2880" ] && [ "$disksize" != "5760" ] && Die "PDBI - disksize is $disksize - bad size"
2091    echo -en "..."
2092    imagefile=$imagesdir/mindi-bootroot.$disksize.img
2093    mountpoint=$MINDI_TMP/mountpoint.$$
2094    mkdir -p $mountpoint
2095    dd if=/dev/zero of=$imagefile bs=1k count=$disksize &> /dev/null || Die "Cannot dd blank file"
2096    echo "Creating vfat filesystem on $imagefile" >> $LOGFILE
2097    mkfs.vfat $imagefile >> $LOGFILE 2>> $LOGFILE
2098    syslinux $imagefile >> $LOGFILE 2>> $LOGFILE
2099
2100    mount -t vfat -o loop $imagefile $mountpoint || LogIt "Cannot mount (PBDI)"
2101
2102    # copy Mindi's skeleton fs & lilo/syslinux/whatever stuff into it
2103    old_pwd=`pwd`
2104    MakeSyslinuxMessageFile $mountpoint/message.txt
2105    cd $mountpoint
2106    [ -e "$sys_cfg_file" ] || Die "Obi Wan, word up?"
2107    cat $sys_cfg_file | HackSyslinuxFile $ramdisk_size $mountpoint > syslinux.cfg || Die "Cannot copy syslinux.cfg from mindi_home to tmp_root"
2108    if [ "$NFS_DEV" != "" ] ; then
2109        perl -pi -e 's/interactive/iso/' syslinux.cfg
2110    fi
2111    cd $old_pwd
2112    echo "Copying $MINDI_TMP/mindi.rdz to $mountpoint/initrd.img..." >> $LOGFILE
2113    cp -f $MINDI_TMP/mindi.rdz $mountpoint/initrd.img 2>> $LOGFILE
2114    if [ "$?" -ne "0" ] ; then
2115        LogIt "Failed to copy $MINDI_TMP/mindi.rdz to $mountpoint"
2116        cat $MINDI_TMP/mtpt.$$ >> $LOGFILE
2117        LogIt "Please unload some of your modules and try again."
2118        rm -f $MINDI_TMP/mtpt.$$
2119        LogIt "Cannot incorporate mindi.rdz in bootdisk (kernel / modules too big?)"
2120        retval=$(($retval+1))
2121    fi
2122
2123    mkdir -p $mountpoint/tmp
2124    cp -f $MINDI_TMP/mondo-restore.cfg $mountpoint/tmp &> /dev/null
2125
2126    # copy the kernel across
2127    [ "$mountpoint" != "" ] && rm -Rf $mountpoint/lost+found
2128    dd if=/dev/zero of=$mountpoint/zero bs=1k count=16 &> /dev/null
2129    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2130    cp -f $kernelpath $mountpoint/vmlinuz &> /dev/null
2131    if [ "$?" -ne "0" ] || [ "$FORCE_DUAL_FLOPPIES" = "yes" ] ; then
2132        echo "Files at mountpoint ($mountpoint) :-" >> $LOGFILE
2133        du -sk $mountpoint/* >> $LOGFILE
2134        echo "--- end of list of files ---" >> $LOGFILE
2135        echo -en "Kernel size = `du -sk $kernelpath | cut -f1` K\nRamdisk free = $free_space K\n\
2136Sorry, your kernel is too big for a boot/root floppy.\nI'll try the new boot/root two-disk thingy.\n" >> $LOGFILE
2137        rm -f $mountpoint/vmlinuz
2138        cd $old_pwd
2139        umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2140        rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2141
2142        res=0
2143        write_full_floppy_of_kernel $kernelpath $imagesdir/mindi-boot.1440.img 1440
2144        res=$(($res+$?))
2145        cp -f $MINDI_TMP/mindi.rdz $imagesdir/mindi-root.1440.img 2>> $LOGFILE
2146        res=$(($res+$?))
2147        rm -f $imagefile
2148        if [ "$res" -ne "0" ]; then
2149            LogIt "WARNING - failed to create 1.44MB boot/root floppies"
2150            rm -f $imagesdir/mindi-*.1440.img
2151        fi
2152        return $res
2153    fi
2154    free_space=`df -k -P $mountpoint | tail -n1 | tr -s ' ' '\t' | cut -f4`
2155    max_kernel_size=$(($free_space+`du -sk $kernelpath | cut -f1`))
2156    echo "Free space left on floppy = $free_space KB" >> $LOGFILE
2157    echo "Max kernel size on $disksize KB floppy (est'd) = $max_kernel_size K" >> $LOGFILE
2158
2159    # make it bootable
2160    rm -f $mountpoint/zero
2161    mkdir -p $mountpoint/etc
2162    [ -e "$MINDI_LIB/memdisk" ] && cp -f $MINDI_LIB/memdisk $mountpoint 2>> $LOGFILE
2163    umount $mountpoint || Die "Cannot unmount mountpoint ($mountpoint)"
2164    echo -en "..."
2165    rmdir $mountpoint || LogIt "Cannot rmdir (PBDI)"
2166
2167    if [ "$retval" -eq "0" ] ; then
2168        echo -en "...$DONE\n"
2169        if [ "$KERN_DISK_MADE" ] ; then
2170            rm -f $imagefile
2171            LogIt "$disksize KB boot disks were created OK\n"
2172        fi
2173    else
2174        echo -en "...failed\n"
2175        LogIt $disksize"KB boot disk was NOT created\n"
2176        rm -f $imagefile
2177    fi
2178    [ "$retval" -ne "0" ] && LogIt "PrepareBootDiskImage() is returning nonzero"
2179    return $retval
2180}
2181
2182
2183PrepareDataDiskImages() {
2184    local needlist bigdir minidir_root tardir diskdir imagesdir res i j k old_pwd lines lfiles
2185
2186    imagesdir=$1
2187    rm -f $imagesdir/mindi-*.img $imagesdir/[0-9]*.tar.gz $imagesdir/mindi.iso
2188    needlist=$MINDI_TMP/what-we-need.txt
2189    bigdir=$MINDI_TMP/bigdir
2190    minidir_root=$MINDI_TMP/minidir
2191    mkdir -p $minidir_root
2192    mkdir -p $bigdir/usr/bin
2193    tardir=$MINDI_TMP/tardir
2194
2195    if [ -e "$DEPLIST_FILE" ]; then
2196        lfiles="$DEPLIST_FILE $DEPLIST_DIR/*"
2197    else
2198        lfiles="$DEPLIST_DIR/*"
2199    fi
2200    lines=`grep -vx " *#.*" $lfiles | grep -vx "" | wc -l`
2201    cat $lfiles | GenerateGiantDependencyList $needlist $lines
2202    res=$?
2203    if [ "$YOUR_KERNEL_SUCKS" ]; then
2204        pwd=`pwd`
2205        cd $MINDI_TMP
2206        for i in `ListKernelModulePaths | HackPathsToFailsafe` ; do
2207            cp --parents -pRdf ./$i $bigdir 2>> $LOGFILE || Die "PDDI can't cp $i->$bigdir"
2208            if [ "`du -sk $i | cut -f1`" -lt "$(($CHOPSIZE*2))" ] ; then
2209                cp --parents -pRdf $i $bigdir 2>> $LOGFILE
2210            else
2211                ChopUpAndCopyFile $i $bigdir $CHOPSIZE $BIGNO
2212                BIGNO=$(($BIGNO+1))
2213            fi
2214        done
2215        for i in $EXTRA_MODS ; do
2216            j=`find lib/modules/$FAILSAFE_KVER -name $i.*o 2> /dev/null`
2217            [ ! "$j" ] && echo "WARNING - cannot find failsafe module $i.o" >> $LOGFILE
2218            for k in $j ; do
2219                if [ "`du -sk $k | cut -f1`" -lt "$CHOPSIZE" ] ; then
2220                    cp --parents -pRdf $k $bigdir 2>> $LOGFILE
2221                else
2222                    ChopUpAndCopyFile $k $bigdir $CHOPSIZE $BIGNO
2223                    BIGNO=$(($BIGNO+1))
2224                fi
2225                echo "Added failsafe module $k to ramdisk" >> $LOGFILE
2226            done
2227        done
2228        cd $pwd
2229    else
2230        ListKernelModulePaths >> $needlist
2231    fi
2232    if [ "$res" -ne "0" ] ; then
2233        Die "You have $res file`PluralOrNot $res` present in dependency list\nbut absent from filesystem."
2234    fi
2235    FindAndAddUserKeyboardMappingFile
2236    mkdir -p $bigdir/tmp
2237    if [ _"$MONDO_SHARE" != _"" ]; then
2238        cp -f $MONDORESTORECFG $bigdir/tmp &> /dev/null
2239    fi
2240    [ -d "/mnt/.boot.d" ] && echo "Oh Jebus" > $bigdir/tmp/DUMBASS-GENTOO
2241    DropOptimizedLibraries $needlist $bigdir
2242    echo -en "Assembling dependency files"
2243    CopyDependenciesToDirectory < $needlist $bigdir
2244
2245    # also copy io.sys and msdos.sys, if we can find them
2246    for i in `mount | cut -d' ' -f3` ; do
2247        for j in io.sys msdos.sys ; do
2248            [ -e "$i/$j" ] && cp -f $i/$j $bigdir 2>> $LOGFILE
2249        done
2250    done
2251
2252    # master boot record, too
2253    if [ _"$MONDORESTORECFG" != _"" ]; then
2254        i=`grep bootloader.device $MONDORESTORECFG | cut -d'=' -f2 2> /dev/null`
2255        if [ "$i" ] ; then
2256            LogIt "Backing up $i's MBR"
2257            dd if=$i of=$bigdir/BOOTLOADER.MBR bs=446 count=1 >> $LOGFILE 2>> $LOGFILE
2258            sleep 1
2259            sync
2260            j=$i
2261            [ -h "$j" ] && j=`readlink -f $j`
2262            LogIt "Creating /dev/boot_device ($j)"
2263            mkdir -p $bigdir/dev
2264            cp -pRdf $j $bigdir/dev/boot_device 2> /dev/null || Die "Unable to create /dev/boot_device on ramdisk"
2265        fi
2266    fi
2267
2268    old_pwd=`pwd`
2269    cd $bigdir
2270
2271    [ -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'."
2272    cp -Rdf $MINDI_LIB/aux-tools/* . 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping aux-tools"
2273    if [ -e "$MINDI_LIB/x11-tools.tgz" ] ; then
2274        tar -zxf $MINDI_LIB/x11-tools.tgz 2>> $LOGFILE || LogIt "WARNING - error occurred while unzipping x11-tools.tgz"
2275    fi
2276    if [ -e "$MONDO_SHARE/restore-scripts" ]; then
2277        cp -Rdf $MONDO_SHARE/restore-scripts/* . 2>> $LOGFILE
2278        [ "$?" -ne "0" ] && Die "Cannot find/install $MONDO_SHARE/restore-scripts"
2279    fi
2280    [ -d "/lib/dev-state" ] && cp --parents -pRdf /lib/dev-state . 2>> $LOGFILE
2281    cd $old_pwd
2282    echo -e "$DONE"
2283    TOTAL_BIGDIR_SIZE=`du -sk $bigdir | cut -f1`
2284    SplitDirectoryIntoMinidirs $bigdir $minidir_root
2285    noof_disks=$?
2286    [ "$noof_disks" -eq "0" ] && Die "Too much stuff!"
2287    MakeMountlist $MINDI_TMP/mountlist.txt
2288    mkdir -p $minidir_root/$noof_disks/tmp
2289    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"
2290    if [ _"$MONDO_SHARE" != _"" ]; then
2291        cp -f $minidir_root/$noof_disks/tmp/mountlist.txt $MINDI_TMP/. 2>> $LOGFILE
2292    fi
2293    [ $LVM != "false" ] && $MINDI_LIB/analyze-my-lvm > $minidir_root/$noof_disks/tmp/i-want-my-lvm || LVM="false"
2294    cat $minidir_root/$noof_disks/tmp/mountlist.txt >> $LOGFILE
2295    ZipMinidirsIntoTarballs $minidir_root $tardir $noof_disks
2296    CreateDataDiskImagesFromTarballs $tardir $imagesdir $noof_disks
2297    FRIENDLY_OUTSTRING="Boot and data disk images were created."
2298    # One 1.72MB boot disk, one 2.88MB boot disk and $noof_disks data disk images
2299    rmdir $tardir $bigdir
2300    rm -f $needlist
2301    return $noof_disks
2302}
2303
2304
2305ProcessLDD() {
2306    local main_fname incoming j i fname f newf
2307    main_fname=$1
2308    read incoming
2309    while [ "$incoming" != "" ] ; do
2310        # We take the full path name of the dyn. lib. we want
2311        incoming=`echo "$incoming" | sed '/[[:blank:]]*.*[[:blank:]]*=>[[:blank:]]*(.*/d ; s/[[:blank:]]*.*[[:blank:]]*=>[[:blank:]]*\(\/.*\)/\1/ ; s/[[:blank:]]*\(\/.*\)[[:blank:]]*(.*/\1/'`
2312        for f in `echo "$incoming"` ; do
2313            echo "$f `ReadAllLink $f`"
2314        done
2315        read incoming
2316    done
2317}
2318
2319
2320Prompt() {
2321    echo -en "$1"
2322    read line
2323}
2324
2325
2326ReadLine() {
2327    local i incoming
2328    read incoming
2329    i=0
2330    while [ "$i" -le "32" ] && [ "$incoming" = "" ] ; do
2331        i=$(($i+1))
2332        read incoming
2333    done
2334    echo "$incoming"
2335}
2336
2337
2338RejigHyperlinks() {
2339    local minidir_root noof_disks fname path diskno old_pwd awk_loc gawk_loc dir i
2340    minidir_root=$1
2341    noof_disks=$2
2342
2343    old_pwd=`pwd`
2344    diskno=1
2345    while [ "$diskno" -le "$noof_disks" ] ; do
2346        mkdir -p $minidir_root/$diskno
2347        cd $minidir_root/$diskno
2348        for fname in `find -type d -o -print` ; do
2349            [ -h "$minidir_root/$diskno/$fname" ] && MoveHyperlinkSensibly $fname $minidir_root $diskno $noof_disks
2350        done
2351        diskno=$(($diskno+1))
2352    done
2353
2354    cd $old_pwd
2355    return
2356}
2357
2358
2359ReplaceIndividualLine() {
2360    local orig_file new_file lino newstring lines_total lines_remaining
2361
2362    orig_file=$1.orig
2363    mv -f $1 $orig_file || Die "Cannot move $1 to $orig_file"
2364    new_file=$1
2365    lino=$2
2366    newstring="$3"
2367    if [ "$lino" = "" ] || [ "$lino" -lt "1" ] ; then
2368        echo "Can't find string" >> $LOGFILE
2369        return 1
2370    fi
2371    lines_total=`wc -l $orig_file | $AWK '{print $1;}'`
2372    lines_remaining=$(($lines_total-$lino))
2373    head -n$(($lino-1)) $orig_file > $new_file
2374    echo "$newstring" >> $new_file
2375    echo "# The above line was added by Mindi, at the user's instruction" >> $new_file
2376    tail -n$lines_remaining $orig_file >> $new_file
2377    echo "Replace line $lino of $new_file with user-specified line, '$newstring'" >> $LOGFILE
2378    [ -x "$orig_file" ] && chmod +x $new_file
2379    rm -f $orig_file
2380    return 0
2381}
2382
2383
2384ScanCDandTape() {
2385    local i
2386
2387    for i in /dev/st0 /dev/ht0 /dev/cdrom /dev/cdrom0 /dev/cdrom 1 ; do
2388        dd if=$i of=/dev/null bs=64k count=1 &> /dev/null
2389    done
2390}
2391
2392
2393SizeOfPartition() {
2394    local devpath drive res stub
2395    device=$1
2396    if [ "`echo "$device" | grep -F "/dev/md"`" != "" ] ; then
2397        res=`SizeOfRaidPartition $device`
2398        [ "$res" = "" ] && Die "Cannot find $device's size - is your /etc/raidtab sane?"
2399        echo "$res"
2400        return 0
2401    fi
2402    # patch from Bill <bill@iwizard.biz> - 2003/08/25
2403    res=`$FDISK -s $device 2>> $LOGFILE`
2404    # end patch
2405    [ "$res" = "" ] && res=`df -k -P -x supermount | tr -s '\t' ' ' | grep -F "$device " | cut -d' ' -f2`
2406    [ "$res" = "" ] && res="-1"
2407    echo $res
2408    return 0
2409}
2410
2411
2412SizeOfRaidPartition() {
2413    local real_dev smallest_size silly tmp
2414
2415    silly=999999999
2416    smallest_size=$silly
2417
2418    for real_dev in `GetRaidDevMembers $1` ; do
2419        tmp=`SizeOfPartition $real_dev`
2420        [ "$tmp" -lt "$smallest_size" ] && smallest_size=$tmp
2421    done
2422
2423    if [ "$smallest_size" = "$silly" ] ; then
2424        echo "-1"
2425        return 1
2426    else
2427        echo "$smallest_size"
2428        return 0
2429    fi
2430}
2431
2432
2433StripComments()
2434{
2435    local tempfile
2436
2437    tempfile=$MINDI_TMP/$$.strip.txt
2438    cp -f $1 $tempfile 2>> $LOGFILE
2439    $AWK '{if (substr($0,0,1)!="#" || substr($0,0,3)=="#!/") {print $0;};}' $tempfile > $1
2440    rm -f $tempfile
2441    echo "Stripped comments from $2" >> $LOGFILE
2442}
2443
2444
2445SplitDirectoryIntoMinidirs() {
2446    local bigdir minidir_root i noof_disks old_pwd res
2447
2448    bigdir=$1
2449    minidir_root=$2
2450    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/*
2451
2452    TryToFitDataIntoSeveralDirs $bigdir $minidir_root
2453    noof_disks=$?
2454    if [ "$noof_disks" -eq "0" ] ; then
2455        echo "Failed to fit data into several dirs."
2456        return 0
2457    fi
2458    RejigHyperlinks $minidir_root $noof_disks
2459    [ "$bigdir" != "" ] && rm -Rf $bigdir/*
2460    return $noof_disks
2461}
2462
2463
2464StripExecutable()
2465{
2466    local tmpfile
2467
2468    tmpfile=$MINDI_TMP/stripped.$$.dat
2469    [ -d "$1" ] || [ -h "$1" ] && return
2470    cp -f $1 $tmpfile 2>> $LOGFILE
2471    strip $tmpfile 2> /dev/null
2472    if [ "$?" -eq "0" ] ; then
2473        cp -f $tmpfile $1 2>> $LOGFILE
2474        echo "Stripped binary $2" >> $LOGFILE
2475    fi
2476    rm -f $tmpfile
2477}
2478
2479
2480TemporarilyCompressAllFiles() {
2481    local i orig_fname out_fname out_list
2482
2483    i=0
2484    out_list=$2/compressed/compressed.txt
2485    mkdir -p $2/compressed
2486    > $out_list
2487    for orig_fname in $1 ; do
2488        out_fname=$2/compressed/$orig_fname.gz
2489        mkdir -p $out_fname 2> /dev/null
2490        rmdir $out_fname 2> /dev/null
2491        gzip -c6 $orig_fname > $out_fname 2> /dev/null
2492        i=$(((($i+1))%15))
2493        [ "$i" -eq "0" ] && echo -en "."
2494        du -sk $out_fname >> $out_list
2495    done
2496}
2497
2498
2499TryToFindKernelPath() {
2500    local fname incoming res fkern_ver we_want_version possible_kernels noof_kernels kernelpath kdate duff_kernels
2501
2502    we_want_version=`uname -r`
2503    possible_kernels=""
2504    duff_kernels=""
2505   
2506    if [ "$ARCH" = "ia64" ] ; then
2507       root="/boot/efi/efi"
2508    else
2509       root="/"
2510    fi
2511    for fname in `find $root -maxdepth 2 -type f | grep -F lin | grep -Ev '^/proc/|^/net/'` ; do
2512        [ ! -e "$fname" ] && continue
2513        [ "$fname" = "/boot/vmlinuz.shipped" ] && [ -f "/boot/vmlinuz" ] && continue; # ignore SuSE's extra kernel
2514        file $fname | grep -q gzip
2515        if [ "$?" -eq "0" ] ; then
2516            # Used by ia64
2517            fkern_ver=`gzip -cd $fname | strings 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2518        else
2519            fkern_ver=`strings $fname 2> /dev/null | grep "[2-9]+*[.][0-9]+*[.][0-9]+*[^\@]*@"`
2520        fi
2521        [ "$fkern_ver" = "" ] && continue
2522        [ "`echo "$fkern_ver" |grep -F "$we_want_version "`" = "" ] && continue
2523        [ -f "$fname" ] || continue
2524        [ -h "$fname" ] && continue
2525        kdate=`uname -v | $AWK '{for(i=1;i<NF;i++){if(index($i,":")){print $i;};};}' | $AWK '{print $NF;}'`
2526        file $fname | grep -q gzip
2527        if [ "$?" -eq "0" ] ; then
2528            # Used by ia64
2529            if [ "`gzip -cd $fname | strings 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2530                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting? Naughty but I'll allow it..."
2531                duff_kernels="$fname $duff_kernels"
2532            else
2533                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2534                possible_kernels="$fname $possible_kernels"
2535            fi
2536        else
2537            if [ "`strings $fname 2> /dev/null | grep -F "$kdate"`" = "" ] ; then
2538                LogIt "Have you recompiled your kernel \"$fname\" w/o rebooting?\n Naughty but I'll allow it..."
2539                duff_kernels="$fname $duff_kernels"
2540            else
2541                [ "`echo "$fname" | grep -F "vmlinux"`" ] && continue
2542                possible_kernels="$fname $possible_kernels"
2543            fi
2544        fi
2545    done
2546    if [ ! "$possible_kernels" ] && uname -a | grep Knoppix > /dev/null ; then
2547        possible_kernels=`find /boot/vmlinuz-2.* | tail -n1`
2548    fi
2549    if [ ! "$possible_kernels" ] ; then
2550        LogIt "No kernel matches exactly. Are there any duff kernels?"
2551        possible_kernels="$duff_kernels"
2552        if [ ! "$possible_kernels" ] ; then
2553            LogIt "Sorry, no duff kernels either"
2554        else
2555            LogIt "I bet you're running Debian or Gentoo, aren't you?"
2556            LogIt "Your kernel doesn't have a sane builddate. Oh well..."
2557        fi
2558    fi
2559    possible_kernels=`echo "$possible_kernels" | tr -s ' ' '\n' | sort -u | tr '\n' ' '`
2560    noof_kernels=`CountItemsIn "$possible_kernels"`
2561    if [ "$noof_kernels" -eq "0" ] ; then
2562        LogIt "Could not find your kernel."
2563        if [ -e "/boot/vmlinuz" ] ; then
2564            LogIt "Using /boot/vmlinuz as a last resort."
2565            output=/boot/vmlinuz
2566        else
2567            output=""
2568        fi
2569    elif [ "$noof_kernels" -eq "1" ] ; then
2570        kernelpath=`echo "$possible_kernels" | sed s/' '//`
2571        echo "Your kernel is $kernelpath (v`uname -r`)" >> $LOGFILE
2572        output="$kernelpath"
2573    else
2574        for i in $possible_kernels ; do
2575            if echo $i | grep "`uname -r`" ; then
2576                LogIt "OK, I used my initiative and found that "
2577                LogIt "$i is probably your kernel. "
2578                output="$i"
2579                return
2580            fi
2581        done
2582        if echo " $possible_kernels " | grep -F "/boot/vmlinuz " &> /dev/null ; then
2583            output=/boot/vmlinuz
2584            echo "Schlomo, this one's for you." >> $LOGFILE
2585        else
2586            LogIt "Two or more possible kernels found. You may specify any one of them and the "
2587            LogIt "boot disks will still work, probably. If one does not work, try another."
2588            LogIt "$possible_kernels"
2589            echo ""
2590        fi
2591    fi
2592    echo "$output" | tr -s ' ' '\n' | sort -u | tr '\n' ' '
2593}
2594
2595
2596TryToFitDataIntoSeveralDirs() {
2597    local bigdir minidir_root noof_disks diskno list_of_files filename old_pwd progress
2598    local i retval noof_disks total_files list_of_devs
2599
2600    bigdir=$1
2601    minidir_root=$2
2602    BIG_CLUNKY_SIZE_COUNTER=0
2603    retval=0
2604    noof_disks=1
2605
2606    echo -en "\r                                                                            \rDividing data into several groups..."
2607    old_pwd=`pwd`
2608    cd $bigdir
2609    list_of_files=`GetFileSizeList . | sort -nr | cut -f2 | grep -Fv "/dev/"`
2610    progress=0
2611    total_files=`CountItemsIn "$list_of_files"`
2612    if [ "`echo "$filename" | grep -x "/dev/.*"`" ] ; then
2613        filesize=1
2614    fi
2615    mkdir -p $minidir_root/$noof_disks
2616    if [ -e "dev" ] ; then
2617        echo "Copying dev/* to $minidir_root/$noof_disks" >> $LOGFILE
2618        cp --parents -pRdf dev $minidir_root/$noof_disks 2>> $LOGFILE
2619    fi
2620    TemporarilyCompressAllFiles "$list_of_files" $minidir_root
2621    for filename in $list_of_files ; do
2622        AddFileToDir $filename $minidir_root $noof_disks
2623        i=$?
2624        if [ "$i" -gt "$noof_disks" ] ; then
2625            noof_disks=$i
2626            echo -en "\r\t\t\t\t\t\t($noof_disks disks)"
2627        fi
2628        if [ "$i" -eq "0" ] ; then
2629            LogIt "Cannot add file $filename to minidir $minidir_root"
2630            retval=$(($retval+1))
2631        fi
2632        progress=$(($progress+1))
2633        echo -en "\r\t\t\t\t\t\t\t\t$(($progress*100/$total_files))% complete\r"
2634    done
2635    cd $old_pwd
2636    echo -en "\rThe files have been subdivided into $noof_disks directories.                                                            \r"
2637    [ "$minidir_root" != "" ] && rm -Rf $minidir_root/compressed
2638    if [ "$retval" -gt "0" ] ; then
2639        return 0
2640    else
2641        return $noof_disks
2642    fi
2643}
2644
2645
2646TurnTgzIntoRdz() {
2647    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
2648
2649    tgz_dir_fname=$1
2650    rdz_fname=$2
2651    ramdisksize=$3
2652    disksize=$4
2653    kernelsize=$5
2654    maxsize=$(($disksize-$kernelsize))
2655    maxsize=$(($maxsize*2)); # to allow for compression of 50%
2656    tempfile=$MINDI_TMP/temp.rd
2657    mountpoint=$MINDI_TMP/mnt1
2658    res=0
2659    echo -en "..."
2660    dd if=/dev/zero of=$tempfile bs=1k count=$ramdisk_size &> /dev/null || Die "Not enough room for temporary ramdisk (TurnTgzIntoRdz)"
2661    echo -en "..."
2662    echo "Creating ext2 filesystem on $tempfile" >> $LOGFILE
2663    mke2fs -b 1024 -m 1 -i 2048 -F $tempfile >> $LOGFILE 2>> $LOGFILE
2664    echo -en "..."
2665    mkdir -p $mountpoint
2666    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."
2667    echo -en "..."
2668    old_pwd=`pwd`
2669    cd $mountpoint
2670    cp -Rdf $tgz_dir_fname/* . 2>&1 >> $LOGFILE
2671    tar -zxf symlinks.tgz || Die "Cannot untar symlinks.tgz"
2672    cd dev || Die "Can't cd to dev"
2673    tar -zxf dev-entries.tgz || Die "Cannot untar dev-entries.tgz"
2674    rm -f dev-entries.tgz
2675    cd ..
2676
2677    for w in insmod.static insmod.static.old ; do
2678        s=`which $w 2> /dev/null`
2679        if [ -e "$s" ] ; then
2680            cp --parents -af $s . 2>> $LOGFILE
2681        fi
2682    done
2683
2684    mkdir -p tmp
2685    [ -e "/dev/.devfsd" ] && echo "/dev/.devfsd found" > tmp/USE-DEVFS
2686    for w in cdrom floppy groovy-stuff ; do
2687        mkdir -p mnt/$w
2688    done
2689    #if [ "$RUN_AFTER_INITIAL_BOOT_PHASE" ] ; then
2690        #ReplaceIndividualLine sbin/init `grep -n "#WHOLIVESINAPINEAPPLEUNDERTHESEA#" sbin/init | cut -d':' -f1` "$RUN_AFTER_INITIAL_BOOT_PHASE"
2691    #fi
2692    if [ "$RUN_AFTER_BOOT_PHASE_COMPLETE" ] ; then
2693        ReplaceIndividualLine sbin/init `grep -n "#ABSORBENTANDYELLOWANDPOROUSISHE#" sbin/init | cut -d':' -f1` "$RUN_AFTER_BOOT_PHASE_COMPLETE"
2694    fi
2695
2696    lsmod > tmp/original-lsmod.txt
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 $IDE_MODS ide-scsi sr_mod cdrom isocd isofs `WhichOfTheseModulesAreLoaded "$SCSI_MODS"`"
2726    else
2727        list_of_groovy_mods="$CDROM_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 | gzip -v9 > $rdz_fname 2> /dev/null
2776        # log that we are done
2777        echo "...done." >> $LOGFILE
2778    ;;
2779    "initramfs")
2780        # say what will be used
2781        echo "Creating a gzip'ed cpio (AKA initramfs) initrd image..." >> $LOGFILE
2782        # make sure that cpio is there
2783        which cpio &> /dev/null; [ $? -eq 0 ] || Die "cpio not found. Please install package cpio and try again."
2784        # go into filesystem
2785        cd $mountpoint
2786        # kernel expects init in cpio filesystem
2787        ln -sf sbin/init init
2788        # create cpio image file and unmount loop filesystem
2789        find . -print | cpio -o -H newc | gzip -9 > $old_pwd/$rdz_fname 2> /dev/null
2790        cd $old_pwd
2791        umount $mountpoint || Die "Cannot unmount $tempfile"
2792        # log that we are done
2793        echo "...done." >> $LOGFILE
2794    ;;
2795    *)
2796        Die "Filesystem $gvFileSystem not supported for initrd image. Terminating."
2797    ;;
2798    esac
2799    if [ "$res" -eq "0" ] ; then
2800        echo -en "..."
2801    else
2802        echo -en "\rMade an rdz WITH ERRORS.           \n"
2803    fi
2804    return 0
2805}
2806
2807
2808WhichOfTheseModulesAreLoaded() {
2809    local modname loaded_modules
2810    loaded_modules=" `lsmod | tr -s ' ' '\t' | cut -f1 | grep -Fvx "Modules" | tr '\n' ' '` "
2811    for modname in $1 ; do
2812        [ "`echo "$loaded_modules" | grep -F " $modname "`" ] && echo "$modname"
2813    done
2814}
2815
2816
2817ZipMinidirsIntoTarballs() {
2818    local minidir_root tardir noof_disks diskno old_pwd i
2819    minidir_root=$1
2820    tardir=$2
2821    noof_disks=$3
2822
2823    echo -en "Tarring and zipping the group`PluralOrNot $noof_disks`..."
2824    mkdir -p $tardir
2825    mkdir -p $minidir_root/all
2826    old_pwd=`pwd`
2827    diskno=1
2828    while [ "$diskno" -le "$noof_disks" ] ; do
2829        cd $minidir_root/$diskno || LogIt "WARNING - cannot cd to $minidir_root/$diskno"
2830        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."
2831        diskno=$(($diskno+1))
2832        echo -n "..."
2833        cp -pRdf * $minidir_root/all 2>> $LOGFILE
2834    done
2835    mkdir -p $minidir_root/all/tmp
2836    cd $minidir_root/all
2837    size_of_all_tools=`du -sk . | cut -f1`
2838    if [ _"$MONDO_SHARE" != _"" ]; then
2839        for q in filelist.full.gz biggielist.txt ; do
2840            [ ! -e "$MINDI_TMP/$q" ] && Die "Cannot find $MINDI_TMP/$q"
2841            cp -pRdf $MINDI_TMP/$q tmp/ 2>> $LOGFILE
2842        done
2843        mkdir -p $minidir_root/all/tmp
2844    fi
2845    tar -b 4096 -cf - * 2> /dev/null | gzip -9 > $tardir/all.tar.gz
2846    dd if=/dev/zero bs=1k count=64 >> $imagesdir/all.tar.gz 2> /dev/null
2847    [ "`du -sm $imagesdir/all.tar.gz | cut -f1`" -ge "30" ] && Die "You have too many tools in your shed"
2848    cd $old_pwd
2849    [ "$minidir_root" != "" ] && rm -Rf $minidir_root
2850    echo -e "$DONE"
2851}
2852
2853
2854##############################################################################
2855#----------------------------------- Main -----------------------------------#
2856##############################################################################
2857
2858# Now we can create what we nedd
2859mkdir -p $MINDI_TMP
2860
2861# Purge from potential old run
2862if [ _"$MINDI_CACHE" = _"" ]; then
2863    Die "MINDI_CACHE undefined"
2864fi
2865rm -rf $MINDI_CACHE 2> /dev/null
2866mkdir -p $MINDI_CACHE
2867
2868
2869if [ "$1" = "--printvar" ] ; then
2870    shift
2871    if [ _"$1" != _"" ] ; then
2872        set | egrep "^$1" | cut -d= -f2
2873    fi
2874    MindiExit 0
2875fi
2876
2877> $LOGFILE
2878echo "mindi v$MINDI_VERSION" >> $LOGFILE
2879echo "$ARCH architecture detected" >> $LOGFILE
2880echo "mindi called with the following arguments:" >> $LOGFILE
2881echo "$@" >> $LOGFILE
2882echo "Start date : `date`" >> $LOGFILE
2883echo "-----------------------------" >> $LOGFILE
2884
2885if [ -e "/etc/conf.modules" ] && [ ! -e "/etc/modules.conf" ] ; then
2886    LogIt "WARNING - Ancient distro detected." 1
2887    ln -sf /etc/conf.modules /etc/modules.conf
2888fi
2889[ -e "/sbin/mkdosfs" ] && [ ! -e "/sbin/mkfs.vfat" ] && ln -sf /sbin/mkdosfs /sbin/mkfs.vfat
2890
2891# Log some capital variables
2892[ "$MINDI_PREFIX" = "XXX" ] && Die "Mindi has not been installed correctly."
2893echo "MONDO_SHARE = $MONDO_SHARE" >> $LOGFILE
2894echo "MINDI_LIB = $MINDI_LIB" >> $LOGFILE
2895echo "MINDI_SBIN = $MINDI_SBIN" >> $LOGFILE
2896[ "$MINDI_CONF" = "YYY" ] && Die "Mindi has not been installed correctly."
2897echo "MINDI_CONF = $MINDI_CONF" >> $LOGFILE
2898if [ -f $MINDI_CONF ]; then
2899    echo "-----------------------------" >> $LOGFILE
2900    echo " Mindi configuration file    " >> $LOGFILE
2901    echo "-----------------------------" >> $LOGFILE
2902    cat $MINDI_CONF >> $LOGFILE
2903    echo "-----------------------------" >> $LOGFILE
2904fi
2905
2906
2907trap AbortHere SIGTERM SIGHUP SIGQUIT SIGKILL SIGABRT SIGINT
2908
2909# Sanity checks
2910which which > /dev/null 2> /dev/null || Die "Please install 'which'."
2911which strings > /dev/null 2> /dev/null || Die "Please install binutils and libbinutils; you have no 'strings' executable."
2912which 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."
2913which gawk > /dev/null 2> /dev/null && AWK=`which gawk 2>/dev/null` || AWK="`which awk 2>/dev/null`"
2914if which awk &> /dev/null ; then
2915    if ! which gawk &> /dev/null ; then
2916        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"
2917    fi
2918fi
2919which mke2fs > /dev/null 2> /dev/null || Die "Please put mke2fs in system path"
2920[ ! -e "$FDISK" ] && Die "Cannot find (s)fdisk"
2921
2922[ "`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"
2923# If we have a 2.6 kernel, the system uses module-init-tools which means that we
2924# may have the modprobe configuration spread out across multiple files in
2925# directory /etc/modprobe.d. If this is the case we concatenate these files into
2926# a temporary file for further processing. Otherwise we continue in the standard
2927# way. Note further that in case /etc/modprobe.d exists, we use it and ignore
2928# /etc/modprobe.conf which is exactly what module-init-tools does. The temporary
2929# modprobe.conf file is created in MakeModuleLoadingScript. AL041128.
2930if [ -d "/etc/modprobe.d" ] && [ `uname -r | cut -c1-3` == "2.6" ] ; then
2931    TMPMODPROBE_FLAG="Y"
2932else
2933    TMPMODPROBE_FLAG="N"
2934    [ -e "/etc/modprobe.conf" ] && [ ! -e "/etc/modules.conf" ] && ln -sf /etc/modprobe.conf /etc/modules.conf
2935    [ ! -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..."
2936fi
2937
2938# Update the PATH variable if incomplete
2939if [ -e "/sbin/mkfs" ] && ! which mkfs &> /dev/null ; then
2940    PATH=$PATH:/sbin:/usr/sbin
2941    export PATH
2942    echo "Your PATH did not include /sbin or /usr/sbin. I have fixed that, temporarily." >> $LOGFILE
2943    echo "However, you may wish to ask your vendor to provide a permanent fix..." >> $LOGFILE
2944    echo " Or you might like to call 'su -' instead of 'su', for example." >> $LOGFILE
2945fi
2946
2947# If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
2948if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ] && [ "$kernelpath" = "FAILSAFE" ]; then
2949    source $MINDI_LIB/FindDistroFailsafe
2950    # Log kernel image
2951    LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
2952else
2953    [ -f "$MINDI_LIB/vmlinuz" ] && FAILSAFE_KVER=`strings $MINDI_LIB/vmlinuz 2> /dev/null | grep -E "2\.[46]" | cut -d' ' -f1`
2954fi
2955
2956if ! which mkfs.vfat &> /dev/null ; then
2957    Die "mkfs.vfat missing from your filesystem - please install your dosfstools RPM or DEB package. Perhaps your PATH environmental variable is broken, too?"
2958fi
2959
2960### BERLIOS
2961### Fix as it's not mandatory on ia64
2962if [ "$ARCH" = "ia64" ] ; then
2963    if which elilo &> /dev/null ; then
2964        LILO_EXE=elilo
2965    else
2966        LILO_EXE=`which false`
2967    fi
2968else
2969    FindIsolinuxBinary
2970    FindLiloBinary
2971fi
2972trap "Aborted" SIGTERM
2973DONE="\r\t\t\t\t\t\t\t\tDone.         "
2974CHOPSIZE=240
2975BIGNO=0
2976MAX_COMPRESSED_SIZE="$mindi_max_compressed_size"
2977
2978#
2979# Kernel management: Attempt to locate kernel specific module path
2980# if module path is found then use it other wise use uname -r to set it...
2981#
2982#
2983kernelpath="$mindi_kernel"
2984if [ "$kernelpath" = "NATIVE" ]; then
2985    kernelpath=""
2986fi
2987if [ "$kernelpath" = "" ]; then 
2988    kernelpath=`TryToFindKernelPath`
2989fi
2990kernelname=`echo $kernelpath | cut -d'-' -f2-`
2991echo "kernelname = $kernelname" >> $LOGFILE
2992echo "kernelpath = $kernelpath" >> $LOGFILE
2993if [ ! -d "/lib/modules/$kernelname" ] && [ "$kernelpath" != "FAILSAFE" ]
2994then
2995   echo "Module path for ${kernelpath} not found..." >> $LOGFILE
2996   echo "using running kernel\'s modules." >> $LOGFILE
2997   kernelname=`uname -r`
2998else
2999   echo "Using modules for kernel: ${kernelname}" >> $LOGFILE
3000fi
3001
3002if [ -d "/proc/lvm" ]; then
3003    # LVM v1
3004    LVMCMD=""
3005    LVM="v1"
3006elif [ -d "/dev/mapper" ]; then
3007    # LVM v2
3008    LVMCMD="lvm"
3009    LVM="v2"
3010else
3011    LVM="false"
3012fi
3013echo "LVM set to $LVM" >> $LOGFILE
3014echo "----------" >> $LOGFILE
3015echo "df result:" >> $LOGFILE
3016echo "----------" >> $LOGFILE
3017df -T >> $LOGFILE
3018echo "-------------" >> $LOGFILE
3019echo "mount result:" >> $LOGFILE
3020echo "-------------" >> $LOGFILE
3021mount >> $LOGFILE
3022echo "-------------" >> $LOGFILE
3023echo "lsmod result:" >> $LOGFILE
3024echo "-------------" >> $LOGFILE
3025lsmod >> $LOGFILE
3026echo "-------------" >> $LOGFILE
3027echo "Liste of extra modules is:" >> $LOGFILE
3028echo "$EXTRA_MODS" >> $LOGFILE
3029echo "-------------" >> $LOGFILE
3030
3031
3032FLOPPY_WAS_MOUNTED=""
3033for mtpt in /media/floppy /mnt/floppy /floppy ; do
3034    if mount | grep -w $mtpt &> /dev/null ; then
3035        FLOPPY_WAS_MOUNTED="$FLOPPY_WAS_MOUNTED $mtpt"
3036        umount $mtpt
3037    fi
3038done
3039
3040#
3041# If we have a USB device we need to store info
3042# and remove it from the parameters line
3043#
3044if [ "$#" -ne "0" ] ; then
3045    if [ "$1" = "--usb" ] ; then
3046        shift
3047        USBDEVICE=$1
3048        if [ _"$USBDEVICE" = _"" ]; then
3049            Die "No USB device specified"
3050        fi
3051        shift
3052    fi
3053fi
3054
3055#
3056# Default value for parameters coming from mondo potentially
3057#
3058if [ "$ARCH" = "ia64" ] ; then
3059    USE_LILO=yes
3060else
3061    USE_LILO=no
3062fi
3063
3064#
3065# These variables are normaly only significant in a mondo environment
3066# Not enforced yet
3067#
3068CDRECOVERY="no"
3069NOT_BOOT="no"
3070EXCLUDE_DEVS=""
3071IMAGE_DEVS=""
3072NFS_DEV=""
3073
3074#
3075# Deal with parameters
3076#
3077if [ "$#" -ne "0" ] ; then
3078    if [ "$1" = "--findkernel" ] ; then
3079        res=`TryToFindKernelPath`
3080        if [ "$res" = "" ] ; then
3081            MindiExit -1
3082        else
3083            echo "$res"
3084            MindiExit 0
3085        fi
3086    elif [ "$1" = "--makemountlist" ] ; then
3087        [ ! "$2" ] && Die "Please specify the output file"
3088        MakeMountlist $2
3089        MindiExit $?
3090    elif [ "$1" = "-V" ] || [ "$1" = "-v" ] || [ "$1" = "--version" ] || [ "$1" = "-version" ] ; then
3091        echo "Mindi v$MINDI_VERSION"
3092        MindiExit 0
3093    elif [ "$1" = "--custom" ] ; then
3094        if [ _"$MONDO_SHARE" = _"" ]; then
3095            Die "--custom is reserved for mondoarchive calls"
3096        fi
3097        MONDO_TMP=$2
3098        # Change MINDI_TMP for the one provided by mondo
3099        # So that it can get back the built files
3100        mv $MINDI_TMP/* $MINDI_TMP/.??* $MONDO_TMP 2> /dev/null
3101        rmdir $MINDI_TMP
3102        MINDI_TMP=$MONDO_TMP
3103        mkdir -p $MINDI_TMP
3104        # This is the scratch dir in mondo
3105        MINDI_CACHE=$3
3106        if [ _"$MINDI_CACHE" != _"" ]; then
3107            mkdir -p $MINDI_CACHE
3108        fi
3109
3110        if [ ! -e "$MONDORESTORECFG" ]; then
3111            Die "MONDORESTORECFG undefined. Use an uptodate mondoarchive version"
3112        fi
3113
3114        if [ ! -e "$MONDO_CACHE" ]; then
3115            Die "MONDO_CACHE undefined. Use an uptodate mondoarchive version"
3116        else
3117            #
3118            # Get from mondo our additional configuration
3119            #
3120            echo "Using $MONDO_CACHE/mindi.conf as additional config file"
3121            if [ -f $MONDO_CACHE/mindi.conf ]; then
3122                . $MONDO_CACHE/mindi.conf
3123                echo "-----------------------------" >> $LOGFILE
3124                echo " Mondo configuration file    " >> $LOGFILE
3125                echo "-----------------------------" >> $LOGFILE
3126                cat $MONDO_CACHE/mindi.conf >> $LOGFILE
3127                echo "-----------------------------" >> $LOGFILE
3128            else
3129                Die "No mindi.conf file created by mondo. Aborting"
3130            fi
3131        fi
3132
3133        echo "Here is your $MONDORESTORECFG file:" >> $LOGFILE
3134        echo "------------------------------------" >> $LOGFILE
3135        cat $MONDORESTORECFG >> $LOGFILE
3136        echo "-----------------------------------" >> $LOGFILE
3137
3138        CDRECOVERY=`grep use-cdrecovery $MONDORESTORECFG | cut -d'=' -f2`
3139        NOT_BOOT=`grep non-bootable $MONDORESTORECFG | cut -d'=' -f2`
3140        USE_LILO=`grep use-lilo $MONDORESTORECFG | cut -d'=' -f2`
3141        EXCLUDE_DEVS=`grep excluded-devs $MONDORESTORECFG | cut -d'=' -f2`
3142        NFS_DEV=`grep nfs-dev $MONDORESTORECFG | cut -d'=' -f2`
3143        VALUE=`grep image-devs $MONDORESTORECFG | cut -d'=' -f2`
3144        if [ "$VALUE" = "(null)" ] || [ "$VALUE" = "" ] ; then
3145            IMAGE_DEVS=""
3146        else
3147            IMAGE_DEVS="`echo "$VALUE" | tr '|' ' '`"
3148        fi
3149        [ "$CDRECOVERY" = "yes" ] && [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] && Die "Sorry, you can't use --cd-recovery and --write-tapes at the same time"
3150        MONDO_ROOT=`echo $MINDI_CACHE | sed 's/\(.*\)\/.*/\1/'`
3151        if [ _"$MONDO_ROOT" != _"" ]; then
3152            mkdir -p $MONDO_ROOT
3153        else
3154            Die "MONDO_ROOT is undefined"
3155        fi
3156    else
3157        echo "Syntax: mindi (--custom ....)" >> /dev/stderr
3158        MindiExit -1
3159    fi
3160fi
3161#ScanCDandTape
3162[ "$CDRECOVERY" = "yes" ] || CDRECOVERY=no
3163if [ "$CDRECOVERY" = "yes" ] ; then
3164    iso_cfg_file=$MINDI_LIB/isolinux-H.cfg
3165    sys_cfg_file=$MINDI_LIB/syslinux-H.cfg
3166else
3167    iso_cfg_file=$MINDI_LIB/isolinux.cfg
3168    sys_cfg_file=$MINDI_LIB/syslinux.cfg
3169fi
3170
3171[ -e "$iso_cfg_file" ] || Die "Cannot find $iso_cfg_file"
3172if [ _"$MONDO_SHARE" = _"" ]; then
3173    LogIt "Mindi Linux mini-distro generator v$MINDI_VERSION"
3174    LogIt "Latest Mindi is available from http://www.mondorescue.org"
3175    LogIt "BusyBox sources are available from http://www.busybox.net"
3176else
3177    echo "You are using Mindi-Linux v$MINDI_VERSION to make boot+data disks" >> /var/log/mondo-archive.log
3178fi
3179if [ -f $MINDI_LIB/rootfs/bin/busybox ]; then
3180    LogIt "Mindi-`$MINDI_LIB/rootfs/bin/busybox 2>&1 | head -1`"
3181else
3182    LogIt "Unable to find mindi-busybox, please install it"
3183    MindiExit -1
3184fi
3185
3186# for Mandrake 9.2, which comes with two aes.o.gz modules :-/
3187insmod /lib/modules/`uname -r`/*/*/misc/aes.*o.gz >> $LOGFILE 2>> $LOGFILE
3188for i in loop cdrom ide-cd isofs linear raid0 raid1 raid5 ; do
3189    insmod $i >> $LOGFILE 2>> $LOGFILE
3190done
3191
3192KERN_DISK_MADE=""
3193
3194if [ "$NOT_BOOT" = "yes" ]; then
3195    LogIt "Just creating a small all.tar.gz for Mondo. Nothing else."
3196    mkdir -p $MINDI_TMP/small-all/tmp
3197    MakeMountlist $MINDI_TMP/small-all/tmp/mountlist.txt
3198    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"
3199    cd $MINDI_TMP/small-all
3200    tar -cv tmp | gzip -9 > $MINDI_CACHE/all.tar.gz || Die "Cannot make small all.tar.gz"
3201    sync
3202    LogIt "Done. Exiting."
3203    MindiExit 0
3204fi
3205
3206if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3207    LogIt "Including the generation of a Bootable USB device on $USBDEVICE"
3208fi
3209if [ "$kernelpath" = "" ] ; then
3210    if [ _"$MONDO_SHARE" != _"" ]; then
3211        Die "Please use -k <path> to specify kernel."
3212    fi
3213    if [ $INTERACTIVE == "yes" ]; then
3214        echo -en "Do you want to use your own kernel to build the boot disk ([y]/n) ?"
3215        read ch
3216        if [ "$ch" != "n" ] && [ "$ch" != "N" ] ; then
3217            USE_OWN_KERNEL="yes"
3218        fi
3219    fi
3220    if [ "$USE_OWN_KERNEL" = "yes" ]; then
3221        YOUR_KERNEL_SUCKS=""
3222        kernelpath=`TryToFindKernelPath`
3223        if [ "$kernelpath" = "" ] ; then
3224            echo -n "Please enter kernel path : "
3225            read kernelpath
3226        fi
3227    else
3228        YOUR_KERNEL_SUCKS="That's why you're using mine, dude. :-)"
3229    fi
3230fi
3231if [ _"$MONDO_SHARE" = _"" ] && [ $INTERACTIVE = "yes" ] && [ "$ARCH" != "ia64" ] ; then
3232    echo -en "Would you like to use LILO (instead of syslinux)\nfor your boot CD/floppies (y/[n]) ?"
3233    read ch
3234    if [ "$ch" = "y" ] || [ "$ch" = "Y" ] ; then
3235        USE_LILO=yes
3236    fi
3237fi
3238if [ "$YOUR_KERNEL_SUCKS" != "" ] || [ "$kernelpath" = "" ] || [ "$kernelpath" = "SUCKS" ] || [ "$kernelpath" = "FAILSAFE" ] ; then
3239    # If we have a distribution-specific script for finding a FAILSAFE kernel, use it.
3240    if [ -f "$MINDI_LIB/FindDistroFailsafe" ] && [ ! "$1" = "--makemountlist" ]; then
3241        source $MINDI_LIB/FindDistroFailsafe
3242        # Log kernel image
3243        LogIt "FAILSAFE kernel image to be used is: $FAILSAFE_KBIN ($FAILSAFE_KVER)"
3244        kernelpath="$FAILSAFE_KBIN"
3245        LogIt "I shall include a failsafe kernel, not your kernel, in the boot disks.\n"
3246        LogIt "The failsafe kernel is $kernelpath.\n"
3247        LogIt "However, you are still running your kernel. If Mindi fails to create your\n"
3248        LogIt "disks then it may still be a result of a problem with your kernel.\n"
3249        pwd=`pwd`
3250        cd $MINDI_TMP
3251        mkdir -p lib/modules
3252        cp -a "/lib/modules/$FAILSAFE_KVER" "lib/modules/$FAILSAFE_KVER" || Die "Cannot copy kernel modules."
3253        cd $pwd
3254    else
3255        kernelpath=$MINDI_LIB/vmlinuz
3256        LogIt "I shall include Mindi's failsafe kernel, not your kernel, in the boot disks."
3257        LogIt "However, you are still running your kernel. If Mindi fails to create your"
3258        LogIt "disks then it may still be a result of a problem with your kernel."
3259        pwd=`pwd`
3260        cd $MINDI_TMP
3261        bzip2 -dc $MINDI_LIB/lib.tar.bz2 | tar -x || Die "Cannot unzip lib.tar.bz2"
3262        cd $pwd
3263    fi
3264    YOUR_KERNEL_SUCKS="Your kernel sucks"
3265fi
3266echo -e "Mindi's temp dir = $MINDI_TMP \nMindi's output dir=$MINDI_CACHE" >> $LOGFILE
3267[ "$(($RANDOM%64))" -eq "0" ] && LogIt "Dude, I've looked inside your computer and it's really dusty..."
3268
3269[ "$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."
3270
3271rm -f $MINDI_CACHE/{*img,*gz,*iso}
3272
3273PrepareDataDiskImages $MINDI_CACHE
3274noof_disks=$?
3275ramdisk_size=$(($size_of_all_tools+$EXTRA_SPACE))
3276rds=$(($ramdisk_size-$((ramdisk_size%4096))))
3277ramdisk_size=$rds
3278
3279echo "Ramdisk will be $ramdisk_size KB" >> $LOGFILE
3280if [ "$USE_LILO" = "yes" ] ; then
3281    if [ "$ARCH" = "ia64" ] ; then
3282        PrepareBootDiskImage_LILO $MINDI_CACHE $IA64_BOOT_SIZE $kernelpath $ramdisk_size || Die "Failed to create ia64 floppy disk image."
3283    else
3284        if ! PrepareBootDiskImage_LILO $MINDI_CACHE 2880 $kernelpath $ramdisk_size ;  then
3285            LogIt "WARNING - failed to create 2.88MB floppy disk image."
3286            LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3287            PrepareBootDiskImage_LILO $MINDI_CACHE 5760 $kernelpath $ramdisk_size || Die "Failed to create 2.88MB floppy disk image."
3288        fi
3289    fi
3290else
3291    if ! PrepareBootDiskImage_SYSLINUX $MINDI_CACHE 2880 $kernelpath $ramdisk_size ; then
3292        LogIt "WARNING - failed to create 2.88MB floppy disk image."
3293        LogIt "Please reduce your kernel's size if you want to make a 2.88MB floppy disk."
3294        PrepareBootDiskImage_SYSLINUX $MINDI_CACHE 5760 $kernelpath $ramdisk_size || Die "Failed to create 5.76MB floppy disk image."
3295    fi
3296fi
3297
3298[ -e "$MINDI_LIB/memtest.img" ] && BOOT_MEDIA_MESSAGE="$BOOT_MEDIA_MESSAGE\n\
3299...Or type 'memtest' to test your PC's RAM thoroughly.\n"
3300
3301if [ _"$MONDO_SHARE" = _"" ]; then
3302    ListImagesForUser $MINDI_CACHE
3303    if [ "$PROMPT_WRITE_BOOT_FLOPPIES" = "yes" ]; then
3304        OfferToCopyImagesToDisks $MINDI_CACHE $boot_dev $FDDEVICE
3305    fi
3306    OfferToMakeBootableISO $MINDI_CACHE
3307    if [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3308        OfferToMakeBootableUSB $MINDI_CACHE
3309    fi
3310    LogIt "Finished."
3311elif [ "$PROMPT_MAKE_TAPE_IMAGE" = "yes" ] ; then
3312    rm -f $MINDI_CACHE/{*img,*gz,*iso}
3313    OfferToMakeBootableISO $MINDI_CACHE
3314    if [ -e "$MINDI_CACHE/all.tar.gz" ] ; then
3315        cp -f $MINDI_CACHE/all.tar.gz $MINDI_TMP/ 2>> $LOGFILE
3316    else
3317        Die "Cannot find all.tar.gz, to be written to tape"
3318    fi
3319elif [ "$PROMPT_MAKE_USB_IMAGE" = "yes" ]; then
3320    OfferToMakeBootableUSB $MINDI_CACHE
3321else
3322    OfferToMakeBootableISO $MINDI_CACHE
3323fi
3324# cleanup
3325LogIt "$FRIENDLY_OUTSTRING"
3326for mtpt in $FLOPPY_WAS_MOUNTED ; do
3327    mount $mtpt
3328done
3329MindiExit 0
Note: See TracBrowser for help on using the repository browser.