Changeset 1206 in MondoRescue

Timestamp:

Feb 26, 2007, 6:20:12 AM (17 years ago)

Author:

Bruno Cornec

Message:

Merge trunk memory management for mondo-rstr-newt.c

File:

• branches/stable/mondo/src/mondorestore/mondo-rstr-newt.c (modified) (130 diffs)

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

@@ -1 @@
-/***************************************************************************
+/*
  * $Id$
 */
@@ -16 +16 @@
 #ifdef __FreeBSD__
 #define OSSWAP(linux,fbsd) fbsd
-//#include <libgen.h>
 #else
 #define OSSWAP(linux,fbsd) linux
@@ -62 +61 @@
 {
     /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
 
     /** newt **************************************************************/
@@ -87 +86 @@
 
     newtPushHelpLine
-        ("   Add one of the following unallocated RAID partitions to this RAID device.");
-    sprintf(tmp, "%-26s %s", "Device", "Size");
+        (_
+         ("   Add one of the following unallocated RAID partitions to this RAID device."));
+    mr_asprintf(&tmp, "%-26s %s", _("Device"), _("Size"));
     headerMsg = newtLabel(1, 1, tmp);
+    mr_free(tmp);
+
     partitionsListbox =
         newtListbox(1, 2, 6, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
@@ -95 +97 @@
                              partitionsListbox);
     i = 7;
-    bOK = newtCompactButton(i, 9, "  OK  ");
-    bCancel = newtCompactButton(i += 9, 9, "Cancel");
-    newtOpenWindow(22, 6, 36, 10, "Unallocated RAID partitions");
+    bOK = newtCompactButton(i, 9, _("  OK  "));
+    bCancel = newtCompactButton(i += 9, 9, _("Cancel"));
+    newtOpenWindow(22, 6, 36, 10, _("Unallocated RAID partitions"));
     myForm = newtForm(NULL, NULL, 0);
     newtFormAddComponents(myForm, headerMsg, partitionsListbox, bOK,
@@ -127 +129 @@
 
 
-
-
 /**
  * Add an entry to @p mountlist.
@@ -162 +162 @@
     newtComponent formatComp;
 
-    /** buffers **********************************************************/
-    char drive_to_add[MAX_STR_LEN];
-    char mountpoint_str[MAX_STR_LEN];
-    char size_str[MAX_STR_LEN];
-    char device_str[MAX_STR_LEN];
-    char format_str[MAX_STR_LEN];
-
-    /** pointers *********************************************************/
-    char *mountpoint_here;
-    char *size_here;
-    char *device_here;
-    char *format_here;
+    char *drive_to_add = NULL;
+    char *mountpoint_str = NULL;
+    char *size_str = NULL;
+    char *device_str = NULL;
+    char *format_str = NULL;
+    char *mountpoint_here = NULL;
+    char *size_here = NULL;
+    char *device_here = NULL;
+    char *format_here = NULL;
 
     assert(mountlist != NULL);
@@ -180 +177 @@
     assert(keylist != NULL);
 
-    strcpy(device_str, "/dev/");
-    strcpy(mountpoint_str, "/");
+    mr_asprintf(&device_str, "/dev/");
+    mr_asprintf(&mountpoint_str, "/");
 #ifdef __FreeBSD__
-    strcpy(format_str, "ufs");
+    mr_asprintf(&format_str, "ufs");
 #else
-    strcpy(format_str, "ext2");
+    mr_asprintf(&format_str, "ext2");
 #endif
-    size_str[0] = '\0';
-    /* sprintf(size_str,""); */
-    newtOpenWindow(20, 5, 48, 10, "Add entry");
-    label0 = newtLabel(2, 1, "Device:    ");
-    label1 = newtLabel(2, 2, "Mountpoint:");
-    label2 = newtLabel(2, 3, "Size (MB): ");
-    label3 = newtLabel(2, 4, "Format:    ");
+    newtOpenWindow(20, 5, 48, 10, _("Add entry"));
+    label0 = newtLabel(2, 1, _("Device:    "));
+    label1 = newtLabel(2, 2, _("Mountpoint:"));
+    label2 = newtLabel(2, 3, _("Size (MB): "));
+    label3 = newtLabel(2, 4, _("Format:    "));
     deviceComp =
         newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
     mountpointComp =
         newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
+
     formatComp =
         newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
     sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0);
-    bOK = newtButton(5, 6, "  OK  ");
-    bCancel = newtButton(17, 6, "Cancel");
+    bOK = newtButton(5, 6, _("  OK  "));
+    bCancel = newtButton(17, 6, _("Cancel"));
     newtPushHelpLine
-        ("To add an entry to the mountlist, please fill in these fields and then hit 'OK'");
+        (_
+         ("To add an entry to the mountlist, please fill in these fields and then hit 'OK'"));
     myForm = newtForm(NULL, NULL, 0);
     newtFormAddComponents(myForm, deviceComp, mountpointComp, sizeComp,
@@ -211 +208 @@
     for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
         b_res = newtRunForm(myForm);
-        strcpy(device_str, device_here);
-        strcpy(mountpoint_str, mountpoint_here);
-        strcpy(format_str, format_here);
-        strcpy(size_str, size_here);
-//      log_it ("Originals = %s,%s,%s,%s", device_str, mountpoint_str, format_str, size_str);
+
+        mr_free(device_str);
+        mr_asprintf(&device_str, device_here);
         mr_strip_spaces(device_str);
+
+        mr_free(format_str);
+        mr_asprintf(&format_str, format_here);
+        mr_strip_spaces(format_str);
+
+        mr_free(mountpoint_str);
+        mr_asprintf(&mountpoint_str, mountpoint_here);
         mr_strip_spaces(mountpoint_str);
-        mr_strip_spaces(format_str);
+
+        mr_free(size_str);
+        mr_asprintf(&size_str, size_here);
         mr_strip_spaces(size_str);
-//      log_it ("Modified = %s,%s,%s,%s", device_str, mountpoint_str, format_str, size_str);
+
         if (b_res == bOK) {
             if (device_str[strlen(device_str) - 1] == '/') {
-                popup_and_OK("You left the device nearly blank!");
+                popup_and_OK(_("You left the device nearly blank!"));
                 b_res = NULL;
             }
             if (size_of_specific_device_in_mountlist(mountlist, device_str)
                 >= 0) {
-                popup_and_OK("Can't add this - you've got one already!");
+                popup_and_OK(_
+                             ("Can't add this - you've got one already!"));
                 b_res = NULL;
             }
@@ -237 +242 @@
     newtPopWindow();
     if (b_res == bCancel) {
+        mr_free(device_str);
+        mr_free(format_str);
+        mr_free(mountpoint_str);
+        mr_free(size_str);
         return;
     }
-    strcpy(drive_to_add, device_str);
+    mr_asprintf(&drive_to_add, device_str);
     for (i = strlen(drive_to_add); isdigit(drive_to_add[i - 1]); i--);
     num_to_add = atoi(drive_to_add + i);
-    drive_to_add[i] = '\0';
+    mr_free(drive_to_add);
+
     currline = mountlist->entries;
     strcpy(mountlist->el[currline].device, device_str);
     strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
+    mr_free(mountpoint_str);
+
     strcpy(mountlist->el[currline].format, format_str);
+    mr_free(format_str);
+
     mountlist->el[currline].size = atol(size_str) * 1024;
+    mr_free(size_str);
+
     mountlist->entries++;
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
@@ -253 +269 @@
                                     device_str);
     }
+    mr_free(device_str);
     redraw_mountlist(mountlist, keylist, listbox);
 }
@@ -267 +284 @@
 
     /** buffers ***********************************************************/
-    char sz_out[MAX_STR_LEN];
+    char *sz_out = NULL;
 
     /** int ****************************************************************/
@@ -275 +292 @@
     assert(raidrec != NULL);
 
-    sz_out[0] = '\0';
+    malloc_string(sz_out);
     if (popup_and_get_string
-        ("Add variable", "Enter the name of the variable to add", sz_out,
+        ("Add variable", _("Enter the name of the variable to add"), sz_out,
          MAX_STR_LEN)) {
         mr_strip_spaces(sz_out);
@@ -286 +303 @@
         if (i < items) {
             popup_and_OK
-                ("No need to add that variable. It is already listed here.");
+                (_
+                 ("No need to add that variable. It is already listed here."));
         } else {
             strcpy(raidrec->additional_vars.el[items].label, sz_out);
@@ -293 +311 @@
         }
     }
+    mr_free(sz_out);
 }
 #endif
@@ -313 +332 @@
 
     /** structures ********************************************************/
-    struct vinum_volume *raidrec;
-
-    /** int ***************************************************************/
+    struct vinum_volume *raidrec = NULL;
+
     int i = 0, j = 0;
     int noof_partitions = 0;
 
-    /** long **************************************************************/
-    long total_size = 0;
-    long plex_size = 0;
+    long total_size = 0L;
+    long plex_size = 0L;
     long smallest_partition = 999999999;
     long smallest_plex = 999999999;
