Changeset 1196 in MondoRescue for branches/stable

Timestamp:

Feb 21, 2007, 2:40:49 AM (18 years ago)

Author:

Bruno Cornec

Message:

ChangeLog for mindi UTF-8
mr_strcat much more powerful as taking a vararg (+ tests).
improved text output to log file for mondo
merge from trunk memory management for mondorestore (begining)

Location:

branches/stable

Files:

• mondo/src/common/newt-specific.c (modified) (1 diff)
• mondo/src/include/mr_mem.h (modified) (2 diffs)
• mondo/src/lib/mr_mem.c (modified) (1 diff)
• mondo/src/mondorestore/mondo-prep.c (modified) (70 diffs)
• mondo/src/mondorestore/mondo-rstr-tools.c (modified) (1 diff)
• mondo/src/test/test-mem.c (modified) (1 diff)
• mondo/src/test/test-mem.res (modified) (1 diff)
• tools/quality (modified) (1 diff)

branches/stable/mondo/src/common/newt-specific.c

@@ -1081 +1081 @@
 
     if (g_text_mode) {
+        /* Not very useful
         printf(_("---progress-form---1--- %s\n"), blurb1);
+        */
         printf(_("---progress-form---2--- %s\n"), blurb2);
+        /* Not very useful
         printf(_("---progress-form---3--- %s\n"), blurb3);
-        printf(_("---progress-form---E---\n"));
+        */
         mr_asprintf(&taskprogress, "TASK:  [");
         for (i = 0; i < percentage; i += 5) {

branches/stable/mondo/src/include/mr_mem.h

@@ -23 +23 @@
 #define mr_malloc(x) mr_malloc_int((size_t)x,__LINE__,__FILE__)
 #define mr_setenv(x,y) mr_setenv_int(x,y,__LINE__,__FILE__)
-#define mr_strcat(x,y) mr_strcat_int((char **)&x,y, __LINE__,__FILE__);
+#define mr_strcat(x,y,args...) mr_strcat_int((char **)&x, __LINE__,__FILE__, y,## args);
 
 /* Internal function bringing debuging info 
@@ -33 +33 @@
 extern inline void *mr_malloc_int(size_t size, int line, char *file);
 extern inline void mr_setenv_int(const char *name, const char *value, int line, char *file);
-extern void mr_strcat_int(char **in, const char *add, int line, char *file);
+extern void mr_strcat_int(char **in, int line, char *file, const char *fmt, ...);
 
 #endif                          /* MR_MEM_H */

branches/stable/mondo/src/lib/mr_mem.c

@@ -114 +114 @@
  * Equivalent function of strcat but safe 
  * from memory allocation point of view
+ * and richer from an interface point of view
  */
-void mr_strcat_int(char **in, const char *add, int line, char *file) {
-    char *p =NULL;
+void mr_strcat_int(char **in, int line, const char *file, const char *fmt, ...) {
+    char *p = NULL;
+    char *fmt2 = NULL;
+    va_list args;
+    int res = 0;
     
-    if (add == NULL) {
+    if (fmt == NULL) {
         return;
     }
     if (in == NULL) {
-        mr_msg_int(1,line,file,"Unable to add %s to NULL pointer\nExiting...", add);
+        mr_msg_int(1,line,file,"Unable to add to NULL pointer\nExiting...");
         mr_exit(-1, "Unable to add to a NULL pointer");
     }
+    va_start(args,fmt);
     if (*in == NULL) {
-        mr_asprintf_int(&p,line,file,add);
+        res = vasprintf(in, fmt, args);
+        if (res == -1) {
+            mr_msg_int(1,line,file,"Unable to alloc memory in mr_strcat\nExiting...");
+            mr_exit(-1,"Unable to alloc memory in mr_strcat");
+        }
     } else {
-        mr_asprintf_int(&p,line,file,"%s%s",*in,add);
+        mr_asprintf_int(&fmt2, line, file, "%s%s", *in, fmt);
+        res = vasprintf(&p, fmt2, args);
+        mr_free_int((void **)&fmt2,line,file);
         mr_free_int((void **)in,line,file);
+        *in = p;
     }
-    *in = p;
+    va_end(args);
 }
+
+

branches/stable/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"
+
 #include <sys/ioctl.h>
 #include <linux/hdreg.h>
 #include <math.h>
+#include <unistd.h>
 #include "mr_mem.h"
 #include "mr_msg.h"
@@ -42 +44 @@
 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;
-
-
-
-
-
-
-
-
 
 
 void wipe_MBRs_and_reboot_if_necessary(struct mountlist_itself *mountlist)
 {
-    char *command;
-    char *tmp;
-    int lino;
-    int i;
-    FILE *fout;
-    char *buf;
-    const int blocksize = 512;
+    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.
-    malloc_string(command);
-    malloc_string(tmp);
-    buf = mr_malloc(blocksize);
+
+    // 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 :)
     {
@@ -83 +67 @@
         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);
-            if (!run_program_and_log_output(command, 1)) {
+            mr_asprintf(&command,
+                     "dd if=%s bs=512 count=1 2> /dev/null | grep \"%s\"",
+                     drivelist->el[lino].device, MONDO_WAS_HERE);
+            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);
@@ -94 +80 @@
 
         if (lino == drivelist->entries) {
-// zero & reboot
+            // 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++) {
-                for (i = 0; i < blocksize; i++) {
-                    buf[i] = 0;
-                }
-                sprintf(buf, "%s\n", MONDO_WAS_HERE);
+                mr_asprintf(&buf, "%s\n", MONDO_WAS_HERE);
                 fout = fopen(drivelist->el[lino].device, "w+");
                 if (!fout) {
@@ -112 +96 @@
                             drivelist->el[lino].device);
                 } else {
-                    if (1 != fwrite(buf, blocksize, 1, fout)) {
+                    if (1 != fwrite(buf, strlen(buf)+1, 1, fout)) {
                         mr_msg(1, "Failed to wipe %s",
                                 drivelist->el[lino].device);
@@ -121 +105 @@
                     fclose(fout);
                 }
-            }
-            system("sync");
-            system("sync");
-            system("sync");
+                mr_free(buf);
+            }
+            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!
-    mr_free(command);
-    mr_free(tmp);
     mr_msg(1, "Cool. I didn't have to wipe anything.");
 }
 
 
-
-
-
-
 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)) {
@@ -168 +148 @@
     return (i);
 }
-
-
-
-
-
-
-
-
 
 
@@ -187 +159 @@
  * @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;
+    long extents = 0L;
     fpos_t orig_pos;
+    size_t n = 0;
+    size_t n1 = 0;
 
     /** pointers **********************************************/
-    FILE *fin;
+    FILE *fin = NULL;
 
     /** end *****************************************************/
@@ -231 +199 @@
     }
 
-    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 = mr_malloc(512);
-
-//  do_this_last[0] = '\0';
     iamhere("STARTING");
     mr_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");
+        mr_asprintf(&lvscan_sz, "lvm lvscan");
+        mr_asprintf(&lvremove_sz, "lvm lvremove");
+        mr_asprintf(&vgscan_sz, "lvm vgscan");
+        mr_asprintf(&pvscan_sz, "lvm pvscan");
+        mr_asprintf(&vgchange_sz, "lvm vgchange");
+        mr_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,
+        mr_asprintf(&lvscan_sz, "lvscan");
+        mr_asprintf(&lvremove_sz, "lvremove");
+        mr_asprintf(&vgscan_sz, "vgscan");
+        mr_asprintf(&pvscan_sz, "pvscan");
+        mr_asprintf(&vgchange_sz, "vgchange");
+        mr_asprintf(&vgremove_sz, "vgremove");
+    }
+    mr_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);
+    mr_free(lvscan_sz);
+    mr_free(lvremove_sz);
+
     run_program_and_log_output(command, 5);
