Changeset 2334 in MondoRescue for branches/2.2.10/mondo/src/mondorestore/mondo-rstr-newt.c

Timestamp:

Aug 18, 2009, 5:28:18 PM (15 years ago)

Author:

Bruno Cornec

Message:

r3369@localhost: bruno | 2009-08-18 16:57:27 +0200

• Transform bout 100 strcpy in dyn. allocation. Quality is improving
• function figure_out_kernel_path_interactively_if_necessary now return a dynamically allocated string
• mondoarchive checked with valgrind in text an newt modes

File:

• branches/2.2.10/mondo/src/mondorestore/mondo-rstr-newt.c (modified) (62 diffs)

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

@@ -78 +78 @@
     newtPushHelpLine
         ("   Add one of the following unallocated RAID partitions to this RAID device.");
-    mr_asprintf(&tmp, "%-26s %s", "Device", "Size");
+    mr_asprintf(tmp, "%-26s %s", "Device", "Size");
     headerMsg = newtLabel(1, 1, tmp);
     partitionsListbox =
@@ -104 +104 @@
 
             items = disklist->entries;
-            strcpy(disklist->el[items].device,
-                   unallocated_raid_partitions->el[currline].device);
+            strcpy(disklist->el[items].device, unallocated_raid_partitions->el[currline].device);
             disklist->el[items].index = index;
             disklist->entries = ++items;
@@ -154 +153 @@
 
     /** 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];
+    char *drive_to_add = NULL;
+    char *mountpoint_str = NULL;
+    char *size_str = NULL;
+    char *device_str = NULL;
+    char *format_str = NULL;
 
     /** pointers *********************************************************/
@@ -171 +170 @@
     assert(keylist != NULL);
 
-    strcpy(device_str, "/dev/");
-    strcpy(mountpoint_str, "/");
+    mr_asprintf(device_str, "/dev/");
+    mr_asprintf(mountpoint_str, "/");
+    mr_asprintf(size_str, "");
 #ifdef __FreeBSD__
-    strcpy(format_str, "ufs");
+    mr_asprintf(format_str, "ufs");
 #else
-    strcpy(format_str, "ext3");
+    mr_asprintf(format_str, "ext3");
 #endif
-    size_str[0] = '\0';
     newtOpenWindow(20, 5, 48, 10, "Add entry");
     label0 = newtLabel(2, 1, "Device:    ");
@@ -184 +183 @@
     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);
+    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  ");
@@ -201 +197 @@
     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, "%s", device_here);
+
+        mr_free(mountpoint_str);
+        mr_asprintf(mountpoint_str, "%s", mountpoint_here);
+        mr_strip_spaces(mountpoint_str);
+
+        mr_free(format_str);
+        mr_asprintf(format_str, "%s", format_here);
+        mr_strip_spaces(format_str);
+
+        mr_free(size_str);
+        mr_asprintf(size_str, "%s", size_here);
+        mr_strip_spaces(size_str);
+
         strip_spaces(device_str);
-        strip_spaces(mountpoint_str);
-        strip_spaces(format_str);
-        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] == '/') {
@@ -216 +218 @@
                 b_res = NULL;
             }
-            if (size_of_specific_device_in_mountlist(mountlist, device_str)
-                >= 0) {
+            if (size_of_specific_device_in_mountlist(mountlist, device_str) >= 0) {
                 popup_and_OK("Can't add this - you've got one already!");
                 b_res = NULL;
@@ -229 +230 @@
         return;
     }
-    strcpy(drive_to_add, device_str);
+    mr_asprintf(drive_to_add, "%s", 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) * 1024L;
+    mr_free(size_str);
+
     mountlist->entries++;
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
-        initiate_new_raidlist_entry(raidlist, mountlist, currline,
-                                    device_str);
-    }
+        initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str);
+    }
+    mr_free(device_str);
+
     redraw_mountlist(mountlist, keylist, listbox);
 }
@@ -316 +325 @@
     /** buffers ***********************************************************/
     char tmp = NULL;
