Changeset 3877 in MondoRescue for branches/3.3

Timestamp:

Mar 8, 2024, 3:59:07 AM (4 months ago)

Author:

Bruno Cornec

Message:

More compiler fixes

Location:

branches/3.3/mondo/src/common

Files:

• libmondo-archive.c (modified) (10 diffs)
• libmondo-devices-EXT.h (modified) (1 diff)
• libmondo-devices.c (modified) (5 diffs)
• libmondo-stream.c (modified) (9 diffs)
• libmondo-tools.c (modified) (2 diffs)
• libmondo-verify.c (modified) (3 diffs)

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

@@ -318 +318 @@
 
 
+
+
+/**
+ * Finalize the backup.
+ * For streaming backups, this writes the closing block
+ * to the stream. For CD-based backups, this creates
+ * the final ISO image.
+ * @param bkpinfo The backup information structure, used only
+ * for the @c backup_media_type.
+ * @ingroup MLarchiveGroup
+ */
+int do_that_final_phase()
+{
+
+    /*@ int ************************************** */
+    int res = 0;
+    int retval = 0;
+
+    /*@ buffers ********************************** */
+
+    assert(bkpinfo != NULL);
+    mvaddstr_and_log_it(g_currentY, 0,
+                        "Writing any remaining data to media         ");
+
+    log_msg(1, "Closing tape/CD/USB ... ");
+    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
+        /* write tape/cdstream */
+        closeout_tape();
+    } else {
+        /* write final ISO/USB */
+        res = write_final_iso_if_necessary();
+        retval += res;
+        if (res) {
+            log_msg(1, "write_final_iso_if_necessary returned an error");
+        }
+    }
+    log_msg(2, "Fork is exiting ... ");
+
+    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+
+    /* final stuff */
+    if (retval) {
+        mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
+    } else {
+        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+    }
+
+    return (retval);
+}
+
+/**
+ * Wrapper around @c make_slices_and_images().
+ * @param bkpinfo The backup information structure. Fields used:
+ * - @c backup_media_type
+ * - @c scratchdir
+ * - @c tmpdir
+ * @return The number of errors encountered (0 for success)
+ * @ingroup MLarchiveGroup
+ */
+int make_those_slices_phase()
+{
+
+    /*@ int ***************************************************** */
+    int res = 0;
+    int retval = 0;
+
+    /*@ buffers ************************************************** */
+    char *biggielist = NULL;
+    char *command = NULL;
+    char *blah = NULL;
+    char *xattr_fname = NULL;
+    char *acl_fname = NULL;
+
+    assert(bkpinfo != NULL);
+    /* slice big files */
+    mvaddstr_and_log_it(g_currentY, 0, "Archiving large files to media           ");
+    mr_asprintf(biggielist, "%s/archives/biggielist.txt", bkpinfo->scratchdir);
+    if (g_getfattr) {
+        mr_asprintf(xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
+    }
+    if (g_getfacl) {
+        mr_asprintf(acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
+    }
+
+    mr_asprintf(command, "cp %s/biggielist.txt %s", bkpinfo->tmpdir, biggielist);
+    paranoid_system(command);
+    mr_free(command);
+
+    mr_asprintf(blah, "biggielist = %s", biggielist);
+    log_msg(2, blah);
+    mr_free(blah);
+
+    if (!does_file_exist(biggielist)) {
+        log_msg(1, "BTW, the biggielist does not exist");
+    }
+
+    if (g_getfattr) {
+        get_fattr_list(biggielist, xattr_fname);
+        mr_asprintf(command, "cp %s %s/archives/", xattr_fname, bkpinfo->scratchdir);
+        paranoid_system(command);
+        mr_free(command);
+    }
+    if (g_getfacl) {
+        get_acl_list(biggielist, acl_fname);
+        mr_asprintf(command, "cp %s %s/archives/", acl_fname, bkpinfo->scratchdir);
+        paranoid_system(command);
+        mr_free(command);
+    }
+
+    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
+        res += write_EXAT_files_to_tape(xattr_fname, acl_fname);
+        mr_asprintf(blah, "%ld", count_lines_in_file(biggielist));
+        write_header_block_to_stream((off_t)0, blah, BLK_START_BIGGIEFILES);
+        mr_free(blah);
+    }
+    res = make_slices_and_images(biggielist);
+    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
+        write_header_block_to_stream((off_t)0, "end-of-biggiefiles", BLK_STOP_BIGGIEFILES);
+    }
+    retval += res;
+    if (res) {
+        log_msg(1, "make_slices_and_images returned an error");
+        mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
+    } else {
+        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+    }
+    mr_free(biggielist);
+    mr_free(xattr_fname);
+    mr_free(acl_fname);
+    return (retval);
+}
+
+
+
+/**
+ * Wrapper around @c make_afioballs_and_images().
+ * @param bkpinfo the backup information structure. Only the
+ * @c backup_media_type field is used within this function.
+ * @return return code of make_afioballs_and_images
+ * @see make_afioballs_and_images
+ * @ingroup MLarchiveGroup
+ */
+int make_those_afios_phase()
+{
+    /*@ int ******************************************* */
+    int res = 0;
+    int retval = 0;
+
+    assert(bkpinfo != NULL);
+
+    mvaddstr_and_log_it(g_currentY, 0, "Archiving regular files to media          ");
+
+    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
+        write_header_block_to_stream((off_t)0, "start-of-afioballs", BLK_START_AFIOBALLS);
+#if __FreeBSD__ == 5
+        log_msg(1, "Using single-threaded make_afioballs_and_images() to suit b0rken FreeBSD 5.0");
+        res = make_afioballs_and_images_OLD();
+#else
+        res = make_afioballs_and_images_OLD();
+#endif
+        write_header_block_to_stream((off_t)0, "stop-afioballs", BLK_STOP_AFIOBALLS);
+    } else {
+        res = make_afioballs_and_images();
+    }
+
+    retval += res;
+    if (res) {
+        mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
+        log_msg(1, "make_afioballs_and_images returned an error");
+    } else {
+        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+    }
+    return (retval);
+}
 
 
@@ -890 +1064 @@
 
 
+/**
+ * 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;
+    }
+}
+
+
 
 /**
@@ -1051 +1252 @@
 
 
-
-
-
-/**
- * Finalize the backup.
- * For streaming backups, this writes the closing block
- * to the stream. For CD-based backups, this creates
- * the final ISO image.
- * @param bkpinfo The backup information structure, used only
- * for the @c backup_media_type.
- * @ingroup MLarchiveGroup
- */
-int do_that_final_phase()
+/**
+ * Write the final ISO image.
+ * @param bkpinfo The backup information structure. Used only
+ * in the call to @c write_iso_and_go_on().
+ * @return The number of errors encountered (0 for success)
+ * @see write_iso_and_go_on
+ * @see make_iso_fs
+ * @bug The final ISO is written even if there are no files on it. In practice,
+ * however, this occurs rarely.
+ */
+int write_final_iso_if_necessary()
 {
-
-    /*@ int ************************************** */
-    int res = 0;
-    int retval = 0;
-
-    /*@ buffers ********************************** */
+    /*@ int ***************************************************** */
+    int res;
+
+    /*@ buffers ************************************************** */
+    char *tmp = NULL;
 
     assert(bkpinfo != NULL);
-    mvaddstr_and_log_it(g_currentY, 0,
-                        "Writing any remaining data to media         ");
-
-    log_msg(1, "Closing tape/CD/USB ... ");
-    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
-        /* write tape/cdstream */
-        closeout_tape();
-    } else {
-        /* write final ISO/USB */
-        res = write_final_iso_if_necessary();
-        retval += res;
-        if (res) {
-            log_msg(1, "write_final_iso_if_necessary returned an error");
-        }
-    }
-    log_msg(2, "Fork is exiting ... ");
-
-    mvaddstr_and_log_it(g_currentY++, 74, "Done.");
-
-    /* final stuff */
-    if (retval) {
-        mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
-    } else {
-        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
-    }
-
-    return (retval);
+    // I should really check if there are any slices or tarballs to be copied to CD-R(W)'s; the odds are approx. 1 in a million that there are no files here, so I'll just go ahead & make one more CD anyway
+
+    tmp = mr_center_string("Writing the final ISO", 80);
+    log_msg(2, tmp);
+    if (!g_text_mode) {
+        newtPushHelpLine(tmp);
+    }
+    mr_free(tmp);
+    res = write_iso_and_go_on(TRUE);
+    if (!g_text_mode) {
+        newtPopHelpLine();
+    }
+    log_msg(2, "Returning from writing final ISO (res=%d)", res);
+    return (res);
+}
+
+
+
+
+/**
+ * Remove the archives in @c d.
+ * This could possibly include any of:
+ * - all afioballs (compressed and not)
+ * - all filelists
+ * - all slices
+ * - all checksums
+ * - a zero filler file
+ *
+ * @param d The directory to wipe the archives from.
+ * @ingroup utilityGroup
+ */
+void wipe_archives(char *d)
+{
+    /*@ buffers ********************************************* */
+    char *tmp = NULL;
+    char *dir = NULL;
+
+    assert_string_is_neither_NULL_nor_zerolength(d);
+
+    mr_asprintf(dir, "%s/archives", d);
+    mr_asprintf(tmp, "rm -f %s/*.afio.* %s/*.star.*", dir, dir);
+    run_program_and_log_output(tmp, FALSE);
+    mr_free(tmp);
+    mr_asprintf(tmp, "rm -f %s/*list.[0-9]* %s/slice*", dir, dir);
+    run_program_and_log_output(tmp, FALSE);
+    mr_free(tmp);
+    mr_asprintf(tmp, "rm -f %s/cklist* %s/zero", dir, dir);
+    run_program_and_log_output(tmp, FALSE);
+    mr_free(tmp);
+    log_msg(1, "Wiped %s's archives", dir);
+    mr_asprintf(tmp, "ls -l %s", dir);
+    mr_free(dir);
+    run_program_and_log_output(tmp, FALSE);
+    mr_free(tmp);
 }
 
@@ -1212 +1437 @@
 
 
-
-
-
-
+/**
+ * @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;
 
 
@@ -1535 +1776 @@
 
 /**
+ * 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.
  *
@@ -1847 +2228 @@
 
 /**
+ * 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);
+}
+
+
+/**
  * Back up big files by chopping them up.
  * This function backs up all "big" files (where "big" depends
@@ -2136 +2772 @@
 /* @} - end of LLarchiveGroup */
 