+    mr_free(command);
+
     sleep(1);
-    sprintf(command,
+    mr_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", vgscan_sz, vgchange_sz, vgremove_sz);
+    mr_free(vgchange_sz);
+    mr_free(vgremove_sz);
+
     run_program_and_log_output(command, 5);
+    mr_free(command);
+
     if (just_erase_existing_volumes) {
         paranoid_fclose(fin);
         mr_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");
+        mr_msg(1, "Not many errors. Returning 0.");
+        return (0);
     }
 
     mr_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 (mr_getline(&incoming, &n1, fin); !feof(fin); mr_getline(&incoming, &n1, fin)) {
         fgetpos(fin, &orig_pos);
+        /* we want to execute lines begining with a # */
         if (incoming[0] != '#') {
             continue;
         }
-        if (res && strstr(command, "create") && vacuum_pack) {
-            sleep(2);
-            system("sync");
-            system("sync");
-            system("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)) {
+            // include next line(s) if they end in /dev (cos we've got a broken i-want-my-lvm)
+            for (mr_getline(&tmp, &n, fin); !feof(fin); mr_getline(&tmp, &n, fin)) {
                 if (tmp[0] == '#') {
                     fsetpos(fin, &orig_pos);
@@ -301 +264 @@
                 } else {
                     fgetpos(fin, &orig_pos);
-                    strcat(incoming, tmp);
+                    mr_strcat(incoming, tmp);
                 }
             }
+            mr_free(tmp);
+
             for (q = incoming; *q != '\0'; q++) {
                 if (*q < 32) {
@@ -309 +274 @@
                 }
             }
-            strcpy(tmp, p + strlen("vgcreate") + 1);
-            for (q = tmp; *q > 32; q++);
+            mr_asprintf(&tmp1, p + strlen("vgcreate") + 1);
+            for (q = tmp1; *q > 32; q++);
             *q = '\0';
-            mr_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);
+            mr_msg(1, "Deleting old entries at /dev/%s", tmp1);
+            mr_asprintf(&command, "rm -Rf /dev/%s", tmp1);
+            mr_free(tmp1);
+
             run_program_and_log_output(command, 1);
+            mr_free(command);
+
             run_program_and_log_output(vgscan_sz, 1);
             run_program_and_log_output(pvscan_sz, 1);
@@ -324 +291 @@
         }
         for (p = incoming + 1; *p == ' '; p++);
-        strcpy(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';
+
+        /* BERLIOS: we should rather define LVMv1 or v2 and use it */
         res = run_program_and_log_output(command, 5);
         if (res > 0 && (p = strstr(command, "lvm "))) {
@@ -341 +310 @@
             if (strstr(command, "lvm lvcreate"))
                 lvmversion = 2;
-            log_it("%s... so I'll get creative.", tmp);
             if (lvmversion == 2) {
-                strcpy(tmp, call_program_and_get_last_line_of_output
-                       ("tail -n5 /var/log/mondo-archive.log | grep Insufficient | tail -n1"));
+                mr_asprintf(&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 /var/log/mondo-archive.log | grep lvcreate | tail -n1"));
+                mr_asprintf(&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);
             mr_msg(5, "p='%s' --> extents=%ld", p, extents);
+            mr_free(tmp);
+
             p = strstr(command, "-L");
             if (!p) {
@@ -363 +333 @@
                         *q = ' ';
                     }
+                    /* BERLIOS: Dangerous: no size control !! */
                     sprintf(p, "%ld", extents);
                     i = strlen(p);
@@ -373 +344 @@
                         *(q - 1) = ' ';
                     }
+                    /* BERLIOS: Dangerous: no size control !! */
                     sprintf(p, "%ld%c", extents, 'm');
                     i = strlen(p);
@@ -387 +359 @@
                 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.");
                 }
             }
@@ -399 +371 @@
             retval++;
         }
-        sprintf(tmp, "echo \"%s\" >> /tmp/out.sh", command);
+        mr_asprintf(&tmp, "echo \"%s\" >> /tmp/out.sh", command);
         system(tmp);
+        mr_free(tmp);
         sleep(1);
     }
     paranoid_fclose(fin);
-    mr_msg(1, "Closed i-want-my-lvm. Finished doing funky stuff.");
-  end_of_i_want_my_lvm:
-    mr_free(tmp);
-    mr_free(incoming);
-    mr_free(command);
-    mr_free(lvscan_sz);
-    mr_free(lvremove_sz);
     mr_free(vgscan_sz);
     mr_free(pvscan_sz);
-    mr_free(vgcreate_sz);
-    mr_free(vgchange_sz);
-    mr_free(vgremove_sz);
-//  mr_free(do_this_last);
-    system("sync");
-    system("sync");
-    system("sync");
+    mr_free(command);
+    mr_free(incoming);
+
+    mr_msg(1, "Closed i-want-my-lvm. Finished doing funky stuff.");
+    sync();
+    sync();
+    sync();
     sleep(1);
     iamhere("ENDING");
@@ -445 +411 @@
                                                      *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 *p = NULL;
+    size_t n = 0;
 
     /** init *************************************************************/
@@ -464 +423 @@
     /** end **************************************************************/
 
-    malloc_string(incoming);
-    malloc_string(tmp);
     assert(new_mountlist != NULL);
     assert(old_mountlist != NULL);
@@ -471 +428 @@
 #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
@@ -480 +438 @@
             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);
             }
