Changeset 1175 in MondoRescue

Timestamp:

Feb 16, 2007, 2:15:30 PM (17 years ago)

Author:

Bruno Cornec

Message:

Merge trunk memory management for libmondo-stream.c

File:

• branches/stable/mondo/src/common/libmondo-stream.c (modified) (66 diffs)

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

@@ -130 +130 @@
     }
     sleep(1);
-    paranoid_system("sync");
+    sync();
     sleep(1);
     paranoid_pclose(g_tape_stream);
     log_it("closein_tape() -- leaving");
-/*
-  for(i=0; i < g_tapecatalog->entries; i++)
-    {
-      log_it("i=%d type=%s num=%d aux=%ld", i, (g_tapecatalog->el[i].type==fileset)?"fileset":"bigslice", g_tapecatalog->el[i].number, g_tapecatalog->el[i].aux);
-    }
-*/
     if (!bkpinfo->please_dont_eject) {
         eject_device(bkpinfo->media_device);
@@ -161 +155 @@
     /*@ int's ******************************************************* */
     int retval = 0;
-//  int res = 0;
-//  int ctrl_chr = '\0';
-
-    /*@ buffers ***************************************************** */
-//  char fname[MAX_STR_LEN];
 
     /*@ long long's ************************************************* */
-//  long long size;
-    int i;
-    char *blk;
+    int i = 0;
+    char *blk = NULL;
 
     blk = (char *) mr_malloc(256 * 1024);
 
     sleep(1);
-    paranoid_system("sync");
+    sync();
     sleep(1);
     log_it("closeout_tape() -- entering");
@@ -182 +170 @@
                                      BLK_END_OF_BACKUP);
     retval += write_header_block_to_stream((off_t)0, "end-of-tape", BLK_END_OF_TAPE);   /* just in case */
-/* write 1MB of crap */
+    /* write 1MB of crap */
     for (i = 0; i < 256 * 1024; i++) {
         blk[i] = (int) (random() & 0xFF);
@@ -193 +181 @@
         }
     }
-/* write 1MB of zeroes */
-/*
-    for (i = 0; i < 256*1024; i++)
-      {
-        blk[i] = 0;
-      }
-    for (i = 0; i < 4; i++)
-      {
-        fwrite (blk, 1, 256*1024, g_tape_stream);
-        if (should_we_write_to_next_tape (bkpinfo->media_size[g_current_media_number], 256*1024))
-          {
-            start_to_write_to_next_tape (bkpinfo);
-          }
-      }
-*/
     sleep(2);
     paranoid_pclose(g_tape_stream);
@@ -218 +191 @@
                g_tapecatalog->el[i].tape_posK);
     }
-    //  if (!bkpinfo->please_dont_eject)
-    //    { eject_device(bkpinfo->media_device); }
     mr_free(blk);
     mr_free(g_tapecatalog);
@@ -232 +203 @@
     int res;
 
-    malloc_string(command);
-    sprintf(command, "mt -f %s status", dev);
+    mr_asprintf(&command, "mt -f %s status", dev);
     res = run_program_and_log_output(command, 1);
     mr_free(command);
@@ -255 +225 @@
 {
     char tmp[MAX_STR_LEN];
-    char command[MAX_STR_LEN * 2];
+    char *command = NULL;
     char cdr_exe[MAX_STR_LEN];
-//  char tape_description_[MAX_STR_LEN];
-//  char tape_manufacturer_cdr[MAX_STR_LEN];
-//  FILE*fin;
     int res;
 
@@ -269 +236 @@
         strcpy(cdr_exe, "dvdrecord");
     }