-
-/**
- * Wrapper around @c make_afioballs_and_images().
- * @param bkpinfo the backup information structure. Only the
- * @c backup_media_type field is used within this function.
- * @return return code of make_afioballs_and_images
- * @see make_afioballs_and_images
- * @ingroup MLarchiveGroup
- */
-int make_those_afios_phase()
-{
-    /*@ int ******************************************* */
-    int res = 0;
-    int retval = 0;
-
-    assert(bkpinfo != NULL);
-
-    mvaddstr_and_log_it(g_currentY, 0, "Archiving regular files to media          ");
-
-    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
-        write_header_block_to_stream((off_t)0, "start-of-afioballs", BLK_START_AFIOBALLS);
-#if __FreeBSD__ == 5
-        log_msg(1, "Using single-threaded make_afioballs_and_images() to suit b0rken FreeBSD 5.0");
-        res = make_afioballs_and_images_OLD();
-#else
-        res = make_afioballs_and_images_OLD();
-#endif
-        write_header_block_to_stream((off_t)0, "stop-afioballs", BLK_STOP_AFIOBALLS);
-    } else {
-        res = make_afioballs_and_images();
-    }
-
-    retval += res;
-    if (res) {
-        mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
-        log_msg(1, "make_afioballs_and_images returned an error");
-    } else {
-        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
-    }
-    return (retval);
-}
-
-/**
- * Wrapper around @c make_slices_and_images().
+/**
+ * Write an ISO image to <tt>[bkpinfo->isodir]/bkpinfo->prefix-[g_current_media_number].iso</tt>.
  * @param bkpinfo The backup information structure. Fields used:
  * - @c backup_media_type
+ * - @c prefix
+ * - @c isodir
+ * - @c manual_cd_tray
+ * - @c media_size
+ * - @c netfs_remote_dir
  * - @c scratchdir
- * - @c tmpdir
+ * - @c verify_data
+ *
+ * @param last_cd If TRUE, this is the last CD to write; if FALSE, it's not.
  * @return The number of errors encountered (0 for success)
- * @ingroup MLarchiveGroup
- */
-int make_those_slices_phase()
+ * @see make_iso_fs
+ */
+int write_iso_and_go_on(bool last_cd)
 {
-
-    /*@ int ***************************************************** */
+    /*@ pointers **************************************************** */
+    FILE *fout;
+
+    /*@ buffers ***************************************************** */
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *cdno_fname = NULL;
+    char *lastcd_fname = NULL;
+    char *isofile = NULL;
+    char *mds = NULL;
+
+    /*@ bool ******************************************************** */
+    bool that_one_was_ok;
+    bool orig_vfy_flag_val;
+
+    /*@ int *********************************************************** */
     int res = 0;
-    int retval = 0;
-
-    /*@ buffers ************************************************** */
-    char *biggielist = NULL;
-    char *command = NULL;
-    char *blah = NULL;
-    char *xattr_fname = NULL;
-    char *acl_fname = NULL;
 
     assert(bkpinfo != NULL);
-    /* slice big files */
-    mvaddstr_and_log_it(g_currentY, 0, "Archiving large files to media           ");
-    mr_asprintf(biggielist, "%s/archives/biggielist.txt", bkpinfo->scratchdir);
-    if (g_getfattr) {
-        mr_asprintf(xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
-    }
-    if (g_getfacl) {
-        mr_asprintf(acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
-    }
-
-    mr_asprintf(command, "cp %s/biggielist.txt %s", bkpinfo->tmpdir, biggielist);
-    paranoid_system(command);
-    mr_free(command);
-
-    mr_asprintf(blah, "biggielist = %s", biggielist);
-    log_msg(2, blah);
-    mr_free(blah);
-
-    if (!does_file_exist(biggielist)) {
-        log_msg(1, "BTW, the biggielist does not exist");
-    }
-
-    if (g_getfattr) {
-        get_fattr_list(biggielist, xattr_fname);
-        mr_asprintf(command, "cp %s %s/archives/", xattr_fname, bkpinfo->scratchdir);
-        paranoid_system(command);
-        mr_free(command);
-    }
-    if (g_getfacl) {
-        get_acl_list(biggielist, acl_fname);
-        mr_asprintf(command, "cp %s %s/archives/", acl_fname, bkpinfo->scratchdir);
-        paranoid_system(command);
-        mr_free(command);
-    }
-
-    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
-        res += write_EXAT_files_to_tape(xattr_fname, acl_fname);
-        mr_asprintf(blah, "%ld", count_lines_in_file(biggielist));
-        write_header_block_to_stream((off_t)0, blah, BLK_START_BIGGIEFILES);
-        mr_free(blah);
-    }
-    res = make_slices_and_images(biggielist);
-    if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
-        write_header_block_to_stream((off_t)0, "end-of-biggiefiles", BLK_STOP_BIGGIEFILES);
-    }
-    retval += res;
-    if (res) {
-        log_msg(1, "make_slices_and_images returned an error");
-        mvaddstr_and_log_it(g_currentY++, 74, "Errors.");
-    } else {
-        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
-    }
-    mr_free(biggielist);
-    mr_free(xattr_fname);
-    mr_free(acl_fname);
-    return (retval);
+    orig_vfy_flag_val = bkpinfo->verify_data;
+    if (bkpinfo->media_size <= 0) {
+        fatal_error("write_iso_and_go_on() - unknown media size");
+    }
+
+    mds = media_descriptor_string(bkpinfo->backup_media_type);
+    log_msg(1, "OK, time to make %s #%d", mds, g_current_media_number);
+    mr_free(mds);
+
+    /* label the ISO with its number */
+
+    mr_asprintf(cdno_fname, "%s/archives/THIS-CD-NUMBER", bkpinfo->scratchdir);
+    fout = fopen(cdno_fname, "w");
+    mr_free(cdno_fname);
+
+    fprintf(fout, "%d", g_current_media_number);
+    paranoid_fclose(fout);
+
+    mr_asprintf(tmp1, "cp -f %s/autorun %s/", g_mondo_home, bkpinfo->scratchdir);
+    if (run_program_and_log_output(tmp1, FALSE)) {
+        log_msg(2, "Warning - unable to copy autorun to scratchdir");
+    }
+    mr_free(tmp1);
+
+    /* last CD or not? Label accordingly */
+    mr_asprintf(lastcd_fname, "%s/archives/NOT-THE-LAST", bkpinfo->scratchdir);
+    if (last_cd) {
+        unlink(lastcd_fname);
+        log_msg(2,
+                "OK, you're telling me this is the last CD. Fair enough.");
+    } else {
+        fout = fopen(lastcd_fname, "w");
+        fprintf(fout,
+                "You're listening to 90.3 WPLN, Nashville Public Radio.\n");
+        paranoid_fclose(fout);
+    }
+    mr_free(lastcd_fname);
+
+    if (space_occupied_by_cd(bkpinfo->scratchdir) / 1024 > bkpinfo->media_size) {
+        log_to_screen("Warning! CD is too big. It occupies %ld KB, which is more than the %ld MB allowed.",(long) space_occupied_by_cd(bkpinfo->scratchdir),(long) bkpinfo->media_size);
+    }
+
+    if (bkpinfo->netfs_remote_dir != NULL) {
+        // NETFS
+        mr_asprintf(isofile, "%s/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix, g_current_media_number);
+    } else {
+        // ISO
+        mr_asprintf(isofile, "%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->prefix, g_current_media_number);
+    }
+    for (that_one_was_ok = FALSE; !that_one_was_ok;) {
+        if (bkpinfo->backup_media_type != usb) {
+            res = make_iso_fs(isofile);
+        } else {
+            res = make_usb_fs();
+        }
+        if (g_current_media_number == 1 && !res
+            && (bkpinfo->backup_media_type == cdr)) {
+            if ((tmp = find_optical_device())   == NULL) {  // make sure find_optical_device() finds, records CD-R's loc
+                log_msg(3, "*Sigh* Mike, I hate your computer.");
+                // if it can't be found then force pausing
+                bkpinfo->manual_cd_tray = TRUE;
+            } else {
+                log_msg(3, "Great. Found Mike's CD-ROM drive.");
+            }
+            mr_free(tmp);
+        }
+        if (bkpinfo->verify_data && !res) {
+            mds = media_descriptor_string(g_backup_media_type);
+            log_to_screen("Please reboot from the 1st %s in Compare Mode, as a precaution.", mds);
+            mr_free(mds);
+            if (chdir("/")) {
+                // FIXME
+            }
+            log_it("Before calling verification of image()");
+            if (bkpinfo->backup_media_type == usb) {
+                res += verify_usb_image();
+            } else {
+                res += verify_cd_image();
+            }
+            log_it("After calling verification of image()");
+        }
+        if (!res) {
+            that_one_was_ok = TRUE;
+        } else {
+            mds = media_descriptor_string(bkpinfo->backup_media_type);
+            mr_asprintf(tmp1, "Failed to create %s #%d. Retry?", mds, g_current_media_number);
+            mr_free(mds);
+            res = ask_me_yes_or_no(tmp1);
+            mr_free(tmp1);
+
+            if (!res) {
+                if (ask_me_yes_or_no("Abort the backup?")) {
+                    fatal_error("FAILED TO BACKUP");
+                } else {
+                    break;
+                }
+            } else {
+                log_msg(2, "Retrying, at user's request...");
+                res = 0;
+            }
+        }
+    }
+    mr_free(isofile);
+
+    g_current_media_number++;
+    wipe_archives(bkpinfo->scratchdir);
+    mr_asprintf(tmp1, "rm -Rf %s/images/*gz %s/images/*data*img", bkpinfo->scratchdir, bkpinfo->scratchdir);
+    if (system(tmp1)) {
+        log_msg(2, "Error occurred when I tried to delete the redundant IMGs and GZs");
+    }
+    mr_free(tmp1);
+
+    if (last_cd) {
+        log_msg(2, "This was your last media.");
+    } else {
+        log_msg(2, "Continuing to backup your data...");
+    }
+
+    bkpinfo->verify_data = orig_vfy_flag_val;
+    return (0);
 }
 
-
-/**
- * @addtogroup LLarchiveGroup
- * @{
- */
-/**
- * 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;
+/* @} - end of LLarchiveGroup */
 
 /**
@@ -2365 +3025 @@
 /* @} - end of LLarchiveGroup */
 
-
-/**
- * @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;
-
 /**
  * Copy some files to tape.
@@ -2497 +3144 @@
 }
 
-
-/**
- * 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;
-        }
-    }
-
-}
-
-
-/**
- * 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;
-    }
-}
-
 /* @} - end of utilityGroup */
-
-
-/**
- * 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);
-}
-
-
-/**
- * Remove the archives in @c d.
- * This could possibly include any of:
- * - all afioballs (compressed and not)
- * - all filelists
- * - all slices
- * - all checksums
- * - a zero filler file
- *
- * @param d The directory to wipe the archives from.
- * @ingroup utilityGroup
- */
-void wipe_archives(char *d)
-{
-    /*@ buffers ********************************************* */
-    char *tmp = NULL;
-    char *dir = NULL;
-
-    assert_string_is_neither_NULL_nor_zerolength(d);
-
-    mr_asprintf(dir, "%s/archives", d);
-    mr_asprintf(tmp, "rm -f %s/*.afio.* %s/*.star.*", dir, dir);
-    run_program_and_log_output(tmp, FALSE);
-    mr_free(tmp);
-    mr_asprintf(tmp, "rm -f %s/*list.[0-9]* %s/slice*", dir, dir);
-    run_program_and_log_output(tmp, FALSE);
-    mr_free(tmp);
-    mr_asprintf(tmp, "rm -f %s/cklist* %s/zero", dir, dir);
-    run_program_and_log_output(tmp, FALSE);
-    mr_free(tmp);
-    log_msg(1, "Wiped %s's archives", dir);
-    mr_asprintf(tmp, "ls -l %s", dir);
-    mr_free(dir);
-    run_program_and_log_output(tmp, FALSE);
-    mr_free(tmp);
-}
 
 
@@ -2966 +3151 @@
  * @{
  */
-/**
- * Write the final ISO image.
- * @param bkpinfo The backup information structure. Used only
- * in the call to @c write_iso_and_go_on().
- * @return The number of errors encountered (0 for success)
- * @see write_iso_and_go_on
- * @see make_iso_fs
- * @bug The final ISO is written even if there are no files on it. In practice,
- * however, this occurs rarely.
- */
-int write_final_iso_if_necessary()
-{
-    /*@ int ***************************************************** */
-    int res;
-
-    /*@ buffers ************************************************** */
-    char *tmp = NULL;
-
-    assert(bkpinfo != NULL);
-    // I should really check if there are any slices or tarballs to be copied to CD-R(W)'s; the odds are approx. 1 in a million that there are no files here, so I'll just go ahead & make one more CD anyway
-
-    tmp = mr_center_string("Writing the final ISO", 80);
-    log_msg(2, tmp);
-    if (!g_text_mode) {
-        newtPushHelpLine(tmp);
-    }
-    mr_free(tmp);
-    res = write_iso_and_go_on(TRUE);
-    if (!g_text_mode) {
-        newtPopHelpLine();
-    }
-    log_msg(2, "Returning from writing final ISO (res=%d)", res);
-    return (res);
-}
-
-
-/**
- * Write an ISO image to <tt>[bkpinfo->isodir]/bkpinfo->prefix-[g_current_media_number].iso</tt>.
- * @param bkpinfo The backup information structure. Fields used:
- * - @c backup_media_type
- * - @c prefix
- * - @c isodir
- * - @c manual_cd_tray
- * - @c media_size
- * - @c netfs_remote_dir
- * - @c scratchdir
- * - @c verify_data
- *
- * @param last_cd If TRUE, this is the last CD to write; if FALSE, it's not.
- * @return The number of errors encountered (0 for success)
- * @see make_iso_fs
- */
-int write_iso_and_go_on(bool last_cd)
-{
-    /*@ pointers **************************************************** */
-    FILE *fout;
-
-    /*@ buffers ***************************************************** */
-    char *tmp = NULL;
-    char *tmp1 = NULL;
-    char *cdno_fname = NULL;
-    char *lastcd_fname = NULL;
-    char *isofile = NULL;
-    char *mds = NULL;
-
-    /*@ bool ******************************************************** */
-    bool that_one_was_ok;
-    bool orig_vfy_flag_val;
-
-    /*@ int *********************************************************** */
-    int res = 0;
-
-    assert(bkpinfo != NULL);
-    orig_vfy_flag_val = bkpinfo->verify_data;
-    if (bkpinfo->media_size <= 0) {
-        fatal_error("write_iso_and_go_on() - unknown media size");
-    }
-
-    mds = media_descriptor_string(bkpinfo->backup_media_type);
-    log_msg(1, "OK, time to make %s #%d", mds, g_current_media_number);
-    mr_free(mds);
-
-    /* label the ISO with its number */
-
-    mr_asprintf(cdno_fname, "%s/archives/THIS-CD-NUMBER", bkpinfo->scratchdir);
-    fout = fopen(cdno_fname, "w");
-    mr_free(cdno_fname);
-
-    fprintf(fout, "%d", g_current_media_number);
-    paranoid_fclose(fout);
-
-    mr_asprintf(tmp1, "cp -f %s/autorun %s/", g_mondo_home, bkpinfo->scratchdir);
-    if (run_program_and_log_output(tmp1, FALSE)) {
-        log_msg(2, "Warning - unable to copy autorun to scratchdir");
-    }
-    mr_free(tmp1);
-
-    /* last CD or not? Label accordingly */
-    mr_asprintf(lastcd_fname, "%s/archives/NOT-THE-LAST", bkpinfo->scratchdir);
-    if (last_cd) {
-        unlink(lastcd_fname);
-        log_msg(2,
-                "OK, you're telling me this is the last CD. Fair enough.");
-    } else {
-        fout = fopen(lastcd_fname, "w");
-        fprintf(fout,
-                "You're listening to 90.3 WPLN, Nashville Public Radio.\n");
-        paranoid_fclose(fout);
-    }
-    mr_free(lastcd_fname);
-
-    if (space_occupied_by_cd(bkpinfo->scratchdir) / 1024 > bkpinfo->media_size) {
-        log_to_screen("Warning! CD is too big. It occupies %ld KB, which is more than the %ld MB allowed.",(long) space_occupied_by_cd(bkpinfo->scratchdir),(long) bkpinfo->media_size);
-    }
-
-    if (bkpinfo->netfs_remote_dir != NULL) {
-        // NETFS
-        mr_asprintf(isofile, "%s/%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->netfs_remote_dir, bkpinfo->prefix, g_current_media_number);
-    } else {
-        // ISO
-        mr_asprintf(isofile, "%s/%s-%d.iso", bkpinfo->isodir, bkpinfo->prefix, g_current_media_number);
-    }
-    for (that_one_was_ok = FALSE; !that_one_was_ok;) {
-        if (bkpinfo->backup_media_type != usb) {
-            res = make_iso_fs(isofile);
-        } else {
-            res = make_usb_fs();
-        }
-        if (g_current_media_number == 1 && !res
-            && (bkpinfo->backup_media_type == cdr)) {
-            if ((tmp = find_optical_device())   == NULL) {  // make sure find_optical_device() finds, records CD-R's loc
-                log_msg(3, "*Sigh* Mike, I hate your computer.");
-                // if it can't be found then force pausing
-                bkpinfo->manual_cd_tray = TRUE;
-            } else {
-                log_msg(3, "Great. Found Mike's CD-ROM drive.");
-            }
-            mr_free(tmp);
-        }
-        if (bkpinfo->verify_data && !res) {
-            mds = media_descriptor_string(g_backup_media_type);
-            log_to_screen("Please reboot from the 1st %s in Compare Mode, as a precaution.", mds);
-            mr_free(mds);
-            if (chdir("/")) {
-                // FIXME
-            }
-            log_it("Before calling verification of image()");
-            if (bkpinfo->backup_media_type == usb) {
-                res += verify_usb_image();
-            } else {
-                res += verify_cd_image();
-            }
-            log_it("After calling verification of image()");
-        }
-        if (!res) {
-            that_one_was_ok = TRUE;
-        } else {
-            mds = media_descriptor_string(bkpinfo->backup_media_type);
-            mr_asprintf(tmp1, "Failed to create %s #%d. Retry?", mds, g_current_media_number);
-            mr_free(mds);
-            res = ask_me_yes_or_no(tmp1);
-            mr_free(tmp1);
-
-            if (!res) {
-                if (ask_me_yes_or_no("Abort the backup?")) {
-                    fatal_error("FAILED TO BACKUP");
-                } else {
-                    break;
-                }
-            } else {
-                log_msg(2, "Retrying, at user's request...");
-                res = 0;
-            }
-        }
-    }
-    mr_free(isofile);
-
-    g_current_media_number++;
-    wipe_archives(bkpinfo->scratchdir);
-    mr_asprintf(tmp1, "rm -Rf %s/images/*gz %s/images/*data*img", bkpinfo->scratchdir, bkpinfo->scratchdir);
-    if (system(tmp1)) {
-        log_msg(2, "Error occurred when I tried to delete the redundant IMGs and GZs");
-    }
-    mr_free(tmp1);
-
-    if (last_cd) {
-        log_msg(2, "This was your last media.");
-    } else {
-        log_msg(2, "Continuing to backup your data...");
-    }
-
-    bkpinfo->verify_data = orig_vfy_flag_val;
-    return (0);
-}
-
-/* @} - end of LLarchiveGroup */
-
-
 
 

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

@@ -24 +24 @@
 extern char *make_vn(char *file);
 extern int kick_vn(char *vn);
-extern char which_boot_loader(char *which_device);
+extern char which_boot_loader(const char *which_device);
 
 extern int interactively_obtain_media_parameters_from_user(bool);

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

@@ -1164 +1164 @@
         log_msg(3, "Mounting next media %d",cd_number_i_want);
         g_current_media_number = cd_number_i_want;
-        mount_media();
+        mount_media(MNT_CDROM);
 
         mds = media_descriptor_string(bkpinfo->backup_media_type);
@@ -1825 +1825 @@
 
 /**
- * Ask user for details of backup/restore information.
- * Called when @c mondoarchive doesn't get any parameters.
- * @param bkpinfo The backup information structure to fill out with the user's data.
- * @param archiving_to_media TRUE if archiving, FALSE if restoring.
- * @return 0, always.
- * @bug No point of `int' return value.
- * @ingroup archiveGroup
- */
-int interactively_obtain_media_parameters_from_user(bool archiving_to_media)
-// archiving_to_media is TRUE if I'm being called by mondoarchive
-// archiving_to_media is FALSE if I'm being called by mondorestore
-{
-    char *tmp = NULL;
-    char *sz = NULL;
-    char *tmpro = NULL;
-    char *tmp1 = NULL;
-    char *tmp2 = NULL;
-    char *mds = NULL;
-    char *oldtmp = NULL;
-    char *q = NULL;
-    char p[16*MAX_STR_LEN];
-    char *sz_size = NULL;
-    char *command = NULL;
-    char *compression_type = NULL;
-    char *comment = NULL;
-    int i;
-    FILE *fin;
-
-    malloc_string(tmp1);
-    assert(bkpinfo != NULL);
-    bkpinfo->nonbootable_backup = FALSE;
-
-    // Tape, CD, NETFS, ...?
-    srandom(getpid());
-    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));
-
-    /* Why asking to remove the media with tape ?
-    if (bkpinfo->backup_media_type == tape && bkpinfo->restore_data) {
-        popup_and_OK("Please remove media from drive(s)");
-    }
-    */
-    if (archiving_to_media) {
-        // TODO: Should be common ?
-        setup_tmpdir(NULL);
-        /*
-         * Set the scratchdir to reside on the partition with the most free space.
-         * Automatically excludes DOS, NTFS, SMB, and NFS filesystems.
-         */
-#ifdef __FreeBSD__
-        tmp = call_program_and_get_last_line_of_output("df -m -P -t nonfs,msdosfs,ntfs,ntfs-3g,vmhgfs,smbfs,smb,cifs,afs,gfs,ocfs,ocfs2,mvfs,nsspool,nssvol | grep -vE \"none|Filesystem\" | awk '{printf \"%s %s\\n\", $4, $6;}' | sort -nr | awk '{print $NF;}' | while read x ; do test -w $x && echo $x && break ; done");
-#else
-        tmp = call_program_and_get_last_line_of_output("df -m -P -x nfs -x nfs4 -x fuse.sshfs -x fuse -x vfat -x ntfs -x ntfs-3g -x vmhgfs -x smbfs -x smb -x cifs -x afs -x gfs -x ocfs -x ocfs2 -x mvfs -x nsspool -x nssvol -x iso9660 | grep -vE \"none|Filesystem|/dev/shm\" | awk '{printf \"%s %s\\n\", $4, $6;}' | sort -nr | awk '{print $NF;}' | while read x ; do test -w $x && echo $x && break ; done");
-#endif
-
-        if (tmp[0] != '/') {
-            mr_asprintf(sz, "%s", tmp);
-            mr_free(tmp);
-            mr_asprintf(tmp, "/%s", sz);
-            mr_free(sz);
-        }
-        setup_scratchdir(tmp);
-        mr_free(tmp);
-
-        if ((compression_type = which_compression_type()) == NULL) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-
-        bkpinfo->compression_level = (bkpinfo->backup_media_type == cdstream) ? 1 : 5;
-        if ((bkpinfo->compression_level = which_compression_level()) == -1) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        bkpinfo->cdrw_speed = (bkpinfo->backup_media_type == cdstream) ? 2 : 4;
-        bkpinfo->use_lzo = (bkpinfo->backup_media_type == cdstream) ? TRUE : FALSE;
-    }
-    mvaddstr_and_log_it(2, 0, " ");
-
-    // Find device's /dev (or SCSI) entry
-    switch (bkpinfo->backup_media_type) {
-    case cdr:
-    case dvd:
-    case usb:
-        /* Never try to eject a USB device */
-        if (bkpinfo->backup_media_type == usb) {
-            bkpinfo->please_dont_eject = TRUE;
-        }
-        mds = media_descriptor_string(bkpinfo->backup_media_type);
-        if (bkpinfo->backup_media_type != usb) {
-            if (ask_me_yes_or_no("Is your computer a laptop type (manual insert of MondoRescue media)?")) {
-                bkpinfo->manual_cd_tray = TRUE;
-            }
-        }
-
-        if (bkpinfo->media_device == NULL) {
-            bkpinfo->media_device = find_device(bkpinfo->backup_media_type);
-            if (bkpinfo->media_device != NULL) {
-                log_msg(1, "MondoRescue device found automatically for your %s is %s", mds, bkpinfo->media_device);
-            } else {
-                log_msg(1, "No MondoRescue device found yet for your %s", mds);
-            }
-        }
-
-        if (archiving_to_media) {
-            if (bkpinfo->backup_media_type == dvd) {
-                strcpy(tmp1, "1");
-                mr_asprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
-                log_msg(1, "Setting to DVD defaults");
-            } else {
-                strcpy(tmp1, "4");
-                mr_asprintf(sz_size, "%d", 650);
-                log_msg(1, "Setting to CD defaults");
-            }
-
-            mr_asprintf(comment, "What speed is your %s writer?", mds);
-            if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
-                if (!popup_and_get_string("Speed", comment, tmp1, 4)) {
-                    log_to_screen("User has chosen not to backup the machine");
-                    mr_free(comment);
-                    finish(1);
-                }
-            }
-            mr_free(comment);
-            bkpinfo->cdrw_speed = atoi(tmp1);   // if DVD then this shouldn't ever be used anyway :)
-
-            strcpy(tmp1, sz_size);
-            mr_asprintf(comment, "How much data (in Megabytes) will each %s store?", mds);
-            if (!popup_and_get_string("Size", comment, tmp1, 5)) {
-                log_to_screen("User has chosen not to backup the machine");
-                finish(1);
-            }
-            mr_asprintf(sz_size, "%s", tmp1);
-            bkpinfo->media_size = atoi(sz_size);
-
-            if (bkpinfo->media_size <= 0) {
-                log_to_screen("User has chosen not to backup the machine");
-                finish(1);
-            }
-        }
-        /* No break because we continue even for usb */
-    case cdstream:
-
-        // If media_device not found ask
-        if (bkpinfo->media_device == NULL) {
-            mr_asprintf(comment, "Please specify your Mondorescue %s media /dev entry", mds);
-            tmp2 = mr_popup_and_get_string("/dev entry?", comment, bkpinfo->media_device);
-            if (!tmp2) {
-                log_to_screen("User has chosen not to backup the machine");
-                finish(1);
-            } else {
-                mr_free(bkpinfo->media_device);
-                bkpinfo->media_device = tmp2;
-            }
-        }
-        log_msg(2, "%s device found at %s", mds, bkpinfo->media_device);
-        mr_asprintf(tmp, "MondoRescue thinks your %s media corresponds to %s. Is this correct?", mds, bkpinfo->media_device);
-        if (!ask_me_yes_or_no(tmp)) {
-            mr_free(bkpinfo->media_device);
-        }
-        mr_free(tmp);
-
-        if (bkpinfo->media_device == NULL) {
-            mr_asprintf(tmp, "Please then specify your Mondorescue %s media /dev entry", mds);
-            tmp2 = mr_popup_and_get_string("/dev entry?", tmp, bkpinfo->media_device);
-            mr_free(tmp);
-            if (tmp2 == NULL) {
-                log_to_screen("User has chosen not to backup the machine");
-                finish(1);
-            } else {
-                mr_free(bkpinfo->media_device);
-                bkpinfo->media_device = tmp2;
-            }
-        }
-        mr_free(mds);
-
-        if (bkpinfo->backup_media_type == cdstream) {
-            bkpinfo->media_size = 650;
-        }
-        break;
-    case udev:
-        if (!ask_me_yes_or_no
-            ("This option is for advanced users only. Are you sure?")) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-    case tape:
-
-        bkpinfo->media_device = find_tape_device();
-        if (bkpinfo->media_device != NULL) {
-            if ((fin = fopen(bkpinfo->media_device, "r"))) {
-                paranoid_fclose(fin);
-            } else {
-                if (does_file_exist("/tmp/mondorestore.cfg")) {
-                    read_cfg_var("/tmp/mondorestore.cfg", "media-dev", bkpinfo->media_device);
-                }
-            }
-        }
-        if (bkpinfo->media_device != NULL) {
-            mr_asprintf(tmp, "Mondorescue thinks your tape streamer at %s; is that correct?", bkpinfo->media_device);
-            if (!ask_me_yes_or_no(tmp)) {
-                mr_free(bkpinfo->media_device);
-            }
-            mr_free(tmp);
-        }
-        if (bkpinfo->media_device == NULL) {
-            tmp2 = mr_popup_and_get_string("Device name?", "What is the /dev entry of your tape streamer?", "");
-            if (tmp2 == NULL) {
-                log_to_screen("User has chosen not to backup the machine");
-                finish(1);
-            } else {
-                bkpinfo->media_device = tmp2;
-            }
-        }
-        mr_asprintf(tmp, "ls -l %s", bkpinfo->media_device);
-        if (run_program_and_log_output(tmp, FALSE)) {
-            log_to_screen("User has not specified a valid /dev entry");
-            finish(1);
-        }
-        mr_free(tmp);
-
-        mr_asprintf(sz_size,"%ld",bkpinfo->internal_tape_block_size);
-        tmp = mr_popup_and_get_string("Tape block size?", "What is the block size of your tape streamer?", sz_size);
-        if (tmp == NULL) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        bkpinfo->internal_tape_block_size = atol(tmp);
-        mr_free(sz_size);
-        mr_free(tmp);
-
-        // log the block-size
-        log_msg(0,"Tape block size= %ld", bkpinfo->internal_tape_block_size);
-
-        if (bkpinfo->internal_tape_block_size <= 0) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-
-        bkpinfo->media_size = 0;
-        log_msg(4, "media_size = %ld", bkpinfo->media_size);
-
-        if (archiving_to_media) {
-            bkpinfo->use_obdr = ask_me_yes_or_no("Do you want to activate OBDR support for your tapes ?");
-            if (bkpinfo->use_obdr) {
-                log_msg(4, "obdr mode = TRUE");
-            } else {
-                log_msg(4, "obdr mode = FALSE");
-            }
-        }
-        break;
-
-    case netfs:
-        /* Never try to eject a NETFS device */
-        bkpinfo->please_dont_eject = TRUE;
-        /*  Force NFS to be the protocol by default */
-        if (bkpinfo->netfs_proto == NULL) {
-            mr_asprintf(bkpinfo->netfs_proto, "nfs");
-        }
-
-        /* Initiate bkpinfo netfs_mount path from running environment if not already done */
-        if (bkpinfo->netfs_mount == NULL) {
-            bkpinfo->netfs_mount = call_program_and_get_last_line_of_output("mount | grep \":\" | cut -d' ' -f1 | head -n1");
-        }
-#ifdef __FreeBSD__
-        if (TRUE)
-#else
-        if (!bkpinfo->disaster_recovery)
-#endif
-        {
-            if (!popup_and_get_string("Network shared dir.", "Please enter path and directory where archives are stored remotely. (Mondo has taken a guess at the correct value. If it is incorrect, delete it and type the correct one.)", p,(MAX_STR_LEN / 4)-1)) {
-                log_to_screen("User has chosen not to backup the machine");
-                finish(1);
-            }
-            mr_free(bkpinfo->netfs_mount);
-            // check whether already mounted - we better remove
-            // surrounding spaces and trailing '/' for this
-            bkpinfo->netfs_mount = mr_strip_spaces(p);
-            if (bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] == '/')
-                bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] = '\0';
-            q = strchr(bkpinfo->netfs_mount, '@');
-            if (q != NULL) {
-                /* User found. Store the 2 values */
-                q++;
-                /* new netfs mount */
-                strcpy(tmp1,q);
-            } else {
-                strcpy(tmp1,bkpinfo->netfs_mount);
-            }
-            mr_asprintf(command, "mount | grep \"%s \" | cut -d' ' -f3", tmp1);
-            mr_free(bkpinfo->isodir);
-            bkpinfo->isodir = call_program_and_get_last_line_of_output(command);
-            mr_free(command);
-
-            if (!bkpinfo->restore_data) {
-                mr_asprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
-                mr_asprintf(comment, "How much data (in Megabytes) will each media store?");
-                strcpy(tmp1, sz_size);
-                mr_free(sz_size);
-                if (!popup_and_get_string("Size", comment, tmp1, 5)) {
-                    log_to_screen("User has chosen not to backup the machine");
-                    finish(1);
-                }
-                mr_free(comment);
-                mr_asprintf(sz_size, "%s", tmp1);
-            } else {
-                mr_asprintf(sz_size, "0");
-            }
-            bkpinfo->media_size = atoi(sz_size);
-            mr_free(sz_size);
-
-            if (bkpinfo->media_size < 0) {
-                log_to_screen("User has chosen not to backup the machine");
-                finish(1);
-            }
-        }
-        /*  TODO: Useless I think */
-        if (bkpinfo->disaster_recovery) {
-            mr_asprintf(command ,"umount %s/isodir 2> /dev/null", bkpinfo->tmpdir);
-            paranoid_system(command);
-            mr_free(command);
-
-        }
-        strcpy(tmp1, bkpinfo->netfs_proto);
-        if (!popup_and_get_string("Network protocol", "Which protocol should I use (nfs/sshfs/smbfs) ?",tmp1, MAX_STR_LEN-1)) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        mr_free(bkpinfo->netfs_proto);
-        mr_asprintf(bkpinfo->netfs_proto, "%s", tmp1);
-
-        strcpy(tmp1, bkpinfo->netfs_mount);
-        if (!popup_and_get_string("Network share", "Which remote share should I mount?", tmp1, MAX_STR_LEN-1)) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        mr_free(bkpinfo->netfs_mount);
-        mr_asprintf(bkpinfo->netfs_mount, "%s", tmp1);
-
-        if (bkpinfo->netfs_user) {
-            strcpy(tmp1, bkpinfo->netfs_user);
-        } else {
-            strcpy(tmp1, "");
-        }
-        if (!popup_and_get_string("Network user", "Which user should I use if any ?",tmp1, MAX_STR_LEN-1)) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        mr_free(bkpinfo->netfs_user);
-        if (strcmp(tmp1, "") != 0) {
-            mr_asprintf(bkpinfo->netfs_user, "%s", tmp1);
-        }
-
-        /* Initiate bkpinfo isodir path from running environment if mount already done */
-        log_msg(3, "Testing mount for %s", bkpinfo->netfs_mount);
-        if (is_this_device_mounted(bkpinfo->netfs_mount)) {
-            mr_free(bkpinfo->isodir);
-            bkpinfo->isodir = call_program_and_get_last_line_of_output("mount | grep \":\" | cut -d' ' -f3 | head -n1");
-        } else {
-            // Why netfsdir ?
-            mr_asprintf(bkpinfo->isodir, "%s/netfsdir", bkpinfo->tmpdir);
-            mr_asprintf(command, "mkdir -p %s", bkpinfo->isodir);
-            run_program_and_log_output(command, 5);
-            mr_free(command);
-
-            if (bkpinfo->restore_data) {
-                /*  mount the FS read-only in restore mode to avoid any erase of whatever */
-                mr_asprintf(tmpro, "-o ro");
-            } else {
-                mr_asprintf(tmpro, "");
-            }
-
-            /*  Build the mount string */
-            if (strstr(bkpinfo->netfs_proto, "smbfs")) {
-                mr_asprintf(tmp, "mount -t cifs %s %s %s",bkpinfo->netfs_mount, bkpinfo->isodir,tmpro);
-                if (bkpinfo->netfs_user) {
-                    mr_strcat(tmp, " -o user=%s", bkpinfo->netfs_user);
-                }
-            else {
-                if (strstr(bkpinfo->netfs_proto, "sshfs")) {
-                    mr_asprintf(tmp, "sshfs %s ",tmpro);
-                } else {
-                    mr_asprintf(tmp, "mount -t %s -o nolock %s ", bkpinfo->netfs_proto,tmpro);
-                }
-                if (bkpinfo->netfs_user) {
-                    mr_strcat(tmp, "%s@", bkpinfo->netfs_user);
-                }
-                mr_strcat(tmp, "%s %s", bkpinfo->netfs_mount, bkpinfo->isodir);
-            }
-            run_program_and_log_output(tmp, 3);
-            mr_free(tmp);
-
-            malloc_string(g_selfmounted_isodir);
-            strcpy(g_selfmounted_isodir, bkpinfo->isodir);
-            }
-        }
-        
-        log_msg(3, "Testing mount for %s", bkpinfo->netfs_mount);
-        if (!is_this_device_mounted(bkpinfo->netfs_mount)) {
-            popup_and_OK("Please mount that partition before you try to backup to or restore from it.");
-            finish(1);
-        }
-        if (bkpinfo->netfs_remote_dir == NULL) {
-            fatal_error("bkpinfo->netfs_remote_dir should not be NULL");
-        }
-        strcpy(tmp1, bkpinfo->netfs_remote_dir);
-        if (!popup_and_get_string ("Directory", "Which directory within that mountpoint?", tmp1, MAX_STR_LEN-1)) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        mr_free(bkpinfo->netfs_remote_dir);
-        // check whether writable - we better remove surrounding spaces for this
-        bkpinfo->netfs_remote_dir = mr_strip_spaces(tmp1);
-
-        tmp = mr_popup_and_get_string("Prefix.", "Please enter the prefix that will be prepended to your ISO filename.  Example: machine1 to obtain machine1-[1-9]*.iso files", bkpinfo->prefix);
-        if (tmp == NULL) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        mr_free(bkpinfo->prefix);
-        bkpinfo->prefix = tmp;
-        log_msg(3, "prefix set to %s", bkpinfo->prefix);
-        log_msg(3, "Just set netfs_remote_dir to %s", bkpinfo->netfs_remote_dir);
-        log_msg(3, "isodir is still %s", bkpinfo->isodir);
-        break;
-
-    case iso:
-        if (!bkpinfo->disaster_recovery) {
-            tmp = mr_popup_and_get_string("Storage dir.", "Please enter the full path name to the directory for your ISO images.  Example: /mnt/raid0_0", bkpinfo->isodir);
-            if (tmp == NULL) {
-                log_to_screen("User has chosen not to backup the machine");
-                finish(1);
-            } else {
-                mr_free(bkpinfo->isodir);
-                bkpinfo->isodir = tmp;
-            }
-            if (archiving_to_media) {
-                sprintf(tmp1, "%d", DEFAULT_DVD_DISK_SIZE); // 4.7 salesman's GB = 4.482 real GB = 4482 MB
-                if (!popup_and_get_string("ISO size.", "Please enter how big you want each ISO image to be (in megabytes). This should be less than or equal to the size of the CD-R[W]'s (700) or DVD's (4480) you plan to backup to.", tmp1, 16)) {
-                    log_to_screen("User has chosen not to backup the machine");
-                    finish(1);
-                }
-                bkpinfo->media_size = atoi(tmp1);
-            } else {
-                bkpinfo->media_size = 650;
-            }
-        }
-        tmp = mr_popup_and_get_string("Prefix.", "Please enter the prefix that will be prepended to your ISO filename.  Example: machine1 to obtain machine1-[1-9]*.iso files", bkpinfo->prefix);
-        if (tmp == NULL) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        mr_free(bkpinfo->prefix);
-        bkpinfo->prefix = tmp;
-        log_msg(3, "prefix set to %s", bkpinfo->prefix);
-        break;
-    default:
-        fatal_error("I, Mojo Jojo, shall defeat those pesky Powerpuff Girls!");
-    }
-
-    if (archiving_to_media) {
-        /*  Needs to be done before calling which_boot_loader */
-        bkpinfo->boot_type = mr_boot_type();
-        mr_free(bkpinfo->boot_device);
-#ifdef __FreeBSD__
-        bkpinfo->boot_device = call_program_and_get_last_line_of_output("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/\\([0-9]\\).*/\\1/'");
-#else
-        bkpinfo->boot_device = call_program_and_get_last_line_of_output("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/[0-9].*//'");
-#endif
-        i = which_boot_loader(bkpinfo->boot_device);
-        if (i == 'U')           // unknown
-        {
-
-#ifdef __FreeBSD__
-            if (!popup_and_get_string("Boot device", "What is your boot device? (e.g. /dev/ad0)", bkpinfo->boot_device,(MAX_STR_LEN / 4)-1)) {
-                log_to_screen("User has chosen not to backup the machine");
-                finish(1);
-            }
-            i = which_boot_loader(bkpinfo->boot_device);
-#else
-            strcpy(tmp1, bkpinfo->boot_device);
-            if (!popup_and_get_string("Boot device", "What is your boot device? (e.g. /dev/hda)", tmp1,(MAX_STR_LEN / 4)-1)) {
-                log_to_screen("User has chosen not to backup the machine");
-                finish(1);
-            }
-            mr_free(bkpinfo->boot_device);
-            mr_asprintf(bkpinfo->boot_device, "%s", tmp1);
-
-            if (does_string_exist_in_boot_block(bkpinfo->boot_device, "ELILO")) {
-                i = 'E';
-            } else
-                if (does_string_exist_in_boot_block(bkpinfo->boot_device, "LILO")) {
-                i = 'L';
-            } else
-                if (does_string_exist_in_boot_block(bkpinfo->boot_device, "GRUB")) {
-                i = 'G';
-            } else {
-                i = 'U';
-            }
-#endif
-            if (i == 'U') {
-                if (ask_me_yes_or_no("Unidentified boot loader. Shall I restore it byte-for-byte at restore time and hope for the best?")) {
-                    i = 'R';    // raw
-                } else {
-                    log_to_screen("I cannot find your boot loader. Please run mondoarchive with parameters.");
-                    finish(1);
-                }
-            }
-        }
-        bkpinfo->boot_loader = i;
-        /* TODO: Check consistency of boot type and boot loader */
-
-        if (bkpinfo->include_paths) {
-            strcpy(tmp1, bkpinfo->include_paths);
-            mr_free(bkpinfo->include_paths);
-        } else {
-            strcpy(tmp1, "/");
-        }
-        if (!popup_and_get_string("Backup paths", "Please enter paths (separated by '|') which you want me to backup. The default is '/' (i.e. everything).", tmp1, MAX_STR_LEN-1)) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        mr_asprintf(bkpinfo->include_paths, "%s", tmp1);
-
-        tmp = list_of_NETFS_mounts_only();
-        if (strlen(tmp) > 2) {
-            mr_strcat(bkpinfo->exclude_paths, "|%s",tmp);
-        }
-        mr_free(tmp);
-// NTFS 
-        tmp = call_program_and_get_last_line_of_output("mr-parted2fdisk -l 2>/dev/null | grep -i ntfs | awk '{ print $1};' | tr -s '\\n' ' ' | awk '{ print $0};'");
-        strncpy(tmp1, tmp,(MAX_STR_LEN / 4)-1);
-        mr_free(tmp);
-        if (strlen(tmp1) > 2) {
-            if (!popup_and_get_string("NTFS partitions", "Please enter/confirm the NTFS partitions you wish to backup as well.", tmp1,(MAX_STR_LEN / 4)-1)) {
-                log_to_screen("User has chosen not to backup the machine");
-                finish(1);
-            }
-            mr_asprintf(bkpinfo->image_devs, "%s", tmp1);
-        }
-
-        if (bkpinfo->exclude_paths != NULL ) {
-            mr_asprintf(p, "%s", bkpinfo->exclude_paths);
-        } else {
-            mr_asprintf(p, "%s", "");
-        }
-        tmp = mr_popup_and_get_string("Exclude paths", "Please enter paths which you do NOT want to backup. Separate them with '|'. NB: /tmp and /proc are always excluded. :-) Just hit 'Enter' if you want to do a full system backup.", p);
-        mr_free(p);
-        if (tmp == NULL) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        mr_free(bkpinfo->exclude_paths);
-        bkpinfo->exclude_paths = tmp;
-
-        mr_asprintf(oldtmp, "%s", bkpinfo->tmpdir);
-        if (bkpinfo->tmpdir != NULL ) {
-            mr_asprintf(p, "%s", bkpinfo->tmpdir);
-        } else {
-            mr_asprintf(p, "%s", "");
-        }
-        tmp = mr_popup_and_get_string("Temporary directory", "Please enter your temporary directory.", p);
-        mr_free(p);
-        if (tmp == NULL) {
-            mr_free(oldtmp);
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        /*  if modified to another path */
-        if (strcmp(tmp,oldtmp) != 0) {
-            setup_tmpdir(tmp);
-        }
-        mr_free(oldtmp);
-
-        mr_asprintf(oldtmp, "%s", bkpinfo->scratchdir);
-        if (bkpinfo->scratchdir != NULL ) {
-            mr_asprintf(p, "%s", bkpinfo->scratchdir);
-        } else {
-            mr_asprintf(p, "%s", "");
-        }
-        tmp = mr_popup_and_get_string("Scratch directory", "Please enter your scratch directory.", p);
-        mr_free(p);
-        if (tmp == NULL) {
-            mr_free(oldtmp);
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-        /*  if modified to another path */
-        if (strcmp(tmp,oldtmp) != 0) {
-            setup_scratchdir(tmp);
-        }
-        mr_free(oldtmp);
-
-        if (ask_me_yes_or_no("Do you want to backup extended attributes?")) {
-            mr_free(g_getfattr);
-            g_getfattr = find_home_of_exe("getfattr");
-            mr_free(g_getfacl);
-            g_getfacl = find_home_of_exe("getfacl");
-            log_it("Backup of extended attributes");
-        }
-// Interactive mode:
-#ifdef __IA64__
-        bkpinfo->make_cd_use_lilo = TRUE;
-#else
-        bkpinfo->make_cd_use_lilo = FALSE;
-#endif
-        bkpinfo->backup_data = TRUE;
-        if (strcmp(compression_type,"lzo") == 0) {
-            mr_asprintf(bkpinfo->zip_exe, "%s", "lzop");
-            mr_asprintf(bkpinfo->zip_suffix, "%s", "lzo");
-        } else if (strcmp(compression_type,"gzip") == 0) {
-            mr_asprintf(bkpinfo->zip_exe, "%s", "gzip");
-            mr_asprintf(bkpinfo->zip_suffix, "%s", "gz");
-        } else if (strcmp(compression_type,"lzma") == 0) {
-            mr_asprintf(bkpinfo->zip_exe, "%s", "xz");
-            mr_asprintf(bkpinfo->zip_suffix, "%s", "xz");
-        } else if (strcmp(compression_type,"bzip2") == 0) {
-            mr_asprintf(bkpinfo->zip_exe, "%s", "bzip2");
-            mr_asprintf(bkpinfo->zip_suffix, "%s", "bz2");
-        } else {
-            mr_free(bkpinfo->zip_exe);
-            mr_free(bkpinfo->zip_suffix);
-        }
-        mr_free(compression_type);
-
-#if __FreeBSD__ == 5
-        mr_asprintf(bkpinfo->kernel_path, "%s", "/boot/kernel/kernel");
-#elif __FreeBSD__ == 4
-        mr_asprintf(bkpinfo->kernel_path, "%s", "/kernel");
-#elif linux
-        if (figure_out_kernel_path_interactively_if_necessary(bkpinfo->kernel_path)) {
-            fatal_error("Kernel not found. Please specify manually with the '-k' switch.");
-        }
-#else
-#error "I don't know about this system!"
-#endif
-
-
-        bkpinfo->verify_data =
-            ask_me_yes_or_no
-            ("Will you want to verify your backups after Mondo has created them?");
-
-        if (!ask_me_yes_or_no
-            ("Are you sure you want to proceed? Hit 'no' to abort.")) {
-            log_to_screen("User has chosen not to backup the machine");
-            finish(1);
-        }
-    } else {
-        bkpinfo->restore_data = TRUE;   // probably...
-    }
-
-    if (bkpinfo->backup_media_type == iso
-        || bkpinfo->backup_media_type == netfs) {
-        g_ISO_restore_mode = TRUE;
-    }
-#ifdef __FreeSD__
-// skip
-#else
-    if (bkpinfo->backup_media_type == netfs) {
-        log_msg(3, "I think the Remote mount is mounted at %s", bkpinfo->isodir);
-    }
-    log_it("isodir = %s", bkpinfo->isodir);
-    if (bkpinfo->netfs_mount) {
-        log_it("netfs_mount = '%s'", bkpinfo->netfs_mount);
-    }
-    if (bkpinfo->netfs_user) {
-        log_it("netfs_user = '%s'", bkpinfo->netfs_user);
-    }
-    if (bkpinfo->netfs_proto) {
-        log_it("netfs_proto = '%s'", bkpinfo->netfs_proto);
-    }
-#endif
-
-    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));
-    if (bkpinfo->prefix != NULL) {
-        log_it("prefix = %s", bkpinfo->prefix);
-    }
-    log_it("compression = %ld", bkpinfo->compression_level);
-    log_it("exclude_path = %s", bkpinfo->exclude_paths);
-    if (bkpinfo->include_paths) {
-        log_it("include_path = %s", bkpinfo->include_paths);
-    }
-
-    /* Handle devices passed in bkpinfo and print result */
-    /*  the mr_make_devlist_from_pathlist function appends */
-    /*  to the *_paths variables so copy before */
-    mr_make_devlist_from_pathlist(bkpinfo->exclude_paths, 'E');
-    mr_make_devlist_from_pathlist(bkpinfo->include_paths, 'I');
-
-    log_it("scratchdir = '%s'", bkpinfo->scratchdir);
-    log_it("tmpdir = '%s'", bkpinfo->tmpdir);
-    if (bkpinfo->image_devs) {
-        log_it("image_devs = '%s'", bkpinfo->image_devs);
-    }
-    log_it("boot_device = '%s' (loader=%c)", bkpinfo->boot_device, bkpinfo->boot_loader);
-    if (bkpinfo->media_size < 0) {
-        if (archiving_to_media) {
-            fatal_error("Media size is less than zero.");
-        } else {
-            log_msg(2, "Warning - media size is less than zero.");
-            bkpinfo->media_size = 0;
-        }
-    }
-    paranoid_free(sz_size);
-    paranoid_free(tmp1);
-    return (0);
-}
-
-
-/**
- * Get a |-separated list of NETFS mounts.
- * @return The list created.
- * @note The return value points to allocated string that needs to be freed by
- * caller
- * @bug Even though we only want the mounts, the devices are still checked.
- */
-char *list_of_NETFS_mounts_only(void)
-{
-    char *exclude_these_directories = NULL;
-
-    exclude_these_directories = call_program_and_get_last_line_of_output("mount -t coda,ncpfs,fuse.sshfs,nfs,nfs4,vmhgfs,smbfs,cifs,afs,gfs,ocfs,ocfs2,mvfs,nsspool,nssvol,fuse.boostfs | tr -s '\t' ' ' | cut -d' ' -f3 | tr -s '\n' '|' | awk '{print $0;}'");
-    log_msg(9,"list_of_NETFS_mounts_only returns %s",exclude_these_directories);
-    return(exclude_these_directories);
-}
-
-/* @} - end of utilityGroup */
-
-
-
-
-
-/**
- * Create a randomly-named FIFO. The format is @p stub "." [random] [random] where
- * [random] is a random number between 1 and 32767.
- * @param store_name_here Where to store the new filename.
- * @param stub A random number will be appended to this to make the FIFO's name.
- * @ingroup deviceGroup
- */
-void make_fifo(char *store_name_here, char *stub)
-{
-    char *tmp = NULL;
-
-    assert_string_is_neither_NULL_nor_zerolength(stub);
-
-    sprintf(store_name_here, "%s%d%d", stub, (int) (random() % 32768),
-            (int) (random() % 32768));
-    make_hole_for_file(store_name_here);
-    mkfifo(store_name_here, S_IRWXU | S_IRWXG);
-    mr_asprintf(tmp, "chmod 770 %s", store_name_here);
-    paranoid_system(tmp);
-    mr_free(tmp);
-}
-
-
-
-/**
- * @addtogroup deviceGroup
- * @{
- */
-/**
- * If we can read @p dev, set @p output to it.
- * If @p dev cannot be read, set @p output to "".
- * @param dev The device to check for.
- * @param output Set to @p dev if @p dev exists, "" otherwise.
- * @return TRUE if @p dev exists, FALSE if it doesn't.
- */
-bool set_dev_to_this_if_rx_OK(char *output, char *dev)
-{
-    char *command = NULL;
-    bool ret=FALSE;
-
-    if (!dev || dev[0] == '\0') {
-        output[0] = '\0';
-        return(ret);
-    }
-//  assert_string_is_neither_NULL_nor_zerolength(dev);
-    if (!bkpinfo->please_dont_eject) {
-        log_msg(10, "Injecting %s", dev);
-        inject_device(dev);
-    }
-    if (!does_file_exist(dev)) {
-        log_msg(10, "%s doesn't exist. Returning FALSE.", dev);
-        return(ret);
-    }
-    mr_asprintf(command, "dd bs=%ld count=1 if=%s of=/dev/null &> /dev/null", 512L, dev);
-    if (!run_program_and_log_output(command, FALSE) && !run_program_and_log_output(command, FALSE)) {
-        strcpy(output, dev);
-        log_msg(4, "Found it - %s", dev);
-        ret = TRUE;
-    } else {
-        output[0] = '\0';
-        log_msg(4, "It's not %s", dev);
-    }
-    mr_free(command);
-    return(ret);
-}
-
-
-
-
-
-/**
- * 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(bkpinfo->media_device, MNT_CDROM)) {
-        mount_media(MNT_CDROM);
-    }
-
-    cd_number = atoi(last_line_of_file(MNT_CDROM "/archives/THIS-CD-NUMBER"));
-    return(cd_number);
-}
-
-
-/**
- * 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() {
-
-/*@ 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);
-}
-
-
-/**
  * Find out which boot loader is in use.
  * @param which_device Device to look for the boot loader on.
@@ -2713 +1831 @@
  */
 #ifdef __FreeBSD__
