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

Timestamp:

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

Author:

Bruno Cornec

Message:

Fix all remaining compiler errors

Location:

branches/3.3/mondo/src/common

Files:

• libmondo-archive.c (modified) (6 diffs)
• libmondo-cli.c (modified) (6 diffs)
• libmondo-devices.c (modified) (6 diffs)
• libmondo-fifo.c (modified) (1 diff)
• libmondo-filelist.c (modified) (2 diffs)
• libmondo-raid-EXT.h (modified) (1 diff)
• libmondo-raid.c (modified) (3 diffs)
• libmondo-stream.c (modified) (4 diffs)
• libmondo-tools-EXT.h (modified) (2 diffs)
• libmondo-tools.c (modified) (1 diff)
• libmondo.h (deleted)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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