Changeset 688 in MondoRescue for trunk/mondo/mondo/mondorestore

Timestamp:

Jul 17, 2006, 3:44:46 PM (18 years ago)

Author:

bcornec

Message:

Huge memory management patch.
Still not finished but a lot as been done.
What remains is around some functions returning strings, and some structure members.
(Could not finish due to laptop failure !)

Location:

trunk/mondo/mondo/mondorestore

Files:

• mondo-prep.c (modified) (116 diffs)
• mondo-restore-EXT.h (modified) (1 diff)
• mondo-restore.c (modified) (161 diffs)
• mondo-restore.h (modified) (2 diffs)
• mondo-rstr-compare-EXT.h (modified) (1 diff)
• mondo-rstr-compare.c (modified) (37 diffs)
• mondo-rstr-compare.h (modified) (1 diff)
• mondo-rstr-newt.c (modified) (129 diffs)
• mondo-rstr-newt.h (modified) (6 diffs)
• mondo-rstr-tools-EXT.h (modified) (3 diffs)
• mondo-rstr-tools.c (modified) (122 diffs)
• mondo-rstr-tools.h (modified) (3 diffs)
• mondoprep.h (modified) (4 diffs)
• mr-externs.h (modified) (2 diffs)

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

@@ -1 +1 @@
 /***************************************************************************
-mondo-prep.c  -  description
------------------
-
-begin: Fri Apr 19 16:40:35 EDT 2002
-copyright : (C) 2002 Mondo  Hugo Rabson
-email     : Hugo Rabson <hugorabson@msn.com>
-edited by : by Stan Benoit 4/2002
-email     : troff@nakedsoul.org
-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.                                   *
- *                                                                         *
- ***************************************************************************/
-
-/* mondo-prep.c             Hugo Rabson
-
-
-
-07/20
-- when starting RAID, don't do it twice :)
-- moved Joshua's new get_phys_size_of_drive() code
-  from resize_drive... into get_phys_size_of_drive()
-
-06/29
-- make sure software RAID devices are formatted IF user says they're to be
-- drivelist is struct now, not char[][]
-
-06/26
-- drop make_relevant_partition_bootable(); do it yourself in C (mostly)
-- offer to reboot if partition table is locked up by the kernel
-
-06/22
-- be sure not to resize non-NTFS images when restoring
-- set non-NTFS images' partition types properly
-
-06/19
-- shut down all LVMs and VGs before prepping
-
-05/07
-- usage of parted2fdisk instead of fdisk alone (ia32/ia64 compatibility)
-  BCO
-
-03/31
-- rewrote partitioning and formatting code to call fdisk once per disk
-
-10/21/2003
-- suspend/resume Newt gui before/after calling do_my_funky_lvm_stuff()
-
-10/20
-- rewrote format_everything() - what a mess it was.
-  It now does things in three phases:-
-  - formats software RAID devices (/dev/md0, etc.)
-  - formats and configures LVM devices
-  - formats regular partitions (/dev/hda1, /dev/sdb2, etc.) 
-    and any LVMs recently prepped
-
-10/07
-- use strstr(format, "raid") instead of strcmp(format,"raid") to determin
-  if partition is a RAID component
-
-09/23
-- better comments
-
-09/18
-- better logging of RAID activity
-
-05/05
-- added Joshua Oreman's FreeBSD patches
-
-04/30
-- added textonly mode
-
-04/24
-- added lots of assert()'s and log_OS_error()'s
-
-04/21
-- format_everything() --- don't let bar go too far
-- mkfs -c to check for bad blocks when formatting
-
-04/04
-- misc clean-up (Tom Mortell)
-
-01/15/2003
-- added code for LVM and SW Raid (Brian Borgeson)
-
-12/10/2002
-- line 1238: friendlier output
-
-11/20
-- when wiping a given device in preparation for partitioning + formatting
-  it, don't wipe the MBR; just the partition table. That allows for
-  stupid-ass Compaq users who like to play with their MBR's.
-- disable mountlist.txt-->mountlist.txt.pre-resize copying (superfluous)
-
-09/09
-- run_program_and_log_output() now takes boolean operator to specify
-  whether it will log its activities in the event of _success_
-
-07/01 - 07/31
-- added hooks to libmondo
-- RAID enhancements (Philippe de Muyter)
-
-01/01 - 03/31
-- partition_device() will refuse to partition /dev/mdX now (cos it's a
-  virtual drive); however, it will return 0 (i.e. not an error)
-- make_list_of_drives() will exclude /dev/md* from list
-- mkreiserfs -ff instead of -q (Andy Glass)
-- don't resize drive if drive not found (or if its size cannot be det'd)
-- when generating list of drives from mountlist, skip the 'p' at the end
-  of drive name if /dev/ida/ or /dev/cciss/; just do it (Michael Eisenberg)
-- don't specify journal size when formatting ext3
-  (used to have -Jsize=10 in the call to mkfs)
-- handles files >2GB in size
-- format interactively, if Interactive Mode
-- removed reference to g_tape_size
-- when executing /tmp/i-want-my-lvm, only record the error# if the command
-  was _not_ an 'insmod' command
-- pass partition size to fdisk in Kilobytes now, not Megabytes
-- log fdisk's output to /tmp/mondo-restore.log if it fails
-- don't try to format partitions of type 'image'
-- don't type to set types of 'image' partitions
-- if format code is 1 or 2 chars then assume it is a hex string
-- took out all '/ /' comments
-- don't extrapolate/add partition from RAID dev to mountlist if it's already
-  present in mountlist
-- less repetitive logging in the event of vacuum-packing of last part'n
-- no extrapolation at all: RAID partitions should be listed in mountlist
-  already, thanks to either Mindi v0.5x or the mountlist editor itself
-- no longer say, 'and logging to...' when setting a partition's type
-- don't run mkfs on RAID partitions (/dev/hd*, /dev/sd*); just set type
-- the setting of a partition's type now takes place in a separate subroutine
-  from the subroutine that actually creates the partition
-- no need to set type if 83: 83 is the default (under fdisk)
-- turned on '-Wall'; cleaned up some cruft
-- if vacuum-packing partition (i.e. size=0MB --> max) then say, "(maximum)"
-  not, "(0 MB)"
-
-11/22/2001
-- preliminary code review
-- created on Nov 22nd, 2001
-*/
+ * $Id
+**/
 
 /**
@@ -159 +14 @@
 #include "../common/libmondo.h"
 #include "mondo-rstr-tools-EXT.h"
+
 #include <sys/ioctl.h>
 #include <linux/hdreg.h>
 #include <math.h>
+#include <unistd.h>
 
 
@@ -185 +42 @@
 extern char *g_mountlist_fname;
 extern long g_current_progress, g_maximum_progress;
-
 extern bool g_text_mode;
-
 extern void pause_for_N_seconds(int, char *);
 
-
 FILE *g_fprep = NULL;
-
-
-
 int g_partition_table_locked_up = 0;
-
-
-
-
-
-
-
-
 
 
@@ -209 +52 @@
 {
     char *command;
-    char *tmp;
     int lino;
     int i;
@@ -218 +60 @@
 // If LVMs are present and a zero-and-reboot wasn't recently undertaken
 // then zero & insist on reboot.
-    malloc_string(command);
-    malloc_string(tmp);
     buf = malloc(blocksize);
     if (does_file_exist("/tmp/i-want-my-lvm"))  // FIXME - cheating :)
@@ -226 +66 @@
         make_list_of_drives_in_mountlist(mountlist, drivelist);
         for (lino = 0; lino < drivelist->entries; lino++) {
-            sprintf(command,
-                    "dd if=%s bs=512 count=1 2> /dev/null | grep \"%s\"",
-                    drivelist->el[lino].device, MONDO_WAS_HERE);
+            asprintf(&command,
+                     "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)) {
                 log_msg(1, "Found MONDO_WAS_HERE marker on drive#%d (%s)",
                         lino, drivelist->el[lino].device);
+                paranoid_free(command);
                 break;
             }
+            paranoid_free(command);
         }
 
@@ -239 +81 @@
 // zero & reboot
             log_to_screen
-                (_("I am sorry for the inconvenience but I must ask you to reboot."));
-            log_to_screen
-                (_("I need to reset the Master Boot Record; in order to be"));
-            log_to_screen
-                (_("sure the kernel notices, I must reboot after doing it."));
+                (_
+                 ("I am sorry for the inconvenience but I must ask you to reboot."));
+            log_to_screen(_
+                          ("I need to reset the Master Boot Record; in order to be"));
+            log_to_screen(_
+                          ("sure the kernel notices, I must reboot after doing it."));
             log_to_screen("Please hit 'Enter' to reboot.");
             for (lino = 0; lino < drivelist->entries; lino++) {
@@ -265 +108 @@
                 }
             }
-            system("sync");
-            system("sync");
-            system("sync");
+            sync();
+            sync();
+            sync();
             popup_and_OK
-                (_("I must now reboot. Please leave the boot media in the drive and repeat your actions - e.g. type 'nuke' - and it should work fine."));
+                (_
+                 ("I must reboot now. Please leave the boot media in the drive and repeat your actions - e.g. type 'nuke' - and it should work fine."));
             system("reboot");
         }
     }
 // Still here? Cool!
-    paranoid_free(command);
-    paranoid_free(tmp);
     log_msg(1, "Cool. I didn't have to wipe anything.");
 }
-
-
-
-
 
 
@@ -311 +149 @@
     return (i);
 }
-
-
-
-
-
-
-
-
 
 
@@ -330 +160 @@
  * @return The number of errors encountered (0 for success).
  */
-
-
 int do_my_funky_lvm_stuff(bool just_erase_existing_volumes,
                           bool vacuum_pack)
 {
-    /**  buffers **********************************************/
-    char *tmp;
-    char *incoming;
-    char *command;
-    char *lvscan_sz;
-    char *lvremove_sz;
-    char *pvscan_sz;
-    char *vgscan_sz;
-    char *vgcreate_sz;
-    char *vgchange_sz;
-    char *vgremove_sz;
-//  char *do_this_last;
-
     /** char **************************************************/
-    char *p;
-    char *q;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *incoming = NULL;
+    char *command = NULL;
+    char *lvscan_sz = NULL;
+    char *lvremove_sz = NULL;
+    char *pvscan_sz = NULL;
+    char *vgscan_sz = NULL;
+    char *vgchange_sz = NULL;
+    char *vgremove_sz = NULL;
+    char *p = NULL;
+    char *q = NULL;
 
     /** int ***************************************************/
     int retval = 0;
     int res = 0;
-    int i;
+    int i = 0;
     int lvmversion = 1;
     long extents;
     fpos_t orig_pos;
+    size_t n = 0;
+    size_t n1 = 0;
 
     /** pointers **********************************************/
@@ -374 +201 @@
     }
 
-    malloc_string(tmp);
-    malloc_string(incoming);
-    malloc_string(lvscan_sz);
-    malloc_string(lvremove_sz);
-    malloc_string(vgscan_sz);
-    malloc_string(pvscan_sz);
-    malloc_string(vgcreate_sz);
-    malloc_string(vgchange_sz);
-    malloc_string(vgremove_sz);
-//  malloc_string(do_this_last); // postpone lvcreate call if necessary
-    command = malloc(512);
-
-//  do_this_last[0] = '\0';
     iamhere("STARTING");
     log_msg(1, "OK, opened i-want-my-lvm. Shutting down LVM volumes...");
     if (find_home_of_exe("lvm"))    // found it :) cool
     {
-        strcpy(lvscan_sz, "lvm lvscan");
-        strcpy(lvremove_sz, "lvm lvremove");
-        strcpy(vgscan_sz, "lvm vgscan");
-        strcpy(pvscan_sz, "lvm pvscan");
-        strcpy(vgcreate_sz, "lvm vgcreate");
-        strcpy(vgchange_sz, "lvm vgchange");
-        strcpy(vgremove_sz, "lvm vgremove");
+        asprintf(&lvscan_sz, "lvm lvscan");
+        asprintf(&lvremove_sz, "lvm lvremove");
+        asprintf(&vgscan_sz, "lvm vgscan");
+        asprintf(&pvscan_sz, "lvm pvscan");
+        asprintf(&vgchange_sz, "lvm vgchange");
+        asprintf(&vgremove_sz, "lvm vgremove");
     } else {
-        strcpy(lvscan_sz, "lvscan");
-        strcpy(lvremove_sz, "lvremove");
-        strcpy(vgscan_sz, "vgscan");
-        strcpy(pvscan_sz, "pvscan");
-        strcpy(vgcreate_sz, "vgcreate");
-        strcpy(vgchange_sz, "vgchange");
-        strcpy(vgremove_sz, "vgremove");
-    }
-    sprintf(command,
+        asprintf(&lvscan_sz, "lvscan");
+        asprintf(&lvremove_sz, "lvremove");
+        asprintf(&vgscan_sz, "vgscan");
+        asprintf(&pvscan_sz, "pvscan");
+        asprintf(&vgchange_sz, "vgchange");
+        asprintf(&vgremove_sz, "vgremove");
+    }
+    asprintf(&command,
             "for i in `%s | cut -d\"'\" -f2 | sort -r` ; do echo \"Shutting down lv $i\" >> "
             MONDO_LOGFILE "; %s -f $i; done", lvscan_sz, lvremove_sz);
+    paranoid_free(lvscan_sz);
+    paranoid_free(lvremove_sz);
+
     run_program_and_log_output(command, 5);
+    paranoid_free(command);
+
     sleep(1);
-    sprintf(command,
+    asprintf(&command,
             "for i in `%s | grep -i lvm | cut -d'\"' -f2` ; do %s -a n $i ; %s $i; echo \"Shutting down vg $i\" >> "
-            MONDO_LOGFILE "; done; %s -a n", vgscan_sz, vgchange_sz,
-            vgremove_sz, vgremove_sz);
+            MONDO_LOGFILE "; done; %s -a n", vgscan_sz, vgchange_sz, vgremove_sz, vgremove_sz);
+    paranoid_free(vgchange_sz);
+    paranoid_free(vgremove_sz);
+
     run_program_and_log_output(command, 5);
+    paranoid_free(command);
+
     if (just_erase_existing_volumes) {
         paranoid_fclose(fin);
         log_msg(1, "Closed i-want-my-lvm. Finished erasing LVMs.");
-        retval = 0;
-        goto end_of_i_want_my_lvm;
+        sync();
+        sync();
+        sync();
+        sleep(1);
+        iamhere("ENDING");
+        log_msg(1, "Not many errors. Returning 0.");
+        return (0);
     }
 
     log_msg(1, "OK, rewound i-want-my-lvm. Doing funky stuff...");
     rewind(fin);
-    for (fgets(incoming, 512, fin); !feof(fin); fgets(incoming, 512, fin)) {
+    for (getline(&incoming, &n1, fin); !feof(fin); getline(&incoming, &n1, fin)) {
         fgetpos(fin, &orig_pos);
+        /* BERLIOS : Strange no ? */
         if (incoming[0] != '#') {
             continue;
@@ -433 +260 @@
         if (res && strstr(command, "create") && vacuum_pack) {
             sleep(2);
-            system("sync");
-            system("sync");
-            system("sync");
+            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)
-            for (fgets(tmp, 512, fin); !feof(fin); fgets(tmp, 512, fin)) {
+            for (getline(&tmp, &n, fin); !feof(fin); getline(&tmp, &n, fin)) {
                 if (tmp[0] == '#') {
                     fsetpos(fin, &orig_pos);
@@ -445 +272 @@
                 } else {
                     fgetpos(fin, &orig_pos);
-                    strcat(incoming, tmp);
+                    asprintf(&tmp1, "%s%s", incoming, tmp);
+                    paranoid_free(incoming);
+                    incoming = tmp1;
                 }
             }
+            paranoid_free(tmp);
+
             for (q = incoming; *q != '\0'; q++) {
                 if (*q < 32) {
@@ -453 +284 @@
                 }
             }
-            strcpy(tmp, p + strlen("vgcreate") + 1);
-            for (q = tmp; *q > 32; q++);
+            malloc_string(tmp1);
+            strcpy(tmp1, p + strlen("vgcreate") + 1);
+            for (q = tmp1; *q > 32; q++);
             *q = '\0';
-            log_msg(1, "Deleting old entries at /dev/%s", tmp);
-//             sprintf(command, "%s -f %s", vgremove_sz, tmp);
-//             run_program_and_log_output(command, 1);
-            sprintf(command, "rm -Rf /dev/%s", tmp);
-            run_program_and_log_output(command, 1);
+            log_msg(1, "Deleting old entries at /dev/%s", tmp1);
+            asprintf(&tmp, "rm -Rf /dev/%s", tmp1);
+            paranoid_free(tmp1);
+            run_program_and_log_output(tmp, 1);
+            paranoid_free(tmp);
+
             run_program_and_log_output(vgscan_sz, 1);
             run_program_and_log_output(pvscan_sz, 1);
@@ -468 +301 @@
         }
         for (p = incoming + 1; *p == ' '; p++);
-        strcpy(command, p);
+        paranoid_free(command);
+        asprintf(&command, p);
         for (p = command; *p != '\0'; p++);
         for (; *(p - 1) < 32; p--);
@@ -485 +319 @@
             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) {
-                strcpy(tmp, call_program_and_get_last_line_of_output
-                       ("tail -n5 "MONDO_LOGFILE" | grep Insufficient | tail -n1"));
+                tmp = call_program_and_get_last_line_of_output
+                        ("tail -n5 " MONDO_LOGFILE
+                        " | grep Insufficient | tail -n1");
             } else {
-                strcpy(tmp, call_program_and_get_last_line_of_output
-                       ("tail -n5 "MONDO_LOGFILE" | grep lvcreate | tail -n1"));
+                tmp = call_program_and_get_last_line_of_output
+                       ("tail -n5 " MONDO_LOGFILE
+                        " | grep lvcreate | tail -n1");
             }
             for (p = tmp; *p != '\0' && !isdigit(*p); p++);
             extents = atol(p);
             log_msg(5, "p='%s' --> extents=%ld", p, extents);
+            paranoid_free(tmp);
             p = strstr(command, "-L");
             if (!p) {
@@ -543 +382 @@
             retval++;
         }
-        sprintf(tmp, "echo \"%s\" >> /tmp/out.sh", command);
+        asprintf(&tmp, "echo \"%s\" >> /tmp/out.sh", command);
         system(tmp);
+        paranoid_free(tmp);
         sleep(1);
     }
     paranoid_fclose(fin);
-    log_msg(1, "Closed i-want-my-lvm. Finished doing funky stuff.");
-  end_of_i_want_my_lvm:
-    paranoid_free(tmp);
-    paranoid_free(incoming);
-    paranoid_free(command);
-    paranoid_free(lvscan_sz);
-    paranoid_free(lvremove_sz);
     paranoid_free(vgscan_sz);
     paranoid_free(pvscan_sz);
-    paranoid_free(vgcreate_sz);
-    paranoid_free(vgchange_sz);
-    paranoid_free(vgremove_sz);
-//  paranoid_free(do_this_last);
-    system("sync");
-    system("sync");
-    system("sync");
+    paranoid_free(command);
+    paranoid_free(incoming);
+
+    log_msg(1, "Closed i-want-my-lvm. Finished doing funky stuff.");
+    sync();
+    sync();
+    sync();
     sleep(1);
     iamhere("ENDING");
@@ -589 +422 @@
                                                      *old_mountlist)
 {
-    /** pointers *********************************************************/
-    FILE *fin;
-
-    /** int **************************************************************/
-    int lino;
-    int j;
-
-    /** buffers **********************************************************/
-    char *incoming;
-    char *tmp;
-
-    /** pointers *********************************************************/
-    char *p;
+    FILE *fin = NULL;
+    int lino = 0;
+    int j = 0;
+    char *incoming = NULL;
+    char *tmp = NULL;
+    char *p = NULL;
+    size_t n = 0;
 
     /** init *************************************************************/
@@ -608 +435 @@
     /** end **************************************************************/
 
-    malloc_string(incoming);
-    malloc_string(tmp);
     assert(new_mountlist != NULL);
     assert(old_mountlist != NULL);
@@ -615 +440 @@
 #ifdef __FreeBSD__
     log_to_screen
-        (_("I don't know how to extrapolate the mountlist on FreeBSD. Sorry."));
+        (_
+         ("I don't know how to extrapolate the mountlist on FreeBSD. Sorry."));
     return (1);
 #endif
@@ -624 +450 @@
             if (!does_file_exist("/etc/raidtab")) {
                 log_to_screen
-                    (_("Cannot find /etc/raidtab - cannot extrapolate the fdisk entries"));
+                    (_
+                     ("Cannot find /etc/raidtab - cannot extrapolate the fdisk entries"));
                 finish(1);
             }
@@ -631 +458 @@
                 finish(1);
             }
-            for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin)
+            for (getline(&incoming, &n, fin); !feof(fin)
                  && !strstr(incoming, old_mountlist->el[lino].device);
-                 fgets(incoming, MAX_STR_LEN - 1, fin));
+                 getline(&incoming, &n, fin));
             if (!feof(fin)) {
-                sprintf(tmp, "Investigating %s",
+                asprintf(&tmp, "Investigating %s",
                         old_mountlist->el[lino].device);
                 log_it(tmp);
-                for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin)
+                paranoid_free(tmp);
+
+                for (getline(&incoming, &n, fin); !feof(fin)
                      && !strstr(incoming, "raiddev");
-                     fgets(incoming, MAX_STR_LEN - 1, fin)) {
+                     getline(&incoming, &n, fin)) {
                     if (strstr(incoming, OSSWAP("device", "drive"))
                         && !strchr(incoming, '#')) {
@@ -647 +476 @@
                         *p = '\0';
                         for (p--; p > incoming && *(p - 1) > 32; p--);
-                        sprintf(tmp, "Extrapolating %s", p);
+                        asprintf(&tmp, "Extrapolating %s", p);
                         log_it(tmp);
+                        paranoid_free(tmp);
+
                         for (j = 0;
                              j < new_mountlist->entries
@@ -666 +497 @@
                             new_mountlist->entries++;
                         } else {
-                            sprintf(tmp,
-                                    "Not adding %s to mountlist: it's already there",
-                                    p);
+                            asprintf(&tmp,
+                                    "Not adding %s to mountlist: it's already there", p);
                             log_it(tmp);
+                            paranoid_free(tmp);
                         }
                     }
                 }
             }
+            paranoid_free(incoming);
             paranoid_fclose(fin);
         } else {
@@ -687 +519 @@
         }
     }
-    paranoid_free(incoming);
-    paranoid_free(tmp);
 
     return (0);
@@ -702 +532 @@
  * @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 **************************************************************/
-  int i   = 0;
-  int j   = 0;
-  int res = 0;
-  
+    int i = 0;
+    int j = 0;
+    int res = 0;
+
   /** buffers ***********************************************************/
-  char *devices = NULL;
-  char *strtmp  = NULL;
-  char *level   = NULL;
-  char *program = NULL;
-  
-  // leave straight away if raidlist is initial or has no entries
-  if (!raidlist || raidlist->entries == 0) {
-    log_msg(1, "No RAID arrays found.");
-    return 1;
-  } else {
-    log_msg(1, "%d RAID arrays found.", raidlist->entries);
-  }
-  // find raidlist entry for requested device
-  for (i = 0; i < raidlist->entries; i++) {
-    if (!strcmp(raidlist->el[i].raid_device, device)) break;
-  }
-  // check whether RAID device was found in raidlist
-  if (i == raidlist->entries) {
-    log_msg(1, "RAID device %s not found in list.", device);
-    return 1;
-  }
-  // create device list from normal disks followed by spare ones
-  asprintf(&devices, raidlist->el[i].data_disks.el[0].device);
-  for (j = 1; j < raidlist->el[i].data_disks.entries; j++) {
-    asprintf(&strtmp, "%s", devices);
-    paranoid_free(devices);
-    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);
-    paranoid_free(devices);
-    asprintf(&devices, "%s %s", strtmp,
-         raidlist->el[i].spare_disks.el[j].device);
-    paranoid_free(strtmp);
-  }
-  // translate RAID level
-  if (raidlist->el[i].raid_level == -2) {
-    asprintf(&level, "multipath");
-  } else if (raidlist->el[i].raid_level == -1) {
-    asprintf(&level, "linear");
-  } else {
-    asprintf(&level, "raid%d", raidlist->el[i].raid_level);
-  }
-  // create RAID device:
-  // - RAID device, number of devices and devices mandatory
-  // - parity algorithm, chunk size and spare devices optional
-  // - faulty devices ignored
-  // - persistent superblock always used as this is recommended
-  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);
-    paranoid_free(program);
-    switch(raidlist->el[i].parity) {
-    case 0:
-      asprintf(&program, "%s --parity=%s", strtmp, "la");
-      break;
-    case 1:
-      asprintf(&program, "%s --parity=%s", strtmp, "ra");
-      break;
-    case 2:
-      asprintf(&program, "%s --parity=%s", strtmp, "ls");
-      break;
-    case 3:
-      asprintf(&program, "%s --parity=%s", strtmp, "rs");
-      break;
-    default:
-      fatal_error("Unknown RAID parity algorithm.");
-      break;
-    }
-    paranoid_free(strtmp);
-  }
-  if (raidlist->el[i].chunk_size != -1) {
-    asprintf(&strtmp, "%s", program);
-    paranoid_free(program);
-    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);
-    paranoid_free(program);
-    asprintf(&program, "%s --spare-devices=%d", strtmp,
-         raidlist->el[i].spare_disks.entries);
-    paranoid_free(strtmp);
-  }
-  asprintf(&strtmp, "%s", program);
-  paranoid_free(program);
-  asprintf(&program, "%s %s", strtmp, devices);
-  paranoid_free(strtmp);
-  res = run_program_and_log_output(program, 1);
-  // free memory
-  paranoid_free(devices);
-  paranoid_free(level);
-  paranoid_free(program);
-  // return to calling instance
-  return res;
+    char *devices = NULL;
+    char *strtmp = NULL;
+    char *level = NULL;
+    char *program = NULL;
+
+    // leave straight away if raidlist is initial or has no entries
+    if (!raidlist || raidlist->entries == 0) {
+        log_msg(1, "No RAID arrays found.");
+        return 1;
+    } else {
+        log_msg(1, "%d RAID arrays found.", raidlist->entries);
+    }
+    // find raidlist entry for requested device
+    for (i = 0; i < raidlist->entries; i++) {
+        if (!strcmp(raidlist->el[i].raid_device, device))
+            break;
+    }
+    // check whether RAID device was found in raidlist
+    if (i == raidlist->entries) {
+        log_msg(1, "RAID device %s not found in list.", device);
+        return 1;
+    }
+    // create device list from normal disks followed by spare ones
+    asprintf(&devices, raidlist->el[i].data_disks.el[0].device);
+    for (j = 1; j < raidlist->el[i].data_disks.entries; j++) {
+        asprintf(&strtmp, "%s", devices);
+        paranoid_free(devices);
+        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);
+        paranoid_free(devices);
+        asprintf(&devices, "%s %s", strtmp,
+                 raidlist->el[i].spare_disks.el[j].device);
+        paranoid_free(strtmp);
+    }
+    // translate RAID level
+    if (raidlist->el[i].raid_level == -2) {
+        asprintf(&level, "multipath");
+    } else if (raidlist->el[i].raid_level == -1) {
+        asprintf(&level, "linear");
+    } else {
+        asprintf(&level, "raid%d", raidlist->el[i].raid_level);
+    }
+    // create RAID device:
+    // - RAID device, number of devices and devices mandatory
+    // - parity algorithm, chunk size and spare devices optional
+    // - faulty devices ignored
+    // - persistent superblock always used as this is recommended
+    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);
+        paranoid_free(program);
+        switch (raidlist->el[i].parity) {
+        case 0:
+            asprintf(&program, "%s --parity=%s", strtmp, "la");
+            break;
+        case 1:
+            asprintf(&program, "%s --parity=%s", strtmp, "ra");
+            break;
+        case 2:
+            asprintf(&program, "%s --parity=%s", strtmp, "ls");
+            break;
+        case 3:
+            asprintf(&program, "%s --parity=%s", strtmp, "rs");
+            break;
+        default:
+            fatal_error("Unknown RAID parity algorithm.");
+            break;
+        }
+        paranoid_free(strtmp);
+    }
+    if (raidlist->el[i].chunk_size != -1) {
+        asprintf(&strtmp, "%s", program);
+        paranoid_free(program);
+        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);
+        paranoid_free(program);
+        asprintf(&program, "%s --spare-devices=%d", strtmp,
+                 raidlist->el[i].spare_disks.entries);
+        paranoid_free(strtmp);
+    }
+    asprintf(&strtmp, "%s", program);
+    paranoid_free(program);
+    asprintf(&program, "%s %s", strtmp, devices);
+    paranoid_free(strtmp);
+    res = run_program_and_log_output(program, 1);
+    // free memory
+    paranoid_free(devices);
+    paranoid_free(level);
+    paranoid_free(program);
+    // return to calling instance
+    return res;
 }
 
@@ -823 +656 @@
  * @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 **************************************************************/
-    int res;
+    int res = 0;
     int retval = 0;
 #ifdef __FreeBSD__
@@ -833 +667 @@
 
     /** buffers ***********************************************************/
-    char *program;
-    char *tmp;
+    char *program = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *line = NULL;
+    char *status = NULL;
+    FILE *pin;
+    FILE *fin;
+    size_t n = 0;
+    size_t n1 = 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);
+        asprintf(&tmp, "Not formatting %s (it is a RAID disk)", device);
         log_it(tmp);
-        paranoid_free(program);
         paranoid_free(tmp);
         return (0);
@@ -853 +691 @@
     if (strcmp(format, "swap") == 0) {
         log_it("Not formatting %s - it's swap", device);
-        paranoid_free(program);
-        paranoid_free(tmp);
         return (0);
     }
 #endif
     if (strlen(format) <= 2) {
-        sprintf(tmp,
+        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(program);
         paranoid_free(tmp);
         return (0);
     }
     if (is_this_device_mounted(device)) {
-        sprintf(tmp, _("%s is mounted - cannot format it       "), device);
+        asprintf(&tmp, _("%s is mounted - cannot format it       "), device);
         log_to_screen(tmp);
-        paranoid_free(program);
         paranoid_free(tmp);
         return (1);
@@ -880 +714 @@
             if (!does_file_exist("/tmp/raidconf.txt")) {
                 log_to_screen
-                    (_("/tmp/raidconf.txt does not exist. I therefore cannot start Vinum."));
+                    (_
+                     ("/tmp/raidconf.txt does not exist. I therefore cannot start Vinum."));
             } else {
                 int res;
@@ -888 +723 @@
                 if (res) {
                     log_to_screen
-                        (_("`vinum create /tmp/raidconf.txt' returned errors. Please fix them and re-run mondorestore."));
+                        (_
+                         ("`vinum create /tmp/raidconf.txt' returned errors. Please fix them and re-run mondorestore."));
                     finish(1);
                 }
@@ -896 +732 @@
 
         if (vinum_started_yet) {
-            FILE *fin;
-            char line[MAX_STR_LEN];
-            sprintf(tmp,
-                    _("Initializing Vinum device %s (this may take a *long* time)"),
+            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
-            sprintf(program,
+            asprintf(&program,
                     "for plex in `vinum lv -r %s | grep '^P' | tr '\t' ' ' | tr -s ' ' | cut -d' ' -f2`; do echo $plex; done > /tmp/plexes",
                     basename(device));
             system(program);
+
             if (g_fprep) {
                 fprintf(g_fprep, "%s\n", program);
             }
+            paranoid_free(program);
+
             fin = fopen("/tmp/plexes", "r");
-            while (fgets(line, MAX_STR_LEN - 1, fin)) {
+            while (getline(&line, &n, fin)) {
                 if (strchr(line, '\n'))
                     *(strchr(line, '\n')) = '\0';   // get rid of the \n on the end
 
-                sprintf(tmp, "Initializing plex: %s", line);
+                asprintf(&tmp, "Initializing plex: %s", line);
                 open_evalcall_form(tmp);
-                sprintf(tmp, "vinum init %s", line);
+                paranoid_free(tmp);
+
+                asprintf(&tmp, "vinum init %s", line);
                 system(tmp);
+                paranoid_free(tmp);
+
                 while (1) {
-                    sprintf(tmp,
+                    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");
-                    char status[MAX_STR_LEN / 4];
-                    fgets(status, MAX_STR_LEN / 4 - 1, pin);
+                    pin = popen(tmp, "r");
+                    paranoid_free(tmp);
+
+                    getline(&status, &n1, pin);
                     pclose(pin);
 
@@ -934 +778 @@
                     update_evalcall_form(atoi(status));
                     usleep(250000);
+                    paranoid_free(status);
                 }
                 close_evalcall_form();
             }
+            paranoid_free(line);
             fclose(fin);
             unlink("/tmp/plexes");
@@ -942 +788 @@
         }
 #else
-        sprintf(tmp, _("Initializing RAID device %s"), device);
+        asprintf(&tmp, _("Initializing RAID device %s"), device);
         log_to_screen(tmp);
+        paranoid_free(tmp);
 
 // Shouldn't be necessary.
         log_to_screen(_("Stopping %s"), device);
         stop_raid_device(device);
-        system("sync");
+        sync();
         sleep(1);
+        /* BERLIOS: This code is wrong as program has not been initialized
         if (g_fprep) {
             fprintf(g_fprep, "%s\n", program);
         }
+        */
 
         log_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);
-            log_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);
+            log_msg(1, "Creating RAID device %s via mdadm returned %d",
+                    device, res);
         } else {
-            sprintf(program, "mkraid --really-force %s", device);
+            asprintf(&program, "mkraid --really-force %s", device);
             res = run_program_and_log_output(program, 1);
             log_msg(1, "%s returned %d", program, res);
-            system("sync");
+            sync();
             sleep(3);
             start_raid_device(device);
@@ -969 +819 @@
                 fprintf(g_fprep, "%s\n", program);
             }
-        }
-        system("sync");
+            paranoid_free(program);
+        }
+        sync();
         sleep(2);
-//      log_to_screen("Starting %s", device);
-//      sprintf(program, "raidstart %s", device);
-//      res = run_program_and_log_output(program, 1);
-//      log_msg(1, "%s returned %d", program, res);
-//      system("sync"); sleep(1);
-#endif
-        system("sync");
+#endif
+        sync();
         sleep(1);
         newtResume();
@@ -987 +833 @@
     if (!strcmp(format, "lvm")) {
         log_msg(1, "Don't format %s - it's part of an lvm volume", device);
-        paranoid_free(program);
-        paranoid_free(tmp);
         return (0);
     }
+    /* This function allocates program */
     res = which_format_command_do_i_need(format, program);
-    sprintf(tmp, "%s %s", program, device);
     if (strstr(program, "kludge")) {
-        strcat(tmp, " /");
-    }
-    sprintf(program, "sh -c 'echo -en \"y\\ny\\ny\\n\" | %s'", tmp);
-    sprintf(tmp, "Formatting %s as %s", device, format);
+        asprintf(&tmp, "%s %s /", program, device);
+    } else {
+        asprintf(&tmp, "%s %s", program, device);
+    }
+    paranoid_free(program);
+
+    asprintf(&program, "sh -c 'echo -en \"y\\ny\\ny\\n\" | %s'", tmp);
+    paranoid_free(tmp);
+
+    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")) {
-        sprintf(tmp, "Kludge failed; using regular mkfs.%s to format %s",
-                format, device);
 #ifdef __FreeBSD__
-        sprintf(program, "newfs_msdos -F 32 %s", device);
+        paranoid_free(program);
+        asprintf(&program, "newfs_msdos -F 32 %s", device);
 #else
 #ifdef __IA64__
         /* For EFI partitions take fat16 
          * as we want to make small ones */
-        sprintf(program, "mkfs -t %s -F 16 %s", format, device);
+        paranoid_free(program);
+        asprintf(&program, "mkfs -t %s -F 16 %s", format, device);
 #else
-        sprintf(program, "mkfs -t %s -F 32 %s", format, device);
+        paranoid_free(program);
+        asprintf(&program, "mkfs -t %s -F 32 %s", format, device);
 #endif
 #endif
@@ -1019 +871 @@
         }
     }
+    paranoid_free(program);
+
     retval += res;
     if (retval) {
-        strcat(tmp, _("...failed"));
+        asprintf(&tmp1, "%s%s",tmp, _("...failed"));
     } else {
-        strcat(tmp, _("...OK"));
-    }
-
-    log_to_screen(tmp);
-    paranoid_free(program);
+        asprintf(&tmp1, "%s%s",tmp, _("...OK"));
+    }
     paranoid_free(tmp);
-    system("sync");
+
+    log_to_screen(tmp1);
+    paranoid_free(tmp1);
+    sync();
     sleep(1);
     return (retval);
 }
-
-
-
 
 
@@ -1044 +895 @@
  * @return The number of errors encountered (0 for success).
  */
-int format_everything(struct mountlist_itself *mountlist, bool interactively,
-                          struct raidlist_itself *raidlist)
+int format_everything(struct mountlist_itself *mountlist,
+                      bool interactively, struct raidlist_itself *raidlist)
 {
     /** int **************************************************************/
@@ -1068 +919 @@
 
     assert(mountlist != NULL);
-    malloc_string(tmp);
-    sprintf(tmp, "format_everything (mountlist, interactively = %s",
+    asprintf(&tmp, "format_everything (mountlist, interactively = %s",
             (interactively) ? "true" : "false");
     log_it(tmp);
+    paranoid_free(tmp);
+
     mvaddstr_and_log_it(g_currentY, 0, _("Formatting partitions     "));
     open_progress_form(_("Formatting partitions"),
@@ -1085 +937 @@
     log_msg(1, "Stopping all RAID devices");
     stop_all_raid_devices(mountlist);
-    system("sync");
-    system("sync");
-    system("sync");
+    sync();
+    sync();
+    sync();
     sleep(2);
     log_msg(1, "Prepare soft-RAIDs");   // prep and format too
@@ -1096 +948 @@
             if (interactively) {
                 // ask user if we should format the current device
-                sprintf(tmp, "Shall I format %s (%s) ?", me->device,
+                asprintf(&tmp, "Shall I format %s (%s) ?", me->device,
                         me->mountpoint);
                 do_it = ask_me_yes_or_no(tmp);
+                paranoid_free(tmp);
             } else {
                 do_it = TRUE;
@@ -1109 +962 @@
         }
     }
-    system("sync");
-    system("sync");
-    system("sync");
+    sync();
+    sync();
+    sync();
     sleep(2);
 // This last step is probably necessary
@@ -1126 +979 @@
             newtSuspend();
         }
-/*
-        for(i=0; i<3; i++)
-          {
-            res = do_my_funky_lvm_stuff(FALSE, FALSE);
-            if (!res) { break; }
-            sleep(3);
-            res = do_my_funky_lvm_stuff(TRUE, FALSE);
-            sleep(3);
-          }
-        if (res) {
-            log_msg(1, "Vacuum-packing...");
-*/
         res = do_my_funky_lvm_stuff(FALSE, TRUE);
-/*
-        }
-*/
         if (!g_text_mode) {
             newtResume();
@@ -1150 +988 @@
             log_to_screen("Failed to initialize LVM");
         }
-        // retval += res;
         if (res) {
             retval++;
@@ -1162 +999 @@
         me = &mountlist->el[lino];  // the current mountlist entry
         if (!strcmp(me->mountpoint, "image")) {
-            sprintf(tmp, "Not formatting %s - it's an image", me->device);
+            asprintf(&tmp, "Not formatting %s - it's an image", me->device);
             log_it(tmp);
+            paranoid_free(tmp);
         } else if (!strcmp(me->format, "raid")) {
-            sprintf(tmp, "Not formatting %s - it's a raid-let",
+            asprintf(&tmp, "Not formatting %s - it's a raid-let",
                     me->device);
             log_it(tmp);
+            paranoid_free(tmp);
             continue;
         } else if (!strcmp(me->format, "lvm")) {
-            sprintf(tmp, "Not formatting %s - it's an LVM", me->device);
+            asprintf(&tmp, "Not formatting %s - it's an LVM", me->device);
             log_it(tmp);
+            paranoid_free(tmp);
             continue;
         } else if (!strncmp(me->device, "/dev/md", 7)) {
-            sprintf(tmp, "Already formatted %s - it's a soft-RAID dev",
+            asprintf(&tmp, "Already formatted %s - it's a soft-RAID dev",
                     me->device);
             log_it(tmp);
+            paranoid_free(tmp);
             continue;
         } else if (!does_file_exist(me->device)
                    && strncmp(me->device, "/dev/hd", 7)
                    && strncmp(me->device, "/dev/sd", 7)) {
-            sprintf(tmp,
+            asprintf(&tmp,
                     "Not formatting %s yet - doesn't exist - probably an LVM",
                     me->device);
             log_it(tmp);
+            paranoid_free(tmp);
             continue;
         } else {
             if (interactively) {
                 // ask user if we should format the current device
-                sprintf(tmp, "Shall I format %s (%s) ?", me->device,
+                asprintf(&tmp, "Shall I format %s (%s) ?", me->device,
                         me->mountpoint);
                 do_it = ask_me_yes_or_no(tmp);
+                paranoid_free(tmp);
             } else {
                 do_it = TRUE;
@@ -1215 +1058 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
         log_to_screen
-            (_("Errors occurred during the formatting of your hard drives."));
+            (_
+             ("Errors occurred during the formatting of your hard drives."));
     } else {
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     }
 
-    sprintf(tmp, "format_everything () - %s",
+    asprintf(&tmp, "format_everything () - %s",
             (retval) ? "failed!" : "finished successfully");
     log_it(tmp);
+    paranoid_free(tmp);
 
     if (g_partition_table_locked_up > 0) {
@@ -1228 +1073 @@
 //123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 
             log_to_screen
-                (_("Partition table locked up %d times. At least one 'mkfs' (format) command"),
+                (_
+                 ("Partition table locked up %d times. At least one 'mkfs' (format) command"),
                  g_partition_table_locked_up);
-            log_to_screen
-                (_("failed. I think these two events are related. Sometimes, fdisk's ioctl() call"));
-            log_to_screen
-                (_("to refresh its copy of the partition table causes the kernel to lock the "));
-            log_to_screen
-                (_("partition table. I believe this has just happened."));
+            log_to_screen(_
+                          ("failed. I think these two events are related. Sometimes, fdisk's ioctl() call"));
+            log_to_screen(_
+                          ("to refresh its copy of the partition table causes the kernel to lock the "));
+            log_to_screen(_
+                          ("partition table. I believe this has just happened."));
             if (ask_me_yes_or_no
-                (_("Please choose 'yes' to reboot and try again; or 'no' to ignore this warning and continue.")))
+                (_
+                 ("Please choose 'yes' to reboot and try again; or 'no' to ignore this warning and continue.")))
             {
-                system("sync");
-                system("sync");
-                system("sync");
+                sync();
+                sync();
+                sync();
                 system("reboot");
             }
         } else {
             log_to_screen
-                (_("Partition table locked up %d time%c. However, disk formatting succeeded."),
+                (_
+                 ("Partition table locked up %d time%c. However, disk formatting succeeded."),
                  g_partition_table_locked_up,
                  (g_partition_table_locked_up == 1) ? '.' : 's');
@@ -1254 +1102 @@
     system("clear");
     newtResume();
-    paranoid_free(tmp);
     return (retval);
 }
@@ -1281 +1128 @@
     /** end **************************************************************/
 
-    malloc_string(tmp);
     assert_string_is_neither_NULL_nor_zerolength(drivename);
 
     if (devno_we_must_allow_for >= 5) {
-        sprintf(tmp, "Making dummy primary %s%d", drivename, 1);
+        asprintf(&tmp, "Making dummy primary %s%d", drivename, 1);
         log_it(tmp);
+        paranoid_free(tmp);
+
         g_maximum_progress++;
         res =
@@ -1299 +1147 @@
     }
     for (; current_devno < devno_we_must_allow_for; current_devno++) {
-        sprintf(tmp, "Creating dummy partition %s%d", drivename,
+        asprintf(&tmp, "Creating dummy partition %s%d", drivename,
                 current_devno);
         log_it(tmp);
+        paranoid_free(tmp);
+
         g_maximum_progress++;
         res =
@@ -1309 +1159 @@
         previous_devno = current_devno;
     }
-    paranoid_free(tmp);
     return (previous_devno);
 }
@@ -1340 +1189 @@
     }
 }
+
 
 /* The following 2 functions are stolen from /usr/src/sbin/disklabel/disklabel.c */
@@ -1442 +1292 @@
     static struct disklabel loclab;
     struct partition *dp;
-    char lnamebuf[BBSIZE];
+    char *lnamebuf;
     int f;
     u_int secsize, u;
     off_t mediasize;
 
-    (void) snprintf(lnamebuf, BBSIZE, "%s", dkname);
+    asprintf(&lnamebuf, "%s", dkname);
     if ((f = open(lnamebuf, O_RDONLY)) == -1) {
         warn("cannot open %s", lnamebuf);
+        paranoid_free(lnamebuf);
         return (NULL);
     }
+    paranoid_free(lnamebuf);
 
     /* New world order */
@@ -1522 +1374 @@
                          char *drivename, struct disklabel *ret)
 {
-    char subdev_str[MAX_STR_LEN];
-    char command[MAX_STR_LEN];
+    char *subdev_str;
+    char *command;
     struct disklabel *lp;
     int i, lo = 0;
@@ -1533 +1385 @@
     for (c = 'a'; c <= 'z'; ++c) {
         int idx;
-        sprintf(subdev_str, "%s%c", drivename, c);
+        asprintf(&subdev_str, "%s%c", drivename, c);
         if ((idx = find_device_in_mountlist(mountlist, subdev_str)) < 0) {
             lp->d_partitions[c - 'a'].p_size = 0;
@@ -1558 +1410 @@
                 lp->d_partitions[c - 'a'].p_fstype = FS_OTHER;
         }
+        paranoid_free(subdev_str);
     }
 
@@ -1588 +1441 @@
     display_disklabel(ftmp, lp);
     fclose(ftmp);
-    sprintf(command, "disklabel -wr %s auto", canonical_name(drivename));
+    asprintf(&command, "disklabel -wr %s auto", canonical_name(drivename));
     retval += run_program_and_log_output(command, TRUE);
-    sprintf(command, "disklabel -R %s /tmp/disklabel",
+    paranoid_free(command);
+
+    asprintf(&command, "disklabel -R %s /tmp/disklabel",
             canonical_name(drivename));
     retval += run_program_and_log_output(command, TRUE);
+    paranoid_free(command);
     if (ret)
         *ret = *lp;
@@ -1609 +1465 @@
 {
     /** int *************************************************************/
-    int current_devno;
+    int current_devno = 0;
     int previous_devno = 0;
-    int lino;
+    int lino = 0;
     int retval = 0;
-    int i;
+    int i = 0;
     FILE *pout_to_fdisk = NULL;
 
 #ifdef __FreeBSD__
     bool fbsd_part = FALSE;
-    char subdev_str[MAX_STR_LEN];
+    char *subdev_str = NULL;
 #endif
 
@@ -1625 +1481 @@
 
     /** buffers *********************************************************/
-    char *device_str;
-    char *format;
-    char *tmp;
+    char *device_str = NULL;
+    char *format = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
 
     /** end *************************************************************/
@@ -1634 +1491 @@
     assert_string_is_neither_NULL_nor_zerolength(drivename);
 
-    malloc_string(device_str);
-    malloc_string(format);
-    malloc_string(tmp);
-
-    sprintf(tmp, "Partitioning drive %s", drivename);
+    asprintf(&tmp, "Partitioning drive %s", drivename);
     log_it(tmp);
+    paranoid_free(tmp);
 
 #if __FreeBSD__
@@ -1646 +1500 @@
 #else
     make_hole_for_file(FDISK_LOG);
-    sprintf(tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG);
+    asprintf(&tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG,
+            FDISK_LOG);
     pout_to_fdisk = popen(tmp, "w");
+    paranoid_free(tmp);
+
     if (!pout_to_fdisk) {
-        log_to_screen(_("Cannot call parted2fdisk to configure %s"), drivename);
-        paranoid_free(device_str);
-        paranoid_free(format);
-        paranoid_free(tmp);
+        log_to_screen(_("Cannot call parted2fdisk to configure %s"),
+                      drivename);
         return (1);
     }
 #endif
     for (current_devno = 1; current_devno < 99; current_devno++) {
-        build_partition_name(device_str, drivename, current_devno);
+        device_str = build_partition_name(drivename, current_devno);
         lino = find_device_in_mountlist(mountlist, device_str);
 
@@ -1670 +1525 @@
                 // try DangerouslyDedicated mode
                 for (c = 'a'; c <= 'z'; c++) {
-                    sprintf(subdev_str, "%s%c", drivename, c);
-                    if (find_device_in_mountlist(mountlist, subdev_str) >
-                        0) {
+                    asprintf(&subdev_str, "%s%c", drivename, c);
+                    if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
                         fbsd_part = TRUE;
                     }
+                    paranoid_free(subdev_str);
                 }
                 if (fbsd_part) {
@@ -1685 +1540 @@
                     if (system(command)) {
                         log_to_screen
-                            (_("Warning! Unable to make the drive bootable."));
+                            (_
+                             ("Warning! Unable to make the drive bootable."));
                     }
                     paranoid_free(device_str);
-                    paranoid_free(format);
-                    paranoid_free(tmp);
+
                     return r;
                 }
             }
             for (c = 'a'; c <= 'z'; c++) {
-                sprintf(subdev_str, "%s%c", device_str, c);
+                asprintf(&subdev_str, "%s%c", device_str, c);
                 if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
                     fbsd_part = TRUE;
                 }
+                paranoid_free(subdev_str);
             }
             // Now we check the subpartitions of the current partition.
@@ -1703 +1559 @@
                 int i, line;
 
-                strcpy(format, "ufs");
+                asprintf(&format, "ufs");
                 partsize = 0;
                 for (i = 'a'; i < 'z'; ++i) {
-                    sprintf(subdev_str, "%s%c", device_str, i);
+                    asprintf(&subdev_str, "%s%c", device_str, i);
                     line = find_device_in_mountlist(mountlist, subdev_str);
+                    paranoid_free(subdev_str);
+
                     if (line > 0) {
                         // We found one! Add its size to the total size.
@@ -1730 +1588 @@
 #if __FreeBSD__
             // FreeBSD doesn't let you write to blk devices in <512byte chunks.
-//          sprintf(tmp, "dd if=/dev/zero of=%s count=1 bs=512", drivename);
-//          if (run_program_and_log_output(tmp, TRUE)) {
             file = open(drivename, O_WRONLY);
             if (!file) {
-                sprintf(tmp,
+                asprintf(&tmp,
                         _("Warning - unable to open %s for wiping it's partition table"),
                         drivename);
                 log_to_screen(tmp);
+                paranoid_free(tmp);
             }
 
             for (i = 0; i < 512; i++) {
                 if (!write(file, "\0", 1)) {
-                    sprintf(tmp, _("Warning - unable to write to %s"),
+                    asprintf(&tmp, _("Warning - unable to write to %s"),
                             drivename);
                     log_to_screen(tmp);
+                    paranoid_free(tmp);
                 }
             }
-            system("sync");
+            sync();
 #else
             iamhere("New, kernel-friendly partition remover");
@@ -1754 +1612 @@
                 fflush(pout_to_fdisk);
             }
-//          sprintf(tmp, "dd if=/dev/zero of=%s count=1 bs=512", drivename);
-//          run_program_and_log_output(tmp, 1);
 #endif
             if (current_devno > 1) {
@@ -1767 +1623 @@
 #endif
 
-            strcpy(format, mountlist->el[lino].format);
+            asprintf(&format, mountlist->el[lino].format);
             partsize = mountlist->el[lino].size;
 
@@ -1776 +1632 @@
         if (current_devno == 5 && previous_devno == 4) {
             log_to_screen
-                (_("You must leave at least one partition spare as the Extended partition."));
+                (_
+                 ("You must leave at least one partition spare as the Extended partition."));
             paranoid_free(device_str);
             paranoid_free(format);
-            paranoid_free(tmp);
+
             return (1);
         }
@@ -1789 +1646 @@
 #ifdef __FreeBSD__
         if ((current_devno <= 4) && fbsd_part) {
-            sprintf(tmp, "disklabel -B %s", basename(device_str));
+            asprintf(&tmp, "disklabel -B %s", basename(device_str));
             retval += label_drive_or_slice(mountlist, device_str, 0);
             if (system(tmp)) {
@@ -1795 +1652 @@
                     (_("Warning! Unable to make the slice bootable."));
             }
+            paranoid_free(tmp);
         }
 #endif
@@ -1800 +1658 @@
         previous_devno = current_devno;
     }
+    paranoid_free(device_str);
+    paranoid_free(format);
 
     if (pout_to_fdisk) {
-// mark relevant partition as bootable
-        sprintf(tmp, "a\n%s\n",
-                call_program_and_get_last_line_of_output
-                ("make-me-bootable /tmp/mountlist.txt dummy"));
+        // mark relevant partition as bootable
+        tmp1 = call_program_and_get_last_line_of_output
+                ("make-me-bootable /tmp/mountlist.txt dummy");
+        asprintf(&tmp, "a\n%s\n", tmp1);
+        paranoid_free(tmp1);
+
         fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
-// close fdisk
+        paranoid_free(tmp);
+
+        // close fdisk
         fput_string_one_char_at_a_time(pout_to_fdisk, "w\n");
-        system("sync");
+        sync();
         paranoid_pclose(pout_to_fdisk);
         log_msg(0,
                 "------------------- fdisk.log looks like this ------------------");
-        sprintf(tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
+        asprintf(&tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
         system(tmp);
+        paranoid_free(tmp);
+
         log_msg(0,
                 "------------------- end of fdisk.log... word! ------------------");
-        sprintf(tmp, "tail -n6 %s | grep -F \"16: \"", FDISK_LOG);
+        asprintf(&tmp, "tail -n6 %s | grep -F \"16: \"", FDISK_LOG);
         if (!run_program_and_log_output(tmp, 5)) {
             g_partition_table_locked_up++;
             log_to_screen
-                (_("A flaw in the Linux kernel has locked the partition table."));
-        }
-    }
-    paranoid_free(device_str);
-    paranoid_free(format);
-    paranoid_free(tmp);
+                (_
+                 ("A flaw in the Linux kernel has locked the partition table."));
+        }
+        paranoid_free(tmp);
+    }
     return (retval);
 }
+
 
 /**
@@ -1851 +1717 @@
     char *partition_name;
     char *tmp;
-    char *logfile;
     char *output;
 
@@ -1861 +1726 @@
     /** end ***************************************************************/
 
-    malloc_string(program);
-    malloc_string(partition_name);
-    malloc_string(tmp);
-    malloc_string(logfile);
-    malloc_string(output);
-
     assert_string_is_neither_NULL_nor_zerolength(drive);
     assert(format != NULL);
@@ -1874 +1733 @@
 
     if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
-        sprintf(tmp, "Not partitioning %s - it is a virtual drive", drive);
+        asprintf(&tmp, "Not partitioning %s - it is a virtual drive", drive);
         log_it(tmp);
-        paranoid_free(program);
-        paranoid_free(partition_name);
         paranoid_free(tmp);
-        paranoid_free(logfile);
-        paranoid_free(output);
         return (0);
     }
-    build_partition_name(partition_name, drive, partno);
+    partition_name = build_partition_name(drive, partno);
     if (partsize <= 0) {
-        sprintf(tmp, "Partitioning device %s (max size)", partition_name);
+        asprintf(&tmp, "Partitioning device %s (max size)", partition_name);
     } else {
-        sprintf(tmp, "Partitioning device %s (%lld MB)", partition_name,
+        asprintf(&tmp, "Partitioning device %s (%lld MB)", partition_name,
                 (long long) partsize / 1024);
     }
     update_progress_form(tmp);
     log_it(tmp);
+    paranoid_free(tmp);
 
     if (is_this_device_mounted(partition_name)) {
-        sprintf(tmp, _("%s is mounted, and should not be partitioned"),
+        asprintf(&tmp, _("%s is mounted, and should not be partitioned"),
                 partition_name);
+        paranoid_free(partition_name);
+
         log_to_screen(tmp);
-        paranoid_free(program);
-        paranoid_free(partition_name);
         paranoid_free(tmp);
-        paranoid_free(logfile);
-        paranoid_free(output);
         return (1);
-/*
-    } else if (does_partition_exist(drive, partno)) {
-        sprintf(tmp, "%s already has a partition", partition_name);
-        log_to_screen(tmp);
-        return (1);
-*/
-    }
-
-
-    /*  sprintf(tmp,"Partitioning %s  ",partition_name); */
-    /*  mvaddstr_and_log_it(g_currentY+1,30,tmp); */
+    }
+
     p = (char *) strrchr(partition_name, '/');
-    sprintf(logfile, "/tmp/fdisk.log.%s", ++p);
-    sprintf(program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE,
+    asprintf(&program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE,
             MONDO_LOGFILE);
 
-    /* BERLIOS: shoould not be called each time */
+    /* BERLIOS: should not be called each time */
     part_table_fmt = which_partition_format(drive);
-    output[0] = '\0';
     /* make it a primary/extended/logical */
     if (partno <= 4) {
-        sprintf(output + strlen(output), "n\np\n%d\n", partno);
+        asprintf(&output,"n\np\n%d\n", partno);
     } else {
         /* MBR needs an extended partition if more than 4 partitions */
@@ -1931 +1774 @@
                 if (prev_partno >= 4) {
                     log_to_screen
-                        (_("You need to leave at least one partition free, for 'extended/logical'"));
+                        (_
+                         ("You need to leave at least one partition free, for 'extended/logical'"));
+                    paranoid_free(partition_name);
                     paranoid_free(program);
-                    paranoid_free(partition_name);
-                    paranoid_free(tmp);
-                    paranoid_free(logfile);
+
                     paranoid_free(output);
                     return (1);
                 } else {
-                    sprintf(output + strlen(output), "n\ne\n%d\n\n\n",
-                            prev_partno + 1);
+                    asprintf(&output,"n\ne\n%d\n\n\n",prev_partno + 1);
                 }
             }
-            strcat(output + strlen(output), "n\nl\n");
+            asprintf(&tmp,"%sn\nl\n",output);
+            paranoid_free(output);
+            output = tmp;
         } else {
             /* GPT allows more than 4 primary partitions */
-            sprintf(output + strlen(output), "n\np\n%d\n", partno);
+            asprintf(&output,"n\np\n%d\n",partno);
         }
     }
     paranoid_free(part_table_fmt);
-    strcat(output + strlen(output), "\n");  /*start block (ENTER for next free blk */
+    /*start block (ENTER for next free blk */
+    asprintf(&tmp,"%s\n",output);
+    paranoid_free(output);
+    output = tmp;
+
     if (partsize > 0) {
         if (!strcmp(format, "7")) {
@@ -1956 +1804 @@
             partsize += 512;
         }
-        sprintf(output + strlen(output), "+%lldK", (long long) (partsize));
-    }
-    strcat(output + strlen(output), "\n");
+        asprintf(&tmp,"%s+%lldK", output,  (long long) (partsize));
+        paranoid_free(output);
+        output = tmp;
+    }
+    asprintf(&tmp,"%s\n",output);
+    paranoid_free(output);
+    output = tmp;
 #if 0
 /*
 #endif
-    sprintf(tmp,"PARTSIZE = +%ld",(long)partsize);
+    asprintf(&tmp,"PARTSIZE = +%ld",(long)partsize);
     log_it(tmp);
+    paranoid_free(tmp);
+
     log_it("---fdisk command---");
     log_it(output);
@@ -1977 +1831 @@
         fput_string_one_char_at_a_time(pout_to_fdisk, output);
         fput_string_one_char_at_a_time(pout_to_fdisk, "\n\np\n");
-        strcpy(tmp, last_line_of_file(FDISK_LOG));
+        tmp = last_line_of_file(FDISK_LOG);
         if (strstr(tmp, " (m ")) {
             log_msg(1, "Successfully created %s%d", drive, partno);
@@ -1985 +1839 @@
                     partno);
         }
+        paranoid_free(tmp);
+
         if (!retval) {
             log_msg(1, "Trying to set %s%d's partition type now", drive,
@@ -2002 +1858 @@
         }
     } else {
-        strcat(output, "w\n\n");
+        asprintf(&tmp,"%sw\n\n",output);
+        paranoid_free(output);
+        output = tmp;
+
         if (g_fprep) {
             fprintf(g_fprep, "echo \"%s\" | %s\n", output, program);
@@ -2020 +1879 @@
                                  format, -1);
             if (res) {
-                sprintf(tmp, "Failed to vacuum-pack %s", partition_name);
+                asprintf(&tmp, "Failed to vacuum-pack %s", partition_name);
                 log_it(tmp);
+                paranoid_free(tmp);
+
                 retval++;
             } else {
@@ -2032 +1893 @@
                                    partsize);
             if (retval) {
-                sprintf(tmp, "Partitioned %s but failed to set its type",
+                asprintf(&tmp, "Partitioned %s but failed to set its type",
                         partition_name);
                 log_it(tmp);
+                paranoid_free(tmp);
             } else {
                 if (partsize > 0) {
-                    sprintf(tmp, "Partition %s created+configured OK",
+                    asprintf(&tmp, "Partition %s created+configured OK",
                             partition_name);
                     log_to_screen(tmp);
+                    paranoid_free(tmp);
                 } else {
                     log_it("Returning from a successful vacuum-pack");
@@ -2045 +1908 @@
             }
         } else {
-            sprintf(tmp, "Failed to partition %s", partition_name);
+            asprintf(&tmp, "Failed to partition %s", partition_name);
             if (partsize > 0) {
                 log_to_screen(tmp);
@@ -2051 +1914 @@
                 log_it(tmp);
             }
+            paranoid_free(tmp);
             retval++;
         }
@@ -2056 +1920 @@
     g_current_progress++;
     log_it("partition_device() --- leaving");
+    paranoid_free(partition_name);
     paranoid_free(program);
-    paranoid_free(partition_name);
-    paranoid_free(tmp);
-    paranoid_free(logfile);
     paranoid_free(output);
     return (retval);
 }
-
 
 
@@ -2124 +1985 @@
     open_progress_form(_("Partitioning devices"),
                        _("I am now going to partition all your drives."),
-                       _("This should not take more than five minutes."), "",
-                       mountlist->entries);
+                       _("This should not take more than five minutes."),
+                       "", mountlist->entries);
 
     make_list_of_drives_in_mountlist(mountlist, drivelist);
@@ -2138 +1999 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
         log_to_screen
-            (_("Errors occurred during the partitioning of your hard drives."));
+            (_
+             ("Errors occurred during the partitioning of your hard drives."));
     } else {
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
@@ -2168 +2030 @@
 {
     /** buffers *********************************************************/
-    char *partition;
-    char *command;
-    char *output;
-    char *tmp;
-    char *partcode;
-    char *logfile;
+    char *partition = NULL;
+    char *command = NULL;
+    char *output = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *partcode = NULL;
 
     /** pointers *********************************************************/
-    char *p;
-    FILE *fout;
+    char *p = NULL;
+    FILE *fout = NULL;
 
     /** int **************************************************************/
@@ -2187 +2049 @@
     assert(format != NULL);
 
-    malloc_string(partition);
-    malloc_string(command);
-    malloc_string(output);
-    malloc_string(tmp);
-    malloc_string(partcode);
-    malloc_string(logfile);
-
-    build_partition_name(partition, drive, partno);
+    partition = build_partition_name(drive, partno);
     p = (char *) strrchr(partition, '/');
-    sprintf(logfile, "/tmp/fdisk-set-type.%s.log", ++p);
     if (strcmp(format, "swap") == 0) {
-        strcpy(partcode, "82");
+        asprintf(&partcode, "82");
     } else if (strcmp(format, "vfat") == 0) {
         if (partsize / 1024 > 8192) {
-            strcpy(partcode, "c");
+            asprintf(&partcode, "c");
         } else {
-            strcpy(partcode, "b");
+            asprintf(&partcode, "b");
         }
     } else if (strcmp(format, "ext2") == 0
@@ -2209 +2063 @@
                || strcmp(format, "ext3") == 0 || strcmp(format, "xfs") == 0
                || strcmp(format, "jfs") == 0) {
-        strcpy(partcode, "83");
+        asprintf(&partcode, "83");
     } else if (strcmp(format, "minix") == 0) {
-        strcpy(partcode, "81");
+        asprintf(&partcode, "81");
     } else if (strcmp(format, "raid") == 0) {
-        strcpy(partcode, "fd");
+        asprintf(&partcode, "fd");
     } else if ((strcmp(format, "ufs") == 0)
                || (strcmp(format, "ffs") == 0)) {   /* raid autodetect */
-        strcpy(partcode, "a5");
+        asprintf(&partcode, "a5");
     } else if (strcmp(format, "lvm") == 0) {
-        strcpy(partcode, "8e");
+        asprintf(&partcode, "8e");
     } else if (format[0] == '\0') { /* LVM physical partition */
-        partcode[0] = '\0';
+        asprintf(&partcode, "");
     } else if (strlen(format) >= 1 && strlen(format) <= 2) {
-        strcpy(partcode, format);
+        asprintf(&partcode, format);
     } else {
         /* probably an image */
-        sprintf(tmp,
+        asprintf(&tmp,
                 "Unknown format ('%s') - using supplied string anyway",
                 format);
         mvaddstr_and_log_it(g_currentY++, 0, tmp);
+        paranoid_free(tmp);
 #ifdef __FreeBSD__
-        strcpy(partcode, format);   // was a5
+        asprintf(&partcode, format);    // was a5
 #else
-        strcpy(partcode, format);   // was 83
-#endif
-    }
-    sprintf(tmp, "Setting %s's type to %s (%s)", partition, format,
+        asprintf(&partcode, format);    // was 83
+#endif
+    }
+    asprintf(&tmp, "Setting %s's type to %s (%s)", partition, format,
             partcode);
+    paranoid_free(partition);
+
     log_msg(1, tmp);
+    paranoid_free(tmp);
     if (partcode[0] != '\0' && strcmp(partcode, "83")) {    /* no need to set type if 83: 83 is default */
 
@@ -2243 +2101 @@
             res = 0;
             fput_string_one_char_at_a_time(pout_to_fdisk, "t\n");
+            tmp1 = last_line_of_file(FDISK_LOG);
             if (partno > 1
-                || strstr(last_line_of_file(FDISK_LOG), " (1-4)")) {
+                || strstr(tmp1, " (1-4)")) {
                 log_msg(5, "Specifying partno (%d) - yay", partno);
-                sprintf(tmp, "%d\n", partno);
+                asprintf(&tmp, "%d\n", partno);
                 fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
-                log_msg(5, "A - last line = '%s'",
-                        last_line_of_file(FDISK_LOG));
-            }
-
-            sprintf(tmp, "%s\n", partcode);
+                paranoid_free(tmp);
+                paranoid_free(tmp1);
+                tmp1 = last_line_of_file(FDISK_LOG);
+                log_msg(5, "A - last line = '%s'", tmp1);
+            }
+            paranoid_free(tmp1);
+
+            asprintf(&tmp, "%s\n", partcode);
             fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
-            log_msg(5, "B - last line = '%s'",
-                    last_line_of_file(FDISK_LOG));
+            paranoid_free(tmp);
+            tmp1 = last_line_of_file(FDISK_LOG);
+            log_msg(5, "B - last line = '%s'",tmp1);
+            paranoid_free(tmp1);
+
             fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
-            log_msg(5, "C - last line = '%s'",
-                    last_line_of_file(FDISK_LOG));
-
-            strcpy(tmp, last_line_of_file(FDISK_LOG));
+            tmp1 = last_line_of_file(FDISK_LOG);
+            log_msg(5, "C - last line = '%s'",tmp1);
+            paranoid_free(tmp1);
+
+            tmp = last_line_of_file(FDISK_LOG);
             if (!strstr(tmp, " (m ")) {
                 log_msg(1, "last line = '%s'; part type set failed", tmp);
@@ -2266 +2132 @@
                 fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
             }
+            paranoid_free(tmp);
             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");
-            sprintf(command, "parted2fdisk %s >> %s 2>> %s", drive,
+            asprintf(&output, "t\n%d\n%s\nw\n", partno, partcode);
+            asprintf(&command, "parted2fdisk %s >> %s 2>> %s", drive,
                     MONDO_LOGFILE, MONDO_LOGFILE);
             log_msg(5, "output = '%s'", output);
@@ -2284 +2150 @@
                 paranoid_pclose(fout);
             }
-        }
+            paranoid_free(command);
+            paranoid_free(output);
+        }
+        /* BERLIOS: Useless as command not initialized in all cases
         if (res) {
             log_OS_error(command);
         }
-    }
-
-    paranoid_free(partition);
-    paranoid_free(command);
-    paranoid_free(output);
-    paranoid_free(tmp);
+        */
+    }
     paranoid_free(partcode);
-    paranoid_free(logfile);
+
 
     return (res);
@@ -2313 +2178 @@
 
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
-    malloc_string(program);
 
 #ifdef __FreeBSD__
@@ -2320 +2184 @@
         return 1;
     }
-    sprintf(program, "vinum start -f %s", raid_device);
+    asprintf(&program, "vinum start -f %s", raid_device);
 #else
-    sprintf(program, "raidstart %s", raid_device);
+    asprintf(&program, "raidstart %s", raid_device);
 //      sprintf (program, "raidstart " RAID_DEVICE_STUB "*");
 #endif
@@ -2330 +2194 @@
         fprintf(g_fprep, "%s\n", program);
     }
+    paranoid_free(program);
+
     if (res) {
         log_msg(1, "Warning - failed to start RAID device %s",
@@ -2338 +2204 @@
     return (retval);
 }
-
 
 
@@ -2358 +2223 @@
 
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
-    malloc_string(program);
 
 #ifdef __FreeBSD__
@@ -2365 +2229 @@
         return 1;
     }
-    sprintf(program, "vinum stop -f %s", raid_device);
+    asprintf(&program, "vinum stop -f %s", raid_device);
 #else
-    // use raidstop if it exists, otherwise use mdadm
-    if (run_program_and_log_output("which raidstop", FALSE)) {
-        sprintf(program, "mdadm -S %s", raid_device);
+    // use raidstop if it exists, otherwise use mdadm
+    if (run_program_and_log_output("which raidstop", FALSE)) {
+        asprintf(&program, "mdadm -S %s", raid_device);
     } else {
-        sprintf(program, "raidstop %s", raid_device);
+        asprintf(&program, "raidstop %s", raid_device);
     }
 #endif
@@ -2379 +2243 @@
         fprintf(g_fprep, "%s\n", program);
     }
+    paranoid_free(program);
+
     if (res) {
         log_msg(1, "Warning - failed to stop RAID device %s", raid_device);
@@ -2409 +2275 @@
     return (retval);
 }
+
 
 /**
@@ -2421 +2288 @@
     int retval = 0;
 #ifndef __FreeBSD__
-    int res;
+    int res = 0;
 #endif
 
     /** char ************************************************************/
-    char *incoming;
+    char *incoming = NULL;
 #ifndef __FreeBSD__
-    char *dev;
+    char *dev = NULL;
 #endif
     /** pointers ********************************************************/
 #ifndef __FreeBSD__
-    char *p;
-#endif
-    FILE *fin;
-    int i;
+    char *p = NULL;
+#endif
+    FILE *fin = NULL;
+    int i = 0;
+    size_t n = 0;
 
     /** end ****************************************************************/
 
-    malloc_string(dev);
-    malloc_string(incoming);
     assert(mountlist != NULL);
 
@@ -2449 +2315 @@
              "r");
         if (!fin) {
-            paranoid_free(dev);
-            paranoid_free(incoming);
             return (1);
         }
-        for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
-             fgets(incoming, MAX_STR_LEN - 1, fin)) {
+        for (getline(&incoming, &n, fin); !feof(fin);
+             getline(&incoming, &n, fin)) {
             retval += stop_raid_device(incoming);
         }
@@ -2461 +2325 @@
         if (!fin) {
             log_OS_error("/proc/mdstat");
-            paranoid_free(dev);
-            paranoid_free(incoming);
             return (1);
         }
-        for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
-             fgets(incoming, MAX_STR_LEN - 1, fin)) {
+        for (getline(&incoming, &n, fin); !feof(fin);
+             getline(&incoming, &n, fin)) {
             for (p = incoming;
                  *p != '\0' && (*p != 'm' || *(p + 1) != 'd'
                                 || !isdigit(*(p + 2))); p++);
             if (*p != '\0') {
-                sprintf(dev, "/dev/%s", p);
+                asprintf(&dev, "/dev/%s", p);
+                /* BERLIOS : 32 Hard coded value */
                 for (p = dev; *p > 32; p++);
                 *p = '\0';
                 res = stop_raid_device(dev);
-            }
-        }
-#endif
+                paranoid_free(dev);
+            }
+        }
+#endif
+        paranoid_free(incoming);
     }
     paranoid_fclose(fin);
@@ -2483 +2348 @@
         log_msg(1, "Warning - unable to stop some RAID devices");
     }
-    paranoid_free(dev);
-    paranoid_free(incoming);
-    system("sync");
-    system("sync");
-    system("sync");
+    sync();
+    sync();
+    sync();
     sleep(1);
     return (retval);
 }
-
 
 
@@ -2510 +2372 @@
     /** end ***************************************************************/
 
-    malloc_string(tmp);
     assert_string_is_neither_NULL_nor_zerolength(format);
     assert(program != NULL);
@@ -2542 +2403 @@
         sprintf(program, "mkfs -t %s -c", format);  // -c checks for bad blocks
 #endif
-        sprintf(tmp, "Unknown format (%s) - assuming '%s' will do", format,
+        asprintf(&tmp, "Unknown format (%s) - assuming '%s' will do", format,
                 program);
         log_it(tmp);
+        paranoid_free(tmp);
         res = 0;
     }
-    paranoid_free(tmp);
     return (res);
 }
@@ -2573 +2434 @@
     /** end *************************************************************/
 
-    malloc_string(tmp);
     assert(mountlist != NULL);
     assert_string_is_neither_NULL_nor_zerolength(drive_name);
@@ -2584 +2444 @@
             original_size_of_drive += mountlist->el[partno].size;
         } else {
-            sprintf(tmp, "Skipping %s", mountlist->el[partno].device);
+            asprintf(&tmp, "Skipping %s", mountlist->el[partno].device);
 //                      log_to_screen(tmp);
+            paranoid_free(tmp);
         }
     }
     original_size_of_drive = original_size_of_drive / 1024;
-    paranoid_free(tmp);
     return (original_size_of_drive);
 }
@@ -2632 +2492 @@
     /** end **************************************************************/
 
-    malloc_string(tmp);
     assert(mountlist != NULL);
     assert_string_is_neither_NULL_nor_zerolength(drive_name);
@@ -2639 +2498 @@
         if (strncmp(drive_name, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))
             == 0) {
-            paranoid_free(tmp);
             return;
         }
@@ -2653 +2511 @@
     if (current_size_of_drive <= 0) {
         log_it("Not resizing to match %s - can't find drive", drive_name);
-        paranoid_free(tmp);
         return;
     }
-    sprintf(tmp, _("Expanding entries to suit drive %s (%ld MB)"), drive_name,
-            current_size_of_drive);
+    asprintf(&tmp, _("Expanding entries to suit drive %s (%ld MB)"),
+            drive_name, current_size_of_drive);
     log_to_screen(tmp);
+    paranoid_free(tmp);
 
     drivemntlist = malloc(sizeof(struct mountlist_reference));
@@ -2675 +2533 @@
 
     if (original_size_of_drive <= 0) {
-        sprintf(tmp, _("Cannot resize %s's entries. Drive not found."),
+        asprintf(&tmp, _("Cannot resize %s's entries. Drive not found."),
                 drive_name);
         log_to_screen(tmp);
@@ -2683 +2541 @@
     factor =
         (float) (current_size_of_drive) / (float) (original_size_of_drive);
-    sprintf(tmp, "Disk %s was %ld MB; is now %ld MB; factor = %f",
+    asprintf(&tmp, "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);
+    paranoid_free(tmp);
 
     lastpart = drivemntlist->entries - 1;
@@ -2705 +2564 @@
             newsizL = (long) new_size;
         }
-        sprintf(tmp, _("Changing %s from %lld KB to %ld KB"),
+        asprintf(&tmp, _("Changing %s from %lld KB to %ld KB"),
                 drivemntlist->el[partno]->device,
                 drivemntlist->el[partno]->size, newsizL);
         log_to_screen(tmp);
+        paranoid_free(tmp);
         drivemntlist->el[partno]->size = newsizL;
     }
     final_size = get_phys_size_of_drive(drive_name);
-    sprintf(tmp, _("final_size = %ld MB"), final_size);
+    asprintf(&tmp, _("final_size = %ld MB"), final_size);
     log_to_screen(tmp);
     paranoid_free(tmp);
@@ -2778 +2638 @@
     log_msg(1, "Creating list of partitions for drive %s", drive_name);
 
-    tmp_drive_name = strdup(drive_name);
+    asprintf(&tmp_drive_name,drive_name);
     if (!tmp_drive_name)
         fatal_error("Out of memory");
@@ -2798 +2658 @@
         }
     }
-    if (tmp_drive_name)
-        free(tmp_drive_name);
+    paranoid_free(tmp_drive_name);
 }
 

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

@@ -1 @@
-/* mondo-restore-EXT.h */
+/* 
+ * $Id$
+**/
 
 #ifdef __FreeBSD__

trunk/mondo/mondo/mondorestore/mondo-restore.c

@@ -1 +1 @@
 /***************************************************************************
-       mondo-restore.c  -  restores mondoarchive data
-                             -------------------
-    begin                : Fri May 19 2000
-    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                                      *
- ***************************************************************************
-.
-
-
-07/26
-- workaround - if not /dev then don't call partimagehack
-
-07/21
-- if switch to Interactive Mode during nuke then don't nuke twice :) just once
-
-07/18
-- better support of users who boot from LVM CD and nuke-restore non-LVM backups
-
-07/10
-- when using 'star', exclude all 'not removed.' messages from log (misleading, they are)
-- try w/ ACLs, then w/o ACLs if star fails w/ ACLs
-- added ACL, xattr support for afio
-
-06/26
-- remove make_relevant_partition_bootable(); roll into mondo-prep.c
-- changed various newtDrawRootText() calls to use g_noof_rows instead of
-  integers
-
-06/19
-- don't try to access biggiestruct before it is populated w/ data relating
-  to biggiefile; instead, use control char to find out if biggiefile is
-  to be restored w/ partimagehack or not
-- added AUX_VER
-
-06/15
-- read_cfg_file_into_bkpinfo() --- use user-supplied 'isodir' instead of
-  archive's 'isodir' if different
-  Conor Daly <conor.daly@met.ie>
-
-06/17
-- restore with partimagehack if NTFS device; dd, if non-NTFS device
-
-06/14
-- unmount all; remount, run grub-mr; unmount again
-
-04/09
-- fixed subset restoration bug introduced when I added 'star' support
-
-04/04
-- cleaned up restore_a_tarball_from_stream()
-
-04/03
-- added star support
-- pause for 3s between partitioning and formatting (if in Nuke Mode)
-
-03/28
-- check that g_mountlist_fname was correcfly set; abort if it wasn't
-
-03/25
-- removed dev_null code
-
-03/22/04
-- added mode_of_file()
-- added code to check for unauthorised modification of /dev/null
-  by afio (for instance)
-
-12/27/03
-- check /tmp/cmdline instead of /proc/cmdline if on FreeBSD
-
-11/15
-- added g_fprep
-- "Switch to interactive mode?" msg is now more informative
-
-11/05
-- after 'Are you sure?' when user specifies / as restore path, set
-  restore_path[] to "" so that files are restored to [blank]/file/name :)
-
-10/29
-- moved "No restoring or comparing will take place today" block
-  up to before iso_fiddly_bits (if iso) is called - fix bug
-  if you're in ISO Mode and you say "exit to shell"
-
-10/22
-- swapped calls to chmod() and chown() after restoration
-  of big files (Jens)
-
-10/21
-- changed "/mnt/cdrom" to MNT_CDROM
-
-10/19
-- restore biggiefiles selectively from CD properly
-- use find_my_editor() to find pico/vi/whatever
-- better use of call_program_and_get_last_line_of_output() to
-  scan /proc/cmdline
-
-10/18
-- don't report 'missing compressor' if no compressor used at all
-
-10/14
-- log afio's error messages to /var/log/mondo-archive.log
-  when restoring :)
-- call vi if pico is not available
-
-10/09
-- better logging if fatal error (cannot openout bigfile)
-- better GUI feedback when restoring big files
-- restore_everything() now uses s_node* instead of char*
-- ditto restore_all_*_from_*()
-
-10/02
-- succinct msg instead of pop-ups, if used -H
-
-09/27
-- tweaked restore-time gui
-
-09/26
-- proper reporting of DVD/CDR/etc. type in displayed dialogs
-
-09/23
-- malloc/free global strings in new subroutines - malloc_libmondo_global_strings()
-  and free_libmondo_global_strings() - which are in libmondo-tools.c
-
-09/21
-- trying to fix "mondorestore <no params>" segfault
-
-09/18
-- better remounting of /
-- cleaned up run_grub()
-- sensible command-line handling in Live Mode
-
-09/17
-- cleaned up GRUB installer script a bit
-
-09/15
-- remount / as r/w if in disaster recovery mode;
-  helps for b0rken distros
-
-09/13
-- major NTFS hackage
-
-09/12
-- changed some in-sub var decl'ns to malloc()'s
-
-09/05
-- don't let me run unless I'm root
-- finished NTFS/partimagehack support (CD only); working on tape now
-
-09/01
-- fixed cosmetic bug in biggiefile restore window
-
-06/01 - 08/31
-- added code to main() to make sure NFS
-  (backup) share is mounted in Nuke and Compare Modes
-- added code to run_grub() to mount /boot before running grub-install
-- fixed some stray assert()'s in restore_a_biggiefile_from_stream()
-- fixed bugs in extract_config_file_from_ramdisk()
-  and get_cfg_file_from_archive() which
-  stopped fape+floppy users from being able to
-  boot from floppy and leave floppy in drive :)
-- added hooks to partimage for doing imagedevs
-- fixed calls to popup_and_get_string()
-
-05/01 - 05/31
-- fixed biggiefile atime/utime dates restoration bug, I think
-- added misc clean-up (Steve Hindle)
-- fixed support for subdir-within-NFS-mount
-- if nuke mode fails & user reverts to interactive mode _and succeeds_,
-  don't claim nuke mode aborted :)
-- unmount_all_devices() uses mountlist->el[lino].mountpt
-  instead of mountlist->el[lino].device where possible
-- added Joshua Oreman's FreeBSD patches
-- copied missing paragraph from 1.6x's read_cfg_file_into_bkpinfo()
-  to 1.7x's; affected tape streamer users (badly!)
-- cleaned up some paranoid assert()'s
-- use which("post-nuke") instead of find_home_of_exe("post-nuke")
-- fixed "Don't eject while restoring" mode
-- get_cfg_file_from_archive() --- also recovers mountlist.txt now :)
-- don't eject if 'donteject' is in kernel's command line
-- added 'don't panic' msg to start of log
-
-04/01 - 04/30
-- added text mode (cat /proc/cmdline; if textonly then text mode is on)
-- delete /var/lock/subsys/ * when nuking
-- don't resize mountlist if "noresize" present in /proc/cmdline
-- changed from chmod -R 1777 tmp to chmod 1777 tmp
-- replace newtFinished() and newtInit() with
-  newtSuspend() and newtResume()
-- get_cfg_file_from_archive() returns 1 instead of aborting now
-- read_cfg_file_into_bkpinfo) --- if autorun CD but its config
-  file indicates a non-CD backup media then ask, just in case
-- sped up restore_a_tarball_from_CD() a bit
-- line 4469 --- if post-nuke not found then don't run it :)
-- replaced "/mnt/RESTORING" with MNT_RESTORING (#define'd)
-- moved compare_*() into mondorestore/mondo-rstr-compare.c
-- moved some RAID subroutines into common/libmondo-raid.c
-- fixed some iso live compare problems
-- replaced FILELIST_FULL with g_filelist_full and FILELIST_FULL_STUB;
-  g_filelist_full being the full path of the filelist.full text file and
-  FILELIST_FULL_STUB being "tmp/filelist.full" (relative path);
-- ditto BIGGIELIST_TXT, MONDO_CFG_FILE
-- added lots of assert()'s and log_OS_error()'s
-- in Nuke Mode, check mountlist's sanity before doing anything else;
-  if it fails sanity test, offer to revert to Interactive Mode (or abort)
-- copy log to /mnt/RESTORING/root at end
-- read_cfg_file_into_bkpinfo() --- read iso-dev and isodir if bkptype==iso
-- line 1701 --- delete ramdisk file after extracting config info
-- moved call to make_relevant_partitions_bootable() from
-  within run_boot_loader() to within interactive_mode() and
-  nuke_mode(), after unmounting disks
-- if editing fstab or *.conf, try to use pico if available
-- better calling of make-me-bootable
-- don't sort mountlist anywhere anymore except _locally_ in
-  mount_all_devices() and unmount_all_devices()
-- edit fstab, grub.conf _after_ stabgrub-me if it fails
-- run_boot_loader() --- backup all crucial files to /etc/ *.pristine first
-- added iso_fiddly_bits()
-- fixed ISO mode support
-- mount_cdrom() only searches for device if NOT in disaster recovery mode
-- changed lost of system()'s into run_program_and_log_output()'s
-- don't eject if bkpinfo->please_dont_eject_when_restoring
-- cleaned up post-nuke handling code
-- always eject CD at end, unless bkpinfo->please_dont_...
-- misc clean-up (Tom Mortell)
-- afio uses -c (1024L*1024L)/TAPE_BLOCK_SIZE now
-  instead of -c 1024
-
-01/01 - 03/31/2003
-- commented out sort_... line (BB)
-- clean-up (Stan Benoit)
-- added code for LVM and SW Raid (Brian Borgeson)
-- line 814 - added -p to 'mkdir -p tmp'
-- mount_cdrom() - calls find_cdrom_device() if
-  bkpinfo->media_device is blank (to fill it)
-
-11/01 - 12/31/2002
-- mount_cdrom() better at handling multiple CD drives
-- minor clean-up in restore_a_tarball_from_CD()
-- if --live-from-cd then assume restoring live from CD
-- tweaked it to run better w/ ArkLinux
-- create /mnt/RESTORING/mnt/.boot.d for Gentoo users
-  after restoring
-- cleaned up iso_mode(); no longer asks for NFS info 3 times
-- mount_cdrom() was trying to mount /mnt/isodir/%s/%d.iso;
-  is now just %s/%d.iso
-- mount/unmount /boot if necessary (Gentoo)
-- added RAW MBR support; added run_raw_mbr() for the purpose
-- unmount & remount supermounts at start/end of live restore
-- copy /tmp/mountlist.txt to /tmp/mountlist.txt.orig at start
-- cleaned up string-handling in get_cfg_info_from_archives()
-- fixed run_grub() to call new stabgrub-me script
-- popup list of changed files after Compare Mode
-- permit mondorestore --edit-mountlist even if live mode
-- create a repaired copy of grub-install which is RAID-friendly;
-  use it when initializing boot sector with run_grub()
-- use grub-MR instead of grub-install
-- fixed read_cfg_file_into_bkpinfo() to ignore cfg file's backup_media_type
-  if user has already specified a backup media type interactively
-
-10/01 - 10/31
-- run_grub() will let you specify the boot device as well as edit the system
-  files, if grub-install fails
-- fixed bug in fwrite() call in restore_biggiefile_from_CD()
-- fixed bug affecting restoration of bigfiles from CD's w/0 compression
-- run_grub() will run 'grub-install {boot device}' instead of
-  'grub-install (hd0)'
-
-09/01 - 09/30
-- use /tmp/tmpfs/mondo.tmp instead of /tmp/mondo.tmp
-- initialize MOUNTLIST_FNAME at start of main()
-- differential-related cleanup
-- better handling of CD-ROM drives which aren't /dev/cdrom :)
-- run_program_and_log_output() now takes boolean operator to specify
-  whether it will log its activities in the event of _success_
-- always load config file from archive before operating on it
-- moved some subroutines around; now closer to alphabetical order
-- changed mount.mindi to mount.bootisk
-- mount disks readonly if in Compare Mode
-- set /dev/null's permissions to 777, just in case it somehow gets mangled
-  ...which apparently happen with some devfs-based Linux distributions
-- remove /var/run/ *.pid after restoring
-- move spurious lockfiles from /home/ * to /home/ * /.disabled
-- if Interactive Mode then ask user which media, etc. (i.e. catchall mode
-  is now same as Interactive Mode)
-
-08/01 - 08/30
-- use data structure to store the fname, checksum, mods & perms of each bigfile
-  ... biggiestruct :)
-- if a filelist is tiny (2 bytes or less) then ignore it
-- insist_on_this_cd_number() --- now takes 2 params, not 1
-- re-enabled 'g_current_media_number = 1' in restore_everything()
-- added same to compare_mode()
-- replaced lots of global char[]'s with malloc()'s
-- if differential backup then don't permit formatting or fdisking,
-  whether Interactive or Nuke mode
-- added call to register_pid() at start of main()
-- if Nuke Mode & it succeeds then ask user if they have contributed yet
-- changed tape-size to media-size (config file)
-- changed using_* to backup_media_type
-- changed *_from_tape to *_from_stream
-
-07/01 - 07/31
-- added find_and_mount_actual_cdrom()
-- temp dir is always random
-- skip tarballs if they don't contain files we're looking for
-  (used to read the whole thing & _then_ skip)
-- use media_size[1] instead of media_size[0]
-- fixed serious bug in line 1546 - should have been !=, not ==; stopped
-  mondorestore from correctly restoring big files
-- bigfile piping enhancements (Philippe de Muyter)
-- unmount CD-ROM after restoring from live filesystem
-- TAPE_BLOCK_SIZE treated as %ld, not %d
-
-06/01 - 06/30
-- added signal-trapping
-- disabled 'nr-failed-disks' flag
-- fixed problem w/selective restore
-- don't change /tmp's permissions unless it doesn't exist & must be created
-- fixed bug in --mbr
-- is_file_in_list() enhanced to exclude /mnt/RESTORING or whatever
-- added support for uncompressed archives
-- --monitas-live now accepts path-to-restore_to_, not just path to restore
-- added some debugging/tracking code to the NFS section
-- various monitas-related enhancements
-- added --isonuke and --mbr switches
-- better logging in run_grub()
-- improved --monitas-live
-- mkdir -p /mnt/RESTORING/var/run/console just in case user excludes it
-- afio now uses 16MB buffer instead of 8MB
-- always use bkpinfo->media_size[0], now that -s has been expanded
-- popup and ask where to restore data, if restoring selectively
-
-05/01 - 05/31
-- add '--monitas' flag
-- don't run chmod -R 1777 /mnt/RESTORING/tmp before unmounting unless
-  restoring at the time...
-
-04/01 - 04/30
-- delete old /tmp/filelist.full,biggielist.txt if found when restoring to
-  live filesystem
-- replace MONDO_VERSION #define with VERSION from ../config.h
-- write fname of bigfile to screen when having trouble reading/comparing it
-- if restoring to live filesystem then wipe /tmp/tmpfs/ * afterwards
-- removed spurious finish(0) from main()
-
-03/01 - 03/31/2002
-- if /tmp/m*ndo-restore.cfg not found then assume live restore; restore
-  to / instead of /mnt/RESTORING
-- clean up is_file_in_list() to deal with the /mnt/RESTORING/ prefix
-- exclude leading '/' from filelist.restore-these
-- if /tmp/fstab.new exists then use _it_ instead of /tmp/fstab to label
-  ext2 or ext3 partitions
-- improved logging
-
-[...]
-
-07/10/2001 --- first incarnation
-*/
-
+ * $Id$
+ */
 
 /**
@@ -381 +11 @@
  * #include statements                                                    *
  **************************************************************************/
+#include <unistd.h>
+
 #include "../common/my-stuff.h"
 #include "../common/mondostructures.h"
@@ -443 +75 @@
  * The device to mount to get at the ISO images. Ignored unless @p g_ISO_restore_mode.
  */
-char *g_isodir_device;
+char *g_isodir_device = NULL;
 
 /**
  * The format of @p g_isodir_device. Ignored unless @p g_ISO_restore_mode.
  */
-char *g_isodir_format;
+char *g_isodir_format = NULL;
 
 /**
  * The location of 'biggielist.txt', containing the biggiefiles on the current archive set.
  */
-char *g_biggielist_txt;
+char *g_biggielist_txt = NULL;
 
 /**
@@ -459 +91 @@
  * the current archive set.
  */
-char *g_filelist_full;
+char *g_filelist_full = NULL;
 
 /**
@@ -465 +97 @@
  * as images, not as individual files.
  */
-char *g_filelist_imagedevs;
+char *g_filelist_imagedevs = NULL;
 
 /**
@@ -471 +103 @@
  * @see g_filelist_imagedevs
  */
-char *g_imagedevs_restthese;
+char *g_imagedevs_restthese = NULL;
 
 /**
@@ -477 +109 @@
  * information for this backup.
  */
-char *g_mondo_cfg_file;
+char *g_mondo_cfg_file = NULL;
 
 /**
@@ -483 +115 @@
  * user's partitions and hard drives.
  */
-char *g_mountlist_fname;
+char *g_mountlist_fname = NULL;
 
 /**
@@ -489 +121 @@
  * to avoid link errors.
  */
-char *g_mondo_home;
+char *g_mondo_home = NULL;
 
 /* @} - end of "Restore-Time Globals" in globalGroup */
-
-
 
 extern int copy_from_src_to_dest(FILE * f_orig, FILE * f_archived,
                                  char direction);
-
-
 
 /**************************************************************************
@@ -508 +136 @@
  */
 #define COMPAQ_PROLIANTS_SUCK _("Partition and format your disk using Compaq's disaster recovery CD. After you've done that, please reboot with your Mondo CD/floppy in Interactive Mode.")
-
-
 
 
@@ -561 +187 @@
 
 
-
-
-
 /**
  * Determine whether @p mountlist contains a Compaq diagnostic partition.
@@ -604 +227 @@
     popup_and_OK(COMPAQ_PROLIANTS_SUCK);
     if (ask_me_yes_or_no
-        (_("Would you like to reboot and use your Compaq CD to prep your hard drive?")))
+        (_
+         ("Would you like to reboot and use your Compaq CD to prep your hard drive?")))
     {
-        fatal_error
-            (_("Aborting. Please reboot and prep your hard drive with your Compaq CD."));
+        fatal_error(_
+                    ("Aborting. Please reboot and prep your hard drive with your Compaq CD."));
     }
 }
@@ -614 +238 @@
  *END_OFFER_TO_ABORT_BECAUSE_COMPAQ_PROLIANTS_SUCK                        *
  **************************************************************************/
-
 
 
@@ -637 +260 @@
     assert(mountlist != NULL);
     assert(raidlist != NULL);
-    malloc_string(tmp);
     iamhere("pre wrm");
     c = which_restore_mode();
@@ -644 +266 @@
         interactively_obtain_media_parameters_from_user(bkpinfo, FALSE);
     } else {
-        popup_and_OK(_("No restoring or comparing will take place today."));
+        popup_and_OK(_
+                     ("No restoring or comparing will take place today."));
         if (is_this_device_mounted("/mnt/cdrom")) {
             run_program_and_log_output("umount /mnt/cdrom", FALSE);
         }
         if (g_ISO_restore_mode) {
-            sprintf(tmp, "umount %s", bkpinfo->isodir);
+            asprintf(&tmp, "umount %s", bkpinfo->isodir);
             run_program_and_log_output(tmp, FALSE);
+            paranoid_free(tmp);
         }
         paranoid_MR_finish(0);
@@ -677 +301 @@
         retval += compare_mode(bkpinfo, mountlist, raidlist);
     }
-    paranoid_free(tmp);
     return (retval);
 }
@@ -726 +349 @@
 
 
-
-
 /**
  * @addtogroup restoreGroup
@@ -754 +375 @@
     bool restore_all;
 
-  /** needs malloc **********/
-    char *tmp;
-    char *fstab_fname;
-    char *old_restpath;
-
-    struct s_node *filelist;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *fstab_fname = NULL;
+    char *old_restpath = NULL;
+
+    struct s_node *filelist = NULL;
 
     /* try to partition and format */
@@ -765 +386 @@
     log_msg(2, "interactive_mode --- starting (great, assertions OK)");
 
-    malloc_string(tmp);
-    malloc_string(fstab_fname);
-    malloc_string(old_restpath);
     assert(bkpinfo != NULL);
     assert(mountlist != NULL);
@@ -776 +394 @@
     if (g_text_mode) {
         if (!ask_me_yes_or_no
-            (_("Interactive Mode + textonly = experimental! Proceed anyway?")))
+            (_
+             ("Interactive Mode + textonly = experimental! Proceed anyway?")))
         {
             fatal_error("Wise move.");
@@ -787 +406 @@
     iamhere("Done loading config file; resizing ML");
 #ifdef __FreeBSD__
-    if (strstr
-        (call_program_and_get_last_line_of_output("cat /tmp/cmdline"),
-         "noresize"))
+    tmp = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
 #else
-    if (strstr
-        (call_program_and_get_last_line_of_output("cat /proc/cmdline"),
-         "noresize"))
+    tmp = call_program_and_get_last_line_of_output("cat /proc/cmdline");
 #endif
-    {
+    if (strstr(tmp,"noresize")) {
         log_msg(1, "Not resizing mountlist.");
     } else {
@@ -804 +419 @@
         if (g_text_mode) {
             save_mountlist_to_disk(mountlist, g_mountlist_fname);
-            sprintf(tmp, "%s %s", find_my_editor(), g_mountlist_fname);
+            tmp1 = find_my_editor();
+            asprintf(&tmp, "%s %s", tmp1, g_mountlist_fname);
+            paranoid_free(tmp1);
+
             res = system(tmp);
+            paranoid_free(tmp);
             load_mountlist(mountlist, g_mountlist_fname);
         } else {
@@ -819 +438 @@
         mvaddstr_and_log_it(1, 30, _("Restoring Interactively"));
         if (bkpinfo->differential) {
-            log_to_screen(_("Because this is a differential backup, disk"));
-            log_to_screen
-                (_(" partitioning and formatting will not take place."));
+            log_to_screen(_
+                          ("Because this is a differential backup, disk"));
+            log_to_screen(_
+                          (" partitioning and formatting will not take place."));
             done = TRUE;
         } else {
             if (ask_me_yes_or_no
-                (_("Do you want to erase and partition your hard drives?"))) {
+                (_
+                 ("Do you want to erase and partition your hard drives?")))
+            {
                 if (partition_table_contains_Compaq_diagnostic_partition
                     (mountlist)) {
@@ -836 +458 @@
                     if (ptn_errs) {
                         log_to_screen
-                            (_("Warning. Errors occurred during disk partitioning."));
+                            (_
+                             ("Warning. Errors occurred during disk partitioning."));
                     }
 
-                    fmt_errs = format_everything(mountlist, FALSE, raidlist);
+                    fmt_errs =
+                        format_everything(mountlist, FALSE, raidlist);
                     if (!fmt_errs) {
                         log_to_screen
-                            (_("Errors during disk partitioning were handled OK."));
-                        log_to_screen
-                            (_("Partitions were formatted OK despite those errors."));
+                            (_
+                             ("Errors during disk partitioning were handled OK."));
+                        log_to_screen(_
+                                      ("Partitions were formatted OK despite those errors."));
                         ptn_errs = 0;
                     }
@@ -854 +479 @@
             } else {
                 mvaddstr_and_log_it(g_currentY++, 0,
-                                    _("User opted not to partition the devices"));
+                                    _
+                                    ("User opted not to partition the devices"));
                 if (ask_me_yes_or_no
                     (_("Do you want to format your hard drives?"))) {
-                    fmt_errs = format_everything(mountlist, TRUE, raidlist);
+                    fmt_errs =
+                        format_everything(mountlist, TRUE, raidlist);
                     if (!fmt_errs) {
                         done = TRUE;
@@ -869 +496 @@
                 mvaddstr_and_log_it(g_currentY++,
                                     0,
-                                    _("Errors occurred. Please repartition and format drives manually."));
+                                    _
+                                    ("Errors occurred. Please repartition and format drives manually."));
                 done = FALSE;
             }
@@ -875 +503 @@
                 mvaddstr_and_log_it(g_currentY++,
                                     0,
-                                    _("Errors occurred during partitioning. Formatting, however, went OK."));
+                                    _
+                                    ("Errors occurred during partitioning. Formatting, however, went OK."));
                 done = TRUE;
             }
@@ -881 +510 @@
                 if (!ask_me_yes_or_no(_("Re-edit the mountlist?"))) {
                     retval++;
-                    goto end_of_func;
+                    iamhere("Leaving interactive_mode()");
+                    return (retval);
                 }
             }
@@ -891 +521 @@
         unmount_all_devices(mountlist);
         retval++;
-        goto end_of_func;
+        iamhere("Leaving interactive_mode()");
+        return (retval);
     }
     /* restore */
     if ((restore_all =
-         ask_me_yes_or_no(_("Do you want me to restore all of your data?"))))
+         ask_me_yes_or_no(_
+                          ("Do you want me to restore all of your data?"))))
     {
         log_msg(1, "Restoring all data");
         retval += restore_everything(bkpinfo, NULL);
-    } else
-        if ((restore_all =
+    } else if ((restore_all =
              ask_me_yes_or_no
              (_("Do you want me to restore _some_ of your data?")))) {
-        strcpy(old_restpath, bkpinfo->restore_path);
+        old_restpath = bkpinfo->restore_path;
         for (done = FALSE; !done;) {
             unlink("/tmp/filelist.full");
@@ -912 +543 @@
             if (filelist) {
               gotos_suck:
-                strcpy(tmp, old_restpath);
 // (NB: %s is where your filesystem is mounted now, by default)", MNT_RESTORING);
                 if (popup_and_get_string
-                    (_("Restore path"), _("Restore files to where?"), tmp,
-                     MAX_STR_LEN / 4)) {
-                    if (!strcmp(tmp, "/")) {
+                    (_("Restore path"), _("Restore files to where?"), bkpinfo->restore_path)) {
+                    if (!strcmp(bkpinfo->restore_path, "/")) {
                         if (!ask_me_yes_or_no(_("Are you sure?"))) {
+                            paranoid_free(bkpinfo->restore_path);
+                            bkpinfo->restore_path = old_restpath;
                             goto gotos_suck;
                         }
-                        tmp[0] = '\0';  // so we restore to [blank]/file/name :)
+                        paranoid_alloc(bkpinfo->restore_path, "");  // so we restore to [blank]/file/name :)
                     }
-                    strcpy(bkpinfo->restore_path, tmp);
                     log_msg(1, "Restoring subset");
                     retval += restore_everything(bkpinfo, filelist);
                     free_filelist(filelist);
                 } else {
-                    strcpy(bkpinfo->restore_path, old_restpath);
+                    bkpinfo->restore_path = old_restpath;
                     free_filelist(filelist);
                 }
@@ -939 +569 @@
             }
         }
-        strcpy(old_restpath, bkpinfo->restore_path);
     } else {
         mvaddstr_and_log_it(g_currentY++,
                             0,
-                            _("User opted not to restore any data.                                  "));
+                            _
+                            ("User opted not to restore any data.                                  "));
     }
     if (retval) {
         mvaddstr_and_log_it(g_currentY++,
                             0,
-                            _("Errors occurred during the restore phase.            "));
+                            _
+                            ("Errors occurred during the restore phase.            "));
     }
 
@@ -956 +587 @@
         mvaddstr_and_log_it(g_currentY++,
                             0,
-                            _("User opted not to initialize the boot loader."));
+                            _
+                            ("User opted not to initialize the boot loader."));
     }
 
 //  run_program_and_log_output("cp -af /etc/lvm " MNT_RESTORING "/etc/", 1);
     protect_against_braindead_sysadmins();
-    //  modify_rclocal_one_time( MNT_RESTORING "/etc" );
     retval += unmount_all_devices(mountlist);
     /*  if (restore_some || restore_all || */
@@ -967 +598 @@
         (_("Label your ext2 and ext3 partitions if necessary?"))) {
         mvaddstr_and_log_it(g_currentY, 0,
-                            _("Using e2label to label your ext2,3 partitions"));
+                            _
+                            ("Using e2label to label your ext2,3 partitions"));
         if (does_file_exist("/tmp/fstab.new")) {
-            strcpy(fstab_fname, "/tmp/fstab.new");
+            asprintf(&fstab_fname, "/tmp/fstab.new");
         } else {
-            strcpy(fstab_fname, "/tmp/fstab");
-        }
-        sprintf(tmp,
+            asprintf(&fstab_fname, "/tmp/fstab");
+        }
+        asprintf(&tmp,
                 "label-partitions-as-necessary %s < %s >> %s 2>> %s",
                 g_mountlist_fname, fstab_fname, MONDO_LOGFILE,
                 MONDO_LOGFILE);
+        paranoid_free(fstab_fname);
+
         res = system(tmp);
+        paranoid_free(tmp);
         if (res) {
             log_to_screen
@@ -992 +627 @@
         mvaddstr_and_log_it(g_currentY++,
                             0,
-                            _("Warning - errors occurred during the restore phase."));
-    }
-  end_of_func:
-    paranoid_free(tmp);
-    paranoid_free(fstab_fname);
-    paranoid_free(old_restpath);
-    iamhere("Leaving interactive_mode()");
-    return (retval);
+                            _
+                            ("Warning - errors occurred during the restore phase."));
+    }
 }
 
@@ -1005 +635 @@
  *END_INTERACTIVE_MODE                                                    *
  **************************************************************************/
-
 
 
@@ -1054 +683 @@
     if (system("umount /tmp/isodir 2> /dev/null")) {
         log_to_screen
-            (_("WARNING - unable to unmount device where the ISO files are stored."));
+            (_
+             ("WARNING - unable to unmount device where the ISO files are stored."));
     }
 //    }
@@ -1065 +695 @@
 
 
-/*            MONDO - saving your a$$ since Feb 18th, 2000            */
-
-
+static void call_me_after_the_nuke(int retval) {
+
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+
+    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."));
+    } else {
+#ifdef __FreeBSD__
+        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");
+#endif
+        if ((strstr(tmp1,"restore") == NULL) ||
+            (strstr(tmp1,"RESTORE") == NULL)) {
+                /* -H option */
+                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);
+                paranoid_free(tmp);
+        }
+        paranoid_free(tmp1);
+
+        log_to_screen(_
+             ("Mondo has restored your system. Please remove the backup media and reboot."));
+        log_to_screen(_
+             ("Thank you for using Mondo Rescue."));
+        log_to_screen(_
+             ("Please visit our website at http://www.mondorescue.org for more information."));
+    }
+    g_I_have_just_nuked = TRUE;
+    return;
+}
 
 
@@ -1087 +749 @@
     int res = 0;
     bool boot_loader_installed = FALSE;
-  /** malloc **/
-    char tmp[MAX_STR_LEN], tmpA[MAX_STR_LEN], tmpB[MAX_STR_LEN],
-        tmpC[MAX_STR_LEN];
+    char *tmp = NULL;
+    char tmpA[MAX_STR_LEN];
+    char tmpB[MAX_STR_LEN];
+    char tmpC[MAX_STR_LEN];
 
     assert(bkpinfo != NULL);
@@ -1100 +763 @@
     load_mountlist(mountlist, g_mountlist_fname);   // in case read_cfg_file_into_bkpinfo updated the mountlist
 #ifdef __FreeBSD__
-    if (strstr
-        (call_program_and_get_last_line_of_output("cat /tmp/cmdline"),
-         "noresize"))
+    tmp = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
 #else
-    if (strstr
-        (call_program_and_get_last_line_of_output("cat /proc/cmdline"),
-         "noresize"))
+    tmp = call_program_and_get_last_line_of_output("cat /proc/cmdline");
 #endif
-    {
+    if (strstr(tmp,"noresize")) {
         log_msg(2, "Not resizing mountlist.");
     } else {
         resize_mountlist_proportionately_to_suit_new_drives(mountlist);
     }
+    paranoid_free(tmp);
+
     if (!evaluate_mountlist(mountlist, tmpA, tmpB, tmpC)) {
-        sprintf(tmp,
-                _("Mountlist analyzed. Result: \"%s %s %s\" Switch to Interactive Mode?"),
+        asprintf(&tmp,
+                _
+                ("Mountlist analyzed. Result: \"%s %s %s\" Switch to Interactive Mode?"),
                 tmpA, tmpB, tmpC);
         if (ask_me_yes_or_no(tmp)) {
+            paranoid_free(tmp);
             retval = interactive_mode(bkpinfo, mountlist, raidlist);
             finish(retval);
         } else {
+            paranoid_free(tmp);
             fatal_error("Nuke Mode aborted. ");
         }
@@ -1128 +792 @@
     if (bkpinfo->differential) {
         log_to_screen(_("Because this is a differential backup, disk"));
-        log_to_screen(_("partitioning and formatting will not take place."));
+        log_to_screen(_
+                      ("partitioning and formatting will not take place."));
         res = 0;
     } else {
@@ -1138 +803 @@
             g_fprep = fopen("/tmp/prep.sh", "w");
 #ifdef __FreeBSD__
-            if (strstr
-                (call_program_and_get_last_line_of_output
-                 ("cat /tmp/cmdline"), "nopart"))
+            tmp = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
 #else
-            if (strstr
-                (call_program_and_get_last_line_of_output
-                 ("cat /proc/cmdline"), "nopart"))
+            tmp = call_program_and_get_last_line_of_output("cat /proc/cmdline");
 #endif
-            {
+            if (strstr(tmp,,"nopart")) {
                 log_msg(2,
                         "Not partitioning drives due to 'nopart' option.");
@@ -1154 +815 @@
                 if (res) {
                     log_to_screen
-                        (_("Warning. Errors occurred during partitioning."));
+                        (_
+                         ("Warning. Errors occurred during partitioning."));
                     res = 0;
                 }
             }
+            paranoid_free(tmp);
+
             retval += res;
             if (!res) {
                 log_to_screen(_("Preparing to format your disk(s)"));
                 sleep(1);
-                system("sync");
-                log_to_screen(_("Please wait. This may take a few minutes."));
+                sync();
+                log_to_screen(_
+                              ("Please wait. This may take a few minutes."));
                 res += format_everything(mountlist, FALSE, raidlist);
             }
@@ -1173 +838 @@
         mvaddstr_and_log_it(g_currentY++,
                             0,
-                            _("Failed to partition and/or format your hard drives."));
+                            _
+                            ("Failed to partition and/or format your hard drives."));
 
         if (ask_me_yes_or_no(_("Try in interactive mode instead?"))) {
             retval = interactive_mode(bkpinfo, mountlist, raidlist);
-            goto after_the_nuke;
+            call_me_after_the_nuke(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);
@@ -1188 +854 @@
         unmount_all_devices(mountlist);
         log_to_screen
-            (_("Unable to mount all partitions. Sorry, I cannot proceed."));
+            (_
+             ("Unable to mount all partitions. Sorry, I cannot proceed."));
         return (retval);
     }
@@ -1200 +867 @@
     protect_against_braindead_sysadmins();
 //  run_program_and_log_output("cp -af /etc/lvm " MNT_RESTORING "/etc/", 1);
-    //  modify_rclocal_one_time( MNT_RESTORING "/etc" );
     retval += unmount_all_devices(mountlist);
     mvaddstr_and_log_it(g_currentY,
                         0,
-                        _("Using e2label to label your ext2,3 partitions"));
-
-    sprintf(tmp, "label-partitions-as-necessary %s < /tmp/fstab",
+                        _
+                        ("Using e2label to label your ext2,3 partitions"));
+
+    asprintf(&tmp, "label-partitions-as-necessary %s < /tmp/fstab",
             g_mountlist_fname);
     res = run_program_and_log_output(tmp, TRUE);
+    paranoid_free(tmp);
+
     if (res) {
-        log_to_screen(_("label-partitions-as-necessary returned an error"));
+        log_to_screen(_
+                      ("label-partitions-as-necessary returned an error"));
         mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
     } else {
@@ -1216 +886 @@
     }
     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. Please 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 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");
-    }
-*/
-    return (retval);
+    call_me_after_the_nuke(retval);
+    return(retval);
 }
-
 /**************************************************************************
  *END_NUKE_MODE                                                           *
  **************************************************************************/
-
 
 
@@ -1263 +904 @@
     int retval = 0;
 
-  /** malloc **/
-    char *old_restpath;
-
-    struct mountlist_itself *mountlist;
-//  static
-    struct raidlist_itself *raidlist;
-    struct s_node *filelist;
+    char *old_restpath = NULL;
+
+    struct mountlist_itself *mountlist = NULL;
+    struct raidlist_itself *raidlist = NULL;
+    struct s_node *filelist = NULL;
 
     log_msg(1, "restore_to_live_filesystem() - starting");
     assert(bkpinfo != NULL);
-    malloc_string(old_restpath);
+
     mountlist = malloc(sizeof(struct mountlist_itself));
     raidlist = malloc(sizeof(struct raidlist_itself));
+
     if (!mountlist || !raidlist) {
         fatal_error("Cannot malloc() mountlist and/or raidlist");
     }
 
-    strcpy(bkpinfo->restore_path, "/");
+    paranoid_alloc(bkpinfo->restore_path, "/");
     if (!g_restoring_live_from_cd) {
         popup_and_OK
-            (_("Please insert tape/CD/boot floppy, then hit 'OK' to continue."));
+            (_
+             ("Please insert tape/CD/boot floppy, then hit 'OK' to continue."));
         sleep(1);
     }
@@ -1308 +949 @@
     if (filelist) {
         save_filelist(filelist, "/tmp/selected-files.txt");
-        strcpy(old_restpath, bkpinfo->restore_path);
+        old_restpath = bkpinfo->restore_path;
         if (popup_and_get_string(_("Restore path"),
                                  _("Restore files to where? )"),
-                                 bkpinfo->restore_path, MAX_STR_LEN / 4)) {
+                                 bkpinfo->restore_path)) {
             iamhere("Restoring everything");
             retval += restore_everything(bkpinfo, filelist);
-            free_filelist(filelist);
-            strcpy(bkpinfo->restore_path, old_restpath);
-        } else {
-            free_filelist(filelist);
-        }
-        strcpy(bkpinfo->restore_path, old_restpath);
+        }
+        free_filelist(filelist);
+        bkpinfo->restore_path = old_restpath;
     }
     if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
@@ -1329 +967 @@
         eject_device(bkpinfo->media_device);
     }
-    paranoid_free(old_restpath);
     free(mountlist);
     free(raidlist);
@@ -1358 +995 @@
  * @return 0 for success (or skip), nonzero for failure.
  */
-int
+char *
 restore_a_biggiefile_from_CD(struct s_bkpinfo *bkpinfo,
                              long bigfileno,
-                             struct s_node *filelist,
-                             char *pathname_of_last_file_restored)
+                             struct s_node *filelist)
 {
-    FILE *fin;
-    FILE *fout;
-    FILE *fbzip2;
-
-  /** malloc ***/
-    char *checksum, *outfile_fname, *tmp, *bzip2_command,
-        *ntfsprog_command, *suffix, *sz_devfile;
-    char *bigblk;
-    char *p;
+    FILE *fin = NULL;
+    FILE *fout = NULL;
+    FILE *fbzip2 = NULL;
+    char *checksum = NULL;
+    char *outfile_fname = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *tmp2 = NULL;
+    char *tmp3 = NULL;
+    char *bzip2_command = NULL;
+    char *bigblk = NULL;
+    char *pathname_of_last_file_restored = NULL;
     int retval = 0;
     int finished = FALSE;
     long sliceno;
     long siz;
-    char ntfsprog_fifo[MAX_STR_LEN];
+    long siz1;
+    char *ntfsprog_fifo = NULL;
     char *file_to_openout = NULL;
     struct s_filename_and_lstat_info biggiestruct;
-    struct utimbuf the_utime_buf, *ubuf;
+    struct utimbuf the_utime_buf, *ubuf = NULL;
     bool use_ntfsprog_hack = FALSE;
     pid_t pid;
     int res = 0;
     int old_loglevel;
-    char sz_msg[MAX_STR_LEN];
-    struct s_node *node;
+    char *sz_msg;
+    struct s_node *node = NULL;
 
     old_loglevel = g_loglevel;
@@ -1392 +1032 @@
     assert(bkpinfo != NULL);
 
-    malloc_string(checksum);
-    malloc_string(outfile_fname);
-    malloc_string(tmp);
-    malloc_string(bzip2_command);
-    malloc_string(ntfsprog_command);
-    malloc_string(suffix);
-    malloc_string(sz_devfile);
-
-    pathname_of_last_file_restored[0] = '\0';
     if (!(bigblk = malloc(TAPE_BLOCK_SIZE))) {
         fatal_error("Cannot malloc bigblk");
     }
 
-    if (!(fin = fopen(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""), "r"))) {
+    tmp = slice_fname(bigfileno, 0, ARCHIVES_PATH, "");
+    if (!(fin = fopen(tmp,"r"))) {
         log_to_screen(_("Cannot even open bigfile's info file"));
-        return (1);
-    }
+        paranoid_free(tmp);
+        return (pathname_of_last_file_restored);
+    }
+    paranoid_free(tmp);
 
     memset((void *) &biggiestruct, 0, sizeof(biggiestruct));
@@ -1418 +1052 @@
     paranoid_fclose(fin);
 
-    strcpy(checksum, biggiestruct.checksum);
+    asprintf(&checksum, biggiestruct.checksum);
 
     if (!checksum[0]) {
-        sprintf(tmp, "Warning - bigfile %ld does not have a checksum",
+        asprintf(&tmp, "Warning - bigfile %ld does not have a checksum",
                 bigfileno + 1);
         log_msg(3, tmp);
+        paranoid_free(tmp);
+        /* BERLIOS : Useless ???
         p = checksum;
-    }
+        */
+    }
+    paranoid_free(checksum);
 
     if (!strncmp(biggiestruct.filename, "/dev/", 5))    // Whether NTFS or not :)
     {
-        strcpy(outfile_fname, biggiestruct.filename);
+        asprintf(&outfile_fname, biggiestruct.filename);
     } else {
-        sprintf(outfile_fname, "%s/%s", bkpinfo->restore_path,
+        asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
                 biggiestruct.filename);
     }
@@ -1441 +1079 @@
             log_msg(0, "Skipping %s (name isn't in filelist)",
                     biggiestruct.filename);
-            pathname_of_last_file_restored[0] = '\0';
-            return (0);
+            return (pathname_of_last_file_restored);
         } else if (!(node->selected)) {
             log_msg(1, "Skipping %s (name isn't in biggielist subset)",
                     biggiestruct.filename);
-            pathname_of_last_file_restored[0] = '\0';
-            return (0);
+            return (pathname_of_last_file_restored);
         }
     }
@@ -1470 +1106 @@
                 "Calling ntfsclone in background because %s is an NTFS /dev entry",
                 outfile_fname);
-        sprintf(sz_devfile, "/tmp/%d.%d.000", (int) (random() % 32768),
+        asprintf(&ntfsprog_fifo, "/tmp/%d.%d.000", (int) (random() % 32768),
                 (int) (random() % 32768));
-        mkfifo(sz_devfile, 0x770);
-        strcpy(ntfsprog_fifo, sz_devfile);
+        mkfifo(ntfsprog_fifo, 0x770);
+
         file_to_openout = ntfsprog_fifo;
         switch (pid = fork()) {
@@ -1484 +1120 @@
             res =
                 feed_outfrom_ntfsprog(biggiestruct.filename,
-                                       ntfsprog_fifo);
+                                      ntfsprog_fifo);
 //          log_msg(3, "CHILD - fip - exiting");
             exit(res);
@@ -1493 +1129 @@
                     (long int) (pid));
         }
+        // BERLIOS: Is it the right place ??
+        paranoid_free(ntfsprog_fifo);
     } else {
         use_ntfsprog_hack = FALSE;
-        ntfsprog_fifo[0] = '\0';
         file_to_openout = outfile_fname;
         if (!does_file_exist(outfile_fname))    // yes, it looks weird with the '!' but it's correct that way
@@ -1503 +1140 @@
     }
 
-    sprintf(tmp, "Reassembling big file %ld (%s)", bigfileno + 1,
+    asprintf(&tmp, "Reassembling big file %ld (%s)", bigfileno + 1,
             outfile_fname);
     log_msg(2, tmp);
+    paranoid_free(tmp);
 
     /*
@@ -1513 +1151 @@
      */
 
-    strncpy(pathname_of_last_file_restored, biggiestruct.filename,
-            MAX_STR_LEN - 1);
-    pathname_of_last_file_restored[MAX_STR_LEN - 1] = '\0';
+    asprintf(&pathname_of_last_file_restored, biggiestruct.filename);
 
     log_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?"));
-        return (1);
+        return (pathname_of_last_file_restored);
     }
     log_msg(3, "Opened out to %s", outfile_fname);  // CD/DVD --> mondorestore --> ntfsclone --> hard disk itself
 
     for (sliceno = 1, finished = FALSE; !finished;) {
-        if (!does_file_exist
-            (slice_fname(bigfileno, sliceno, ARCHIVES_PATH, ""))
-            &&
-            !does_file_exist(slice_fname
-                             (bigfileno, sliceno, ARCHIVES_PATH, "lzo"))
-            &&
-            !does_file_exist(slice_fname
-                             (bigfileno, sliceno, ARCHIVES_PATH, "bz2"))) {
+        tmp = slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "");
+        tmp1 = slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "lzo");
+        tmp2 = slice_fname(bigfileno, sliceno, ARCHIVES_PATH, "bz2");
+        if (!does_file_exist(tmp) && !does_file_exist(tmp1) &&
+            !does_file_exist(tmp2)) {
             log_msg(3,
                     "Cannot find a data slice or terminator slice on CD %d",
                     g_current_media_number);
             g_current_media_number++;
-            sprintf(tmp,
+            asprintf(&tmp3,
                     "Asking for %s #%d so that I may read slice #%ld\n",
                     media_descriptor_string(bkpinfo->backup_media_type),
                     g_current_media_number, sliceno);
-            log_msg(2, tmp);
-            sprintf(tmp, _("Restoring from %s #%d"),
+            log_msg(2, tmp3);
+            paranoid_free(tmp3);
+
+            asprintf(&tmp3, _("Restoring from %s #%d"),
                     media_descriptor_string(bkpinfo->backup_media_type),
                     g_current_media_number);
-            log_to_screen(tmp);
+            log_to_screen(tmp3);
+            paranoid_free(tmp3);
+
             insist_on_this_cd_number(bkpinfo, g_current_media_number);
             log_to_screen(_("Continuing to restore."));
         } else {
-            strcpy(tmp,
-                   slice_fname(bigfileno, sliceno, ARCHIVES_PATH, ""));
             if (does_file_exist(tmp) && length_of_file(tmp) == 0) {
                 log_msg(2,
@@ -1558 +1193 @@
                 continue;
             } else {
-                if (does_file_exist
-                    (slice_fname
-                     (bigfileno, sliceno, ARCHIVES_PATH, "lzo"))) {
-                    strcpy(bzip2_command, "lzop");
-                    strcpy(suffix, "lzo");
-                } else
-                    if (does_file_exist
-                        (slice_fname
-                         (bigfileno, sliceno, ARCHIVES_PATH, "bz2"))) {
-                    strcpy(bzip2_command, "bzip2");
-                    strcpy(suffix, "bz2");
-                } else
-                    if (does_file_exist
-                        (slice_fname
-                         (bigfileno, sliceno, ARCHIVES_PATH, ""))) {
-                    strcpy(bzip2_command, "");
-                    strcpy(suffix, "");
+                if (does_file_exist(tmp1)) {
+                    asprintf(&bzip2_command, "lzop -dc %s 2>> %s",tmp1, MONDO_LOGFILE);
+                } else if (does_file_exist(tmp2)) {
+                        asprintf(&bzip2_command, "bzip2 -dc %s 2>> %s",tmp2, MONDO_LOGFILE);
+                } else if (does_file_exist(tmp)) {
+                        asprintf(&bzip2_command, "");
                 } else {
                     log_to_screen(_("OK, that's pretty fsck0red..."));
-                    return (1);
+                    return (pathname_of_last_file_restored);
                 }
             }
-            if (bzip2_command[0] != '\0') {
-                sprintf(bzip2_command + strlen(bzip2_command),
-                        " -dc %s 2>> %s",
-                        slice_fname(bigfileno, sliceno, ARCHIVES_PATH,
-                                    suffix), MONDO_LOGFILE);
-            } else {
-                sprintf(bzip2_command, "cat %s 2>> %s",
-                        slice_fname(bigfileno, sliceno, ARCHIVES_PATH,
-                                    suffix), MONDO_LOGFILE);
-            }
-            sprintf(tmp, "Working on %s #%d, file #%ld, slice #%ld    ",
+
+            if (bzip2_command == NULL) {
+                asprintf(&bzip2_command, "cat %s 2>> %s", tmp, MONDO_LOGFILE);
+            }
+            asprintf(&tmp3, "Working on %s #%d, file #%ld, slice #%ld ",
                     media_descriptor_string(bkpinfo->backup_media_type),
                     g_current_media_number, bigfileno + 1, sliceno);
-            log_msg(2, tmp);
-
+            log_msg(2, tmp3);
             if (!g_text_mode) {
-                newtDrawRootText(0, g_noof_rows - 2, tmp);
+                newtDrawRootText(0, g_noof_rows - 2, tmp3);
                 newtRefresh();
-                strip_spaces(tmp);
-                update_progress_form(tmp);
-            }
+                update_progress_form(tmp3);
+            }
+            paranoid_free(tmp3);
+
             if (!(fbzip2 = popen(bzip2_command, "r"))) {
                 fatal_error("Can't run popen command");
             }
+            paranoid_free(bzip2_command);
+
             while (!feof(fbzip2)) {
                 siz = fread(bigblk, 1, TAPE_BLOCK_SIZE, fbzip2);
                 if (siz > 0) {
-                    sprintf(sz_msg, "Read %ld from fbzip2", siz);
-                    siz = fwrite(bigblk, 1, siz, fout);
-                    sprintf(sz_msg + strlen(sz_msg),
-                            "; written %ld to fout", siz);
-//        log_msg(2. sz_msg);
+                    siz1 = fwrite(bigblk, 1, siz, fout);
+                    asprintf(&sz_msg, "Read %ld from fbzip2; written %ld to fout", siz, siz1);
+                    log_it(sz_msg);
+                    paranoid_free(sz_msg);
                 }
             }
@@ -1620 +1239 @@
             g_current_progress++;
         }
-    }
-/*
-  memset(bigblk, TAPE_BLOCK_SIZE, 1); // This all looks very fishy...
-  fwrite( bigblk, 1, TAPE_BLOCK_SIZE, fout);
-  fwrite( bigblk, 1, TAPE_BLOCK_SIZE, fout);
-  fwrite( bigblk, 1, TAPE_BLOCK_SIZE, fout);
-  fwrite( bigblk, 1, TAPE_BLOCK_SIZE, fout);
-*/
+        paranoid_free(tmp);
+        paranoid_free(tmp1);
+        paranoid_free(tmp2);
+    }
     paranoid_fclose(fout);
     g_loglevel = old_loglevel;
@@ -1633 +1248 @@
     if (use_ntfsprog_hack) {
         log_msg(3, "Waiting for ntfsclone to finish");
-        sprintf(tmp,
+        asprintf(&tmp,
                 " ps | grep \" ntfsclone \" | grep -v grep > /dev/null 2> /dev/null");
         while (system(tmp) == 0) {
             sleep(1);
         }
+        paranoid_free(tmp);
         log_it("OK, ntfsclone has really finished");
     }
@@ -1649 +1265 @@
         utime(outfile_fname, ubuf);
     }
+    paranoid_free(outfile_fname);
     paranoid_free(bigblk);
-    paranoid_free(checksum);
-    paranoid_free(outfile_fname);
-    paranoid_free(tmp);
-    paranoid_free(bzip2_command);
-    paranoid_free(ntfsprog_command);
-    paranoid_free(suffix);
-    paranoid_free(sz_devfile);
-
-    return (retval);
+
+    return (pathname_of_last_file_restored);
 }
+
 
 /**************************************************************************
  *END_ RESTORE_A_BIGGIEFILE_FROM_CD                                       *
  **************************************************************************/
-
 
 
@@ -1674 +1284 @@
  * @param orig_bf_fname The original filename of the biggiefile.
  * @param biggiefile_number The number of the biggiefile (starting from 0).
- * @param orig_checksum Unused.
- * @param biggiefile_size Unused.
  * @param filelist The node structure containing the list of files to be restored.
  * If @p orig_bf_fname is not in the list, it will be ignored.
  * @return 0 for success (or skip), nonzero for failure.
- * @bug orig_checksum and biggiefile_size are unused (except to check that they are non-NULL).
- */
-int restore_a_biggiefile_from_stream(struct s_bkpinfo *bkpinfo, char *orig_bf_fname, long biggiefile_number, char *orig_checksum,   //UNUSED
-                                     long long biggiefile_size, //UNUSED
+ */
+char *restore_a_biggiefile_from_stream(struct s_bkpinfo *bkpinfo, char *orig_bf_fname, long biggiefile_number,
                                      struct s_node *filelist,
-                                     int use_ntfsprog,
-                                     char *pathname_of_last_file_restored)
+                                     int use_ntfsprog)
 {
     FILE *pout;
@@ -1691 +1296 @@
 
   /** mallocs ********/
-    char *tmp;
-    char *command;
-    char *outfile_fname;
-    char *ntfsprog_command;
-    char *sz_devfile;
-    char *ntfsprog_fifo;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *command = NULL;
+    char *outfile_fname = NULL;
+    char *ntfsprog_command = NULL;
+    char *ntfsprog_fifo = NULL;
     char *file_to_openout = NULL;
+    char *pathname_of_last_file_restored = NULL;
 
     struct s_node *node;
@@ -1714 +1320 @@
     ubuf = &the_utime_buf;
 
-    malloc_string(tmp);
-    malloc_string(ntfsprog_fifo);
-    malloc_string(outfile_fname);
-    malloc_string(command);
-    malloc_string(sz_devfile);
-    malloc_string(ntfsprog_command);
     old_loglevel = g_loglevel;
     assert(bkpinfo != NULL);
     assert(orig_bf_fname != NULL);
-    assert(orig_checksum != NULL);
-
-    pathname_of_last_file_restored[0] = '\0';
+
     if (use_ntfsprog == BLK_START_A_PIHBIGGIE) {
         use_ntfsprog = 1;
@@ -1737 +1335 @@
     }
 
-    strncpy(pathname_of_last_file_restored, orig_bf_fname,
-            MAX_STR_LEN - 1);
-    pathname_of_last_file_restored[MAX_STR_LEN - 1] = '\0';
+    asprintf(&pathname_of_last_file_restored, orig_bf_fname);
 
     /* open out to biggiefile to be restored (or /dev/null if biggiefile is not to be restored) */
@@ -1750 +1346 @@
                     "Skipping big file %ld (%s) - not in biggielist subset",
                     biggiefile_number + 1, orig_bf_fname);
-            pathname_of_last_file_restored[0] = '\0';
+            pathname_of_last_file_restored = NULL;
         } else if (!(node->selected)) {
             dummy_restore = TRUE;
             log_msg(1, "Skipping %s (name isn't in biggielist subset)",
                     orig_bf_fname);
-            pathname_of_last_file_restored[0] = '\0';
+            pathname_of_last_file_restored = NULL;
         }
     }
@@ -1761 +1357 @@
     if (use_ntfsprog) {
         if (strncmp(orig_bf_fname, "/dev/", 5)) {
-            log_msg(1,
-                    "I was in error when I set use_ntfsprog to TRUE.");
+            log_msg(1, "I was in error when I set use_ntfsprog to TRUE.");
             log_msg(1, "%s isn't even in /dev", orig_bf_fname);
             use_ntfsprog = FALSE;
@@ -1770 +1365 @@
     if (use_ntfsprog) {
         g_loglevel = 4;
-        strcpy(outfile_fname, orig_bf_fname);
+        asprintf(&outfile_fname, orig_bf_fname);
         use_ntfsprog_hack = TRUE;
         log_msg(2,
                 "Calling ntfsclone in background because %s is a /dev entry",
                 outfile_fname);
-        sprintf(sz_devfile, "/tmp/%d.%d.000", (int) (random() % 32768),
+        asprintf(&ntfsprog_fifo, "/tmp/%d.%d.000", (int) (random() % 32768),
                 (int) (random() % 32768));
-        mkfifo(sz_devfile, 0x770);
-        strcpy(ntfsprog_fifo, sz_devfile);
+        mkfifo(ntfsprog_fifo, 0x770);
+
         file_to_openout = ntfsprog_fifo;
         switch (pid = fork()) {
@@ -1787 +1382 @@
                     "CHILD - fip - calling feed_outfrom_ntfsprog(%s, %s)",
                     outfile_fname, ntfsprog_fifo);
-            res =
-                feed_outfrom_ntfsprog(outfile_fname, ntfsprog_fifo);
+            res = feed_outfrom_ntfsprog(outfile_fname, ntfsprog_fifo);
 //          log_msg(3, "CHILD - fip - exiting");
             exit(res);
@@ -1797 +1391 @@
                     (long int) (pid));
         }
+        paranoid_free(ntfsprog_fifo);
     } else {
         if (!strncmp(orig_bf_fname, "/dev/", 5))    // non-NTFS partition
         {
-            strcpy(outfile_fname, orig_bf_fname);
+            asprintf(&outfile_fname, orig_bf_fname);
         } else                  // biggiefile
         {
-            sprintf(outfile_fname, "%s/%s", bkpinfo->restore_path,
+            asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
                     orig_bf_fname);
         }
         use_ntfsprog_hack = FALSE;
-        ntfsprog_fifo[0] = '\0';
         file_to_openout = outfile_fname;
         if (!does_file_exist(outfile_fname))    // yes, it looks weird with the '!' but it's correct that way
@@ -1813 +1407 @@
             make_hole_for_file(outfile_fname);
         }
-        sprintf(tmp, "Reassembling big file %ld (%s)",
+        asprintf(&tmp1, "Reassembling big file %ld (%s)",
                 biggiefile_number + 1, orig_bf_fname);
-        log_msg(2, tmp);
+        log_msg(2, tmp1);
+        paranoid_free(tmp1);
     }
 
     if (dummy_restore) {
-        sprintf(outfile_fname, "/dev/null");
+        paranoid_free(outfile_fname);
+        asprintf(&outfile_fname, "/dev/null");
     }
 
     if (!bkpinfo->zip_exe[0]) {
-        sprintf(command, "cat > \"%s\"", file_to_openout);
+        asprintf(&command, "cat > \"%s\"", file_to_openout);
     } else {
-        sprintf(command, "%s -dc > \"%s\" 2>> %s", bkpinfo->zip_exe,
+        asprintf(&command, "%s -dc > \"%s\" 2>> %s", bkpinfo->zip_exe,
                 file_to_openout, MONDO_LOGFILE);
     }
-    sprintf(tmp, "Pipe command = '%s'", command);
-    log_msg(3, tmp);
+    asprintf(&tmp1, "Pipe command = '%s'", command);
+    log_msg(3, tmp1);
+    paranoid_free(tmp1);
 
     /* restore biggiefile, one slice at a time */
@@ -1835 +1432 @@
         fatal_error("Cannot pipe out");
     }
+    paranoid_free(command);
+
     for (res = read_header_block_from_stream(&slice_siz, tmp, &ctrl_chr);
          ctrl_chr != BLK_STOP_A_BIGGIE;
@@ -1841 +1440 @@
             wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
         }
-        sprintf(tmp, "Working on file #%ld, slice #%ld    ",
+        asprintf(&tmp1, "Working on file #%ld, slice #%ld    ",
                 biggiefile_number + 1, current_slice_number);
-        log_msg(2, tmp);
+        log_msg(2, tmp1);
+
         if (!g_text_mode) {
-            newtDrawRootText(0, g_noof_rows - 2, tmp);
+            newtDrawRootText(0, g_noof_rows - 2, tmp1);
             newtRefresh();
         }
-        strip_spaces(tmp);
-        update_progress_form(tmp);
+        strip_spaces(tmp1);
+        update_progress_form(tmp1);
+        paranoid_free(tmp1);
+
         if (current_slice_number == 0) {
             res =
@@ -1879 +1481 @@
         g_current_progress++;
     }
+    paranoid_free(tmp);
     paranoid_pclose(pout);
 
@@ -1886 +1489 @@
     if (use_ntfsprog_hack) {
         log_msg(3, "Waiting for ntfsclone to finish");
-        sprintf(tmp,
+        asprintf(&tmp,
                 " ps | grep \" ntfsclone \" | grep -v grep > /dev/null 2> /dev/null");
         while (system(tmp) == 0) {
             sleep(1);
-        }
+        }   
+        paranoid_free(tmp);
         log_msg(3, "OK, ntfsclone has really finished");
     }
@@ -1905 +1509 @@
     }
 
-    paranoid_free(tmp);
     paranoid_free(outfile_fname);
-    paranoid_free(command);
-    paranoid_free(ntfsprog_command);
-    paranoid_free(sz_devfile);
-    paranoid_free(ntfsprog_fifo);
     g_loglevel = old_loglevel;
-    return (retval);
+    return (pathname_of_last_file_restored);
 }
 
@@ -1918 +1517 @@
  *END_RESTORE_A_BIGGIEFILE_FROM_STREAM                                    *
  **************************************************************************/
-
 
 
@@ -1943 +1541 @@
   /** malloc **/
     char *command;
-    char *tmp;
+    char *tmp = NULL;
     char *filelist_name;
-    char *filelist_subset_fname;
-    char *executable;
-    char *temp_log;
-    char screen_message[100];
+    char *filelist_subset_fname = NULL;
+    char *executable = NULL;
+    char *temp_log = NULL;
     long matches = 0;
     bool use_star;
-    char *xattr_fname;
-    char *acl_fname;
-//  char files_to_restore_this_time_fname[MAX_STR_LEN];
+    char *xattr_fname = NULL;
+    char *acl_fname = NULL;
 
     assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
-    malloc_string(command);
-    malloc_string(tmp);
-    malloc_string(filelist_name);
-    malloc_string(filelist_subset_fname);
-    malloc_string(executable);
-    malloc_string(temp_log);
-    malloc_string(xattr_fname);
-    malloc_string(acl_fname);
 
     log_msg(5, "Entering");
-    filelist_subset_fname[0] = '\0';
     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);
+    asprintf(&command, "mkdir -p %s/tmp", MNT_RESTORING);
     run_program_and_log_output(command, 9);
-    sprintf(temp_log, "/tmp/%d.%d", (int) (random() % 32768),
-            (int) (random() % 32768));
-
-    sprintf(filelist_name, MNT_CDROM "/archives/filelist.%ld",
+    paranoid_free(command);
+
+    asprintf(&filelist_name, MNT_CDROM "/archives/filelist.%ld",
             current_tarball_number);
     if (length_of_file(filelist_name) <= 2) {
@@ -1984 +1569 @@
                 "but it's non-critical. It's cosmetic. Don't worry about it.");
         retval = 0;
-        goto leave_sub;
+        log_msg(5, "Leaving");
+        return (retval);
     }
     if (count_lines_in_file(filelist_name) <= 0
@@ -1990 +1576 @@
         log_msg(3, "length_of_file(%s) = %llu", tarball_fname,
                 length_of_file(tarball_fname));
-        sprintf(tmp, "Unable to restore fileset #%ld (CD I/O error)",
+        asprintf(&tmp, "Unable to restore fileset #%ld (CD I/O error)",
                 current_tarball_number);
         log_to_screen(tmp);
+        paranoid_free(tmp);
         retval = 1;
-        goto leave_sub;
+        log_msg(5, "Leaving");
+        return (retval);
     }
 
     if (filelist) {
-        sprintf(filelist_subset_fname, "/tmp/filelist-subset-%ld.tmp",
+        asprintf(&filelist_subset_fname, "/tmp/filelist-subset-%ld.tmp",
                 current_tarball_number);
         if ((matches =
@@ -2005 +1593 @@
                                              use_star))
             <= 0) {
-            sprintf(tmp, "Skipping fileset %ld", current_tarball_number);
+            asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
             log_msg(1, tmp);
+            paranoid_free(tmp);
         } else {
             log_msg(3, "Saved fileset %ld's subset to %s",
                     current_tarball_number, filelist_subset_fname);
         }
-        sprintf(screen_message, "Tarball #%ld --- %ld matches",
+        asprintf(&tmp, "Tarball #%ld --- %ld matches",
                 current_tarball_number, matches);
-        log_to_screen(screen_message);
+        log_to_screen(tmp);
+        paranoid_free(tmp);
     } else {
-        filelist_subset_fname[0] = '\0';
-    }
+        filelist_subset_fname = NULL;
+    }
+    paranoid_free(filelist_name);
 
     if (filelist == NULL || matches > 0) {
-        sprintf(xattr_fname, XATTR_LIST_FNAME_RAW_SZ,
+        asprintf(&xattr_fname, XATTR_LIST_FNAME_RAW_SZ,
                 MNT_CDROM "/archives", current_tarball_number);
-        sprintf(acl_fname, ACL_LIST_FNAME_RAW_SZ, MNT_CDROM "/archives",
+        asprintf(&acl_fname, ACL_LIST_FNAME_RAW_SZ, MNT_CDROM "/archives",
                 current_tarball_number);
         if (strstr(tarball_fname, ".bz2")) {
-            strcpy(executable, "bzip2");
+            asprintf(&executable, "bzip2");
         } else if (strstr(tarball_fname, ".lzo")) {
-            strcpy(executable, "lzop");
+            asprintf(&executable, "lzop");
         } else {
-            executable[0] = '\0';
-        }
-        if (executable[0]) {
-            sprintf(tmp, "which %s > /dev/null 2> /dev/null", executable);
+            executable = NULL;
+        }
+
+        if (executable == NULL) {
+            asprintf(&tmp, "which %s > /dev/null 2> /dev/null", executable);
             if (run_program_and_log_output(tmp, FALSE)) {
                 log_to_screen
-                    (_("(compare_a_tarball) Compression program not found - oh no!"));
+                    (_
+                     ("(compare_a_tarball) Compression program not found - oh no!"));
                 paranoid_MR_finish(1);
             }
-            strcpy(tmp, executable);
-            sprintf(executable, "-P %s -Z", tmp);
+            paranoid_free(tmp);
+
+            asprintf(&tmp, executable);
+            asprintf(&executable, "-P %s -Z", tmp);
+            paranoid_free(tmp);
         }
 #ifdef __FreeBSD__
@@ -2046 +1642 @@
 #endif
 
-//      if (strstr(tarball_fname, ".star."))
+        asprintf(&temp_log, "/tmp/%d.%d", (int) (random() % 32768),
+            (int) (random() % 32768));
+
         if (use_star) {
-            sprintf(command,
+            if (strstr(tarball_fname, ".bz2")) {
+                asprintf(&tmp, " -bz");
+            } else {
+                asprintf(&tmp, "");
+            }
+            asprintf(&command,
                     "star -x -force-remove -U " STAR_ACL_SZ
-                    " errctl= file=%s", tarball_fname);
-            if (strstr(tarball_fname, ".bz2")) {
-                strcat(command, " -bz");
-            }
+                    " errctl= file=%s %s 2>> %s >> %s", tarball_fname, tmp, temp_log, temp_log);
+            paranoid_free(tmp);
         } else {
-            if (filelist_subset_fname[0] != '\0') {
-                sprintf(command,
-                        "afio -i -M 8m -b %ld -c %ld %s -w '%s' %s",
+            if (filelist_subset_fname != NULL) {
+                asprintf(&command,
+                        "afio -i -M 8m -b %ld -c %ld %s -w '%s' %s 2>> %s >> %s",
                         TAPE_BLOCK_SIZE,
                         BUFSIZE, executable, filelist_subset_fname,
 //             files_to_restore_this_time_fname,
-                        tarball_fname);
+                        tarball_fname, temp_log, temp_log);
             } else {
-                sprintf(command,
-                        "afio -i -b %ld -c %ld -M 8m %s %s",
+                asprintf(&command,
+                        "afio -i -b %ld -c %ld -M 8m %s %s 2>> %s >> %s",
                         TAPE_BLOCK_SIZE,
-                        BUFSIZE, executable, tarball_fname);
-            }
-        }
+                        BUFSIZE, executable, tarball_fname, temp_log, temp_log);
+            }
+        }
+        paranoid_free(executable);
+
 #undef BUFSIZE
-        sprintf(command + strlen(command), " 2>> %s >> %s", temp_log,
-                temp_log);
         log_msg(1, "command = '%s'", command);
         unlink(temp_log);
@@ -2083 +1684 @@
             }
         }
+        paranoid_free(command);
+
         if (res && length_of_file(temp_log) < 5) {
             res = 0;
@@ -2092 +1695 @@
             if (res) {
                 log_to_screen
-                    (_("Errors occurred while setting extended attributes"));
+                    (_
+                     ("Errors occurred while setting extended attributes"));
             } else {
                 log_msg(1, "I set xattr OK");
@@ -2103 +1707 @@
             if (res) {
                 log_to_screen
-                    (_("Errors occurred while setting access control lists"));
+                    (_
+                     ("Errors occurred while setting access control lists"));
             } else {
                 log_msg(1, "I set ACL OK");
@@ -2110 +1715 @@
         }
         if (retval) {
-            sprintf(command, "cat %s >> %s", temp_log, MONDO_LOGFILE);
+            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);
@@ -2117 +1723 @@
             log_msg(2, "Fileset #%d processed OK", current_tarball_number);
         }
+        unlink(xattr_fname);
+        paranoid_free(xattr_fname);
     }
     if (does_file_exist("/PAUSE")) {
         popup_and_OK
-            (_("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
+            (_
+             ("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
     }
     unlink(filelist_subset_fname);
-    unlink(xattr_fname);
     unlink(acl_fname);
     unlink(temp_log);
 
-  leave_sub:
-    paranoid_free(command);
-    paranoid_free(tmp);
-    paranoid_free(filelist_name);
     paranoid_free(filelist_subset_fname);
-    paranoid_free(executable);
+    paranoid_free(acl_fname);
     paranoid_free(temp_log);
-    paranoid_free(xattr_fname);
-    paranoid_free(acl_fname);
+
     log_msg(5, "Leaving");
     return (retval);
@@ -2172 +1775 @@
 
   /** malloc add ***/
-    char *tmp;
-    char *command;
-    char *afio_fname;
-    char *filelist_fname;
-    char *filelist_subset_fname;
-    char *executable;
+    char *tmp = NULL;
+    char *command = NULL;
+    char *afio_fname = NULL;
+    char *filelist_fname = NULL;
+    char *filelist_subset_fname = NULL;
+    char *executable = NULL;
     long matches = 0;
     bool restore_this_fileset = FALSE;
@@ -2184 +1787 @@
     assert(bkpinfo != NULL);
     assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
-    malloc_string(filelist_subset_fname);
-    malloc_string(filelist_fname);
-    malloc_string(afio_fname);
-    malloc_string(executable);
-    malloc_string(command);
-    malloc_string(tmp);
-    filelist_subset_fname[0] = '\0';
     /* to do it with a file... */
     use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
-    sprintf(tmp,
+    asprintf(&tmp,
             "Restoring from fileset #%ld (%ld KB) on %s #%d",
             current_tarball_number, (long) size >> 10,
@@ -2199 +1795 @@
             g_current_media_number);
     log_msg(2, tmp);
+    paranoid_free(tmp);
     run_program_and_log_output("mkdir -p " MNT_RESTORING "/tmp", FALSE);
 
@@ -2206 +1803 @@
    * in afio or someting; oh darn.. OK, use tmpfs :-)                         *
    ****************************************************************************/
-    filelist_fname[0] = filelist_subset_fname[0] = '\0';
-    sprintf(afio_fname, "/tmp/tmpfs/archive.tmp.%ld",
+    asprintf(&afio_fname, "/tmp/tmpfs/archive.tmp.%ld",
             current_tarball_number);
-    sprintf(filelist_fname, "%s/filelist.%ld", bkpinfo->tmpdir,
+    asprintf(&filelist_fname, "%s/filelist.%ld", bkpinfo->tmpdir,
             current_tarball_number);
-    sprintf(filelist_subset_fname, "%s/filelist-subset-%ld.tmp",
+    asprintf(&filelist_subset_fname, "%s/filelist-subset-%ld.tmp",
             bkpinfo->tmpdir, current_tarball_number);
-//  sprintf(filelist_fname, "/tmp/tmpfs/temp-filelist.%ld", current_tarball_number);
     res = read_file_from_stream_to_file(bkpinfo, afio_fname, size);
     if (strstr(tarball_fname, ".star")) {
@@ -2221 +1816 @@
         log_msg(1, "Warning - error reading afioball from tape");
     }
-    if (bkpinfo->compression_level == 0) {
-        executable[0] = '\0';
-    } else {
+    if (bkpinfo->compression_level != 0) {
         if (bkpinfo->use_star) {
-            strcpy(executable, " -bz");
+            asprintf(&executable, " -bz");
         } else {
-            sprintf(executable, "-P %s -Z", bkpinfo->zip_exe);
+            asprintf(&executable, "-P %s -Z", bkpinfo->zip_exe);
         }
     }
@@ -2238 +1831 @@
         if (strstr(tarball_fname, ".star.")) {
             use_star = TRUE;
-            sprintf(command, "star -t file=%s %s", afio_fname, executable);
+            asprintf(&command, "star -t file=%s %s > %s 2>> %s", afio_fname, executable, filelist_fname, MONDO_LOGFILE);
         } else {
             use_star = FALSE;
-            sprintf(command, "afio -t -M 8m -b %ld %s %s", TAPE_BLOCK_SIZE,
-                    executable, afio_fname);
-        }
-        sprintf(command + strlen(command), " > %s 2>> %s", filelist_fname,
-                MONDO_LOGFILE);
+            asprintf(&command, "afio -t -M 8m -b %ld %s %s > %s 2>> %s", TAPE_BLOCK_SIZE,
+                    executable, afio_fname, filelist_fname, MONDO_LOGFILE);
+        }
         log_msg(1, "command = %s", command);
         if (system(command)) {
             log_msg(4, "Warning - error occurred while retrieving TOC");
         }
+        paranoid_free(command);
         if ((matches =
              save_filelist_entries_in_common(filelist_fname, filelist,
@@ -2259 +1851 @@
                         current_tarball_number);
             }
-            sprintf(tmp, "Skipping fileset %ld", current_tarball_number);
+            asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
             log_msg(2, tmp);
+            paranoid_free(tmp);
             restore_this_fileset = FALSE;
         } else {
@@ -2269 +1862 @@
         }
     }
+    unlink(filelist_fname);
+    paranoid_free(filelist_fname);
 
 // Concoct the call to star/afio to restore files
-    if (strstr(tarball_fname, ".star."))    // star
-    {
-        sprintf(command, "star -x file=%s %s", afio_fname, executable);
+    if (strstr(tarball_fname, ".star.")) {
+        // star
         if (filelist) {
-            sprintf(command + strlen(command), " list=%s",
-                    filelist_subset_fname);
-        }
-    } else                      // afio
-    {
-        sprintf(command, "afio -i -M 8m -b %ld %s", TAPE_BLOCK_SIZE,
-                executable);
+            asprintf(&command, "star -x file=%s %s list=%s 2>> %s", afio_fname, executable
+                    filelist_subset_fname,MONDO_LOGFILE);
+        } else {
+            asprintf(&command,"star -x file=%s %s 2>> %s", afio_fname, executable,MONDO_LOGFILE);
+        }
+    } else {
+        // afio
         if (filelist) {
-            sprintf(command + strlen(command), " -w %s",
-                    filelist_subset_fname);
-        }
-        sprintf(command + strlen(command), " %s", afio_fname);
-    }
-    sprintf(command + strlen(command), " 2>> %s", MONDO_LOGFILE);
-
-// Call if IF there are files to restore (selectively/unconditionally)
+            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 {
+            asprintf(&command, "afio -i -M 8m -b %ld %s %s 2>> %s", TAPE_BLOCK_SIZE, executable,afio_fname,MONDO_LOGFILE);
+        }
+    }
+    paranoid_free(executable);
+
+    // Call if IF there are files to restore (selectively/unconditionally)
     if (restore_this_fileset) {
         log_msg(1, "Calling command='%s'", command);
@@ -2315 +1909 @@
         log_msg(1, "NOT CALLING '%s'", command);
     }
+    paranoid_free(command);
 
     if (does_file_exist("/PAUSE") && current_tarball_number >= 50) {
@@ -2322 +1917 @@
 
     unlink(filelist_subset_fname);
-    unlink(filelist_fname);
     unlink(afio_fname);
 
     paranoid_free(filelist_subset_fname);
-    paranoid_free(filelist_fname);
     paranoid_free(afio_fname);
-    paranoid_free(command);
-    paranoid_free(tmp);
     return (retval);
 }
@@ -2336 +1927 @@
  *END_RESTORE_A_TARBALL_FROM_STREAM                                       *
  **************************************************************************/
-
-
 
 
@@ -2354 +1943 @@
 {
     int retval = 0;
-    int res;
-    long noof_biggiefiles, bigfileno = 0, total_slices;
-  /** malloc **/
-    char *tmp;
-    bool just_changed_cds = FALSE, finished;
-    char *xattr_fname;
-    char *acl_fname;
-    char *biggies_whose_EXATs_we_should_set;    // EXtended ATtributes
-    char *pathname_of_last_biggie_restored;
+    int res = 0;
+    long noof_biggiefiles = 0L, bigfileno = 0L, total_slices = 0L;
+    char *tmp = NULL;
+    bool just_changed_cds = FALSE, finished = FALSE;
+    char *xattr_fname = NULL;
+    char *acl_fname = NULL;
+    char *biggies_whose_EXATs_we_should_set = NULL; // EXtended ATtributes
+    char *pathname_of_last_biggie_restored = NULL;
     FILE *fbw = NULL;
 
-    malloc_string(xattr_fname);
-    malloc_string(acl_fname);
-    malloc_string(tmp);
-    malloc_string(biggies_whose_EXATs_we_should_set);
-    malloc_string(pathname_of_last_biggie_restored);
     assert(bkpinfo != NULL);
 
-    sprintf(biggies_whose_EXATs_we_should_set,
+    asprintf(&biggies_whose_EXATs_we_should_set,
             "%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
     if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w"))) {
@@ -2381 +1964 @@
     read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
     total_slices = atol(tmp);
-    sprintf(tmp, _("Reassembling large files      "));
+    paranoid_free(tmp);
+
+    asprintf(&tmp, _("Reassembling large files      "));
     mvaddstr_and_log_it(g_currentY, 0, tmp);
+    paranoid_free(tmp);
+
     if (length_of_file(BIGGIELIST) < 6) {
         log_msg(1, "OK, no biggielist; not restoring biggiefiles");
@@ -2393 +1980 @@
         return (0);
     }
-    sprintf(tmp, "OK, there are %ld biggiefiles in the archives",
+    asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
             noof_biggiefiles);
     log_msg(2, tmp);
+    paranoid_free(tmp);
 
     open_progress_form(_("Reassembling large files"),
@@ -2403 +1991 @@
     for (bigfileno = 0, finished = FALSE; !finished;) {
         log_msg(2, "Thinking about restoring bigfile %ld", bigfileno + 1);
-        if (!does_file_exist(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""))) {
+        tmp = slice_fname(bigfileno, 0, ARCHIVES_PATH, "");
+        if (!does_file_exist(tmp)) {
             log_msg(3,
                     "...but its first slice isn't on this CD. Perhaps this was a selective restore?");
@@ -2410 +1999 @@
                     media_descriptor_string(bkpinfo->backup_media_type),
                     g_current_media_number);
-            log_msg(3, "Slicename would have been %s",
-                    slice_fname(bigfileno + 1, 0, ARCHIVES_PATH, ""));
+            tmp1 = slice_fname(bigfileno + 1, 0, ARCHIVES_PATH, "");
+            log_msg(3, "Slicename would have been %s", tmp1);
+            paranoid_free(tmp1);
+
             // I'm not positive 'just_changed_cds' is even necessary...
             if (just_changed_cds) {
@@ -2420 +2011 @@
                 insist_on_this_cd_number(bkpinfo,
                                          ++g_current_media_number);
-                sprintf(tmp, _("Restoring from %s #%d"),
+                asprintf(&tmp, _("Restoring from %s #%d"),
                         media_descriptor_string(bkpinfo->
                                                 backup_media_type),
                         g_current_media_number);
                 log_to_screen(tmp);
+                paranoid_free(tmp);
+
                 just_changed_cds = TRUE;
             } else {
@@ -2434 +2027 @@
         } else {
             just_changed_cds = FALSE;
-            sprintf(tmp, _("Restoring big file %ld"), bigfileno + 1);
+            asprintf(&tmp, _("Restoring big file %ld"), bigfileno + 1);
             update_progress_form(tmp);
-            res =
-                restore_a_biggiefile_from_CD(bkpinfo, bigfileno, filelist,
-                                             pathname_of_last_biggie_restored);
+            paranoid_free(tmp);
+
+            pathname_of_last_biggie_restored =
+                restore_a_biggiefile_from_CD(bkpinfo, bigfileno, filelist);
             iamhere(pathname_of_last_biggie_restored);
             if (fbw && pathname_of_last_biggie_restored[0]) {
                 fprintf(fbw, "%s\n", pathname_of_last_biggie_restored);
             }
+            paranoid_free(pathname_of_last_biggie_restored);
             retval += res;
             bigfileno++;
 
         }
+        paranoid_free(tmp);
     }
 
     if (fbw) {
         fclose(fbw);
-        sprintf(acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
-        sprintf(xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
+        asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
+        asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
         if (length_of_file(acl_fname) > 0 && find_home_of_exe("setfacl")) {
             set_acl_list(biggies_whose_EXATs_we_should_set, acl_fname);
@@ -2460 +2056 @@
             set_fattr_list(biggies_whose_EXATs_we_should_set, xattr_fname);
         }
-    }
+        paranoid_free(acl_fname);
+        paranoid_free(xattr_fname);
+    }
+    paranoid_free(biggies_whose_EXATs_we_should_set);
+
     if (does_file_exist("/PAUSE")) {
         popup_and_OK
-            (_("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
+            (_
+             ("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
     }
     close_progress_form();
@@ -2471 +2072 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     }
-    paranoid_free(xattr_fname);
-    paranoid_free(acl_fname);
-    paranoid_free(tmp);
-    paranoid_free(biggies_whose_EXATs_we_should_set);
-    paranoid_free(pathname_of_last_biggie_restored);
     return (retval);
 }
-
 /**************************************************************************
  *END_RESTORE_ALL_BIGGIFILES_FROM_CD                                      *
  **************************************************************************/
-
 
 
@@ -2506 +2100 @@
   /**malloc ***/
     char *tmp;
+    char *tmp1;
     char *tarball_fname;
     char *progress_str;
     char *comment;
-
-    malloc_string(tmp);
-    malloc_string(tarball_fname);
-    malloc_string(progress_str);
-    malloc_string(comment);
 
     assert(bkpinfo != NULL);
@@ -2527 +2117 @@
     read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
     max_val = atol(tmp) + 1;
-    sprintf(progress_str, _("Restoring from %s #%d"),
+    paranoid_free(tmp);
+
+    asprintf(&progress_str, _("Restoring from %s #%d"),
             media_descriptor_string(bkpinfo->backup_media_type),
             g_current_media_number);
@@ -2538 +2130 @@
         insist_on_this_cd_number(bkpinfo, g_current_media_number);
         update_progress_form(progress_str);
-        sprintf(tarball_fname, MNT_CDROM "/archives/%ld.afio.bz2",
+
+        asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.bz2",
                 current_tarball_number);
         if (!does_file_exist(tarball_fname)) {
-            sprintf(tarball_fname, MNT_CDROM "/archives/%ld.afio.lzo",
+            paranoid_free(tarball_fname);
+            asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.lzo",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            sprintf(tarball_fname, MNT_CDROM "/archives/%ld.afio.",
+            paranoid_free(tarball_fname);
+            asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            sprintf(tarball_fname, MNT_CDROM "/archives/%ld.star.bz2",
+            paranoid_free(tarball_fname);
+            asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.bz2",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            sprintf(tarball_fname, MNT_CDROM "/archives/%ld.star.",
+            paranoid_free(tarball_fname);
+            asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
+            paranoid_free(tarball_fname);
             if (current_tarball_number == 0) {
                 log_to_screen
-                    (_("No tarballs. Strange. Maybe you only backed up freakin' big files?"));
+                    (_
+                     ("No tarballs. Strange. Maybe you only backed up freakin' big files?"));
                 return (0);
             }
@@ -2569 +2168 @@
             }
             g_current_media_number++;
-            sprintf(progress_str, _("Restoring from %s #%d"),
+            paranoid_free(progress_str);
+            asprintf(&progress_str, _("Restoring from %s #%d"),
                     media_descriptor_string(bkpinfo->backup_media_type),
                     g_current_media_number);
             log_to_screen(progress_str);
         } else {
-            sprintf(progress_str, _("Restoring from fileset #%ld on %s #%d"),
+            paranoid_free(progress_str);
+            asprintf(&progress_str,
+                    _("Restoring from fileset #%ld on %s #%d"),
                     current_tarball_number,
                     media_descriptor_string(bkpinfo->backup_media_type),
@@ -2586 +2188 @@
                                               filelist);
             }
-            sprintf(tmp, _("%s #%d, fileset #%ld - restore "),
+            if (res) {
+                asprintf(&tmp1, _("reported errors"));
+            } else {
+                asprintf(&tmp1, _("succeeded"));
+            }
+            asprintf(&tmp, _("%s #%d, fileset #%ld - restore %s"),
                     media_descriptor_string(bkpinfo->backup_media_type),
-                    g_current_media_number, current_tarball_number);
-            if (res) {
-                strcat(tmp, _("reported errors"));
-            } else if (attempts > 1) {
-                strcat(tmp, _("succeeded"));
-            } else {
-                strcat(tmp, _("succeeded"));
-            }
+                    g_current_media_number, current_tarball_number,tmp1);
+            paranoid_free(tmp1);
+            
             if (attempts > 1) {
-                sprintf(tmp + strlen(tmp), _(" (%d attempts) - review logs"),
-                        attempts);
-            }
-            strcpy(comment, tmp);
+                asprintf(&tmp1, _(" (%d attempts) - review logs"), attempts);
+            }
+            asprintf(&comment, "%s%s", tmp, tmp1);
+            paranoid_free(tmp);
+            paranoid_free(tmp1);
             if (attempts > 1) {
                 log_to_screen(comment);
             }
+            paranoid_free(comment);
 
             retval += res;
@@ -2609 +2213 @@
             g_current_progress++;
         }
-    }
+        paranoid_free(tarball_fname);
+    }
+    paranoid_free(progress_str);
     close_progress_form();
+
     if (retval) {
         mvaddstr_and_log_it(g_currentY++, 74, _("Errors."));
@@ -2616 +2223 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     }
-    paranoid_free(tmp);
-    paranoid_free(tarball_fname);
-    paranoid_free(progress_str);
-    paranoid_free(comment);
 
     return (retval);
@@ -2627 +2230 @@
  *END_RESTORE_ALL_TARBALLS_FROM_CD                                        *
  **************************************************************************/
-
 
 
@@ -2650 +2252 @@
 
   /** malloc add ****/
-    char *tmp;
-    char *biggie_fname;
-    char *biggie_cksum;
-    char *xattr_fname;
-    char *acl_fname;
-    char *p;
-    char *pathname_of_last_biggie_restored;
-    char *biggies_whose_EXATs_we_should_set;    // EXtended ATtributes
-    long long biggie_size;
+    char *tmp = NULL;
+    char *biggie_fname = NULL;
+    char *xattr_fname = NULL;
+    char *acl_fname = NULL;
+    char *p = NULL;
+    char *pathname_of_last_biggie_restored = NULL;
+    char *biggies_whose_EXATs_we_should_set = NULL; // EXtended ATtributes
+    long long biggie_size = NULL;
     FILE *fbw = NULL;
 
-    malloc_string(tmp);
-    malloc_string(biggie_fname);
-    malloc_string(biggie_cksum);
-    malloc_string(xattr_fname);
-    malloc_string(acl_fname);
-    malloc_string(biggies_whose_EXATs_we_should_set);
-    malloc_string(pathname_of_last_biggie_restored);
     assert(bkpinfo != NULL);
 
     read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
-
     total_slices = atol(tmp);
-    sprintf(tmp, "Reassembling large files      ");
-    sprintf(xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
-    sprintf(acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
+    paranoid_free(tmp);
+
+    asprintf(&tmp, "Reassembling large files      ");
+    asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
+    asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
     mvaddstr_and_log_it(g_currentY, 0, tmp);
-    sprintf(biggies_whose_EXATs_we_should_set,
+    paranoid_free(tmp);
+
+    asprintf(&biggies_whose_EXATs_we_should_set,
             "%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
     if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w"))) {
@@ -2694 +2291 @@
 
     noof_biggiefiles = atol(biggie_fname);
-    sprintf(tmp, "OK, there are %ld biggiefiles in the archives",
+    asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
             noof_biggiefiles);
     log_msg(2, tmp);
+    paranoid_free(tmp);
+
     open_progress_form(_("Reassembling large files"),
                        _("I am now reassembling all the large files."),
@@ -2713 +2312 @@
             wrong_marker(BLK_START_A_NORMBIGGIE, ctrl_chr);
         }
+        /* BERLIOS: useless
         p = strrchr(biggie_fname, '/');
         if (!p) {
@@ -2719 +2319 @@
             p++;
         }
-        sprintf(tmp, _("Restoring big file %ld (%lld K)"),
+        */
+        asprintf(&tmp, _("Restoring big file %ld (%lld K)"),
                 current_bigfile_number + 1, biggie_size / 1024);
         update_progress_form(tmp);
-        res = restore_a_biggiefile_from_stream(bkpinfo, biggie_fname,
+        paranoid_free(tmp);
+
+        pathname_of_last_biggie_restored = restore_a_biggiefile_from_stream(bkpinfo, biggie_fname,
                                                current_bigfile_number,
-                                               biggie_cksum,
-                                               biggie_size,
-                                               filelist, ctrl_chr,
-                                               pathname_of_last_biggie_restored);
+                                               filelist, ctrl_chr);
         log_msg(1, "I believe I have restored %s",
                 pathname_of_last_biggie_restored);
@@ -2733 +2333 @@
             fprintf(fbw, "%s\n", pathname_of_last_biggie_restored);
         }
+        paranoid_free(pathname_of_last_biggie_restored);
+
         retval += res;
         current_bigfile_number++;
@@ -2739 +2341 @@
     if (current_bigfile_number != noof_biggiefiles
         && noof_biggiefiles != 0) {
-        sprintf(tmp, "Warning - bigfileno=%ld but noof_biggiefiles=%ld\n",
+        asprintf(&tmp, "Warning - bigfileno=%ld but noof_biggiefiles=%ld\n",
                 current_bigfile_number, noof_biggiefiles);
     } else {
-        sprintf(tmp,
+        asprintf(&tmp,
                 "%ld biggiefiles in biggielist.txt; %ld biggiefiles processed today.",
                 noof_biggiefiles, current_bigfile_number);
     }
     log_msg(1, tmp);
+    paranoid_free(tmp);
 
     if (fbw) {
@@ -2768 +2371 @@
         }
     }
+    paranoid_free(xattr_fname);
+    paranoid_free(acl_fname);
+    paranoid_free(biggies_whose_EXATs_we_should_set);
+
     if (does_file_exist("/PAUSE")) {
         popup_and_OK
-            (_("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
+            (_
+             ("Press ENTER to go on. Delete /PAUSE to stop these pauses."));
     }
 
@@ -2779 +2387 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     }
-    paranoid_free(biggies_whose_EXATs_we_should_set);
-    paranoid_free(pathname_of_last_biggie_restored);
     paranoid_free(biggie_fname);
-    paranoid_free(biggie_cksum);
-    paranoid_free(xattr_fname);
-    paranoid_free(acl_fname);
-    paranoid_free(tmp);
     return (retval);
 }
@@ -2792 +2394 @@
  *END_RESTORE_ALL_BIGGIEFILES_FROM_STREAM                                 *
  **************************************************************************/
-
-
-
-
 
 
@@ -2819 +2417 @@
 
   /** malloc **/
-    char *tmp;
-    char *progress_str;
-    char *tmp_fname;
-    char *xattr_fname;
-    char *acl_fname;
+    char *tmp = NULL;
+    char *progress_str = NULL;
+    char *tmp_fname = NULL;
+    char *xattr_fname = NULL;
+    char *acl_fname = NULL;
 
     long long tmp_size;
 
-    malloc_string(tmp);
-    malloc_string(progress_str);
-    malloc_string(tmp_fname);
     assert(bkpinfo != NULL);
-    malloc_string(xattr_fname);
-    malloc_string(acl_fname);
     mvaddstr_and_log_it(g_currentY, 0, _("Restoring from archives"));
     read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
     max_val = atol(tmp) + 1;
+    paranoid_free(tmp);
 
     chdir(bkpinfo->restore_path);   /* I don't know why this is needed _here_ but it seems to be. -HR, 02/04/2002 */
@@ -2841 +2435 @@
     run_program_and_log_output("pwd", 5);
 
-    sprintf(progress_str, _("Restoring from media #%d"),
+    asprintf(&progress_str, _("Restoring from media #%d"),
             g_current_media_number);
     log_to_screen(progress_str);
@@ -2863 +2457 @@
     while (ctrl_chr != BLK_STOP_AFIOBALLS) {
         update_progress_form(progress_str);
-        sprintf(xattr_fname, "%s/xattr-subset-%ld.tmp", bkpinfo->tmpdir,
+        asprintf(&xattr_fname, "%s/xattr-subset-%ld.tmp", bkpinfo->tmpdir,
                 current_afioball_number);
-        sprintf(acl_fname, "%s/acl-subset-%ld.tmp", bkpinfo->tmpdir,
+        asprintf(&acl_fname, "%s/acl-subset-%ld.tmp", bkpinfo->tmpdir,
                 current_afioball_number);
         unlink(xattr_fname);
@@ -2879 +2473 @@
             wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
         }
-        sprintf(tmp,
+        /* BERLIOS: useless ?
+        asprintf(&tmp,
                 _("Restoring from fileset #%ld (name=%s, size=%ld K)"),
                 current_afioball_number, tmp_fname, (long) tmp_size >> 10);
+                */
         res =
             restore_a_tarball_from_stream(bkpinfo, tmp_fname,
@@ -2889 +2485 @@
         retval += res;
         if (res) {
-            sprintf(tmp, _("Fileset %ld - errors occurred"),
+            asprintf(&tmp, _("Fileset %ld - errors occurred"),
                     current_afioball_number);
             log_to_screen(tmp);
+            paranoid_free(tmp);
         }
         res =
@@ -2901 +2498 @@
         current_afioball_number++;
         g_current_progress++;
-        sprintf(progress_str, _("Restoring from fileset #%ld on %s #%d"),
+
+        paranoid_free(progress_str);
+        asprintf(&progress_str, _("Restoring from fileset #%ld on %s #%d"),
                 current_afioball_number,
                 media_descriptor_string(bkpinfo->backup_media_type),
@@ -2909 +2508 @@
         unlink(xattr_fname);
         unlink(acl_fname);
+        paranoid_free(xattr_fname);
+        paranoid_free(acl_fname);
     }                           // next
+    paranoid_free(progress_str);
+    paranoid_free(tmp_fname);
+
     log_msg(1, "All done with afioballs");
     close_progress_form();
@@ -2917 +2521 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     }
-    paranoid_free(tmp);
-    paranoid_free(progress_str);
-    paranoid_free(tmp_fname);
-    paranoid_free(xattr_fname);
-    paranoid_free(acl_fname);
     return (retval);
 }
@@ -2946 +2545 @@
 
   /** mallco ***/
-    char *cwd;
-    char *newpath;
-    char *tmp;
+    char *cwd = NULL;
+    char *newpath = NULL;
+    char *tmp = NULL;
     assert(bkpinfo != NULL);
 
     malloc_string(cwd);
     malloc_string(newpath);
-    malloc_string(tmp);
     log_msg(2, "restore_everything() --- starting");
     g_current_media_number = 1;
+    /* BERLIOS: should test return value, or better change the function */
     getcwd(cwd, MAX_STR_LEN - 1);
-    sprintf(tmp, "mkdir -p %s", bkpinfo->restore_path);
+    asprintf(&tmp, "mkdir -p %s", bkpinfo->restore_path);
     run_program_and_log_output(tmp, FALSE);
+    paranoid_free(tmp);
+
     log_msg(1, "Changing dir to %s", bkpinfo->restore_path);
     chdir(bkpinfo->restore_path);
+    /* BERLIOS: should test return value, or better change the function */
     getcwd(newpath, MAX_STR_LEN - 1);
     log_msg(1, "path is now %s", newpath);
@@ -2966 +2568 @@
     if (!find_home_of_exe("petris") && !g_text_mode) {
         newtDrawRootText(0, g_noof_rows - 2,
-                         _("Press ALT-<left cursor> twice to play Petris :-) "));
+                         _
+                         ("Press ALT-<left cursor> twice to play Petris :-) "));
         newtRefresh();
     }
-    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);
         mvaddstr_and_log_it(g_currentY++, 0,
-                            _("Restoring OS and data from streaming media"));
+                            _
+                            ("Restoring OS and data from streaming media"));
         if (bkpinfo->backup_media_type == cdstream) {
             openin_cdstream(bkpinfo);
@@ -3008 +2613 @@
     paranoid_free(cwd);
     paranoid_free(newpath);
-    paranoid_free(tmp);
     return (resA + resB);
 }
@@ -3017 +2621 @@
 
 
-
-/**
- * @brief Haha. You wish! (This function is not implemented :-)
- */
-int
-restore_live_from_monitas_server(struct s_bkpinfo *bkpinfo,
-                                 char *monitas_device,
-                                 char *restore_this_directory,
-                                 char *restore_here)
-     /* NB: bkpinfo hasn't been populated yet, except for ->tmp which is "/tmp" */
-{
-    FILE *fout;
-    int retval = 0;
-    int i;
-    int j;
-    struct mountlist_itself the_mountlist;
-    static struct raidlist_itself the_raidlist;
-  /** malloc **/
-    char tmp[MAX_STR_LEN + 1];
-    char command[MAX_STR_LEN + 1];
-    char datablock[256 * 1024];
-    char datadisks_fname[MAX_STR_LEN + 1];
-    long k;
-    long length;
-    long long llt;
-    struct s_node *filelist = NULL;
-    assert(bkpinfo != NULL);
-    assert_string_is_neither_NULL_nor_zerolength(monitas_device);
-    assert(restore_this_directory != NULL);
-    assert(restore_here != NULL);
-
-    sprintf(tmp, "restore_here = '%s'", restore_here);
-
-    log_msg(2, tmp);
-
-    log_msg(2, "restore_live_from_monitas_server() - starting");
-    unlink("/tmp/mountlist.txt");
-    unlink("/tmp/filelist.full");
-    unlink("/tmp/biggielist.txt");
-    if (restore_here[0] == '\0') {
-        strcpy(bkpinfo->restore_path, MNT_RESTORING);
-    } else {
-        strcpy(bkpinfo->restore_path, restore_here);
-    }
-    log_msg(3, "FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI");
-    sprintf(tmp, "FYI - data will be restored to %s",
-            bkpinfo->restore_path);
-    log_msg(3, tmp);
-    log_msg(3, "FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI FYI");
-    sprintf(datadisks_fname, "/tmp/mondorestore.datadisks.%d",
-            (int) (random() % 32768));
-    chdir(bkpinfo->tmpdir);
-
-    sprintf(command, "cat %s", monitas_device);
-    g_tape_stream = popen(command, "r");    // for compatibility with openin_tape()
-    if (!(fout = fopen(datadisks_fname, "w"))) {
-        log_OS_error(datadisks_fname);
-        return (1);
-    }
-    for (i = 0; i < 32; i++) {
-        for (j = 0; j < 4; j++) {
-            for (length = k = 0; length < 256 * 1024; length += k) {
-                k = fread(datablock + length, 1, 256 * 1024 - length,
-                          g_tape_stream);
-            }
-            fwrite(datablock, 1, length, fout);
-            g_tape_posK += length;
-        }
-    }
-    paranoid_fclose(fout);
-    sprintf(command,
-            "tar -zxvf %s tmp/mondo-restore.cfg tmp/mountlist.txt tmp/filelist.full tmp/biggielist.txt",
-            datadisks_fname);
-    run_program_and_log_output(command, 4);
-    read_header_block_from_stream(&llt, tmp, &i);
-    read_header_block_from_stream(&llt, tmp, &i);
-
-    unlink(datadisks_fname);
-    read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
-    retval = load_mountlist(&the_mountlist, g_mountlist_fname);
-
-
-    load_raidtab_into_raidlist(&the_raidlist, RAIDTAB_FNAME);
-    iamhere("FIXME");
-    fatal_error("This will fail");
-    sprintf(command,
-            "grep -x \"%s.*\" %s > %s",
-            restore_this_directory, g_filelist_full, g_filelist_full);
-    if (system(command)) {
-        retval++;
-        log_to_screen
-            (_("Error(s) occurred while processing filelist and wildcard"));
-    }
-    iamhere("FIXME");
-    fatal_error("This will fail");
-    sprintf(command,
-            "grep -x \"%s.*\" %s > %s",
-            restore_this_directory, g_biggielist_txt, g_biggielist_txt);
-    if (system(command)) {
-        log_msg(1,
-                "Error(s) occurred while processing biggielist and wildcard");
-    }
-    sprintf(command, "touch %s", g_biggielist_txt);
-    run_program_and_log_output(command, FALSE);
-//  filelist = load_filelist(g_filelist_restthese);  // FIXME --- this probably doesn't work because it doesn't include the biggiefiles
-    retval += restore_everything(bkpinfo, filelist);
-    free_filelist(filelist);
-    log_msg(2, "--------End of restore_live_from_monitas_server--------");
-    return (retval);
-}
-
-/**************************************************************************
- *END_RESTORE_LIVE_FROM_MONITAS_SERVER                                    *
- **************************************************************************/
-
-
-
-
 extern void wait_until_software_raids_are_prepped(char *, int);
-
 
 char which_restore_mode(void);
@@ -3146 +2631 @@
 void welcome_to_mondorestore()
 {
-    log_msg(0, "-------------- Mondo Restore v%s -------------", PACKAGE_VERSION);
+    log_msg(0, "-------------- Mondo Restore v%s -------------",
+            PACKAGE_VERSION);
     log_msg(0,
             "DON'T PANIC! Mondorestore logs almost everything, so please ");
@@ -3170 +2656 @@
             "stopped for some reason, chances are it's detailed here.    ");
     log_msg(0,
-            "More than likely there's a message at the very end of this  ");
+            "More than likely there's a message near the end of this     ");
     log_msg(0,
             "log that will tell you what is wrong.  Please read it!      ");
@@ -3178 +2664 @@
 
 
-
 /**
  * Restore the user's data.
@@ -3185 +2670 @@
 int main(int argc, char *argv[])
 {
-    FILE *fin;
-    FILE *fout;
+    FILE *fin = NULL;
+    FILE *fout = NULL;
     int retval = 0;
-    int res;
-//  int c;
-    char *tmp;
-
-    struct mountlist_itself *mountlist;
-    struct raidlist_itself *raidlist;
-    struct s_bkpinfo *bkpinfo;
-    struct s_node *filelist;
-    char *a, *b;
+    int res = 0;
+    char *tmp = NULL;
+
+    struct mountlist_itself *mountlist = NULL;
+    struct raidlist_itself *raidlist = NULL;
+    struct s_bkpinfo *bkpinfo = NULL;
+    struct s_node *filelist = NULL;
+    char *a = NULL, *b = NULL;
 
   /**************************************************************************
@@ -3215 +2699 @@
 
     g_loglevel = DEFAULT_MR_LOGLEVEL;
-    malloc_string(tmp);
 
 /* Configure global variables */
 #ifdef __FreeBSD__
-    if (strstr
-        (call_program_and_get_last_line_of_output("cat /tmp/cmdline"),
-         "textonly"))
+    tmp = call_program_and_get_last_line_of_output("cat /tmp/cmdline");
 #else
-    if (strstr
-        (call_program_and_get_last_line_of_output("cat /proc/cmdline"),
-         "textonly"))
+    tmp = call_program_and_get_last_line_of_output("cat /proc/cmdline");
 #endif
-    {
+    if (strstr(tmp,"textonly")) {
         g_text_mode = TRUE;
         log_msg(1, "TEXTONLY MODE");
@@ -3233 +2712 @@
         g_text_mode = FALSE;
     }                           // newt :-)
+    paranoid_free(tmp);
+
     if (!
         (bkpinfo = g_bkpinfo_DONTUSETHIS =
@@ -3247 +2728 @@
     malloc_libmondo_global_strings();
 
-    asprintf(&g_mondo_home,
-             call_program_and_get_last_line_of_output
-             ("which mondorestore"));
+    g_mondo_home = call_program_and_get_last_line_of_output("which mondorestore"));
     sprintf(g_tmpfs_mountpt, "/tmp/tmpfs");
     make_hole_for_dir(g_tmpfs_mountpt);
@@ -3257 +2736 @@
     run_program_and_log_output("mkdir -p /mnt/floppy", FALSE);
 
-    malloc_string(tmp);
-    malloc_string(a);
-    malloc_string(b);
     setup_MR_global_filenames(bkpinfo); // malloc() and set globals, using bkpinfo->tmpdir etc.
     reset_bkpinfo(bkpinfo);
@@ -3281 +2757 @@
 
 /* Backup original mountlist.txt */
-    sprintf(tmp, "%s.orig", g_mountlist_fname);
+    asprintf(&tmp, "%s.orig", g_mountlist_fname);
     if (!does_file_exist(g_mountlist_fname)) {
         log_msg(2,
@@ -3287 +2763 @@
                 __LINE__, g_mountlist_fname);
     } else if (!does_file_exist(tmp)) {
-        sprintf(tmp, "cp -f %s %s.orig", g_mountlist_fname,
+        paranoid_free(tmp);
+        asprintf(&tmp, "cp -f %s %s.orig", g_mountlist_fname,
                 g_mountlist_fname);
         run_program_and_log_output(tmp, FALSE);
     }
+    paranoid_free(tmp);
 
 /* Init directories */
     make_hole_for_dir(bkpinfo->tmpdir);
-    sprintf(tmp, "mkdir -p %s", bkpinfo->tmpdir);
+    asprintf(&tmp, "mkdir -p %s", bkpinfo->tmpdir);
     run_program_and_log_output(tmp, FALSE);
+    paranoid_free(tmp);
+
     make_hole_for_dir("/var/log");
     make_hole_for_dir("/tmp/tmpfs");    /* just in case... */
     run_program_and_log_output("umount " MNT_CDROM, FALSE);
     run_program_and_log_output
-        ("ln -sf "MONDO_LOGFILE" /tmp/mondo-restore.log",
-         FALSE);
+        ("ln -sf " MONDO_LOGFILE " /tmp/mondo-restore.log", FALSE);
 
     run_program_and_log_output("rm -Rf /tmp/tmpfs/mondo.tmp.*", FALSE);
@@ -3361 +2840 @@
         system("rm -Rf /tmp/*pih*");
 
-        restore_a_biggiefile_from_CD(bkpinfo, 42, NULL, tmp);
+        (void)restore_a_biggiefile_from_CD(bkpinfo, 42, NULL);
     }
 
@@ -3378 +2857 @@
 //      finish(0);
 //      toggle_path_selection (filelist, "/root/stuff", TRUE);
-        strcpy(a, argv[3]);
-        strcpy(b, argv[4]);
+        asprintf(&a, argv[3]);
+        asprintf(&b, argv[4]);
 
         res = save_filelist_entries_in_common(a, filelist, b, FALSE);
         free_filelist(filelist);
+        paranoid_free(a);
+        paranoid_free(b);
         printf("res = %d", res);
         finish(0);
@@ -3444 +2925 @@
         if (argc != 1) {
             popup_and_OK
-                (_("Live mode doesn't support command-line parameters yet."));
+                (_
+                 ("Live mode doesn't support command-line parameters yet."));
             paranoid_MR_finish(1);
 //    return(1);
@@ -3454 +2936 @@
         if (argc > 1 && strcmp(argv[argc - 1], "--live-from-cd") == 0) {
             g_restoring_live_from_cd = TRUE;
-        }
-        if (argc == 5 && strcmp(argv[1], "--monitas-live") == 0) {
-            retval =
-                restore_live_from_monitas_server(bkpinfo,
-                                                 argv[2],
-                                                 argv[3], argv[4]);
         } else {
             log_msg(2, "Calling restore_to_live_filesystem()");
@@ -3466 +2942 @@
         log_msg(2, "Still here. Yay.");
         if (strlen(bkpinfo->tmpdir) > 0) {
-            sprintf(tmp, "rm -Rf %s/*", bkpinfo->tmpdir);
+            asprintf(&tmp, "rm -Rf %s/*", bkpinfo->tmpdir);
             run_program_and_log_output(tmp, FALSE);
+            paranoid_free(tmp);
         }
         unmount_boot_if_necessary();    /* for Gentoo users */
@@ -3496 +2973 @@
                 sprintf(bkpinfo->isodir, "/tmp/isodir");
                 run_program_and_log_output("mkdir -p /tmp/isodir", 5);
-                sprintf(tmp, "mount %s -t nfs -o nolock /tmp/isodir",
+                asprintf(&tmp, "mount %s -t nfs -o nolock /tmp/isodir",
                         bkpinfo->nfs_mount);
                 run_program_and_log_output(tmp, 1);
+                paranoid_free(tmp);
             }
         }
@@ -3505 +2983 @@
         if (retval) {
             log_to_screen
-                (_("Warning - load_raidtab_into_raidlist returned an error"));
+                (_
+                 ("Warning - load_raidtab_into_raidlist returned an error"));
         }
 
@@ -3577 +3056 @@
         if (does_file_exist("/tmp/changed.files")) {
             log_to_screen
-                (_("See /tmp/changed.files for list of files that have changed."));
+                (_
+                 ("See /tmp/changed.files for list of files that have changed."));
         }
         mvaddstr_and_log_it(g_currentY++,
                             0,
-                            _("Run complete. Errors were reported. Please review the logfile."));
+                            _
+                            ("Run complete. Errors were reported. Please review the logfile."));
     } else {
         if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
             mvaddstr_and_log_it(g_currentY++,
                                 0,
-                                _("Run complete. Please remove floppy/CD/media and reboot."));
+                                _
+                                ("Run complete. Please remove floppy/CD/media and reboot."));
         } else {
             run_program_and_log_output("sync", FALSE);
@@ -3607 +3089 @@
             mvaddstr_and_log_it(g_currentY++,
                                 0,
-                                _("Run complete. Please remove media and reboot."));
+                                _
+                                ("Run complete. Please remove media and reboot."));
         }
     }
@@ -3617 +3100 @@
             if (mount_all_devices(mountlist, TRUE)) {
                 log_to_screen
-                    (_("Unable to re-mount partitions for post-nuke stuff"));
+                    (_
+                     ("Unable to re-mount partitions for post-nuke stuff"));
             } else {
                 log_msg(1, "Re-mounted partitions for post-nuke stuff");
-                sprintf(tmp, "post-nuke %s %d", bkpinfo->restore_path,
+                asprintf(&tmp, "post-nuke %s %d", bkpinfo->restore_path,
                         retval);
                 if (!g_text_mode) {
@@ -3629 +3113 @@
                     log_OS_error(tmp);
                 }
+                paranoid_free(tmp);
                 if (!g_text_mode) {
                     newtResume();
@@ -3647 +3132 @@
     unlink("/tmp/mondo-run-prog.tmp");
     set_signals(FALSE);
-    sprintf(tmp, "rm -Rf %s", bkpinfo->tmpdir);
+    asprintf(&tmp, "rm -Rf %s", bkpinfo->tmpdir);
     run_program_and_log_output(tmp, FALSE);
+    paranoid_free(tmp);
+
     log_to_screen
-        (_("Restore log copied to /tmp/mondo-restore.log on your hard disk"));
-    sprintf(tmp,
-            _("Mondo-restore is exiting (retval=%d)                                      "),
+        (_
+         ("Restore log copied to /tmp/mondo-restore.log on your hard disk"));
+    asprintf(&tmp,
+            _
+            ("Mondo-restore is exiting (retval=%d)                                      "),
             retval);
     log_to_screen(tmp);
-    sprintf(tmp, "umount %s", bkpinfo->isodir);
+    paranoid_free(tmp);
+
+    asprintf(&tmp, "umount %s", bkpinfo->isodir);
     run_program_and_log_output(tmp, 5);
+    paranoid_free(tmp);
+
     paranoid_free(mountlist);
     paranoid_free(raidlist);
@@ -3664 +3157 @@
     paranoid_MR_finish(retval); // frees global stuff plus bkpinfo
     free_libmondo_global_strings(); // it's fine to have this here :) really :)
-    paranoid_free(a);
-    paranoid_free(b);
-    paranoid_free(tmp);
 
     unlink("/tmp/filelist.full");
@@ -3679 +3169 @@
 
 
-
-
-
 /**************************************************************************
  *END_MONDO-RESTORE.C                                                     *

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

@@ -1 @@
-/* mondo-restore.h
+/* 
  * $Id$
- */
+**/
 
 /**************************************************************************
@@ -22 +22 @@
 int restore_mode(struct s_bkpinfo *, struct mountlist_itself *,
                  struct raidlist_itself *);
-int restore_a_biggiefile_from_CD(struct s_bkpinfo *, long, struct s_node *,
-                                 char *);
 int restore_a_biggiefile_from_stream(struct s_bkpinfo *, char *, long,
                                      char *, long long, struct s_node *,

trunk/mondo/mondo/mondorestore/mondo-rstr-compare-EXT.h

@@ -1 @@
-/* mondo-rstr-compare-EXT.h */
+/* 
+ * $Id$
+**/
 
 

trunk/mondo/mondo/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
-*/
+ * $Id$ - compares mondoarchive data
+**/
 
 
@@ -58 +7 @@
 #include "../common/mondostructures.h"
 #include "../common/libmondo.h"
-//#include "../../config.h"
 #include "mr-externs.h"
 #include "mondo-rstr-compare.h"
@@ -67 +15 @@
 #endif
 
-//static char cvsid[] = "$Id$";
-
 void popup_changelist_from_file(char *);
 
@@ -89 +35 @@
 
   /** needs malloc *******/
-    char *checksum_ptr;
-    char *original_cksum_ptr;
-    char *bigfile_fname_ptr;
-    char *tmp_ptr;
-    char *command_ptr;
-
-    char *checksum, *original_cksum, *bigfile_fname, *tmp, *command;
-
-    char *p;
-    int i;
+    char *checksum = NULL;
+    char *original_cksum = NULL;
+    char *bigfile_fname = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *command = NULL;
+
+    char *p = NULL;
+    int i = 0;
+    int n = 0;
     int retval = 0;
 
     struct s_filename_and_lstat_info biggiestruct;
 
-    malloc_string(checksum);
-    malloc_string(original_cksum);
-    malloc_string(bigfile_fname);
-    malloc_string(tmp);
-    malloc_string(command);
-    malloc_string(checksum_ptr);
-    malloc_string(original_cksum_ptr);
-    malloc_string(bigfile_fname_ptr);
-    malloc_string(command_ptr);
-    malloc_string(tmp_ptr);
-
-  /*********************************************************************
-   * allocate memory clear test                sab 16 feb 2003         *
-   *********************************************************************/
     assert(bkpinfo != NULL);
-    memset(checksum_ptr, '\0', sizeof(checksum));
-    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 **/
-
-    if (!does_file_exist(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""))) {
+
+    tmp1 = slice_fname(bigfileno, 0, ARCHIVES_PATH, "");
+    if (!does_file_exist(tmp1)) {
         if (does_file_exist(MNT_CDROM "/archives/NOT-THE-LAST")) {
             insist_on_this_cd_number(bkpinfo, (++g_current_media_number));
         } else {
-            sprintf(tmp_ptr,
-                    "No CD's left. No biggiefiles left. No prob, Bob.");
-            log_msg(2, tmp_ptr);
+            log_msg(2, "No CD's left. No biggiefiles left. No problem.");
             return (0);
         }
     }
-    if (!(fin = fopen(slice_fname(bigfileno, 0, ARCHIVES_PATH, ""), "r"))) {
-        sprintf(tmp_ptr,
-                _("Cannot open bigfile %ld (%s)'s info file"),
-                bigfileno + 1, bigfile_fname_ptr);
-        log_to_screen(tmp_ptr);
+    if (!(fin = fopen(tmp1, "r"))) {
+        asprintf(&tmp, _("Cannot open bigfile %ld (%s)'s info file"),
+                bigfileno + 1, tmp);
+        log_to_screen(tmp);
+        paranoid_free(tmp);
+        paranoid_free(tmp1);
         return (1);
     }
@@ -145 +71 @@
     paranoid_fclose(fin);
 
-    strcpy(checksum_ptr, biggiestruct.checksum);
-    strcpy(bigfile_fname_ptr, biggiestruct.filename);
-
-    log_msg(2, "biggiestruct.filename = %s", biggiestruct.filename);
-    log_msg(2, "biggiestruct.checksum = %s", biggiestruct.checksum);
-
-    sprintf(tmp_ptr, _("Comparing %s"), bigfile_fname_ptr);
+    asprintf(&checksum, biggiestruct.checksum);
+    asprintf(&bigfile_fname, biggiestruct.filename);
+
+    log_msg(2, "biggiestruct.filename = %s", bigfile_fname);
+    log_msg(2, "biggiestruct.checksum = %s", checksum);
 
     if (!g_text_mode) {
-        newtDrawRootText(0, 22, tmp_ptr);
+        asprintf(&tmp, _("Comparing %s"), bigfile_fname);
+        newtDrawRootText(0, 22, tmp);
         newtRefresh();
-    }
+        paranoid_free(tmp);
+    }
+    /* BERLIOS: Useless ?
     if (!checksum[0]) {
         log_msg(2, "Warning - %s has no checksum", bigfile_fname_ptr);
-    }
-    if (!strncmp(bigfile_fname_ptr, "/dev/", 5)) {
-        strcpy(original_cksum_ptr, "IGNORE");
-    } else {
-        sprintf(command_ptr,
+    } */
+    if (!strncmp(bigfile_fname, "/dev/", 5)) {
+        log_msg(2, _("Ignoring device %s"), bigfile_fname);
+        return(0);
+    } else {
+        asprintf(&command,
                 "md5sum \"%s%s\" > /tmp/md5sum.txt 2> /tmp/errors.txt",
-                MNT_RESTORING, bigfile_fname_ptr);
-    }
-    log_msg(2, command_ptr);
-    paranoid_system
-        ("cat /tmp/errors >> /tmp/mondo-restore.log 2> /dev/null");
-    if (system(command_ptr)) {
+                MNT_RESTORING, bigfile_fname);
+    }
+    log_msg(2, command);
+    paranoid_system("cat /tmp/errors >> /tmp/mondo-restore.log 2> /dev/null");
+    if (system(command)) {
         log_OS_error("Warning - command failed");
-        original_cksum[0] = '\0';
+        paranoid_free(command);
+        paranoid_free(bigfile_fname);
         return (1);
     } else {
+        paranoid_free(command);
         if (!(fin = fopen("/tmp/md5sum.txt", "r"))) {
-            log_msg(2,
-                    "Unable to open /tmp/md5sum.txt; can't get live checksum");
-            original_cksum[0] = '\0';
+            log_msg(2, "Unable to open /tmp/md5sum.txt; can't get live checksum");
+            paranoid_free(bigfile_fname);
             return (1);
         } else {
-            fgets(original_cksum_ptr, MAX_STR_LEN - 1, fin);
+            getline(&original_cksum, &n, fin);
             paranoid_fclose(fin);
-            for (i = strlen(original_cksum_ptr);
+            for (i = strlen(original_cksum);
                  i > 0 && original_cksum[i - 1] < 32; i--);
             original_cksum[i] = '\0';
-            p = (char *) strchr(original_cksum_ptr, ' ');
+            p = (char *) strchr(original_cksum, ' ');
             if (p) {
                 *p = '\0';
@@ -192 +120 @@
         }
     }
-    sprintf(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");
+    if (!strcmp(checksum, original_cksum) != 0) {
+        log_msg(1, "bigfile #%ld ('%s') ... OK", bigfileno + 1, bigfile_fname);
+    } else {
+        log_msg(1, "bigfile #%ld ('%s') ... changed", bigfileno + 1, bigfile_fname);
         retval++;
     }
-    log_msg(1, tmp_ptr);
+    paranoid_free(original_cksum);
+    paranoid_free(checksum);
+
     if (retval) {
         if (!(fout = fopen("/tmp/changed.txt", "a"))) {
             fatal_error("Cannot openout changed.txt");
         }
-        fprintf(fout, "%s\n", bigfile_fname_ptr);
+        fprintf(fout, "%s\n", bigfile_fname);
         paranoid_fclose(fout);
     }
-
-    paranoid_free(original_cksum_ptr);
-    paranoid_free(original_cksum);
-    paranoid_free(bigfile_fname_ptr);
     paranoid_free(bigfile_fname);
-    paranoid_free(checksum_ptr);
-    paranoid_free(checksum);
-    paranoid_free(command_ptr);
-    paranoid_free(command);
-    paranoid_free(tmp_ptr);
-    paranoid_free(tmp);
 
     return (retval);
@@ -238 +156 @@
     int res;
     long noof_biggiefiles, bigfileno = 0;
-    char tmp[MAX_STR_LEN];
+    char *tmp;
 
     assert(bkpinfo != NULL);
@@ -254 +172 @@
     }
     mvaddstr_and_log_it(g_currentY, 0,
-                        _("Comparing large files                                                  "));
+                        _
+                        ("Comparing large files                                                  "));
     open_progress_form(_("Comparing large files"),
                        _("I am now comparing the large files"),
@@ -260 +179 @@
                        noof_biggiefiles);
     for (bigfileno = 0; bigfileno < noof_biggiefiles; bigfileno++) {
-        sprintf(tmp, "Comparing big file #%ld", bigfileno + 1);
+        asprintf(&tmp, "Comparing big file #%ld", bigfileno + 1);
         log_msg(1, tmp);
         update_progress_form(tmp);
+        paranoid_free(tmp);
         res = compare_a_biggiefile(bkpinfo, bigfileno);
         retval += res;
@@ -268 +188 @@
     }
     close_progress_form();
+    /* BERLIOS: useless ?
     return (0);
+    */
     if (retval) {
         mvaddstr_and_log_it(g_currentY++, 74, _("Errors."));
@@ -299 +221 @@
 
   /***  needs malloc *********/
-    char *command, *tmp, *filelist_name, *logfile, *archiver_exe,
-        *compressor_exe;
-
-    malloc_string(command);
-    malloc_string(tmp);
-    malloc_string(filelist_name);
-    malloc_string(logfile);
-    malloc_string(archiver_exe);
-    malloc_string(compressor_exe);
+    char *command = NULL;
+    char *tmp = NULL;
+    char *filelist_name = NULL;
+    char *logfile = NULL;
+    char *archiver_exe = NULL;
+    char *compressor_exe = NULL;
 
     use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
     assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
-    sprintf(logfile, "/tmp/afio.log.%d", current_tarball_number);
-    sprintf(filelist_name, MNT_CDROM "/archives/filelist.%d",
+    asprintf(&filelist_name, MNT_CDROM "/archives/filelist.%d",
             current_tarball_number);
 
     noof_lines = count_lines_in_file(filelist_name);
+    paranoid_free(filelist_name);
 
     if (strstr(tarball_fname, ".bz2")) {
-        strcpy(compressor_exe, "bzip2");
+        asprintf(&compressor_exe, "bzip2");
     } else if (strstr(tarball_fname, ".lzo")) {
-        strcpy(compressor_exe, "lzop");
-    } else {
-        compressor_exe[0] = '\0';
+        asprintf(&compressor_exe, "lzop");
+    } else {
+        compressor_exe = NULL;
     }
 
     if (use_star) {
-        strcpy(archiver_exe, "star");
-    } else {
-        strcpy(archiver_exe, "afio");
-    }
-
-    if (compressor_exe[0]) {
-        strcpy(tmp, compressor_exe);
-        if (!find_home_of_exe(tmp)) {
+        asprintf(&archiver_exe, "star -bz");
+    } else {
+        asprintf(&archiver_exe, "afio");
+    }
+
+    if (compressor_exe != NULL) {
+        if (!find_home_of_exe(compressor_exe)) {
             fatal_error("(compare_a_tarball) Compression program missing");
         }
-        if (use_star)           // star
-        {
-            if (!strcmp(compressor_exe, "bzip2")) {
-                strcat(archiver_exe, " -bz");
-            } else {
+        if (use_star) {
+            if (strcmp(compressor_exe, "bzip2")) {
                 fatal_error
                     ("(compare_a_tarball) Please use only bzip2 with star");
             }
-        } else                  // afio
-        {
+        } else {
+            asprintf(&tmp, compressor_exe);
             sprintf(compressor_exe, "-P %s -Z", tmp);
+            paranoid_free(tmp);
         }
     }
@@ -356 +272 @@
 #define BUFSIZE (1024L*1024L)/TAPE_BLOCK_SIZE
 #endif
+
+    asprintf(&logfile, "/tmp/afio.log.%d", current_tarball_number);
     if (use_star)               // doesn't use compressor_exe
     {
-        sprintf(command,
+        asprintf(&command,
                 "%s -diff H=star file=%s >> %s 2>> %s",
                 archiver_exe, tarball_fname, logfile, logfile);
     } else {
-        sprintf(command,
+        asprintf(&command,
                 "%s -r -b %ld -M 16m -c %ld %s %s >> %s 2>> %s",
                 archiver_exe,
@@ -369 +287 @@
     }
 #undef BUFSIZE
+    paranoid_free(archiver_exe);
+    paranoid_free(compressor_exe);
 
     res = system(command);
@@ -374 +294 @@
     if (res) {
         log_OS_error(command);
-        sprintf(tmp, "Warning - afio returned error = %d", res);
     }
     if (length_of_file(logfile) > 5) {
@@ -385 +304 @@
         archiver_errors = 0;
     }
-    sprintf(tmp, "%ld difference%c in fileset #%d          ",
-            archiver_errors, (archiver_errors != 1) ? 's' : ' ',
-            current_tarball_number);
+    paranoid_free(command);
+
     if (archiver_errors) {
-        sprintf(tmp,
+        asprintf(&tmp,
                 "Differences found while processing fileset #%d       ",
                 current_tarball_number);
         log_msg(1, tmp);
+        paranoid_free(tmp);
     }
     unlink(logfile);
-    paranoid_free(command);
-    paranoid_free(tmp);
-    paranoid_free(filelist_name);
     paranoid_free(logfile);
-    malloc_string(archiver_exe);
-    malloc_string(compressor_exe);
     return (retval);
 }
@@ -422 +336 @@
   /**  needs malloc **********/
 
-    char *tarball_fname, *progress_str, *tmp;
+    char *tarball_fname = NULL;
+    char *progress_str = NULL;
+    char *tmp = NULL;
     long max_val;
-
-    malloc_string(tarball_fname);
-    malloc_string(progress_str);
-    malloc_string(tmp);
 
     assert(bkpinfo != NULL);
@@ -434 +346 @@
 
     max_val = atol(tmp);
-    sprintf(progress_str, _("Comparing with %s #%d "),
+    paranoid_free(tmp);
+
+    asprintf(&progress_str, _("Comparing with %s #%d "),
             media_descriptor_string(bkpinfo->backup_media_type),
             g_current_media_number);
@@ -448 +362 @@
         insist_on_this_cd_number(bkpinfo, g_current_media_number);
         update_progress_form(progress_str);
-        sprintf(tarball_fname,
+        asprintf(&tarball_fname,
                 MNT_CDROM "/archives/%d.afio.bz2", current_tarball_number);
 
         if (!does_file_exist(tarball_fname)) {
-            sprintf(tarball_fname, MNT_CDROM "/archives/%d.afio.lzo",
+            paranoid_free(tarball_fname);
+            asprintf(&tarball_fname, MNT_CDROM "/archives/%d.afio.lzo",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            sprintf(tarball_fname, MNT_CDROM "/archives/%d.afio.",
+            paranoid_free(tarball_fname);
+            asprintf(&tarball_fname, MNT_CDROM "/archives/%d.afio.",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            sprintf(tarball_fname, MNT_CDROM "/archives/%d.star.bz2",
+            paranoid_free(tarball_fname);
+            asprintf(&tarball_fname, MNT_CDROM "/archives/%d.star.bz2",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            sprintf(tarball_fname, MNT_CDROM "/archives/%d.star.",
+            paranoid_free(tarball_fname);
+            asprintf(&tarball_fname, MNT_CDROM "/archives/%d.star.",
                     current_tarball_number);
         }
@@ -473 +391 @@
                 == 0) {
                 log_msg(2, "OK, I think I'm done with tarballs...");
+                paranoid_free(tarball_fname);
                 break;
             }
             log_msg(2, "OK, I think it's time for another CD...");
             g_current_media_number++;
-            sprintf(progress_str, _("Comparing with %s #%d "),
+            paranoid_free(progress_str);
+            asprintf(&progress_str, _("Comparing with %s #%d "),
                     media_descriptor_string(bkpinfo->backup_media_type),
                     g_current_media_number);
@@ -483 +403 @@
         } else {
             res = compare_a_tarball(tarball_fname, current_tarball_number);
+            paranoid_free(tarball_fname);
 
             g_current_progress++;
@@ -488 +409 @@
         }
     }
+    paranoid_free(progress_str);
     close_progress_form();
+
     if (retval) {
         mvaddstr_and_log_it(g_currentY++, 74, _("Errors."));
@@ -494 +417 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     }
-    paranoid_free(tarball_fname);
-    paranoid_free(progress_str);
-    paranoid_free(tmp);
     return (retval);
 }
@@ -519 +439 @@
 {
   /** needs malloc *********/
-    char *tmp, *cwd, *new, *command;
+    char *tmp = NULL;
+    char *cwd = NULL;
+    char *new = NULL;
+    char *command = NULL;
     int resA = 0;
     int resB = 0;
     long noof_changed_files;
 
-    malloc_string(tmp);
     malloc_string(cwd);
     malloc_string(new);
-    malloc_string(command);
 
     assert(bkpinfo != NULL);
@@ -534 +455 @@
     chdir(bkpinfo->restore_path);
     getcwd(new, MAX_STR_LEN - 1);
-    sprintf(tmp, "new path is %s", new);
     insist_on_this_cd_number(bkpinfo, g_current_media_number);
     unlink("/tmp/changed.txt");
@@ -543 +463 @@
     noof_changed_files = count_lines_in_file("/tmp/changed.txt");
     if (noof_changed_files) {
-        sprintf(tmp, _("%ld files do not match the backup            "),
+        asprintf(&tmp, _("%ld files do not match the backup            "),
                 noof_changed_files);
         //      mvaddstr_and_log_it( g_currentY++, 0, tmp );
         log_to_screen(tmp);
-        sprintf(command, "cat /tmp/changed.txt >> %s", MONDO_LOGFILE);
+        paranoid_free(tmp);
+
+        asprintf(&command, "cat /tmp/changed.txt >> %s", MONDO_LOGFILE);
         paranoid_system(command);
-    } else {
-        sprintf(tmp, _("All files match the backup                     "));
+        paranoid_free(command);
+    } else {
+        asprintf(&tmp, _("All files match the backup                     "));
         mvaddstr_and_log_it(g_currentY++, 0, tmp);
         log_to_screen(tmp);
-    }
-
-    paranoid_free(tmp);
+        paranoid_free(tmp);
+    }
+
     paranoid_free(cwd);
     paranoid_free(new);
-    paranoid_free(command);
 
     return (resA + resB);
@@ -566 +488 @@
  *END_COMPARE_TO_CD                                                       *
  **************************************************************************/
-
-
 
 
@@ -588 +508 @@
     char *tmp;
 
-    malloc_string(tmp);
-
   /**************************************************************************
    * also deletes tmp/filelist.full & tmp/biggielist.txt _and_ tries to     *
@@ -600 +518 @@
     while (get_cfg_file_from_archive(bkpinfo)) {
         if (!ask_me_yes_or_no
-            (_("Failed to find config file/archives. Choose another source?")))
+            (_
+             ("Failed to find config file/archives. Choose another source?")))
         {
             fatal_error("Unable to find config file/archives. Aborting.");
@@ -628 +547 @@
         mvaddstr_and_log_it(g_currentY++,
                             0,
-                            _("Warning - differences found during the compare phase"));
+                            _
+                            ("Warning - differences found during the compare phase"));
     }
 
@@ -635 +555 @@
     if (count_lines_in_file("/tmp/changed.txt") > 0) {
         mvaddstr_and_log_it(g_currentY++, 0,
-                            _("Differences found while files were being compared."));
+                            _
+                            ("Differences found while files were being compared."));
         streamline_changes_file("/tmp/changed.files", "/tmp/changed.txt");
         if (count_lines_in_file("/tmp/changed.files") <= 0) {
             mvaddstr_and_log_it(g_currentY++, 0,
-                                _("...but they were logfiles and temporary files. Your archives are fine."));
-            log_to_screen
-                (_("The differences were logfiles and temporary files. Your archives are fine."));
+                                _
+                                ("...but they were logfiles and temporary files. Your archives are fine."));
+            log_to_screen(_
+                          ("The differences were logfiles and temporary files. Your archives are fine."));
         } else {
             q = count_lines_in_file("/tmp/changed.files");
-            sprintf(tmp, _("%ld significant difference%s found."), q,
+            asprintf(&tmp, _("%ld significant difference%s found."), q,
                     (q != 1) ? "s" : "");
             mvaddstr_and_log_it(g_currentY++, 0, tmp);
             log_to_screen(tmp);
-
-            strcpy(tmp,
+            paranoid_free(tmp);
+
+            asprintf(&tmp,
                    _("Type 'less /tmp/changed.files' for a list of non-matching files"));
             mvaddstr_and_log_it(g_currentY++, 0, tmp);
             log_to_screen(tmp);
+            paranoid_free(tmp);
 
             log_msg(2, "calling popup_changelist_from_file()");
@@ -660 +584 @@
     } else {
         log_to_screen
-            (_("No significant differences were found. Your backup is perfect."));
+            (_
+             ("No significant differences were found. Your backup is perfect."));
     }
     kill_petris();
-    paranoid_free(tmp);
     return (retval);
 }
@@ -670 +594 @@
  *END_COMPARE_MODE                                                        *
  **************************************************************************/
+
 
 /**
@@ -683 +608 @@
     int res;
 
+    char *dir = NULL;
+    char *command = NULL;
+
+    assert(bkpinfo != NULL);
   /** needs malloc **/
-    char *dir, *command, *tmp;
-
-    assert(bkpinfo != NULL);
     malloc_string(dir);
-    malloc_string(command);
     getcwd(dir, MAX_STR_LEN);
     chdir(bkpinfo->restore_path);
 
-    sprintf(command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp",
+    asprintf(&command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp",
             bkpinfo->restore_path);
     run_program_and_log_output(command, FALSE);
+    paranoid_free(command);
     mvaddstr_and_log_it(g_currentY,
                         0, _("Verifying archives against filesystem"));
@@ -700 +626 @@
     if (bkpinfo->disaster_recovery
         && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
-        asprintf(&tmp, 
-               last_line_of_file("/tmp/CDROM-LIVES-HERE"));
         paranoid_free(bkpinfo->media_device);
-        bkpinfo->media_device = tmp;
+        // last_line_of_file allocates the string
+        bkpinfo->media_device = last_line_of_file("/tmp/CDROM-LIVES-HERE");
     } else {
         paranoid_free(bkpinfo->media_device);
+        // find_cdrom_device allocates the string
         bkpinfo->media_device = find_cdrom_device(FALSE);
     }
@@ -721 +647 @@
     mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     paranoid_free(dir);
-    paranoid_free(command);
     return (res);
 }
@@ -744 +669 @@
 {
     int res;
-    char *dir, *command;
+    char *dir = NULL;
+    char *command = NULL;
 
     assert(bkpinfo != NULL);
     malloc_string(dir);
-    malloc_string(command);
 
     getcwd(dir, MAX_STR_LEN);
     chdir(bkpinfo->restore_path);
-    sprintf(command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp",
+    asprintf(&command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp",
             bkpinfo->restore_path);
     run_program_and_log_output(command, FALSE);
+    paranoid_free(command);
+
     mvaddstr_and_log_it(g_currentY,
                         0, _("Verifying archives against filesystem"));
@@ -765 +692 @@
     }
     paranoid_free(dir);
-    paranoid_free(command);
     return (res);
 }

trunk/mondo/mondo/mondorestore/mondo-rstr-compare.h

@@ -1 @@
-/* mondo-rstr-compare.h
+/*
  * $Id$
- */
+**/
 
 

trunk/mondo/mondo/mondorestore/mondo-rstr-newt.c

@@ -1 +1 @@
 /***************************************************************************
  * $Id$
-*/
+**/
 
 
@@ -11 +11 @@
 #ifdef __FreeBSD__
 #define OSSWAP(linux,fbsd) fbsd
-//#include <libgen.h>
 #else
 #define OSSWAP(linux,fbsd) linux
@@ -17 +16 @@
 
 #include "mondo-rstr-newt.h"
-
-//static char cvsid[] = "$Id$";
-
-extern char err_log_lines[NOOF_ERR_LINES][MAX_STR_LEN];
-
 
 /**
@@ -57 +51 @@
 {
     /** buffers ***********************************************************/
-    char *tmp;
+    char *tmp = NULL;
 
     /** newt **************************************************************/
@@ -82 +76 @@
 
     newtPushHelpLine
-        (_("   Add one of the following unallocated RAID partitions to this RAID device."));
+        (_
+         ("   Add one of the following unallocated RAID partitions to this RAID device."));
     asprintf(&tmp, "%-26s %s", _("Device"), _("Size"));
     headerMsg = newtLabel(1, 1, tmp);
@@ -157 +152 @@
     newtComponent formatComp;
 
-    /** buffers **********************************************************/
-    char *drive_to_add;
-    char *mountpoint_str;
+    char *drive_to_add = NULL;
+    char *mountpoint_str = NULL;
     char *size_str = NULL;
-    char *device_str;
-    char *format_str;
-
-    /** pointers *********************************************************/
-    char *mountpoint_here;
-    char *size_here;
-    char *device_here;
-    char *format_here;
+    char *device_str = NULL;
+    char *format_str = NULL;
+    char *mountpoint_here = NULL;
+    char *size_here = NULL;
+    char *device_here = NULL;
+    char *format_here = NULL;
 
     assert(mountlist != NULL);
@@ -198 +190 @@
     bCancel = newtButton(17, 6, _("Cancel"));
     newtPushHelpLine
-        (_("To add an entry to the mountlist, please fill in these fields and then hit 'OK'"));
+        (_
+         ("To add an entry to the mountlist, please fill in these fields and then hit 'OK'"));
     myForm = newtForm(NULL, NULL, 0);
     newtFormAddComponents(myForm, deviceComp, mountpointComp, sizeComp,
@@ -229 +222 @@
             if (size_of_specific_device_in_mountlist(mountlist, device_str)
                 >= 0) {
-                popup_and_OK(_("Can't add this - you've got one already!"));
+                popup_and_OK(_
+                             ("Can't add this - you've got one already!"));
                 b_res = NULL;
             }
@@ -286 +280 @@
 
     if (popup_and_get_string
-        ("Add variable", _("Enter the name of the variable to add"), sz_out,
-         MAX_STR_LEN)) {
-        strip_spaces(sz_out);
+        ("Add variable", _("Enter the name of the variable to add"),
+         sz_out)) {
         items = raidrec->additional_vars.entries;
         for (i = 0;
@@ -295 +288 @@
         if (i < items) {
             popup_and_OK
-                (_("No need to add that variable. It is already listed here."));
+                (_
+                 ("No need to add that variable. It is already listed here."));
         } else {
             strcpy(raidrec->additional_vars.el[items].label, sz_out);
@@ -302 +296 @@
         }
     }
+    paranoid_free(sz_out);
 }
 #endif
@@ -322 +317 @@
 
     /** structures ********************************************************/
-    struct vinum_volume *raidrec;
-
-    /** int ***************************************************************/
+    struct vinum_volume *raidrec = NULL;
+
     int i = 0, j = 0;
     int noof_partitions = 0;
 
-    /** long **************************************************************/
     long total_size = 0;
     long plex_size = 0;
@@ -335 +328 @@
     long sp = 0;
 
-    /** buffers ***********************************************************/
-    char *tmp;
-    char *devname;
-
-
-
+    char *tmp = NULL;
+    char *devname = NULL;
 
     for (i = 0;
@@ -347 +336 @@
     if (i == raidlist->entries) {
         asprintf(&tmp,
-                "Cannot calc size of raid device %s - cannot find it in raidlist",
-                raid_device);
+                 "Cannot calc size of raid device %s - cannot find it in raidlist",
+                 raid_device);
         log_it(tmp);
         paranoid_free(tmp);
@@ -411 +400 @@
     }
 
-    asprintf(&tmp, "I have calculated %s's real size to be %ld", raid_device,
-            (long) smallest_plex);
+    asprintf(&tmp, "I have calculated %s's real size to be %ld",
+             raid_device, (long) smallest_plex);
     log_it(tmp);
     paranoid_free(tmp);
@@ -420 +409 @@
 
     /** structures ********************************************************/
-    struct raid_device_record *raidrec;
+    struct raid_device_record *raidrec = NULL;
 
     /** int ***************************************************************/
@@ -432 +421 @@
 
     /** buffers ***********************************************************/
-    char *tmp;
+    char *tmp = NULL;
 
     assert(mountlist != NULL);
@@ -443 +432 @@
     if (i == raidlist->entries) {
         asprintf(&tmp,
-                "Cannot calc size of raid device %s - cannot find it in raidlist",
-                raid_device);
+                 "Cannot calc size of raid device %s - cannot find it in raidlist",
+                 raid_device);
         log_it(tmp);
         paranoid_free(tmp);
@@ -469 +458 @@
         total_size = smallest_partition * (noof_partitions - 1);
     }
-    asprintf(&tmp, "I have calculated %s's real size to be %ld", raid_device,
-            (long) total_size);
+    asprintf(&tmp, "I have calculated %s's real size to be %ld",
+             raid_device, (long) total_size);
     log_it(tmp);
     paranoid_free(tmp);
@@ -478 +467 @@
 
 
-
 /**
  * Choose the RAID level for the RAID device record in @p raidrec.
@@ -495 +483 @@
 
     /** buffers ***********************************************************/
-    char *tmp;
-    char *prompt;
-    char *sz;
+    char *tmp = NULL;
+    char *prompt = NULL;
+    char *sz = NULL;
 
     asprintf(&prompt,
-            _("Please enter the RAID level you want. (concat, striped, raid5)"));
+             _
+             ("Please enter the RAID level you want. (concat, striped, raid5)"));
     if (raidrec->raidlevel == -1) {
         asprintf(&tmp, "concat");
@@ -509 +498 @@
     }
     for (out = 999; out == 999;) {
-        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
+        res = popup_and_get_string("Specify RAID level", prompt, tmp);
         if (!res) {
             return;
         }
-        strip_spaces(tmp);
+        /* BERLIOS: Useless ??? 
         if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
             asprintf(&sz, tmp);
@@ -520 +509 @@
             paranoid_free(sz);
         }
+        */
         if (!strcmp(tmp, "concat")) {
             out = -1;
@@ -544 +534 @@
 #else
     /** buffers ***********************************************************/
-    char *tmp;
-    char personalities[MAX_STR_LEN];
-    char *prompt;
-    char *sz;
+    char *tmp = NULL;
+    char *personalities = NULL;
+    char *prompt = NULL;
+    char *sz = NULL;
     int out = 0, res = 0;
 
@@ -554 +544 @@
     system
         ("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null");
-    strcpy(personalities,
-           last_line_of_file("/tmp/raid-personalities.txt"));
+    personalities = last_line_of_file("/tmp/raid-personalities.txt"));
     asprintf(&prompt, _("Please enter the RAID level you want. %s"),
-            personalities);
+             personalities);
+    paranoid_free(personalities);
+
     if (raidrec->raid_level == -1) {
         asprintf(&tmp, "linear");
@@ -566 +557 @@
          out != -1 && out != 0 && out != 1 && out != 4 && out != 5
          && out != 10;) {
-        res = popup_and_get_string(_("Specify RAID level"), prompt, tmp, 10);
+        res =
+            popup_and_get_string(_("Specify RAID level"), prompt, tmp);
         if (!res) {
             return;
         }
-        strip_spaces(tmp);
+        /* BERLIOS: Useless ???
         if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
             asprintf(&sz, tmp);
-            strncpy(tmp, sz + 1, strlen(sz) - 2);
+            paranoid_free(tmp);
+
+            asprintf(&tmp, sz + 1);
             tmp[strlen(sz) - 2] = '\0';
             paranoid_free(sz);
         }
+        */
         if (!strcmp(tmp, "linear")) {
             out = -1;
@@ -585 +580 @@
         }
         log_it(tmp);
-        paranoid_free(tmp);
         if (is_this_raid_personality_registered(out)) {
             log_it
@@ -591 +585 @@
         } else {
             if (ask_me_yes_or_no
-                (_("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")))
+                (_
+                 ("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")))
             {
                 out = 999;
@@ -597 +592 @@
         }
     }
+    paranoid_free(tmp);
     paranoid_free(prompt);
     raidrec->raid_level = out;
@@ -622 +618 @@
 
     /** buffers ***********************************************************/
-    char *tmp;
+    char *tmp = NULL;
 
     assert(mountlist != NULL);
@@ -634 +630 @@
              pos++);
         if (pos < mountlist->entries) {
-            asprintf(&tmp,
-                    "Deleting partition %s cos it was part of a now-defunct RAID",
-                    mountlist->el[pos].device);
-            log_it(tmp);
-            paranoid_free(tmp);
+            log_it("Deleting partition %s cos it was part of a now-defunct RAID",
+                     mountlist->el[pos].device);
             memcpy((void *) &mountlist->el[pos],
                    (void *) &mountlist->el[mountlist->entries - 1],
@@ -665 +658 @@
 
     /** buffers ***********************************************************/
-    char *tmp;
+    char *tmp = NULL;
 
     assert(disklist != NULL);
@@ -671 +664 @@
 
     asprintf(&tmp, _("Delete %s from RAID device %s - are you sure?"),
-            disklist->el[currline].device, raid_device);
+             disklist->el[currline].device, raid_device);
     if (!ask_me_yes_or_no(tmp)) {
         paranoid_free(tmp);
@@ -705 +698 @@
 
     /** buffers ***********************************************************/
-    char *tmp;
-    char *device;
+    char *tmp = NULL;
+    char *device = NULL;
 
     assert(mountlist != NULL);
@@ -718 +711 @@
                                                   device);
     if (pos >= 0) {
-        asprintf(&tmp, _("Cannot delete %s: it is in use by RAID device %s"),
-                mountlist->el[currline].device,
-                raidlist->el[pos].OSSWAP(raid_device, volname));
+        asprintf(&tmp,
+                 _("Cannot delete %s: it is in use by RAID device %s"),
+                 mountlist->el[currline].device,
+                 raidlist->el[pos].OSSWAP(raid_device, volname));
         popup_and_OK(tmp);
         paranoid_free(tmp);
@@ -726 +720 @@
     }
     asprintf(&tmp, _("Delete %s - are you sure?"),
-            mountlist->el[currline].device);
+             mountlist->el[currline].device);
     if (!ask_me_yes_or_no(tmp)) {
         paranoid_free(tmp);
@@ -740 +734 @@
              && strcmp(mountlist->el[currline].device, device);
              currline++);
-        if (currline == mountlist->entries) {
-            log_it("Dev is gone. I can't delete it. Ho-hum");
-            paranoid_free(device);
-            return;
-        }
+            if (currline == mountlist->entries) {
+                log_it("Dev is gone. I can't delete it. Ho-hum");
+                paranoid_free(device);
+                return;
+            }
         paranoid_free(device);
     }
@@ -775 +769 @@
 
     /** buffers ***********************************************************/
-    char *tmp;
+    char *tmp = NULL;
 
     assert(mountlist != NULL);
@@ -785 +779 @@
         return;
     }
-    asprintf(&tmp, _("Do you want me to delete %s's partitions, too?", device));
+    asprintf(&tmp,
+             _("Do you want me to delete %s's partitions, too?"), device);
     delete_partitions_too = ask_me_yes_or_no(tmp);
     if (delete_partitions_too) {
@@ -846 +841 @@
 
     /** buffers ************************************************************/
-    char *tmp;
+    char *tmp = NULL;
 
     /** structures *********************************************************/
-    struct additional_raid_variables *av;
+    struct additional_raid_variables *av = NULL;
 
     assert(raidrec != NULL);
 
     av = &raidrec->additional_vars;
-    asprintf(&tmp, _("Delete %s - are you sure?", av->el[lino].label));
+    asprintf(&tmp, _("Delete %s - are you sure?"), av->el[lino].label);
     if (ask_me_yes_or_no(tmp)) {
         if (!strcmp(av->el[lino].label, "persistent-superblock")
@@ -860 +855 @@
             paranoid_free(tmp);
             asprintf(&tmp, _("%s must not be deleted. It would be bad."),
-                    av->el[lino].label);
+                     av->el[lino].label);
             popup_and_OK(tmp);
         } else {
@@ -891 +886 @@
 
     /** structures *******************************************************/
-    struct s_node *node;
+    struct s_node *node = NULL;
 
     /** buffers **********************************************************/
-    static char *current_filename;
-    char *tmp;
+    static char *current_filename = NULL;
+    char *tmp = NULL;
 
     /** bool *************************************************************/
@@ -905 +900 @@
     assert(keylist != NULL);
     assert(listbox != NULL);
-
 
     if (depth == 0) {
@@ -927 +921 @@
                     warned_already = TRUE;
                     asprintf(&tmp,
-                            _("Too many lines. Displaying first %d entries only. Close a directory to see more."),
-                            ARBITRARY_MAXIMUM);
+                             _
+                             ("Too many lines. Displaying first %d entries only. Close a directory to see more."),
+                             ARBITRARY_MAXIMUM);
                     popup_and_OK(tmp);
                     paranoid_free(tmp);
@@ -964 +959 @@
         newtListboxClear(listbox);
         for (i = 0; i < lines_in_flist_window; i++) {
-            asprintf(&tmp, "%c%c %-80s", (g_is_path_selected[i] ? '*' : ' '),
-                    (g_is_path_expanded[i] ? '+' : '-'),
-                    strip_path(g_strings_of_flist_window[i]));
-            // BERLIOS: this is dangerous now 
+            asprintf(&tmp, "%c%c %-80s",
+                     (g_is_path_selected[i] ? '*' : ' '),
+                     (g_is_path_expanded[i] ? '+' : '-'),
+                     strip_path(g_strings_of_flist_window[i]));
+            // BERLIOS: this is dangerous now  => Memory leak
             if (strlen(tmp) > 71) {
                 tmp[70] = '\0';
@@ -1011 +1007 @@
         slashcount--;           /* Keep one slash 'cos Hugh does... */
 
+    /* BERLIOS: tmpnopath and prev not defined !! How can this compile ?? */
     for (i = 0; i < slashcount; i++) {  /* Replace each dir with a space char */
         tmpnopath[i] = ' ';
@@ -1062 +1059 @@
     void *keylist[ARBITRARY_MAXIMUM];
 
-    /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-
     /** bool **************************************************************/
     bool dummybool;
@@ -1074 +1068 @@
     log_to_screen(_("Editing filelist"));
     newtPushHelpLine
-        (_("   Please edit the filelist to your satisfaction, then click OK or Cancel."));
+        (_
+         ("   Please edit the filelist to your satisfaction, then click OK or Cancel."));
     j = 4;
     bLess = newtCompactButton(j, 17, _(" Less "));
@@ -1111 +1106 @@
                 indexno = 0;
             }
-            sprintf(tmp, "You selected '%s'",
+            log_it("You selected '%s'",
                     g_strings_of_flist_window[indexno]);
-            log_it(tmp);
             if (b_res == bMore) {
                 g_is_path_expanded[indexno] = TRUE;
@@ -1204 +1198 @@
     newtComponent b_raid = NULL;
 
-  /** buffers ***********************************************************/
-    char device_str[MAX_STR_LEN];
-    char mountpoint_str[MAX_STR_LEN];
-    char size_str[MAX_STR_LEN];
-    char format_str[MAX_STR_LEN];
-    char tmp[MAX_STR_LEN];
-    char device_used_to_be[MAX_STR_LEN];
-    char mountpt_used_to_be[MAX_STR_LEN];
-
-    /** pointers **********************************************************/
-    char *device_here;
-    char *mountpoint_here;
-    char *size_here;
-    char *format_here;
-
-    /** int ***************************************************************/
+    char *device_str = NULL;
+    char *mountpoint_str = NULL;
+    char *size_str = NULL;
+    char *format_str = NULL;
+    char *tmp = NULL;
+    char *device_used_to_be = NULL;
+    char *mountpt_used_to_be = NULL;
+    char *device_here = NULL;
+    char *mountpoint_here = NULL;
+    char *size_here = NULL;
+    char *format_here = NULL;
+
     int j = 0;
 
@@ -1229 +1219 @@
     memcpy((void *) &bkp_raidlist, (void *) raidlist,
            sizeof(struct raidlist_itself));
-    strcpy(device_str, mountlist->el[currline].device);
-    strcpy(device_used_to_be, mountlist->el[currline].device);
-    strcpy(mountpoint_str, mountlist->el[currline].mountpoint);
-    strcpy(mountpt_used_to_be, mountlist->el[currline].mountpoint);
-    strcpy(format_str, mountlist->el[currline].format);
-    sprintf(size_str, "%lld", mountlist->el[currline].size / 1024);
+    asprintf(&device_str, mountlist->el[currline].device);
+    asprintf(&device_used_to_be, mountlist->el[currline].device);
+    asprintf(&mountpoint_str, mountlist->el[currline].mountpoint);
+    asprintf(&mountpt_used_to_be, mountlist->el[currline].mountpoint);
+    asprintf(&format_str, mountlist->el[currline].format);
+    asprintf(&size_str, "%lld", mountlist->el[currline].size / 1024);
+
     newtOpenWindow(20, 5, 48, 10, "Edit entry");
     label0 = newtLabel(2, 1, _("Device:"));
@@ -1242 +1233 @@
     deviceComp =
         newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
+    paranoid_free(device_str);
+
     mountpointComp =
         newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
+    paranoid_free(mountpoint_str);
+
     formatComp =
         newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
+    paranoid_free(format_str);
+
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
         || !strcmp(mountlist->el[currline].mountpoint, "image")) {
@@ -1252 +1249 @@
         sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0);
     }
+    paranoid_free(size_str);
+
     bOK = newtButton(2, 6, _("  OK  "));
     bCancel = newtButton(14, 6, _("Cancel"));
@@ -1258 +1257 @@
     }
     newtPushHelpLine
-        (_("       Edit this partition's mountpoint, size and format; then click 'OK'."));
+        (_
+         ("       Edit this partition's mountpoint, size and format; then click 'OK'."));
     myForm = newtForm(NULL, NULL, 0);
     newtFormAddComponents(myForm, deviceComp, mountpointComp, sizeComp,
@@ -1265 +1265 @@
     for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
         b_res = newtRunForm(myForm);
-        strcpy(device_str, device_here);
+
+        paranoid_free(device_str);
+        asprintf(&device_str, device_here);
         strip_spaces(device_str);
-        strcpy(mountpoint_str, mountpoint_here);
+
+        paranoid_free(mountpoint_str);
+        asprintf(&mountpoint_str, mountpoint_here);
         strip_spaces(mountpoint_str);
-        strcpy(format_str, format_here);
+
+        paranoid_free(format_str);
+        asprintf(&format_str, format_here);
+        paranoid_free(format_here);
         strip_spaces(format_str);
         if (b_res == bOK && strstr(device_str, RAID_DEVICE_STUB)
@@ -1279 +1286 @@
         } else if (b_res == bOK && !strcmp(mountpoint_str, "image")
                    && strcmp(mountpt_used_to_be, "image")) {
-            popup_and_OK(_("You can't change a regular device to an image."));
+            popup_and_OK(_
+                         ("You can't change a regular device to an image."));
             b_res = NULL;
             continue;
         }
+        paranoid_free(mountpt_used_to_be);
+
         if (!strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
             && strcmp(mountlist->el[currline].mountpoint, "image")) {
-            strcpy(size_str, size_here);
+            asprintf(&size_str, size_here);
             strip_spaces(size_str);
         } else {
-            sprintf(size_str, "%ld",
+            asprintf(&size_str, "%ld",
                     calculate_raid_device_size(mountlist, raidlist,
                                                mountlist->el[currline].
@@ -1294 +1304 @@
             newtLabelSetText(sizeComp, size_str);
         }
+        paranoid_free(size_here);
+
         /* do not let user click RAID button if user has changed device_str */
         if (b_res == b_raid) {
@@ -1302 +1314 @@
                  */
                 popup_and_OK
-                    (_("You cannot edit the RAID settings until you have OK'd your change to the device node."));
+                    (_
+                     ("You cannot edit the RAID settings until you have OK'd your change to the device node."));
             } else {
                 j = find_raid_device_in_raidlist(raidlist,
@@ -1309 +1322 @@
                 if (j < 0) {
                     sprintf(tmp,
-                            _("/etc/raidtab does not have an entry for %s; please delete it and add it again"),
+                            _
+                            ("/etc/raidtab does not have an entry for %s; please delete it and add it again"),
                             mountlist->el[currline].device);
                     popup_and_OK(tmp);
@@ -1320 +1334 @@
         }
     }
+    paranoid_free(device_here);
+    paranoid_free(mountpoint_here);
+
     newtFormDestroy(myForm);
     newtPopHelpLine();
@@ -1330 +1347 @@
     strcpy(mountlist->el[currline].device, device_str);
     strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
+    paranoid_free(mountpoint_str);
+
     strcpy(mountlist->el[currline].format, format_str);
+    paranoid_free(format_str);
+
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
         || !strcmp(mountlist->el[currline].mountpoint, "image")) {
@@ -1339 +1360 @@
         mountlist->el[currline].size = atol(size_str) * 1024;
     }
+    paranoid_free(size_str);
+
     newtListboxSetEntry(listbox, (int) keylist[currline],
                         mountlist_entry_to_string(mountlist, currline));
@@ -1363 +1386 @@
     else if (strcmp(device_used_to_be, device_str)) {
         popup_and_OK
-            (_("You are renaming a RAID device as another RAID device. I don't like it but I'll allow it."));
+            (_
+             ("You are renaming a RAID device as another RAID device. I don't like it but I'll allow it."));
     }
 #endif
     redraw_mountlist(mountlist, keylist, listbox);
+    paranoid_free(device_str);
+    paranoid_free(device_used_to_be);
 }
 
@@ -1425 +1451 @@
 }
 
+
 void
 edit_raidlist_plex(struct mountlist_itself *mountlist,
@@ -1455 +1482 @@
 
     /** buffers ***********************************************************/
-    char title_of_editraidForm_window[MAX_STR_LEN];
+    char *title_of_editraidForm_window;
 
     /** newt **************************************************************/
@@ -1472 +1499 @@
 
     int currline2 = 0;
+    char *pname = NULL;
+    char *raidlevel = NULL;
+    char *chunksize = NULL;
+    char *entry = NULL;
+    char *msg = NULL;
+    int i = 0;
+    char *headerstr = NULL;
 
     log_it(_("Started edit_raidlist_entry"));
     memcpy((void *) &bkp_raidrec, (void *) raidrec,
            sizeof(struct vinum_volume));
-    sprintf(title_of_editraidForm_window, _("Plexes on %s"),
+    asprintf(&title_of_editraidForm_window, _("Plexes on %s"),
             raidrec->volname);
     newtPushHelpLine(_("   Please select a plex to edit"));
     newtOpenWindow(13, 5, 54, 15, title_of_editraidForm_window);
+    paranoid_free(title_of_editraidForm_window);
+
     for (;;) {
-        int i;
-        char headerstr[MAX_STR_LEN];
-        snprintf(headerstr, MAX_STR_LEN, "%-14s %-8s  %11s  %8s",
-                 _("Plex"), _("Level",) _("Stripe Size"), _("Subdisks"));
+        asprintf(&headerstr, "%-14s %-8s  %11s  %8s", _("Plex"), _("Level",) _("Stripe Size"), _("Subdisks"));
 
         bOK = newtCompactButton(2, 13, _("  OK  "));
@@ -1495 +1528 @@
             newtListbox(2, 3, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
         plexesHeader = newtLabel(2, 2, headerstr);
+        paranoid_free(headerstr);
+
         editraidForm = newtForm(NULL, NULL, 0);
 
@@ -1501 +1536 @@
             keylist[i] = (void *) i;
             if (i < raidrec->plexes) {
-                char pname[64], entry[MAX_STR_LEN], raidlevel[64],
-                    chunksize[64];
                 switch (raidrec->plex[i].raidlevel) {
                 case -1:
-                    strcpy(raidlevel, "concat");
+                    asprintf(&raidlevel, "concat");
                     break;
                 case 0:
-                    strcpy(raidlevel, "striped");
+                    asprintf(&raidlevel, "striped");
                     break;
                 case 5:
-                    strcpy(raidlevel, "raid5");
+                    asprintf(&raidlevel, "raid5");
                     break;
                 default:
-                    sprintf(raidlevel, "raid%i",
+                    asprintf(&raidlevel, "raid%i",
                             raidrec->plex[i].raidlevel);
                     break;
@@ -1520 +1553 @@
 
                 if (raidrec->plex[i].raidlevel == -1) {
-                    strcpy(chunksize, "N/A");
+                    asprintf(&chunksize, "N/A");
                 } else {
-                    sprintf(chunksize, "%dk", raidrec->plex[i].stripesize);
+                    asprintf(&chunksize, "%dk", raidrec->plex[i].stripesize);
                 }
-                snprintf(pname, 64, "%s.p%i", raidrec->volname, i);
-                snprintf(entry, MAX_STR_LEN, "%-14s %-8s  %11s  %8d",
+                asprintf(&pname, "%s.p%i", raidrec->volname, i);
+                asprintf(&entry, "%-14s %-8s  %11s  %8d",
                          pname, raidlevel, chunksize,
                          raidrec->plex[i].subdisks);
+                paranoid_free(pname);
+                paranoid_free(chunksize);
+                paranoid_free(raidlevel);
                 newtListboxAppendEntry(plexesListbox, entry, keylist[i]);
+                paranoid_free(entry);
             }
         }
@@ -1549 +1586 @@
 
         if (b_res == bDelete) {
-            char msg[MAX_STR_LEN];
-            sprintf(msg, _("Are you sure you want to delete %s.p%i?"),
+            asprintf(&msg, _("Are you sure you want to delete %s.p%i?"),
                     raidrec->volname, currline2);
             if (ask_me_yes_or_no(msg)) {
@@ -1559 +1595 @@
                 raidrec->plexes--;
             }
+            paranoid_free(msg);
             continue;
         }
@@ -1581 +1618 @@
 #else
     /** structures ********************************************************/
-    struct raid_device_record *bkp_raidrec;
+    struct raid_device_record *bkp_raidrec = NULL;
 
 
     /** buffers ***********************************************************/
-    char *title_of_editraidForm_window;
-    char *sz_raid_level;
-    char *sz_data_disks;
-    char *sz_spare_disks;
-    char *sz_parity_disks;
-    char *sz_failed_disks;
+    char *title_of_editraidForm_window = NULL;
+    char *sz_raid_level = NULL;
+    char *sz_data_disks = NULL;
+    char *sz_spare_disks = NULL;
+    char *sz_parity_disks = NULL;
+    char *sz_failed_disks = NULL;
 
     /** newt **************************************************************/
@@ -1608 +1645 @@
     assert(raidrec != NULL);
 
-    malloc_string(title_of_editraidForm_window);
-    malloc_string(sz_raid_level);
-    malloc_string(sz_data_disks);
-    malloc_string(sz_spare_disks);
-    malloc_string(sz_parity_disks);
-    malloc_string(sz_failed_disks);
     if (!(bkp_raidrec = malloc(sizeof(struct raid_device_record)))) {
         fatal_error("Cannot malloc space for raidrec");
@@ -1622 +1653 @@
     memcpy((void *) bkp_raidrec, (void *) raidrec,
            sizeof(struct raid_device_record));
-    sprintf(title_of_editraidForm_window, "%s", raidrec->raid_device);
+    asprintf(&title_of_editraidForm_window, _("Edit %s"), raidrec->raid_device);
     log_msg(2, "Opening newt window");
     newtOpenWindow(20, 5, 40, 14, title_of_editraidForm_window);
+    paranoid_free(title_of_editraidForm_window);
+
     for (;;) {
         log_msg(2, "Main loop");
-        sprintf(title_of_editraidForm_window, _("Edit %s"),
-                raidrec->raid_device);
-        strcpy(sz_raid_level,
+        asprintf(&sz_raid_level,
                turn_raid_level_number_to_string(raidrec->raid_level));
-        strcpy(sz_data_disks,
+        asprintf(&sz_data_disks,
                number_of_disks_as_string(raidrec->data_disks.entries,
                                          _("data")));
-        strcpy(sz_spare_disks,
+        asprintf(&sz_spare_disks,
                number_of_disks_as_string(raidrec->spare_disks.entries,
                                          _("spare")));
-        strcpy(sz_parity_disks,
+        asprintf(&sz_parity_disks,
                number_of_disks_as_string(raidrec->parity_disks.entries,
                                          _("parity")));
-        strcpy(sz_failed_disks,
+        asprintf(&sz_failed_disks,
                number_of_disks_as_string(raidrec->failed_disks.entries,
                                          _("failed")));
@@ -1648 +1679 @@
         bSelectFailed = newtButton(20, 5, sz_failed_disks);
         bChangeRaid = newtButton(1, 9, sz_raid_level);
+        paranoid_free(sz_raid_level);
+        paranoid_free(sz_data_disks);
+        paranoid_free(sz_spare_disks);
+        paranoid_free(sz_parity_disks);
+        paranoid_free(sz_failed_disks);
+
         bOK = newtButton(16 + (raidrec->raid_level == -1), 9, _("  OK  "));
         bCancel = newtButton(28, 9, _("Cancel"));
@@ -1654 +1691 @@
                               _("Additional settings and information"));
         newtPushHelpLine
-            (_("  Edit the RAID device's settings to your heart's content, then hit OK/Cancel."));
+            (_
+             ("  Edit the RAID device's settings to your heart's content, then hit OK/Cancel."));
         editraidForm = newtForm(NULL, NULL, 0);
         newtFormAddComponents(editraidForm, bSelectData, bSelectParity,
@@ -1691 +1729 @@
         calculate_raid_device_size(mountlist, raidlist,
                                    raidrec->raid_device);
-    paranoid_free(title_of_editraidForm_window);
-    paranoid_free(sz_raid_level);
-    paranoid_free(sz_data_disks);
-    paranoid_free(sz_spare_disks);
-    paranoid_free(sz_parity_disks);
-    paranoid_free(sz_failed_disks);
     paranoid_free(bkp_raidrec);
 #endif
 }
-
 #ifdef __FreeBSD__
+
 
 /**
@@ -1724 +1756 @@
 
     /** buffers ***********************************************************/
-    char title_of_editraidForm_window[MAX_STR_LEN];
+    char *title_of_editraidForm_window = NULL;
+    char *tmp = NULL;
+    char *entry = NULL;
 
     /** newt **************************************************************/
@@ -1742 +1776 @@
     void *curr_choice_a, *curr_choice_u;
     int currline_a, currline_u;
-
-    struct mountlist_itself *unallocparts;
-
+    int i;
+
+    struct mountlist_itself *unallocparts = NULL;
+
+    /* BERLIOS: Check return value */
     unallocparts = malloc(sizeof(struct mountlist_itself));
 
@@ -1750 +1786 @@
     memcpy((void *) &bkp_raidrec, (void *) raidrec,
            sizeof(struct vinum_plex));
-    sprintf(title_of_editraidForm_window, "%s.p%i",
+    asprintf(&title_of_editraidForm_window, "%s.p%i",
             raidlist->el[currline].volname, currline2);
     newtPushHelpLine
-        (_("   Please select a subdisk to edit, or edit this plex's parameters"));
+        (_
+         ("   Please select a subdisk to edit, or edit this plex's parameters"));
     newtOpenWindow(13, 3, 54, 18, title_of_editraidForm_window);
+    paranoid_free(title_of_editraidForm_window);
+
     for (;;) {
-        int i;
-        char headerstr[MAX_STR_LEN];
-        char tmp[64];
-        snprintf(headerstr, MAX_STR_LEN, "%-24s %s", _("Subdisk"), _("Device"));
-
-
         switch (raidrec->raidlevel) {
         case -1:
-            strcpy(tmp, "concat");
+            asprintf(&tmp, "concat");
             break;
         case 0:
-            strcpy(tmp, "striped");
+            asprintf(&tmp, "striped");
             break;
         case 5:
-            strcpy(tmp, "raid5");
+            asprintf(&tmp, "raid5");
             break;
         default:
-            sprintf(tmp, _("unknown (%i)"), raidrec->raidlevel);
+            asprintf(&tmp, _("unknown (%i)"), raidrec->raidlevel);
             break;
         }
         bLevel = newtCompactButton(2, 2, _(" RAID level "));
         sLevel = newtLabel(19, 2, tmp);
+        paranoid_free(tmp);
 
         if (raidrec->raidlevel >= 0) {
-            sprintf(tmp, "%ik", raidrec->stripesize);
+            asprintf(&tmp, "%ik", raidrec->stripesize);
             bStripeSize = newtCompactButton(2, 4, _(" Stripe size "));
         } else {
-            strcpy(tmp, "N/A");
+            asprintf(&tmp, "N/A");
             bStripeSize = newtLabel(2, 4, _("Stripe size:"));
         }
         sStripeSize = newtLabel(19, 4, tmp);
+        paranoid_free(tmp);
 
         bOK = newtCompactButton(2, 16, _("  OK  "));
@@ -1796 +1831 @@
 
         //  plexesListbox = newtListbox (2, 7, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        //  plexesHeader  = newtLabel (2, 6, headerstr);
         unallocListbox =
             newtListbox(2, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
@@ -1812 +1846 @@
                                                  raidlist);
         for (i = 0; i < ARBITRARY_MAXIMUM; ++i) {
-            char entry[MAX_STR_LEN];
             keylist[i] = (void *) i;
             if (i < raidrec->subdisks) {
-                snprintf(entry, MAX_STR_LEN, "%-17s",
+                asprintf(&entry, "%-17s",
                          find_dev_entry_for_raid_device_name(raidlist,
                                                              raidrec->
@@ -1821 +1854 @@
                                                              which_device));
                 newtListboxAppendEntry(allocListbox, entry, keylist[i]);
+                paranoid_free(entry);
             }
             if (i < unallocparts->entries) {
-                snprintf(entry, MAX_STR_LEN, "%-17s",
-                         unallocparts->el[i].device);
+                asprintf(&entry, "%-17s", unallocparts->el[i].device);
                 newtListboxAppendEntry(unallocListbox, entry, keylist[i]);
+                paranoid_free(entry);
             }
         }
@@ -1875 +1909 @@
             choose_raid_level(raidrec);
         } else if (b_res == bStripeSize) {
-            char tmp[64];
-            sprintf(tmp, "%i", raidrec->stripesize);
+            asprintf(&tmp, "%i", raidrec->stripesize);
             if (popup_and_get_string
                 (_("Stripe size"),
-                 _("Please enter the stripe size in kilobytes."), tmp, 20)) {
+                 _("Please enter the stripe size in kilobytes."), tmp)) {
                 raidrec->stripesize = atoi(tmp);
             }
+            paranoid_free(tmp);
         } else if ((b_res == bAlloc) || (b_res == unallocListbox)) {
             if (currline_u <= unallocparts->entries)
@@ -1922 +1956 @@
 
     /** buffers ***********************************************************/
-    char header[MAX_STR_LEN];
-    char comment[MAX_STR_LEN];
-    char sz_out[MAX_STR_LEN];
+    char *header = NULL;
+    char *comment = NULL;
+    char *sz_out = NULL;
 
     assert(raidrec != 0);
     assert(lino >= 0);
 
-    strcpy(sz_out, raidrec->additional_vars.el[lino].value);
-    sprintf(header, _("Edit %s"), raidrec->additional_vars.el[lino].label);
-    sprintf(comment, _("Please set %s's value (currently '%s')"),
+    asprintf(&sz_out, raidrec->additional_vars.el[lino].value);
+    asprintf(&header, _("Edit %s"), raidrec->additional_vars.el[lino].label);
+    asprintf(&comment, _("Please set %s's value (currently '%s')"),
             raidrec->additional_vars.el[lino].label, sz_out);
-    if (popup_and_get_string(header, comment, sz_out, MAX_STR_LEN)) {
-        strip_spaces(sz_out);
+    if (popup_and_get_string(header, comment, sz_out)) {
         strcpy(raidrec->additional_vars.el[lino].value, sz_out);
     }
-}
-
-
-/* I'm not racist against white people. I just don't like people who think Liberia is near Spain.       - Hugo, 09/01/2001 */
-
+    paranoid_free(header);
+    paranoid_free(comment);
+    paranoid_free(sz_out);
+}
 #endif
+
 
 /**
@@ -1972 +2005 @@
 
     /** ???? *************************************************************/
-    void *curr_choice;
+    void *curr_choice = NULL;
     void *keylist[ARBITRARY_MAXIMUM];
 
@@ -1981 +2014 @@
 
     /** buffers **********************************************************/
-    char tmp[MAX_STR_LEN];
-    char flaws_str_A[MAX_STR_LEN];
-    char flaws_str_B[MAX_STR_LEN];
-    char flaws_str_C[MAX_STR_LEN];
+    char *tmp = NULL;
+    char *flaws_str_A = NULL;
+    char *flaws_str_B = NULL;
+    char *flaws_str_C = NULL;
 
     assert(mountlist != NULL);
     assert(raidlist != NULL);
 
-    strcpy(flaws_str_A, "xxxxxxxxx");
-    strcpy(flaws_str_B, "xxxxxxxxx");
-    strcpy(flaws_str_C, "xxxxxxxxx");
+    asprintf(&flaws_str_A, "xxxxxxxxx");
+    asprintf(&flaws_str_B, "xxxxxxxxx");
+    asprintf(&flaws_str_C, "xxxxxxxxx");
     if (mountlist->entries > ARBITRARY_MAXIMUM) {
         log_to_screen(_("Arbitrary limits suck, man!"));
@@ -1997 +2030 @@
     }
     newtPushHelpLine
-        (_("   Please edit the mountlist to your satisfaction, then click OK or Cancel."));
+        (_
+         ("   Please edit the mountlist to your satisfaction, then click OK or Cancel."));
     i = 4;
     bAdd = newtCompactButton(i, 17, _(" Add "));
@@ -2005 +2039 @@
     bCancel = newtCompactButton(i += 12, 17, _("Cancel"));
     bOK = newtCompactButton(i += 12, 17, _("  OK  "));
-    sprintf(tmp, "%-24s %-24s %-8s  %s", _("Device"), _("Mountpoint"), _("Format"),
-            _("Size (MB)"));
+    asprintf(&tmp, "%-24s %-24s %-8s  %s", _("Device"), _("Mountpoint"),
+            _("Format"), _("Size (MB)"));
     headerMsg = newtLabel(2, 1, tmp);
     flawsLabelA = newtLabel(2, 13, flaws_str_A);
@@ -2026 +2060 @@
         newtLabelSetText(flawsLabelC, flaws_str_C);
         b_res = newtRunForm(myForm);
+        /* BERLIOS: This needs to be re-written */
         if (b_res == bOK) {
             if (!evaluate_mountlist
@@ -2035 +2070 @@
                 finished =
                     ask_me_yes_or_no
-                    (_("Are you sure you want to save your mountlist and continue? (No changes will be made to your partition table at this time.)"));
+                    (_
+                     ("Are you sure you want to save your mountlist and continue? (No changes will be made to your partition table at this time.)"));
             }
         } else if (b_res == bCancel) {
@@ -2041 +2077 @@
         } else if (b_res == bReload) {
             if (ask_me_yes_or_no(_("Reload original mountlist?"))) {
-/*
-This would be really dumb. RAIDTAB_FNAME is #define'd.   --- Hugo, 2003/04/24
-          if (!RAIDTAB_FNAME[0])
-        {
-                  strcpy(RAIDTAB_FNAME, "/etc/raidtab");
-          log_it("Warning - raidtab_fname is blank. Assuming %s", g_raidtab_fname);
-        }
-*/
                 load_mountlist(mountlist, mountlist_fname);
                 load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
@@ -2076 +2104 @@
                     } else {
                         popup_and_OK
-                            (_("Please add an entry. Then press ENTER to edit it."));
+                            (_
+                             ("Please add an entry. Then press ENTER to edit it."));
                     }
                 }
             }
         }
+        paranoid_free(flaws_str_A);
+        paranoid_free(flaws_str_B);
+        paranoid_free(flaws_str_C);
     }
     newtFormDestroy(myForm);
@@ -2095 +2127 @@
 
 
-
 /**
  * Edit the mountlist.
@@ -2107 +2138 @@
 {
     int res = 0;
-//  char tmp[MAX_STR_LEN];
 
     iamhere("entering eml");
@@ -2121 +2151 @@
     return (res);
 }
-
-
 
 
@@ -2149 +2177 @@
 
     /** ?? ***************************************************************/
-    void *keylist[ARBITRARY_MAXIMUM], *curr_choice;
+    void *keylist[ARBITRARY_MAXIMUM], *curr_choice = NULL;
 
     /** buffers **********************************************************/
-    char title_of_window[MAX_STR_LEN];
+    char *title_of_window = NULL;
 
     /** int **************************************************************/
@@ -2163 +2191 @@
     memcpy((void *) &bkp_raidrec, (void *) raidrec,
            sizeof(struct raid_device_record));
-    sprintf(title_of_window, "Additional variables");
+    asprintf(&title_of_window, "Additional variables");
     newtPushHelpLine
-        (_("  Edit the additional fields to your heart's content, then click OK or Cancel."));
-    headerMsg = newtLabel(1, 1, _("Label                            Value"));
+        (_
+         ("  Edit the additional fields to your heart's content, then click OK or Cancel."));
+    headerMsg =
+        newtLabel(1, 1, _("Label                            Value"));
     varsListbox =
         newtListbox(1, 2, 6, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
@@ -2176 +2206 @@
     bCancel = newtCompactButton(i += 9, 9, _("Cancel"));
     newtOpenWindow(17, 7, 46, 10, title_of_window);
+    paranoid_free(title_of_window);
+
     myForm = newtForm(NULL, NULL, 0);
     newtFormAddComponents(myForm, headerMsg, varsListbox, bAdd, bEdit,
@@ -2247 +2279 @@
 
 
-
 /**
  * Locate @p device in @p raidlist.
@@ -2259 +2290 @@
                              char *device)
 {
-
     /** int ***************************************************************/
     int i = 0;
 #ifdef __FreeBSD__
-    char vdev[64];
-#else
-// Linux
+    char *vdev = NULL;
 #endif
 
@@ -2273 +2301 @@
 #ifdef __FreeBSD__
     for (i = 0; i < raidlist->entries; i++) {
-        sprintf(vdev, "/dev/vinum/%s", raidlist->el[i].volname);
-        if (!strcmp(device, vdev))
+        asprintf(&vdev, "/dev/vinum/%s", raidlist->el[i].volname);
+        if (!strcmp(device, vdev)) {
+            paranoid_free(vdev);
             break;
+        }
+        paranoid_free(vdev);
     }
 #else
@@ -2305 +2336 @@
     /** initialize ********************************************************/
 
-    assert(isodir_device != NULL);
-    assert(isodir_format != NULL);
-    assert(isodir_path != NULL);
-
-    log_it("%d - AAA - isodir_path = %s", isodir_path);
-    isodir_format[0] = '\0';
-    if (isodir_device[0] == '\0') {
-        strcpy(isodir_device, "/dev/");
-    }
-    if (isodir_path[0] == '\0') {
-        strcpy(isodir_path, "/");
+    // %d no var ???
+    // log_it("%d - AAA - isodir_path = %s", isodir_path);
+    if (isodir_device == NULL) {
+        asprintf(&isodir_device, "/dev/");
+    }
+    if (isodir_path == NULL) {
+        asprintf(&isodir_path, "/");
     }
     if (does_file_exist("/tmp/NFS-SERVER-PATH")) {
-        strcpy(isodir_device, last_line_of_file("/tmp/NFS-SERVER-MOUNT"));
-        strcpy(isodir_format, "nfs");
-        strcpy(isodir_path, last_line_of_file("/tmp/NFS-SERVER-PATH"));
+        paranoid_free(isodir_device);
+        isodir_device = last_line_of_file("/tmp/NFS-SERVER-MOUNT");
+        asprintf(&isodir_format, "nfs");
+        paranoid_free(isodir_path);
+        isodir_path = last_line_of_file("/tmp/NFS-SERVER-PATH");
     }
     if (nuke_me_please) {
@@ -2327 +2356 @@
 
     if (popup_and_get_string
-        (_("ISO Mode - device"), _("On what device do the ISO files live?"),
-         isodir_device, MAX_STR_LEN / 4)) {
+        (_("ISO Mode - device"),
+         _("On what device do the ISO files live?"), isodir_device)) {
         if (popup_and_get_string
             (_("ISO Mode - format"),
-             _("What is the disk format of the device? (Hit ENTER if you don't know.)"),
-             isodir_format, 16)) {
+             _
+             ("What is the disk format of the device? (Hit ENTER if you don't know.)"),
+             isodir_format)) {
             if (popup_and_get_string
                 (_("ISO Mode - path"),
-                 _("At what path on this device can the ISO files be found?"),
-                 isodir_path, MAX_STR_LEN / 4)) {
-                strip_spaces(isodir_device);
-                strip_spaces(isodir_format);
-                strip_spaces(isodir_path);
-                log_it("%d - BBB - isodir_path = %s", isodir_path);
+                 _
+                 ("At what path on this device can the ISO files be found?"),
+                 isodir_path)) {
+                // Same pb:
+                // log_it("%d - BBB - isodir_path = %s", isodir_path);
                 return (TRUE);
             }
@@ -2362 +2391 @@
                             int currline, char *device)
 {
-
     /** structure *********************************************************/
     struct OSSWAP (raid_device_record, vinum_volume) * raidrec;
@@ -2415 +2443 @@
     raidrec->additional_vars.entries = items;
 }
-
 #endif
+
 
 /**
@@ -2433 +2461 @@
 
     newtPushHelpLine
-        (_("This is where I nuke your hard drives. Mhahahahaha. No-one can stop Mojo Jojo!"));
+        (_
+         ("This is where I nuke your hard drives. Mhahahahaha. No-one can stop Mojo Jojo!"));
     newtOpenWindow(24, 3, 32, 13, _("Nuking"));
     b1 = newtButton(7, 1, _("Slowly"));
@@ -2447 +2476 @@
 
 
-
 /**
  * Redraw the disklist.
@@ -2512 +2540 @@
 
 
-
-
 /**
  * Redraw the list of unallocated RAID partitions.
@@ -2531 +2557 @@
 
     /** buffers **********************************************************/
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
 
     assert(unallocated_raid_partitions != NULL);
@@ -2542 +2568 @@
     }
     for (i = 0; i < unallocated_raid_partitions->entries; i++) {
-        sprintf(tmp, "%-22s %8lld",
+        asprintf(&tmp, "%-22s %8lld",
                 unallocated_raid_partitions->el[i].device,
                 unallocated_raid_partitions->el[i].size / 1024);
         newtListboxAppendEntry(listbox, tmp, keylist[i]);
-    }
-}
+        paranoid_free(tmp);
+    }
+}
+
 
 #ifndef __FreeBSD__
@@ -2565 +2593 @@
 
     /** buffers *********************************************************/
-    char tmp[MAX_STR_LEN];
+    char *tmp;
 
     assert(additional_vars != NULL);
@@ -2577 +2605 @@
     }
     for (i = 0; i < additional_vars->entries; i++) {
-        sprintf(tmp, "%-32s %-8s", additional_vars->el[i].label,
+        asprintf(&tmp, "%-32s %-8s", additional_vars->el[i].label,
                 additional_vars->el[i].value);
         newtListboxAppendEntry(listbox, tmp, keylist[i]);
+        paranoid_free(tmp);
     }
 }
@@ -2622 +2651 @@
 #endif
 
+
 /**
  * Change all RAID devices to use @p new_dev instead of @p old_dev.
@@ -2635 +2665 @@
 {
     /** buffers ********************************************************/
-    char tmp[MAX_STR_LEN];
+    char *tmp;
 
     /** int ************************************************************/
@@ -2647 +2677 @@
     pos = which_raid_device_is_using_this_partition(raidlist, old_dev);
     if (pos < 0) {
-        sprintf(tmp, "No need to rejig %s in raidlist: it's not listed.",
+        asprintf(&tmp, "No need to rejig %s in raidlist: it's not listed.",
                 old_dev);
         log_it(tmp);
+        paranoid_free(tmp);
     } else {
         if ((j =
@@ -2681 +2712 @@
 #endif
         else {
-            sprintf(tmp,
+            asprintf(&tmp,
                     "%s is supposed to be listed in this raid dev but it's not...",
                     old_dev);
             log_it(tmp);
+            paranoid_free(tmp);
         }
     }
@@ -2717 +2749 @@
     res = read_variableINT_and_remove_from_raidvars(raidrec, "block-size");
 }
+
 
 /**
@@ -2734 +2767 @@
                   struct list_of_disks *disklist)
 {
-    void *curr_choice;
-
-    /** ??? ***************************************************************/
+    void *curr_choice = NULL;
 
     /** structures ********************************************************/
-    struct raidlist_itself *bkp_raidlist;
-    struct raid_device_record *bkp_raidrec;
-    struct list_of_disks *bkp_disklist;
-    struct mountlist_itself *unallocated_raid_partitions;
+    struct raidlist_itself *bkp_raidlist = NULL;
+    struct raid_device_record *bkp_raidrec = NULL;
+    struct list_of_disks *bkp_disklist = NULL;
+    struct mountlist_itself *unallocated_raid_partitions = NULL;
 
     /** newt **************************************************************/
@@ -2756 +2787 @@
     /** buffers **********************************************************/
     void *keylist[ARBITRARY_MAXIMUM];
-    char *tmp;
-    char *help_text;
-    char *title_of_window;
-    char *sz_res;
-    char *header_text;
+    char *tmp = NULL;
+    char *help_text = NULL;
+    char *title_of_window = NULL;
+    char *sz_res = NULL;
+    char *header_text = NULL;
 
   /** int **************************************************************/
@@ -2773 +2804 @@
 
     iamhere("malloc'ing");
-    malloc_string(tmp);
-    malloc_string(help_text);
-    malloc_string(title_of_window);
-    malloc_string(sz_res);
-    malloc_string(header_text);
     if (!(bkp_raidrec = malloc(sizeof(struct raid_device_record)))) {
         fatal_error("Cannot malloc space for raidrec");
@@ -2801 +2827 @@
 
     iamhere("Post-malloc");
-    strcpy(help_text,
-           _("   Edit this RAID device's list of partitions. Choose OK or Cancel when done."));
-    sprintf(header_text, "%-24s    %s", _("Device"), _("Index"));
-    sprintf(title_of_window, _("%s contains..."), raidrec->raid_device);
+    asprintf(&help_text,
+           _
+           ("   Edit this RAID device's list of partitions. Choose OK or Cancel when done."));
+    asprintf(&header_text, "%-24s    %s", _("Device"), _("Index"));
+    asprintf(&title_of_window, _("%s contains..."), raidrec->raid_device);
     newtPushHelpLine(help_text);
+    paranoid_free(help_text);
     for (b_res = (newtComponent) 12345; b_res != bOK && b_res != bCancel;) {
         headerMsg = newtLabel(1, 1, header_text);
@@ -2844 +2872 @@
                     if (unallocated_raid_partitions->entries <= 0) {
                         popup_and_OK
-                            (_("There are no unallocated partitions marked for RAID."));
+                            (_
+                             ("There are no unallocated partitions marked for RAID."));
                     } else {
                         log_it
-                            (_("Done. The user may add one or more of the above to RAID device"));
+                            (_
+                             ("Done. The user may add one or more of the above to RAID device"));
                         add_disklist_entry(disklist, raidrec->raid_device,
                                            unallocated_raid_partitions);
-                        log_it(_("I have finished adding a disklist entry."));
+                        log_it(_
+                               ("I have finished adding a disklist entry."));
                         redraw_disklist(disklist, keylist,
                                         partitionsListbox);
@@ -2859 +2890 @@
                     redraw_disklist(disklist, keylist, partitionsListbox);
                 } else {
-                    sprintf(tmp, _("%s's index is %d. What should it be?"),
+                    asprintf(&tmp, _("%s's index is %d. What should it be?"),
                             raidrec->raid_device,
                             disklist->el[currline].index);
-                    sprintf(sz_res, "%d", disklist->el[currline].index);
-                    if (popup_and_get_string(_("Set index"), tmp, sz_res, 10)) {
+                    asprintf(&sz_res, "%d", disklist->el[currline].index);
+                    if (popup_and_get_string
+                        (_("Set index"), tmp, sz_res)) {
                         disklist->el[currline].index = atoi(sz_res);
                     }
+                    paranoid_free(tmp);
+                    paranoid_free(sz_res);
                     redraw_disklist(disklist, keylist, partitionsListbox);
                 }
@@ -2873 +2907 @@
         newtPopWindow();
     }
+    paranoid_free(title_of_window);
+    paranoid_free(header_text);
+
     newtPopHelpLine();
     if (b_res == bCancel) {
@@ -2882 +2919 @@
                sizeof(struct list_of_disks));
     }
-    paranoid_free(tmp);
-    paranoid_free(help_text);
-    paranoid_free(title_of_window);
-    paranoid_free(sz_res);
-    paranoid_free(header_text);
     paranoid_free(bkp_raidrec);
     paranoid_free(bkp_disklist);
@@ -2895 +2927 @@
 
 
-
 /**
  * Ask the user which restore mode (nuke, interactive, or compare) we should use.
@@ -2906 +2937 @@
   /** char *************************************************************/
     char output = '\0';
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
+    size_t n = 0;
 
   /** newt *************************************************************/
@@ -2920 +2952 @@
         for (output = 'z'; !strchr("AICE", output); output = tmp[0]) {
             printf
-                (_("Which mode - (A)utomatic, (I)nteractive, \n(C)ompare only, or (E)xit to shell?\n--> "));
-            fgets(tmp, MAX_STR_LEN - 1, stdin);
-        }
+                (_
+                 ("Which mode - (A)utomatic, (I)nteractive, \n(C)ompare only, or (E)xit to shell?\n--> "));
+            getline(&tmp, &n, stdin);
+        }
+        paranoid_free(tmp);
         return (output);
     }
 
     newtPushHelpLine
-        (_("   Do you want to 'nuke' your system, restore interactively, or just compare?"));
+        (_
+         ("   Do you want to 'nuke' your system, restore interactively, or just compare?"));
     newtOpenWindow(24, 3, 32, 17, _("How should I restore?"));
     b1 = newtButton(7, 1, _("Automatically"));

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

@@ -1 @@
-/***************************************************************************
-                          mondo-rstr-newt.h  -  description
-                             -------------------
-    begin                : Sat Apr 20 2002
-    copyright            : (C) 2002 by Stan Benoit
-    email                : troff@nakedsoul.org
-    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.                                   *
- *                                                                         *
- ***************************************************************************/
-
+/*
+ * $Id$
+**/
 
 #include "../common/my-stuff.h"
@@ -72 +57 @@
 extern bool g_ISO_restore_mode;
 
-
-/* my global variables */
-
-//extern newtComponent g_progressForm, g_blurb1, g_blurb2, g_blurb3, g_label,
-//  g_timeline, g_percentline, g_scale;
-//extern char err_log_lines[NOOF_ERR_LINES][MAX_STR_LEN], g_blurb_str_1[MAX_STR_LEN] =
-//  "", g_blurb_str_2[MAX_STR_LEN] = "", g_blurb_str_3[MAX_STR_LEN] = "";
-//newtComponent g_isoform_main =
-//  NULL, g_isoform_header, g_isoform_scale, g_isoform_timeline,
-//  g_isoform_pcline;
-//long g_isoform_starttime;
-//int g_isoform_old_progress = -1;
-//char g_isoform_header_str[MAX_STR_LEN];
-//int g_mysterious_dot_counter;
-
-
-
-
-
 /* my subroutines */
 
@@ -137 +103 @@
                    struct raidlist_itself *);
 void edit_raidrec_additional_vars(struct raid_device_record *);
-int evaluate_drive_within_mountlist(struct mountlist_itself *, char *,
-                                    char *);
 int evaluate_mountlist(struct mountlist_itself *, char *, char *, char *);
 int find_device_in_mountlist(struct mountlist_itself *, char *);
@@ -151 +115 @@
 void log_to_screen(const char *fmt, ...);
 int look_for_duplicate_mountpoints(struct mountlist_itself *, char *);
-int look_for_weird_formats(struct mountlist_itself *, char *);
 void make_list_of_unallocated_raid_partitions(struct mountlist_itself *,
                                               struct mountlist_itself *,
@@ -162 +125 @@
 void open_progress_form(char *, char *, char *, char *, long);
 void popup_and_OK(char *);
-bool popup_and_get_string(char *, char *, char *, int);
+bool popup_and_get_string(char *, char *, char *);
 bool popup_with_buttons(char *, char *, char *);
 void redraw_disklist(struct list_of_disks *, void *keylist[],
@@ -194 +157 @@
 char *strip_path(char *);
 
-
-
-
 /* -------------------------------------------------------------------- */
 
-
-
-
-char tmpnopath[MAX_STR_LEN + 2];
-char tmpprevpath[MAX_STR_LEN + 2];
 
 #ifdef __FreeBSD__

trunk/mondo/mondo/mondorestore/mondo-rstr-tools-EXT.h

@@ -1 @@
-/* mondo-rstr-tools-EXT.h
+/*
  * $Id: mondo-rstr-tools-EXT.h
- */
+**/
 
 extern void free_MR_global_filenames();
@@ -8 +8 @@
 extern int iso_fiddly_bits(struct s_bkpinfo *bkpinfo, bool nuke_me_please);
 extern void kill_petris(void);
-extern int modify_rclocal_one_time(char *path);
 extern int mount_cdrom(struct s_bkpinfo *bkpinfo);
 extern int mount_device(char *, char *, char *, bool);
@@ -27 +26 @@
 extern void set_signals(int on);
 extern void setup_MR_global_filenames(struct s_bkpinfo *bkpinfo);
-//extern void setup_signals(int);
 extern void terminate_daemon(int);
 extern void termination_in_progress(int);

trunk/mondo/mondo/mondorestore/mondo-rstr-tools.c

@@ -1 +1 @@
 /*
  * $Id$
-*/
-
+**/
+
+#include <unistd.h>
 
 #include "../common/my-stuff.h"
@@ -8 +9 @@
 #include "../common/libmondo.h"
 #include "mr-externs.h"
-//#include "mondo-restore.h"
-//#include "mondo-rstr-compare-EXT.h"
 #include "mondo-rstr-tools.h"
 #ifndef S_SPLINT_S
@@ -55 +54 @@
     paranoid_free(g_filelist_full);
     paranoid_free(g_filelist_imagedevs);
-//  paranoid_free (g_imagedevs_pot );
     paranoid_free(g_imagedevs_restthese);
     paranoid_free(g_mondo_cfg_file);
@@ -67 +65 @@
 
 
-
 /**
  * Ask the user which imagedevs from the list contained in @p infname should
@@ -77 +74 @@
 void ask_about_these_imagedevs(char *infname, char *outfname)
 {
-    FILE *fin;
-    FILE *fout;
+    FILE *fin = NULL;
+    FILE *fout = NULL;
   /************************************************************************
    * allocate memory regions. test and set  -sab 16 feb 2003              *
    ************************************************************************/
-    char *incoming;
-    char *question;
+    char *incoming = NULL;
+    char *question = NULL;
 
     size_t n = 0;
@@ -105 +102 @@
 
         asprintf(&question,
-                _("Should I restore the image of %s ?", incoming));
+                 _("Should I restore the image of %s ?"), incoming);
 
         if (ask_me_yes_or_no(question)) {
             fprintf(fout, "%s\n", incoming);
         }
+        paranoid_free(question);
     }
 
   /*** free memory ***********/
     paranoid_free(incoming);
-    paranoid_free(question);
-
 
     paranoid_fclose(fout);
@@ -124 +120 @@
  *ASK_ABOUT_THESE_IMAGEDEVS                                               *
  **************************************************************************/
-
-
-
-
-
-
 
 
@@ -147 +137 @@
                                  char *output_mountlist_file)
 {
-    char *mountpt;
-    char *command;
-    char *orig_fname;
+    char *mountpt = NULL;
+    char *command = NULL;
+    char *orig_fname = NULL;
     int retval = 0;
 
     assert(bkpinfo != NULL);
-    malloc_string(mountpt);
-    malloc_string(command);
-    malloc_string(orig_fname);
     assert_string_is_neither_NULL_nor_zerolength(ramdisk_fname);
     assert_string_is_neither_NULL_nor_zerolength(output_cfg_file);
     assert_string_is_neither_NULL_nor_zerolength(output_mountlist_file);
-    sprintf(mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
-    sprintf(command, "mkdir -p %s", mountpt);
+    asprintf(&mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
+    asprintf(&command, "mkdir -p %s", mountpt);
     run_program_and_log_output(command, FALSE);
-    sprintf(command, "gzip -dc %s > %s/mindi.rd 2> /dev/null",
+    paranoid_free(command);
+
+    asprintf(&command, "gzip -dc %s > %s/mindi.rd 2> /dev/null",
             ramdisk_fname, bkpinfo->tmpdir);
-
     run_program_and_log_output(command, FALSE);
-    sprintf(command, "umount %s", mountpt);
-
+    paranoid_free(command);
+
+    asprintf(&command, "umount %s", mountpt);
     run_program_and_log_output(command, FALSE);
-
-    sprintf(command, "mount -o loop %s/mindi.rd -t ext2 %s",
+    paranoid_free(command);
+
+    asprintf(&command, "mount -o loop %s/mindi.rd -t ext2 %s",
             bkpinfo->tmpdir, mountpt);
-
     run_program_and_log_output(command, FALSE);
-
-    sprintf(command, "mkdir -p %s/tmp", bkpinfo->tmpdir);
-
+    paranoid_free(command);
+
+    asprintf(&command, "mkdir -p %s/tmp", bkpinfo->tmpdir);
     run_program_and_log_output(command, FALSE);
-
-    sprintf(command, "cp -f %s/%s %s",  // %s/%s becomes {mountpt}/tmp/m*ndo-restore.cfg
+    paranoid_free(command);
+
+    asprintf(&command, "cp -f %s/%s %s",    // %s/%s becomes {mountpt}/tmp/m*ndo-restore.cfg
             mountpt, g_mondo_cfg_file, output_cfg_file);
     run_program_and_log_output(command, FALSE);
-
-    sprintf(orig_fname, "%s/%s", mountpt, g_mountlist_fname);
+    paranoid_free(command);
+
+    asprintf(&orig_fname, "%s/%s", mountpt, g_mountlist_fname);
     if (does_file_exist(orig_fname)) {
-        sprintf(command, "cp -f %s %s", orig_fname, output_mountlist_file);
+        asprintf(&command, "cp -f %s %s", orig_fname, output_mountlist_file);
         run_program_and_log_output(command, FALSE);
-    }
-    sprintf(command, "umount %s", mountpt);
+        paranoid_free(command);
+    }
+    asprintf(&command, "umount %s", mountpt);
+    paranoid_free(mountpt);
+
     run_program_and_log_output(command, FALSE);
+    paranoid_free(command);
+
     if (!does_file_exist(output_cfg_file)
         || (!does_file_exist(output_mountlist_file)
@@ -199 +195 @@
         retval = 0;
     }
-    paranoid_free(mountpt);
-    paranoid_free(command);
     paranoid_free(orig_fname);
     return (retval);
-
-}
-
-
+}
 
 
@@ -217 +208 @@
     while (get_cfg_file_from_archive(bkpinfo)) {
         if (!ask_me_yes_or_no
-            (_("Failed to find config file/archives. Choose another source?")))
+            (_
+             ("Failed to find config file/archives. Choose another source?")))
         {
             fatal_error("Could not find config file/archives. Aborting.");
@@ -237 +229 @@
 
   /** needs malloc **/
-    char *command;
-    char *file;
-    char *tmp;
-    int res;
-
-    malloc_string(command);
-    malloc_string(file);
-    malloc_string(tmp);
+    char *command = NULL;
+    char *file = NULL;
+    char *tmp = NULL;
+    int res = 0;
+
     assert_string_is_neither_NULL_nor_zerolength(f);
     assert_string_is_neither_NULL_nor_zerolength(list_fname);
@@ -250 +239 @@
 
     if (strncmp(preamble, f, strlen(preamble)) == 0) {
-        strcpy(file, f + strlen(preamble));
-    } else {
-        strcpy(file, f);
+        asprintf(&file, f + strlen(preamble));
+    } else {
+        asprintf(&file, f);
     }
     if (file[0] == '/' && file[1] == '/') {
-        strcpy(tmp, file);
-        strcpy(file, tmp + 1);
-    }
-    sprintf(tmp,
+        asprintf(&tmp, file);
+        paranoid_free(file);
+        asprintf(&file, tmp + 1);
+        paranoid_free(tmp);
+    }
+    asprintf(&tmp,
             "Checking to see if f=%s, file=%s, is in the list of biggiefiles",
             f, file);
     log_msg(2, tmp);
-    sprintf(command, "grep -x \"%s\" %s", file, list_fname);
+    paranoid_free(tmp);
+
+    asprintf(&command, "grep -x \"%s\" %s", file, list_fname);
+    paranoid_free(file);
+
     res = run_program_and_log_output(command, FALSE);
     paranoid_free(command);
-    paranoid_free(file);
-    paranoid_free(tmp);
     if (res) {
         return (FALSE);
@@ -273 +266 @@
     }
 }
-
 /**************************************************************************
  *END_IS_FILE_IN_LIST                                                     *
  **************************************************************************/
-
 
 
@@ -291 +282 @@
 int iso_fiddly_bits(struct s_bkpinfo *bkpinfo, bool nuke_me_please)
 {
-    char *mount_isodir_command, *tmp, *command;
-    int retval = 0, i;
+    char *mount_isodir_command = NULL;
+    char *tmp = NULL;
+    char *command = NULL;
+    int retval = 0, i = 0;
     bool already_mounted = FALSE;
 
     assert(bkpinfo != NULL);
-    malloc_string(mount_isodir_command);
-    malloc_string(tmp);
-    malloc_string(command);
     g_ISO_restore_mode = TRUE;
     read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
@@ -308 +298 @@
         }
 /* End patch */
-        sprintf(command, "mkdir -p %s", bkpinfo->isodir);
+        asprintf(&command, "mkdir -p %s", bkpinfo->isodir);
         run_program_and_log_output(command, 5);
+        paranoid_free(command);
         log_msg(2, "Setting isodir to %s", bkpinfo->isodir);
     }
@@ -324 +315 @@
         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);
+        if (g_isodir_format != NULL) {
+            asprintf(&mount_isodir_command, "mount %s -t %s -o ro %s", g_isodir_device, g_isodir_format, bkpinfo->isodir);
+        } else {
+            asprintf(&mount_isodir_command, "mount %s -o ro %s", g_isodir_device, bkpinfo->isodir);
+        }
         run_program_and_log_output("df -P -m", FALSE);
-        sprintf(tmp,
+        asprintf(&tmp,
                 "The 'mount' command is '%s'. PLEASE report this command to be if you have problems, ok?",
                 mount_isodir_command);
         log_msg(1, tmp);
+        paranoid_free(tmp);
+
         if (run_program_and_log_output(mount_isodir_command, FALSE)) {
             popup_and_OK
-                (_("Cannot mount the device where the ISO files are stored."));
+                (_
+                 ("Cannot mount the device where the ISO files are stored."));
+            paranoid_free(mount_isodir_command);
             return (1);
         }
+        paranoid_free(mount_isodir_command);
         log_to_screen
-            (_("I have mounted the device where the ISO files are stored."));
+            (_
+             ("I have mounted the device where the ISO files are stored."));
     }
     if (!IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
@@ -348 +343 @@
     }
     i = what_number_cd_is_this(bkpinfo);    /* has the side-effect of calling mount_cdrom() */
-    sprintf(tmp, "%s #%d has been mounted via loopback mount",
+    asprintf(&tmp, "%s #%d has been mounted via loopback mount",
             media_descriptor_string(bkpinfo->backup_media_type), i);
     log_msg(1, tmp);
+    paranoid_free(tmp);
+
     if (i < 0) {
         popup_and_OK
@@ -358 +355 @@
     log_msg(2, "%ld: bkpinfo->isodir is now %s", __LINE__,
             bkpinfo->isodir);
-    paranoid_free(mount_isodir_command);
-    paranoid_free(tmp);
-    paranoid_free(command);
     return (retval);
 }
 
 
-
-
 /**
  * Kill all Petris processes.
@@ -373 +365 @@
 {
     char *command;
-    malloc_string(command);
-    sprintf(command,
+    asprintf(&command,
             "kill `ps wax 2> /dev/null | grep petris 2> /dev/null | grep -v grep | cut -d' ' -f2` 2> /dev/null");
     paranoid_system(command);
@@ -383 +374 @@
  *END_KILL_PETRIS                                                         *
  **************************************************************************/
-
-
-/**
- * (Disabled) Modify rc.local to fix some things on first boot.
- * This function currently doesn't do anything except make sure /tmp has the
- * right permissions.
- * @param path The path to /etc on the user's filesystem.
- * @return 0 for success, nonzero for failure.
- */
-int modify_rclocal_one_time(char *path)
-{
-  /** malloc **/
-    char *rclocal_fname;
-    char *newfile_fname;
-    char *tmp;
-
-    malloc_string(rclocal_fname);
-    malloc_string(newfile_fname);
-    malloc_string(tmp);
-    assert_string_is_neither_NULL_nor_zerolength(path);
-
-    sprintf(rclocal_fname, "%s/rc.local", path);
-
-//  sprintf(tmp, "chmod 1777 %s/tmp", MNT_RESTORING);
-//  run_program_and_log_output( tmp, FALSE );
-    return (0);                 /* remove this line to open the floodgates... */
-
-    if (!does_file_exist(rclocal_fname)) {
-        sprintf(rclocal_fname, "%s/rc.d/rc.local", path);
-    }
-    if (!does_file_exist(rclocal_fname)) {
-        paranoid_free(rclocal_fname);
-        paranoid_free(newfile_fname);
-        paranoid_free(tmp);
-        return (1);
-    }
-    sprintf(newfile_fname, "%s/rc.local.mondorescue", path);
-    sprintf(tmp, "grep mondorescue %s > /dev/null 2> /dev/null",
-            rclocal_fname);
-    if (system(tmp)) {
-        sprintf(tmp, "echo \"[ -e %s ] && %s\n\" >> %s",
-                newfile_fname, newfile_fname, rclocal_fname);
-
-        paranoid_system(tmp);
-    }
-    sprintf(tmp, "echo -en \"#!/bin/sh\
-\\n\
-\\n\
-grep -v mondorescue %s > %s\\n\
-rm -f /var/lock/subsys/*xfs*\\n\
-rm -f /var/run/xfs.*\\n\
-killall xfs\\n\
-service xfs start\\n\
-yes | rm -f %s\\n\
-\" > %s", rclocal_fname, rclocal_fname, newfile_fname, newfile_fname);
-    sprintf(tmp, "chmod +x \"%s\"", newfile_fname);
-    run_program_and_log_output(tmp, FALSE);
-    paranoid_free(rclocal_fname);
-    paranoid_free(newfile_fname);
-    paranoid_free(tmp);
-    return (0);
-}
-
-/**************************************************************************
- *END_ MODIFY_RCLOCAL_ONE_TIME                                            *
- **************************************************************************/
-
-
-
 
 
@@ -463 +385 @@
                       *p_external_copy_of_mountlist, bool writeable)
 {
-    int retval = 0, lino, res;
-    char *tmp, *these_failed, *format;
-    struct mountlist_itself *mountlist;
-
-    malloc_string(tmp);
-    malloc_string(format);
-    malloc_string(these_failed);
+    int retval = 0;
+    int lino = 0;
+    int res = 0;
+    char *tmp = NULL;
+    char *these_failed = NULL;
+    char *format = NULL;
+    struct mountlist_itself *mountlist = NULL;
+
     assert(p_external_copy_of_mountlist != NULL);
     mountlist = malloc(sizeof(struct mountlist_itself));
@@ -476 +399 @@
     sort_mountlist_by_mountpoint(mountlist, 0);
 
-  /** menset **/
-    these_failed[0] = '\0';
-
     mvaddstr_and_log_it(g_currentY, 0, _("Mounting devices         "));
     open_progress_form(_("Mounting devices"),
@@ -490 +410 @@
                     "Again with the /proc - why is this in your mountlist?");
         } else if (is_this_device_mounted(mountlist->el[lino].device)) {
-            sprintf(tmp, _("%s is already mounted"),
+            asprintf(&tmp, _("%s is already mounted"),
                     mountlist->el[lino].device);
             log_to_screen(tmp);
+            paranoid_free(tmp);
         } else if (strcmp(mountlist->el[lino].mountpoint, "none")
                    && strcmp(mountlist->el[lino].mountpoint, "lvm")
                    && strcmp(mountlist->el[lino].mountpoint, "raid")
                    && strcmp(mountlist->el[lino].mountpoint, "image")) {
-            sprintf(tmp, "Mounting %s", mountlist->el[lino].device);
+            asprintf(&tmp, "Mounting %s", mountlist->el[lino].device);
             update_progress_form(tmp);
-            strcpy(format, mountlist->el[lino].format);
+            paranoid_free(tmp);
+
+            asprintf(&format, mountlist->el[lino].format);
             if (!strcmp(format, "ext3")) {
-                strcpy(format, "ext2");
+                paranoid_free(format);
+                asprintf(&format, "ext2");
             }
             res = mount_device(mountlist->el[lino].device,
@@ -508 +432 @@
             retval += res;
             if (res) {
-                strcat(these_failed, mountlist->el[lino].device);
-                strcat(these_failed, " ");
-            }
+                if (these_failed != NULL) { /* not the first time */
+                    asprintf(&tmp, "%s %s", these_failed, mountlist->el[lino].device);
+                    paranoid_free(these_failed);
+                    these_failed = tmp;
+                } else { /* The first time */
+                    asprintf(&these_failed, "%s ", mountlist->el[lino].device);
+                }
+            }
+            paranoid_free(format);
         }
         g_current_progress++;
@@ -519 +449 @@
         if (g_partition_table_locked_up > 0) {
             log_to_screen
-                (_("fdisk's ioctl() call to refresh its copy of the partition table causes the kernel to"));
-            log_to_screen
-                (_("lock up the partition table. You might have to reboot and use Interactive Mode to"));
-            log_to_screen
-                (_("format and restore *without* partitioning first. Sorry for the inconvenience."));
-        }
-        sprintf(tmp, _("Could not mount devices %s- shall I abort?"),
+                (_
+                 ("fdisk's ioctl() call to refresh its copy of the partition table causes the kernel to"));
+            log_to_screen(_
+                          ("lock up the partition table. You might have to reboot and use Interactive Mode to"));
+            log_to_screen(_
+                          ("format and restore *without* partitioning first. Sorry for the inconvenience."));
+        }
+        asprintf(&tmp, _("Could not mount devices %s- shall I abort?"),
                 these_failed);
+        paranoid_free(these_failed);
+
         if (!ask_me_yes_or_no(tmp)) {
             retval = 0;
             log_to_screen
-                (_("Continuing, although some devices failed to be mounted"));
+                (_
+                 ("Continuing, although some devices failed to be mounted"));
             mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
         } else {
@@ -537 +471 @@
                 (_("Unable to mount some or all of your partitions."));
         }
+        paranoid_free(tmp);
     } else {
         log_to_screen(_("All partitions were mounted OK."));
@@ -543 +478 @@
     run_program_and_log_output("df -P -m", 3);
     paranoid_free(mountlist);
-    paranoid_free(tmp);
-    paranoid_free(format);
-    paranoid_free(these_failed);
     return (retval);
 }
-
  /**************************************************************************
   *END_MOUNT_ALL_DEVICES                                                   *
@@ -565 +496 @@
 int mount_cdrom(struct s_bkpinfo *bkpinfo)
 {
-    char *mount_cmd, *tmp;
+    char *mount_cmd = NULL;
+    char *tmp = NULL;
     int i, res;
 #ifdef __FreeBSD__
-    char mdd[32];
-    char *mddev = mdd;
+    char *mddev = NULL;
 #endif
 
-    malloc_string(mount_cmd);
     assert(bkpinfo != NULL);
 
@@ -578 +508 @@
         || bkpinfo->backup_media_type == udev) {
         log_msg(8, "Tape/udev. Therefore, no need to mount CDROM.");
-        paranoid_free(mount_cmd);
         return 0;
     }
@@ -584 +513 @@
     if (!run_program_and_log_output("mount | grep -F " MNT_CDROM, FALSE)) {
         log_msg(2, "mount_cdrom() - CD already mounted. Fair enough.");
-        paranoid_free(mount_cmd);
         return (0);
     }
@@ -597 +525 @@
         }
 #ifdef __FreeBSD__
-        sprintf(mount_cmd, "/mnt/isodir/%s/%s/%s-%d.iso", bkpinfo->isodir,
-                bkpinfo->nfs_remote_dir, bkpinfo->prefix, g_current_media_number);
+        asprintf(&mount_cmd, "/mnt/isodir/%s/%s/%s-%d.iso", bkpinfo->isodir,
+                bkpinfo->nfs_remote_dir, bkpinfo->prefix,
+                g_current_media_number);
         mddev = make_vn(mount_cmd);
-        sprintf(mount_cmd, "mount_cd9660 -r %s " MNT_CDROM, mddev);
+        paranoid_free(mount_cmd);
+
+        asprintf(&mount_cmd, "mount_cd9660 -r %s " MNT_CDROM, mddev);
+        paranoid_free(mddev);
 #else
-        sprintf(mount_cmd, "mount %s/%s/%s-%d.iso -t iso9660 -o loop,ro %s",
-                bkpinfo->isodir, bkpinfo->nfs_remote_dir,
-                bkpinfo->prefix, g_current_media_number, MNT_CDROM);
+        asprintf(&mount_cmd,
+                "mount %s/%s/%s-%d.iso -t iso9660 -o loop,ro %s",
+                bkpinfo->isodir, bkpinfo->nfs_remote_dir, bkpinfo->prefix,
+                g_current_media_number, MNT_CDROM);
 #endif
 
     } else if (bkpinfo->backup_media_type == iso) {
 #ifdef __FreeBSD__
-        sprintf(mount_cmd, "%s/%s-%d.iso", bkpinfo->isodir,
+        asprintf(&mount_cmd, "%s/%s-%d.iso", bkpinfo->isodir,
                 bkpinfo->prefix, g_current_media_number);
         mddev = make_vn(mount_cmd);
-        sprintf(mount_cmd, "mount_cd9660 -r %s %s", mddev, MNT_CDROM);
+        paranoid_free(mount_cmd);
+
+        asprintf(&mount_cmd, "mount_cd9660 -r %s %s", mddev, MNT_CDROM);
+        paranoid_free(mddev);
 #else
-        sprintf(mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s",
-                bkpinfo->isodir, bkpinfo->prefix, g_current_media_number, MNT_CDROM);
+        asprintf(&mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s",
+                bkpinfo->isodir, bkpinfo->prefix, g_current_media_number,
+                MNT_CDROM);
 #endif
     } else if (strstr(bkpinfo->media_device, "/dev/"))
 #ifdef __FreeBSD__
     {
-        sprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
+        asprintf(&mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
                 MNT_CDROM);
     }
 #else
     {
-        sprintf(mount_cmd, "mount %s -t iso9660 -o ro %s",
+        asprintf(&mount_cmd, "mount %s -t iso9660 -o ro %s",
                 bkpinfo->media_device, MNT_CDROM);
     }
@@ -634 +571 @@
             && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
             paranoid_free(bkpinfo->media_device);
-            asprintf(&tmp,
-                   last_line_of_file("/tmp/CDROM-LIVES-HERE"));
-            bkpinfo->media_device = tmp;
+            bkpinfo->media_device = last_line_of_file("/tmp/CDROM-LIVES-HERE");
         } else {
             paranoid_free(bkpinfo->media_device);
@@ -643 +578 @@
 
 #ifdef __FreeBSD__
-        sprintf(mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
+        asprintf(&mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
                 MNT_CDROM);
 #else
-        sprintf(mount_cmd, "mount %s -t iso9660 -o ro %s",
+        asprintf(&mount_cmd, "mount %s -t iso9660 -o ro %s",
                 bkpinfo->media_device, MNT_CDROM);
 #endif
@@ -662 +597 @@
         }
     }
+    paranoid_free(mount_cmd);
+
     if (res) {
         log_msg(2, "Failed, despite %d attempts", i);
@@ -667 +604 @@
         log_msg(2, "Mounted CD-ROM drive OK");
     }
-    paranoid_free(mount_cmd);
     return (res);
 }
-
-
-
-
-
 /**************************************************************************
  *END_MOUNT_CDROM                                                         *
@@ -692 +623 @@
     int res = 0;
 
-  /** malloc **/
-    char *tmp, *command, *mountdir, *mountpoint, *additional_parameters;
+    char *tmp = NULL;
+    char *command = NULL;
+    char *mountdir = NULL;
+    char *mountpoint = NULL;
+    char *additional_parameters = NULL;
+    char *p1 = NULL;
+    char *p2 = NULL;
+    char *p3 = NULL;
 
     assert_string_is_neither_NULL_nor_zerolength(device);
     assert_string_is_neither_NULL_nor_zerolength(mpt);
     assert(format != NULL);
-    malloc_string(tmp);
-    malloc_string(command);
-    malloc_string(mountdir);
-    malloc_string(mountpoint);
-    malloc_string(additional_parameters);
 
     if (!strcmp(mpt, "/1")) {
-        strcpy(mountpoint, "/");
+        asprintf(&mountpoint, "/");
         log_msg(3, "Mommm! SME is being a dildo!");
     } else {
-        strcpy(mountpoint, mpt);
+        asprintf(&mountpoint, mpt);
     }
 
     if (!strcmp(mountpoint, "lvm")) {
+        paranoid_free(mountpoint);
         return (0);
     }
     if (!strcmp(mountpoint, "image")) {
+        paranoid_free(mountpoint);
         return (0);
     }
-    sprintf(tmp, "Mounting device %s   ", device);
+    asprintf(&tmp, "Mounting device %s   ", device);
     log_msg(1, tmp);
+
     if (writeable) {
-        strcpy(additional_parameters, "-o rw");
-    } else {
-        strcpy(additional_parameters, "-o ro");
+        asprintf(&p1, "-o rw");
+    } else {
+        asprintf(&p1, "-o ro");
     }
     if (find_home_of_exe("setfattr")) {
-        strcat(additional_parameters, ",user_xattr");
+        asprintf(&p2, ",user_xattr");
+    } else {
+        asprintf(&p2, "");
     }
     if (find_home_of_exe("setfacl")) {
-        strcat(additional_parameters, ",acl");
-    }
+        asprintf(&p3, ",acl");
+    } else {
+        asprintf(&p3, "");
+    }
+    asprintf(&additional_parameters, "%s%s%s", p1, p2, p3);
+    paranoid_free(p1);
+    paranoid_free(p2);
+    paranoid_free(p3);
 
     if (!strcmp(mountpoint, "swap")) {
-        sprintf(command, "swapon %s", device);
+        asprintf(&command, "swapon %s", device);
     } else {
         if (!strcmp(mountpoint, "/")) {
-            strcpy(mountdir, MNT_RESTORING);
+            asprintf(&mountdir, MNT_RESTORING);
         } else {
-            sprintf(mountdir, "%s%s", MNT_RESTORING, mountpoint);
-        }
-        sprintf(command, "mkdir -p %s", mountdir);
+            asprintf(&mountdir, "%s%s", MNT_RESTORING, mountpoint);
+        }
+        asprintf(&command, "mkdir -p %s", mountdir);
         run_program_and_log_output(command, FALSE);
-        sprintf(command, "mount -t %s %s %s %s 2>> %s", format, device,
+        paranoid_free(command);
+
+        asprintf(&command, "mount -t %s %s %s %s 2>> %s", format, device,
                 additional_parameters, mountdir, MONDO_LOGFILE);
         log_msg(2, "command='%s'", command);
     }
+    paranoid_free(additional_parameters);
+
     res = run_program_and_log_output(command, TRUE);
     if (res && (strstr(command, "xattr") || strstr(command, "acl"))) {
         log_msg(1, "Re-trying without the fancy extra parameters");
-        sprintf(command, "mount -t %s %s %s 2>> %s", format, device,
+        paranoid_free(command);
+
+        asprintf(&command, "mount -t %s %s %s 2>> %s", format, device,
                 mountdir, MONDO_LOGFILE);
         res = run_program_and_log_output(command, TRUE);
@@ -760 +709 @@
         } else {
             log_msg(2, "Retrying w/o the '-t' switch");
-            sprintf(command, "mount %s %s 2>> %s", device, mountdir,
+            paranoid_free(command);
+
+            asprintf(&command, "mount %s %s 2>> %s", device, mountdir,
                     MONDO_LOGFILE);
             log_msg(2, "2nd command = '%s'", command);
@@ -772 +723 @@
         }
     }
+    paranoid_free(tmp);
+    paranoid_free(command);
+    paranoid_free(mountdir);
+
     if (res && !strcmp(mountpoint, "swap")) {
         log_msg(2, "That's ok. It's just a swap partition.");
@@ -777 +732 @@
         res = 0;
     }
-
-    paranoid_free(tmp);
-    paranoid_free(command);
-    paranoid_free(mountdir);
     paranoid_free(mountpoint);
-    paranoid_free(additional_parameters);
 
     return (res);
 }
-
 /**************************************************************************
  *END_MOUNT_DEVICE                                                        *
  **************************************************************************/
-
 
 
@@ -819 +767 @@
                                TRUE);
 }
-
 /**************************************************************************
  *END_PROTECT_AGAINST_BRAINDEAD_SYSADMINS                                 *
  **************************************************************************/
-
-
 
 
@@ -836 +781 @@
 int read_cfg_file_into_bkpinfo(char *cfgf, struct s_bkpinfo *bkpinfo)
 {
-  /** add mallocs **/
-    char *value;
-    char *tmp;
-    char *command;
-    char *iso_mnt;
-    char *iso_path;
-    char *old_isodir;
-    char cfg_file[100];
+    char *value = NULL;
+    char *tmp = NULL;
+    char *command = NULL;
+    char *iso_mnt = NULL;
+    char *iso_path = NULL;
+    char *old_isodir = NULL;
+    char *cfg_file = NULL;
     t_bkptype media_specified_by_user;
 
-    malloc_string(command);
-    malloc_string(iso_mnt);
-    malloc_string(iso_path);
-    malloc_string(old_isodir);
-    malloc_string(value);
-    malloc_string(tmp);
-//  assert_string_is_neither_NULL_nor_zerolength(cfg_file);
     assert(bkpinfo != NULL);
 
     if (!cfgf) {
-        strcpy(cfg_file, g_mondo_cfg_file);
-    } else {
-        strcpy(cfg_file, cfgf);
+        cfg_file = g_mondo_cfg_file;
+    } else {
+        cfg_file = cfgf;
     }
 
@@ -873 +810 @@
             bkpinfo->backup_media_type = dvd;
         } else if (!strcmp(value, "iso")) {
-/*
-      if (am_I_in_disaster_recovery_mode()
-      && !run_program_and_log_output("mount /dev/cdrom "MNT_CDROM, 1)
-      && does_file_exist(MNT_CDROM"/archives/filelist.0"))
-*/
-
-// Patch by Conor Daly - 2004/07/12
+            // Patch by Conor Daly - 2004/07/12
             bkpinfo->backup_media_type = iso;
             if (am_I_in_disaster_recovery_mode()) {
@@ -896 +827 @@
                 }
             }
+            paranoid_free(value);
+
             if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
-                    strcpy(bkpinfo->prefix,value);
+                paranoid_free(bkpinfo->prefix);
+                bkpinfo->prefix = value;
             } else {
-                    strcpy(bkpinfo->prefix,STD_PREFIX);
+                paranoid_alloc(bkpinfo->prefix, STD_PREFIX);
             }
         } else if (!strcmp(value, "nfs")) {
             bkpinfo->backup_media_type = nfs;
+            paranoid_free(value);
             if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
-                    strcpy(bkpinfo->prefix,value);
+                paranoid_free(bkpinfo->prefix);
+                bkpinfo->prefix = value;
             } else {
-                    strcpy(bkpinfo->prefix,STD_PREFIX);
+                paranoid_alloc(bkpinfo->prefix, STD_PREFIX);
             }
         } else if (!strcmp(value, "tape")) {
@@ -918 +854 @@
         fatal_error("backup-media-type not specified!");
     }
+    paranoid_free(value);
+
     if (bkpinfo->disaster_recovery) {
         if (bkpinfo->backup_media_type == cdstream) {
@@ -930 +868 @@
             read_cfg_var(cfg_file, "media-size", value);
             bkpinfo->media_size[1] = atol(value);
-            sprintf(tmp, "Backup medium is TAPE --- dev=%s",
+            paranoid_free(value);
+
+            asprintf(&tmp, "Backup medium is TAPE --- dev=%s",
                     bkpinfo->media_device);
             log_msg(2, tmp);
+            paranoid_free(tmp);
         } else {
             paranoid_alloc(bkpinfo->media_device, "/dev/cdrom");
@@ -949 +890 @@
         log_msg(1, "Goody! ... bkpinfo->use_star is now true.");
     }
+    paranoid_free(value);
 
     if (0 == read_cfg_var(cfg_file, "internal-tape-block-size", value)) {
@@ -960 +902 @@
                 DEFAULT_INTERNAL_TAPE_BLOCK_SIZE);
     }
+    paranoid_free(value);
 
     read_cfg_var(cfg_file, "use-lzo", value);
     if (strstr(value, "yes")) {
         bkpinfo->use_lzo = TRUE;
-        strcpy(bkpinfo->zip_exe, "lzop");
-        strcpy(bkpinfo->zip_suffix, "lzo");
-    } else {
+        paranoid_alloc(bkpinfo->zip_exe, "lzop");
+        paranoid_alloc(bkpinfo->zip_suffix, "lzo");
+    } else {
+        paranoid_free(value);
         read_cfg_var(cfg_file, "use-comp", value);
         if (strstr(value, "yes")) {
             bkpinfo->use_lzo = FALSE;
-            strcpy(bkpinfo->zip_exe, "bzip2");
-            strcpy(bkpinfo->zip_suffix, "bz2");
+            paranoid_alloc(bkpinfo->zip_exe, "bzip2");
+            paranoid_alloc(bkpinfo->zip_suffix, "bz2");
         } else {
-            bkpinfo->zip_exe[0] = bkpinfo->zip_suffix[0] = '\0';
-        }
-    }
-
-    value[0] = '\0';
+            // Just to be sure
+            bkpinfo->zip_exe = NULL;
+            bkpinfo->zip_suffix = NULL;
+        }
+    }
+    paranoid_free(value);
+
     read_cfg_var(cfg_file, "differential", value);
     if (!strcmp(value, "yes") || !strcmp(value, "1")) {
@@ -983 +929 @@
     }
     log_msg(2, "differential var = '%s'", value);
+    paranoid_free(value);
+
     if (bkpinfo->differential) {
         log_msg(2, "THIS IS A DIFFERENTIAL BACKUP");
@@ -990 +938 @@
 
     read_cfg_var(g_mondo_cfg_file, "please-dont-eject", tmp);
-    if (tmp[0]
-        ||
-        strstr(call_program_and_get_last_line_of_output
-               ("cat /proc/cmdline"), "donteject")) {
+#ifdef __FreeBSD__
+    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");
+#endif
+    if ((tmp != NULL) || strstr(tmp1,"donteject")) {
         bkpinfo->please_dont_eject = TRUE;
         log_msg(2, "Ok, I shan't eject when restoring! Groovy.");
     }
+    paranoid_free(tmp);
+    paranoid_free(tmp1);
 
     if (bkpinfo->backup_media_type == nfs) {
@@ -1018 +970 @@
          * isodir in disaster recovery mode
          */
-        strcpy(old_isodir, bkpinfo->isodir);
+        old_isodir = bkpinfo->isodir;
         read_cfg_var(g_mondo_cfg_file, "iso-mnt", iso_mnt);
         read_cfg_var(g_mondo_cfg_file, "isodir", iso_path);
-        sprintf(bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
-        if (!bkpinfo->isodir[0]) {
-            strcpy(bkpinfo->isodir, old_isodir);
-        }
+        if (iso_mnt && iso_path) {
+            asprintf(&bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
+        } else {
+            bkpinfo->isodir = old_isodir;
+        }
+        paranoid_free(iso_mnt);
+        paranoid_free(iso_path);
+
         if (!bkpinfo->disaster_recovery) {
             if (strcmp(old_isodir, bkpinfo->isodir)) {
@@ -1030 +986 @@
                     ("user nominated isodir differs from archive, keeping user's choice: %s %s\n",
                      old_isodir, bkpinfo->isodir);
-                strcpy(bkpinfo->isodir, old_isodir);
-            }
-        }
+                if (bkpinfo->isodir != old_isodir) {
+                    paranoid_free(old_isodir);
+                }
+            } else {
+                paranoid_free(old_isodir);
+            }
+        }
+
         read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
-        log_msg(2, "isodir=%s; iso-dev=%s", bkpinfo->isodir,
-                g_isodir_device);
+        log_msg(2, "isodir=%s; iso-dev=%s", bkpinfo->isodir, g_isodir_device);
         if (bkpinfo->disaster_recovery) {
             if (is_this_device_mounted(g_isodir_device)) {
                 log_msg(2, "NB: isodir is already mounted");
                 /* Find out where it's mounted */
-                sprintf(command,
+                asprintf(&command,
                         "mount | grep -w %s | tail -n1 | cut -d' ' -f3",
                         g_isodir_device);
                 log_it("command = %s", command);
-                log_it("res of it = %s",
-                       call_program_and_get_last_line_of_output(command));
-                sprintf(iso_mnt, "%s",
-                        call_program_and_get_last_line_of_output(command));
+                tmp = call_program_and_get_last_line_of_output(command);
+                log_it("res of it = %s", tmp);
+                iso_mnt = tmp;
+                paranoid_free(command);
             } else {
-                sprintf(iso_mnt, "/tmp/isodir");
-                sprintf(tmp, "mkdir -p %s", iso_mnt);
+                asprintf(&iso_mnt, "/tmp/isodir");
+                asprintf(&tmp, "mkdir -p %s", iso_mnt);
                 run_program_and_log_output(tmp, 5);
-                sprintf(tmp, "mount %s %s", g_isodir_device, iso_mnt);
+                paranoid_free(tmp);
+
+                asprintf(&tmp, "mount %s %s", g_isodir_device, iso_mnt);
                 if (run_program_and_log_output(tmp, 3)) {
                     log_msg(1,
@@ -1058 +1020 @@
                     bkpinfo->backup_media_type = cdr;
                     paranoid_alloc(bkpinfo->media_device, "/dev/cdrom");
-                    bkpinfo->isodir[0] = iso_mnt[0] = iso_path[0] = '\0';
+                    paranoid_free(bkpinfo->isodir);
+                    paranoid_free(iso_mnt);
+                    paranoid_free(iso_path);
+                    asprintf(&iso_mnt, "");
+                    asprintf(&iso_path, "");
+
                     if (mount_cdrom(bkpinfo)) {
                         fatal_error
@@ -1067 +1034 @@
                     }
                 }
+                paranoid_free(tmp);
             }
             /* bkpinfo->isodir should now be the true path to prefix-1.iso etc... */
             if (bkpinfo->backup_media_type == iso) {
-                sprintf(bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
-            }
+                paranoid_free(bkpinfo->isodir);
+                asprintf(&bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
+            }
+            paranoid_free(iso_mnt);
+            paranoid_free(iso_path);
         }
     }
@@ -1080 +1051 @@
                 log_msg(2,
                         "bkpinfo->backup_media_type != media_specified_by_user, so I'd better ask :)");
-                interactively_obtain_media_parameters_from_user(bkpinfo,
-                                                                FALSE);
+                interactively_obtain_media_parameters_from_user(bkpinfo, FALSE);
                 media_specified_by_user = bkpinfo->backup_media_type;
                 get_cfg_file_from_archive(bkpinfo);
@@ -1093 +1063 @@
     }
     g_backup_media_type = bkpinfo->backup_media_type;
-    paranoid_free(value);
-    paranoid_free(tmp);
-    paranoid_free(command);
-    paranoid_free(iso_mnt);
-    paranoid_free(iso_path);
-    paranoid_free(old_isodir);
     return (0);
-
-}
-
+}
 /**************************************************************************
  *END_READ_CFG_FILE_INTO_BKPINFO                                          *
  **************************************************************************/
-
-
 
 
@@ -1125 +1085 @@
     struct s_node *filelist;
 
-  /** add mallocs**/
-    char *command;
-    char *tmp;
+    char *command = NULL;
+    char *tmp = NULL;
     int res = 0;
+    size_t n = 0;
     pid_t pid;
 
     assert(bkpinfo != NULL);
-    malloc_string(command);
     malloc_string(tmp);
 
@@ -1150 +1109 @@
         unlink("/tmp/i-want-my-lvm");
         if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
-            sprintf(command,
+            asprintf(&command,
                     "tar -zxf %s %s %s %s %s %s",
                     bkpinfo->media_device,
@@ -1159 +1118 @@
             log_msg(1, "tarcommand = %s", command);
             run_program_and_log_output(command, 1);
+            paranoid_free(command);
         } else {
             log_msg(2,
@@ -1166 +1126 @@
             log_msg(2, "Back from iotcn");
             run_program_and_log_output("mount", 1);
-            sprintf(command,
+            asprintf(&command,
                     "tar -zxf %s/images/all.tar.gz %s %s %s %s %s",
                     MNT_CDROM,
@@ -1176 +1136 @@
             log_msg(1, "tarcommand = %s", command);
             run_program_and_log_output(command, 1);
-//    popup_and_OK("Press ENTER to continue");
+            paranoid_free(command);
+
             if (!does_file_exist(BIGGIELIST_TXT_STUB)) {
                 fatal_error
@@ -1186 +1147 @@
             }
         }
-        sprintf(command, "cp -f %s %s", MONDO_CFG_FILE_STUB,
+        asprintf(&command, "cp -f %s %s", MONDO_CFG_FILE_STUB,
                 g_mondo_cfg_file);
         run_program_and_log_output(command, FALSE);
-
-        sprintf(command, "cp -f %s/%s %s", bkpinfo->tmpdir,
+        paranoid_free(command);
+
+        asprintf(&command, "cp -f %s/%s %s", bkpinfo->tmpdir,
                 BIGGIELIST_TXT_STUB, g_biggielist_txt);
         log_msg(1, "command = %s", command);
         paranoid_system(command);
-        sprintf(command, "ln -sf %s/%s %s", bkpinfo->tmpdir,
+        paranoid_free(command);
+
+        asprintf(&command, "ln -sf %s/%s %s", bkpinfo->tmpdir,
                 FILELIST_FULL_STUB, g_filelist_full);
         log_msg(1, "command = %s", command);
         paranoid_system(command);
+        paranoid_free(command);
     }
 
     if (am_I_in_disaster_recovery_mode()
         &&
-        ask_me_yes_or_no(_("Do you want to retrieve the mountlist as well?")))
+        ask_me_yes_or_no(_
+                         ("Do you want to retrieve the mountlist as well?")))
     {
-//      sprintf(command, "cp -f tmp/mountlist.txt /tmp");
-        sprintf(command, "ln -sf %s/%s /tmp", MOUNTLIST_FNAME_STUB,
+        asprintf(&command, "ln -sf %s/%s /tmp", MOUNTLIST_FNAME_STUB,
                 bkpinfo->tmpdir);
         paranoid_system(command);
+        paranoid_free(command);
     }
 
     chdir(tmp);
+    paranoid_free(tmp);
 
     if (!does_file_exist(g_biggielist_txt)) {
@@ -1230 +1197 @@
         log_to_screen(("Pre-processing filelist"));
         if (!does_file_exist(g_biggielist_txt)) {
-            sprintf(command, "> %s", g_biggielist_txt);
+            asprintf(&command, "> %s", g_biggielist_txt);
             paranoid_system(command);
-        }
-        sprintf(command, "grep  -x \"/dev/.*\" %s > %s",
+            paranoid_free(command);
+        }
+        asprintf(&command, "grep  -x \"/dev/.*\" %s > %s",
                 g_biggielist_txt, g_filelist_imagedevs);
         paranoid_system(command);
+        paranoid_free(command);
         exit(0);
         break;
@@ -1254 +1223 @@
     if (g_text_mode) {
         printf(_("Restore which directory? --> "));
-        fgets(tmp, sizeof(tmp), stdin);
+        getline(&tmp, &n, stdin);
         toggle_path_selection(filelist, tmp, TRUE);
         if (strlen(tmp) == 0) {
@@ -1261 +1230 @@
             res = 0;
         }
+        paranoid_free(tmp);
     } else {
         res = edit_filelist(filelist);
@@ -1282 +1252 @@
                                       TRUE);
     }
-
-    paranoid_free(command);
-    paranoid_free(tmp);
     return (filelist);
 }
-
 /**************************************************************************
  *END_ PROCESS_FILELIST_AND_BIGGIELIST                                    *
  **************************************************************************/
-
-
 
 
@@ -1304 +1268 @@
 int backup_crucial_file(char *path_root, char *filename)
 {
-    char *tmp;
-    char *command;
-    int res;
-
-    malloc_string(tmp);
-    malloc_string(command);
+    char *command = NULL;
+    int res = 0;
+
     assert(path_root != NULL);
     assert_string_is_neither_NULL_nor_zerolength(filename);
 
-    sprintf(tmp, "%s/%s", path_root, filename);
-    sprintf(command, "cp -f %s %s.pristine", tmp, tmp);
-
+    asprintf(&command, "cp -f %s/%s %s/%s.pristine", path_root, filename,path_root, filename);
     res = run_program_and_log_output(command, 5);
-    paranoid_free(tmp);
     paranoid_free(command);
     return (res);
@@ -1334 +1292 @@
     int retval = 0;
 
-  /** malloc *******/
-    char *device;
-    char *tmp;
-    char *name;
-
-    malloc_string(device);
-    malloc_string(tmp);
-    malloc_string(name);
+    char *device = NULL;
+    char *tmp = NULL;
+    char *name = NULL;
+
     backup_crucial_file(MNT_RESTORING, "/etc/fstab");
     backup_crucial_file(MNT_RESTORING, "/etc/grub.conf");
@@ -1348 +1302 @@
     read_cfg_var(g_mondo_cfg_file, "bootloader.device", device);
     read_cfg_var(g_mondo_cfg_file, "bootloader.name", name);
-    sprintf(tmp, "run_boot_loader: device='%s', name='%s'", device, name);
+    asprintf(&tmp, "run_boot_loader: device='%s', name='%s'", device, name);
     log_msg(2, tmp);
-    system("sync");
+    paranoid_free(tmp);
+
+    sync();
     if (!strcmp(name, "LILO")) {
         res = run_lilo(offer_to_hack_scripts);
@@ -1371 +1327 @@
 #ifdef __FreeBSD__
     else if (!strcmp(name, "BOOT0")) {
-        sprintf(tmp, "boot0cfg -B %s", device);
+        asprintf(&tmp, "boot0cfg -B %s", device);
         res = run_program_and_log_output(tmp, FALSE);
-    } else {
-        sprintf(tmp, "ls /dev | grep -xq %ss[1-4].*", device);
+        paranoid_free(tmp);
+    } else {
+        asprintf(&tmp, "ls /dev | grep -xq %ss[1-4].*", device);
         if (!system(tmp)) {
-            sprintf(tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
+            paranoid_free(tmp);
+            asprintf(&tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
             res = run_program_and_log_output(tmp, 3);
         } else {
@@ -1382 +1340 @@
                     "I'm not running any boot loader. You have a DD boot drive. It's already loaded up.");
         }
+        paranoid_free(tmp);
     }
 #else
     else {
         log_to_screen
-            (_("Unable to determine type of boot loader. Defaulting to LILO."));
+            (_
+             ("Unable to determine type of boot loader. Defaulting to LILO."));
         res = run_lilo(offer_to_hack_scripts);
     }
 #endif
+    paranoid_free(device);
+    paranoid_free(name);
+
     retval += res;
     if (res) {
@@ -1396 +1359 @@
         log_to_screen(_("Your boot loader ran OK"));
     }
-    paranoid_free(device);
-    paranoid_free(tmp);
-    paranoid_free(name);
     return (retval);
 }
-
 /**************************************************************************
  *END_ RUN_BOOT_LOADER                                                    *
@@ -1407 +1366 @@
 
 
-
 /**
  * Attempt to find the user's editor.
  * @return The editor found ("vi" if none could be found).
- * @note The returned string points to static storage that will be overwritten with each call.
+ * @note The returned string points to malloced storage that needs to be freed by caller
  */
 char *find_my_editor(void)
 {
-    static char output[MAX_STR_LEN];
+    char *output = NULL;
+
+    /* BERLIOS: This should use $EDITOR + conf file rather first */
     if (find_home_of_exe("pico")) {
-        strcpy(output, "pico");
+        asprintf(&output, "pico");
     } else if (find_home_of_exe("nano")) {
-        strcpy(output, "nano");
+        asprintf(&output, "nano");
     } else if (find_home_of_exe("e3em")) {
-        strcpy(output, "e3em");
+        asprintf(&output, "e3em");
     } else if (find_home_of_exe("e3vi")) {
-        strcpy(output, "e3vi");
-    } else {
-        strcpy(output, "vi");
+        asprintf(&output, "e3vi");
+    } else {
+        asprintf(&output, "vi");
     }
     if (!find_home_of_exe(output)) {
@@ -1442 +1402 @@
 int run_grub(bool offer_to_run_stabgrub, char *bd)
 {
-  /** malloc **/
-    char *command;
-    char *boot_device;
-    char *rootdev;
-    char *rootdrive;
-    char *conffile;
-    char *tmp;
-    char *editor;
-
-    int res;
-    int done;
-
-    malloc_string(command);
-    malloc_string(boot_device);
-    malloc_string(tmp);
-    malloc_string(editor);
-    malloc_string(rootdev);
-    malloc_string(rootdrive);
-    malloc_string(conffile);
+    char *command = NULL;
+    char *tmp = NULL;
+    char *editor = NULL;
+
+    int res = 0;
+    int done = 0;
+
     assert_string_is_neither_NULL_nor_zerolength(bd);
-    strcpy(editor, "vi");       // find_my_editor() );
-    strcpy(boot_device, bd);
-
-    if (!run_program_and_log_output("which grub-MR", FALSE)) {
-        log_msg(1, "Yay! grub-MR found...");
-        sprintf(command, "grub-MR %s /tmp/mountlist.txt", boot_device);
-        log_msg(1, "command = %s", command);
-    } else {
-        sprintf(command, "chroot " MNT_RESTORING " grub-install %s",
-                boot_device);
-        log_msg(1, "WARNING - grub-MR not found; using grub-install");
-    }
+
     if (offer_to_run_stabgrub
         && ask_me_yes_or_no(_("Did you change the mountlist?")))
@@ -1480 +1417 @@
         mvaddstr_and_log_it(g_currentY,
                             0,
-                            _("Modifying fstab and grub.conf, and running GRUB...                             "));
+                            _
+                            ("Modifying fstab and grub.conf, and running GRUB...                             "));
         for (done = FALSE; !done;) {
             popup_and_get_string(_("Boot device"),
-                                 _("Please confirm/enter the boot device. If in doubt, try /dev/hda"),
-                                 boot_device, MAX_STR_LEN / 4);
-            sprintf(command, "stabgrub-me %s", boot_device);
+                                 _("Please confirm/enter the boot device. If in doubt, try /dev/hda"), bd);
+            asprintf(&command, "stabgrub-me %s", bd);
             res = run_program_and_log_output(command, 1);
+            paranoid_free(command);
+
             if (res) {
                 popup_and_OK
-                    (_("GRUB installation failed. Please install manually using 'grub-install' or similar command. You are now chroot()'ed to your restored system. Please type 'exit' when you are done."));
+                    (_
+                     ("GRUB installation failed. Please install manually using 'grub-install' or similar command. You are now chroot()'ed to your restored system. Please type 'exit' when you are done."));
                 newtSuspend();
                 system("chroot " MNT_RESTORING);
@@ -1501 +1441 @@
                 newtSuspend();
             }
-            sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+            editor = find_my_editor();
+            asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
             paranoid_system(tmp);
-            sprintf(tmp, "%s " MNT_RESTORING "/etc/grub.conf", editor);
+            paranoid_free(tmp);
+
+            asprintf(&tmp, "%s " MNT_RESTORING "/etc/grub.conf", editor);
+            paranoid_free(editor);
+
             paranoid_system(tmp);
+            paranoid_free(tmp);
+
             if (!g_text_mode) {
                 newtResume();
             }
         }
-    } else
+    } else {
         /* nuke mode */
-    {
+        if (!run_program_and_log_output("which grub-MR", FALSE)) {
+            log_msg(1, "Yay! grub-MR found...");
+            asprintf(&command, "grub-MR %s /tmp/mountlist.txt", bd);
+            log_msg(1, "command = %s", command);
+        } else {
+            asprintf(&command, "chroot " MNT_RESTORING " grub-install %s", bd);
+            log_msg(1, "WARNING - grub-MR not found; using grub-install");
+        }
         mvaddstr_and_log_it(g_currentY,
                             0,
-                            _("Running GRUB...                                                 "));
+                            _
+                            ("Running GRUB...                                                 "));
         iamhere(command);
         res = run_program_and_log_output(command, 1);
+        paranoid_free(command);
+
         if (res) {
             popup_and_OK
-                (_("Because of bugs in GRUB's own installer, GRUB was not installed properly. Please install the boot loader manually now, using this chroot()'ed shell prompt. Type 'exit' when you have finished."));
+                (_
+                 ("Because of bugs in GRUB's own installer, GRUB was not installed properly. Please install the boot loader manually now, using this chroot()'ed shell prompt. Type 'exit' when you have finished."));
             newtSuspend();
             system("chroot " MNT_RESTORING);
@@ -1529 +1487 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
         log_to_screen
-            (_("GRUB ran w/error(s). See /tmp/mondo-restore.log for more info."));
+            (_
+             ("GRUB ran w/error(s). See /tmp/mondo-restore.log for more info."));
         log_msg(1, "Type:-");
         log_msg(1, "    mount-me");
@@ -1542 +1501 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     }
-    paranoid_free(rootdev);
-    paranoid_free(rootdrive);
-    paranoid_free(conffile);
-    paranoid_free(command);
-    paranoid_free(boot_device);
-    paranoid_free(tmp);
-    paranoid_free(editor);
-
     return (res);
 }
-
 /**************************************************************************
  *END_RUN_GRUB                                                            *
@@ -1565 +1515 @@
 int run_elilo(bool offer_to_run_stabelilo)
 {
-  /** malloc **/
-    char *command;
-    char *tmp;
-    char *editor;
-
-    int res;
-    int done;
-
-    malloc_string(command);
-    malloc_string(tmp);
-    malloc_string(editor);
-    strcpy(editor, find_my_editor());
+    char *command = NULL;
+    char *tmp = NULL;
+    char *editor = NULL;
+
+    int res = 0;
+    int done = 0;
+
     if (offer_to_run_stabelilo
         && ask_me_yes_or_no(_("Did you change the mountlist?")))
@@ -1584 +1529 @@
         mvaddstr_and_log_it(g_currentY,
                             0,
-                            _("Modifying fstab and elilo.conf...                             "));
-        sprintf(command, "stabelilo-me");
+                            _
+                            ("Modifying fstab and elilo.conf...                             "));
+        asprintf(&command, "stabelilo-me");
         res = run_program_and_log_output(command, 3);
+        paranoid_free(command);
+
         if (res) {
             popup_and_OK
-                (_("You will now edit fstab and elilo.conf, to make sure they match your new mountlist."));
+                (_
+                 ("You will now edit fstab and elilo.conf, to make sure they match your new mountlist."));
             for (done = FALSE; !done;) {
                 if (!g_text_mode) {
                     newtSuspend();
                 }
-                sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+                editor = find_my_editor();
+                asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
                 paranoid_system(tmp);
-                sprintf(tmp, "%s " MNT_RESTORING "/etc/elilo.conf",
-                        editor);
+                paranoid_free(tmp);
+
+                asprintf(&tmp, "%s " MNT_RESTORING "/etc/elilo.conf", editor);
+                paranoid_free(editor);
+
                 paranoid_system(tmp);
+                paranoid_free(tmp);
+
                 if (!g_text_mode) {
                     newtResume();
@@ -1616 +1571 @@
         res = TRUE;
     }
-    paranoid_free(command);
-    paranoid_free(tmp);
-    paranoid_free(editor);
     return (res);
 }
-
 /**************************************************************************
  *END_RUN_ELILO                                                            *
@@ -1635 +1586 @@
 {
   /** malloc **/
-    char *command;
-    char *tmp;
-    char *editor;
-
-    int res;
-    int done;
+    char *command = NULL;
+    char *tmp = NULL;
+    char *editor = NULL;
+
+    int res = 0;
+    int done = 0;
     bool run_lilo_M = FALSE;
-    malloc_string(command);
-    malloc_string(tmp);
-    malloc_string(editor);
 
     if (!run_program_and_log_output
@@ -1651 +1599 @@
     }
 
-    strcpy(editor, find_my_editor());
     if (offer_to_run_stablilo
-        && ask_me_yes_or_no(_("Did you change the mountlist?")))
-
+        && ask_me_yes_or_no(_("Did you change the mountlist?"))) {
         /* interactive mode */
-    {
         mvaddstr_and_log_it(g_currentY,
                             0,
-                            _("Modifying fstab and lilo.conf, and running LILO...                             "));
-        sprintf(command, "stablilo-me");
+                            _
+                            ("Modifying fstab and lilo.conf, and running LILO...                             "));
+        asprintf(&command, "stablilo-me");
         res = run_program_and_log_output(command, 3);
+        paranoid_free(command);
+
         if (res) {
             popup_and_OK
-                (_("You will now edit fstab and lilo.conf, to make sure they match your new mountlist."));
+                (_
+                 ("You will now edit fstab and lilo.conf, to make sure they match your new mountlist."));
             for (done = FALSE; !done;) {
                 if (!g_text_mode) {
                     newtSuspend();
                 }
-                sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+                editor = find_my_editor();
+                asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
                 paranoid_system(tmp);
-                sprintf(tmp, "%s " MNT_RESTORING "/etc/lilo.conf", editor);
+                paranoid_free(tmp);
+
+                asprintf(&tmp, "%s " MNT_RESTORING "/etc/lilo.conf", editor);
+                paranoid_free(editor);
+
                 paranoid_system(tmp);
+                paranoid_free(tmp);
+
                 if (!g_text_mode) {
                     newtResume();
@@ -1699 +1655 @@
             log_to_screen(_("lilo.conf and fstab were modified OK"));
         }
-    } else
+    } else {
         /* nuke mode */
-    {
         mvaddstr_and_log_it(g_currentY,
                             0,
-                            _("Running LILO...                                                 "));
+                            _
+                            ("Running LILO...                                                 "));
         res =
             run_program_and_log_output("chroot " MNT_RESTORING " lilo -L",
@@ -1716 +1672 @@
             mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
             log_to_screen
-                (_("Failed to re-jig fstab and/or lilo. Edit/run manually, please."));
+                (_
+                 ("Failed to re-jig fstab and/or lilo. Edit/run manually, please."));
         } else {
             mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
@@ -1727 +1684 @@
                                    " lilo -M /dev/sda", 3);
     }
-    paranoid_free(command);
-    paranoid_free(tmp);
-    paranoid_free(editor);
     return (res);
 }
@@ -1746 +1700 @@
 int run_raw_mbr(bool offer_to_hack_scripts, char *bd)
 {
-  /** malloc **/
-    char *command;
-    char *boot_device;
-    char *tmp;
-    char *editor;
-    int res;
-    int done;
-
-    malloc_string(command);
-    malloc_string(boot_device);
-    malloc_string(tmp);
-    malloc_string(editor);
+    char *command = NULL;
+    char *tmp = NULL;
+    char *editor = NULL;
+    int res = 0;
+    int done = 0;
+
     assert_string_is_neither_NULL_nor_zerolength(bd);
 
-    strcpy(editor, find_my_editor());
-    strcpy(boot_device, bd);
-    sprintf(command, "raw-MR %s /tmp/mountlist.txt", boot_device);
-    log_msg(2, "run_raw_mbr() --- command='%s'", command);
-
     if (offer_to_hack_scripts
-        && ask_me_yes_or_no(_("Did you change the mountlist?")))
+        && ask_me_yes_or_no(_("Did you change the mountlist?"))) {
         /* interactive mode */
-    {
         mvaddstr_and_log_it(g_currentY, 0,
-                            _("Modifying fstab and restoring MBR...                           "));
+                            _
+                            ("Modifying fstab and restoring MBR...                           "));
         for (done = FALSE; !done;) {
             if (!run_program_and_log_output("which vi", FALSE)) {
@@ -1777 +1720 @@
                     newtSuspend();
                 }
-                sprintf(tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+                editor = find_my_editor();
+                asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+                paranoid_free(editor);
+
                 paranoid_system(tmp);
+                paranoid_free(tmp);
+
                 if (!g_text_mode) {
                     newtResume();
@@ -1785 +1733 @@
             }
             popup_and_get_string(_("Boot device"),
-                                 _("Please confirm/enter the boot device. If in doubt, try /dev/hda"),
-                                 boot_device, MAX_STR_LEN / 4);
-            sprintf(command, "stabraw-me %s", boot_device);
+                                 _
+                                 ("Please confirm/enter the boot device. If in doubt, try /dev/hda"), bd);
+            asprintf(&command, "stabraw-me %s", bd);
             res = run_program_and_log_output(command, 3);
+            paranoid_free(command);
+
             if (res) {
-                done = ask_me_yes_or_no(_("Modifications failed. Re-try?"));
+                done =
+                    ask_me_yes_or_no(_("Modifications failed. Re-try?"));
             } else {
                 done = TRUE;
             }
         }
-    } else
+    } else {
         /* nuke mode */
-    {
         mvaddstr_and_log_it(g_currentY, 0,
-                            _("Restoring MBR...                                               "));
+                            _
+                            ("Restoring MBR...                                               "));
+        asprintf(&command, "raw-MR %s /tmp/mountlist.txt", bd);
+        log_msg(2, "run_raw_mbr() --- command='%s'", command);
         res = run_program_and_log_output(command, 3);
+        paranoid_free(command);
     }
     if (res) {
         mvaddstr_and_log_it(g_currentY++, 74, _("Failed."));
         log_to_screen
-            (_("MBR+fstab processed w/error(s). See /tmp/mondo-restore.log for more info."));
+            (_
+             ("MBR+fstab processed w/error(s). See /tmp/mondo-restore.log for more info."));
     } else {
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     }
-    paranoid_free(command);
-    paranoid_free(boot_device);
-    paranoid_free(tmp);
-    paranoid_free(editor);
     return (res);
 }
-
 /**************************************************************************
  *END_RUN_RAW_MBR                                                         *
  **************************************************************************/
-
-
-
 
 
@@ -1858 +1805 @@
 void setup_MR_global_filenames(struct s_bkpinfo *bkpinfo)
 {
-    char *temppath;
-
     assert(bkpinfo != NULL);
 
-    malloc_string(g_biggielist_txt);
-    malloc_string(g_filelist_full);
-    malloc_string(g_filelist_imagedevs);
-    malloc_string(g_imagedevs_restthese);
-    malloc_string(g_mondo_cfg_file);
-    malloc_string(g_mountlist_fname);
     malloc_string(g_tmpfs_mountpt);
-    malloc_string(g_isodir_device);
-    malloc_string(g_isodir_format);
-
-    temppath = bkpinfo->tmpdir;
-
-    sprintf(g_biggielist_txt, "%s/%s", temppath, BIGGIELIST_TXT_STUB);
-    sprintf(g_filelist_full, "%s/%s", temppath, FILELIST_FULL_STUB);
-    sprintf(g_filelist_imagedevs, "%s/tmp/filelist.imagedevs", temppath);
-//  sprintf(g_imagedevs_pot, "%s/tmp/imagedevs.pot", temppath);
-    sprintf(g_imagedevs_restthese, "%s/tmp/imagedevs.restore-these",
-            temppath);
+
+    asprintf(&g_biggielist_txt, "%s/%s",bkpinfo->tmpdir , BIGGIELIST_TXT_STUB);
+    asprintf(&g_filelist_full, "%s/%s", bkpinfo->tmpdir, FILELIST_FULL_STUB);
+    asprintf(&g_filelist_imagedevs, "%s/tmp/filelist.imagedevs", bkpinfo->tmpdir);
+    asprintf(&g_imagedevs_restthese, "%s/tmp/imagedevs.restore-these",
+            bkpinfo->tmpdir);
     if (bkpinfo->disaster_recovery) {
-        sprintf(g_mondo_cfg_file, "/%s", MONDO_CFG_FILE_STUB);
-        sprintf(g_mountlist_fname, "/%s", MOUNTLIST_FNAME_STUB);
-    } else {
-        sprintf(g_mondo_cfg_file, "%s/%s", temppath, MONDO_CFG_FILE_STUB);
-        sprintf(g_mountlist_fname, "%s/%s", temppath,
-                MOUNTLIST_FNAME_STUB);
-    }
-}
-
+        asprintf(&g_mondo_cfg_file, "/%s", MONDO_CFG_FILE_STUB);
+        asprintf(&g_mountlist_fname, "/%s", MOUNTLIST_FNAME_STUB);
+    } else {
+        asprintf(&g_mondo_cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
+        asprintf(&g_mountlist_fname, "%s/%s", bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
+    }
+}
 /**************************************************************************
  *END_SET_GLOBAL_FILENAME                                                 *
@@ -1905 +1837 @@
     FILE *fin;
     FILE *fout;
-  /** malloc **/
-    char *incoming;
+    char *incoming = NULL;
+    size_t n = 0;
 
     assert_string_is_neither_NULL_nor_zerolength(output_file);
     assert_string_is_neither_NULL_nor_zerolength(input_file);
-    malloc_string(incoming);
 
     if (!(fin = fopen(input_file, "r"))) {
@@ -1919 +1850 @@
         fatal_error("cannot open output_file");
     }
-    for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin);
-         fgets(incoming, MAX_STR_LEN - 1, fin)) {
+    for (getline(&incoming, &n, fin); !feof(fin);
+         getline(&incoming, &n, fin)) {
         if (strncmp(incoming, "etc/adjtime", 11)
             && strncmp(incoming, "etc/mtab", 8)
@@ -1930 +1861 @@
             fprintf(fout, "%s", incoming);  /* don't need \n here, for some reason.. */
     }
+    paranoid_free(incoming);
     paranoid_fclose(fout);
     paranoid_fclose(fin);
-    paranoid_free(incoming);
-}
-
+}
 /**************************************************************************
  *END_STREAMLINE_CHANGES_FILE                                             *
@@ -1947 +1877 @@
 {
     log_to_screen
-        (_("Mondorestore is terminating in response to a signal from the OS"));
+        (_
+         ("Mondorestore is terminating in response to a signal from the OS"));
     paranoid_MR_finish(254);
 }
-
 /**************************************************************************
  *END_TERMINATE_DAEMON                                                    *
@@ -1962 +1892 @@
 {
     int i;
-    /* MALLOC * */
-    char *tmp;
-
-    malloc_string(tmp);
+    char *tmp = NULL;
+
     if (does_file_exist("/tmp/NOPAUSE")) {
         return;
     }
     open_progress_form(_("CAUTION"),
-                       _("Be advised: I am about to ERASE your hard disk(s)!"),
+                       _
+                       ("Be advised: I am about to ERASE your hard disk(s)!"),
                        _("You may press Ctrl+Alt+Del to abort safely."),
                        "", 20);
     for (i = 0; i < 20; i++) {
         g_current_progress = i;
-        sprintf(tmp, _("You have %d seconds left to abort."), 20 - i);
+        asprintf(&tmp, _("You have %d seconds left to abort."), 20 - i);
         update_progress_form(tmp);
+        paranoid_free(tmp);
         sleep(1);
     }
     close_progress_form();
-    paranoid_free(tmp);
-}
-
+}
 /**************************************************************************
  *END_TWENTY_SECONDS_TIL_YIKES                                            *
@@ -1988 +1916 @@
 
 
-
-
-
 /**
  * Exit due to a signal (no cleanup).
@@ -2001 +1926 @@
     pthread_exit(0);
 }
-
 /**************************************************************************
  *END_TERMINATION_IN_PROGRESS                                             *
@@ -2007 +1931 @@
 
 
-
 /**
  * Unmount all devices in @p p_external_copy_of_mountlist.
@@ -2017 +1940 @@
 {
     struct mountlist_itself *mountlist;
-    int retval = 0, lino, res = 0, i;
-    char *command;
-    char *tmp;
-
-    malloc_string(command);
-    malloc_string(tmp);
+    int retval = 0;
+    int lino = 0;
+    int res = 0;
+    int i = 0;
+    char *command = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+
     assert(p_external_copy_of_mountlist != NULL);
 
@@ -2034 +1959 @@
     open_progress_form(_("Unmounting devices"),
                        _("Unmounting all devices that were mounted,"),
-                       _("in preparation for the post-restoration reboot."),
+                       _
+                       ("in preparation for the post-restoration reboot."),
                        "", mountlist->entries);
     chdir("/");
@@ -2047 +1973 @@
     }
 
-    paranoid_system("sync");
+    sync();
 
     if (run_program_and_log_output
@@ -2067 +1993 @@
             continue;
         }
-        sprintf(tmp, _("Unmounting device %s  "), mountlist->el[lino].device);
+        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")) {
-                sprintf(command, "swapoff %s", mountlist->el[lino].device);
+                asprintf(&command, "swapoff %s", mountlist->el[lino].device);
             } else {
                 if (!strcmp(mountlist->el[lino].mountpoint, "/1")) {
-                    sprintf(command, "umount %s/", MNT_RESTORING);
+                    asprintf(&command, "umount %s/", MNT_RESTORING);
                     log_msg(3,
                             "Well, I know a certain kitty-kitty who'll be sleeping with Mommy tonight...");
                 } else {
-                    sprintf(command, "umount " MNT_RESTORING "%s",
+                    asprintf(&command, "umount " MNT_RESTORING "%s",
                             mountlist->el[lino].mountpoint);
                 }
@@ -2085 +2013 @@
             log_msg(10, "The 'umount' command is '%s'", command);
             res = run_program_and_log_output(command, 3);
+            paranoid_free(command);
         } else {
-            strcat(tmp, _("...not mounted anyway :-) OK"));
+            asprintf(&tmp1, "%s%s", tmp, _("...not mounted anyway :-) OK"));
+            paranoid_free(tmp);
+            tmp = tmp1;
             res = 0;
         }
         g_current_progress++;
         if (res) {
-            strcat(tmp, _("...Failed"));
+            asprintf(&tmp1, "%s%s", tmp, _("...Failed"));
+            paranoid_free(tmp);
+            tmp = tmp1;
             retval++;
             log_to_screen(tmp);
@@ -2097 +2030 @@
             log_msg(2, tmp);
         }
+        paranoid_free(tmp);
     }
     close_progress_form();
@@ -2110 +2044 @@
     }
     free(mountlist);
-    paranoid_free(command);
-    paranoid_free(tmp);
     return (retval);
 }
-
 /**************************************************************************
  *END_UNMOUNT_ALL_DEVICES                                                 *
  **************************************************************************/
-
 
 
@@ -2129 +2059 @@
 int extract_cfg_file_and_mountlist_from_tape_dev(char *dev)
 {
-    char *command;
+    char *command = NULL;
     int res = 0;
-    // BCO: below 32KB seems to block at least on RHAS 2.1 and MDK 10.0
+    // BERLIOS: below 32KB seems to block at least on RHAS 2.1 and MDK 10.0
     long tape_block_size = 32768;
 
-    malloc_string(command);
-
     // tar -zxvf-
-    sprintf(command,
+    asprintf(&command,
             "dd if=%s bs=%ld count=%ld 2> /dev/null | tar -zx %s %s %s %s %s",
             dev,
@@ -2146 +2074 @@
     log_msg(2, "command = '%s'", command);
     res = run_program_and_log_output(command, -1);
+    paranoid_free(command);
+
     if (res != 0 && does_file_exist(MONDO_CFG_FILE_STUB)) {
         res = 0;
     }
-    paranoid_free(command);
     return (res);
 }
-
 
 
@@ -2166 +2094 @@
 {
     int retval = 0;
-
-   /** malloc *****/
-    char *device;
-    char *command;
-    char *cfg_file;
-    char *mounted_cfgf_path;
-    char *tmp;
-    char *sav;
-    char *mountpt;
-    char *ramdisk_fname;
-    char *mountlist_file;
-    int res;
+    char *device = NULL;
+    char *command = NULL;
+    char *cfg_file = NULL;
+    char *mounted_cfgf_path = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+    char *sav = NULL;
+    char *mountpt = NULL;
+    char *ramdisk_fname = NULL;
+    char *mountlist_file = NULL;
+    int res = 0;
 
     bool try_plan_B;
 
     assert(bkpinfo != NULL);
-    malloc_string(cfg_file);
-    malloc_string(mounted_cfgf_path);
-    malloc_string(mountpt);
-    malloc_string(ramdisk_fname);
-    malloc_string(mountlist_file);
-    malloc_string(device);
-    malloc_string(command);
-    malloc_string(tmp);
     log_msg(2, "gcffa --- starting");
     log_to_screen(_("I'm thinking..."));
-    sprintf(mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
-    device[0] = '\0';
+    asprintf(&mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
     chdir(bkpinfo->tmpdir);
-    strcpy(cfg_file, MONDO_CFG_FILE_STUB);
-    unlink(cfg_file);           // cfg_file[] is missing the '/' at the start, FYI, by intent
+    // MONDO_CFG_FILE_STUB is missing the '/' at the start, FYI, by intent
+    unlink(MONDO_CFG_FILE_STUB);
+
     unlink(FILELIST_FULL_STUB);
     unlink(BIGGIELIST_TXT_STUB);
     unlink("tmp/i-want-my-lvm");
-    sprintf(command, "mkdir -p %s", mountpt);
+    asprintf(&command, "mkdir -p %s", mountpt);
     run_program_and_log_output(command, FALSE);
-
-//   unlink( "tmp/mondo-restore.cfg" ); // superfluous, surely?
-
-    sprintf(cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
-    sprintf(mountlist_file, "%s/%s", bkpinfo->tmpdir,
+    paranoid_free(command);
+
+    asprintf(&cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
+    asprintf(&mountlist_file, "%s/%s", bkpinfo->tmpdir,
             MOUNTLIST_FNAME_STUB);
-    //   make_hole_for_file( cfg_file );
-    //   make_hole_for_file( mountlist_file);
     log_msg(2, "mountpt = %s; cfg_file=%s", mountpt, cfg_file);
 
     /* Floppy? */
-    sprintf(tmp, "mkdir -p %s", mountpt);
+    asprintf(&tmp, "mkdir -p %s", mountpt);
     run_program_and_log_output(tmp, FALSE);
-    sprintf(tmp, "mkdir -p %s/tmp", bkpinfo->tmpdir);
+    paranoid_free(tmp);
+
+    asprintf(&tmp, "mkdir -p %s/tmp", bkpinfo->tmpdir);
     run_program_and_log_output(tmp, FALSE);
-
-    sprintf(command, "mount /dev/fd0u1722 %s", mountpt);
-    sprintf(tmp,
+    paranoid_free(tmp);
+
+    asprintf(&command, "mount /dev/fd0u1722 %s", mountpt);
+    asprintf(&tmp,
             "(sleep 15; kill `ps ax | grep \"%s\" | cut -d' ' -f1` 2> /dev/null) &",
             command);
     log_msg(1, "tmp = '%s'", tmp);
     system(tmp);
+    paranoid_free(tmp);
+
     res = run_program_and_log_output(command, FALSE);
+    paranoid_free(command);
+
     if (res) {
-        sprintf(command, "mount /dev/fd0H1440 %s", mountpt);
+        asprintf(&command, "mount /dev/fd0H1440 %s", mountpt);
         res = run_program_and_log_output(command, FALSE);
+        paranoid_free(command);
     }
     if (res) {
@@ -2237 +2161 @@
 // NB: If busybox does not support 'mount -o loop' then Plan A WILL NOT WORK.
         log_msg(2, "Processing floppy (plan A?)");
-        sprintf(ramdisk_fname, "%s/mindi.rdz", mountpt);
+        asprintf(&ramdisk_fname, "%s/mindi.rdz", mountpt);
         if (!does_file_exist(ramdisk_fname)) {
-            sprintf(ramdisk_fname, "%s/initrd.img", mountpt);
+            paranoid_free(ramdisk_fname);
+            asprintf(&ramdisk_fname, "%s/initrd.img", mountpt);
         }
         if (!does_file_exist(ramdisk_fname)) {
@@ -2250 +2175 @@
                     "Warning - failed to extract config file from ramdisk. I think this boot disk is mangled.");
         }
-        sprintf(command, "umount %s", mountpt);
+        asprintf(&command, "umount %s", mountpt);
         run_program_and_log_output(command, 5);
+        paranoid_free(command);
+
         unlink(ramdisk_fname);
+        paranoid_free(ramdisk_fname);
     }
     if (!does_file_exist(cfg_file)) {
@@ -2277 +2205 @@
             run_program_and_log_output("mkdir -p tmp", FALSE);
 
-            if (strlen(bkpinfo->media_device) == 0) {
-                paranoid_alloc(bkpinfo->media_device, "/dev/st0");
-                log_msg(2, "media_device is blank; assuming %s", bkpinfo->media_device);
-            }
-            asprintf(&sav,bkpinfo->media_device);
+            if (bkpinfo->media_device == NULL) {
+                asprintf(&bkpinfo->media_device, "/dev/st0");
+                log_msg(2, "media_device is blank; assuming %s",
+                        bkpinfo->media_device);
+            }
+            asprintf(&sav, bkpinfo->media_device);
             if (extract_cfg_file_and_mountlist_from_tape_dev
                 (bkpinfo->media_device)) {
@@ -2303 +2232 @@
 
             if (!does_file_exist("tmp/mondo-restore.cfg")) {
-                log_to_screen(_("Cannot find config info on tape/CD/floppy"));
+                log_to_screen(_
+                              ("Cannot find config info on tape/CD/floppy"));
                 return (1);
             }
@@ -2309 +2239 @@
             log_msg(2,
                     "gcffa --- looking at mounted CD for mindi-boot.2880.img");
-            sprintf(command,
+            /* BERLIOS : Useless ?
+            asprintf(&command,
                     "mount " MNT_CDROM
                     "/images/mindi-boot.2880.img -o loop %s", mountpt);
-            sprintf(mounted_cfgf_path, "%s/%s", mountpt, cfg_file);
+                    */
+            asprintf(&mounted_cfgf_path, "%s/%s", mountpt, cfg_file);
             if (!does_file_exist(mounted_cfgf_path)) {
                 log_msg(2,
                         "gcffa --- Plan C, a.k.a. untarring some file from all.tar.gz");
-                sprintf(command, "tar -zxvf " MNT_CDROM "/images/all.tar.gz %s %s %s %s %s", MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, "tmp/i-want-my-lvm");  // add -b TAPE_BLOCK_SIZE if you _really_ think it's necessary
+                asprintf(&command, "tar -zxvf " MNT_CDROM "/images/all.tar.gz %s %s %s %s %s", MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, "tmp/i-want-my-lvm");    // add -b TAPE_BLOCK_SIZE if you _really_ think it's necessary
                 run_program_and_log_output(command, TRUE);
+                paranoid_free(command);
+
                 if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
                     fatal_error
@@ -2323 +2257 @@
                 }
             }
-        }
-    }
+            paranoid_free(mounted_cfgf_path);
+        }
+    }
+    paranoid_free(mountpt);
+
     if (does_file_exist(MONDO_CFG_FILE_STUB)) {
         log_msg(1, "gcffa --- great! We've got the config file");
-        sprintf(tmp, "%s/%s",
-                call_program_and_get_last_line_of_output("pwd"),
-                MONDO_CFG_FILE_STUB);
-        sprintf(command, "cp -f %s %s", tmp, cfg_file);
+        tmp1 = call_program_and_get_last_line_of_output("pwd");
+        asprintf(&tmp, "%s/%s", tmp1,MONDO_CFG_FILE_STUB);
+        asprintf(&command, "cp -f %s %s", tmp, cfg_file);
         iamhere(command);
+
         if (strcmp(tmp, cfg_file)
             && run_program_and_log_output(command, 1)) {
@@ -2340 +2277 @@
             log_msg(1, "... and I moved it successfully to %s", cfg_file);
         }
-        sprintf(command, "cp -f %s/%s %s",
-                call_program_and_get_last_line_of_output("pwd"),
+        paranoid_free(command);
+
+        asprintf(&command, "cp -f %s/%s %s",tmp1,
                 MOUNTLIST_FNAME_STUB, mountlist_file);
+        paranoid_free(tmp1);
+
         iamhere(command);
         if (strcmp(tmp, cfg_file)
@@ -2349 +2289 @@
         } else {
             log_msg(1, "Got mountlist too");
-            sprintf(command, "cp -f %s %s", mountlist_file,
+            paranoid_free(command);
+            asprintf(&command, "cp -f %s %s", mountlist_file,
                     g_mountlist_fname);
             if (run_program_and_log_output(command, 1)) {
@@ -2355 +2296 @@
             } else {
                 log_msg(1, "Copied mountlist to /tmp as well OK");
-                sprintf(command, "cp -f tmp/i-want-my-lvm /tmp/");
+                paranoid_free(command);
+                asprintf(&command, "cp -f tmp/i-want-my-lvm /tmp/");
                 run_program_and_log_output(command, 1);
-/*        sprintf(command, "grep \" lvm \" %s", g_mountlist_fname);
-          if (!run_program_and_log_output(command, 5) && !does_file_exist("/tmp/i-want-my-lvm"))
-            {
-          log_msg(1, "Warning. You want LVM but I don't have i-want-my-lvm. FIXME.");
-        }
-              else if (run_program_and_log_output(command,5) && does_file_exist("/tmp/i-want-my-lvm"))
-                {
-          log_msg(1, "Warning. You don't want LVM but i-want-my-lvm exists. I'll delete it. Cool.");
-              do_my_funky_lvm_stuff(TRUE, FALSE); // ...after I stop any LVMs :)
-          stop_raid_device("/dev/md0");
-          stop_raid_device("/dev/md1");
-          stop_raid_device("/dev/md2");
-          unlink("/tmp/i-want-my-lvm");
-        }
-          else if (!run_program_and_log_output(command,5) && does_file_exist("/tmp/i-want-my-lvm"))
-            {
-          log_msg(1, "You had better pray that i-want-my-lvm patches your mountlist. FIXME.");
-        }
-*/
-            }
-        }
+            }
+        }
+        paranoid_free(command);
+        paranoid_free(tmp);
     }
     run_program_and_log_output("umount " MNT_CDROM, FALSE);
@@ -2384 +2309 @@
         log_msg(1, "%s not found", cfg_file);
         log_to_screen
-            (_("Oh dear. Unable to recover configuration file from boot disk"));
+            (_
+             ("Oh dear. Unable to recover configuration file from boot disk"));
         return (1);
     }
@@ -2394 +2320 @@
 /* start SAH */
     else {
-        sprintf(command, "cp -f %s %s/%s", MOUNTLIST_FNAME_STUB,
+        asprintf(&command, "cp -f %s %s/%s", MOUNTLIST_FNAME_STUB,
                 bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
         run_program_and_log_output(command, FALSE);
-    }
-/*--commented out by SAH
-  sprintf( command, "cp -f %s %s/%s", cfg_file, bkpinfo->tmpdir, MONDO_CFG_FILE_STUB );
-  run_program_and_log_output( command, FALSE );
-  sprintf( command, "cp -f %s %s/%s", mountlist_file, bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB );
-  run_program_and_log_output( command, FALSE );
-*/
+        paranoid_free(command);
+    }
 /* end SAH */
 
-    sprintf(command, "cp -f %s /%s", cfg_file, MONDO_CFG_FILE_STUB);
+    asprintf(&command, "cp -f %s /%s", cfg_file, MONDO_CFG_FILE_STUB);
+    paranoid_free(cfg_file);
+
     run_program_and_log_output(command, FALSE);
-    sprintf(command, "cp -f %s /%s", mountlist_file, MOUNTLIST_FNAME_STUB);
+    paranoid_free(command);
+
+    asprintf(&command, "cp -f %s /%s", mountlist_file, MOUNTLIST_FNAME_STUB);
+    paranoid_free(mountlist_file);
+
     run_program_and_log_output(command, FALSE);
-    sprintf(command, "cp -f etc/raidtab /etc/");
+    paranoid_free(command);
+
+    asprintf(&command, "cp -f etc/raidtab /etc/");
     run_program_and_log_output(command, FALSE);
-    sprintf(command, "cp -f tmp/i-want-my-lvm /tmp/");
+    paranoid_free(command);
+
+    asprintf(&command, "cp -f tmp/i-want-my-lvm /tmp/");
     run_program_and_log_output(command, FALSE);
+    paranoid_free(command);
+
     g_backup_media_type = bkpinfo->backup_media_type;
-    paranoid_free(device);
-    paranoid_free(command);
-    paranoid_free(tmp);
-    paranoid_free(cfg_file);
-    paranoid_free(mounted_cfgf_path);
-    paranoid_free(mountpt);
-    paranoid_free(ramdisk_fname);
-    paranoid_free(mountlist_file);
     return (retval);
 }
-
 /**************************************************************************
  *END_GET_CFG_FILE_FROM_ARCHIVE                                           *
  **************************************************************************/
-
 /* @} - end restoreUtilityGroup */
-
-
-/***************************************************************************
- * F@                                                                      *
- * () -- Hugo Rabson                                  *
- *                                                                         *
- * Purpose:                                                                *
- *                                                                         *
- * Called by:                                                              *
- * Params:    -                      -                                     *
- * Returns:   0=success; nonzero=failure                                   *
- ***************************************************************************/
-
 
 
@@ -2449 +2359 @@
                                            int wait_for_percentage)
 {
-    struct raidlist_itself *raidlist;
-    int unfinished_mdstat_devices = 9999, i;
-    char *screen_message;
-
-    malloc_string(screen_message);
+    struct raidlist_itself *raidlist = NULL;
+    int unfinished_mdstat_devices = 9999, i = 0;
+    char *screen_message = NULL;
+
     raidlist = malloc(sizeof(struct raidlist_itself));
 
@@ -2461 +2370 @@
         if (parse_mdstat(raidlist, "/dev/")) {
             log_to_screen("Sorry, cannot read %s", MDSTAT_FILE);
-            log_msg(1,"Sorry, cannot read %s", MDSTAT_FILE);
+            log_msg(1, "Sorry, cannot read %s", MDSTAT_FILE);
             return;
         }
-        for (unfinished_mdstat_devices = i = 0; i <= raidlist->entries; i++) {
+        for (unfinished_mdstat_devices = i = 0; i <= raidlist->entries;
+             i++) {
             if (raidlist->el[i].progress < wait_for_percentage) {
                 unfinished_mdstat_devices++;
-                log_msg(1,"Sync'ing %s (i=%d)", raidlist->el[i].raid_device, i);
-                sprintf(screen_message, "Sync'ing %s",
+                log_msg(1, "Sync'ing %s (i=%d)",
+                        raidlist->el[i].raid_device, i);
+                asprintf(&screen_message, "Sync'ing %s",
                         raidlist->el[i].raid_device);
                 open_evalcall_form(screen_message);
+                paranoid_free(screen_message);
+
                 if (raidlist->el[i].progress == -1) // delayed while another partition inits
                 {
@@ -2476 +2389 @@
                 }
                 while (raidlist->el[i].progress < wait_for_percentage) {
-                    log_msg(1,"Percentage sync'ed: %d", raidlist->el[i].progress);
+                    log_msg(1, "Percentage sync'ed: %d",
+                            raidlist->el[i].progress);
                     update_evalcall_form(raidlist->el[i].progress);
                     sleep(2);
@@ -2488 +2402 @@
         }
     }
-    paranoid_free(screen_message);
     paranoid_free(raidlist);
 }

trunk/mondo/mondo/mondorestore/mondo-rstr-tools.h

@@ -1 @@
-/* mondo-rstr-tools.h
+/*
  * $Id: mondo-rstr-tools.h
- */
+**/
 
 void free_global_filenames();
@@ -8 +8 @@
 int iso_fiddly_bits(struct s_bkpinfo *bkpinfo, bool nuke_me_please);
 void kill_petris(void);
-int modify_rclocal_one_time(char *path);
 int mount_cdrom(struct s_bkpinfo *bkpinfo);
 int mount_device(char *, char *, char *, bool);
@@ -26 +25 @@
 void set_signals(int on);
 void setup_global_filenames(struct s_bkpinfo *bkpinfo);
-//void setup_signals(int);
 void twenty_seconds_til_yikes(void);
 int run_raw_mbr(bool offer_to_hack_scripts, char *bd);

trunk/mondo/mondo/mondorestore/mondoprep.h

@@ -1 @@
-/***************************************************************************
-                          mondoprep.h  -  description
-                             -------------------
-    begin                : Sat Apr 20 2002
-    copyright            : (C) 2002 by Stan Benoit
-    email                : troff@nakedsoul.org
-    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.                                   *
- *                                                                         *
- ***************************************************************************/
+/*
+ * $Id$
+**/
 
 
@@ -28 +14 @@
 extern bool ask_me_yes_or_no(char *);
 extern long get_phys_size_of_drive(char *);
-//extern void log_to_screen (char *);
 extern void update_progress_form(char *);
 extern void open_progress_form(char *, char *, char *, char *, long);
 extern void close_progress_form(void);
 extern void popup_and_OK(char *);
-extern bool popup_and_get_string(char *, char *, char *, int);
+extern bool popup_and_get_string(char *, char *, char *);
 extern long get_time(void);
 extern bool is_this_device_mounted(char *);
@@ -41 +26 @@
 extern off_t length_of_file(char *);
 extern long noof_lines_that_match_wildcard(char *, char *);
-//extern char *slice_fname (long, long, bool, char *);
 extern char *last_line_of_file(char *);
 extern void log_file_end_to_screen(char *, char *);
@@ -58 +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/mondo/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);
@@ -59 +60 @@
 extern int partition_everything(struct mountlist_itself *);
 extern void popup_and_OK(char *);
-extern bool popup_and_get_string(char *, char *, char *, int);
+extern bool popup_and_get_string(char *, char *, char *);
 extern void setup_newt_stuff(void);
 extern void reset_bkpinfo(struct s_bkpinfo *);