Changeset 3879 in MondoRescue

Timestamp:

Mar 9, 2024, 3:10:04 AM (4 months ago)

Author:

Bruno Cornec

Message:

Fix all remaining compiler errors

Location:

branches/3.3/mondo

Files:

• bootstrap (modified) (1 diff)
• configure.ac (modified) (3 diffs)
• src/common/libmondo-archive.c (modified) (6 diffs)
• src/common/libmondo-cli.c (modified) (6 diffs)
• src/common/libmondo-devices.c (modified) (6 diffs)
• src/common/libmondo-fifo.c (modified) (1 diff)
• src/common/libmondo-filelist.c (modified) (2 diffs)
• src/common/libmondo-raid-EXT.h (modified) (1 diff)
• src/common/libmondo-raid.c (modified) (3 diffs)
• src/common/libmondo-stream.c (modified) (4 diffs)
• src/common/libmondo-tools-EXT.h (modified) (2 diffs)
• src/common/libmondo-tools.c (modified) (1 diff)
• src/common/libmondo.h (deleted)
• src/include/my-stuff.h (modified) (5 diffs)
• src/mondoarchive/mondoarchive.c (modified) (1 diff)
• src/mondorestore/Makefile.am (modified) (1 diff)
• src/mondorestore/libmondo-mountlist.h (deleted)
• src/mondorestore/mondo-prep.c (modified) (9 diffs)
• src/mondorestore/mondo-rstr-compare.c (modified) (6 diffs)
• src/mondorestore/mondo-rstr-compare.h (deleted)
• src/mondorestore/mondo-rstr-mountlist.c (modified) (5 diffs)
• src/mondorestore/mondo-rstr-newt.c (modified) (14 diffs)
• src/mondorestore/mondo-rstr-newt.h (deleted)
• src/mondorestore/mondo-rstr-tools.c (modified) (10 diffs)
• src/mondorestore/mondo-rstr-tools.h (deleted)
• src/mondorestore/mondoprep.h (deleted)
• src/mondorestore/mondorestore-EXT.h (deleted)
• src/mondorestore/mondorestore.c (modified) (9 diffs)
• src/mondorestore/mr-externs.h (deleted)
• test/Makefile.am (modified) (1 diff)
• test/test-mountlist.c (modified) (1 diff)
• test/test-truncname.c (modified) (1 diff)

branches/3.3/mondo/bootstrap

@@ -30 +30 @@
 libtoolize -f -c --automake
 aclocal
-autoheader
+#autoheader # to be used with AC_CONFIG_HEADER
 rm -f missing
 automake --add-missing --copy

branches/3.3/mondo/configure.ac

@@ -13 +13 @@
 AC_CONFIG_SRCDIR([src/mondoarchive/mondoarchive.c])
 AC_CONFIG_MACRO_DIR([m4])
-AC_CONFIG_HEADERS([config.h])
 
-AC_PREREQ([2.63])
+AC_PREREQ([2.71])
 AC_CANONICAL_HOST
 AC_CANONICAL_TARGET
@@ -74 +73 @@
         GCC_MAJ="`gcc -dumpversion 2>&1 | cut -d. -f1`"
         GCC_MIN="`gcc -dumpversion 2>&1 | cut -d. -f2`"
-        CFLAGS="$CFLAGS -Wall -Wextra -Wundef -Wshadow -Wpointer-arith -Wcast-align -Wwrite-strings -Waggregate-return -Wcast-qual -Wswitch-default -Wswitch-enum -Wconversion -Wno-return-type -Wformat=2 -Werror=implicit-function-declaration -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_REENTRANT -D_FORTIFY_SOURCE=2 -fstack-clash-protection -fstack-protector-strong -fcf-protection -fsanitize=undefined -Wl,-z,defs -Wl,-z,now -Wl,-z,relro" # -Wstrict-prototypes -Werror"
+
+        # Just test for dev machine on x86_64 ubsan used for option -fsanitize=undefined
+        if [ -f /usr/lib64/libubsan.so ]; then
+            CFLAGS="$CFLAGS -fsanitize=undefined"
+            HAVE_UBSAN=1
+        else
+            HAVE_UBSAN=0
+        fi
+
+        # Just test for dev machine on x86_64 asan used for option -fsanitize=address
+        if [ -f /usr/lib64/libasan.so ]; then
+            CFLAGS="$CFLAGS -fsanitize=address"
+            HAVE_ASAN=1
+        else
+            HAVE_ASAN=0
+        fi
+
+        CFLAGS="$CFLAGS -Wall -Wextra -Wundef -Wshadow -Wpointer-arith -Wcast-align -Wwrite-strings -Waggregate-return -Wcast-qual -Wswitch-default -Wswitch-enum -Wno-return-type -Wformat=2 -Werror=implicit-function-declaration -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_REENTRANT -D_FORTIFY_SOURCE=2 -fstack-clash-protection -fstack-protector-strong -fcf-protection -Wl,-z,defs -Wl,-z,now -Wl,-z,relro -Wno-discarded-qualifiers" # -Wconversion -Wstrict-prototypes -Werror"
         ;;
     *)
@@ -103 +119 @@
 
 # Checks for header files.
-AC_HEADER_STDC
+AC_CHECK_INCLUDES_DEFAULT
+AC_PROG_EGREP
+
 AC_HEADER_SYS_WAIT
 AC_HEADER_STDBOOL

branches/3.3/mondo/src/common/libmondo-archive.c

@@ -33 +33 @@
 #include <stdarg.h>
 #include <unistd.h>
+
 #define DVDRWFORMAT 1
+
+/**
+ * Maximum number of filesets allowed in this function.
+ */
+#define MAX_NOOF_SETS_HERE 32767
+
+/**
+ * Offset of the bkpinfo pointer (in bytes) from the
+ * buffer passed to create_afio_files_in_background.
+ */
+#define BKPINFO_LOC_OFFSET (16+MAX_NOOF_SETS_HERE/8+16)
 
 
@@ -355 +367 @@
 
 
+/**
+ * Create a USB image in @c destfile, from files in @c bkpinfo->scratchdir.
+ *
+ * @param bkpinfo The backup information structure. Fields used:
+ * - @c backup_media_type
+ * - @c nonbootable_backup
+ * - @c scratchdir
+ *
+ * @param destfile Where to put the generated USB image.
+ * @return The number of errors encountered (0 for success)
+ */
+int make_usb_fs()
+{
+    /*@ int ********************************************** */
+    int retval = 0;
+    int res;
+
+    /*@ buffers ****************************************** */
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *result_sz = NULL;
+    char *message_to_screen = NULL;
+    char *old_pwd = NULL;
+    char *mds = NULL;
+
+    assert(bkpinfo != NULL);
+
+    log_msg(2, "make_usb_fs --- scratchdir=%s", bkpinfo->scratchdir);
+    old_pwd = mr_getcwd();
+    mr_asprintf(tmp, "chmod 700 %s", bkpinfo->scratchdir);
+    run_program_and_log_output(tmp, FALSE);
+    mr_free(tmp);
+    if (chdir(bkpinfo->scratchdir)) {
+        // FIXME
+    }
+
+    mds = media_descriptor_string(bkpinfo->backup_media_type);
+    mr_asprintf(message_to_screen, "Copying data to make %s #%d",mds, g_current_media_number);
+    mr_free(mds);
+    log_msg(1, message_to_screen);
+
+    if (bkpinfo->media_device) {
+        mr_asprintf(tmp1, "%s1", bkpinfo->media_device);
+    } else {
+        mr_asprintf(tmp1, "");
+    }
+    if (is_this_device_mounted(tmp1)) {
+        log_msg(1, "USB device mounted. Remounting it at the right place");
+        mr_asprintf(tmp, "umount %s", tmp1);
+        run_program_and_log_output(tmp, FALSE);
+        mr_free(tmp);
+    }
+    mr_free(tmp1);
+
+    log_msg(1, "Mounting USB device.");
+    mr_asprintf(tmp1, "%s/usb", bkpinfo->tmpdir);
+    mr_asprintf(tmp, "mkdir -p %s", tmp1);
+    run_program_and_log_output(tmp, FALSE);
+    mr_free(tmp);
+
+
+    /* Mindi always create one single parition on the USB dev */
+    mr_asprintf(tmp, "mount %s1 %s", bkpinfo->media_device, tmp1);
+    run_program_and_log_output(tmp, FALSE);
+    mr_free(tmp);
+
+    if (bkpinfo->nonbootable_backup) {
+        log_msg(1, "Making nonbootable USB backup not implemented yet");
+    } else {
+        log_msg(1, "Making bootable backup");
+
+        /* Command to execute */
+        mr_asprintf(tmp,"cd %s ; rm -fr %s/syslinux ; mv * %s", bkpinfo->scratchdir, tmp1, tmp1); 
+        res = eval_call_to_make_USB(tmp, message_to_screen);
+        if (res) {
+            mr_asprintf(result_sz, "%s ...failed",tmp);
+        } else {
+            mr_asprintf(result_sz, "%s ...OK",tmp);
+        }
+        log_to_screen(result_sz);
+        mr_free(result_sz);
+        mr_free(tmp);
+        retval += res;
+
+        /* Recreate the required structure under the scratch dir */
+        mr_asprintf(tmp,"mkdir %s/archive", bkpinfo->scratchdir); 
+        run_program_and_log_output(tmp, FALSE);
+        mr_free(tmp);
+    }
+    paranoid_free(message_to_screen);
+
+    /*  Copy the current logfile - of course incomplete to the media */
+    mr_system("gzip -c9 %s > %s/archives/%s", MONDO_LOGFILE, tmp1, MONDO_LOGFILENAME);
+    paranoid_free(tmp1);
+
+    if (is_this_device_mounted(bkpinfo->media_device)) {
+        mr_asprintf(tmp, "umount %s1", bkpinfo->media_device);
+        run_program_and_log_output(tmp, FALSE);
+        mr_free(tmp);
+    }
+
+    if (chdir(old_pwd)) {
+        // FIXME
+    }
+    mr_free(old_pwd);
+    if (retval) {
+        log_msg(1, "WARNING - make_usb_fs returned an error");
+    }
+    return(retval);
+}
+
+
+/**
+ * Make sure the user has a valid CD-R(W) in the CD drive.
+ * @param cd_dev Set to the CD-R(W) device checked.
+ * @param keep_looping If TRUE, keep pestering user until they insist
+ * or insert a correct CD; if FALSE, only check once.
+ * @return 0 (there was an OK CD in the drive) or 1 (there wasn't).
+ */
+int interrogate_disk_currently_in_cddrive(char *cd_dev,
+                                             bool keep_looping)
+{
+    int res = 0;
+    char *bkp = NULL;
+    char *cdrecord = NULL;
+
+    mr_asprintf(bkp, "%s", cd_dev);
+    if ((cd_dev = find_optical_device()) != NULL) {
+        if (!system("which cdrecord > /dev/null 2> /dev/null")) {
+            mr_asprintf(cdrecord, "cdrecord dev=%s -atip", cd_dev);
+        } else if (!system("which dvdrecord > /dev/null 2> /dev/null")) {
+            mr_asprintf(cdrecord, "cdrecord dev=%s -atip", cd_dev);
+        } else {
+            log_msg(2, "Oh well. I guess I'll just pray then.");
+        }
+        if (cdrecord != NULL) {
+            if (!keep_looping) {
+                retract_CD_tray_and_defeat_autorun();
+                res = run_program_and_log_output(cdrecord, 5);
+            } else {
+                while ((res = run_program_and_log_output(cdrecord, 5))) {
+                    retract_CD_tray_and_defeat_autorun();
+                    if (ask_me_yes_or_no
+                        ("Unable to examine CD. Are you sure this is a valid CD-R(W) CD?"))
+                    {
+                        log_msg(1, "Well, he insisted...");
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    mr_free(bkp);
+
+    mr_free(cdrecord);
+    return (res);
+}
+
+
+/**
+ * Asks the user to put a CD-R(W) in the drive.
+ * @param ask_for_one_if_more_than_this (unused)
+ * @param pmountable If non-NULL, pointed-to value is set to TRUE if the CD is mountable, FALSE otherwise.
+ */
+void pause_and_ask_for_cdr(int ask_for_one_if_more_than_this, bool * pmountable) {
+
+    /*@ buffers ********************************************* */
+    char *tmp = NULL;
+    char *cdrom_dev = NULL;
+    char *cd_dev = NULL;
+    char *our_serial_str = NULL;
+    bool ok_go_ahead_burn_it;
+    int cd_number = -1;
+    int attempt_to_mount_returned_this = 999;
+    char *mtpt = NULL;
+    char *szcdno = NULL;
+    char *szserfname = NULL;
+    char *szunmount = NULL;
+    char *mds = NULL;
+
+    malloc_string(cd_dev);
+
+    mds = media_descriptor_string(g_backup_media_type);
+    log_to_screen("I am about to burn %s #%d", mds, g_current_media_number);
+    mr_free(mds);
+    if (g_current_media_number < ask_for_one_if_more_than_this) {
+        return;
+    }
+    log_to_screen("Scanning CD-ROM drive...");
+    mr_asprintf(mtpt, "%s/cd.mtpt", bkpinfo->tmpdir);
+    make_hole_for_dir(mtpt);
+
+  gotos_make_me_puke:
+    ok_go_ahead_burn_it = TRUE;
+    mr_free(cdrom_dev);
+    if ((cdrom_dev = find_optical_device()) != NULL) {
+        /* When enabled, it made CD eject-and-retract when wrong CD inserted.. Weird
+        log_msg(2, "paafcd: Retracting CD-ROM drive if possible" );
+        retract_CD_tray_and_defeat_autorun();
+        */
+        mr_asprintf(tmp, "umount %s", cdrom_dev);
+        run_program_and_log_output(tmp, 1);
+        mr_asprintf(szcdno, "%s/archives/THIS-CD-NUMBER", mtpt);
+        mr_asprintf(szserfname, "%s/archives/SERIAL-STRING", mtpt);
+        mr_asprintf(szunmount, "umount %s", mtpt);
+        cd_number = -1;
+        mr_asprintf(tmp, "mount %s %s", cdrom_dev, mtpt);
+        mr_asprintf(our_serial_str, "%s", "");
+        attempt_to_mount_returned_this = run_program_and_log_output(tmp, 1);
+        mr_free(tmp);
+
+        if (attempt_to_mount_returned_this) {
+            log_msg(4, "Failed to mount %s at %s", cdrom_dev, mtpt);
+            log_to_screen("If there's a CD/DVD in the drive, it's blank.");
+        } else if (!does_file_exist(szcdno) || !does_file_exist(szserfname)) {
+            mds = media_descriptor_string(g_backup_media_type);
+            log_to_screen("%s has data on it but it's probably not a Mondo CD.", mds);
+            mr_free(mds);
+        } else {
+            mds = media_descriptor_string(g_backup_media_type);
+            log_to_screen("%s found in drive. It's a Mondo disk.", mds);
+            mr_free(mds);
+
+            cd_number = atoi(last_line_of_file(szcdno));
+            mr_asprintf(tmp, "cat %s 2> /dev/null", szserfname);
+            mr_free(our_serial_str);
+            our_serial_str = call_program_and_get_last_line_of_output(tmp);
+            mr_free(tmp);
+            // FIXME - should be able to use last_line_of_file(), surely?
+        }
+        mr_free(szcdno);
+        mr_free(szserfname);
+
+        run_program_and_log_output(szunmount, 1);
+        mr_free(szunmount);
+
+        log_msg(2, "paafcd: cd_number = %d", cd_number);
+        log_msg(2, "our serial str = %s; bkpinfo->serial_string = %s", our_serial_str, bkpinfo->serial_string);
+        if (cd_number > 0 && !strcmp(our_serial_str, bkpinfo->serial_string)) {
+            mds = media_descriptor_string(g_backup_media_type);
+            log_msg(2, "This %s is part of this backup set!", mds);
+            ok_go_ahead_burn_it = FALSE;
+            if (cd_number == g_current_media_number - 1) {
+                log_to_screen("I think you've left the previous %s in the drive.", mds);
+            } else {
+                log_to_screen("Please remove this %s. It is part of the backup set you're making now.", mds);
+            }
+            mr_free(mds);
+
+        } else {
+            log_to_screen("...but not part of _our_ backup set.");
+        }
+        mr_free(our_serial_str);
+    } else {
+        mds = media_descriptor_string(g_backup_media_type);
+        log_msg(2,
+                "paafcd: Can't find CD-ROM drive. Perhaps it has a blank %s in it?", mds);
+        if (interrogate_disk_currently_in_cddrive(cd_dev, FALSE)) {
+            ok_go_ahead_burn_it = FALSE;
+            log_to_screen("There isn't a writable %s in the drive.", mds);
+        }
+        mr_free(mds);
+    }
+
+    if (!ok_go_ahead_burn_it) {
+        if (!bkpinfo->please_dont_eject) {
+            eject_device(cdrom_dev);
+        }
+        mds = media_descriptor_string(g_backup_media_type);
+        mr_asprintf(tmp, "I am about to burn %s #%d of the backup set. Please insert %s and press Enter.", mds, g_current_media_number, mds);
+        mr_free(mds);
+
+        popup_and_OK(tmp);
+        mr_free(tmp);
+        goto gotos_make_me_puke;
+    } else {
+        log_msg(2, "paafcd: OK, going ahead and burning it.");
+    }
+
+    mds = media_descriptor_string(g_backup_media_type);
+    log_msg(2, "paafcd: OK, I assume I have a blank/reusable %s in the drive...", mds);
+
+    log_to_screen("Proceeding w/ %s in drive.", mds);
+    mr_free(mds);
+
+    mr_free(cdrom_dev);
+    paranoid_free(cd_dev);
+    mr_free(mtpt);
+    if (pmountable) {
+        if (attempt_to_mount_returned_this) {
+            *pmountable = FALSE;
+        } else {
+            *pmountable = TRUE;
+        }
+    }
+
+}
+
+
+/**
+ * @addtogroup LLarchiveGroup
+ * @{
+ */
+
+void pause_for_N_seconds(int how_long, char *msg)
+{
+    int i;
+    open_evalcall_form(msg);
+    for (i = 0; i < how_long; i++) {
+        update_evalcall_form((int) ((100.0 / (float) (how_long) * i)));
+        sleep(1);
+    }
+    close_evalcall_form();
+}
+
+
+/**
+ * Create an ISO image in @c destfile, from files in @c bkpinfo->scratchdir.
+ *
+ * @param bkpinfo The backup information structure. Fields used:
+ * - @c backup_media_type
+ * - @c call_after_iso
+ * - @c call_before_iso
+ * - @c call_burn_iso
+ * - @c call_make_iso
+ * - @c make_cd_use_lilo
+ * - @c manual_cd_tray
+ * - @c nonbootable_backup
+ * - @c scratchdir
+ *
+ * @param destfile Where to put the generated ISO image.
+ * @return The number of errors encountered (0 for success)
+ */
+int make_iso_fs(char *destfile) {
+    /*@ int ********************************************** */
+    int retval = 0;
+    int res;
+
+    /*@ buffers ****************************************** */
+    char *tmp = NULL;
+    char *old_pwd = NULL;
+    char *result_sz = NULL;
+    char *message_to_screen = NULL;
+    char *sz_blank_disk = NULL;
+    char *isofs_cmd = NULL;
+    char *full_isofs_cmd = NULL;
+    char *mds = NULL;
+    char *uefistr = NULL;
+    bool cd_is_mountable;
+
+    assert(bkpinfo != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(destfile);
+
+    if (bkpinfo->backup_media_type == iso && bkpinfo->manual_cd_tray) {
+        popup_and_OK("Please insert new media and press Enter.");
+    }
+
+    log_msg(2, "make_iso_fs --- scratchdir=%s --- destfile=%s", bkpinfo->scratchdir, destfile);
+    old_pwd = mr_getcwd();
+    mr_asprintf(tmp, "chmod 700 %s", bkpinfo->scratchdir);
+    run_program_and_log_output(tmp, FALSE);
+    mr_free(tmp);
+
+    if (chdir(bkpinfo->scratchdir)) {
+        // FIXME
+    }
+
+    if (bkpinfo->call_before_iso != NULL) {
+        mr_asprintf(message_to_screen, "Running pre-ISO call for CD#%d", g_current_media_number);
+        res = eval_call_to_make_ISO(bkpinfo->call_before_iso, destfile, g_current_media_number, message_to_screen);
+        if (res) {
+            mr_strcat(message_to_screen, "...failed");
+        } else {
+            mr_strcat(message_to_screen, "...OK");
+        }
+        log_to_screen(message_to_screen);
+        paranoid_free(message_to_screen);
+
+        retval += res;
+    }
+
+    if (bkpinfo->call_make_iso != NULL) {
+        log_msg(2, "bkpinfo->call_make_iso = %s", bkpinfo->call_make_iso);
+        mds = media_descriptor_string(bkpinfo->backup_media_type);
+        mr_asprintf(message_to_screen, "Making an ISO (%s #%d)", mds, g_current_media_number);
+        mr_free(mds);
+
+        pause_and_ask_for_cdr(2, &cd_is_mountable); /* if g_current_media_number >= 2 then pause & ask */
+        if (retval) {
+            log_to_screen
+                ("Serious error(s) occurred already. I shan't try to write to media.");
+        } else {
+            res =
+                eval_call_to_make_ISO(bkpinfo->call_make_iso, bkpinfo->scratchdir, g_current_media_number, message_to_screen);
+            if (res) {
+                log_to_screen("%s...failed to write", message_to_screen);
+            } else {
+                log_to_screen("%s...OK", message_to_screen);
+                mr_asprintf(tmp, "tail -n10 %s | grep -F ':-('", MONDO_LOGFILE);
+                if (!run_program_and_log_output(tmp, 1)) {
+                    log_to_screen
+                        ("Despite nonfatal errors, growisofs confirms the write was successful.");
+                }
+                mr_free(tmp);
+            }
+            retval += res;
+#ifdef DVDRWFORMAT
+            mr_asprintf(tmp, "tail -n8 %s | grep 'blank=full.*dvd-compat.*DAO'", MONDO_LOGFILE);
+            if (g_backup_media_type == dvd
+                && (res || !run_program_and_log_output(tmp, 1))) {
+                log_to_screen
+                    ("Failed to write to disk. I shall blank it and then try again.");
+                sleep(5);
+                /* reset error counter before trying to blank DVD */
+                retval -= res;
+                sync();
+                pause_for_N_seconds(5, "Letting DVD drive settle");
+
+// dvd+rw-format --- OPTION 2
+                if (!bkpinfo->please_dont_eject) {
+                    log_to_screen("Ejecting media to clear drive status.");
+                    eject_device(bkpinfo->media_device);
+                    inject_device(bkpinfo->media_device);
+                }
+                pause_for_N_seconds(5, "Letting DVD drive settle");
+                if (bkpinfo->media_device) {
+                    mr_asprintf(sz_blank_disk, "dvd+rw-format -force %s", bkpinfo->media_device);
+                } else {
+                    mr_asprintf(sz_blank_disk, "dvd+rw-format");
+                }
+                log_msg(3, "sz_blank_disk = '%s'", sz_blank_disk);
+                res = run_external_binary_with_percentage_indicator_NEW("Blanking DVD disk", sz_blank_disk);
+                if (res) {
+                    log_to_screen("Warning - format failed. (Was it a DVD-R?) Sleeping for 5 seconds to take a breath...");
+                    pause_for_N_seconds(5, "Letting DVD drive settle... and trying again.");
+                    res = run_external_binary_with_percentage_indicator_NEW("Blanking DVD disk", sz_blank_disk);
+                    if (res) {
+                        log_to_screen("Format failed a second time.");
+                    }
+                } else {
+                    log_to_screen
+                        ("Format succeeded. Sleeping for 5 seconds to take a breath...");
+                }
+                mr_free(sz_blank_disk);
+                pause_for_N_seconds(5, "Letting DVD drive settle");
+                if (!bkpinfo->please_dont_eject) {
+                    log_to_screen("Ejecting media to clear drive status.");
+                    eject_device(bkpinfo->media_device);
+                    inject_device(bkpinfo->media_device);
+                }
+                pause_for_N_seconds(5, "Letting DVD drive settle");
+                res = eval_call_to_make_ISO(bkpinfo->call_make_iso, bkpinfo->scratchdir, g_current_media_number, message_to_screen);
+                retval += res;
+                if (!bkpinfo->please_dont_eject) {
+                    log_to_screen("Ejecting media.");
+                    eject_device(bkpinfo->media_device);
+                }
+                if (res) {
+                    log_to_screen("Dagnabbit. It still failed.");
+                } else {
+                    log_to_screen
+                        ("OK, this time I successfully backed up to DVD.");
+                }
+            }
+            mr_free(tmp);
+#endif
+            if (g_backup_media_type == dvd && !bkpinfo->please_dont_eject) {
+                eject_device(bkpinfo->media_device);
+            }
+        }
+        paranoid_free(message_to_screen);
+    } else {
+        mds = media_descriptor_string(bkpinfo->backup_media_type);
+        mr_asprintf(message_to_screen, "Running mkisofs to make %s #%d", mds, g_current_media_number);
+        log_msg(1, message_to_screen);
+        mr_asprintf(result_sz, "Call to mkisofs to make ISO (%s #%d) ", mds,  g_current_media_number);
+        mr_free(mds);
+        if ((tmp = find_home_of_exe("xorriso")) != NULL) {
+            mr_asprintf(isofs_cmd, "%s %s", tmp, MONDO_XORRISO_OPT);
+        } else if ((tmp = find_home_of_exe("genisoimage")) != NULL) {
+            mr_asprintf(isofs_cmd, "%s %s", tmp, MONDO_GENISOIMAGE_OPT);
+        } else if ((tmp = find_home_of_exe("mkisofs")) != NULL) {
+            mr_asprintf(isofs_cmd, "%s %s", tmp, MONDO_MKISOFS_OPT);
+        } else if ((tmp = find_home_of_exe("wodim")) != NULL) {
+            mr_asprintf(isofs_cmd, "%s %s", tmp, MONDO_WODIM_OPT);
+        } else {
+            fatal_error("Unable to find a command to create ISO among xorriso, genisoimage, mksiofs or wodim, please install one");
+        }
+        mr_free(tmp);
+        if (bkpinfo->nonbootable_backup) {
+            log_msg(1, "Making nonbootable backup");
+            mr_asprintf(full_isofs_cmd, "%s%s-o '_ISO_' .",isofs_cmd,MONDO_MKISOFS);
+            res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
+            mr_free(full_isofs_cmd);
+        } else {
+            log_msg(1, "Making bootable backup");
+
+#ifdef __FreeBSD__
+            bkpinfo->make_cd_use_lilo = TRUE;
+#endif
+
+
+            log_msg(1, "make_cd_use_lilo is actually %d", bkpinfo->make_cd_use_lilo);
+            if (bkpinfo->make_cd_use_lilo) {
+                log_msg(1, "make_cd_use_lilo = TRUE");
+#ifdef __IA64__
+                log_msg(1, "IA64 --> elilo");
+                mr_asprintf(full_isofs_cmd, "%s%s-o '_ISO_' .",isofs_cmd,MONDO_MKISOFS_REGULAR_ELILO);
+                res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
+                mr_free(full_isofs_cmd);
+#else
+                log_msg(1, "Non-ia64 --> lilo");
+                mr_asprintf(full_isofs_cmd, "%s%s-b images/mindi-bootroot.img -c images/boot.cat -o '_ISO_' .",isofs_cmd,MONDO_MKISOFS);
+                // FIXME: fixed boot size probably wrong. lilo to be removed
+                res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
+                mr_free(full_isofs_cmd);
+#endif
+            } else {
+                log_msg(1, "make_cd_use_lilo = FALSE");
+                log_msg(1, "Isolinux");
+                if (bkpinfo->boot_type == UEFI) {
+                    if (strstr(isofs_cmd,"xorriso")) {
+                        /*  xorriso needs another '-' before efi-boot */
+                        mr_asprintf(uefistr, "%s -%s", MONDO_UEFI_PREFIX, MONDO_MKISOFS_UEFI);
+                    } else {
+                        mr_asprintf(uefistr, "%s %s", MONDO_UEFI_PREFIX, MONDO_MKISOFS_UEFI);
+                    }
+                } else {
+                    mr_asprintf(uefistr, "%s",MONDO_MKISOFS_CMS);
+                }
+                mr_asprintf(full_isofs_cmd, "%s%s%s-o '_ISO_' .",isofs_cmd,MONDO_MKISOFS_REGULAR_SYSLINUX,uefistr);
+                mr_free(uefistr);
+
+                res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
+                mr_free(full_isofs_cmd);
+            }
+        }
+        mr_free(isofs_cmd);
+        paranoid_free(message_to_screen);
+
+        if (res) {
+            mr_strcat(result_sz, "...failed");
+        } else {
+            mr_strcat(result_sz, "...OK");
+        }
+        log_to_screen(result_sz);
+        paranoid_free(result_sz);
+        retval += res;
+    }
+
+    if (bkpinfo->backup_media_type == cdr) {
+        if (is_this_device_mounted(bkpinfo->media_device)) {
+            log_msg(2, "Warning - %s mounted. I'm unmounting it before I burn to it.", bkpinfo->media_device);
+            mr_asprintf(tmp, "umount %s", bkpinfo->media_device);
+            run_program_and_log_output(tmp, FALSE);
+            mr_free(tmp);
+        }
+    }
+
+    if (bkpinfo->call_burn_iso != NULL) {
+        log_msg(2, "bkpinfo->call_burn_iso = %s", bkpinfo->call_burn_iso);
+        mds = media_descriptor_string(bkpinfo->backup_media_type);
+        mr_asprintf(message_to_screen, "Burning %s #%d", mds, g_current_media_number);
+        mr_free(mds);
+        pause_and_ask_for_cdr(2, &cd_is_mountable);
+        res = eval_call_to_make_ISO(bkpinfo->call_burn_iso, destfile, g_current_media_number, message_to_screen);
+        if (res) {
+            mr_strcat(message_to_screen, "...failed");
+        } else {
+            mr_strcat(message_to_screen, "...OK");
+        }
+        log_to_screen(message_to_screen);
+        paranoid_free(message_to_screen);
+
+        retval += res;
+    }
+
+    if (bkpinfo->call_after_iso != NULL) {
+        mds = media_descriptor_string(bkpinfo->backup_media_type);
+        mr_asprintf(message_to_screen, "Running post-ISO call (%s #%d)", mds, g_current_media_number);
+        mr_free(mds);
+        res = eval_call_to_make_ISO(bkpinfo->call_after_iso, destfile, g_current_media_number, message_to_screen);
+        if (res) {
+            mr_strcat(message_to_screen, "...failed");
+        } else {
+            mr_strcat(message_to_screen, "...OK");
+        }
+        log_to_screen(message_to_screen);
+        paranoid_free(message_to_screen);
+
+        retval += res;
+    }
+
+    if (chdir(old_pwd)) {
+        // FIXME
+    }
+    mr_free(old_pwd);
+    if (retval) {
+        log_msg(1, "WARNING - make_iso_fs returned an error");
+    }
+    return (retval);
+}
+
+
+bool is_dev_an_NTFS_dev(char *bigfile_fname)
+{
+    char *tmp = NULL;
+    char *command = NULL;
+    bool ret = TRUE;
+
+    mr_asprintf(command, "dd if=%s bs=512 count=1 2> /dev/null | strings | head -n1", bigfile_fname);
+    log_msg(1, "command = '%s'", command);
+    tmp = call_program_and_get_last_line_of_output(command);
+    mr_free(command);
+
+    log_msg(1, "--> tmp = '%s'", tmp);
+    if (strstr(tmp, "NTFS")) {
+        log_it("TRUE");
+        ret = TRUE;
+    } else {
+        log_it("FALSE");
+        ret = FALSE;
+    }
+    mr_free(tmp);
+    return(ret);
+}
+
+
 
 /**
@@ -601 +1241 @@
         mvaddstr_and_log_it(g_currentY++, 74, "Done.");
     }
+
+    return (retval);
+}
+
+/**
+ * Copy some files to tape.
+ * This function copies the files specified as parameters into the tape stream.
+ *
+ * @param bkpinfo The backup information structure. Used only in the call to
+ * @c write_file_to_stream_from_file().
+ *
+ * @param files_to_add The files to copy to the tape stream.
+ * @warning The list of @c files_to_add must be terminated with @c NULL.
+ * @note Files may be split across multiple tapes if necessary.
+ *
+ * @return The number of errors encountered (0 for success)
+ */
+int
+_move_files_to_stream(char *files_to_add, ...)
+{
+
+    /*@ int ************************************************************ */
+    int retval = 0;
+    int res = 0;
+    /*@ buffers ******************************************************** */
+
+    /*@ char *********************************************************** */
+    char start_chr;
+    char stop_chr;
+    char *curr_file = NULL;
+    char *cf;
+    /*@ long long ****************************************************** */
+    off_t length_of_incoming_file = (off_t)0;
+    va_list ap;
+
+    assert(bkpinfo != NULL);
+    va_start(ap, files_to_add);
+    for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
+        if (!cf) {
+            continue;
+        }
+        mr_asprintf(curr_file, "%s", cf);
+        if (!does_file_exist(curr_file)) {
+            log_msg(1,
+                    "Warning - you're trying to add a non-existent file - '%s' to the tape",
+                    curr_file);
+        }
+        /* create header chars */
+        start_chr = BLK_START_AN_AFIO_OR_SLICE;
+        stop_chr = BLK_STOP_AN_AFIO_OR_SLICE;
+        /* ask for new tape if necessary */
+        length_of_incoming_file = length_of_file(curr_file);
+        write_header_block_to_stream(length_of_incoming_file, curr_file, start_chr);
+        res = write_file_to_stream_from_file(curr_file);
+        retval += res;
+        unlink(curr_file);
+        mr_free(curr_file);
+        /* write closing header */
+        write_header_block_to_stream((off_t)0, "finished-writing-file", stop_chr);
+    }
+    va_end(ap);
+
+    if (retval) {
+        log_msg(1,
+                "Warning - errors occurred while I was adding file to tape");
+    }
+    return (retval);
+}
+
+/**
+ * Move some files to the ISO scratch directory.
+ * This function moves files specified as parameters, into the directory
+ * @c bkpinfo->scratchdir, where the files that will be stored on the next
+ * CD are waiting.
+ *
+ * @param bkpinfo The backup information structure. Fields used:
+ * - @c media_size
+ * - @c scratchdir
+ * @param files_to_add The files to add to the scratchdir.
+ * @warning The list of @c files_to_add must be terminated with @c NULL.
+ * @note If and when the space occupied by the scratchdir would exceed
+ * the capacity of the current CD,
+ * <tt>write_iso_and_go_on(bkpinfo, FALSE)</tt> is called and the
+ * scratchdir is emptied.
+ *
+ * @return The number of errors encountered (0 for success)
+ */
+int _move_files_to_cd(char *files_to_add, ...)
+{
+
+    /*@ int ************************************************************ */
+    int retval = 0;
+    int res = 0;
+
+    /*@ buffers ******************************************************** */
+    char *tmp = NULL;
+    char *curr_file = NULL;
+    char *cf;
+
+    /*@ long ************************************************************ */
+    va_list ap;
+    long long would_occupy;
+
+    assert(bkpinfo != NULL);
+    would_occupy = space_occupied_by_cd(bkpinfo->scratchdir);
+    va_start(ap, files_to_add); // initialize the variable arguments
+    for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
+        if (!cf) {
+            continue;
+        }
+        mr_asprintf(curr_file, "%s", cf);
+        if (!does_file_exist(curr_file)) {
+            log_msg(1, "Warning - you're trying to add a non-existent file - '%s' to the CD", curr_file);
+        } else {
+            log_msg(8, "Trying to add file %s to CD", curr_file);
+            would_occupy += length_of_file(curr_file) / 1024;
+        }
+        mr_free(curr_file);
+    }
+    va_end(ap);
+
+    if (bkpinfo->media_size <= 0) {
+        fatal_error("move_files_to_cd() - unknown media size");
+    }
+    if (would_occupy / 1024 > bkpinfo->media_size) {
+        res = write_iso_and_go_on(FALSE);   /* FALSE because this is not the last CD we'll write */
+        retval += res;
+        if (res) {
+            log_msg(1, "WARNING - write_iso_and_go_on returned an error");
+        }
+    }
+
+    va_start(ap, files_to_add); // initialize the variable arguments
+    for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
+        if (!cf) {
+            continue;
+        }
+        mr_asprintf(curr_file, "%s", cf);
+
+        mr_asprintf(tmp, "mv -f %s %s/archives/", curr_file, bkpinfo->scratchdir);
+        mr_free(curr_file);
+        res = run_program_and_log_output(tmp, 5);
+        retval += res;
+        if (res) {
+            log_msg(1, "(move_files_to_cd) '%s' failed", tmp);
+        } else {
+            log_msg(8, "Moved %s to CD OK", tmp);
+        }
+        mr_free(tmp);
+    }
+    va_end(ap);
+
+    if (retval) {
+        log_msg(1,
+                "Warning - errors occurred while I was adding files to CD dir");
+    }
+    return (retval);
+}
+
+
+
+/**
+ * @addtogroup LLarchiveGroup
+ * @{
+ */
+/**
+ * Function pointer to an appropriate @c move_files_to_stream routine.
+ * You can set this to your own function (for example, one to
+ * transfer files over the network) or leave it as is.
+ */
+int (*move_files_to_stream) (char *, ...) =
+    _move_files_to_stream;
+
+
+/**
+ * Function pointer to an appropriate @c move_files_to_cd routine.
+ * You can set this to your own function (for example, one to
+ * transfer files over the network) or leave it as is.
+ */
+int (*move_files_to_cd) (char *, ...) =
+    _move_files_to_cd;
+
+
+/**
+ * Set the <tt>N</tt>th bit of @c array to @c true_or_false.
+ * @param array The bit array (as a @c char pointer).
+ * @param N The bit number to set or reset.
+ * @param true_or_false If TRUE then set bit @c N, if FALSE then reset bit @c N.
+ * @see get_bit_N_of_array
+ */
+void set_bit_N_of_array(char *array, int N, bool true_or_false)
+{
+    int bit_number;
+    int mask, orig_val, to_add;
+    int element_number;
+
+    assert(array != NULL);
+
+    element_number = N / 8;
+    bit_number = N % 8;
+    to_add = (1 << bit_number);
+    mask = 255 - to_add;
+    orig_val = array[element_number] & mask;
+    //  log_it("array[%d]=%02x; %02x&%02x = %02x", element_number, array[element_number], mask, orig_val);
+    if (true_or_false) {
+        array[element_number] = orig_val | to_add;
+    }
+}
+
+
+/**
+ * Get the <tt>N</tt>th bit of @c array.
+ * @param array The bit-array (as a @c char pointer).
+ * @param N The number of the bit you want.
+ * @return TRUE (bit is set) or FALSE (bit is not set).
+ * @see set_bit_N_of_array
+ * @ingroup utilityGroup
+ */
+bool get_bit_N_of_array(char *array, int N)
+{
+    int element_number;
+    int bit_number;
+    int mask;
+
+    element_number = N / 8;
+    bit_number = N % 8;
+    mask = 1 << bit_number;
+    if (array[element_number] & mask) {
+        return (TRUE);
+    } else {
+        return (FALSE);
+    }
+}
+
+
+
+/**
+ * Chop up @c filename.
+ * @param bkpinfo The backup information structure. Fields used:
+ * - @c backup_media_type
+ * - @c compression_level
+ * - @c optimal_set_size
+ * - @c tmpdir
+ * - @c use_lzo
+ * - @c zip_exe
+ * - @c zip_suffix
+ *
+ * @param biggie_filename The file to chop up.
+ * @param ntfsprog_fifo The FIFO to ntfsclone if this is an imagedev, NULL otherwise.
+ * @param biggie_file_number The sequence number of this biggie file (starting from 0).
+ * @param noof_biggie_files The number of biggie files there are total.
+ * @return The number of errors encountered (0 for success)
+ * @see make_slices_and_images
+ * @ingroup LLarchiveGroup
+ */
+int slice_up_file_etc(char *biggie_filename, char *ntfsprog_fifo, long biggie_file_number, long noof_biggie_files, bool use_ntfsprog) {
+
+    /*@ buffers ************************************************** */
+    char *tmp = NULL;
+    char *checksum_line = NULL;
+    char *command = NULL;
+    char *tempblock = NULL;
+    char *curr_slice_fname_uncompressed = NULL;
+    char *curr_slice_fname_compressed = NULL;
+    char *file_to_archive = NULL;
+    char *file_to_openin = NULL;
+    /*@ pointers ************************************************** */
+    char *pB = NULL;
+    FILE *fin = NULL;
+    FILE *fout = NULL;
+
+    /*@ bool ****************************************************** */
+    bool finished = FALSE;
+
+    /*@ long ****************************************************** */
+    size_t blksize = (size_t)0;
+    long slice_num = 0L;
+    long i = 0L;
+    bool should_I_compress_slices = TRUE;
+    char *suffix = NULL;                // for compressed slices
+
+    /*@ long long ************************************************** */
+    off_t totalread = (off_t)0;
+    off_t totallength = (off_t)0;
+
+    /*@ int ******************************************************** */
+    int retval = 0;
+    int res = 0;
+
+    /*@ structures ************************************************** */
+    struct s_filename_and_lstat_info biggiestruct;
+
+    assert(bkpinfo != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(biggie_filename);
+
+    biggiestruct.for_backward_compatibility = '\n';
+    biggiestruct.use_ntfsprog = use_ntfsprog;
+    if (is_this_file_compressed(biggie_filename) || bkpinfo->compression_level == 0) {
+        mr_asprintf(suffix, "%s", "");
+        should_I_compress_slices = FALSE;
+    } else {
+        mr_asprintf(suffix, "%s", bkpinfo->zip_suffix);
+        should_I_compress_slices = TRUE;
+    }
+
+    if (bkpinfo->optimal_set_size < 999L) {
+        fatal_error("bkpinfo->optimal_set_size is insanely small");
+    }
+
+    if (ntfsprog_fifo) {
+        file_to_openin = ntfsprog_fifo;
+        mr_asprintf(checksum_line, "IGNORE");
+        log_msg(2, "Not calculating checksum for %s: it would take too long", biggie_filename);
+        if ((tmp = find_home_of_exe("ntfsresize")) == NULL) {
+            fatal_error("ntfsresize not found");
+        }
+        mr_asprintf(command, "%s --force --info %s|grep '^You might resize at '|cut -d' ' -f5", tmp, biggie_filename);
+        mr_free(tmp);
+        log_it("command = %s", command);
+        tmp = call_program_and_get_last_line_of_output(command);
+        mr_free(command);
+        log_it("res of it = %s", tmp); 
+        totallength = (off_t)atoll(tmp);
+        mr_free(tmp);
+    } else {
+        file_to_openin = biggie_filename;
+        if (strchr(biggie_filename,'\'') != NULL) {
+            mr_asprintf(command, "md5sum \"%s\"", biggie_filename);
+        } else {
+            mr_asprintf(command, "md5sum '%s'", biggie_filename);
+        }
+        if (!(fin = popen(command, "r"))) {
+            log_OS_error("Unable to popen-in command");
+            mr_free(suffix);
+            return (1);
+        }
+        mr_free(command);
+        mr_getline(checksum_line, fin);
+        pclose(fin);
+        totallength = length_of_file(biggie_filename);
+    }
+    lstat(biggie_filename, &biggiestruct.properties);
+    strcpy(biggiestruct.filename, biggie_filename);
+    pB = strchr(checksum_line, ' ');
+    if (!pB) {
+        pB = strchr(checksum_line, '\t');
+    }
+    if (pB) {
+        *pB = '\0';
+    }
+    strcpy(biggiestruct.checksum, checksum_line);
+    mr_free(checksum_line);
+
+    mr_asprintf(tmp, "%s", slice_fname(biggie_file_number, 0, bkpinfo->tmpdir, ""));
+    fout = fopen(tmp, "w");
+    if (fout == NULL) {
+        log_msg(1, "Unable to open and write to %s", tmp);
+        mr_free(tmp);
+        mr_free(suffix);
+        return (1);
+    }
+    res = fwrite((void *) &biggiestruct, 1, sizeof(biggiestruct), fout);
+    paranoid_fclose(fout);
+    mr_free(tmp);
+
+    log_msg(1, "Opening in %s; slicing it and writing to CD/tape", file_to_openin);
+    if (!(fin = fopen(file_to_openin, "r"))) {
+        log_OS_error("Unable to openin biggie_filename");
+        log_to_screen("Cannot archive bigfile '%s': not found", biggie_filename);
+
+        mr_free(suffix);
+        return (1);
+    }
+    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
+        res = move_files_to_stream(slice_fname(biggie_file_number, 0, bkpinfo->tmpdir, ""), NULL);
+    } else {
+        res = move_files_to_cd(slice_fname(biggie_file_number, 0, bkpinfo->tmpdir, ""), NULL);
+    }
+    i = bkpinfo->optimal_set_size / 256L;
+    if (!(tempblock = (char *) malloc(256 * 1024))) {
+        fatal_error("malloc error 256*1024");
+    }
+    for (slice_num = 1; !finished; slice_num++) {
+        mr_asprintf(curr_slice_fname_uncompressed, "%s", slice_fname(biggie_file_number, slice_num, bkpinfo->tmpdir, ""));
+        mr_asprintf(curr_slice_fname_compressed, "%s", slice_fname(biggie_file_number, slice_num, bkpinfo->tmpdir, suffix));
+
+        tmp = percent_media_full_comment();
+        update_progress_form(tmp);
+        mr_free(tmp);
+
+        if (!(fout = fopen(curr_slice_fname_uncompressed, "w"))) {
+            log_OS_error(curr_slice_fname_uncompressed);
+            mr_free(suffix);
+            return (1);
+        }
+        if ((i == bkpinfo->optimal_set_size / 256L) && (totalread < (off_t)1.1 * totallength)) {
+            for (i = 0L; i < (bkpinfo->optimal_set_size / 256L); i++) {
+                blksize = fread(tempblock, 1, 256 * 1024, fin);
+                if (blksize > (size_t)0) {
+                    totalread = totalread + (off_t)blksize;
+                    res = fwrite(tempblock, 1, blksize, fout);
+                } else {
+                    break;
+                }
+            }
+        } else {
+            i = 0L;
+        }
+        paranoid_fclose(fout);
+        if (i > 0L)             // length_of_file (curr_slice_fname_uncompressed)
+        {
+            if (!does_file_exist(curr_slice_fname_uncompressed)) {
+                log_msg(2, "Warning - '%s' doesn't exist. How can I compress slice?", curr_slice_fname_uncompressed);
+            }
+            if (should_I_compress_slices && bkpinfo->compression_level > 0) {
+                mr_asprintf(command, "%s -%d %s", bkpinfo->zip_exe, bkpinfo->compression_level, curr_slice_fname_uncompressed);
+                log_msg(2, command);
+                if ((res = system(command))) {
+                    log_OS_error(command);
+                }
+                //          did_I_compress_slice = TRUE;
+            } else {
+                mr_asprintf(command, "mv %s %s 2>> %s", curr_slice_fname_uncompressed, curr_slice_fname_compressed, MONDO_LOGFILE);
+                res = 0;        // don't do it :)
+                //          did_I_compress_slice = FALSE;
+            }
+            mr_free(command);
+
+            retval += res;
+            if (res) {
+                log_msg(2, "Failed to compress the slice");
+            }
+            if (bkpinfo->use_lzo && strcmp(curr_slice_fname_compressed, curr_slice_fname_uncompressed)) {
+                unlink(curr_slice_fname_uncompressed);
+            }
+            if (res) {
+                mr_asprintf(tmp, "Problem with slice # %ld", slice_num);
+            } else {
+                mr_asprintf(tmp, "%s - Bigfile #%ld, slice #%ld compressed OK          ", biggie_filename, biggie_file_number + 1, slice_num);
+            }
+            if (!g_text_mode) {
+                newtDrawRootText(0, g_noof_rows - 2, tmp);
+                newtRefresh();
+            } else {
+                log_msg(2, tmp);
+            }
+            mr_free(tmp);
+
+            mr_asprintf(file_to_archive, "%s", curr_slice_fname_compressed);
+            g_current_progress++;
+        } else {                /* if i==0 then ... */
+            finished = TRUE;
+            mr_asprintf(file_to_archive, "%s", curr_slice_fname_uncompressed);
+            if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
+                break;
+            }
+        }
+        mr_free(curr_slice_fname_uncompressed);
+        mr_free(curr_slice_fname_compressed);
+
+        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
+            register_in_tape_catalog(biggieslice, biggie_file_number, slice_num, file_to_archive);
+            maintain_collection_of_recent_archives(bkpinfo->tmpdir, file_to_archive);
+            res = move_files_to_stream(file_to_archive, NULL);
+        } else {
+            res = move_files_to_cd(file_to_archive, NULL);
+        }
+        mr_free(file_to_archive);
+
+        retval += res;
+        if (res) {
+            log_to_screen("Failed to add slice %ld of bigfile %ld to scratchdir", slice_num, biggie_file_number + 1);
+            fatal_error("Hard disk full. You should have bought a bigger one.");
+        }
+    }
+    mr_free(tempblock);
+    mr_free(suffix);
+    paranoid_fclose(fin);
+    mr_asprintf(tmp, "Sliced bigfile #%ld", biggie_file_number + 1);
+    if (retval) {
+        mr_strcat(tmp, "...FAILED");
+    } else {
+        mr_strcat(tmp, "...OK!");
+    }
+    log_msg(1, tmp);
+    mr_free(tmp);
 
     return (retval);
@@ -708 +1834 @@
                     mr_free(sz_devfile);
                     fatal_error("Fork failure");
+                    break;
                 case 0:
                     log_msg(2, "CHILD - fip - calling feed_into_ntfsprog(%s, %s)", bigfile_fname, sz_devfile);
@@ -855 +1982 @@
     return (retval);
 }
+/* @} - end of LLarchiveGroup */
+
+/**
+ * Main function for each @c afio thread.
+ * @param inbuf A transfer block containing:
+ * - @c p_last_set_archived: [offset 0] pointer to an @c int
+ *   containing the last set archived.
+ * - @c p_archival_threads_running: [offset 4] pointer to an @c int
+ *   containing the number of archival threads currently running.
+ * - @c p_next_set_to_archive: [offset 8] pointer to an @c int containing
+ *   the next set that should be archived.
+ * - @c p_list_of_fileset_flags: [offset 12] @c char pointer pointing to a
+ *   bit array, where each bit corresponds to a filelist (1=needs
+ *   to be archived, 0=archived).
+ * - @c bkpinfo: [offset BKPINFO_LOC_OFFSET] pointer to backup information
+ *   structure. Fields used:
+ *   - @c tmpdir
+ *   - @c zip_suffix
+ *
+ * Any of the above may be modified by the caller at any time.
+ *
+ * @bug Assumes @c int pointers are 4 bytes.
+ * @see archive_this_fileset
+ * @see make_afioballs_and_images
+ * @return NULL, always.
+ * @ingroup LLarchiveGroup
+ */
+void *create_afio_files_in_background(void *inbuf)
+{
+    long int archiving_set_no = 0L;
+    char *archiving_filelist_fname = NULL;
+    char *archiving_afioball_fname = NULL;
+    char *curr_xattr_list_fname = NULL;
+    char *curr_acl_list_fname = NULL;
+
+    char *tmp = NULL;
+    int res = 0, retval = 0;
+    int *p_archival_threads_running;
+    int *p_last_set_archived;
+    int *p_next_set_to_archive;
+    char *p_list_of_fileset_flags;
+    int this_thread_no = g_current_thread_no++;
+
+    p_last_set_archived = (int *) inbuf;
+    p_archival_threads_running = (int *) (inbuf + 4);
+    p_next_set_to_archive = (int *) (inbuf + 8);
+    p_list_of_fileset_flags = (char *) (inbuf + 12);
+
+    mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, 0L);
+
+    while (does_file_exist(archiving_filelist_fname)) {
+        if (g_exiting) {
+            mr_free(archiving_filelist_fname);
+            fatal_error("Execution run aborted (pthread)");
+        }
+        if (archiving_set_no >= MAX_NOOF_SETS_HERE) {
+            mr_free(archiving_filelist_fname);
+            fatal_error("Maximum number of filesets exceeded. Adjust MAX_NOOF_SETS_HERE, please.");
+        }
+        if (!semaphore_p()) {
+            log_msg(3, "P sem failed (pid=%d)", (int) getpid());
+            mr_free(archiving_filelist_fname);
+            fatal_error("Cannot get semaphore P");
+        }
+        if (archiving_set_no < *p_next_set_to_archive) {
+            archiving_set_no = *p_next_set_to_archive;
+        }
+        *p_next_set_to_archive = *p_next_set_to_archive + 1;
+        if (!semaphore_v()) {
+            mr_free(archiving_filelist_fname);
+            fatal_error("Cannot get semaphore V");
+        }
+
+        /* backup this set of files */
+        mr_asprintf(archiving_afioball_fname, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no, bkpinfo->zip_suffix);
+        mr_free(archiving_filelist_fname);
+        mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
+        if (!does_file_exist(archiving_filelist_fname)) {
+            log_msg(3, "%s[%d:%d] - well, I would archive %d, except that it doesn't exist. I'll stop now.", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
+            mr_free(archiving_afioball_fname);
+            break;
+        }
+
+        mr_asprintf(tmp, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no - ARCH_BUFFER_NUM, bkpinfo->zip_suffix);
+        if (does_file_exist(tmp)) {
+            log_msg(4, "%s[%d:%d] - waiting for storer", FORTY_SPACES, getpid(), this_thread_no);
+            while (does_file_exist(tmp)) {
+                sleep(1);
+            }
+            log_msg(4, "[%d] - continuing", getpid());
+        }
+        mr_free(tmp);
+
+        log_msg(4, "%s[%d:%d] - EXATing %d...", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
+
+        if (g_getfattr) {
+            mr_asprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
+            get_fattr_list(archiving_filelist_fname, curr_xattr_list_fname);
+            mr_free(curr_xattr_list_fname);
+        }
+        if (g_getfacl) {
+            mr_asprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
+            get_acl_list(archiving_filelist_fname, curr_acl_list_fname);
+            mr_free(curr_acl_list_fname);
+        }
+
+        log_msg(4, "%s[%d:%d] - archiving %d...", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
+        res = archive_this_fileset(archiving_filelist_fname, archiving_afioball_fname, archiving_set_no);
+        mr_free(archiving_afioball_fname);
+
+        retval += res;
+
+        if (res) {
+            log_to_screen("Errors occurred while archiving set %ld. Please review logs.", archiving_set_no);
+        }
+
+        if (!semaphore_p()) {
+            mr_free(archiving_filelist_fname);
+            fatal_error("Cannot get semaphore P");
+        }
+
+        set_bit_N_of_array(p_list_of_fileset_flags, archiving_set_no, 5);
+
+        if (*p_last_set_archived < archiving_set_no) {
+            *p_last_set_archived = archiving_set_no;
+        }                       // finished archiving this one
+
+        if (!semaphore_v()) {
+            mr_free(archiving_filelist_fname);
+            fatal_error("Cannot get semaphore V");
+        }
+        log_msg(4, "%s[%d:%d] - archived %d OK", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
+        archiving_set_no++;
+
+        mr_free(archiving_filelist_fname);
+        mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
+    }
+    mr_free(archiving_filelist_fname);
+
+    if (!semaphore_p()) {
+        fatal_error("Cannot get semaphore P");
+    }
+    (*p_archival_threads_running)--;
+    if (!semaphore_v()) {
+        fatal_error("Cannot get semaphore V");
+    }
+    log_msg(3, "%s[%d:%d] - exiting", FORTY_SPACES, getpid(), this_thread_no);
+    pthread_exit(NULL);
+}
+
 
 /**
@@ -1859 +3136 @@
 
 
-
-/**
- * Set the <tt>N</tt>th bit of @c array to @c true_or_false.
- * @param array The bit array (as a @c char pointer).
- * @param N The bit number to set or reset.
- * @param true_or_false If TRUE then set bit @c N, if FALSE then reset bit @c N.
- * @see get_bit_N_of_array
- */
-void set_bit_N_of_array(char *array, int N, bool true_or_false)
-{
-    int bit_number;
-    int mask, orig_val, to_add;
-    int element_number;
-
-    assert(array != NULL);
-
-    element_number = N / 8;
-    bit_number = N % 8;
-    to_add = (1 << bit_number);
-    mask = 255 - to_add;
-    orig_val = array[element_number] & mask;
-    //  log_it("array[%d]=%02x; %02x&%02x = %02x", element_number, array[element_number], mask, orig_val);
-    if (true_or_false) {
-        array[element_number] = orig_val | to_add;
-    }
-}
-
-
-
-/**
- * Maximum number of filesets allowed in this function.
- */
-#define MAX_NOOF_SETS_HERE 32767
-
-/**
- * Offset of the bkpinfo pointer (in bytes) from the
- * buffer passed to create_afio_files_in_background.
- */
-#define BKPINFO_LOC_OFFSET (16+MAX_NOOF_SETS_HERE/8+16)
-
-/**
- * Main function for each @c afio thread.
- * @param inbuf A transfer block containing:
- * - @c p_last_set_archived: [offset 0] pointer to an @c int
- *   containing the last set archived.
- * - @c p_archival_threads_running: [offset 4] pointer to an @c int
- *   containing the number of archival threads currently running.
- * - @c p_next_set_to_archive: [offset 8] pointer to an @c int containing
- *   the next set that should be archived.
- * - @c p_list_of_fileset_flags: [offset 12] @c char pointer pointing to a
- *   bit array, where each bit corresponds to a filelist (1=needs
- *   to be archived, 0=archived).
- * - @c bkpinfo: [offset BKPINFO_LOC_OFFSET] pointer to backup information
- *   structure. Fields used:
- *   - @c tmpdir
- *   - @c zip_suffix
- *
- * Any of the above may be modified by the caller at any time.
- *
- * @bug Assumes @c int pointers are 4 bytes.
- * @see archive_this_fileset
- * @see make_afioballs_and_images
- * @return NULL, always.
- * @ingroup LLarchiveGroup
- */
-void *create_afio_files_in_background(void *inbuf)
-{
-    long int archiving_set_no = 0L;
-    char *archiving_filelist_fname = NULL;
-    char *archiving_afioball_fname = NULL;
-    char *curr_xattr_list_fname = NULL;
-    char *curr_acl_list_fname = NULL;
-
-    char *tmp = NULL;
-    int res = 0, retval = 0;
-    int *p_archival_threads_running;
-    int *p_last_set_archived;
-    int *p_next_set_to_archive;
-    char *p_list_of_fileset_flags;
-    int this_thread_no = g_current_thread_no++;
-
-    p_last_set_archived = (int *) inbuf;
-    p_archival_threads_running = (int *) (inbuf + 4);
-    p_next_set_to_archive = (int *) (inbuf + 8);
-    p_list_of_fileset_flags = (char *) (inbuf + 12);
-
-    mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, 0L);
-
-    while (does_file_exist(archiving_filelist_fname)) {
-        if (g_exiting) {
-            mr_free(archiving_filelist_fname);
-            fatal_error("Execution run aborted (pthread)");
-        }
-        if (archiving_set_no >= MAX_NOOF_SETS_HERE) {
-            mr_free(archiving_filelist_fname);
-            fatal_error("Maximum number of filesets exceeded. Adjust MAX_NOOF_SETS_HERE, please.");
-        }
-        if (!semaphore_p()) {
-            log_msg(3, "P sem failed (pid=%d)", (int) getpid());
-            mr_free(archiving_filelist_fname);
-            fatal_error("Cannot get semaphore P");
-        }
-        if (archiving_set_no < *p_next_set_to_archive) {
-            archiving_set_no = *p_next_set_to_archive;
-        }
-        *p_next_set_to_archive = *p_next_set_to_archive + 1;
-        if (!semaphore_v()) {
-            mr_free(archiving_filelist_fname);
-            fatal_error("Cannot get semaphore V");
-        }
-
-        /* backup this set of files */
-        mr_asprintf(archiving_afioball_fname, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no, bkpinfo->zip_suffix);
-        mr_free(archiving_filelist_fname);
-        mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
-        if (!does_file_exist(archiving_filelist_fname)) {
-            log_msg(3, "%s[%d:%d] - well, I would archive %d, except that it doesn't exist. I'll stop now.", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
-            mr_free(archiving_afioball_fname);
-            break;
-        }
-
-        mr_asprintf(tmp, AFIOBALL_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no - ARCH_BUFFER_NUM, bkpinfo->zip_suffix);
-        if (does_file_exist(tmp)) {
-            log_msg(4, "%s[%d:%d] - waiting for storer", FORTY_SPACES, getpid(), this_thread_no);
-            while (does_file_exist(tmp)) {
-                sleep(1);
-            }
-            log_msg(4, "[%d] - continuing", getpid());
-        }
-        mr_free(tmp);
-
-        log_msg(4, "%s[%d:%d] - EXATing %d...", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
-
-        if (g_getfattr) {
-            mr_asprintf(curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
-            get_fattr_list(archiving_filelist_fname, curr_xattr_list_fname);
-            mr_free(curr_xattr_list_fname);
-        }
-        if (g_getfacl) {
-            mr_asprintf(curr_acl_list_fname, ACL_LIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
-            get_acl_list(archiving_filelist_fname, curr_acl_list_fname);
-            mr_free(curr_acl_list_fname);
-        }
-
-        log_msg(4, "%s[%d:%d] - archiving %d...", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
-        res = archive_this_fileset(archiving_filelist_fname, archiving_afioball_fname, archiving_set_no);
-        mr_free(archiving_afioball_fname);
-
-        retval += res;
-
-        if (res) {
-            log_to_screen("Errors occurred while archiving set %ld. Please review logs.", archiving_set_no);
-        }
-
-        if (!semaphore_p()) {
-            mr_free(archiving_filelist_fname);
-            fatal_error("Cannot get semaphore P");
-        }
-
-        set_bit_N_of_array(p_list_of_fileset_flags, archiving_set_no, 5);
-
-        if (*p_last_set_archived < archiving_set_no) {
-            *p_last_set_archived = archiving_set_no;
-        }                       // finished archiving this one
-
-        if (!semaphore_v()) {
-            mr_free(archiving_filelist_fname);
-            fatal_error("Cannot get semaphore V");
-        }
-        log_msg(4, "%s[%d:%d] - archived %d OK", FORTY_SPACES, getpid(), this_thread_no, archiving_set_no);
-        archiving_set_no++;
-
-        mr_free(archiving_filelist_fname);
-        mr_asprintf(archiving_filelist_fname, FILELIST_FNAME_RAW_SZ, bkpinfo->tmpdir, archiving_set_no);
-    }
-    mr_free(archiving_filelist_fname);
-
-    if (!semaphore_p()) {
-        fatal_error("Cannot get semaphore P");
-    }
-    (*p_archival_threads_running)--;
-    if (!semaphore_v()) {
-        fatal_error("Cannot get semaphore V");
-    }
-    log_msg(3, "%s[%d:%d] - exiting", FORTY_SPACES, getpid(), this_thread_no);
-    pthread_exit(NULL);
-}
-
-
-/**
- * Get the <tt>N</tt>th bit of @c array.
- * @param array The bit-array (as a @c char pointer).
- * @param N The number of the bit you want.
- * @return TRUE (bit is set) or FALSE (bit is not set).
- * @see set_bit_N_of_array
- * @ingroup utilityGroup
- */
-bool get_bit_N_of_array(char *array, int N)
-{
-    int element_number;
-    int bit_number;
-    int mask;
-
-    element_number = N / 8;
-    bit_number = N % 8;
-    mask = 1 << bit_number;
-    if (array[element_number] & mask) {
-        return (TRUE);
-    } else {
-        return (FALSE);
-    }
-}
-
-
-/**
- * Move some files to the ISO scratch directory.
- * This function moves files specified as parameters, into the directory
- * @c bkpinfo->scratchdir, where the files that will be stored on the next
- * CD are waiting.
- *
- * @param bkpinfo The backup information structure. Fields used:
- * - @c media_size
- * - @c scratchdir
- * @param files_to_add The files to add to the scratchdir.
- * @warning The list of @c files_to_add must be terminated with @c NULL.
- * @note If and when the space occupied by the scratchdir would exceed
- * the capacity of the current CD,
- * <tt>write_iso_and_go_on(bkpinfo, FALSE)</tt> is called and the
- * scratchdir is emptied.
- *
- * @return The number of errors encountered (0 for success)
- */
-int _move_files_to_cd(char *files_to_add, ...)
-{
-
-    /*@ int ************************************************************ */
-    int retval = 0;
-    int res = 0;
-
-    /*@ buffers ******************************************************** */
-    char *tmp = NULL;
-    char *curr_file = NULL;
-    char *cf;
-
-    /*@ long ************************************************************ */
-    va_list ap;
-    long long would_occupy;
-
-    assert(bkpinfo != NULL);
-    would_occupy = space_occupied_by_cd(bkpinfo->scratchdir);
-    va_start(ap, files_to_add); // initialize the variable arguments
-    for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
-        if (!cf) {
-            continue;
-        }
-        mr_asprintf(curr_file, "%s", cf);
-        if (!does_file_exist(curr_file)) {
-            log_msg(1, "Warning - you're trying to add a non-existent file - '%s' to the CD", curr_file);
-        } else {
-            log_msg(8, "Trying to add file %s to CD", curr_file);
-            would_occupy += length_of_file(curr_file) / 1024;
-        }
-        mr_free(curr_file);
-    }
-    va_end(ap);
-
-    if (bkpinfo->media_size <= 0) {
-        fatal_error("move_files_to_cd() - unknown media size");
-    }
-    if (would_occupy / 1024 > bkpinfo->media_size) {
-        res = write_iso_and_go_on(FALSE);   /* FALSE because this is not the last CD we'll write */
-        retval += res;
-        if (res) {
-            log_msg(1, "WARNING - write_iso_and_go_on returned an error");
-        }
-    }
-
-    va_start(ap, files_to_add); // initialize the variable arguments
-    for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
-        if (!cf) {
-            continue;
-        }
-        mr_asprintf(curr_file, "%s", cf);
-
-        mr_asprintf(tmp, "mv -f %s %s/archives/", curr_file, bkpinfo->scratchdir);
-        mr_free(curr_file);
-        res = run_program_and_log_output(tmp, 5);
-        retval += res;
-        if (res) {
-            log_msg(1, "(move_files_to_cd) '%s' failed", tmp);
-        } else {
-            log_msg(8, "Moved %s to CD OK", tmp);
-        }
-        mr_free(tmp);
-    }
-    va_end(ap);
-
-    if (retval) {
-        log_msg(1,
-                "Warning - errors occurred while I was adding files to CD dir");
-    }
-    return (retval);
-}
-
-/* @} - end of LLarchiveGroup */
-
-/**
- * Copy some files to tape.
- * This function copies the files specified as parameters into the tape stream.
- *
- * @param bkpinfo The backup information structure. Used only in the call to
- * @c write_file_to_stream_from_file().
- *
- * @param files_to_add The files to copy to the tape stream.
- * @warning The list of @c files_to_add must be terminated with @c NULL.
- * @note Files may be split across multiple tapes if necessary.
- *
- * @return The number of errors encountered (0 for success)
- */
-int
-_move_files_to_stream(char *files_to_add, ...)
-{
-
-    /*@ int ************************************************************ */
-    int retval = 0;
-    int res = 0;
-    /*@ buffers ******************************************************** */
-
-    /*@ char *********************************************************** */
-    char start_chr;
-    char stop_chr;
-    char *curr_file = NULL;
-    char *cf;
-    /*@ long long ****************************************************** */
-    off_t length_of_incoming_file = (off_t)0;
-    va_list ap;
-
-    assert(bkpinfo != NULL);
-    va_start(ap, files_to_add);
-    for (cf = files_to_add; cf != NULL; cf = va_arg(ap, char *)) {
-        if (!cf) {
-            continue;
-        }
-        mr_asprintf(curr_file, "%s", cf);
-        if (!does_file_exist(curr_file)) {
-            log_msg(1,
-                    "Warning - you're trying to add a non-existent file - '%s' to the tape",
-                    curr_file);
-        }
-        /* create header chars */
-        start_chr = BLK_START_AN_AFIO_OR_SLICE;
-        stop_chr = BLK_STOP_AN_AFIO_OR_SLICE;
-        /* ask for new tape if necessary */
-        length_of_incoming_file = length_of_file(curr_file);
-        write_header_block_to_stream(length_of_incoming_file, curr_file, start_chr);
-        res = write_file_to_stream_from_file(curr_file);
-        retval += res;
-        unlink(curr_file);
-        mr_free(curr_file);
-        /* write closing header */
-        write_header_block_to_stream((off_t)0, "finished-writing-file", stop_chr);
-    }
-    va_end(ap);
-
-    if (retval) {
-        log_msg(1,
-                "Warning - errors occurred while I was adding file to tape");
-    }
-    return (retval);
-}
-
-
-/**
- * @addtogroup LLarchiveGroup
- * @{
- */
-/**
- * Function pointer to an appropriate @c move_files_to_stream routine.
- * You can set this to your own function (for example, one to
- * transfer files over the network) or leave it as is.
- */
-int (*move_files_to_stream) (char *, ...) =
-    _move_files_to_stream;
-
-
-/**
- * Function pointer to an appropriate @c move_files_to_cd routine.
- * You can set this to your own function (for example, one to
- * transfer files over the network) or leave it as is.
- */
-int (*move_files_to_cd) (char *, ...) =
-    _move_files_to_cd;
-
-
-
-/**
- * @addtogroup LLarchiveGroup
- * @{
- */
-
-void pause_for_N_seconds(int how_long, char *msg)
-{
-    int i;
-    open_evalcall_form(msg);
-    for (i = 0; i < how_long; i++) {
-        update_evalcall_form((int) ((100.0 / (float) (how_long) * i)));
-        sleep(1);
-    }
-    close_evalcall_form();
-}
-
-
-
-
-/**
- * Create a USB image in @c destfile, from files in @c bkpinfo->scratchdir.
- *
- * @param bkpinfo The backup information structure. Fields used:
- * - @c backup_media_type
- * - @c nonbootable_backup
- * - @c scratchdir
- *
- * @param destfile Where to put the generated USB image.
- * @return The number of errors encountered (0 for success)
- */
-int make_usb_fs()
-{
-    /*@ int ********************************************** */
-    int retval = 0;
-    int res;
-
-    /*@ buffers ****************************************** */
-    char *tmp = NULL;
-    char *tmp1 = NULL;
-    char *result_sz = NULL;
-    char *message_to_screen = NULL;
-    char *old_pwd = NULL;
-    char *mds = NULL;
-
-    assert(bkpinfo != NULL);
-
-    log_msg(2, "make_usb_fs --- scratchdir=%s", bkpinfo->scratchdir);
-    old_pwd = mr_getcwd();
-    mr_asprintf(tmp, "chmod 700 %s", bkpinfo->scratchdir);
-    run_program_and_log_output(tmp, FALSE);
-    mr_free(tmp);
-    if (chdir(bkpinfo->scratchdir)) {
-        // FIXME
-    }
-
-    mds = media_descriptor_string(bkpinfo->backup_media_type);
-    mr_asprintf(message_to_screen, "Copying data to make %s #%d",mds, g_current_media_number);
-    mr_free(mds);
-    log_msg(1, message_to_screen);
-
-    if (bkpinfo->media_device) {
-        mr_asprintf(tmp1, "%s1", bkpinfo->media_device);
-    } else {
-        mr_asprintf(tmp1, "");
-    }
-    if (is_this_device_mounted(tmp1)) {
-        log_msg(1, "USB device mounted. Remounting it at the right place");
-        mr_asprintf(tmp, "umount %s", tmp1);
-        run_program_and_log_output(tmp, FALSE);
-        mr_free(tmp);
-    }
-    mr_free(tmp1);
-
-    log_msg(1, "Mounting USB device.");
-    mr_asprintf(tmp1, "%s/usb", bkpinfo->tmpdir);
-    mr_asprintf(tmp, "mkdir -p %s", tmp1);
-    run_program_and_log_output(tmp, FALSE);
-    mr_free(tmp);
-
-
-    /* Mindi always create one single parition on the USB dev */
-    mr_asprintf(tmp, "mount %s1 %s", bkpinfo->media_device, tmp1);
-    run_program_and_log_output(tmp, FALSE);
-    mr_free(tmp);
-
-    if (bkpinfo->nonbootable_backup) {
-        log_msg(1, "Making nonbootable USB backup not implemented yet");
-    } else {
-        log_msg(1, "Making bootable backup");
-
-        /* Command to execute */
-        mr_asprintf(tmp,"cd %s ; rm -fr %s/syslinux ; mv * %s", bkpinfo->scratchdir, tmp1, tmp1); 
-        res = eval_call_to_make_USB(tmp, message_to_screen);
-        if (res) {
-            mr_asprintf(result_sz, "%s ...failed",tmp);
-        } else {
-            mr_asprintf(result_sz, "%s ...OK",tmp);
-        }
-        log_to_screen(result_sz);
-        mr_free(result_sz);
-        mr_free(tmp);
-        retval += res;
-
-        /* Recreate the required structure under the scratch dir */
-        mr_asprintf(tmp,"mkdir %s/archive", bkpinfo->scratchdir); 
-        run_program_and_log_output(tmp, FALSE);
-        mr_free(tmp);
-    }
-    paranoid_free(message_to_screen);
-
-    /*  Copy the current logfile - of course incomplete to the media */
-    mr_system("gzip -c9 %s > %s/archives/%s", MONDO_LOGFILE, tmp1, MONDO_LOGFILENAME);
-    paranoid_free(tmp1);
-
-    if (is_this_device_mounted(bkpinfo->media_device)) {
-        mr_asprintf(tmp, "umount %s1", bkpinfo->media_device);
-        run_program_and_log_output(tmp, FALSE);
-        mr_free(tmp);
-    }
-
-    if (chdir(old_pwd)) {
-        // FIXME
-    }
-    mr_free(old_pwd);
-    if (retval) {
-        log_msg(1, "WARNING - make_usb_fs returned an error");
-    }
-    return(retval);
-}
-
-/**
- * Make sure the user has a valid CD-R(W) in the CD drive.
- * @param cd_dev Set to the CD-R(W) device checked.
- * @param keep_looping If TRUE, keep pestering user until they insist
- * or insert a correct CD; if FALSE, only check once.
- * @return 0 (there was an OK CD in the drive) or 1 (there wasn't).
- */
-int interrogate_disk_currently_in_cddrive(char *cd_dev,
-                                             bool keep_looping)
-{
-    int res = 0;
-    char *bkp = NULL;
-    char *cdrecord = NULL;
-
-    mr_asprintf(bkp, "%s", cd_dev);
-    if ((cd_dev = find_optical_device()) != NULL) {
-        if (!system("which cdrecord > /dev/null 2> /dev/null")) {
-            mr_asprintf(cdrecord, "cdrecord dev=%s -atip", cd_dev);
-        } else if (!system("which dvdrecord > /dev/null 2> /dev/null")) {
-            mr_asprintf(cdrecord, "cdrecord dev=%s -atip", cd_dev);
-        } else {
-            log_msg(2, "Oh well. I guess I'll just pray then.");
-        }
-        if (cdrecord != NULL) {
-            if (!keep_looping) {
-                retract_CD_tray_and_defeat_autorun();
-                res = run_program_and_log_output(cdrecord, 5);
-            } else {
-                while ((res = run_program_and_log_output(cdrecord, 5))) {
-                    retract_CD_tray_and_defeat_autorun();
-                    if (ask_me_yes_or_no
-                        ("Unable to examine CD. Are you sure this is a valid CD-R(W) CD?"))
-                    {
-                        log_msg(1, "Well, he insisted...");
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    mr_free(bkp);
-
-    mr_free(cdrecord);
-    return (res);
-}
-
-
-/**
- * Asks the user to put a CD-R(W) in the drive.
- * @param ask_for_one_if_more_than_this (unused)
- * @param pmountable If non-NULL, pointed-to value is set to TRUE if the CD is mountable, FALSE otherwise.
- */
-void pause_and_ask_for_cdr(int ask_for_one_if_more_than_this, bool * pmountable) {
-
-    /*@ buffers ********************************************* */
-    char *tmp = NULL;
-    char *cdrom_dev = NULL;
-    char *cd_dev = NULL;
-    char *our_serial_str = NULL;
-    bool ok_go_ahead_burn_it;
-    int cd_number = -1;
-    int attempt_to_mount_returned_this = 999;
-    char *mtpt = NULL;
-    char *szcdno = NULL;
-    char *szserfname = NULL;
-    char *szunmount = NULL;
-    char *mds = NULL;
-
-    malloc_string(cd_dev);
-
-    mds = media_descriptor_string(g_backup_media_type);
-    log_to_screen("I am about to burn %s #%d", mds, g_current_media_number);
-    mr_free(mds);
-    if (g_current_media_number < ask_for_one_if_more_than_this) {
-        return;
-    }
-    log_to_screen("Scanning CD-ROM drive...");
-    mr_asprintf(mtpt, "%s/cd.mtpt", bkpinfo->tmpdir);
-    make_hole_for_dir(mtpt);
-
-  gotos_make_me_puke:
-    ok_go_ahead_burn_it = TRUE;
-    mr_free(cdrom_dev);
-    if ((cdrom_dev = find_optical_device()) != NULL) {
-        /* When enabled, it made CD eject-and-retract when wrong CD inserted.. Weird
-        log_msg(2, "paafcd: Retracting CD-ROM drive if possible" );
-        retract_CD_tray_and_defeat_autorun();
-        */
-        mr_asprintf(tmp, "umount %s", cdrom_dev);
-        run_program_and_log_output(tmp, 1);
-        mr_asprintf(szcdno, "%s/archives/THIS-CD-NUMBER", mtpt);
-        mr_asprintf(szserfname, "%s/archives/SERIAL-STRING", mtpt);
-        mr_asprintf(szunmount, "umount %s", mtpt);
-        cd_number = -1;
-        mr_asprintf(tmp, "mount %s %s", cdrom_dev, mtpt);
-        mr_asprintf(our_serial_str, "%s", "");
-        attempt_to_mount_returned_this = run_program_and_log_output(tmp, 1);
-        mr_free(tmp);
-
-        if (attempt_to_mount_returned_this) {
-            log_msg(4, "Failed to mount %s at %s", cdrom_dev, mtpt);
-            log_to_screen("If there's a CD/DVD in the drive, it's blank.");
-        } else if (!does_file_exist(szcdno) || !does_file_exist(szserfname)) {
-            mds = media_descriptor_string(g_backup_media_type);
-            log_to_screen("%s has data on it but it's probably not a Mondo CD.", mds);
-            mr_free(mds);
-        } else {
-            mds = media_descriptor_string(g_backup_media_type);
-            log_to_screen("%s found in drive. It's a Mondo disk.", mds);
-            mr_free(mds);
-
-            cd_number = atoi(last_line_of_file(szcdno));
-            mr_asprintf(tmp, "cat %s 2> /dev/null", szserfname);
-            mr_free(our_serial_str);
-            our_serial_str = call_program_and_get_last_line_of_output(tmp);
-            mr_free(tmp);
-            // FIXME - should be able to use last_line_of_file(), surely?
-        }
-        mr_free(szcdno);
-        mr_free(szserfname);
-
-        run_program_and_log_output(szunmount, 1);
-        mr_free(szunmount);
-
-        log_msg(2, "paafcd: cd_number = %d", cd_number);
-        log_msg(2, "our serial str = %s; bkpinfo->serial_string = %s", our_serial_str, bkpinfo->serial_string);
-        if (cd_number > 0 && !strcmp(our_serial_str, bkpinfo->serial_string)) {
-            mds = media_descriptor_string(g_backup_media_type);
-            log_msg(2, "This %s is part of this backup set!", mds);
-            ok_go_ahead_burn_it = FALSE;
-            if (cd_number == g_current_media_number - 1) {
-                log_to_screen("I think you've left the previous %s in the drive.", mds);
-            } else {
-                log_to_screen("Please remove this %s. It is part of the backup set you're making now.", mds);
-            }
-            mr_free(mds);
-
-        } else {
-            log_to_screen("...but not part of _our_ backup set.");
-        }
-        mr_free(our_serial_str);
-    } else {
-        mds = media_descriptor_string(g_backup_media_type);
-        log_msg(2,
-                "paafcd: Can't find CD-ROM drive. Perhaps it has a blank %s in it?", mds);
-        if (interrogate_disk_currently_in_cddrive(cd_dev, FALSE)) {
-            ok_go_ahead_burn_it = FALSE;
-            log_to_screen("There isn't a writable %s in the drive.", mds);
-        }
-        mr_free(mds);
-    }
-
-    if (!ok_go_ahead_burn_it) {
-        if (!bkpinfo->please_dont_eject) {
-            eject_device(cdrom_dev);
-        }
-        mds = media_descriptor_string(g_backup_media_type);
-        mr_asprintf(tmp, "I am about to burn %s #%d of the backup set. Please insert %s and press Enter.", mds, g_current_media_number, mds);
-        mr_free(mds);
-
-        popup_and_OK(tmp);
-        mr_free(tmp);
-        goto gotos_make_me_puke;
-    } else {
-        log_msg(2, "paafcd: OK, going ahead and burning it.");
-    }
-
-    mds = media_descriptor_string(g_backup_media_type);
-    log_msg(2, "paafcd: OK, I assume I have a blank/reusable %s in the drive...", mds);
-
-    log_to_screen("Proceeding w/ %s in drive.", mds);
-    mr_free(mds);
-
-    mr_free(cdrom_dev);
-    paranoid_free(cd_dev);
-    mr_free(mtpt);
-    if (pmountable) {
-        if (attempt_to_mount_returned_this) {
-            *pmountable = FALSE;
-        } else {
-            *pmountable = TRUE;
-        }
-    }
-
-}
-
-
-/**
- * Create an ISO image in @c destfile, from files in @c bkpinfo->scratchdir.
- *
- * @param bkpinfo The backup information structure. Fields used:
- * - @c backup_media_type
- * - @c call_after_iso
- * - @c call_before_iso
- * - @c call_burn_iso
- * - @c call_make_iso
- * - @c make_cd_use_lilo
- * - @c manual_cd_tray
- * - @c nonbootable_backup
- * - @c scratchdir
- *
- * @param destfile Where to put the generated ISO image.
- * @return The number of errors encountered (0 for success)
- */
-int make_iso_fs(char *destfile) {
-    /*@ int ********************************************** */
-    int retval = 0;
-    int res;
-
-    /*@ buffers ****************************************** */
-    char *tmp = NULL;
-    char *old_pwd = NULL;
-    char *result_sz = NULL;
-    char *message_to_screen = NULL;
-    char *sz_blank_disk = NULL;
-    char *isofs_cmd = NULL;
-    char *full_isofs_cmd = NULL;
-    char *mds = NULL;
-    char *uefistr = NULL;
-    bool cd_is_mountable;
-
-    assert(bkpinfo != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(destfile);
-
-    if (bkpinfo->backup_media_type == iso && bkpinfo->manual_cd_tray) {
-        popup_and_OK("Please insert new media and press Enter.");
-    }
-
-    log_msg(2, "make_iso_fs --- scratchdir=%s --- destfile=%s", bkpinfo->scratchdir, destfile);
-    old_pwd = mr_getcwd();
-    mr_asprintf(tmp, "chmod 700 %s", bkpinfo->scratchdir);
-    run_program_and_log_output(tmp, FALSE);
-    mr_free(tmp);
-
-    if (chdir(bkpinfo->scratchdir)) {
-        // FIXME
-    }
-
-    if (bkpinfo->call_before_iso != NULL) {
-        mr_asprintf(message_to_screen, "Running pre-ISO call for CD#%d", g_current_media_number);
-        res = eval_call_to_make_ISO(bkpinfo->call_before_iso, destfile, g_current_media_number, message_to_screen);
-        if (res) {
-            mr_strcat(message_to_screen, "...failed");
-        } else {
-            mr_strcat(message_to_screen, "...OK");
-        }
-        log_to_screen(message_to_screen);
-        paranoid_free(message_to_screen);
-
-        retval += res;
-    }
-
-    if (bkpinfo->call_make_iso != NULL) {
-        log_msg(2, "bkpinfo->call_make_iso = %s", bkpinfo->call_make_iso);
-        mds = media_descriptor_string(bkpinfo->backup_media_type);
-        mr_asprintf(message_to_screen, "Making an ISO (%s #%d)", mds, g_current_media_number);
-        mr_free(mds);
-
-        pause_and_ask_for_cdr(2, &cd_is_mountable); /* if g_current_media_number >= 2 then pause & ask */
-        if (retval) {
-            log_to_screen
-                ("Serious error(s) occurred already. I shan't try to write to media.");
-        } else {
-            res =
-                eval_call_to_make_ISO(bkpinfo->call_make_iso, bkpinfo->scratchdir, g_current_media_number, message_to_screen);
-            if (res) {
-                log_to_screen("%s...failed to write", message_to_screen);
-            } else {
-                log_to_screen("%s...OK", message_to_screen);
-                mr_asprintf(tmp, "tail -n10 %s | grep -F ':-('", MONDO_LOGFILE);
-                if (!run_program_and_log_output(tmp, 1)) {
-                    log_to_screen
-                        ("Despite nonfatal errors, growisofs confirms the write was successful.");
-                }
-                mr_free(tmp);
-            }
-            retval += res;
-#ifdef DVDRWFORMAT
-            mr_asprintf(tmp, "tail -n8 %s | grep 'blank=full.*dvd-compat.*DAO'", MONDO_LOGFILE);
-            if (g_backup_media_type == dvd
-                && (res || !run_program_and_log_output(tmp, 1))) {
-                log_to_screen
-                    ("Failed to write to disk. I shall blank it and then try again.");
-                sleep(5);
-                /* reset error counter before trying to blank DVD */
-                retval -= res;
-                sync();
-                pause_for_N_seconds(5, "Letting DVD drive settle");
-
-// dvd+rw-format --- OPTION 2
-                if (!bkpinfo->please_dont_eject) {
-                    log_to_screen("Ejecting media to clear drive status.");
-                    eject_device(bkpinfo->media_device);
-                    inject_device(bkpinfo->media_device);
-                }
-                pause_for_N_seconds(5, "Letting DVD drive settle");
-                if (bkpinfo->media_device) {
-                    mr_asprintf(sz_blank_disk, "dvd+rw-format -force %s", bkpinfo->media_device);
-                } else {
-                    mr_asprintf(sz_blank_disk, "dvd+rw-format");
-                }
-                log_msg(3, "sz_blank_disk = '%s'", sz_blank_disk);
-                res = run_external_binary_with_percentage_indicator_NEW("Blanking DVD disk", sz_blank_disk);
-                if (res) {
-                    log_to_screen("Warning - format failed. (Was it a DVD-R?) Sleeping for 5 seconds to take a breath...");
-                    pause_for_N_seconds(5, "Letting DVD drive settle... and trying again.");
-                    res = run_external_binary_with_percentage_indicator_NEW("Blanking DVD disk", sz_blank_disk);
-                    if (res) {
-                        log_to_screen("Format failed a second time.");
-                    }
-                } else {
-                    log_to_screen
-                        ("Format succeeded. Sleeping for 5 seconds to take a breath...");
-                }
-                mr_free(sz_blank_disk);
-                pause_for_N_seconds(5, "Letting DVD drive settle");
-                if (!bkpinfo->please_dont_eject) {
-                    log_to_screen("Ejecting media to clear drive status.");
-                    eject_device(bkpinfo->media_device);
-                    inject_device(bkpinfo->media_device);
-                }
-                pause_for_N_seconds(5, "Letting DVD drive settle");
-                res = eval_call_to_make_ISO(bkpinfo->call_make_iso, bkpinfo->scratchdir, g_current_media_number, message_to_screen);
-                retval += res;
-                if (!bkpinfo->please_dont_eject) {
-                    log_to_screen("Ejecting media.");
-                    eject_device(bkpinfo->media_device);
-                }
-                if (res) {
-                    log_to_screen("Dagnabbit. It still failed.");
-                } else {
-                    log_to_screen
-                        ("OK, this time I successfully backed up to DVD.");
-                }
-            }
-            mr_free(tmp);
-#endif
-            if (g_backup_media_type == dvd && !bkpinfo->please_dont_eject) {
-                eject_device(bkpinfo->media_device);
-            }
-        }
-        paranoid_free(message_to_screen);
-    } else {
-        mds = media_descriptor_string(bkpinfo->backup_media_type);
-        mr_asprintf(message_to_screen, "Running mkisofs to make %s #%d", mds, g_current_media_number);
-        log_msg(1, message_to_screen);
-        mr_asprintf(result_sz, "Call to mkisofs to make ISO (%s #%d) ", mds,  g_current_media_number);
-        mr_free(mds);
-        if ((tmp = find_home_of_exe("xorriso")) != NULL) {
-            mr_asprintf(isofs_cmd, "%s %s", tmp, MONDO_XORRISO_OPT);
-        } else if ((tmp = find_home_of_exe("genisoimage")) != NULL) {
-            mr_asprintf(isofs_cmd, "%s %s", tmp, MONDO_GENISOIMAGE_OPT);
-        } else if ((tmp = find_home_of_exe("mkisofs")) != NULL) {
-            mr_asprintf(isofs_cmd, "%s %s", tmp, MONDO_MKISOFS_OPT);
-        } else if ((tmp = find_home_of_exe("wodim")) != NULL) {
-            mr_asprintf(isofs_cmd, "%s %s", tmp, MONDO_WODIM_OPT);
-        } else {
-            fatal_error("Unable to find a command to create ISO among xorriso, genisoimage, mksiofs or wodim, please install one");
-        }
-        mr_free(tmp);
-        if (bkpinfo->nonbootable_backup) {
-            log_msg(1, "Making nonbootable backup");
-            mr_asprintf(full_isofs_cmd, "%s%s-o '_ISO_' .",isofs_cmd,MONDO_MKISOFS);
-            res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
-            mr_free(full_isofs_cmd);
-        } else {
-            log_msg(1, "Making bootable backup");
-
-#ifdef __FreeBSD__
-            bkpinfo->make_cd_use_lilo = TRUE;
-#endif
-
-
-            log_msg(1, "make_cd_use_lilo is actually %d", bkpinfo->make_cd_use_lilo);
-            if (bkpinfo->make_cd_use_lilo) {
-                log_msg(1, "make_cd_use_lilo = TRUE");
-#ifdef __IA64__
-                log_msg(1, "IA64 --> elilo");
-                mr_asprintf(full_isofs_cmd, "%s%s-o '_ISO_' .",isofs_cmd,MONDO_MKISOFS_REGULAR_ELILO);
-                res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
-                mr_free(full_isofs_cmd);
-#else
-                log_msg(1, "Non-ia64 --> lilo");
-                mr_asprintf(full_isofs_cmd, "%s%s-b images/mindi-bootroot.img -c images/boot.cat -o '_ISO_' .",isofs_cmd,MONDO_MKISOFS);
-                // FIXME: fixed boot size probably wrong. lilo to be removed
-                res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
-                mr_free(full_isofs_cmd);
-#endif
-            } else {
-                log_msg(1, "make_cd_use_lilo = FALSE");
-                log_msg(1, "Isolinux");
-                if (bkpinfo->boot_type == UEFI) {
-                    if (strstr(isofs_cmd,"xorriso")) {
-                        /*  xorriso needs another '-' before efi-boot */
-                        mr_asprintf(uefistr, "%s -%s", MONDO_UEFI_PREFIX, MONDO_MKISOFS_UEFI);
-                    } else {
-                        mr_asprintf(uefistr, "%s %s", MONDO_UEFI_PREFIX, MONDO_MKISOFS_UEFI);
-                    }
-                } else {
-                    mr_asprintf(uefistr, "%s",MONDO_MKISOFS_CMS);
-                }
-                mr_asprintf(full_isofs_cmd, "%s%s%s-o '_ISO_' .",isofs_cmd,MONDO_MKISOFS_REGULAR_SYSLINUX,uefistr);
-                mr_free(uefistr);
-
-                res = eval_call_to_make_ISO(full_isofs_cmd, destfile, g_current_media_number, message_to_screen);
-                mr_free(full_isofs_cmd);
-            }
-        }
-        mr_free(isofs_cmd);
-        paranoid_free(message_to_screen);
-
-        if (res) {
-            mr_strcat(result_sz, "...failed");
-        } else {
-            mr_strcat(result_sz, "...OK");
-        }
-        log_to_screen(result_sz);
-        paranoid_free(result_sz);
-        retval += res;
-    }
-
-    if (bkpinfo->backup_media_type == cdr) {
-        if (is_this_device_mounted(bkpinfo->media_device)) {
-            log_msg(2, "Warning - %s mounted. I'm unmounting it before I burn to it.", bkpinfo->media_device);
-            mr_asprintf(tmp, "umount %s", bkpinfo->media_device);
-            run_program_and_log_output(tmp, FALSE);
-            mr_free(tmp);
-        }
-    }
-
-    if (bkpinfo->call_burn_iso != NULL) {
-        log_msg(2, "bkpinfo->call_burn_iso = %s", bkpinfo->call_burn_iso);
-        mds = media_descriptor_string(bkpinfo->backup_media_type);
-        mr_asprintf(message_to_screen, "Burning %s #%d", mds, g_current_media_number);
-        mr_free(mds);
-        pause_and_ask_for_cdr(2, &cd_is_mountable);
-        res = eval_call_to_make_ISO(bkpinfo->call_burn_iso, destfile, g_current_media_number, message_to_screen);
-        if (res) {
-            mr_strcat(message_to_screen, "...failed");
-        } else {
-            mr_strcat(message_to_screen, "...OK");
-        }
-        log_to_screen(message_to_screen);
-        paranoid_free(message_to_screen);
-
-        retval += res;
-    }
-
-    if (bkpinfo->call_after_iso != NULL) {
-        mds = media_descriptor_string(bkpinfo->backup_media_type);
-        mr_asprintf(message_to_screen, "Running post-ISO call (%s #%d)", mds, g_current_media_number);
-        mr_free(mds);
-        res = eval_call_to_make_ISO(bkpinfo->call_after_iso, destfile, g_current_media_number, message_to_screen);
-        if (res) {
-            mr_strcat(message_to_screen, "...failed");
-        } else {
-            mr_strcat(message_to_screen, "...OK");
-        }
-        log_to_screen(message_to_screen);
-        paranoid_free(message_to_screen);
-
-        retval += res;
-    }
-
-    if (chdir(old_pwd)) {
-        // FIXME
-    }
-    mr_free(old_pwd);
-    if (retval) {
-        log_msg(1, "WARNING - make_iso_fs returned an error");
-    }
-    return (retval);
-}
-
-
-bool is_dev_an_NTFS_dev(char *bigfile_fname)
-{
-    char *tmp = NULL;
-    char *command = NULL;
-    bool ret = TRUE;
-
-    mr_asprintf(command, "dd if=%s bs=512 count=1 2> /dev/null | strings | head -n1", bigfile_fname);
-    log_msg(1, "command = '%s'", command);
-    tmp = call_program_and_get_last_line_of_output(command);
-    mr_free(command);
-
-    log_msg(1, "--> tmp = '%s'", tmp);
-    if (strstr(tmp, "NTFS")) {
-        log_it("TRUE");
-        ret = TRUE;
-    } else {
-        log_it("FALSE");
-        ret = FALSE;
-    }
-    mr_free(tmp);
-    return(ret);
-}
-
-
-/**
- * Chop up @c filename.
- * @param bkpinfo The backup information structure. Fields used:
- * - @c backup_media_type
- * - @c compression_level
- * - @c optimal_set_size
- * - @c tmpdir
- * - @c use_lzo
- * - @c zip_exe
- * - @c zip_suffix
- *
- * @param biggie_filename The file to chop up.
- * @param ntfsprog_fifo The FIFO to ntfsclone if this is an imagedev, NULL otherwise.
- * @param biggie_file_number The sequence number of this biggie file (starting from 0).
- * @param noof_biggie_files The number of biggie files there are total.
- * @return The number of errors encountered (0 for success)
- * @see make_slices_and_images
- * @ingroup LLarchiveGroup
- */
-int slice_up_file_etc(char *biggie_filename, char *ntfsprog_fifo, long biggie_file_number, long noof_biggie_files, bool use_ntfsprog) {
-
-    /*@ buffers ************************************************** */
-    char *tmp = NULL;
-    char *checksum_line = NULL;
-    char *command = NULL;
-    char *tempblock = NULL;
-    char *curr_slice_fname_uncompressed = NULL;
-    char *curr_slice_fname_compressed = NULL;
-    char *file_to_archive = NULL;
-    char *file_to_openin = NULL;
-    /*@ pointers ************************************************** */
-    char *pB = NULL;
-    FILE *fin = NULL;
-    FILE *fout = NULL;
-
-    /*@ bool ****************************************************** */
-    bool finished = FALSE;
-
-    /*@ long ****************************************************** */
-    size_t blksize = (size_t)0;
-    long slice_num = 0L;
-    long i = 0L;
-    bool should_I_compress_slices = TRUE;
-    char *suffix = NULL;                // for compressed slices
-
-    /*@ long long ************************************************** */
-    off_t totalread = (off_t)0;
-    off_t totallength = (off_t)0;
-
-    /*@ int ******************************************************** */
-    int retval = 0;
-    int res = 0;
-
-    /*@ structures ************************************************** */
-    struct s_filename_and_lstat_info biggiestruct;
-
-    assert(bkpinfo != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(biggie_filename);
-
-    biggiestruct.for_backward_compatibility = '\n';
-    biggiestruct.use_ntfsprog = use_ntfsprog;
-    if (is_this_file_compressed(biggie_filename) || bkpinfo->compression_level == 0) {
-        mr_asprintf(suffix, "%s", "");
-        should_I_compress_slices = FALSE;
-    } else {
-        mr_asprintf(suffix, "%s", bkpinfo->zip_suffix);
-        should_I_compress_slices = TRUE;
-    }
-
-    if (bkpinfo->optimal_set_size < 999L) {
-        fatal_error("bkpinfo->optimal_set_size is insanely small");
-    }
-
-    if (ntfsprog_fifo) {
-        file_to_openin = ntfsprog_fifo;
-        mr_asprintf(checksum_line, "IGNORE");
-        log_msg(2, "Not calculating checksum for %s: it would take too long", biggie_filename);
-        if ((tmp = find_home_of_exe("ntfsresize")) == NULL) {
-            fatal_error("ntfsresize not found");
-        }
-        mr_asprintf(command, "%s --force --info %s|grep '^You might resize at '|cut -d' ' -f5", tmp, biggie_filename);
-        mr_free(tmp);
-        log_it("command = %s", command);
-        tmp = call_program_and_get_last_line_of_output(command);
-        mr_free(command);
-        log_it("res of it = %s", tmp); 
-        totallength = (off_t)atoll(tmp);
-        mr_free(tmp);
-    } else {
-        file_to_openin = biggie_filename;
-        if (strchr(biggie_filename,'\'') != NULL) {
-            mr_asprintf(command, "md5sum \"%s\"", biggie_filename);
-        } else {
-            mr_asprintf(command, "md5sum '%s'", biggie_filename);
-        }
-        if (!(fin = popen(command, "r"))) {
-            log_OS_error("Unable to popen-in command");
-            mr_free(suffix);
-            return (1);
-        }
-        mr_free(command);
-        mr_getline(checksum_line, fin);
-        pclose(fin);
-        totallength = length_of_file(biggie_filename);
-    }
-    lstat(biggie_filename, &biggiestruct.properties);
-    strcpy(biggiestruct.filename, biggie_filename);
-    pB = strchr(checksum_line, ' ');
-    if (!pB) {
-        pB = strchr(checksum_line, '\t');
-    }
-    if (pB) {
-        *pB = '\0';
-    }
-    strcpy(biggiestruct.checksum, checksum_line);
-    mr_free(checksum_line);
-
-    mr_asprintf(tmp, "%s", slice_fname(biggie_file_number, 0, bkpinfo->tmpdir, ""));
-    fout = fopen(tmp, "w");
-    if (fout == NULL) {
-        log_msg(1, "Unable to open and write to %s", tmp);
-        mr_free(tmp);
-        mr_free(suffix);
-        return (1);
-    }
-    res = fwrite((void *) &biggiestruct, 1, sizeof(biggiestruct), fout);
-    paranoid_fclose(fout);
-    mr_free(tmp);
-
-    log_msg(1, "Opening in %s; slicing it and writing to CD/tape", file_to_openin);
-    if (!(fin = fopen(file_to_openin, "r"))) {
-        log_OS_error("Unable to openin biggie_filename");
-        log_to_screen("Cannot archive bigfile '%s': not found", biggie_filename);
-
-        mr_free(suffix);
-        return (1);
-    }
-    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
-        res = move_files_to_stream(slice_fname(biggie_file_number, 0, bkpinfo->tmpdir, ""), NULL);
-    } else {
-        res = move_files_to_cd(slice_fname(biggie_file_number, 0, bkpinfo->tmpdir, ""), NULL);
-    }
-    i = bkpinfo->optimal_set_size / 256L;
-    if (!(tempblock = (char *) malloc(256 * 1024))) {
-        fatal_error("malloc error 256*1024");
-    }
-    for (slice_num = 1; !finished; slice_num++) {
-        mr_asprintf(curr_slice_fname_uncompressed, "%s", slice_fname(biggie_file_number, slice_num, bkpinfo->tmpdir, ""));
-        mr_asprintf(curr_slice_fname_compressed, "%s", slice_fname(biggie_file_number, slice_num, bkpinfo->tmpdir, suffix));
-
-        tmp = percent_media_full_comment();
-        update_progress_form(tmp);
-        mr_free(tmp);
-
-        if (!(fout = fopen(curr_slice_fname_uncompressed, "w"))) {
-            log_OS_error(curr_slice_fname_uncompressed);
-            mr_free(suffix);
-            return (1);
-        }
-        if ((i == bkpinfo->optimal_set_size / 256L) && (totalread < (off_t)1.1 * totallength)) {
-            for (i = 0L; i < (bkpinfo->optimal_set_size / 256L); i++) {
-                blksize = fread(tempblock, 1, 256 * 1024, fin);
-                if (blksize > (size_t)0) {
-                    totalread = totalread + (off_t)blksize;
-                    res = fwrite(tempblock, 1, blksize, fout);
-                } else {
-                    break;
-                }
-            }
-        } else {
-            i = 0L;
-        }
-        paranoid_fclose(fout);
-        if (i > 0L)             // length_of_file (curr_slice_fname_uncompressed)
-        {
-            if (!does_file_exist(curr_slice_fname_uncompressed)) {
-                log_msg(2, "Warning - '%s' doesn't exist. How can I compress slice?", curr_slice_fname_uncompressed);
-            }
-            if (should_I_compress_slices && bkpinfo->compression_level > 0) {
-                mr_asprintf(command, "%s -%d %s", bkpinfo->zip_exe, bkpinfo->compression_level, curr_slice_fname_uncompressed);
-                log_msg(2, command);
-                if ((res = system(command))) {
-                    log_OS_error(command);
-                }
-                //          did_I_compress_slice = TRUE;
-            } else {
-                mr_asprintf(command, "mv %s %s 2>> %s", curr_slice_fname_uncompressed, curr_slice_fname_compressed, MONDO_LOGFILE);
-                res = 0;        // don't do it :)
-                //          did_I_compress_slice = FALSE;
-            }
-            mr_free(command);
-
-            retval += res;
-            if (res) {
-                log_msg(2, "Failed to compress the slice");
-            }
-            if (bkpinfo->use_lzo && strcmp(curr_slice_fname_compressed, curr_slice_fname_uncompressed)) {
-                unlink(curr_slice_fname_uncompressed);
-            }
-            if (res) {
-                mr_asprintf(tmp, "Problem with slice # %ld", slice_num);
-            } else {
-                mr_asprintf(tmp, "%s - Bigfile #%ld, slice #%ld compressed OK          ", biggie_filename, biggie_file_number + 1, slice_num);
-            }
-            if (!g_text_mode) {
-                newtDrawRootText(0, g_noof_rows - 2, tmp);
-                newtRefresh();
-            } else {
-                log_msg(2, tmp);
-            }
-            mr_free(tmp);
-
-            mr_asprintf(file_to_archive, "%s", curr_slice_fname_compressed);
-            g_current_progress++;
-        } else {                /* if i==0 then ... */
-            finished = TRUE;
-            mr_asprintf(file_to_archive, "%s", curr_slice_fname_uncompressed);
-            if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
-                break;
-            }
-        }
-        mr_free(curr_slice_fname_uncompressed);
-        mr_free(curr_slice_fname_compressed);
-
-        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
-            register_in_tape_catalog(biggieslice, biggie_file_number, slice_num, file_to_archive);
-            maintain_collection_of_recent_archives(bkpinfo->tmpdir, file_to_archive);
-            res = move_files_to_stream(file_to_archive, NULL);
-        } else {
-            res = move_files_to_cd(file_to_archive, NULL);
-        }
-        mr_free(file_to_archive);
-
-        retval += res;
-        if (res) {
-            log_to_screen("Failed to add slice %ld of bigfile %ld to scratchdir", slice_num, biggie_file_number + 1);
-            fatal_error("Hard disk full. You should have bought a bigger one.");
-        }
-    }
-    mr_free(tempblock);
-    mr_free(suffix);
-    paranoid_fclose(fin);
-    mr_asprintf(tmp, "Sliced bigfile #%ld", biggie_file_number + 1);
-    if (retval) {
-        mr_strcat(tmp, "...FAILED");
-    } else {
-        mr_strcat(tmp, "...OK!");
-    }
-    log_msg(1, tmp);
-    mr_free(tmp);
-
-    return (retval);
-}
-
-
 /* @} - end of LLarchiveGroup */
 

branches/3.3/mondo/src/common/libmondo-cli.c

@@ -15 +15 @@
 #include "mr_str.h"
 #include "mondostructures.h"
-#include "libmondo-cli-EXT.h"
+#include "libmondo-string-EXT.h"
+#include "libmondo-files-EXT.h"
+#include "libmondo-stream-EXT.h"
+#include "libmondo-devices-EXT.h"
+#include "libmondo-fork-EXT.h"
+#include "libmondo-fifo-EXT.h"
 #include "newt-specific-EXT.h"
-#include "libmondo.h"
 
 extern int g_loglevel;
@@ -61 +65 @@
 
 long g_max_biggie_size = BIGGIEMAXSIZE;
-
-/**
- * @addtogroup cliGroup
- * @{
- */
-/**
- * Populate @p bkpinfo from the command-line parameters stored in @p argc and @p argv.
- * @param argc The argument count, including the program name; @p argc passed to main().
- * @param argv The argument vector; @p argv passed to main().
- * @param bkpinfo The backup information structure to populate.
- * @return The number of problems with the command line (0 for success).
- */
-int
-handle_incoming_parameters(int argc, char *argv[])
-{
-    /*@ int *** */
-    int res = 0;
-    int retval = 0;
-    int i = 0;
-
-    /*@ buffers *************** */
-    char flag_val[128][MAX_STR_LEN];
-    bool flag_set[128];
-
-    for (i = 0; i < 128; i++) {
-        flag_val[i][0] = '\0';
-        flag_set[i] = FALSE;
-    }
-    bkpinfo->media_size = 650; /* default */
-    res = retrieve_switches_from_command_line(argc, argv, flag_val, flag_set);
-    retval += res;
-    if (!retval) {
-        res = process_switches(flag_val, flag_set);
-        retval += res;
-    }
-
-    log_msg(3, "Switches:-");
-    for (i = 0; i < 128; i++) {
-        if (flag_set[i]) {
-            log_msg(3, "-%c %s", i, flag_val[i]);
-        }
-    }
-    bkpinfo->boot_type = mr_boot_type();
-
-    return (retval);
-}
 
 
@@ -131 +89 @@
 }
 
+
 /**
- * Process mondoarchive's command-line switches.
- * @param bkpinfo The backup information structure to populate.
- * @param flag_val An array of the argument passed to each switch (the letter is the index).
- * If a switch is not set or has no argument, the field in @p flag_val doesn't matter.
- * @param flag_set An array of <tt>bool</tt>s indexed by switch letter: TRUE if it's set,
- * FALSE if it's not.
- * @return The number of problems with the switches, or 0 for success.
- * @bug Maybe include a list of all switches (inc. intentionally undocumented ones not in the manual!) here?
+ * Print a not-so-helpful help message and exit.
  */
-int
-process_switches(char flag_val[128][MAX_STR_LEN], bool flag_set[128])
+void help_screen()
 {
-
-    /*@ ints *** */
-    int i = 0;
-    int retval = 0;
-
-    /*@ buffers ** */
-    char *tmp = NULL;
-    char *tmp1 = NULL;
-    char *tmp2 = NULL;
-    char *psz = NULL;
-    char *p = NULL;
-    char *q = NULL;
-    char *q2 = NULL;
-
-    long itbs = 0L;
-
-    struct stat buf;
-
-    malloc_string(tmp);
-
-    assert(bkpinfo != NULL);
-    assert(flag_val != NULL);
-    assert(flag_set != NULL);
-
-    bkpinfo->internal_tape_block_size = DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
-
-    /* compulsory */
-    i = flag_set['c'] + flag_set['i'] + flag_set['n'] +
-        flag_set['t'] + flag_set['u'] + flag_set['r'] +
-        flag_set['w'] + flag_set['C'] + flag_set['U'];
-    if ((i == 0) && (! bkpinfo->restore_data)) {
-        retval++;
-        log_to_screen("You must specify the media type\n");
-    }
-    if (i > 1) {
-        retval++;
-        log_to_screen("Please specify only one media type\n");
-    }
-
-    if (flag_set['K']) {
-        g_loglevel = atoi(flag_val['K']);
-            log_msg(1,"Loglevel forced to %d",g_loglevel);
-        if (g_loglevel < 3) {
-            g_loglevel = 3;
-        }
-    }
-
-    if ((flag_set['L'] && flag_set['0']) && (! bkpinfo->restore_data)) {
-        retval++;
-        log_to_screen("You cannot have 'no compression' _and_ LZOP.\n");
-    }
-    if (! bkpinfo->restore_data) {
-        bkpinfo->backup_data = flag_set['O'];
-    }
-    bkpinfo->verify_data = flag_set['V'];
-
-    if (flag_set['I'] && !bkpinfo->backup_data) {
-        log_to_screen("-I switch is ignored if just verifying");
-    }
-    if (flag_set['E'] && !bkpinfo->backup_data) {
-        log_to_screen("-E switch is ignored if just verifying");
-    }
-
-    if ((tmp = find_home_of_exe("afio")) == NULL) {
-        mr_free(tmp);
-        if ((tmp = find_home_of_exe("star")) != NULL) {
-            mr_free(tmp);
-            flag_set['R'] = TRUE;
-            log_msg(1, "Using star instead of afio");
-        } else {
-            mr_free(tmp);
-            fatal_error("Neither afio nor star is installed. Please install at least one.");
-        }
-    }
-
-    if (flag_set['R']) {
-        bkpinfo->use_star = TRUE;
-        if (flag_set['L']) {
-            fatal_error("You may not use star and lzop at the same time.");
-        }
-        if ((tmp = find_home_of_exe("star")) == NULL) {
-            mr_free(tmp);
-            fatal_error("Please install 'star' if you are going to use -R. Thanks.");
-        }
-        mr_free(tmp);
-    }
-
-    if ((flag_set['W']) && (! bkpinfo->restore_data)) {
-        bkpinfo->nonbootable_backup = TRUE;
-        log_to_screen("Warning - you have opted for non-bootable backup");
-        if (flag_set['f'] || flag_set['l']) {
-            log_to_screen
-                ("You don't need to specify bootloader or bootdevice");
-        }
-    }
-
-    if (flag_set['I']) {
-        if (flag_val['I'][0] == '-') {
-            retval++;
-            log_to_screen("Please supply a sensible value with '-I'\n");
-        }
-        if (!strcmp(flag_val['I'],"/")) {
-            log_msg(2, "'/' is pleonastic.");
-        }
-        if (bkpinfo->include_paths && bkpinfo->include_paths[0]) {
-            mr_strcat(bkpinfo->include_paths, "|");
-        }
-
-        mr_asprintf(tmp1, "%s", flag_val['I']);
-        p = tmp1;
-        q = tmp1;
-
-        /* Cut the flag_val['I'] in parts containing all paths to test them */
-        while (p != NULL) {
-            q = strchr(p, '|');
-            if (q != NULL) {
-                *q = '\0';
-                if ((stat(p, &buf) != 0) && (! bkpinfo->restore_data)) {
-                    log_msg(1, "ERROR ! %s doesn't exist", p);
-                    fatal_error("ERROR ! You specified a directory to include which doesn't exist");
-                }
-                p = q+1 ;
-            } else {
-                if ((stat(p, &buf) != 0) && (! bkpinfo->restore_data)) {
-                    log_msg(1, "ERROR ! %s doesn't exist", p);
-                    fatal_error("ERROR ! You specified a directory to include which doesn't exist");
-                }
-                p = NULL;
-            }
-        }
-        mr_free(tmp1);
-        mr_make_devlist_from_pathlist(flag_val['I'], 'I');
-        log_msg(4, "Finished with the -I option");
-    }
-
-    if (g_kernel_version >= 2.6 && !flag_set['d'] && (flag_set['c'] || flag_set['w']) && (! bkpinfo->restore_data)) {
-        fatal_error("If you are using the 2.6.x kernel, please specify the CD-R(W) device.");
-    }
-
-
-    if (flag_set['J']) {
-        if (flag_set['I']) {
-            retval++;
-            log_to_screen("Please do not use -J in combination with -I. If you want to make a list of files to backup, that's fine, use -J <filename> but please don't muddy the waters by combining -J with -I. Thanks. :-)");
-        }
-        bkpinfo->make_filelist = FALSE;
-        mr_asprintf(bkpinfo->include_paths, "%s", flag_val['J']);
-    }
-
-    if ((flag_set['c'] || flag_set['w'] || flag_set['C'] || flag_set['r']) && (! bkpinfo->restore_data)) {
-        if (system("which cdrecord > /dev/null 2> /dev/null") && system("which dvdrecord > /dev/null 2> /dev/null")) {
-            fatal_error("Please install dvdrecord/cdrecord and try again.");
-        }
-        if (flag_set['C']) {
-            bkpinfo->cdrw_speed = atoi(flag_val['C']);
-            if (bkpinfo->cdrw_speed < 1) {
-                fatal_error("You specified a silly speed for a CD-R[W] drive");
-            }
-            if (!flag_set['L']) {
-                log_to_screen("You must use -L with -C. Therefore I am setting it for you.");
-                flag_set['L'] = 1;
-                flag_val['L'][0] = '\0';
-            }
-        } else {
-            log_msg(3, "flag_val['c'] = %s", flag_val['c']);
-            log_msg(3, "flag_val['w'] = %s", flag_val['w']);
-            if (flag_set['c']) {
-                bkpinfo->cdrw_speed = atoi(flag_val['c']);
-            } else if (flag_set['w']) {
-                bkpinfo->cdrw_speed = atoi(flag_val['w']);
-            } else if (flag_set['r']) {
-                bkpinfo->cdrw_speed = 1;    /*atoi(flag_val['r']); */
-            }
-
-            if (bkpinfo->cdrw_speed < 1) {
-                fatal_error("You specified a silly speed for a CD-R[W] drive");
-            }
-        }
-    }
-
-    if ((flag_set['t'] && !flag_set['d']) && (! bkpinfo->restore_data)) {
-        log_it("Hmm! No tape drive specified. Let's see what we can do.");
-        if ((bkpinfo->media_device = find_tape_device()) == NULL) {
-            fatal_error("Tape device not specified and I couldn't find it either. Please use option -d");
-        }
-        flag_set['d'] = TRUE;
-        log_to_screen("You didn't specify a tape streamer device. I'm assuming %s", bkpinfo->media_device);
-    }
-
-    if (flag_set['U'])          // USB
-    {
-        if (! flag_set['d']) {
-            fatal_error("You need to specify a device file with -d for bootable USB device usage");
-        }
-        if ((!flag_set['s']) && (! bkpinfo->restore_data)) {
-            fatal_error("You did not specify a size (-s) for your USB device. Aborting");
-        }
-    }
-
-    if (flag_set['r'])          // DVD
-    {
-        if (flag_set['m']) {
-            fatal_error("Manual CD tray (-m) not yet supported in conjunction w/ DVD drives. Drop -m.");
-        }
-        if (!flag_set['d']) {
-            if ((bkpinfo->media_device = find_optical_device()) != NULL) {
-                flag_set['d'] = TRUE;
-                log_to_screen("I guess DVD drive is at %s", bkpinfo->media_device);
-            }
-        }
-        if (strchr(bkpinfo->media_device, ',')) {
-            fatal_error("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag.");
-        }
-        if (! bkpinfo->restore_data) {
-            if (!flag_set['s']) {
-                sprintf(flag_val['s'], "%d", DEFAULT_DVD_DISK_SIZE);    // 4.7 salesman's GB = 4.482 real GB = 4582 MB
-                strcat(flag_val['s'], "m");
-                log_to_screen("You did not specify a size (-s) for DVD. I'm guessing %s.", flag_val['s']);
-                flag_set['s'] = 1;
-            }
-        }
-    }
-
-    if (flag_set['t'] || flag_set['u']) {   /* tape size */
-        if (strchr(flag_val['d'], ',')) {
-            fatal_error("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag.");
-        }
-        if ((flag_set['O']) && (! bkpinfo->restore_data)) {
-            if (flag_set['s']) {
-                if (flag_set['t']) {
-                    fatal_error("For the moment, please don't specify a tape size. Mondo should handle end-of-tape gracefully anyway.");
-                }
-                if (process_the_s_switch(flag_val['s'])) {
-                    fatal_error("Bad -s switch");
-                }
-            } else if (flag_set['u'] || flag_set['t']) {
-                bkpinfo->media_size = 0;
-            } else {
-                retval++;
-                log_to_screen("Tape size not specified.\n");
-            }
-        }
-    } else if (! bkpinfo->restore_data) {           /* CD|USB size */
-        if (flag_set['s']) {
-            if (process_the_s_switch(flag_val['s'])) {
-                fatal_error("Bad -s switch");
-            }
-        }
-        if (flag_set['w']) {
-            bkpinfo->wipe_media_first = TRUE;
-        }                       /* CD-RW */
-    }
-
-    if (flag_set['n']) {
-        mr_asprintf(bkpinfo->netfs_mount, "%s", flag_val['n']);
-        if (!flag_set['d']) {
-            mr_asprintf(bkpinfo->netfs_remote_dir, "/");
-            mr_asprintf(bkpinfo->isodir, "%s", ".");
-        }
-        /* test for protocol */
-        p = strstr(bkpinfo->netfs_mount, "://");
-        if (p == NULL) {
-            /* protocol not found assuming NFS for compatibility */
-            mr_asprintf(q,"nfs");
-
-            p = strchr(bkpinfo->netfs_mount, ':');
-            if (p == NULL) {
-                fatal_error("No protocol specified for remote share mount, nor any old NFS syntax found.\nPlease do man mondoarchive as syntax changed");
-            }
-            /* p points on to the string server:/path */
-            p = bkpinfo->netfs_mount;
-
-        } else {
-            /* Isolate the protocol */
-            *p = '\0';
-            mr_asprintf(q,"%s",bkpinfo->netfs_mount);
-
-            /* Skip proto now */
-            p++;
-            p++;
-            p++;
-        }
-        /* whatever done before proto is pointed to by q */
-        bkpinfo->netfs_proto = q;
-
-        /* p points on to the string server:/path */
-        /* Store the 2 values */
-        q2 = bkpinfo->netfs_mount;
-        mr_asprintf(bkpinfo->netfs_mount, "%s", p);
-        mr_free(q2);
-
-        /* test if we specified a user */
-        p = strchr(bkpinfo->netfs_mount, '@');
-        if (p != NULL) {
-            /* User found. Store the 2 values */
-            mr_asprintf(bkpinfo->netfs_user, "%s", bkpinfo->netfs_mount);
-            p = strchr(bkpinfo->netfs_user, '@');
-            *p = '\0';
-            p = strchr(bkpinfo->netfs_mount, '@');
-            p++;
-            /* new netfs mount */
-            q2 = bkpinfo->netfs_mount;
-            mr_asprintf(bkpinfo->netfs_mount, "%s", p);
-            mr_free(q2);
-        }
-        if (bkpinfo->netfs_user != NULL) {
-            mr_asprintf(tmp1, "mount | grep -E \"^[a-z]*#*[%s@]*%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_user, bkpinfo->netfs_mount);
-        } else {
-            mr_asprintf(tmp1, "mount | grep -E \"^[a-z]*#*%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_mount);
-        }
-        mr_free(bkpinfo->isodir);
-        bkpinfo->isodir = call_program_and_get_last_line_of_output(tmp1);
-        mr_free(tmp1);
-
-        log_msg(3, "proto = %s", bkpinfo->netfs_proto);
-        log_msg(3, "mount = %s", bkpinfo->netfs_mount);
-        if (bkpinfo->netfs_user) {
-            log_msg(3, "user = %s", bkpinfo->netfs_user);
-        }
-        log_msg(3, "isodir= %s", bkpinfo->isodir);
-
-        if (strlen(bkpinfo->isodir) < 3) {
-            log_to_screen("Network share %s is not mounted. Trying to mount it for you.\n",bkpinfo->netfs_mount);
-            if (bkpinfo->netfs_user) {
-                if (strstr(bkpinfo->netfs_proto, "sshfs")) {
-                    mr_asprintf(tmp1, "sshfs %s@%s", bkpinfo->netfs_user, bkpinfo->netfs_mount);
-                } else if (strstr(bkpinfo->netfs_proto, "smbfs")) {
-                    mr_asprintf(tmp1, "mount -t cifs %s -o user=%s", bkpinfo->netfs_mount, bkpinfo->netfs_user);
-                } else if (strstr(bkpinfo->netfs_proto, "nfs")) {
-                    mr_asprintf(tmp1, "mount -t %s %s@%s", bkpinfo->netfs_proto, bkpinfo->netfs_user, bkpinfo->netfs_mount);
-                } else {
-                    log_to_screen("Protocol %s not supported yet for network backups.\n", bkpinfo->netfs_proto);
-                    fatal_error("Bad Protocol\n");
-                }
-            } else {
-                if (strstr(bkpinfo->netfs_proto, "sshfs")) {
-                    mr_asprintf(tmp1, "sshfs %s", bkpinfo->netfs_mount);
-                } else if (strstr(bkpinfo->netfs_proto, "smbfs")) {
-                    mr_asprintf(tmp1, "mount -t cifs %s", bkpinfo->netfs_mount);
-                } else if (strstr(bkpinfo->netfs_proto, "nfs")) {
-                    mr_asprintf(tmp1, "mount -t %s %s", bkpinfo->netfs_proto, bkpinfo->netfs_mount);
-                } else {
-                    log_to_screen("Protocol %s not supported yet for network backups.\n", bkpinfo->netfs_proto);
-                    fatal_error("Bad Protocol\n");
-                }
-            }
-            i = system(tmp1);
-            mr_free(tmp1);
-
-            if (i) {
-                log_to_screen("Unable to mount Network share %s. Please mount manually.\n", bkpinfo->netfs_mount);
-                retval++;
-            } else {
-                if (bkpinfo->netfs_user) {
-                    mr_asprintf(tmp1, "mount | grep -E \"^[%s@]*%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_user, bkpinfo->netfs_mount);
-                } else {
-                    mr_asprintf(tmp1, "mount | grep -E \"^%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_mount);
-                }
-                mr_free(bkpinfo->isodir);
-                bkpinfo->isodir = call_program_and_get_last_line_of_output(tmp1);
-                if (strlen(bkpinfo->isodir) < 3) {
-                    retval++;
-                    log_to_screen("Network share %s is strangely not mounted. Please mount manually...\n", bkpinfo->netfs_mount);
-                }
-            }
-        }
-    }
-
-    if (flag_set['c']) {
-        bkpinfo->backup_media_type = cdr;
-    }
-    if (flag_set['C']) {
-        bkpinfo->backup_media_type = cdstream;
-    }
-    if (flag_set['i']) {
-        bkpinfo->backup_media_type = iso;
-    }
-    if (flag_set['n']) {
-        bkpinfo->backup_media_type = netfs;
-        /* Never try to eject a Network device */
-        bkpinfo->please_dont_eject = TRUE;
-    }
-    if (flag_set['r']) {
-        bkpinfo->backup_media_type = dvd;
-    }
-    if (flag_set['t']) {
-        bkpinfo->backup_media_type = tape;
-    }
-    if (flag_set['u']) {
-        bkpinfo->backup_media_type = udev;
-    }
-    if (flag_set['U']) {
-        bkpinfo->backup_media_type = usb;
-        /* Never try to eject a USB device */
-        bkpinfo->please_dont_eject = TRUE;
-    }
-    if (flag_set['z']) {
-        if ((tmp = find_home_of_exe("getfattr")) != NULL) {
-            mr_asprintf(g_getfattr,"getfattr");
-        }
-        mr_free(tmp);
-        if ((tmp = find_home_of_exe("getfacl")) != NULL) {
-            mr_asprintf(g_getfattr,"getfaacl");
-        }
-        mr_free(tmp);
-    }
-
-    /* optional, popular */
-    if (flag_set['g']) {
-        g_text_mode = FALSE;
-    }
-
-    if (flag_set['E']) {
-        if ((flag_val['E'][0] == '-')) {
-            retval++;
-            log_to_screen("Please supply a sensible value with '-E'\n");
-        }
-        mr_asprintf(tmp1, "%s", flag_val['E']);
-
-        p = tmp1;
-        q = tmp1;
-
-        /* Cut the flag_val['E'] in parts containing all paths to test them */
-        while (p != NULL) {
-            q = strchr(p, '|');
-            if (q != NULL) {
-                *q = '\0';
-                /* Fix bug 14 where ending / cause a problem later 
-                * so handled here for the moment */
-                q--;
-                if (*q == '/') {
-                    *q = '\0';
-                }
-                q++;
-                /* End of bug fix */
-                if ((stat(p, &buf) != 0) && (! bkpinfo->restore_data)) {
-                    log_msg(1, "WARNING ! %s doesn't exist", p);
-                }
-                p = q+1 ;
-            } else {
-                if ((stat(p, &buf) != 0) && (! bkpinfo->restore_data)) {
-                    log_msg(1, "WARNING ! %s doesn't exist", p);
-                }
-                p = NULL;
-            }
-        }
-        mr_free(tmp1);
-
-        mr_make_devlist_from_pathlist(flag_val['E'], 'E');
-        log_msg(4, "Finished with the -E option");
-    }
-
-    if (flag_set['e']) {
-        bkpinfo->please_dont_eject = TRUE;
-    }
-
-    if (flag_set['M']) {
-        g_max_biggie_size = atol(flag_val['M']);
-        log_msg(1, "Max size for biggie file is now %ld KB", g_max_biggie_size);
-    }
-
-    if ((flag_set['N']) && (! bkpinfo->restore_data))       // exclude Network mounts & devices
-    {
-        psz = list_of_NETFS_mounts_only();
-        log_msg(5, "-N means we'll exclude %s", psz);
-        if (bkpinfo->exclude_paths) {
-            mr_strcat(bkpinfo->exclude_paths, "|%s", psz);
-            mr_free(psz);
-        } else {
-            bkpinfo->exclude_paths = psz;
-        }
-
-        if (bkpinfo->exclude_paths != NULL) {
-            log_msg(3, "-N means we're now excluding %s", bkpinfo->exclude_paths);
-        }
-    }
-
-    if (flag_set['b']) {
-        mr_asprintf(psz, "%s", flag_val['b']);
-        log_msg(1, "psz = '%s'", psz);
-        if (psz[strlen(psz) - 1] == 'k') {
-            psz[strlen(psz) - 1] = '\0';
-            itbs = atol(psz) * 1024L;
-        } else {
-            itbs = atol(psz);
-        }
-        mr_free(psz);
-        log_msg(1, "'%s' --> %ld", flag_val['b'], itbs);
-        log_msg(1, "Internal tape block size is now %ld bytes", itbs);
-        if (itbs % 512 != 0 || itbs < 256 || itbs > 1024L * 1024) {
-            fatal_error("Are you nuts? Silly, your internal tape block size is. Abort, I shall.");
-        }
-        bkpinfo->internal_tape_block_size = itbs;
-    }
-
-    if ((flag_set['D']) && (! bkpinfo->restore_data)) {
-        bkpinfo->differential = 1;
-//      bkpinfo->differential = atoi (flag_val['D']);
-        if ((bkpinfo->differential < 1) || (bkpinfo->differential > 9)) {
-            fatal_error("The D option should be between 1 and 9 inclusive");
-        }
-    }
-
-    if (flag_set['x']) {
-        mr_asprintf(bkpinfo->image_devs, "%s", flag_val['x']);
-        if ((run_program_and_log_output("which ntfsclone", 2)) && (! bkpinfo->restore_data)) {
-            fatal_error("Please install ntfsprogs package/tarball.");
-        }
-    }
-
-    if (flag_set['m']) {
-        bkpinfo->manual_cd_tray = TRUE;
-    }
-
-    if ((flag_set['k']) && (! bkpinfo->restore_data)) {
-        mr_asprintf(bkpinfo->kernel_path, "%s", flag_val['k']);
-        if (!does_file_exist(bkpinfo->kernel_path)) {
-            retval++;
-            log_to_screen("You specified kernel '%s', which does not exist\n", bkpinfo->kernel_path);
-        }
-    }
-
-    if (flag_set['p']) {
-        mr_asprintf(bkpinfo->prefix, "%s", flag_val['p']);
-        log_msg(1,"Prefix forced to %s",bkpinfo->prefix);
-    }
-
-    if (flag_set['d']) {        /* backup directory (if ISO/NETFS) */
-        if (flag_set['i']) {
-            // what is flag_val['d'] is NULL/undefined
-            mr_asprintf(bkpinfo->isodir, "%s", flag_val['d']);
-            mr_asprintf(tmp1, "ls -l %s", bkpinfo->isodir);
-            if (run_program_and_log_output(tmp1, 2)) {
-                mr_free(tmp1);
-                fatal_error("output folder does not exist - please create it");
-            }
-            mr_free(tmp1);
-        } else if (flag_set['n']) {
-            mr_free(bkpinfo->netfs_remote_dir);
-            // what is flag_val['d'] is NULL/undefined
-            mr_asprintf(bkpinfo->netfs_remote_dir, "%s", flag_val['d']);
-        } else {                /* backup device (if tape/CD-R/CD-RW) */
-            /* bkpinfo-> media_device already setup upper */
-        }
-    }
-
-    if ((flag_set['n']) && (! bkpinfo->restore_data)) {
-        mr_asprintf(tmp1,"%s/%s/.dummy.txt", bkpinfo->isodir,bkpinfo->netfs_remote_dir);
-        if ((bkpinfo->netfs_user) && (strstr(bkpinfo->netfs_proto,"nfs"))) {
-            mr_asprintf(tmp2, "su - %s -c \"echo hi > %s\"", bkpinfo->netfs_user, tmp1);
-        } else {
-            mr_asprintf(tmp2, "echo hi > %s", tmp1);
-        }
-        i = run_program_and_log_output(tmp2, 2);
-        mr_free(tmp2);
-
-        if (i) {
-            retval++;
-            log_to_screen("Are you sure directory '%s' exists in remote dir '%s'?\nIf so, do you have rights to write to it?\n", bkpinfo->netfs_remote_dir, bkpinfo->netfs_mount);
-        }
-        unlink(tmp1);
-        mr_free(tmp1);
-    }
-
-    if (!flag_set['d'] && (flag_set['c'] || flag_set['w'] || flag_set['C'])) {
-            tmp1 = mr_popup_and_get_string("Device", "Please specify the device", bkpinfo->media_device);
-            if (tmp1 == NULL) {
-                retval++;
-                log_to_screen("User opted to cancel.");
-            } else {
-                mr_free(bkpinfo->media_device);
-                bkpinfo->media_device = tmp1;
-            }
-        } else {
-    }
-
-    if ((!flag_set['d'] && !flag_set['n'] && !flag_set['C']) && (! bkpinfo->restore_data)) {
-        retval++;
-        log_to_screen("Please specify the backup device/directory.\n");
-        fatal_error("You didn't use -d to specify the backup device/directory.");
-    }
-
-    for (i = '0'; i <= '9'; i++) {
-        if (flag_set[i]) {
-            bkpinfo->compression_level = i - '0';
-        }                       /* not '\0' but '0' */
-    }
-
-    if (flag_set['S']) {
-        setup_scratchdir(flag_val['S']);
-        mr_asprintf(tmp1, "touch %s/.foo.dat", bkpinfo->scratchdir);
-        if (run_program_and_log_output(tmp1, 1)) {
-            retval++;
-            mr_free(tmp1);
-            log_to_screen("Please specify a scratchdir which I can write to. :)");
-            fatal_error("I cannot write to the scratchdir you specified.");
-        }
-        mr_free(tmp1);
-
-        mr_asprintf(tmp1, "ln -sf %s/.foo.dat %s/.bar.dat", bkpinfo->scratchdir, bkpinfo->scratchdir);
-        if (run_program_and_log_output(tmp1, 1)) {
-            retval++;
-            mr_free(tmp1);
-            log_to_screen("Please don't specify a SAMBA or VFAT or NFS scratchdir.");
-            fatal_error("I cannot write to the scratchdir you specified.");
-        }
-        mr_free(tmp1);
-    }
-
-    if (flag_set['T']) {
-        setup_tmpdir(flag_val['T']);
-        mr_asprintf(tmp1, "touch %s/.foo.dat", bkpinfo->tmpdir);
-        i = run_program_and_log_output(tmp1, 1);
-        mr_free(tmp1);
-
-        if (i) {
-            retval++;
-            log_to_screen("Please specify a tempdir which I can write to. :)");
-            fatal_error("I cannot write to the tempdir you specified.");
-        }
-        mr_asprintf(tmp1, "ln -sf %s/.foo.dat %s/.bar.dat", bkpinfo->tmpdir, bkpinfo->tmpdir);
-        i = run_program_and_log_output(tmp1, 1);
-        mr_free(tmp1);
-
-        if (i) {
-            retval++;
-            log_to_screen("Please don't specify a SAMBA or VFAT or NFS tmpdir.");
-            fatal_error("I cannot write to the tempdir you specified.");
-        }
-    }
-
-    if ((flag_set['A']) && (! bkpinfo->restore_data)) {
-        mr_asprintf(bkpinfo->call_after_iso, "%s", flag_val['A']);
-    }
-
-    if ((flag_set['B']) && (! bkpinfo->restore_data)) {
-        mr_asprintf(bkpinfo->call_before_iso, "%s", flag_val['B']);
-    }
-
-    if ((flag_set['H']) && (! bkpinfo->restore_data)) {
-        g_cd_recovery = TRUE;
-    }
-
-    if ((flag_set['l']) && (! bkpinfo->restore_data)) {
-#ifdef __FreeBSD__
-#  define BOOT_LOADER_CHARS "GLBMR"
-#else
-#  ifdef __IA64__
-#    define BOOT_LOADER_CHARS "GER"
-#  else
-#    define BOOT_LOADER_CHARS "GLR"
-#  endif
-#endif
-        if (!strchr(BOOT_LOADER_CHARS, (bkpinfo->boot_loader = flag_val['l'][0]))) {
-            log_msg(1, "%c? What is %c? I need G, L, E or R.", bkpinfo->boot_loader, bkpinfo->boot_loader);
-            fatal_error("Please specify GRUB, LILO, ELILO  or RAW with the -l switch");
-        }
-#undef BOOT_LOADER_CHARS
-    }
-
-    if (flag_set['f']) {
-        mr_free(bkpinfo->boot_device);
-        mr_asprintf(bkpinfo->boot_device, "%s", resolve_softlinks_to_get_to_actual_device_file(flag_val['f']));
-    }
-
-    if ((flag_set['P']) && (! bkpinfo->restore_data)) {
-        mr_asprintf(bkpinfo->postnuke_tarball, "%s", flag_val['P']);
-    }
-
-    if (flag_set['Q']) {
-        i = which_boot_loader(tmp);
-        log_msg(3, "boot loader is %c, residing at %s", i, tmp);
-        printf("boot loader is %c, residing at %s\n", i, tmp);
-        finish(0);
-    }
-
-    if ((flag_set['L']) && (! bkpinfo->restore_data)) {
-        bkpinfo->use_lzo = TRUE;
-        if (run_program_and_log_output("which lzop", 2)) {
-            retval++;
-            log_to_screen("Please install LZOP. You can't use '-L' until you do.\n");
-        }
-    }
-
-    if (flag_set['F']) {
-        log_msg(3, "-F means we will fail immediately at the first interaction request");
-        g_fail_immediately = TRUE;
-    }
-
-    if ((flag_set['G']) && (! bkpinfo->restore_data)) {
-        bkpinfo->use_gzip = TRUE;
-        if (run_program_and_log_output("which gzip", 2)) {
-            retval++;
-            log_to_screen("Please install gzip. You can't use '-G' until you do.\n");
-        }
-    }
-
-    if ((flag_set['Y']) && (! bkpinfo->restore_data)) {
-        bkpinfo->use_lzma = TRUE;
-        if (run_program_and_log_output("which lzma", 2)) {
-            retval++;
-            log_to_screen("Please install lzma. You can't use '-Y' until you do.\n");
-        }
-    }
-
-    bkpinfo->use_obdr = FALSE;
-    if (flag_set['o']) {
-        if ((!flag_set['t']) && (! bkpinfo->restore_data)) {
-            log_to_screen("OBDR support is only available for tapes. Use the -t option");
-            fatal_error("Aborting");
-        }
-        bkpinfo->use_obdr = TRUE;
-    }
-
-#ifndef __FreeBSD__
-    if ((!is_this_a_valid_disk_format("vfat")) && (! bkpinfo->restore_data)) {
-        bkpinfo->make_cd_use_lilo = TRUE;
-        log_to_screen("Your kernel appears not to support vfat filesystems. I am therefore");
-        log_to_screen("using LILO instead of SYSLINUX as the media boot loader.");
-    }
-    if ((run_program_and_log_output("which mkfs.vfat", 2)) && (! bkpinfo->restore_data)) {
-        bkpinfo->make_cd_use_lilo = TRUE;
-#ifdef __IA32__
-        log_to_screen("Your filesystem is missing 'mkfs.vfat', so I cannot use SYSLINUX as");
-        log_to_screen("your boot loader. I shall therefore use LILO instead.");
-#endif
-#ifdef __IA64__
-        log_to_screen("Your filesystem is missing 'mkfs.vfat', so I cannot prepare the EFI");
-        log_to_screen("environment correctly. Please install it.");
-        fatal_error("Aborting");
-#endif
-    }
-#ifdef __IA64__
-    /* We force ELILO usage on IA64 */
-    bkpinfo->make_cd_use_lilo = TRUE;
-#endif
-#endif
-
-    if (! bkpinfo->restore_data) {
-        i = flag_set['O'] + flag_set['V'];
-        if (i == 0) {
-            retval++;
-            log_to_screen("Specify backup (-O), verify (-V) or both (-OV).\n");
-        }
-    }
-
-    if ((! bkpinfo->restore_data) && (flag_set['Z'])) {
-            fatal_error("The -Z switch is only valid in restore mode");
-    }
-
-    if (flag_set['Z']) {
-        if (! strcmp(flag_val['Z'], "nuke")) {
-            bkpinfo->restore_mode = nuke;
-        } else if (! strcmp(flag_val['Z'], "interactive")) {
-            bkpinfo->restore_mode = interactive;
-        } else if (! strcmp(flag_val['Z'], "compare")) {
-            bkpinfo->restore_mode = compare;
-        } else if (! strcmp(flag_val['Z'], "mbr")) {
-            bkpinfo->restore_mode = mbr;
-        } else if (! strcmp(flag_val['Z'], "iso")) {
-            bkpinfo->restore_mode = isoonly;
-        } else if (! strcmp(flag_val['Z'], "isonuke")) {
-            bkpinfo->restore_mode = isonuke;
-        } else {
-            bkpinfo->restore_mode = interactive;
-        }
-    }
-
-/* and finally... */
-
-    paranoid_free(tmp);
-    return (retval);
+    log_msg(1, "Type 'man mondoarchive' for more information");
+    exit(1);
 }
-
 
 
@@ -983 +163 @@
 
 
-
-
 /**
- * Print a not-so-helpful help message and exit.
+ * Process mondoarchive's command-line switches.
+ * @param bkpinfo The backup information structure to populate.
+ * @param flag_val An array of the argument passed to each switch (the letter is the index).
+ * If a switch is not set or has no argument, the field in @p flag_val doesn't matter.
+ * @param flag_set An array of <tt>bool</tt>s indexed by switch letter: TRUE if it's set,
+ * FALSE if it's not.
+ * @return The number of problems with the switches, or 0 for success.
+ * @bug Maybe include a list of all switches (inc. intentionally undocumented ones not in the manual!) here?
  */
-void help_screen()
+int
+process_switches(char flag_val[128][MAX_STR_LEN], bool flag_set[128])
 {
-    log_msg(1, "Type 'man mondoarchive' for more information");
-    exit(1);
+
+    /*@ ints *** */
+    int i = 0;
+    int retval = 0;
+
+    /*@ buffers ** */
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *tmp2 = NULL;
+    char *psz = NULL;
+    char *p = NULL;
+    char *q = NULL;
+    char *q2 = NULL;
+
+    long itbs = 0L;
+
+    struct stat buf;
+
+    malloc_string(tmp);
+
+    assert(bkpinfo != NULL);
+    assert(flag_val != NULL);
+    assert(flag_set != NULL);
+
+    bkpinfo->internal_tape_block_size = DEFAULT_INTERNAL_TAPE_BLOCK_SIZE;
+
+    /* compulsory */
+    i = flag_set['c'] + flag_set['i'] + flag_set['n'] +
+        flag_set['t'] + flag_set['u'] + flag_set['r'] +
+        flag_set['w'] + flag_set['C'] + flag_set['U'];
+    if ((i == 0) && (! bkpinfo->restore_data)) {
+        retval++;
+        log_to_screen("You must specify the media type\n");
+    }
+    if (i > 1) {
+        retval++;
+        log_to_screen("Please specify only one media type\n");
+    }
+
+    if (flag_set['K']) {
+        g_loglevel = atoi(flag_val['K']);
+            log_msg(1,"Loglevel forced to %d",g_loglevel);
+        if (g_loglevel < 3) {
+            g_loglevel = 3;
+        }
+    }
+
+    if ((flag_set['L'] && flag_set['0']) && (! bkpinfo->restore_data)) {
+        retval++;
+        log_to_screen("You cannot have 'no compression' _and_ LZOP.\n");
+    }
+    if (! bkpinfo->restore_data) {
+        bkpinfo->backup_data = flag_set['O'];
+    }
+    bkpinfo->verify_data = flag_set['V'];
+
+    if (flag_set['I'] && !bkpinfo->backup_data) {
+        log_to_screen("-I switch is ignored if just verifying");
+    }
+    if (flag_set['E'] && !bkpinfo->backup_data) {
+        log_to_screen("-E switch is ignored if just verifying");
+    }
+
+    if ((tmp = find_home_of_exe("afio")) == NULL) {
+        mr_free(tmp);
+        if ((tmp = find_home_of_exe("star")) != NULL) {
+            mr_free(tmp);
+            flag_set['R'] = TRUE;
+            log_msg(1, "Using star instead of afio");
+        } else {
+            mr_free(tmp);
+            fatal_error("Neither afio nor star is installed. Please install at least one.");
+        }
+    }
+
+    if (flag_set['R']) {
+        bkpinfo->use_star = TRUE;
+        if (flag_set['L']) {
+            fatal_error("You may not use star and lzop at the same time.");
+        }
+        if ((tmp = find_home_of_exe("star")) == NULL) {
+            mr_free(tmp);
+            fatal_error("Please install 'star' if you are going to use -R. Thanks.");
+        }
+        mr_free(tmp);
+    }
+
+    if ((flag_set['W']) && (! bkpinfo->restore_data)) {
+        bkpinfo->nonbootable_backup = TRUE;
+        log_to_screen("Warning - you have opted for non-bootable backup");
+        if (flag_set['f'] || flag_set['l']) {
+            log_to_screen
+                ("You don't need to specify bootloader or bootdevice");
+        }
+    }
+
+    if (flag_set['I']) {
+        if (flag_val['I'][0] == '-') {
+            retval++;
+            log_to_screen("Please supply a sensible value with '-I'\n");
+        }
+        if (!strcmp(flag_val['I'],"/")) {
+            log_msg(2, "'/' is pleonastic.");
+        }
+        if (bkpinfo->include_paths && bkpinfo->include_paths[0]) {
+            mr_strcat(bkpinfo->include_paths, "|");
+        }
+
+        mr_asprintf(tmp1, "%s", flag_val['I']);
+        p = tmp1;
+        q = tmp1;
+
+        /* Cut the flag_val['I'] in parts containing all paths to test them */
+        while (p != NULL) {
+            q = strchr(p, '|');
+            if (q != NULL) {
+                *q = '\0';
+                if ((stat(p, &buf) != 0) && (! bkpinfo->restore_data)) {
+                    log_msg(1, "ERROR ! %s doesn't exist", p);
+                    fatal_error("ERROR ! You specified a directory to include which doesn't exist");
+                }
+                p = q+1 ;
+            } else {
+                if ((stat(p, &buf) != 0) && (! bkpinfo->restore_data)) {
+                    log_msg(1, "ERROR ! %s doesn't exist", p);
+                    fatal_error("ERROR ! You specified a directory to include which doesn't exist");
+                }
+                p = NULL;
+            }
+        }
+        mr_free(tmp1);
+        mr_make_devlist_from_pathlist(flag_val['I'], 'I');
+        log_msg(4, "Finished with the -I option");
+    }
+
+    if (g_kernel_version >= 2.6 && !flag_set['d'] && (flag_set['c'] || flag_set['w']) && (! bkpinfo->restore_data)) {
+        fatal_error("If you are using the 2.6.x kernel, please specify the CD-R(W) device.");
+    }
+
+
+    if (flag_set['J']) {
+        if (flag_set['I']) {
+            retval++;
+            log_to_screen("Please do not use -J in combination with -I. If you want to make a list of files to backup, that's fine, use -J <filename> but please don't muddy the waters by combining -J with -I. Thanks. :-)");
+        }
+        bkpinfo->make_filelist = FALSE;
+        mr_asprintf(bkpinfo->include_paths, "%s", flag_val['J']);
+    }
+
+    if ((flag_set['c'] || flag_set['w'] || flag_set['C'] || flag_set['r']) && (! bkpinfo->restore_data)) {
+        if (system("which cdrecord > /dev/null 2> /dev/null") && system("which dvdrecord > /dev/null 2> /dev/null")) {
+            fatal_error("Please install dvdrecord/cdrecord and try again.");
+        }
+        if (flag_set['C']) {
+            bkpinfo->cdrw_speed = atoi(flag_val['C']);
+            if (bkpinfo->cdrw_speed < 1) {
+                fatal_error("You specified a silly speed for a CD-R[W] drive");
+            }
+            if (!flag_set['L']) {
+                log_to_screen("You must use -L with -C. Therefore I am setting it for you.");
+                flag_set['L'] = 1;
+                flag_val['L'][0] = '\0';
+            }
+        } else {
+            log_msg(3, "flag_val['c'] = %s", flag_val['c']);
+            log_msg(3, "flag_val['w'] = %s", flag_val['w']);
+            if (flag_set['c']) {
+                bkpinfo->cdrw_speed = atoi(flag_val['c']);
+            } else if (flag_set['w']) {
+                bkpinfo->cdrw_speed = atoi(flag_val['w']);
+            } else if (flag_set['r']) {
+                bkpinfo->cdrw_speed = 1;    /*atoi(flag_val['r']); */
+            }
+
+            if (bkpinfo->cdrw_speed < 1) {
+                fatal_error("You specified a silly speed for a CD-R[W] drive");
+            }
+        }
+    }
+
+    if ((flag_set['t'] && !flag_set['d']) && (! bkpinfo->restore_data)) {
+        log_it("Hmm! No tape drive specified. Let's see what we can do.");
+        if ((bkpinfo->media_device = find_tape_device()) == NULL) {
+            fatal_error("Tape device not specified and I couldn't find it either. Please use option -d");
+        }
+        flag_set['d'] = TRUE;
+        log_to_screen("You didn't specify a tape streamer device. I'm assuming %s", bkpinfo->media_device);
+    }
+
+    if (flag_set['U'])          // USB
+    {
+        if (! flag_set['d']) {
+            fatal_error("You need to specify a device file with -d for bootable USB device usage");
+        }
+        if ((!flag_set['s']) && (! bkpinfo->restore_data)) {
+            fatal_error("You did not specify a size (-s) for your USB device. Aborting");
+        }
+    }
+
+    if (flag_set['r'])          // DVD
+    {
+        if (flag_set['m']) {
+            fatal_error("Manual CD tray (-m) not yet supported in conjunction w/ DVD drives. Drop -m.");
+        }
+        if (!flag_set['d']) {
+            if ((bkpinfo->media_device = find_optical_device()) != NULL) {
+                flag_set['d'] = TRUE;
+                log_to_screen("I guess DVD drive is at %s", bkpinfo->media_device);
+            }
+        }
+        if (strchr(bkpinfo->media_device, ',')) {
+            fatal_error("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag.");
+        }
+        if (! bkpinfo->restore_data) {
+            if (!flag_set['s']) {
+                sprintf(flag_val['s'], "%d", DEFAULT_DVD_DISK_SIZE);    // 4.7 salesman's GB = 4.482 real GB = 4582 MB
+                strcat(flag_val['s'], "m");
+                log_to_screen("You did not specify a size (-s) for DVD. I'm guessing %s.", flag_val['s']);
+                flag_set['s'] = 1;
+            }
+        }
+    }
+
+    if (flag_set['t'] || flag_set['u']) {   /* tape size */
+        if (strchr(flag_val['d'], ',')) {
+            fatal_error("Please don't give a SCSI node. Give a _device_, preferably a /dev entry, for the parameter of the -d flag.");
+        }
+        if ((flag_set['O']) && (! bkpinfo->restore_data)) {
+            if (flag_set['s']) {
+                if (flag_set['t']) {
+                    fatal_error("For the moment, please don't specify a tape size. Mondo should handle end-of-tape gracefully anyway.");
+                }
+                if (process_the_s_switch(flag_val['s'])) {
+                    fatal_error("Bad -s switch");
+                }
+            } else if (flag_set['u'] || flag_set['t']) {
+                bkpinfo->media_size = 0;
+            } else {
+                retval++;
+                log_to_screen("Tape size not specified.\n");
+            }
+        }
+    } else if (! bkpinfo->restore_data) {           /* CD|USB size */
+        if (flag_set['s']) {
+            if (process_the_s_switch(flag_val['s'])) {
+                fatal_error("Bad -s switch");
+            }
+        }
+        if (flag_set['w']) {
+            bkpinfo->wipe_media_first = TRUE;
+        }                       /* CD-RW */
+    }
+
+    if (flag_set['n']) {
+        mr_asprintf(bkpinfo->netfs_mount, "%s", flag_val['n']);
+        if (!flag_set['d']) {
+            mr_asprintf(bkpinfo->netfs_remote_dir, "/");
+            mr_asprintf(bkpinfo->isodir, "%s", ".");
+        }
+        /* test for protocol */
+        p = strstr(bkpinfo->netfs_mount, "://");
+        if (p == NULL) {
+            /* protocol not found assuming NFS for compatibility */
+            mr_asprintf(q,"nfs");
+
+            p = strchr(bkpinfo->netfs_mount, ':');
+            if (p == NULL) {
+                fatal_error("No protocol specified for remote share mount, nor any old NFS syntax found.\nPlease do man mondoarchive as syntax changed");
+            }
+            /* p points on to the string server:/path */
+            p = bkpinfo->netfs_mount;
+
+        } else {
+            /* Isolate the protocol */
+            *p = '\0';
+            mr_asprintf(q,"%s",bkpinfo->netfs_mount);
+
+            /* Skip proto now */
+            p++;
+            p++;
+            p++;
+        }
+        /* whatever done before proto is pointed to by q */
+        bkpinfo->netfs_proto = q;
+
+        /* p points on to the string server:/path */
+        /* Store the 2 values */
+        q2 = bkpinfo->netfs_mount;
+        mr_asprintf(bkpinfo->netfs_mount, "%s", p);
+        mr_free(q2);
+
+        /* test if we specified a user */
+        p = strchr(bkpinfo->netfs_mount, '@');
+        if (p != NULL) {
+            /* User found. Store the 2 values */
+            mr_asprintf(bkpinfo->netfs_user, "%s", bkpinfo->netfs_mount);
+            p = strchr(bkpinfo->netfs_user, '@');
+            *p = '\0';
+            p = strchr(bkpinfo->netfs_mount, '@');
+            p++;
+            /* new netfs mount */
+            q2 = bkpinfo->netfs_mount;
+            mr_asprintf(bkpinfo->netfs_mount, "%s", p);
+            mr_free(q2);
+        }
+        if (bkpinfo->netfs_user != NULL) {
+            mr_asprintf(tmp1, "mount | grep -E \"^[a-z]*#*[%s@]*%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_user, bkpinfo->netfs_mount);
+        } else {
+            mr_asprintf(tmp1, "mount | grep -E \"^[a-z]*#*%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_mount);
+        }
+        mr_free(bkpinfo->isodir);
+        bkpinfo->isodir = call_program_and_get_last_line_of_output(tmp1);
+        mr_free(tmp1);
+
+        log_msg(3, "proto = %s", bkpinfo->netfs_proto);
+        log_msg(3, "mount = %s", bkpinfo->netfs_mount);
+        if (bkpinfo->netfs_user) {
+            log_msg(3, "user = %s", bkpinfo->netfs_user);
+        }
+        log_msg(3, "isodir= %s", bkpinfo->isodir);
+
+        if (strlen(bkpinfo->isodir) < 3) {
+            log_to_screen("Network share %s is not mounted. Trying to mount it for you.\n",bkpinfo->netfs_mount);
+            if (bkpinfo->netfs_user) {
+                if (strstr(bkpinfo->netfs_proto, "sshfs")) {
+                    mr_asprintf(tmp1, "sshfs %s@%s", bkpinfo->netfs_user, bkpinfo->netfs_mount);
+                } else if (strstr(bkpinfo->netfs_proto, "smbfs")) {
+                    mr_asprintf(tmp1, "mount -t cifs %s -o user=%s", bkpinfo->netfs_mount, bkpinfo->netfs_user);
+                } else if (strstr(bkpinfo->netfs_proto, "nfs")) {
+                    mr_asprintf(tmp1, "mount -t %s %s@%s", bkpinfo->netfs_proto, bkpinfo->netfs_user, bkpinfo->netfs_mount);
+                } else {
+                    log_to_screen("Protocol %s not supported yet for network backups.\n", bkpinfo->netfs_proto);
+                    fatal_error("Bad Protocol\n");
+                }
+            } else {
+                if (strstr(bkpinfo->netfs_proto, "sshfs")) {
+                    mr_asprintf(tmp1, "sshfs %s", bkpinfo->netfs_mount);
+                } else if (strstr(bkpinfo->netfs_proto, "smbfs")) {
+                    mr_asprintf(tmp1, "mount -t cifs %s", bkpinfo->netfs_mount);
+                } else if (strstr(bkpinfo->netfs_proto, "nfs")) {
+                    mr_asprintf(tmp1, "mount -t %s %s", bkpinfo->netfs_proto, bkpinfo->netfs_mount);
+                } else {
+                    log_to_screen("Protocol %s not supported yet for network backups.\n", bkpinfo->netfs_proto);
+                    fatal_error("Bad Protocol\n");
+                }
+            }
+            i = system(tmp1);
+            mr_free(tmp1);
+
+            if (i) {
+                log_to_screen("Unable to mount Network share %s. Please mount manually.\n", bkpinfo->netfs_mount);
+                retval++;
+            } else {
+                if (bkpinfo->netfs_user) {
+                    mr_asprintf(tmp1, "mount | grep -E \"^[%s@]*%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_user, bkpinfo->netfs_mount);
+                } else {
+                    mr_asprintf(tmp1, "mount | grep -E \"^%s[/]* .*\" | cut -d' ' -f3", bkpinfo->netfs_mount);
+                }
+                mr_free(bkpinfo->isodir);
+                bkpinfo->isodir = call_program_and_get_last_line_of_output(tmp1);
+                if (strlen(bkpinfo->isodir) < 3) {
+                    retval++;
+                    log_to_screen("Network share %s is strangely not mounted. Please mount manually...\n", bkpinfo->netfs_mount);
+                }
+            }
+        }
+    }
+
+    if (flag_set['c']) {
+        bkpinfo->backup_media_type = cdr;
+    }
+    if (flag_set['C']) {
+        bkpinfo->backup_media_type = cdstream;
+    }
+    if (flag_set['i']) {
+        bkpinfo->backup_media_type = iso;
+    }
+    if (flag_set['n']) {
+        bkpinfo->backup_media_type = netfs;
+        /* Never try to eject a Network device */
+        bkpinfo->please_dont_eject = TRUE;
+    }
+    if (flag_set['r']) {
+        bkpinfo->backup_media_type = dvd;
+    }
+    if (flag_set['t']) {
+        bkpinfo->backup_media_type = tape;
+    }
+    if (flag_set['u']) {
+        bkpinfo->backup_media_type = udev;
+    }
+    if (flag_set['U']) {
+        bkpinfo->backup_media_type = usb;
+        /* Never try to eject a USB device */
+        bkpinfo->please_dont_eject = TRUE;
+    }
+    if (flag_set['z']) {
+        if ((tmp = find_home_of_exe("getfattr")) != NULL) {
+            mr_asprintf(g_getfattr,"getfattr");
+        }
+        mr_free(tmp);
+        if ((tmp = find_home_of_exe("getfacl")) != NULL) {
+            mr_asprintf(g_getfattr,"getfaacl");
+        }
+        mr_free(tmp);
+    }
+
+    /* optional, popular */
+    if (flag_set['g']) {
+        g_text_mode = FALSE;
+    }
+
+    if (flag_set['E']) {
+        if ((flag_val['E'][0] == '-')) {
+            retval++;
+            log_to_screen("Please supply a sensible value with '-E'\n");
+        }
+        mr_asprintf(tmp1, "%s", flag_val['E']);
+
+        p = tmp1;
+        q = tmp1;
+
+        /* Cut the flag_val['E'] in parts containing all paths to test them */
+        while (p != NULL) {
+            q = strchr(p, '|');
+            if (q != NULL) {
+                *q = '\0';
+                /* Fix bug 14 where ending / cause a problem later 
+                * so handled here for the moment */
+                q--;
+                if (*q == '/') {
+                    *q = '\0';
+                }
+                q++;
+                /* End of bug fix */
+                if ((stat(p, &buf) != 0) && (! bkpinfo->restore_data)) {
+                    log_msg(1, "WARNING ! %s doesn't exist", p);
+                }
+                p = q+1 ;
+            } else {
+                if ((stat(p, &buf) != 0) && (! bkpinfo->restore_data)) {
+                    log_msg(1, "WARNING ! %s doesn't exist", p);
+                }
+                p = NULL;
+            }
+        }
+        mr_free(tmp1);
+
+        mr_make_devlist_from_pathlist(flag_val['E'], 'E');
+        log_msg(4, "Finished with the -E option");
+    }
+
+    if (flag_set['e']) {
+        bkpinfo->please_dont_eject = TRUE;
+    }
+
+    if (flag_set['M']) {
+        g_max_biggie_size = atol(flag_val['M']);
+        log_msg(1, "Max size for biggie file is now %ld KB", g_max_biggie_size);
+    }
+
+    if ((flag_set['N']) && (! bkpinfo->restore_data))       // exclude Network mounts & devices
+    {
+        psz = list_of_NETFS_mounts_only();
+        log_msg(5, "-N means we'll exclude %s", psz);
+        if (bkpinfo->exclude_paths) {
+            mr_strcat(bkpinfo->exclude_paths, "|%s", psz);
+            mr_free(psz);
+        } else {
+            bkpinfo->exclude_paths = psz;
+        }
+
+        if (bkpinfo->exclude_paths != NULL) {
+            log_msg(3, "-N means we're now excluding %s", bkpinfo->exclude_paths);
+        }
+    }
+
+    if (flag_set['b']) {
+        mr_asprintf(psz, "%s", flag_val['b']);
+        log_msg(1, "psz = '%s'", psz);
+        if (psz[strlen(psz) - 1] == 'k') {
+            psz[strlen(psz) - 1] = '\0';
+            itbs = atol(psz) * 1024L;
+        } else {
+            itbs = atol(psz);
+        }
+        mr_free(psz);
+        log_msg(1, "'%s' --> %ld", flag_val['b'], itbs);
+        log_msg(1, "Internal tape block size is now %ld bytes", itbs);
+        if (itbs % 512 != 0 || itbs < 256 || itbs > 1024L * 1024) {
+            fatal_error("Are you nuts? Silly, your internal tape block size is. Abort, I shall.");
+        }
+        bkpinfo->internal_tape_block_size = itbs;
+    }
+
+    if ((flag_set['D']) && (! bkpinfo->restore_data)) {
+        bkpinfo->differential = 1;
+//      bkpinfo->differential = atoi (flag_val['D']);
+        if ((bkpinfo->differential < 1) || (bkpinfo->differential > 9)) {
+            fatal_error("The D option should be between 1 and 9 inclusive");
+        }
+    }
+
+    if (flag_set['x']) {
+        mr_asprintf(bkpinfo->image_devs, "%s", flag_val['x']);
+        if ((run_program_and_log_output("which ntfsclone", 2)) && (! bkpinfo->restore_data)) {
+            fatal_error("Please install ntfsprogs package/tarball.");
+        }
+    }
+
+    if (flag_set['m']) {
+        bkpinfo->manual_cd_tray = TRUE;
+    }
+
+    if ((flag_set['k']) && (! bkpinfo->restore_data)) {
+        mr_asprintf(bkpinfo->kernel_path, "%s", flag_val['k']);
+        if (!does_file_exist(bkpinfo->kernel_path)) {
+            retval++;
+            log_to_screen("You specified kernel '%s', which does not exist\n", bkpinfo->kernel_path);
+        }
+    }
+
+    if (flag_set['p']) {
+        mr_asprintf(bkpinfo->prefix, "%s", flag_val['p']);
+        log_msg(1,"Prefix forced to %s",bkpinfo->prefix);
+    }
+
+    if (flag_set['d']) {        /* backup directory (if ISO/NETFS) */
+        if (flag_set['i']) {
+            // what is flag_val['d'] is NULL/undefined
+            mr_asprintf(bkpinfo->isodir, "%s", flag_val['d']);
+            mr_asprintf(tmp1, "ls -l %s", bkpinfo->isodir);
+            if (run_program_and_log_output(tmp1, 2)) {
+                mr_free(tmp1);
+                fatal_error("output folder does not exist - please create it");
+            }
+            mr_free(tmp1);
+        } else if (flag_set['n']) {
+            mr_free(bkpinfo->netfs_remote_dir);
+            // what is flag_val['d'] is NULL/undefined
+            mr_asprintf(bkpinfo->netfs_remote_dir, "%s", flag_val['d']);
+        } else {                /* backup device (if tape/CD-R/CD-RW) */
+            /* bkpinfo-> media_device already setup upper */
+        }
+    }
+
+    if ((flag_set['n']) && (! bkpinfo->restore_data)) {
+        mr_asprintf(tmp1,"%s/%s/.dummy.txt", bkpinfo->isodir,bkpinfo->netfs_remote_dir);
+        if ((bkpinfo->netfs_user) && (strstr(bkpinfo->netfs_proto,"nfs"))) {
+            mr_asprintf(tmp2, "su - %s -c \"echo hi > %s\"", bkpinfo->netfs_user, tmp1);
+        } else {
+            mr_asprintf(tmp2, "echo hi > %s", tmp1);
+        }
+        i = run_program_and_log_output(tmp2, 2);
+        mr_free(tmp2);
+
+        if (i) {
+            retval++;
+            log_to_screen("Are you sure directory '%s' exists in remote dir '%s'?\nIf so, do you have rights to write to it?\n", bkpinfo->netfs_remote_dir, bkpinfo->netfs_mount);
+        }
+        unlink(tmp1);
+        mr_free(tmp1);
+    }
+
+    if (!flag_set['d'] && (flag_set['c'] || flag_set['w'] || flag_set['C'])) {
+            tmp1 = mr_popup_and_get_string("Device", "Please specify the device", bkpinfo->media_device);
+            if (tmp1 == NULL) {
+                retval++;
+                log_to_screen("User opted to cancel.");
+            } else {
+                mr_free(bkpinfo->media_device);
+                bkpinfo->media_device = tmp1;
+            }
+        } else {
+    }
+
+    if ((!flag_set['d'] && !flag_set['n'] && !flag_set['C']) && (! bkpinfo->restore_data)) {
+        retval++;
+        log_to_screen("Please specify the backup device/directory.\n");
+        fatal_error("You didn't use -d to specify the backup device/directory.");
+    }
+
+    for (i = '0'; i <= '9'; i++) {
+        if (flag_set[i]) {
+            bkpinfo->compression_level = i - '0';
+        }                       /* not '\0' but '0' */
+    }
+
+    if (flag_set['S']) {
+        setup_scratchdir(flag_val['S']);
+        mr_asprintf(tmp1, "touch %s/.foo.dat", bkpinfo->scratchdir);
+        if (run_program_and_log_output(tmp1, 1)) {
+            retval++;
+            mr_free(tmp1);
+            log_to_screen("Please specify a scratchdir which I can write to. :)");
+            fatal_error("I cannot write to the scratchdir you specified.");
+        }
+        mr_free(tmp1);
+
+        mr_asprintf(tmp1, "ln -sf %s/.foo.dat %s/.bar.dat", bkpinfo->scratchdir, bkpinfo->scratchdir);
+        if (run_program_and_log_output(tmp1, 1)) {
+            retval++;
+            mr_free(tmp1);
+            log_to_screen("Please don't specify a SAMBA or VFAT or NFS scratchdir.");
+            fatal_error("I cannot write to the scratchdir you specified.");
+        }
+        mr_free(tmp1);
+    }
+
+    if (flag_set['T']) {
+        setup_tmpdir(flag_val['T']);
+        mr_asprintf(tmp1, "touch %s/.foo.dat", bkpinfo->tmpdir);
+        i = run_program_and_log_output(tmp1, 1);
+        mr_free(tmp1);
+
+        if (i) {
+            retval++;
+            log_to_screen("Please specify a tempdir which I can write to. :)");
+            fatal_error("I cannot write to the tempdir you specified.");
+        }
+        mr_asprintf(tmp1, "ln -sf %s/.foo.dat %s/.bar.dat", bkpinfo->tmpdir, bkpinfo->tmpdir);
+        i = run_program_and_log_output(tmp1, 1);
+        mr_free(tmp1);
+
+        if (i) {
+            retval++;
+            log_to_screen("Please don't specify a SAMBA or VFAT or NFS tmpdir.");
+            fatal_error("I cannot write to the tempdir you specified.");
+        }
+    }
+
+    if ((flag_set['A']) && (! bkpinfo->restore_data)) {
+        mr_asprintf(bkpinfo->call_after_iso, "%s", flag_val['A']);
+    }
+
+    if ((flag_set['B']) && (! bkpinfo->restore_data)) {
+        mr_asprintf(bkpinfo->call_before_iso, "%s", flag_val['B']);
+    }
+
+    if ((flag_set['H']) && (! bkpinfo->restore_data)) {
+        g_cd_recovery = TRUE;
+    }
+
+    if ((flag_set['l']) && (! bkpinfo->restore_data)) {
+#ifdef __FreeBSD__
+#  define BOOT_LOADER_CHARS "GLBMR"
+#else
+#  ifdef __IA64__
+#    define BOOT_LOADER_CHARS "GER"
+#  else
+#    define BOOT_LOADER_CHARS "GLR"
+#  endif
+#endif
+        if (!strchr(BOOT_LOADER_CHARS, (bkpinfo->boot_loader = flag_val['l'][0]))) {
+            log_msg(1, "%c? What is %c? I need G, L, E or R.", bkpinfo->boot_loader, bkpinfo->boot_loader);
+            fatal_error("Please specify GRUB, LILO, ELILO  or RAW with the -l switch");
+        }
+#undef BOOT_LOADER_CHARS
+    }
+
+    if (flag_set['f']) {
+        mr_free(bkpinfo->boot_device);
+        mr_asprintf(bkpinfo->boot_device, "%s", resolve_softlinks_to_get_to_actual_device_file(flag_val['f']));
+    }
+
+    if ((flag_set['P']) && (! bkpinfo->restore_data)) {
+        mr_asprintf(bkpinfo->postnuke_tarball, "%s", flag_val['P']);
+    }
+
+    if (flag_set['Q']) {
+        i = which_boot_loader(tmp);
+        log_msg(3, "boot loader is %c, residing at %s", i, tmp);
+        printf("boot loader is %c, residing at %s\n", i, tmp);
+        finish(0);
+    }
+
+    if ((flag_set['L']) && (! bkpinfo->restore_data)) {
+        bkpinfo->use_lzo = TRUE;
+        if (run_program_and_log_output("which lzop", 2)) {
+            retval++;
+            log_to_screen("Please install LZOP. You can't use '-L' until you do.\n");
+        }
+    }
+
+    if (flag_set['F']) {
+        log_msg(3, "-F means we will fail immediately at the first interaction request");
+        g_fail_immediately = TRUE;
+    }
+
+    if ((flag_set['G']) && (! bkpinfo->restore_data)) {
+        bkpinfo->use_gzip = TRUE;
+        if (run_program_and_log_output("which gzip", 2)) {
+            retval++;
+            log_to_screen("Please install gzip. You can't use '-G' until you do.\n");
+        }
+    }
+
+    if ((flag_set['Y']) && (! bkpinfo->restore_data)) {
+        bkpinfo->use_lzma = TRUE;
+        if (run_program_and_log_output("which lzma", 2)) {
+            retval++;
+            log_to_screen("Please install lzma. You can't use '-Y' until you do.\n");
+        }
+    }
+
+    bkpinfo->use_obdr = FALSE;
+    if (flag_set['o']) {
+        if ((!flag_set['t']) && (! bkpinfo->restore_data)) {
+            log_to_screen("OBDR support is only available for tapes. Use the -t option");
+            fatal_error("Aborting");
+        }
+        bkpinfo->use_obdr = TRUE;
+    }
+
+#ifndef __FreeBSD__
+    if ((!is_this_a_valid_disk_format("vfat")) && (! bkpinfo->restore_data)) {
+        bkpinfo->make_cd_use_lilo = TRUE;
+        log_to_screen("Your kernel appears not to support vfat filesystems. I am therefore");
+        log_to_screen("using LILO instead of SYSLINUX as the media boot loader.");
+    }
+    if ((run_program_and_log_output("which mkfs.vfat", 2)) && (! bkpinfo->restore_data)) {
+        bkpinfo->make_cd_use_lilo = TRUE;
+#ifdef __IA32__
+        log_to_screen("Your filesystem is missing 'mkfs.vfat', so I cannot use SYSLINUX as");
+        log_to_screen("your boot loader. I shall therefore use LILO instead.");
+#endif
+#ifdef __IA64__
+        log_to_screen("Your filesystem is missing 'mkfs.vfat', so I cannot prepare the EFI");
+        log_to_screen("environment correctly. Please install it.");
+        fatal_error("Aborting");
+#endif
+    }
+#ifdef __IA64__
+    /* We force ELILO usage on IA64 */
+    bkpinfo->make_cd_use_lilo = TRUE;
+#endif
+#endif
+
+    if (! bkpinfo->restore_data) {
+        i = flag_set['O'] + flag_set['V'];
+        if (i == 0) {
+            retval++;
+            log_to_screen("Specify backup (-O), verify (-V) or both (-OV).\n");
+        }
+    }
+
+    if ((! bkpinfo->restore_data) && (flag_set['Z'])) {
+            fatal_error("The -Z switch is only valid in restore mode");
+    }
+
+    if (flag_set['Z']) {
+        if (! strcmp(flag_val['Z'], "nuke")) {
+            bkpinfo->restore_mode = nuke;
+        } else if (! strcmp(flag_val['Z'], "interactive")) {
+            bkpinfo->restore_mode = interactive;
+        } else if (! strcmp(flag_val['Z'], "compare")) {
+            bkpinfo->restore_mode = compare;
+        } else if (! strcmp(flag_val['Z'], "mbr")) {
+            bkpinfo->restore_mode = mbr;
+        } else if (! strcmp(flag_val['Z'], "iso")) {
+            bkpinfo->restore_mode = isoonly;
+        } else if (! strcmp(flag_val['Z'], "isonuke")) {
+            bkpinfo->restore_mode = isonuke;
+        } else {
+            bkpinfo->restore_mode = interactive;
+        }
+    }
+
+/* and finally... */
+
+    paranoid_free(tmp);
+    return (retval);
+}
+
+
+
+/**
+ * @addtogroup cliGroup
+ * @{
+ */
+/**
+ * Populate @p bkpinfo from the command-line parameters stored in @p argc and @p argv.
+ * @param argc The argument count, including the program name; @p argc passed to main().
+ * @param argv The argument vector; @p argv passed to main().
+ * @param bkpinfo The backup information structure to populate.
+ * @return The number of problems with the command line (0 for success).
+ */
+int
+handle_incoming_parameters(int argc, char *argv[])
+{
+    /*@ int *** */
+    int res = 0;
+    int retval = 0;
+    int i = 0;
+
+    /*@ buffers *************** */
+    char flag_val[128][MAX_STR_LEN];
+    bool flag_set[128];
+
+    for (i = 0; i < 128; i++) {
+        flag_val[i][0] = '\0';
+        flag_set[i] = FALSE;
+    }
+    bkpinfo->media_size = 650; /* default */
+    res = retrieve_switches_from_command_line(argc, argv, flag_val, flag_set);
+    retval += res;
+    if (!retval) {
+        res = process_switches(flag_val, flag_set);
+        retval += res;
+    }
+
+    log_msg(3, "Switches:-");
+    for (i = 0; i < 128; i++) {
+        if (flag_set[i]) {
+            log_msg(3, "-%c %s", i, flag_val[i]);
+        }
+    }
+    bkpinfo->boot_type = mr_boot_type();
+
+    return (retval);
 }
 
@@ -1058 +1062 @@
 
 
-/**
- * Turn signal-trapping on or off.
- * @param on If TRUE, turn it on; if FALSE, turn it off (we still trap it, just don't do as much).
- */
-void set_signals(int on)
-{
-    int signals[] = { SIGTERM, SIGHUP, SIGTRAP, SIGABRT, SIGINT, SIGKILL, SIGSTOP, 0 };
-    int i;
-
-    signal(SIGPIPE, sigpipe_occurred);
-    for (i = 0; signals[i]; i++) {
-        if (on) {
-            signal(signals[i], terminate_daemon);
-        } else {
-            signal(signals[i], termination_in_progress);
-        }
-    }
-}
-
-
-
 
 /**
@@ -1091 +1074 @@
 }
 
+
+
+/**
+ * Turn signal-trapping on or off.
+ * @param on If TRUE, turn it on; if FALSE, turn it off (we still trap it, just don't do as much).
+ */
+void set_signals(int on)
+{
+    int signals[] = { SIGTERM, SIGHUP, SIGTRAP, SIGABRT, SIGINT, SIGKILL, SIGSTOP, 0 };
+    int i;
+
+    signal(SIGPIPE, sigpipe_occurred);
+    for (i = 0; signals[i]; i++) {
+        if (on) {
+            signal(signals[i], terminate_daemon);
+        } else {
+            signal(signals[i], termination_in_progress);
+        }
+    }
+}
+
 /* @} - end of cliGroup */

branches/3.3/mondo/src/common/libmondo-devices.c

@@ -80 +80 @@
 
 /**
- * Retract all CD trays and wait for autorun to complete.
- * @ingroup deviceGroup
- */
-void retract_CD_tray_and_defeat_autorun(void)
-{
-//  log_it("rctada: Retracting optical tray", __LINE__);
-    if (!bkpinfo->please_dont_eject) {
-        if (bkpinfo->media_device != NULL) {
-            inject_device(bkpinfo->media_device);
-    }
-    if (!run_program_and_log_output("ps | grep autorun | grep -v grep", 5)) {
-        log_it("autorun detected; sleeping for 2 seconds");
-        sleep(2);
-    }
-}
-
-
-
-/**
- * Find out what device is mounted as root (/).
- * @return Root device.
- * @note The returned string points to storage that needs to be freed by
- * caller
- * @bug A bit of a misnomer; it's actually finding out the root device.
- * The mountpoint (where it's mounted) will obviously be '/'.
- */
-char *where_is_root_mounted(void) {
-
-/*@ buffers **************** */
-char *tmp = NULL;
-
-#ifdef __FreeBSD__
-    tmp = call_program_and_get_last_line_of_output("mount | grep \" on / \" | cut -d' ' -f1");
-#else
-    tmp = call_program_and_get_last_line_of_output("mount | grep \" on / \" | cut -d' ' -f1 | sed s/[0-9]// | sed s/[0-9]//");
-    if (strstr(tmp, "/dev/cciss/")) {
-        mr_free(tmp);
-        tmp = call_program_and_get_last_line_of_output("mount | grep \" on / \" | cut -d' ' -f1 | cut -dp -f1");
-    }
-    if (strstr(tmp, "/dev/md")) {
-        mr_free(tmp);
-        tmp = call_program_and_get_last_line_of_output("mount | grep \" on / \" | cut -d' ' -f1");
-    }
-#endif
-
-return (tmp);
-}
-
-
-
-/**
- * Determine whether we're booted off a ramdisk.
- * @return @c TRUE (we are) or @c FALSE (we aren't).
- * @ingroup utilityGroup
- */
-bool am_I_in_disaster_recovery_mode(void)
-{
-    char *tmp = NULL;
-    bool is_this_a_ramdisk = FALSE;
-
-    tmp = where_is_root_mounted();
-    log_msg(0, "root is mounted at %s", tmp);
-    log_msg(0, "That doesn't mean %s is the root partition. It's just a debugging message. Relax. It's part of am_I_in_disaster_recovery_mode().", tmp);
-
-#ifdef __FreeBSD__
-    if (strstr(tmp, "/dev/md")) {
-        is_this_a_ramdisk = TRUE;
-    }
-#else
-    if (!strncmp(tmp, "/dev/ram", 8)
-        || (!strncmp(tmp, "/dev/rd", 7) && !strcmp(tmp, "/dev/rd/")
-            && strncmp(tmp, "/dev/rd/cd", 10)) || strstr(tmp, "rootfs")
-        || !strcmp(tmp, "/dev/root")) {
-        is_this_a_ramdisk = TRUE;
-    } else {
-        is_this_a_ramdisk = FALSE;
-    }
-#endif
-    mr_free(tmp);
-
-    if (is_this_a_ramdisk) {
-        if (!does_file_exist("/THIS-IS-A-RAMDISK")) {
-            log_to_screen("Using /dev/root is stupid of you but I'll forgive you.");
-            is_this_a_ramdisk = FALSE;
-        }
-    }
-    if (does_file_exist("/THIS-IS-A-RAMDISK")) {
-        is_this_a_ramdisk = TRUE;
-    }
-
-    log_msg(1, "Is this a ramdisk? result = %s", (is_this_a_ramdisk) ? "TRUE" : "FALSE");
-    return (is_this_a_ramdisk);
-}
-
-
-
-
-
-/**
- * Turn @c bkpinfo->backup_media_type into a human-readable string.
- * @return The human readable string (e.g. @c cdr becomes <tt>"cdr"</tt>).
- * @note The returned string points to static storage that will be overwritten with each call.
- * @ingroup stringGroup
- */
-static char *bkptype_to_string(t_bkptype bt)
-{
-    static char output[MAX_STR_LEN / 4];
-    switch (bt) {
-    case none:
-        strcpy(output, "none");
-        break;
-    case iso:
-        strcpy(output, "iso");
-        break;
-    case cdr:
-        strcpy(output, "cdr");
-        break;
-    case cdstream:
-        strcpy(output, "cdstream");
-        break;
-    case netfs:
-        strcpy(output, "netfs");
-        break;
-    case tape:
-        strcpy(output, "tape");
-        break;
-    case udev:
-        strcpy(output, "udev");
-        break;
-    case usb:
-        strcpy(output, "usb");
-        break;
-    default:
-        strcpy(output, "default");
-    }
-    return (output);
-}
-
-
-
-/**
- * @addtogroup deviceGroup
- * @{
- */
-/**
- * Eject the tray of the specified CD device.
- * @param dev The device to eject.
- * @return the return value of the @c eject command. (0=success, nonzero=failure)
- */
-int eject_device(char *dev)
-{
-    char *command = NULL;
-    int res1 = 0, res2 = 0;
-
-    if (dev == NULL) {
-        return (1);
-    }
-
-    if (IS_THIS_A_STREAMING_BACKUP(g_backup_media_type)
-        && g_backup_media_type != udev) {
-        mr_asprintf(command, "mt -f %s offline", dev);
-        res1 = run_program_and_log_output(command, 1);
-        mr_free(command);
-    } else {
-        res1 = 0;
-    }
-
-#ifdef __FreeBSD__
-    if (strstr(dev, "acd")) {
-        mr_asprintf(command, "cdcontrol -f %s eject", dev);
-    } else {
-        mr_asprintf(command, "camcontrol eject `echo %s | sed 's|/dev/||'`", dev);
-    }
-#else
-    mr_asprintf(command, "eject %s", dev);
-#endif
-
-    log_msg(3, "Ejecting %s", dev);
-    res2 = run_program_and_log_output(command, 1);
-    mr_free(command);
-    if (res1 && res2) {
-        return (1);
-    } else {
-        return (0);
-    }
-}
-
-/**
- * Load (inject) the tray of the specified CD device.
- * @param dev The device to load/inject.
- * @return 0 for success, nonzero for failure.
- */
-int inject_device(char *dev)
-{
-    char *command = NULL;
-    int i;
-
-    if (dev == NULL) {
-        return (1);
-    }
-
-#ifdef __FreeBSD__
-    if (strstr(dev, "acd")) {
-        mr_asprintf(command, "cdcontrol -f %s close", dev);
-    } else {
-        mr_asprintf(command, "camcontrol load `echo %s | sed 's|/dev/||'`", dev);
-    }
-#else
-    mr_asprintf(command, "eject -t %s", dev);
-#endif
-    i = run_program_and_log_output(command, FALSE);
-    mr_free(command);
-    return (i);
-}
-
-
-/**
- * Determine whether the specified @p device (really, you can use any file)
- * exists.
- * @return TRUE if it exists, FALSE if it doesn't.
- */
-bool does_device_exist(char *device)
-{
-
-    /*@ buffers *********************************************************** */
-    char *tmp = NULL;
-    bool ret;
-
-    assert_string_is_neither_NULL_nor_zerolength(device);
-
-    mr_asprintf(tmp, "ls %s > /dev/null 2> /dev/null", device);
-
-    if (system(tmp)) {
-        ret = FALSE;
-    } else {
-        ret = TRUE;
-    }
-    mr_free(tmp);
-    return (ret);
-}
-
-
-/**
- * Determine whether a non-Microsoft partition exists on any connected hard drive.
- * @return TRUE (there's a Linux/FreeBSD partition) or FALSE (Microsoft has taken over yet another innocent machine).
- */
-bool does_nonMS_partition_exist(void)
-{
-#if __FreeBSD__
-    return
-        !system("for drive in /dev/ad? /dev/da?; do fdisk $drive | grep -q FreeBSD && exit 0; done; false");
-#else
-    return
-        !system("mr-parted2fdisk -l 2>/dev/null | grep '^/dev/' | grep -Eqv '(MS|DOS|EFI|FAT|NTFS)'");
-#endif
-}
-
-/**
- * Determine whether the specified @p partno exists on the specified @p drive.
- * @param drive The drive to search for the partition in.
- * @param partno The partition number to look for.
- * @return 0 if it exists, nonzero otherwise.
- */
-int does_partition_exist(const char *drive, int partno)
-{
-    /*@ buffers **************************************************** */
-    char *program = NULL;
-    char *incoming = NULL;
-    char *searchstr = NULL;
-
-    /*@ ints ******************************************************* */
-    int res = 0;
-
-    /*@ pointers *************************************************** */
-    FILE *fin;
-
-    /*@ end vars *************************************************** */
-    assert_string_is_neither_NULL_nor_zerolength(drive);
-    assert(partno >= 0 && partno < 999);
-
-#ifdef __FreeBSD__
-    // We assume here that this is running from mondorestore. (It is.)
-    tmp = build_partition_name(drive, partno);
-    mr_asprintf(program, "ls %s %s >/dev/null 2>&1", drive, tmp);
-    mr_free(tmp);
-    res = system(program);
-    mr_free(program);
-    return(res);
-#endif
-
-    mr_asprintf(program, "mr-parted2fdisk -l %s 2> /dev/null", drive);
-    fin = popen(program, "r");
-    if (!fin) {
-        log_it("program=%s", program);
-        log_OS_error("Cannot popen-in program");
-        mr_free(program);
-        return (0);
-    }
-    mr_free(program);
-
-    searchstr = build_partition_name(drive, partno);
-    mr_strcat(searchstr, " ");
-    for (res = 0, mr_getline(incoming, fin); !res && !feof(fin) ; mr_getline(incoming, fin)) {
-        if (strstr(incoming, searchstr)) {
-            res = 1;
-        }
-        mr_free(incoming);
-    }
-    mr_free(searchstr);
-    mr_free(incoming);
-
-    if (pclose(fin)) {
-        log_OS_error("Cannot pclose fin");
-    }
-    return (res);
-}
-
-
-
-
-
-/**
- * Determine whether given NULL-terminated @p str exists in the begining of @p dev.
- * @param dev The device to look in.
- * @param str The string to look for.
- * @return TRUE if it exists, FALSE if it doesn't.
- */
-bool does_string_exist_in_boot_block(char *dev, char *str)
-{
-    /*@ buffers **************************************************** */
-    char *command = NULL;
-
-    /*@ end vars *************************************************** */
-    int i;
-
-    assert_string_is_neither_NULL_nor_zerolength(dev);
-    assert_string_is_neither_NULL_nor_zerolength(str);
-
-    /* For UEFI detection, this should be extended to count=1000 ! */
-    if (bkpinfo->boot_type == UEFI) {
-        mr_asprintf(command, "dd if=%s bs=446 count=1000 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null", dev, str);
-    } else {
-        mr_asprintf(command, "dd if=%s bs=446 count=1 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null", dev, str);
-    }
-    i = system(command);
-    mr_free(command);
-    if (i) {
-        return (FALSE);
-    } else {
-        return (TRUE);
-    }
-}
-
-/**
- * Determine whether specified @p str exists in the first @p n sectors of
- * @p dev.
- * @param dev The device to look in.
- * @param str The string to look for.
- * @param n The number of 512-byte sectors to search.
- */
-bool does_string_exist_in_first_N_blocks(char *dev, char *str, int n)
-{
-    /*@ buffers **************************************************** */
-    char *command = NULL;
-    /*@ end vars *************************************************** */
-    int i;
-
-    mr_asprintf(command, "dd if=%s bs=512 count=%i 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null", dev, n, str);
-    i = system(command);
-    mr_free(command);
-    if (i) {
-        return (FALSE);
-    } else {
-        return (TRUE);
-    }
-}
-
-
-/* 
- * This function tries to find an optical media device
- * and return it's device file to the caller that needs to free it
- */
-char *find_optical_device(void) {
-    char *dev = NULL;
-    char *tmp1 = NULL;
-    char *command = NULL;
-
-    log_to_screen("I am looking for your optical burner. Please wait.");
-
-    if (bkpinfo->media_device != NULL) {
-        log_msg(3, "Been there, done that. Returning %s", bkpinfo->media_device);
-        return (bkpinfo->media_device);
-    }
-
-    mr_asprintf(tmp1, "cdrecord -inq 2> /dev/null | grep -E '^Detected '  | cut -d':' -f2");
-    dev = call_program_and_get_last_line_of_output(tmp1);
-    mr_free(tmp1);
-
-    if ((dev != NULL) && does_file_exist(dev)) {
-        log_msg(2, "find_optical_device found %s automatically", dev);
-    } else {
-        mr_free(dev);
-        tmp1 = find_home_of_exe("lsscsi");
-        if (tmp1 != NULL) {
-            mr_asprintf(command, "%s | grep ' cd' | awk '{print $NF}' | head -1", tmp1);
-            dev = call_program_and_get_last_line_of_output(command);
-            mr_free(command);
-        }
-        mr_free(tmp1);
-
-        if ((dev == NULL) || !does_file_exist(dev)) {
-            /* trying something else then */
-            mr_asprintf(dev, "%s", VANILLA_SCSI_CDROM);
-            if (!does_file_exist(dev)) {
-                mr_asprintf(dev, "%s", ALT_CDROM);
-                if (!does_file_exist(dev)) {
-                    mr_asprintf(dev, "%s", "/dev/cdrom");
-                    if (!does_file_exist(dev)) {
-                        mr_asprintf(dev, "%s", "/dev/dvd");
-                        if (!does_file_exist(dev)) {
-                            log_it("Unable to find a tape device on this system");
-                        }
-                    }
-                }
-            }
-        }
-        if (dev != NULL) {
-            log_it("find_optical_device found %s manually", dev);
-        }
-    } 
-
-    if ((dev != NULL) && does_file_exist(dev)) {
-        log_it("find_optical_device returns %s", dev);
-    } else {
-        mr_free(dev);
-        log_it("find_optical_device found no optical burner on your system returning NULL");
-    }
-    return(dev);
-}
-/**
-* Mount the CD-ROM or USB device at /mnt/cdrom.
-* @param bkpinfo The backup information structure. Fields used: 
-* - @c bkpinfo->backup_media_type
-* - @c bkpinfo->disaster_recovery
-* - @c bkpinfo->isodir
-* - @c bkpinfo->media_device
-* @return TRUE for success, FALSE for failure.
-*/
-bool mount_media(const char *mountpoint) {
-
-    char *mount_cmd = NULL;
-    char *mountdir = NULL;
-    char *tmp = NULL;
-    int i = 0, res = 0;
-#ifdef __FreeBSD__
-    char mdd[32];
-    char *mddev = mdd;
-    char *dev;
-#endif
-
-    if (bkpinfo->backup_media_type == tape || bkpinfo->backup_media_type == udev) {
-        log_msg(8, "Tape/udev. Therefore, no need to mount a media.");
-        return(TRUE);
-    }
-
-    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
-
-    mr_asprintf(tmp, "mount | grep -F %s", mountpoint);
-    if (!run_program_and_log_output(tmp, FALSE)) {
-        log_msg(2, "mount_media() - media already mounted. Fair enough.");
-        mr_free(tmp);
-        return (TRUE);
-    }
-    mr_free(tmp);
-
-    make_hole_for_dir(mountpoint);
-
-    if (bkpinfo->backup_media_type == netfs) {
-        log_msg(2, "Mounting for Network thingy");
-        log_msg(2, "isodir = %s", bkpinfo->isodir);
-        if (((bkpinfo->isodir == NULL) || !strcmp(bkpinfo->isodir, "/")) && am_I_in_disaster_recovery_mode()) {
-            mr_asprintf(bkpinfo->isodir, "%s", "/tmp/isodir");
-            log_msg(1, "isodir is being set to %s", bkpinfo->isodir);
-        }
-#ifdef __FreeBSD__
-        if (bkpinfo->netfs_remote_dir != NULL) {
-            // NETFS
-            mr_asprintf(mount_cmd, "/mnt/isodir/%s/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix, g_current_media_number);
-        } else {
-            // ISO
-            mr_asprintf(mount_cmd, "/mnt/isodir/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->prefix, g_current_media_number);
-        }
-        mddev = make_vn(mount_cmd);
-        mr_free(mount_cmd);
-
-        mr_asprintf(mount_cmd, "mount_cd9660 -r %s %s", mddev, mountpoint);
-#else
-        if (bkpinfo->netfs_remote_dir != NULL) {
-            // NETFS
-            mr_asprintf(mount_cmd, "mount %s/%s/%s-%d.iso -t iso9660 -o loop,ro %s", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix, g_current_media_number, mountpoint);
-        } else {
-            // ISO
-            mr_asprintf(mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s", bkpinfo->isodir, bkpinfo->prefix, g_current_media_number, mountpoint);
-        }
-#endif
-
-    } else if (bkpinfo->backup_media_type == iso) {
-        if (bkpinfo->subdir) {
-            mr_asprintf(mountdir, "%s/%s", bkpinfo->isodir, bkpinfo->subdir);
-        } else {
-            mr_asprintf(mountdir, "%s", bkpinfo->isodir);
-        }
-#ifdef __FreeBSD__
-        mr_asprintf(mount_cmd, "%s/%s-%d.iso", mountdir, bkpinfo->prefix, g_current_media_number);
-        mddev = make_vn(mount_cmd);
-        mr_free(mount_cmd);
-
-        mr_asprintf(mount_cmd, "mount_cd9660 -r %s %s", mddev, mountpoint);
-#else
-        mr_asprintf(mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s", mountdir, bkpinfo->prefix, g_current_media_number, mountpoint);
-#endif
-        mr_free(mountdir);
-    } else if (bkpinfo->backup_media_type == usb) {
-        mr_asprintf(mount_cmd, "mount -t vfat %s %s", bkpinfo->media_device, mountpoint);
-    } else {    //  optical
-        if (bkpinfo->disaster_recovery
-            && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
-            mr_asprintf(bkpinfo->media_device, "%s", last_line_of_file("/tmp/CDROM-LIVES-HERE"));
-        } else {
-            if (bkpinfo->media_device == NULL) {
-                bkpinfo->media_device = find_optical_device();
-            }
-        }
-
-#ifdef __FreeBSD__
-        if (g_ISO_restore_mode) {
-            mr_asprintf(dev, "%s", make_vn(bkpinfo->media_device));
-            if (!dev) {
-                mr_asprintf(command, "Unable to mount ISO (make_vn(%s) failed)", bkpinfo->media_device);
-                fatal_error(command);
-            }
-            mr_free(bkpinfo->media_device);
-            bkpinfo->media_device = dev
-        }
-
-        mr_asprintf(mount_cmd, "mount_cd9660 -r %s %s 2>> %s", bkpinfo->media_device, mountpoint, MONDO_LOGFILE);
-#else
-        mr_asprintf(mount_cmd, "mount %s -o loop,ro -t iso9660 %s 2>> %s", bkpinfo->media_device, mountpoint, MONDO_LOGFILE);
-#endif
-        log_msg(2, "(mount_media) --- command = %s", mount_cmd);
-        // usefull ??
-        if (strncmp(bkpinfo->media_device, "/dev/", 5) == 0) {
-            retract_CD_tray_and_defeat_autorun();
-        }
-    }
-
-    for (i = 0; i < 2; i++) {
-        res = run_program_and_log_output(mount_cmd, FALSE);
-        if (!res) {
-            break;
-        } else {
-            log_msg(2, "Failed to mount device.");
-            sleep(5);
-            sync();
-        }
-    }
-    mr_free(mount_cmd);
-
-    if (res) {
-        log_msg(2, "Failed, despite %d attempts", i);
-        return(FALSE);
-    } else {
-        log_msg(2, "Mounted media drive OK");
-        return(TRUE);
-    }
-}
-/**************************************************************************
-*END_MOUNT_MEDIA                                                         *
-**************************************************************************/
-
-
-
-
-/**
- * Try to mount CD/DVD at @p mountpoint. If the CD/DVD is not found or has
- * not been specified, call find_optical_device() to find it.
- * @param mountpoint Where to mount the CD-ROM.
- * @return TRUE for success, FALSE for failure.
- * @see mount_media
- */
-bool find_and_mount_actual_cd(char *mountpoint) {
-
-    /*@ buffers ***************************************************** */
-
-    /*@ int's  ****************************************************** */
-    bool res;
-
-    /*@ end vars **************************************************** */
-
-    assert(bkpinfo != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
-
-    if (bkpinfo->media_device == NULL) {
-        bkpinfo->media_device = find_optical_device();
-    }
-
-    if (bkpinfo->backup_media_type != iso) {
-        retract_CD_tray_and_defeat_autorun();
-    }
-
-    if ((bkpinfo->media_device == NULL) || (res = mount_media(mountpoint))) {
-        mr_free(bkpinfo->media_device);
-        if ((bkpinfo->media_device = mr_popup_and_get_string("CD-ROM device", "Please enter your CD-ROM's /dev device", "/dev/cdrom")) == NULL) {
-            res = TRUE;
-        } else {
-            res = mount_media(mountpoint);
-        }
-    }
-    if (res) {
-        log_msg(1, "mount failed");
-    } else {
-        log_msg(1, "mount succeeded with %s", bkpinfo->media_device);
-    }
-    return (res);
-}
-/* 
- * This function tries to find a USB media device
- * and return it's device file to the caller that needs to free it
- */
-char *find_usb_device(void)
-{
-    char *dev = NULL;
-    char *tmp1 = NULL;
-    char *command = NULL;
-
-    log_to_screen("I am looking for your USB key. Please wait.");
-
-    if (bkpinfo->media_device != NULL) {
-        log_msg(3, "Been there, done that. Returning %s", bkpinfo->media_device);
-        return (bkpinfo->media_device);
-    }
-
-    tmp1 = find_home_of_exe("lsscsi");
-    if (tmp1 != NULL) {
-        mr_asprintf(command, "%s | grep ' disk' | grep USB | awk '{print $NF}' | head -1", tmp1);
-        dev = call_program_and_get_last_line_of_output(command);
-        mr_free(command);
-    }
-    mr_free(tmp1);
-
-    if ((dev == NULL) || !does_file_exist(dev)) {
-        tmp1 = find_home_of_exe("lsblk");
-        if (tmp1 != NULL) {
-            mr_asprintf(command, "%s --noheadings --raw --output rm,tran,type,path --sort path | awk '/^1 usb disk/ {d=$4} END {print d}'", tmp1);
-            dev = call_program_and_get_last_line_of_output(command);
-            mr_free(command);
-        }
-        mr_free(tmp1);
-        log_it("Unable to find a tape device on this system");
-    }
-    if (dev != NULL) {
-        log_it("find_usb_device found %s manually", dev);
-    }
-
-    if ((dev != NULL) && does_file_exist(dev)) {
-        log_it("find_usb_device returns %s", dev);
-    } else {
-        mr_free(dev);
-        log_it("find_usb_device found no USB key on your system returning NULL");
-    }
-    return(dev);
-}
-
-
-
-/* Generic fund to find a media 
- * Return a dynamically allocted string that caller needs to free 
- * @media_type is the type of media to look for
- */
-
-char *find_device(t_bkptype media_type) {
-
-    if (media_type == usb) {
-        return(find_usb_device());
-    } else if (media_type == tape) {
-        return(find_tape_device());
-    } else if ((media_type == dvd) || (media_type == cdr)) {
-        return(find_optical_device());
-    } else {
-        return(NULL);
-    }
-}
-
-
-
-
-#include <sys/ioctl.h>
-
-/**
- * Find the size of the specified @p drive, in megabytes. Uses @c ioctl calls
- * and @c dmesg.
- * @param drive The device to find the size of.
- * @return size in megabytes.
- */
-long get_phys_size_of_drive(char *drive)
-{
-    int fd;
-#if linux
-    unsigned long long s = 0;
-    int fileid, cylinders = 0;
-    int cylindersize = 0;
-    int gotgeo = 0;
-
-
-    struct hd_geometry hdgeo;
-#elif __FreeBSD__
-    off_t s;
-#endif
-
-    long outvalA = -1;
-    long outvalB = -1;
-    long outvalC = -1;
-
-    if ((fd = open(drive, O_RDONLY)) != -1) {
-        if (ioctl(fd,
-#if linux
-#ifdef BLKGETSIZE64
-                  BLKGETSIZE64,
-#else
-                  BLKGETSIZE,
-#endif
-#elif __FreeBSD__
-                  DIOCGMEDIASIZE,
-#endif
-                  &s) != -1) {
-            close(fd);
-            // s>>11 works for older disks but not for newer ones
-            outvalB =
-#if linux
-#ifdef BLKGETSIZE64
-                s >> 20
-#else
-                s >> 11
-#endif
-#else
-                s >> 20
-#endif
-                ;
-        }
-    }
-
-    if (outvalB <= 0) {
-        log_msg(1, "Error getting size of %s: %s", drive, strerror(errno));
-#if linux
-        fileid = open(drive, O_RDONLY);
-        if (fileid != -1) {
-            if (ioctl(fileid, HDIO_GETGEO, &hdgeo) != -1) {
-                if (hdgeo.cylinders && hdgeo.heads && hdgeo.sectors) {
-                    cylindersize = hdgeo.heads * hdgeo.sectors / 2;
-                    outvalA = cylindersize * cylinders / 1024;
-                    log_msg(2, "Got Harddisk geometry, C:%d, H:%d, S:%d",
-                            hdgeo.cylinders, hdgeo.heads, hdgeo.sectors);
-                    gotgeo = 1;
-                } else {
-                    log_msg(1, "Harddisk geometry wrong");
-                }
-            } else {
-                log_msg(1,
-                        "Error in ioctl() getting new hard disk geometry (%s), resizing in unsafe mode",
-                        strerror(errno));
-            }
-            close(fileid);
-        } else {
-            log_msg(1, "Failed to open %s for reading: %s", drive,
-                    strerror(errno));
-        }
-        if (!gotgeo) {
-            log_msg(1, "Failed to get harddisk geometry, using old mode");
-        }
-#endif
-    }
-// OLDER DISKS will give ridiculously low value for outvalB (so outvalA is returned) :)
-// NEWER DISKS will give sane value for outvalB (close to outvalA, in other words) :)
-
-    outvalC = (outvalA > outvalB) ? outvalA : outvalB;
-
-//  log_msg (5, "drive = %s, error = %s", drive, strerror (errno));
-//  fatal_error ("GPSOD: Unable to get size of drive");
-    log_msg(1, "%s --> %ld or %ld --> %ld", drive, outvalA, outvalB,
-            outvalC);
-
-    return (outvalC);
-}
-
-/**
- * Determine whether @p format is supported by the kernel. Uses /proc/filesystems
- * under Linux and @c lsvfs under FreeBSD.
- * @param format The format to test.
- * @return TRUE if the format is supported, FALSE if not.
- */
-bool is_this_a_valid_disk_format(char *format)
-{
-    char *good_formats = NULL;
-    char *command = NULL;
-    char *format_sz = NULL;
-    char *p = NULL;
-
-    FILE *pin;
-    int retval;
-
-    assert_string_is_neither_NULL_nor_zerolength(format);
-
-    mr_asprintf(format_sz, "%s ", format);
-
-#ifdef __FreeBSD__
-    mr_asprintf(command, "lsvfs | tr -s '\t' ' ' | grep -v Filesys | grep -v -- -- | cut -d' ' -f1 | tr -s '\n' ' '");
-#else
-    mr_asprintf(command, "grep -v nodev /proc/filesystems | tr -s '\t' ' ' | cut -d' ' -f2 | tr -s '\n' ' '");
-#endif
-
-    pin = popen(command, "r");
-    mr_free(command);
-
-    if (!pin) {
-        log_OS_error("Unable to read good formats");
-        retval = 0;
-    } else {
-        mr_getline(p, pin);
-        good_formats = mr_strip_spaces(p);
-        mr_free(p);
-        (void)pclose(pin);
-        mr_strcat(good_formats, " swap lvm raid ntfs-3g ntfs 7 ");  // " ntfs 7 " -- um, cheating much? :)
-        if (strstr(good_formats, format_sz)) {
-            retval = 1;
-        } else {
-            retval = 0;
-        }
-    }
-    mr_free(good_formats);
-    mr_free(format_sz);
-
-    return (retval);
-}
-
-
-/** @def SWAPLIST_COMMAND The command to list the swap files/partitions in use. */
-
-/**
- * Determine whether @p device_raw is currently mounted.
- * @param device_raw The device to check.
- * @return TRUE if it's mounted, FALSE if not.
- */
-bool is_this_device_mounted(char *device_raw)
-{
-
-    char *tmp = NULL;
-    bool retval = FALSE;
-
-    mr_asprintf(tmp, "mr-device-mounted %s > /dev/null", device_raw);
-    if (system(tmp) == 0) {
-        retval = TRUE;
-    }
-    mr_free(tmp);
-    return(retval);
-}
-
-/* previous C version replaced by a call to a perl script, fixing issues with symlinks between devices - RHEL7 e.g.
-    FILE *fin;
-
-    char *incoming = NULL;
-    char *device_with_tab = NULL;
-    char *device_with_space = NULL;
-    char *tmp = NULL;
-    bool retval = FALSE;
-
-#ifdef __FreeBSD__
-#define SWAPLIST_COMMAND "swapinfo"
-#else
-#define SWAPLIST_COMMAND "cat /proc/swaps"
-#endif
-
-
-    if (device_raw == NULL) {
-        return(FALSE);
-    }
-
-    if (device_raw[0] != '/' && !strstr(device_raw, ":/")) {
-        log_msg(1, "%s needs to have a '/' prefixed - I'll do it", device_raw);
-        mr_asprintf(tmp, "/%s", device_raw);
-    } else {
-        mr_asprintf(tmp, "%s", device_raw);
-    }
-    log_msg(1, "Is %s mounted?", tmp);
-    if (!strcmp(tmp, "/proc") || !strcmp(tmp, "proc")) {
-        log_msg(1, "I don't know how the heck /proc made it into the mountlist. I'll ignore it.");
-        mr_free(tmp);
-        return(FALSE);
-    }
-    mr_asprintf(device_with_tab, "%s\t", tmp);
-    mr_asprintf(device_with_space, "%s ", tmp);
-    mr_free(tmp);
-
-    if (!(fin = popen("mount", "r"))) {
-        log_OS_error("Cannot popen 'mount'");
-        return(FALSE);
-    }
-
-    for (mr_getline(incoming, fin); !feof(fin); mr_getline(incoming, fin)) {
-        if (strstr(incoming, device_with_space) || strstr(incoming, device_with_tab)) {
-            paranoid_pclose(fin);
-            mr_free(incoming);
-            return(TRUE);
-        }
-        mr_free(incoming);
-    }
-    mr_free(incoming);
-    mr_free(device_with_tab);
-    paranoid_pclose(fin);
-
-    mr_asprintf(tmp, "%s | grep -E \"^%s\" > /dev/null 2> /dev/null", SWAPLIST_COMMAND, device_with_space);
-    mr_free(device_with_space);
-    log_msg(4, "tmp (command) = '%s'", tmp);
-    if (!system(tmp)) {
-        retval = TRUE;
-    }
-    mr_free(tmp);
-    return(retval);
-}
-*/
-
-#ifdef __FreeBSD__
-//                       CODE IS FREEBSD-SPECIFIC
-/**
- * Create a loopback device for specified @p fname.
- * @param fname The file to associate with a device.
- * @return /dev entry for the device, or NULL if it couldn't be allocated.
- */
-char *make_vn(char *fname)
-{
-    char *device = (char *) malloc(MAX_STR_LEN);
-    char *mddevice = NULL;
-    char *command = NULL;
-    char *tmp = NULL;
-    int vndev = 2;
-
-    tmp = call_program_and_get_last_line_of_output("/sbin/sysctl -n kern.osreldate");
-    if (atoi(tmp) < 500000) {
-        do {
-            mr_asprintf(mddevice, "vn%ic", vndev++);
-            mr_free(command);
-            mr_asprintf(command, "vnconfig %s %s", mddevice, fname);
-            if (vndev > 10) {
-                mr_free(tmp);
-                mr_free(mddevice);
-                mr_free(command);
-                return NULL;
-            }
-        }
-        while (system(command));
-    } else {
-        mr_asprintf(command, "mdconfig -a -t vnode -f %s", fname);
-        mddevice = call_program_and_get_last_line_of_output(command);
-        if (!strstr(mddevice, "md")) {
-            mr_free(tmp);
-            mr_free(command);
-            mr_free(mddevice);
-            return NULL;
-        }
-    }
-    mr_free(tmp);
-    mr_free(command);
-    sprintf(device, "/dev/%s", mddevice);
-    mr_free(mddevice);
-    return device;
-}
-
-
-
-//                       CODE IS FREEBSD-SPECIFIC
-/**
- * Deallocate specified @p dname.
- * This should be called when you are done with the device created by make_vn(),
- * so the system does not run out of @c vn devices.
- * @param dname The device to deallocate.
- * @return 0 for success, nonzero for failure.
- */
-int kick_vn(char *dname)
-{
-    char *command = NULL;
-    char *tmp = NULL;
-    int res = 0;
-
-    if (strncmp(dname, "/dev/", 5) == 0) {
-        dname += 5;
-    }
-
-    tmp = call_program_and_get_last_line_of_output("/sbin/sysctl -n kern.osreldate");
-    if (atoi(tmp) < 500000) {
-        mr_asprintf(command, "vnconfig -d %s", dname);
-    } else {
-        mr_asprintf(command, "mdconfig -d -u %s", dname);
-    }
-    mr_free(tmp);
-    res = system(command);
-    mr_free(command);
-    return(res);
-}
-#endif
-
-
-/**
- * Mount the CD-ROM at @p mountpoint.
- * @param device The device (or file if g_ISO_restore_mode) to mount.
- * @param mountpoint The place to mount it.
- * @return 0 for success, nonzero for failure.
- */
-int mount_USB_here(char *device, char *mountpoint)
-{
-    /*@ buffer ****************************************************** */
-    char *command = NULL;
-    int retval;
-
-    assert_string_is_neither_NULL_nor_zerolength(device);
-    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
-
-    make_hole_for_dir(mountpoint);
-    if (isdigit(device[0])) {
-        return(1);
-    }
-    log_msg(4, "(mount_USB_here --- device=%s, mountpoint=%s", device, mountpoint);
-
-#ifdef __FreeBSD__
-    mr_asprintf(command, "mount_vfat %s %s 2>> %s", device, mountpoint, MONDO_LOGFILE);
-
-#else
-    mr_asprintf(command, "mount %s -t vfat %s 2>> %s", device, mountpoint, MONDO_LOGFILE);
-#endif
-
-    log_msg(4, command);
-    retval = system(command);
-    log_msg(1, "system(%s) returned %d", command, retval);
-    mr_free(command);
-
-    return (retval);
-}
-
-/**
- * Find out what number CD is in the drive.
- * @param bkpinfo The backup information structure. The @c bkpinfo->media_device field is the only one used.
- * @return The current CD number, or -1 if it could not be found.
- * @note If the CD is not mounted, it will be mounted
- * (and remain mounted after this function returns).
- */
-int what_number_cd_is_this(void) {
-
-    int cd_number = -1;
-    char *mountdev = NULL;
-    char *tmp = NULL;
-
-    assert(bkpinfo != NULL);
-//  log_it("Asking what_number_cd_is_this");
-    if ((g_ISO_restore_mode) || (g_restoring_live_from_cd)) {
-        tmp = call_program_and_get_last_line_of_output("mount | grep iso9660 | awk '{print $3;}'");
-        mr_asprintf(mountdev, "%s%s", tmp, "/archives/THIS-CD-NUMBER");
-        mr_free(tmp);
-        cd_number = atoi(last_line_of_file(mountdev));
-        mr_free(mountdev);
-        return (cd_number);
-    }
-
-    if ((bkpinfo->media_device == NULL) || !does_file_exist(bkpinfo->media_device)) {
-        log_it("ERROR: bkpinfo->media_device shoulnd't be unaccessible here\n");
-        /* trying again ! */
-        bkpinfo->media_device = find_optical_device();
-    }
-    if ((bkpinfo->media_device == NULL) || !does_file_exist(bkpinfo->media_device)) {
-        fatal_error("ERROR: bkpinfo->media_device shoulnd't really be unaccessible here\n");
-    }
-    if (!is_this_device_mounted(MNT_CDROM)) {
-        mount_media(MNT_CDROM);
-    }
-
-    cd_number = atoi(last_line_of_file(MNT_CDROM "/archives/THIS-CD-NUMBER"));
-    return(cd_number);
-}
-
-
-
-
-/**
- * Ask the user for CD number @p cd_number_i_want.
- * Sets g_current_media_number once the correct CD is inserted.
- * @param bkpinfo The backup information structure. Fields used:
- * - @c bkpinfo->backup_media_type
- * - @c bkpinfo->prefix
- * - @c bkpinfo->isodir
- * - @c bkpinfo->media_device
- * - @c bkpinfo->please_dont_eject_when_restoring
- * @param cd_number_i_want The CD number to ask for.
- */
-void
-insist_on_this_cd_number(int cd_number_i_want)
-{
-
-    /*@ int ************************************************************* */
-    int res = 0;
-
-
-    /*@ buffers ********************************************************* */
-    char *tmp = NULL;
-    char *mds = NULL;
-    char *request = NULL;
-
-    assert(bkpinfo != NULL);
-    assert(cd_number_i_want > 0);
-
-//  log_msg(3, "Insisting on CD number %d", cd_number_i_want);
-
-    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
-        log_msg(3,
-                "No need to insist_on_this_cd_number when the backup type isn't CD-R(W) or NFS or ISO");
-        return;
-    }
-    if (!does_file_exist(MNT_CDROM)) {
-        mr_asprintf(tmp, "mkdir -p " MNT_CDROM);
-        run_program_and_log_output(tmp, 5);
-        mr_free(tmp);
-    }
-
-    if (g_ISO_restore_mode || bkpinfo->backup_media_type == iso || bkpinfo->backup_media_type == netfs) {
-        g_ISO_restore_mode = TRUE;
-    }
-    if ((res = what_number_cd_is_this()) != cd_number_i_want) {
-        log_msg(3, "Currently, we hold %d but we want %d", res, cd_number_i_want);
-
-        /* Now we need to umount the current media to have the next mounted after */
-        run_program_and_log_output("umount -d " MNT_CDROM, FALSE);
-        log_msg(3, "Mounting next media %d",cd_number_i_want);
-        g_current_media_number = cd_number_i_want;
-        mount_media(MNT_CDROM);
-
-        mds = media_descriptor_string(bkpinfo->backup_media_type);
-        log_msg(3, "Insisting on %s #%d", mds, cd_number_i_want);
-        mr_asprintf(request, "Please insert %s #%d and press Enter.", mds, cd_number_i_want);
-        mr_free(mds);
-
-        while (what_number_cd_is_this() != cd_number_i_want) {
-            sync();
-            if (is_this_device_mounted(MNT_CDROM)) {
-                res =
-                    run_program_and_log_output("umount -d " MNT_CDROM, FALSE);
-            } else {
-                res = 0;
-            }
-            if (res) {
-                log_to_screen("WARNING - failed to unmount CD-ROM drive");
-            }
-            if (!bkpinfo->please_dont_eject) {
-                res = eject_device(bkpinfo->media_device);
-            } else {
-                res = 0;
-            }
-            if (res) {
-                log_to_screen("WARNING - failed to eject CD-ROM disk");
-            }
-            popup_and_OK(request);
-            if (!bkpinfo->please_dont_eject) {
-                inject_device(bkpinfo->media_device);
-            }
-            sync();
-        }
-        mr_free(request);
-
-        log_msg(1, "Thankyou. Proceeding...");
-        g_current_media_number = cd_number_i_want;
-    }
-}
-
-/* @} - end of deviceGroup */
-
-
-
-/**
- * Creates a singly linked list of all of the non-NETFS mounted file systems.
- * @param DSFptr A pointer  to the structure MOUNTED_FS_STRUCT used to hold 
- * the list of mounted file systems. 
- * @return None. 
- */
-static void add_mounted_fs_struct (MOUNTED_FS_STRUCT *DSFptr)
-{
-    assert (DSFptr);
-    if (DSF_Head == NULL) {
-        DSF_Head = DSFptr;
-    } else {
-        DSF_Tail->next = DSFptr;
-    }
-    DSFptr->next = NULL;
-    DSF_Tail = DSFptr;
-}
-
-/**
- * Find the structure, in the singly linked list of all of the non-NETFS 
- * mounted file systems, that contains the specified device.
- * @param device The device to find 
- * @return NULL if it didn't find the device, a pointer to the
- * structure if it did. 
- */
-static MOUNTED_FS_STRUCT *find_device_in_list (char *device)
-{
-    MOUNTED_FS_STRUCT *DSFptr = NULL;
-
-    DSFptr = DSF_Head;
-    while (DSFptr != NULL) {
-        if (!strcmp(DSFptr->device, device)) {
-            break;
-        }
-        DSFptr = DSFptr->next;
-    }
-    return (DSFptr);
-}
-
-/**
- * Find the structure, in the singly linked list of all of the non-NETFS 
- * mounted file systems, that contains the specified mount point.
- * @param mount_point The mount point to find 
- * @return NULL is it didn't find the mount point, a pointer to the
- * structure if it did. 
- */
-static MOUNTED_FS_STRUCT *find_mount_point_in_list (char *mount_point)
-{
-    MOUNTED_FS_STRUCT *DSFptr = NULL;
-
-    DSFptr = DSF_Head;
-    while (DSFptr != NULL) {
-        if (!strcmp(DSFptr->mount_point, mount_point)) {
-            break;
-        }
-        DSFptr = DSFptr->next;
-    }
-    return (DSFptr);
-}
-
-/**
  * Frees the memory for all of the structures on the linked list of 
  * all of the non-NETFS mounted file systems.
@@ -1339 +96 @@
     DSF_Tail = NULL;
 }
+
+
+/**
+ * Creates a singly linked list of all of the non-NETFS mounted file systems.
+ * @param DSFptr A pointer  to the structure MOUNTED_FS_STRUCT used to hold 
+ * the list of mounted file systems. 
+ * @return None. 
+ */
+static void add_mounted_fs_struct (MOUNTED_FS_STRUCT *DSFptr)
+{
+    assert (DSFptr);
+    if (DSF_Head == NULL) {
+        DSF_Head = DSFptr;
+    } else {
+        DSF_Tail->next = DSFptr;
+    }
+    DSFptr->next = NULL;
+    DSF_Tail = DSFptr;
+}
+
 
 
@@ -1415 +192 @@
 }
 
+/**
+ * Find the structure, in the singly linked list of all of the non-NETFS 
+ * mounted file systems, that contains the specified mount point.
+ * @param mount_point The mount point to find 
+ * @return NULL is it didn't find the mount point, a pointer to the
+ * structure if it did. 
+ */
+static MOUNTED_FS_STRUCT *find_mount_point_in_list (char *mount_point)
+{
+    MOUNTED_FS_STRUCT *DSFptr = NULL;
+
+    DSFptr = DSF_Head;
+    while (DSFptr != NULL) {
+        if (!strcmp(DSFptr->mount_point, mount_point)) {
+            break;
+        }
+        DSFptr = DSFptr->next;
+    }
+    return (DSFptr);
+}
+
+
+/**
+ * Find the structure, in the singly linked list of all of the non-NETFS 
+ * mounted file systems, that contains the specified device.
+ * @param device The device to find 
+ * @return NULL if it didn't find the device, a pointer to the
+ * structure if it did. 
+ */
+static MOUNTED_FS_STRUCT *find_device_in_list(char *device) {
+    MOUNTED_FS_STRUCT *DSFptr = NULL;
+
+    DSFptr = DSF_Head;
+    while (DSFptr != NULL) {
+        if (!strcmp(DSFptr->device, device)) {
+            break;
+        }
+        DSFptr = DSFptr->next;
+    }
+    return (DSFptr);
+}
 
 
@@ -1749 +567 @@
 
 
+/**
+ * Load (inject) the tray of the specified CD device.
+ * @param dev The device to load/inject.
+ * @return 0 for success, nonzero for failure.
+ */
+int inject_device(char *dev)
+{
+    char *command = NULL;
+    int i;
+
+    if (dev == NULL) {
+        return (1);
+    }
+
+#ifdef __FreeBSD__
+    if (strstr(dev, "acd")) {
+        mr_asprintf(command, "cdcontrol -f %s close", dev);
+    } else {
+        mr_asprintf(command, "camcontrol load `echo %s | sed 's|/dev/||'`", dev);
+    }
+#else
+    mr_asprintf(command, "eject -t %s", dev);
+#endif
+    i = run_program_and_log_output(command, FALSE);
+    mr_free(command);
+    return (i);
+}
+
+
+/**
+ * Retract all CD trays and wait for autorun to complete.
+ * @ingroup deviceGroup
+ */
+void retract_CD_tray_and_defeat_autorun(void)
+{
+//  log_it("rctada: Retracting optical tray", __LINE__);
+    if (!bkpinfo->please_dont_eject) {
+        if (bkpinfo->media_device != NULL) {
+            inject_device(bkpinfo->media_device);
+        }
+    }
+    if (!run_program_and_log_output("ps | grep autorun | grep -v grep", 5)) {
+        log_it("autorun detected; sleeping for 2 seconds");
+        sleep(2);
+    }
+}
+
+
+
+/**
+ * Find out what device is mounted as root (/).
+ * @return Root device.
+ * @note The returned string points to storage that needs to be freed by
+ * caller
+ * @bug A bit of a misnomer; it's actually finding out the root device.
+ * The mountpoint (where it's mounted) will obviously be '/'.
+ */
+char *where_is_root_mounted(void) {
+
+/*@ buffers **************** */
+char *tmp = NULL;
+
+#ifdef __FreeBSD__
+    tmp = call_program_and_get_last_line_of_output("mount | grep \" on / \" | cut -d' ' -f1");
+#else
+    tmp = call_program_and_get_last_line_of_output("mount | grep \" on / \" | cut -d' ' -f1 | sed s/[0-9]// | sed s/[0-9]//");
+    if (strstr(tmp, "/dev/cciss/")) {
+        mr_free(tmp);
+        tmp = call_program_and_get_last_line_of_output("mount | grep \" on / \" | cut -d' ' -f1 | cut -dp -f1");
+    }
+    if (strstr(tmp, "/dev/md")) {
+        mr_free(tmp);
+        tmp = call_program_and_get_last_line_of_output("mount | grep \" on / \" | cut -d' ' -f1");
+    }
+#endif
+
+return (tmp);
+}
+
+
+
+/**
+ * Determine whether we're booted off a ramdisk.
+ * @return @c TRUE (we are) or @c FALSE (we aren't).
+ * @ingroup utilityGroup
+ */
+bool am_I_in_disaster_recovery_mode(void)
+{
+    char *tmp = NULL;
+    bool is_this_a_ramdisk = FALSE;
+
+    tmp = where_is_root_mounted();
+    log_msg(0, "root is mounted at %s", tmp);
+    log_msg(0, "That doesn't mean %s is the root partition. It's just a debugging message. Relax. It's part of am_I_in_disaster_recovery_mode().", tmp);
+
+#ifdef __FreeBSD__
+    if (strstr(tmp, "/dev/md")) {
+        is_this_a_ramdisk = TRUE;
+    }
+#else
+    if (!strncmp(tmp, "/dev/ram", 8)
+        || (!strncmp(tmp, "/dev/rd", 7) && !strcmp(tmp, "/dev/rd/")
+            && strncmp(tmp, "/dev/rd/cd", 10)) || strstr(tmp, "rootfs")
+        || !strcmp(tmp, "/dev/root")) {
+        is_this_a_ramdisk = TRUE;
+    } else {
+        is_this_a_ramdisk = FALSE;
+    }
+#endif
+    mr_free(tmp);
+
+    if (is_this_a_ramdisk) {
+        if (!does_file_exist("/THIS-IS-A-RAMDISK")) {
+            log_to_screen("Using /dev/root is stupid of you but I'll forgive you.");
+            is_this_a_ramdisk = FALSE;
+        }
+    }
+    if (does_file_exist("/THIS-IS-A-RAMDISK")) {
+        is_this_a_ramdisk = TRUE;
+    }
+
+    log_msg(1, "Is this a ramdisk? result = %s", (is_this_a_ramdisk) ? "TRUE" : "FALSE");
+    return (is_this_a_ramdisk);
+}
+
+
+
+
+
+/**
+ * Turn @c bkpinfo->backup_media_type into a human-readable string.
+ * @return The human readable string (e.g. @c cdr becomes <tt>"cdr"</tt>).
+ * @note The returned string points to static storage that will be overwritten with each call.
+ * @ingroup stringGroup
+ */
+static char *bkptype_to_string(t_bkptype bt)
+{
+    char *output = NULL;
+    switch (bt) {
+    case none:
+        mr_asprintf(output, "%s", "none");
+        break;
+    case iso:
+        mr_asprintf(output, "%s", "iso");
+        break;
+    case cdr:
+        mr_asprintf(output, "%s", "cdr");
+        break;
+    case cdstream:
+        mr_asprintf(output, "%s", "cdstream");
+        break;
+    case netfs:
+        mr_asprintf(output, "%s", "netfs");
+        break;
+    case tape:
+        mr_asprintf(output, "%s", "tape");
+        break;
+    case udev:
+        mr_asprintf(output, "%s", "udev");
+        break;
+    case usb:
+        mr_asprintf(output, "%s", "usb");
+        break;
+    default:
+        mr_asprintf(output, "%s", "default");
+    }
+    return (output);
+}
+
+
+
+/**
+ * @addtogroup deviceGroup
+ * @{
+ */
+/**
+ * Eject the tray of the specified CD device.
+ * @param dev The device to eject.
+ * @return the return value of the @c eject command. (0=success, nonzero=failure)
+ */
+int eject_device(char *dev)
+{
+    char *command = NULL;
+    int res1 = 0, res2 = 0;
+
+    if (dev == NULL) {
+        return (1);
+    }
+
+    if (IS_THIS_A_STREAMING_BACKUP(g_backup_media_type)
+        && g_backup_media_type != udev) {
+        mr_asprintf(command, "mt -f %s offline", dev);
+        res1 = run_program_and_log_output(command, 1);
+        mr_free(command);
+    } else {
+        res1 = 0;
+    }
+
+#ifdef __FreeBSD__
+    if (strstr(dev, "acd")) {
+        mr_asprintf(command, "cdcontrol -f %s eject", dev);
+    } else {
+        mr_asprintf(command, "camcontrol eject `echo %s | sed 's|/dev/||'`", dev);
+    }
+#else
+    mr_asprintf(command, "eject %s", dev);
+#endif
+
+    log_msg(3, "Ejecting %s", dev);
+    res2 = run_program_and_log_output(command, 1);
+    mr_free(command);
+    if (res1 && res2) {
+        return (1);
+    } else {
+        return (0);
+    }
+}
+
+/**
+ * Determine whether a non-Microsoft partition exists on any connected hard drive.
+ * @return TRUE (there's a Linux/FreeBSD partition) or FALSE (Microsoft has taken over yet another innocent machine).
+ */
+bool does_nonMS_partition_exist(void)
+{
+#if __FreeBSD__
+    return
+        !system("for drive in /dev/ad? /dev/da?; do fdisk $drive | grep -q FreeBSD && exit 0; done; false");
+#else
+    return
+        !system("mr-parted2fdisk -l 2>/dev/null | grep '^/dev/' | grep -Eqv '(MS|DOS|EFI|FAT|NTFS)'");
+#endif
+}
+
+/**
+ * Determine whether the specified @p partno exists on the specified @p drive.
+ * @param drive The drive to search for the partition in.
+ * @param partno The partition number to look for.
+ * @return 0 if it exists, nonzero otherwise.
+ */
+int does_partition_exist(const char *drive, int partno)
+{
+    /*@ buffers **************************************************** */
+    char *program = NULL;
+    char *incoming = NULL;
+    char *searchstr = NULL;
+
+    /*@ ints ******************************************************* */
+    int res = 0;
+
+    /*@ pointers *************************************************** */
+    FILE *fin;
+
+    /*@ end vars *************************************************** */
+    assert_string_is_neither_NULL_nor_zerolength(drive);
+    assert(partno >= 0 && partno < 999);
+
+#ifdef __FreeBSD__
+    // We assume here that this is running from mondorestore. (It is.)
+    tmp = build_partition_name(drive, partno);
+    mr_asprintf(program, "ls %s %s >/dev/null 2>&1", drive, tmp);
+    mr_free(tmp);
+    res = system(program);
+    mr_free(program);
+    return(res);
+#endif
+
+    mr_asprintf(program, "mr-parted2fdisk -l %s 2> /dev/null", drive);
+    fin = popen(program, "r");
+    if (!fin) {
+        log_it("program=%s", program);
+        log_OS_error("Cannot popen-in program");
+        mr_free(program);
+        return (0);
+    }
+    mr_free(program);
+
+    searchstr = build_partition_name(drive, partno);
+    mr_strcat(searchstr, " ");
+    for (res = 0, mr_getline(incoming, fin); !res && !feof(fin) ; mr_getline(incoming, fin)) {
+        if (strstr(incoming, searchstr)) {
+            res = 1;
+        }
+        mr_free(incoming);
+    }
+    mr_free(searchstr);
+    mr_free(incoming);
+
+    if (pclose(fin)) {
+        log_OS_error("Cannot pclose fin");
+    }
+    return (res);
+}
+
+
+
+
+
+/**
+ * Determine whether given NULL-terminated @p str exists in the begining of @p dev.
+ * @param dev The device to look in.
+ * @param str The string to look for.
+ * @return TRUE if it exists, FALSE if it doesn't.
+ */
+bool does_string_exist_in_boot_block(char *dev, char *str)
+{
+    /*@ buffers **************************************************** */
+    char *command = NULL;
+
+    /*@ end vars *************************************************** */
+    int i;
+
+    assert_string_is_neither_NULL_nor_zerolength(dev);
+    assert_string_is_neither_NULL_nor_zerolength(str);
+
+    /* For UEFI detection, this should be extended to count=1000 ! */
+    if (bkpinfo->boot_type == UEFI) {
+        mr_asprintf(command, "dd if=%s bs=446 count=1000 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null", dev, str);
+    } else {
+        mr_asprintf(command, "dd if=%s bs=446 count=1 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null", dev, str);
+    }
+    i = system(command);
+    mr_free(command);
+    if (i) {
+        return (FALSE);
+    } else {
+        return (TRUE);
+    }
+}
+
+/**
+ * Determine whether specified @p str exists in the first @p n sectors of
+ * @p dev.
+ * @param dev The device to look in.
+ * @param str The string to look for.
+ * @param n The number of 512-byte sectors to search.
+ */
+bool does_string_exist_in_first_N_blocks(char *dev, char *str, int n)
+{
+    /*@ buffers **************************************************** */
+    char *command = NULL;
+    /*@ end vars *************************************************** */
+    int i;
+
+    mr_asprintf(command, "dd if=%s bs=512 count=%i 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null", dev, n, str);
+    i = system(command);
+    mr_free(command);
+    if (i) {
+        return (FALSE);
+    } else {
+        return (TRUE);
+    }
+}
+
+
+/* 
+ * This function tries to find an optical media device
+ * and return it's device file to the caller that needs to free it
+ */
+char *find_optical_device(void) {
+    char *dev = NULL;
+    char *tmp1 = NULL;
+    char *command = NULL;
+
+    log_to_screen("I am looking for your optical burner. Please wait.");
+
+    if (bkpinfo->media_device != NULL) {
+        log_msg(3, "Been there, done that. Returning %s", bkpinfo->media_device);
+        return (bkpinfo->media_device);
+    }
+
+    mr_asprintf(tmp1, "cdrecord -inq 2> /dev/null | grep -E '^Detected '  | cut -d':' -f2");
+    dev = call_program_and_get_last_line_of_output(tmp1);
+    mr_free(tmp1);
+
+    if ((dev != NULL) && does_file_exist(dev)) {
+        log_msg(2, "find_optical_device found %s automatically", dev);
+    } else {
+        mr_free(dev);
+        tmp1 = find_home_of_exe("lsscsi");
+        if (tmp1 != NULL) {
+            mr_asprintf(command, "%s | grep ' cd' | awk '{print $NF}' | head -1", tmp1);
+            dev = call_program_and_get_last_line_of_output(command);
+            mr_free(command);
+        }
+        mr_free(tmp1);
+
+        if ((dev == NULL) || !does_file_exist(dev)) {
+            /* trying something else then */
+            mr_asprintf(dev, "%s", VANILLA_SCSI_CDROM);
+            if (!does_file_exist(dev)) {
+                mr_asprintf(dev, "%s", ALT_CDROM);
+                if (!does_file_exist(dev)) {
+                    mr_asprintf(dev, "%s", "/dev/cdrom");
+                    if (!does_file_exist(dev)) {
+                        mr_asprintf(dev, "%s", "/dev/dvd");
+                        if (!does_file_exist(dev)) {
+                            log_it("Unable to find a tape device on this system");
+                        }
+                    }
+                }
+            }
+        }
+        if (dev != NULL) {
+            log_it("find_optical_device found %s manually", dev);
+        }
+    } 
+
+    if ((dev != NULL) && does_file_exist(dev)) {
+        log_it("find_optical_device returns %s", dev);
+    } else {
+        mr_free(dev);
+        log_it("find_optical_device found no optical burner on your system returning NULL");
+    }
+    return(dev);
+}
+/**
+* Mount the CD-ROM or USB device at /mnt/cdrom.
+* @param bkpinfo The backup information structure. Fields used: 
+* - @c bkpinfo->backup_media_type
+* - @c bkpinfo->disaster_recovery
+* - @c bkpinfo->isodir
+* - @c bkpinfo->media_device
+* @return TRUE for success, FALSE for failure.
+*/
+bool mount_media(const char *mountpoint) {
+
+    char *mount_cmd = NULL;
+    char *mountdir = NULL;
+    char *tmp = NULL;
+    int i = 0, res = 0;
+#ifdef __FreeBSD__
+    char mdd[32];
+    char *mddev = mdd;
+    char *dev;
+#endif
+
+    if (bkpinfo->backup_media_type == tape || bkpinfo->backup_media_type == udev) {
+        log_msg(8, "Tape/udev. Therefore, no need to mount a media.");
+        return(TRUE);
+    }
+
+    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
+
+    mr_asprintf(tmp, "mount | grep -F %s", mountpoint);
+    if (!run_program_and_log_output(tmp, FALSE)) {
+        log_msg(2, "mount_media() - media already mounted. Fair enough.");
+        mr_free(tmp);
+        return (TRUE);
+    }
+    mr_free(tmp);
+
+    make_hole_for_dir(mountpoint);
+
+    if (bkpinfo->backup_media_type == netfs) {
+        log_msg(2, "Mounting for Network thingy");
+        log_msg(2, "isodir = %s", bkpinfo->isodir);
+        if (((bkpinfo->isodir == NULL) || !strcmp(bkpinfo->isodir, "/")) && am_I_in_disaster_recovery_mode()) {
+            mr_asprintf(bkpinfo->isodir, "%s", "/tmp/isodir");
+            log_msg(1, "isodir is being set to %s", bkpinfo->isodir);
+        }
+#ifdef __FreeBSD__
+        if (bkpinfo->netfs_remote_dir != NULL) {
+            // NETFS
+            mr_asprintf(mount_cmd, "/mnt/isodir/%s/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix, g_current_media_number);
+        } else {
+            // ISO
+            mr_asprintf(mount_cmd, "/mnt/isodir/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->prefix, g_current_media_number);
+        }
+        mddev = make_vn(mount_cmd);
+        mr_free(mount_cmd);
+
+        mr_asprintf(mount_cmd, "mount_cd9660 -r %s %s", mddev, mountpoint);
+#else
+        if (bkpinfo->netfs_remote_dir != NULL) {
+            // NETFS
+            mr_asprintf(mount_cmd, "mount %s/%s/%s-%d.iso -t iso9660 -o loop,ro %s", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix, g_current_media_number, mountpoint);
+        } else {
+            // ISO
+            mr_asprintf(mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s", bkpinfo->isodir, bkpinfo->prefix, g_current_media_number, mountpoint);
+        }
+#endif
+
+    } else if (bkpinfo->backup_media_type == iso) {
+        if (bkpinfo->subdir) {
+            mr_asprintf(mountdir, "%s/%s", bkpinfo->isodir, bkpinfo->subdir);
+        } else {
+            mr_asprintf(mountdir, "%s", bkpinfo->isodir);
+        }
+#ifdef __FreeBSD__
+        mr_asprintf(mount_cmd, "%s/%s-%d.iso", mountdir, bkpinfo->prefix, g_current_media_number);
+        mddev = make_vn(mount_cmd);
+        mr_free(mount_cmd);
+
+        mr_asprintf(mount_cmd, "mount_cd9660 -r %s %s", mddev, mountpoint);
+#else
+        mr_asprintf(mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s", mountdir, bkpinfo->prefix, g_current_media_number, mountpoint);
+#endif
+        mr_free(mountdir);
+    } else if (bkpinfo->backup_media_type == usb) {
+        mr_asprintf(mount_cmd, "mount -t vfat %s %s", bkpinfo->media_device, mountpoint);
+    } else {    //  optical
+        if (bkpinfo->disaster_recovery
+            && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
+            mr_asprintf(bkpinfo->media_device, "%s", last_line_of_file("/tmp/CDROM-LIVES-HERE"));
+        } else {
+            if (bkpinfo->media_device == NULL) {
+                bkpinfo->media_device = find_optical_device();
+            }
+        }
+
+#ifdef __FreeBSD__
+        if (g_ISO_restore_mode) {
+            mr_asprintf(dev, "%s", make_vn(bkpinfo->media_device));
+            if (!dev) {
+                mr_asprintf(command, "Unable to mount ISO (make_vn(%s) failed)", bkpinfo->media_device);
+                fatal_error(command);
+            }
+            mr_free(bkpinfo->media_device);
+            bkpinfo->media_device = dev
+        }
+
+        mr_asprintf(mount_cmd, "mount_cd9660 -r %s %s 2>> %s", bkpinfo->media_device, mountpoint, MONDO_LOGFILE);
+#else
+        mr_asprintf(mount_cmd, "mount %s -o loop,ro -t iso9660 %s 2>> %s", bkpinfo->media_device, mountpoint, MONDO_LOGFILE);
+#endif
+        log_msg(2, "(mount_media) --- command = %s", mount_cmd);
+        // usefull ??
+        if (strncmp(bkpinfo->media_device, "/dev/", 5) == 0) {
+            retract_CD_tray_and_defeat_autorun();
+        }
+    }
+
+    for (i = 0; i < 2; i++) {
+        res = run_program_and_log_output(mount_cmd, FALSE);
+        if (!res) {
+            break;
+        } else {
+            log_msg(2, "Failed to mount device.");
+            sleep(5);
+            sync();
+        }
+    }
+    mr_free(mount_cmd);
+
+    if (res) {
+        log_msg(2, "Failed, despite %d attempts", i);
+        return(FALSE);
+    } else {
+        log_msg(2, "Mounted media drive OK");
+        return(TRUE);
+    }
+}
+/**************************************************************************
+*END_MOUNT_MEDIA                                                         *
+**************************************************************************/
+
+
+
+
+/**
+ * Try to mount CD/DVD at @p mountpoint. If the CD/DVD is not found or has
+ * not been specified, call find_optical_device() to find it.
+ * @param mountpoint Where to mount the CD-ROM.
+ * @return TRUE for success, FALSE for failure.
+ * @see mount_media
+ */
+bool find_and_mount_actual_cd(char *mountpoint) {
+
+    /*@ buffers ***************************************************** */
+
+    /*@ int's  ****************************************************** */
+    bool res;
+
+    /*@ end vars **************************************************** */
+
+    assert(bkpinfo != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
+
+    if (bkpinfo->media_device == NULL) {
+        bkpinfo->media_device = find_optical_device();
+    }
+
+    if (bkpinfo->backup_media_type != iso) {
+        retract_CD_tray_and_defeat_autorun();
+    }
+
+    if ((bkpinfo->media_device == NULL) || (res = mount_media(mountpoint))) {
+        mr_free(bkpinfo->media_device);
+        if ((bkpinfo->media_device = mr_popup_and_get_string("CD-ROM device", "Please enter your CD-ROM's /dev device", "/dev/cdrom")) == NULL) {
+            res = TRUE;
+        } else {
+            res = mount_media(mountpoint);
+        }
+    }
+    if (res) {
+        log_msg(1, "mount failed");
+    } else {
+        log_msg(1, "mount succeeded with %s", bkpinfo->media_device);
+    }
+    return (res);
+}
+/* 
+ * This function tries to find a USB media device
+ * and return it's device file to the caller that needs to free it
+ */
+char *find_usb_device(void)
+{
+    char *dev = NULL;
+    char *tmp1 = NULL;
+    char *command = NULL;
+
+    log_to_screen("I am looking for your USB key. Please wait.");
+
+    if (bkpinfo->media_device != NULL) {
+        log_msg(3, "Been there, done that. Returning %s", bkpinfo->media_device);
+        return (bkpinfo->media_device);
+    }
+
+    tmp1 = find_home_of_exe("lsscsi");
+    if (tmp1 != NULL) {
+        mr_asprintf(command, "%s | grep ' disk' | grep USB | awk '{print $NF}' | head -1", tmp1);
+        dev = call_program_and_get_last_line_of_output(command);
+        mr_free(command);
+    }
+    mr_free(tmp1);
+
+    if ((dev == NULL) || !does_file_exist(dev)) {
+        tmp1 = find_home_of_exe("lsblk");
+        if (tmp1 != NULL) {
+            mr_asprintf(command, "%s --noheadings --raw --output rm,tran,type,path --sort path | awk '/^1 usb disk/ {d=$4} END {print d}'", tmp1);
+            dev = call_program_and_get_last_line_of_output(command);
+            mr_free(command);
+        }
+        mr_free(tmp1);
+        log_it("Unable to find a tape device on this system");
+    }
+    if (dev != NULL) {
+        log_it("find_usb_device found %s manually", dev);
+    }
+
+    if ((dev != NULL) && does_file_exist(dev)) {
+        log_it("find_usb_device returns %s", dev);
+    } else {
+        mr_free(dev);
+        log_it("find_usb_device found no USB key on your system returning NULL");
+    }
+    return(dev);
+}
+
+
+
+/* Generic fund to find a media 
+ * Return a dynamically allocted string that caller needs to free 
+ * @media_type is the type of media to look for
+ */
+
+char *find_device(t_bkptype media_type) {
+
+    if (media_type == usb) {
+        return(find_usb_device());
+    } else if (media_type == tape) {
+        return(find_tape_device());
+    } else if ((media_type == dvd) || (media_type == cdr)) {
+        return(find_optical_device());
+    } else {
+        return(NULL);
+    }
+}
+
+
+
+
+#include <sys/ioctl.h>
+
+/**
+ * Find the size of the specified @p drive, in megabytes. Uses @c ioctl calls
+ * and @c dmesg.
+ * @param drive The device to find the size of.
+ * @return size in megabytes.
+ */
+long get_phys_size_of_drive(char *drive)
+{
+    int fd;
+#if linux
+    unsigned long long s = 0;
+    int fileid, cylinders = 0;
+    int cylindersize = 0;
+    int gotgeo = 0;
+
+
+    struct hd_geometry hdgeo;
+#elif __FreeBSD__
+    off_t s;
+#endif
+
+    long outvalA = -1;
+    long outvalB = -1;
+    long outvalC = -1;
+
+    if ((fd = open(drive, O_RDONLY)) != -1) {
+        if (ioctl(fd,
+#if linux
+#ifdef BLKGETSIZE64
+                  BLKGETSIZE64,
+#else
+                  BLKGETSIZE,
+#endif
+#elif __FreeBSD__
+                  DIOCGMEDIASIZE,
+#endif
+                  &s) != -1) {
+            close(fd);
+            // s>>11 works for older disks but not for newer ones
+            outvalB =
+#if linux
+#ifdef BLKGETSIZE64
+                s >> 20
+#else
+                s >> 11
+#endif
+#else
+                s >> 20
+#endif
+                ;
+        }
+    }
+
+    if (outvalB <= 0) {
+        log_msg(1, "Error getting size of %s: %s", drive, strerror(errno));
+#if linux
+        fileid = open(drive, O_RDONLY);
+        if (fileid != -1) {
+            if (ioctl(fileid, HDIO_GETGEO, &hdgeo) != -1) {
+                if (hdgeo.cylinders && hdgeo.heads && hdgeo.sectors) {
+                    cylindersize = hdgeo.heads * hdgeo.sectors / 2;
+                    outvalA = cylindersize * cylinders / 1024;
+                    log_msg(2, "Got Harddisk geometry, C:%d, H:%d, S:%d",
+                            hdgeo.cylinders, hdgeo.heads, hdgeo.sectors);
+                    gotgeo = 1;
+                } else {
+                    log_msg(1, "Harddisk geometry wrong");
+                }
+            } else {
+                log_msg(1,
+                        "Error in ioctl() getting new hard disk geometry (%s), resizing in unsafe mode",
+                        strerror(errno));
+            }
+            close(fileid);
+        } else {
+            log_msg(1, "Failed to open %s for reading: %s", drive,
+                    strerror(errno));
+        }
+        if (!gotgeo) {
+            log_msg(1, "Failed to get harddisk geometry, using old mode");
+        }
+#endif
+    }
+// OLDER DISKS will give ridiculously low value for outvalB (so outvalA is returned) :)
+// NEWER DISKS will give sane value for outvalB (close to outvalA, in other words) :)
+
+    outvalC = (outvalA > outvalB) ? outvalA : outvalB;
+
+//  log_msg (5, "drive = %s, error = %s", drive, strerror (errno));
+//  fatal_error ("GPSOD: Unable to get size of drive");
+    log_msg(1, "%s --> %ld or %ld --> %ld", drive, outvalA, outvalB,
+            outvalC);
+
+    return (outvalC);
+}
+
+/**
+ * Determine whether @p format is supported by the kernel. Uses /proc/filesystems
+ * under Linux and @c lsvfs under FreeBSD.
+ * @param format The format to test.
+ * @return TRUE if the format is supported, FALSE if not.
+ */
+bool is_this_a_valid_disk_format(char *format)
+{
+    char *good_formats = NULL;
+    char *command = NULL;
+    char *format_sz = NULL;
+    char *p = NULL;
+
+    FILE *pin;
+    int retval;
+
+    assert_string_is_neither_NULL_nor_zerolength(format);
+
+    mr_asprintf(format_sz, "%s ", format);
+
+#ifdef __FreeBSD__
+    mr_asprintf(command, "lsvfs | tr -s '\t' ' ' | grep -v Filesys | grep -v -- -- | cut -d' ' -f1 | tr -s '\n' ' '");
+#else
+    mr_asprintf(command, "grep -v nodev /proc/filesystems | tr -s '\t' ' ' | cut -d' ' -f2 | tr -s '\n' ' '");
+#endif
+
+    pin = popen(command, "r");
+    mr_free(command);
+
+    if (!pin) {
+        log_OS_error("Unable to read good formats");
+        retval = 0;
+    } else {
+        mr_getline(p, pin);
+        good_formats = mr_strip_spaces(p);
+        mr_free(p);
+        (void)pclose(pin);
+        mr_strcat(good_formats, " swap lvm raid ntfs-3g ntfs 7 ");  // " ntfs 7 " -- um, cheating much? :)
+        if (strstr(good_formats, format_sz)) {
+            retval = 1;
+        } else {
+            retval = 0;
+        }
+    }
+    mr_free(good_formats);
+    mr_free(format_sz);
+
+    return (retval);
+}
+
+
+/** @def SWAPLIST_COMMAND The command to list the swap files/partitions in use. */
+
+/**
+ * Determine whether @p device_raw is currently mounted.
+ * @param device_raw The device to check.
+ * @return TRUE if it's mounted, FALSE if not.
+ */
+bool is_this_device_mounted(char *device_raw)
+{
+
+    char *tmp = NULL;
+    bool retval = FALSE;
+
+    mr_asprintf(tmp, "mr-device-mounted %s > /dev/null", device_raw);
+    if (system(tmp) == 0) {
+        retval = TRUE;
+    }
+    mr_free(tmp);
+    return(retval);
+}
+
+#ifdef __FreeBSD__
+//                       CODE IS FREEBSD-SPECIFIC
+/**
+ * Create a loopback device for specified @p fname.
+ * @param fname The file to associate with a device.
+ * @return /dev entry for the device, or NULL if it couldn't be allocated.
+ */
+char *make_vn(char *fname)
+{
+    char *device = (char *) malloc(MAX_STR_LEN);
+    char *mddevice = NULL;
+    char *command = NULL;
+    char *tmp = NULL;
+    int vndev = 2;
+
+    tmp = call_program_and_get_last_line_of_output("/sbin/sysctl -n kern.osreldate");
+    if (atoi(tmp) < 500000) {
+        do {
+            mr_asprintf(mddevice, "vn%ic", vndev++);
+            mr_free(command);
+            mr_asprintf(command, "vnconfig %s %s", mddevice, fname);
+            if (vndev > 10) {
+                mr_free(tmp);
+                mr_free(mddevice);
+                mr_free(command);
+                return NULL;
+            }
+        }
+        while (system(command));
+    } else {
+        mr_asprintf(command, "mdconfig -a -t vnode -f %s", fname);
+        mddevice = call_program_and_get_last_line_of_output(command);
+        if (!strstr(mddevice, "md")) {
+            mr_free(tmp);
+            mr_free(command);
+            mr_free(mddevice);
+            return NULL;
+        }
+    }
+    mr_free(tmp);
+    mr_free(command);
+    sprintf(device, "/dev/%s", mddevice);
+    mr_free(mddevice);
+    return device;
+}
+
+
+
+//                       CODE IS FREEBSD-SPECIFIC
+/**
+ * Deallocate specified @p dname.
+ * This should be called when you are done with the device created by make_vn(),
+ * so the system does not run out of @c vn devices.
+ * @param dname The device to deallocate.
+ * @return 0 for success, nonzero for failure.
+ */
+int kick_vn(char *dname)
+{
+    char *command = NULL;
+    char *tmp = NULL;
+    int res = 0;
+
+    if (strncmp(dname, "/dev/", 5) == 0) {
+        dname += 5;
+    }
+
+    tmp = call_program_and_get_last_line_of_output("/sbin/sysctl -n kern.osreldate");
+    if (atoi(tmp) < 500000) {
+        mr_asprintf(command, "vnconfig -d %s", dname);
+    } else {
+        mr_asprintf(command, "mdconfig -d -u %s", dname);
+    }
+    mr_free(tmp);
+    res = system(command);
+    mr_free(command);
+    return(res);
+}
+#endif
+
+
+/**
+ * Mount the CD-ROM at @p mountpoint.
+ * @param device The device (or file if g_ISO_restore_mode) to mount.
+ * @param mountpoint The place to mount it.
+ * @return 0 for success, nonzero for failure.
+ */
+int mount_USB_here(char *device, char *mountpoint)
+{
+    /*@ buffer ****************************************************** */
+    char *command = NULL;
+    int retval;
+
+    assert_string_is_neither_NULL_nor_zerolength(device);
+    assert_string_is_neither_NULL_nor_zerolength(mountpoint);
+
+    make_hole_for_dir(mountpoint);
+    if (isdigit(device[0])) {
+        return(1);
+    }
+    log_msg(4, "(mount_USB_here --- device=%s, mountpoint=%s", device, mountpoint);
+
+#ifdef __FreeBSD__
+    mr_asprintf(command, "mount_vfat %s %s 2>> %s", device, mountpoint, MONDO_LOGFILE);
+
+#else
+    mr_asprintf(command, "mount %s -t vfat %s 2>> %s", device, mountpoint, MONDO_LOGFILE);
+#endif
+
+    log_msg(4, command);
+    retval = system(command);
+    log_msg(1, "system(%s) returned %d", command, retval);
+    mr_free(command);
+
+    return (retval);
+}
+
+/**
+ * Find out what number CD is in the drive.
+ * @param bkpinfo The backup information structure. The @c bkpinfo->media_device field is the only one used.
+ * @return The current CD number, or -1 if it could not be found.
+ * @note If the CD is not mounted, it will be mounted
+ * (and remain mounted after this function returns).
+ */
+int what_number_cd_is_this(void) {
+
+    int cd_number = -1;
+    char *mountdev = NULL;
+    char *tmp = NULL;
+
+    assert(bkpinfo != NULL);
+//  log_it("Asking what_number_cd_is_this");
+    if ((g_ISO_restore_mode) || (g_restoring_live_from_cd)) {
+        tmp = call_program_and_get_last_line_of_output("mount | grep iso9660 | awk '{print $3;}'");
+        mr_asprintf(mountdev, "%s%s", tmp, "/archives/THIS-CD-NUMBER");
+        mr_free(tmp);
+        cd_number = atoi(last_line_of_file(mountdev));
+        mr_free(mountdev);
+        return (cd_number);
+    }
+
+    if ((bkpinfo->media_device == NULL) || !does_file_exist(bkpinfo->media_device)) {
+        log_it("ERROR: bkpinfo->media_device shoulnd't be unaccessible here\n");
+        /* trying again ! */
+        bkpinfo->media_device = find_optical_device();
+    }
+    if ((bkpinfo->media_device == NULL) || !does_file_exist(bkpinfo->media_device)) {
+        fatal_error("ERROR: bkpinfo->media_device shoulnd't really be unaccessible here\n");
+    }
+    if (!is_this_device_mounted(MNT_CDROM)) {
+        mount_media(MNT_CDROM);
+    }
+
+    cd_number = atoi(last_line_of_file(MNT_CDROM "/archives/THIS-CD-NUMBER"));
+    return(cd_number);
+}
+
+
+
+
+/**
+ * Ask the user for CD number @p cd_number_i_want.
+ * Sets g_current_media_number once the correct CD is inserted.
+ * @param bkpinfo The backup information structure. Fields used:
+ * - @c bkpinfo->backup_media_type
+ * - @c bkpinfo->prefix
+ * - @c bkpinfo->isodir
+ * - @c bkpinfo->media_device
+ * - @c bkpinfo->please_dont_eject_when_restoring
+ * @param cd_number_i_want The CD number to ask for.
+ */
+void
+insist_on_this_cd_number(int cd_number_i_want)
+{
+
+    /*@ int ************************************************************* */
+    int res = 0;
+
+
+    /*@ buffers ********************************************************* */
+    char *tmp = NULL;
+    char *mds = NULL;
+    char *request = NULL;
+
+    assert(bkpinfo != NULL);
+    assert(cd_number_i_want > 0);
+
+//  log_msg(3, "Insisting on CD number %d", cd_number_i_want);
+
+    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
+        log_msg(3,
+                "No need to insist_on_this_cd_number when the backup type isn't CD-R(W) or NFS or ISO");
+        return;
+    }
+    if (!does_file_exist(MNT_CDROM)) {
+        mr_asprintf(tmp, "mkdir -p " MNT_CDROM);
+        run_program_and_log_output(tmp, 5);
+        mr_free(tmp);
+    }
+
+    if (g_ISO_restore_mode || bkpinfo->backup_media_type == iso || bkpinfo->backup_media_type == netfs) {
+        g_ISO_restore_mode = TRUE;
+    }
+    if ((res = what_number_cd_is_this()) != cd_number_i_want) {
+        log_msg(3, "Currently, we hold %d but we want %d", res, cd_number_i_want);
+
+        /* Now we need to umount the current media to have the next mounted after */
+        run_program_and_log_output("umount -d " MNT_CDROM, FALSE);
+        log_msg(3, "Mounting next media %d",cd_number_i_want);
+        g_current_media_number = cd_number_i_want;
+        mount_media(MNT_CDROM);
+
+        mds = media_descriptor_string(bkpinfo->backup_media_type);
+        log_msg(3, "Insisting on %s #%d", mds, cd_number_i_want);
+        mr_asprintf(request, "Please insert %s #%d and press Enter.", mds, cd_number_i_want);
+        mr_free(mds);
+
+        while (what_number_cd_is_this() != cd_number_i_want) {
+            sync();
+            if (is_this_device_mounted(MNT_CDROM)) {
+                res =
+                    run_program_and_log_output("umount -d " MNT_CDROM, FALSE);
+            } else {
+                res = 0;
+            }
+            if (res) {
+                log_to_screen("WARNING - failed to unmount CD-ROM drive");
+            }
+            if (!bkpinfo->please_dont_eject) {
+                res = eject_device(bkpinfo->media_device);
+            } else {
+                res = 0;
+            }
+            if (res) {
+                log_to_screen("WARNING - failed to eject CD-ROM disk");
+            }
+            popup_and_OK(request);
+            if (!bkpinfo->please_dont_eject) {
+                inject_device(bkpinfo->media_device);
+            }
+            sync();
+        }
+        mr_free(request);
+
+        log_msg(1, "Thankyou. Proceeding...");
+        g_current_media_number = cd_number_i_want;
+    }
+}
+
+
 /* Update the bkpinfo structure for exclude & include paths 
  * in order to handle correctly paths corresponding to devices */
@@ -2108 +2017 @@
     // Tape, CD, NETFS, ...?
     srandom(getpid());
-    bkpinfo->backup_media_type =
-        (g_restoring_live_from_cd) ? cdr :
-        which_backup_media_type(bkpinfo->restore_data);
+    bkpinfo->backup_media_type = (g_restoring_live_from_cd) ? cdr : which_backup_media_type(bkpinfo->restore_data);
     if (bkpinfo->backup_media_type == none) {
         log_to_screen("User has chosen not to backup the machine");
         finish(1);
     }
-    log_msg(3, "media type = %s", bkptype_to_string(bkpinfo->backup_media_type));
+    tmp = bkptype_to_string(bkpinfo->backup_media_type);
+    log_msg(3, "media type = %s", tmp);
+    mr_free(tmp);
 
     /* Why asking to remove the media with tape ?
@@ -2755 +2664 @@
     log_it("media device = %s", bkpinfo->media_device);
     log_it("media size = %ld", bkpinfo->media_size);
-    log_it("media type = %s", bkptype_to_string(bkpinfo->backup_media_type));
+    tmp = bkptype_to_string(bkpinfo->backup_media_type);
+    log_it("media type = %s", tmp);
+    mr_free(tmp);
     if (bkpinfo->prefix != NULL) {
         log_it("prefix = %s", bkpinfo->prefix);

branches/3.3/mondo/src/common/libmondo-fifo.c

@@ -23 +23 @@
 #include "mr_mem.h"
 #include "mondostructures.h"
-#include "libmondo.h"
+#include "libmondo-devices-EXT.h"
+#include "libmondo-fork-EXT.h"
+#include "newt-specific-EXT.h"
+
 
 /**

branches/3.3/mondo/src/common/libmondo-filelist.c

@@ -60 +60 @@
 extern char *g_getfacl;
 extern char *g_getfattr;
+
+
+int sort_file(char *orig_fname)
+{
+    char *tmp_fname = NULL;
+    char *command = NULL;
+    int retval = 0;
+
+    log_msg(5, "Sorting file %s", orig_fname);
+
+    if (!does_file_exist(orig_fname)) {
+        log_msg(2, "file %s empty", orig_fname);
+        return (0);
+    }                           // no sense in trying to sort an empty file
+
+    mr_asprintf(tmp_fname, "%s/sortfile", bkpinfo->tmpdir);
+    mr_asprintf(command, "sort %s > %s 2>> %s", orig_fname, tmp_fname, MONDO_LOGFILE);
+    retval = system(command);
+    mr_free(command);
+
+    if (retval) {
+        log_msg(2, "Failed to sort %s - oh dear", orig_fname);
+    } else {
+        log_msg(5, "Sorted %s --> %s OK. Copying it back to %s now", orig_fname, tmp_fname, orig_fname);
+        mr_asprintf(command, "mv -f %s %s", tmp_fname, orig_fname);
+        retval += run_program_and_log_output(command, 5);
+        mr_free(command);
+
+        if (retval) {
+            log_msg(2, "Failed to copy %s back to %s - oh dear", tmp_fname, orig_fname);
+        } else {
+            log_msg(5, "%s was sorted OK.", orig_fname);
+        }
+    }
+    mr_free(tmp_fname);
+    log_msg(5, "Finished sorting file %s", orig_fname);
+    return (retval);
+}
+
 
 
@@ -310 +349 @@
     return (retval);
 }
-
-
-
-int sort_file(char *orig_fname)
-{
-    char *tmp_fname = NULL;
-    char *command = NULL;
-    int retval = 0;
-
-    log_msg(5, "Sorting file %s", orig_fname);
-
-    if (!does_file_exist(orig_fname)) {
-        log_msg(2, "file %s empty", orig_fname);
-        return (0);
-    }                           // no sense in trying to sort an empty file
-
-    mr_asprintf(tmp_fname, "%s/sortfile", bkpinfo->tmpdir);
-    mr_asprintf(command, "sort %s > %s 2>> %s", orig_fname, tmp_fname, MONDO_LOGFILE);
-    retval = system(command);
-    mr_free(command);
-
-    if (retval) {
-        log_msg(2, "Failed to sort %s - oh dear", orig_fname);
-    } else {
-        log_msg(5, "Sorted %s --> %s OK. Copying it back to %s now", orig_fname, tmp_fname, orig_fname);
-        mr_asprintf(command, "mv -f %s %s", tmp_fname, orig_fname);
-        retval += run_program_and_log_output(command, 5);
-        mr_free(command);
-
-        if (retval) {
-            log_msg(2, "Failed to copy %s back to %s - oh dear", tmp_fname, orig_fname);
-        } else {
-            log_msg(5, "%s was sorted OK.", orig_fname);
-        }
-    }
-    mr_free(tmp_fname);
-    log_msg(5, "Finished sorting file %s", orig_fname);
-    return (retval);
-}
-
 
 

branches/3.3/mondo/src/common/libmondo-raid-EXT.h

@@ -22 +22 @@
 extern void process_raidtab_line(FILE *, struct raid_device_record *,
                                  char *, char *);
-extern int save_raidlist_to_raidtab(struct raidlist_itself *raidlist,
-                                    char *fname);
 extern void save_raidrec_to_file(struct raid_device_record *raidrec,
                                  FILE * fout);

branches/3.3/mondo/src/common/libmondo-raid.c

@@ -245 +245 @@
 }
 #endif
+
+
+/**
+ * Save a disklist to a stream in raidtab format.
+ * @param listname One of "raid-disk", "spare-disk", "parity-disk", or "failed-disk".
+ * @param disklist The disklist to save to @p fout.
+ * @param fout The stream to write to.
+ */
+void save_disklist_to_file(const char *listname, struct list_of_disks *disklist, FILE * fout)
+{
+    int i;
+
+    assert_string_is_neither_NULL_nor_zerolength(listname);
+    assert(disklist != NULL);
+    assert(fout != NULL);
+
+    for (i = 0; i < disklist->entries; i++) {
+        fprintf(fout, "    device                %s\n", disklist->el[i].device);
+        fprintf(fout, "    %-21s %d\n", listname, disklist->el[i].index);
+    }
+}
+/**
+ * Retrieve the next line from a raidtab stream.
+ * @param fin The file to read the input from.
+ * @param label Where to put the line's label.
+ * @param value Where to put the line's value.
+ * @return 0 if the line was read and stored successfully, 1 if we're at end of file.
+ */
+static int get_next_raidtab_line(FILE * fin, char **label, char **value)
+{
+    char *incoming = NULL;
+    char *p = NULL;
+    char *res = NULL;
+
+    assert(fin != NULL);
+
+    if (feof(fin)) {
+        return (1);
+    }
+
+    for (mr_getline(res, fin); !feof(fin); mr_getline(res, fin)) {
+        log_msg(10,"Found in raidtab line: %s",res);
+        incoming = mr_strip_spaces(res);
+        mr_free(res);
+        p = strchr(incoming, ' ');
+        if (strlen(incoming) < 3 || incoming[0] == '#' || !p) {
+            mr_free(incoming);
+            continue;
+        }
+        *(p++) = '\0';
+        while (*p == ' ') {
+            p++;
+        }
+        *label = incoming;
+        *value = p;
+        log_msg(10,"Found in raidtab pair: %s|%s",*label,*value);
+        return (0);
+    }
+    return (1);
+}
+
+
+/**
+ * Save the additional RAID variables to a stream.
+ * @param vars The RAID variable list to save.
+ * @param fout The FILE pointer to save them to.
+ */
+void
+save_additional_vars_to_file(struct additional_raid_variables *vars,
+                             FILE * fout)
+{
+    int i;
+
+    assert(vars != NULL);
+    assert(fout != NULL);
+
+    for (i = 0; i < vars->entries; i++) {
+        fprintf(fout, "    %-21s %s\n", vars->el[i].label,
+                vars->el[i].value);
+    }
+}
+
+
 
 
@@ -341 +424 @@
 }
 
-
-/**
- * Save the additional RAID variables to a stream.
- * @param vars The RAID variable list to save.
- * @param fout The FILE pointer to save them to.
- */
-void
-save_additional_vars_to_file(struct additional_raid_variables *vars,
-                             FILE * fout)
-{
-    int i;
-
-    assert(vars != NULL);
-    assert(fout != NULL);
-
-    for (i = 0; i < vars->entries; i++) {
-        fprintf(fout, "    %-21s %s\n", vars->el[i].label,
-                vars->el[i].value);
-    }
-}
-
-
 /**
  * Save a raidlist structure to disk in raidtab format.
@@ -412 +473 @@
     paranoid_fclose(fout);
     return (0);
-}
-
-
-/**
- * Save a disklist to a stream in raidtab format.
- * @param listname One of "raid-disk", "spare-disk", "parity-disk", or "failed-disk".
- * @param disklist The disklist to save to @p fout.
- * @param fout The stream to write to.
- */
-void save_disklist_to_file(const char *listname, struct list_of_disks *disklist, FILE * fout)
-{
-    int i;
-
-    assert_string_is_neither_NULL_nor_zerolength(listname);
-    assert(disklist != NULL);
-    assert(fout != NULL);
-
-    for (i = 0; i < disklist->entries; i++) {
-        fprintf(fout, "    device                %s\n", disklist->el[i].device);
-        fprintf(fout, "    %-21s %d\n", listname, disklist->el[i].index);
-    }
-}
-/**
- * Retrieve the next line from a raidtab stream.
- * @param fin The file to read the input from.
- * @param label Where to put the line's label.
- * @param value Where to put the line's value.
- * @return 0 if the line was read and stored successfully, 1 if we're at end of file.
- */
-static int get_next_raidtab_line(FILE * fin, char **label, char **value)
-{
-    char *incoming = NULL;
-    char *p = NULL;
-    char *res = NULL;
-
-    assert(fin != NULL);
-
-    if (feof(fin)) {
-        return (1);
-    }
-
-    for (mr_getline(res, fin); !feof(fin); mr_getline(res, fin)) {
-        log_msg(10,"Found in raidtab line: %s",res);
-        incoming = mr_strip_spaces(res);
-        mr_free(res);
-        p = strchr(incoming, ' ');
-        if (strlen(incoming) < 3 || incoming[0] == '#' || !p) {
-            mr_free(incoming);
-            continue;
-        }
-        *(p++) = '\0';
-        while (*p == ' ') {
-            p++;
-        }
-        *label = incoming;
-        *value = p;
-        log_msg(10,"Found in raidtab pair: %s|%s",*label,*value);
-        return (0);
-    }
-    return (1);
 }
 

branches/3.3/mondo/src/common/libmondo-stream.c

@@ -80 +80 @@
 
 
+
+
+/**
+ * Log (to screen) an erroneous marker, along with what it should have been.
+ * @param should_be What we were expecting.
+ * @param it_is What we got.
+ */
+void wrong_marker(int should_be, int it_is)
+{
+    char *tmp1 = NULL;
+    char *tmp2 = NULL;
+    tmp1 =  marker_to_string(should_be);
+    tmp2 =  marker_to_string(it_is);
+    log_to_screen("Wrong marker! (Should be %s, is actually %s)", tmp1, tmp2);
+    mr_free(tmp1);
+    mr_free(tmp2);
+}
+
+
+
+
+/**
+ * Read a header block from the currently opened stream (CD or tape).
+ * This block indicates the length of the following file (if it's file-related)
+ * the filename (if it's file-related), and the block type.
+ * @param plen Where to put the length of the file. Valid only for file-related header blocks.
+ * @param filename Where to put the name of the file. Valid only for file-related header blocks.
+ * @param pcontrol_char Where to put the type of block (e.g. start-file, end-file, start-tape, ...)
+ * @return 0 for success, nonzero for failure.
+ * @note If you read a marker (@p pcontrol_char) you're not expecting, you can call wrong_marker().
+ */
+int
+read_header_block_from_stream(long long *plen, char *filename,
+                              int *pcontrol_char)
+{
+
+    /*@ buffers ***************************************************** */
+    char *tempblock;
+    char *tmp = NULL;
+
+    /*@ int ********************************************************* */
+    int i, retval;
+
+    /*@ end vars *************************************************** */
+
+    tempblock = (char *) malloc((size_t) TAPE_BLOCK_SIZE);
+
+    for (i = 0; i < (int) TAPE_BLOCK_SIZE; i++) {
+        tempblock[i] = 0;
+    }
+    while (!(*pcontrol_char = tempblock[7000])) {
+        g_tape_posK += fread(tempblock, 1, (size_t) TAPE_BLOCK_SIZE, g_tape_stream) / 1024;
+    }
+    memcpy((char *) plen, tempblock + 7001, sizeof(long long));
+    if (strcmp(tempblock + 6000 + *pcontrol_char, STR_HEADER)) {
+        log_it("Bad header block at %ld K", (long) g_tape_posK);
+    }
+    strcpy(filename, tempblock + 1000);
+    if (*pcontrol_char == BLK_ABORTED_BACKUP) {
+        log_to_screen("I can't verify an aborted backup.");
+        retval = 1;
+    } else {
+        retval = 0;
+    }
+    for (i = 1000; i < 1020; i++) {
+        if (tempblock[i] < 32 || tempblock[i] > 126) {
+            tempblock[i] = ' ';
+        }
+    }
+    tempblock[i] = '\0';
+    tmp = marker_to_string(*pcontrol_char);
+    log_msg(6, "%s (fname=%s, size=%ld K)", tmp, tempblock + 1000, (long) (*plen) >> 10);
+    mr_free(tmp);
+    paranoid_free(tempblock);
+    return (retval);
+}
 
 
@@ -206 +282 @@
 }
 
-
-
-
-/**
- * Log (to screen) an erroneous marker, along with what it should have been.
- * @param should_be What we were expecting.
- * @param it_is What we got.
- */
-void wrong_marker(int should_be, int it_is)
-{
-    char *tmp1 = NULL;
-    char *tmp2 = NULL;
-    tmp1 =  marker_to_string(should_be);
-    tmp2 =  marker_to_string(it_is);
-    log_to_screen("Wrong marker! (Should be %s, is actually %s)", tmp1, tmp2);
-    mr_free(tmp1);
-    mr_free(tmp2);
-}
-
-
-
-/**
- * Read a header block from the currently opened stream (CD or tape).
- * This block indicates the length of the following file (if it's file-related)
- * the filename (if it's file-related), and the block type.
- * @param plen Where to put the length of the file. Valid only for file-related header blocks.
- * @param filename Where to put the name of the file. Valid only for file-related header blocks.
- * @param pcontrol_char Where to put the type of block (e.g. start-file, end-file, start-tape, ...)
- * @return 0 for success, nonzero for failure.
- * @note If you read a marker (@p pcontrol_char) you're not expecting, you can call wrong_marker().
- */
-int
-read_header_block_from_stream(long long *plen, char *filename,
-                              int *pcontrol_char)
-{
-
-    /*@ buffers ***************************************************** */
-    char *tempblock;
-    char *tmp = NULL;
-
-    /*@ int ********************************************************* */
-    int i, retval;
-
-    /*@ end vars *************************************************** */
-
-    tempblock = (char *) malloc((size_t) TAPE_BLOCK_SIZE);
-
-    for (i = 0; i < (int) TAPE_BLOCK_SIZE; i++) {
-        tempblock[i] = 0;
-    }
-    while (!(*pcontrol_char = tempblock[7000])) {
-        g_tape_posK += fread(tempblock, 1, (size_t) TAPE_BLOCK_SIZE, g_tape_stream) / 1024;
-    }
-    memcpy((char *) plen, tempblock + 7001, sizeof(long long));
-    if (strcmp(tempblock + 6000 + *pcontrol_char, STR_HEADER)) {
-        log_it("Bad header block at %ld K", (long) g_tape_posK);
-    }
-    strcpy(filename, tempblock + 1000);
-    if (*pcontrol_char == BLK_ABORTED_BACKUP) {
-        log_to_screen("I can't verify an aborted backup.");
-        retval = 1;
-    } else {
-        retval = 0;
-    }
-    for (i = 1000; i < 1020; i++) {
-        if (tempblock[i] < 32 || tempblock[i] > 126) {
-            tempblock[i] = ' ';
-        }
-    }
-    tempblock[i] = '\0';
-    tmp = marker_to_string(*pcontrol_char);
-    log_msg(6, "%s (fname=%s, size=%ld K)", tmp, tempblock + 1000, (long) (*plen) >> 10);
-    mr_free(tmp);
-    paranoid_free(tempblock);
-    return (retval);
-}
 
 
@@ -561 +561 @@
     return (dev);
 }
+
+
+/**
+ * Seek through the stream until we find a header block where the NAME field matches
+ * @p the_file_I_was_reading. This is useful if you've just started reading from
+ * a new tape and want to find the file you were reading when the tape ended.
+ * @param the_file_I_was_reading File name to look for.
+ * @return 0 for success, nonzero for failure.
+ */
+int skip_incoming_files_until_we_find_this_one(char
+                                               *the_file_I_was_reading)
+{
+    char *pA;
+    char *pB;
+    int res;
+    int ctrl_chr;
+    char *temp_fname;
+    char *datablock;
+    long long temp_size, size;
+    long bytes_to_write;
+
+    datablock = malloc(TAPE_BLOCK_SIZE);
+    malloc_string(temp_fname);
+    pB = strrchr(the_file_I_was_reading, '/');
+    if (pB) {
+        pB++;
+    } else {
+        pB = the_file_I_was_reading;
+    }
+    log_msg(1, "skip_incoming_..(%s)", pB);
+    log_msg(2, "Looking for initial START_AN_AFIO_OR_SLICE");
+    ctrl_chr = -1;
+    while (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
+        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
+        if (res) {
+            // FIXME
+        }
+        if (ctrl_chr == BLK_START_AN_AFIO_OR_SLICE) {
+            break;
+        }
+        log_msg(1, "%lld %s %c", temp_size, temp_fname, ctrl_chr);
+        wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
+        log_msg(3, "Still trying to re-sync w/ tape");
+    }
+    while (ctrl_chr != BLK_START_FILE) {
+        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
+        if (res) {
+            //FIXME
+        }
+        if (ctrl_chr == BLK_START_FILE) {
+            break;
+        }
+        log_msg(1, "%lld %s %c", temp_size, temp_fname, ctrl_chr);
+        wrong_marker(BLK_START_FILE, ctrl_chr);
+        log_msg(3, "Still trying to re-sync w/ tape");
+    }
+    pA = strrchr(temp_fname, '/');
+    if (pA) {
+        pA++;
+    } else {
+        pA = temp_fname;
+    }
+    pB = strrchr(the_file_I_was_reading, '/');
+    if (pB) {
+        pB++;
+    } else {
+        pB = the_file_I_was_reading;
+    }
+    while (strcmp(pA, pB)) {
+        log_msg(6, "Skipping %s (it's not %s)", temp_fname, the_file_I_was_reading);
+        for (size = temp_size; size > 0; size -= bytes_to_write) {
+            bytes_to_write =
+                (size < TAPE_BLOCK_SIZE) ? (long) size : TAPE_BLOCK_SIZE;
+            if (fread(datablock, 1, (size_t) TAPE_BLOCK_SIZE, g_tape_stream)) {
+                // FIXME - needs error-checking and -catching
+            }
+        }
+        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
+        if (ctrl_chr != BLK_STOP_FILE) {
+            wrong_marker(BLK_STOP_FILE, ctrl_chr);
+        }
+        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
+        if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
+            wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
+        }
+        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
+        if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
+            wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
+        }
+        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
+        if (ctrl_chr != BLK_START_FILE) {
+            wrong_marker(BLK_START_FILE, ctrl_chr);
+        }
+        pA = strrchr(temp_fname, '/');
+        if (pA) {
+            pA++;
+        } else {
+            pA = temp_fname;
+        }
+        pB = strrchr(the_file_I_was_reading, '/');
+        if (pB) {
+            pB++;
+        } else {
+            pB = the_file_I_was_reading;
+        }
+    }
+    log_msg(2, "Reading %s (it matches %s)", temp_fname, the_file_I_was_reading);
+    paranoid_free(temp_fname);
+    paranoid_free(datablock);
+    return (0);
+}
+
+
+/**
+ * Start to read from the next tape. Assumes the user has already inserted it.
+ * @param bkpinfo The backup information structure. @c bkpinfo->media_device is the only field used.
+ * @return 0 for success, nonzero for failure.
+ */
+int start_to_read_from_next_tape()
+{
+    /*@ int ********************************************************* */
+    int res = 0;
+    char *sz_msg;
+    int ctrlchr;
+    long long temp_size;
+    malloc_string(sz_msg);
+    /*@ end vars *************************************************** */
+
+    if (bkpinfo->media_device == NULL) {
+        log_it("Unable to open in from NULL device");
+        return (1);
+    }
+
+    paranoid_pclose(g_tape_stream);
+    sync();
+    sync();
+    sync();
+    log_it("Next tape requested.");
+    insist_on_this_tape_number(g_current_media_number + 1); // will increment it, too
+    log_it("Opening IN the next tape");
+    if (!(g_tape_stream = open_device_via_buffer(bkpinfo->media_device, 'r', bkpinfo->internal_tape_block_size))) {
+        log_OS_error(g_tape_fifo);
+        log_to_screen("Cannot openin stream device");
+        return (1);
+    }
+    g_tape_posK = 0;
+    g_sigpipe = FALSE;
+    res += read_header_block_from_stream(&temp_size, sz_msg, &ctrlchr); /* just in case */
+    if (ctrlchr != BLK_START_OF_TAPE) {
+        wrong_marker(BLK_START_OF_TAPE, ctrlchr);
+    }
+    res += read_header_block_from_stream(&temp_size, sz_msg, &ctrlchr); /* just in case */
+    if (ctrlchr != BLK_START_OF_BACKUP) {
+        wrong_marker(BLK_START_OF_BACKUP, ctrlchr);
+    } else {
+        log_msg(3, "Next tape opened OK. Whoopee!");
+    }
+    paranoid_free(sz_msg);
+    return (res);
+}
+
 
 
@@ -1404 +1565 @@
 
 /**
- * Seek through the stream until we find a header block where the NAME field matches
- * @p the_file_I_was_reading. This is useful if you've just started reading from
- * a new tape and want to find the file you were reading when the tape ended.
- * @param the_file_I_was_reading File name to look for.
- * @return 0 for success, nonzero for failure.
- */
-int skip_incoming_files_until_we_find_this_one(char
-                                               *the_file_I_was_reading)
-{
-    char *pA;
-    char *pB;
-    int res;
-    int ctrl_chr;
-    char *temp_fname;
-    char *datablock;
-    long long temp_size, size;
-    long bytes_to_write;
-
-    datablock = malloc(TAPE_BLOCK_SIZE);
-    malloc_string(temp_fname);
-    pB = strrchr(the_file_I_was_reading, '/');
-    if (pB) {
-        pB++;
-    } else {
-        pB = the_file_I_was_reading;
-    }
-    log_msg(1, "skip_incoming_..(%s)", pB);
-    log_msg(2, "Looking for initial START_AN_AFIO_OR_SLICE");
-    ctrl_chr = -1;
-    while (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
-        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
-        if (res) {
-            // FIXME
-        }
-        if (ctrl_chr == BLK_START_AN_AFIO_OR_SLICE) {
-            break;
-        }
-        log_msg(1, "%lld %s %c", temp_size, temp_fname, ctrl_chr);
-        wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
-        log_msg(3, "Still trying to re-sync w/ tape");
-    }
-    while (ctrl_chr != BLK_START_FILE) {
-        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
-        if (res) {
-            //FIXME
-        }
-        if (ctrl_chr == BLK_START_FILE) {
-            break;
-        }
-        log_msg(1, "%lld %s %c", temp_size, temp_fname, ctrl_chr);
-        wrong_marker(BLK_START_FILE, ctrl_chr);
-        log_msg(3, "Still trying to re-sync w/ tape");
-    }
-    pA = strrchr(temp_fname, '/');
-    if (pA) {
-        pA++;
-    } else {
-        pA = temp_fname;
-    }
-    pB = strrchr(the_file_I_was_reading, '/');
-    if (pB) {
-        pB++;
-    } else {
-        pB = the_file_I_was_reading;
-    }
-    while (strcmp(pA, pB)) {
-        log_msg(6, "Skipping %s (it's not %s)", temp_fname, the_file_I_was_reading);
-        for (size = temp_size; size > 0; size -= bytes_to_write) {
-            bytes_to_write =
-                (size < TAPE_BLOCK_SIZE) ? (long) size : TAPE_BLOCK_SIZE;
-            if (fread(datablock, 1, (size_t) TAPE_BLOCK_SIZE, g_tape_stream)) {
-                // FIXME - needs error-checking and -catching
-            }
-        }
-        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
-        if (ctrl_chr != BLK_STOP_FILE) {
-            wrong_marker(BLK_STOP_FILE, ctrl_chr);
-        }
-        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
-        if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
-            wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
-        }
-        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
-        if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
-            wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
-        }
-        res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
-        if (ctrl_chr != BLK_START_FILE) {
-            wrong_marker(BLK_START_FILE, ctrl_chr);
-        }
-        pA = strrchr(temp_fname, '/');
-        if (pA) {
-            pA++;
-        } else {
-            pA = temp_fname;
-        }
-        pB = strrchr(the_file_I_was_reading, '/');
-        if (pB) {
-            pB++;
-        } else {
-            pB = the_file_I_was_reading;
-        }
-    }
-    log_msg(2, "Reading %s (it matches %s)", temp_fname, the_file_I_was_reading);
-    paranoid_free(temp_fname);
-    paranoid_free(datablock);
-    return (0);
-}
-
-
-/**
- * Start to read from the next tape. Assumes the user has already inserted it.
- * @param bkpinfo The backup information structure. @c bkpinfo->media_device is the only field used.
- * @return 0 for success, nonzero for failure.
- */
-int start_to_read_from_next_tape()
-{
-    /*@ int ********************************************************* */
-    int res = 0;
-    char *sz_msg;
-    int ctrlchr;
-    long long temp_size;
-    malloc_string(sz_msg);
-    /*@ end vars *************************************************** */
-
-    if (bkpinfo->media_device == NULL) {
-        log_it("Unable to open in from NULL device");
-        return (1);
-    }
-
-    paranoid_pclose(g_tape_stream);
-    sync();
-    sync();
-    sync();
-    log_it("Next tape requested.");
-    insist_on_this_tape_number(g_current_media_number + 1); // will increment it, too
-    log_it("Opening IN the next tape");
-    if (!(g_tape_stream = open_device_via_buffer(bkpinfo->media_device, 'r', bkpinfo->internal_tape_block_size))) {
-        log_OS_error(g_tape_fifo);
-        log_to_screen("Cannot openin stream device");
-        return (1);
-    }
-    g_tape_posK = 0;
-    g_sigpipe = FALSE;
-    res += read_header_block_from_stream(&temp_size, sz_msg, &ctrlchr); /* just in case */
-    if (ctrlchr != BLK_START_OF_TAPE) {
-        wrong_marker(BLK_START_OF_TAPE, ctrlchr);
-    }
-    res += read_header_block_from_stream(&temp_size, sz_msg, &ctrlchr); /* just in case */
-    if (ctrlchr != BLK_START_OF_BACKUP) {
-        wrong_marker(BLK_START_OF_BACKUP, ctrlchr);
-    } else {
-        log_msg(3, "Next tape opened OK. Whoopee!");
-    }
-    paranoid_free(sz_msg);
-    return (res);
-}
-
-
-
-/**
  * Copy a file from the currently opened stream (CD or tape) to the stream indicated
  * by @p fout.

branches/3.3/mondo/src/common/libmondo-tools-EXT.h

@@ -4 +4 @@
 extern long get_time();
 extern char *mr_date(void);
-extern void (*log_debug_msg) (int debug_level, const char *szFile,
-                              const char *szFunction, int nLine,
-                              const char *fmt, ...);
-extern void standard_log_debug_msg(int debug_level, const char *szFile,
-                                   const char *szFunction, int nLine,
-                                   const char *fmt, ...);
 extern int read_cfg_var(char *config_file, char *label, char *value);
 extern int write_cfg_var(char *config_file, char *label, char *value);
@@ -45 +39 @@
 extern char *get_uname_m();
 
-extern bool does_nonMS_partition_exist(void);
-
-
 extern void stop_magicdev_if_necessary(void);
 extern void restart_magicdev_if_necessary(void);

branches/3.3/mondo/src/common/libmondo-tools.c

@@ -74 +74 @@
 
 extern t_bkptype g_backup_media_type;
-
-extern bool am_I_in_disaster_recovery_mode(void);
 
 /*-----------------------------------------------------------*/

branches/3.3/mondo/src/include/my-stuff.h

@@ -5 +5 @@
 #define HAVE_MALLOC 1
 
-
-// Extra info for ACLs and SELINUX users
-#define STAR_ACL_SZ "-xattr -acl"
-
 /**
  * @file
@@ -25 +21 @@
 #ifndef _MY_STUFF_H_
 #define _MY_STUFF_H_
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
 
 #ifndef __FreeBSD__
@@ -83 +75 @@
  */
 #define MONDO_CACHE "/var/cache/mondo"
+#define ARCHIVES_PATH MNT_CDROM"/archives"
+#define BIGGIELIST ARCHIVES_PATH"/biggielist.txt"
 
 /**
@@ -109 +103 @@
 #define assert(exp) ((exp)?((void)0):_mondo_assert_fail(__FILE__, __FUNCTION__, __LINE__, #exp))
 #endif
+
+// Extra info for ACLs and SELINUX users
+#define STAR_ACL_SZ "-xattr -acl"
 
 #define CRC_M16 0xA001          ///< Mask for crc16.
@@ -351 +348 @@
 #define MONDO_MNTLISTCHG "/tmp/mountlist.changed"
 
+extern void (*log_debug_msg) (int debug_level, const char *szFile,
+                              const char *szFunction, int nLine,
+                              const char *fmt, ...);
+extern void standard_log_debug_msg(int debug_level, const char *szFile,
+                                   const char *szFunction, int nLine,
+                                   const char *fmt, ...);
 
 /**

branches/3.3/mondo/src/mondoarchive/mondoarchive.c

@@ -12 +12 @@
 #include "mr_str.h"
 #include "mr_msg.h"
-#include "../common/mondostructures.h"
-#include "../common/libmondo.h"
-#include "../common/libmondo-cli-EXT.h"
-#include "../common/libmondo-tools-EXT.h"
+#include "mondostructures.h"
+#include "libmondo-cli-EXT.h"
+#include "libmondo-tools-EXT.h"
+#include "libmondo-archive-EXT.h"
+#include "libmondo-fork-EXT.h"
+#include "libmondo-files-EXT.h"
+#include "libmondo-filelist-EXT.h"
+#include "libmondo-raid-EXT.h"
+#include "libmondo-devices-EXT.h"
+#include "newt-specific-EXT.h"
 #include "mondoarchive.h"
 

branches/3.3/mondo/src/mondorestore/Makefile.am

@@ -7 +7 @@
 
 ## Headers
-noinst_HEADERS        = mondorestore.h mondo-rstr-compare.h mondo-rstr-newt.h mondo-rstr-tools.h \
-                        mondorestore-EXT.h mr-externs.h \
-                        mondo-rstr-compare-EXT.h mondo-rstr-tools-EXT.h mondoprep.h \
-                        libmondo-mountlist.h libmondo-mountlist-EXT.h \
-                        mondorestore.h
+noinst_HEADERS        = mondorestore.h \
+                        mondo-rstr-compare-EXT.h mondo-rstr-tools-EXT.h \
+                        libmondo-mountlist-EXT.h
 
 ## The program

branches/3.3/mondo/src/mondorestore/mondo-prep.c

@@ -5 +5 @@
 
 
-#include "my-stuff.h"
-#include "mr_mem.h"
-#include "../common/mondostructures.h"
-#include "mondoprep.h"
-#include "../common/libmondo.h"
-#include "../common/libmondo-tools-EXT.h"
-#include "mondo-rstr-tools-EXT.h"
-#include "libmondo-mountlist-EXT.h"
 #include <sys/ioctl.h>
 #include <linux/hdreg.h>
 #include <math.h>
+#include "my-stuff.h"
+#include "mr_mem.h"
+#include "mondostructures.h"
+#include "mondo-rstr-tools-EXT.h"
+#include "libmondo-mountlist-EXT.h"
+#include "libmondo-tools-EXT.h"
+#include "libmondo-gui-EXT.h"
+#include "libmondo-devices-EXT.h"
+#include "libmondo-fork-EXT.h"
+#include "libmondo-string-EXT.h"
+#include "libmondo-files-EXT.h"
+#include "newt-specific-EXT.h"
 
 
@@ -32 +36 @@
 #endif
 
-#define ARCHIVES_PATH MNT_CDROM"/archives"
 #define MONDO_WAS_HERE "MONDOWOZEREMONDOWOZEREMONDOWOZEREhahahaMOJOJOJO"
 
@@ -39 +42 @@
 extern char *g_mountlist_fname;
 extern long g_current_progress, g_maximum_progress;
-
 extern bool g_text_mode;
+extern int g_currentY;
+
 
 extern void pause_for_N_seconds(int, char *);
@@ -628 +632 @@
 
 
+
+/**
+ * Stop @p raid_device using @p raidstop.
+ * @param raid_device The software RAID device to stop.
+ * @return 0 for success, nonzero for failure.
+ */
+int stop_raid_device(char *raid_device) {
+
+/** int *************************************************************/
+int res;
+int retval = 0;
+
+/** buffers *********************************************************/
+char *program = NULL;
+
+/** end *************************************************************/
+
+assert_string_is_neither_NULL_nor_zerolength(raid_device);
+
+#ifdef __FreeBSD__
+if (is_this_device_mounted(raid_device)) {
+    log_it("Can't stop %s when it's mounted!", raid_device);
+    return 1;
+}
+mr_asprintf(program, "vinum stop -f %s", raid_device);
+#else
+// use raidstop if it exists, otherwise use mdadm
+if (run_program_and_log_output("which raidstop", FALSE)) {
+    mr_asprintf(program, "mdadm -S %s", raid_device);
+} else {
+    mr_asprintf(program, "raidstop %s", raid_device);
+}
+#endif
+log_msg(1, "program = %s", program);
+res = run_program_and_log_output(program, 1);
+if (g_fprep) {
+    fprintf(g_fprep, "%s\n", program);
+}
+mr_free(program);
+
+if (res) {
+    log_msg(1, "Warning - failed to stop RAID device %s", raid_device);
+}
+retval += res;
+return (retval);
+}
+
+
+
+int start_raid_device(char *raid_device) {
+
+/** int *************************************************************/
+int res;
+int retval = 0;
+
+/** buffers *********************************************************/
+char *program = NULL;
+
+/** end *************************************************************/
+
+assert_string_is_neither_NULL_nor_zerolength(raid_device);
+
+#ifdef __FreeBSD__
+if (is_this_device_mounted(raid_device)) {
+    log_it("Can't start %s when it's mounted!", raid_device);
+    return 1;
+}
+mr_asprintf(program, "vinum start -f %s", raid_device);
+#else
+mr_asprintf(program, "raidstart %s", raid_device);
+#endif
+log_msg(1, "program = %s", program);
+res = run_program_and_log_output(program, 1);
+if (g_fprep) {
+    fprintf(g_fprep, "%s\n", program);
+}
+mr_free(program);
+
+if (res) {
+    log_msg(1, "Warning - failed to start RAID device %s", raid_device);
+}
+retval += res;
+sleep(1);
+return (retval);
+}
+
+
+/**
+ * Decide which command we need to use to format a device of type @p format.
+ * @param format The filesystem type we are about to format.
+ * @param program Where to put the binary name for this format.
+ * @return 0 for success, nonzero for failure.
+ */
+char *which_format_command_do_i_need(char *format) {
+
+char *program = NULL;
+
+assert_string_is_neither_NULL_nor_zerolength(format);
+
+if (strcmp(format, "swap") == 0) {
+#ifdef __FreeBSD__
+    mr_asprintf(program, "true");
+#else
+    mr_asprintf(program, "mkswap -f");
+#endif
+} else if (strcmp(format, "vfat") == 0) {
+#ifdef __FreeBSD__
+    mr_asprintf(program, "newfs_msdos -F 32");
+#else
+#ifdef __IA64__
+    /* For EFI partitions on ia64 take fat16 
+     * as we want to make small ones */
+    mr_asprintf(program, "mkfs.vfat -F 16");
+#else
+    /* mkfs.vfat will make the best possible choice itself */
+    /* should avoid problems with mr-label later on when used */
+    mr_asprintf(program, "mkfs.vfat");
+#endif
+#endif
+#ifndef __FreeBSD__
+} else if (strcmp(format, "reiserfs") == 0) {
+    mr_asprintf(program, "mkreiserfs -ff");
+} else if (strcmp(format, "xfs") == 0) {
+    /*  Cf: https://bugzilla.redhat.com/show_bug.cgi?id=1309498 */
+    mr_asprintf(program, "mkfs.xfs -f -q -m crc=0 -n ftype=0");
+} else if (strcmp(format, "jfs") == 0) {
+    mr_asprintf(program, "mkfs.jfs");
+} else if (strcmp(format, "ext3") == 0) {
+    mr_asprintf(program, "mkfs -t ext3 -F -q");
+} else if (strcmp(format, "ext4") == 0) {
+    mr_asprintf(program, "mkfs -t ext4 -F -q");
+} else if (strcmp(format, "btrfs") == 0) {
+    mr_asprintf(program, "mkfs.btrfs -f");
+} else if (strcmp(format, "minix") == 0) {
+    mr_asprintf(program, "mkfs.minix");
+} else if (strcmp(format, "vmfs") == 0) {
+    mr_asprintf(program, "mkfs -t vmfs");
+} else if (strcmp(format, "ntfs") == 0) { 
+    /* 
+     * mkfs.ntfs treats the '-c' switch as 'specify cluster size' 
+     * so the default "mkfs -t %s -c" command structure fails 
+     */ 
+    mr_asprintf(program, "mkfs -t ntfs");
+} else if (strcmp(format, "ocfs2") == 0) {
+    /*
+     * For existing OCFS2 volumes, mkfs.ocfs2 ensures the volume is not mounted on any node in the cluster before formatting. For that to work, mkfs.ocfs2 expects the O2CB cluster service to be running. Specify this option to disable this check.
+     *
+     */
+    mr_asprintf(program, "mkfs -t ocfs2 -F");
+#endif
+} else if (strcmp(format, "ext2") == 0) {
+    mr_asprintf(program, "mke2fs -F -q");
+} else {
+#ifdef __FreeBSD__
+    mr_asprintf(program, "newfs_%s", format);
+#else
+    mr_asprintf(program, "mkfs -t %s -c", format);  // -c checks for bad blocks
+#endif
+    log_it("Unknown format (%s) - assuming '%s' will do", format, program);
+}
+return(program);
+}
+
+
+
 /**
  * Format @p device as a @p format filesystem.
@@ -821 +990 @@
 return (retval);
 }
+
+
+/**
+ * Stop all software RAID devices listed in @p mountlist.
+ * @param mountlist The mountlist to stop the RAID devices in.
+ * @return The number of errors encountered (0 for success).
+ * @bug @p mountlist is not used.
+ */
+int stop_all_raid_devices(struct mountlist_itself *mountlist) {
+
+/** int *************************************************************/
+int retval = 0;
+
+/** char ************************************************************/
+char *incoming;
+#ifndef __FreeBSD__
+char *dev;
+#endif
+/** pointers ********************************************************/
+#ifndef __FreeBSD__
+char *p;
+#endif
+FILE *fin;
+char *q;
+int i;
+
+/** end ****************************************************************/
+
+malloc_string(incoming);
+assert(mountlist != NULL);
+
+for (i = 0; i < 3; i++) {
+#ifdef __FreeBSD__
+    fin = popen("vinum list | grep '^[PVS]' | sed 's/S/1/;s/P/2/;s/V/3/' | sort | cut -d' ' -f2", "r");
+    if (!fin) {
+        paranoid_free(incoming);
+        return (1);
+    }
+    for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL); q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
+        retval += stop_raid_device(incoming);
+    }
+#else
+    fin = fopen("/proc/mdstat", "r");
+    if (!fin) {
+        log_OS_error("/proc/mdstat");
+        paranoid_free(incoming);
+        return (1);
+    }
+    for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL); q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
+        for (p = incoming; *p != '\0' && (*p != 'm' || *(p + 1) != 'd' || !isdigit(*(p + 2))); p++);
+        if (*p != '\0') {
+            malloc_string(dev);
+            sprintf(dev, "/dev/%s", p);
+            for (p = dev; *p > 32; p++);
+            *p = '\0';
+            retval += stop_raid_device(dev);
+            paranoid_free(dev);
+        }
+    }
+#endif
+}
+paranoid_fclose(fin);
+if (retval) {
+    log_msg(1, "Warning - unable to stop some RAID devices");
+}
+paranoid_free(incoming);
+paranoid_system("sync");
+paranoid_system("sync");
+paranoid_system("sync");
+sleep(1);
+return (retval);
+}
+
+
 
 
@@ -984 +1227 @@
 paranoid_system("clear");
 newtResume();
+return (retval);
+}
+
+
+/**
+ * Set the type of partition number @p partno on @p drive to @p format.
+ * @param drive The drive to change the type of a partition on.
+ * @param partno The partition number on @p drive to change the type of.
+ * @param format The filesystem type this partition will eventually contain.
+ * @param partsize The size of this partition, in @e bytes (used for vfat
+ * type calculations).
+ * @return 0 for success, nonzero for failure.
+ */
+int set_partition_type(FILE * pout_to_fdisk, const char *drive, int partno, const char *format, long long partsize) {
+
+/** buffers *********************************************************/
+char *partition = NULL;
+char *command = NULL;
+char *output = NULL;
+char *tmp = NULL;
+char *partcode = NULL;
+
+/** pointers *********************************************************/
+FILE *fout;
+
+/** int **************************************************************/
+int res = 0;
+
+/** end **************************************************************/
+
+assert_string_is_neither_NULL_nor_zerolength(drive);
+assert(format != NULL);
+
+partition = build_partition_name(drive, partno);
+if (strcmp(format, "swap") == 0) {
+    mr_asprintf(partcode, "82");
+} else if (strcmp(format, "vfat") == 0) {
+    if (partsize / 1024 > 8192) {
+        mr_asprintf(partcode, "c");
+    } else {
+        mr_asprintf(partcode, "b");
+    }
+} else if (strcmp(format, "ext2") == 0
+             || strcmp(format, "reiserfs") == 0
+             || strcmp(format, "ext3") == 0 
+             || strcmp(format, "ext4") == 0 
+             || strcmp(format, "xfs") == 0
+             || strcmp(format, "jfs") == 0
+             || strcmp(format, "btrfs") == 0) {
+    mr_asprintf(partcode, "83");
+} else if (strcmp(format, "minix") == 0) {
+    mr_asprintf(partcode, "81");
+} else if (strcmp(format, "vmfs3") == 0) {
+    mr_asprintf(partcode, "fb");
+} else if (strcmp(format, "vmkcore") == 0) {
+    mr_asprintf(partcode, "fc");
+} else if (strcmp(format, "raid") == 0) {
+    mr_asprintf(partcode, "fd");
+} else if (strcmp(format, "ntfs") == 0) {
+    mr_asprintf(partcode, "7");
+} else if ((strcmp(format, "ufs") == 0)
+             || (strcmp(format, "ffs") == 0)) { /* raid autodetect */
+    mr_asprintf(partcode, "a5");
+} else if (strcmp(format, "lvm") == 0) {
+    mr_asprintf(partcode, "8e");
+} else if (format[0] == '\0') { /* LVM physical partition */
+    mr_asprintf(partcode, "");
+} else if (strlen(format) >= 1 && strlen(format) <= 2) {
+    mr_asprintf(partcode, "%s", format);
+} else {
+    /* probably an image */
+    mr_asprintf(tmp, "Unknown format ('%s') - using supplied string anyway", format);
+    mvaddstr_and_log_it(g_currentY++, 0, tmp);
+    mr_free(tmp);
+
+#ifdef __FreeBSD__
+    mr_asprintf(partcode, "%s", format);    // was a5
+#else
+    mr_asprintf(partcode, "%s", format);    // was 83
+#endif
+}
+log_msg(1, "Setting %s's type to %s (%s)", partition, format, partcode);
+mr_free(partition);
+
+if ((strcmp(partcode,"") != 0) && strcmp(partcode, "83")) { /* no need to set type if 83: 83 is default */
+
+    if (pout_to_fdisk) {
+        res = 0;
+        fput_string_one_char_at_a_time(pout_to_fdisk, "t\n");
+        if (partno > 1
+            || strstr(last_line_of_file(FDISK_LOG), " (1-4)")) {
+            log_msg(5, "Specifying partno (%d) - yay", partno);
+            mr_asprintf(tmp, "%d\n", partno);
+            fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
+            log_msg(5, "A - last line = '%s'", last_line_of_file(FDISK_LOG));
+            mr_free(tmp);
+        }
+
+        mr_asprintf(tmp, "%s\n", partcode);
+        fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
+        mr_free(tmp);
+
+        log_msg(5, "B - last line = '%s'",
+                last_line_of_file(FDISK_LOG));
+        fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
+        log_msg(5, "C - last line = '%s'",
+                last_line_of_file(FDISK_LOG));
+
+        mr_asprintf(tmp, "%s", last_line_of_file(FDISK_LOG));
+        if (!strstr(tmp, " (m ")) {
+            log_msg(1, "last line = '%s'; part type set failed", tmp);
+            res++;
+            fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
+        }
+        mr_free(tmp);
+
+        fput_string_one_char_at_a_time(pout_to_fdisk, "p\n");
+    } else {
+        mr_asprintf(output, "t\n%d\n%s\nw\n", partno, partcode);
+        mr_asprintf(command, "mr-parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE);
+        log_msg(5, "output = '%s'", output);
+        log_msg(5, "partno=%d; partcode=%s", partno, partcode);
+        log_msg(5, "command = '%s'", command);
+        fout = popen(command, "w");
+        if (!fout) {
+            log_OS_error(command);
+            res = 1;
+        } else {
+            res = 0;
+            fprintf(fout, "%s", output);
+            paranoid_pclose(fout);
+        }
+        mr_free(command);
+        paranoid_free(output);
+    }
+}
+mr_free(partcode);
+
+return (res);
+}
+
+
+/**
+ * Create partition number @p partno on @p drive with @p fdisk.
+ * @param drive The drive to create the partition on.
+//  * @param partno The partition number of the new partition (1-4 are primary, >=5 is logical).
+ * @param prev_partno The partition number of the most recently prepped partition.
+ * @param format The filesystem type of this partition (used to set the type).
+ * @param partsize The size of the partition in @e bytes.
+ * @return 0 for success, nonzero for failure.
+ */
+int partition_device(FILE * pout_to_fdisk, const char *drive, int partno, int prev_partno, const char *format, long long partsize) {
+
+/** int **************************************************************/
+int retval = 0;
+int res = 0;
+
+/** buffers **********************************************************/
+char *program = NULL;
+char *partition_name = NULL;
+char *tmp = NULL;
+char *output = NULL;
+
+/** pointers **********************************************************/
+char *part_table_fmt = NULL;
+FILE *fout;
+
+/** end ***************************************************************/
+
+assert_string_is_neither_NULL_nor_zerolength(drive);
+assert(format != NULL);
+
+log_it("partition_device('%s', %d, %d, '%s', %lld) --- starting", drive, partno, prev_partno, format, partsize);
+
+if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
+    log_it("Not partitioning %s - it is a virtual drive", drive);
+    return (0);
+}
+
+partition_name = build_partition_name(drive, partno);
+if (partsize <= 0) {
+    mr_asprintf(tmp, "Partitioning device %s (max size)", partition_name);
+} else {
+    mr_asprintf(tmp, "Partitioning device %s (%lld MB)", partition_name, (long long) partsize / 1024);
+}
+update_progress_form(tmp);
+log_it(tmp);
+mr_free(tmp);
+
+if (is_this_device_mounted(partition_name)) {
+    log_to_screen("%s is mounted, and should not be partitioned", partition_name);
+    mr_free(partition_name);
+    return (1);
+}
+
+
+mr_asprintf(program, "mr-parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE);
+
+/* TODO: should not be called each time */
+part_table_fmt = which_partition_format(drive);
+mr_asprintf(output, "");
+
+/* make it a primary/extended/logical */
+if (partno <= 4) {
+    mr_strcat(output, "n\np\n%d\n", partno);
+} else {
+    /* MBR needs an extended partition if more than 4 partitions */
+    if (strcmp(part_table_fmt, "MBR") == 0) {
+        if (partno == 5) {
+            if (prev_partno >= 4) {
+                log_to_screen("You need to leave at least one partition free, for 'extended/logical'");
+                mr_free(partition_name);
+                paranoid_free(output);
+                return (1);
+            } else {
+                mr_strcat(output, "n\ne\n%d\n\n\n", prev_partno + 1);
+            }
+        }
+        mr_strcat(output, "n\nl\n");
+    } else {
+        /* GPT allows more than 4 primary partitions */
+        mr_strcat(output, "n\np\n%d\n", partno);
+    }
+}
+mr_free(part_table_fmt);
+
+mr_strcat(output, "\n");    /*start block (ENTER for next free blk */
+if (partsize > 0) {
+    if (!strcmp(format, "7")) {
+        log_msg(1, "Adding 512K, just in case");
+        partsize += 512;
+    }
+    mr_strcat(output, "+%lldK", (long long) (partsize));
+}
+mr_strcat(output, "\n");
+#if 0
+/*
+#endif
+log_it("PARTSIZE = +%ld",(long)partsize);
+log_it("---fdisk command---");
+log_it(output);
+log_it("---end of fdisk---");
+#if 0
+*/
+#endif
+
+
+if (pout_to_fdisk) {
+    log_msg(1, "Doing the new all-in-one fdisk thing");
+    mr_strcat(output, "\n\np\n\n");
+    log_msg(1, "output = '%s'", output);
+    fput_string_one_char_at_a_time(pout_to_fdisk, output);
+    mr_asprintf(tmp, "%s", last_line_of_file(FDISK_LOG));
+    if (strstr(tmp, " (m ")) {
+        log_msg(1, "Successfully created partition %d on %s", partno, drive);
+    } else {
+        log_msg(1, "last line = %s", tmp);
+        log_msg(1, "Failed to create partition %d on %s; sending 'Enter'...", partno, drive);
+    }
+    mr_free(tmp);
+
+    if (!retval) {
+        log_msg(1, "Trying to set partition %d type now on %s", partno, drive);
+        retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
+        if (retval) {
+            log_msg(1, "Failed. Trying again...");
+            retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
+        }
+    }
+    if (retval) {
+        log_msg(1, "...but failed to set type");
+    }
+} else {
+    mr_strcat(output, "w\n\n");
+    if (g_fprep) {
+        fprintf(g_fprep, "echo \"%s\" | %s\n", output, program);
+    }
+    /* write to disk; close fdisk's stream */
+    if (!(fout = popen(program, "w"))) {
+        log_OS_error("can't popen-out to program");
+    } else {
+        fputs(output, fout);
+        paranoid_pclose(fout);
+    }
+
+    if (!does_partition_exist(drive, partno) && partsize > 0) {
+        log_it("Vaccum-packing");
+        g_current_progress--;
+        res = partition_device(pout_to_fdisk, drive, partno, prev_partno, format, -1);
+        if (res) {
+            log_it("Failed to vacuum-pack %s", partition_name);
+            retval++;
+        } else {
+            retval = 0;
+        }
+    }
+    if (does_partition_exist(drive, partno)) {
+        retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
+        if (retval) {
+            log_it("Partitioned %s but failed to set its type", partition_name);
+        } else {
+            if (partsize > 0) {
+                log_to_screen("Partition %s created+configured OK", partition_name);
+            } else {
+                log_it("Returning from a successful vacuum-pack");
+            }
+        }
+    } else {
+        mr_asprintf(tmp, "Failed to partition %s", partition_name);
+        if (partsize > 0) {
+            log_to_screen(tmp);
+        } else {
+            log_it(tmp);
+        }
+        mr_free(tmp);
+        retval++;
+    }
+}
+mr_free(program);
+mr_free(output);
+mr_free(partition_name);
+
+g_current_progress++;
+log_it("partition_device() --- leaving");
 return (retval);
 }
@@ -1532 +2099 @@
 }
 
-/**
- * Create partition number @p partno on @p drive with @p fdisk.
- * @param drive The drive to create the partition on.
-//  * @param partno The partition number of the new partition (1-4 are primary, >=5 is logical).
- * @param prev_partno The partition number of the most recently prepped partition.
- * @param format The filesystem type of this partition (used to set the type).
- * @param partsize The size of the partition in @e bytes.
- * @return 0 for success, nonzero for failure.
- */
-int partition_device(FILE * pout_to_fdisk, const char *drive, int partno, int prev_partno, const char *format, long long partsize) {
-
-/** int **************************************************************/
-int retval = 0;
-int res = 0;
-
-/** buffers **********************************************************/
-char *program = NULL;
-char *partition_name = NULL;
-char *tmp = NULL;
-char *output = NULL;
-
-/** pointers **********************************************************/
-char *part_table_fmt = NULL;
-FILE *fout;
-
-/** end ***************************************************************/
-
-assert_string_is_neither_NULL_nor_zerolength(drive);
-assert(format != NULL);
-
-log_it("partition_device('%s', %d, %d, '%s', %lld) --- starting", drive, partno, prev_partno, format, partsize);
-
-if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
-    log_it("Not partitioning %s - it is a virtual drive", drive);
-    return (0);
-}
-
-partition_name = build_partition_name(drive, partno);
-if (partsize <= 0) {
-    mr_asprintf(tmp, "Partitioning device %s (max size)", partition_name);
-} else {
-    mr_asprintf(tmp, "Partitioning device %s (%lld MB)", partition_name, (long long) partsize / 1024);
-}
-update_progress_form(tmp);
-log_it(tmp);
-mr_free(tmp);
-
-if (is_this_device_mounted(partition_name)) {
-    log_to_screen("%s is mounted, and should not be partitioned", partition_name);
-    mr_free(partition_name);
-    return (1);
-}
-
-
-mr_asprintf(program, "mr-parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE);
-
-/* TODO: should not be called each time */
-part_table_fmt = which_partition_format(drive);
-mr_asprintf(output, "");
-
-/* make it a primary/extended/logical */
-if (partno <= 4) {
-    mr_strcat(output, "n\np\n%d\n", partno);
-} else {
-    /* MBR needs an extended partition if more than 4 partitions */
-    if (strcmp(part_table_fmt, "MBR") == 0) {
-        if (partno == 5) {
-            if (prev_partno >= 4) {
-                log_to_screen("You need to leave at least one partition free, for 'extended/logical'");
-                mr_free(partition_name);
-                paranoid_free(output);
-                return (1);
-            } else {
-                mr_strcat(output, "n\ne\n%d\n\n\n", prev_partno + 1);
-            }
-        }
-        mr_strcat(output, "n\nl\n");
-    } else {
-        /* GPT allows more than 4 primary partitions */
-        mr_strcat(output, "n\np\n%d\n", partno);
-    }
-}
-mr_free(part_table_fmt);
-
-mr_strcat(output, "\n");    /*start block (ENTER for next free blk */
-if (partsize > 0) {
-    if (!strcmp(format, "7")) {
-        log_msg(1, "Adding 512K, just in case");
-        partsize += 512;
-    }
-    mr_strcat(output, "+%lldK", (long long) (partsize));
-}
-mr_strcat(output, "\n");
-#if 0
-/*
-#endif
-log_it("PARTSIZE = +%ld",(long)partsize);
-log_it("---fdisk command---");
-log_it(output);
-log_it("---end of fdisk---");
-#if 0
-*/
-#endif
-
-
-if (pout_to_fdisk) {
-    log_msg(1, "Doing the new all-in-one fdisk thing");
-    mr_strcat(output, "\n\np\n\n");
-    log_msg(1, "output = '%s'", output);
-    fput_string_one_char_at_a_time(pout_to_fdisk, output);
-    mr_asprintf(tmp, "%s", last_line_of_file(FDISK_LOG));
-    if (strstr(tmp, " (m ")) {
-        log_msg(1, "Successfully created partition %d on %s", partno, drive);
-    } else {
-        log_msg(1, "last line = %s", tmp);
-        log_msg(1, "Failed to create partition %d on %s; sending 'Enter'...", partno, drive);
-    }
-    mr_free(tmp);
-
-    if (!retval) {
-        log_msg(1, "Trying to set partition %d type now on %s", partno, drive);
-        retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
-        if (retval) {
-            log_msg(1, "Failed. Trying again...");
-            retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
-        }
-    }
-    if (retval) {
-        log_msg(1, "...but failed to set type");
-    }
-} else {
-    mr_strcat(output, "w\n\n");
-    if (g_fprep) {
-        fprintf(g_fprep, "echo \"%s\" | %s\n", output, program);
-    }
-    /* write to disk; close fdisk's stream */
-    if (!(fout = popen(program, "w"))) {
-        log_OS_error("can't popen-out to program");
-    } else {
-        fputs(output, fout);
-        paranoid_pclose(fout);
-    }
-
-    if (!does_partition_exist(drive, partno) && partsize > 0) {
-        log_it("Vaccum-packing");
-        g_current_progress--;
-        res = partition_device(pout_to_fdisk, drive, partno, prev_partno, format, -1);
-        if (res) {
-            log_it("Failed to vacuum-pack %s", partition_name);
-            retval++;
-        } else {
-            retval = 0;
-        }
-    }
-    if (does_partition_exist(drive, partno)) {
-        retval = set_partition_type(pout_to_fdisk, drive, partno, format, partsize);
-        if (retval) {
-            log_it("Partitioned %s but failed to set its type", partition_name);
-        } else {
-            if (partsize > 0) {
-                log_to_screen("Partition %s created+configured OK", partition_name);
-            } else {
-                log_it("Returning from a successful vacuum-pack");
-            }
-        }
-    } else {
-        mr_asprintf(tmp, "Failed to partition %s", partition_name);
-        if (partsize > 0) {
-            log_to_screen(tmp);
-        } else {
-            log_it(tmp);
-        }
-        mr_free(tmp);
-        retval++;
-    }
-}
-mr_free(program);
-mr_free(output);
-mr_free(partition_name);
-
-g_current_progress++;
-log_it("partition_device() --- leaving");
-return (retval);
-}
-
-
 
 /**
@@ -1789 +2170 @@
 
 
-
 /**
- * Set the type of partition number @p partno on @p drive to @p format.
- * @param drive The drive to change the type of a partition on.
- * @param partno The partition number on @p drive to change the type of.
- * @param format The filesystem type this partition will eventually contain.
- * @param partsize The size of this partition, in @e bytes (used for vfat
- * type calculations).
- * @return 0 for success, nonzero for failure.
+ * Create a mountlist_reference structure for @p drive_name in @p mountlist.
+ * @param mountlist The complete mountlist to get the drive references from.
+ * @param drive_name The drive to put in @p drivemntlist.
+ * @param drivemntlist The mountlist_reference structure to put the drive's entries in.
+ * @note @p drivemntlist and @p drivemntlist->el must be allocated by the caller.
+ * @author Ralph Grewe
  */
-int set_partition_type(FILE * pout_to_fdisk, const char *drive, int partno, const char *format, long long partsize) {
-
-/** buffers *********************************************************/
-char *partition = NULL;
-char *command = NULL;
-char *output = NULL;
-char *tmp = NULL;
-char *partcode = NULL;
-
-/** pointers *********************************************************/
-FILE *fout;
-
-/** int **************************************************************/
-int res = 0;
-
-/** end **************************************************************/
-
-assert_string_is_neither_NULL_nor_zerolength(drive);
-assert(format != NULL);
-
-partition = build_partition_name(drive, partno);
-if (strcmp(format, "swap") == 0) {
-    mr_asprintf(partcode, "82");
-} else if (strcmp(format, "vfat") == 0) {
-    if (partsize / 1024 > 8192) {
-        mr_asprintf(partcode, "c");
-    } else {
-        mr_asprintf(partcode, "b");
-    }
-} else if (strcmp(format, "ext2") == 0
-             || strcmp(format, "reiserfs") == 0
-             || strcmp(format, "ext3") == 0 
-             || strcmp(format, "ext4") == 0 
-             || strcmp(format, "xfs") == 0
-             || strcmp(format, "jfs") == 0
-             || strcmp(format, "btrfs") == 0) {
-    mr_asprintf(partcode, "83");
-} else if (strcmp(format, "minix") == 0) {
-    mr_asprintf(partcode, "81");
-} else if (strcmp(format, "vmfs3") == 0) {
-    mr_asprintf(partcode, "fb");
-} else if (strcmp(format, "vmkcore") == 0) {
-    mr_asprintf(partcode, "fc");
-} else if (strcmp(format, "raid") == 0) {
-    mr_asprintf(partcode, "fd");
-} else if (strcmp(format, "ntfs") == 0) {
-    mr_asprintf(partcode, "7");
-} else if ((strcmp(format, "ufs") == 0)
-             || (strcmp(format, "ffs") == 0)) { /* raid autodetect */
-    mr_asprintf(partcode, "a5");
-} else if (strcmp(format, "lvm") == 0) {
-    mr_asprintf(partcode, "8e");
-} else if (format[0] == '\0') { /* LVM physical partition */
-    mr_asprintf(partcode, "");
-} else if (strlen(format) >= 1 && strlen(format) <= 2) {
-    mr_asprintf(partcode, "%s", format);
-} else {
-    /* probably an image */
-    mr_asprintf(tmp, "Unknown format ('%s') - using supplied string anyway", format);
-    mvaddstr_and_log_it(g_currentY++, 0, tmp);
-    mr_free(tmp);
-
-#ifdef __FreeBSD__
-    mr_asprintf(partcode, "%s", format);    // was a5
-#else
-    mr_asprintf(partcode, "%s", format);    // was 83
-#endif
-}
-log_msg(1, "Setting %s's type to %s (%s)", partition, format, partcode);
-mr_free(partition);
-
-if ((strcmp(partcode,"") != 0) && strcmp(partcode, "83")) { /* no need to set type if 83: 83 is default */
-
-    if (pout_to_fdisk) {
-        res = 0;
-        fput_string_one_char_at_a_time(pout_to_fdisk, "t\n");
-        if (partno > 1
-            || strstr(last_line_of_file(FDISK_LOG), " (1-4)")) {
-            log_msg(5, "Specifying partno (%d) - yay", partno);
-            mr_asprintf(tmp, "%d\n", partno);
-            fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
-            log_msg(5, "A - last line = '%s'", last_line_of_file(FDISK_LOG));
-            mr_free(tmp);
-        }
-
-        mr_asprintf(tmp, "%s\n", partcode);
-        fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
-        mr_free(tmp);
-
-        log_msg(5, "B - last line = '%s'",
-                last_line_of_file(FDISK_LOG));
-        fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
-        log_msg(5, "C - last line = '%s'",
-                last_line_of_file(FDISK_LOG));
-
-        mr_asprintf(tmp, "%s", last_line_of_file(FDISK_LOG));
-        if (!strstr(tmp, " (m ")) {
-            log_msg(1, "last line = '%s'; part type set failed", tmp);
-            res++;
-            fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
-        }
-        mr_free(tmp);
-
-        fput_string_one_char_at_a_time(pout_to_fdisk, "p\n");
-    } else {
-        mr_asprintf(output, "t\n%d\n%s\nw\n", partno, partcode);
-        mr_asprintf(command, "mr-parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE, MONDO_LOGFILE);
-        log_msg(5, "output = '%s'", output);
-        log_msg(5, "partno=%d; partcode=%s", partno, partcode);
-        log_msg(5, "command = '%s'", command);
-        fout = popen(command, "w");
-        if (!fout) {
-            log_OS_error(command);
-            res = 1;
-        } else {
-            res = 0;
-            fprintf(fout, "%s", output);
-            paranoid_pclose(fout);
-        }
-        mr_free(command);
-        paranoid_free(output);
-    }
-}
-mr_free(partcode);
-
-return (res);
-}
-
-
-int start_raid_device(char *raid_device) {
-
-/** int *************************************************************/
-int res;
-int retval = 0;
-
-/** buffers *********************************************************/
-char *program = NULL;
-
-/** end *************************************************************/
-
-assert_string_is_neither_NULL_nor_zerolength(raid_device);
-
-#ifdef __FreeBSD__
-if (is_this_device_mounted(raid_device)) {
-    log_it("Can't start %s when it's mounted!", raid_device);
-    return 1;
-}
-mr_asprintf(program, "vinum start -f %s", raid_device);
-#else
-mr_asprintf(program, "raidstart %s", raid_device);
-#endif
-log_msg(1, "program = %s", program);
-res = run_program_and_log_output(program, 1);
-if (g_fprep) {
-    fprintf(g_fprep, "%s\n", program);
-}
-mr_free(program);
-
-if (res) {
-    log_msg(1, "Warning - failed to start RAID device %s", raid_device);
-}
-retval += res;
-sleep(1);
-return (retval);
-}
-
-
-
-/**
- * Stop @p raid_device using @p raidstop.
- * @param raid_device The software RAID device to stop.
- * @return 0 for success, nonzero for failure.
- */
-int stop_raid_device(char *raid_device) {
-
-/** int *************************************************************/
-int res;
-int retval = 0;
-
-/** buffers *********************************************************/
-char *program = NULL;
-
-/** end *************************************************************/
-
-assert_string_is_neither_NULL_nor_zerolength(raid_device);
-
-#ifdef __FreeBSD__
-if (is_this_device_mounted(raid_device)) {
-    log_it("Can't stop %s when it's mounted!", raid_device);
-    return 1;
-}
-mr_asprintf(program, "vinum stop -f %s", raid_device);
-#else
-// use raidstop if it exists, otherwise use mdadm
-if (run_program_and_log_output("which raidstop", FALSE)) {
-    mr_asprintf(program, "mdadm -S %s", raid_device);
-} else {
-    mr_asprintf(program, "raidstop %s", raid_device);
-}
-#endif
-log_msg(1, "program = %s", program);
-res = run_program_and_log_output(program, 1);
-if (g_fprep) {
-    fprintf(g_fprep, "%s\n", program);
-}
-mr_free(program);
-
-if (res) {
-    log_msg(1, "Warning - failed to stop RAID device %s", raid_device);
-}
-retval += res;
-return (retval);
-}
-
-
-int start_all_raid_devices(struct mountlist_itself *mountlist) {
-
-int i;
-int retval = 0;
-int res;
-
-for (i = 0; i < mountlist->entries; i++) {
-    if (!strncmp(mountlist->el[i].device, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
-        log_msg(1, "Starting %s", mountlist->el[i].device);
-        res = start_raid_device(mountlist->el[i].device);
-        retval += res;
-    }
-}
-if (retval) {
-    log_msg(1, "Started all s/w raid devices OK");
-} else {
-    log_msg(1, "Failed to start some/all s/w raid devices");
-}
-return (retval);
-}
-
-/**
- * Stop all software RAID devices listed in @p mountlist.
- * @param mountlist The mountlist to stop the RAID devices in.
- * @return The number of errors encountered (0 for success).
- * @bug @p mountlist is not used.
- */
-int stop_all_raid_devices(struct mountlist_itself *mountlist) {
-
-/** int *************************************************************/
-int retval = 0;
-
-/** char ************************************************************/
-char *incoming;
-#ifndef __FreeBSD__
-char *dev;
-#endif
-/** pointers ********************************************************/
-#ifndef __FreeBSD__
-char *p;
-#endif
-FILE *fin;
-char *q;
-int i;
-
-/** end ****************************************************************/
-
-malloc_string(incoming);
+void create_mountlist_for_drive(struct mountlist_itself *mountlist, char *drive_name, struct mountlist_reference *drivemntlist) {
+
+int partno;
+char *tmp_drive_name, *c;
+
 assert(mountlist != NULL);
-
-for (i = 0; i < 3; i++) {
-#ifdef __FreeBSD__
-    fin = popen("vinum list | grep '^[PVS]' | sed 's/S/1/;s/P/2/;s/V/3/' | sort | cut -d' ' -f2", "r");
-    if (!fin) {
-        paranoid_free(incoming);
-        return (1);
-    }
-    for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL); q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
-        retval += stop_raid_device(incoming);
-    }
-#else
-    fin = fopen("/proc/mdstat", "r");
-    if (!fin) {
-        log_OS_error("/proc/mdstat");
-        paranoid_free(incoming);
-        return (1);
-    }
-    for (q = fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin) && (q != NULL); q = fgets(incoming, MAX_STR_LEN - 1, fin)) {
-        for (p = incoming; *p != '\0' && (*p != 'm' || *(p + 1) != 'd' || !isdigit(*(p + 2))); p++);
-        if (*p != '\0') {
-            malloc_string(dev);
-            sprintf(dev, "/dev/%s", p);
-            for (p = dev; *p > 32; p++);
-            *p = '\0';
-            retval += stop_raid_device(dev);
-            paranoid_free(dev);
-        }
-    }
-#endif
-}
-paranoid_fclose(fin);
-if (retval) {
-    log_msg(1, "Warning - unable to stop some RAID devices");
-}
-paranoid_free(incoming);
-paranoid_system("sync");
-paranoid_system("sync");
-paranoid_system("sync");
-sleep(1);
-return (retval);
-}
-
-
-
-/**
- * Decide which command we need to use to format a device of type @p format.
- * @param format The filesystem type we are about to format.
- * @param program Where to put the binary name for this format.
- * @return 0 for success, nonzero for failure.
- */
-char *which_format_command_do_i_need(char *format) {
-
-char *program = NULL;
-
-assert_string_is_neither_NULL_nor_zerolength(format);
-
-if (strcmp(format, "swap") == 0) {
-#ifdef __FreeBSD__
-    mr_asprintf(program, "true");
-#else
-    mr_asprintf(program, "mkswap -f");
-#endif
-} else if (strcmp(format, "vfat") == 0) {
-#ifdef __FreeBSD__
-    mr_asprintf(program, "newfs_msdos -F 32");
-#else
-#ifdef __IA64__
-    /* For EFI partitions on ia64 take fat16 
-     * as we want to make small ones */
-    mr_asprintf(program, "mkfs.vfat -F 16");
-#else
-    /* mkfs.vfat will make the best possible choice itself */
-    /* should avoid problems with mr-label later on when used */
-    mr_asprintf(program, "mkfs.vfat");
-#endif
-#endif
-#ifndef __FreeBSD__
-} else if (strcmp(format, "reiserfs") == 0) {
-    mr_asprintf(program, "mkreiserfs -ff");
-} else if (strcmp(format, "xfs") == 0) {
-    /*  Cf: https://bugzilla.redhat.com/show_bug.cgi?id=1309498 */
-    mr_asprintf(program, "mkfs.xfs -f -q -m crc=0 -n ftype=0");
-} else if (strcmp(format, "jfs") == 0) {
-    mr_asprintf(program, "mkfs.jfs");
-} else if (strcmp(format, "ext3") == 0) {
-    mr_asprintf(program, "mkfs -t ext3 -F -q");
-} else if (strcmp(format, "ext4") == 0) {
-    mr_asprintf(program, "mkfs -t ext4 -F -q");
-} else if (strcmp(format, "btrfs") == 0) {
-    mr_asprintf(program, "mkfs.btrfs -f");
-} else if (strcmp(format, "minix") == 0) {
-    mr_asprintf(program, "mkfs.minix");
-} else if (strcmp(format, "vmfs") == 0) {
-    mr_asprintf(program, "mkfs -t vmfs");
-} else if (strcmp(format, "ntfs") == 0) { 
-    /* 
-     * mkfs.ntfs treats the '-c' switch as 'specify cluster size' 
-     * so the default "mkfs -t %s -c" command structure fails 
-     */ 
-    mr_asprintf(program, "mkfs -t ntfs");
-} else if (strcmp(format, "ocfs2") == 0) {
-    /*
-     * For existing OCFS2 volumes, mkfs.ocfs2 ensures the volume is not mounted on any node in the cluster before formatting. For that to work, mkfs.ocfs2 expects the O2CB cluster service to be running. Specify this option to disable this check.
-     *
-     */
-    mr_asprintf(program, "mkfs -t ocfs2 -F");
-#endif
-} else if (strcmp(format, "ext2") == 0) {
-    mr_asprintf(program, "mke2fs -F -q");
-} else {
-#ifdef __FreeBSD__
-    mr_asprintf(program, "newfs_%s", format);
-#else
-    mr_asprintf(program, "mkfs -t %s -c", format);  // -c checks for bad blocks
-#endif
-    log_it("Unknown format (%s) - assuming '%s' will do", format, program);
-}
-return(program);
+assert(drive_name != NULL);
+assert(drivemntlist != NULL);
+
+log_msg(1, "Creating list of partitions for drive %s", drive_name);
+
+tmp_drive_name = strdup(drive_name);
+if (!tmp_drive_name)
+    fatal_error("Out of memory");
+
+/* devfs devices? */
+c = strrchr(tmp_drive_name, '/');
+if (c && strncmp(c, "/disc", 5) == 0) {
+    /* yup its devfs, change the "disc" to "part" so the existing code works */
+    strcpy(c + 1, "part");
+}
+drivemntlist->entries = 0;
+for (partno = 0; partno < mountlist->entries; partno++) {
+    if (strncmp(mountlist->el[partno].device, tmp_drive_name, strlen(tmp_drive_name)) == 0) {
+        drivemntlist->el[drivemntlist->entries] = &mountlist->el[partno];
+        drivemntlist->entries++;
+    }
+}
+if (tmp_drive_name)
+    free(tmp_drive_name);
 }
 
@@ -2331 +2357 @@
 paranoid_free(drivelist);
 }
-
-/**
- * Create a mountlist_reference structure for @p drive_name in @p mountlist.
- * @param mountlist The complete mountlist to get the drive references from.
- * @param drive_name The drive to put in @p drivemntlist.
- * @param drivemntlist The mountlist_reference structure to put the drive's entries in.
- * @note @p drivemntlist and @p drivemntlist->el must be allocated by the caller.
- * @author Ralph Grewe
- */
-void create_mountlist_for_drive(struct mountlist_itself *mountlist, char *drive_name, struct mountlist_reference *drivemntlist) {
-
-int partno;
-char *tmp_drive_name, *c;
-
-assert(mountlist != NULL);
-assert(drive_name != NULL);
-assert(drivemntlist != NULL);
-
-log_msg(1, "Creating list of partitions for drive %s", drive_name);
-
-tmp_drive_name = strdup(drive_name);
-if (!tmp_drive_name)
-    fatal_error("Out of memory");
-
-/* devfs devices? */
-c = strrchr(tmp_drive_name, '/');
-if (c && strncmp(c, "/disc", 5) == 0) {
-    /* yup its devfs, change the "disc" to "part" so the existing code works */
-    strcpy(c + 1, "part");
-}
-drivemntlist->entries = 0;
-for (partno = 0; partno < mountlist->entries; partno++) {
-    if (strncmp(mountlist->el[partno].device, tmp_drive_name, strlen(tmp_drive_name)) == 0) {
-        drivemntlist->el[drivemntlist->entries] = &mountlist->el[partno];
-        drivemntlist->entries++;
-    }
-}
-if (tmp_drive_name)
-    free(tmp_drive_name);
-}
-
 /* @} - end of prepGroup */

branches/3.3/mondo/src/mondorestore/mondo-rstr-compare.c

@@ -7 +7 @@
 #include "mr_mem.h"
 #include "mr_file.h"
-#include "../common/mondostructures.h"
-#include "../common/libmondo.h"
-//#include "../../config.h"
-#include "mr-externs.h"
-#include "mondo-rstr-compare.h"
-#include "mondorestore-EXT.h"
+#include "mr_sys.h"
+#include "mondostructures.h"
 #include "mondo-rstr-tools-EXT.h"
+#include "libmondo-string-EXT.h"
+#include "libmondo-verify-EXT.h"
+#include "libmondo-files-EXT.h"
+#include "libmondo-tools-EXT.h"
+#include "libmondo-fork-EXT.h"
+#include "libmondo-devices-EXT.h"
+#include "libmondo-string-EXT.h"
+#include "libmondo-mountlist-EXT.h"
+#include "libmondo-raid-EXT.h"
+#include "newt-specific-EXT.h"
 
 extern char *MONDO_LOGFILE;
@@ -21 +27 @@
 
 extern char *g_mountlist_fname;
+extern int g_current_media_number;
+extern bool g_text_mode;
+extern int g_currentY;
+extern long g_current_progress;
+extern char *g_mondo_cfg_file;
+
+// in mondo-rstr-newt.c
+extern int edit_mountlist(char *, struct mountlist_itself *, struct raidlist_itself *);
 
 //static char cvsid[] = "$Id$";
@@ -63 +77 @@
 
     if (!does_file_exist(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""))) {
-        if (does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")) {
+        if (does_file_exist(ARCHIVES_PATH "/NOT-THE-LAST")) {
             insist_on_this_cd_number((++g_current_media_number));
         } else {
@@ -368 +382 @@
         insist_on_this_cd_number(g_current_media_number);
         update_progress_form(progress_str);
-        mr_asprintf(tarball_fname, MNT_CDROM "/archives/%d.afio.bz2", current_tarball_number);
+        mr_asprintf(tarball_fname, ARCHIVES_PATH "/%d.afio.bz2", current_tarball_number);
 
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%d.afio.lzo", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%d.afio.lzo", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%d.afio.lzma", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%d.afio.lzma", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%d.afio.gz", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%d.afio.gz", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%d.afio.", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%d.afio.", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%d.star.bz2", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%d.star.bz2", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%d.star.", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%d.star.", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            if (!does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST") ||
-                system("find " MNT_CDROM
-                       "/archives/slice* > /dev/null 2> /dev/null")
+            if (!does_file_exist(ARCHIVES_PATH "/NOT-THE-LAST") ||
+                system("find " ARCHIVES_PATH "/slice* > /dev/null 2> /dev/null")
                 == 0) {
                 log_msg(2, "OK, I think I'm done with tarballs...");
@@ -492 +505 @@
  **************************************************************************/
 
+/**
+ * Compare all data on a tape-based backup.
+ * @param bkpinfo The backup information structure. Field used: @c bkpinfo->restore_path.
+ * @return 0 for success, nonzero for failure.
+ */
+/**************************************************************************
+ * F@COMPARE_TO_TAPE()                                                    *
+ * compare_to_tape() -  gots me??                                         *
+ *                                                                        *
+ * returns: int                                                           *
+ **************************************************************************/
+int compare_to_tape()
+{
+    int res;
+    char *dir;
+    char *command = NULL;
+
+    assert(bkpinfo != NULL);
+    malloc_string(dir);
+
+    if (getcwd(dir, MAX_STR_LEN)) {
+        // FIXME
+    }
+    if (chdir(bkpinfo->restore_path)) {
+        // FIXME
+    }
+    mr_asprintf(command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp", bkpinfo->restore_path);
+    run_program_and_log_output(command, FALSE);
+    mr_free(command);
+
+    mvaddstr_and_log_it(g_currentY, 0, "Verifying archives against filesystem");
+    res = verify_tape_backups();
+    if (chdir(dir)) {
+        // FIXME
+    }
+    if (res) {
+        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
+    } else {
+        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+    }
+    paranoid_free(dir);
+    return (res);
+}
+
+/**************************************************************************
+ *END_COMPARE_TO_TAPE                                                     *
+ **************************************************************************/
+
+
+/**
+ * Compare all data on a cdstream-based backup.
+ * @param bkpinfo The backup information structure. Fields used:
+ * - @c bkpinfo->disaster_recovery
+ * - @c bkpinfo->media_device
+ * - @c bkpinfo->restore_path
+ * @return 0 for success, nonzero for failure.
+ */
+int compare_to_cdstream()
+{
+    int res;
+
+  /** needs malloc **/
+    char *dir;
+    char *command = NULL;
+
+    assert(bkpinfo != NULL);
+    malloc_string(dir);
+    if (getcwd(dir, MAX_STR_LEN)) {
+        // FIXME
+    }
+    if (chdir(bkpinfo->restore_path)) {
+        // FIXME
+    }
+
+    mr_asprintf(command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp", bkpinfo->restore_path);
+    run_program_and_log_output(command, FALSE);
+    mr_free(command);
+    mvaddstr_and_log_it(g_currentY, 0, "Verifying archives against filesystem");
+
+    if (bkpinfo->disaster_recovery
+        && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
+        mr_asprintf(bkpinfo->media_device, "%s", last_line_of_file("/tmp/CDROM-LIVES-HERE"));
+    } else {
+        bkpinfo->media_device = find_optical_device();
+    }
+    res = verify_tape_backups();
+    if (chdir(dir)) {
+        // FIXME
+    }
+    if (length_of_file(MONDO_CACHE"/changed.txt") > 2
+        && length_of_file(MONDO_CACHE"/changed.files") > 2) {
+        log_msg(0,
+                "Type 'less "MONDO_CACHE"/changed.files' to see which files don't match the archives");
+        log_msg(2, "Calling popup_changelist_from_file()");
+        popup_changelist_from_file(MONDO_CACHE"/changed.files");
+        log_msg(2, "Returned from popup_changelist_from_file()");
+    }
+
+    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+    paranoid_free(dir);
+    return (res);
+}
+
+/**************************************************************************
+ *END_COMPARE_CD_STREAM                                                   *
+ **************************************************************************/
 
 
@@ -620 +739 @@
  *END_COMPARE_MODE                                                        *
  **************************************************************************/
-
-/**
- * Compare all data on a cdstream-based backup.
- * @param bkpinfo The backup information structure. Fields used:
- * - @c bkpinfo->disaster_recovery
- * - @c bkpinfo->media_device
- * - @c bkpinfo->restore_path
- * @return 0 for success, nonzero for failure.
- */
-int compare_to_cdstream()
-{
-    int res;
-
-  /** needs malloc **/
-    char *dir;
-    char *command = NULL;
-
-    assert(bkpinfo != NULL);
-    malloc_string(dir);
-    if (getcwd(dir, MAX_STR_LEN)) {
-        // FIXME
-    }
-    if (chdir(bkpinfo->restore_path)) {
-        // FIXME
-    }
-
-    mr_asprintf(command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp", bkpinfo->restore_path);
-    run_program_and_log_output(command, FALSE);
-    mr_free(command);
-    mvaddstr_and_log_it(g_currentY, 0, "Verifying archives against filesystem");
-
-    if (bkpinfo->disaster_recovery
-        && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
-        mr_asprintf(bkpinfo->media_device, "%s", last_line_of_file("/tmp/CDROM-LIVES-HERE"));
-    } else {
-        bkpinfo->media_device = find_optical_device();
-    }
-    res = verify_tape_backups();
-    if (chdir(dir)) {
-        // FIXME
-    }
-    if (length_of_file(MONDO_CACHE"/changed.txt") > 2
-        && length_of_file(MONDO_CACHE"/changed.files") > 2) {
-        log_msg(0,
-                "Type 'less "MONDO_CACHE"/changed.files' to see which files don't match the archives");
-        log_msg(2, "Calling popup_changelist_from_file()");
-        popup_changelist_from_file(MONDO_CACHE"/changed.files");
-        log_msg(2, "Returned from popup_changelist_from_file()");
-    }
-
-    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
-    paranoid_free(dir);
-    return (res);
-}
-
-/**************************************************************************
- *END_COMPARE_CD_STREAM                                                   *
- **************************************************************************/
-
-
-/**
- * Compare all data on a tape-based backup.
- * @param bkpinfo The backup information structure. Field used: @c bkpinfo->restore_path.
- * @return 0 for success, nonzero for failure.
- */
-/**************************************************************************
- * F@COMPARE_TO_TAPE()                                                    *
- * compare_to_tape() -  gots me??                                         *
- *                                                                        *
- * returns: int                                                           *
- **************************************************************************/
-int compare_to_tape()
-{
-    int res;
-    char *dir;
-    char *command = NULL;
-
-    assert(bkpinfo != NULL);
-    malloc_string(dir);
-
-    if (getcwd(dir, MAX_STR_LEN)) {
-        // FIXME
-    }
-    if (chdir(bkpinfo->restore_path)) {
-        // FIXME
-    }
-    mr_asprintf(command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp", bkpinfo->restore_path);
-    run_program_and_log_output(command, FALSE);
-    mr_free(command);
-
-    mvaddstr_and_log_it(g_currentY, 0, "Verifying archives against filesystem");
-    res = verify_tape_backups();
-    if (chdir(dir)) {
-        // FIXME
-    }
-    if (res) {
-        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
-    } else {
-        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
-    }
-    paranoid_free(dir);
-    return (res);
-}
-
-/**************************************************************************
- *END_COMPARE_TO_TAPE                                                     *
- **************************************************************************/
-
 /* @} - end compareGroup */

branches/3.3/mondo/src/mondorestore/mondo-rstr-mountlist.c

@@ -12 +12 @@
 #include "mr_mem.h"
 #include "mondostructures.h"
-#include "libmondo-mountlist.h"
-
 #include "libmondo-raid-EXT.h"
 #include "libmondo-devices-EXT.h"
@@ -535 +533 @@
 
 /**
+ * Make a list of the drives mentioned in the mountlist.
+ * @param mountlist The mountlist to examine.
+ * @param drivelist Where to put the list of drives found.
+ * @return The number of physical (non-RAID non-LVM) drives found, or \<= 0 for error.
+ */
+int
+make_list_of_drives_in_mountlist(struct mountlist_itself *mountlist,
+                                 struct list_of_disks *drivelist)
+{
+
+    /*@ int ************************************************************* */
+    int lino;
+    int noof_drives;
+    int j;
+
+    /*@ buffers ********************************************************* */
+    char *drive = NULL;
+    char *truncdrive = NULL;
+
+    long long size;
+
+    assert(mountlist != NULL);
+    assert(drivelist != NULL);
+    log_it("Making list of drives");
+    for (lino = 0, noof_drives = 0; lino < mountlist->entries; lino++) {
+
+        mr_asprintf(drive, "%s", mountlist->el[lino].device);
+        if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
+            log_msg(8, "Not putting %s in list of drives: it's a virtual drive", drive);
+            mr_free(drive);
+            continue;
+        }
+
+        size = mountlist->el[lino].size;
+        if (size == 0) {
+            log_msg(8, "Not putting %s in list of drives: it has zero size (maybe an LVM volume)", drive);
+            mr_free(drive);
+            continue;
+        }
+
+        log_msg(8, "Putting %s with size %lli in list of drives", drive, size);
+
+        /* memory allocation */
+        truncdrive = truncate_to_drive_name(drive);
+        mr_free(drive);
+
+        log_msg(8, "drive truncated to %s", truncdrive);
+
+        for (j = 0;
+             j < noof_drives
+             && strcmp(drivelist->el[j].device, truncdrive) != 0; j++) {
+            continue;
+        }
+        if (j == noof_drives) {
+            strncpy(drivelist->el[noof_drives].device, truncdrive, 63);
+            drivelist->el[noof_drives].device[63] = '\0';
+            log_msg(8,"Adding drive %s to list", drivelist->el[noof_drives].device);
+            noof_drives++;
+        }
+        paranoid_free(truncdrive);
+        if (noof_drives >= MAXIMUM_DISKS_PER_RAID_DEV) {
+            log_msg(0, "Unable to handle mountlist with more than %d lines", MAXIMUM_DISKS_PER_RAID_DEV);
+            log_to_screen("Unable to handle a so big mountlist");
+            finish(1);
+        }
+    }
+    drivelist->entries = noof_drives;
+    log_msg(8, "Made list of %d drives",noof_drives);
+
+    return (noof_drives);
+}
+
+
+/**
  * Evaluate a whole mountlist for flaws. Calls evaluate_drive_within_mountlist()
  * for each drive, and then spreads the flaws across three lines.
@@ -642 +714 @@
         return (i);
     }
-}
-
-
-/**
- * Make a list of the drives mentioned in the mountlist.
- * @param mountlist The mountlist to examine.
- * @param drivelist Where to put the list of drives found.
- * @return The number of physical (non-RAID non-LVM) drives found, or \<= 0 for error.
- */
-int
-make_list_of_drives_in_mountlist(struct mountlist_itself *mountlist,
-                                 struct list_of_disks *drivelist)
-{
-
-    /*@ int ************************************************************* */
-    int lino;
-    int noof_drives;
-    int j;
-
-    /*@ buffers ********************************************************* */
-    char *drive = NULL;
-    char *truncdrive = NULL;
-
-    long long size;
-
-    assert(mountlist != NULL);
-    assert(drivelist != NULL);
-    log_it("Making list of drives");
-    for (lino = 0, noof_drives = 0; lino < mountlist->entries; lino++) {
-
-        mr_asprintf(drive, "%s", mountlist->el[lino].device);
-        if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
-            log_msg(8, "Not putting %s in list of drives: it's a virtual drive", drive);
-            mr_free(drive);
-            continue;
-        }
-
-        size = mountlist->el[lino].size;
-        if (size == 0) {
-            log_msg(8, "Not putting %s in list of drives: it has zero size (maybe an LVM volume)", drive);
-            mr_free(drive);
-            continue;
-        }
-
-        log_msg(8, "Putting %s with size %lli in list of drives", drive, size);
-
-        /* memory allocation */
-        truncdrive = truncate_to_drive_name(drive);
-        mr_free(drive);
-
-        log_msg(8, "drive truncated to %s", truncdrive);
-
-        for (j = 0;
-             j < noof_drives
-             && strcmp(drivelist->el[j].device, truncdrive) != 0; j++) {
-            continue;
-        }
-        if (j == noof_drives) {
-            strncpy(drivelist->el[noof_drives].device, truncdrive, 63);
-            drivelist->el[noof_drives].device[63] = '\0';
-            log_msg(8,"Adding drive %s to list", drivelist->el[noof_drives].device);
-            noof_drives++;
-        }
-        paranoid_free(truncdrive);
-        if (noof_drives >= MAXIMUM_DISKS_PER_RAID_DEV) {
-            log_msg(0, "Unable to handle mountlist with more than %d lines", MAXIMUM_DISKS_PER_RAID_DEV);
-            log_to_screen("Unable to handle a so big mountlist");
-            finish(1);
-        }
-    }
-    drivelist->entries = noof_drives;
-    log_msg(8, "Made list of %d drives",noof_drives);
-
-    return (noof_drives);
 }
 
@@ -938 +936 @@
 
 /**
+ * Swap two entries in the mountlist in-place.
+ * @param mountlist The mountlist to swap the entries in.
+ * @param a The index number of the first entry.
+ * @param b The index number of the second entry.
+ */
+void
+swap_mountlist_entries(struct mountlist_itself *mountlist, int a, int b)
+{
+    /*@ mallocs *** */
+    char *device = NULL;
+    char *mountpoint = NULL;
+    char *format = NULL;
+
+    long long size;
+
+    assert(mountlist != NULL);
+    assert(a >= 0);
+    assert(b >= 0);
+
+    mr_asprintf(device, "%s", mountlist->el[a].device);
+    mr_asprintf(mountpoint, "%s", mountlist->el[a].mountpoint);
+    mr_asprintf(format, "%s", mountlist->el[a].format);
+
+    size = mountlist->el[a].size;
+
+    strcpy(mountlist->el[a].device, mountlist->el[b].device);
+    strcpy(mountlist->el[a].mountpoint, mountlist->el[b].mountpoint);
+    strcpy(mountlist->el[a].format, mountlist->el[b].format);
+
+    mountlist->el[a].size = mountlist->el[b].size;
+
+    strcpy(mountlist->el[b].device, device);
+    strcpy(mountlist->el[b].mountpoint, mountpoint);
+    strcpy(mountlist->el[b].format, format);
+
+    mountlist->el[b].size = size;
+    mr_free(device);
+    mr_free(mountpoint);
+    mr_free(format);
+}
+
+
+
+/**
  * Sort the mountlist alphabetically by device.
  * The sorting is done in-place.
@@ -991 +1033 @@
 }
 
-
-/**
- * Swap two entries in the mountlist in-place.
- * @param mountlist The mountlist to swap the entries in.
- * @param a The index number of the first entry.
- * @param b The index number of the second entry.
- */
-void
-swap_mountlist_entries(struct mountlist_itself *mountlist, int a, int b)
-{
-    /*@ mallocs *** */
-    char *device = NULL;
-    char *mountpoint = NULL;
-    char *format = NULL;
-
-    long long size;
-
-    assert(mountlist != NULL);
-    assert(a >= 0);
-    assert(b >= 0);
-
-    mr_asprintf(device, "%s", mountlist->el[a].device);
-    mr_asprintf(mountpoint, "%s", mountlist->el[a].mountpoint);
-    mr_asprintf(format, "%s", mountlist->el[a].format);
-
-    size = mountlist->el[a].size;
-
-    strcpy(mountlist->el[a].device, mountlist->el[b].device);
-    strcpy(mountlist->el[a].mountpoint, mountlist->el[b].mountpoint);
-    strcpy(mountlist->el[a].format, mountlist->el[b].format);
-
-    mountlist->el[a].size = mountlist->el[b].size;
-
-    strcpy(mountlist->el[b].device, device);
-    strcpy(mountlist->el[b].mountpoint, mountpoint);
-    strcpy(mountlist->el[b].format, format);
-
-    mountlist->el[b].size = size;
-    mr_free(device);
-    mr_free(mountpoint);
-    mr_free(format);
-}
-
 /* @} - end of mountlistGroup */

branches/3.3/mondo/src/mondorestore/mondo-rstr-newt.c

@@ -10 +10 @@
 #endif
 
-#include "mondo-rstr-newt.h"
+#include "my-stuff.h"
+#include "mondostructures.h"
 #include "mr_mem.h"
 #include "mr_str.h"
+#include "libmondo-raid-EXT.h"
+#include "libmondo-mountlist-EXT.h"
+#include "libmondo-string-EXT.h"
+#include "libmondo-tools-EXT.h"
+#include "libmondo-files-EXT.h"
+#include "libmondo-filelist-EXT.h"
+#include "newt-specific-EXT.h"
 
 //static char cvsid[] = "$Id$";
@@ -18 +26 @@
 extern bool popup_with_buttons(char *p, char *button1, char *button2);
 extern char err_log_lines[NOOF_ERR_LINES][MAX_STR_LEN];
+
+static char g_strings_of_flist_window[ARBITRARY_MAXIMUM][MAX_STR_LEN];
+static bool g_is_path_selected[ARBITRARY_MAXIMUM];
+static bool g_is_path_expanded[ARBITRARY_MAXIMUM];
+static char tmpnopath[MAX_STR_LEN + 2];
+static char tmpprevpath[MAX_STR_LEN + 2];
+
+// from mondo-rstr-mountlist.c
+extern void make_list_of_unallocated_raid_partitions(struct mountlist_itself *, struct mountlist_itself *, struct raidlist_itself *);
+
+extern bool g_text_mode;
+
 
 /**
@@ -36 +56 @@
 
 /**
- * @addtogroup restoreGuiGroup
- * @{
- */
+ * Redraw the list of unallocated RAID partitions.
+ * @param unallocated_raid_partitions The mountlist containing unallocated RAID partitions.
+ * @param keylist The list of keys for @p listbox.
+ * @param listbox The Newt listbox component to redraw.
+ * @ingroup restoreGuiDisklist
+ */
+void redraw_unallocpartnslist(struct mountlist_itself
+                              *unallocated_raid_partitions,
+                              void *keylist[ARBITRARY_MAXIMUM],
+                              newtComponent listbox)
+{
+
+    /** long *************************************************************/
+    long i = 0;
+
+    /** buffers **********************************************************/
+    char tmp[MAX_STR_LEN];
+
+    assert(unallocated_raid_partitions != NULL);
+    assert(keylist != NULL);
+    assert(listbox != NULL);
+
+    newtListboxClear(listbox);
+    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
+        keylist[i] = (void *) i;
+    }
+    for (i = 0; i < unallocated_raid_partitions->entries; i++) {
+        sprintf(tmp, "%-22s %8lld",
+                unallocated_raid_partitions->el[i].device,
+                unallocated_raid_partitions->el[i].size / 1024L);
+        newtListboxAppendEntry(listbox, tmp, keylist[i]);
+    }
+}
+
+
+/**
+ * Find the next free location to place a disk in @p disklist.
+ * @param disklist The disklist to operate on.
+ * @return The next free location (starting from 0).
+ * @ingroup restoreGuiDisklist
+ */
+int find_next_free_index_in_disklist(struct list_of_disks *disklist)
+{
+
+    /** int ***************************************************************/
+    int index = -1;
+    int pos = 0;
+
+  /** bool **************************************************************/
+    bool done;
+
+    assert(disklist != NULL);
+
+    for (done = FALSE; !done;) {
+        for (pos = 0;
+             pos < disklist->entries && disklist->el[pos].index <= index;
+             pos++);
+        if (pos >= disklist->entries) {
+            done = TRUE;
+        } else {
+            index = disklist->el[pos].index;
+        }
+    }
+    return (index + 1);
+}
+
+
+
 /**
  * Add an entry in @p disklist from the list in @p unallocated_raid_partitions.
@@ -118 +203 @@
 
 
-
-
-/**
- * Add an entry to @p mountlist.
- * @param mountlist The mountlist to add an entry to.
- * @param raidlist The raidlist that accompanies @p mountlist.
- * @param listbox The listbox component in the mountlist editor.
- * @param currline The line selected in @p listbox.
+/**
+ * Locate @p device in @p raidlist.
+ * @param raidlist The raidlist ot search in.
+ * @param device The RAID device to search for.
+ * @return The index of the device, or -1 if it could not be found.
+ * @ingroup restoreGuiMountlist
+ */
+int
+find_raid_device_in_raidlist(struct raidlist_itself *raidlist,
+                             char *device)
+{
+
+    /** int ***************************************************************/
+    int i = 0;
+#ifdef __FreeBSD__
+    char *vdev = NULL;
+    int res = 0;
+#else
+// Linux
+#endif
+
+    assert(raidlist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(device);
+
+#ifdef __FreeBSD__
+    for (i = 0; i < raidlist->entries; i++) {
+        mr_asprintf(vdev, "/dev/vinum/%s", raidlist->el[i].volname);
+        res = strcmp(device, vdev);
+        mr_free(vdev);
+
+        if (!res)
+            break;
+    }
+#else
+
+    for (i = 0;
+         strcmp(raidlist->el[i].raid_device, device)
+         && i < raidlist->entries; i++);
+#endif
+    if (i == raidlist->entries) {
+        return (-1);
+    } else {
+        return (i);
+    }
+}
+
+
+/**
+ * Redraw the disklist.
+ * @param disklist The disklist to read from.
  * @param keylist The list of keys for @p listbox.
+ * @param listbox The Newt listbox component to redraw.
+ * @ingroup restoreGuiDisklist
+ */
+void
+redraw_disklist(struct list_of_disks *disklist,
+                void *keylist[ARBITRARY_MAXIMUM], newtComponent listbox)
+{
+
+    /** long **************************************************************/
+    long i = 0;
+    char *tmp = NULL;
+
+    assert(disklist != NULL);
+    assert(keylist != NULL);
+    assert(listbox != NULL);
+
+    newtListboxClear(listbox);
+
+    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
+        keylist[i] = (void *) i;
+    }
+    for (i = 0; i < disklist->entries; i++) {
+        tmp = disklist_entry_to_string(disklist, i);
+        newtListboxAppendEntry(listbox, tmp, keylist[i]);
+        mr_free(tmp);
+    }
+}
+
+
+
+/**
+ * Delete entry number @p currline from @p disklist.
+ * @param disklist The disklist to remove the entry from.
+ * @param raid_device The RAID device containing the partition we're removing.
+ * Used only in the popup "are you sure?" box.
+ * @param currline The line number (starting from 0) of the item to delete.
+ * @ingroup restoreGuiDisklist
+ */
+void
+delete_disklist_entry(struct list_of_disks *disklist, char *raid_device,
+                      int currline)
+{
+
+    /** int ***************************************************************/
+    int pos = 0;
+    int res = 0;
+
+    /** buffers ***********************************************************/
+    char *tmp = NULL;
+
+    assert(disklist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(raid_device);
+
+    mr_asprintf(tmp, "Delete %s from RAID device %s - are you sure?", disklist->el[currline].device, raid_device);
+    res = ask_me_yes_or_no(tmp);
+    mr_free(tmp);
+
+    if (!res) {
+        return;
+    }
+    for (pos = currline; pos < disklist->entries - 1; pos++) {
+        strcpy(disklist->el[pos].device, disklist->el[pos + 1].device);
+    }
+    disklist->entries--;
+}
+
+
+
+/**
+ * Select the RAID disks to use in @p raidrec.
+ * @param mountlist_dontedit The mountlist (will not be edited).
+ * @param raidlist The raidlist to modify.
+ * @param raidrec The RAID device record in @p raidlist to work on.
+ * @param description_of_list The type of disks we're selecting (e.g. "data").
+ * @param disklist The disklist to put the user-selected disks in.
  * @ingroup restoreGuiMountlist
  */
 void
-add_mountlist_entry(struct mountlist_itself *mountlist,
-                    struct raidlist_itself *raidlist,
-                    newtComponent listbox, int currline, void *keylist[])
+select_raid_disks(struct mountlist_itself *mountlist_dontedit,
+                  struct raidlist_itself *raidlist,
+                  struct raid_device_record *raidrec,
+                  char *description_of_list,
+                  struct list_of_disks *disklist)
+{
+    void *curr_choice;
+
+    /** ??? ***************************************************************/
+
+    /** structures ********************************************************/
+    struct raidlist_itself *bkp_raidlist;
+    struct raid_device_record *bkp_raidrec;
+    struct list_of_disks *bkp_disklist;
+    struct mountlist_itself *unallocated_raid_partitions;
+
+    /** newt **************************************************************/
+    newtComponent myForm = NULL;
+    newtComponent bAdd = NULL;
+    newtComponent bDelete = NULL;
+    newtComponent bOK = NULL;
+    newtComponent bCancel = NULL;
+    newtComponent b_res = NULL;
+    newtComponent partitionsListbox = NULL;
+    newtComponent headerMsg = NULL;
+
+    /** buffers **********************************************************/
+    void *keylist[ARBITRARY_MAXIMUM];
+    char *tmp = NULL;
+    char *help_text = NULL;
+    char *title_of_window = NULL;
+    char sz_res[MAX_STR_LEN];
+    char *header_text = NULL;
+
+  /** int **************************************************************/
+    int i = 0;
+    int currline = 0;
+
+    assert(mountlist_dontedit != NULL);
+    assert(raidlist != NULL);
+    assert(raidrec != NULL);
+    assert(description_of_list != NULL);
+    assert(disklist != NULL);
+
+    log_it("malloc'ing");
+    bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
+    bkp_disklist = mr_malloc(sizeof(struct list_of_disks));
+    bkp_raidlist = mr_malloc(sizeof(struct raidlist_itself));
+    unallocated_raid_partitions = mr_malloc(sizeof(struct mountlist_itself));
+
+    memcpy((void *) bkp_raidlist, (void *) raidlist, sizeof(struct raidlist_itself));
+    memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record));
+    memcpy((void *) bkp_disklist, (void *) disklist, sizeof(struct list_of_disks));
+
+    log_it("Post-malloc");
+    mr_asprintf(help_text, "   Edit this RAID device's list of partitions. Choose OK or Cancel when done.");
+    mr_asprintf(header_text, "%-24s    %s", "Device", "Index");
+    mr_asprintf(title_of_window, "%s contains...", raidrec->raid_device);
+    newtPushHelpLine(help_text);
+    for (b_res = (newtComponent) 12345; b_res != bOK && b_res != bCancel;) {
+        headerMsg = newtLabel(1, 1, header_text);
+        partitionsListbox =
+            newtListbox(1, 2, 6, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
+        redraw_disklist(disklist, keylist, partitionsListbox);
+        i = 1;
+        bAdd = newtCompactButton(i, 9, " Add ");
+        bDelete = newtCompactButton(i += 8, 9, "Delete");
+        bOK = newtCompactButton(i += 9, 9, "  OK  ");
+        bCancel = newtCompactButton(i += 9, 9, "Cancel");
+        newtOpenWindow(21, 7, 38, 10, title_of_window);
+        myForm = newtForm(NULL, NULL, 0);
+        if (disklist->entries == 0) {
+            newtFormAddComponents(myForm, headerMsg, bAdd, bDelete, bOK,
+                                  bCancel, NULL);
+        } else {
+            newtFormAddComponents(myForm, headerMsg, partitionsListbox,
+                                  bAdd, bDelete, bOK, bCancel, NULL);
+        }
+        b_res = newtRunForm(myForm);
+        if (b_res == bOK || b_res == bCancel) { /* do nothing */
+// That's OK. At the end of this subroutine (after this do/while loop),
+// we'll throw away the changes if Cancel was pushed.
+        } else {
+            curr_choice = newtListboxGetCurrent(partitionsListbox);
+            for (i = 0; i < disklist->entries && keylist[i] != curr_choice;
+                 i++);
+            if (i == disklist->entries && disklist->entries > 0) {
+                log_to_screen("I don't know what that button does!");
+            } else {
+                currline = i;
+                if (b_res == bAdd) {
+                    log_it("Making list of unallocated RAID slices");
+                    make_list_of_unallocated_raid_partitions
+                        (unallocated_raid_partitions, mountlist_dontedit,
+                         raidlist);
+                    if (unallocated_raid_partitions->entries <= 0) {
+                        popup_and_OK
+                            ("There are no unallocated partitions marked for RAID.");
+                    } else {
+                        log_it
+                            ("Done. The user may add one or more of the above to RAID device");
+                        add_disklist_entry(disklist, raidrec->raid_device,
+                                           unallocated_raid_partitions);
+                        log_it("I have finished adding a disklist entry.");
+                        redraw_disklist(disklist, keylist,
+                                        partitionsListbox);
+                    }
+                } else if (b_res == bDelete) {
+                    delete_disklist_entry(disklist, raidrec->raid_device,
+                                          currline);
+                    redraw_disklist(disklist, keylist, partitionsListbox);
+                } else {
+                    mr_asprintf(tmp, "%s's index is %d. What should it be?", raidrec->raid_device, disklist->el[currline].index);
+                    sprintf(sz_res, "%d", disklist->el[currline].index);
+                    if (popup_and_get_string("Set index", tmp, sz_res, 10)) {
+                        disklist->el[currline].index = atoi(sz_res);
+                    }
+                    mr_free(tmp);
+
+                    redraw_disklist(disklist, keylist, partitionsListbox);
+                }
+            }
+        }
+        newtFormDestroy(myForm);
+        newtPopWindow();
+    }
+    newtPopHelpLine();
+    mr_free(help_text);
+    mr_free(header_text);
+    mr_free(title_of_window);
+
+    if (b_res == bCancel) {
+        memcpy((void *) raidlist, (void *) bkp_raidlist, sizeof(struct raidlist_itself));
+        memcpy((void *) raidrec, (void *) bkp_raidrec, sizeof(struct raid_device_record));
+        memcpy((void *) disklist, (void *) bkp_disklist, sizeof(struct list_of_disks));
+    }
+    mr_free(bkp_raidrec);
+    mr_free(bkp_disklist);
+    mr_free(bkp_raidlist);
+    mr_free(unallocated_raid_partitions);
+}
+
+
+#ifndef __FreeBSD__
+/**
+ * Insert the RAID variables not stored in the "additional RAID variables" list there too.
+ * @param raidrec The RAID device record to operate on.
+ * @ingroup restoreGuiVarslist
+ */
+void insert_essential_additionalvars(struct raid_device_record *raidrec)
 {
 
     /** int **************************************************************/
+    int items = 0;
+
+    assert(raidrec != NULL);
+
+    items = raidrec->additional_vars.entries;
+    write_variableINT_to_raid_var_line(raidrec, items++,
+                                       "persistent-superblock",
+                                       raidrec->persistent_superblock);
+    write_variableINT_to_raid_var_line(raidrec, items++, "chunk-size",
+                                       raidrec->chunk_size);
+    raidrec->additional_vars.entries = items;
+}
+
+#endif
+
+
+#ifndef __FreeBSD__
+/**
+ * Redraw the list of additional RAID variables.
+ * @param additional_vars The list of additional RAID varibals.
+ * @param keylist The list of keys for @p listbox.
+ * @param listbox The Newt listbox component to redraw.
+ * @ingroup restoreGuiVarslist
+ */
+void
+redraw_varslist(struct additional_raid_variables *additional_vars,
+                void *keylist[], newtComponent listbox)
+{
+    /** long ************************************************************/
+    long i = 0;
+
+    /** buffers *********************************************************/
+    char tmp[MAX_STR_LEN];
+
+    assert(additional_vars != NULL);
+    assert(keylist != NULL);
+    assert(listbox != NULL);
+
+    newtListboxClear(listbox);
+
+    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
+        keylist[i] = (void *) i;
+    }
+    for (i = 0; i < additional_vars->entries; i++) {
+        sprintf(tmp, "%-32s %-8s", additional_vars->el[i].label,
+                additional_vars->el[i].value);
+        newtListboxAppendEntry(listbox, tmp, keylist[i]);
+    }
+}
+
+#endif
+
+
+#ifndef __FreeBSD__
+/**
+ * Remove variable @p label from the RAID variables list in @p raidrec.
+ * @param raidrec The RAID device record to remove the variable from.
+ * @param label The variable name to remove.
+ * @return The value of the variable removed.
+ * @ingroup restoreUtilityGroup
+ */
+int
+read_variableINT_and_remove_from_raidvars(struct
+                                          OSSWAP (raid_device_record,
+                                                  vinum_volume) * raidrec,
+                                          char *label)
+{
+    /** int ***************************************************************/
     int i = 0;
-
-    /** newt *************************************************************/
-    newtComponent myForm;
+    int res = 0;
+
+
+    assert(raidrec != NULL);
+    assert(label != NULL);
+
+    for (i = 0;
+         i < raidrec->additional_vars.entries
+         && strcmp(raidrec->additional_vars.el[i].label, label); i++);
+    if (i == raidrec->additional_vars.entries) {
+        res = -1;
+    } else {
+        res = atoi(raidrec->additional_vars.el[i].value);
+        for (i++; i < raidrec->additional_vars.entries; i++) {
+            memcpy((void *) &raidrec->additional_vars.el[i - 1],
+                   (void *) &raidrec->additional_vars.el[i],
+                   sizeof(struct raid_var_line));
+        }
+        raidrec->additional_vars.entries--;
+    }
+    return (res);
+}
+#endif
+
+#ifndef __FreeBSD__
+/**
+ * Remove the essential RAID variables from the "additional variables" section.
+ * If they have been changed, set them in their normal locations too.
+ * @param raidrec The RAID device record to operate on.
+ * @ingroup restoreUtilityVarslist
+ */
+void remove_essential_additionalvars(struct raid_device_record *raidrec)
+{
+
+    /** int **************************************************************/
+    int res = 0;
+
+    assert(raidrec != NULL);
+
+    res =
+        read_variableINT_and_remove_from_raidvars(raidrec,
+                                                  "persistent-superblock");
+    if (res > 0) {
+        raidrec->persistent_superblock = res;
+    }
+    res = read_variableINT_and_remove_from_raidvars(raidrec, "chunk-size");
+    if (res > 0) {
+        raidrec->chunk_size = res;
+    }
+    res = read_variableINT_and_remove_from_raidvars(raidrec, "block-size");
+}
+
+#endif
+
+
+
+/**
+ * Choose the RAID level for the RAID device record in @p raidrec.
+ * @param raidrec The RAID device record to set the RAID level of.
+ * @ingroup restoreGuiMountlist
+ */
+void
+choose_raid_level(struct OSSWAP (raid_device_record, vinum_plex) * raidrec)
+{
+
+#ifdef __FreeBSD__
+
+    /** int ***************************************************************/
+    int res = 0;
+    int out = 0;
+
+    /** buffers ***********************************************************/
+    char tmp[MAX_STR_LEN];
+    char *prompt = NULL;
+    char sz[MAX_STR_LEN];
+
+    mr_asprintf(prompt, "Please enter the RAID level you want. (concat, striped, raid5)");
+    if (raidrec->raidlevel == -1) {
+        strcpy(tmp, "concat");
+    } else if (raidrec->raidlevel == 0) {
+        strcpy(tmp, "striped");
+    } else {
+        sprintf(tmp, "raid%i", raidrec->raidlevel);
+    }
+    for (out = 999; out == 999;) {
+        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
+        if (!res) {
+            mr_free(prompt);
+            return;
+        }
+        strip_spaces(tmp);
+        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
+            strcpy(sz, tmp);
+            strncpy(tmp, sz + 1, strlen(sz) - 2);
+            tmp[strlen(sz) - 2] = '\0';
+        }
+        if (!strcmp(tmp, "concat")) {
+            out = -1;
+        } else if (!strcmp(tmp, "striped")) {
+            out = 0;
+        } else if (!strcmp(tmp, "raid5")) {
+            out = 5;
+        }
+        log_it(tmp);
+        if (is_this_raid_personality_registered(out)) {
+            log_it("Groovy. You've picked a RAID personality which is registered.");
+        } else {
+            if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?"))
+            {
+                out = 999;
+            }
+        }
+    }
+    mr_free(prompt);
+
+    raidrec->raidlevel = out;
+#else
+    /** buffers ***********************************************************/
+    char tmp[MAX_STR_LEN];
+    char *personalities = NULL;
+    char *prompt = NULL;
+    char sz[MAX_STR_LEN];
+    int out = 0;
+    int res = 0;
+
+
+    assert(raidrec != NULL);
+    paranoid_system("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null");
+    mr_asprintf(personalities, "%s", last_line_of_file("/tmp/raid-personalities.txt"));
+    mr_asprintf(prompt, "Please enter the RAID level you want. %s", personalities);
+    mr_free(personalities);
+
+    if (raidrec->raid_level == -1) {
+        strcpy(tmp, "linear");
+    } else {
+        sprintf(tmp, "%d", raidrec->raid_level);
+    }
+    for (out = 999;
+         out != -1 && out != 0 && out != 1 && out != 4 && out != 5
+         && out != 10;) {
+        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
+        if (!res) {
+            return;
+        }
+        strip_spaces(tmp);
+        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
+            strcpy(sz, tmp);
+            strncpy(tmp, sz + 1, strlen(sz) - 2);
+            tmp[strlen(sz) - 2] = '\0';
+        }
+        if (!strcmp(tmp, "linear")) {
+            out = -1;
+        } else if (!strncmp(tmp, "raid", 4)) {
+            out = atoi(tmp + 4);
+        } else {
+            out = atoi(tmp);
+        }
+        log_it(tmp);
+        if (is_this_raid_personality_registered(out)) {
+            log_it("Groovy. You've picked a RAID personality which is registered.");
+        } else {
+            if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")) {
+                out = 999;
+            }
+        }
+    }
+    mr_free(prompt);
+
+    raidrec->raid_level = out;
+#endif
+}
+
+
+#ifdef __FreeBSD__
+
+/**
+ * Edit the plex @p raidrec in @p raidlist.
+ * @param mountlist The mountlist to get some of the information from.
+ * @param raidlist The raidlist containing information about RAID devices.
+ * @param raidrec The plex to edit.
+ * @param currline The line number (starting from 0) of the RAID device in @p mountlist.
+ * @param currline2 The line number (starting from 0) of the plex within the RAID device.
+ * @author Joshua Oreman
+ * @ingroup restoreGuiMountlist
+ */
+void
+edit_raidlist_plex(struct mountlist_itself *mountlist,
+                   struct raidlist_itself *raidlist,
+                   struct vinum_plex *raidrec, int currline, int currline2)
+{
+
+    /** structures ********************************************************/
+    struct vinum_plex bkp_raidrec;
+
+
+    /** buffers ***********************************************************/
+    char *title_of_editraidForm_window = NULL;
+
+    /** newt **************************************************************/
+    newtComponent editraidForm;
     newtComponent bOK;
     newtComponent bCancel;
+    newtComponent bEdit;
+    newtComponent bAdd;
+    newtComponent bDelete;
     newtComponent b_res;
-    newtComponent mountpointComp;
-    newtComponent label0;
-    newtComponent label1;
-    newtComponent label2;
-    newtComponent label3;
-    newtComponent sizeComp;
-    newtComponent deviceComp;
-    newtComponent formatComp;
-
-    /** buffers **********************************************************/
-    char *drive_to_add = NULL;
-    char *mountpoint_str = NULL;
-    char *size_str = NULL;
-    char *device_str = NULL;
-    char *format_str = NULL;
-
-    /** pointers *********************************************************/
-    char *mountpoint_here;
-    char *size_here;
-    char *device_here;
-    char *format_here;
-
-    assert(mountlist != NULL);
-    assert(raidlist != NULL);
-    assert(listbox != NULL);
-    assert(keylist != NULL);
-
-    mr_asprintf(device_str, "/dev/");
-    mr_asprintf(mountpoint_str, "/");
-    mr_asprintf(size_str, "");
-#ifdef __FreeBSD__
-    mr_asprintf(format_str, "ufs");
+    newtComponent unallocListbox, allocListbox;
+    newtComponent bLevel, sLevel;
+    newtComponent bStripeSize, sStripeSize;
+    newtComponent bAlloc, bUnalloc;
+
+    void *keylist[ARBITRARY_MAXIMUM];
+    void *curr_choice_a, *curr_choice_u;
+    int currline_a, currline_u;
+
+    char *p = NULL;
+    char *tmp = NULL;
+    char *entry = NULL;
+
+    struct mountlist_itself *unallocparts;
+
+    unallocparts = malloc(sizeof(struct mountlist_itself));
+
+    log_it("Started edit_raidlist_entry");
+    memcpy((void *) &bkp_raidrec, (void *) raidrec,
+           sizeof(struct vinum_plex));
+    mr_asprintf(title_of_editraidForm_window, "%s.p%i", raidlist->el[currline].volname, currline2);
+    newtPushHelpLine
+        ("   Please select a subdisk to edit, or edit this plex's parameters");
+    newtOpenWindow(13, 3, 54, 18, title_of_editraidForm_window);
+    mr_free(title_of_editraidForm_window);
+
+    for (;;) {
+        int i;
+
+        switch (raidrec->raidlevel) {
+        case -1:
+            mr_asprintf(tmp, "concat");
+            break;
+        case 0:
+            mr_asprintf(tmp, "striped");
+            break;
+        case 5:
+            mr_asprintf(tmp, "raid5");
+            break;
+        default:
+            mr_asprintf(tmp, "unknown (%i)", raidrec->raidlevel);
+            break;
+        }
+        bLevel = newtCompactButton(2, 2, " RAID level ");
+        sLevel = newtLabel(19, 2, tmp);
+        mr_free(tmp);
+
+        if (raidrec->raidlevel >= 0) {
+            mr_asprintf(tmp, "%ik", raidrec->stripesize);
+            bStripeSize = newtCompactButton(2, 4, " Stripe size ");
+        } else {
+            mr_asprintf(tmp, "N/A");
+            bStripeSize = newtLabel(2, 4, "Stripe size:");
+        }
+        sStripeSize = newtLabel(19, 4, tmp);
+        mr_free(tmp);
+
+        bOK = newtCompactButton(2, 16, "  OK  ");
+        bCancel = newtCompactButton(12, 16, "Cancel");
+        bAdd = newtCompactButton(22, 16, " Add ");
+        bEdit = newtCompactButton(32, 16, " Edit ");
+        bDelete = newtCompactButton(42, 16, "Delete");
+
+
+        unallocListbox =
+            newtListbox(2, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
+        allocListbox =
+            newtListbox(33, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
+        bAlloc = newtButton(23, 7, " -> ");
+        bUnalloc = newtButton(23, 11, " <- ");
+
+        editraidForm = newtForm(NULL, NULL, 0);
+
+        newtListboxClear(allocListbox);
+        newtListboxClear(unallocListbox);
+        bzero(unallocparts, sizeof(struct mountlist_itself));
+        make_list_of_unallocated_raid_partitions(unallocparts, mountlist,
+                                                 raidlist);
+        for (i = 0; i < ARBITRARY_MAXIMUM; ++i) {
+            keylist[i] = (void *) i;
+            if (i < raidrec->subdisks) {
+                mr_asprintf(entry, "%-17s", find_dev_entry_for_raid_device_name(raidlist, raidrec->sd[i].which_device));
+                newtListboxAppendEntry(allocListbox, entry, keylist[i]);
+                mr_free(entry);
+            }
+            if (i < unallocparts->entries) {
+                mr_asprintf(entry, "%-17s", unallocparts->el[i].device);
+                newtListboxAppendEntry(unallocListbox, entry, keylist[i]);
+                mr_free(entry);
+            }
+        }
+
+#define COMP(x)  newtFormAddComponent (editraidForm, x)
+#define UCOMP(x) if (unallocparts->entries > 0) COMP(x)
+#define ACOMP(x) if (raidrec->subdisks > 0) COMP(x)
+        editraidForm = newtForm(NULL, NULL, 0);
+        UCOMP(unallocListbox);
+        UCOMP(bAlloc);
+        ACOMP(allocListbox);
+        ACOMP(bUnalloc);
+        COMP(bOK);
+        COMP(bCancel);
+        COMP(bLevel);
+        COMP(sLevel);
+        if (raidrec->raidlevel != -1) {
+            COMP(bStripeSize);
+            COMP(sStripeSize);
+        }
+#undef COMP
+#undef UCOMP
+#undef ACOMP
+
+        newtDrawForm(editraidForm);
+        newtRefresh();
+        b_res = newtRunForm(editraidForm);
+        if (b_res == bOK || b_res == bCancel) {
+            break;
+        }
+
+        curr_choice_a = (raidrec->subdisks > 0) ?
+            newtListboxGetCurrent(allocListbox) : (void *) 1234;
+        curr_choice_u = (unallocparts->entries > 0) ?
+            newtListboxGetCurrent(unallocListbox) : (void *) 1234;
+        for (currline_a = 0; currline_a < raidrec->subdisks; ++currline_a) {
+            if (currline_a > ARBITRARY_MAXIMUM)
+                break;
+            if (keylist[currline_a] == curr_choice_a)
+                break;
+        }
+        for (currline_u = 0; currline_u < unallocparts->entries;
+             ++currline_u) {
+            if (currline_u > ARBITRARY_MAXIMUM)
+                break;
+            if (keylist[currline_u] == curr_choice_u)
+                break;
+        }
+        if (b_res == bLevel) {
+            choose_raid_level(raidrec);
+        } else if (b_res == bStripeSize) {
+            char tmp1[64];
+            sprintf(tmp1, "%i", raidrec->stripesize);
+            if (popup_and_get_string
+                ("Stripe size",
+                 "Please enter the stripe size in kilobytes.", tmp1, 20)) {
+                raidrec->stripesize = atoi(tmp1);
+            }
+        } else if ((b_res == bAlloc) || (b_res == unallocListbox)) {
+            if (currline_u <= unallocparts->entries)
+                add_raid_subdisk(raidlist, raidrec,
+                                 unallocparts->el[currline_u].device);
+        } else if ((b_res == bUnalloc) || (b_res == allocListbox)) {
+            if (currline_a <= raidrec->subdisks) {
+                memcpy((void *) &raidrec->sd[currline_a],
+                       (void *) &raidrec->sd[raidrec->subdisks - 1],
+                       sizeof(struct vinum_subdisk));
+                raidrec->subdisks--;
+            }
+        }
+    newtFormDestroy(editraidForm);
+    newtRefresh();
+}
+
+if (b_res == bCancel) {
+    memcpy((void *) raidrec, (void *) &bkp_raidrec, sizeof(struct vinum_plex));
+}
+newtPopWindow();
+newtPopHelpLine();
+}
 #else
-    mr_asprintf(format_str, "ext3");
+/**
+ * Edit additional RAID variable number @p lino.
+ * @param raidrec The RAID device record to edit the variable in.
+ * @param lino The line number (starting from 0) of the variable to edit.
+ * @ingroup restoreGuiVarslist
+ */
+void edit_varslist_entry(struct raid_device_record *raidrec, int lino)
+{
+
+    /** buffers ***********************************************************/
+    char *header = NULL;
+    char *comment = NULL;
+    char sz_out[MAX_STR_LEN];
+
+    assert(raidrec != 0);
+    assert(lino >= 0);
+
+    strcpy(sz_out, raidrec->additional_vars.el[lino].value);
+    mr_asprintf(header, "Edit %s", raidrec->additional_vars.el[lino].label);
+    mr_asprintf(comment, "Please set %s's value (currently '%s')", raidrec->additional_vars.el[lino].label, sz_out);
+    if (popup_and_get_string(header, comment, sz_out, MAX_STR_LEN)) {
+        strip_spaces(sz_out);
+        strcpy(raidrec->additional_vars.el[lino].value, sz_out);
+    }
+    mr_free(header);
+    mr_free(comment);
+}
 #endif
-    newtOpenWindow(20, 5, 48, 10, "Add entry");
-    label0 = newtLabel(2, 1, "Device:    ");
-    label1 = newtLabel(2, 2, "Mountpoint:");
-    label2 = newtLabel(2, 3, "Size (MB): ");
-    label3 = newtLabel(2, 4, "Format:    ");
-    deviceComp = newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
-    mountpointComp = newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
-    formatComp = newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
-    sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0);
-    bOK = newtButton(5, 6, "  OK  ");
-    bCancel = newtButton(17, 6, "Cancel");
-    newtPushHelpLine
-        ("To add an entry to the mountlist, please fill in these fields and then hit 'OK'");
-    myForm = newtForm(NULL, NULL, 0);
-    newtFormAddComponents(myForm, deviceComp, mountpointComp, sizeComp,
-                          formatComp, label0, label1, label2, label3, bOK,
-                          bCancel, NULL);
-    for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
-        b_res = newtRunForm(myForm);
-        mr_free(device_str);
-        device_str = mr_strip_spaces(device_here);
-
-        mr_free(mountpoint_str);
-        mountpoint_str = mr_strip_spaces(mountpoint_here);
-
-        mr_free(format_str);
-        format_str = mr_strip_spaces(format_here);
-
-        mr_free(size_str);
-        size_str = mr_strip_spaces(size_here);
-
-        if (b_res == bOK) {
-            if (device_str[strlen(device_str) - 1] == '/') {
-                popup_and_OK("You left the device nearly blank!");
-                b_res = NULL;
-            }
-            if (size_of_specific_device_in_mountlist(mountlist, device_str) >= 0) {
-                popup_and_OK("Can't add this - you've got one already!");
-                b_res = NULL;
-            }
-        }
-    }
-    newtFormDestroy(myForm);
-    newtPopHelpLine();
-    newtPopWindow();
-    if (b_res == bCancel) {
-        return;
-    }
-    mr_asprintf(drive_to_add, "%s", device_str);
-    for (i = strlen(drive_to_add); isdigit(drive_to_add[i - 1]); i--);
-    mr_free(drive_to_add);
-
-    currline = mountlist->entries;
-    strcpy(mountlist->el[currline].device, device_str);
-    strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
-    mr_free(mountpoint_str);
-
-    strcpy(mountlist->el[currline].format, format_str);
-    mr_free(format_str);
-
-    mountlist->el[currline].size = atol(size_str) * 1024L;
-    mr_free(size_str);
-
-    mountlist->entries++;
-    if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
-        initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str);
-    }
-    mr_free(device_str);
-
-    redraw_mountlist(mountlist, keylist, listbox);
-}
 
 
@@ -289 +997 @@
 }
 #endif
+
+
+#ifndef __FreeBSD__
+/**
+ * Delete entry number @p lino in the additional RAID variables section of @p raidrec.
+ * @param raidrec The RAID device record containing the RAID variable to delete.
+ * @param lino The line number (starting from 0) of the variable to delete.
+ * @ingroup restoreGuiVarslist
+ */
+void delete_varslist_entry(struct raid_device_record *raidrec, int lino)
+{
+
+    /** buffers ************************************************************/
+    char *tmp = NULL;
+    int res = 0;
+
+    /** structures *********************************************************/
+    struct additional_raid_variables *av;
+
+    assert(raidrec != NULL);
+
+    av = &raidrec->additional_vars;
+    mr_asprintf(tmp, "Delete %s - are you sure?", av->el[lino].label);
+    res = ask_me_yes_or_no(tmp);
+    mr_free(tmp);
+
+    if (res) {
+        if (!strcmp(av->el[lino].label, "persistent-superblock")
+            || !strcmp(av->el[lino].label, "chunk-size")) {
+            mr_asprintf(tmp, "%s must not be deleted. It would be bad.", av->el[lino].label);
+            popup_and_OK(tmp);
+            mr_free(tmp);
+        } else {
+            memcpy((void *) &av->el[lino], (void *) &av->el[av->entries--],
+                   sizeof(struct raid_var_line));
+        }
+    }
+}
+#endif
+
+
+
+#ifndef __FreeBSD__
+/**
+ * Edit the additional RAID variables in @p raidrec.
+ * @param raidrec The RAID device record to edit the RAID variables in.
+ * @ingroup restoreGuiVarslist
+ */
+void edit_raidrec_additional_vars(struct raid_device_record *raidrec)
+{
+
+    /** structure *********************************************************/
+    struct raid_device_record bkp_raidrec;
+
+    /** newt **************************************************************/
+    newtComponent myForm;
+    newtComponent bAdd;
+    newtComponent bEdit;
+    newtComponent bDelete;
+    newtComponent bOK;
+    newtComponent bCancel;
+    newtComponent b_res;
+    newtComponent varsListbox;
+    newtComponent headerMsg;
+
+    /** ?? ***************************************************************/
+    void *keylist[ARBITRARY_MAXIMUM], *curr_choice;
+
+    /** buffers **********************************************************/
+    char title_of_window[MAX_STR_LEN];
+
+    /** int **************************************************************/
+    int i = 0;
+    int currline = 0;
+
+
+    assert(raidrec != NULL);
+
+    memcpy((void *) &bkp_raidrec, (void *) raidrec,
+           sizeof(struct raid_device_record));
+    sprintf(title_of_window, "Additional variables");
+    newtPushHelpLine
+        ("  Edit the additional fields to your heart's content, then click OK or Cancel.");
+    headerMsg = newtLabel(1, 1, "Label                            Value");
+    varsListbox =
+        newtListbox(1, 2, 6, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
+    i = 1;
+    bAdd = newtCompactButton(i, 9, " Add ");
+    bEdit = newtCompactButton(i += 8, 9, " Edit ");
+    bDelete = newtCompactButton(i += 9, 9, "Delete");
+    bOK = newtCompactButton(i += 9, 9, "  OK  ");
+    bCancel = newtCompactButton(i += 9, 9, "Cancel");
+    newtOpenWindow(17, 7, 46, 10, title_of_window);
+    myForm = newtForm(NULL, NULL, 0);
+    newtFormAddComponents(myForm, headerMsg, varsListbox, bAdd, bEdit,
+                          bDelete, bOK, bCancel, NULL);
+    insert_essential_additionalvars(raidrec);
+    redraw_varslist(&raidrec->additional_vars, keylist, varsListbox);
+    for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
+        b_res = newtRunForm(myForm);
+        curr_choice = newtListboxGetCurrent(varsListbox);
+        for (currline = 0;
+             currline < raidrec->additional_vars.entries
+             && keylist[currline] != curr_choice; currline++);
+        if (currline == raidrec->additional_vars.entries
+            && raidrec->additional_vars.entries > 0) {
+            log_it("Warning - I don't know what this button does");
+        }
+        if (b_res == bOK) {     /* do nothing */
+        } else if (b_res == bCancel) {  /* do nothing */
+        } else if (b_res == bAdd) {
+            add_varslist_entry(raidrec);
+        } else if (b_res == bDelete) {
+            delete_varslist_entry(raidrec, currline);
+        } else {
+            edit_varslist_entry(raidrec, currline);
+        }
+        redraw_varslist(&raidrec->additional_vars, keylist, varsListbox);
+    }
+    remove_essential_additionalvars(raidrec);
+    newtFormDestroy(myForm);
+    newtPopWindow();
+    newtPopHelpLine();
+    if (b_res == bCancel) {
+        memcpy((void *) raidrec, (void *) &bkp_raidrec,
+               sizeof(struct raid_device_record));
+    }
+    return;
+}
+#endif
+
 
 /**
@@ -445 +1284 @@
 
 /**
- * Choose the RAID level for the RAID device record in @p raidrec.
- * @param raidrec The RAID device record to set the RAID level of.
+ * Edit the entry for @p raidrec in @p raidlist.
+ * @param mountlist The mountlist to get some information from.
+ * @param raidlist The raidlist containing information about RAID devices.
+ * @param raidrec The RAID device record for this partition.
+ * @param currline The line number (starting from 0) in the mountlist of the RAID device.
  * @ingroup restoreGuiMountlist
  */
+void edit_raidlist_entry(struct mountlist_itself *mountlist,
+                    struct raidlist_itself *raidlist,
+                    struct OSSWAP (raid_device_record,
+                                   vinum_volume) * raidrec, int currline)
+{
+
+#ifdef __FreeBSD__
+    /** structures ********************************************************/
+    struct vinum_volume bkp_raidrec;
+
+
+    /** buffers ***********************************************************/
+    char title_of_editraidForm_window[MAX_STR_LEN];
+
+    /** newt **************************************************************/
+    newtComponent editraidForm;
+    newtComponent bOK;
+    newtComponent bCancel;
+    newtComponent bEdit;
+    newtComponent bAdd;
+    newtComponent bDelete;
+    newtComponent b_res;
+    newtComponent plexesListbox;
+    newtComponent plexesHeader;
+
+    void *keylist[10];
+    void *curr_choice;
+    char *raidlevel = NULL;
+    char *chunksize = NULL;
+    char *msg = NULL;
+
+    int currline2 = 0;
+    int res = 0;
+
+    log_it("Started edit_raidlist_entry");
+    memcpy((void *) &bkp_raidrec, (void *) raidrec,
+           sizeof(struct vinum_volume));
+    sprintf(title_of_editraidForm_window, "Plexes on %s",
+            raidrec->volname);
+    newtPushHelpLine("   Please select a plex to edit");
+    newtOpenWindow(13, 5, 54, 15, title_of_editraidForm_window);
+    for (;;) {
+        int i;
+        char *headerstr = NULL;
+        mr_asprintf(headerstr, "%-14s %-8s  %11s  %8s", "Plex", "Level", "Stripe Size", "Subdisks");
+
+        bOK = newtCompactButton(2, 13, "  OK  ");
+        bCancel = newtCompactButton(12, 13, "Cancel");
+        bAdd = newtCompactButton(22, 13, " Add ");
+        bEdit = newtCompactButton(32, 13, " Edit ");
+        bDelete = newtCompactButton(42, 13, "Delete");
+
+        plexesListbox =
+            newtListbox(2, 3, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
+        plexesHeader = newtLabel(2, 2, headerstr);
+        mr_free(headerstr);
+        editraidForm = newtForm(NULL, NULL, 0);
+
+        newtListboxClear(plexesListbox);
+        for (i = 0; i < 10; ++i) {
+            keylist[i] = (void *) i;
+            if (i < raidrec->plexes) {
+                char *pname;
+                char *entry;
+                switch (raidrec->plex[i].raidlevel) {
+                case -1:
+                    mr_asprintf(raidlevel, "concat");
+                    break;
+                case 0:
+                    mr_asprintf(raidlevel, "striped");
+                    break;
+                case 5:
+                    mr_asprintf(raidlevel, "raid5");
+                    break;
+                default:
+                    mr_asprintf(raidlevel, "raid%i", raidrec->plex[i].raidlevel);
+                    break;
+                }
+
+                if (raidrec->plex[i].raidlevel == -1) {
+                    mr_asprintf(chunksize, "N/A");
+                } else {
+                    mr_asprintf(chunksize, "%dk", raidrec->plex[i].stripesize);
+                }
+                mr_asprintf(pname, "%s.p%i", raidrec->volname, i);
+                mr_asprintf(entry, "%-14s %-8s  %11s  %8d", pname, raidlevel, chunksize, raidrec->plex[i].subdisks);
+                mr_free(pname);
+                mr_free(raidlevel);
+                mr_free(chunksize);
+
+                newtListboxAppendEntry(plexesListbox, entry, keylist[i]);
+                mr_free(entry);
+            }
+        }
+
+        newtFormAddComponents(editraidForm, bOK, bCancel, bAdd, bEdit,
+                              bDelete, plexesListbox, plexesHeader, NULL);
+
+        b_res = newtRunForm(editraidForm);
+        if (b_res == bOK || b_res == bCancel) {
+            break;
+        }
+
+        curr_choice = newtListboxGetCurrent(plexesListbox);
+        for (currline2 = 0; currline2 < raidrec->plexes; ++currline2) {
+            if (currline2 > 9)
+                break;
+            if (keylist[currline2] == curr_choice)
+                break;
+        }
+
+        if (b_res == bDelete) {
+            mr_asprintf(msg, "Are you sure you want to delete %s.p%i?", raidrec->volname, currline2);
+            res = ask_me_yes_or_no(msg);
+            mr_free(msg);
+
+            if (res) {
+                log_it("Deleting RAID plex");
+                memcpy((void *) &raidrec->plex[currline2],
+                       (void *) &raidrec->plex[raidrec->plexes - 1],
+                       sizeof(struct vinum_plex));
+                raidrec->plexes--;
+            }
+            continue;
+        }
+        if (b_res == bAdd) {
+            raidrec->plex[raidrec->plexes].raidlevel = 0;
+            raidrec->plex[raidrec->plexes].stripesize = 279;
+            raidrec->plex[raidrec->plexes].subdisks = 0;
+            currline2 = raidrec->plexes++;
+        }
+        edit_raidlist_plex(mountlist, raidlist, &raidrec->plex[currline2],
+                           currline, currline2);
+        newtFormDestroy(editraidForm);
+    }
+    if (b_res == bCancel) {
+        memcpy((void *) raidrec, (void *) &bkp_raidrec,
+               sizeof(struct vinum_volume));
+    }
+    newtPopHelpLine();
+    newtPopWindow();
+    mountlist->el[currline].size =
+        calculate_raid_device_size(mountlist, raidlist, raidrec->volname);
+#else
+    /** structures ********************************************************/
+    struct raid_device_record *bkp_raidrec;
+
+
+    /** buffers ***********************************************************/
+    char *title_of_editraidForm_window;
+    char *sz_raid_level = NULL;
+    char *sz_data_disks = NULL;
+    char *sz_spare_disks = NULL;
+    char *sz_parity_disks = NULL;
+    char *sz_failed_disks = NULL;
+
+    /** newt **************************************************************/
+    newtComponent editraidForm;
+    newtComponent bOK;
+    newtComponent bCancel;
+    newtComponent bAdditional;
+    newtComponent bChangeRaid;
+    newtComponent bSelectData;
+    newtComponent bSelectSpare;
+    newtComponent bSelectParity;
+    newtComponent bSelectFailed;
+    newtComponent b_res;
+
+    assert(mountlist != NULL);
+    assert(raidlist != NULL);
+    assert(raidrec != NULL);
+
+    bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
+    log_it("Started edit_raidlist_entry");
+
+    memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record));
+    mr_asprintf(title_of_editraidForm_window, "%s", raidrec->raid_device);
+    log_msg(2, "Opening newt window");
+    newtOpenWindow(20, 5, 40, 14, title_of_editraidForm_window);
+    for (;;) {
+        log_msg(2, "Main loop");
+        mr_free(title_of_editraidForm_window);
+        mr_asprintf(title_of_editraidForm_window, "Edit %s", raidrec->raid_device);
+        sz_raid_level = turn_raid_level_number_to_string(raidrec->raid_level);
+        sz_data_disks = number_of_disks_as_string(raidrec->data_disks.entries, "data");
+        sz_spare_disks = number_of_disks_as_string(raidrec->spare_disks.entries, "spare");
+        sz_parity_disks = number_of_disks_as_string(raidrec->parity_disks.entries, "parity");
+        sz_failed_disks = number_of_disks_as_string(raidrec->failed_disks.entries, "failed");
+        bSelectData = newtButton(1, 1, sz_data_disks);
+        bSelectSpare = newtButton(20, 1, sz_spare_disks);
+        bSelectParity = newtButton(1, 5, sz_parity_disks);
+        bSelectFailed = newtButton(20, 5, sz_failed_disks);
+        bChangeRaid = newtButton(1, 9, sz_raid_level);
+        bOK = newtButton(16 + (raidrec->raid_level == -1), 9, "  OK  ");
+        bCancel = newtButton(28, 9, "Cancel");
+        bAdditional =
+            newtCompactButton(1, 13,
+                              "Additional settings and information");
+        newtPushHelpLine
+            ("  Edit the RAID device's settings to your heart's content, then hit OK/Cancel.");
+        editraidForm = newtForm(NULL, NULL, 0);
+        newtFormAddComponents(editraidForm, bSelectData, bSelectParity,
+                              bChangeRaid, bSelectSpare, bSelectFailed,
+                              bOK, bCancel, bAdditional);
+        b_res = newtRunForm(editraidForm);
+        if (b_res == bChangeRaid) {
+            choose_raid_level(raidrec);
+        } else if (b_res == bSelectData) {
+            select_raid_disks(mountlist, raidlist, raidrec, "data", &raidrec->data_disks);
+        } else if (b_res == bSelectSpare) {
+            select_raid_disks(mountlist, raidlist, raidrec, "spare", &raidrec->spare_disks);
+        } else if (b_res == bSelectParity) {
+            select_raid_disks(mountlist, raidlist, raidrec, "parity", &raidrec->parity_disks);
+        } else if (b_res == bSelectFailed) {
+            select_raid_disks(mountlist, raidlist, raidrec, "failed", &raidrec->failed_disks);
+        } else if (b_res == bAdditional) {
+            edit_raidrec_additional_vars(raidrec);
+        }
+        newtFormDestroy(editraidForm);
+        if (b_res == bOK || b_res == bCancel) {
+            break;
+        }
+        mr_free(sz_data_disks);
+        mr_free(sz_spare_disks);
+        mr_free(sz_parity_disks);
+        mr_free(sz_failed_disks);
+    }
+    if (b_res == bCancel) {
+        memcpy((void *) raidrec, (void *) bkp_raidrec, sizeof(struct raid_device_record));
+    }
+    newtPopHelpLine();
+    newtPopWindow();
+    mountlist->el[currline].size = calculate_raid_device_size(mountlist, raidlist, raidrec->raid_device);
+    mr_free(title_of_editraidForm_window);
+    mr_free(sz_raid_level);
+    paranoid_free(bkp_raidrec);
+#endif
+}
+
+
+/**
+ * Create a new raidtab entry for @p device in @p raidlist.
+ * @param raidlist The raidlist to add the device to.
+ * @param mountlist The mountlist containing information about the user's partitions.
+ * @param currline The selected line in the mountlist.
+ * @param device The RAID device (e.g. /dev/md0) to use.
+ * @ingroup restoreGuiMountlist
+ */
 void
-choose_raid_level(struct OSSWAP (raid_device_record, vinum_plex) * raidrec)
-{
-
+initiate_new_raidlist_entry(struct raidlist_itself *raidlist,
+                            struct mountlist_itself *mountlist,
+                            int currline, char *device)
+{
+
+    /** structure *********************************************************/
+    struct OSSWAP (raid_device_record, vinum_volume) * raidrec;
+
+    /** int ***************************************************************/
+    int pos_in_raidlist = 0;
+
+    assert(raidlist != NULL);
+    assert(mountlist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(device);
+
+    pos_in_raidlist =
+        find_raid_device_in_raidlist(raidlist,
+                                     mountlist->el[currline].device);
+    if (pos_in_raidlist >= 0) {
+        fatal_error("Sorry, that RAID device already exists. Weird.");
+    }
+    pos_in_raidlist = raidlist->entries++;
+    raidrec = &raidlist->el[pos_in_raidlist];
+    initialize_raidrec(raidrec);
+    strcpy(raidrec->OSSWAP(raid_device, volname), OSSWAP(device, basename(device)));
+#ifndef __FreeBSD__
+    choose_raid_level(raidrec);
+    select_raid_disks(mountlist, raidlist, raidrec, "data",
+                      &raidrec->data_disks);
+#endif
+    edit_raidlist_entry(mountlist, raidlist, raidrec, currline);
+}
+
+
+/**
+ * Redraw the mountlist.
+ * @param mountlist The mountlist to read from.
+ * @param keylist The list of keys for @p listbox.
+ * @param listbox The Newt listbox component to redraw.
+ * @ingroup restoreGuiMountlist
+ */
+void
+redraw_mountlist(struct mountlist_itself *mountlist,
+                 void *keylist[ARBITRARY_MAXIMUM], newtComponent listbox)
+{
+
+    /** long **************************************************************/
+    long i = 0;
+    char * tmp = NULL;
+
+    assert(mountlist != NULL);
+    assert(keylist != NULL);
+    assert(listbox != NULL);
+
+    newtListboxClear(listbox);
+//  sort_mountlist_by_device (mountlist);
+    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
+        keylist[i] = (void *) i;
+    }
+    for (i = 0; i < mountlist->entries; i++) {
+        tmp = mountlist_entry_to_string(mountlist, i);
+        newtListboxAppendEntry(listbox, tmp, keylist[i]);
+        mr_free(tmp);
+    }
+}
+
+
+
+
+/**
+ * Add an entry to @p mountlist.
+ * @param mountlist The mountlist to add an entry to.
+ * @param raidlist The raidlist that accompanies @p mountlist.
+ * @param listbox The listbox component in the mountlist editor.
+ * @param currline The line selected in @p listbox.
+ * @param keylist The list of keys for @p listbox.
+ * @ingroup restoreGuiMountlist
+ */
+void
+add_mountlist_entry(struct mountlist_itself *mountlist,
+                    struct raidlist_itself *raidlist,
+                    newtComponent listbox, int currline, void *keylist[])
+{
+
+    /** int **************************************************************/
+    int i = 0;
+
+    /** newt *************************************************************/
+    newtComponent myForm;
+    newtComponent bOK;
+    newtComponent bCancel;
+    newtComponent b_res;
+    newtComponent mountpointComp;
+    newtComponent label0;
+    newtComponent label1;
+    newtComponent label2;
+    newtComponent label3;
+    newtComponent sizeComp;
+    newtComponent deviceComp;
+    newtComponent formatComp;
+
+    /** buffers **********************************************************/
+    char *drive_to_add = NULL;
+    char *mountpoint_str = NULL;
+    char *size_str = NULL;
+    char *device_str = NULL;
+    char *format_str = NULL;
+
+    /** pointers *********************************************************/
+    char *mountpoint_here;
+    char *size_here;
+    char *device_here;
+    char *format_here;
+
+    assert(mountlist != NULL);
+    assert(raidlist != NULL);
+    assert(listbox != NULL);
+    assert(keylist != NULL);
+
+    mr_asprintf(device_str, "/dev/");
+    mr_asprintf(mountpoint_str, "/");
+    mr_asprintf(size_str, "");
 #ifdef __FreeBSD__
-
-    /** int ***************************************************************/
-    int res = 0;
-    int out = 0;
-
-    /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-    char *prompt = NULL;
-    char sz[MAX_STR_LEN];
-
-    mr_asprintf(prompt, "Please enter the RAID level you want. (concat, striped, raid5)");
-    if (raidrec->raidlevel == -1) {
-        strcpy(tmp, "concat");
-    } else if (raidrec->raidlevel == 0) {
-        strcpy(tmp, "striped");
-    } else {
-        sprintf(tmp, "raid%i", raidrec->raidlevel);
-    }
-    for (out = 999; out == 999;) {
-        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
-        if (!res) {
-            mr_free(prompt);
-            return;
-        }
-        strip_spaces(tmp);
-        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
-            strcpy(sz, tmp);
-            strncpy(tmp, sz + 1, strlen(sz) - 2);
-            tmp[strlen(sz) - 2] = '\0';
-        }
-        if (!strcmp(tmp, "concat")) {
-            out = -1;
-        } else if (!strcmp(tmp, "striped")) {
-            out = 0;
-        } else if (!strcmp(tmp, "raid5")) {
-            out = 5;
-        }
-        log_it(tmp);
-        if (is_this_raid_personality_registered(out)) {
-            log_it("Groovy. You've picked a RAID personality which is registered.");
-        } else {
-            if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?"))
-            {
-                out = 999;
+    mr_asprintf(format_str, "ufs");
+#else
+    mr_asprintf(format_str, "ext3");
+#endif
+    newtOpenWindow(20, 5, 48, 10, "Add entry");
+    label0 = newtLabel(2, 1, "Device:    ");
+    label1 = newtLabel(2, 2, "Mountpoint:");
+    label2 = newtLabel(2, 3, "Size (MB): ");
+    label3 = newtLabel(2, 4, "Format:    ");
+    deviceComp = newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
+    mountpointComp = newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
+    formatComp = newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
+    sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0);
+    bOK = newtButton(5, 6, "  OK  ");
+    bCancel = newtButton(17, 6, "Cancel");
+    newtPushHelpLine
+        ("To add an entry to the mountlist, please fill in these fields and then hit 'OK'");
+    myForm = newtForm(NULL, NULL, 0);
+    newtFormAddComponents(myForm, deviceComp, mountpointComp, sizeComp,
+                          formatComp, label0, label1, label2, label3, bOK,
+                          bCancel, NULL);
+    for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
+        b_res = newtRunForm(myForm);
+        mr_free(device_str);
+        device_str = mr_strip_spaces(device_here);
+
+        mr_free(mountpoint_str);
+        mountpoint_str = mr_strip_spaces(mountpoint_here);
+
+        mr_free(format_str);
+        format_str = mr_strip_spaces(format_here);
+
+        mr_free(size_str);
+        size_str = mr_strip_spaces(size_here);
+
+        if (b_res == bOK) {
+            if (device_str[strlen(device_str) - 1] == '/') {
+                popup_and_OK("You left the device nearly blank!");
+                b_res = NULL;
             }
-        }
-    }
-    mr_free(prompt);
-
-    raidrec->raidlevel = out;
-#else
-    /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-    char *personalities = NULL;
-    char *prompt = NULL;
-    char sz[MAX_STR_LEN];
-    int out = 0;
-    int res = 0;
-
-
-    assert(raidrec != NULL);
-    paranoid_system("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null");
-    mr_asprintf(personalities, "%s", last_line_of_file("/tmp/raid-personalities.txt"));
-    mr_asprintf(prompt, "Please enter the RAID level you want. %s", personalities);
-    mr_free(personalities);
-
-    if (raidrec->raid_level == -1) {
-        strcpy(tmp, "linear");
-    } else {
-        sprintf(tmp, "%d", raidrec->raid_level);
-    }
-    for (out = 999;
-         out != -1 && out != 0 && out != 1 && out != 4 && out != 5
-         && out != 10;) {
-        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
-        if (!res) {
-            return;
-        }
-        strip_spaces(tmp);
-        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
-            strcpy(sz, tmp);
-            strncpy(tmp, sz + 1, strlen(sz) - 2);
-            tmp[strlen(sz) - 2] = '\0';
-        }
-        if (!strcmp(tmp, "linear")) {
-            out = -1;
-        } else if (!strncmp(tmp, "raid", 4)) {
-            out = atoi(tmp + 4);
-        } else {
-            out = atoi(tmp);
-        }
-        log_it(tmp);
-        if (is_this_raid_personality_registered(out)) {
-            log_it("Groovy. You've picked a RAID personality which is registered.");
-        } else {
-            if (ask_me_yes_or_no("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")) {
-                out = 999;
+            if (size_of_specific_device_in_mountlist(mountlist, device_str) >= 0) {
+                popup_and_OK("Can't add this - you've got one already!");
+                b_res = NULL;
             }
         }
     }
-    mr_free(prompt);
-
-    raidrec->raid_level = out;
-#endif
+    newtFormDestroy(myForm);
+    newtPopHelpLine();
+    newtPopWindow();
+    if (b_res == bCancel) {
+        return;
+    }
+    mr_asprintf(drive_to_add, "%s", device_str);
+    for (i = strlen(drive_to_add); isdigit(drive_to_add[i - 1]); i--);
+    mr_free(drive_to_add);
+
+    currline = mountlist->entries;
+    strcpy(mountlist->el[currline].device, device_str);
+    strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
+    mr_free(mountpoint_str);
+
+    strcpy(mountlist->el[currline].format, format_str);
+    mr_free(format_str);
+
+    mountlist->el[currline].size = atol(size_str) * 1024L;
+    mr_free(size_str);
+
+    mountlist->entries++;
+    if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
+        initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str);
+    }
+    mr_free(device_str);
+
+    redraw_mountlist(mountlist, keylist, listbox);
 }
 
@@ -601 +1780 @@
 
 
-
-/**
- * Delete entry number @p currline from @p disklist.
- * @param disklist The disklist to remove the entry from.
- * @param raid_device The RAID device containing the partition we're removing.
- * Used only in the popup "are you sure?" box.
- * @param currline The line number (starting from 0) of the item to delete.
- * @ingroup restoreGuiDisklist
- */
-void
-delete_disklist_entry(struct list_of_disks *disklist, char *raid_device,
-                      int currline)
-{
-
-    /** int ***************************************************************/
-    int pos = 0;
-    int res = 0;
-
-    /** buffers ***********************************************************/
-    char *tmp = NULL;
-
-    assert(disklist != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(raid_device);
-
-    mr_asprintf(tmp, "Delete %s from RAID device %s - are you sure?", disklist->el[currline].device, raid_device);
-    res = ask_me_yes_or_no(tmp);
-    mr_free(tmp);
-
-    if (!res) {
-        return;
-    }
-    for (pos = currline; pos < disklist->entries - 1; pos++) {
-        strcpy(disklist->el[pos].device, disklist->el[pos + 1].device);
-    }
-    disklist->entries--;
-}
-
-
-
-/**
- * Delete entry number @p currline from @p mountlist.
- * @param mountlist The mountlist to delete the entry from.
- * @param raidlist The raidlist that goes with @p mountlist.
- * @param listbox The Newt listbox component in the mountlist editor.
- * @param currline The line number (starting from 0) of the item to delete.
- * @param keylist The list of keys for @p listbox.
- * @ingroup restoreGuiMountlist
- */
-void
-delete_mountlist_entry(struct mountlist_itself *mountlist,
-                       struct raidlist_itself *raidlist,
-                       newtComponent listbox, int currline,
-                       void *keylist[])
-{
-
-    /** int ***************************************************************/
-    int pos = 0;
-    int res = 0;
-
-    /** buffers ***********************************************************/
-    char *tmp = NULL;
-    char *device = NULL;
-
-
-    assert(mountlist != NULL);
-    assert(raidlist != NULL);
-    assert(listbox != NULL);
-    assert(keylist != NULL);
-
-    pos = which_raid_device_is_using_this_partition(raidlist, mountlist->el[currline].device);
-    if (pos >= 0) {
-        mr_asprintf(tmp, "Cannot delete %s: it is in use by RAID device %s", mountlist->el[currline].device, raidlist->el[pos].OSSWAP(raid_device, volname));
-        popup_and_OK(tmp);
-        mr_free(tmp);
-        return;
-    }
-    mr_asprintf(tmp, "Delete %s - are you sure?", mountlist->el[currline].device);
-    res = ask_me_yes_or_no(tmp);
-    mr_free(tmp);
-
-    if (!res) {
-        return;
-    }
-    if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
-        mr_asprintf(device, "%s", mountlist->el[currline].device);
-        delete_raidlist_entry(mountlist, raidlist, device);
-        for (currline = 0;
-             currline < mountlist->entries
-             && strcmp(mountlist->el[currline].device, device);
-             currline++);
-        mr_free(device);
-
-        if (currline == mountlist->entries) {
-            log_it("Dev is gone. I can't delete it. Ho-hum");
-            return;
-        }
-    }
-    memcpy((void *) &mountlist->el[currline],
-           (void *) &mountlist->el[mountlist->entries - 1],
-           sizeof(struct mountlist_line));
-    mountlist->entries--;
-    redraw_mountlist(mountlist, keylist, listbox);
-}
-
-
 /**
  * Delete @p device from @p raidlist.
@@ -713 +1787 @@
  * @ingroup restoreGuiMountlist
  */
-void
-delete_raidlist_entry(struct mountlist_itself *mountlist,
+void delete_raidlist_entry(struct mountlist_itself *mountlist,
                       struct raidlist_itself *raidlist, char *device)
 {
@@ -783 +1856 @@
 
 
-#ifndef __FreeBSD__
-/**
- * Delete entry number @p lino in the additional RAID variables section of @p raidrec.
- * @param raidrec The RAID device record containing the RAID variable to delete.
- * @param lino The line number (starting from 0) of the variable to delete.
- * @ingroup restoreGuiVarslist
- */
-void delete_varslist_entry(struct raid_device_record *raidrec, int lino)
-{
-
-    /** buffers ************************************************************/
+
+/**
+ * Delete entry number @p currline from @p mountlist.
+ * @param mountlist The mountlist to delete the entry from.
+ * @param raidlist The raidlist that goes with @p mountlist.
+ * @param listbox The Newt listbox component in the mountlist editor.
+ * @param currline The line number (starting from 0) of the item to delete.
+ * @param keylist The list of keys for @p listbox.
+ * @ingroup restoreGuiMountlist
+ */
+void
+delete_mountlist_entry(struct mountlist_itself *mountlist,
+                       struct raidlist_itself *raidlist,
+                       newtComponent listbox, int currline,
+                       void *keylist[])
+{
+
+    /** int ***************************************************************/
+    int pos = 0;
+    int res = 0;
+
+    /** buffers ***********************************************************/
     char *tmp = NULL;
-    int res = 0;
-
-    /** structures *********************************************************/
-    struct additional_raid_variables *av;
-
-    assert(raidrec != NULL);
-
-    av = &raidrec->additional_vars;
-    mr_asprintf(tmp, "Delete %s - are you sure?", av->el[lino].label);
+    char *device = NULL;
+
+
+    assert(mountlist != NULL);
+    assert(raidlist != NULL);
+    assert(listbox != NULL);
+    assert(keylist != NULL);
+
+    pos = which_raid_device_is_using_this_partition(raidlist, mountlist->el[currline].device);
+    if (pos >= 0) {
+        mr_asprintf(tmp, "Cannot delete %s: it is in use by RAID device %s", mountlist->el[currline].device, raidlist->el[pos].OSSWAP(raid_device, volname));
+        popup_and_OK(tmp);
+        mr_free(tmp);
+        return;
+    }
+    mr_asprintf(tmp, "Delete %s - are you sure?", mountlist->el[currline].device);
     res = ask_me_yes_or_no(tmp);
     mr_free(tmp);
 
-    if (res) {
-        if (!strcmp(av->el[lino].label, "persistent-superblock")
-            || !strcmp(av->el[lino].label, "chunk-size")) {
-            mr_asprintf(tmp, "%s must not be deleted. It would be bad.", av->el[lino].label);
-            popup_and_OK(tmp);
-            mr_free(tmp);
+    if (!res) {
+        return;
+    }
+    if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
+        mr_asprintf(device, "%s", mountlist->el[currline].device);
+        delete_raidlist_entry(mountlist, raidlist, device);
+        for (currline = 0;
+             currline < mountlist->entries
+             && strcmp(mountlist->el[currline].device, device);
+             currline++);
+        mr_free(device);
+
+        if (currline == mountlist->entries) {
+            log_it("Dev is gone. I can't delete it. Ho-hum");
+            return;
+        }
+    }
+    memcpy((void *) &mountlist->el[currline],
+           (void *) &mountlist->el[mountlist->entries - 1],
+           sizeof(struct mountlist_line));
+    mountlist->entries--;
+    redraw_mountlist(mountlist, keylist, listbox);
+}
+
+
+/**
+ * Strip a path to the bare minimum (^ pointing to the directory above, plus filename).
+ * @param tmp The path to strip.
+ * @return The stripped path.
+ * @author Conor Daly
+ * @ingroup restoreUtilityGroup
+ */
+char *strip_path(char *tmp)
+{
+
+    int i = 0, j = 0, slashcount = 0;
+    int slashloc = 0, lastslashloc = 0;
+
+    while (tmp[i] != '\0') {    /* Count the slashes in tmp
+                                   1 slash per dir */
+        if (tmp[i] == '/') {
+            slashcount++;
+            lastslashloc = slashloc;
+            slashloc = i;
+            if (tmp[i + 1] == '\0') {   /* if this slash is last char, back off */
+                slashcount--;
+                slashloc = lastslashloc;
+            }
+        }
+        i++;
+    }
+    if (slashcount > 0)
+        slashcount--;           /* Keep one slash 'cos Hugh does... */
+
+    for (i = 0; i < slashcount; i++) {  /* Replace each dir with a space char */
+        tmpnopath[i] = ' ';
+    }
+
+    i = slashloc;
+    j = slashcount;
+    while (tmp[i] != '\0') {    /* Now add what's left of tmp */
+        if ((tmpprevpath[j] == ' ' || tmpprevpath[j] == '^')
+            && tmp[i] == '/' && tmpnopath[j - 1] != '^' && j != 0) {    /* Add a pointer upwards if this is not in the same dir as line above */
+            tmpnopath[j - 1] = '^';
         } else {
-            memcpy((void *) &av->el[lino], (void *) &av->el[av->entries--],
-                   sizeof(struct raid_var_line));
-        }
-    }
-}
-#endif
+            tmpnopath[j++] = tmp[i++];
+        }
+    }
+    tmpnopath[j] = '\0';
+
+    strcpy(tmpprevpath, tmpnopath); /* Make a copy for next iteration */
+
+    return (tmpnopath);
+}
+
 
 
@@ -924 +2077 @@
         return (0);
     }
-}
-
-
-/**
- * Strip a path to the bare minimum (^ pointing to the directory above, plus filename).
- * @param tmp The path to strip.
- * @return The stripped path.
- * @author Conor Daly
- * @ingroup restoreUtilityGroup
- */
-char *strip_path(char *tmp)
-{
-
-    int i = 0, j = 0, slashcount = 0;
-    int slashloc = 0, lastslashloc = 0;
-
-    while (tmp[i] != '\0') {    /* Count the slashes in tmp
-                                   1 slash per dir */
-        if (tmp[i] == '/') {
-            slashcount++;
-            lastslashloc = slashloc;
-            slashloc = i;
-            if (tmp[i + 1] == '\0') {   /* if this slash is last char, back off */
-                slashcount--;
-                slashloc = lastslashloc;
-            }
-        }
-        i++;
-    }
-    if (slashcount > 0)
-        slashcount--;           /* Keep one slash 'cos Hugh does... */
-
-    for (i = 0; i < slashcount; i++) {  /* Replace each dir with a space char */
-        tmpnopath[i] = ' ';
-    }
-
-    i = slashloc;
-    j = slashcount;
-    while (tmp[i] != '\0') {    /* Now add what's left of tmp */
-        if ((tmpprevpath[j] == ' ' || tmpprevpath[j] == '^')
-            && tmp[i] == '/' && tmpnopath[j - 1] != '^' && j != 0) {    /* Add a pointer upwards if this is not in the same dir as line above */
-            tmpnopath[j - 1] = '^';
-        } else {
-            tmpnopath[j++] = tmp[i++];
-        }
-    }
-    tmpnopath[j] = '\0';
-
-    strcpy(tmpprevpath, tmpnopath); /* Make a copy for next iteration */
-
-    return (tmpnopath);
 }
 
@@ -1113 +2215 @@
 
 /**
+ * Change all RAID devices to use @p new_dev instead of @p old_dev.
+ * @param raidlist The raidlist to make the changes in.
+ * @param old_dev The old name of the device (what it used to be).
+ * @param new_dev The new name of the device (what it is now).
+ * @ingroup restoreGuiMountlist
+ */
+void rejig_partition_name_in_raidlist_if_necessary(struct raidlist_itself
+                                                   *raidlist,
+                                                   char *old_dev,
+                                                   char *new_dev)
+{
+    /** int ************************************************************/
+    int pos = 0;
+    int j = 0;
+
+    assert(raidlist != NULL);
+    assert_string_is_neither_NULL_nor_zerolength(old_dev);
+    assert_string_is_neither_NULL_nor_zerolength(new_dev);
+
+    pos = which_raid_device_is_using_this_partition(raidlist, old_dev);
+    if (pos < 0) {
+        log_it("No need to rejig %s in raidlist: it's not listed.", old_dev);
+    } else {
+        if ((j =
+             where_in_drivelist_is_drive(&raidlist->
+                                         OSSWAP(el[pos].data_disks, disks),
+                                         old_dev)) >= 0) {
+            strcpy(raidlist->OSSWAP(el[pos].data_disks, disks).el[j].device, new_dev);
+        } else
+            if ((j =
+                 where_in_drivelist_is_drive(&raidlist->
+                                             OSSWAP(el[pos].spare_disks,
+                                                    spares),
+                                             old_dev)) >= 0) {
+            strcpy(raidlist->OSSWAP(el[pos].spare_disks, spares).el[j].device, new_dev);
+        }
+#ifndef __FreeBSD__
+        else if ((j =
+                  where_in_drivelist_is_drive(&raidlist->el[pos].
+                                              parity_disks,
+                                              old_dev)) >= 0) {
+            strcpy(raidlist->el[pos].parity_disks.el[j].device, new_dev);
+        } else
+            if ((j =
+                 where_in_drivelist_is_drive(&raidlist->el[pos].
+                                             failed_disks,
+                                             old_dev)) >= 0) {
+            strcpy(raidlist->el[pos].failed_disks.el[j].device, new_dev);
+        }
+#endif
+        else {
+            log_it("%s is supposed to be listed in this raid dev but it's not...", old_dev);
+        }
+    }
+}
+
+
+/**
  * Edit an entry in @p mountlist.
  * @param mountlist The mountlist containing information about the user's partitions.
@@ -1380 +2540 @@
                    struct vinum_plex *raidrec, int currline,
                    int currline2);
-
-#endif
-
-
-/**
- * Edit the entry for @p raidrec in @p raidlist.
- * @param mountlist The mountlist to get some information from.
- * @param raidlist The raidlist containing information about RAID devices.
- * @param raidrec The RAID device record for this partition.
- * @param currline The line number (starting from 0) in the mountlist of the RAID device.
- * @ingroup restoreGuiMountlist
- */
-void
-edit_raidlist_entry(struct mountlist_itself *mountlist,
-                    struct raidlist_itself *raidlist,
-                    struct OSSWAP (raid_device_record,
-                                   vinum_volume) * raidrec, int currline)
-{
-
-#ifdef __FreeBSD__
-    /** structures ********************************************************/
-    struct vinum_volume bkp_raidrec;
-
-
-    /** buffers ***********************************************************/
-    char title_of_editraidForm_window[MAX_STR_LEN];
-
-    /** newt **************************************************************/
-    newtComponent editraidForm;
-    newtComponent bOK;
-    newtComponent bCancel;
-    newtComponent bEdit;
-    newtComponent bAdd;
-    newtComponent bDelete;
-    newtComponent b_res;
-    newtComponent plexesListbox;
-    newtComponent plexesHeader;
-
-    void *keylist[10];
-    void *curr_choice;
-    char *raidlevel = NULL;
-    char *chunksize = NULL;
-    char *msg = NULL;
-
-    int currline2 = 0;
-    int res = 0;
-
-    log_it("Started edit_raidlist_entry");
-    memcpy((void *) &bkp_raidrec, (void *) raidrec,
-           sizeof(struct vinum_volume));
-    sprintf(title_of_editraidForm_window, "Plexes on %s",
-            raidrec->volname);
-    newtPushHelpLine("   Please select a plex to edit");
-    newtOpenWindow(13, 5, 54, 15, title_of_editraidForm_window);
-    for (;;) {
-        int i;
-        char *headerstr = NULL;
-        mr_asprintf(headerstr, "%-14s %-8s  %11s  %8s", "Plex", "Level", "Stripe Size", "Subdisks");
-
-        bOK = newtCompactButton(2, 13, "  OK  ");
-        bCancel = newtCompactButton(12, 13, "Cancel");
-        bAdd = newtCompactButton(22, 13, " Add ");
-        bEdit = newtCompactButton(32, 13, " Edit ");
-        bDelete = newtCompactButton(42, 13, "Delete");
-
-        plexesListbox =
-            newtListbox(2, 3, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        plexesHeader = newtLabel(2, 2, headerstr);
-        mr_free(headerstr);
-        editraidForm = newtForm(NULL, NULL, 0);
-
-        newtListboxClear(plexesListbox);
-        for (i = 0; i < 10; ++i) {
-            keylist[i] = (void *) i;
-            if (i < raidrec->plexes) {
-                char *pname;
-                char *entry;
-                switch (raidrec->plex[i].raidlevel) {
-                case -1:
-                    mr_asprintf(raidlevel, "concat");
-                    break;
-                case 0:
-                    mr_asprintf(raidlevel, "striped");
-                    break;
-                case 5:
-                    mr_asprintf(raidlevel, "raid5");
-                    break;
-                default:
-                    mr_asprintf(raidlevel, "raid%i", raidrec->plex[i].raidlevel);
-                    break;
-                }
-
-                if (raidrec->plex[i].raidlevel == -1) {
-                    mr_asprintf(chunksize, "N/A");
-                } else {
-                    mr_asprintf(chunksize, "%dk", raidrec->plex[i].stripesize);
-                }
-                mr_asprintf(pname, "%s.p%i", raidrec->volname, i);
-                mr_asprintf(entry, "%-14s %-8s  %11s  %8d", pname, raidlevel, chunksize, raidrec->plex[i].subdisks);
-                mr_free(pname);
-                mr_free(raidlevel);
-                mr_free(chunksize);
-
-                newtListboxAppendEntry(plexesListbox, entry, keylist[i]);
-                mr_free(entry);
-            }
-        }
-
-        newtFormAddComponents(editraidForm, bOK, bCancel, bAdd, bEdit,
-                              bDelete, plexesListbox, plexesHeader, NULL);
-
-        b_res = newtRunForm(editraidForm);
-        if (b_res == bOK || b_res == bCancel) {
-            break;
-        }
-
-        curr_choice = newtListboxGetCurrent(plexesListbox);
-        for (currline2 = 0; currline2 < raidrec->plexes; ++currline2) {
-            if (currline2 > 9)
-                break;
-            if (keylist[currline2] == curr_choice)
-                break;
-        }
-
-        if (b_res == bDelete) {
-            mr_asprintf(msg, "Are you sure you want to delete %s.p%i?", raidrec->volname, currline2);
-            res = ask_me_yes_or_no(msg);
-            mr_free(msg);
-
-            if (res) {
-                log_it("Deleting RAID plex");
-                memcpy((void *) &raidrec->plex[currline2],
-                       (void *) &raidrec->plex[raidrec->plexes - 1],
-                       sizeof(struct vinum_plex));
-                raidrec->plexes--;
-            }
-            continue;
-        }
-        if (b_res == bAdd) {
-            raidrec->plex[raidrec->plexes].raidlevel = 0;
-            raidrec->plex[raidrec->plexes].stripesize = 279;
-            raidrec->plex[raidrec->plexes].subdisks = 0;
-            currline2 = raidrec->plexes++;
-        }
-        edit_raidlist_plex(mountlist, raidlist, &raidrec->plex[currline2],
-                           currline, currline2);
-        newtFormDestroy(editraidForm);
-    }
-    if (b_res == bCancel) {
-        memcpy((void *) raidrec, (void *) &bkp_raidrec,
-               sizeof(struct vinum_volume));
-    }
-    newtPopHelpLine();
-    newtPopWindow();
-    mountlist->el[currline].size =
-        calculate_raid_device_size(mountlist, raidlist, raidrec->volname);
-#else
-    /** structures ********************************************************/
-    struct raid_device_record *bkp_raidrec;
-
-
-    /** buffers ***********************************************************/
-    char *title_of_editraidForm_window;
-    char *sz_raid_level = NULL;
-    char *sz_data_disks = NULL;
-    char *sz_spare_disks = NULL;
-    char *sz_parity_disks = NULL;
-    char *sz_failed_disks = NULL;
-
-    /** newt **************************************************************/
-    newtComponent editraidForm;
-    newtComponent bOK;
-    newtComponent bCancel;
-    newtComponent bAdditional;
-    newtComponent bChangeRaid;
-    newtComponent bSelectData;
-    newtComponent bSelectSpare;
-    newtComponent bSelectParity;
-    newtComponent bSelectFailed;
-    newtComponent b_res;
-
-    assert(mountlist != NULL);
-    assert(raidlist != NULL);
-    assert(raidrec != NULL);
-
-    bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
-    log_it("Started edit_raidlist_entry");
-
-    memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record));
-    mr_asprintf(title_of_editraidForm_window, "%s", raidrec->raid_device);
-    log_msg(2, "Opening newt window");
-    newtOpenWindow(20, 5, 40, 14, title_of_editraidForm_window);
-    for (;;) {
-        log_msg(2, "Main loop");
-        mr_free(title_of_editraidForm_window);
-        mr_asprintf(title_of_editraidForm_window, "Edit %s", raidrec->raid_device);
-        sz_raid_level = turn_raid_level_number_to_string(raidrec->raid_level);
-        sz_data_disks = number_of_disks_as_string(raidrec->data_disks.entries, "data");
-        sz_spare_disks = number_of_disks_as_string(raidrec->spare_disks.entries, "spare");
-        sz_parity_disks = number_of_disks_as_string(raidrec->parity_disks.entries, "parity");
-        sz_failed_disks = number_of_disks_as_string(raidrec->failed_disks.entries, "failed");
-        bSelectData = newtButton(1, 1, sz_data_disks);
-        bSelectSpare = newtButton(20, 1, sz_spare_disks);
-        bSelectParity = newtButton(1, 5, sz_parity_disks);
-        bSelectFailed = newtButton(20, 5, sz_failed_disks);
-        bChangeRaid = newtButton(1, 9, sz_raid_level);
-        bOK = newtButton(16 + (raidrec->raid_level == -1), 9, "  OK  ");
-        bCancel = newtButton(28, 9, "Cancel");
-        bAdditional =
-            newtCompactButton(1, 13,
-                              "Additional settings and information");
-        newtPushHelpLine
-            ("  Edit the RAID device's settings to your heart's content, then hit OK/Cancel.");
-        editraidForm = newtForm(NULL, NULL, 0);
-        newtFormAddComponents(editraidForm, bSelectData, bSelectParity,
-                              bChangeRaid, bSelectSpare, bSelectFailed,
-                              bOK, bCancel, bAdditional);
-        b_res = newtRunForm(editraidForm);
-        if (b_res == bChangeRaid) {
-            choose_raid_level(raidrec);
-        } else if (b_res == bSelectData) {
-            select_raid_disks(mountlist, raidlist, raidrec, "data", &raidrec->data_disks);
-        } else if (b_res == bSelectSpare) {
-            select_raid_disks(mountlist, raidlist, raidrec, "spare", &raidrec->spare_disks);
-        } else if (b_res == bSelectParity) {
-            select_raid_disks(mountlist, raidlist, raidrec, "parity", &raidrec->parity_disks);
-        } else if (b_res == bSelectFailed) {
-            select_raid_disks(mountlist, raidlist, raidrec, "failed", &raidrec->failed_disks);
-        } else if (b_res == bAdditional) {
-            edit_raidrec_additional_vars(raidrec);
-        }
-        newtFormDestroy(editraidForm);
-        if (b_res == bOK || b_res == bCancel) {
-            break;
-        }
-        mr_free(sz_data_disks);
-        mr_free(sz_spare_disks);
-        mr_free(sz_parity_disks);
-        mr_free(sz_failed_disks);
-    }
-    if (b_res == bCancel) {
-        memcpy((void *) raidrec, (void *) bkp_raidrec, sizeof(struct raid_device_record));
-    }
-    newtPopHelpLine();
-    newtPopWindow();
-    mountlist->el[currline].size = calculate_raid_device_size(mountlist, raidlist, raidrec->raid_device);
-    mr_free(title_of_editraidForm_window);
-    mr_free(sz_raid_level);
-    paranoid_free(bkp_raidrec);
-#endif
-}
-
-#ifdef __FreeBSD__
-
-/**
- * Edit the plex @p raidrec in @p raidlist.
- * @param mountlist The mountlist to get some of the information from.
- * @param raidlist The raidlist containing information about RAID devices.
- * @param raidrec The plex to edit.
- * @param currline The line number (starting from 0) of the RAID device in @p mountlist.
- * @param currline2 The line number (starting from 0) of the plex within the RAID device.
- * @author Joshua Oreman
- * @ingroup restoreGuiMountlist
- */
-void
-edit_raidlist_plex(struct mountlist_itself *mountlist,
-                   struct raidlist_itself *raidlist,
-                   struct vinum_plex *raidrec, int currline, int currline2)
-{
-
-    /** structures ********************************************************/
-    struct vinum_plex bkp_raidrec;
-
-
-    /** buffers ***********************************************************/
-    char *title_of_editraidForm_window = NULL;
-
-    /** newt **************************************************************/
-    newtComponent editraidForm;
-    newtComponent bOK;
-    newtComponent bCancel;
-    newtComponent bEdit;
-    newtComponent bAdd;
-    newtComponent bDelete;
-    newtComponent b_res;
-    newtComponent unallocListbox, allocListbox;
-    newtComponent bLevel, sLevel;
-    newtComponent bStripeSize, sStripeSize;
-    newtComponent bAlloc, bUnalloc;
-
-    void *keylist[ARBITRARY_MAXIMUM];
-    void *curr_choice_a, *curr_choice_u;
-    int currline_a, currline_u;
-
-    char *p = NULL;
-    char *tmp = NULL;
-    char *entry = NULL;
-
-    struct mountlist_itself *unallocparts;
-
-    unallocparts = malloc(sizeof(struct mountlist_itself));
-
-    log_it("Started edit_raidlist_entry");
-    memcpy((void *) &bkp_raidrec, (void *) raidrec,
-           sizeof(struct vinum_plex));
-    mr_asprintf(title_of_editraidForm_window, "%s.p%i", raidlist->el[currline].volname, currline2);
-    newtPushHelpLine
-        ("   Please select a subdisk to edit, or edit this plex's parameters");
-    newtOpenWindow(13, 3, 54, 18, title_of_editraidForm_window);
-    mr_free(title_of_editraidForm_window);
-
-    for (;;) {
-        int i;
-
-        switch (raidrec->raidlevel) {
-        case -1:
-            mr_asprintf(tmp, "concat");
-            break;
-        case 0:
-            mr_asprintf(tmp, "striped");
-            break;
-        case 5:
-            mr_asprintf(tmp, "raid5");
-            break;
-        default:
-            mr_asprintf(tmp, "unknown (%i)", raidrec->raidlevel);
-            break;
-        }
-        bLevel = newtCompactButton(2, 2, " RAID level ");
-        sLevel = newtLabel(19, 2, tmp);
-        mr_free(tmp);
-
-        if (raidrec->raidlevel >= 0) {
-            mr_asprintf(tmp, "%ik", raidrec->stripesize);
-            bStripeSize = newtCompactButton(2, 4, " Stripe size ");
-        } else {
-            mr_asprintf(tmp, "N/A");
-            bStripeSize = newtLabel(2, 4, "Stripe size:");
-        }
-        sStripeSize = newtLabel(19, 4, tmp);
-        mr_free(tmp);
-
-        bOK = newtCompactButton(2, 16, "  OK  ");
-        bCancel = newtCompactButton(12, 16, "Cancel");
-        bAdd = newtCompactButton(22, 16, " Add ");
-        bEdit = newtCompactButton(32, 16, " Edit ");
-        bDelete = newtCompactButton(42, 16, "Delete");
-
-
-        unallocListbox =
-            newtListbox(2, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        allocListbox =
-            newtListbox(33, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        bAlloc = newtButton(23, 7, " -> ");
-        bUnalloc = newtButton(23, 11, " <- ");
-
-        editraidForm = newtForm(NULL, NULL, 0);
-
-        newtListboxClear(allocListbox);
-        newtListboxClear(unallocListbox);
-        bzero(unallocparts, sizeof(struct mountlist_itself));
-        make_list_of_unallocated_raid_partitions(unallocparts, mountlist,
-                                                 raidlist);
-        for (i = 0; i < ARBITRARY_MAXIMUM; ++i) {
-            keylist[i] = (void *) i;
-            if (i < raidrec->subdisks) {
-                mr_asprintf(entry, "%-17s", find_dev_entry_for_raid_device_name(raidlist, raidrec->sd[i].which_device));
-                newtListboxAppendEntry(allocListbox, entry, keylist[i]);
-                mr_free(entry);
-            }
-            if (i < unallocparts->entries) {
-                mr_asprintf(entry, "%-17s", unallocparts->el[i].device);
-                newtListboxAppendEntry(unallocListbox, entry, keylist[i]);
-                mr_free(entry);
-            }
-        }
-
-#define COMP(x)  newtFormAddComponent (editraidForm, x)
-#define UCOMP(x) if (unallocparts->entries > 0) COMP(x)
-#define ACOMP(x) if (raidrec->subdisks > 0) COMP(x)
-        editraidForm = newtForm(NULL, NULL, 0);
-        UCOMP(unallocListbox);
-        UCOMP(bAlloc);
-        ACOMP(allocListbox);
-        ACOMP(bUnalloc);
-        COMP(bOK);
-        COMP(bCancel);
-        COMP(bLevel);
-        COMP(sLevel);
-        if (raidrec->raidlevel != -1) {
-            COMP(bStripeSize);
-            COMP(sStripeSize);
-        }
-#undef COMP
-#undef UCOMP
-#undef ACOMP
-
-        newtDrawForm(editraidForm);
-        newtRefresh();
-        b_res = newtRunForm(editraidForm);
-        if (b_res == bOK || b_res == bCancel) {
-            break;
-        }
-
-        curr_choice_a = (raidrec->subdisks > 0) ?
-            newtListboxGetCurrent(allocListbox) : (void *) 1234;
-        curr_choice_u = (unallocparts->entries > 0) ?
-            newtListboxGetCurrent(unallocListbox) : (void *) 1234;
-        for (currline_a = 0; currline_a < raidrec->subdisks; ++currline_a) {
-            if (currline_a > ARBITRARY_MAXIMUM)
-                break;
-            if (keylist[currline_a] == curr_choice_a)
-                break;
-        }
-        for (currline_u = 0; currline_u < unallocparts->entries;
-             ++currline_u) {
-            if (currline_u > ARBITRARY_MAXIMUM)
-                break;
-            if (keylist[currline_u] == curr_choice_u)
-                break;
-        }
-        if (b_res == bLevel) {
-            choose_raid_level(raidrec);
-        } else if (b_res == bStripeSize) {
-            char tmp1[64];
-            sprintf(tmp1, "%i", raidrec->stripesize);
-            if (popup_and_get_string
-                ("Stripe size",
-                 "Please enter the stripe size in kilobytes.", tmp1, 20)) {
-                raidrec->stripesize = atoi(tmp1);
-            }
-        } else if ((b_res == bAlloc) || (b_res == unallocListbox)) {
-            if (currline_u <= unallocparts->entries)
-                add_raid_subdisk(raidlist, raidrec,
-                                 unallocparts->el[currline_u].device);
-        } else if ((b_res == bUnalloc) || (b_res == allocListbox)) {
-            if (currline_a <= raidrec->subdisks) {
-                memcpy((void *) &raidrec->sd[currline_a],
-                       (void *) &raidrec->sd[raidrec->subdisks - 1],
-                       sizeof(struct vinum_subdisk));
-                raidrec->subdisks--;
-            }
-        }
-    newtFormDestroy(editraidForm);
-    newtRefresh();
-}
-
-if (b_res == bCancel) {
-    memcpy((void *) raidrec, (void *) &bkp_raidrec, sizeof(struct vinum_plex));
-}
-newtPopWindow();
-newtPopHelpLine();
-}
-#else
-/**
- * Edit additional RAID variable number @p lino.
- * @param raidrec The RAID device record to edit the variable in.
- * @param lino The line number (starting from 0) of the variable to edit.
- * @ingroup restoreGuiVarslist
- */
-void edit_varslist_entry(struct raid_device_record *raidrec, int lino)
-{
-
-    /** buffers ***********************************************************/
-    char *header = NULL;
-    char *comment = NULL;
-    char sz_out[MAX_STR_LEN];
-
-    assert(raidrec != 0);
-    assert(lino >= 0);
-
-    strcpy(sz_out, raidrec->additional_vars.el[lino].value);
-    mr_asprintf(header, "Edit %s", raidrec->additional_vars.el[lino].label);
-    mr_asprintf(comment, "Please set %s's value (currently '%s')", raidrec->additional_vars.el[lino].label, sz_out);
-    if (popup_and_get_string(header, comment, sz_out, MAX_STR_LEN)) {
-        strip_spaces(sz_out);
-        strcpy(raidrec->additional_vars.el[lino].value, sz_out);
-    }
-    mr_free(header);
-    mr_free(comment);
-}
 
 #endif
@@ -2048 +2727 @@
 }
 
-
-
-
-#ifndef __FreeBSD__
-/**
- * Edit the additional RAID variables in @p raidrec.
- * @param raidrec The RAID device record to edit the RAID variables in.
- * @ingroup restoreGuiVarslist
- */
-void edit_raidrec_additional_vars(struct raid_device_record *raidrec)
-{
-
-    /** structure *********************************************************/
-    struct raid_device_record bkp_raidrec;
-
-    /** newt **************************************************************/
-    newtComponent myForm;
-    newtComponent bAdd;
-    newtComponent bEdit;
-    newtComponent bDelete;
-    newtComponent bOK;
-    newtComponent bCancel;
-    newtComponent b_res;
-    newtComponent varsListbox;
-    newtComponent headerMsg;
-
-    /** ?? ***************************************************************/
-    void *keylist[ARBITRARY_MAXIMUM], *curr_choice;
-
-    /** buffers **********************************************************/
-    char title_of_window[MAX_STR_LEN];
-
-    /** int **************************************************************/
-    int i = 0;
-    int currline = 0;
-
-
-    assert(raidrec != NULL);
-
-    memcpy((void *) &bkp_raidrec, (void *) raidrec,
-           sizeof(struct raid_device_record));
-    sprintf(title_of_window, "Additional variables");
-    newtPushHelpLine
-        ("  Edit the additional fields to your heart's content, then click OK or Cancel.");
-    headerMsg = newtLabel(1, 1, "Label                            Value");
-    varsListbox =
-        newtListbox(1, 2, 6, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-    i = 1;
-    bAdd = newtCompactButton(i, 9, " Add ");
-    bEdit = newtCompactButton(i += 8, 9, " Edit ");
-    bDelete = newtCompactButton(i += 9, 9, "Delete");
-    bOK = newtCompactButton(i += 9, 9, "  OK  ");
-    bCancel = newtCompactButton(i += 9, 9, "Cancel");
-    newtOpenWindow(17, 7, 46, 10, title_of_window);
-    myForm = newtForm(NULL, NULL, 0);
-    newtFormAddComponents(myForm, headerMsg, varsListbox, bAdd, bEdit,
-                          bDelete, bOK, bCancel, NULL);
-    insert_essential_additionalvars(raidrec);
-    redraw_varslist(&raidrec->additional_vars, keylist, varsListbox);
-    for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
-        b_res = newtRunForm(myForm);
-        curr_choice = newtListboxGetCurrent(varsListbox);
-        for (currline = 0;
-             currline < raidrec->additional_vars.entries
-             && keylist[currline] != curr_choice; currline++);
-        if (currline == raidrec->additional_vars.entries
-            && raidrec->additional_vars.entries > 0) {
-            log_it("Warning - I don't know what this button does");
-        }
-        if (b_res == bOK) {     /* do nothing */
-        } else if (b_res == bCancel) {  /* do nothing */
-        } else if (b_res == bAdd) {
-            add_varslist_entry(raidrec);
-        } else if (b_res == bDelete) {
-            delete_varslist_entry(raidrec, currline);
-        } else {
-            edit_varslist_entry(raidrec, currline);
-        }
-        redraw_varslist(&raidrec->additional_vars, keylist, varsListbox);
-    }
-    remove_essential_additionalvars(raidrec);
-    newtFormDestroy(myForm);
-    newtPopWindow();
-    newtPopHelpLine();
-    if (b_res == bCancel) {
-        memcpy((void *) raidrec, (void *) &bkp_raidrec,
-               sizeof(struct raid_device_record));
-    }
-    return;
-}
-#endif
-
-
-/**
- * Find the next free location to place a disk in @p disklist.
- * @param disklist The disklist to operate on.
- * @return The next free location (starting from 0).
- * @ingroup restoreGuiDisklist
- */
-int find_next_free_index_in_disklist(struct list_of_disks *disklist)
-{
-
-    /** int ***************************************************************/
-    int index = -1;
-    int pos = 0;
-
-  /** bool **************************************************************/
-    bool done;
-
-    assert(disklist != NULL);
-
-    for (done = FALSE; !done;) {
-        for (pos = 0;
-             pos < disklist->entries && disklist->el[pos].index <= index;
-             pos++);
-        if (pos >= disklist->entries) {
-            done = TRUE;
-        } else {
-            index = disklist->el[pos].index;
-        }
-    }
-    return (index + 1);
-}
-
-
-
-/**
- * Locate @p device in @p raidlist.
- * @param raidlist The raidlist ot search in.
- * @param device The RAID device to search for.
- * @return The index of the device, or -1 if it could not be found.
- * @ingroup restoreGuiMountlist
- */
-int
-find_raid_device_in_raidlist(struct raidlist_itself *raidlist,
-                             char *device)
-{
-
-    /** int ***************************************************************/
-    int i = 0;
-#ifdef __FreeBSD__
-    char *vdev = NULL;
-    int res = 0;
-#else
-// Linux
-#endif
-
-    assert(raidlist != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(device);
-
-#ifdef __FreeBSD__
-    for (i = 0; i < raidlist->entries; i++) {
-        mr_asprintf(vdev, "/dev/vinum/%s", raidlist->el[i].volname);
-        res = strcmp(device, vdev);
-        mr_free(vdev);
-
-        if (!res)
-            break;
-    }
-#else
-
-    for (i = 0;
-         strcmp(raidlist->el[i].raid_device, device)
-         && i < raidlist->entries; i++);
-#endif
-    if (i == raidlist->entries) {
-        return (-1);
-    } else {
-        return (i);
-    }
-}
-
-
-/**
- * Create a new raidtab entry for @p device in @p raidlist.
- * @param raidlist The raidlist to add the device to.
- * @param mountlist The mountlist containing information about the user's partitions.
- * @param currline The selected line in the mountlist.
- * @param device The RAID device (e.g. /dev/md0) to use.
- * @ingroup restoreGuiMountlist
- */
-void
-initiate_new_raidlist_entry(struct raidlist_itself *raidlist,
-                            struct mountlist_itself *mountlist,
-                            int currline, char *device)
-{
-
-    /** structure *********************************************************/
-    struct OSSWAP (raid_device_record, vinum_volume) * raidrec;
-
-    /** int ***************************************************************/
-    int pos_in_raidlist = 0;
-
-    assert(raidlist != NULL);
-    assert(mountlist != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(device);
-
-    pos_in_raidlist =
-        find_raid_device_in_raidlist(raidlist,
-                                     mountlist->el[currline].device);
-    if (pos_in_raidlist >= 0) {
-        fatal_error("Sorry, that RAID device already exists. Weird.");
-    }
-    pos_in_raidlist = raidlist->entries++;
-    raidrec = &raidlist->el[pos_in_raidlist];
-    initialize_raidrec(raidrec);
-    strcpy(raidrec->OSSWAP(raid_device, volname), OSSWAP(device, basename(device)));
-#ifndef __FreeBSD__
-    choose_raid_level(raidrec);
-    select_raid_disks(mountlist, raidlist, raidrec, "data",
-                      &raidrec->data_disks);
-#endif
-    edit_raidlist_entry(mountlist, raidlist, raidrec, currline);
-}
-
-
-#ifndef __FreeBSD__
-/**
- * Insert the RAID variables not stored in the "additional RAID variables" list there too.
- * @param raidrec The RAID device record to operate on.
- * @ingroup restoreGuiVarslist
- */
-void insert_essential_additionalvars(struct raid_device_record *raidrec)
-{
-
-    /** int **************************************************************/
-    int items = 0;
-
-    assert(raidrec != NULL);
-
-    items = raidrec->additional_vars.entries;
-    write_variableINT_to_raid_var_line(raidrec, items++,
-                                       "persistent-superblock",
-                                       raidrec->persistent_superblock);
-    write_variableINT_to_raid_var_line(raidrec, items++, "chunk-size",
-                                       raidrec->chunk_size);
-    raidrec->additional_vars.entries = items;
-}
-
-#endif
-
 /**
  * Dummy function that proves that we can get to the point where Mondo is run.
@@ -2314 +2752 @@
     newtPopHelpLine();
 }
-
-
-
-/**
- * Redraw the disklist.
- * @param disklist The disklist to read from.
- * @param keylist The list of keys for @p listbox.
- * @param listbox The Newt listbox component to redraw.
- * @ingroup restoreGuiDisklist
- */
-void
-redraw_disklist(struct list_of_disks *disklist,
-                void *keylist[ARBITRARY_MAXIMUM], newtComponent listbox)
-{
-
-    /** long **************************************************************/
-    long i = 0;
-    char *tmp = NULL;
-
-    assert(disklist != NULL);
-    assert(keylist != NULL);
-    assert(listbox != NULL);
-
-    newtListboxClear(listbox);
-
-    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
-        keylist[i] = (void *) i;
-    }
-    for (i = 0; i < disklist->entries; i++) {
-        tmp = disklist_entry_to_string(disklist, i);
-        newtListboxAppendEntry(listbox, tmp, keylist[i]);
-        mr_free(tmp);
-    }
-}
-
-
-/**
- * Redraw the mountlist.
- * @param mountlist The mountlist to read from.
- * @param keylist The list of keys for @p listbox.
- * @param listbox The Newt listbox component to redraw.
- * @ingroup restoreGuiMountlist
- */
-void
-redraw_mountlist(struct mountlist_itself *mountlist,
-                 void *keylist[ARBITRARY_MAXIMUM], newtComponent listbox)
-{
-
-    /** long **************************************************************/
-    long i = 0;
-    char * tmp = NULL;
-
-    assert(mountlist != NULL);
-    assert(keylist != NULL);
-    assert(listbox != NULL);
-
-    newtListboxClear(listbox);
-//  sort_mountlist_by_device (mountlist);
-    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
-        keylist[i] = (void *) i;
-    }
-    for (i = 0; i < mountlist->entries; i++) {
-        tmp = mountlist_entry_to_string(mountlist, i);
-        newtListboxAppendEntry(listbox, tmp, keylist[i]);
-        mr_free(tmp);
-    }
-}
-
-
-
-
-/**
- * Redraw the list of unallocated RAID partitions.
- * @param unallocated_raid_partitions The mountlist containing unallocated RAID partitions.
- * @param keylist The list of keys for @p listbox.
- * @param listbox The Newt listbox component to redraw.
- * @ingroup restoreGuiDisklist
- */
-void redraw_unallocpartnslist(struct mountlist_itself
-                              *unallocated_raid_partitions,
-                              void *keylist[ARBITRARY_MAXIMUM],
-                              newtComponent listbox)
-{
-
-    /** long *************************************************************/
-    long i = 0;
-
-    /** buffers **********************************************************/
-    char tmp[MAX_STR_LEN];
-
-    assert(unallocated_raid_partitions != NULL);
-    assert(keylist != NULL);
-    assert(listbox != NULL);
-
-    newtListboxClear(listbox);
-    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
-        keylist[i] = (void *) i;
-    }
-    for (i = 0; i < unallocated_raid_partitions->entries; i++) {
-        sprintf(tmp, "%-22s %8lld",
-                unallocated_raid_partitions->el[i].device,
-                unallocated_raid_partitions->el[i].size / 1024L);
-        newtListboxAppendEntry(listbox, tmp, keylist[i]);
-    }
-}
-
-#ifndef __FreeBSD__
-/**
- * Redraw the list of additional RAID variables.
- * @param additional_vars The list of additional RAID varibals.
- * @param keylist The list of keys for @p listbox.
- * @param listbox The Newt listbox component to redraw.
- * @ingroup restoreGuiVarslist
- */
-void
-redraw_varslist(struct additional_raid_variables *additional_vars,
-                void *keylist[], newtComponent listbox)
-{
-    /** long ************************************************************/
-    long i = 0;
-
-    /** buffers *********************************************************/
-    char tmp[MAX_STR_LEN];
-
-    assert(additional_vars != NULL);
-    assert(keylist != NULL);
-    assert(listbox != NULL);
-
-    newtListboxClear(listbox);
-
-    for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
-        keylist[i] = (void *) i;
-    }
-    for (i = 0; i < additional_vars->entries; i++) {
-        sprintf(tmp, "%-32s %-8s", additional_vars->el[i].label,
-                additional_vars->el[i].value);
-        newtListboxAppendEntry(listbox, tmp, keylist[i]);
-    }
-}
-
-
-/**
- * Remove variable @p label from the RAID variables list in @p raidrec.
- * @param raidrec The RAID device record to remove the variable from.
- * @param label The variable name to remove.
- * @return The value of the variable removed.
- * @ingroup restoreUtilityGroup
- */
-int
-read_variableINT_and_remove_from_raidvars(struct
-                                          OSSWAP (raid_device_record,
-                                                  vinum_volume) * raidrec,
-                                          char *label)
-{
-    /** int ***************************************************************/
-    int i = 0;
-    int res = 0;
-
-
-    assert(raidrec != NULL);
-    assert(label != NULL);
-
-    for (i = 0;
-         i < raidrec->additional_vars.entries
-         && strcmp(raidrec->additional_vars.el[i].label, label); i++);
-    if (i == raidrec->additional_vars.entries) {
-        res = -1;
-    } else {
-        res = atoi(raidrec->additional_vars.el[i].value);
-        for (i++; i < raidrec->additional_vars.entries; i++) {
-            memcpy((void *) &raidrec->additional_vars.el[i - 1],
-                   (void *) &raidrec->additional_vars.el[i],
-                   sizeof(struct raid_var_line));
-        }
-        raidrec->additional_vars.entries--;
-    }
-    return (res);
-}
-#endif
-
-/**
- * Change all RAID devices to use @p new_dev instead of @p old_dev.
- * @param raidlist The raidlist to make the changes in.
- * @param old_dev The old name of the device (what it used to be).
- * @param new_dev The new name of the device (what it is now).
- * @ingroup restoreGuiMountlist
- */
-void rejig_partition_name_in_raidlist_if_necessary(struct raidlist_itself
-                                                   *raidlist,
-                                                   char *old_dev,
-                                                   char *new_dev)
-{
-    /** int ************************************************************/
-    int pos = 0;
-    int j = 0;
-
-    assert(raidlist != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(old_dev);
-    assert_string_is_neither_NULL_nor_zerolength(new_dev);
-
-    pos = which_raid_device_is_using_this_partition(raidlist, old_dev);
-    if (pos < 0) {
-        log_it("No need to rejig %s in raidlist: it's not listed.", old_dev);
-    } else {
-        if ((j =
-             where_in_drivelist_is_drive(&raidlist->
-                                         OSSWAP(el[pos].data_disks, disks),
-                                         old_dev)) >= 0) {
-            strcpy(raidlist->OSSWAP(el[pos].data_disks, disks).el[j].device, new_dev);
-        } else
-            if ((j =
-                 where_in_drivelist_is_drive(&raidlist->
-                                             OSSWAP(el[pos].spare_disks,
-                                                    spares),
-                                             old_dev)) >= 0) {
-            strcpy(raidlist->OSSWAP(el[pos].spare_disks, spares).el[j].device, new_dev);
-        }
-#ifndef __FreeBSD__
-        else if ((j =
-                  where_in_drivelist_is_drive(&raidlist->el[pos].
-                                              parity_disks,
-                                              old_dev)) >= 0) {
-            strcpy(raidlist->el[pos].parity_disks.el[j].device, new_dev);
-        } else
-            if ((j =
-                 where_in_drivelist_is_drive(&raidlist->el[pos].
-                                             failed_disks,
-                                             old_dev)) >= 0) {
-            strcpy(raidlist->el[pos].failed_disks.el[j].device, new_dev);
-        }
-#endif
-        else {
-            log_it("%s is supposed to be listed in this raid dev but it's not...", old_dev);
-        }
-    }
-}
-
-
-#ifndef __FreeBSD__
-/**
- * Remove the essential RAID variables from the "additional variables" section.
- * If they have been changed, set them in their normal locations too.
- * @param raidrec The RAID device record to operate on.
- * @ingroup restoreUtilityVarslist
- */
-void remove_essential_additionalvars(struct raid_device_record *raidrec)
-{
-
-    /** int **************************************************************/
-    int res = 0;
-
-    assert(raidrec != NULL);
-
-    res =
-        read_variableINT_and_remove_from_raidvars(raidrec,
-                                                  "persistent-superblock");
-    if (res > 0) {
-        raidrec->persistent_superblock = res;
-    }
-    res = read_variableINT_and_remove_from_raidvars(raidrec, "chunk-size");
-    if (res > 0) {
-        raidrec->chunk_size = res;
-    }
-    res = read_variableINT_and_remove_from_raidvars(raidrec, "block-size");
-}
-
-/**
- * Select the RAID disks to use in @p raidrec.
- * @param mountlist_dontedit The mountlist (will not be edited).
- * @param raidlist The raidlist to modify.
- * @param raidrec The RAID device record in @p raidlist to work on.
- * @param description_of_list The type of disks we're selecting (e.g. "data").
- * @param disklist The disklist to put the user-selected disks in.
- * @ingroup restoreGuiMountlist
- */
-void
-select_raid_disks(struct mountlist_itself *mountlist_dontedit,
-                  struct raidlist_itself *raidlist,
-                  struct raid_device_record *raidrec,
-                  char *description_of_list,
-                  struct list_of_disks *disklist)
-{
-    void *curr_choice;
-
-    /** ??? ***************************************************************/
-
-    /** structures ********************************************************/
-    struct raidlist_itself *bkp_raidlist;
-    struct raid_device_record *bkp_raidrec;
-    struct list_of_disks *bkp_disklist;
-    struct mountlist_itself *unallocated_raid_partitions;
-
-    /** newt **************************************************************/
-    newtComponent myForm = NULL;
-    newtComponent bAdd = NULL;
-    newtComponent bDelete = NULL;
-    newtComponent bOK = NULL;
-    newtComponent bCancel = NULL;
-    newtComponent b_res = NULL;
-    newtComponent partitionsListbox = NULL;
-    newtComponent headerMsg = NULL;
-
-    /** buffers **********************************************************/
-    void *keylist[ARBITRARY_MAXIMUM];
-    char *tmp = NULL;
-    char *help_text = NULL;
-    char *title_of_window = NULL;
-    char sz_res[MAX_STR_LEN];
-    char *header_text = NULL;
-
-  /** int **************************************************************/
-    int i = 0;
-    int currline = 0;
-
-    assert(mountlist_dontedit != NULL);
-    assert(raidlist != NULL);
-    assert(raidrec != NULL);
-    assert(description_of_list != NULL);
-    assert(disklist != NULL);
-
-    log_it("malloc'ing");
-    bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
-    bkp_disklist = mr_malloc(sizeof(struct list_of_disks));
-    bkp_raidlist = mr_malloc(sizeof(struct raidlist_itself));
-    unallocated_raid_partitions = mr_malloc(sizeof(struct mountlist_itself));
-
-    memcpy((void *) bkp_raidlist, (void *) raidlist, sizeof(struct raidlist_itself));
-    memcpy((void *) bkp_raidrec, (void *) raidrec, sizeof(struct raid_device_record));
-    memcpy((void *) bkp_disklist, (void *) disklist, sizeof(struct list_of_disks));
-
-    log_it("Post-malloc");
-    mr_asprintf(help_text, "   Edit this RAID device's list of partitions. Choose OK or Cancel when done.");
-    mr_asprintf(header_text, "%-24s    %s", "Device", "Index");
-    mr_asprintf(title_of_window, "%s contains...", raidrec->raid_device);
-    newtPushHelpLine(help_text);
-    for (b_res = (newtComponent) 12345; b_res != bOK && b_res != bCancel;) {
-        headerMsg = newtLabel(1, 1, header_text);
-        partitionsListbox =
-            newtListbox(1, 2, 6, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        redraw_disklist(disklist, keylist, partitionsListbox);
-        i = 1;
-        bAdd = newtCompactButton(i, 9, " Add ");
-        bDelete = newtCompactButton(i += 8, 9, "Delete");
-        bOK = newtCompactButton(i += 9, 9, "  OK  ");
-        bCancel = newtCompactButton(i += 9, 9, "Cancel");
-        newtOpenWindow(21, 7, 38, 10, title_of_window);
-        myForm = newtForm(NULL, NULL, 0);
-        if (disklist->entries == 0) {
-            newtFormAddComponents(myForm, headerMsg, bAdd, bDelete, bOK,
-                                  bCancel, NULL);
-        } else {
-            newtFormAddComponents(myForm, headerMsg, partitionsListbox,
-                                  bAdd, bDelete, bOK, bCancel, NULL);
-        }
-        b_res = newtRunForm(myForm);
-        if (b_res == bOK || b_res == bCancel) { /* do nothing */
-// That's OK. At the end of this subroutine (after this do/while loop),
-// we'll throw away the changes if Cancel was pushed.
-        } else {
-            curr_choice = newtListboxGetCurrent(partitionsListbox);
-            for (i = 0; i < disklist->entries && keylist[i] != curr_choice;
-                 i++);
-            if (i == disklist->entries && disklist->entries > 0) {
-                log_to_screen("I don't know what that button does!");
-            } else {
-                currline = i;
-                if (b_res == bAdd) {
-                    log_it("Making list of unallocated RAID slices");
-                    make_list_of_unallocated_raid_partitions
-                        (unallocated_raid_partitions, mountlist_dontedit,
-                         raidlist);
-                    if (unallocated_raid_partitions->entries <= 0) {
-                        popup_and_OK
-                            ("There are no unallocated partitions marked for RAID.");
-                    } else {
-                        log_it
-                            ("Done. The user may add one or more of the above to RAID device");
-                        add_disklist_entry(disklist, raidrec->raid_device,
-                                           unallocated_raid_partitions);
-                        log_it("I have finished adding a disklist entry.");
-                        redraw_disklist(disklist, keylist,
-                                        partitionsListbox);
-                    }
-                } else if (b_res == bDelete) {
-                    delete_disklist_entry(disklist, raidrec->raid_device,
-                                          currline);
-                    redraw_disklist(disklist, keylist, partitionsListbox);
-                } else {
-                    mr_asprintf(tmp, "%s's index is %d. What should it be?", raidrec->raid_device, disklist->el[currline].index);
-                    sprintf(sz_res, "%d", disklist->el[currline].index);
-                    if (popup_and_get_string("Set index", tmp, sz_res, 10)) {
-                        disklist->el[currline].index = atoi(sz_res);
-                    }
-                    mr_free(tmp);
-
-                    redraw_disklist(disklist, keylist, partitionsListbox);
-                }
-            }
-        }
-        newtFormDestroy(myForm);
-        newtPopWindow();
-    }
-    newtPopHelpLine();
-    mr_free(help_text);
-    mr_free(header_text);
-    mr_free(title_of_window);
-
-    if (b_res == bCancel) {
-        memcpy((void *) raidlist, (void *) bkp_raidlist, sizeof(struct raidlist_itself));
-        memcpy((void *) raidrec, (void *) bkp_raidrec, sizeof(struct raid_device_record));
-        memcpy((void *) disklist, (void *) bkp_disklist, sizeof(struct list_of_disks));
-    }
-    mr_free(bkp_raidrec);
-    mr_free(bkp_disklist);
-    mr_free(bkp_raidlist);
-    mr_free(unallocated_raid_partitions);
-}
-#endif
-
-
 
 /**

branches/3.3/mondo/src/mondorestore/mondo-rstr-tools.c

@@ -10 +10 @@
 #include "mr_file.h"
 #include "mr_sys.h"
-#include "../common/mondostructures.h"
-#include "../common/libmondo.h"
-#include "mr-externs.h"
-#include "mondo-rstr-tools.h"
+#include "mondostructures.h"
 #include "libmondo-mountlist-EXT.h"
+#include "libmondo-tools-EXT.h"
+#include "libmondo-filelist-EXT.h"
+#include "libmondo-files-EXT.h"
+#include "libmondo-devices-EXT.h"
+#include "libmondo-string-EXT.h"
+#include "libmondo-raid-EXT.h"
+#include "libmondo-fork-EXT.h"
 #include "newt-specific-EXT.h"
+// no include for now in mondo-rstr-newt.c
+extern int edit_filelist(struct s_node *);
 
 /**
@@ -74 +80 @@
 extern char *g_mountlist_fname; // where mountlist.txt (the mountlist file) is stored
 extern char *g_mondo_home;      // homedir of Mondo; usually /usr/local/share/mondo
+extern int g_currentY;
+extern bool g_restoring_live_from_cd;
+extern bool g_text_mode;
+extern int g_current_media_number;
 
 extern t_bkptype g_backup_media_type;
@@ -169 +179 @@
 
 
-
+/**
+ * Extract mondorestore.cfg and the mountlist from the tape inserted
+ * to the ./tmp/ directory.
+ * @param dev The tape device to read from.
+ * @return 0 for success, nonzero for failure.
+ */
+int extract_cfg_file_and_mountlist_from_tape_dev(char *dev)
+{
+    char *command = NULL;
+    int res = 0;
+
+    if (bkpinfo->use_obdr) {
+        skip_obdr();
+    } else {
+        // TODO: below 32KB seems to block at least on RHAS 2.1 and MDK 10.0
+        set_tape_block_size_with_mt(bkpinfo->internal_tape_block_size);
+    }
+
+    mr_asprintf(command, "dd if=%s bs=%ld count=%ld 2> /dev/null | tar -zx ./%s ./%s ./%s ./%s ./%s", dev, bkpinfo->internal_tape_block_size, 1024L * 1024 * 32 / bkpinfo->internal_tape_block_size, MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);
+    log_msg(2, "command = '%s'", command);
+    res = run_program_and_log_output(command, -1);
+    mr_free(command);
+
+    if (res != 0) {
+        if (does_file_exist(MONDO_CFG_FILE_STUB)) {
+            res = 0;
+        } else {
+            /* Doing that allow us to remain compatible with pre-2.2.5 versions */
+            log_msg(2, "pre-2.2.4 compatible mode on");
+            mr_asprintf(command,    "dd if=%s bs=%ld count=%ld 2> /dev/null | tar -zx %s %s %s %s %s", dev, bkpinfo->internal_tape_block_size, 1024L * 1024 * 32 / bkpinfo->internal_tape_block_size, MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);
+            log_msg(2, "command = '%s'", command);
+            res = run_program_and_log_output(command, -1);
+            mr_free(command);
+            if ((res != 0) && (does_file_exist(MONDO_CFG_FILE_STUB))) {
+                res = 0;
+            }
+        }
+    }
+    paranoid_free(command);
+    return (res);
+}
+
+
+
+
+
+/**
+ * Get the configuration file from the tape, or CD.
+ * @param bkpinfo The backup information structure. Fields used:
+ * - @c bkpinfo->backup_media_type
+ * - @c bkpinfo->media_device
+ * - @c bkpinfo->tmpdir
+ * @return 0 for success, nonzero for failure.
+ */
+int get_cfg_file_from_archive()
+{
+    int retval = 0;
+
+   /** malloc *****/
+    char *command = NULL;
+    char *cfg_file = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *mountpt = NULL;
+    char *mountlist_file = NULL;
+    bool extract_mountlist_stub = FALSE;
+    bool extract_i_want_my_lvm = FALSE;
+
+    bool try_plan_B;
+
+    assert(bkpinfo != NULL);
+    log_msg(2, "gcffa --- starting");
+    log_to_screen("I'm thinking...");
+    mr_asprintf(mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
+    if (chdir(bkpinfo->tmpdir)) {
+        // FIXME
+    }
+    mr_asprintf(cfg_file, "%s", MONDO_CFG_FILE_STUB);
+    unlink(cfg_file);           // cfg_file[] is missing the '/' at the start, FYI, by intent
+    mr_free(cfg_file);
+
+    unlink(FILELIST_FULL_STUB);
+    unlink(BIGGIELIST_TXT_STUB);
+    mr_asprintf(command, "mkdir -p %s", mountpt);
+    run_program_and_log_output(command, FALSE);
+    mr_free(command);
+
+    mr_asprintf(cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
+    mr_asprintf(mountlist_file, "%s/%s", bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
+    log_msg(2, "mountpt = %s; cfg_file=%s", mountpt, cfg_file);
+    mr_free(mountpt);
+
+    if (!does_file_exist(cfg_file)) {
+        log_msg(2, "gcffa --- we don't have cfg file yet.");
+        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
+            try_plan_B = TRUE;
+        } else {
+            log_msg(2, "gcffa --- calling mount_media now :)");
+            if (!mount_media(MNT_CDROM)) {
+                log_msg(2, "gcffa --- managed to mount CD; so, no need for Plan B");
+                try_plan_B = FALSE;
+            } else {
+                try_plan_B = TRUE;
+            }
+            if (what_number_cd_is_this() > 1) {
+                insist_on_this_cd_number((g_current_media_number = 1));
+            }
+        }
+        if (try_plan_B) {
+            log_msg(2, "gcffa --- OK, switching to Plan B");
+            if (chdir(bkpinfo->tmpdir)) {
+                // FIXME
+            }
+            run_program_and_log_output("mkdir -p tmp", FALSE);
+
+            if (bkpinfo->media_device == NULL) {
+                mr_asprintf(bkpinfo->media_device, "%s", "/dev/st0");
+                log_msg(2, "media_device is blank; assuming %s", bkpinfo->media_device);
+            }
+            mr_asprintf(tmp, "%s", bkpinfo->media_device);
+            if (extract_cfg_file_and_mountlist_from_tape_dev(bkpinfo->media_device)) {
+                mr_free(bkpinfo->media_device);
+                mr_asprintf(bkpinfo->media_device, "%s", "/dev/st0");
+                if (extract_cfg_file_and_mountlist_from_tape_dev(bkpinfo->media_device)) {
+                    mr_free(bkpinfo->media_device);
+                    mr_asprintf(bkpinfo->media_device, "%s", "/dev/osst0");
+                    if (extract_cfg_file_and_mountlist_from_tape_dev(bkpinfo->media_device)) {
+                        mr_free(bkpinfo->media_device);
+                        mr_asprintf(bkpinfo->media_device, "%s", "/dev/ht0");
+                        if (extract_cfg_file_and_mountlist_from_tape_dev(bkpinfo->media_device)) {
+                            log_msg(3, "I tried lots of devices but none worked.");
+                            mr_free(bkpinfo->media_device);
+                        }
+                    }
+                }
+            }
+            if (bkpinfo->media_device == NULL) {
+                bkpinfo->media_device = tmp;
+            } else {
+                mr_free(tmp);
+            }
+
+            if (!does_file_exist("tmp/mondorestore.cfg")) {
+                log_to_screen("Cannot find config info on media");
+                return (1);
+            }
+        } else {
+                if (does_file_exist("/"MOUNTLIST_FNAME_STUB)) {
+                    extract_mountlist_stub = FALSE;
+                } else {
+                    extract_mountlist_stub = TRUE;
+                }
+                if (does_file_exist("/"IWANTMYLVM_STUB)) {
+                    extract_i_want_my_lvm = FALSE;
+                } else {
+                    extract_i_want_my_lvm = TRUE;
+                }
+
+                log_msg(2, "gcffa --- Plan B, a.k.a. untarring some file from all.tar.gz");
+                mr_asprintf(command, "tar -zxvf " MNT_CDROM "/images/all.tar.gz ./%s ./%s ./%s ./%s ./%s", MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);    // add -b TAPE_BLOCK_SIZE if you _really_ think it's necessary
+                run_program_and_log_output(command, TRUE);
+                mr_free(command);
+
+                if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
+                    /* Doing that allow us to remain compatible with pre-2.2.5 versions */
+                    log_msg(2, "pre-2.2.4 compatible mode on");
+                    mr_asprintf(command, "tar -zxvf " MNT_CDROM "/images/all.tar.gz %s %s %s %s %s", MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);  // add -b TAPE_BLOCK_SIZE if you _really_ think it's necessary
+                    run_program_and_log_output(command, TRUE);
+                    mr_free(command);
+                    if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
+                        fatal_error
+                            ("Please reinsert the disk/CD and try again.");
+                    }
+                }
+        }
+    }
+    if (does_file_exist(MONDO_CFG_FILE_STUB)) {
+        log_msg(1, "gcffa --- great! We've got the config file");
+        tmp1 = call_program_and_get_last_line_of_output("pwd");
+        mr_asprintf(tmp, "%s/%s", tmp1, MONDO_CFG_FILE_STUB);
+        mr_asprintf(command, "cp -f %s %s", tmp, cfg_file);
+        log_it("%s",command);
+        if (strcmp(tmp, cfg_file) && run_program_and_log_output(command, 1)) {
+            log_msg(1,
+                    "... but an error occurred when I tried to move it to %s",
+                    cfg_file);
+        } else {
+            log_msg(1, "... and I moved it successfully to %s", cfg_file);
+        }
+        mr_free(command);
+
+        mr_asprintf(command, "cp -f %s/%s %s", tmp1, MOUNTLIST_FNAME_STUB, mountlist_file);
+        mr_free(tmp1);
+        log_it("%s",command);
+        if (extract_mountlist_stub) {
+            if (strcmp(tmp, cfg_file) && run_program_and_log_output(command, 1)) {
+                log_msg(1, "Failed to get mountlist");
+            } else {
+                log_msg(1, "Got mountlist too");
+                mr_free(command);
+                mr_asprintf(command, "cp -f %s %s", mountlist_file, g_mountlist_fname);
+                if (run_program_and_log_output(command, 1)) {
+                    log_msg(1, "Failed to copy mountlist to /tmp");
+                } else {
+                    log_msg(1, "Copied mountlist to /tmp as well OK");
+                    mr_free(command);
+                    mr_asprintf(command, "cp -f %s /tmp/",IWANTMYLVM_STUB);
+                    run_program_and_log_output(command, 1);
+                }
+            }
+        }
+        mr_free(command);
+        mr_free(tmp);
+    }
+
+    run_program_and_log_output("umount -d " MNT_CDROM, FALSE);
+    if (!does_file_exist(cfg_file)) {
+        log_it("%s",cfg_file);
+        log_msg(1, "%s not found", cfg_file);
+        log_to_screen("Oh dear. Unable to recover configuration file from boot disk");
+        return (1);
+    }
+
+    log_to_screen("Recovered mondorestore.cfg");
+    if (!does_file_exist(MOUNTLIST_FNAME_STUB)) {
+        log_to_screen("...but not mountlist.txt - a pity, really...");
+    } else {
+            /* Is this code really useful ??? */
+        if (extract_mountlist_stub) {
+            mr_asprintf(command, "cp -f %s %s/%s", MOUNTLIST_FNAME_STUB, bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
+            run_program_and_log_output(command, FALSE);
+            mr_free(command);
+        }
+    }
+
+    mr_asprintf(command, "cp -f %s /%s", cfg_file, MONDO_CFG_FILE_STUB);
+    mr_free(cfg_file);
+
+    run_program_and_log_output(command, FALSE);
+    mr_free(command);
+
+    if (extract_mountlist_stub) {
+        mr_asprintf(command, "cp -f %s /%s", mountlist_file, MOUNTLIST_FNAME_STUB);
+        run_program_and_log_output(command, FALSE);
+        mr_free(command);
+    }
+    mr_free(mountlist_file);
+
+    mr_asprintf(command, "cp -f etc/raidtab /etc/");
+    run_program_and_log_output(command, FALSE);
+    mr_free(command);
+
+    if (extract_i_want_my_lvm) {
+        mr_asprintf(command, "cp -f %s /tmp/",IWANTMYLVM_STUB);
+        run_program_and_log_output(command, FALSE);
+        mr_free(command);
+    }
+    g_backup_media_type = bkpinfo->backup_media_type;
+    return (retval);
+}
+
+/**************************************************************************
+ *END_GET_CFG_FILE_FROM_ARCHIVE                                           *
+ **************************************************************************/
 
 
@@ -642 +915 @@
 /** add mallocs **/
 char value[MAX_STR_LEN];
+char *tmp = NULL;
 char *tmp1 = NULL;
 char *envtmp1 = NULL;
@@ -683 +957 @@
                 run_program_and_log_output("mount /dev/cdrom "MNT_CDROM, 1);
             }
-            if (does_file_exist(MNT_CDROM"/archives/filelist.0")) {
+            if (does_file_exist(ARCHIVES_PATH "/filelist.0")) {
                 bkpinfo->backup_media_type = cdr;
                 run_program_and_log_output("umount -d "MNT_CDROM, 1);
@@ -1284 +1558 @@
 
 /**
- * Install the user's boot loader in the MBR.
- * Currently LILO, ELILO, GRUB, RAW (dd of MBR), and the FreeBSD bootloader are supported.
- * @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
- * @return 0 for success, nonzero for failure.
- */
-int run_boot_loader(bool offer_to_hack_scripts)
-{
-    int res;
-    int retval = 0;
-
-  /** malloc *******/
-    char *device = NULL;
-    char *disk = NULL;
-    char *name = NULL;
-    char *type = NULL;
-    char *cmd = NULL;
-
-    malloc_string(device);
-    malloc_string(name);
-    malloc_string(type);
-
-    /* In order to have a working bootloader, we need to have all devices
-     * ready in the chroot. If they are not there (udev) then copy them from
-     * the current /dev location 
-     */
-    mr_asprintf(cmd,"tar cf - /dev | ( cd %s ; tar xf - )",MNT_RESTORING);
-    run_program_and_log_output(cmd, 3);
-    mr_free(cmd);
-
-    backup_crucial_file(MNT_RESTORING, "/etc/fstab");
-    backup_crucial_file(MNT_RESTORING, "/boot/grub/menu.lst");
-    backup_crucial_file(MNT_RESTORING, "/boot/grub/grub.cfg");
-    backup_crucial_file(MNT_RESTORING, "/boot/grub2/grub.cfg");
-    backup_crucial_file(MNT_RESTORING, "/etc/lilo.conf");
-    backup_crucial_file(MNT_RESTORING, "/etc/elilo.conf");
-    backup_crucial_file(MNT_RESTORING, "/boot/grub/device.map");
-    backup_crucial_file(MNT_RESTORING, "/boot/grub2/device.map");
-    backup_crucial_file(MNT_RESTORING, "/etc/mtab");
-    read_cfg_var(g_mondo_cfg_file, "bootloader.device", device);
-    read_cfg_var(g_mondo_cfg_file, "bootloader.name", name);
-    read_cfg_var(g_mondo_cfg_file, "boot-type", type);
-    log_msg(2, "run_boot_loader: device='%s', name='%s', type='%s'", device, name, type);
-    sync();
-
-    offer_to_make_initrd();
-
-    disk = truncate_to_drive_name(device);
-    if (strcmp(type,"BIOS") == 0) {
-        // Force installation of a MBR bootloader brought by mindi on the disk
-        // in case none was available and we then start from a partition
-        log_msg(2, "Reinstalling mbr.bin on %s", disk);
-        mr_system("dd bs=440 count=1 conv=notrunc if=/tmp/mbr.bin of=%s &> /dev/null",disk);
-    } else {
-        // Same for GPT
-        log_msg(2, "Reinstalling gptmbr.bin on %s", disk);
-        mr_system("dd bs=440 count=1 conv=notrunc if=/tmp/gptmbr.bin of=%s &> /dev/null",disk);
-    }
-
-    // Now reinstall bootloader
-    if (!strcmp(name, "LILO")) {
-        res = run_lilo(offer_to_hack_scripts);
-    } else if (!strcmp(name, "ELILO")) {
-        res = run_elilo(offer_to_hack_scripts);
-    } else if (!strcmp(name, "GRUB")) {
-        res = run_grub(offer_to_hack_scripts, device);
-    } else if (!strcmp(name, "RAW")) {
-        res = run_raw_mbr(offer_to_hack_scripts, device);
-    }
-#ifdef __FreeBSD__
-    else if (!strcmp(name, "BOOT0")) {
-        mr_asprintf(tmp, "boot0cfg -B %s", device);
-        res = run_program_and_log_output(tmp, FALSE);
-        paranoid_free(tmp);
-    } else {
-        mr_asprintf(tmp, "ls /dev | grep -Eq '^%ss[1-4].*'", device);
-        if (!system(tmp)) {
-            mr_free(tmp);
-            mr_asprintf(tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
-            res = run_program_and_log_output(tmp, 3);
-        } else {
-            log_msg(1, "I'm not running any boot loader. You have a DD boot drive. It's already loaded up.");
-        }
-        mr_free(tmp);
-    }
-#else
-    else {
-        log_to_screen
-            ("Unable to determine type of boot loader. Defaulting to LILO.");
-        res = run_lilo(offer_to_hack_scripts);
-    }
-#endif
-    retval += res;
-    if (res) {
-        log_to_screen("Your boot loader returned an error");
-    } else {
-        log_to_screen("Your boot loader ran OK");
-    }
-    paranoid_free(device);
-    paranoid_free(name);
-    return (retval);
-}
-
-/**************************************************************************
- *END_ RUN_BOOT_LOADER                                                    *
- **************************************************************************/
-
-
-
-/**
  * Attempt to find the user's editor.
  * @return The editor found ("vi" if none could be found).
@@ -1417 +1582 @@
     return (output);
 }
+
+
+
+
+/**
+ * Install LILO on the user's boot drive (determined by /etc/lilo.conf).
+ * @param offer_to_run_stablilo If TRUE, then offer to hack the user's fstab for them.
+ * @return 0 for success, nonzero for failure.
+ */
+int run_lilo(bool offer_to_run_stablilo)
+{
+  /** malloc **/
+    char *command = NULL;
+    char *tmp = NULL;
+    char *editor = NULL;
+
+    int res;
+    int done;
+    bool run_lilo_M = FALSE;
+
+    if (!run_program_and_log_output
+        ("grep \"boot.*=.*/dev/md\" " MNT_RESTORING "/etc/lilo.conf", 1)) {
+        run_lilo_M = TRUE;
+    }
+
+    if (offer_to_run_stablilo
+        && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
+
+        /* interactive mode */
+    {
+        mvaddstr_and_log_it(g_currentY,
+                            0,
+                            "Modifying fstab and lilo.conf, and running LILO...                             ");
+        mr_asprintf(command, "mr-stablilo-me");
+        res = run_program_and_log_output(command, 3);
+        mr_free(command);
+
+        if (res) {
+            popup_and_OK
+                ("You will now edit fstab and lilo.conf, to make sure they match your new mountlist.");
+            for (done = FALSE; !done;) {
+                editor = find_my_editor();
+                if (editor == NULL) {
+                    popup_and_OK("No editor found. You won't be able to edit conf files");
+                } else {
+                    if (!g_text_mode) {
+                        newtSuspend();
+                    }
+                    mr_asprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+                    paranoid_system(tmp);
+                    mr_free(tmp);
+    
+                    mr_asprintf(tmp, "%s " MNT_RESTORING "/etc/lilo.conf", editor);
+                    paranoid_system(tmp);
+                    mr_free(tmp);
+                    mr_free(editor);
+    
+                    if (!g_text_mode) {
+                        newtResume();
+                    }
+//              newtCls();
+                    if (ask_me_yes_or_no("Edit them again?")) {
+                        continue;
+                    }
+                }
+                mr_free(editor);
+
+                res = run_program_and_log_output("chroot " MNT_RESTORING " lilo -L", 3);
+                if (res) {
+                    res = run_program_and_log_output("chroot " MNT_RESTORING " lilo", 3);
+                }
+                if (res) {
+                    done = ask_me_yes_or_no("LILO failed. Re-edit system files?");
+                } else {
+                    done = TRUE;
+                }
+            }
+        } else {
+            log_to_screen("lilo.conf and fstab were modified OK");
+        }
+    } else
+        /* nuke mode */
+    {
+        mvaddstr_and_log_it(g_currentY,
+                            0,
+                            "Running LILO...                                                 ");
+        res =
+            run_program_and_log_output("chroot " MNT_RESTORING " lilo -L",
+                                       3);
+        if (res) {
+            res =
+                run_program_and_log_output("chroot " MNT_RESTORING " lilo",
+                                           3);
+        }
+        if (res) {
+            mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
+            log_to_screen
+                ("Failed to re-jig fstab and/or lilo. Edit/run manually, please.");
+        } else {
+            mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+        }
+    }
+    if (run_lilo_M) {
+        run_program_and_log_output("chroot " MNT_RESTORING
+                                   " lilo -M /dev/hda", 3);
+        run_program_and_log_output("chroot " MNT_RESTORING
+                                   " lilo -M /dev/sda", 3);
+    }
+    return (res);
+}
+
+/**************************************************************************
+ *END_RUN_LILO                                                            *
+ **************************************************************************/
+
+
+/**
+ * Install a raw MBR onto @p bd.
+ * @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
+ * @param bd The device to copy the stored MBR to.
+ * @return 0 for success, nonzero for failure.
+ */
+int run_raw_mbr(bool offer_to_hack_scripts, char *bd)
+{
+  /** malloc **/
+    char *command = NULL;
+    char *boot_device = NULL;
+    char *tmp = NULL;
+    char *editor;
+    int res;
+    int done;
+
+    malloc_string(boot_device);
+    assert_string_is_neither_NULL_nor_zerolength(bd);
+
+    strcpy(boot_device, bd);
+
+    if (offer_to_hack_scripts
+        && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?")) {
+        /* interactive mode */
+        mvaddstr_and_log_it(g_currentY, 0, "Modifying fstab and restoring MBR...                           ");
+        for (done = FALSE; !done;) {
+            popup_and_OK("You will now edit fstab");
+            editor = find_my_editor();
+            if (editor == NULL) {
+                popup_and_OK("No editor found. You won't be able to edit conf files");
+            } else {
+                if (!g_text_mode) {
+                    newtSuspend();
+                }
+                mr_asprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+
+                paranoid_system(tmp);
+                mr_free(tmp);
+                if (!g_text_mode) {
+                    newtResume();
+                }
+            }
+            mr_free(editor);
+
+            popup_and_get_string("Boot device", "Please confirm/enter the boot device. If in doubt, try /dev/hda", boot_device, MAX_STR_LEN / 4);
+            mr_asprintf(command, "mr-stabraw-me %s", boot_device);
+            res = run_program_and_log_output(command, 3);
+            mr_free(command);
+
+            if (res) {
+                done = ask_me_yes_or_no("Modifications failed. Re-try?");
+            } else {
+                done = TRUE;
+            }
+        }
+    } else {
+        /* nuke mode */
+        mr_asprintf(command, "mr-raw %s /"MOUNTLIST_FNAME_STUB, boot_device);
+        log_msg(2, "run_raw_mbr() --- command='%s'", command);
+
+        mvaddstr_and_log_it(g_currentY, 0, "Restoring MBR...                                               ");
+        res = run_program_and_log_output(command, 3);
+        mr_free(command);
+    }
+    if (res) {
+        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
+        log_to_screen("MBR+fstab processed w/error(s). See %s for more info.", MONDO_LOGFILE);
+    } else {
+        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+    }
+    paranoid_free(boot_device);
+    return (res);
+}
+
+/**************************************************************************
+ *END_RUN_RAW_MBR                                                         *
+ **************************************************************************/
 
 
@@ -1465 +1823 @@
                     popup_and_OK("The mountlist was changed. You will now edit fstab, mtab, device.map and menu.lst/grub.cfg in order to fix grub install");
                 }
-                editor = find_my_editor());
+                editor = find_my_editor();
                 if (editor == NULL) {
                     popup_and_OK("No editor found. You won't be able to edit conf files");
@@ -1644 +2002 @@
 
 
-/**
- * Install LILO on the user's boot drive (determined by /etc/lilo.conf).
- * @param offer_to_run_stablilo If TRUE, then offer to hack the user's fstab for them.
+
+/**
+ * Install the user's boot loader in the MBR.
+ * Currently LILO, ELILO, GRUB, RAW (dd of MBR), and the FreeBSD bootloader are supported.
+ * @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
  * @return 0 for success, nonzero for failure.
  */
-int run_lilo(bool offer_to_run_stablilo)
+int run_boot_loader(bool offer_to_hack_scripts)
 {
-  /** malloc **/
-    char *command = NULL;
-    char *tmp = NULL;
-    char *editor = NULL;
-
     int res;
-    int done;
-    bool run_lilo_M = FALSE;
-
-    if (!run_program_and_log_output
-        ("grep \"boot.*=.*/dev/md\" " MNT_RESTORING "/etc/lilo.conf", 1)) {
-        run_lilo_M = TRUE;
-    }
-
-    if (offer_to_run_stablilo
-        && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?"))
-
-        /* interactive mode */
-    {
-        mvaddstr_and_log_it(g_currentY,
-                            0,
-                            "Modifying fstab and lilo.conf, and running LILO...                             ");
-        mr_asprintf(command, "mr-stablilo-me");
-        res = run_program_and_log_output(command, 3);
-        mr_free(command);
-
-        if (res) {
-            popup_and_OK
-                ("You will now edit fstab and lilo.conf, to make sure they match your new mountlist.");
-            for (done = FALSE; !done;) {
-                editor = find_my_editor();
-                if (editor == NULL) {
-                    popup_and_OK("No editor found. You won't be able to edit conf files");
-                } else {
-                    if (!g_text_mode) {
-                        newtSuspend();
-                    }
-                    mr_asprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
-                    paranoid_system(tmp);
-                    mr_free(tmp);
-    
-                    mr_asprintf(tmp, "%s " MNT_RESTORING "/etc/lilo.conf", editor);
-                    paranoid_system(tmp);
-                    mr_free(tmp);
-                    mr_free(editor);
-    
-                    if (!g_text_mode) {
-                        newtResume();
-                    }
-//              newtCls();
-                    if (ask_me_yes_or_no("Edit them again?")) {
-                        continue;
-                    }
-                }
-                mr_free(editor);
-
-                res = run_program_and_log_output("chroot " MNT_RESTORING " lilo -L", 3);
-                if (res) {
-                    res = run_program_and_log_output("chroot " MNT_RESTORING " lilo", 3);
-                }
-                if (res) {
-                    done = ask_me_yes_or_no("LILO failed. Re-edit system files?");
-                } else {
-                    done = TRUE;
-                }
-            }
+    int retval = 0;
+
+  /** malloc *******/
+    char *device = NULL;
+    char *disk = NULL;
+    char *name = NULL;
+    char *type = NULL;
+    char *cmd = NULL;
+
+    malloc_string(device);
+    malloc_string(name);
+    malloc_string(type);
+
+    /* In order to have a working bootloader, we need to have all devices
+     * ready in the chroot. If they are not there (udev) then copy them from
+     * the current /dev location 
+     */
+    mr_asprintf(cmd,"tar cf - /dev | ( cd %s ; tar xf - )",MNT_RESTORING);
+    run_program_and_log_output(cmd, 3);
+    mr_free(cmd);
+
+    backup_crucial_file(MNT_RESTORING, "/etc/fstab");
+    backup_crucial_file(MNT_RESTORING, "/boot/grub/menu.lst");
+    backup_crucial_file(MNT_RESTORING, "/boot/grub/grub.cfg");
+    backup_crucial_file(MNT_RESTORING, "/boot/grub2/grub.cfg");
+    backup_crucial_file(MNT_RESTORING, "/etc/lilo.conf");
+    backup_crucial_file(MNT_RESTORING, "/etc/elilo.conf");
+    backup_crucial_file(MNT_RESTORING, "/boot/grub/device.map");
+    backup_crucial_file(MNT_RESTORING, "/boot/grub2/device.map");
+    backup_crucial_file(MNT_RESTORING, "/etc/mtab");
+    read_cfg_var(g_mondo_cfg_file, "bootloader.device", device);
+    read_cfg_var(g_mondo_cfg_file, "bootloader.name", name);
+    read_cfg_var(g_mondo_cfg_file, "boot-type", type);
+    log_msg(2, "run_boot_loader: device='%s', name='%s', type='%s'", device, name, type);
+    sync();
+
+    offer_to_make_initrd();
+
+    disk = truncate_to_drive_name(device);
+    if (strcmp(type,"BIOS") == 0) {
+        // Force installation of a MBR bootloader brought by mindi on the disk
+        // in case none was available and we then start from a partition
+        log_msg(2, "Reinstalling mbr.bin on %s", disk);
+        mr_system("dd bs=440 count=1 conv=notrunc if=/tmp/mbr.bin of=%s &> /dev/null",disk);
+    } else {
+        // Same for GPT
+        log_msg(2, "Reinstalling gptmbr.bin on %s", disk);
+        mr_system("dd bs=440 count=1 conv=notrunc if=/tmp/gptmbr.bin of=%s &> /dev/null",disk);
+    }
+
+    // Now reinstall bootloader
+    if (!strcmp(name, "LILO")) {
+        res = run_lilo(offer_to_hack_scripts);
+    } else if (!strcmp(name, "ELILO")) {
+        res = run_elilo(offer_to_hack_scripts);
+    } else if (!strcmp(name, "GRUB")) {
+        res = run_grub(offer_to_hack_scripts, device);
+    } else if (!strcmp(name, "RAW")) {
+        res = run_raw_mbr(offer_to_hack_scripts, device);
+    }
+#ifdef __FreeBSD__
+    else if (!strcmp(name, "BOOT0")) {
+        mr_asprintf(tmp, "boot0cfg -B %s", device);
+        res = run_program_and_log_output(tmp, FALSE);
+        paranoid_free(tmp);
+    } else {
+        mr_asprintf(tmp, "ls /dev | grep -Eq '^%ss[1-4].*'", device);
+        if (!system(tmp)) {
+            mr_free(tmp);
+            mr_asprintf(tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
+            res = run_program_and_log_output(tmp, 3);
         } else {
-            log_to_screen("lilo.conf and fstab were modified OK");
-        }
-    } else
-        /* nuke mode */
-    {
-        mvaddstr_and_log_it(g_currentY,
-                            0,
-                            "Running LILO...                                                 ");
-        res =
-            run_program_and_log_output("chroot " MNT_RESTORING " lilo -L",
-                                       3);
-        if (res) {
-            res =
-                run_program_and_log_output("chroot " MNT_RESTORING " lilo",
-                                           3);
-        }
-        if (res) {
-            mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
-            log_to_screen
-                ("Failed to re-jig fstab and/or lilo. Edit/run manually, please.");
-        } else {
-            mvaddstr_and_log_it(g_currentY++, 74, "Done.");
-        }
-    }
-    if (run_lilo_M) {
-        run_program_and_log_output("chroot " MNT_RESTORING
-                                   " lilo -M /dev/hda", 3);
-        run_program_and_log_output("chroot " MNT_RESTORING
-                                   " lilo -M /dev/sda", 3);
-    }
-    return (res);
+            log_msg(1, "I'm not running any boot loader. You have a DD boot drive. It's already loaded up.");
+        }
+        mr_free(tmp);
+    }
+#else
+    else {
+        log_to_screen
+            ("Unable to determine type of boot loader. Defaulting to LILO.");
+        res = run_lilo(offer_to_hack_scripts);
+    }
+#endif
+    retval += res;
+    if (res) {
+        log_to_screen("Your boot loader returned an error");
+    } else {
+        log_to_screen("Your boot loader ran OK");
+    }
+    paranoid_free(device);
+    paranoid_free(name);
+    return (retval);
 }
 
 /**************************************************************************
- *END_RUN_LILO                                                            *
- **************************************************************************/
-
-
-/**
- * Install a raw MBR onto @p bd.
- * @param offer_to_hack_scripts If TRUE, then offer to hack the user's fstab for them.
- * @param bd The device to copy the stored MBR to.
- * @return 0 for success, nonzero for failure.
- */
-int run_raw_mbr(bool offer_to_hack_scripts, char *bd)
-{
-  /** malloc **/
-    char *command = NULL;
-    char *boot_device = NULL;
-    char *tmp = NULL;
-    char *editor;
-    int res;
-    int done;
-
-    malloc_string(boot_device);
-    assert_string_is_neither_NULL_nor_zerolength(bd);
-
-    strcpy(boot_device, bd);
-
-    if (offer_to_hack_scripts
-        && ask_me_yes_or_no("Did you change the mountlist or cloned the system ?")) {
-        /* interactive mode */
-        mvaddstr_and_log_it(g_currentY, 0, "Modifying fstab and restoring MBR...                           ");
-        for (done = FALSE; !done;) {
-            popup_and_OK("You will now edit fstab");
-            editor = find_my_editor());
-            if (editor == NULL) {
-                popup_and_OK("No editor found. You won't be able to edit conf files");
-            } else {
-                if (!g_text_mode) {
-                    newtSuspend();
-                }
-                mr_asprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
-
-                paranoid_system(tmp);
-                mr_free(tmp);
-                if (!g_text_mode) {
-                    newtResume();
-                }
-            }
-            mr_free(editor);
-
-            popup_and_get_string("Boot device", "Please confirm/enter the boot device. If in doubt, try /dev/hda", boot_device, MAX_STR_LEN / 4);
-            mr_asprintf(command, "mr-stabraw-me %s", boot_device);
-            res = run_program_and_log_output(command, 3);
-            mr_free(command);
-
-            if (res) {
-                done = ask_me_yes_or_no("Modifications failed. Re-try?");
-            } else {
-                done = TRUE;
-            }
-        }
-    } else {
-        /* nuke mode */
-        mr_asprintf(command, "mr-raw %s /"MOUNTLIST_FNAME_STUB, boot_device);
-        log_msg(2, "run_raw_mbr() --- command='%s'", command);
-
-        mvaddstr_and_log_it(g_currentY, 0, "Restoring MBR...                                               ");
-        res = run_program_and_log_output(command, 3);
-        mr_free(command);
-    }
-    if (res) {
-        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
-        log_to_screen("MBR+fstab processed w/error(s). See %s for more info.", MONDO_LOGFILE);
-    } else {
-        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
-    }
-    paranoid_free(boot_device);
-    return (res);
-}
-
-/**************************************************************************
- *END_RUN_RAW_MBR                                                         *
+ *END_ RUN_BOOT_LOADER                                                    *
  **************************************************************************/
 
@@ -2068 +2344 @@
  *END_UNMOUNT_ALL_DEVICES                                                 *
  **************************************************************************/
-
-/**
- * Extract mondorestore.cfg and the mountlist from the tape inserted
- * to the ./tmp/ directory.
- * @param dev The tape device to read from.
- * @return 0 for success, nonzero for failure.
- */
-int extract_cfg_file_and_mountlist_from_tape_dev(char *dev)
-{
-    char *command = NULL;
-    int res = 0;
-
-    if (bkpinfo->use_obdr) {
-        skip_obdr();
-    } else {
-        // TODO: below 32KB seems to block at least on RHAS 2.1 and MDK 10.0
-        set_tape_block_size_with_mt(bkpinfo->internal_tape_block_size);
-    }
-
-    mr_asprintf(command, "dd if=%s bs=%ld count=%ld 2> /dev/null | tar -zx ./%s ./%s ./%s ./%s ./%s", dev, bkpinfo->internal_tape_block_size, 1024L * 1024 * 32 / bkpinfo->internal_tape_block_size, MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);
-    log_msg(2, "command = '%s'", command);
-    res = run_program_and_log_output(command, -1);
-    mr_free(command);
-
-    if (res != 0) {
-        if (does_file_exist(MONDO_CFG_FILE_STUB)) {
-            res = 0;
-        } else {
-            /* Doing that allow us to remain compatible with pre-2.2.5 versions */
-            log_msg(2, "pre-2.2.4 compatible mode on");
-            mr_asprintf(command,    "dd if=%s bs=%ld count=%ld 2> /dev/null | tar -zx %s %s %s %s %s", dev, bkpinfo->internal_tape_block_size, 1024L * 1024 * 32 / bkpinfo->internal_tape_block_size, MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);
-            log_msg(2, "command = '%s'", command);
-            res = run_program_and_log_output(command, -1);
-            mr_free(command);
-            if ((res != 0) && (does_file_exist(MONDO_CFG_FILE_STUB))) {
-                res = 0;
-            }
-        }
-    }
-    paranoid_free(command);
-    return (res);
-}
-
-
-/**
- * Get the configuration file from the tape, or CD.
- * @param bkpinfo The backup information structure. Fields used:
- * - @c bkpinfo->backup_media_type
- * - @c bkpinfo->media_device
- * - @c bkpinfo->tmpdir
- * @return 0 for success, nonzero for failure.
- */
-int get_cfg_file_from_archive()
-{
-    int retval = 0;
-
-   /** malloc *****/
-    char *command = NULL;
-    char *cfg_file = NULL;
-    char *tmp = NULL;
-    char *tmp1 = NULL;
-    char *mountpt = NULL;
-    char *mountlist_file = NULL;
-    bool extract_mountlist_stub = FALSE;
-    bool extract_i_want_my_lvm = FALSE;
-
-    bool try_plan_B;
-
-    assert(bkpinfo != NULL);
-    log_msg(2, "gcffa --- starting");
-    log_to_screen("I'm thinking...");
-    mr_asprintf(mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
-    if (chdir(bkpinfo->tmpdir)) {
-        // FIXME
-    }
-    mr_asprintf(cfg_file, "%s", MONDO_CFG_FILE_STUB);
-    unlink(cfg_file);           // cfg_file[] is missing the '/' at the start, FYI, by intent
-    mr_free(cfg_file);
-
-    unlink(FILELIST_FULL_STUB);
-    unlink(BIGGIELIST_TXT_STUB);
-    mr_asprintf(command, "mkdir -p %s", mountpt);
-    run_program_and_log_output(command, FALSE);
-    mr_free(command);
-
-    mr_asprintf(cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
-    mr_asprintf(mountlist_file, "%s/%s", bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
-    log_msg(2, "mountpt = %s; cfg_file=%s", mountpt, cfg_file);
-    mr_free(mountpt);
-
-    if (!does_file_exist(cfg_file)) {
-        log_msg(2, "gcffa --- we don't have cfg file yet.");
-        if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
-            try_plan_B = TRUE;
-        } else {
-            log_msg(2, "gcffa --- calling mount_media now :)");
-            if (!mount_media(MNT_CDROM)) {
-                log_msg(2, "gcffa --- managed to mount CD; so, no need for Plan B");
-                try_plan_B = FALSE;
-            } else {
-                try_plan_B = TRUE;
-            }
-            if (what_number_cd_is_this() > 1) {
-                insist_on_this_cd_number((g_current_media_number = 1));
-            }
-        }
-        if (try_plan_B) {
-            log_msg(2, "gcffa --- OK, switching to Plan B");
-            if (chdir(bkpinfo->tmpdir)) {
-                // FIXME
-            }
-            run_program_and_log_output("mkdir -p tmp", FALSE);
-
-            if (bkpinfo->media_device == NULL) {
-                mr_asprintf(bkpinfo->media_device, "%s", "/dev/st0");
-                log_msg(2, "media_device is blank; assuming %s", bkpinfo->media_device);
-            }
-            mr_asprintf(tmp, "%s", bkpinfo->media_device);
-            if (extract_cfg_file_and_mountlist_from_tape_dev(bkpinfo->media_device)) {
-                mr_free(bkpinfo->media_device);
-                mr_asprintf(bkpinfo->media_device, "%s", "/dev/st0");
-                if (extract_cfg_file_and_mountlist_from_tape_dev(bkpinfo->media_device)) {
-                    mr_free(bkpinfo->media_device);
-                    mr_asprintf(bkpinfo->media_device, "%s", "/dev/osst0");
-                    if (extract_cfg_file_and_mountlist_from_tape_dev(bkpinfo->media_device)) {
-                        mr_free(bkpinfo->media_device);
-                        mr_asprintf(bkpinfo->media_device, "%s", "/dev/ht0");
-                        if (extract_cfg_file_and_mountlist_from_tape_dev(bkpinfo->media_device)) {
-                            log_msg(3, "I tried lots of devices but none worked.");
-                            mr_free(bkpinfo->media_device);
-                        }
-                    }
-                }
-            }
-            if (bkpinfo->media_device == NULL) {
-                bkpinfo->media_device = tmp;
-            } else {
-                mr_free(tmp);
-            }
-
-            if (!does_file_exist("tmp/mondorestore.cfg")) {
-                log_to_screen("Cannot find config info on media");
-                return (1);
-            }
-        } else {
-                if (does_file_exist("/"MOUNTLIST_FNAME_STUB)) {
-                    extract_mountlist_stub = FALSE;
-                } else {
-                    extract_mountlist_stub = TRUE;
-                }
-                if (does_file_exist("/"IWANTMYLVM_STUB)) {
-                    extract_i_want_my_lvm = FALSE;
-                } else {
-                    extract_i_want_my_lvm = TRUE;
-                }
-
-                log_msg(2, "gcffa --- Plan B, a.k.a. untarring some file from all.tar.gz");
-                mr_asprintf(command, "tar -zxvf " MNT_CDROM "/images/all.tar.gz ./%s ./%s ./%s ./%s ./%s", MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);    // add -b TAPE_BLOCK_SIZE if you _really_ think it's necessary
-                run_program_and_log_output(command, TRUE);
-                mr_free(command);
-
-                if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
-                    /* Doing that allow us to remain compatible with pre-2.2.5 versions */
-                    log_msg(2, "pre-2.2.4 compatible mode on");
-                    mr_asprintf(command, "tar -zxvf " MNT_CDROM "/images/all.tar.gz %s %s %s %s %s", MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, IWANTMYLVM_STUB);  // add -b TAPE_BLOCK_SIZE if you _really_ think it's necessary
-                    run_program_and_log_output(command, TRUE);
-                    mr_free(command);
-                    if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
-                        fatal_error
-                            ("Please reinsert the disk/CD and try again.");
-                    }
-                }
-        }
-    }
-    if (does_file_exist(MONDO_CFG_FILE_STUB)) {
-        log_msg(1, "gcffa --- great! We've got the config file");
-        tmp1 = call_program_and_get_last_line_of_output("pwd");
-        mr_asprintf(tmp, "%s/%s", tmp1, MONDO_CFG_FILE_STUB);
-        mr_asprintf(command, "cp -f %s %s", tmp, cfg_file);
-        log_it("%s",command);
-        if (strcmp(tmp, cfg_file) && run_program_and_log_output(command, 1)) {
-            log_msg(1,
-                    "... but an error occurred when I tried to move it to %s",
-                    cfg_file);
-        } else {
-            log_msg(1, "... and I moved it successfully to %s", cfg_file);
-        }
-        mr_free(command);
-
-        mr_asprintf(command, "cp -f %s/%s %s", tmp1, MOUNTLIST_FNAME_STUB, mountlist_file);
-        mr_free(tmp1);
-        log_it("%s",command);
-        if (extract_mountlist_stub) {
-            if (strcmp(tmp, cfg_file) && run_program_and_log_output(command, 1)) {
-                log_msg(1, "Failed to get mountlist");
-            } else {
-                log_msg(1, "Got mountlist too");
-                mr_free(command);
-                mr_asprintf(command, "cp -f %s %s", mountlist_file, g_mountlist_fname);
-                if (run_program_and_log_output(command, 1)) {
-                    log_msg(1, "Failed to copy mountlist to /tmp");
-                } else {
-                    log_msg(1, "Copied mountlist to /tmp as well OK");
-                    mr_free(command);
-                    mr_asprintf(command, "cp -f %s /tmp/",IWANTMYLVM_STUB);
-                    run_program_and_log_output(command, 1);
-                }
-            }
-        }
-        mr_free(command);
-        mr_free(tmp);
-    }
-
-    run_program_and_log_output("umount -d " MNT_CDROM, FALSE);
-    if (!does_file_exist(cfg_file)) {
-        log_it("%s",cfg_file);
-        log_msg(1, "%s not found", cfg_file);
-        log_to_screen("Oh dear. Unable to recover configuration file from boot disk");
-        return (1);
-    }
-
-    log_to_screen("Recovered mondorestore.cfg");
-    if (!does_file_exist(MOUNTLIST_FNAME_STUB)) {
-        log_to_screen("...but not mountlist.txt - a pity, really...");
-    } else {
-            /* Is this code really useful ??? */
-        if (extract_mountlist_stub) {
-            mr_asprintf(command, "cp -f %s %s/%s", MOUNTLIST_FNAME_STUB, bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
-            run_program_and_log_output(command, FALSE);
-            mr_free(command);
-        }
-    }
-
-    mr_asprintf(command, "cp -f %s /%s", cfg_file, MONDO_CFG_FILE_STUB);
-    mr_free(cfg_file);
-
-    run_program_and_log_output(command, FALSE);
-    mr_free(command);
-
-    if (extract_mountlist_stub) {
-        mr_asprintf(command, "cp -f %s /%s", mountlist_file, MOUNTLIST_FNAME_STUB);
-        run_program_and_log_output(command, FALSE);
-        mr_free(command);
-    }
-    mr_free(mountlist_file);
-
-    mr_asprintf(command, "cp -f etc/raidtab /etc/");
-    run_program_and_log_output(command, FALSE);
-    mr_free(command);
-
-    if (extract_i_want_my_lvm) {
-        mr_asprintf(command, "cp -f %s /tmp/",IWANTMYLVM_STUB);
-        run_program_and_log_output(command, FALSE);
-        mr_free(command);
-    }
-    g_backup_media_type = bkpinfo->backup_media_type;
-    return (retval);
-}
-
-/**************************************************************************
- *END_GET_CFG_FILE_FROM_ARCHIVE                                           *
- **************************************************************************/
-
 /* @} - end restoreUtilityGroup */
 

branches/3.3/mondo/src/mondorestore/mondorestore.c

@@ -13 +13 @@
 #include "mr_mem.h"
 #include "mr_file.h"
-#include "../common/mondostructures.h"
-#include "../common/libmondo.h"
-#include "mr-externs.h"
+#include "mondostructures.h"
 #include "mondorestore.h"
 #include "mr_msg.h"
@@ -21 +19 @@
 #include "mondo-rstr-tools-EXT.h"
 #include "libmondo-mountlist-EXT.h"
+#include "libmondo-tools-EXT.h"
+#include "libmondo-gui-EXT.h"
+#include "libmondo-devices-EXT.h"
+#include "libmondo-fork-EXT.h"
+#include "libmondo-string-EXT.h"
+#include "libmondo-archive-EXT.h"
+#include "libmondo-raid-EXT.h"
+#include "libmondo-filelist-EXT.h"
+#include "libmondo-files-EXT.h"
+#include "libmondo-stream-EXT.h"
+#include "libmondo-cli-EXT.h"
 #include "newt-specific-EXT.h"
 
 extern void wait_until_software_raids_are_prepped(char *, int);
 extern void twenty_seconds_til_yikes(void);
+// in mondo-prep.c
+extern void resize_mountlist_proportionately_to_suit_new_drives(struct mountlist_itself *);
+extern int format_everything(struct mountlist_itself *, bool , struct raidlist_itself *);
+extern int partition_everything(struct mountlist_itself *);
+extern int fput_string_one_char_at_a_time(FILE *, char *);
+extern int do_my_funky_lvm_stuff(bool, bool );
+extern int stop_all_raid_devices(struct mountlist_itself *);
+
+// in mondo-rstr-newt.c
+extern int edit_mountlist(char *, struct mountlist_itself *, struct raidlist_itself *);
+
+// from libmondo-devices.c
+extern bool g_restoring_live_from_cd;
+extern bool g_restoring_live_from_netfs;
+
+extern int g_currentY;
 
 /* We don't have a cleanup function yet */
@@ -53 +78 @@
 extern int g_partition_table_locked_up;
 extern int g_noof_rows;
-
-extern int partition_everything(struct mountlist_itself *mountlist);
-extern int handle_incoming_parameters(int argc, char *argv[]);
+extern int g_current_media_number;
 
 /**
@@ -121 +144 @@
 char *g_getfattr;
 
+extern long g_current_progress;
+extern int g_currentY;
+extern int g_current_media_number;
+
+
 /* @} - end of "Restore-Time Globals" in globalGroup */
 
-
-
-extern int copy_from_src_to_dest(FILE * f_orig, FILE * f_archived,
-                                 char direction);
 
 
@@ -580 +604 @@
                 just_changed_cds = FALSE;
                 log_msg(3, "I'll continue to scan this CD for bigfiles to be restored.");
-            } else if (does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")) {
+            } else if (does_file_exist(ARCHIVES_PATH "/NOT-THE-LAST")) {
                 insist_on_this_cd_number(++g_current_media_number);
                 log_to_screen("Restoring from %s #%d", mds, g_current_media_number);
@@ -691 +715 @@
     paranoid_free(command);
 
-    mr_asprintf(filelist_name, MNT_CDROM "/archives/filelist.%ld", current_tarball_number);
+    mr_asprintf(filelist_name, ARCHIVES_PATH "/filelist.%ld", current_tarball_number);
     if (length_of_file(filelist_name) <= 2) {
         log_msg(2, "There are _zero_ files in filelist '%s'", filelist_name);
@@ -726 +750 @@
     if (filelist == NULL || matches > 0) {
         if (g_getfattr) {
-            mr_asprintf(xattr_fname, XATTR_LIST_FNAME_RAW_SZ, MNT_CDROM "/archives", current_tarball_number);
+            mr_asprintf(xattr_fname, XATTR_LIST_FNAME_RAW_SZ, ARCHIVES_PATH, current_tarball_number);
         }
         if (g_getfacl) {
-            mr_asprintf(acl_fname, ACL_LIST_FNAME_RAW_SZ, MNT_CDROM "/archives", current_tarball_number);
+            mr_asprintf(acl_fname, ACL_LIST_FNAME_RAW_SZ, ARCHIVES_PATH, current_tarball_number);
         }
         if (strstr(tarball_fname, ".bz2")) {
@@ -922 +946 @@
         mr_free(progress_str);
 
-        mr_asprintf(tarball_fname, MNT_CDROM "/archives/%ld.afio.bz2", current_tarball_number);
+        mr_asprintf(tarball_fname, ARCHIVES_PATH "/%ld.afio.bz2", current_tarball_number);
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%ld.afio.gz", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%ld.afio.gz", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%ld.afio.lzma", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%ld.afio.lzma", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%ld.afio.lzo", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%ld.afio.lzo", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%ld.afio.", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%ld.afio.", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%ld.star.bz2", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%ld.star.bz2", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
             mr_free(tarball_fname);
-            mr_asprintf(tarball_fname, MNT_CDROM "/archives/%ld.star.", current_tarball_number);
+            mr_asprintf(tarball_fname, ARCHIVES_PATH "/%ld.star.", current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
@@ -954 +978 @@
                 return (0);
             }
-            if (!does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")
-                || system("find " MNT_CDROM
-                          "/archives/slice* > /dev/null 2> /dev/null") ==
+            if (!does_file_exist(ARCHIVES_PATH "/NOT-THE-LAST")
+                || system("find " ARCHIVES_PATH "/slice* > /dev/null 2> /dev/null") ==
                 0) {
                 break;

branches/3.3/mondo/test/Makefile.am

@@ -1 @@
-AM_CPPFLAGS = -DMONDO_CONF_DIR=\"$(sysconfdir)/mondo\" -I${top_builddir}/src/include -I${top_builddir}/src/common
+AM_CPPFLAGS = -DMONDO_CONF_DIR=\"$(sysconfdir)/mondo\" -I${top_builddir}/src/include -I${top_builddir}/src/common -I${top_builddir}/src/mondoarchive -I${top_builddir}/src/mondorestore
 AUTOMAKE_OPTIONS = subdir-objects
 

branches/3.3/mondo/test/test-mountlist.c

@@ -8 +8 @@
 #include "my-stuff.h"
 #include "mr_mem.h"
-#include "../common/mondostructures.h"
-#include "../common/libmondo.h"
-#include "../mondorestore/mondorestore.h"
-#include "../mondorestore/mr-externs.h"
-#include "../mondorestore/libmondo-mountlist-EXT.h"
-
+#include "mondostructures.h"
+#include "mondorestore.h"
+#include "libmondo-mountlist-EXT.h"
+#include "libmondo-raid-EXT.h"
+#include "libmondo-tools-EXT.h"
+#include "newt-specific-EXT.h"
+extern void resize_mountlist_proportionately_to_suit_new_drives(struct mountlist_itself *);
+extern int edit_mountlist(char *, struct mountlist_itself *, struct raidlist_itself *);
 
 #define RAIDTAB_TEST "/tmp/raidtab"

branches/3.3/mondo/test/test-truncname.c

@@ -8 +8 @@
 #include "my-stuff.h"
 #include "mr_mem.h"
-#include "../common/mondostructures.h"
-#include "../common/libmondo.h"
-#include "../mondoarchive/mondoarchive.h"
+#include "mondostructures.h"
+#include "mondoarchive.h"
+#include "libmondo-tools-EXT.h"
+#include "newt-specific-EXT.h"
 
 extern void twenty_seconds_til_yikes(void);