Changeset 2009 in MondoRescue

Timestamp:

Aug 11, 2008, 3:05:15 AM (16 years ago)

Author:

Bruno Cornec

Message:

Commit ald modifs in trunk - just in case

Location:

trunk/mondo/src

Files:

• mondoarchive/mondo-cli.c (modified) (16 diffs)
• mondorestore/Makefile.am (modified) (3 diffs)
• mondorestore/mondo-prep.c (modified) (88 diffs)
• mondorestore/mondo-restore-EXT.h (modified) (1 diff)
• mondorestore/mondo-rstr-compare.c (modified) (18 diffs)
• mondorestore/mondo-rstr-newt.h (modified) (2 diffs)
• mondorestore/mondoprep.h (modified) (1 diff)
• mondorestore/mondorestore.c (moved) (moved from trunk/mondo/src/mondorestore/mondo-restore.c ) (86 diffs)
• mondorestore/mr-externs.h (modified) (3 diffs)

trunk/mondo/src/mondoarchive/mondo-cli.c

@@ -140 +140 @@
 {
     int j;
-    char *tmp;
-    char *p;
-    char *q;
-    char *comment;
+    char *tmp = NULL;
+    char *p = NULL;
+    char *q = NULL;
 
     assert(bkpinfo != NULL);
@@ -159 +158 @@
         mr_free(tmp);
 
-        mr_asprintf(&comment, "media_size[%d] = %ld", j,
+        mr_msg(3, "media_size[%d] = %ld", j,
                 bkpinfo->media_size[j]);
-        mr_msg(3, comment);
-        mr_free(comment);
     }
     for (; j <= MAX_NOOF_MEDIA; j++) {
@@ -201 +198 @@
     char *tmp = NULL;
     char *tmp1 = NULL;
+    char *tmp2 = NULL;
     char *psz = NULL;
     char *p = NULL;
@@ -398 +396 @@
         mr_free(tmp); // allocation from find_tape_device_and_size
 
-        mr_asprintf(&tmp,
+        mr_asprintf(&tmp2,
                 _("You didn't specify a tape streamer device. I'm assuming %s"),
                 flag_val['d']);
-        log_to_screen(tmp);
-        mr_free(tmp);
+        log_to_screen(tmp2);
+        mr_free(tmp2);
         percent = 0;
     }
@@ -481 +479 @@
             mr_allocstr(bkpinfo->nfs_remote_dir,"/");
         }
-        mr_asprintf(&tmp, "mount | grep -E '^%s .*$' | cut -d' ' -f3",
+        mr_asprintf(&tmp2, "mount | grep -E '^%s .*$' | cut -d' ' -f3",
                 bkpinfo->nfs_mount);
         mr_free(bkpinfo->isodir);
-        bkpinfo->isodir = call_program_and_get_last_line_of_output(tmp);
-        mr_free(tmp);
+        bkpinfo->isodir = call_program_and_get_last_line_of_output(tmp2);
+        mr_free(tmp2);
 
         if (strlen(bkpinfo->isodir) < 3) {
@@ -642 +640 @@
             if (!does_file_exist(bkpinfo->kernel_path)) {
                 retval++;
-                mr_asprintf(&tmp,
+                mr_asprintf(&tmp2,
                     _("You specified kernel '%s', which does not exist\n"),
                     bkpinfo->kernel_path);
-                log_to_screen(tmp);
-                mr_free(tmp);
+                log_to_screen(tmp2);
+                mr_free(tmp2);
             }
         } else {
@@ -660 +658 @@
         if (flag_set['i']) {
             mr_allocstr(bkpinfo->isodir,flag_val['d']);
-            mr_asprintf(&tmp, "ls -l %s", bkpinfo->isodir);
-            if (run_program_and_log_output(tmp, FALSE)) {
+            mr_asprintf(&tmp2, "ls -l %s", bkpinfo->isodir);
+            if (run_program_and_log_output(tmp2, FALSE)) {
                 fatal_error
                     ("output folder does not exist - please create it");
             }
-            mr_free(tmp);
+            mr_free(tmp2);
         } else if (flag_set['n']) {
             mr_allocstr(bkpinfo->nfs_remote_dir,flag_val['d']);
@@ -674 +672 @@
 
     if (flag_set['n']) {
-        mr_asprintf(&tmp, "echo hi > %s/%s/.dummy.txt", bkpinfo->isodir,
+        mr_asprintf(&tmp2, "echo hi > %s/%s/.dummy.txt", bkpinfo->isodir,
                 bkpinfo->nfs_remote_dir);
-        if (run_program_and_log_output(tmp, FALSE)) {
+        if (run_program_and_log_output(tmp2, FALSE)) {
             retval++;
-            mr_free(tmp);
-            mr_asprintf(&tmp,
+            mr_free(tmp2);
+            mr_asprintf(&tmp2,
                     _("Are you sure directory '%s' exists in remote dir '%s'?\nIf so, do you have rights to write to it?\n"),
                     bkpinfo->nfs_remote_dir, bkpinfo->nfs_mount);
-            log_to_screen(tmp);
-        }
-        mr_free(tmp);
+            log_to_screen(tmp2);
+        }
+        mr_free(tmp2);
     }
 
@@ -730 +728 @@
         mr_free(bkpinfo->tmpdir);
         bkpinfo->tmpdir = tmp;
-        mr_asprintf(&tmp, "touch %s/.foo.dat", flag_val['T']);
-        if (run_program_and_log_output(tmp, 1)) {
+        mr_asprintf(&tmp2, "touch %s/.foo.dat", flag_val['T']);
+        if (run_program_and_log_output(tmp2, 1)) {
             retval++;
             log_to_screen
@@ -737 +735 @@
             fatal_error("I cannot write to the tempdir you specified.");
         }
-        mr_free(tmp);
-
-        mr_asprintf(&tmp, "ln -sf %s/.foo.dat %s/.bar.dat", flag_val['T'],
+        mr_free(tmp2);
+
+        mr_asprintf(&tmp2, "ln -sf %s/.foo.dat %s/.bar.dat", flag_val['T'],
                 flag_val['T']);
-        if (run_program_and_log_output(tmp, 1)) {
+        if (run_program_and_log_output(tmp2, 1)) {
             retval++;
             log_to_screen
@@ -747 +745 @@
             fatal_error("I cannot write to the tempdir you specified.");
         }
-        mr_free(tmp);
+        mr_free(tmp2);
     }
 
@@ -788 +786 @@
         mr_allocstr(bkpinfo->boot_device,tmp);
     }
+
     if (flag_set['Q']) {
-        if (tmp == NULL) {
-            printf("-f option required when using -Q\n");
-            finish(-1);
-        }
-        i = which_boot_loader(tmp);
-        mr_msg(3, "boot loader is %c, residing at %s", i, tmp);
-        printf(_("boot loader is %c, residing at %s\n"), i, tmp);
-        mr_free(tmp);
+        if (bkpinfo->boot_device == NULL) {
+            fatal_error("-f option required when using -Q\n");
+        }
+        i = which_boot_loader(bkpinfo->boot_device);
+        mr_msg(3, "boot loader is %c, residing at %s", i, bkpinfo->boot_device);
+        log_to_screen(_("boot loader is %c, residing at %s\n"), i, tmp);
         finish(0);
     }
-    mr_free(tmp);
 
     if (flag_set['P']) {
@@ -880 +876 @@
     return (retval);
 }
-
 
 
@@ -901 +896 @@
     /*@ ints ** */
     int opt = 0;
-    char *tmp;
+    char *tmp = NULL;
     int i = 0;
-    int len;
+    int len = 0;
 
     /*@ bools *** */
@@ -965 +960 @@
 
 
-
-
 /**
  * Print a not-so-helpful help message and exit.
  */
-void help_screen()
+void help_screen(void)
 {
     mr_msg(1, "Type 'man mondo-archive' for more information\n");
@@ -983 +976 @@
 void terminate_daemon(int sig)
 {
-    char *tmp;
-    char *tmp2;
+    char *tmp = NULL;
+    char *tmp2 = NULL;
 
     switch (sig) {

trunk/mondo/src/mondorestore/Makefile.am

@@ -1 @@
-## $Id$
 ##
 ## $Id$
@@ -5 +4 @@
 ## Process with Automake to generate Makefile.in
 ##
-AM_CPPFLAGS = -DMONDO_CONF_DIR=\"$(sysconfdir)\" -I${top_builddir}/src/include
+AM_CPPFLAGS = -DMONDO_CONF_DIR=\"$(sysconfdir)\" -I${top_builddir}/src/include -I${top_builddir}/src/common
 
 ## Headers
@@ -14 +13 @@
 ## The program
 sbin_PROGRAMS         = mondorestore
-mondorestore_SOURCES  = mondo-prep.c mondo-restore.c mondo-rstr-newt.c \
+mondorestore_SOURCES  = mondo-prep.c mondorestore.c mondo-rstr-newt.c \
                         mondo-rstr-compare.c mondo-rstr-tools.c
 mondorestore_LDADD    = ${top_builddir}/src/common/libmondo.a ${top_builddir}/src/lib/libmr.a @MONDORESTORE_STATIC@

trunk/mondo/src/mondorestore/mondo-prep.c

@@ -10 +10 @@
 
 #include "my-stuff.h"
-#include "../common/mondostructures.h"
+#include "mondostructures.h"
 #include "mondoprep.h"
-#include "../common/libmondo.h"
+#include "libmondo.h"
 #include "mondo-rstr-tools-EXT.h"
 
@@ -20 +20 @@
 #include <unistd.h>
 #include "mr_mem.h"
+#include "mr_msg.h"
 
 
@@ -52 +53 @@
 void wipe_MBRs_and_reboot_if_necessary(struct mountlist_itself *mountlist)
 {
-    char *command;
-    int lino;
-    FILE *fout;
-    char *buf;
+    char *command = NULL;
+    int lino = 0;
+    int res = 0;
+    FILE *fout = NULL;
+    char *buf = NULL;
     struct list_of_disks *drivelist = NULL;
-// If LVMs are present and a zero-and-reboot wasn't recently undertaken
-// then zero & insist on reboot.
+
+    // If LVMs are present and a zero-and-reboot wasn't recently undertaken
+    // then zero & insist on reboot.
     if (does_file_exist("/tmp/i-want-my-lvm"))  // FIXME - cheating :)
     {
@@ -67 +70 @@
                      "dd if=%s bs=512 count=1 2> /dev/null | grep \"%s\"",
                      drivelist->el[lino].device, MONDO_WAS_HERE);
-            if (!run_program_and_log_output(command, 1)) {
+            res = run_program_and_log_output(command, 1);
+            mr_free(command);
+            if (!res) {
                 mr_msg(1, "Found MONDO_WAS_HERE marker on drive#%d (%s)",
                         lino, drivelist->el[lino].device);
-                mr_free(command);
                 break;
             }
-            mr_free(command);
         }
 
         if (lino == drivelist->entries) {
-// zero & reboot
+            // zero & reboot
             log_to_screen
                 (_
@@ -120 +123 @@
 int fput_string_one_char_at_a_time(FILE * fout, char *str)
 {
-    int i, j;
-    FILE *fq;
+    int i = 0, j = 0;
+    FILE *fq = NULL;
 
     if (ferror(fout)) {
@@ -159 +162 @@
                           bool vacuum_pack)
 {
-    /** char **************************************************/
     char *tmp = NULL;
     char *tmp1 = NULL;
@@ -178 +180 @@
     int i = 0;
     int lvmversion = 1;
-    long extents;
+    long extents = 0L;
     fpos_t orig_pos;
     size_t n = 0;
@@ -184 +186 @@
 
     /** pointers **********************************************/
-    FILE *fin;
+    FILE *fin = NULL;
 
     /** end *****************************************************/
@@ -257 +259 @@
             continue;
         }
-        if (res && strstr(command, "create") && vacuum_pack) {
-            sleep(2);
-            sync();
-            sync();
-            sync();
-        }
         if ((p = strstr(incoming, "vgcreate"))) {
             // include next line(s) if they end in /dev (cos we've got a broken i-want-my-lvm)
@@ -271 +267 @@
                 } else {
                     fgetpos(fin, &orig_pos);
-                    mr_asprintf(&tmp1, "%s%s", incoming, tmp);
-                    mr_free(incoming);
-                    incoming = tmp1;
+                    mr_strcat(incoming, tmp);
                 }
             }
@@ -287 +281 @@
             *q = '\0';
             mr_msg(1, "Deleting old entries at /dev/%s", tmp1);
-            mr_asprintf(&tmp, "rm -Rf /dev/%s", tmp1);
+            mr_asprintf(&command, "rm -Rf /dev/%s", tmp1);
             mr_free(tmp1);
 
-            run_program_and_log_output(tmp, 1);
-            mr_free(tmp);
+            run_program_and_log_output(command, 1);
+            mr_free(command);
 
             run_program_and_log_output(vgscan_sz, 1);
@@ -300 +294 @@
         }
         for (p = incoming + 1; *p == ' '; p++);
-        mr_allocstr(command,p);
+        mr_asprintf(&command,p);
         for (p = command; *p != '\0'; p++);
-        for (; *(p - 1) < 32; p--);
+        for (; (*(p - 1) < 32) && (p > command) ; p--);
         *p = '\0';
 
@@ -319 +313 @@
             if (strstr(command, "lvm lvcreate"))
                 lvmversion = 2;
-            /* BERLIOS : this tmp may be uninitialized ?
-            log_it("%s... so I'll get creative.", tmp);
-            */
             if (lvmversion == 2) {
                 tmp = call_program_and_get_last_line_of_output
-                        ("tail -n5 " MONDO_LOGFILE
-                        " | grep Insufficient | tail -n1");
+                        ("tail -n5 " MONDO_LOGFILE " | grep Insufficient | tail -n1");
             } else {
                 tmp = call_program_and_get_last_line_of_output
-                       ("tail -n5 " MONDO_LOGFILE
-                        " | grep lvcreate | tail -n1");
+                       ("tail -n5 " MONDO_LOGFILE " | grep lvcreate | tail -n1");
             }
             for (p = tmp; *p != '\0' && !isdigit(*p); p++);
@@ -373 +362 @@
                 mr_msg(0, "%s --> %d", command, res);
                 if (!res) {
-                    mr_msg(5, "YAY! This time, it succeeded.");
+                    mr_msg(5, "Yep! This time, it succeeded.");
                 }
             }
@@ -429 +418 @@
     int j = 0;
     char *incoming = NULL;
-    char *tmp = NULL;
     char *p = NULL;
     size_t n = 0;
@@ -465 +453 @@
                  mr_getline(&incoming, &n, fin));
             if (!feof(fin)) {
-                mr_asprintf(&tmp, "Investigating %s",
+                log_it("Investigating %s",
                         old_mountlist->el[lino].device);
-                log_it(tmp);
-                mr_free(tmp);
-
                 for (mr_getline(&incoming, &n, fin); !feof(fin)
                      && !strstr(incoming, "raiddev");
@@ -476 +461 @@
                         && !strchr(incoming, '#')) {
                         for (p = incoming + strlen(incoming);
-                             *(p - 1) <= 32; p--);
+                             (*(p - 1) <= 32) && (p >= incoming) ; p--);
                         *p = '\0';
-                        for (p--; p > incoming && *(p - 1) > 32; p--);
-                        mr_asprintf(&tmp, "Extrapolating %s", p);
-                        log_it(tmp);
-                        mr_free(tmp);
-
+                        for (p--; (p >= incoming) && (*(p - 1) > 32); p--);
+                        log_it("Extrapolating %s", p);
                         for (j = 0;
                              j < new_mountlist->entries
@@ -500 +482 @@
                             new_mountlist->entries++;
                         } else {
-                            mr_asprintf(&tmp,
-                                    "Not adding %s to mountlist: it's already there", p);
-                            log_it(tmp);
-                            mr_free(tmp);
+                            log_it("Not adding %s to mountlist: it's already there", p);
                         }
                     }
@@ -509 +488 @@
             }
             mr_free(incoming);
+
             paranoid_fclose(fin);
         } else {
@@ -534 +514 @@
  * @return 0 for success, nonzero for failure.
  */
-int create_raid_device_via_mdadm(struct raidlist_itself *raidlist,
-                                 char *device)
+int create_raid_device_via_mdadm(struct raidlist_itself *raidlist, char *device)
 {
   /** int **************************************************************/
@@ -567 +546 @@
   mr_asprintf(&devices, raidlist->el[i].data_disks.el[0].device);
   for (j = 1; j < raidlist->el[i].data_disks.entries; j++) {
-    mr_asprintf(&strtmp, "%s", devices);
-    mr_free(devices);
-    mr_asprintf(&devices, "%s %s", strtmp,
-         raidlist->el[i].data_disks.el[j].device);
-    mr_free(strtmp);
+    mr_strcat(devices, " %s", raidlist->el[i].data_disks.el[j].device);
   }
   for (j = 0; j < raidlist->el[i].spare_disks.entries; j++) {
-    mr_asprintf(&strtmp, "%s", devices);
-    mr_free(devices);
-    mr_asprintf(&devices, "%s %s", strtmp,
-         raidlist->el[i].spare_disks.el[j].device);
-    mr_free(strtmp);
+    mr_strcat(devices, " %s", raidlist->el[i].spare_disks.el[j].device);
   }
   // translate RAID level
@@ -597 +568 @@
        raidlist->el[i].raid_device, level,
        raidlist->el[i].data_disks.entries);
+  mr_free(level);
   if (raidlist->el[i].parity != -1) {
-    asprintf(&strtmp, "%s", program);
-    mr_free(program);
     switch(raidlist->el[i].parity) {
     case 0:
-      mr_asprintf(&program, "%s --parity=%s", strtmp, "la");
+      mr_strcat(program, " --parity=%s", "la");
       break;
     case 1:
-      mr_asprintf(&program, "%s --parity=%s", strtmp, "ra");
+      mr_strcat(program, " --parity=%s", "ra");
       break;
     case 2:
-      mr_asprintf(&program, "%s --parity=%s", strtmp, "ls");
+      mr_strcat(program, " --parity=%s", "ls");
       break;
     case 3:
-      mr_asprintf(&program, "%s --parity=%s", strtmp, "rs");
+      mr_strcat(program, " --parity=%s", "rs");
       break;
     default:
@@ -617 +587 @@
       break;
     }
-    mr_free(strtmp);
   }
   if (raidlist->el[i].chunk_size != -1) {
-    mr_asprintf(&strtmp, "%s", program);
-    mr_free(program);
-    mr_asprintf(&program, "%s --chunk=%d", strtmp, raidlist->el[i].chunk_size);
-    mr_free(strtmp);
+        mr_strcat(program, " --chunk=%d", raidlist->el[i].chunk_size);
   }
   if (raidlist->el[i].spare_disks.entries > 0) {
-    mr_asprintf(&strtmp, "%s", program);
-    mr_free(program);
-    mr_asprintf(&program, "%s --spare-devices=%d", strtmp,
-         raidlist->el[i].spare_disks.entries);
-    mr_free(strtmp);
+        mr_strcat(program, " --spare-devices=%d", raidlist->el[i].spare_disks.entries);
   }
-  mr_asprintf(&strtmp, "%s", program);
-  mr_free(program);
-  mr_asprintf(&program, "%s %s", strtmp, devices);
-  mr_free(strtmp);
+    mr_strcat(program, " %s", devices);
   res = run_program_and_log_output(program, 1);
   // free memory
   mr_free(devices);
-  mr_free(level);
   mr_free(program);
   // return to calling instance
-  return res;
+  return(res);
 }
 
@@ -656 +614 @@
  * @return 0 for success, nonzero for failure.
  */
-int format_device(char *device, char *format,
-                  struct raidlist_itself *raidlist)
+int format_device(char *device, char *format, struct raidlist_itself *raidlist)
 {
     /** int **************************************************************/
@@ -673 +630 @@
     char *line = NULL;
     char *status = NULL;
-    FILE *pin;
-    FILE *fin;
+    FILE *pin = NULL;
+    FILE *fin = NULL;
     size_t n = 0;
     size_t n1 = 0;
@@ -685 +642 @@
 
     if (strstr(format, "raid")) {   // do not form RAID disks; do it to /dev/md* instead
-        mr_asprintf(&tmp, "Not formatting %s (it is a RAID disk)", device);
-        log_it(tmp);
-        mr_free(tmp);
+        log_it("Not formatting %s (it is a RAID disk)", device);
         return (0);
     }
@@ -700 +655 @@
                 "%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);
-        mr_free(tmp);
         return (0);
     }
     if (is_this_device_mounted(device)) {
-        mr_asprintf(&tmp, _("%s is mounted - cannot format it       "), device);
-        log_to_screen(tmp);
-        mr_free(tmp);
+        log_to_screen(_("%s is mounted - cannot format it       "), device);
         return (1);
     }
@@ -734 +685 @@
 
         if (vinum_started_yet) {
-            mr_asprintf(&tmp,
-                    _
-                    ("Initializing Vinum device %s (this may take a *long* time)"),
+            log_to_screen(_("Initializing Vinum device %s (this may take a *long* time)"),
                     device);
-            log_to_screen(tmp);
-            mr_free(tmp);
 
             /* format raid partition */
@@ -785 +732 @@
             }
             mr_free(line);
+
             fclose(fin);
             unlink("/tmp/plexes");
@@ -790 +738 @@
         }
 #else
-        mr_asprintf(&tmp, _("Initializing RAID device %s"), device);
-        log_to_screen(tmp);
-        mr_free(tmp);
-
-// Shouldn't be necessary.
+        log_to_screen(_("Initializing RAID device %s"), device);
+
+        // Shouldn't be necessary.
         log_to_screen(_("Stopping %s"), device);
         stop_raid_device(device);
         sync();
         sleep(1);
-        /* BERLIOS: This code is wrong as program has not been initialized
-        if (g_fprep) {
-            fprintf(g_fprep, "%s\n", program);
-        }
-        */
 
         mr_msg(1, "Making %s", device);
         // use mkraid if it exists, otherwise use mdadm
-        if (run_program_and_log_output("which mkraid", FALSE)) {
-            res = create_raid_device_via_mdadm(raidlist, device);
-            mr_msg(1, "Creating RAID device %s via mdadm returned %d",
-                    device, res);
+        if (run_program_and_log_output("which mkraid", FALSE)) {
+            res = create_raid_device_via_mdadm(raidlist, device);
+            mr_msg(1, "Creating RAID device %s via mdadm returned %d", device, res);
         } else {
             mr_asprintf(&program, "mkraid --really-force %s", device);
@@ -830 +770 @@
         newtResume();
     }
-//#ifndef __FreeBSD__
-//#endif
 
     if (!strcmp(format, "lvm")) {
@@ -849 +787 @@
     mr_free(tmp);
 
-    mr_asprintf(&tmp, "Formatting %s as %s", device, format);
+    mr_asprintf(&tmp, _("Formatting %s as %s"), device, format);
     update_progress_form(tmp);
 
     res = run_program_and_log_output(program, FALSE);
     if (res && strstr(program, "kludge")) {
+        mr_free(tmp);
+        mr_asprintf(&tmp, _("Kludge failed; using regular mkfs.%s to format %s"), format, device);
+        mr_free(program);
 #ifdef __FreeBSD__
-        mr_free(program);
         mr_asprintf(&program, "newfs_msdos -F 32 %s", device);
 #else
@@ -861 +801 @@
         /* For EFI partitions take fat16 
          * as we want to make small ones */
-        mr_free(program);
         mr_asprintf(&program, "mkfs -t %s -F 16 %s", format, device);
 #else
-        mr_free(program);
         mr_asprintf(&program, "mkfs -t %s -F 32 %s", format, device);
 #endif
@@ -877 +815 @@
     retval += res;
     if (retval) {
-        mr_asprintf(&tmp1, "%s%s",tmp, _("...failed"));
+        mr_strcat(tmp, _("...failed"));
     } else {
-        mr_asprintf(&tmp1, "%s%s",tmp, _("...OK"));
-    }
+        mr_strcat(tmp, _("...OK"));
+    }
+    log_to_screen(tmp);
     mr_free(tmp);
 
-    log_to_screen(tmp1);
-    mr_free(tmp1);
     sync();
     sleep(1);
@@ -902 +839 @@
     /** int **************************************************************/
     int retval = 0;
-    int lino;
-    int res;
-//  int i;
-//  struct list_of_disks *drivelist;
+    int lino = 0;
+    int res = 0;
 
     /** long *************************************************************/
-    long progress_step;
+    long progress_step = 0L;
 
     /** bools ************************************************************/
-    bool do_it;
+    bool do_it = FALSE;
 
     /** buffers **********************************************************/
-    char *tmp;
+    char *tmp = NULL;
 
     /** pointers *********************************************************/
-    struct mountlist_line *me;  // mountlist entry
+    struct mountlist_line *me = NULL;   // mountlist entry
     /** end **************************************************************/
 
     assert(mountlist != NULL);
-    mr_asprintf(&tmp, "format_everything (mountlist, interactively = %s",
+    log_it("format_everything (mountlist, interactively = %s",
             (interactively) ? "true" : "false");
-    log_it(tmp);
-    mr_free(tmp);
-
     mvaddstr_and_log_it(g_currentY, 0, _("Formatting partitions     "));
     open_progress_form(_("Formatting partitions"),
@@ -935 +867 @@
         (mountlist->entries >
          0) ? g_maximum_progress / mountlist->entries : 1;
-// start soft-raids now (because LVM might depend on them)
-// ...and for simplicity's sake, let's format them at the same time :)
+    // start soft-raids now (because LVM might depend on them)
+    // ...and for simplicity's sake, let's format them at the same time :)
     mr_msg(1, "Stopping all RAID devices");
     stop_all_raid_devices(mountlist);
@@ -968 +900 @@
     sync();
     sleep(2);
-// This last step is probably necessary
-//  log_to_screen("Re-starting software RAIDs...");
-//  start_all_raid_devices(mountlist);
-//  system("sync"); system("sync"); system("sync"); 
-//  sleep(5);
-// do LVMs now
+    // This last step is probably necessary
+    //  log_to_screen("Re-starting software RAIDs...");
+    //  start_all_raid_devices(mountlist);
+    //  system("sync"); system("sync"); system("sync"); 
+    //  sleep(5);
+    // do LVMs now
     mr_msg(1, "Creating LVMs");
     if (does_file_exist("/tmp/i-want-my-lvm")) {
@@ -995 +927 @@
         sleep(3);
     }
-// do regulars at last
+    // do regulars at last
     sleep(2);                   // woo!
     mr_msg(1, "Formatting regulars");
@@ -1001 +933 @@
         me = &mountlist->el[lino];  // the current mountlist entry
         if (!strcmp(me->mountpoint, "image")) {
-            mr_asprintf(&tmp, "Not formatting %s - it's an image", me->device);
-            log_it(tmp);
-            mr_free(tmp);
+            log_it("Not formatting %s - it's an image", me->device);
         } else if (!strcmp(me->format, "raid")) {
-            mr_asprintf(&tmp, "Not formatting %s - it's a raid-let",
-                    me->device);
-            log_it(tmp);
-            mr_free(tmp);
+            log_it("Not formatting %s - it's a raid-let", me->device);
             continue;
         } else if (!strcmp(me->format, "lvm")) {
-            mr_asprintf(&tmp, "Not formatting %s - it's an LVM", me->device);
-            log_it(tmp);
-            mr_free(tmp);
+            log_it("Not formatting %s - it's an LVM", me->device);
             continue;
         } else if (!strncmp(me->device, "/dev/md", 7)) {
-            mr_asprintf(&tmp, "Already formatted %s - it's a soft-RAID dev",
-                    me->device);
-            log_it(tmp);
-            mr_free(tmp);
+            log_it("Already formatted %s - it's a soft-RAID dev", me->device);
             continue;
         } else if (!does_file_exist(me->device)
                    && strncmp(me->device, "/dev/hd", 7)
                    && strncmp(me->device, "/dev/sd", 7)) {
-            mr_asprintf(&tmp,
-                    "Not formatting %s yet - doesn't exist - probably an LVM",
-                    me->device);
-            log_it(tmp);
-            mr_free(tmp);
+            log_it("Not formatting %s yet - doesn't exist - probably an LVM", me->device);
             continue;
         } else {
@@ -1066 +984 @@
     }
 
-    mr_asprintf(&tmp, "format_everything () - %s",
+    log_it("format_everything () - %s",
             (retval) ? "failed!" : "finished successfully");
-    log_it(tmp);
-    mr_free(tmp);
 
     if (g_partition_table_locked_up > 0) {
@@ -1120 +1036 @@
 {
     /** int **************************************************************/
-    int current_devno;
-    int previous_devno;
+    int current_devno = 0;
+    int previous_devno = 0;
     int retval = 0;
-    int res;
-
-    /** buffers **********************************************************/
-    char *tmp;
+    int res = 0;
 
     /** end **************************************************************/
@@ -1133 +1046 @@
 
     if (devno_we_must_allow_for >= 5) {
-        mr_asprintf(&tmp, "Making dummy primary %s%d", drivename, 1);
-        log_it(tmp);
-        mr_free(tmp);
-
+        log_it("Making dummy primary %s%d", drivename, 1);
         g_maximum_progress++;
         res =
@@ -1149 +1059 @@
     }
     for (; current_devno < devno_we_must_allow_for; current_devno++) {
-        mr_asprintf(&tmp, "Creating dummy partition %s%d", drivename,
-                current_devno);
-        log_it(tmp);
-        mr_free(tmp);
-
+        log_it("Creating dummy partition %s%d", drivename, current_devno);
         g_maximum_progress++;
         res =
@@ -1293 +1199 @@
 {
     static struct disklabel loclab;
-    struct partition *dp;
-    char *lnamebuf;
+    struct partition *dp = NULL;
+    char *lnamebuf = NULL;
     int f;
     u_int secsize, u;
@@ -1376 +1282 @@
                          char *drivename, struct disklabel *ret)
 {
-    char *subdev_str;
-    char *command;
-    struct disklabel *lp;
+    char *subdev_str = NULL;
+    char *command = NULL;
+    struct disklabel *lp = NULL;
     int i, lo = 0;
     int retval = 0;
-    char c;
-    FILE *ftmp;
+    char c = ' ';
+    FILE *ftmp = NULL;
 
     lp = get_virgin_disklabel(drivename);
@@ -1493 +1399 @@
     assert_string_is_neither_NULL_nor_zerolength(drivename);
 
-    mr_asprintf(&tmp, "Partitioning drive %s", drivename);
-    log_it(tmp);
-    mr_free(tmp);
+    log_it("Partitioning drive %s", drivename);
 
 #if __FreeBSD__
@@ -1523 +1427 @@
             // then see if the user has picked 'dangerously-dedicated' mode.
             // If so, then we just call label_drive_or_slice() and return.
-            char c;
-            char *command;
+            char c = ' ';
+            char *command = NULL;
 
             if (current_devno == 1) {
@@ -1593 +1497 @@
             file = open(drivename, O_WRONLY);
             if (!file) {
-                mr_asprintf(&tmp,
-                        _("Warning - unable to open %s for wiping it's partition table"),
-                        drivename);
-                log_to_screen(tmp);
-                mr_free(tmp);
+                log_to_screen(_("Warning - unable to open %s for wiping it's partition table"), drivename);
             }
 
             for (i = 0; i < 512; i++) {
                 if (!write(file, "\0", 1)) {
-                    mr_asprintf(&tmp, _("Warning - unable to write to %s"),
-                            drivename);
-                    log_to_screen(tmp);
-                    mr_free(tmp);
+                    log_to_screen(_("Warning - unable to write to %s"), drivename);
                 }
             }
@@ -1625 +1522 @@
         if (!fbsd_part) {
 #endif
-
+            mr_free(format);
             mr_asprintf(&format, mountlist->el[lino].format);
             partsize = mountlist->el[lino].size;
@@ -1633 +1530 @@
 #endif
 
+#ifndef __IA64__
         if (current_devno == 5 && previous_devno == 4) {
             log_to_screen
@@ -1641 +1539 @@
             return (1);
         }
+#endif
 
         retval +=
@@ -1716 +1615 @@
 
     /** buffers **********************************************************/
-    char *program;
-    char *partition_name;
-    char *tmp;
-    char *output;
+    char *program = NULL;
+    char *partition_name = NULL;
+    char *tmp = NULL;
+    char *output = NULL;
 
     /** pointers **********************************************************/
-    char *p;
-    char *part_table_fmt;
-    FILE *fout;
+    char *p = NULL;
+    char *part_table_fmt = NULL;
+    FILE *fout = NULL;
 
     /** end ***************************************************************/
@@ -1735 +1634 @@
 
     if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
-        mr_asprintf(&tmp, "Not partitioning %s - it is a virtual drive", drive);
-        log_it(tmp);
-        mr_free(tmp);
+        log_it("Not partitioning %s - it is a virtual drive", drive);
         return (0);
     }
@@ -1752 +1649 @@
 
     if (is_this_device_mounted(partition_name)) {
-        mr_asprintf(&tmp, _("%s is mounted, and should not be partitioned"),
+        log_to_screen("%s is mounted, and should not be partitioned",
                 partition_name);
         mr_free(partition_name);
-
-        log_to_screen(tmp);
-        mr_free(tmp);
         return (1);
     }
 
     p = (char *) strrchr(partition_name, '/');
-    mr_asprintf(&program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE,
-            MONDO_LOGFILE);
 
     /* BERLIOS: should not be called each time */
@@ -1779 +1671 @@
                          ("You need to leave at least one partition free, for 'extended/logical'"));
                     mr_free(partition_name);
-                    mr_free(program);
-
-                    mr_free(output);
                     return (1);
                 } else {
@@ -1787 +1676 @@
                 }
             }
-            mr_asprintf(&tmp,"%sn\nl\n",output);
-            mr_free(output);
-            output = tmp;
+            mr_strcat(output, "n\nl\n");
         } else {
             /* GPT allows more than 4 primary partitions */
@@ -1797 +1684 @@
     mr_free(part_table_fmt);
     /*start block (ENTER for next free blk */
-    mr_asprintf(&tmp,"%s\n",output);
-    mr_free(output);
-    output = tmp;
-
+    mr_strcat(output, "\n");    
     if (partsize > 0) {
         if (!strcmp(format, "7")) {
@@ -1806 +1690 @@
             partsize += 512;
         }
-        mr_asprintf(&tmp,"%s+%lldK", output,  (long long) (partsize));
-        mr_free(output);
-        output = tmp;
-    }
-    mr_asprintf(&tmp,"%s\n",output);
-    mr_free(output);
-    output = tmp;
+        mr_strcat(output, "+%lldK", (long long) (partsize));
+    }
+    mr_strcat(output, "\n");
 #if 0
 /*
 #endif
-    mr_asprintf(&tmp,"PARTSIZE = +%ld",(long)partsize);
-    log_it(tmp);
-    mr_free(tmp);
-
+    log_it("PARTSIZE = +%ld",(long)partsize);
     log_it("---fdisk command---");
     log_it(output);
@@ -1860 +1737 @@
         }
     } else {
-        mr_asprintf(&tmp,"%sw\n\n",output);
-        mr_free(output);
-        output = tmp;
+        mr_strcat(output, "w\n\n");
+        mr_asprintf(&program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE,
+            MONDO_LOGFILE);
 
         if (g_fprep) {
@@ -1874 +1751 @@
             paranoid_pclose(fout);
         }
+        mr_free(program);
+
         if (!does_partition_exist(drive, partno) && partsize > 0) {
             log_it("Vaccum-packing");
@@ -1881 +1760 @@
                                  format, -1);
             if (res) {
-                mr_asprintf(&tmp, "Failed to vacuum-pack %s", partition_name);
-                log_it(tmp);
-                mr_free(tmp);
-
+                log_it("Failed to vacuum-pack %s", partition_name);
                 retval++;
             } else {
@@ -1895 +1771 @@
                                    partsize);
             if (retval) {
-                mr_asprintf(&tmp, "Partitioned %s but failed to set its type",
+                log_it("Partitioned %s but failed to set its type",
                         partition_name);
-                log_it(tmp);
-                mr_free(tmp);
             } else {
                 if (partsize > 0) {
-                    mr_asprintf(&tmp, "Partition %s created+configured OK",
+                    log_to_screen(_("Partition %s created+configured OK"),
                             partition_name);
-                    log_to_screen(tmp);
-                    mr_free(tmp);
                 } else {
                     log_it("Returning from a successful vacuum-pack");
@@ -1923 +1795 @@
     log_it("partition_device() --- leaving");
     mr_free(partition_name);
-    mr_free(program);
     mr_free(output);
     return (retval);
@@ -1939 +1810 @@
 {
     /** int ************************************************************/
-    int lino;
+    int lino = 0;
     int retval = 0;
-    int i;
-    int res;
+    int i = 0;
+    int res = 0;
 
     /** buffer *********************************************************/
-    struct list_of_disks *drivelist;
-    /*  struct mountlist_itself new_mtlist, *mountlist; */
+    struct list_of_disks *drivelist = NULL;
 
     /** end ************************************************************/
@@ -1955 +1825 @@
     log_it("partition_everything() --- starting");
     mvaddstr_and_log_it(g_currentY, 0, "Partitioning hard drives      ");
-    /*  mountlist=orig_mtlist; */
     if (mountlist_contains_raid_devices(mountlist)) {
         /*      mountlist=&new_mtlist; */
@@ -1977 +1846 @@
     stop_all_raid_devices(mountlist);
     mr_msg(0, "Done.");
-
-/*  
-    if (does_file_exist("/tmp/i-want-my-lvm"))
-      {
-        wipe_MBRs_and_reboot_if_necessary(mountlist); // i.e. if it wasn't done recently
-      }
-*/
 
     open_progress_form(_("Partitioning devices"),
@@ -2010 +1872 @@
     system("clear");
     newtResume();
-    mr_free((void*) drivelist);
+    mr_free(drivelist);
     return (retval);
 }
-
-
-
-
 
 
@@ -2076 +1934 @@
         mr_asprintf(&partcode, "8e");
     } else if (format[0] == '\0') { /* LVM physical partition */
-        mr_asprintf(&partcode, "%s", "");
+        mr_asprintf(&partcode, "");
     } else if (strlen(format) >= 1 && strlen(format) <= 2) {
         mr_asprintf(&partcode, format);
@@ -2098 +1956 @@
     mr_msg(1, tmp);
     mr_free(tmp);
+
     if (partcode[0] != '\0' && strcmp(partcode, "83")) {    /* no need to set type if 83: 83 is default */
 
@@ -2119 +1978 @@
             fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
             mr_free(tmp);
+
             tmp1 = last_line_of_file(FDISK_LOG);
             mr_msg(5, "B - last line = '%s'",tmp1);
@@ -2170 +2030 @@
 {
     /** int *************************************************************/
-    int res;
+    int res = 0;
     int retval = 0;
 
     /** buffers *********************************************************/
-    char *program;
+    char *program = NULL;
 
     /** end *************************************************************/
@@ -2187 +2047 @@
     mr_asprintf(&program, "vinum start -f %s", raid_device);
 #else
-    mr_asprintf(&program, "raidstart %s", raid_device);
+    // use raidstart if it exists, otherwise use mdadm
+    if (run_program_and_log_output("which raidstart", FALSE)) {
+        // BERLIOS: Not sure it's sufficient
+        mr_asprintf(&program, "mdadm -A %s", raid_device);
+    } else {
+        mr_asprintf(&program, "raidstart %s", raid_device);
+    }
 #endif
     mr_msg(1, "program = %s", program);
@@ -2214 +2080 @@
 {
     /** int *************************************************************/
-    int res;
+    int res = 0;
     int retval = 0;
 
     /** buffers *********************************************************/
-    char *program;
+    char *program = NULL;
 
     /** end *************************************************************/
@@ -2255 +2121 @@
 int start_all_raid_devices(struct mountlist_itself *mountlist)
 {
-    int i;
+    int i = 0;
     int retval = 0;
-    int res;
+    int res = 0;
 
     for (i = 0; i < mountlist->entries; i++) {
@@ -2366 +2232 @@
     /** int *************************************************************/
     int res = 0;
-
-    /** buffers *********************************************************/
-    char *tmp;
 
     /** end ***************************************************************/
@@ -2402 +2265 @@
         mr_asprintf(&program, "mkfs -t %s -c", format); // -c checks for bad blocks
 #endif
-        mr_asprintf(&tmp, "Unknown format (%s) - assuming '%s' will do", format,
+        log_it("Unknown format (%s) - assuming '%s' will do", format,
                 program);
-        log_it(tmp);
-        mr_free(tmp);
         res = 0;
     }
@@ -2423 +2284 @@
 {
     /** long ************************************************************/
-    long original_size_of_drive;
+    long original_size_of_drive = 0L;
 
     /** int *************************************************************/
-    int partno;
-
-    /** buffers *********************************************************/
-    char *tmp;
+    int partno = 0;
 
     /** end *************************************************************/
@@ -2442 +2300 @@
              strlen(drive_name)) == 0) {
             original_size_of_drive += mountlist->el[partno].size;
-        } else {
-            mr_asprintf(&tmp, "Skipping %s", mountlist->el[partno].device);
-//                      log_to_screen(tmp);
-            mr_free(tmp);
         }
     }
@@ -2468 +2322 @@
                                                      char *drive_name)
 {
-    /**buffers **********************************************************/
-    char *tmp;
-
     /** int *************************************************************/
-    int partno, lastpart;
+    int partno = 0, lastpart = 0;
                /** remove driveno, noof_drives stan benoit apr 2002**/
 
@@ -2478 +2329 @@
     float factor;
     float new_size;
-//  float newcylinderno;
 
     /** long *************************************************************/
-    long newsizL;
-    long current_size_of_drive = 0;
-    long original_size_of_drive = 0;
-    long final_size;            /* all in Megabytes */
-    struct mountlist_reference *drivemntlist;
+    long newsizL = 0L;
+    long current_size_of_drive = 0L;
+    long original_size_of_drive = 0L;
+    long final_size = 0L;           /* all in Megabytes */
+    struct mountlist_reference *drivemntlist = NULL;
 
     /** structures *******************************************************/
@@ -2507 +2357 @@
         return;
     }
-    mr_asprintf(&tmp, _("Expanding entries to suit drive %s (%ld MB)"),
-            drive_name, current_size_of_drive);
-    log_to_screen(tmp);
-    mr_free(tmp);
+    log_to_screen("Expanding entries to suit drive %s (%ld MB)", drive_name,
+            current_size_of_drive);
 
     drivemntlist = mr_malloc(sizeof(struct mountlist_reference));
@@ -2524 +2372 @@
 
     if (original_size_of_drive <= 0) {
-        mr_asprintf(&tmp, _("Cannot resize %s's entries. Drive not found."),
+        log_to_screen(_("Cannot resize %s's entries. Drive not found."),
                 drive_name);
-        log_to_screen(tmp);
-        mr_free(tmp);
         return;
     }
     factor =
         (float) (current_size_of_drive) / (float) (original_size_of_drive);
-    mr_asprintf(&tmp, "Disk %s was %ld MB; is now %ld MB; factor = %f",
+    log_to_screen(_("Disk %s was %ld MB; is now %ld MB; factor = %f"),
             drive_name, original_size_of_drive, current_size_of_drive,
             factor);
-    log_to_screen(tmp);
-    mr_free(tmp);
 
     lastpart = drivemntlist->entries - 1;
@@ -2555 +2399 @@
             newsizL = (long) new_size;
         }
-        mr_asprintf(&tmp, _("Changing %s from %lld KB to %ld KB"),
+        log_to_screen(_("Changing %s from %lld KB to %ld KB"),
                 drivemntlist->el[partno]->device,
                 drivemntlist->el[partno]->size, newsizL);
-        log_to_screen(tmp);
-        mr_free(tmp);
         drivemntlist->el[partno]->size = newsizL;
     }
     final_size = get_phys_size_of_drive(drive_name);
-    mr_asprintf(&tmp, _("final_size = %ld MB"), final_size);
-    log_to_screen(tmp);
-    mr_free(tmp);
+    log_to_screen(_("final_size = %ld MB"), final_size);
 }
 
@@ -2579 +2419 @@
 {
     /** buffers *********************************************************/
-    struct list_of_disks *drivelist;
+    struct list_of_disks *drivelist = NULL;
 
     /** int *************************************************************/
-    int driveno;
+    int driveno = 0;
 
     /** end *************************************************************/
@@ -2592 +2432 @@
             ("resize_mountlist_prop...() - warning - mountlist fname is blank");
         log_it("That does NOT affect the functioning of this subroutine.");
-        log_it("--- Hugo, 2002/11/20");
     }
     iamhere("Resizing mountlist");
@@ -2604 +2443 @@
     }
     log_to_screen(_("Mountlist adjusted to suit current hard drive(s)"));
-    mr_free((void*) drivelist);
+    mr_free(drivelist);
 }
 
@@ -2619 +2458 @@
                                 struct mountlist_reference *drivemntlist)
 {
-    int partno;
-    char *tmp_drive_name, *c;
+    int partno = 0;
+    char *tmp_drive_name = NULL, *c = NULL;
 
     assert(mountlist != NULL);
@@ -2628 +2467 @@
     mr_msg(1, "Creating list of partitions for drive %s", drive_name);
 
-    mr_asprintf(&tmp_drive_name,drive_name);
-    if (!tmp_drive_name)
-        fatal_error("Out of memory");
+    mr_asprintf(&tmp_drive_name, drive_name);
 
     /* devfs devices? */

trunk/mondo/src/mondorestore/mondo-restore-EXT.h

@@ -13 +13 @@
 extern char *g_isodir_format;
 
-extern struct s_bkpinfo *g_bkpinfo_DONTUSETHIS;
 extern char *g_biggielist_txt;
 extern char *g_filelist_full;

trunk/mondo/src/mondorestore/mondo-rstr-compare.c

@@ -4 +4 @@
 */
 
+#include <pthread.h>
 #include "my-stuff.h"
 #include "../common/mondostructures.h"
 #include "../common/libmondo.h"
+#include "mr_msg.h"
+#include "mr_mem.h"
 #include "mr-externs.h"
 #include "mondo-rstr-compare.h"
 #include "mondo-restore-EXT.h"
 #include "mondo-rstr-tools-EXT.h"
-#ifndef S_SPLINT_S
-#include <pthread.h>
-#endif
-#include "mr_mem.h"
+
+//static char cvsid[] = "$Id$";
 
 void popup_changelist_from_file(char *);
@@ -32 +33 @@
 {
 
-    FILE *fin;
-    FILE *fout;
+    FILE *fin = NULL;
+    FILE *fout = NULL;
 
   /** needs malloc *******/
@@ -62 +63 @@
     }
     if (!(fin = fopen(tmp1, "r"))) {
-        mr_asprintf(&tmp, _("Cannot open bigfile %ld (%s)'s info file"),
-                bigfileno + 1, tmp);
-        log_to_screen(tmp);
-        mr_free(tmp);
+        log_to_screen(_("Cannot open bigfile %ld (%s)'s info file"),
+                bigfileno + 1, tmp1);
         mr_free(tmp1);
         return (1);
@@ -74 +73 @@
     paranoid_fclose(fin);
 
-    mr_asprintf(&checksum, biggiestruct.checksum);
     mr_asprintf(&bigfile_fname, biggiestruct.filename);
-
     mr_msg(2, "biggiestruct.filename = %s", bigfile_fname);
-    mr_msg(2, "biggiestruct.checksum = %s", checksum);
+    if (!biggiestruct.checksum[0]) {
+        mr_msg(2, "Warning - %s has no checksum", bigfile_fname);
+    } else {
+        mr_asprintf(&checksum, biggiestruct.checksum);
+        mr_msg(2, "biggiestruct.checksum = %s", checksum);
+    }
 
     if (!g_text_mode) {
@@ -86 +88 @@
         mr_free(tmp);
     }
-    /* BERLIOS: Useless ?
-    if (!checksum[0]) {
-        mr_msg(2, "Warning - %s has no checksum", bigfile_fname_ptr);
-    } */
+
     if (!strncmp(bigfile_fname, "/dev/", 5)) {
         mr_msg(2, _("Ignoring device %s"), bigfile_fname);
+        mr_free(bigfile_fname);
         return(0);
-    } else {
-        mr_asprintf(&command,
-                "md5sum \"%s%s\" > /tmp/md5sum.txt 2> /tmp/errors.txt",
-                MNT_RESTORING, bigfile_fname);
-    }
+    }
+    mr_asprintf(&command,
+            "md5sum \"%s%s\" > /tmp/md5sum.txt 2> /tmp/errors.txt",
+            MNT_RESTORING, bigfile_fname);
     mr_msg(2, command);
-    paranoid_system("cat /tmp/errors >> /tmp/mondo-restore.log 2> /dev/null");
     if (system(command)) {
         log_OS_error("Warning - command failed");
+        paranoid_system("cat /tmp/errors >> /tmp/mondo-restore.log 2> /dev/null");
         mr_free(command);
         mr_free(bigfile_fname);
@@ -157 +156 @@
 {
     int retval = 0;
-    int res;
-    long noof_biggiefiles, bigfileno = 0;
-    char *tmp;
+    int res = 0;
+    long noof_biggiefiles = 0L, bigfileno = 0L;
+    char *tmp = NULL;
 
     assert(bkpinfo != NULL);
@@ -186 +185 @@
         update_progress_form(tmp);
         mr_free(tmp);
+
         res = compare_a_biggiefile(bkpinfo, bigfileno);
         retval += res;
@@ -218 +218 @@
 {
     int retval = 0;
-    int res;
-    long noof_lines;
-    long archiver_errors;
-    bool use_star;
-
-  /***  needs malloc *********/
+    int res = 0;
+    long noof_lines = 0L;
+    long archiver_errors = 0L;
+    bool use_star = FALSE;
+
     char *command = NULL;
     char *tmp = NULL;
@@ -242 +241 @@
         mr_asprintf(&compressor_exe, "bzip2");
     } else if (strstr(tarball_fname, ".gz")) {
-        strcpy(compressor_exe, "gzip");
-    } else if (strstr(tarball_fname, ".gz")) {
-        strcpy(compressor_exe, "gzip");
+        mr_asprintf(&compressor_exe, "gzip");
     } else if (strstr(tarball_fname, ".lzo")) {
         mr_asprintf(&compressor_exe, "lzop");
@@ -275 +272 @@
         }
     }
-// star -diff H=star -bz file=....
 
 #ifdef __FreeBSD__
@@ -317 +313 @@
         archiver_errors = 0;
     }
-
     if (archiver_errors) {
-        mr_asprintf(&tmp,
-                "Differences found while processing fileset #%d       ",
+        mr_msg(1, "Differences found while processing fileset #%d       ",
                 current_tarball_number);
-        mr_msg(1, tmp);
-        mr_free(tmp);
     }
     unlink(logfile);
@@ -343 +335 @@
 {
     int retval = 0;
-    int res;
+    int res = 0;
     int current_tarball_number = 0;
-
-  /**  needs malloc **********/
 
     char *tarball_fname = NULL;
     char *progress_str = NULL;
     char *tmp = NULL;
-    long max_val;
+    long max_val = 0L;
 
     assert(bkpinfo != NULL);
@@ -415 +405 @@
         } else {
             res = compare_a_tarball(tarball_fname, current_tarball_number);
-            mr_free(tarball_fname);
-
             g_current_progress++;
             current_tarball_number++;
         }
+        mr_free(tarball_fname);
     }
     mr_free(progress_str);
@@ -457 +446 @@
     int resA = 0;
     int resB = 0;
-    long noof_changed_files;
+    long noof_changed_files = 0L;
 
     malloc_string(cwd);
@@ -475 +464 @@
     noof_changed_files = count_lines_in_file("/tmp/changed.txt");
     if (noof_changed_files) {
-        mr_asprintf(&tmp, _("%ld files do not match the backup            "),
+        log_to_screen(_("%ld files do not match the backup            "),
                 noof_changed_files);
-        //      mvaddstr_and_log_it( g_currentY++, 0, tmp );
-        log_to_screen(tmp);
-        mr_free(tmp);
-
         mr_asprintf(&command, "cat /tmp/changed.txt >> %s", MONDO_LOGFILE);
         paranoid_system(command);
@@ -517 +502 @@
 {
     int retval = 0;
-    long q;
-    char *tmp;
+    long q = 0L;
+    char *tmp = NULL;
 
   /**************************************************************************
@@ -633 +618 @@
     run_program_and_log_output(command, FALSE);
     mr_free(command);
+
     mvaddstr_and_log_it(g_currentY,
                         0, _("Verifying archives against filesystem"));
@@ -680 +666 @@
 int compare_to_tape(struct s_bkpinfo *bkpinfo)
 {
-    int res;
+    int res = 0;
     char *dir = NULL;
     char *command = NULL;

trunk/mondo/src/mondorestore/mondo-rstr-newt.h

@@ -4 +4 @@
 
 #include "my-stuff.h"
-#include "../common/mondostructures.h"
-#include "../common/libmondo.h"
+#include "mr_str.h"
+
+#include "mondostructures.h"
+#include "libmondo.h"
 #ifdef   __FreeBSD__
 #define  raid_device_record             vinum_volume
@@ -29 +31 @@
 extern long get_phys_size_of_drive(char *);
 extern bool is_this_device_mounted(char *);
-extern void strip_spaces(char *);
+extern void mr_strip_spaces(char *);
 extern void initialize_raidrec(struct raid_device_record *);
 extern int make_list_of_drives(struct mountlist_itself *,

trunk/mondo/src/mondorestore/mondoprep.h

@@ -42 +42 @@
 int start_all_raid_devices(struct mountlist_itself *);
 int stop_all_raid_devices(struct mountlist_itself *);
-int format_everything(struct mountlist_itself *, bool,
-                      struct raidlist_itself *);
+int format_everything(struct mountlist_itself *, bool, struct raidlist_itself *);
 int partition_device(FILE *, const char *, int, int, const char *,
                      long long);

trunk/mondo/src/mondorestore/mondorestore.c

@@ -15 +15 @@
 
 #include "my-stuff.h"
-#include "../common/mondostructures.h"
-#include "../common/libmondo.h"
+#include "mr_mem.h"
+#include "mr_msg.h"
+#include "mr_str.h"
+
+#include "mondostructures.h"
+#include "libmondo.h"
 #include "mr-externs.h"
 #include "mondo-restore.h"
@@ -24 +28 @@
 #include <pthread.h>
 #endif
-#include "mr_mem.h"
 
 extern void twenty_seconds_til_yikes(void);
@@ -41 +44 @@
  **************************************************************************/
 extern char *g_tmpfs_mountpt;   // declared in libmondo-tools.c
-extern struct s_bkpinfo *g_bkpinfo_DONTUSETHIS; // used by finish() to free
-                                                // up global bkpinfo struct
 extern bool g_text_mode;
 extern FILE *g_fprep;
@@ -429 +430 @@
                     }
 
-                    fmt_errs =
-                        format_everything(mountlist, FALSE, raidlist);
+                    fmt_errs = format_everything(mountlist, FALSE, raidlist);
                     if (!fmt_errs) {
                         log_to_screen
@@ -510 +510 @@
             if (filelist) {
               gotos_suck:
-// (NB: %s is where your filesystem is mounted now, by default)", MNT_RESTORING);
+                // (NB: MNT_RESTORING is where your filesystem is mounted now, by default)
                 if (popup_and_get_string
                     (_("Restore path"), _("Restore files to where?"), bkpinfo->restore_path)) {
@@ -558 +558 @@
     }
 
-//  run_program_and_log_output("cp -af /etc/lvm " MNT_RESTORING "/etc/", 1);
     protect_against_braindead_sysadmins();
     retval += unmount_all_devices(mountlist);
@@ -585 +584 @@
             mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
         } else {
-            mvaddstr_and_log_it(g_currentY++, 74, "Done.");
+            mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
         }
         retval += res;
@@ -597 +596 @@
                             ("Warning - errors occurred during the restore phase."));
     }
+    iamhere("Leaving interactive_mode()");
     return(retval);
 }
@@ -619 +619 @@
          struct raidlist_itself *raidlist, bool nuke_me_please)
 {
-    char c;
+    char c = ' ';
     int retval = 0;
 
@@ -647 +647 @@
         paranoid_system("umount " MNT_CDROM);
     }
-//  if (! already_mounted)
-//    {
     if (system("umount /tmp/isodir 2> /dev/null")) {
         log_to_screen
@@ -654 +652 @@
              ("WARNING - unable to unmount device where the ISO files are stored."));
     }
-//    }
     return (retval);
 }
@@ -661 +658 @@
  *END_ISO_MODE                                                            *
  **************************************************************************/
-
-
 static void call_me_after_the_nuke(int retval) {
 
@@ -670 +665 @@
     if (retval) {
         log_to_screen(_("Errors occurred during the nuke phase."));
-        log_to_screen(_("Please visit our website at http://www.mondorescue.org for more information."));
+        log_to_screen(_("Please visit our website at http://www.mondores
+cue.org for more information."));
     } else {
 #ifdef __FreeBSD__
-        tmp1 = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
+    tmp1 = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
 #else
-        tmp1 = call_program_and_get_last_line_of_output("cat /proc/cmdline");
+    tmp1 = call_program_and_get_last_line_of_output("cat /proc/cmdline");
 #endif
         if ((strstr(tmp1,"restore") == NULL) ||
-            (strstr(tmp1,"RESTORE") == NULL)) {
-                /* -H option */
-                mr_asprintf(&tmp,
-                    _
-                    (" Mondo has restored your system. Please remove the backup media and reboot.\n\nPlease visit our website at http://www.mondorescue.org for more information."));
-                popup_and_OK(tmp);
-                mr_free(tmp);
+        (strstr(tmp1,"RESTORE") == NULL)) {
+            /* -H option */
+            mr_asprintf(&tmp,
+                _
+                (" Mondo has restored your system. Please remove the backup media and reboot.\n\nPlease visit our website at http://www.
+mondorescue.org for more information."));
+            popup_and_OK(tmp);
+            mr_free(tmp);
         }
         mr_free(tmp1);
 
         log_to_screen(_
-             ("Mondo has restored your system. Please remove the backup media and reboot."));
+            ("Mondo has restored your system. Please remove the backup media and reboot."));
         log_to_screen(_
-             ("Thank you for using Mondo Rescue."));
+            ("Thank you for using Mondo Rescue."));
         log_to_screen(_
-             ("Please visit our website at http://www.mondorescue.org for more information."));
+            ("Please visit our website at http://www.mondorescue.org for more information."));
     }
     g_I_have_just_nuked = TRUE;
@@ -750 +747 @@
             mr_free(tmp);
             retval = interactive_mode(bkpinfo, mountlist, raidlist);
-            goto after_the_nuke;
+            call_me_after_the_nuke(retval);
+            return(retval);
         } else {
             mr_free(tmp);
@@ -812 +810 @@
             retval = interactive_mode(bkpinfo, mountlist, raidlist);
             call_me_after_the_nuke(retval);
+            return(retval);
         } else
             if (!ask_me_yes_or_no
                 (_("Would you like to try to proceed anyway?"))) {
-        }
-        return(retval);
+                return(retval);
+        }
     }
     retval = mount_all_devices(mountlist, TRUE);
@@ -834 +833 @@
     }
     protect_against_braindead_sysadmins();
-//  run_program_and_log_output("cp -af /etc/lvm " MNT_RESTORING "/etc/", 1);
     retval += unmount_all_devices(mountlist);
     mvaddstr_and_log_it(g_currentY,
@@ -855 +853 @@
     retval += res;
 
-  after_the_nuke:
-    if (retval) {
-        log_to_screen("Errors occurred during the nuke phase.");
-    } else if (strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "RESTORE"))    // Bruno's thing
-    {
-        log_to_screen
-            ("PC was restored successfully. Thank you for using Mondo Rescue.");
-        log_to_screen
-            ("Please visit our website at http://www.mondorescue.org for more information.");
-    } else {
-        strcpy(tmp,"Mondo has restored your system.\n\nPlease wait for the command prompt. Then remove the backup media and reboot.\n\nPlease visit our website at http://www.mondorescue.org for more information.");
-        if (strstr(call_program_and_get_last_line_of_output("cat /proc/cmdline"), "restore") == NULL) {
-            popup_and_OK(tmp);
-        }
-        log_to_screen
-          ("Mondo has restored your system. Please wait for the command prompt.");
-        log_to_screen
-            ("Then remove the backup media and reboot.");
-        log_to_screen
-            ("Please visit our website at http://www.mondorescue.org for more information.");
-    }
-    g_I_have_just_nuked = TRUE;
-/*
-  if (!boot_loader_installed && !does_file_exist(DO_MBR_PLEASE))
-    {
-      log_to_screen("PLEASE RUN 'mondorestore --mbr' NOW TO INITIALIZE YOUR BOOT SECTOR");
-      write_one_liner_data_file(DO_MBR_PLEASE, "mondorestore --mbr");
-    }
-*/
+    call_me_after_the_nuke(retval);
     return (retval);
 }
+
 /**************************************************************************
  *END_NUKE_MODE                                                           *
@@ -996 +967 @@
     FILE *fout = NULL;
     FILE *fbzip2 = NULL;
+
     char *checksum = NULL;
-    char *outfile_fname = NULL;
-    char *tmp = NULL;
+    char *outfile_fname = NULL;
+    char *tmp = NULL;
     char *tmp0 = NULL;
     char *tmp1 = NULL;
     char *tmp2 = NULL;
     char *tmp3 = NULL;
-    char *bzip2_command = NULL;
+    char *bzip2_command = NULL;
     char *bigblk = NULL;
     char *pathname_of_last_file_restored = NULL;
     int finished = FALSE;
-    long sliceno;
+    long sliceno = 0L;
     long siz;
     long siz1;
@@ -1018 +990 @@
     int res = 0;
     int old_loglevel;
-    char *sz_msg;
+    char *sz_msg = NULL;
     struct s_node *node = NULL;
 
@@ -1046 +1018 @@
 
     if (!checksum[0]) {
-        mr_asprintf(&tmp, "Warning - bigfile %ld does not have a checksum",
+        mr_msg(3, "Warning - bigfile %ld does not have a checksum",
                 bigfileno + 1);
-        mr_msg(3, tmp);
-        mr_free(tmp);
-        /* BERLIOS : Useless ???
-        p = checksum;
-        */
     }
     mr_free(checksum);
@@ -1090 +1057 @@
 
     if (biggiestruct.use_ntfsprog)  // if it's an NTFS device
-//  if (!strncmp ( biggiestruct.filename, "/dev/", 5))
     {
         g_loglevel = 4;
@@ -1112 +1078 @@
                 feed_outfrom_ntfsprog(biggiestruct.filename,
                                       ntfsprog_fifo);
-//          mr_msg(3, "CHILD - fip - exiting");
             exit(res);
             break;
@@ -1120 +1085 @@
                     (long int) (pid));
         }
-        // BERLIOS: Is it the right place ??
-        mr_free(ntfsprog_fifo);
     } else {
         use_ntfsprog_hack = FALSE;
@@ -1131 +1094 @@
     }
 
-    mr_asprintf(&tmp, "Reassembling big file %ld (%s)", bigfileno + 1,
+    mr_msg(2, "Reassembling big file %ld (%s)", bigfileno + 1,
             outfile_fname);
-    mr_msg(2, tmp);
-    mr_free(tmp);
 
     /*
@@ -1146 +1107 @@
     mr_msg(3, "file_to_openout = %s", file_to_openout);
     if (!(fout = fopen(file_to_openout, "w"))) {
-        log_to_screen(_("Cannot openout outfile_fname - hard disk full?"));
+        log_to_screen(_("Cannot openout file_to_openout - hard disk full?"));
         return (pathname_of_last_file_restored);
     }
+    mr_free(ntfsprog_fifo);
     mr_msg(3, "Opened out to %s", outfile_fname);   // CD/DVD --> mondorestore --> ntfsclone --> hard disk itself
 
@@ -1164 +1126 @@
                     g_current_media_number);
             g_current_media_number++;
-            mr_asprintf(&tmp3,
-                    "Asking for %s #%d so that I may read slice #%ld\n",
-                    bkpinfo->backup_media_string,
+            mr_msg(2, "Asking for %s #%d so that I may read slice #%ld\n",
+                    media_descriptor_string(bkpinfo->backup_media_type),
                     g_current_media_number, sliceno);
-            mr_msg(2, tmp3);
-            mr_free(tmp3);
-
-            mr_asprintf(&tmp3, _("Restoring from %s #%d"),
+            log_to_screen(_("Restoring from %s #%d"),
                     bkpinfo->backup_media_string,
                     g_current_media_number);
-            log_to_screen(tmp3);
-            mr_free(tmp3);
-
             insist_on_this_cd_number(bkpinfo, g_current_media_number);
             log_to_screen(_("Continuing to restore."));
@@ -1194 +1149 @@
                         mr_asprintf(&bzip2_command, "bzip2 -dc %s 2>> %s",tmp2, MONDO_LOGFILE);
                 } else if (does_file_exist(tmp)) {
-                        mr_asprintf(&bzip2_command, "%s", "");
+                        mr_asprintf(&bzip2_command, "");
                 } else {
                     log_to_screen(_("OK, that's pretty fsck0red..."));
@@ -1204 +1159 @@
                 mr_asprintf(&bzip2_command, "cat %s 2>> %s", tmp, MONDO_LOGFILE);
             }
-            mr_asprintf(&tmp3, "Working on %s #%d, file #%ld, slice #%ld ",
+            mr_asprintf(&tmp3, "Working on %s #%d, file #%ld, slice #%ld",
                     bkpinfo->backup_media_string,
                     g_current_media_number, bigfileno + 1, sliceno);
@@ -1216 +1171 @@
 
             if (!(fbzip2 = popen(bzip2_command, "r"))) {
+                mr_free(bzip2_command);
                 fatal_error("Can't run popen command");
             }
@@ -1224 +1180 @@
                 if (siz > 0) {
                     siz1 = fwrite(bigblk, 1, siz, fout);
-                    mr_asprintf(&sz_msg, "Read %ld from fbzip2; written %ld to fout", siz, siz1);
-                    log_it(sz_msg);
-                    mr_free(sz_msg);
                 }
             }
             paranoid_pclose(fbzip2);
-
 
             sliceno++;
@@ -1288 +1240 @@
                                      int use_ntfsprog)
 {
-    FILE *pout;
-    FILE *fin;
+    FILE *pout = NULL;
+    FILE *fin = NULL;
 
   /** mallocs ********/
@@ -1300 +1252 @@
     char *pathname_of_last_file_restored = NULL;
 
-    struct s_node *node;
-
-    int old_loglevel;
+    struct s_node *node = NULL;
+
+    int old_loglevel = 0;
     long current_slice_number = 0;
     int retval = 0;
     int res = 0;
     int ctrl_chr = '\0';
-    long long slice_siz;
+    long long slice_siz = 0L;
     bool dummy_restore = FALSE;
     bool use_ntfsprog_hack = FALSE;
     pid_t pid;
     struct s_filename_and_lstat_info biggiestruct;
-    struct utimbuf the_utime_buf, *ubuf;
+    struct utimbuf the_utime_buf, *ubuf = NULL;
     ubuf = &the_utime_buf;
 
@@ -1380 +1332 @@
                     outfile_fname, ntfsprog_fifo);
             res = feed_outfrom_ntfsprog(outfile_fname, ntfsprog_fifo);
-//          mr_msg(3, "CHILD - fip - exiting");
             exit(res);
             break;
@@ -1388 +1339 @@
                     (long int) (pid));
         }
-        mr_free(ntfsprog_fifo);
     } else {
         if (!strncmp(orig_bf_fname, "/dev/", 5))    // non-NTFS partition
@@ -1404 +1354 @@
             make_hole_for_file(outfile_fname);
         }
-        mr_asprintf(&tmp1, "Reassembling big file %ld (%s)",
+        mr_msg(2, "Reassembling big file %ld (%s)",
                 biggiefile_number + 1, orig_bf_fname);
-        mr_msg(2, tmp1);
-        mr_free(tmp1);
     }
 
@@ -1421 +1369 @@
                 file_to_openout, MONDO_LOGFILE);
     }
-    mr_asprintf(&tmp1, "Pipe command = '%s'", command);
-    mr_msg(3, tmp1);
-    mr_free(tmp1);
+    mr_msg(3, "Pipe command = '%s'", command);
+    mr_free(outfile_fname);
+    mr_free(ntfsprog_fifo);
 
     /* restore biggiefile, one slice at a time */
@@ -1445 +1393 @@
             newtRefresh();
         }
-        strip_spaces(tmp1);
+        mr_strip_spaces(tmp1);
         update_progress_form(tmp1);
         mr_free(tmp1);
@@ -1506 +1454 @@
     }
 
-    mr_free(outfile_fname);
     g_loglevel = old_loglevel;
     return (pathname_of_last_file_restored);
@@ -1533 +1480 @@
 {
     int retval = 0;
-    int res;
-    char *p;
+    int res = 0;
+    char *p = NULL;
 
   /** malloc **/
-    char *command;
+    char *command = NULL;
     char *tmp = NULL;
-    char *filelist_name;
+    char *filelist_name = NULL;
     char *filelist_subset_fname = NULL;
     char *executable = NULL;
     char *temp_log = NULL;
     long matches = 0;
-    bool use_star;
+    bool use_star = FALSE;
     char *xattr_fname = NULL;
     char *acl_fname = NULL;
@@ -1567 +1514 @@
         retval = 0;
         mr_msg(5, "Leaving");
+        mr_free(filelist_name);
         return (retval);
     }
@@ -1573 +1521 @@
         mr_msg(3, "length_of_file(%s) = %llu", tarball_fname,
                 length_of_file(tarball_fname));
-        mr_asprintf(&tmp, "Unable to restore fileset #%ld (CD I/O error)",
+        log_to_screen(_("Unable to restore fileset #%ld (CD I/O error)"),
                 current_tarball_number);
-        log_to_screen(tmp);
-        mr_free(tmp);
         retval = 1;
         mr_msg(5, "Leaving");
+        mr_free(filelist_name);
         return (retval);
     }
@@ -1590 +1537 @@
                                              use_star))
             <= 0) {
-            mr_asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
-            mr_msg(1, tmp);
-            mr_free(tmp);
+            mr_msg(1, "Skipping fileset %ld", current_tarball_number);
         } else {
             mr_msg(3, "Saved fileset %ld's subset to %s",
                     current_tarball_number, filelist_subset_fname);
         }
