source: trunk/mindi/mindi @ 1085

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

merge -r1081:1082 $SVN_M/branches/stable

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