Changeset 3877 in MondoRescue for branches/3.3/mondo/src/common/libmondo-stream.c

Timestamp:

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

Author:

Bruno Cornec

Message:

More compiler fixes

File:

• branches/3.3/mondo/src/common/libmondo-stream.c (modified) (9 diffs)

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);
-}
-
-
-
-
-
-
-
-