-        mr_asprintf(&tmp, "Tarball #%ld --- %ld matches",
+        log_to_screen("Tarball #%ld --- %ld matches",
                 current_tarball_number, matches);
-        log_to_screen(tmp);
-        mr_free(tmp);
-    } else {
-        filelist_subset_fname = NULL;
     }
     mr_free(filelist_name);
@@ -1616 +1557 @@
         }
         if (strstr(tarball_fname, ".bz2")) {
-            mr_asprintf(&executable, "bzip2");
+            mr_asprintf(&executable, "-P bzip2 -Z");
         } else if (strstr(tarball_fname, ".gz")) {
-            strcpy(executable, "gzip");
-        } else if (strstr(tarball_fname, ".gz")) {
-            strcpy(executable, "gzip");
+            mr_asprintf(&executable, "-P gzip -Z");
         } else if (strstr(tarball_fname, ".lzo")) {
-            mr_asprintf(&executable, "lzop");
-        } else {
-            executable = NULL;
+            mr_asprintf(&executable, "-P lzop -Z");
         }
 
@@ -1633 +1570 @@
                     (_
                      ("(compare_a_tarball) Compression program not found - oh no!"));
+                mr_free(tmp);
+                mr_free(executable);
+                mr_free(acl_fname);
+                mr_free(xattr_fname);
+                mr_free(filelist_subset_fname);
                 paranoid_MR_finish(1);
             }