@@ -487 +446 @@
                 finish(1);
             }
-            for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin)
+            for (mr_getline(&incoming, &n, fin); !feof(fin)
                  && !strstr(incoming, old_mountlist->el[lino].device);
-                 fgets(incoming, MAX_STR_LEN - 1, fin));
+                 mr_getline(&incoming, &n, fin));
             if (!feof(fin)) {
-                sprintf(tmp, "Investigating %s",
+                log_it("Investigating %s",
                         old_mountlist->el[lino].device);
-                log_it(tmp);
-                for (fgets(incoming, MAX_STR_LEN - 1, fin); !feof(fin)
+                for (mr_getline(&incoming, &n, fin); !feof(fin)
                      && !strstr(incoming, "raiddev");
-                     fgets(incoming, MAX_STR_LEN - 1, fin)) {
+                     mr_getline(&incoming, &n, fin)) {
                     if (strstr(incoming, OSSWAP("device", "drive"))
                         && !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--);
-                        sprintf(tmp, "Extrapolating %s", p);
-                        log_it(tmp);
+                        for (p--; (p >= incoming) && (*(p - 1) > 32); p--);
+                        log_it("Extrapolating %s", p);
                         for (j = 0;
                              j < new_mountlist->entries
@@ -522 +479 @@
                             new_mountlist->entries++;
                         } else {
-                            sprintf(tmp,
-                                    "Not adding %s to mountlist: it's already there",
-                                    p);
-                            log_it(tmp);
+                            log_it("Not adding %s to mountlist: it's already there", p);
                         }
                     }
                 }
             }
+            mr_free(incoming);
+
             paranoid_fclose(fin);
         } else {
@@ -543 +499 @@
         }
     }
