Changeset 122 in MondoRescue for trunk/mondo/mondo

Timestamp:

Nov 15, 2005, 12:01:12 AM (18 years ago)

Author:

bcornec

Message:

memory management going on (libmondo-verify.c, libmondo-devices.c, libmondo-string.c, libmondo-stream.c)

Location:

trunk/mondo/mondo/common

Files:

• X-specific.h (modified) (1 diff)
• libmondo-devices.c (modified) (1 diff)
• libmondo-stream.c (modified) (78 diffs)
• libmondo-string.c (modified) (1 diff)
• libmondo-verify.c (modified) (17 diffs)
• mondostructures.h (modified) (2 diffs)
• my-stuff.h (modified) (1 diff)

trunk/mondo/mondo/common/X-specific.h

@@ -1 +1 @@
 /* X-specific.h */
-
-#include <config.h>
 
 #ifdef __cplusplus

trunk/mondo/mondo/common/libmondo-devices.c

@@ -1829 +1829 @@
     malloc_string(command);
     malloc_string(comment);
-    malloc_string(prompt);
     assert(bkpinfo != NULL);
     sz_size[0] = '\0';

trunk/mondo/mondo/common/libmondo-stream.c

@@ -1 @@
-/* libmondo-stream.c
-   $Id$
+/* $Id$
 
 ...tools for talking to tapes, Monitas streams, etc.
-
-
-07/10
-- added ACL and XATTR support
-
-04/17
-- added bkpinfo->internal_tape_block_size
-- fixed bug in set_tape_block_size_with_mt()
-
-03/25
-- call 'mt' when opening tape in/out, to set block size to 32K
-
-02/06/2004
-- only eject_device() at end of closein_tape() --- not closeout_tape()
-
-10/26/2003
-- call eject_device() at end of closein_tape() and closeout_tape()
- 
-09/25
-- added docu-header to each subroutine
-
-09/20
-- working on multi-tape code
-- friendlier message in insist_on_this_tape_number()
-- delay is now 5s
-
-09/10
-- adding multi-tape support
-- adding 'back catalog' of previous archives, so that we may resume
-  from point of end-of-tape (approx.)
-
-09/08
-- cleaned up insist_on_this_tape_number() --- 10s delay for same tape now
-
-08/27
-- improved find_tape_device_and_size() --- tries /dev/osst*
-
-05/05
-- added Joshua Oreman's FreeBSD patches
-
-04/24
-- added lots of assert()'s and log_OS_error()'s
-
-04/06/2003
-- use find_home_of_exe() instead of which
-
-12/13/2002
-- cdrecord -scanbus call was missing 2> /dev/null
-
-11/24
-- disabled fatal_error("Bad marker")
-
-10/29
-- replaced convoluted grep wih wc (KP)
-
-09/07
-- removed g_end_of_tape_reached
-- lots of multitape-related fixes
-
-08/01 - 08/31
-- write 16MB of zeroes to end of tape when closing(out)
-- compensate for 'buffer' and its distortion of speed of writing/reading
-  when writing/reading data disks at start of tape
-- rewrote lots of multitape stuff
-- wrote workaround to allow >2GB of archives w/buffering
-- do not close/reopen tape when starting to read/write from
-  new tape: no need! 'buffer' handles all that; we're writing
-  to/reading from a FIFO, so no need to close/reopen when new tape
-- write 8MB of zeroes at end of tape, just in case
-- re-enable various calls to *_evalcall_form
-- added g_end_of_tape_reached
-- fixed bugs in start_to_[read|write]_[to|from]_next_tape
-- added internal buffering, replacing the external 'buffer' exe
-- wait 10 seconds (after user inserts new tape), to
-  let tape stabilize in drive
-- added insist_on_this_tape_number()
-- worked on find_tape_device_and_size()
-- cleaned up some log_it() calls
-- added find_tape_device_and_size()
-- replaced using_cdstream with backup_media_type
-- replace *_from_tape with *_from_stream
-- replace *_to_stream with *_to_stream
-
-07/01 - 07/31
-- leave 32MB at end of tape, to avoid overrunning
-- started [07/24/2002]
 */
 
-
-/**
+/*
+ *
  * @file
  * Functions for writing data to/reading data from streams (tape, CD stream, etc.)
@@ -185 +98 @@
     int ctrl_chr = '\0';
 
-    /*@ buffers ***************************************************** */
-    char fname[MAX_STR_LEN];
-
     /*@ long long's ************************************************* */
     long long size;
@@ -196 +106 @@
 
     log_it("closein_tape() -- entering");
-    res = read_header_block_from_stream(&size, fname, &ctrl_chr);
+    res = read_header_block_from_stream(&size, NULL, &ctrl_chr);
     retval += res;
     if (ctrl_chr != BLK_END_OF_BACKUP) {
         wrong_marker(BLK_END_OF_BACKUP, ctrl_chr);
     }