-            mr_free(tmp);
-
-            mr_asprintf(&tmp, executable);
-            mr_asprintf(&executable, "-P %s -Z", tmp);
             mr_free(tmp);
         }
@@ -1647 +1585 @@
 #endif
 
-        mr_asprintf(&temp_log, "/tmp/%d.%d", (int) (random() % 32768),
-            (int) (random() % 32768));
-
         if (use_star) {
+            mr_sprintf(&command,
+                    "star -x -force-remove -U " STAR_ACL_SZ
+                    " errctl= file=%s", tarball_fname);
             if (strstr(tarball_fname, ".bz2")) {
-                mr_asprintf(&tmp, " -bz");
-            } else {
-                mr_asprintf(&tmp, "%s", "");
-            }
-            mr_asprintf(&command,
-                    "star -x -force-remove -U " STAR_ACL_SZ
-                    " errctl= file=%s %s 2>> %s >> %s", tarball_fname, tmp, temp_log, temp_log);
-            mr_free(tmp);
+                mr_strcat(command, " -bz");
+            }
         } else {
             if (filelist_subset_fname != NULL) {
                 mr_asprintf(&command,
-                        "afio -i -M 8m -b %ld -c %ld %s -w '%s' %s 2>> %s >> %s",
+                        "afio -i -M 8m -b %ld -c %ld %s -w '%s' %s",
                         TAPE_BLOCK_SIZE,
                         BUFSIZE, executable, filelist_subset_fname,
-//             files_to_restore_this_time_fname,
-                        tarball_fname, temp_log, temp_log);
+                        tarball_fname);
             } else {
                 mr_asprintf(&command,
-                        "afio -i -b %ld -c %ld -M 8m %s %s 2>> %s >> %s",
+                        "afio -i -b %ld -c %ld -M 8m %s %s",
                         TAPE_BLOCK_SIZE,
-                        BUFSIZE, executable, tarball_fname, temp_log, temp_log);
+                        BUFSIZE, executable, tarball_fname);
             }
         }
