Changeset 688 in MondoRescue for trunk/mondo/mondo/mondorestore/mondo-prep.c

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 !)

File:

• trunk/mondo/mondo/mondorestore/mondo-prep.c (modified) (116 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);
 }