-    res = read_header_block_from_stream(&size, fname, &ctrl_chr);
+    res = read_header_block_from_stream(&size, NULL, &ctrl_chr);
     retval += res;
     if (ctrl_chr != BLK_END_OF_TAPE) {
@@ -214 +124 @@
     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);
@@ -241 +145 @@
     /*@ 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;
@@ -262 +160 @@
                                      BLK_END_OF_BACKUP);
     retval += write_header_block_to_stream(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);
@@ -273 +171 @@
         }
     }
-/* 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);
@@ -298 +181 @@
                g_tapecatalog->el[i].tape_posK);
     }
-    //  if (!bkpinfo->please_dont_eject)
-    //    { eject_device(bkpinfo->media_device); }
     paranoid_free(blk);
     paranoid_free(g_tapecatalog);
@@ -312 +193 @@
     int res;
 
-    malloc_string(command);
-    sprintf(command, "mt -f %s status", dev);
+    asprintf(&command, "mt -f %s status", dev);
     res = run_program_and_log_output(command, 1);
     paranoid_free(command);
@@ -334 +214 @@
 int find_tape_device_and_size(char *dev, char *siz)
 {
-    char tmp[MAX_STR_LEN];
-    char command[MAX_STR_LEN * 2];
-    char cdr_exe[MAX_STR_LEN];
-//  char tape_description_[MAX_STR_LEN];
-//  char tape_manufacturer_cdr[MAX_STR_LEN];
-//  FILE*fin;
+    char *tmp;
+    char *command;
+    char *cdr_exe;
     int res;
 
@@ -345 +222 @@
     dev[0] = siz[0] = '\0';
     if (find_home_of_exe("cdrecord")) {
-        strcpy(cdr_exe, "cdrecord");
-    } else {
-        strcpy(cdr_exe, "dvdrecord");
-    }
-    sprintf(command, "%s -scanbus 2> /dev/null | grep -i tape | wc -l",
+        asprintf(&cdr_exe, "cdrecord");
+    } else {
+        asprintf(&cdr_exe, "dvdrecord");
+    }
+    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));
+    asprintf(&tmp, call_program_and_get_last_line_of_output(command));
+    paranoid_free(command);
+
     if (atoi(tmp) != 1) {
         log_it
@@ -358 +237 @@
         return 1;
     }
-    sprintf(command,
+    paranoid_free(tmp);
+
+    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));
+    asprintf(&tmp, call_program_and_get_last_line_of_output(command));
+    paranoid_free(command);
     if (strlen(tmp) < 2) {
         log_it("Could not find tape device");
         return 1;
     }
-    sprintf(command,
+    paranoid_free(tmp);
+
+    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));
+    paranoid_free(cdr_exe);
+
+    asprintf(&tmp, call_program_and_get_last_line_of_output(command));
+    paranoid_free(command);
     strcpy(dev, VANILLA_SCSI_TAPE);
     dev[strlen(dev) - 1] = '\0';
     strcat(dev, tmp);           // e.g. '/dev/st0' becomes '/dev/stN'
+    paranoid_free(tmp);
+
     res = 0;
     if (!mt_says_tape_exists(dev)) {
@@ -393 +282 @@
     log_it("At this point, dev = %s and res = %d", dev, res);
 
-    strcpy(tmp, call_program_and_get_last_line_of_output("\
+    asprintf(&tmp, call_program_and_get_last_line_of_output("\
 cdrecord -scanbus 2> /dev/null | tr -s '\t' ' ' | \
 grep \"[0-9]*,[0-9]*,[0-9]*\" | grep -v \"[0-9]*) \\*\" | grep -i TAPE | \
@@ -402 +291 @@
     } else {
         log_it("Turning %s", dev);
-        strcpy(tmp, (strrchr(dev, '/') != NULL) ? strrchr(dev, '/') : dev);
+        paranoid_free(tmp);
+        asprintf(&tmp, (strrchr(dev, '/') != NULL) ? strrchr(dev, '/') : dev);
         sprintf(dev, "/dev/os%s", tmp);
         log_it("...into %s", dev);
@@ -427 +317 @@
         return (0);
     }
-}
-
-
-
-
-
+    paranoid_free(tmp);
+}
 
 int read_EXAT_files_from_tape(struct s_bkpinfo *bkpinfo,
@@ -441 +327 @@
     int res = 0;
     int retval = 0;
+    char *fname = &res;     /* Should NOT be NULL */
 
 // xattr
-    res = read_header_block_from_stream(ptmp_size, tmp_fname, pctrl_chr);
+    res = read_header_block_from_stream(ptmp_size, fname, pctrl_chr);
     if (*pctrl_chr != BLK_START_EXAT_FILE) {
         wrong_marker(BLK_START_EXAT_FILE, *pctrl_chr);
     }