-    mr_free(incoming);
-    mr_free(tmp);
-
     return (0);
 }
@@ -561 +514 @@
 {
   /** int **************************************************************/
-  int i   = 0;
-  int j   = 0;
-  int res = 0;
-  
+    int i = 0;
+    int j = 0;
+    int res = 0;
+
   /** buffers ***********************************************************/
   char *devices = NULL;
@@ -590 +543 @@
   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
@@ -620 +565 @@
        raidlist->el[i].raid_device, level,
        raidlist->el[i].data_disks.entries);
+  mr_free(level);
   if (raidlist->el[i].parity != -1) {
-    mr_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:
@@ -640 +584 @@
       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);
 }
 
@@ -682 +614 @@
 {
     /** int **************************************************************/
-    int res;
+    int res = 0;
     int retval = 0;
 #ifdef __FreeBSD__
@@ -689 +621 @@
 
     /** buffers ***********************************************************/
-    char *program;
-    char *tmp;
+    char *program = NULL;
+    char *program2 = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
+#ifdef __FreeBSD__
+    char *line = NULL;
+    char *status = NULL;
+    FILE *pin = NULL;
+    FILE *fin = NULL;
+    size_t n = 0;
+    size_t n1 = 0;
+#endif
 
     /** 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);
-        log_it(tmp);
-        mr_free(program);
-        mr_free(tmp);
+        log_it("Not formatting %s (it is a RAID disk)", device);
         return (0);
     }
@@ -709 +646 @@
     if (strcmp(format, "swap") == 0) {
         log_it("Not formatting %s - it's swap", device);
-        mr_free(program);
-        mr_free(tmp);
         return (0);
     }
 #endif
     if (strlen(format) <= 2) {
-        sprintf(tmp,
+        mr_asprintf(&tmp,
                 "%s has a really small format type ('%s') - this is probably a hexadecimal string, which would suggest the partition is an image --- I shouldn't format it",
                 device, format);
-        log_it(tmp);
-        mr_free(program);
-        mr_free(tmp);
         return (0);
     }
     if (is_this_device_mounted(device)) {
-        sprintf(tmp, "%s is mounted - cannot format it       ", device);
-        log_to_screen(tmp);
-        mr_free(program);
-        mr_free(tmp);
+        log_to_screen(_("%s is mounted - cannot format it       "), device);
         return (1);
     }
@@ -736 +665 @@
             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;
@@ -744 +674 @@
                 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);
                 }
@@ -752 +683 @@
 
         if (vinum_started_yet) {
-            FILE *fin;
-            char line[MAX_STR_LEN];
-            sprintf(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);
+
             /* format raid partition */
-            //      sprintf (program, "mkraid --really-force %s", device); --- disabled -- BB, 02/12/2003
-            sprintf(program,
+            mr_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);
             }
+            mr_free(program);
+
             fin = fopen("/tmp/plexes", "r");
-            while (fgets(line, MAX_STR_LEN - 1, fin)) {
+            while (mr_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);
+                mr_asprintf(&tmp, "Initializing plex: %s", line);
                 open_evalcall_form(tmp);
-                sprintf(tmp, "vinum init %s", line);
+                mr_free(tmp);
+
+                mr_asprintf(&tmp, "vinum init %s", line);
                 system(tmp);
+                mr_free(tmp);
+
                 while (1) {
-                    sprintf(tmp,
+                    mr_asprintf(&tmp,
                             "vinum lp -r %s | grep '^S' | head -1 | tr -s ' ' | cut -d: -f2 | cut -f1 | sed 's/^ //' | sed 's/I //' | sed 's/%%//'",
                             line);
-                    FILE *pin = popen(tmp, "r");
-                    char status[MAX_STR_LEN / 4];
-                    fgets(status, MAX_STR_LEN / 4 - 1, pin);
+                    pin = popen(tmp, "r");
+                    mr_free(tmp);
+
+                    mr_getline(&status, &n1, pin);
                     pclose(pin);
 
@@ -790 +725 @@
                     update_evalcall_form(atoi(status));
                     usleep(250000);
+                    mr_free(status);
                 }
                 close_evalcall_form();
             }
+            mr_free(line);
+
             fclose(fin);
             unlink("/tmp/plexes");
@@ -798 +736 @@
         }
 #else
-        sprintf(tmp, "Initializing RAID device %s", device);
-        log_to_screen(tmp);
-
-// Shouldn't be necessary.
-        log_to_screen("Stopping %s", device);
+        log_to_screen(_("Initializing RAID device %s"), device);
+
+        // Shouldn't be necessary.
+        log_to_screen(_("Stopping %s"), device);
         stop_raid_device(device);
