Changeset 3879 in MondoRescue for branches/3.3/mondo/src/mondorestore

Timestamp:

Mar 9, 2024, 3:10:04 AM (2 years ago)

Author:

Bruno Cornec

Message:

Fix all remaining compiler errors

Location:

branches/3.3/mondo/src/mondorestore

Files:

• Makefile.am (modified) (1 diff)
• libmondo-mountlist.h (deleted)
• mondo-prep.c (modified) (9 diffs)
• mondo-rstr-compare.c (modified) (6 diffs)
• mondo-rstr-compare.h (deleted)
• mondo-rstr-mountlist.c (modified) (5 diffs)
• mondo-rstr-newt.c (modified) (14 diffs)
• mondo-rstr-newt.h (deleted)
• mondo-rstr-tools.c (modified) (10 diffs)
• mondo-rstr-tools.h (deleted)
• mondoprep.h (deleted)
• mondorestore-EXT.h (deleted)
• mondorestore.c (modified) (9 diffs)
• mr-externs.h (deleted)

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;