-    if (!strstr(tmp_fname, "xattr")) {
+    if (!strstr(fname, "xattr")) {
         fatal_error("Wrong order, sunshine.");
     }
+    paranoid_free(fname);
+    fname = &res;
     read_file_from_stream_to_file(bkpinfo, xattr_fname, *ptmp_size);
-    res = read_header_block_from_stream(ptmp_size, tmp_fname, pctrl_chr);
+    res = read_header_block_from_stream(ptmp_size, NULL, pctrl_chr);
     if (*pctrl_chr != BLK_STOP_EXAT_FILE) {
         wrong_marker(BLK_STOP_EXAT_FILE, *pctrl_chr);
     }
-// acl
-    res = read_header_block_from_stream(ptmp_size, tmp_fname, pctrl_chr);
-    if (!strstr(tmp_fname, "acl")) {
+    // acl
+    res = read_header_block_from_stream(ptmp_size, fname, pctrl_chr);
+    if (!strstr(fname, "acl")) {
         fatal_error("Wrong order, sunshine.");
     }
+    paranoid_free(fname);
+    fname = &res;
     if (*pctrl_chr != BLK_START_EXAT_FILE) {
         wrong_marker(BLK_START_EXAT_FILE, *pctrl_chr);
     }
     read_file_from_stream_to_file(bkpinfo, acl_fname, *ptmp_size);
-    res = read_header_block_from_stream(ptmp_size, tmp_fname, pctrl_chr);
+    res = read_header_block_from_stream(ptmp_size, NULL, pctrl_chr);
     if (*pctrl_chr != BLK_STOP_EXAT_FILE) {
         wrong_marker(BLK_STOP_EXAT_FILE, *pctrl_chr);
     }
-    res = read_header_block_from_stream(ptmp_size, tmp_fname, pctrl_chr);
+    res = read_header_block_from_stream(ptmp_size, NULL, pctrl_chr);
     if (*pctrl_chr != BLK_STOP_EXTENDED_ATTRIBUTES) {
         wrong_marker(BLK_STOP_EXTENDED_ATTRIBUTES, *pctrl_chr);
     }
-// tarball itself
-    res = read_header_block_from_stream(ptmp_size, tmp_fname, pctrl_chr);
+    // tarball itself
+    res = read_header_block_from_stream(ptmp_size, fname, pctrl_chr);
     log_msg(1, "Got xattr and acl; now looking for afioball");
+    tmp_fname = fname;
     return (retval);
 }
@@ -483 +375 @@
 {
     int res = 0;
-// EXATs
+    // EXATs
     write_header_block_to_stream(length_of_file(xattr_fname), xattr_fname,
                                  BLK_START_EXTENDED_ATTRIBUTES);
-// xattr
+    // xattr
     write_header_block_to_stream(length_of_file(xattr_fname), xattr_fname,
                                  BLK_START_EXAT_FILE);
@@ -513 +405 @@
 {
     int i;
-    char tmp[MAX_STR_LEN];
+    char *tmp;
 
     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,
+        asprintf(&tmp,
                 "When the tape drive goes quiet, please insert volume %d in this series.",
                 tapeno);
         popup_and_OK(tmp);
+        paranoid_free(tmp);
         open_evalcall_form("Waiting while the tape drive settles");
     } else {
@@ -540 +433 @@
 
 
-
-
 /**
  * Debugging aid - log the offset we're at on the tape (reading or writing).
@@ -547 +438 @@
 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);
@@ -576 +462 @@
     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 *command;
+    char *tmpdir;
+    char *old_fname;
     char *p;
+    /* BERLIOS: useless
     char suffix[16];
+    */
 
     bufsize_K = (long long) (1024LL * (1 + g_tape_buffer_size_MB));
-    sprintf(tmpdir, "%s/tmpfs/backcatalog", td);
+    asprintf(&tmpdir, "%s/tmpfs/backcatalog", td);
+    /* BERLIOS: useless
     if ((p = strrchr(latest_fname, '.'))) {
         strcpy(suffix, ++p);
@@ -589 +478 @@
         suffix[0] = '\0';
     }
+    */
     if (strstr(latest_fname, ".afio.") || strstr(latest_fname, ".star.")) {
         type = fileset;
@@ -599 +489 @@
     }
     mkdir(tmpdir, 0x700);
-    sprintf(command, "cp -f %s %s", latest_fname, tmpdir);
+    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);
     }
+    paranoid_free(command);
+
     last = g_tapecatalog->entries - 1;
     if (last <= 0) {
@@ -626 +518 @@
 
     for (i = curr - 1; i >= 0 && curr - i < 10; i--) {
-        sprintf(old_fname, "%s/%s", tmpdir, g_tapecatalog->el[i].fname);
+        asprintf(&old_fname, "%s/%s", tmpdir, g_tapecatalog->el[i].fname);
         unlink(old_fname);
-    }
+        paranoid_free(old_fname);
+    }
+    paranoid_free(tmpdir);
     return (0);
 }