-    sprintf(command, "%s -scanbus 2> /dev/null | grep -i tape | wc -l",
+    mr_asprintf(&command, "%s -scanbus 2> /dev/null | grep -i tape | wc -l",
             cdr_exe);
     strcpy(tmp, call_program_and_get_last_line_of_output(command));
+    mr_free(command);
     if (atoi(tmp) != 1) {
         log_it
@@ -278 +246 @@
         return 1;
     }
-    sprintf(command,
+    mr_asprintf(&command,
             "%s -scanbus 2> /dev/null | tr -s '\t' ' ' | grep \"[0-9]*,[0-9]*,[0-9]*\" | grep -v \"[0-9]*) \\*\" | grep -i TAPE | cut -d' ' -f2 | head -n1",
             cdr_exe);
     strcpy(tmp, call_program_and_get_last_line_of_output(command));
+    mr_free(command);
     if (strlen(tmp) < 2) {
         log_it("Could not find tape device");
         return 1;
     }
-    sprintf(command,
+    mr_asprintf(&command,
             "%s -scanbus 2> /dev/null | tr -s '\t' ' ' | grep \"[0-9]*,[0-9]*,[0-9]*\" | grep -v \"[0-9]*) \\*\" | grep -i TAPE | cut -d' ' -f3 | cut -d')' -f1 | head -n1",
             cdr_exe);
     strcpy(tmp, call_program_and_get_last_line_of_output(command));
+    mr_free(command);
+
     strcpy(dev, VANILLA_SCSI_TAPE);
     dev[strlen(dev) - 1] = '\0';
@@ -350 +321 @@
 
 
-
-
-
-
 int read_EXAT_files_from_tape(struct s_bkpinfo *bkpinfo,
                               long long *ptmp_size, char *tmp_fname,
@@ -379 +346 @@
         mr_msg(1, "Got xattr");
     }
-// acl
+    // acl
     if (g_getfacl) {
         res = read_header_block_from_stream(ptmp_size, fname, pctrl_chr);
@@ -399 +366 @@
         mr_msg(1, "Got acl");
     }
-// tarball itself
+    // tarball itself
     res = read_header_block_from_stream(ptmp_size, tmp_fname, pctrl_chr);
     mr_msg(1, "now looking for afioball");
@@ -443 +410 @@
 {
     int i;
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
 
     log_it("Insisting on tape #%d", tapeno);
     if (g_current_media_number != tapeno) {
         //      log_it("g_current_media_number = %d", g_current_media_number);
-        sprintf(tmp,
-                "When the tape drive goes quiet, please insert volume %d in this series.",
-                tapeno);
+        mr_asprintf(&tmp,
+                 _("When the tape drive goes quiet, please insert volume %d in this series."),
+                 tapeno);
         popup_and_OK(tmp);
-        open_evalcall_form("Waiting while the tape drive settles");
-    } else {
-        open_evalcall_form("Waiting while the tape drive rewinds");
+        mr_free(tmp);
+        open_evalcall_form(_("Waiting while the tape drive settles"));
+    } else {
+        open_evalcall_form(_("Waiting while the tape drive rewinds"));
     }
 
@@ -470 +438 @@
 
 
-
-
 /**
  * Debugging aid - log the offset we're at on the tape (reading or writing).
@@ -477 +443 @@
 void log_tape_pos(void)
 {
-    /*@ buffers ***************************************************** */
-
-
-    /*@ end vars *************************************************** */
-
     log_it("Tape position -- %ld KB (%ld MB)", (long) g_tape_posK,
            (long) g_tape_posK >> 10);
 }
-
-
 
 
@@ -506 +465 @@
     int last, curr, i;
     t_archtype type = other;
-    char command[MAX_STR_LEN];
-    char tmpdir[MAX_STR_LEN];
-    char old_fname[MAX_STR_LEN];
-    char *p;
-    char suffix[16];
+    char *command = NULL;
+    char *tmpdir = NULL;
+    char *old_fname = NULL;
 
     bufsize_K = (long long) (1024LL * (1 + g_tape_buffer_size_MB));
-    sprintf(tmpdir, "%s/tmpfs/backcatalog", td);
-    if ((p = strrchr(latest_fname, '.'))) {
-        strcpy(suffix, ++p);
-    } else {
-        suffix[0] = '\0';
-    }
     if (strstr(latest_fname, ".afio.") || strstr(latest_fname, ".star.")) {
         type = fileset;
@@ -528 +479 @@
             ("Unknown type. Internal error in maintain_collection_of_recent_archives()");
     }
+
+    mr_asprintf(&tmpdir, "%s/tmpfs/backcatalog", td);
     mkdir(tmpdir, 0x700);
-    sprintf(command, "cp -f %s %s", latest_fname, tmpdir);
+    mr_asprintf(&command, "cp -f %s %s", latest_fname, tmpdir);
     if (run_program_and_log_output(command, 6)) {
         log_it("Warning - failed to copy %s to backcatalog at %s",
                latest_fname, tmpdir);
     }
+    mr_free(command);
+
     last = g_tapecatalog->entries - 1;
     if (last <= 0) {
@@ -556 +511 @@
 
     for (i = curr - 1; i >= 0 && curr - i < 10; i--) {
-        sprintf(old_fname, "%s/%s", tmpdir, g_tapecatalog->el[i].fname);
+        mr_asprintf(&old_fname, "%s/%s", tmpdir, g_tapecatalog->el[i].fname);
         unlink(old_fname);
-    }
+        mr_free(old_fname);
+    }
+    mr_free(tmpdir);
     return (0);
 }
-
-
 
 
@@ -575 +530 @@
     return (openin_tape(bkpinfo));
 }
-
-/**
- * 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];
-
 
 
@@ -595 +543 @@
         return (0);
     }
-    malloc_string(tmp);
-    sprintf(tmp, "mt -f %s setblk %ld", tapedev, internal_tape_block_size);
+    mr_asprintf(&tmp, "mt -f %s setblk %ld", tapedev,
+             internal_tape_block_size);
     res = run_program_and_log_output(tmp, 3);
     mr_free(tmp);
     return (res);
 }
-
 
 
@@ -616 +563 @@
     /*@ buffer ***************************************************** */
     char fname[MAX_STR_LEN];
-    char *datablock;
-    char tmp[MAX_STR_LEN];
+    char *datablock = NULL;
+    char *tmp = NULL;
     char old_cwd[MAX_STR_LEN];
-    char outfname[MAX_STR_LEN];
+    char *outfname = NULL;
     /*@ int ******************************************************* */
     int i;
@@ -646 +593 @@
     }
     insist_on_this_tape_number(1);
