Changeset 2211 in MondoRescue for branches/2.2.9/mondo/src/mondorestore

Timestamp:

Jun 3, 2009, 7:10:19 PM (15 years ago)

Author:

Bruno Cornec

Message:

r3089@localhost: bruno | 2009-05-18 06:41:05 +0200

• move call to asprintf to call to mr_asprintf (suppress a compiler warning)
• remove all the most obvious bad call to strcat and replace by mr_strcat as appropriate

Location:

branches/2.2.9/mondo/src/mondorestore

Files:

• mondo-prep.c (modified) (29 diffs)
• mondo-rstr-compare.c (modified) (15 diffs)
• mondo-rstr-newt.c (modified) (4 diffs)
• mondo-rstr-tools.c (modified) (27 diffs)
• mondorestore.c (modified) (19 diffs)

branches/2.2.9/mondo/src/mondorestore/mondo-prep.c

@@ -1 +1 @@
 /***************************************************************************
 $Id$
-***************************************************************************/
-
-/***************************************************************************
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- ***************************************************************************/
-
-/**
- * @file
- * Functions for prepping hard drives: partitioning, formatting, etc.
- */
+* Functions for prepping hard drives: partitioning, formatting, etc.
+*/
 
 
 #include "my-stuff.h"
+#include "mr_mem.h"
 #include "../common/mondostructures.h"
 #include "mondoprep.h"
@@ -349 +337 @@
             log_it("%s... so I'll get creative.", tmp);
             if (lvmversion == 2) {
-                asprintf(&tmp1, "tail -n5 %s | grep Insufficient | tail -n1", MONDO_LOGFILE);
+                mr_asprintf(&tmp1, "tail -n5 %s | grep Insufficient | tail -n1", MONDO_LOGFILE);
                 strcpy(tmp, call_program_and_get_last_line_of_output(tmp1));
                 free(tmp1);
             } else {
-                asprintf(&tmp1, "tail -n5 %s | grep lvcreate | tail -n1", MONDO_LOGFILE);
+                mr_asprintf(&tmp1, "tail -n5 %s | grep lvcreate | tail -n1", MONDO_LOGFILE);
                 strcpy(tmp, call_program_and_get_last_line_of_output(tmp1));
                 free(tmp1);
@@ -596 +584 @@
   }
   // create device list from normal disks followed by spare ones