-
-
 
 
@@ -646 +538 @@
 }
 
+
 /**
  * FIFO used to read/write to the tape device.
@@ -651 +544 @@
  */
 char g_tape_fifo[MAX_STR_LEN];
-
-
 
 int set_tape_block_size_with_mt(char *tapedev,
@@ -665 +556 @@
         return (0);
     }
-    malloc_string(tmp);
-    sprintf(tmp, "mt -f %s setblk %ld", tapedev, internal_tape_block_size);
+    asprintf(&tmp, "mt -f %s setblk %ld", tapedev, internal_tape_block_size);
     res = run_program_and_log_output(tmp, 3);
     paranoid_free(tmp);
     return (res);
 }
-
 
 
@@ -685 +574 @@
 {
     /*@ buffer ***************************************************** */
-    char fname[MAX_STR_LEN];
     char *datablock;
-    char tmp[MAX_STR_LEN];
+    char *tmp;
     char old_cwd[MAX_STR_LEN];
-    char outfname[MAX_STR_LEN];
+    char *outfname;
     /*@ int ******************************************************* */
     int i;
@@ -718 +606 @@
     }
     insist_on_this_tape_number(1);
-    sprintf(outfname, "%s/tmp/all.tar.gz", bkpinfo->tmpdir);
+    asprintf(&outfname, "%s/tmp/all.tar.gz", bkpinfo->tmpdir);
     make_hole_for_file(outfname);
 
@@ -765 +653 @@
     paranoid_fclose(fout);
     paranoid_free(datablock);
-/* find initial blocks */
-    res = read_header_block_from_stream(&size, fname, &ctrl_chr);
+    /* find initial blocks */
+    res = read_header_block_from_stream(&size, NULL, &ctrl_chr);
     retval += res;
     if (ctrl_chr != BLK_START_OF_TAPE) {
         wrong_marker(BLK_START_OF_TAPE, ctrl_chr);
     }