-        system("sync");
+        sync();
         sleep(1);
-        if (g_fprep) {
-            fprintf(g_fprep, "%s\n", program);
-        }
 
         mr_msg(1, "Making %s", device);
@@ -816 +750 @@
             mr_msg(1, "Creating RAID device %s via mdadm returned %d", device, res);
         } else {
-            sprintf(program, "mkraid --really-force %s", device);
+            mr_asprintf(&program, "mkraid --really-force %s", device);
             res = run_program_and_log_output(program, 1);
             mr_msg(1, "%s returned %d", program, res);
-            system("sync");
+            sync();
             sleep(3);
             start_raid_device(device);
@@ -825 +759 @@
                 fprintf(g_fprep, "%s\n", program);
             }
-        }
-        system("sync");
+            mr_free(program);
+        }
+        sync();
         sleep(2);
-//      log_to_screen("Starting %s", device);
-//      sprintf(program, "raidstart %s", device);
-//      res = run_program_and_log_output(program, 1);
-//      mr_msg(1, "%s returned %d", program, res);
-//      system("sync"); sleep(1);
-#endif
-        system("sync");
+#endif
+        sync();
         sleep(1);
         newtResume();
     }
-//#ifndef __FreeBSD__
-//#endif
 
     if (!strcmp(format, "lvm")) {
         mr_msg(1, "Don't format %s - it's part of an lvm volume", device);
-        mr_free(program);
-        mr_free(tmp);
         return (0);
     }
-    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);
+    malloc_string(program2);
+    res = which_format_command_do_i_need(format, program2);
+    mr_asprintf(&tmp, "%s %s", program2, device);
+    if (strstr(program2, "kludge")) {
+        mr_strcat(tmp, " /");
+    }
+    mr_free(program2);
+
+    mr_asprintf(&program, "sh -c 'echo -en \"y\\ny\\ny\\n\" | %s'", tmp);
+    mr_free(tmp);
+
+    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")) {
-        sprintf(tmp, "Kludge failed; using regular mkfs.%s to format %s",
-                format, device);
+        mr_free(tmp);
+        mr_asprintf(&tmp, _("Kludge failed; using regular mkfs.%s to format %s"), format, device);
+        mr_free(program);
 #ifdef __FreeBSD__
-        sprintf(program, "newfs_msdos -F 32 %s", device);
+        mr_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);
+        mr_asprintf(&program, "mkfs -t %s -F 16 %s", format, device);
 #else
-        sprintf(program, "mkfs -t %s -F 32 %s", format, device);
+        mr_asprintf(&program, "mkfs -t %s -F 32 %s", format, device);
 #endif
 #endif
@@ -875 +808 @@
         }
     }
+    mr_free(program);
+
     retval += res;
     if (retval) {
-        strcat(tmp, "...failed");
+        mr_strcat(tmp, _("...failed"));
     } else {
-        strcat(tmp, "...OK");
-    }
-
+        mr_strcat(tmp, _("...OK"));
+    }
     log_to_screen(tmp);
-    mr_free(program);
     mr_free(tmp);
-    system("sync");
+
+    sync();
     sleep(1);
     return (retval);
 }
-
-
-
 
 
@@ -900 +831 @@
  * @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 **************************************************************/
     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);