-char which_boot_loader(char *which_device)
+char which_boot_loader(const char *which_device)
 {
     int count_lilos = 0;
@@ -2757 +1875 @@
 #else
 
-char which_boot_loader(char *which_device)
+char which_boot_loader(const char *which_device)
 {
     /*@ buffer ***************************************************** */
@@ -2879 +1997 @@
 }
 #endif
+
+
+/**
+ * Ask user for details of backup/restore information.
+ * Called when @c mondoarchive doesn't get any parameters.
+ * @param bkpinfo The backup information structure to fill out with the user's data.
+ * @param archiving_to_media TRUE if archiving, FALSE if restoring.
+ * @return 0, always.
+ * @bug No point of `int' return value.
+ * @ingroup archiveGroup
+ */
+int interactively_obtain_media_parameters_from_user(bool archiving_to_media)
+// archiving_to_media is TRUE if I'm being called by mondoarchive
+// archiving_to_media is FALSE if I'm being called by mondorestore
+{
+    char *tmp = NULL;
+    char *sz = NULL;
+    char *tmpro = NULL;
+    char *tmp1 = NULL;
+    char *tmp2 = NULL;
+    char *mds = NULL;
+    char *oldtmp = NULL;
+    char *q = NULL;
+    char p[16*MAX_STR_LEN];
+    char *sz_size = NULL;
+    char *command = NULL;
+    char *compression_type = NULL;
+    char *comment = NULL;
+    char i = '\0';
+    FILE *fin;
+
+    malloc_string(tmp1);
+    assert(bkpinfo != NULL);
+    bkpinfo->nonbootable_backup = FALSE;
+
+    // Tape, CD, NETFS, ...?
+    srandom(getpid());
+    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));
+
+    /* Why asking to remove the media with tape ?
+    if (bkpinfo->backup_media_type == tape && bkpinfo->restore_data) {
+        popup_and_OK("Please remove media from drive(s)");
+    }
+    */
+    if (archiving_to_media) {
+        // TODO: Should be common ?
+        setup_tmpdir(NULL);
+        /*
+         * Set the scratchdir to reside on the partition with the most free space.
+         * Automatically excludes DOS, NTFS, SMB, and NFS filesystems.
+         */
+#ifdef __FreeBSD__
+        tmp = call_program_and_get_last_line_of_output("df -m -P -t nonfs,msdosfs,ntfs,ntfs-3g,vmhgfs,smbfs,smb,cifs,afs,gfs,ocfs,ocfs2,mvfs,nsspool,nssvol | grep -vE \"none|Filesystem\" | awk '{printf \"%s %s\\n\", $4, $6;}' | sort -nr | awk '{print $NF;}' | while read x ; do test -w $x && echo $x && break ; done");
+#else
+        tmp = call_program_and_get_last_line_of_output("df -m -P -x nfs -x nfs4 -x fuse.sshfs -x fuse -x vfat -x ntfs -x ntfs-3g -x vmhgfs -x smbfs -x smb -x cifs -x afs -x gfs -x ocfs -x ocfs2 -x mvfs -x nsspool -x nssvol -x iso9660 | grep -vE \"none|Filesystem|/dev/shm\" | awk '{printf \"%s %s\\n\", $4, $6;}' | sort -nr | awk '{print $NF;}' | while read x ; do test -w $x && echo $x && break ; done");
+#endif
+
+        if (tmp[0] != '/') {
+            mr_asprintf(sz, "%s", tmp);
+            mr_free(tmp);
+            mr_asprintf(tmp, "/%s", sz);
+            mr_free(sz);
+        }
+        setup_scratchdir(tmp);
+        mr_free(tmp);
+
+        if ((compression_type = which_compression_type()) == NULL) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+
+        bkpinfo->compression_level = (bkpinfo->backup_media_type == cdstream) ? 1 : 5;
+        if ((bkpinfo->compression_level = which_compression_level()) == -1) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        bkpinfo->cdrw_speed = (bkpinfo->backup_media_type == cdstream) ? 2 : 4;
+        bkpinfo->use_lzo = (bkpinfo->backup_media_type == cdstream) ? TRUE : FALSE;
+    }
+    mvaddstr_and_log_it(2, 0, " ");
+
+    // Find device's /dev (or SCSI) entry
+    switch (bkpinfo->backup_media_type) {
+    case cdr:
+    case dvd:
+    case usb:
+        /* Never try to eject a USB device */
+        if (bkpinfo->backup_media_type == usb) {
+            bkpinfo->please_dont_eject = TRUE;
+        }
+        mds = media_descriptor_string(bkpinfo->backup_media_type);
+        if (bkpinfo->backup_media_type != usb) {
+            if (ask_me_yes_or_no("Is your computer a laptop type (manual insert of MondoRescue media)?")) {
+                bkpinfo->manual_cd_tray = TRUE;
+            }
+        }
+
+        if (bkpinfo->media_device == NULL) {
+            bkpinfo->media_device = find_device(bkpinfo->backup_media_type);
+            if (bkpinfo->media_device != NULL) {
+                log_msg(1, "MondoRescue device found automatically for your %s is %s", mds, bkpinfo->media_device);
+            } else {
+                log_msg(1, "No MondoRescue device found yet for your %s", mds);
+            }
+        }
+
+        if (archiving_to_media) {
+            if (bkpinfo->backup_media_type == dvd) {
+                strcpy(tmp1, "1");
+                mr_asprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
+                log_msg(1, "Setting to DVD defaults");
+            } else {
+                strcpy(tmp1, "4");
+                mr_asprintf(sz_size, "%d", 650);
+                log_msg(1, "Setting to CD defaults");
+            }
+
+            mr_asprintf(comment, "What speed is your %s writer?", mds);
+            if ((bkpinfo->backup_media_type != dvd) && (bkpinfo->backup_media_type != usb)) {
+                if (!popup_and_get_string("Speed", comment, tmp1, 4)) {
+                    log_to_screen("User has chosen not to backup the machine");
+                    mr_free(comment);
+                    finish(1);
+                }
+            }
+            mr_free(comment);
+            bkpinfo->cdrw_speed = atoi(tmp1);   // if DVD then this shouldn't ever be used anyway :)
+
+            strcpy(tmp1, sz_size);
+            mr_asprintf(comment, "How much data (in Megabytes) will each %s store?", mds);
+            if (!popup_and_get_string("Size", comment, tmp1, 5)) {
+                log_to_screen("User has chosen not to backup the machine");
+                finish(1);
+            }
+            mr_asprintf(sz_size, "%s", tmp1);
+            bkpinfo->media_size = atoi(sz_size);
+
+            if (bkpinfo->media_size <= 0) {
+                log_to_screen("User has chosen not to backup the machine");
+                finish(1);
+            }
+        }
+        /* No break because we continue even for usb */
+    case cdstream:
+
+        // If media_device not found ask
+        if (bkpinfo->media_device == NULL) {
+            mr_asprintf(comment, "Please specify your Mondorescue %s media /dev entry", mds);
+            tmp2 = mr_popup_and_get_string("/dev entry?", comment, bkpinfo->media_device);
+            if (!tmp2) {
+                log_to_screen("User has chosen not to backup the machine");
+                finish(1);
+            } else {
+                mr_free(bkpinfo->media_device);
+                bkpinfo->media_device = tmp2;
+            }
+        }
+        log_msg(2, "%s device found at %s", mds, bkpinfo->media_device);
+        mr_asprintf(tmp, "MondoRescue thinks your %s media corresponds to %s. Is this correct?", mds, bkpinfo->media_device);
+        if (!ask_me_yes_or_no(tmp)) {
+            mr_free(bkpinfo->media_device);
+        }
+        mr_free(tmp);
+
+        if (bkpinfo->media_device == NULL) {
+            mr_asprintf(tmp, "Please then specify your Mondorescue %s media /dev entry", mds);
+            tmp2 = mr_popup_and_get_string("/dev entry?", tmp, bkpinfo->media_device);
+            mr_free(tmp);
+            if (tmp2 == NULL) {
+                log_to_screen("User has chosen not to backup the machine");
+                finish(1);
+            } else {
+                mr_free(bkpinfo->media_device);
+                bkpinfo->media_device = tmp2;
+            }
+        }
+        mr_free(mds);
+
+        if (bkpinfo->backup_media_type == cdstream) {
+            bkpinfo->media_size = 650;
+        }
+        break;
+    case udev:
+        if (!ask_me_yes_or_no
+            ("This option is for advanced users only. Are you sure?")) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+    case tape:
+
+        bkpinfo->media_device = find_tape_device();
+        if (bkpinfo->media_device != NULL) {
+            if ((fin = fopen(bkpinfo->media_device, "r"))) {
+                paranoid_fclose(fin);
+            } else {
+                if (does_file_exist("/tmp/mondorestore.cfg")) {
+                    read_cfg_var("/tmp/mondorestore.cfg", "media-dev", bkpinfo->media_device);
+                }
+            }
+        }
+        if (bkpinfo->media_device != NULL) {
+            mr_asprintf(tmp, "Mondorescue thinks your tape streamer at %s; is that correct?", bkpinfo->media_device);
+            if (!ask_me_yes_or_no(tmp)) {
+                mr_free(bkpinfo->media_device);
+            }
+            mr_free(tmp);
+        }
+        if (bkpinfo->media_device == NULL) {
+            tmp2 = mr_popup_and_get_string("Device name?", "What is the /dev entry of your tape streamer?", "");
+            if (tmp2 == NULL) {
+                log_to_screen("User has chosen not to backup the machine");
+                finish(1);
+            } else {
+                bkpinfo->media_device = tmp2;
+            }
+        }
+        mr_asprintf(tmp, "ls -l %s", bkpinfo->media_device);
+        if (run_program_and_log_output(tmp, FALSE)) {
+            log_to_screen("User has not specified a valid /dev entry");
+            finish(1);
+        }
+        mr_free(tmp);
+
+        mr_asprintf(sz_size,"%ld",bkpinfo->internal_tape_block_size);
+        tmp = mr_popup_and_get_string("Tape block size?", "What is the block size of your tape streamer?", sz_size);
+        if (tmp == NULL) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        bkpinfo->internal_tape_block_size = atol(tmp);
+        mr_free(sz_size);
+        mr_free(tmp);
+
+        // log the block-size
+        log_msg(0,"Tape block size= %ld", bkpinfo->internal_tape_block_size);
+
+        if (bkpinfo->internal_tape_block_size <= 0) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+
+        bkpinfo->media_size = 0;
+        log_msg(4, "media_size = %ld", bkpinfo->media_size);
+
+        if (archiving_to_media) {
+            bkpinfo->use_obdr = ask_me_yes_or_no("Do you want to activate OBDR support for your tapes ?");
+            if (bkpinfo->use_obdr) {
+                log_msg(4, "obdr mode = TRUE");
+            } else {
+                log_msg(4, "obdr mode = FALSE");
+            }
+        }
+        break;
+
+    case netfs:
+        /* Never try to eject a NETFS device */
+        bkpinfo->please_dont_eject = TRUE;
+        /*  Force NFS to be the protocol by default */
+        if (bkpinfo->netfs_proto == NULL) {
+            mr_asprintf(bkpinfo->netfs_proto, "nfs");
+        }
+
+        /* Initiate bkpinfo netfs_mount path from running environment if not already done */
+        if (bkpinfo->netfs_mount == NULL) {
+            bkpinfo->netfs_mount = call_program_and_get_last_line_of_output("mount | grep \":\" | cut -d' ' -f1 | head -n1");
+        }
+#ifdef __FreeBSD__
+        if (TRUE)
+#else
+        if (!bkpinfo->disaster_recovery)
+#endif
+        {
+            if (!popup_and_get_string("Network shared dir.", "Please enter path and directory where archives are stored remotely. (Mondo has taken a guess at the correct value. If it is incorrect, delete it and type the correct one.)", p,(MAX_STR_LEN / 4)-1)) {
+                log_to_screen("User has chosen not to backup the machine");
+                finish(1);
+            }
+            mr_free(bkpinfo->netfs_mount);
+            // check whether already mounted - we better remove
+            // surrounding spaces and trailing '/' for this
+            bkpinfo->netfs_mount = mr_strip_spaces(p);
+            if (bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] == '/')
+                bkpinfo->netfs_mount[strlen(bkpinfo->netfs_mount) - 1] = '\0';
+            q = strchr(bkpinfo->netfs_mount, '@');
+            if (q != NULL) {
+                /* User found. Store the 2 values */
+                q++;
+                /* new netfs mount */
+                strcpy(tmp1,q);
+            } else {
+                strcpy(tmp1,bkpinfo->netfs_mount);
+            }
+            mr_asprintf(command, "mount | grep \"%s \" | cut -d' ' -f3", tmp1);
+            mr_free(bkpinfo->isodir);
+            bkpinfo->isodir = call_program_and_get_last_line_of_output(command);
+            mr_free(command);
+
+            if (!bkpinfo->restore_data) {
+                mr_asprintf(sz_size, "%d", DEFAULT_DVD_DISK_SIZE);  // 4.7 salesman's GB = 4.482 real GB = 4482 MB
+                mr_asprintf(comment, "How much data (in Megabytes) will each media store?");
+                strcpy(tmp1, sz_size);
+                mr_free(sz_size);
+                if (!popup_and_get_string("Size", comment, tmp1, 5)) {
+                    log_to_screen("User has chosen not to backup the machine");
+                    finish(1);
+                }
+                mr_free(comment);
+                mr_asprintf(sz_size, "%s", tmp1);
+            } else {
+                mr_asprintf(sz_size, "0");
+            }
+            bkpinfo->media_size = atoi(sz_size);
+            mr_free(sz_size);
+
+            if (bkpinfo->media_size < 0) {
+                log_to_screen("User has chosen not to backup the machine");
+                finish(1);
+            }
+        }
+        /*  TODO: Useless I think */
+        if (bkpinfo->disaster_recovery) {
+            mr_asprintf(command ,"umount %s/isodir 2> /dev/null", bkpinfo->tmpdir);
+            paranoid_system(command);
+            mr_free(command);
+
+        }
+        strcpy(tmp1, bkpinfo->netfs_proto);
+        if (!popup_and_get_string("Network protocol", "Which protocol should I use (nfs/sshfs/smbfs) ?",tmp1, MAX_STR_LEN-1)) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        mr_free(bkpinfo->netfs_proto);
+        mr_asprintf(bkpinfo->netfs_proto, "%s", tmp1);
+
+        strcpy(tmp1, bkpinfo->netfs_mount);
+        if (!popup_and_get_string("Network share", "Which remote share should I mount?", tmp1, MAX_STR_LEN-1)) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        mr_free(bkpinfo->netfs_mount);
+        mr_asprintf(bkpinfo->netfs_mount, "%s", tmp1);
+
+        if (bkpinfo->netfs_user) {
+            strcpy(tmp1, bkpinfo->netfs_user);
+        } else {
+            strcpy(tmp1, "");
+        }
+        if (!popup_and_get_string("Network user", "Which user should I use if any ?",tmp1, MAX_STR_LEN-1)) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        mr_free(bkpinfo->netfs_user);
+        if (strcmp(tmp1, "") != 0) {
+            mr_asprintf(bkpinfo->netfs_user, "%s", tmp1);
+        }
+
+        /* Initiate bkpinfo isodir path from running environment if mount already done */
+        log_msg(3, "Testing mount for %s", bkpinfo->netfs_mount);
+        if (is_this_device_mounted(bkpinfo->netfs_mount)) {
+            mr_free(bkpinfo->isodir);
+            bkpinfo->isodir = call_program_and_get_last_line_of_output("mount | grep \":\" | cut -d' ' -f3 | head -n1");
+        } else {
+            // Why netfsdir ?
+            mr_asprintf(bkpinfo->isodir, "%s/netfsdir", bkpinfo->tmpdir);
+            mr_asprintf(command, "mkdir -p %s", bkpinfo->isodir);
+            run_program_and_log_output(command, 5);
+            mr_free(command);
+
+            if (bkpinfo->restore_data) {
+                /*  mount the FS read-only in restore mode to avoid any erase of whatever */
+                mr_asprintf(tmpro, "-o ro");
+            } else {
+                mr_asprintf(tmpro, "");
+            }
+
+            /*  Build the mount string */
+            if (strstr(bkpinfo->netfs_proto, "smbfs")) {
+                mr_asprintf(tmp, "mount -t cifs %s %s %s",bkpinfo->netfs_mount, bkpinfo->isodir,tmpro);
+                if (bkpinfo->netfs_user) {
+                    mr_strcat(tmp, " -o user=%s", bkpinfo->netfs_user);
+                }
+            else {
+                if (strstr(bkpinfo->netfs_proto, "sshfs")) {
+                    mr_asprintf(tmp, "sshfs %s ",tmpro);
+                } else {
+                    mr_asprintf(tmp, "mount -t %s -o nolock %s ", bkpinfo->netfs_proto,tmpro);
+                }
+                if (bkpinfo->netfs_user) {
+                    mr_strcat(tmp, "%s@", bkpinfo->netfs_user);
+                }
+                mr_strcat(tmp, "%s %s", bkpinfo->netfs_mount, bkpinfo->isodir);
+            }
+            run_program_and_log_output(tmp, 3);
+            mr_free(tmp);
+
+            malloc_string(g_selfmounted_isodir);
+            strcpy(g_selfmounted_isodir, bkpinfo->isodir);
+            }
+        }
+        
+        log_msg(3, "Testing mount for %s", bkpinfo->netfs_mount);
+        if (!is_this_device_mounted(bkpinfo->netfs_mount)) {
+            popup_and_OK("Please mount that partition before you try to backup to or restore from it.");
+            finish(1);
+        }
+        if (bkpinfo->netfs_remote_dir == NULL) {
+            fatal_error("bkpinfo->netfs_remote_dir should not be NULL");
+        }
+        strcpy(tmp1, bkpinfo->netfs_remote_dir);
+        if (!popup_and_get_string ("Directory", "Which directory within that mountpoint?", tmp1, MAX_STR_LEN-1)) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        mr_free(bkpinfo->netfs_remote_dir);
+        // check whether writable - we better remove surrounding spaces for this
+        bkpinfo->netfs_remote_dir = mr_strip_spaces(tmp1);
+
+        tmp = mr_popup_and_get_string("Prefix.", "Please enter the prefix that will be prepended to your ISO filename.  Example: machine1 to obtain machine1-[1-9]*.iso files", bkpinfo->prefix);
+        if (tmp == NULL) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        mr_free(bkpinfo->prefix);
+        bkpinfo->prefix = tmp;
+        log_msg(3, "prefix set to %s", bkpinfo->prefix);
+        log_msg(3, "Just set netfs_remote_dir to %s", bkpinfo->netfs_remote_dir);
+        log_msg(3, "isodir is still %s", bkpinfo->isodir);
+        break;
+
+    case iso:
+        if (!bkpinfo->disaster_recovery) {
+            tmp = mr_popup_and_get_string("Storage dir.", "Please enter the full path name to the directory for your ISO images.  Example: /mnt/raid0_0", bkpinfo->isodir);
+            if (tmp == NULL) {
+                log_to_screen("User has chosen not to backup the machine");
+                finish(1);
+            } else {
+                mr_free(bkpinfo->isodir);
+                bkpinfo->isodir = tmp;
+            }
+            if (archiving_to_media) {
+                sprintf(tmp1, "%d", DEFAULT_DVD_DISK_SIZE); // 4.7 salesman's GB = 4.482 real GB = 4482 MB
+                if (!popup_and_get_string("ISO size.", "Please enter how big you want each ISO image to be (in megabytes). This should be less than or equal to the size of the CD-R[W]'s (700) or DVD's (4480) you plan to backup to.", tmp1, 16)) {
+                    log_to_screen("User has chosen not to backup the machine");
+                    finish(1);
+                }
+                bkpinfo->media_size = atoi(tmp1);
+            } else {
+                bkpinfo->media_size = 650;
+            }
+        }
+        tmp = mr_popup_and_get_string("Prefix.", "Please enter the prefix that will be prepended to your ISO filename.  Example: machine1 to obtain machine1-[1-9]*.iso files", bkpinfo->prefix);
+        if (tmp == NULL) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        mr_free(bkpinfo->prefix);
+        bkpinfo->prefix = tmp;
+        log_msg(3, "prefix set to %s", bkpinfo->prefix);
+        break;
+    default:
+        fatal_error("I, Mojo Jojo, shall defeat those pesky Powerpuff Girls!");
+    }
+
+    if (archiving_to_media) {
+        /*  Needs to be done before calling which_boot_loader */
+        bkpinfo->boot_type = mr_boot_type();
+        mr_free(bkpinfo->boot_device);
+#ifdef __FreeBSD__
+        bkpinfo->boot_device = call_program_and_get_last_line_of_output("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/\\([0-9]\\).*/\\1/'");
+#else
+        bkpinfo->boot_device = call_program_and_get_last_line_of_output("mount | grep ' / ' | head -1 | cut -d' ' -f1 | sed 's/[0-9].*//'");
+#endif
+        i = which_boot_loader(bkpinfo->boot_device);
+        if (i == 'U')           // unknown
+        {
+
+#ifdef __FreeBSD__
+            if (!popup_and_get_string("Boot device", "What is your boot device? (e.g. /dev/ad0)", bkpinfo->boot_device,(MAX_STR_LEN / 4)-1)) {
+                log_to_screen("User has chosen not to backup the machine");
+                finish(1);
+            }
+            i = which_boot_loader(bkpinfo->boot_device);
+#else
+            strcpy(tmp1, bkpinfo->boot_device);
+            if (!popup_and_get_string("Boot device", "What is your boot device? (e.g. /dev/hda)", tmp1,(MAX_STR_LEN / 4)-1)) {
+                log_to_screen("User has chosen not to backup the machine");
+                finish(1);
+            }
+            mr_free(bkpinfo->boot_device);
+            mr_asprintf(bkpinfo->boot_device, "%s", tmp1);
+
+            if (does_string_exist_in_boot_block(bkpinfo->boot_device, "ELILO")) {
+                i = 'E';
+            } else
+                if (does_string_exist_in_boot_block(bkpinfo->boot_device, "LILO")) {
+                i = 'L';
+            } else
+                if (does_string_exist_in_boot_block(bkpinfo->boot_device, "GRUB")) {
+                i = 'G';
+            } else {
+                i = 'U';
+            }
+#endif
+            if (i == 'U') {
+                if (ask_me_yes_or_no("Unidentified boot loader. Shall I restore it byte-for-byte at restore time and hope for the best?")) {
+                    i = 'R';    // raw
+                } else {
+                    log_to_screen("I cannot find your boot loader. Please run mondoarchive with parameters.");
+                    finish(1);
+                }
+            }
+        }
+        bkpinfo->boot_loader = i;
+        /* TODO: Check consistency of boot type and boot loader */
+
+        if (bkpinfo->include_paths) {
+            strcpy(tmp1, bkpinfo->include_paths);
+            mr_free(bkpinfo->include_paths);
+        } else {
+            strcpy(tmp1, "/");
+        }
+        if (!popup_and_get_string("Backup paths", "Please enter paths (separated by '|') which you want me to backup. The default is '/' (i.e. everything).", tmp1, MAX_STR_LEN-1)) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        mr_asprintf(bkpinfo->include_paths, "%s", tmp1);
+
+        tmp = list_of_NETFS_mounts_only();
+        if (strlen(tmp) > 2) {
+            mr_strcat(bkpinfo->exclude_paths, "|%s",tmp);
+        }
+        mr_free(tmp);
+// NTFS 
+        tmp = call_program_and_get_last_line_of_output("mr-parted2fdisk -l 2>/dev/null | grep -i ntfs | awk '{ print $1};' | tr -s '\\n' ' ' | awk '{ print $0};'");
+        strncpy(tmp1, tmp,(MAX_STR_LEN / 4)-1);
+        mr_free(tmp);
+        if (strlen(tmp1) > 2) {
+            if (!popup_and_get_string("NTFS partitions", "Please enter/confirm the NTFS partitions you wish to backup as well.", tmp1,(MAX_STR_LEN / 4)-1)) {
+                log_to_screen("User has chosen not to backup the machine");
+                finish(1);
+            }
+            mr_asprintf(bkpinfo->image_devs, "%s", tmp1);
+        }
+
+        if (bkpinfo->exclude_paths != NULL ) {
+            mr_asprintf(p, "%s", bkpinfo->exclude_paths);
+        } else {
+            mr_asprintf(p, "%s", "");
+        }
+        tmp = mr_popup_and_get_string("Exclude paths", "Please enter paths which you do NOT want to backup. Separate them with '|'. NB: /tmp and /proc are always excluded. :-) Just hit 'Enter' if you want to do a full system backup.", p);
+        mr_free(p);
+        if (tmp == NULL) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        mr_free(bkpinfo->exclude_paths);
+        bkpinfo->exclude_paths = tmp;
+
+        mr_asprintf(oldtmp, "%s", bkpinfo->tmpdir);
+        if (bkpinfo->tmpdir != NULL ) {
+            mr_asprintf(p, "%s", bkpinfo->tmpdir);
+        } else {
+            mr_asprintf(p, "%s", "");
+        }
+        tmp = mr_popup_and_get_string("Temporary directory", "Please enter your temporary directory.", p);
+        mr_free(p);
+        if (tmp == NULL) {
+            mr_free(oldtmp);
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        /*  if modified to another path */
+        if (strcmp(tmp,oldtmp) != 0) {
+            setup_tmpdir(tmp);
+        }
+        mr_free(oldtmp);
+
+        mr_asprintf(oldtmp, "%s", bkpinfo->scratchdir);
+        if (bkpinfo->scratchdir != NULL ) {
+            mr_asprintf(p, "%s", bkpinfo->scratchdir);
+        } else {
+            mr_asprintf(p, "%s", "");
+        }
+        tmp = mr_popup_and_get_string("Scratch directory", "Please enter your scratch directory.", p);
+        mr_free(p);
+        if (tmp == NULL) {
+            mr_free(oldtmp);
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+        /*  if modified to another path */
+        if (strcmp(tmp,oldtmp) != 0) {
+            setup_scratchdir(tmp);
+        }
+        mr_free(oldtmp);
+
+        if (ask_me_yes_or_no("Do you want to backup extended attributes?")) {
+            mr_free(g_getfattr);
+            g_getfattr = find_home_of_exe("getfattr");
+            mr_free(g_getfacl);
+            g_getfacl = find_home_of_exe("getfacl");
+            log_it("Backup of extended attributes");
+        }
+// Interactive mode:
+#ifdef __IA64__
+        bkpinfo->make_cd_use_lilo = TRUE;
+#else
+        bkpinfo->make_cd_use_lilo = FALSE;
+#endif
+        bkpinfo->backup_data = TRUE;
+        if (strcmp(compression_type,"lzo") == 0) {
+            mr_asprintf(bkpinfo->zip_exe, "%s", "lzop");
+            mr_asprintf(bkpinfo->zip_suffix, "%s", "lzo");
+        } else if (strcmp(compression_type,"gzip") == 0) {
+            mr_asprintf(bkpinfo->zip_exe, "%s", "gzip");
+            mr_asprintf(bkpinfo->zip_suffix, "%s", "gz");
+        } else if (strcmp(compression_type,"lzma") == 0) {
+            mr_asprintf(bkpinfo->zip_exe, "%s", "xz");
+            mr_asprintf(bkpinfo->zip_suffix, "%s", "xz");
+        } else if (strcmp(compression_type,"bzip2") == 0) {
+            mr_asprintf(bkpinfo->zip_exe, "%s", "bzip2");
+            mr_asprintf(bkpinfo->zip_suffix, "%s", "bz2");
+        } else {
+            mr_free(bkpinfo->zip_exe);
+            mr_free(bkpinfo->zip_suffix);
+        }
+        mr_free(compression_type);
+
+#if __FreeBSD__ == 5
+        mr_asprintf(bkpinfo->kernel_path, "%s", "/boot/kernel/kernel");
+#elif __FreeBSD__ == 4
+        mr_asprintf(bkpinfo->kernel_path, "%s", "/kernel");
+#elif linux
+        if (figure_out_kernel_path_interactively_if_necessary(bkpinfo->kernel_path)) {
+            fatal_error("Kernel not found. Please specify manually with the '-k' switch.");
+        }
+#else
+#error "I don't know about this system!"
+#endif
+
+
+        bkpinfo->verify_data =
+            ask_me_yes_or_no
+            ("Will you want to verify your backups after Mondo has created them?");
+
+        if (!ask_me_yes_or_no
+            ("Are you sure you want to proceed? Hit 'no' to abort.")) {
+            log_to_screen("User has chosen not to backup the machine");
+            finish(1);
+        }
+    } else {
+        bkpinfo->restore_data = TRUE;   // probably...
+    }
+
+    if (bkpinfo->backup_media_type == iso
+        || bkpinfo->backup_media_type == netfs) {
+        g_ISO_restore_mode = TRUE;
+    }
+#ifdef __FreeSD__
+// skip
+#else
+    if (bkpinfo->backup_media_type == netfs) {
+        log_msg(3, "I think the Remote mount is mounted at %s", bkpinfo->isodir);
+    }
+    log_it("isodir = %s", bkpinfo->isodir);
+    if (bkpinfo->netfs_mount) {
+        log_it("netfs_mount = '%s'", bkpinfo->netfs_mount);
+    }
+    if (bkpinfo->netfs_user) {
+        log_it("netfs_user = '%s'", bkpinfo->netfs_user);
+    }
+    if (bkpinfo->netfs_proto) {
+        log_it("netfs_proto = '%s'", bkpinfo->netfs_proto);
+    }
+#endif
+
+    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));
+    if (bkpinfo->prefix != NULL) {
+        log_it("prefix = %s", bkpinfo->prefix);
+    }
+    log_it("compression = %ld", bkpinfo->compression_level);
+    log_it("exclude_path = %s", bkpinfo->exclude_paths);
+    if (bkpinfo->include_paths) {
+        log_it("include_path = %s", bkpinfo->include_paths);
+    }
+
+    /* Handle devices passed in bkpinfo and print result */
+    /*  the mr_make_devlist_from_pathlist function appends */
+    /*  to the *_paths variables so copy before */
+    mr_make_devlist_from_pathlist(bkpinfo->exclude_paths, 'E');
+    mr_make_devlist_from_pathlist(bkpinfo->include_paths, 'I');
+
+    log_it("scratchdir = '%s'", bkpinfo->scratchdir);
+    log_it("tmpdir = '%s'", bkpinfo->tmpdir);
+    if (bkpinfo->image_devs) {
+        log_it("image_devs = '%s'", bkpinfo->image_devs);
+    }
+    log_it("boot_device = '%s' (loader=%c)", bkpinfo->boot_device, bkpinfo->boot_loader);
+    if (bkpinfo->media_size < 0) {
+        if (archiving_to_media) {
+            fatal_error("Media size is less than zero.");
+        } else {
+            log_msg(2, "Warning - media size is less than zero.");
+            bkpinfo->media_size = 0;
+        }
+    }
+    paranoid_free(sz_size);
+    paranoid_free(tmp1);
+    return (0);
+}
+
+
+/**
+ * Get a |-separated list of NETFS mounts.
+ * @return The list created.
+ * @note The return value points to allocated string that needs to be freed by
+ * caller
+ * @bug Even though we only want the mounts, the devices are still checked.
+ */
+char *list_of_NETFS_mounts_only(void)
+{
+    char *exclude_these_directories = NULL;
+
+    exclude_these_directories = call_program_and_get_last_line_of_output("mount -t coda,ncpfs,fuse.sshfs,nfs,nfs4,vmhgfs,smbfs,cifs,afs,gfs,ocfs,ocfs2,mvfs,nsspool,nssvol,fuse.boostfs | tr -s '\t' ' ' | cut -d' ' -f3 | tr -s '\n' '|' | awk '{print $0;}'");
+    log_msg(9,"list_of_NETFS_mounts_only returns %s",exclude_these_directories);
+    return(exclude_these_directories);
+}
+
+/* @} - end of utilityGroup */
+
+
+
+
+
+/**
+ * Create a randomly-named FIFO. The format is @p stub "." [random] [random] where
+ * [random] is a random number between 1 and 32767.
+ * @param store_name_here Where to store the new filename.
+ * @param stub A random number will be appended to this to make the FIFO's name.
+ * @ingroup deviceGroup
+ */
+void make_fifo(char *store_name_here, char *stub)
+{
+    char *tmp = NULL;
+
+    assert_string_is_neither_NULL_nor_zerolength(stub);
+
+    sprintf(store_name_here, "%s%d%d", stub, (int) (random() % 32768),
+            (int) (random() % 32768));
+    make_hole_for_file(store_name_here);
+    mkfifo(store_name_here, S_IRWXU | S_IRWXG);
+    mr_asprintf(tmp, "chmod 770 %s", store_name_here);
+    paranoid_system(tmp);
+    mr_free(tmp);
+}
+
+
+
+/**
+ * @addtogroup deviceGroup
+ * @{
+ */
+/**
+ * If we can read @p dev, set @p output to it.
+ * If @p dev cannot be read, set @p output to "".
+ * @param dev The device to check for.
+ * @param output Set to @p dev if @p dev exists, "" otherwise.
+ * @return TRUE if @p dev exists, FALSE if it doesn't.
+ */
+bool set_dev_to_this_if_rx_OK(char *output, char *dev)
+{
+    char *command = NULL;
+    bool ret=FALSE;
+
+    if (!dev || dev[0] == '\0') {
+        output[0] = '\0';
+        return(ret);
+    }
+//  assert_string_is_neither_NULL_nor_zerolength(dev);
+    if (!bkpinfo->please_dont_eject) {
+        log_msg(10, "Injecting %s", dev);
+        inject_device(dev);
+    }
+    if (!does_file_exist(dev)) {
+        log_msg(10, "%s doesn't exist. Returning FALSE.", dev);
+        return(ret);
+    }
+    mr_asprintf(command, "dd bs=%ld count=1 if=%s of=/dev/null &> /dev/null", 512L, dev);
+    if (!run_program_and_log_output(command, FALSE) && !run_program_and_log_output(command, FALSE)) {
+        strcpy(output, dev);
+        log_msg(4, "Found it - %s", dev);
+        ret = TRUE;
+    } else {
+        output[0] = '\0';
+        log_msg(4, "It's not %s", dev);
+    }
+    mr_free(command);
+    return(ret);
+}
+
+
+
+
+
+/**
+ * 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(bkpinfo->media_device, MNT_CDROM)) {
+        mount_media(MNT_CDROM);
+    }
+
+    cd_number = atoi(last_line_of_file(MNT_CDROM "/archives/THIS-CD-NUMBER"));
+    return(cd_number);
+}
+
+
+/**
+ * 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);
+}
 
 

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

@@ -200 +200 @@
     return (retval);
 }
+
+
+
+/**
+ * Start to write to the next tape. Assume 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_write_to_next_tape()
+{
+    int res = 0;
+    char *command = NULL;
+
+    if (bkpinfo->media_device == NULL) {
+        log_it("Unable to open out from NULL device");
+        return (1);
+    }
+
+    paranoid_pclose(g_tape_stream);
+    sync();
+    sync();
+    sync();
+    log_it("New tape requested.");
+    insist_on_this_tape_number(g_current_media_number + 1); // will increment g_current_media, too
+    if (bkpinfo->backup_media_type == cdstream) {
+        mr_asprintf(command, "cdrecord -eject dev=%s speed=%d fs=24m -waiti - >> %s 2>> %s", bkpinfo->media_device, bkpinfo->cdrw_speed, MONDO_LOGFILE, MONDO_LOGFILE);
+        log_it("Opening OUT to next CD with the command");
+        log_it(command);
+        log_it("Let's see what happens, shall we?");
+        g_tape_stream = popen(command, "w");
+        mr_free(command);
+
+        if (!g_tape_stream) {
+            log_to_screen("Failed to openout to cdstream (fifo)");
+            return (1);
+        }
+    } else {
+        log_it("Opening OUT to next tape");
+        if (!(g_tape_stream = open_device_via_buffer(bkpinfo->media_device, 'w', 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 += write_header_block_to_stream((off_t)0, "start-of-tape", BLK_START_OF_TAPE);  /* just in case */
+    res += write_header_block_to_stream((off_t)0, "start-of-backup", BLK_START_OF_BACKUP);  /* just in case */
+    return (res);
+}
+
+
+
+/**
+ * Decide whether we should start a new tape. This is TRUE if we've run out of tape
+ * (got SIGPIPE) or look like we will.
+ * @param mediasize The size of the tape in megabytes.
+ * @param length_of_incoming_file The length of the file we're about to write, in bytes.
+ * @bug This seems like it'll only work for media_size != autodetect, but Mondo only allows
+ * autodetecting the size. Huh?
+ */
+
+/* TODO: Should be reviewed for mediasize being a off_t ??? */
+bool
+should_we_write_to_next_tape(long mediasize,
+                             off_t length_of_incoming_file)
+{
+    /*@ bool's ***************************************************** */
+    bool we_need_a_new_tape = FALSE;
+
+    /*@ end vars *************************************************** */
+
+    if (mediasize == 0) {
+        return (FALSE);
+    }
+    if (mediasize > 0 && (g_tape_posK >> 10 >= mediasize)) {
+        log_it("mediasize = %ld", mediasize);
+        we_need_a_new_tape = TRUE;
+        log_to_screen("Should have started a new tape/CD already");
+    }
+    if ((g_tape_posK + length_of_incoming_file / 1024) >> 10 >=
+        mediasize - (SLICE_SIZE * 4 / 1024)) {
+        log_it("g_tape_posK = %ld\nmediasize = %ld\n", g_tape_posK,
+               mediasize);
+        we_need_a_new_tape = TRUE;
+    }
+    return (we_need_a_new_tape);
+}
+
+
 
 
@@ -354 +444 @@
 
 
+/**
+ * Copy a file from the opened stream (CD or tape) to @p outfile.
+ * @param outfile The file to write to.
+ * @param size The size of the file in the input stream.
+ * @return 0 for success, nonzero for failure.
+ */
+int
+read_file_from_stream_to_file(char *outfile, long long size)
+{
+
+    /*@ int ******************************************************** */
+    int res;
+
+    /*@ end vars *************************************************** */
+
+    res = read_file_from_stream_FULL(outfile, NULL, size);
+
+    return (res);
+}
+
+
+
+
 int read_EXAT_files_from_tape(long long *ptmp_size, char *tmp_fname,
                               int *pctrl_chr, char *xattr_fname,
@@ -419 +532 @@
     return (res);
 }