-    sprintf(outfname, "%s/tmp/all.tar.gz", bkpinfo->tmpdir);
+    mr_asprintf(&outfname, "%s/tmp/all.tar.gz", bkpinfo->tmpdir);
     make_hole_for_file(outfname);
 
@@ -652 +599 @@
                                 bkpinfo->internal_tape_block_size);
 
-//  start_buffer_process( bkpinfo->media_device, g_tape_fifo, FALSE);
     log_it("Opening IN tape");
     if (!
@@ -658 +604 @@
          open_device_via_buffer(bkpinfo->media_device, 'r',
                                 bkpinfo->internal_tape_block_size))) {
-        log_OS_error(g_tape_fifo);
-        log_to_screen("Cannot openin stream device");
+        log_to_screen(_("Cannot openin stream device"));
         return (1);
     }
-    log_to_screen("Reading stream");
+    log_to_screen(_("Reading stream"));
     log_it("stream device = '%s'", bkpinfo->media_device);
-/* skip data disks */
+    /* skip data disks */
     open_evalcall_form("Skipping data disks on stream");
-    log_to_screen("Skipping data disks on stream");
+    log_to_screen(_("Skipping data disks on stream"));
     if (!(fout = fopen(outfname, "w"))) {
         log_OS_error(outfname);
-        log_to_screen("Cannot openout datadisk all.tar.gz file");
+        log_to_screen(_("Cannot openout datadisk all.tar.gz file"));
         return (-1);
     }
@@ -690 +635 @@
     paranoid_fclose(fout);
     mr_free(datablock);
-/* find initial blocks */
+    /* find initial blocks */
     res = read_header_block_from_stream(&size, fname, &ctrl_chr);
     retval += res;
@@ -705 +650 @@
     (void) getcwd(old_cwd, MAX_STR_LEN);
     chdir(bkpinfo->tmpdir);