-    malloc_string(tmp);
-    sprintf(tmp, "format_everything (mountlist, interactively = %s",
+    log_it("format_everything (mountlist, interactively = %s",
             (interactively) ? "true" : "false");
-    log_it(tmp);
-    mvaddstr_and_log_it(g_currentY, 0, "Formatting partitions     ");
-    open_progress_form("Formatting partitions",
-                       "I am now formatting your hard disk partitions.",
-                       "This may take up to five minutes.", "",
+    mvaddstr_and_log_it(g_currentY, 0, _("Formatting partitions     "));
+    open_progress_form(_("Formatting partitions"),
+                       _("I am now formatting your hard disk partitions."),
+                       _("This may take up to five minutes."), "",
                        mountlist->entries + 1);
 
@@ -937 +864 @@
         (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);
-    system("sync");
-    system("sync");
-    system("sync");
+    sync();
+    sync();
+    sync();
     sleep(2);
     mr_msg(1, "Prepare soft-RAIDs");    // prep and format too
@@ -952 +879 @@
             if (interactively) {
                 // ask user if we should format the current device
-                sprintf(tmp, "Shall I format %s (%s) ?", me->device,
+                mr_asprintf(&tmp, "Shall I format %s (%s) ?", me->device,
                         me->mountpoint);
                 do_it = ask_me_yes_or_no(tmp);
+                mr_free(tmp);
             } else {
                 do_it = TRUE;
@@ -965 +893 @@
         }
     }
-    system("sync");
-    system("sync");
-    system("sync");
+    sync();
+    sync();
+    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")) {
         wait_until_software_raids_are_prepped("/proc/mdstat", 100);
-        log_to_screen("Configuring LVM");
+        log_to_screen(_("Configuring LVM"));
         if (!g_text_mode) {
             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) {
-            mr_msg(1, "Vacuum-packing...");
-*/
         res = do_my_funky_lvm_stuff(FALSE, TRUE);
-/*
-        }
-*/
         if (!g_text_mode) {
             newtResume();
@@ -1006 +919 @@
             log_to_screen("Failed to initialize LVM");
         }
-        // retval += res;
         if (res) {
             retval++;
@@ -1012 +924 @@
         sleep(3);
     }
-// do regulars at last
+    // do regulars at last
     sleep(2);                   // woo!
     mr_msg(1, "Formatting regulars");
@@ -1018 +930 @@
         me = &mountlist->el[lino];  // the current mountlist entry
         if (!strcmp(me->mountpoint, "image")) {
-            sprintf(tmp, "Not formatting %s - it's an image", me->device);
-            log_it(tmp);
+            log_it("Not formatting %s - it's an image", me->device);
         } else if (!strcmp(me->format, "raid")) {
-            sprintf(tmp, "Not formatting %s - it's a raid-let",
-                    me->device);
-            log_it(tmp);
+            log_it("Not formatting %s - it's a raid-let", me->device);
             continue;
         } else if (!strcmp(me->format, "lvm")) {
-            sprintf(tmp, "Not formatting %s - it's an LVM", me->device);
-            log_it(tmp);
+            log_it("Not formatting %s - it's an LVM", me->device);
             continue;
         } else if (!strncmp(me->device, "/dev/md", 7)) {
-            sprintf(tmp, "Already formatted %s - it's a soft-RAID dev",
-                    me->device);
-            log_it(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)) {
-            sprintf(tmp,
-                    "Not formatting %s yet - doesn't exist - probably an LVM",
-                    me->device);
-            log_it(tmp);
+            log_it("Not formatting %s yet - doesn't exist - probably an LVM", me->device);
             continue;
         } else {
             if (interactively) {
                 // ask user if we should format the current device
-                sprintf(tmp, "Shall I format %s (%s) ?", me->device,
+                mr_asprintf(&tmp, "Shall I format %s (%s) ?", me->device,
                         me->mountpoint);
                 do_it = ask_me_yes_or_no(tmp);
+                mr_free(tmp);
             } else {
                 do_it = TRUE;
@@ -1069 +973 @@
 
     if (retval) {
-        mvaddstr_and_log_it(g_currentY++, 74, "Failed.");
+        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",
+        mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
+    }
+
+    log_it("format_everything () - %s",
             (retval) ? "failed!" : "finished successfully");
-    log_it(tmp);
 
     if (g_partition_table_locked_up > 0) {
@@ -1084 +988 @@
 //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');
@@ -1110 +1017 @@
     system("clear");
     newtResume();
-    mr_free(tmp);
     return (retval);
 }
@@ -1127 +1033 @@
 {
     /** 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 **************************************************************/
 
-    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);
-        log_it(tmp);
+        log_it("Making dummy primary %s%d", drivename, 1);
         g_maximum_progress++;
         res =
@@ -1155 +1056 @@
     }
     for (; current_devno < devno_we_must_allow_for; current_devno++) {
-        sprintf(tmp, "Creating dummy partition %s%d", drivename,
-                current_devno);
-        log_it(tmp);
+        log_it("Creating dummy partition %s%d", drivename, current_devno);
         g_maximum_progress++;
         res =
@@ -1165 +1064 @@
         previous_devno = current_devno;
     }
-    mr_free(tmp);
     return (previous_devno);
 }
@@ -1196 +1094 @@
     }
 }
+
 
 /* The following 2 functions are stolen from /usr/src/sbin/disklabel/disklabel.c */
@@ -1297 +1196 @@
 {
     static struct disklabel loclab;
-    struct partition *dp;
-    char lnamebuf[BBSIZE];
+    struct partition *dp = NULL;
+    char *lnamebuf = NULL;
     int f;
     u_int secsize, u;
     off_t mediasize;
 
-    (void) snprintf(lnamebuf, BBSIZE, "%s", dkname);
+    mr_asprintf(&lnamebuf, "%s", dkname);
     if ((f = open(lnamebuf, O_RDONLY)) == -1) {
         warn("cannot open %s", lnamebuf);
+        mr_free(lnamebuf);
         return (NULL);
     }
+    mr_free(lnamebuf);
 
     /* New world order */
@@ -1378 +1279 @@
                          char *drivename, struct disklabel *ret)
 {
-    char subdev_str[MAX_STR_LEN];
-    char command[MAX_STR_LEN];
-    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);
     for (c = 'a'; c <= 'z'; ++c) {
         int idx;
-        sprintf(subdev_str, "%s%c", drivename, c);
+        mr_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;
@@ -1414 +1315 @@
                 lp->d_partitions[c - 'a'].p_fstype = FS_OTHER;
         }
+        mr_free(subdev_str);
     }
 
@@ -1444 +1346 @@
     display_disklabel(ftmp, lp);
     fclose(ftmp);
-    sprintf(command, "disklabel -wr %s auto", canonical_name(drivename));
+    mr_asprintf(&command, "disklabel -wr %s auto", canonical_name(drivename));
     retval += run_program_and_log_output(command, TRUE);
-    sprintf(command, "disklabel -R %s /tmp/disklabel",
+    mr_free(command);
+
+    mr_asprintf(&command, "disklabel -R %s /tmp/disklabel",
             canonical_name(drivename));
     retval += run_program_and_log_output(command, TRUE);
+    mr_free(command);
     if (ret)
         *ret = *lp;
@@ -1465 +1370 @@
 {
     /** 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
 
@@ -1481 +1386 @@
 
     /** buffers *********************************************************/
-    char *device_str;
-    char *format;
-    char *tmp;
+    char *device_str = NULL;
+    char *format = NULL;
+    char *tmp = NULL;
+    char *tmp1 = NULL;
 
     /** end *************************************************************/
@@ -1490 +1396 @@
     assert_string_is_neither_NULL_nor_zerolength(drivename);
 
-    malloc_string(device_str);
-    malloc_string(format);
-    malloc_string(tmp);
-
-    sprintf(tmp, "Partitioning drive %s", drivename);
-    log_it(tmp);
+    log_it("Partitioning drive %s", drivename);
 
 #if __FreeBSD__
@@ -1502 +1403 @@
 #else
     make_hole_for_file(FDISK_LOG);
-    sprintf(tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG, FDISK_LOG);
+    mr_asprintf(&tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG,
+            FDISK_LOG);
     pout_to_fdisk = popen(tmp, "w");
+    mr_free(tmp);
+
     if (!pout_to_fdisk) {
-        log_to_screen("Cannot call parted2fdisk to configure %s", drivename);
-        mr_free(device_str);
-        mr_free(format);
-        mr_free(tmp);
+        log_to_screen(_("Cannot call parted2fdisk to configure %s"),
+                      drivename);
         return (1);
     }
 #endif
+
+    malloc_string(device_str);
+
     for (current_devno = 1; current_devno < 99; current_devno++) {
         build_partition_name(device_str, drivename, current_devno);
@@ -1522 +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 c = ' ';
+            char *command = NULL;
+
             if (current_devno == 1) {
                 // 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) {
+                    mr_asprintf(&subdev_str, "%s%c", drivename, c);
+                    if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
                         fbsd_part = TRUE;
                     }
+                    mr_free(subdev_str);
                 }
                 if (fbsd_part) {
@@ -1536 +1443 @@
                                                  drivename,
                                                  0);
-                    char command[MAX_STR_LEN];
-                    sprintf(command, "disklabel -B %s",
+                    mr_asprintf(&command, "disklabel -B %s",
                             basename(drivename));
                     if (system(command)) {
                         log_to_screen
-                            ("Warning! Unable to make the drive bootable.");
+                            (_
+                             ("Warning! Unable to make the drive bootable."));
                     }
+                    mr_free(command);
                     mr_free(device_str);
-                    mr_free(format);
-                    mr_free(tmp);
                     return r;
                 }
             }
             for (c = 'a'; c <= 'z'; c++) {
-                sprintf(subdev_str, "%s%c", device_str, c);
+                mr_asprintf(&subdev_str, "%s%c", device_str, c);
                 if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
                     fbsd_part = TRUE;
                 }
+                mr_free(subdev_str);
             }
             // Now we check the subpartitions of the current partition.
@@ -1559 +1466 @@
                 int i, line;
 
-                strcpy(format, "ufs");
+                mr_asprintf(&format, "ufs");
                 partsize = 0;
                 for (i = 'a'; i < 'z'; ++i) {
-                    sprintf(subdev_str, "%s%c", device_str, i);
+                    mr_asprintf(&subdev_str, "%s%c", device_str, i);
                     line = find_device_in_mountlist(mountlist, subdev_str);
+                    mr_free(subdev_str);
+
                     if (line > 0) {
                         // We found one! Add its size to the total size.
@@ -1586 +1495 @@
 #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,
-                        "Warning - unable to open %s for wiping it's partition table",
-                        drivename);
-                log_to_screen(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)) {
-                    sprintf(tmp, "Warning - unable to write to %s",
-                            drivename);
-                    log_to_screen(tmp);
+                    log_to_screen(_("Warning - unable to write to %s"), drivename);
                 }
             }