-    long sp = 0;
-
-    /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-
-
-
+    long sp = 0L;
+
+    char *devname = NULL;
 
     for (i = 0;
@@ -336 +349 @@
          && strcmp(raidlist->el[i].volname, basename(raid_device)); i++);
     if (i == raidlist->entries) {
-        sprintf(tmp,
-                "Cannot calc size of raid device %s - cannot find it in raidlist",
+        log_it("Cannot calc size of raid device %s - cannot find it in raidlist",
                 raid_device);
-        log_it(tmp);
         return (0);             // Isn't this more sensible than 999999999? If the raid dev !exists,
         // then it has no size, right?
@@ -351 +362 @@
         int k = 0, l = 0;
         for (k = 0; k < raidrec->plex[j].subdisks; ++k) {
-            char devname[64];
-            strcpy(devname, raidrec->plex[j].sd[k].which_device);
+            mr_asprintf(&devname, raidrec->plex[j].sd[k].which_device);
             for (l = 0; l < raidlist->disks.entries; ++l) {
                 if (!strcmp(devname, raidlist->disks.el[l].name)) {
@@ -380 +390 @@
                 }
             }
+            mr_free(devname);
         }
 
@@ -400 +411 @@
     }
 
-    sprintf(tmp, "I have calculated %s's real size to be %ld", raid_device,
+    log_it("I have calculated %s's real size to be %ld", raid_device,
             (long) smallest_plex);
-    log_it(tmp);
     return (smallest_plex);
 #else
@@ -408 +418 @@
 
     /** structures ********************************************************/
-    struct raid_device_record *raidrec;
+    struct raid_device_record *raidrec = NULL;
 
     /** int ***************************************************************/
@@ -419 +429 @@
     long sp = 0;
 
-    /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-
     assert(mountlist != NULL);
     assert(raidlist != NULL);
@@ -430 +437 @@
          && strcmp(raidlist->el[i].raid_device, raid_device); i++);
     if (i == raidlist->entries) {
-        sprintf(tmp,
-                "Cannot calc size of raid device %s - cannot find it in raidlist",
+        log_it("Cannot calc size of raid device %s - cannot find it in raidlist",
                 raid_device);
-        log_it(tmp);
         return (999999999);
     }
@@ -456 +461 @@
         total_size = smallest_partition * (noof_partitions - 1);
     }
-    sprintf(tmp, "I have calculated %s's real size to be %ld", raid_device,
+    log_it("I have calculated %s's real size to be %ld", raid_device,
             (long) total_size);
-    log_it(tmp);
     return (total_size);
 #endif
 }
-
 
 
@@ -481 +484 @@
 
     /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-    char prompt[MAX_STR_LEN];
-    char sz[MAX_STR_LEN];
-
-    sprintf(prompt,
-            "Please enter the RAID level you want. (concat, striped, raid5)");
+    char *tmp = NULL;
+    char *prompt = NULL;
+    char *sz = NULL;
+
+    malloc_string(tmp);
+    mr_asprintf(&prompt,
+             _
+             ("Please enter the RAID level you want. (concat, striped, raid5)"));
     if (raidrec->raidlevel == -1) {
         strcpy(tmp, "concat");
@@ -492 +497 @@
         strcpy(tmp, "striped");
     } else {
-        sprintf(tmp, "raid%i", raidrec->raidlevel);
+        strcpy(tmp, "raid%i", raidrec->raidlevel);
     }
     for (out = 999; out == 999;) {
-        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
+        res = popup_and_get_string(_("Specify RAID level"), prompt, tmp, 10);
         if (!res) {
+            mr_free(tmp);
+            mr_free(prompt);
             return;
         }
         mr_strip_spaces(tmp);
+        /* BERLIOS: Useless ??? */
         if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
-            strcpy(sz, tmp);
+            mr_asprintf(&sz, tmp);
             strncpy(tmp, sz + 1, strlen(sz) - 2);
             tmp[strlen(sz) - 2] = '\0';
+            mr_free(sz);
         }
         if (!strcmp(tmp, "concat")) {
@@ -511 +520 @@
         } else if (!strcmp(tmp, "raid5")) {
             out = 5;
+        } else {
+            continue;
+        }
+        log_it(tmp);
+
+        if (is_this_raid_personality_registered(out)) {
+            log_it
+                ("Groovy. You've picked a RAID personality which is registered.");
+        } else {
+            if (ask_me_yes_or_no
+                (_("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")))
+            {
+                out = 999;
+            }
+        }
+    }
+    mr_free(prompt);
+    mr_free(tmp);
+    raidrec->raidlevel = out;
+#else
+    /** buffers ***********************************************************/
+    char *tmp = NULL;
+    char *personalities = NULL;
+    char *prompt = NULL;
+    char *sz = NULL;
+    int out = 0, res = 0;
+
+    malloc_string(tmp);
+    assert(raidrec != NULL);
+    system
+        ("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null");
+    mr_asprintf(&personalities,
+           last_line_of_file("/tmp/raid-personalities.txt"));
+    mr_asprintf(&prompt, _("Please enter the RAID level you want. %s"),
+             personalities);
+    mr_free(personalities);
+
+    if (raidrec->raid_level == -1) {
+        strcpy(tmp, "linear");
+    } else {
+        sprintf(tmp, "%d", raidrec->raid_level);
+    }
+    for (out = 999;
+         out != -1 && out != 0 && out != 1 && out != 4 && out != 5
+         && out != 10;) {
+        res = popup_and_get_string(_("Specify RAID level"), prompt, tmp, 10);
+        if (!res) {
+            return;
+        }
+        mr_strip_spaces(tmp);
+        /* BERLIOS: Useless ??? */
+        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
+            mr_asprintf(&sz, tmp);
+            strncpy(tmp, sz + 1, strlen(sz) - 2);
+            tmp[strlen(sz) - 2] = '\0';
+            mr_free(sz);
+        }
+        if (!strcmp(tmp, "linear")) {
+            out = -1;
+        } else if (!strncmp(tmp, "raid", 4)) {
+            out = atoi(tmp + 4);
+        } else {
+            out = atoi(tmp);
         }
         log_it(tmp);
@@ -518 +590 @@
         } else {
             if (ask_me_yes_or_no
-                ("You have chosen a RAID personality which is not registered with the kernel. Make another selection?"))
+                (_
+                 ("You have chosen a RAID personality which is not registered with the kernel. Make another selection?")))
             {
                 out = 999;
@@ -524 +597 @@
         }
     }
-    raidrec->raidlevel = out;
-#else
-    /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-    char personalities[MAX_STR_LEN];
-    char prompt[MAX_STR_LEN];
-    char sz[MAX_STR_LEN];
-    int out = 0, res = 0;
-
-
-    assert(raidrec != NULL);
-    system
-        ("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null");
-    strcpy(personalities,
-           last_line_of_file("/tmp/raid-personalities.txt"));
-    sprintf(prompt, "Please enter the RAID level you want. %s",
-            personalities);
-    if (raidrec->raid_level == -1) {
-        strcpy(tmp, "linear");
-    } else {
-        sprintf(tmp, "%d", raidrec->raid_level);
-    }
-    for (out = 999;
-         out != -1 && out != 0 && out != 1 && out != 4 && out != 5
-         && out != 10;) {
-        res = popup_and_get_string("Specify RAID level", prompt, tmp, 10);
-        if (!res) {
-            return;
-        }
-        mr_strip_spaces(tmp);
-        if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
-            strcpy(sz, tmp);
-            strncpy(tmp, sz + 1, strlen(sz) - 2);
-            tmp[strlen(sz) - 2] = '\0';
-        }
-        if (!strcmp(tmp, "linear")) {
-            out = -1;
-        } else if (!strncmp(tmp, "raid", 4)) {
-            out = atoi(tmp + 4);
-        } else {
-            out = atoi(tmp);
-        }
-        log_it(tmp);
-        if (is_this_raid_personality_registered(out)) {
-            log_it
-                ("Groovy. You've picked a RAID personality which is registered.");
-        } else {
-            if (ask_me_yes_or_no
-                ("You have chosen a RAID personality which is not registered with the kernel. Make another selection?"))
-            {
-                out = 999;
-            }
-        }
-    }
+    mr_free(tmp);
+    mr_free(prompt);
     raidrec->raid_level = out;
 #endif
 }
-
 
 
@@ -602 +622 @@
     int pos = 0;
 
-    /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-
     assert(mountlist != NULL);
     assert(raidlist != NULL);
@@ -615 +632 @@
              pos++);
         if (pos < mountlist->entries) {
-            sprintf(tmp,
-                    "Deleting partition %s cos it was part of a now-defunct RAID",
-                    mountlist->el[pos].device);
-            log_it(tmp);
+            log_it("Deleting partition %s cos it was part of a now-defunct RAID",
+                     mountlist->el[pos].device);
             memcpy((void *) &mountlist->el[pos],
                    (void *) &mountlist->el[mountlist->entries - 1],
@@ -626 +641 @@
     }
 }
-
 
 
@@ -646 +660 @@
 
     /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
 
     assert(disklist != NULL);
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
 
-    sprintf(tmp, "Delete %s from RAID device %s - are you sure?",
-            disklist->el[currline].device, raid_device);
+    mr_asprintf(&tmp, _("Delete %s from RAID device %s - are you sure?"),
+             disklist->el[currline].device, raid_device);
     if (!ask_me_yes_or_no(tmp)) {
+        mr_free(tmp);
         return;
     }
+    mr_free(tmp);
     for (pos = currline; pos < disklist->entries - 1; pos++) {
         /* memcpy((void*)&disklist->el[pos], (void*)&disklist->el[pos+1], sizeof(struct s_disk)); */
@@ -662 +678 @@
     disklist->entries--;
 }
-
 
 
@@ -685 +700 @@
 
     /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-    char device[MAX_STR_LEN];
-
+    char *tmp = NULL;
+    char *device = NULL;
 
     assert(mountlist != NULL);
@@ -699 +713 @@
                                                   device);
     if (pos >= 0) {
-        sprintf(tmp, "Cannot delete %s: it is in use by RAID device %s",
-                mountlist->el[currline].device,
-                raidlist->el[pos].OSSWAP(raid_device, volname));
+        mr_asprintf(&tmp,
+                 _("Cannot delete %s: it is in use by RAID device %s"),
+                 mountlist->el[currline].device,
+                 raidlist->el[pos].OSSWAP(raid_device, volname));
         popup_and_OK(tmp);
+        mr_free(tmp);
         return;
     }