-    sprintf(tmp, "tar -zxf %s tmp/mondo-restore.cfg 2> /dev/null",
-            outfname);
+    mr_asprintf(&tmp, "tar -zxf %s tmp/mondo-restore.cfg 2> /dev/null",
+             outfname);
     paranoid_system(tmp);
+    mr_free(tmp);
     paranoid_system("cp -f tmp/mondo-restore.cfg . 2> /dev/null");
     chdir(old_cwd);
     unlink(outfname);
+    mr_free(outfname);
     return (retval);
 }
@@ -725 +672 @@
 {
     /*@ buffers ***************************************************** */
-    char command[MAX_STR_LEN * 2];
+    char *command = NULL;
 
     /*@ end vars *************************************************** */
 
-/*  add 'dummy' if testing */
-    sprintf(command,
-            "cdrecord -eject dev=%s speed=%d fs=24m -waiti - >> %s 2>> %s",
-            cddev, speed, MONDO_LOGFILE, MONDO_LOGFILE);
-/*  initialise the catalog */
+    /*  add 'dummy' if testing */
+    mr_asprintf(&command,
+             "cdrecord -eject dev=%s speed=%d fs=24m -waiti - >> %s 2>> %s",
+             cddev, speed, MONDO_LOGFILE, MONDO_LOGFILE);
+    /*  initialise the catalog */
     g_current_media_number = 1;
     g_tapecatalog = mr_malloc(sizeof(struct s_tapecatalog));
     g_tapecatalog->entries = 0;
-/* log stuff */
+    /* log stuff */
     log_it("Opening OUT cdstream with the command");
     log_it(command);
-/*  log_it("Let's see what happens, shall we?"); */
+    /*  log_it("Let's see what happens, shall we?"); */
     g_tape_stream = popen(command, "w");
+    mr_free(command);
     if (g_tape_stream) {
         return (0);
     } else {
-        log_to_screen("Failed to openout to cdstream (fifo)");
+        log_to_screen(_("Failed to openout to cdstream (fifo)"));
         return (1);
     }
 }
+
 
 /**
@@ -759 +708 @@
 int openout_tape(char *tapedev, long internal_tape_block_size)
 {
-//  char sz_call_to_buffer[MAX_STR_LEN];
-
     g_current_media_number = 1;
     if (g_tape_stream) {
@@ -775 +722 @@
         (g_tape_stream =
          open_device_via_buffer(tapedev, 'w', internal_tape_block_size))) {
-        log_OS_error(g_tape_fifo);
-        log_to_screen("Cannot openin stream device");
+        log_to_screen(_("Cannot openin stream device"));
         return (1);
     }
     return (0);
 }
-
-
 
 
@@ -806 +750 @@
     return (res);
 }
-
 
 
@@ -828 +771 @@
 
     res = read_file_from_stream_FULL(bkpinfo, NULL, fout, size);
-/*  fflush(g_tape_stream);
-  fflush(fout);*/
     return (res);
 }
