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

Timestamp:

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

Author:

Bruno Cornec

Message:

Commit ald modifs in trunk - just in case

File:

• trunk/mondo/src/mondorestore/mondo-prep.c (modified) (88 diffs)

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

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