-  asprintf(&devices, "%s", raidlist->el[i].data_disks.el[0].device);
+  mr_asprintf(&devices, "%s", raidlist->el[i].data_disks.el[0].device);
   for (j = 1; j < raidlist->el[i].data_disks.entries; j++) {
-    asprintf(&strtmp, "%s", devices);
+    mr_asprintf(&strtmp, "%s", devices);
     paranoid_free(devices);
-    asprintf(&devices, "%s %s", strtmp,
+    mr_asprintf(&devices, "%s %s", strtmp,
          raidlist->el[i].data_disks.el[j].device);
     paranoid_free(strtmp);
   }
   for (j = 0; j < raidlist->el[i].spare_disks.entries; j++) {
-    asprintf(&strtmp, "%s", devices);
+    mr_asprintf(&strtmp, "%s", devices);
     paranoid_free(devices);
-    asprintf(&devices, "%s %s", strtmp,
+    mr_asprintf(&devices, "%s %s", strtmp,
          raidlist->el[i].spare_disks.el[j].device);
     paranoid_free(strtmp);
@@ -613 +601 @@
   // translate RAID level
   if (raidlist->el[i].raid_level == -2) {
-    asprintf(&level, "multipath");
+    mr_asprintf(&level, "multipath");
   } else if (raidlist->el[i].raid_level == -1) {
-    asprintf(&level, "linear");
+    mr_asprintf(&level, "linear");
   } else {
-    asprintf(&level, "raid%d", raidlist->el[i].raid_level);
+    mr_asprintf(&level, "raid%d", raidlist->el[i].raid_level);
   }
   // create RAID device:
@@ -624 +612 @@
   // - faulty devices ignored
   // - persistent superblock always used as this is recommended
-  asprintf(&program,
+  mr_asprintf(&program,
        "mdadm --create --force --run --auto=yes %s --level=%s --raid-devices=%d",
        raidlist->el[i].raid_device, level,
        raidlist->el[i].data_disks.entries);
   if (raidlist->el[i].parity != -1) {
-    asprintf(&strtmp, "%s", program);
+    mr_asprintf(&strtmp, "%s", program);
     paranoid_free(program);
     switch(raidlist->el[i].parity) {
     case 0:
-      asprintf(&program, "%s --parity=%s", strtmp, "la");
+      mr_asprintf(&program, "%s --parity=%s", strtmp, "la");
       break;
     case 1:
-      asprintf(&program, "%s --parity=%s", strtmp, "ra");
+      mr_asprintf(&program, "%s --parity=%s", strtmp, "ra");
       break;
     case 2:
-      asprintf(&program, "%s --parity=%s", strtmp, "ls");
+      mr_asprintf(&program, "%s --parity=%s", strtmp, "ls");
       break;
     case 3:
-      asprintf(&program, "%s --parity=%s", strtmp, "rs");
+      mr_asprintf(&program, "%s --parity=%s", strtmp, "rs");
       break;
     default:
@@ -651 +639 @@
   }
   if (raidlist->el[i].chunk_size != -1) {
-    asprintf(&strtmp, "%s", program);
+    mr_asprintf(&strtmp, "%s", program);
     paranoid_free(program);
-    asprintf(&program, "%s --chunk=%d", strtmp, raidlist->el[i].chunk_size);
+    mr_asprintf(&program, "%s --chunk=%d", strtmp, raidlist->el[i].chunk_size);
     paranoid_free(strtmp);
   }
   if (raidlist->el[i].spare_disks.entries > 0) {
-    asprintf(&strtmp, "%s", program);
+    mr_asprintf(&strtmp, "%s", program);
     paranoid_free(program);
-    asprintf(&program, "%s --spare-devices=%d", strtmp,
+    mr_asprintf(&program, "%s --spare-devices=%d", strtmp,
          raidlist->el[i].spare_disks.entries);
     paranoid_free(strtmp);
   }
-  asprintf(&strtmp, "%s", program);
+  mr_asprintf(&strtmp, "%s", program);
   paranoid_free(program);
-  asprintf(&program, "%s %s", strtmp, devices);
+  mr_asprintf(&program, "%s %s", strtmp, devices);
   paranoid_free(strtmp);
   res = run_program_and_log_output(program, 1);
@@ -690 +678 @@
 {
     /** int **************************************************************/
-    int res;
-    int retval = 0;
 #ifdef __FreeBSD__
     static bool vinum_started_yet = FALSE;
@@ -698 +684 @@
     /** buffers ***********************************************************/
     char *program;
-    char *tmp;
+    char *tmp = NULL;
+    int res = 0;
+    int retval = 0;
 
     /** end ****************************************************************/
 
     malloc_string(program);
-    malloc_string(tmp);
     assert_string_is_neither_NULL_nor_zerolength(device);
     assert(format != NULL);
 
     if (strstr(format, "raid")) {   // do not form RAID disks; do it to /dev/md* instead
-        sprintf(tmp, "Not formatting %s (it is a RAID disk)", device);
+        mr_asprintf(&tmp, "Not formatting %s (it is a RAID disk)", device);
         log_it(tmp);
+        paranoid_free(tmp);
         paranoid_free(program);
-        paranoid_free(tmp);
         return (0);
     }
@@ -723 +710 @@
 #endif
     if (strlen(format) <= 2) {
-        sprintf(tmp,
+        mr_asprintf(&tmp,
                 "%s has a really small format type ('%s') - this is probably a hexadecimal string, which would suggest the partition is an image --- I shouldn't format it",
                 device, format);
         log_it(tmp);
+        paranoid_free(tmp);
         paranoid_free(program);
+        return (0);
+    }
+    if (is_this_device_mounted(device)) {
+        mr_asprintf(&tmp, "%s is mounted - cannot format it       ", device);
+        log_to_screen(tmp);
         paranoid_free(tmp);
-        return (0);
-    }
-    if (is_this_device_mounted(device)) {
-        sprintf(tmp, "%s is mounted - cannot format it       ", device);
-        log_to_screen(tmp);
         paranoid_free(program);
-        paranoid_free(tmp);
         return (1);
     }
@@ -762 +749 @@
             FILE *fin;
             char line[MAX_STR_LEN];
-            sprintf(tmp,
-                    "Initializing Vinum device %s (this may take a *long* time)",
-                    device);
+
+            mr_asprintf(&tmp, "Initializing Vinum device %s (this may take a *long* time)", device);
             log_to_screen(tmp);
+            paranoid_free(tmp);
+
             /* format raid partition */
             //      sprintf (program, "mkraid --really-force %s", device); --- disabled -- BB, 02/12/2003
@@ -780 +768 @@
                     *(strchr(line, '\n')) = '\0';   // get rid of the \n on the end
 
-                sprintf(tmp, "Initializing plex: %s", line);
+                mr_asprintf(&tmp, "Initializing plex: %s", line);
                 open_evalcall_form(tmp);
-                sprintf(tmp, "vinum init %s", line);
+                paranoid_free(tmp);
+
+                mr_asprintf(&tmp, "vinum init %s", line);
                 system(tmp);
+                paranoid_free(tmp);
+
                 while (1) {
-                    sprintf(tmp,
+                    mr_asprintf(&tmp,
                             "vinum lp -r %s | grep '^S' | head -1 | tr -s ' ' | cut -d: -f2 | cut -f1 | sed 's/^ //' | sed 's/I //' | sed 's/%%//'",
                             line);
                     FILE *pin = popen(tmp, "r");
+                    paranoid_free(tmp);
+
                     char status[MAX_STR_LEN / 4];
                     fgets(status, MAX_STR_LEN / 4 - 1, pin);
@@ -806 +800 @@
         }
 #else
-        sprintf(tmp, "Initializing RAID device %s", device);
+        mr_asprintf(&tmp, "Initializing RAID device %s", device);
         log_to_screen(tmp);
+        paranoid_free(tmp);
 
 // Shouldn't be necessary.
@@ -856 +851 @@
     }
     res = which_format_command_do_i_need(format, program);
-    sprintf(tmp, "%s %s", program, device);
+    mr_asprintf(&tmp, "%s %s", program, device);
     if (strstr(program, "kludge")) {
-        strcat(tmp, " /");
+        mr_strcat(tmp, " /");
     }
     sprintf(program, "sh -c 'echo -en \"y\\ny\\ny\\n\" | %s'", tmp);
-    sprintf(tmp, "Formatting %s as %s", device, format);
+    paranoid_free(tmp);
+
+    mr_asprintf(&tmp, "Formatting %s as %s", device, format);
     update_progress_form(tmp);
+    paranoid_free(tmp);
+
     res = run_program_and_log_output(program, FALSE);
+    mr_asprintf(&tmp, "");
     if (res && strstr(program, "kludge")) {
-        sprintf(tmp, "Kludge failed; using regular mkfs.%s to format %s",
+        mr_strcat(tmp, "Kludge failed; using regular mkfs.%s to format %s",
                 format, device);
 #ifdef __FreeBSD__
@@ -885 +885 @@
     retval += res;
     if (retval) {
-        strcat(tmp, "...failed");
+        mr_strcat(tmp, "...failed");
     } else {
-        strcat(tmp, "...OK");
+        mr_strcat(tmp, "...OK");
     }
 
     log_to_screen(tmp);
+    paranoid_free(tmp);
+
     paranoid_free(program);
-    paranoid_free(tmp);
     system("sync");
     sleep(1);
@@ -1717 +1718 @@
     char *tmp;
     char *logfile;
-    char *output;
+    char *output = NULL;
 
     /** pointers **********************************************************/
@@ -1730 +1731 @@
     malloc_string(tmp);
     malloc_string(logfile);
-    malloc_string(output);
 
     assert_string_is_neither_NULL_nor_zerolength(drive);
@@ -1745 +1745 @@
         paranoid_free(tmp);
         paranoid_free(logfile);
-        paranoid_free(output);
         return (0);
     }
@@ -1766 +1765 @@
         paranoid_free(tmp);
         paranoid_free(logfile);
-        paranoid_free(output);
         return (1);
 /*
@@ -1786 +1784 @@
     /* BERLIOS: should not be called each time */
     part_table_fmt = which_partition_format(drive);
-    output[0] = '\0';
+    mr_asprintf(&output, "");
     /* make it a primary/extended/logical */
     if (partno <= 4) {
-        sprintf(output + strlen(output), "n\np\n%d\n", partno);
+        mr_strcat(output, "n\np\n%d\n", partno);
     } else {
         /* MBR needs an extended partition if more than 4 partitions */
@@ -1804 +1802 @@
                     return (1);
                 } else {
-                    sprintf(output + strlen(output), "n\ne\n%d\n\n\n",
-                            prev_partno + 1);
+                    mr_strcat(output, "n\ne\n%d\n\n\n", prev_partno + 1);
                 }
             }
-            strcat(output + strlen(output), "n\nl\n");
+            mr_strcat(output, "n\nl\n");
         } else {
             /* GPT allows more than 4 primary partitions */
-            sprintf(output + strlen(output), "n\np\n%d\n", partno);
-        }
-    }
-    strcat(output + strlen(output), "\n");  /*start block (ENTER for next free blk */
+            mr_strcat(output, "n\np\n%d\n", partno);
+        }
+    }
+    mr_strcat(output, "\n");    /*start block (ENTER for next free blk */
     if (partsize > 0) {
         if (!strcmp(format, "7")) {
@@ -1820 +1817 @@
             partsize += 512;
         }
-        sprintf(output + strlen(output), "+%lldK", (long long) (partsize));
-    }
-    strcat(output + strlen(output), "\n");
+        mr_strcat(output, "+%lldK", (long long) (partsize));
+    }
+    mr_strcat(output, "\n");
 #if 0
 /*
@@ -1864 +1861 @@
         }
     } else {
-        strcat(output, "w\n\n");
+        mr_strcat(output, "w\n\n");
         if (g_fprep) {
             fprintf(g_fprep, "echo \"%s\" | %s\n", output, program);
@@ -1916 +1913 @@
         }
     }
+    paranoid_free(output);
+
     g_current_progress++;
     log_it("partition_device() --- leaving");
@@ -1922 +1921 @@
     paranoid_free(tmp);
     paranoid_free(logfile);
-    paranoid_free(output);
     return (retval);
 }
@@ -2032 +2030 @@
     char *partition;
     char *command;
-    char *output;
+    char *output = NULL;
     char *tmp;
     char *partcode;
@@ -2051 +2049 @@
     malloc_string(partition);
     malloc_string(command);
-    malloc_string(output);
     malloc_string(tmp);
     malloc_string(partcode);
@@ -2138 +2135 @@
             fput_string_one_char_at_a_time(pout_to_fdisk, "p\n");
         } else {
-            sprintf(output, "t\n%d\n%s\n", partno, partcode);
-            strcat(output, "w\n");
+            mr_asprintf(&output, "t\n%d\n%s\nw\n", partno, partcode);
             sprintf(command, "parted2fdisk %s >> %s 2>> %s", drive,
                     MONDO_LOGFILE, MONDO_LOGFILE);
@@ -2154 +2150 @@
                 paranoid_pclose(fout);
             }
+            paranoid_free(output);
         }
         if (res) {
@@ -2162 +2159 @@
     paranoid_free(partition);
     paranoid_free(command);
-    paranoid_free(output);
     paranoid_free(tmp);
     paranoid_free(partcode);

branches/2.2.9/mondo/src/mondorestore/mondo-rstr-compare.c

@@ -1 +1 @@
 /***************************************************************************
-       mondo-compare.c  -  compares mondoarchive data
-                             -------------------
-    begin                : Fri Apr 25 2003
-    copyright            : (C) 2000 by Hugo Rabson
-    email                : Hugo Rabson <hugorabson@msn.com>
     cvsid                : $Id$
 ***************************************************************************/
 
-/***************************************************************************
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- ***************************************************************************/
-
-/***************************************************************************
- *                         Change Log                                      *
- ***************************************************************************
-.
-
-
-
-10/21/2003
-- changed "/mnt/cdrom" to MNT_CDROM
-
-10/18
-- don't say unknown compressor if no compressor at all
-
-09/17
-- cleaned up logging & conversion-to-changed.txt
-- cleaned up compare_mode()
-
-09/16
-- fixed bad malloc(),free() pairs in compare_a_biggiefile()
-
-09/14
-- compare_mode() --- a couple of strings were the wrong way round,
-  e.g. changed.txt and changed.files
-
-05/05
-- exclude /dev/ * from list of changed files
-
-04/30
-- added textonly mode
-
-04/27
-- improved compare_mode() to allow for ISO/cd/crazy people
-
-04/25
-- first incarnation
-*/
-
-
 #include <pthread.h>
 #include "my-stuff.h"
+#include "mr_mem.h"
 #include "../common/mondostructures.h"
 #include "../common/libmondo.h"
@@ -97 +46 @@
     char *original_cksum_ptr;
     char *bigfile_fname_ptr;
-    char *tmp_ptr;
+    char *tmp_ptr = NULL;
     char *command_ptr;
 
@@ -117 +66 @@
     malloc_string(bigfile_fname_ptr);
     malloc_string(command_ptr);
-    malloc_string(tmp_ptr);
 
   /*********************************************************************
@@ -126 +74 @@
     memset(original_cksum_ptr, '\0', sizeof(original_cksum));
     memset(bigfile_fname_ptr, '\0', sizeof(bigfile_fname));
-    memset(tmp_ptr, '\0', sizeof(tmp));
     memset(command_ptr, '\0', sizeof(command));
   /** end **/
@@ -134 +81 @@
             insist_on_this_cd_number((++g_current_media_number));
         } else {
-            sprintf(tmp_ptr,
+            mr_asprintf(&tmp_ptr,
                     "No CD's left. No biggiefiles left. No prob, Bob.");
             log_msg(2, tmp_ptr);
+            paranoid_free(tmp_ptr);
             return (0);
         }
     }
     if (!(fin = fopen(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""), "r"))) {
-        sprintf(tmp_ptr,
+        mr_asprintf(&tmp_ptr,
                 "Cannot open bigfile %ld (%s)'s info file",
                 bigfileno + 1, bigfile_fname_ptr);
         log_to_screen(tmp_ptr);
+        paranoid_free(tmp_ptr);
         return (1);
     }
@@ -156 +105 @@
     log_msg(2, "biggiestruct.checksum = %s", biggiestruct.checksum);
 
-    sprintf(tmp_ptr, "Comparing %s", bigfile_fname_ptr);
-
     if (!g_text_mode) {
+        mr_asprintf(&tmp_ptr, "Comparing %s", bigfile_fname_ptr);
         newtDrawRootText(0, 22, tmp_ptr);
+        paranoid_free(tmp_ptr);
         newtRefresh();
     }
@@ -173 +122 @@
     }
     log_msg(2, command_ptr);
-    sprintf(tmp_ptr, "cat /tmp/errors >> %s 2> /dev/null", MONDO_LOGFILE);
+    mr_asprintf(&tmp_ptr, "cat /tmp/errors >> %s 2> /dev/null", MONDO_LOGFILE);
     paranoid_system(tmp_ptr);
+    paranoid_free(tmp_ptr);
+
     if (system(command_ptr)) {
         log_OS_error("Warning - command failed");
@@ -197 +148 @@
         }
     }