-
 
 
@@ -852 +792 @@
 {
     /*@ buffers ***************************************************** */
-    char *tmp;
-    char *datablock;
+    char *tmp = NULL;
+    char *datablock = NULL;
     char *temp_fname;
     char *temp_cksum;
-    char *actual_cksum;
-//  char *pA, *pB;
+    char *actual_cksum = NULL;
 
     /*@ int ********************************************************* */
@@ -871 +810 @@
 
     /*@ long    ***************************************************** */
-    long bytes_to_write = 0 /*,i */ ;
-//  long bytes_successfully_read_in_this_time = 0;
+    long bytes_to_write = 0;
 
     /*@ long long *************************************************** */
@@ -880 +818 @@
     long long where_I_was_before_tape_change = 0;
     /*@ unsigned int ************************************************ */
-    /*  unsigned int ch; */
     unsigned int crc16;
     unsigned int crctt;
@@ -887 +824 @@
 
     /*@ init  ******************************************************* */
-    malloc_string(tmp);
     malloc_string(temp_fname);
     malloc_string(temp_cksum);
-    malloc_string(actual_cksum);
     datablock = mr_malloc(TAPE_BLOCK_SIZE);
     crc16 = 0;
@@ -900 +835 @@
     res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
     if (orig_size != temp_size && orig_size != -1) {
-        sprintf(tmp,
-                "output file's size should be %ld K but is apparently %ld K",
-                (long) size >> 10, (long) temp_size >> 10);
+        mr_asprintf(&tmp,
+                 "output file's size should be %ld K but is apparently %ld K",
+                 (long) size >> 10, (long) temp_size >> 10);
         log_to_screen(tmp);
+        mr_free(tmp);
     }
     if (ctrl_chr != BLK_START_FILE) {
@@ -909 +845 @@
         return (1);
     }
-    sprintf(tmp, "Reading file from tape; writing to '%s'; %ld KB",
-            outfname, (long) size >> 10);
+    mr_asprintf(&tmp, "Reading file from tape; writing to '%s'; %ld KB",
+             outfname, (long) size >> 10);
+    log_to_screen(tmp);
+    mr_free(tmp);
 
     if (foutstream) {
@@ -919 +857 @@
     if (!fout) {
         log_OS_error(outfname);
-        log_to_screen("Cannot openout file");
+        log_to_screen(_("Cannot openout file"));
         return (1);
     }
@@ -966 +904 @@
     mr_msg(6, ".......................... Should be %lld", orig_size);
     g_tape_posK += total_read_from_tape_for_this_file / 1024;
-    sprintf(actual_cksum, "%04x%04x", crc16, crctt);
+    mr_asprintf(&actual_cksum, "%04x%04x", crc16, crctt);
     if (foutstream) {           /*log_it("Finished writing to foutstream"); */
     } else {
@@ -977 +915 @@
     }
     if (strcmp(temp_cksum, actual_cksum)) {
-        sprintf(tmp, "actual cksum=%s; recorded cksum=%s", actual_cksum,
-                temp_cksum);
+        mr_asprintf(&tmp, _("actual cksum=%s; recorded cksum=%s"), actual_cksum,
+                 temp_cksum);
         log_to_screen(tmp);
-        sprintf(tmp, "%s (%ld K) is corrupt on tape", temp_fname,
-                (long) orig_size >> 10);
+        mr_free(tmp);
+
+        mr_asprintf(&tmp, _("%s (%ld K) is corrupt on tape"), temp_fname,
+                 (long) orig_size >> 10);
         log_to_screen(tmp);
+        mr_free(tmp);
         retval++;
-    } else {
-        sprintf(tmp, "%s is GOOD on tape", temp_fname);
-        /*      log_it(tmp); */
-    }
+    }
+    mr_free(actual_cksum);
     mr_free(datablock);
-    mr_free(tmp);
     mr_free(temp_fname);
     mr_free(temp_cksum);
-    mr_free(actual_cksum);
     return (retval);
 }
-
 
 
@@ -1031 +967 @@
                   g_tape_stream) / 1024;
     }
-/*  memcpy((char*)plength_of_incoming_file,(char*)tempblock+7001,sizeof(long long)); */
-/*  for(*plen=0,i=7;i>=0;i--) {*plen<<=8; *plen |= tempblock[7001+i];} */
     memcpy((char *) plen, tempblock + 7001, sizeof(long long));
     if (strcmp(tempblock + 6000 + *pcontrol_char, "Mondolicious, baby")) {
@@ -1038 +972 @@
     }
     strcpy(filename, tempblock + 1000);
-/*  strcpy(cksum,tempblock+5555);*/
-/*  log_it( "%s  (reading) fname=%s, filesize=%ld K",
-       marker_to_string (*pcontrol_char), filename,
-       (long) ((*plen) >> 10));
-*/
     if (*pcontrol_char == BLK_ABORTED_BACKUP) {
         log_to_screen("I can't verify an aborted backup.");
@@ -1061 +990 @@
     return (retval);
 }