+
+
+/**
+ * Copy @p infile to the opened stream (CD or tape).
+ * @param bkpinfo The backup information structure. @c bkpinfo->media_size is the only field used.
+ * @param infile The file to write to the stream.
+ * @return 0 for success, nonzero for failure.
+ */
+int write_file_to_stream_from_file(char *infile)
+{
+    /*@ buffers **************************************************** */
+    char datablock[TAPE_BLOCK_SIZE];
+    char *checksum = NULL;
+    char *infile_basename;
+
+    /*@ int ******************************************************** */
+    int retval = 0;
+    int noof_blocks;
+
+    /*  unsigned int ch; */
+    unsigned int crc16;
+    unsigned int crctt;
+
+    /*@ pointers *************************************************** */
+    FILE *fin;
+    char *p;
+
+    /*@ long ******************************************************* */
+    long bytes_to_read = 0;
+    long i;
+
+    off_t filesize;
+
+#ifdef EXTRA_TAPE_CHECKSUMS
+    int ch;
+#endif
+
+    /*@ initialize ************************************************ */
+    crc16 = 0;
+    crctt = 0;
+
+
+
+    /*@ end vars *************************************************** */
+
+    infile_basename = strrchr(infile, '/');
+    if (infile_basename) {
+        infile_basename++;
+    } else {
+        infile_basename = infile;
+    }
+    filesize = length_of_file(infile);
+    if (should_we_write_to_next_tape(bkpinfo->media_size, filesize)) {
+        start_to_write_to_next_tape();
+        write_backcatalog_to_tape();
+    }
+    p = strrchr(infile, '/');
+    if (!p) {
+        p = infile;
+    } else {
+        p++;
+    }
+    log_it("Writing file '%s' to tape (%ld KB)", p, (long) filesize >> 10);
+    write_header_block_to_stream(filesize, infile_basename, BLK_START_FILE);
+//go_here_to_restart_saving_of_file:
+    if (!(fin = fopen(infile, "r"))) {
+        log_OS_error(infile);
+        return (1);
+    }
+    for (noof_blocks = 0; filesize > 0;
+         noof_blocks++, filesize -= bytes_to_read) {
+        if (filesize < TAPE_BLOCK_SIZE) {
+            bytes_to_read = (long) filesize;
+            for (i = 0; i < TAPE_BLOCK_SIZE; i++) {
+                datablock[i] = '\0';
+            }
+        } else {
+            bytes_to_read = TAPE_BLOCK_SIZE;
+        }
+        if (fread(datablock, 1, (size_t) bytes_to_read, fin)) {
+            // FIXME
+        }
+        g_tape_posK +=
+            fwrite(datablock, 1, /*bytes_to_read */ 
+                   (size_t) TAPE_BLOCK_SIZE,
+                   g_tape_stream) / 1024;
+        if (g_sigpipe) {
+            log_it("Sigpipe occurred recently. I'll start a new tape.");
+            fclose(fin);
+            g_sigpipe = FALSE;
+            start_to_write_to_next_tape();
+            write_backcatalog_to_tape();    // kinda-sorta recursive :)
+            return (0);
+        }
+#ifdef EXTRA_TAPE_CHECKSUMS
+        for (i = 0; i < bytes_to_read; i++) {
+            ch = datablock[i];
+            crc16 = updcrcr(crc16, (unsigned) ch);
+            crctt = updcrc(crctt, (unsigned) ch);
+        }
+#endif
+    }
+    paranoid_fclose(fin);
+    mr_asprintf(checksum, "%04x%04x", crc16, crctt);
+    /* TODO: what does it do ??? */
+    write_header_block_to_stream((off_t)g_current_media_number, checksum, BLK_STOP_FILE);
+    mr_free(checksum);
+
+//  log_it("File '%s' written to tape.", infile);
+    return (retval);
+}
+
+
+
+
+
+
 
 
@@ -566 +796 @@
 }
 