-
-
-
+    char *devname = NULL;
 
     for (i = 0;
@@ -324 +331 @@
          && strcmp(raidlist->el[i].volname, basename(raid_device)); i++);
     if (i == raidlist->entries) {
-        mr_asprintf(&tmp, "Cannot calc size of raid device %s - cannot find it in raidlist", raid_device);
-        log_it(tmp);
-        mr_free(tmp);
+        log_it("Cannot calc size of raid device %s - cannot find it in raidlist", raid_device);
         return (0);             // Isn't this more sensible than 999999999? If the raid dev !exists,
         // then it has no size, right?
@@ -338 +343 @@
         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, "%s", raidrec->plex[j].sd[k].which_device);
             for (l = 0; l < raidlist->disks.entries; ++l) {
                 if (!strcmp(devname, raidlist->disks.el[l].name)) {
@@ -367 +371 @@
                 }
             }
+            mr_free(devname);
         }
 
@@ -387 +392 @@
     }
 
-    mr_asprintf(&tmp, "I have calculated %s's real size to be %ld", raid_device, (long) smallest_plex);
-    log_it(tmp);
-    mr_free(tmp);
+    log_it("I have calculated %s's real size to be %ld", raid_device, (long) smallest_plex);
     return (smallest_plex);
 #else
@@ -406 +409 @@
     long sp = 0;
 
-    /** buffers ***********************************************************/
-    char tmp = NULL;
-
     assert(mountlist != NULL);
     assert(raidlist != NULL);
@@ -417 +417 @@
          && strcmp(raidlist->el[i].raid_device, raid_device); i++);
     if (i == raidlist->entries) {
-        mr_asprintf(&tmp, "Cannot calc size of raid device %s - cannot find it in raidlist", raid_device);
-        log_it(tmp);
-        mr_free(tmp);
+        log_it("Cannot calc size of raid device %s - cannot find it in raidlist", raid_device);
         return (999999999);
     }
@@ -442 +440 @@
         total_size = smallest_partition * (noof_partitions - 1);
     }
-    mr_asprintf(&tmp, "I have calculated %s's real size to be %ld", raid_device, (long) total_size);
-    log_it(tmp);
-    mr_free(tmp);
+    log_it("I have calculated %s's real size to be %ld", raid_device, (long) total_size);
     return (total_size);
 #endif
@@ -499 +495 @@
             }
             p[i] = '\0';
-            mr_free(sz);
         }
         if (!strcmp(p, "concat")) {
@@ -568 +563 @@
             }
             p[i] = '\0';
-            mr_free(sz);
         }
         if (!strcmp(p, "linear")) {
@@ -613 +607 @@
 
     /** buffers ***********************************************************/
-    char *tmp = NULL;
-
     assert(mountlist != NULL);
     assert(raidlist != NULL);
@@ -625 +617 @@
              pos++);
         if (pos < mountlist->entries) {
-            mr_asprintf(&tmp, "Deleting partition %s cos it was part of a now-defunct RAID", mountlist->el[pos].device);
-            log_it(tmp);
-            mr_free(tmp);
+            log_it("Deleting partition %s cos it was part of a now-defunct RAID", mountlist->el[pos].device);
 
             memcpy((void *) &mountlist->el[pos],
@@ -662 +652 @@
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
 
-    mr_asprintf(&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);
     res = ask_me_yes_or_no(tmp);
     mr_free(tmp);
@@ -699 +689 @@
     /** buffers ***********************************************************/
     char *tmp = NULL;
-    char device[MAX_STR_LEN];
+    char *device = NULL;
 
 
@@ -707 +697 @@
     assert(keylist != NULL);
 
-    /* BERLIOS: Why isn't device initialized here ? what is expected */
-    pos =
-        which_raid_device_is_using_this_partition(raidlist,
-                                                  mountlist->el[currline].
-                                                  device);
+    pos = which_raid_device_is_using_this_partition(raidlist, mountlist->el[currline].device);
     if (pos >= 0) {
-        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));
+        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;
     }
-    mr_asprintf(&tmp, "Delete %s - are you sure?", mountlist->el[currline].device);
+    mr_asprintf(tmp, "Delete %s - are you sure?", mountlist->el[currline].device);
     res = ask_me_yes_or_no(tmp);
     mr_free(tmp);
@@ -726 +712 @@
     }
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
-        strcpy(device, mountlist->el[currline].device);
+        mr_asprintf(device, "%s", mountlist->el[currline].device);
         delete_raidlist_entry(mountlist, raidlist, device);
         for (currline = 0;
@@ -732 +718 @@
              && strcmp(mountlist->el[currline].device, device);
              currline++);