-
 
 
@@ -1107 +1035 @@
 
 
-
-
 /**
  * Decide whether we should start a new tape. This is TRUE if we've run out of tape
@@ -1134 +1060 @@
         log_it("mediasize = %ld", mediasize);
         we_need_a_new_tape = TRUE;
-        log_to_screen("Should have started a new tape/CD already");
+        log_to_screen(_("Should have started a new tape/CD already"));
     }
     if ((g_tape_posK + length_of_incoming_file / 1024) >> 10 >=
@@ -1280 +1206 @@
 
     paranoid_pclose(g_tape_stream);
-    system("sync");
-    system("sync");
-    system("sync");
+    sync();
+    sync();
+    sync();
     log_it("Next tape requested.");
     insist_on_this_tape_number(g_current_media_number + 1); // will increment it, too
@@ -1290 +1216 @@
          open_device_via_buffer(bkpinfo->media_device, 'r',
                                 bkpinfo->internal_tape_block_size))) {
-        log_OS_error(g_tape_fifo);
-        log_to_screen("Cannot openin stream device");
+        log_to_screen(_("Cannot openin stream device"));
         return (1);
     }
@@ -1311 +1236 @@
 
 
-
 /**
  * Start to write to the next tape. Assume the user has already inserted it.
@@ -1320 +1244 @@
 {
     int res = 0;
-    char command[MAX_STR_LEN * 2];
+    char *command = NULL;
+
     paranoid_pclose(g_tape_stream);
-    system("sync");
-    system("sync");
-    system("sync");
+    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 (g_current_media_number > MAX_NOOF_MEDIA) {
         res++;
-        log_to_screen("Too many tapes. Man, you need to use nfs!");
+        log_to_screen(_("Too many tapes. Man, you need to use nfs!"));
     }
     if (bkpinfo->backup_media_type == cdstream) {
-        sprintf(command,
-                "cdrecord -eject dev=%s speed=%d fs=24m -waiti - >> %s 2>> %s",
-                bkpinfo->media_device, bkpinfo->cdrw_speed, MONDO_LOGFILE,
-                MONDO_LOGFILE);
+        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)");
+            log_to_screen(_("Failed to openout to cdstream (fifo)"));
             return (1);
         }
@@ -1350 +1276 @@
              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");
+            log_to_screen(_("Cannot openin stream device"));
             return (1);
         }
@@ -1361 +1286 @@
     return (res);
 }
-
-
 
 
@@ -1380 +1303 @@
 {
     int i, last, res = 0;
-    char *fname;
+    char *fname = NULL;
 
     mr_msg(2, "I am now writing back catalog to tape");
-    malloc_string(fname);
     last = g_tapecatalog->entries - 1;
     for (i = 0; i <= last; i++) {
-        sprintf(fname, "%s/tmpfs/backcatalog/%s", bkpinfo->tmpdir,
-                g_tapecatalog->el[i].fname);
+        mr_asprintf(&fname, "%s/tmpfs/backcatalog/%s", bkpinfo->tmpdir,
+                 g_tapecatalog->el[i].fname);
         if (!does_file_exist(fname)) {
             mr_msg(6, "Can't write %s - it doesn't exist.", fname);
@@ -1405 +1327 @@
             }
         }
-    }
-    mr_free(fname);
+        mr_free(fname);
+    }
     mr_msg(2, "Finished writing back catalog to tape");
     return (res);
@@ -1412 +1334 @@
 
 
-
 /**
  * Write all.tar.gz (produced by Mindi) to the first 32M of the first tape.
@@ -1421 +1342 @@
 {
     /*@ pointers *************************************************** */
-    FILE *fin;
-    char tmp[MAX_STR_LEN];
+    FILE *fin = NULL;
+    char *tmp = NULL;
 
     /*@ long ******************************************************* */
@@ -1436 +1357 @@
     /*@ end vars *************************************************** */
 
-    open_evalcall_form("Writing data disks to tape");
-    log_to_screen("Writing data disks to tape");
+    open_evalcall_form(_("Writing data disks to tape"));
+    log_to_screen(_("Writing data disks to tape"));
     log_it("Data disks = %s", fname);
     if (!does_file_exist(fname)) {
-        sprintf(tmp, "Cannot find %s", fname);
+        mr_asprintf(&tmp, _("Cannot find %s"), fname);
         log_to_screen(tmp);
+        mr_free(tmp);
         return (1);
     }