-            system("sync");
+            sync();
 #else
             iamhere("New, kernel-friendly partition remover");
@@ -1610 +1512 @@
                 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) {
@@ -1622 +1522 @@
         if (!fbsd_part) {
 #endif
-
-            strcpy(format, mountlist->el[lino].format);
+            mr_free(format);
+            mr_asprintf(&format, mountlist->el[lino].format);
             partsize = mountlist->el[lino].size;
 
@@ -1633 +1533 @@
         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."));
             mr_free(device_str);
             mr_free(format);
-            mr_free(tmp);
             return (1);
         }
@@ -1647 +1547 @@
 #ifdef __FreeBSD__
         if ((current_devno <= 4) && fbsd_part) {
-            sprintf(tmp, "disklabel -B %s", basename(device_str));
+            mr_asprintf(&tmp, "disklabel -B %s", basename(device_str));
             retval += label_drive_or_slice(mountlist, device_str, 0);
             if (system(tmp)) {
                 log_to_screen
-                    ("Warning! Unable to make the slice bootable.");
-            }
+                    (_("Warning! Unable to make the slice bootable."));
+            }
+            mr_free(tmp);
         }
 #endif
@@ -1658 +1559 @@
         previous_devno = current_devno;
     }
+    mr_free(device_str);
+    mr_free(format);
 
     if (pout_to_fdisk) {
-// mark relevant partition as bootable
-        sprintf(tmp, "a\n%s\n",
+        // mark relevant partition as bootable
+        mr_asprintf(&tmp, "a\n%s\n",
                 call_program_and_get_last_line_of_output
                 ("make-me-bootable /tmp/mountlist.txt dummy"));
         fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
-// close fdisk
+        mr_free(tmp);
+
+        // close fdisk
         fput_string_one_char_at_a_time(pout_to_fdisk, "w\n");
-        system("sync");
+        sync();
         paranoid_pclose(pout_to_fdisk);
         mr_msg(0,
                 "------------------- fdisk.log looks like this ------------------");
-        sprintf(tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
+        mr_asprintf(&tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
         system(tmp);
+        mr_free(tmp);
+
         mr_msg(0,
                 "------------------- end of fdisk.log... word! ------------------");
-        sprintf(tmp, "tail -n6 %s | grep -F \"16: \"", FDISK_LOG);
+        mr_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.");
-        }
-    }
-    mr_free(device_str);
-    mr_free(format);
-    mr_free(tmp);
+                (_
+                 ("A flaw in the Linux kernel has locked the partition table."));
+        }
+        mr_free(tmp);
+    }
     return (retval);
 }