-    res = read_header_block_from_stream(&size, fname, &ctrl_chr);
+    res = read_header_block_from_stream(&size, NULL, &ctrl_chr);
     retval += res;
     if (ctrl_chr != BLK_START_OF_BACKUP) {
@@ -780 +668 @@
     (void) getcwd(old_cwd, MAX_STR_LEN);
     chdir(bkpinfo->tmpdir);
-    sprintf(tmp, "tar -zxf %s tmp/mondo-restore.cfg 2> /dev/null",
+    asprintf(&tmp, "tar -zxf %s tmp/mondo-restore.cfg 2> /dev/null",
             outfname);
     paranoid_system(tmp);
+    paranoid_free(tmp);
     paranoid_system("cp -f tmp/mondo-restore.cfg . 2> /dev/null");
     chdir(old_cwd);
     unlink(outfname);
+    paranoid_free(outfname);
     return (retval);
 }
@@ -800 +690 @@
 {
     /*@ buffers ***************************************************** */
-    char command[MAX_STR_LEN * 2];
+    char command;
 
     /*@ end vars *************************************************** */
 
-/*  add 'dummy' if testing */
-    sprintf(command,
+    /*  add 'dummy' if testing */
+    asprintf(&command,
             "cdrecord -eject dev=%s speed=%d fs=24m -waiti - >> %s 2>> %s",
             cddev, speed, MONDO_LOGFILE, MONDO_LOGFILE);
-/*  initialise the catalog */
+    /*  initialise the catalog */
     g_current_media_number = 1;
     if (!(g_tapecatalog = malloc(sizeof(struct s_tapecatalog)))) {
@@ -814 +704 @@
     }
     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");
+    paranoid_free(command);
     if (g_tape_stream) {
         return (0);
@@ -827 +718 @@
 }
 
+
 /**
  * Start writing to a tape device for the backup.
@@ -836 +728 @@
 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) {
@@ -862 +752 @@
 
 
-
-
 /**
  * Copy a file from the opened stream (CD or tape) to @p outfile.
@@ -885 +773 @@
     return (res);
 }
-
 
 
@@ -907 +794 @@
 
     res = read_file_from_stream_FULL(bkpinfo, NULL, fout, size);
-/*  fflush(g_tape_stream);
-  fflush(fout);*/
     return (res);
 }
-
 
 
@@ -933 +817 @@
     char *tmp;
     char *datablock;
-    char *temp_fname;
-    char *temp_cksum;
+    char *temp_fname = bkpinfo;     /* Should NOT be NULL */
+    char *temp_cksum = bkpinfo;     /* Should NOT be NULL */
     char *actual_cksum;
-//  char *pA, *pB;
 
     /*@ int ********************************************************* */
@@ -950 +833 @@
 
     /*@ long    ***************************************************** */
-    long bytes_to_write = 0 /*,i */ ;
-//  long bytes_successfully_read_in_this_time = 0;
+    long bytes_to_write = 0;
 
     /*@ long long *************************************************** */
@@ -959 +841 @@
     long long where_I_was_before_tape_change = 0;
     /*@ unsigned int ************************************************ */
-    /*  unsigned int ch; */
     unsigned int crc16;
     unsigned int crctt;
@@ -966 +847 @@
 
     /*@ init  ******************************************************* */
-    malloc_string(tmp);
-    malloc_string(temp_fname);
-    malloc_string(temp_cksum);
-    malloc_string(actual_cksum);
     datablock = malloc(TAPE_BLOCK_SIZE);
     crc16 = 0;
@@ -979 +856 @@
     res = read_header_block_from_stream(&temp_size, temp_fname, &ctrl_chr);
     if (orig_size != temp_size && orig_size != -1) {
-        sprintf(tmp,
+        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);
+        paranoid_free(tmp);
     }
     if (ctrl_chr != BLK_START_FILE) {
@@ -988 +866 @@
         return (1);
     }
-    sprintf(tmp, "Reading file from tape; writing to '%s'; %ld KB",
+    asprintf(&tmp, "Reading file from tape; writing to '%s'; %ld KB",
             outfname, (long) size >> 10);
+    log_to_screen(tmp);
+    paranoid_free(tmp);
 
     if (foutstream) {
@@ -1045 +925 @@
     log_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);
+    asprintf(&actual_cksum, "%04x%04x", crc16, crctt);
     if (foutstream) {           /*log_it("Finished writing to foutstream"); */
     } else {
@@ -1056 +936 @@
     }
     if (strcmp(temp_cksum, actual_cksum)) {
-        sprintf(tmp, "actual cksum=%s; recorded cksum=%s", actual_cksum,
+        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,
+        paranoid_free(tmp);
+
+        asprintf(&tmp, "%s (%ld K) is corrupt on tape", temp_fname,
                 (long) orig_size >> 10);
         log_to_screen(tmp);
+        paranoid_free(tmp);
         retval++;
-    } else {
-        sprintf(tmp, "%s is GOOD on tape", temp_fname);
-        /*      log_it(tmp); */
-    }
+    }
+    paranoid_free(actual_cksum);
     paranoid_free(datablock);
-    paranoid_free(tmp);
     paranoid_free(temp_fname);
     paranoid_free(temp_cksum);
-    paranoid_free(actual_cksum);
     return (retval);
 }
-
 
 
@@ -1110 +988 @@
                   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")) {
         log_it("Bad header block at %ld K", (long) g_tape_posK);
     }
-    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));
-*/
+    /* the caller manages whether we should allocate or not 
+     * by setting the value to NULL (do not allocate) or 
+     * something (allocate) */
+    if (filename != NULL) {
+        asprintf(&filename, tempblock + 1000);
+    }
     if (*pcontrol_char == BLK_ABORTED_BACKUP) {
         log_to_screen("I can't verify an aborted backup.");
@@ -1140 +1016 @@
     return (retval);
 }
-
 
 
@@ -1186 +1061 @@
 
 
-
-
 /**
  * Decide whether we should start a new tape. This is TRUE if we've run out of tape
@@ -1237 +1110 @@
     int res;
     int ctrl_chr;
-    char *temp_fname;
+    char *temp_fname = &res;        /* should NOT be NULL */
     char *datablock;
     long long temp_size, size;
@@ -1243 +1116 @@
 
     datablock = malloc(TAPE_BLOCK_SIZE);
-    malloc_string(temp_fname);
     pB = strrchr(the_file_I_was_reading, '/');
     if (pB) {
@@ -1263 +1135 @@
         wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
         log_msg(3, "Still trying to re-sync w/ tape");
+        paranoid_free(temp_fname);
+        temp_fname = &res;
     }
     while (ctrl_chr != BLK_START_FILE) {
@@ -1274 +1148 @@
         wrong_marker(BLK_START_FILE, ctrl_chr);
         log_msg(3, "Still trying to re-sync w/ tape");
+        /* Do not desallocate when the while condition is met */
+        if (ctrl_chr != BLK_START_FILE) {
+            paranoid_free(temp_fname);
+            temp_fname = &res;
+        }
     }
     pA = strrchr(temp_fname, '/');
@@ -1296 +1175 @@
             fread(datablock, 1, (size_t) TAPE_BLOCK_SIZE, g_tape_stream);
         }