@@ -1678 +1609 @@
 
 #undef BUFSIZE
+        mr_asprintf(&temp_log, "/tmp/%d.%d", (int) (random() % 32768),
+            (int) (random() % 32768));
+
+        mr_strcat(command, " 2>> %s >> %s", temp_log, temp_log);
         mr_msg(1, "command = '%s'", command);
         unlink(temp_log);
@@ -1732 +1667 @@
         unlink(xattr_fname);
         mr_free(xattr_fname);
+        unlink(acl_fname);
+        mr_free(acl_fname);
+        unlink(temp_log);
+        mr_free(temp_log);
     }
     if (does_file_exist("/PAUSE")) {
@@ -1739 +1678 @@
     }
     unlink(filelist_subset_fname);
-    unlink(acl_fname);
-    unlink(temp_log);
-
     mr_free(filelist_subset_fname);
-    mr_free(acl_fname);
-    mr_free(temp_log);
     mr_msg(5, "Leaving");
     return (retval);
@@ -1789 +1723 @@
     long matches = 0;
     bool restore_this_fileset = FALSE;
-    bool use_star;
+    bool use_star = FALSE;
 
     assert(bkpinfo != NULL);
@@ -1795 +1729 @@
     /* to do it with a file... */
     use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
-    mr_asprintf(&tmp,
-            "Restoring from fileset #%ld (%ld KB) on %s #%d",
+    mr_msg(2, "Restoring from fileset #%ld (%ld KB) on %s #%d",
             current_tarball_number, (long) size >> 10,
             bkpinfo->backup_media_string,
             g_current_media_number);
-    mr_msg(2, tmp);
-    mr_free(tmp);
     run_program_and_log_output("mkdir -p " MNT_RESTORING "/tmp", FALSE);
 
@@ -1837 +1768 @@
         if (strstr(tarball_fname, ".star.")) {
             use_star = TRUE;
-            mr_asprintf(&command, "star -t file=%s %s > %s 2>> %s", afio_fname, executable, filelist_fname, MONDO_LOGFILE);
+            mr_asprintf(&command, "star -t file=%s %s", afio_fname, executable);
         } else {
             use_star = FALSE;
-            mr_asprintf(&command, "afio -t -M 8m -b %ld %s %s > %s 2>> %s", TAPE_BLOCK_SIZE,
-                    executable, afio_fname, filelist_fname, MONDO_LOGFILE);
-        }
+            mr_asprintf(&command, "afio -t -M 8m -b %ld %s %s", TAPE_BLOCK_SIZE,
+                    executable, afio_fname);
+        }
+        mr_strcat(command, " > %s 2>> %s", filelist_fname, MONDO_LOGFILE);
         mr_msg(1, "command = %s", command);
         if (system(command)) {
@@ -1848 +1780 @@
         }
         mr_free(command);