+        mr_free(device);
+
         if (currline == mountlist->entries) {
             log_it("Dev is gone. I can't delete it. Ho-hum");
@@ -775 +763 @@
         return;
     }
-    mr_asprintf(&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) {
@@ -788 +776 @@
                     if (!strcmp(raidlist->el[i].plex[x].sd[y].which_device,
                                 raidlist->disks.el[z].name)) {
-                        strcpy(d.el[d.entries].name,
-                               raidlist->disks.el[z].name);
-                        strcpy(d.el[d.entries++].device,
-                               raidlist->disks.el[z].device);
+                        strcpy(d.el[d.entries].name, raidlist->disks.el[z].name);
+                        strcpy(d.el[d.entries++].device, raidlist->disks.el[z].device);
                     }
                 }
@@ -844 +830 @@
 
     av = &raidrec->additional_vars;
-    mr_asprintf(&tmp, "Delete %s - are you sure?", av->el[lino].label);
+    mr_asprintf(tmp, "Delete %s - are you sure?", av->el[lino].label);
     res = ask_me_yes_or_no(tmp);
     mr_free(tmp);
@@ -851 +837 @@
         if (!strcmp(av->el[lino].label, "persistent-superblock")
             || !strcmp(av->el[lino].label, "chunk-size")) {
-            mr_asprintf(&tmp, "%s must not be deleted. It would be bad.", av->el[lino].label);
+            mr_asprintf(tmp, "%s must not be deleted. It would be bad.", av->el[lino].label);
             popup_and_OK(tmp);
             mr_free(tmp);
@@ -920 +906 @@
                 if (!warned_already) {
                     warned_already = TRUE;
-                    mr_asprintf(&tmp1, "Too many lines. Displaying first %d entries only. Close a directory to see more.", ARBITRARY_MAXIMUM);
+                    mr_asprintf(tmp1, "Too many lines. Displaying first %d entries only. Close a directory to see more.", ARBITRARY_MAXIMUM);
                     popup_and_OK(tmp1);
                     mr_free(tmp1);
                 }
             } else {
-                strcpy(g_strings_of_flist_window[lines_in_flist_window],
-                       current_filename);
+                strcpy(g_strings_of_flist_window[lines_in_flist_window], current_filename);
                 g_is_path_selected[lines_in_flist_window] = node->selected;
                 lines_in_flist_window++;
@@ -941 +926 @@
                 (g_strings_of_flist_window[i],
                  g_strings_of_flist_window[i - 1]) < 0) {
-                mr_asprintf(&tmp1, g_strings_of_flist_window[i]);
-                strcpy(g_strings_of_flist_window[i],
-                       g_strings_of_flist_window[i - 1]);
+                mr_asprintf(tmp1, "%s", 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], tmp1);
                 mr_free(tmp1);
@@ -1048 +1032 @@
     void *curr_choice;
     void *keylist[ARBITRARY_MAXIMUM];
-
-    /** buffers ***********************************************************/
-    char *tmp = NULL;
 
     /** bool **************************************************************/
@@ -1098 +1079 @@
                 indexno = 0;
             }
-            mr_asprintf(&tmp, "You selected '%s'", g_strings_of_flist_window[indexno]);
-            log_it(tmp);
-            mr_free(tmp);
+            log_it("You selected '%s'", g_strings_of_flist_window[indexno]);
 
             if (b_res == bMore) {
@@ -1193 +1172 @@
 
   /** 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 *device_str = NULL;
+    char *mountpoint_str = NULL;
+    char *size_str = NULL;
+    char *format_str = NULL;
     char *tmp = NULL;
-    char device_used_to_be[MAX_STR_LEN];
-    char mountpt_used_to_be[MAX_STR_LEN];
+    char *device_used_to_be = NULL;
+    char *mountpt_used_to_be = NULL;
 
     /** pointers **********************************************************/
@@ -1217 +1196 @@
     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 / 1024L);