+
 
 /**

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

@@ -2427 +2427 @@
                 sprintf(command, "cp -f tmp/i-want-my-lvm /tmp/");
                 run_program_and_log_output(command, 1);
-/*        sprintf(command, "grep \" lvm \" %s", g_mountlist_fname);
-          if (!run_program_and_log_output(command, 5) && !does_file_exist("/tmp/i-want-my-lvm"))
-            {
-          mr_msg(1, "Warning. You want LVM but I don't have i-want-my-lvm. FIXME.");
-        }
-              else if (run_program_and_log_output(command,5) && does_file_exist("/tmp/i-want-my-lvm"))
-                {
-          mr_msg(1, "Warning. You don't want LVM but i-want-my-lvm exists. I'll delete it. Cool.");
-              do_my_funky_lvm_stuff(TRUE, FALSE); // ...after I stop any LVMs :)
-          stop_raid_device("/dev/md0");
-          stop_raid_device("/dev/md1");
-          stop_raid_device("/dev/md2");
-          unlink("/tmp/i-want-my-lvm");
-        }
-          else if (!run_program_and_log_output(command,5) && does_file_exist("/tmp/i-want-my-lvm"))
-            {
-          mr_msg(1, "You had better pray that i-want-my-lvm patches your mountlist. FIXME.");
-        }
-*/
             }
         }

branches/stable/mondo/src/test/test-mem.c

@@ -38 +38 @@
     mr_free(str);
 
+    printf("*** Test2 with mr_strcat\n");
+    mr_asprintf(&str,"Another Chain");
+    mr_strcat(str," %s", "of distrust");
+    printf("Result: %s\n",str);
+    mr_free(str);
+
     printf("*** Test with mr_getline/mr_free\n");
     fd = mr_fopen("/etc/passwd","r");

branches/stable/mondo/src/test/test-mem.res

@@ -6 +6 @@
 *** Test with mr_strcat
 Result: Another Chain of trust
+*** Test2 with mr_strcat
+Result: Another Chain of distrust
 *** Test with mr_getline/mr_free
 1st Result: root:x:0:0:root:/root:/bin/bash

branches/stable/tools/quality

@@ -28 +28 @@
 
 # How many sprintf/strcat/strcpy vs asprintf are they
-for s in asprintf mr_asprintf sprintf strcat strcpy strncpy fgets malloc mr_malloc malloc_string getline mr_getline MAX_STR_LEN getcwd goto free mr_free paranoid_free; do
+for s in asprintf mr_asprintf sprintf strcat strcpy strncpy malloc mr_malloc malloc_string fgets getline mr_getline MAX_STR_LEN getcwd goto free mr_free paranoid_free system paranoid_system mr_system; do
     echo "monodrescue $s usage : "
     tot=0