+
         if ((matches =
              save_filelist_entries_in_common(filelist_fname, filelist,
@@ -1857 +1790 @@
                         current_tarball_number);
             }
-            mr_asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
-            mr_msg(2, tmp);
-            mr_free(tmp);
+            mr_msg(2, "Skipping fileset %ld", current_tarball_number);
             restore_this_fileset = FALSE;
         } else {
@@ -1875 +1806 @@
         // star
         if (filelist) {
-            mr_asprintf(&command, "star -x file=%s %s list=%s 2>> %s", afio_fname, executable,
-                    filelist_subset_fname,MONDO_LOGFILE);
+            mr_asprintf(&command, "star -x file=%s %s list=%s 2>> %s", afio_fname, executable, filelist_subset_fname, MONDO_LOGFILE);
         } else {
-            mr_asprintf(&command,"star -x file=%s %s 2>> %s", afio_fname, executable,MONDO_LOGFILE);
+            mr_asprintf(&command, "star -x file=%s %s 2>> %s", afio_fname, executable, MONDO_LOGFILE);
         }
     } else {
         // afio
         if (filelist) {
-            mr_asprintf(&command, "afio -i -M 8m -b %ld %s -w %s %s 2>> %s", TAPE_BLOCK_SIZE, executable, filelist_subset_fname,afio_fname,MONDO_LOGFILE);
+            mr_asprintf(&command, "afio -i -M 8m -b %ld %s -w %s %s 2>> %s", TAPE_BLOCK_SIZE, executable, filelist_subset_fname, afio_fname, MONDO_LOGFILE);
         } else {
-            mr_asprintf(&command, "afio -i -M 8m -b %ld %s %s 2>> %s", TAPE_BLOCK_SIZE, executable,afio_fname,MONDO_LOGFILE);
+            mr_asprintf(&command, "afio -i -M 8m -b %ld %s %s 2>> %s", TAPE_BLOCK_SIZE, executable, afio_fname, MONDO_LOGFILE);
         }
     }