-    sprintf(tmp_ptr, "bigfile #%ld ('%s') ", bigfileno + 1,
+    mr_asprintf(&tmp_ptr, "bigfile #%ld ('%s') ", bigfileno + 1,
             bigfile_fname_ptr);
     if (!strcmp(checksum_ptr, original_cksum_ptr) != 0) {
-        strcat(tmp_ptr, " ... OK");
-    } else {
-        strcat(tmp_ptr, "... changed");
+        mr_strcat(tmp_ptr, " ... OK");
+    } else {
+        mr_strcat(tmp_ptr, "... changed");
         retval++;
     }
     log_msg(1, tmp_ptr);
+    paranoid_free(tmp_ptr);
+
     if (retval) {
         if (!(fout = fopen(MONDO_CACHE"/changed.txt", "a"))) {
@@ -222 +175 @@
     paranoid_free(command_ptr);
     paranoid_free(command);
-    paranoid_free(tmp_ptr);
     paranoid_free(tmp);
 
@@ -302 +254 @@
 
   /***  needs malloc *********/
-    char *command, *tmp, *filelist_name, *logfile, *archiver_exe,
+    char *command, *tmp, *filelist_name, *logfile,
         *compressor_exe;
+    char *archiver_exe = NULL;
 
     malloc_string(command);
@@ -309 +262 @@
     malloc_string(filelist_name);
     malloc_string(logfile);
-    malloc_string(archiver_exe);
     malloc_string(compressor_exe);
 
@@ -331 +283 @@
 
     if (use_star) {
-        strcpy(archiver_exe, "star");
-    } else {
-        strcpy(archiver_exe, "afio");
+        mr_asprintf(&archiver_exe, "star");
+    } else {
+        mr_asprintf(&archiver_exe, "afio");
     }
 
@@ -344 +296 @@
         {
             if (!strcmp(compressor_exe, "bzip2")) {
-                strcat(archiver_exe, " -bz");
+                mr_strcat(archiver_exe, " -bz");
             } else {
                 fatal_error
@@ -373 +325 @@
                 BUFSIZE, compressor_exe, tarball_fname, logfile, logfile);
     }
+    paranoid_free(archiver_exe);
+
 #undef BUFSIZE
 
@@ -405 +359 @@
     paranoid_free(filelist_name);
     paranoid_free(logfile);
-    paranoid_free(archiver_exe);
     paranoid_free(compressor_exe);
     return (retval);

branches/2.2.9/mondo/src/mondorestore/mondo-rstr-newt.c

@@ -1 +1 @@
 /***************************************************************************
  * $Id$
- */
-
-
-/**
- * @file
  * Functions for handling GUI interfaces in the restore.
  */
@@ -11 +6 @@
 #ifdef __FreeBSD__
 #define OSSWAP(linux,fbsd) fbsd
-//#include <libgen.h>
 #else
 #define OSSWAP(linux,fbsd) linux
@@ -17 +11 @@
 
 #include "mondo-rstr-newt.h"
+#include "mr_mem.h"
 
 //static char cvsid[] = "$Id$";
@@ -1950 +1945 @@
     assert(raidlist != NULL);
 
-    asprintf(&flaws_str_A, "%s", "xxxxxxxxx");
-    asprintf(&flaws_str_B, "%s", "xxxxxxxxx");
-    asprintf(&flaws_str_C, "%s", "xxxxxxxxx");
+    mr_asprintf(&flaws_str_A, "%s", "         ");
+    mr_asprintf(&flaws_str_B, "%s", "         ");
+    mr_asprintf(&flaws_str_C, "%s", "         ");
     if (mountlist->entries > ARBITRARY_MAXIMUM) {
         log_to_screen("Arbitrary limits suck, man!");

branches/2.2.9/mondo/src/mondorestore/mondo-rstr-tools.c

@@ -1 +1 @@
 /***************************************************************************
 $Id$
-
-***************************************************************************
-*                                                                         *
-*   This program is free software; you can redistribute it and/or modify  *
-*   it under the terms of the GNU General Public License as published by  *
-*   the Free Software Foundation; either version 2 of the License, or     *
-*   (at your option) any later version.                                   *
-*                                                                         *
 ***************************************************************************/
 
@@ -14 +6 @@
 #include <linux/fd.h>
 #include "my-stuff.h"
+#include "mr_mem.h"
 #include "../common/mondostructures.h"
 #include "../common/libmondo.h"
@@ -284 +277 @@
 int iso_fiddly_bits(bool nuke_me_please)
 {
-char *mount_isodir_command, *tmp, *command;
+char *mount_isodir_command = NULL;
+char *tmp, *command;
 int retval = 0, i;
 bool already_mounted = FALSE;
 
 assert(bkpinfo != NULL);
-malloc_string(mount_isodir_command);
 malloc_string(tmp);
 malloc_string(command);
@@ -295 +288 @@
 read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
 if (bkpinfo->disaster_recovery) {
-/* Patch Conor Daly 26-june-2004 
-* Don't let this clobber an existing bkpinfo->isodir */
-if (!bkpinfo->isodir[0]) {
-    strcpy(bkpinfo->isodir, "/tmp/isodir");
-}
-/* End patch */
-sprintf(command, "mkdir -p %s", bkpinfo->isodir);
-run_program_and_log_output(command, 5);
-log_msg(2, "Setting isodir to %s", bkpinfo->isodir);
-}
-
-if (!get_isodir_info
-(g_isodir_device, g_isodir_format, bkpinfo->isodir,
- nuke_me_please)) {
-return (1);
+    /* Patch Conor Daly 26-june-2004 
+    * Don't let this clobber an existing bkpinfo->isodir */
+    if (!bkpinfo->isodir[0]) {
+        strcpy(bkpinfo->isodir, "/tmp/isodir");
+    }
+    /* End patch */
+    sprintf(command, "mkdir -p %s", bkpinfo->isodir);
+    run_program_and_log_output(command, 5);
+    log_msg(2, "Setting isodir to %s", bkpinfo->isodir);
+}
+
+if (!get_isodir_info(g_isodir_device, g_isodir_format, bkpinfo->isodir, nuke_me_please)) {
+    return (1);
 }
 paranoid_system("umount " MNT_CDROM " 2> /dev/null");   /* just in case */
 
 if (is_this_device_mounted(g_isodir_device)) {
-log_to_screen("WARNING - isodir is already mounted");
-already_mounted = TRUE;
+    log_to_screen("WARNING - isodir is already mounted");
+    already_mounted = TRUE;
 } else {
-sprintf(mount_isodir_command, "mount %s", g_isodir_device);
-if (strlen(g_isodir_format) > 1) {
-    sprintf(mount_isodir_command + strlen(mount_isodir_command),
-            " -t %s", g_isodir_format);
-}
-strcat(mount_isodir_command, " -o ro ");
-strcat(mount_isodir_command, bkpinfo->isodir);
-run_program_and_log_output("df -m", FALSE);
-sprintf(tmp,
+    mr_asprintf(&mount_isodir_command, "mount %s", g_isodir_device);
+    if (strlen(g_isodir_format) > 1) {
+        mr_strcat(mount_isodir_command, " -t %s", g_isodir_format);
+    }
+    mr_strcat(mount_isodir_command, " -o ro %s", bkpinfo->isodir);
+    run_program_and_log_output("df -m", FALSE);
+    sprintf(tmp,
         "The 'mount' command is '%s'. PLEASE report this command to be if you have problems, ok?",
         mount_isodir_command);
-log_msg(1, tmp);
-if (run_program_and_log_output(mount_isodir_command, FALSE)) {
-    popup_and_OK
-        ("Cannot mount the device where the ISO files are stored.");
-    return (1);
-}
-log_to_screen
+    log_msg(1, tmp);
+    if (run_program_and_log_output(mount_isodir_command, FALSE)) {
+        popup_and_OK
+            ("Cannot mount the device where the ISO files are stored.");
+        return (1);
+    }
+    paranoid_free(mount_isodir_command);
+    log_to_screen
     ("I have mounted the device where the ISO files are stored.");
 }
@@ -351 +341 @@
 log_msg(2, "%ld: bkpinfo->isodir is now %s", __LINE__,
     bkpinfo->isodir);
-paranoid_free(mount_isodir_command);
 paranoid_free(tmp);
 paranoid_free(command);
@@ -385 +374 @@
 
 /** malloc **/
-char *tmp, *command, *mountdir, *mountpoint, *additional_parameters;
+char *tmp, *command, *mountdir, *mountpoint;
+char *additional_parameters = NULL;
 
 assert_string_is_neither_NULL_nor_zerolength(device);
@@ -394 +384 @@
 malloc_string(mountdir);
 malloc_string(mountpoint);
-malloc_string(additional_parameters);
 
     if (!strcmp(mpt, "/1")) {
@@ -412 +401 @@
     log_msg(1, tmp);
     /* Deal with additional params only if not /proc or /sys */
+    mr_asprintf(&additional_parameters, "");
     if (strcmp(format, "proc") && strcmp(format, "sys")) {
         if (writeable) {
-            strcpy(additional_parameters, "-o rw");
+            mr_strcat(additional_parameters, "-o rw");
         } else {
-            strcpy(additional_parameters, "-o ro");
+            mr_strcat(additional_parameters, "-o ro");
         }
         if (find_home_of_exe("setfattr")) {
-            strcat(additional_parameters, ",user_xattr");
+            mr_strcat(additional_parameters, ",user_xattr");
         }
         if (find_home_of_exe("setfacl")) {
-            strcat(additional_parameters, ",acl");
+            mr_strcat(additional_parameters, ",acl");
         }
     }
@@ -440 +430 @@
         log_msg(2, "command='%s'", command);
     }
+    paranoid_free(additional_parameters);
 
     res = run_program_and_log_output(command, TRUE);
@@ -479 +470 @@
 paranoid_free(mountdir);
 paranoid_free(mountpoint);
-paranoid_free(additional_parameters);
 
     return (res);
@@ -498 +488 @@
 {
 int retval = 0, lino, res;
-char *tmp, *these_failed, *format;
-    struct mountlist_itself *mountlist = NULL;
+char *tmp;
+char *these_failed = NULL;
+char *format;
+struct mountlist_itself *mountlist = NULL;
 
 malloc_string(tmp);
 malloc_string(format);
-malloc_string(these_failed);
-/** menset **/
-these_failed[0] = '\0';
 
 assert(p_external_copy_of_mountlist != NULL);
@@ -520 +509 @@
                "", mountlist->entries);
 
+    mr_asprintf(&these_failed, "");
     for (lino = 0; lino < mountlist->entries; lino++) {
         if (!strcmp(mountlist->el[lino].device, "/proc")) {
@@ -540 +530 @@
             retval += res;
             if (res) {
-                strcat(these_failed, mountlist->el[lino].device);
-                strcat(these_failed, " ");
+                mr_strcat(these_failed, "%s ",mountlist->el[lino].device);
             }
         }
@@ -556 +545 @@
                 ("format and restore *without* partitioning first. Sorry for the inconvenience.");
         }
-        sprintf(tmp, "Could not mount device(s) %s- shall I abort?",
-                these_failed);
+        sprintf(tmp, "Could not mount device(s) %s- shall I abort?", these_failed);
 
         if (!ask_me_yes_or_no(tmp)) {
@@ -573 +561 @@
         mvaddstr_and_log_it(g_currentY++, 74, "Done.");
     }
+    paranoid_free(these_failed);
+
     /* Also mounting under MNT_RESTORING  special FS */
     (void)mount_device("/proc","/proc","proc",TRUE);
@@ -580 +570 @@
     paranoid_free(tmp);
     paranoid_free(format);
-    paranoid_free(these_failed);
     return (retval);
 }
@@ -896 +885 @@
 read_cfg_var(cfg_file, "acl", value);
 if (strstr(value, "TRUE")) {
-    asprintf(&g_getfacl,"setfacl");
+    mr_asprintf(&g_getfacl,"setfacl");
     log_msg(1, "We will restore ACLs");
     if (! find_home_of_exe("setfacl")) {
@@ -904 +893 @@
 read_cfg_var(cfg_file, "xattr", value);
 if (strstr(value, "TRUE")) {
-    asprintf(&g_getfattr,"setfattr");
+    mr_asprintf(&g_getfattr,"setfattr");
     log_msg(1, "We will restore XATTRs");
     if (! find_home_of_exe("setfattr")) {
@@ -1398 +1387 @@
      * the current /dev location 
      */
-    asprintf(&cmd,"tar cf - /dev | ( cd %s ; tar xf - )",MNT_RESTORING);
+    mr_asprintf(&cmd,"tar cf - /dev | ( cd %s ; tar xf - )",MNT_RESTORING);
     run_program_and_log_output(cmd, 3);
     paranoid_free(cmd);
@@ -1410 +1399 @@
     read_cfg_var(g_mondo_cfg_file, "bootloader.device", device);
     read_cfg_var(g_mondo_cfg_file, "bootloader.name", name);
-    asprintf(&tmp, "run_boot_loader: device='%s', name='%s'", device, name);
+    mr_asprintf(&tmp, "run_boot_loader: device='%s', name='%s'", device, name);
     log_msg(2, tmp);
     paranoid_free(tmp);
@@ -1427 +1416 @@
 #ifdef __FreeBSD__
     else if (!strcmp(name, "BOOT0")) {
-        asprintf(&tmp, "boot0cfg -B %s", device);
+        mr_asprintf(&tmp, "boot0cfg -B %s", device);
         res = run_program_and_log_output(tmp, FALSE);
         paranoid_free(tmp);
     } else {
-        asprintf(&tmp, "ls /dev | grep -Eq '^%ss[1-4].*'", device);
+        mr_asprintf(&tmp, "ls /dev | grep -Eq '^%ss[1-4].*'", device);
         if (!system(tmp)) {
             paranoid_free(tmp);
-            asprintf(&tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
+            mr_asprintf(&tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
             res = run_program_and_log_output(tmp, 3);
         } else {
@@ -2019 +2008 @@
     int retval = 0, lino, res = 0, i;
     char *command;
-    char *tmp;
+    char *tmp = NULL;
 
     malloc_string(command);
-    malloc_string(tmp);
     assert(p_external_copy_of_mountlist != NULL);
 
@@ -2049 +2037 @@
     paranoid_system("sync");
 
-    sprintf(tmp, "cp -f %s " MNT_RESTORING "/var/log", MONDO_LOGFILE);
+    mr_asprintf(&tmp, "cp -f %s " MNT_RESTORING "/var/log", MONDO_LOGFILE);
     if (run_program_and_log_output(tmp, FALSE)) {
         log_msg(1,
                 "Error. Failed to copy log to PC's /var/log dir. (Mounted read-only?)");
     }
+    paranoid_free(tmp);
     if (does_file_exist("/tmp/DUMBASS-GENTOO")) {
         run_program_and_log_output("mkdir -p " MNT_RESTORING
@@ -2067 +2056 @@
             continue;
         }
-        sprintf(tmp, "Unmounting device %s  ", mountlist->el[lino].device);
+        mr_asprintf(&tmp, "Unmounting device %s  ", mountlist->el[lino].device);
 
         update_progress_form(tmp);
+
         if (is_this_device_mounted(mountlist->el[lino].device)) {
             if (!strcmp(mountlist->el[lino].mountpoint, "swap")) {
@@ -2094 +2084 @@
             res = run_program_and_log_output(command, 3);
         } else {
-            strcat(tmp, "...not mounted anyway :-) OK");
+            mr_strcat(tmp, "...not mounted anyway :-) OK");
             res = 0;
         }
         g_current_progress++;
         if (res) {
-            strcat(tmp, "...Failed");
+            mr_strcat(tmp, "...Failed");
             retval++;
             log_to_screen(tmp);
@@ -2105 +2095 @@
             log_msg(2, tmp);
         }
+        paranoid_free(tmp);
     }
     close_progress_form();
@@ -2119 +2110 @@
     free(mountlist);
     paranoid_free(command);
-    paranoid_free(tmp);
     return (retval);
 }

branches/2.2.9/mondo/src/mondorestore/mondorestore.c

@@ -2 +2 @@
 $Id$
 restores mondoarchive data
+The main file for mondorestore.
 ***************************************************************************/
-
-/**
- * @file
- * The main file for mondorestore.
- */
 
 /**************************************************************************
@@ -14 +10 @@
 #include <pthread.h>
 #include "my-stuff.h"
+#include "mr_mem.h"
 #include "../common/mondostructures.h"
 #include "../common/libmondo.h"
@@ -364 +361 @@
 
     /* Clean up blkid cache file if they exist */
-    asprintf(&tmp1,"%s/etc/blkid.tab",bkpinfo->restore_path);
+    mr_asprintf(&tmp1,"%s/etc/blkid.tab",bkpinfo->restore_path);
     (void)unlink(tmp1);
     paranoid_free(tmp1);
-    asprintf(&tmp1,"%s/etc/blkid.tab.old",bkpinfo->restore_path);
+    mr_asprintf(&tmp1,"%s/etc/blkid.tab.old",bkpinfo->restore_path);
     (void)unlink(tmp1);
     paranoid_free(tmp1);
@@ -379 +376 @@
 
     /* Clean up multiconf cache file if they exist */
-    asprintf(&tmp1,"%s/var/lib/multipath/bindings",bkpinfo->restore_path);
+    mr_asprintf(&tmp1,"%s/var/lib/multipath/bindings",bkpinfo->restore_path);
     (void)unlink(tmp1);
     paranoid_free(tmp1);
 
     /* Edit multipath.conf if needed to adapt wwid */
-    asprintf(&tmp1,"%s/etc/multipath.conf", MNT_RESTORING);
+    mr_asprintf(&tmp1,"%s/etc/multipath.conf", MNT_RESTORING);
     if (does_file_exist(tmp1)) {
         log_msg(2, "We may need to clean /etc/multipath.conf");
@@ -394 +391 @@
 
     if (bkpinfo->restore_mode != nuke) {
-        asprintf(&editor, "%s", find_my_editor());
-        asprintf(&tmp1,"chroot %s %s /etc/multipath.conf", MNT_RESTORING, editor);
+        mr_asprintf(&editor, "%s", find_my_editor());
+        mr_asprintf(&tmp1,"chroot %s %s /etc/multipath.conf", MNT_RESTORING, editor);
         popup_and_OK("You will now edit multipath.conf");
         if (!g_text_mode) {
@@ -788 +785 @@
     assert(raidlist != NULL);
 
-    asprintf(&tmpA, "%s", "xxxxxxxxx");
-    asprintf(&tmpB, "%s", "xxxxxxxxx");
-    asprintf(&tmpC, "%s", "xxxxxxxxx");
+    mr_asprintf(&tmpA, "%s", "         ");
+    mr_asprintf(&tmpB, "%s", "         ");
+    mr_asprintf(&tmpC, "%s", "         ");
 
     log_msg(2, "nuke_mode --- starting");
@@ -1671 +1668 @@
 
   /** malloc **/
-    char *command;
+    char *command = NULL;
     char *tmp;
     char *filelist_name;
@@ -1685 +1682 @@
 
     assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
-    malloc_string(command);
     malloc_string(tmp);
     malloc_string(filelist_name);
@@ -1698 +1694 @@
     use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
 //  sprintf(files_to_restore_this_time_fname, "/tmp/ftrttf.%d.%d", (int)getpid(), (int)random());
-    sprintf(command, "mkdir -p %s/tmp", MNT_RESTORING);
+    mr_asprintf(&command, "mkdir -p %s/tmp", MNT_RESTORING);
     run_program_and_log_output(command, 9);
+    paranoid_free(command);
+
     sprintf(temp_log, "/tmp/%d.%d", (int) (random() % 32768),
             (int) (random() % 32768));
@@ -1783 +1781 @@
 //      if (strstr(tarball_fname, ".star."))
         if (use_star) {
-            sprintf(command,
+            mr_asprintf(&command,
                     "star -x -force-remove -U " STAR_ACL_SZ
                     " errctl= file=%s", tarball_fname);
             if (strstr(tarball_fname, ".bz2")) {
-                strcat(command, " -bz");
+                mr_strcat(command, " -bz");
             }
         } else {
             if (filelist_subset_fname[0] != '\0') {
-                sprintf(command,
+                mr_asprintf(&command,
                         "afio -i -M 8m -b %ld -c %ld %s -w '%s' %s",
                         TAPE_BLOCK_SIZE,
@@ -1798 +1796 @@
                         tarball_fname);
             } else {
-                sprintf(command,
+                mr_asprintf(&command,
                         "afio -i -b %ld -c %ld -M 8m %s %s",
                         TAPE_BLOCK_SIZE,
@@ -1804 +1802 @@
             }
         }
+
 #undef BUFSIZE
-        sprintf(command + strlen(command), " 2>> %s >> %s", temp_log,
-                temp_log);
+        mr_strcat(command, " 2>> %s >> %s", temp_log, temp_log);
         log_msg(1, "command = '%s'", command);
         unlink(temp_log);
@@ -1818 +1816 @@
             }
         }
+        paranoid_free(command);
+
         if (res && length_of_file(temp_log) < 5) {
             res = 0;
@@ -1849 +1849 @@
         }
         if (retval) {
-            sprintf(command, "cat %s >> %s", temp_log, MONDO_LOGFILE);
+            mr_asprintf(&command, "cat %s >> %s", temp_log, MONDO_LOGFILE);
             system(command);
+            paranoid_free(command);
+
             log_msg(2, "Errors occurred while processing fileset #%d",
                     current_tarball_number);
@@ -1867 +1869 @@
 
   leave_sub:
-    paranoid_free(command);
     paranoid_free(tmp);
     paranoid_free(filelist_name);
@@ -2249 +2250 @@
     long max_val;
   /**malloc ***/
-    char *tmp;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
     char *tarball_fname;
     char *progress_str;
@@ -2271 +2273 @@
     read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
     max_val = atol(tmp) + 1;
+    paranoid_free(tmp);
+
     sprintf(progress_str, "Restoring from %s #%d",
             media_descriptor_string(bkpinfo->backup_media_type),
@@ -2334 +2338 @@
                                               filelist);
             }
-            sprintf(tmp, "%s #%d, fileset #%ld - restore ",
+            mr_asprintf(&tmp1, "%s #%d, fileset #%ld - restore ",
                     media_descriptor_string(bkpinfo->backup_media_type),
                     g_current_media_number, current_tarball_number);
             if (res) {
-                strcat(tmp, "reported errors");
+                mr_strcat(tmp1, "reported errors");
             } else if (attempts > 1) {
-                strcat(tmp, "succeeded");
+                mr_strcat(tmp1, "succeeded");
             } else {
-                strcat(tmp, "succeeded");
+                mr_strcat(tmp1, "succeeded");
             }
             if (attempts > 1) {
-                sprintf(tmp + strlen(tmp), " (%d attempts) - review logs",
-                        attempts);
-            }
-            strcpy(comment, tmp);
+                mr_strcat(tmp1, " (%d attempts) - review logs", attempts);
+            }
+            strcpy(comment, tmp1);
+            paranoid_free(tmp1);
             if (attempts > 1) {
                 log_to_screen(comment);
@@ -2364 +2368 @@
         mvaddstr_and_log_it(g_currentY++, 74, "Done.");
     }
-    paranoid_free(tmp);
     paranoid_free(tarball_fname);
     paranoid_free(progress_str);