+        
+        paranoid_free(temp_fname);
+        temp_fname = &res;
         res =
-            read_header_block_from_stream(&temp_size, temp_fname,
+            read_header_block_from_stream(&temp_size, NULL,
                                           &ctrl_chr);
         if (ctrl_chr != BLK_STOP_FILE) {
@@ -1303 +1185 @@
         }
         res =
-            read_header_block_from_stream(&temp_size, temp_fname,
+            read_header_block_from_stream(&temp_size, NULL,
                                           &ctrl_chr);
         if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
@@ -1309 +1191 @@
         }
         res =
-            read_header_block_from_stream(&temp_size, temp_fname,
+            read_header_block_from_stream(&temp_size, NULL,
                                           &ctrl_chr);
         if (ctrl_chr != BLK_START_AN_AFIO_OR_SLICE) {
@@ -1326 +1208 @@
             pA = temp_fname;
         }
+        /* BERLIOS: useless ?
         pB = strrchr(the_file_I_was_reading, '/');
         if (pB) {
@@ -1332 +1215 @@
             pB = the_file_I_was_reading;
         }
+        */
     }
     log_msg(2, "Reading %s (it matches %s)", temp_fname,
@@ -1350 +1234 @@
     /*@ int ********************************************************* */
     int res = 0;
-    char *sz_msg;
     int ctrlchr;
     long long temp_size;
-    malloc_string(sz_msg);
     /*@ end vars *************************************************** */
 
@@ -1373 +1255 @@
     g_tape_posK = 0;
     g_sigpipe = FALSE;
-    res += read_header_block_from_stream(&temp_size, sz_msg, &ctrlchr); /* just in case */
+    res += read_header_block_from_stream(&temp_size, NULL, &ctrlchr);   /* just in case */
     if (ctrlchr != BLK_START_OF_TAPE) {
         wrong_marker(BLK_START_OF_TAPE, ctrlchr);
     }
-    res += read_header_block_from_stream(&temp_size, sz_msg, &ctrlchr); /* just in case */
+    res += read_header_block_from_stream(&temp_size, NULL, &ctrlchr);   /* just in case */
     if (ctrlchr != BLK_START_OF_BACKUP) {
         wrong_marker(BLK_START_OF_BACKUP, ctrlchr);
@@ -1383 +1265 @@
         log_msg(3, "Next tape opened OK. Whoopee!");
     }
-    paranoid_free(sz_msg);
     return (res);
 }
-
 
 
@@ -1397 +1277 @@
 {
     int res = 0;
-    char command[MAX_STR_LEN * 2];
+    char *command;
+
     paranoid_pclose(g_tape_stream);
     system("sync");
@@ -1409 +1290 @@
     }
     if (bkpinfo->backup_media_type == cdstream) {
-        sprintf(command,
+        asprintf(&command,
                 "cdrecord -eject dev=%s speed=%d fs=24m -waiti - >> %s 2>> %s",
                 bkpinfo->media_device, bkpinfo->cdrw_speed, MONDO_LOGFILE,
@@ -1417 +1298 @@
         log_it("Let's see what happens, shall we?");
         g_tape_stream = popen(command, "w");
+        paranoid_free(command);
         if (!g_tape_stream) {
             log_to_screen("Failed to openout to cdstream (fifo)");
@@ -1438 +1320 @@
     return (res);
 }
-
-
 
 
@@ -1460 +1340 @@
 
     log_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,
+        asprintf(&fname, "%s/tmpfs/backcatalog/%s", bkpinfo->tmpdir,
                 g_tapecatalog->el[i].fname);
         if (!does_file_exist(fname)) {
@@ -1482 +1361 @@
             }
         }
-    }
-    paranoid_free(fname);
+        paranoid_free(fname);
+    }
     log_msg(2, "Finished writing back catalog to tape");
     return (res);
@@ -1489 +1368 @@
 
 
-
 /**
  * Write all.tar.gz (produced by Mindi) to the first 32M of the first tape.
@@ -1499 +1377 @@
     /*@ pointers *************************************************** */
     FILE *fin;
-    char tmp[MAX_STR_LEN];
+    char *tmp;
 
     /*@ long ******************************************************* */
@@ -1517 +1395 @@
     log_it("Data disks = %s", fname);
     if (!does_file_exist(fname)) {
-        sprintf(tmp, "Cannot find %s", fname);
+        asprintf(&tmp, "Cannot find %s", fname);
         log_to_screen(tmp);
+        paranoid_free(tmp);
         return (1);
     }
@@ -1550 +1429 @@
 
 
-
-
 /**
  * Copy @p infile to the opened stream (CD or tape).
@@ -1561 +1438 @@
 {
     /*@ buffers **************************************************** */
-    char tmp[MAX_STR_LEN];
+    char *tmp;
     char datablock[TAPE_BLOCK_SIZE];
-    char checksum[MAX_STR_LEN];
+    char *checksum;
     char *infile_basename;
 
@@ -1592 +1469 @@
     crc16 = 0;
     crctt = 0;
-
-
 
     /*@ end vars *************************************************** */
@@ -1615 +1490 @@
         p++;
     }