-
-
-
-/**
- * Open the CD stream for input.
- * @param bkpinfo The backup information structure. Passed to openin_tape().
- * @return 0 for success, nonzero for failure.
- * @note Equivalent to openin_tape() for now, but don't count on this behavior.
- */
-int openin_cdstream()
-{
-    return (openin_tape());
-}
-
-/**
- * FIFO used to read/write to the tape device.
- * @bug This seems obsolete now that we call an external @c buffer program. Please look onto this.
- */
-char g_tape_fifo[MAX_STR_LEN];
-
-
-
-int set_tape_block_size_with_mt(long internal_tape_block_size)
-{
-    char *tmp = NULL;
-    int res;
-
-    if (bkpinfo->media_device == NULL) {
-        return(1);
-    }
-
-    if (strncmp(bkpinfo->media_device, "/dev/", 5)) {
-        log_msg(1, "Not using 'mt setblk'. This isn't an actual /dev entry.");
-        return (0);
-    }
-    mr_asprintf(tmp, "mt -f %s setblk %ld", bkpinfo->media_device, internal_tape_block_size);
-    res = run_program_and_log_output(tmp, 3);
-    mr_free(tmp);
-    return (res);
-}
-
-/**
- * Return the non-rewinding device when passed the normal one
- * @param tapedev The tape device to open for writing.
- * @note the caller needs to free the string returned
- */
-char *get_non_rewind_dev(char *tapedev)
-{
-
-    char *ntapedev = NULL;
-    char *p = NULL;
-    char *q = NULL;
-    char *r = NULL;
-
-    ntapedev = (char *)mr_malloc(strlen(tapedev)+2*sizeof(char));
-    p = strrchr(tapedev,'/');
-    if (p == NULL) {
-        log_it("Didn't find a '/' in %s",tapedev);
-        return(NULL);
-    }
-
-    /* Copy tapedev content up to the last / */
-    q = tapedev;
-    r = ntapedev;
-    while (q != p) {
-        *r = *q;
-        r++;
-        q++;
-    }
-    /* Copy the '/' */
-    *r = *q;
-    r++;
-    q++;
-    /* Adds a 'n' - non-rewinding */
-    *r = 'n';
-    r++;
-    /* Copy the rest of tapedev */
-    while (*q != '\0') {
-        *r = *q;
-        r++;
-        q++;
-    }
-    *r = '\0';
-    if (mt_says_tape_exists(ntapedev)) {
-        log_it("Non-rewinding tape device is %s",ntapedev);
-    } else {
-        log_it("Unable to find non-rewinding tape device.");
-        ntapedev = NULL;
-    }
-    return(ntapedev);
-}
-
-
-
-/**
- * Handle OBDR if we were asked to do so
- * @param tapedev The tape device to open for reading.
- */
-int skip_obdr(void)
-{
-    char *command = NULL;
-    int res = 0;
-
-    if (bkpinfo->media_device == NULL) {
-        return(1);
-    }
-
-    log_it("Skipping OBDR headers");
-    mr_asprintf(command, "mt -f %s rewind",bkpinfo->media_device);
-    res = run_program_and_log_output(command, 1);
-    paranoid_free(command);
-
-    mr_asprintf(command, "mt -f %s fsf 2",bkpinfo->media_device);
-    res = run_program_and_log_output(command, 1);
-    paranoid_free(command);
-
-    set_tape_block_size_with_mt(bkpinfo->internal_tape_block_size);
-    return(res);
-}
-
-/**
- * Handle OBDR if we were asked to do so
- * @param tapedev The tape device to open for writing.
- * @return 0 for success, nonzero for failure.
- * @note This should be called ONLY from backup processes. It will OVERWRITE ANY
- * EXISTING DATA on the tape!
- */
-int create_obdr(void)
-{
-
-    char *command = NULL;
-    int res = 0;
-
-    if (bkpinfo->media_device == NULL) {
-        return(1);
-    }
-
-    log_it("Creating OBDR headers");
-    /* OBDR: First block 10 kB of zero bs = 512 */
-    mr_asprintf(command, "mt -f %s compression off",bkpinfo->media_device);
-    res = run_program_and_log_output(command, 1);
-    paranoid_free(command);
-
-    mr_asprintf(command, "mt -f %s rewind",bkpinfo->media_device);
-    res += run_program_and_log_output(command, 1);
-    paranoid_free(command);
-
-    set_tape_block_size_with_mt(512);
-
-    mr_asprintf(command, "dd if=/dev/zero of=%s bs=512 count=20",bkpinfo->media_device);
-    res += run_program_and_log_output(command, 1);
-    paranoid_free(command);
-
-    /* OBDR: then ISO boot image bs = 2048 */
-    set_tape_block_size_with_mt(2048);
-
-    mr_asprintf(command, "dd if=%s of=%s bs=2048",MINDI_CACHE"/mindi.iso",bkpinfo->media_device);
-    res += run_program_and_log_output(command, 1);
-    paranoid_free(command);
-
-    set_tape_block_size_with_mt(bkpinfo->internal_tape_block_size);
-
-    /* restore compression mode on */
-    mr_asprintf(command, "mt -f %s compression on",bkpinfo->media_device);
-    res = run_program_and_log_output(command, 1);
-    paranoid_free(command);
-
-    return(res);
-}
 
 
@@ -871 +932 @@
 
 
+
+/**
+ * Open the CD stream for input.
+ * @param bkpinfo The backup information structure. Passed to openin_tape().
+ * @return 0 for success, nonzero for failure.
+ * @note Equivalent to openin_tape() for now, but don't count on this behavior.
+ */
+int openin_cdstream()
+{
+    return (openin_tape());
+}
+
+/**
+ * FIFO used to read/write to the tape device.
+ * @bug This seems obsolete now that we call an external @c buffer program. Please look onto this.
+ */
+char g_tape_fifo[MAX_STR_LEN];
+
+
+
+int set_tape_block_size_with_mt(long internal_tape_block_size)
+{
+    char *tmp = NULL;
+    int res;
+
+    if (bkpinfo->media_device == NULL) {
+        return(1);
+    }
+
+    if (strncmp(bkpinfo->media_device, "/dev/", 5)) {
+        log_msg(1, "Not using 'mt setblk'. This isn't an actual /dev entry.");
+        return (0);
+    }
+    mr_asprintf(tmp, "mt -f %s setblk %ld", bkpinfo->media_device, internal_tape_block_size);
+    res = run_program_and_log_output(tmp, 3);
+    mr_free(tmp);
+    return (res);
+}
+
+/**
+ * Return the non-rewinding device when passed the normal one
+ * @param tapedev The tape device to open for writing.
+ * @note the caller needs to free the string returned
+ */
+char *get_non_rewind_dev(char *tapedev)
+{
+
+    char *ntapedev = NULL;
+    char *p = NULL;
+    char *q = NULL;
+    char *r = NULL;
+
+    ntapedev = (char *)mr_malloc(strlen(tapedev)+2*sizeof(char));
+    p = strrchr(tapedev,'/');
+    if (p == NULL) {
+        log_it("Didn't find a '/' in %s",tapedev);
+        return(NULL);
+    }
+
+    /* Copy tapedev content up to the last / */
+    q = tapedev;
+    r = ntapedev;
+    while (q != p) {
+        *r = *q;
+        r++;
+        q++;
+    }
+    /* Copy the '/' */
+    *r = *q;
+    r++;
+    q++;
+    /* Adds a 'n' - non-rewinding */
+    *r = 'n';
+    r++;
+    /* Copy the rest of tapedev */
+    while (*q != '\0') {
+        *r = *q;
+        r++;
+        q++;
+    }
+    *r = '\0';
+    if (mt_says_tape_exists(ntapedev)) {
+        log_it("Non-rewinding tape device is %s",ntapedev);
+    } else {
+        log_it("Unable to find non-rewinding tape device.");
+        ntapedev = NULL;
+    }
+    return(ntapedev);
+}
+
+
+
+/**
+ * Handle OBDR if we were asked to do so
+ * @param tapedev The tape device to open for reading.
+ */
+int skip_obdr(void)
+{
+    char *command = NULL;
+    int res = 0;
+
+    if (bkpinfo->media_device == NULL) {
+        return(1);
+    }
+
+    log_it("Skipping OBDR headers");
+    mr_asprintf(command, "mt -f %s rewind",bkpinfo->media_device);
+    res = run_program_and_log_output(command, 1);
+    paranoid_free(command);
+
+    mr_asprintf(command, "mt -f %s fsf 2",bkpinfo->media_device);
+    res = run_program_and_log_output(command, 1);
+    paranoid_free(command);
+
+    set_tape_block_size_with_mt(bkpinfo->internal_tape_block_size);
+    return(res);
+}
+
+/**
+ * Handle OBDR if we were asked to do so
+ * @param tapedev The tape device to open for writing.
+ * @return 0 for success, nonzero for failure.
+ * @note This should be called ONLY from backup processes. It will OVERWRITE ANY
+ * EXISTING DATA on the tape!
+ */
+int create_obdr(void)
+{
+
+    char *command = NULL;
+    int res = 0;
+
+    if (bkpinfo->media_device == NULL) {
+        return(1);
+    }
+
+    log_it("Creating OBDR headers");
+    /* OBDR: First block 10 kB of zero bs = 512 */
+    mr_asprintf(command, "mt -f %s compression off",bkpinfo->media_device);
+    res = run_program_and_log_output(command, 1);
+    paranoid_free(command);
+
+    mr_asprintf(command, "mt -f %s rewind",bkpinfo->media_device);
+    res += run_program_and_log_output(command, 1);
+    paranoid_free(command);
+
+    set_tape_block_size_with_mt(512);
+
+    mr_asprintf(command, "dd if=/dev/zero of=%s bs=512 count=20",bkpinfo->media_device);
+    res += run_program_and_log_output(command, 1);
+    paranoid_free(command);
+
+    /* OBDR: then ISO boot image bs = 2048 */
+    set_tape_block_size_with_mt(2048);
+
+    mr_asprintf(command, "dd if=%s of=%s bs=2048",MINDI_CACHE"/mindi.iso",bkpinfo->media_device);
+    res += run_program_and_log_output(command, 1);
+    paranoid_free(command);
+
+    set_tape_block_size_with_mt(bkpinfo->internal_tape_block_size);
+
+    /* restore compression mode on */
+    mr_asprintf(command, "mt -f %s compression on",bkpinfo->media_device);
+    res = run_program_and_log_output(command, 1);
+    paranoid_free(command);
+
+    return(res);
+}
+
+
 /**
  * Start writing to a CD stream.
@@ -948 +1178 @@
 }
 return (0);
-}
-
-
-
-
-/**
- * Copy a file from the opened stream (CD or tape) to @p outfile.
- * @param outfile The file to write to.
- * @param size The size of the file in the input stream.
- * @return 0 for success, nonzero for failure.
- */
-int
-read_file_from_stream_to_file(char *outfile, long long size)
-{
-
-    /*@ int ******************************************************** */
-    int res;
-
-    /*@ end vars *************************************************** */
-
-    res = read_file_from_stream_FULL(outfile, NULL, size);
-
-    return (res);
-}
-
-
-
-/**
- * Copy a file from the currently opened stream (CD or tape) to the stream indicated
- * by @p fout.
- * @param bkpinfo The backup information structure. @c bkpinfo->media_size is the only field used.
- * @param fout The stream to write the file to.
- * @param size The size of the file in bytes.
- * @return 0 for success, nonzero for failure.
- */
-int
-read_file_from_stream_to_stream(FILE * fout, long long size)
-{
-
-    /*@ int ******************************************************** */
-    int res;
-
-    /*@ end vars *************************************************** */
-
-    res = read_file_from_stream_FULL(NULL, fout, size);
-/*  fflush(g_tape_stream);
-  fflush(fout);*/
-    return (res);
 }
 