@@ -1992 +1922 @@
         return (0);
     }
-    mr_asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
-            noof_biggiefiles);
-    mr_msg(2, tmp);
-    mr_free(tmp);
+    mr_msg(2, "OK, there are %ld biggiefiles in the archives", noof_biggiefiles);
 
     open_progress_form(_("Reassembling large files"),
@@ -2023 +1950 @@
                 insist_on_this_cd_number(bkpinfo,
                                          ++g_current_media_number);
-                mr_asprintf(&tmp, _("Restoring from %s #%d"),
+                log_to_screen(_("Restoring from %s #%d"),
                         bkpinfo->backup_media_string,
                         g_current_media_number);
-                log_to_screen(tmp);
-                mr_free(tmp);
-
                 just_changed_cds = TRUE;
             } else {
@@ -2051 +1975 @@
             retval += res;
             bigfileno++;
-
-        }
-        mr_free(tmp);
+        }
     }
 
@@ -2088 +2010 @@
     return (retval);
 }
+
 /**************************************************************************
  *END_RESTORE_ALL_BIGGIFILES_FROM_CD                                      *
@@ -2108 +2031 @@
 {
     int retval = 0;
-    int res;
-    int attempts;
+    int res = 0;
+    int attempts = 0;
     long current_tarball_number = 0;
-    long max_val;
+    long max_val = 0L;
   /**malloc ***/