-    sprintf(tmp, "Writing file '%s' to tape (%ld KB)", p,
+    asprintf(&tmp, "Writing file '%s' to tape (%ld KB)", p,
             (long) filesize >> 10);
     log_it(tmp);
+    paranoid_free(tmp);
+
     write_header_block_to_stream(filesize, infile_basename,
                                  BLK_START_FILE);
@@ -1656 +1533 @@
     }
     paranoid_fclose(fin);
-    sprintf(checksum, "%04x%04x", crc16, crctt);
+    asprintf(&checksum, "%04x%04x", crc16, crctt);
     write_header_block_to_stream(g_current_media_number, checksum,
                                  BLK_STOP_FILE);
+    paranoid_free(checksum);
 //  log_it("File '%s' written to tape.", infile);
     return (retval);
 }
-
-
-
 
 
@@ -1684 +1559 @@
     /*@ buffers **************************************************** */
     char tempblock[TAPE_BLOCK_SIZE];
-    char tmp[MAX_STR_LEN];
+    char *tmp;
     char *p;
 
@@ -1713 +1588 @@
     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(long long));
-/*  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)",
+    asprintf(&tmp, "%s (fname=%s, size=%ld K)",
             marker_to_string(control_char), p,
             (long) length_of_incoming_file >> 10);
     log_msg(6, tmp);
-/*  log_tape_pos(); */
+    paranoid_free(tmp);
     return (0);
 }
-
-
-
-
-
-
-
-
 
 
@@ -1746 +1610 @@
 {
     /*@ buffer ***************************************************** */
-    char tmp[MAX_STR_LEN];
+    char *tmp;
 
 
     /*@ 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));
+    asprintf(&tmp, "Wrong marker! (Should be %s, is actually %s)",
+            marker_to_string(should_be), marker_to_string(it_is));
     log_to_screen(tmp);
+    paranoid_free(tmp);
 }
 

trunk/mondo/mondo/common/libmondo-string.c

@@ -1062 +1062 @@
 
     /* BERLIOS There is a bug here I can't solve for the moment. If you 
-     * replace %% in the asprintf below by 'percent' it just works, but 
+     * replace %% in the format below by 'percent' it just works, but 
      * like this it creates a huge number. Memory pb somewhere */
     /*

trunk/mondo/mondo/common/libmondo-verify.c

@@ -608 +608 @@
     char *orig_cksum;
     char *tmp;
-    char *slice_fnam;
+    char *slice_fnam = (char *)&res;
 
     /*@ pointers ******************************************************** */
@@ -616 +616 @@
     long long slice_siz;
 
-    malloc_string(slice_fnam);
     assert(bkpinfo != NULL);
     assert_string_is_neither_NULL_nor_zerolength(biggie_fname);
@@ -627 +626 @@
     }
     asprintf(&test_file, "%s/temporary-%s", bkpinfo->tmpdir, p);