-    sprintf(tmp, "Delete %s - are you sure?",
-            mountlist->el[currline].device);
+    mr_asprintf(&tmp, _("Delete %s - are you sure?"),
+             mountlist->el[currline].device);
     if (!ask_me_yes_or_no(tmp)) {
+        mr_free(tmp);
         return;
     }
+    mr_free(tmp);
+
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
-        strcpy(device, mountlist->el[currline].device);
+        mr_asprintf(&device, mountlist->el[currline].device);
         delete_raidlist_entry(mountlist, raidlist, device);
         for (currline = 0;
@@ -717 +736 @@
              && strcmp(mountlist->el[currline].device, device);
              currline++);
-        if (currline == mountlist->entries) {
-            log_it("Dev is gone. I can't delete it. Ho-hum");
-            return;
-        }
+            if (currline == mountlist->entries) {
+                log_it("Dev is gone. I can't delete it. Ho-hum");
+                mr_free(device);
+                return;
+            }
+        mr_free(device);
     }
     memcpy((void *) &mountlist->el[currline],
@@ -750 +771 @@
 
     /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
 
     assert(mountlist != NULL);
@@ -760 +781 @@
         return;
     }
-    sprintf(tmp, "Do you want me to delete %s's partitions, too?", device);
+    mr_asprintf(&tmp,
+             _("Do you want me to delete %s's partitions, too?"), device);
     delete_partitions_too = ask_me_yes_or_no(tmp);
     if (delete_partitions_too) {
@@ -804 +826 @@
         items--;
     }
+    mr_free(tmp);
+
     raidlist->entries = items;
 }
@@ -819 +843 @@
 
     /** buffers ************************************************************/
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
 
     /** structures *********************************************************/
-    struct additional_raid_variables *av;
+    struct additional_raid_variables *av = NULL;
 
     assert(raidrec != NULL);
 
     av = &raidrec->additional_vars;
-    sprintf(tmp, "Delete %s - are you sure?", av->el[lino].label);
+    mr_asprintf(&tmp, _("Delete %s - are you sure?"), av->el[lino].label);
     if (ask_me_yes_or_no(tmp)) {
         if (!strcmp(av->el[lino].label, "persistent-superblock")
             || !strcmp(av->el[lino].label, "chunk-size")) {
-            sprintf(tmp, "%s must not be deleted. It would be bad.",
-                    av->el[lino].label);
+            mr_free(tmp);
+            mr_asprintf(&tmp, _("%s must not be deleted. It would be bad."),
+                     av->el[lino].label);
             popup_and_OK(tmp);
         } else {
@@ -839 +864 @@
         }
     }
+    mr_free(tmp);
 }
 #endif
@@ -861 +887 @@
 
     /** long **************************************************************/
-    long i = 0;
+    long i = 0L;
 
     /** structures *******************************************************/
-    struct s_node *node;
+    struct s_node *node = NULL;
 
     /** buffers **********************************************************/
     static char current_filename[MAX_STR_LEN];
-    char tmp[MAX_STR_LEN + 2];
+    char *tmp = NULL;
 
     /** bool *************************************************************/
-    /*  void*dummyptr; */
-    bool dummybool;
-    static bool warned_already;
+    bool dummybool = FALSE;
+    static bool warned_already = FALSE;
 
     assert(filelist != NULL);
     assert(keylist != NULL);
     assert(listbox != NULL);
-
 
     if (depth == 0) {
@@ -899 +923 @@
                 if (!warned_already) {
                     warned_already = TRUE;
-                    sprintf(tmp,
-                            "Too many lines. Displaying first %d entries only. Close a directory to see more.",
-                            ARBITRARY_MAXIMUM);
+                    mr_asprintf(&tmp,
+                             _
+                             ("Too many lines. Displaying first %d entries only. Close a directory to see more."),
+                             ARBITRARY_MAXIMUM);
                     popup_and_OK(tmp);
+                    mr_free(tmp);
                 }
             } else {
@@ -916 +942 @@
             lines_in_flist_window = ARBITRARY_MAXIMUM;
         }
-/* do an elementary sort */
+        /* do an elementary sort */
         for (i = 1; i < lines_in_flist_window; i++) {
             if (strcmp
                 (g_strings_of_flist_window[i],
                  g_strings_of_flist_window[i - 1]) < 0) {
-                strcpy(tmp, g_strings_of_flist_window[i]);
+                mr_asprintf(&tmp, g_strings_of_flist_window[i]);
                 strcpy(g_strings_of_flist_window[i],
                        g_strings_of_flist_window[i - 1]);
                 strcpy(g_strings_of_flist_window[i - 1], tmp);
+                mr_free(tmp);
+
                 dummybool = g_is_path_selected[i];
                 g_is_path_selected[i] = g_is_path_selected[i - 1];
@@ -931 +959 @@
             }
         }
-/* write list to screen */
+        /* write list to screen */
         newtListboxClear(listbox);
         for (i = 0; i < lines_in_flist_window; i++) {
-            sprintf(tmp, "%c%c %-80s", (g_is_path_selected[i] ? '*' : ' '),
-                    (g_is_path_expanded[i] ? '+' : '-'),
-                    strip_path(g_strings_of_flist_window[i]));
-            tmp[70] = '\0';
+            mr_asprintf(&tmp, "%c%c %-80s",
+                     (g_is_path_selected[i] ? '*' : ' '),
+                     (g_is_path_expanded[i] ? '+' : '-'),
+                     strip_path(g_strings_of_flist_window[i]));
+            if (strlen(tmp) > 71) {
+                tmp[70] = '\0';
+            }
             keylist[i] = (void *) i;
             newtListboxAppendEntry(listbox, tmp, keylist[i]);
+            mr_free(tmp);
         }
         return (lines_in_flist_window);
@@ -977 +1009 @@
         slashcount--;           /* Keep one slash 'cos Hugh does... */
 
+    /* BERLIOS: tmpnopath and prev not defined !! How can this compile ?? */
     for (i = 0; i < slashcount; i++) {  /* Replace each dir with a space char */
         tmpnopath[i] = ' ';
@@ -1025 +1058 @@
 
     /** ???? **************************************************************/
-    void *curr_choice;
+    void *curr_choice = NULL;
     void *keylist[ARBITRARY_MAXIMUM];
 
-    /** buffers ***********************************************************/
-    char tmp[MAX_STR_LEN];
-
     /** bool **************************************************************/
-    bool dummybool;
-
-/*  struct s_node *node; */
+    bool dummybool = FALSE;
+
 
     assert(filelist != NULL);
 
-    log_to_screen("Editing filelist");
+    log_to_screen(_("Editing filelist"));
     newtPushHelpLine
-        ("   Please edit the filelist to your satisfaction, then click OK or Cancel.");
+        (_
+         ("   Please edit the filelist to your satisfaction, then click OK or Cancel."));
     j = 4;
-    bLess = newtCompactButton(j, 17, " Less ");
-    bMore = newtCompactButton(j += 12, 17, " More ");
-    bToggle = newtCompactButton(j += 12, 17, "Toggle");
-    bRegex = newtCompactButton(j += 12, 17, "RegEx");
-    bCancel = newtCompactButton(j += 12, 17, "Cancel");
-    bOK = newtCompactButton(j += 12, 17, "  OK  ");
+    bLess = newtCompactButton(j, 17, _(" Less "));
+    bMore = newtCompactButton(j += 12, 17, _(" More "));
+    bToggle = newtCompactButton(j += 12, 17, _("Toggle"));
+    bRegex = newtCompactButton(j += 12, 17, _("RegEx"));
+    bCancel = newtCompactButton(j += 12, 17, _("Cancel"));
+    bOK = newtCompactButton(j += 12, 17, _("  OK  "));
     filelistListbox =
         newtListbox(2, 1, 15, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
@@ -1053 +1083 @@
     lines_in_flist_window =
         redraw_filelist(filelist, keylist, filelistListbox);
-    newtOpenWindow(1, 3, 77, 18, "Editing filelist");
+    newtOpenWindow(1, 3, 77, 18, _("Editing filelist"));
     myForm = newtForm(NULL, NULL, 0);
     newtFormAddComponents(myForm, filelistListbox, bLess, bMore, bToggle,
@@ -1062 +1092 @@
             finished =
                 ask_me_yes_or_no
-                ("Are you happy with your file selection?");
+                (_("Are you happy with your file selection?"));
         } else if (b_res == bCancel) {
             finished = TRUE;
         } else if (b_res == bRegex) {
-            popup_and_OK("I haven't implemented this yet...");
+            popup_and_OK(_("I haven't implemented this yet..."));
         } else {
             curr_choice = newtListboxGetCurrent(filelistListbox);
@@ -1077 +1107 @@
                 indexno = 0;
             }
-            sprintf(tmp, "You selected '%s'",
+            log_it("You selected '%s'",
                     g_strings_of_flist_window[indexno]);
-            log_it(tmp);
             if (b_res == bMore) {
                 g_is_path_expanded[indexno] = TRUE;
@@ -1131 +1160 @@
         return (0);
     } else {
-/*    popup_and_OK("You pushed 'cancel'. I shall now abort."); */
         return (1);
     }
@@ -1170 +1198 @@
     newtComponent b_raid = NULL;
 
-  /** buffers ***********************************************************/
-    char device_str[MAX_STR_LEN];
-    char mountpoint_str[MAX_STR_LEN];
-    char size_str[MAX_STR_LEN];
-    char format_str[MAX_STR_LEN];
-    char tmp[MAX_STR_LEN];
-    char device_used_to_be[MAX_STR_LEN];
-    char mountpt_used_to_be[MAX_STR_LEN];
-
-    /** pointers **********************************************************/
-    char *device_here;
-    char *mountpoint_here;
-    char *size_here;
-    char *format_here;
-
-    /** int ***************************************************************/
+    char *device_str = NULL;
+    char *mountpoint_str = NULL;
+    char *size_str = NULL;
+    char *format_str = NULL;
+    char *tmp = NULL;
+    char *device_used_to_be = NULL;
+    char *mountpt_used_to_be = NULL;
+    char *device_here = NULL;
+    char *mountpoint_here = NULL;
+    char *size_here = NULL;
+    char *format_here = NULL;
+
     int j = 0;
 
@@ -1195 +1219 @@
     memcpy((void *) &bkp_raidlist, (void *) raidlist,
            sizeof(struct raidlist_itself));
-    strcpy(device_str, mountlist->el[currline].device);
-    strcpy(device_used_to_be, mountlist->el[currline].device);
-    strcpy(mountpoint_str, mountlist->el[currline].mountpoint);
-    strcpy(mountpt_used_to_be, mountlist->el[currline].mountpoint);
-    strcpy(format_str, mountlist->el[currline].format);
-    sprintf(size_str, "%lld", mountlist->el[currline].size / 1024);
-    newtOpenWindow(20, 5, 48, 10, "Edit entry");
-    label0 = newtLabel(2, 1, "Device:");
-    label1 = newtLabel(2, 2, "Mountpoint:");
-    label2 = newtLabel(2, 3, "Size (MB): ");
-    label3 = newtLabel(2, 4, "Format:    ");
+    mr_asprintf(&device_str, mountlist->el[currline].device);
+    mr_asprintf(&device_used_to_be, mountlist->el[currline].device);
+    mr_asprintf(&mountpoint_str, mountlist->el[currline].mountpoint);
+    mr_asprintf(&mountpt_used_to_be, mountlist->el[currline].mountpoint);
+    mr_asprintf(&format_str, mountlist->el[currline].format);
+    mr_asprintf(&size_str, "%lld", mountlist->el[currline].size / 1024);
+
+    newtOpenWindow(20, 5, 48, 10, _("Edit entry"));
+    label0 = newtLabel(2, 1, _("Device:"));
+    label1 = newtLabel(2, 2, _("Mountpoint:"));
+    label2 = newtLabel(2, 3, _("Size (MB): "));
+    label3 = newtLabel(2, 4, _("Format:    "));
     deviceComp =
         newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
+    mr_free(device_str);
+
     mountpointComp =
         newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
+    mr_free(mountpoint_str);
+
     formatComp =
         newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
+    mr_free(format_str);
+
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
         || !strcmp(mountlist->el[currline].mountpoint, "image")) {
@@ -1218 +1249 @@
         sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0);
     }
-    bOK = newtButton(2, 6, "  OK  ");
-    bCancel = newtButton(14, 6, "Cancel");
+    mr_free(size_str);
+
+    bOK = newtButton(2, 6, _("  OK  "));
+    bCancel = newtButton(14, 6, _("Cancel"));
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
         b_raid = newtButton(26, 6, "RAID..");
     }
     newtPushHelpLine