@@ -1147 +1329 @@
 
 /**
- * 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().
+ * Copy a file from the currently opened stream (CD or tape) to the stream indicated
+ * by @p fout.
+ * @param bkpinfo The backup information structure. @c bkpinfo->media_size is the only field used.
+ * @param fout The stream to write the file to.
+ * @param size The size of the file in bytes.
+ * @return 0 for success, nonzero for failure.
  */
 int
-read_header_block_from_stream(long long *plen, char *filename,
-                              int *pcontrol_char)
-{
-
-    /*@ buffers ***************************************************** */
-    char *tempblock;
-    char *tmp = NULL;
-
-    /*@ int ********************************************************* */
-    int i, retval;
+read_file_from_stream_to_stream(FILE * fout, long long size)
+{
+
+    /*@ int ******************************************************** */
+    int res;
 
     /*@ 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);
-}
-
-
-
-/**
- * Add specified file/slice to the internal catalog of all archives written.
- * This lets us restart on a new CD/tape/whatever if it runs out of room. We just
- * write the last [buffer size] MB from the catalog to the new tape, so we know
- * we have @e all archives on some CD/tape/whatever.
- * @param type The type of file we're cataloging (afioball, slice, something else)
- * @param number The fileset number or biggiefile number.
- * @param aux The slice number if it's a biggiefile, or any other additional info.
- * @param fn The original full pathname of the file we're recording.
- * @return The index of the record we just added.
- */
-int register_in_tape_catalog(t_archtype type, int number, long aux,
-                             char *fn)
-{
-    int last;
-    char fname[MAX_TAPECAT_FNAME_LEN+1];
-    char *p;
-
-    p = strrchr(fn, '/');
-    if (p) {
-        p++;
-    } else {
-        p = fn;
-    }
-    strncpy(fname, p, MAX_TAPECAT_FNAME_LEN);
-    fname[MAX_TAPECAT_FNAME_LEN] = '\0';
-    last = g_tapecatalog->entries;
-    if (last >= MAX_TAPECATALOG_ENTRIES) {
-        log_it
-            ("Warning - can't log #%d in tape catalog - too many entries already",
-             number);
-        return (-1);
-    }
-    g_tapecatalog->el[last].type = type;
-    g_tapecatalog->el[last].number = number;
-    g_tapecatalog->el[last].aux = aux;
-    g_tapecatalog->el[last].tape_posK = g_tape_posK;
-    strcpy(g_tapecatalog->el[last].fname, fname);
-    g_tapecatalog->entries++;
-    return (last);              // returns the index of the record we've jsut added
-}
-
-
-
-
-/**
- * Decide whether we should start a new tape. This is TRUE if we've run out of tape
- * (got SIGPIPE) or look like we will.
- * @param mediasize The size of the tape in megabytes.
- * @param length_of_incoming_file The length of the file we're about to write, in bytes.
- * @bug This seems like it'll only work for media_size != autodetect, but Mondo only allows
- * autodetecting the size. Huh?
- */
-
-/* TODO: Should be reviewed for mediasize being a off_t ??? */
-bool
-should_we_write_to_next_tape(long mediasize,
-                             off_t length_of_incoming_file)
-{
-    /*@ bool's ***************************************************** */
-    bool we_need_a_new_tape = FALSE;
-
-    /*@ end vars *************************************************** */
-
-    if (mediasize == 0) {
-        return (FALSE);
-    }
-    if (mediasize > 0 && (g_tape_posK >> 10 >= mediasize)) {
-        log_it("mediasize = %ld", mediasize);
-        we_need_a_new_tape = TRUE;
-        log_to_screen("Should have started a new tape/CD already");
-    }
-    if ((g_tape_posK + length_of_incoming_file / 1024) >> 10 >=
-        mediasize - (SLICE_SIZE * 4 / 1024)) {
-        log_it("g_tape_posK = %ld\nmediasize = %ld\n", g_tape_posK,
-               mediasize);
-        we_need_a_new_tape = TRUE;
-    }
-    return (we_need_a_new_tape);
+    res = read_file_from_stream_FULL(NULL, fout, size);
+/*  fflush(g_tape_stream);
+  fflush(fout);*/
+    return (res);
 }
 
@@ -1448 +1514 @@
 
 /**
- * Start to write to the next tape. Assume 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_write_to_next_tape()
-{
-    int res = 0;
-    char *command = NULL;
-
-    if (bkpinfo->media_device == NULL) {
-        log_it("Unable to open out from NULL device");
-        return (1);
-    }
-
-    paranoid_pclose(g_tape_stream);
-    sync();
-    sync();
-    sync();
-    log_it("New tape requested.");
-    insist_on_this_tape_number(g_current_media_number + 1); // will increment g_current_media, too
-    if (bkpinfo->backup_media_type == cdstream) {
-        mr_asprintf(command, "cdrecord -eject dev=%s speed=%d fs=24m -waiti - >> %s 2>> %s", bkpinfo->media_device, bkpinfo->cdrw_speed, MONDO_LOGFILE, MONDO_LOGFILE);
-        log_it("Opening OUT to next CD with the command");
-        log_it(command);
-        log_it("Let's see what happens, shall we?");
-        g_tape_stream = popen(command, "w");
-        mr_free(command);
-
-        if (!g_tape_stream) {
-            log_to_screen("Failed to openout to cdstream (fifo)");
-            return (1);
-        }
-    } else {
-        log_it("Opening OUT to next tape");
-        if (!(g_tape_stream = open_device_via_buffer(bkpinfo->media_device, 'w', 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 += write_header_block_to_stream((off_t)0, "start-of-tape", BLK_START_OF_TAPE);  /* just in case */
-    res += write_header_block_to_stream((off_t)0, "start-of-backup", BLK_START_OF_BACKUP);  /* just in case */
-    return (res);
+ * 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);
+}
+
+
+
+/**
+ * Add specified file/slice to the internal catalog of all archives written.
+ * This lets us restart on a new CD/tape/whatever if it runs out of room. We just
+ * write the last [buffer size] MB from the catalog to the new tape, so we know
+ * we have @e all archives on some CD/tape/whatever.
+ * @param type The type of file we're cataloging (afioball, slice, something else)
+ * @param number The fileset number or biggiefile number.
+ * @param aux The slice number if it's a biggiefile, or any other additional info.
+ * @param fn The original full pathname of the file we're recording.
+ * @return The index of the record we just added.
+ */
+int register_in_tape_catalog(t_archtype type, int number, long aux,
+                             char *fn)
+{
+    int last;
+    char fname[MAX_TAPECAT_FNAME_LEN+1];
+    char *p;
+
+    p = strrchr(fn, '/');
+    if (p) {
+        p++;
+    } else {
+        p = fn;
+    }
+    strncpy(fname, p, MAX_TAPECAT_FNAME_LEN);
+    fname[MAX_TAPECAT_FNAME_LEN] = '\0';
+    last = g_tapecatalog->entries;
+    if (last >= MAX_TAPECATALOG_ENTRIES) {
+        log_it
+            ("Warning - can't log #%d in tape catalog - too many entries already",
+             number);
+        return (-1);
+    }
+    g_tapecatalog->el[last].type = type;
+    g_tapecatalog->el[last].number = number;
+    g_tapecatalog->el[last].aux = aux;
+    g_tapecatalog->el[last].tape_posK = g_tape_posK;
+    strcpy(g_tapecatalog->el[last].fname, fname);
+    g_tapecatalog->entries++;
+    return (last);              // returns the index of the record we've jsut added
 }
 