@@ -1473 +1395 @@
 
 
-
-
 /**
  * Copy @p infile to the opened stream (CD or tape).
@@ -1484 +1404 @@
 {
     /*@ buffers **************************************************** */
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
     char datablock[TAPE_BLOCK_SIZE];
-    char checksum[MAX_STR_LEN];
-    char *infile_basename;
+    char *checksum = NULL;
+    char *infile_basename = NULL;
 
     /*@ int ******************************************************** */
@@ -1514 +1434 @@
     crc16 = 0;
     crctt = 0;
-
-
 
     /*@ end vars *************************************************** */
@@ -1537 +1455 @@
         p++;
     }
-    sprintf(tmp, "Writing file '%s' to tape (%ld KB)", p,
-            (long) filesize >> 10);
+    mr_asprintf(&tmp, "Writing file '%s' to tape (%ld KB)", p,
+             (long) filesize >> 10);
     log_it(tmp);
+    mr_free(tmp);
+
     write_header_block_to_stream(filesize, infile_basename,
                                  BLK_START_FILE);
@@ -1558 +1478 @@
         }
         (void) fread(datablock, 1, (size_t) bytes_to_read, fin);
-        g_tape_posK +=
-            fwrite(datablock, 1, /*bytes_to_read */ 
-                   (size_t) TAPE_BLOCK_SIZE,
-                   g_tape_stream) / 1024;
+        g_tape_posK += fwrite(datablock, 1, /*bytes_to_read */
+                              (size_t) TAPE_BLOCK_SIZE,
+                              g_tape_stream) / 1024;
         if (g_sigpipe) {
             iamhere("Sigpipe occurred recently. I'll start a new tape.");
@@ -1579 +1498 @@
     }
     paranoid_fclose(fin);
-    sprintf(checksum, "%04x%04x", crc16, crctt);
+    mr_asprintf(&checksum, "%04x%04x", crc16, crctt);
     /* BERLIOS: 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);
 }
-
-
-
 
 
@@ -1608 +1525 @@
     /*@ buffers **************************************************** */
     char tempblock[TAPE_BLOCK_SIZE];
-    char tmp[MAX_STR_LEN];
     char *p;
 
@@ -1628 +1544 @@
     if (!g_tape_stream) {
         log_to_screen
-            ("You're not backing up to tape. Why write a tape header?");
+            (_("You're not backing up to tape. Why write a tape header?"));
         return (1);
     }
@@ -1636 +1552 @@
     sprintf(tempblock + 6000 + control_char, "Mondolicious, baby");
     tempblock[7000] = control_char;
-/*  for(i=0;i<8;i++) {tempblock[7001+i]=olen&0xff; olen>>=8;} */
     memcpy(tempblock + 7001, (char *) &olen, sizeof(off_t));
-/*  if (length_of_incoming_file) {memcpy(tempblock+7001,(char*)&length_of_incoming_file,sizeof(long long));} */
     strcpy(tempblock + 1000, filename);
-/*  strcpy(tempblock+5555,cksum); */
     g_tape_posK +=
         fwrite(tempblock, 1, (size_t) TAPE_BLOCK_SIZE,
                g_tape_stream) / 1024;
-    sprintf(tmp, "%s (fname=%s, size=%ld K)",
+    mr_msg(6, "%s (fname=%s, size=%ld K)",
             marker_to_string(control_char), p,
             (long) length_of_incoming_file >> 10);
-    mr_msg(6, tmp);
-/*  log_tape_pos(); */
     return (0);
 }
-
-
-
-
-
-
-
-
 
 
@@ -1669 +1572 @@
 {
     /*@ buffer ***************************************************** */
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
 
 
     /*@ end vars *************************************************** */
-    sprintf(tmp, "Wrong marker! (Should be %s, ",
-            marker_to_string(should_be));
-    sprintf(tmp + strlen(tmp), "is actually %s)", marker_to_string(it_is));
+    mr_asprintf(&tmp, _("Wrong marker! (Should be %s, is actually %s)"),
+             marker_to_string(should_be), marker_to_string(it_is));
     log_to_screen(tmp);
+    mr_free(tmp);
 }