-    char *tmp;
-    char *tmp1;
-    char *tarball_fname;
-    char *progress_str;
-    char *comment;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *tarball_fname = NULL;
+    char *progress_str = NULL;
+    char *comment = NULL;
 
     assert(bkpinfo != NULL);
@@ -2144 +2067 @@
         insist_on_this_cd_number(bkpinfo, g_current_media_number);
         update_progress_form(progress_str);
-
         mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.bz2",
                 current_tarball_number);
@@ -2178 +2100 @@
                     (_
                      ("No tarballs. Strange. Maybe you only backed up freakin' big files?"));
+                mr_free(progress_str);
                 return (0);
             }
@@ -2184 +2107 @@
                           "/archives/slice* > /dev/null 2> /dev/null") ==
                 0) {
+                mr_free(tarball_fname);
+                mr_free(progress_str);
                 break;
             }
             g_current_media_number++;
             mr_free(progress_str);
+
             mr_asprintf(&progress_str, _("Restoring from %s #%d"),
                     bkpinfo->backup_media_string,
@@ -2199 +2125 @@
                     bkpinfo->backup_media_string,
                     g_current_media_number);
-//    mr_msg(3, "progress_str = %s", progress_str);
             for (res = 999, attempts = 0; attempts < 3 && res != 0;
                  attempts++) {
@@ -2207 +2132 @@
                                               filelist);
             }