@@ -1600 +1718 @@
 
 
-/**
- * Copy @p infile to the opened stream (CD or tape).
- * @param bkpinfo The backup information structure. @c bkpinfo->media_size is the only field used.
- * @param infile The file to write to the stream.
- * @return 0 for success, nonzero for failure.
- */
-int write_file_to_stream_from_file(char *infile)
-{
-    /*@ buffers **************************************************** */
-    char datablock[TAPE_BLOCK_SIZE];
-    char *checksum = NULL;
-    char *infile_basename;
-
-    /*@ int ******************************************************** */
-    int retval = 0;
-    int noof_blocks;
-
-    /*  unsigned int ch; */
-    unsigned int crc16;
-    unsigned int crctt;
-
-    /*@ pointers *************************************************** */
-    FILE *fin;
-    char *p;
-
-    /*@ long ******************************************************* */
-    long bytes_to_read = 0;
-    long i;
-
-    off_t filesize;
-
-#ifdef EXTRA_TAPE_CHECKSUMS
-    int ch;
-#endif
-
-    /*@ initialize ************************************************ */
-    crc16 = 0;
-    crctt = 0;
-
-
-
-    /*@ end vars *************************************************** */
-
-    infile_basename = strrchr(infile, '/');
-    if (infile_basename) {
-        infile_basename++;
-    } else {
-        infile_basename = infile;
-    }
-    filesize = length_of_file(infile);
-    if (should_we_write_to_next_tape(bkpinfo->media_size, filesize)) {
-        start_to_write_to_next_tape();
-        write_backcatalog_to_tape();
-    }
-    p = strrchr(infile, '/');
-    if (!p) {
-        p = infile;
-    } else {
-        p++;
-    }
-    log_it("Writing file '%s' to tape (%ld KB)", p, (long) filesize >> 10);
-    write_header_block_to_stream(filesize, infile_basename, BLK_START_FILE);
-//go_here_to_restart_saving_of_file:
-    if (!(fin = fopen(infile, "r"))) {
-        log_OS_error(infile);
-        return (1);
-    }
-    for (noof_blocks = 0; filesize > 0;
-         noof_blocks++, filesize -= bytes_to_read) {
-        if (filesize < TAPE_BLOCK_SIZE) {
-            bytes_to_read = (long) filesize;
-            for (i = 0; i < TAPE_BLOCK_SIZE; i++) {
-                datablock[i] = '\0';
-            }
-        } else {
-            bytes_to_read = TAPE_BLOCK_SIZE;
-        }
-        if (fread(datablock, 1, (size_t) bytes_to_read, fin)) {
-            // FIXME
-        }
-        g_tape_posK +=
-            fwrite(datablock, 1, /*bytes_to_read */ 
-                   (size_t) TAPE_BLOCK_SIZE,
-                   g_tape_stream) / 1024;
-        if (g_sigpipe) {
-            log_it("Sigpipe occurred recently. I'll start a new tape.");
-            fclose(fin);
-            g_sigpipe = FALSE;
-            start_to_write_to_next_tape();
-            write_backcatalog_to_tape();    // kinda-sorta recursive :)
-            return (0);
-        }
-#ifdef EXTRA_TAPE_CHECKSUMS
-        for (i = 0; i < bytes_to_read; i++) {
-            ch = datablock[i];
-            crc16 = updcrcr(crc16, (unsigned) ch);
-            crctt = updcrc(crctt, (unsigned) ch);
-        }
-#endif
-    }
-    paranoid_fclose(fin);
-    mr_asprintf(checksum, "%04x%04x", crc16, crctt);
-    /* TODO: what does it do ??? */
-    write_header_block_to_stream((off_t)g_current_media_number, checksum, BLK_STOP_FILE);
-    mr_free(checksum);
-
-//  log_it("File '%s' written to tape.", infile);
-    return (retval);
-}
-
-
-
-
-
-
-
-
 
 

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