+    mr_asprintf(device_str, "%s", mountlist->el[currline].device);
+    mr_asprintf(device_used_to_be, "%s", mountlist->el[currline].device);
+    mr_asprintf(mountpoint_str, "%s", mountlist->el[currline].mountpoint);
+    mr_asprintf(mountpt_used_to_be, "%s", mountlist->el[currline].mountpoint);
+    mr_asprintf(format_str, "%s", mountlist->el[currline].format);
+    mr_asprintf(size_str, "%lld", mountlist->el[currline].size / 1024L);
     newtOpenWindow(20, 5, 48, 10, "Edit entry");
     label0 = newtLabel(2, 1, "Device:");
@@ -1228 +1207 @@
     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);
+    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);
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
         || !strcmp(mountlist->el[currline].mountpoint, "image")) {
@@ -1253 +1229 @@
     for (b_res = NULL; b_res != bOK && b_res != bCancel;) {
         b_res = newtRunForm(myForm);
-        strcpy(device_str, device_here);
-        strip_spaces(device_str);
-        strcpy(mountpoint_str, mountpoint_here);
-        strip_spaces(mountpoint_str);
-        strcpy(format_str, format_here);
-        strip_spaces(format_str);
+        mr_free(device_str);
+        mr_asprintf(device_str, "%s", device_here);
+        mr_strip_spaces(device_str);
+
+        mr_free(mountpoint_str);
+        mr_asprintf(mountpoint_str, "%s", mountpoint_here);
+        mr_strip_spaces(mountpoint_str);
+
+        mr_free(format_str);
+        mr_asprintf(format_str, "%s", 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)
@@ -1273 +1255 @@
         if (!strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
             && strcmp(mountlist->el[currline].mountpoint, "image")) {
-            strcpy(size_str, size_here);
-            strip_spaces(size_str);
+            mr_free(size_str);
+            mr_asprintf(size_str, "%s", size_here);
+            mr_strip_spaces(size_str);
         } else {
-            sprintf(size_str, "%ld",
-                    calculate_raid_device_size(mountlist, raidlist,
-                                               mountlist->el[currline].
-                                               device) / 1024);
+            mr_asprintf(size_str, "%ld", calculate_raid_device_size(mountlist, raidlist, mountlist->el[currline].device) / 1024);
             newtLabelSetText(sizeComp, size_str);
         }
@@ -1296 +1276 @@
                                                  device);
                 if (j < 0) {
-                    mr_asprintf(&tmp, "/etc/raidtab does not have an entry for %s; please delete it and add it again", mountlist->el[currline].device);
+                    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);
@@ -1310 +1290 @@
     newtPopHelpLine();
     newtPopWindow();
+    mr_free(mountpt_used_to_be);
+
     if (b_res == bCancel) {
         memcpy((void *) raidlist, (void *) &bkp_raidlist,
                sizeof(struct raidlist_itself));
+        mr_free(device_str);
+        mr_free(device_used_to_be);
+        mr_free(format_str);
+        mr_free(size_str);
         return;
     }
     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)) {
@@ -1327 +1317 @@
         }
     }
+    mr_free(size_str);
     newtListboxSetEntry(listbox, (long) keylist[currline],
                         mountlist_entry_to_string(mountlist, currline));
@@ -1332 +1323 @@
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
         && !strstr(device_used_to_be, RAID_DEVICE_STUB)) {
-        initiate_new_raidlist_entry(raidlist, mountlist, currline,
-                                    device_str);
+        initiate_new_raidlist_entry(raidlist, mountlist, currline, device_str);
     }
     /* if moving from RAID to non-RAID then do funky stuff */
@@ -1350 +1340 @@
 #ifndef __FreeBSD__             /* It works fine under FBSD. */
     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.");
+        popup_and_OK("You are renaming a RAID device as another RAID device. I don't like it but I'll allow it.");
     }
 #endif
+    mr_free(device_str);
+    mr_free(device_used_to_be);
+
     redraw_mountlist(mountlist, keylist, listbox);
 }