+            mr_asprintf(&tmp, _("%s #%d, fileset #%ld - restore "),
+                    media_descriptor_string(bkpinfo->backup_media_type),
+                    g_current_media_number, current_tarball_number);
             if (res) {
-                mr_asprintf(&tmp1, _("reported errors"));
+                mr_strcat(tmp, _("reported errors"));
             } else {
-                mr_asprintf(&tmp1, _("succeeded"));
-            }
-            mr_asprintf(&tmp, _("%s #%d, fileset #%ld - restore %s"),
-                    bkpinfo->backup_media_string,
-                    g_current_media_number, current_tarball_number,tmp1);
-            mr_free(tmp1);
-            
+                mr_strcat(tmp, _("succeeded"));
+            }
             if (attempts > 1) {
-                mr_asprintf(&tmp1, _(" (%d attempts) - review logs"), attempts);
-            }
-            mr_asprintf(&comment, "%s%s", tmp, tmp1);
+                mr_strcat(tmp, _(" (%d attempts) - review logs"), attempts);
+            }
+            if (attempts > 1) {
+                log_to_screen(tmp);
+            }
             mr_free(tmp);
-            mr_free(tmp1);
-            if (attempts > 1) {
-                log_to_screen(comment);
-            }
-            mr_free(comment);
 
             retval += res;
@@ -2242 +2162 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     }
-
     return (retval);
 }
@@ -2262 +2181 @@
                                     struct s_node *filelist)
 {
-    long noof_biggiefiles;
-    long current_bigfile_number = 0;
-    long total_slices;
+    long noof_biggiefiles = 0L;
+    long current_bigfile_number = 0L;
+    long total_slices = 0L;
 
     int retval = 0;
     int res = 0;
-    int ctrl_chr;
+    int ctrl_chr = 0;
 
   /** malloc add ****/
@@ -2302 +2221 @@
                 biggies_whose_EXATs_we_should_set);
     }
-// get xattr and acl files if they're there
+    // get xattr and acl files if they're there
     res =
         read_header_block_from_stream(&biggie_size, biggie_fname,
@@ -2313 +2232 @@
 
     noof_biggiefiles = atol(biggie_fname);
-    mr_asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
+    mr_msg(2, "OK, there are %ld biggiefiles in the archives",
             noof_biggiefiles);
-    mr_msg(2, tmp);
-    mr_free(tmp);
-
     open_progress_form(_("Reassembling large files"),
                        _("I am now reassembling all the large files."),
@@ -2363 +2279 @@
     if (current_bigfile_number != noof_biggiefiles
         && noof_biggiefiles != 0) {
-        mr_asprintf(&tmp, "Warning - bigfileno=%ld but noof_biggiefiles=%ld\n",
+        mr_msg(1, "Warning - bigfileno=%ld but noof_biggiefiles=%ld\n",
                 current_bigfile_number, noof_biggiefiles);
     } else {
-        mr_asprintf(&tmp,
-                "%ld biggiefiles in biggielist.txt; %ld biggiefiles processed today.",
+        mr_msg(1, "%ld biggiefiles in biggielist.txt; %ld biggiefiles processed today.",
                 noof_biggiefiles, current_bigfile_number);
     }
-    mr_msg(1, tmp);
-    mr_free(tmp);
 
     if (fbw) {
@@ -2437 +2350 @@
 {
     int retval = 0;
-    int res;
+    int res = 0;
     long current_afioball_number = 0;
-    int ctrl_chr;
-    long max_val /*, total_noof_files */ ;
+    int ctrl_chr = 0;
+    long max_val = 0L /*, total_noof_files */ ;
 
   /** malloc **/
@@ -2449 +2362 @@
     char *acl_fname = NULL;
 
-    long long tmp_size;
+    long long tmp_size = 0L;
 
     assert(bkpinfo != NULL);
@@ -2515 +2428 @@
         retval += res;
         if (res) {
-            mr_asprintf(&tmp, _("Fileset %ld - errors occurred"),
+            log_to_screen("Fileset %ld - errors occurred",
                     current_afioball_number);
-            log_to_screen(tmp);
-            mr_free(tmp);
         }
         res =
@@ -2609 +2520 @@
     mr_free(tmp);
 
-    mvaddstr_and_log_it(g_currentY, 0,
-                        _("Preparing to read your archives"));
+    mvaddstr_and_log_it(g_currentY, 0, _("Preparing to read your archives"));
     if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
         mount_cdrom(bkpinfo);
@@ -2785 +2695 @@
 void welcome_to_mondorestore()
 {
-    mr_msg(0, "-------------- Mondo Restore v%s -------------",
-            PACKAGE_VERSION);
+    mr_msg(0, "-------------- Mondo Restore v%s -------------", PACKAGE_VERSION);
     mr_msg(0,
             "DON'T PANIC! Mondorestore logs almost everything, so please ");
@@ -2837 +2746 @@
     bool run_postnuke = FALSE;
 
-  /**************************************************************************
-   * hugo-                                                                  *
-   * busy stuff here - it needs some comments -stan                           *
-   *                                                                        *
-   **************************************************************************/
-
 #ifdef ENABLE_NLS
     setlocale(LC_ALL, "");
@@ -2869 +2772 @@
     mr_free(tmp);
 
-    bkpinfo = g_bkpinfo_DONTUSETHIS = mr_malloc(sizeof(struct s_bkpinfo));
+    bkpinfo = mr_malloc(sizeof(struct s_bkpinfo));
     mountlist = mr_malloc(sizeof(struct mountlist_itself));
     raidlist = mr_malloc(sizeof(struct raidlist_itself));
@@ -2927 +2830 @@
     run_program_and_log_output("rm -Rf /tmp/tmpfs/mondo.tmp.*", FALSE);
 
-/* Init GUI */
+    /* Init GUI */
     malloc_libmondo_global_strings();
     setup_newt_stuff();         /* call newtInit and setup screen log */
@@ -2939 +2842 @@
     iamhere("what time is it");
 
-/* Process command-line parameters */
+    /* Process command-line parameters */
     if (argc == 2 && strcmp(argv[1], "--edit-mountlist") == 0) {
 #ifdef __FreeBSD__
@@ -2998 +2901 @@
         // BERLIOS: /usr/lib ???
         toggle_path_selection(filelist, "/usr/share", TRUE);
-//      show_filelist(filelist);
         save_filelist(filelist, "/tmp/out.txt");
-//      finish(0);
-//      toggle_path_selection (filelist, "/root/stuff", TRUE);
         mr_asprintf(&a, argv[3]);
         mr_asprintf(&b, argv[4]);
@@ -3073 +2973 @@
                  ("Live mode doesn't support command-line parameters yet."));
             paranoid_MR_finish(1);
-//    return(1);
         }
         mr_msg(1, "I am in normal, live mode.");
@@ -3225 +3124 @@
             if (!bkpinfo->please_dont_eject) {
                 res = eject_device("/dev/cdrom");
-/*
-              if (res) 
-        {
-          log_to_screen( "WARNING - failed to eject CD-ROM disk" ); 
-        }
-*/
             }
             mvaddstr_and_log_it(g_currentY++,
@@ -3239 +3132 @@
     }
 
-// g_I_have_just_nuked is set true by nuke_mode() just before it returns
+    // g_I_have_just_nuked is set true by nuke_mode() just before it returns
     if (!system("which post-nuke > /dev/null 2> /dev/null")) {
       mr_msg(1, "post-nuke found; find out whether we should run it...");
@@ -3262 +3155 @@
       } else {
         mr_msg(1, "Re-mounted partitions for post-nuke stuff");
-        sprintf(tmp, "post-nuke %s %d", bkpinfo->restore_path,
+        mr_asprintf(&tmp, "post-nuke %s %d", bkpinfo->restore_path,
             retval);
         mr_msg(2, "Calling '%s'", tmp);
@@ -3268 +3161 @@
           log_OS_error(tmp);
         }
+        mr_free(tmp);
         mr_msg(1, "post-nuke returned w/ res=%d", res);
       }
@@ -3274 +3168 @@
     }
 
-/*  
-  log_to_screen("If you are REALLY in a hurry, hit Ctrl-Alt-Del now.");
-  log_to_screen("Otherwise, please wait until the RAID disks are done.");
-  wait_until_software_raids_are_prepped("/proc/mdstat", 100);
-  log_to_screen("Thank you.");
-*/
     unlink("/tmp/mondo-run-prog.tmp");
     set_signals(FALSE);
@@ -3289 +3177 @@
         (_
          ("Restore log copied to /tmp/mondo-restore.log on your hard disk"));
-    mr_asprintf(&tmp,
-            _
-            ("Mondo-restore is exiting (retval=%d)                                      "),
-            retval);
-    log_to_screen(tmp);
-    mr_free(tmp);
+    log_to_screen(_("Mondo-restore is exiting (retval=%d)"), retval);
 
     mr_asprintf(&tmp, "umount %s", bkpinfo->isodir);

trunk/mondo/src/mondorestore/mr-externs.h

@@ -27 +27 @@
 extern int edit_mountlist(char *mountlist_fname, struct mountlist_itself *,
                           struct raidlist_itself *);
-extern int format_everything(struct mountlist_itself *, bool,
-                             struct raidlist_itself *);
+extern int format_everything(struct mountlist_itself *, bool, struct raidlist_itself *);
 extern int format_device(char *, char *, struct raidlist_itself *);
 extern void finish(int);
@@ -72 +71 @@
 extern int read_header_block_from_stream(long long *, char *, int *);
 extern void save_filelist(struct s_node *, char *);
-extern void strip_spaces(char *);
+extern void mr_strip_spaces(char *);
 extern int strcmp_inc_numbers(char *, char *);
 extern char *slice_fname(long, long, char *, char *);
@@ -86 +85 @@
 extern void resize_drive_proportionately_to_suit_new_drives(struct
                                                             mountlist_itself
-                                                            *mountlist, char
+                                                            *mountlist,
+                                                            char
                                                             *drive_name);
 extern void resize_mountlist_proportionately_to_suit_new_drives(struct