-        ("       Edit this partition's mountpoint, size and format; then click 'OK'.");
+        (_
+         ("       Edit this partition's mountpoint, size and format; then click 'OK'."));
     myForm = newtForm(NULL, NULL, 0);
     newtFormAddComponents(myForm, deviceComp, mountpointComp, sizeComp,
@@ -1231 +1265 @@
     for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
         b_res = newtRunForm(myForm);
-        strcpy(device_str, device_here);
+        mr_free(device_str);
+        mr_asprintf(&device_str, device_here);
         mr_strip_spaces(device_str);
-        strcpy(mountpoint_str, mountpoint_here);
+
+        mr_free(mountpoint_str);
+        mr_asprintf(&mountpoint_str, mountpoint_here);
         mr_strip_spaces(mountpoint_str);
-        strcpy(format_str, format_here);
+
+        mr_free(format_str);
+        mr_asprintf(&format_str, format_here);
         mr_strip_spaces(format_str);
+
         if (b_res == bOK && strstr(device_str, RAID_DEVICE_STUB)
             && strstr(device_used_to_be, RAID_DEVICE_STUB)
             && strcmp(device_str, device_used_to_be)) {
-            popup_and_OK("You can't change /dev/mdX to /dev/mdY.");
+            popup_and_OK(_("You can't change /dev/mdX to /dev/mdY."));
             b_res = NULL;
             continue;
         } else if (b_res == bOK && !strcmp(mountpoint_str, "image")
                    && strcmp(mountpt_used_to_be, "image")) {
-            popup_and_OK("You can't change a regular device to an image.");
+            popup_and_OK(_
+                         ("You can't change a regular device to an image."));
             b_res = NULL;
             continue;
         }
+        mr_free(mountpt_used_to_be);
+
+        mr_free(size_str);
         if (!strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
             && strcmp(mountlist->el[currline].mountpoint, "image")) {
-            strcpy(size_str, size_here);
+            mr_asprintf(&size_str, size_here);
             mr_strip_spaces(size_str);
         } else {
-            sprintf(size_str, "%ld",
+            mr_asprintf(&size_str, "%ld",
                     calculate_raid_device_size(mountlist, raidlist,
                                                mountlist->el[currline].
@@ -1260 +1304 @@
             newtLabelSetText(sizeComp, size_str);
         }
+
         /* do not let user click RAID button if user has changed device_str */
         if (b_res == b_raid) {
@@ -1268 +1313 @@
                  */
                 popup_and_OK
-                    ("You cannot edit the RAID settings until you have OK'd your change to the device node.");
+                    (_
+                     ("You cannot edit the RAID settings until you have OK'd your change to the device node."));
             } else {
                 j = find_raid_device_in_raidlist(raidlist,
@@ -1274 +1320 @@
                                                  device);
                 if (j < 0) {
-                    sprintf(tmp,
-                            "/etc/raidtab does not have an entry for %s; please delete it and add it again",
+                    mr_asprintf(&tmp,
+                            _
+                            ("/etc/raidtab does not have an entry for %s; please delete it and add it again"),
                             mountlist->el[currline].device);
                     popup_and_OK(tmp);
+                    mr_free(tmp);
                 } else {
-                    log_it("edit_raidlist_entry - calling");
+                    log_it(_("edit_raidlist_entry - calling"));
                     edit_raidlist_entry(mountlist, raidlist,
                                         &raidlist->el[j], currline);
@@ -1296 +1344 @@
     strcpy(mountlist->el[currline].device, device_str);
     strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
+    mr_free(mountpoint_str);
+
     strcpy(mountlist->el[currline].format, format_str);
+    mr_free(format_str);
+
     if (strcmp(mountlist->el[currline].mountpoint, "image")) {
         if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
@@ -1306 +1358 @@
         }
     }
+    mr_free(size_str);
+
     newtListboxSetEntry(listbox, (long) keylist[currline],
                         mountlist_entry_to_string(mountlist, currline));
@@ -1330 +1384 @@
     else if (strcmp(device_used_to_be, device_str)) {
         popup_and_OK
-            ("You are renaming a RAID device as another RAID device. I don't like it but I'll allow it.");
+            (_
+             ("You are renaming a RAID device as another RAID device. I don't like it but I'll allow it."));
     }
 #endif
     redraw_mountlist(mountlist, keylist, listbox);
+    mr_free(device_str);
+    mr_free(device_used_to_be);
 }
 
@@ -1350 +1407 @@
                  struct vinum_plex *raidrec, char *temp)
 {
-    int i;
+    int i = 0;
     bool found = FALSE;
 
@@ -1392 +1449 @@
 }
 
+
 void
 edit_raidlist_plex(struct mountlist_itself *mountlist,
@@ -1422 +1480 @@
 
     /** buffers ***********************************************************/
-    char title_of_editraidForm_window[MAX_STR_LEN];
+    char *title_of_editraidForm_window = NULL;
 
     /** newt **************************************************************/
@@ -1436 +1494 @@
 
     void *keylist[10];
-    void *curr_choice;
+    void *curr_choice = NULL;
 
     int currline2 = 0;
-
-    log_it("Started edit_raidlist_entry");
+    char *pname = NULL;
+    char *raidlevel = NULL;
+    char *chunksize = NULL;
+    char *entry = NULL;
+    char *msg = NULL;
+    int i = 0;
+    char *headerstr = NULL;
+
+    log_it(_("Started edit_raidlist_entry"));
     memcpy((void *) &bkp_raidrec, (void *) raidrec,
            sizeof(struct vinum_volume));
-    sprintf(title_of_editraidForm_window, "Plexes on %s",
+    mr_asprintf(&title_of_editraidForm_window, _("Plexes on %s"),
             raidrec->volname);
-    newtPushHelpLine("   Please select a plex to edit");
+    newtPushHelpLine(_("   Please select a plex to edit"));
     newtOpenWindow(13, 5, 54, 15, title_of_editraidForm_window);
+    mr_free(title_of_editraidForm_window);
+
     for (;;) {
-        int i;
-        char headerstr[MAX_STR_LEN];
-        snprintf(headerstr, MAX_STR_LEN, "%-14s %-8s  %11s  %8s",
-                 "Plex", "Level", "Stripe Size", "Subdisks");
-
-        bOK = newtCompactButton(2, 13, "  OK  ");
-        bCancel = newtCompactButton(12, 13, "Cancel");
-        bAdd = newtCompactButton(22, 13, " Add ");
-        bEdit = newtCompactButton(32, 13, " Edit ");
-        bDelete = newtCompactButton(42, 13, "Delete");
+        mr_asprintf(&headerstr, "%-14s %-8s  %11s  %8s", _("Plex"), _("Level",) _("Stripe Size"), _("Subdisks"));
+
+        bOK = newtCompactButton(2, 13, _("  OK  "));
+        bCancel = newtCompactButton(12, 13, _("Cancel"));
+        bAdd = newtCompactButton(22, 13, _(" Add "));
+        bEdit = newtCompactButton(32, 13, _(" Edit "));
+        bDelete = newtCompactButton(42, 13, _("Delete"));
 
         plexesListbox =
             newtListbox(2, 3, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
         plexesHeader = newtLabel(2, 2, headerstr);
+        mr_free(headerstr);
+
         editraidForm = newtForm(NULL, NULL, 0);
 
@@ -1468 +1534 @@
             keylist[i] = (void *) i;
             if (i < raidrec->plexes) {
-                char pname[64], entry[MAX_STR_LEN], raidlevel[64],
-                    chunksize[64];
                 switch (raidrec->plex[i].raidlevel) {
                 case -1:
-                    strcpy(raidlevel, "concat");
+                    mr_asprintf(&raidlevel, "concat");
                     break;
                 case 0:
-                    strcpy(raidlevel, "striped");
+                    mr_asprintf(&raidlevel, "striped");
                     break;
                 case 5:
-                    strcpy(raidlevel, "raid5");
+                    mr_asprintf(&raidlevel, "raid5");
                     break;
                 default:
-                    sprintf(raidlevel, "raid%i",
+                    mr_asprintf(&raidlevel, "raid%i",
                             raidrec->plex[i].raidlevel);
                     break;
@@ -1487 +1551 @@
 
                 if (raidrec->plex[i].raidlevel == -1) {
-                    strcpy(chunksize, "N/A");
+                    mr_asprintf(&chunksize, "N/A");
                 } else {
-                    sprintf(chunksize, "%dk", raidrec->plex[i].stripesize);
+                    mr_asprintf(&chunksize, "%dk", raidrec->plex[i].stripesize);
                 }
-                snprintf(pname, 64, "%s.p%i", raidrec->volname, i);
-                snprintf(entry, MAX_STR_LEN, "%-14s %-8s  %11s  %8d",
+                mr_asprintf(&pname, "%s.p%i", raidrec->volname, i);
+                mr_asprintf(&entry, "%-14s %-8s  %11s  %8d",
                          pname, raidlevel, chunksize,
                          raidrec->plex[i].subdisks);
+                mr_free(pname);
+                mr_free(chunksize);
+                mr_free(raidlevel);
                 newtListboxAppendEntry(plexesListbox, entry, keylist[i]);
+                /* BERLIOS : hope it's not necessary anymore */
+                mr_free(entry);
             }
         }
@@ -1516 +1585 @@
 
         if (b_res == bDelete) {
-            char msg[MAX_STR_LEN];
-            sprintf(msg, "Are you sure you want to delete %s.p%i?",
+            mr_asprintf(&msg, _("Are you sure you want to delete %s.p%i?"),
                     raidrec->volname, currline2);
             if (ask_me_yes_or_no(msg)) {
-                log_it("Deleting RAID plex");
+                log_it(_("Deleting RAID plex"));
                 memcpy((void *) &raidrec->plex[currline2],
                        (void *) &raidrec->plex[raidrec->plexes - 1],
@@ -1526 +1594 @@
                 raidrec->plexes--;
             }
+            mr_free(msg);
             continue;
         }
@@ -1548 +1617 @@
 #else
     /** structures ********************************************************/
-    struct raid_device_record *bkp_raidrec;
+    struct raid_device_record *bkp_raidrec = NULL;
 
 
     /** buffers ***********************************************************/
-    char *title_of_editraidForm_window;
-    char *sz_raid_level;
-    char *sz_data_disks;
-    char *sz_spare_disks;
-    char *sz_parity_disks;
-    char *sz_failed_disks;
+    char *title_of_editraidForm_window = NULL;
+    char *sz_raid_level = NULL;
+    char *sz_data_disks = NULL;
+    char *sz_spare_disks = NULL;
+    char *sz_parity_disks = NULL;
+    char *sz_failed_disks = NULL;
 
     /** newt **************************************************************/
@@ -1575 +1644 @@
     assert(raidrec != NULL);
 
-    malloc_string(title_of_editraidForm_window);
-    malloc_string(sz_raid_level);
-    malloc_string(sz_data_disks);
-    malloc_string(sz_spare_disks);
-    malloc_string(sz_parity_disks);
-    malloc_string(sz_failed_disks);
     bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
 
@@ -1587 +1650 @@
     memcpy((void *) bkp_raidrec, (void *) raidrec,
            sizeof(struct raid_device_record));
-    sprintf(title_of_editraidForm_window, "%s", raidrec->raid_device);
+    mr_asprintf(&title_of_editraidForm_window, _("Edit %s"), raidrec->raid_device);
     mr_msg(2, "Opening newt window");
     newtOpenWindow(20, 5, 40, 14, title_of_editraidForm_window);
+    mr_free(title_of_editraidForm_window);
+
     for (;;) {
         mr_msg(2, "Main loop");
-        sprintf(title_of_editraidForm_window, "Edit %s",
-                raidrec->raid_device);
-        strcpy(sz_raid_level,
+        mr_asprintf(&sz_raid_level,
                turn_raid_level_number_to_string(raidrec->raid_level));
-        strcpy(sz_data_disks,
+        mr_asprintf(&sz_data_disks,
                number_of_disks_as_string(raidrec->data_disks.entries,
-                                         "data"));
-        strcpy(sz_spare_disks,
+                                         _("data")));
+        mr_asprintf(&sz_spare_disks,
                number_of_disks_as_string(raidrec->spare_disks.entries,
-                                         "spare"));
-        strcpy(sz_parity_disks,
+                                         _("spare")));
+        mr_asprintf(&sz_parity_disks,
                number_of_disks_as_string(raidrec->parity_disks.entries,
-                                         "parity"));
-        strcpy(sz_failed_disks,
+                                         _("parity")));
+        mr_asprintf(&sz_failed_disks,
                number_of_disks_as_string(raidrec->failed_disks.entries,
-                                         "failed"));
+                                         _("failed")));
         bSelectData = newtButton(1, 1, sz_data_disks);
         bSelectSpare = newtButton(20, 1, sz_spare_disks);
@@ -1613 +1676 @@
         bSelectFailed = newtButton(20, 5, sz_failed_disks);
         bChangeRaid = newtButton(1, 9, sz_raid_level);
-        bOK = newtButton(16 + (raidrec->raid_level == -1), 9, "  OK  ");
-        bCancel = newtButton(28, 9, "Cancel");
+        mr_free(sz_raid_level);
+        mr_free(sz_data_disks);
+        mr_free(sz_spare_disks);
+        mr_free(sz_parity_disks);
+        mr_free(sz_failed_disks);
+
+        bOK = newtButton(16 + (raidrec->raid_level == -1), 9, _("  OK  "));
+        bCancel = newtButton(28, 9, _("Cancel"));
         bAdditional =
             newtCompactButton(1, 13,
-                              "Additional settings and information");
+                              _("Additional settings and information"));
         newtPushHelpLine
-            ("  Edit the RAID device's settings to your heart's content, then hit OK/Cancel.");
+            (_
+             ("  Edit the RAID device's settings to your heart's content, then hit OK/Cancel."));
         editraidForm = newtForm(NULL, NULL, 0);
         newtFormAddComponents(editraidForm, bSelectData, bSelectParity,
@@ -1628 +1698 @@
             choose_raid_level(raidrec);
         } else if (b_res == bSelectData) {
-            select_raid_disks(mountlist, raidlist, raidrec, "data",
+            select_raid_disks(mountlist, raidlist, raidrec, _("data"),
                               &raidrec->data_disks);
         } else if (b_res == bSelectSpare) {
-            select_raid_disks(mountlist, raidlist, raidrec, "spare",
+            select_raid_disks(mountlist, raidlist, raidrec, _("spare"),
                               &raidrec->spare_disks);
         } else if (b_res == bSelectParity) {
-            select_raid_disks(mountlist, raidlist, raidrec, "parity",
+            select_raid_disks(mountlist, raidlist, raidrec, _("parity"),
                               &raidrec->parity_disks);
         } else if (b_res == bSelectFailed) {
-            select_raid_disks(mountlist, raidlist, raidrec, "failed",
+            select_raid_disks(mountlist, raidlist, raidrec, _("failed"),
                               &raidrec->failed_disks);
         } else if (b_res == bAdditional) {
@@ -1656 +1726 @@
         calculate_raid_device_size(mountlist, raidlist,
                                    raidrec->raid_device);
-    mr_free(title_of_editraidForm_window);
-    mr_free(sz_raid_level);
-    mr_free(sz_data_disks);
-    mr_free(sz_spare_disks);
-    mr_free(sz_parity_disks);
-    mr_free(sz_failed_disks);
     mr_free(bkp_raidrec);
 #endif
 }
+
 
 #ifdef __FreeBSD__
@@ -1689 +1754 @@
 
     /** buffers ***********************************************************/
-    char title_of_editraidForm_window[MAX_STR_LEN];
+    char *title_of_editraidForm_window = NULL;
+    char *tmp = NULL;
+    char *entry = NULL;
 
     /** newt **************************************************************/
@@ -1705 +1772 @@
 
     void *keylist[ARBITRARY_MAXIMUM];
-    void *curr_choice_a, *curr_choice_u;
-    int currline_a, currline_u;
-
-    struct mountlist_itself *unallocparts;
+    void *curr_choice_a = NULL, *curr_choice_u = NULL;
+    int currline_a = 0, currline_u = 0;
+    int i = 0;
+
+    struct mountlist_itself *unallocparts = NULL;
 
     unallocparts = mr_malloc(sizeof(struct mountlist_itself));
@@ -1715 +1783 @@
     memcpy((void *) &bkp_raidrec, (void *) raidrec,
            sizeof(struct vinum_plex));
-    sprintf(title_of_editraidForm_window, "%s.p%i",
+    mr_asprintf(&title_of_editraidForm_window, "%s.p%i",
             raidlist->el[currline].volname, currline2);
     newtPushHelpLine
-        ("   Please select a subdisk to edit, or edit this plex's parameters");
+        (_
+         ("   Please select a subdisk to edit, or edit this plex's parameters"));
     newtOpenWindow(13, 3, 54, 18, title_of_editraidForm_window);
+    mr_free(title_of_editraidForm_window);
+
     for (;;) {
-        int i;
-        char headerstr[MAX_STR_LEN];
-        char tmp[64];
-        snprintf(headerstr, MAX_STR_LEN, "%-24s %s", "Subdisk", "Device");
-
-
         switch (raidrec->raidlevel) {
         case -1:
-            strcpy(tmp, "concat");
+            mr_asprintf(&tmp, _("concat"));
             break;
         case 0:
-            strcpy(tmp, "striped");
+            mr_asprintf(&tmp, _("striped"));
             break;
         case 5:
-            strcpy(tmp, "raid5");
+            mr_asprintf(&tmp, _("raid5"));
             break;
         default:
-            sprintf(tmp, "unknown (%i)", raidrec->raidlevel);
+            mr_asprintf(&tmp, _("unknown (%i)"), raidrec->raidlevel);
             break;
         }
-        bLevel = newtCompactButton(2, 2, " RAID level ");
+        bLevel = newtCompactButton(2, 2, _(" RAID level "));
         sLevel = newtLabel(19, 2, tmp);
+        mr_free(tmp);
 
         if (raidrec->raidlevel >= 0) {
-            sprintf(tmp, "%ik", raidrec->stripesize);
-            bStripeSize = newtCompactButton(2, 4, " Stripe size ");
+            mr_asprintf(&tmp, "%ik", raidrec->stripesize);
+            bStripeSize = newtCompactButton(2, 4, _(" Stripe size "));
         } else {
-            strcpy(tmp, "N/A");
-            bStripeSize = newtLabel(2, 4, "Stripe size:");
+            mr_asprintf(&tmp, "N/A");
+            bStripeSize = newtLabel(2, 4, _("Stripe size:"));
         }
         sStripeSize = newtLabel(19, 4, tmp);
-
-        bOK = newtCompactButton(2, 16, "  OK  ");
-        bCancel = newtCompactButton(12, 16, "Cancel");
-        bAdd = newtCompactButton(22, 16, " Add ");
-        bEdit = newtCompactButton(32, 16, " Edit ");
-        bDelete = newtCompactButton(42, 16, "Delete");
-
-
-        //  plexesListbox = newtListbox (2, 7, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        //  plexesHeader  = newtLabel (2, 6, headerstr);
+        mr_free(tmp);
+
+        bOK = newtCompactButton(2, 16, _("  OK  "));
+        bCancel = newtCompactButton(12, 16, _("Cancel"));
+        bAdd = newtCompactButton(22, 16, _(" Add "));
+        bEdit = newtCompactButton(32, 16, _(" Edit "));
+        bDelete = newtCompactButton(42, 16, _("Delete"));
+
         unallocListbox =
             newtListbox(2, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
@@ -1777 +1841 @@
                                                  raidlist);
         for (i = 0; i < ARBITRARY_MAXIMUM; ++i) {
-            char entry[MAX_STR_LEN];
             keylist[i] = (void *) i;
             if (i < raidrec->subdisks) {
-                snprintf(entry, MAX_STR_LEN, "%-17s",
+                mr_asprintf(&entry, "%-17s",
                          find_dev_entry_for_raid_device_name(raidlist,
                                                              raidrec->
@@ -1786 +1849 @@
                                                              which_device));
                 newtListboxAppendEntry(allocListbox, entry, keylist[i]);
+                mr_free(entry);
             }
             if (i < unallocparts->entries) {
-                snprintf(entry, MAX_STR_LEN, "%-17s",
-                         unallocparts->el[i].device);
+                mr_asprintf(&entry, "%-17s", unallocparts->el[i].device);
                 newtListboxAppendEntry(unallocListbox, entry, keylist[i]);
+                mr_free(entry);
             }
         }
@@ -1840 +1904 @@
             choose_raid_level(raidrec);
         } else if (b_res == bStripeSize) {
-            char tmp[64];
+            malloc_string(tmp);
             sprintf(tmp, "%i", raidrec->stripesize);
             if (popup_and_get_string
-                ("Stripe size",
-                 "Please enter the stripe size in kilobytes.", tmp, 20)) {
+                (_("Stripe size"),
+                 _("Please enter the stripe size in kilobytes."), tmp, 20)) {
                 raidrec->stripesize = atoi(tmp);
             }
+            mr_free(tmp);
         } else if ((b_res == bAlloc) || (b_res == unallocListbox)) {
             if (currline_u <= unallocparts->entries)
@@ -1887 +1952 @@
 
     /** buffers ***********************************************************/
-    char header[MAX_STR_LEN];
-    char comment[MAX_STR_LEN];
-    char sz_out[MAX_STR_LEN];
+    char *header = NULL;
+    char *comment = NULL;
+    char *sz_out = NULL;
 
     assert(raidrec != 0);
     assert(lino >= 0);
 
+    malloc_string(sz_out);
     strcpy(sz_out, raidrec->additional_vars.el[lino].value);
-    sprintf(header, "Edit %s", raidrec->additional_vars.el[lino].label);
-    sprintf(comment, "Please set %s's value (currently '%s')",
+    mr_asprintf(&header, _("Edit %s"), raidrec->additional_vars.el[lino].label);
+    mr_asprintf(&comment, _("Please set %s's value (currently '%s')"),
             raidrec->additional_vars.el[lino].label, sz_out);
     if (popup_and_get_string(header, comment, sz_out, MAX_STR_LEN)) {
@@ -1902 +1968 @@
         strcpy(raidrec->additional_vars.el[lino].value, sz_out);
     }
-}
-
-
-/* I'm not racist against white people. I just don't like people who think Liberia is near Spain.       - Hugo, 09/01/2001 */
-
+    mr_free(sz_out);
+    mr_free(header);
+    mr_free(comment);
+}
 #endif
+
 
 /**
@@ -1937 +2003 @@
 
     /** ???? *************************************************************/
-    void *curr_choice;
+    void *curr_choice = NULL;
     void *keylist[ARBITRARY_MAXIMUM];
 
@@ -1944 +2010 @@
     int currline = 0;
     int finished = FALSE;
+    int res = 0;
 
     /** buffers **********************************************************/
-    char tmp[MAX_STR_LEN];
-    char flaws_str_A[MAX_STR_LEN];
-    char flaws_str_B[MAX_STR_LEN];
-    char flaws_str_C[MAX_STR_LEN];
+    char *tmp = NULL;
+    char *flaws_str_A = NULL;
+    char *flaws_str_B = NULL;
+    char *flaws_str_C = NULL;
 
     assert(mountlist != NULL);
     assert(raidlist != NULL);
 
-    strcpy(flaws_str_A, "xxxxxxxxx");
-    strcpy(flaws_str_B, "xxxxxxxxx");
-    strcpy(flaws_str_C, "xxxxxxxxx");
+    mr_asprintf(&flaws_str_A, "xxxxxxxxx");
+    mr_asprintf(&flaws_str_B, "xxxxxxxxx");
+    mr_asprintf(&flaws_str_C, "xxxxxxxxx");
     if (mountlist->entries > ARBITRARY_MAXIMUM) {
-        log_to_screen("Arbitrary limits suck, man!");
+        log_to_screen(_("Arbitrary limits suck, man!"));
         finish(1);
     }
     newtPushHelpLine
-        ("   Please edit the mountlist to your satisfaction, then click OK or Cancel.");
+        (_
+         ("   Please edit the mountlist to your satisfaction, then click OK or Cancel."));
     i = 4;
-    bAdd = newtCompactButton(i, 17, " Add ");
-    bEdit = newtCompactButton(i += 11, 17, " Edit ");
-    bDelete = newtCompactButton(i += 12, 17, "Delete");
-    bReload = newtCompactButton(i += 12, 17, "Reload");
-    bCancel = newtCompactButton(i += 12, 17, "Cancel");
-    bOK = newtCompactButton(i += 12, 17, "  OK  ");
-    sprintf(tmp, "%-24s %-24s %-8s  %s", "Device", "Mountpoint", "Format",
-            "Size (MB)");
+    bAdd = newtCompactButton(i, 17, _(" Add "));
+    bEdit = newtCompactButton(i += 11, 17, _(" Edit "));
+    bDelete = newtCompactButton(i += 12, 17, _("Delete"));
+    bReload = newtCompactButton(i += 12, 17, _("Reload"));
+    bCancel = newtCompactButton(i += 12, 17, _("Cancel"));
+    bOK = newtCompactButton(i += 12, 17, _("  OK  "));
+    mr_asprintf(&tmp, "%-24s %-24s %-8s  %s", _("Device"), _("Mountpoint"),
+            _("Format"), _("Size (MB)"));
     headerMsg = newtLabel(2, 1, tmp);
     flawsLabelA = newtLabel(2, 13, flaws_str_A);
     flawsLabelB = newtLabel(2, 14, flaws_str_B);
     flawsLabelC = newtLabel(2, 15, flaws_str_C);
+    mr_free(flaws_str_A);
+    mr_free(flaws_str_B);
+    mr_free(flaws_str_C);
+
     partitionsListbox =
         newtListbox(2, 2, 10, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
     redraw_mountlist(mountlist, keylist, partitionsListbox);
-    newtOpenWindow(1, 3, 77, 18, "Editing mountlist");
+    newtOpenWindow(1, 3, 77, 18, _("Editing mountlist"));
     myForm = newtForm(NULL, NULL, 0);
     newtFormAddComponents(myForm, headerMsg, partitionsListbox,
                           flawsLabelA, flawsLabelB, flawsLabelC, bAdd,
                           bEdit, bDelete, bReload, bCancel, bOK, NULL);
+
+    malloc_string(flaws_str_A);
+    malloc_string(flaws_str_B);
+    malloc_string(flaws_str_C);
     while (!finished) {
         evaluate_mountlist(mountlist, flaws_str_A, flaws_str_B,
@@ -1990 +2066 @@
         newtLabelSetText(flawsLabelB, flaws_str_B);
         newtLabelSetText(flawsLabelC, flaws_str_C);
+
         b_res = newtRunForm(myForm);
         if (b_res == bOK) {
@@ -1996 +2073 @@
                 finished =
                     ask_me_yes_or_no
-                    ("Your mountlist might not work. Continue anyway?");
+                    (_("Your mountlist might not work. Continue anyway?"));
             } else {
                 finished =
                     ask_me_yes_or_no
-                    ("Are you sure you want to save your mountlist and continue? (No changes will be made to your partition table at this time.)");
+                    (_
+                     ("Are you sure you want to save your mountlist and continue? (No changes will be made to your partition table at this time.)"));
             }
         } else if (b_res == bCancel) {
             finished = TRUE;
         } else if (b_res == bReload) {
-            if (ask_me_yes_or_no("Reload original mountlist?")) {
-/*
-This would be really dumb. RAIDTAB_FNAME is #define'd.   --- Hugo, 2003/04/24
-          if (!RAIDTAB_FNAME[0])
-        {
-                  strcpy(RAIDTAB_FNAME, "/etc/raidtab");
-          log_it("Warning - raidtab_fname is blank. Assuming %s", g_raidtab_fname);
-        }
-*/
+            if (ask_me_yes_or_no(_("Reload original mountlist?"))) {
                 load_mountlist(mountlist, mountlist_fname);
                 load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
@@ -2023 +2093 @@
                  i < mountlist->entries && keylist[i] != curr_choice; i++);
             if (i == mountlist->entries && mountlist->entries > 0) {
-                log_to_screen("I don't know what that button does!");
+                log_to_screen(_("I don't know what that button does!"));
             } else {
                 currline = i;
@@ -2041 +2111 @@
                     } else {
                         popup_and_OK
-                            ("Please add an entry. Then press ENTER to edit it.");
+                            (_
+                             ("Please add an entry. Then press ENTER to edit it."));
                     }
                 }
@@ -2051 +2122 @@
     newtPopHelpLine();
     if (b_res == bOK) {
-        log_it("You pushed 'OK'. I shall now continue.");
+        log_it(_("You pushed 'OK'. I shall now continue."));
         return (0);
     } else {
-        /* popup_and_OK("You pushed 'cancel'. I shall now abort."); */
         return (1);
     }
 }
-
 
 
@@ -2072 +2141 @@
 {
     int res = 0;
-//  char tmp[MAX_STR_LEN];
 
     iamhere("entering eml");
@@ -2086 +2154 @@
     return (res);
 }
-
-
 
 
@@ -2114 +2180 @@
 
     /** ?? ***************************************************************/
-    void *keylist[ARBITRARY_MAXIMUM], *curr_choice;
+    void *keylist[ARBITRARY_MAXIMUM], *curr_choice = NULL;
 
     /** buffers **********************************************************/
-    char title_of_window[MAX_STR_LEN];
+    char *title_of_window = NULL;
 
     /** int **************************************************************/
@@ -2128 +2194 @@
     memcpy((void *) &bkp_raidrec, (void *) raidrec,
            sizeof(struct raid_device_record));
-    sprintf(title_of_window, "Additional variables");
+    mr_asprintf(&title_of_window, "Additional variables");
     newtPushHelpLine
-        ("  Edit the additional fields to your heart's content, then click OK or Cancel.");
-    headerMsg = newtLabel(1, 1, "Label                            Value");
+        (_
+         ("  Edit the additional fields to your heart's content, then click OK or Cancel."));
+    headerMsg =
+        newtLabel(1, 1, _("Label                            Value"));
     varsListbox =
         newtListbox(1, 2, 6, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
     i = 1;
-    bAdd = newtCompactButton(i, 9, " Add ");
-    bEdit = newtCompactButton(i += 8, 9, " Edit ");
-    bDelete = newtCompactButton(i += 9, 9, "Delete");
-    bOK = newtCompactButton(i += 9, 9, "  OK  ");
-    bCancel = newtCompactButton(i += 9, 9, "Cancel");
+    bAdd = newtCompactButton(i, 9, _(" Add "));
+    bEdit = newtCompactButton(i += 8, 9, _(" Edit "));
+    bDelete = newtCompactButton(i += 9, 9, _("Delete"));
+    bOK = newtCompactButton(i += 9, 9, _("  OK  "));
+    bCancel = newtCompactButton(i += 9, 9, _("Cancel"));
     newtOpenWindow(17, 7, 46, 10, title_of_window);
+    mr_free(title_of_window);
+
     myForm = newtForm(NULL, NULL, 0);
     newtFormAddComponents(myForm, headerMsg, varsListbox, bAdd, bEdit,
@@ -2194 +2264 @@
 
   /** bool **************************************************************/
-    bool done;
+    bool done = FALSE;
 
     assert(disklist != NULL);
@@ -2212 +2282 @@
 
 
-
 /**
  * Locate @p device in @p raidlist.
@@ -2228 +2297 @@
     int i = 0;
 #ifdef __FreeBSD__
-    char vdev[64];
-#else
-// Linux
+    char *vdev = NULL;
 #endif
 
@@ -2238 +2305 @@
 #ifdef __FreeBSD__
     for (i = 0; i < raidlist->entries; i++) {
-        sprintf(vdev, "/dev/vinum/%s", raidlist->el[i].volname);
-        if (!strcmp(device, vdev))
+        mr_asprintf(&vdev, "/dev/vinum/%s", raidlist->el[i].volname);
+        if (!strcmp(device, vdev)) {
+            mr_free(vdev);
             break;
+        }
+        mr_free(vdev);
     }
 #else
@@ -2260 +2330 @@
  * @param isodir_device Where to put the device (e.g. /dev/hda4) the user enters.
  * @param isodir_format Where to put the format (e.g. ext2) the user enters.
- * @param isodir_path Where to put the path (e.g. /root/images/mondo) the user enters.
+ * @param isodir_path Where to put the path (e.g. /var/cache/mondo) the user enters.
  * @param nuke_me_please Whether we're planning on nuking or not.
  * @return TRUE if OK was pressed, FALSE otherwise.
@@ -2297 +2367 @@
 
     if (popup_and_get_string
-        ("ISO Mode - device", "On what device do the ISO files live?",
+        (_("ISO Mode - device"), _("On what device do the ISO files live?"),
          isodir_device, MAX_STR_LEN / 4)) {
         if (popup_and_get_string
-            ("ISO Mode - format",
-             "What is the disk format of the device? (Hit ENTER if you don't know.)",
+            (_("ISO Mode - format"),
+             _("What is the disk format of the device? (Hit ENTER if you don't know.)"),
              isodir_format, 16)) {
             if (popup_and_get_string
-                ("ISO Mode - path",
-                 "At what path on this device can the ISO files be found?",
+                (_("ISO Mode - path"),
+                 _("At what path on this device can the ISO files be found?"),
                  isodir_path, MAX_STR_LEN / 4)) {
                 mr_strip_spaces(isodir_device);
@@ -2332 +2402 @@
                             int currline, char *device)
 {
-
     /** structure *********************************************************/
     struct OSSWAP (raid_device_record, vinum_volume) * raidrec;
@@ -2385 +2454 @@
     raidrec->additional_vars.entries = items;
 }
-
 #endif
+
 
 /**
@@ -2403 +2472 @@
 
     newtPushHelpLine
-        ("This is where I nuke your hard drives. Mhahahahaha. No-one can stop Mojo Jojo!");
-    newtOpenWindow(24, 3, 32, 13, "Nuking");
-    b1 = newtButton(7, 1, "Slowly");
-    b2 = newtButton(7, 5, "Medium");
-    b3 = newtButton(7, 9, "Quickly");
+        (_
+         ("This is where I nuke your hard drives. Mhahahahaha. No-one can stop Mojo Jojo!"));
+    newtOpenWindow(24, 3, 32, 13, _("Nuking"));
+    b1 = newtButton(7, 1, _("Slowly"));
+    b2 = newtButton(7, 5, _("Medium"));
+    b3 = newtButton(7, 9, _("Quickly"));
     myForm = newtForm(NULL, NULL, 0);
     newtFormAddComponents(myForm, b1, b2, b3, NULL);
@@ -2417 +2487 @@
 
 
-
 /**
  * Redraw the disklist.
@@ -2470 +2539 @@
 
     newtListboxClear(listbox);
-//  sort_mountlist_by_device (mountlist);
     for (i = 0; i < ARBITRARY_MAXIMUM; i++) {
         keylist[i] = (void *) i;
@@ -2480 +2548 @@
     }
 }
-
-
 
 
@@ -2501 +2567 @@
 
     /** buffers **********************************************************/
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
 
     assert(unallocated_raid_partitions != NULL);
@@ -2512 +2578 @@
     }
     for (i = 0; i < unallocated_raid_partitions->entries; i++) {
-        sprintf(tmp, "%-22s %8lld",
+        mr_asprintf(&tmp, "%-22s %8lld",
                 unallocated_raid_partitions->el[i].device,
                 unallocated_raid_partitions->el[i].size / 1024);
         newtListboxAppendEntry(listbox, tmp, keylist[i]);
-    }
-}
+        mr_free(tmp);
+    }
+}
+
 
 #ifndef __FreeBSD__
@@ -2535 +2603 @@
 
     /** buffers *********************************************************/
-    char tmp[MAX_STR_LEN];
+    char *tmp;
 
     assert(additional_vars != NULL);
@@ -2547 +2615 @@
     }
     for (i = 0; i < additional_vars->entries; i++) {
-        sprintf(tmp, "%-32s %-8s", additional_vars->el[i].label,
+        mr_asprintf(&tmp, "%-32s %-8s", additional_vars->el[i].label,
                 additional_vars->el[i].value);
         newtListboxAppendEntry(listbox, tmp, keylist[i]);
+        mr_free(tmp);
     }
 }
@@ -2593 +2662 @@
 #endif
 
+
 /**
  * Change all RAID devices to use @p new_dev instead of @p old_dev.
@@ -2605 +2675 @@
                                                    char *new_dev)
 {
-    /** buffers ********************************************************/
-    char tmp[MAX_STR_LEN];
 
     /** int ************************************************************/
@@ -2618 +2686 @@
     pos = which_raid_device_is_using_this_partition(raidlist, old_dev);
     if (pos < 0) {
-        sprintf(tmp, "No need to rejig %s in raidlist: it's not listed.",
+        log_it("No need to rejig %s in raidlist: it's not listed.",
                 old_dev);
-        log_it(tmp);
     } else {
         if ((j =
@@ -2652 +2719 @@
 #endif
         else {
-            sprintf(tmp,
-                    "%s is supposed to be listed in this raid dev but it's not...",
+            log_it("%s is supposed to be listed in this raid dev but it's not...",
                     old_dev);
-            log_it(tmp);
         }
     }
@@ -2688 +2753 @@
     res = read_variableINT_and_remove_from_raidvars(raidrec, "block-size");
 }
+
 
 /**
@@ -2705 +2771 @@
                   struct list_of_disks *disklist)
 {
-    void *curr_choice;
-
-    /** ??? ***************************************************************/
+    void *curr_choice = NULL;
 
     /** structures ********************************************************/
-    struct raidlist_itself *bkp_raidlist;
-    struct raid_device_record *bkp_raidrec;
-    struct list_of_disks *bkp_disklist;
-    struct mountlist_itself *unallocated_raid_partitions;
+    struct raidlist_itself *bkp_raidlist = NULL;
+    struct raid_device_record *bkp_raidrec = NULL;
+    struct list_of_disks *bkp_disklist = NULL;
+    struct mountlist_itself *unallocated_raid_partitions = NULL;
 
     /** newt **************************************************************/
@@ -2727 +2791 @@
     /** buffers **********************************************************/
     void *keylist[ARBITRARY_MAXIMUM];
-    char *tmp;
-    char *help_text;
-    char *title_of_window;
-    char *sz_res;
-    char *header_text;
+    char *tmp = NULL;
+    char *help_text = NULL;
+    char *title_of_window = NULL;
+    char *sz_res = NULL;
+    char *header_text = NULL;
 
   /** int **************************************************************/
@@ -2744 +2808 @@
 
     iamhere("malloc'ing");
-    malloc_string(tmp);
-    malloc_string(help_text);
-    malloc_string(title_of_window);
-    malloc_string(sz_res);
-    malloc_string(header_text);
     bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
     bkp_disklist = mr_malloc(sizeof(struct list_of_disks));
@@ -2762 +2821 @@
 
     iamhere("Post-malloc");
-    strcpy(help_text,
-           "   Edit this RAID device's list of partitions. Choose OK or Cancel when done.");
-    sprintf(header_text, "%-24s    %s", "Device", "Index");
-    sprintf(title_of_window, "%s contains...", raidrec->raid_device);
+    mr_asprintf(&help_text,
+           _
+           ("   Edit this RAID device's list of partitions. Choose OK or Cancel when done."));
+    mr_asprintf(&header_text, "%-24s    %s", _("Device"), _("Index"));
+    mr_asprintf(&title_of_window, _("%s contains..."), raidrec->raid_device);
     newtPushHelpLine(help_text);
+    mr_free(help_text);
+
     for (b_res = (newtComponent) 12345; b_res != bOK && b_res != bCancel;) {
         headerMsg = newtLabel(1, 1, header_text);
@@ -2773 +2835 @@
         redraw_disklist(disklist, keylist, partitionsListbox);
         i = 1;
-        bAdd = newtCompactButton(i, 9, " Add ");
-        bDelete = newtCompactButton(i += 8, 9, "Delete");
-        bOK = newtCompactButton(i += 9, 9, "  OK  ");
-        bCancel = newtCompactButton(i += 9, 9, "Cancel");
+        bAdd = newtCompactButton(i, 9, _(" Add "));
+        bDelete = newtCompactButton(i += 8, 9, _("Delete"));
+        bOK = newtCompactButton(i += 9, 9, _("  OK  "));
+        bCancel = newtCompactButton(i += 9, 9, _("Cancel"));
         newtOpenWindow(21, 7, 38, 10, title_of_window);
         myForm = newtForm(NULL, NULL, 0);
@@ -2788 +2850 @@
         b_res = newtRunForm(myForm);
         if (b_res == bOK || b_res == bCancel) { /* do nothing */
-// That's OK. At the end of this subroutine (after this do/while loop),
-// we'll throw away the changes if Cancel was pushed.
+            // That's OK. At the end of this subroutine (after this do/while loop),
+            // we'll throw away the changes if Cancel was pushed.
         } else {
             curr_choice = newtListboxGetCurrent(partitionsListbox);
@@ -2795 +2857 @@
                  i++);
             if (i == disklist->entries && disklist->entries > 0) {
-                log_to_screen("I don't know what that button does!");
+                log_to_screen(_("I don't know what that button does!"));
             } else {
                 currline = i;
                 if (b_res == bAdd) {
-                    log_it("Making list of unallocated RAID slices");
+                    log_it(_("Making list of unallocated RAID slices"));
                     make_list_of_unallocated_raid_partitions
                         (unallocated_raid_partitions, mountlist_dontedit,
@@ -2805 +2867 @@
                     if (unallocated_raid_partitions->entries <= 0) {
                         popup_and_OK
-                            ("There are no unallocated partitions marked for RAID.");
+                            (_
+                             ("There are no unallocated partitions marked for RAID."));
                     } else {
                         log_it
-                            ("Done. The user may add one or more of the above to RAID device");
+                            (_
+                             ("Done. The user may add one or more of the above to RAID device"));
                         add_disklist_entry(disklist, raidrec->raid_device,
                                            unallocated_raid_partitions);
-                        log_it("I have finished adding a disklist entry.");
+                        log_it(_
+                               ("I have finished adding a disklist entry."));
                         redraw_disklist(disklist, keylist,
                                         partitionsListbox);
@@ -2820 +2885 @@
                     redraw_disklist(disklist, keylist, partitionsListbox);
                 } else {
-                    sprintf(tmp, "%s's index is %d. What should it be?",
+                    mr_asprintf(&tmp, _("%s's index is %d. What should it be?"),
                             raidrec->raid_device,
                             disklist->el[currline].index);
+                    malloc_string(sz_res);
                     sprintf(sz_res, "%d", disklist->el[currline].index);
-                    if (popup_and_get_string("Set index", tmp, sz_res, 10)) {
+                    if (popup_and_get_string
+                        (_("Set index"), tmp, sz_res, 10)) {
                         disklist->el[currline].index = atoi(sz_res);
                     }
+                    mr_free(tmp);
+                    mr_free(sz_res);
+
                     redraw_disklist(disklist, keylist, partitionsListbox);
                 }
@@ -2834 +2904 @@
         newtPopWindow();
     }
+    mr_free(title_of_window);
+    mr_free(header_text);
+
     newtPopHelpLine();
     if (b_res == bCancel) {
@@ -2843 +2916 @@
                sizeof(struct list_of_disks));
     }
-    mr_free(tmp);
-    mr_free(help_text);
-    mr_free(title_of_window);
-    mr_free(sz_res);
-    mr_free(header_text);
     mr_free(bkp_raidrec);
     mr_free(bkp_disklist);
@@ -2856 +2924 @@
 
 
-
 /**
  * Ask the user which restore mode (nuke, interactive, or compare) we should use.
@@ -2867 +2934 @@
   /** char *************************************************************/
     char output = '\0';
-    char tmp[MAX_STR_LEN];
+    char *tmp = NULL;
+    size_t n = 0;
 
   /** newt *************************************************************/
@@ -2881 +2949 @@
         for (output = 'z'; !strchr("AICE", output); output = tmp[0]) {
             printf
-                ("Which mode - (A)utomatic, (I)nteractive, \n(C)ompare only, or (E)xit to shell?\n--> ");
-            fgets(tmp, MAX_STR_LEN - 1, stdin);
-        }
+                (_
+                 ("Which mode - (A)utomatic, (I)nteractive, \n(C)ompare only, or (E)xit to shell?\n--> "));
+            mr_getline(&tmp, &n, stdin);
+        }
+        mr_free(tmp);
         return (output);
     }
 
     newtPushHelpLine
-        ("   Do you want to 'nuke' your system, restore interactively, or just compare?");
-    newtOpenWindow(24, 3, 32, 17, "How should I restore?");
-    b1 = newtButton(7, 1, "Automatically");
-    b2 = newtButton(7, 5, "Interactively");
-    b3 = newtButton(7, 9, "Compare only!");
-    b4 = newtButton(7, 13, "Exit to shell");
+        (_
+         ("   Do you want to 'nuke' your system, restore interactively, or just compare?"));
+    newtOpenWindow(24, 3, 32, 17, _("How should I restore?"));
+    b1 = newtButton(7, 1, _("Automatically"));
+    b2 = newtButton(7, 5, _("Interactively"));
+    b3 = newtButton(7, 9, _("Compare only!"));
+    b4 = newtButton(7, 13, _("Exit to shell"));
     myForm = newtForm(NULL, NULL, 0);
     newtFormAddComponents(myForm, b1, b2, b3, b4, NULL);