@@ -1376 +1368 @@
     for (i = 0; i < raidlist->disks.entries; ++i) {
         if (!strcmp(raidlist->disks.el[i].device, temp)) {
-            strcpy(raidrec->sd[raidrec->subdisks].which_device,
-                   raidlist->disks.el[i].name);
+            strcpy(raidrec->sd[raidrec->subdisks].which_device, raidlist->disks.el[i].name);
             found = TRUE;
         }
@@ -1494 +1485 @@
                 switch (raidrec->plex[i].raidlevel) {
                 case -1:
-                    mr_asprintf(&raidlevel, "concat");
+                    mr_asprintf(raidlevel, "concat");
                     break;
                 case 0:
-                    mr_asprintf(&raidlevel, "striped");
+                    mr_asprintf(raidlevel, "striped");
                     break;
                 case 5:
-                    mr_asprintf(&raidlevel, "raid5");
+                    mr_asprintf(raidlevel, "raid5");
                     break;
                 default:
-                    mr_asprintf(&raidlevel, "raid%i", raidrec->plex[i].raidlevel);
+                    mr_asprintf(raidlevel, "raid%i", raidrec->plex[i].raidlevel);
                     break;
                 }
 
                 if (raidrec->plex[i].raidlevel == -1) {
-                    mr_asprintf(&chunksize, "N/A");
+                    mr_asprintf(chunksize, "N/A");
                 } else {
-                    mr_asprintf(&chunksize, "%dk", raidrec->plex[i].stripesize);
+                    mr_asprintf(chunksize, "%dk", raidrec->plex[i].stripesize);
                 }
                 snprintf(pname, 64, "%s.p%i", raidrec->volname, i);
@@ -1540 +1531 @@
 
         if (b_res == bDelete) {
-            mr_asprintf(&msg, "Are you sure you want to delete %s.p%i?", raidrec->volname, currline2);
+            mr_asprintf(msg, "Are you sure you want to delete %s.p%i?", raidrec->volname, currline2);
             res = ask_me_yes_or_no(msg);
             mr_free(msg);
@@ -1578 +1569 @@
     /** buffers ***********************************************************/
     char *title_of_editraidForm_window;
-    char *sz_raid_level;
+    char *sz_raid_level = NULL;
     char *sz_data_disks = NULL;
     char *sz_spare_disks = NULL;
@@ -1600 +1591 @@
     assert(raidrec != NULL);
 
-    malloc_string(title_of_editraidForm_window);
-    malloc_string(sz_raid_level);
-
     bkp_raidrec = mr_malloc(sizeof(struct raid_device_record));
     log_it("Started edit_raidlist_entry");
 
     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, "%s", raidrec->raid_device);
     log_msg(2, "Opening newt window");
     newtOpenWindow(20, 5, 40, 14, title_of_editraidForm_window);
     for (;;) {
         log_msg(2, "Main loop");
-        sprintf(title_of_editraidForm_window, "Edit %s",
-                raidrec->raid_device);
-        strcpy(sz_raid_level,
-               turn_raid_level_number_to_string(raidrec->raid_level));
+        mr_free(title_of_editraidForm_window);
+        mr_asprintf(title_of_editraidForm_window, "Edit %s", raidrec->raid_device);
+        mr_asprintf(sz_raid_level, "%s", turn_raid_level_number_to_string(raidrec->raid_level));
         /* Those 4 strings are allocated by the function  */
         sz_data_disks = number_of_disks_as_string(raidrec->data_disks.entries, "data");
@@ -1666 +1653 @@
     newtPopWindow();
     mountlist->el[currline].size = calculate_raid_device_size(mountlist, raidlist, raidrec->raid_device);
-    paranoid_free(title_of_editraidForm_window);
-    paranoid_free(sz_raid_level);
+    mr_free(title_of_editraidForm_window);
+    mr_free(sz_raid_level);
     paranoid_free(bkp_raidrec);
 #endif
@@ -1715 +1702 @@
 
     char *p = NULL;
+    char *tmp = NULL;
+    char *entry = NULL;
 
     struct mountlist_itself *unallocparts;
@@ -1730 +1719 @@
     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 ");
         sLevel = newtLabel(19, 2, tmp);
+        mr_free(tmp);
 
         if (raidrec->raidlevel >= 0) {
-            sprintf(tmp, "%ik", raidrec->stripesize);
+            mr_asprintf(tmp, "%ik", raidrec->stripesize);
             bStripeSize = newtCompactButton(2, 4, " Stripe size ");
         } else {
-            strcpy(tmp, "N/A");
+            mr_asprintf(tmp, "N/A");
             bStripeSize = newtLabel(2, 4, "Stripe size:");
         }
         sStripeSize = newtLabel(19, 4, tmp);
+        mr_free(tmp);
 
         bOK = newtCompactButton(2, 16, "  OK  ");
@@ -1768 +1755 @@
 
 
-        //  plexesListbox = newtListbox (2, 7, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
-        //  plexesHeader  = newtLabel (2, 6, headerstr);
         unallocListbox =
             newtListbox(2, 7, 7, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
@@ -1785 +1770 @@
                                                  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",
-                         find_dev_entry_for_raid_device_name(raidlist,
-                                                             raidrec->
-                                                             sd[i].
-                                                             which_device));
+                mr_asprintf(entry, "%-17s", find_dev_entry_for_raid_device_name(raidlist, raidrec->sd[i].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);
             }
         }
@@ -1848 +1829 @@
             choose_raid_level(raidrec);
         } else if (b_res == bStripeSize) {
-            char *tmp = NULL;
-
             mr_asprintf(tmp, "%i", raidrec->stripesize);
             p = popup_and_get_string("Stripe size", "Please enter the stripe size in kilobytes.", tmp);
@@ -1973 +1952 @@
     bCancel = newtCompactButton(i += 12, 17, "Cancel");
     bOK = newtCompactButton(i += 12, 17, "  OK  ");
-    mr_asprintf(&tmp, "%-24s %-24s %-8s  %s", "Device", "Mountpoint", "Format", "Size (MB)");
+    mr_asprintf(tmp, "%-24s %-24s %-8s  %s", "Device", "Mountpoint", "Format", "Size (MB)");
     headerMsg = newtLabel(2, 1, tmp);
     flawsLabelA = newtLabel(2, 13, flaws_str_A);
@@ -2238 +2217 @@
 #ifdef __FreeBSD__
     for (i = 0; i < raidlist->entries; i++) {
-        mr_asprintf(&vdev, "/dev/vinum/%s", raidlist->el[i].volname);
+        mr_asprintf(vdev, "/dev/vinum/%s", raidlist->el[i].volname);
         res = strcmp(device, vdev);
         mr_free(vdev);
@@ -2365 +2344 @@
     raidrec = &raidlist->el[pos_in_raidlist];
     initialize_raidrec(raidrec);
-    strcpy(raidrec->OSSWAP(raid_device, volname),
-           OSSWAP(device, basename(device)));
+    strcpy(raidrec->OSSWAP(raid_device, volname), OSSWAP(device, basename(device)));
 #ifndef __FreeBSD__
     choose_raid_level(raidrec);
@@ -2618 +2596 @@
                                                    char *new_dev)
 {
-    /** buffers ********************************************************/
-    char *tmp = NULL;
-
     /** int ************************************************************/
     int pos = 0;
@@ -2631 +2606 @@
     pos = which_raid_device_is_using_this_partition(raidlist, old_dev);
     if (pos < 0) {
-        mr_asprintf(&tmp, "No need to rejig %s in raidlist: it's not listed.", old_dev);
-        log_it(tmp);
-        mr_free(tmp);
+        log_it("No need to rejig %s in raidlist: it's not listed.", old_dev);
     } else {
         if ((j =
@@ -2639 +2612 @@
                                          OSSWAP(el[pos].data_disks, disks),
                                          old_dev)) >= 0) {
-            strcpy(raidlist->OSSWAP(el[pos].data_disks, disks).el[j].
-                   device, new_dev);
+            strcpy(raidlist->OSSWAP(el[pos].data_disks, disks).el[j].device, new_dev);
         } else
             if ((j =
@@ -2647 +2619 @@
                                                     spares),
                                              old_dev)) >= 0) {
-            strcpy(raidlist->OSSWAP(el[pos].spare_disks, spares).el[j].
-                   device, new_dev);
+            strcpy(raidlist->OSSWAP(el[pos].spare_disks, spares).el[j].device, new_dev);
         }
 #ifndef __FreeBSD__
@@ -2665 +2636 @@
 #endif
         else {
-            mr_asprintf(&tmp, "%s is supposed to be listed in this raid dev but it's not...", old_dev);
-            log_it(tmp);
-            mr_free(tmp);
+            log_it("%s is supposed to be listed in this raid dev but it's not...", old_dev);
         }
     }