@@ -650 +650 @@
 
 /**
+ * Check the user's system for sanity. Checks performed:
+ * - make sure user has enough RAM (32mb required, 64mb recommended)
+ * - make sure user has enough free space in @c /
+ * - check kernel for ramdisk support
+ * - make sure afio, cdrecord, mkisofs, bzip2, awk, md5sum, strings, mindi, and buffer exist
+ * - make sure CD-ROM is unmounted
+ * - make sure user's mountlist is OK by running <tt>mindi --makemountlist</tt>
+ *
+ * @return number of problems with the user's setup (0 for success)
+ */
+int some_basic_system_sanity_checks()
+{
+
+    /*@ buffers ************ */
+    char *tmp = NULL;
+
+    /*@ int's *************** */
+    int retval = 0;
+
+    mvaddstr_and_log_it(g_currentY, 0, "Checking sanity of your Linux distribution");
+#ifndef __FreeBSD__
+    if (system("which mkfs.vfat 2> /dev/null 1> /dev/null")
+        && !system("which mkfs.msdos 2> /dev/null 1> /dev/null")) {
+        log_it("OK, you've got mkfs.msdos but not mkfs.vfat; time for the fairy to wave her magic wand...");
+        run_program_and_log_output("ln -sf `which mkfs.msdos` /sbin/mkfs.vfat", FALSE);
+    }
+    tmp = call_program_and_get_last_line_of_output("free | grep Mem | head -n1 | tr -s ' ' '\t' | cut -f2");
+    if (atol(tmp) < 35000) {
+        retval++;
+        log_to_screen("You must have at least 32MB of RAM to use Mondo.");
+    }
+    if (atol(tmp) < 66000) {
+        log_to_screen("WARNING! You have very little RAM. Please upgrade to 64MB or more.");
+    }
+    mr_free(tmp);
+#endif
+
+    if (system("which " MKE2FS_OR_NEWFS " > /dev/null 2> /dev/null")) {
+        retval++;
+        log_to_screen("Unable to find " MKE2FS_OR_NEWFS " in system path.");
+        fatal_error("Please use \"su -\", not \"su\" to become root. OK?\n...and please don't e-mail the mailing list about this. Just read the message. :)");
+    }
+#ifndef __FreeBSD__
+    if (run_program_and_log_output("grep ramdisk /proc/devices", FALSE)) {
+        /* Some SuSE have ramdisk as modules, so insert it first, then test again */
+        run_program_and_log_output("modprobe brd 2> /dev/null > /dev/null",FALSE);
+        if (run_program_and_log_output("grep ramdisk /proc/devices", FALSE)) {
+            if (!ask_me_yes_or_no("Your kernel has no ramdisk support. That's mind-numbingly stupid but I'll allow it if you're planning to use another kernel. Are you?")) {
+                //          retval++;
+                log_to_screen("It looks as if your kernel lacks ramdisk and initrd support.");
+                log_to_screen("I'll allow you to proceed but FYI, if I'm right, your kernel is broken.");
+            }
+        }
+    }
+#endif
+    retval += whine_if_not_found(MKE2FS_OR_NEWFS);
+    if (system("which xorriso > /dev/null 2> /dev/null")) {
+        if (system("which genisoimage > /dev/null 2> /dev/null")) {
+            retval += whine_if_not_found("mkisofs");
+        }
+    }
+    if (system("which wodim > /dev/null 2> /dev/null")) {
+        retval += whine_if_not_found("cdrecord");
+    }
+    retval += whine_if_not_found("bzip2");
+    retval += whine_if_not_found("gzip");
+    retval += whine_if_not_found("cmp");
+    retval += whine_if_not_found("awk");
+    retval += whine_if_not_found("md5sum");
+    retval += whine_if_not_found("strings");
+    retval += whine_if_not_found("mindi");
+    retval += whine_if_not_found("buffer");
+
+    // abort if Windows partition but no ms-sys and parted
+    if (!run_program_and_log_output("mount | grep -Ew 'vfat|fat|dos' | grep -vE \"/dev/fd|nexdisk\"", 0)) {
+        if (!run_program_and_log_output("mount | grep -Ew 'vfat|fat|dos' | grep -Ew efi", 0)) {
+            log_to_screen("I think you have a EFI/UEFI partition.");
+        } else {
+            log_to_screen("I think you have a Windows 9x partition.");
+        }
+        retval += whine_if_not_found("parted");
+    }
+
+    run_program_and_log_output("umount `mount | grep cdr | cut -d' ' -f3 | tr '\n' ' '`", 5);
+    tmp = call_program_and_get_last_line_of_output("mount | grep -E 'cdr(om|w)'");
+    if (strcmp("", tmp)) {
+        if (strstr(tmp, "autofs")) {
+            log_to_screen("Your CD-ROM is mounted via autofs. I therefore cannot tell");
+            log_to_screen("if a CD actually is inserted. If a CD is inserted, please");
+            log_to_screen("eject it. Thank you.");
+            log_it("Ignoring autofs CD-ROM 'mount' since we hope nothing's in it.");
+        } else
+            if (run_program_and_log_output("uname -a | grep Knoppix", 5)) {
+            retval++;
+            mr_free(tmp);
+            fatal_error("Your CD-ROM drive is mounted. Please unmount it.");
+        }
+    }
+    mr_free(tmp);
+
+    run_program_and_log_output("cat /etc/fstab", 5);
+#ifdef __FreeBSD__
+    run_program_and_log_output("vinum printconfig", 5);
+#else
+    run_program_and_log_output("cat /etc/raidtab", 5);
+#endif
+
+    if (run_program_and_log_output("mindi -V", 1)) {
+        log_to_screen("Could not ascertain mindi's version number.");
+        log_to_screen("You have not installed Mondo and/or Mindi properly.");
+        log_to_screen("Please uninstall and reinstall them both.");
+        fatal_error("Please reinstall Mondo and Mindi.");
+    }
+    mr_asprintf(tmp, "mindi --makemountlist %s/mountlist.txt.test", bkpinfo->tmpdir);
+    if (run_program_and_log_output(tmp, 5)) {
+        log_to_screen("%s failed for some reason.", tmp);
+        mr_free(tmp);
+        log_to_screen("Please run that command by hand and examine "MINDI_LOGFILE);
+        log_to_screen("for more information. Perhaps your /etc/fstab file is insane.");
+        log_to_screen("Perhaps Mindi's MakeMountlist() subroutine has a bug. We'll see.");
+        retval++;
+    }
+    mr_free(tmp);
+
+    if (!run_program_and_log_output("mr-parted2fdisk -l 2>/dev/null | grep -i raid", 1) && !does_file_exist("/etc/raidtab")) {
+        log_to_screen("You have RAID partitions but no /etc/raidtab - creating one from /proc/mdstat");
+        create_raidtab_from_mdstat(MDSTAT_FILE,"/etc/raidtab");
+    }
+
+    if (retval) {
+        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
+    } else {
+        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+    }
+    return (retval);
+}
+
+
+
+/**
  * Do some miscellaneous setup tasks to be performed before filling @c bkpinfo.
  * Seeds the random-number generator, loads important modules, checks the sanity
@@ -897 +1037 @@
 }
 
-
-
-/**
- * Check the user's system for sanity. Checks performed:
- * - make sure user has enough RAM (32mb required, 64mb recommended)
- * - make sure user has enough free space in @c /
- * - check kernel for ramdisk support
- * - make sure afio, cdrecord, mkisofs, bzip2, awk, md5sum, strings, mindi, and buffer exist
- * - make sure CD-ROM is unmounted
- * - make sure user's mountlist is OK by running <tt>mindi --makemountlist</tt>
- *
- * @return number of problems with the user's setup (0 for success)
- */
-int some_basic_system_sanity_checks()
-{
-
-    /*@ buffers ************ */
-    char *tmp = NULL;
-
-    /*@ int's *************** */
-    int retval = 0;
-
-    mvaddstr_and_log_it(g_currentY, 0, "Checking sanity of your Linux distribution");
-#ifndef __FreeBSD__
-    if (system("which mkfs.vfat 2> /dev/null 1> /dev/null")
-        && !system("which mkfs.msdos 2> /dev/null 1> /dev/null")) {
-        log_it("OK, you've got mkfs.msdos but not mkfs.vfat; time for the fairy to wave her magic wand...");
-        run_program_and_log_output("ln -sf `which mkfs.msdos` /sbin/mkfs.vfat", FALSE);
-    }
-    tmp = call_program_and_get_last_line_of_output("free | grep Mem | head -n1 | tr -s ' ' '\t' | cut -f2");
-    if (atol(tmp) < 35000) {
-        retval++;
-        log_to_screen("You must have at least 32MB of RAM to use Mondo.");
-    }
-    if (atol(tmp) < 66000) {
-        log_to_screen("WARNING! You have very little RAM. Please upgrade to 64MB or more.");
-    }
-    mr_free(tmp);
-#endif
-
-    if (system("which " MKE2FS_OR_NEWFS " > /dev/null 2> /dev/null")) {
-        retval++;
-        log_to_screen("Unable to find " MKE2FS_OR_NEWFS " in system path.");
-        fatal_error("Please use \"su -\", not \"su\" to become root. OK?\n...and please don't e-mail the mailing list about this. Just read the message. :)");
-    }
-#ifndef __FreeBSD__
-    if (run_program_and_log_output("grep ramdisk /proc/devices", FALSE)) {
-        /* Some SuSE have ramdisk as modules, so insert it first, then test again */
-        run_program_and_log_output("modprobe brd 2> /dev/null > /dev/null",FALSE);
-        if (run_program_and_log_output("grep ramdisk /proc/devices", FALSE)) {
-            if (!ask_me_yes_or_no("Your kernel has no ramdisk support. That's mind-numbingly stupid but I'll allow it if you're planning to use another kernel. Are you?")) {
-                //          retval++;
-                log_to_screen("It looks as if your kernel lacks ramdisk and initrd support.");
-                log_to_screen("I'll allow you to proceed but FYI, if I'm right, your kernel is broken.");
-            }
-        }
-    }
-#endif
-    retval += whine_if_not_found(MKE2FS_OR_NEWFS);
-    if (system("which xorriso > /dev/null 2> /dev/null")) {
-        if (system("which genisoimage > /dev/null 2> /dev/null")) {
-            retval += whine_if_not_found("mkisofs");
-        }
-    }
-    if (system("which wodim > /dev/null 2> /dev/null")) {
-        retval += whine_if_not_found("cdrecord");
-    }
-    retval += whine_if_not_found("bzip2");
-    retval += whine_if_not_found("gzip");
-    retval += whine_if_not_found("cmp");
-    retval += whine_if_not_found("awk");
-    retval += whine_if_not_found("md5sum");
-    retval += whine_if_not_found("strings");
-    retval += whine_if_not_found("mindi");
-    retval += whine_if_not_found("buffer");
-
-    // abort if Windows partition but no ms-sys and parted
-    if (!run_program_and_log_output("mount | grep -Ew 'vfat|fat|dos' | grep -vE \"/dev/fd|nexdisk\"", 0)) {
-        if (!run_program_and_log_output("mount | grep -Ew 'vfat|fat|dos' | grep -Ew efi", 0)) {
-            log_to_screen("I think you have a EFI/UEFI partition.");
-        } else {
-            log_to_screen("I think you have a Windows 9x partition.");
-        }
-        retval += whine_if_not_found("parted");
-    }
-
-    run_program_and_log_output("umount `mount | grep cdr | cut -d' ' -f3 | tr '\n' ' '`", 5);
-    tmp = call_program_and_get_last_line_of_output("mount | grep -E 'cdr(om|w)'");
-    if (strcmp("", tmp)) {
-        if (strstr(tmp, "autofs")) {
-            log_to_screen("Your CD-ROM is mounted via autofs. I therefore cannot tell");
-            log_to_screen("if a CD actually is inserted. If a CD is inserted, please");
-            log_to_screen("eject it. Thank you.");
-            log_it("Ignoring autofs CD-ROM 'mount' since we hope nothing's in it.");
-        } else
-            if (run_program_and_log_output("uname -a | grep Knoppix", 5)) {
-            retval++;
-            mr_free(tmp);
-            fatal_error("Your CD-ROM drive is mounted. Please unmount it.");
-        }
-    }
-    mr_free(tmp);
-
-    run_program_and_log_output("cat /etc/fstab", 5);
-#ifdef __FreeBSD__
-    run_program_and_log_output("vinum printconfig", 5);
-#else
-    run_program_and_log_output("cat /etc/raidtab", 5);
-#endif
-
-    if (run_program_and_log_output("mindi -V", 1)) {
-        log_to_screen("Could not ascertain mindi's version number.");
-        log_to_screen("You have not installed Mondo and/or Mindi properly.");
-        log_to_screen("Please uninstall and reinstall them both.");
-        fatal_error("Please reinstall Mondo and Mindi.");
-    }
-    mr_asprintf(tmp, "mindi --makemountlist %s/mountlist.txt.test", bkpinfo->tmpdir);
-    if (run_program_and_log_output(tmp, 5)) {
-        log_to_screen("%s failed for some reason.", tmp);
-        mr_free(tmp);
-        log_to_screen("Please run that command by hand and examine "MINDI_LOGFILE);
-        log_to_screen("for more information. Perhaps your /etc/fstab file is insane.");
-        log_to_screen("Perhaps Mindi's MakeMountlist() subroutine has a bug. We'll see.");
-        retval++;
-    }
-    mr_free(tmp);
-
-    if (!run_program_and_log_output("mr-parted2fdisk -l 2>/dev/null | grep -i raid", 1) && !does_file_exist("/etc/raidtab")) {
-        log_to_screen("You have RAID partitions but no /etc/raidtab - creating one from /proc/mdstat");
-        create_raidtab_from_mdstat(MDSTAT_FILE,"/etc/raidtab");
-    }
-
-    if (retval) {
-        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
-    } else {
-        mvaddstr_and_log_it(g_currentY++, 74, "Done.");
-    }
-    return (retval);
-}
-
 /**
  * Retrieve the line containing @p label from the config file.

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

@@ -19 +19 @@
 #include "libmondo-devices-EXT.h"
 #include "libmondo-tools-EXT.h"
+#include "libmondo-filelist-EXT.h"
 
 
@@ -33 +34 @@
 extern char *g_getfattr;
 extern char *MONDO_LOGFILE;
+extern int g_current_media_number;
+extern long g_current_progress;
 
 /* Reference to global bkpinfo */
@@ -316 +319 @@
         } else if (does_file_exist(slice_fname(bigfile_num, slice_num, mountpoint, "")) &&
                    (length_of_file(slice_fname(bigfile_num, slice_num, mountpoint, "")) == 0)) {
-            log_msg(2, "ISO=%d  bigfile=%ld ---END---",
-                    g_current_media_number, bigfile_num);
+            log_msg(2, "ISO=%d  bigfile=%ld ---END---", g_current_media_number, bigfile_num);
             bigfile_num++;
             paranoid_fclose(forig);