-    /* BERLIOS: useless
-       asprintf(&tmp,
-       "Temporarily copying biggiefile %s's slices from tape to '%s'",
-       p, test_file);
-       log_it(tmp); 
-       paranoid_free(tmp);
-     */
+    asprintf(&tmp,
+    "Temporarily copying biggiefile %s's slices from tape to '%s'",
+    p, test_file);
+    log_it(tmp); 
+    paranoid_free(tmp);
     for (res =
          read_header_block_from_stream(&slice_siz, slice_fnam, &ctrl_chr);
@@ -645 +642 @@
         res = read_file_from_stream_to_file(bkpinfo, test_file, slice_siz);
         unlink(test_file);
+        paranoid_free(slice_fnam);
+        slice_fnam = (char *)&res;
         res =
             read_header_block_from_stream(&slice_siz, slice_fnam,
@@ -654 +653 @@
         current_slice_number++;
         retval += res;
+        paranoid_free(slice_fnam);
+        slice_fnam = (char *)&res;
     }
     paranoid_free(test_file);
@@ -705 +706 @@
     /*@ buffers ***************************************************** */
     char *tmp;
-    char *fname;
+    char *fname = (char *)&res;             /* Should NOT be NULL */
     char *curr_xattr_list_fname;
     char *curr_acl_list_fname;
@@ -713 +714 @@
 
     assert(bkpinfo != NULL);
-    malloc_string(fname);
 
     asprintf(&curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ,
@@ -725 +725 @@
                        "Please wait. This may take a couple of hours.", "",
                        total_afioballs);
-    res = read_header_block_from_stream(&size, fname, &ctrl_chr);
+    res = read_header_block_from_stream(&size, NULL, &ctrl_chr);
     if (ctrl_chr != BLK_START_AFIOBALLS) {
         iamhere("YOU SHOULD NOT GET HERE");
@@ -731 +731 @@
         if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
             res =
-                read_EXAT_files_from_tape(bkpinfo, &size, fname, &ctrl_chr,
+                read_EXAT_files_from_tape(bkpinfo, &size, NULL, &ctrl_chr,
                                           curr_xattr_list_fname,
                                           curr_acl_list_fname);
@@ -744 +744 @@
     for (res = read_header_block_from_stream(&size, fname, &ctrl_chr);
          ctrl_chr != BLK_STOP_AFIOBALLS;
-         res = read_header_block_from_stream(&size, fname, &ctrl_chr)) {
+         res = 
+         read_header_block_from_stream(&size, fname, &ctrl_chr)) {
         asprintf(&curr_xattr_list_fname, XATTR_LIST_FNAME_RAW_SZ,
                  bkpinfo->tmpdir, current_afioball_number);
@@ -751 +752 @@
         if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
             iamhere("Reading EXAT files from tape");
+            paranoid_free(fname);
+            fname = (char *)&res;
             res =
                 read_EXAT_files_from_tape(bkpinfo, &size, fname, &ctrl_chr,
@@ -777 +780 @@
         current_afioball_number++;
         g_current_progress++;
+        paranoid_free(fname);
+        fname = (char *)&res;
         res = read_header_block_from_stream(&size, fname, &ctrl_chr);
         if (ctrl_chr != BLK_STOP_AN_AFIO_OR_SLICE) {
             wrong_marker(BLK_STOP_AN_AFIO_OR_SLICE, ctrl_chr);
         }
+        paranoid_free(fname);
+        fname = (char *)&res;
     }
     log_msg(1, "All done with afioballs");
@@ -810 +817 @@
 
     /*@ buffers ******************************************************** */
-    char *orig_fname, *logical_fname;
+    char *orig_fname = (char *)&ctrl_chr;   /* Should NOT be NULL */
+    char *logical_fname;
     char *comment;
     char *curr_xattr_list_fname;
@@ -821 +829 @@
 
     assert(bkpinfo != NULL);
-    malloc_string(orig_fname);
 
     asprintf(&curr_xattr_list_fname, XATTR_BIGGLST_FNAME_RAW_SZ,
@@ -829 +836 @@
     asprintf(&comment, "Verifying all bigfiles.");
     log_to_screen(comment);
-    /*
-       asprintf(&tmp, "%s/biggielist.txt", bkpinfo->tmpdir);
-       noof_biggiefiles = count_lines_in_file (tmp); // pointless
-       paranoid_free(tmp);
-     */
     res = read_header_block_from_stream(&size, orig_fname, &ctrl_chr);
     if (ctrl_chr != BLK_START_BIGGIEFILES) {
         if (ctrl_chr == BLK_START_EXTENDED_ATTRIBUTES) {
             iamhere("Grabbing the EXAT biggiefiles");
+            paranoid_free(orig_fname);
+            orig_fname = (char *)&ctrl_chr;
             res =
                 read_EXAT_files_from_tape(bkpinfo, &size, orig_fname,
@@ -846 +850 @@
     paranoid_free(curr_xattr_list_fname);
     paranoid_free(curr_acl_list_fname);
+    paranoid_free(orig_fname);
+    orig_fname = (char *)&ctrl_chr;
 
     if (ctrl_chr != BLK_START_BIGGIEFILES) {
@@ -884 +890 @@
         current_biggiefile_number++;
         g_current_progress++;
+        paranoid_free(orig_fname);
+        orig_fname = (char *)&ctrl_chr;
     }
     close_progress_form();
-    paranoid_free(orig_fname);
     return (retval);
 }

trunk/mondo/mondo/common/mondostructures.h

@@ -18 +18 @@
 
 
-/**
+/*
  * @file
  * The header file defining all of Mondo's structures.
@@ -24 +24 @@
 
 
-/** @def MAX_NOOF_MEDIA The maximum number of media that can be used in any one backup. */
-
-///* So we can override it in config.h: */
+/* @def MAX_NOOF_MEDIA The maximum number of media that can be used in any one backup. */
+
+/* So we can override it in config.h: */
 //#ifndef MAX_NOOF_MEDIA
 #define MAX_NOOF_MEDIA 50

trunk/mondo/mondo/common/my-stuff.h

@@ -17 +17 @@
 #define _MY_STUFF_H_
 
-/* Required for the use of asprintf */
+/* Required for the use of getline, ... */
 #define __USE_GNU