Changeset 900 in MondoRescue for trunk/mondo/src/mondorestore/mondo-rstr-newt.c

Timestamp:

Oct 24, 2006, 8:49:18 AM (18 years ago)

Author:

Bruno Cornec

Message:

Huge patch to introduce low level functions that will bw used everywhere (mr_free, mr_asprintf, ...)
Nearly linking now due to that.

File:

• trunk/mondo/src/mondorestore/mondo-rstr-newt.c (modified) (74 diffs)

trunk/mondo/src/mondorestore/mondo-rstr-newt.c

@@ -16 +16 @@
 
 #include "mondo-rstr-newt.h"
+#include "mr_mem.h"
 
 /**
@@ -78 +79 @@
         (_
          ("   Add one of the following unallocated RAID partitions to this RAID device."));
-    asprintf(&tmp, "%-26s %s", _("Device"), _("Size"));
+    mr_asprintf(&tmp, "%-26s %s", _("Device"), _("Size"));
     headerMsg = newtLabel(1, 1, tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     partitionsListbox =
@@ -167 +168 @@
     assert(keylist != NULL);
 
-    asprintf(&device_str, "/dev/");
-    asprintf(&mountpoint_str, "/");
+    mr_asprintf(&device_str, "/dev/");
+    mr_asprintf(&mountpoint_str, "/");
 #ifdef __FreeBSD__
-    asprintf(&format_str, "ufs");
+    mr_asprintf(&format_str, "ufs");
 #else
-    asprintf(&format_str, "ext2");
+    mr_asprintf(&format_str, "ext2");
 #endif
     newtOpenWindow(20, 5, 48, 10, _("Add entry"));
@@ -199 +200 @@
         b_res = newtRunForm(myForm);
 
-        paranoid_free(device_str);
-        asprintf(&device_str, device_here);
+        mr_free(device_str);
+        mr_asprintf(&device_str, device_here);
         strip_spaces(device_str);
 
-        paranoid_free(format_str);
-        asprintf(&format_str, format_here);
+        mr_free(format_str);
+        mr_asprintf(&format_str, format_here);
         strip_spaces(format_str);
 
-        paranoid_free(mountpoint_str);
-        asprintf(&mountpoint_str, mountpoint_here);
+        mr_free(mountpoint_str);
+        mr_asprintf(&mountpoint_str, mountpoint_here);
         strip_spaces(mountpoint_str);
 
-        paranoid_free(size_str);
-        asprintf(&size_str, size_here);
+        mr_free(size_str);
+        mr_asprintf(&size_str, size_here);
         strip_spaces(size_str);
 
@@ -234 +235 @@
         return;
     }
-    asprintf(&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';
-    paranoid_free(drive_to_add);
+    mr_free(drive_to_add);
 
     currline = mountlist->entries;
     strcpy(mountlist->el[currline].device, device_str);
     strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
-    paranoid_free(mountpoint_str);
+    mr_free(mountpoint_str);
 
     strcpy(mountlist->el[currline].format, format_str);
-    paranoid_free(format_str);
+    mr_free(format_str);
 
     mountlist->el[currline].size = atol(size_str) * 1024;
-    paranoid_free(size_str);
+    mr_free(size_str);
 
     mountlist->entries++;
@@ -256 +257 @@
                                     device_str);
     }
-    paranoid_free(device_str);
+    mr_free(device_str);
     redraw_mountlist(mountlist, keylist, listbox);
 }
@@ -296 +297 @@
         }
     }
-    paranoid_free(sz_out);
+    mr_free(sz_out);
 }
 #endif
@@ -335 +336 @@
          && strcmp(raidlist->el[i].volname, basename(raid_device)); i++);
     if (i == raidlist->entries) {
-        asprintf(&tmp,
+        mr_asprintf(&tmp,
                  "Cannot calc size of raid device %s - cannot find it in raidlist",
                  raid_device);
         log_it(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         return (0);             // Isn't this more sensible than 999999999? If the raid dev !exists,
         // then it has no size, right?
@@ -351 +352 @@
         int k = 0, l = 0;
         for (k = 0; k < raidrec->plex[j].subdisks; ++k) {
-            asprintf(&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)) {
@@ -379 +380 @@
                 }
             }
-            paranoid_free(devname);
+            mr_free(devname);
         }
 
@@ -400 +401 @@
     }
 
-    asprintf(&tmp, "I have calculated %s's real size to be %ld",
+    mr_asprintf(&tmp, "I have calculated %s's real size to be %ld",
              raid_device, (long) smallest_plex);
     log_it(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
     return (smallest_plex);
 #else
@@ -431 +432 @@
          && strcmp(raidlist->el[i].raid_device, raid_device); i++);
     if (i == raidlist->entries) {
-        asprintf(&tmp,
+        mr_asprintf(&tmp,
                  "Cannot calc size of raid device %s - cannot find it in raidlist",
                  raid_device);
         log_it(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         return (999999999);
     }
@@ -458 +459 @@
         total_size = smallest_partition * (noof_partitions - 1);
     }
-    asprintf(&tmp, "I have calculated %s's real size to be %ld",
+    mr_asprintf(&tmp, "I have calculated %s's real size to be %ld",
              raid_device, (long) total_size);
     log_it(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
     return (total_size);
 #endif
@@ -487 +488 @@
     char *sz = NULL;
 
-    asprintf(&prompt,
+    mr_asprintf(&prompt,
              _
              ("Please enter the RAID level you want. (concat, striped, raid5)"));
     if (raidrec->raidlevel == -1) {
-        asprintf(&tmp, "concat");
+        mr_asprintf(&tmp, "concat");
     } else if (raidrec->raidlevel == 0) {
-        asprintf(&tmp, "striped");
+        mr_asprintf(&tmp, "striped");
     } else {
-        asprintf(&tmp, "raid%i", raidrec->raidlevel);
+        mr_asprintf(&tmp, "raid%i", raidrec->raidlevel);
     }
     for (out = 999; out == 999;) {
@@ -504 +505 @@
         /* BERLIOS: Useless ??? 
         if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
-            asprintf(&sz, tmp);
+            mr_asprintf(&sz, tmp);
             strncpy(tmp, sz + 1, strlen(sz) - 2);
             tmp[strlen(sz) - 2] = '\0';
-            paranoid_free(sz);
+            mr_free(sz);
         }
         */
@@ -518 +519 @@
         }
         log_it(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         if (is_this_raid_personality_registered(out)) {
             log_it
@@ -530 +531 @@
         }
     }
-    paranoid_free(prompt);
+    mr_free(prompt);
     raidrec->raidlevel = out;
 #else
@@ -544 +545 @@
         ("grep Pers /proc/mdstat > /tmp/raid-personalities.txt 2> /dev/null");
     personalities = last_line_of_file("/tmp/raid-personalities.txt");
-    asprintf(&prompt, _("Please enter the RAID level you want. %s"),
+    mr_asprintf(&prompt, _("Please enter the RAID level you want. %s"),
              personalities);
-    paranoid_free(personalities);
+    mr_free(personalities);
 
     if (raidrec->raid_level == -1) {
-        asprintf(&tmp, "linear");
+        mr_asprintf(&tmp, "linear");
     } else {
-        asprintf(&tmp, "%d", raidrec->raid_level);
+        mr_asprintf(&tmp, "%d", raidrec->raid_level);
     }
     for (out = 999;
@@ -563 +564 @@
         /* BERLIOS: Useless ???
         if (tmp[0] == '[' && tmp[strlen(tmp) - 1] == ']') {
-            asprintf(&sz, tmp);
-            paranoid_free(tmp);
-
-            asprintf(&tmp, sz + 1);
+            mr_asprintf(&sz, tmp);
+            mr_free(tmp);
+
+            mr_asprintf(&tmp, sz + 1);
             tmp[strlen(sz) - 2] = '\0';
-            paranoid_free(sz);
+            mr_free(sz);
         }
         */
@@ -591 +592 @@
         }
     }
-    paranoid_free(tmp);
-    paranoid_free(prompt);
+    mr_free(tmp);
+    mr_free(prompt);
     raidrec->raid_level = out;
 #endif
@@ -659 +660 @@
     assert_string_is_neither_NULL_nor_zerolength(raid_device);
 
-    asprintf(&tmp, _("Delete %s from RAID device %s - are you sure?"),
+    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)) {
-        paranoid_free(tmp);
+        mr_free(tmp);
         return;
     }
-    paranoid_free(tmp);
+    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)); */
@@ -707 +708 @@
                                                   device);
     if (pos >= 0) {
-        asprintf(&tmp,
+        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);
-        paranoid_free(tmp);
+        mr_free(tmp);
         return;
     }
-    asprintf(&tmp, _("Delete %s - are you sure?"),
+    mr_asprintf(&tmp, _("Delete %s - are you sure?"),
              mountlist->el[currline].device);
     if (!ask_me_yes_or_no(tmp)) {
-        paranoid_free(tmp);
+        mr_free(tmp);
         return;
     }
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)) {
-        asprintf(&device, mountlist->el[currline].device);
+        mr_asprintf(&device, mountlist->el[currline].device);
         delete_raidlist_entry(mountlist, raidlist, device);
         for (currline = 0;
@@ -732 +733 @@
             if (currline == mountlist->entries) {
                 log_it("Dev is gone. I can't delete it. Ho-hum");
-                paranoid_free(device);
+                mr_free(device);
                 return;
             }
-        paranoid_free(device);
+        mr_free(device);
     }
     memcpy((void *) &mountlist->el[currline],
@@ -775 +776 @@
         return;
     }
-    asprintf(&tmp,
+    mr_asprintf(&tmp,
              _("Do you want me to delete %s's partitions, too?"), device);
     delete_partitions_too = ask_me_yes_or_no(tmp);
@@ -820 +821 @@
         items--;
     }
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     raidlist->entries = items;
@@ -845 +846 @@
 
     av = &raidrec->additional_vars;
-    asprintf(&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")) {
-            paranoid_free(tmp);
-            asprintf(&tmp, _("%s must not be deleted. It would be bad."),
+            mr_free(tmp);
+            mr_asprintf(&tmp, _("%s must not be deleted. It would be bad."),
                      av->el[lino].label);
             popup_and_OK(tmp);
         } else {
-            paranoid_free(av->el[lino].label);
-            paranoid_free(av->el[lino].value);
+            mr_free(av->el[lino].label);
+            mr_free(av->el[lino].value);
             memcpy((void *) &av->el[lino], (void *) &av->el[av->entries--],
                    sizeof(struct raid_var_line));
@@ -864 +865 @@
         }
     }
-    paranoid_free(tmp);
+    mr_free(tmp);
 }
 #endif
@@ -924 +925 @@
                 if (!warned_already) {
                     warned_already = TRUE;
-                    asprintf(&tmp,
+                    mr_asprintf(&tmp,
                              _
                              ("Too many lines. Displaying first %d entries only. Close a directory to see more."),
                              ARBITRARY_MAXIMUM);
                     popup_and_OK(tmp);
-                    paranoid_free(tmp);
+                    mr_free(tmp);
                 }
             } else {
@@ -948 +949 @@
                 (g_strings_of_flist_window[i],
                  g_strings_of_flist_window[i - 1]) < 0) {
-                asprintf(&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);
-                paranoid_free(tmp);
+                mr_free(tmp);
 
                 dummybool = g_is_path_selected[i];
@@ -963 +964 @@
         newtListboxClear(listbox);
         for (i = 0; i < lines_in_flist_window; i++) {
-            asprintf(&tmp, "%c%c %-80s",
+            mr_asprintf(&tmp, "%c%c %-80s",
                      (g_is_path_selected[i] ? '*' : ' '),
                      (g_is_path_expanded[i] ? '+' : '-'),
@@ -973 +974 @@
             keylist[i] = (void *) i;
             newtListboxAppendEntry(listbox, tmp, keylist[i]);
-            paranoid_free(tmp);
+            mr_free(tmp);
         }
         return (lines_in_flist_window);
@@ -1223 +1224 @@
     memcpy((void *) &bkp_raidlist, (void *) raidlist,
            sizeof(struct raidlist_itself));
-    asprintf(&device_str, mountlist->el[currline].device);
-    asprintf(&device_used_to_be, mountlist->el[currline].device);
-    asprintf(&mountpoint_str, mountlist->el[currline].mountpoint);
-    asprintf(&mountpt_used_to_be, mountlist->el[currline].mountpoint);
-    asprintf(&format_str, mountlist->el[currline].format);
-    asprintf(&size_str, "%lld", mountlist->el[currline].size / 1024);
+    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");
@@ -1237 +1238 @@
     deviceComp =
         newtEntry(14, 1, device_str, 30, (void *) &device_here, 0);
-    paranoid_free(device_str);
+    mr_free(device_str);
 
     mountpointComp =
         newtEntry(14, 2, mountpoint_str, 30, (void *) &mountpoint_here, 0);
-    paranoid_free(mountpoint_str);
+    mr_free(mountpoint_str);
 
     formatComp =
         newtEntry(14, 4, format_str, 15, (void *) &format_here, 0);
-    paranoid_free(format_str);
+    mr_free(format_str);
 
     if (strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
@@ -1253 +1254 @@
         sizeComp = newtEntry(14, 3, size_str, 10, (void *) &size_here, 0);
     }
-    paranoid_free(size_str);
+    mr_free(size_str);
 
     bOK = newtButton(2, 6, _("  OK  "));
@@ -1270 +1271 @@
         b_res = newtRunForm(myForm);
 
-        paranoid_free(device_str);
-        asprintf(&device_str, device_here);
+        mr_free(device_str);
+        mr_asprintf(&device_str, device_here);
         strip_spaces(device_str);
 
-        paranoid_free(mountpoint_str);
-        asprintf(&mountpoint_str, mountpoint_here);
+        mr_free(mountpoint_str);
+        mr_asprintf(&mountpoint_str, mountpoint_here);
         strip_spaces(mountpoint_str);
 
-        paranoid_free(format_str);
-        asprintf(&format_str, format_here);
-        paranoid_free(format_here);
+        mr_free(format_str);
+        mr_asprintf(&format_str, format_here);
+        mr_free(format_here);
         strip_spaces(format_str);
         if (b_res == bOK && strstr(device_str, RAID_DEVICE_STUB)
@@ -1295 +1296 @@
             continue;
         }
-        paranoid_free(mountpt_used_to_be);
+        mr_free(mountpt_used_to_be);
 
         if (!strstr(mountlist->el[currline].device, RAID_DEVICE_STUB)
             && strcmp(mountlist->el[currline].mountpoint, "image")) {
-            asprintf(&size_str, size_here);
+            mr_asprintf(&size_str, size_here);
             strip_spaces(size_str);
         } else {
-            asprintf(&size_str, "%ld",
+            mr_asprintf(&size_str, "%ld",
                     calculate_raid_device_size(mountlist, raidlist,
                                                mountlist->el[currline].
@@ -1308 +1309 @@
             newtLabelSetText(sizeComp, size_str);
         }
-        paranoid_free(size_here);
+        mr_free(size_here);
 
         /* do not let user click RAID button if user has changed device_str */
@@ -1325 +1326 @@
                                                  device);
                 if (j < 0) {
-                    asprintf(&tmp,
+                    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);
-                    paranoid_free(tmp);
+                    mr_free(tmp);
                 } else {
                     log_it(_("edit_raidlist_entry - calling"));
@@ -1339 +1340 @@
         }
     }
-    paranoid_free(device_here);
-    paranoid_free(mountpoint_here);
+    mr_free(device_here);
+    mr_free(mountpoint_here);
 
     newtFormDestroy(myForm);
@@ -1352 +1353 @@
     strcpy(mountlist->el[currline].device, device_str);
     strcpy(mountlist->el[currline].mountpoint, mountpoint_str);
-    paranoid_free(mountpoint_str);
+    mr_free(mountpoint_str);
 
     strcpy(mountlist->el[currline].format, format_str);
-    paranoid_free(format_str);
+    mr_free(format_str);
 
     if (strcmp(mountlist->el[currline].mountpoint, "image")) {
@@ -1366 +1367 @@
         }
     }
-    paranoid_free(size_str);
+    mr_free(size_str);
 
     newtListboxSetEntry(listbox, (long) keylist[currline],
@@ -1397 +1398 @@
 #endif
     redraw_mountlist(mountlist, keylist, listbox);
-    paranoid_free(device_str);
-    paranoid_free(device_used_to_be);
+    mr_free(device_str);
+    mr_free(device_used_to_be);
 }
 
@@ -1516 +1517 @@
     memcpy((void *) &bkp_raidrec, (void *) raidrec,
            sizeof(struct vinum_volume));
-    asprintf(&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"));
     newtOpenWindow(13, 5, 54, 15, title_of_editraidForm_window);
-    paranoid_free(title_of_editraidForm_window);
+    mr_free(title_of_editraidForm_window);
 
     for (;;) {
-        asprintf(&headerstr, "%-14s %-8s  %11s  %8s", _("Plex"), _("Level",) _("Stripe Size"), _("Subdisks"));
+        mr_asprintf(&headerstr, "%-14s %-8s  %11s  %8s", _("Plex"), _("Level",) _("Stripe Size"), _("Subdisks"));
 
         bOK = newtCompactButton(2, 13, _("  OK  "));
@@ -1534 +1535 @@
             newtListbox(2, 3, 9, NEWT_FLAG_SCROLL | NEWT_FLAG_RETURNEXIT);
         plexesHeader = newtLabel(2, 2, headerstr);
-        paranoid_free(headerstr);
+        mr_free(headerstr);
 
         editraidForm = newtForm(NULL, NULL, 0);
@@ -1544 +1545 @@
                 switch (raidrec->plex[i].raidlevel) {
                 case -1:
-                    asprintf(&raidlevel, "concat");
+                    mr_asprintf(&raidlevel, "concat");
                     break;
                 case 0:
-                    asprintf(&raidlevel, "striped");
+                    mr_asprintf(&raidlevel, "striped");
                     break;
                 case 5:
-                    asprintf(&raidlevel, "raid5");
+                    mr_asprintf(&raidlevel, "raid5");
                     break;
                 default:
-                    asprintf(&raidlevel, "raid%i",
+                    mr_asprintf(&raidlevel, "raid%i",
                             raidrec->plex[i].raidlevel);
                     break;
@@ -1559 +1560 @@
 
                 if (raidrec->plex[i].raidlevel == -1) {
-                    asprintf(&chunksize, "N/A");
+                    mr_asprintf(&chunksize, "N/A");
                 } else {
-                    asprintf(&chunksize, "%dk", raidrec->plex[i].stripesize);
+                    mr_asprintf(&chunksize, "%dk", raidrec->plex[i].stripesize);
                 }
-                asprintf(&pname, "%s.p%i", raidrec->volname, i);
-                asprintf(&entry, "%-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);
-                paranoid_free(pname);
-                paranoid_free(chunksize);
-                paranoid_free(raidlevel);
+                mr_free(pname);
+                mr_free(chunksize);
+                mr_free(raidlevel);
                 newtListboxAppendEntry(plexesListbox, entry, keylist[i]);
-                paranoid_free(entry);
+                mr_free(entry);
             }
         }
@@ -1592 +1593 @@
 
         if (b_res == bDelete) {
-            asprintf(&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)) {
@@ -1601 +1602 @@
                 raidrec->plexes--;
             }
-            paranoid_free(msg);
+            mr_free(msg);
             continue;
         }
@@ -1659 +1660 @@
     memcpy((void *) bkp_raidrec, (void *) raidrec,
            sizeof(struct raid_device_record));
-    asprintf(&title_of_editraidForm_window, _("Edit %s"), raidrec->raid_device);
+    mr_asprintf(&title_of_editraidForm_window, _("Edit %s"), raidrec->raid_device);
     log_msg(2, "Opening newt window");
     newtOpenWindow(20, 5, 40, 14, title_of_editraidForm_window);
-    paranoid_free(title_of_editraidForm_window);
+    mr_free(title_of_editraidForm_window);
 
     for (;;) {
         log_msg(2, "Main loop");
-        asprintf(&sz_raid_level,
+        mr_asprintf(&sz_raid_level,
                turn_raid_level_number_to_string(raidrec->raid_level));
-        asprintf(&sz_data_disks,
+        mr_asprintf(&sz_data_disks,
                number_of_disks_as_string(raidrec->data_disks.entries,
                                          _("data")));
-        asprintf(&sz_spare_disks,
+        mr_asprintf(&sz_spare_disks,
                number_of_disks_as_string(raidrec->spare_disks.entries,
                                          _("spare")));
-        asprintf(&sz_parity_disks,
+        mr_asprintf(&sz_parity_disks,
                number_of_disks_as_string(raidrec->parity_disks.entries,
                                          _("parity")));
-        asprintf(&sz_failed_disks,
+        mr_asprintf(&sz_failed_disks,
                number_of_disks_as_string(raidrec->failed_disks.entries,
                                          _("failed")));
@@ -1685 +1686 @@
         bSelectFailed = newtButton(20, 5, sz_failed_disks);
         bChangeRaid = newtButton(1, 9, sz_raid_level);
-        paranoid_free(sz_raid_level);
-        paranoid_free(sz_data_disks);
-        paranoid_free(sz_spare_disks);
-        paranoid_free(sz_parity_disks);
-        paranoid_free(sz_failed_disks);
+        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  "));
@@ -1735 +1736 @@
         calculate_raid_device_size(mountlist, raidlist,
                                    raidrec->raid_device);
-    paranoid_free(bkp_raidrec);
+    mr_free(bkp_raidrec);
 #endif
 }
@@ -1792 +1793 @@
     memcpy((void *) &bkp_raidrec, (void *) raidrec,
            sizeof(struct vinum_plex));
-    asprintf(&title_of_editraidForm_window, "%s.p%i",
+    mr_asprintf(&title_of_editraidForm_window, "%s.p%i",
             raidlist->el[currline].volname, currline2);
     newtPushHelpLine
@@ -1798 +1799 @@
          ("   Please select a subdisk to edit, or edit this plex's parameters"));
     newtOpenWindow(13, 3, 54, 18, title_of_editraidForm_window);
-    paranoid_free(title_of_editraidForm_window);
+    mr_free(title_of_editraidForm_window);
 
     for (;;) {
         switch (raidrec->raidlevel) {
         case -1:
-            asprintf(&tmp, "concat");
+            mr_asprintf(&tmp, "concat");
             break;
         case 0:
-            asprintf(&tmp, "striped");
+            mr_asprintf(&tmp, "striped");
             break;
         case 5:
-            asprintf(&tmp, "raid5");
+            mr_asprintf(&tmp, "raid5");
             break;
         default:
-            asprintf(&tmp, _("unknown (%i)"), raidrec->raidlevel);
+            mr_asprintf(&tmp, _("unknown (%i)"), raidrec->raidlevel);
             break;
         }
         bLevel = newtCompactButton(2, 2, _(" RAID level "));
         sLevel = newtLabel(19, 2, tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
 
         if (raidrec->raidlevel >= 0) {
-            asprintf(&tmp, "%ik", raidrec->stripesize);
+            mr_asprintf(&tmp, "%ik", raidrec->stripesize);
             bStripeSize = newtCompactButton(2, 4, _(" Stripe size "));
         } else {
-            asprintf(&tmp, "N/A");
+            mr_asprintf(&tmp, "N/A");
             bStripeSize = newtLabel(2, 4, _("Stripe size:"));
         }
         sStripeSize = newtLabel(19, 4, tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
 
         bOK = newtCompactButton(2, 16, _("  OK  "));
@@ -1854 +1855 @@
             keylist[i] = (void *) i;
             if (i < raidrec->subdisks) {
-                asprintf(&entry, "%-17s",
+                mr_asprintf(&entry, "%-17s",
                          find_dev_entry_for_raid_device_name(raidlist,
                                                              raidrec->
@@ -1860 +1861 @@
                                                              which_device));
                 newtListboxAppendEntry(allocListbox, entry, keylist[i]);
-                paranoid_free(entry);
+                mr_free(entry);
             }
             if (i < unallocparts->entries) {
-                asprintf(&entry, "%-17s", unallocparts->el[i].device);
+                mr_asprintf(&entry, "%-17s", unallocparts->el[i].device);
                 newtListboxAppendEntry(unallocListbox, entry, keylist[i]);
-                paranoid_free(entry);
+                mr_free(entry);
             }
         }
@@ -1915 +1916 @@
             choose_raid_level(raidrec);
         } else if (b_res == bStripeSize) {
-            asprintf(&tmp, "%i", raidrec->stripesize);
+            mr_asprintf(&tmp, "%i", raidrec->stripesize);
             if (popup_and_get_string
                 (_("Stripe size"),
@@ -1921 +1922 @@
                 raidrec->stripesize = atoi(tmp);
             }
-            paranoid_free(tmp);
+            mr_free(tmp);
         } else if ((b_res == bAlloc) || (b_res == unallocListbox)) {
             if (currline_u <= unallocparts->entries)
@@ -1969 +1970 @@
     assert(lino >= 0);
 
-    asprintf(&sz_out, raidrec->additional_vars.el[lino].value);
-    asprintf(&header, _("Edit %s"), raidrec->additional_vars.el[lino].label);
-    asprintf(&comment, _("Please set %s's value (currently '%s')"),
+    mr_asprintf(&sz_out, raidrec->additional_vars.el[lino].value);
+    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)) {
-        paranoid_free(raidrec->additional_vars.el[lino].value);
+        mr_free(raidrec->additional_vars.el[lino].value);
         raidrec->additional_vars.el[lino].value = sz_out;
     }
-    paranoid_free(header);
-    paranoid_free(comment);
+    mr_free(header);
+    mr_free(comment);
 }
 #endif
@@ -2043 +2044 @@
     bCancel = newtCompactButton(i += 12, 17, _("Cancel"));
     bOK = newtCompactButton(i += 12, 17, _("  OK  "));
-    asprintf(&tmp, "%-24s %-24s %-8s  %s", _("Device"), _("Mountpoint"),
+    mr_asprintf(&tmp, "%-24s %-24s %-8s  %s", _("Device"), _("Mountpoint"),
             _("Format"), _("Size (MB)"));
     headerMsg = newtLabel(2, 1, tmp);
@@ -2064 +2065 @@
         newtLabelSetText(flawsLabelC, flaws_str_C);
 
-        paranoid_free(flaws_str_A);
-        paranoid_free(flaws_str_B);
-        paranoid_free(flaws_str_C);
+        mr_free(flaws_str_A);
+        mr_free(flaws_str_B);
+        mr_free(flaws_str_C);
 
         b_res = newtRunForm(myForm);
@@ -2196 +2197 @@
     memcpy((void *) &bkp_raidrec, (void *) raidrec,
            sizeof(struct raid_device_record));
-    asprintf(&title_of_window, "Additional variables");
+    mr_asprintf(&title_of_window, "Additional variables");
     newtPushHelpLine
         (_
@@ -2211 +2212 @@
     bCancel = newtCompactButton(i += 9, 9, _("Cancel"));
     newtOpenWindow(17, 7, 46, 10, title_of_window);
-    paranoid_free(title_of_window);
+    mr_free(title_of_window);
 
     myForm = newtForm(NULL, NULL, 0);
@@ -2306 +2307 @@
 #ifdef __FreeBSD__
     for (i = 0; i < raidlist->entries; i++) {
-        asprintf(&vdev, "/dev/vinum/%s", raidlist->el[i].volname);
+        mr_asprintf(&vdev, "/dev/vinum/%s", raidlist->el[i].volname);
         if (!strcmp(device, vdev)) {
-            paranoid_free(vdev);
+            mr_free(vdev);
             break;
         }
-        paranoid_free(vdev);
+        mr_free(vdev);
     }
 #else
@@ -2344 +2345 @@
     // log_it("%d - AAA - isodir_path = %s", isodir_path);
     if (isodir_device == NULL) {
-        asprintf(&isodir_device, "/dev/");
+        mr_asprintf(&isodir_device, "/dev/");
     }
     if (isodir_path == NULL) {
-        asprintf(&isodir_path, "/");
+        mr_asprintf(&isodir_path, "/");
     }
     if (does_file_exist("/tmp/NFS-SERVER-PATH")) {
-        paranoid_free(isodir_device);
+        mr_free(isodir_device);
         isodir_device = last_line_of_file("/tmp/NFS-SERVER-MOUNT");
-        asprintf(&isodir_format, "nfs");
-        paranoid_free(isodir_path);
+        mr_asprintf(&isodir_format, "nfs");
+        mr_free(isodir_path);
         isodir_path = last_line_of_file("/tmp/NFS-SERVER-PATH");
     }
@@ -2415 +2416 @@
     raidrec = &raidlist->el[pos_in_raidlist];
     initialize_raidrec(raidrec);
-    asprintf(&raidrec->OSSWAP(raid_device, volname),
+    mr_asprintf(&raidrec->OSSWAP(raid_device, volname),
            OSSWAP(device, basename(device)));
 #ifndef __FreeBSD__
@@ -2573 +2574 @@
     }
     for (i = 0; i < unallocated_raid_partitions->entries; i++) {
-        asprintf(&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]);
-        paranoid_free(tmp);
+        mr_free(tmp);
     }
 }
@@ -2610 +2611 @@
     }
     for (i = 0; i < additional_vars->entries; i++) {
-        asprintf(&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]);
-        paranoid_free(tmp);
+        mr_free(tmp);
     }
 }
@@ -2683 +2684 @@
     pos = which_raid_device_is_using_this_partition(raidlist, old_dev);
     if (pos < 0) {
-        asprintf(&tmp, "No need to rejig %s in raidlist: it's not listed.",
+        mr_asprintf(&tmp, "No need to rejig %s in raidlist: it's not listed.",
                 old_dev);
         log_it(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
     } else {
         if ((j =
@@ -2718 +2719 @@
 #endif
         else {
-            asprintf(&tmp,
+            mr_asprintf(&tmp,
                     "%s is supposed to be listed in this raid dev but it's not...",
                     old_dev);
             log_it(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
         }
     }
@@ -2833 +2834 @@
 
     iamhere("Post-malloc");
-    asprintf(&help_text,
+    mr_asprintf(&help_text,
            _
            ("   Edit this RAID device's list of partitions. Choose OK or Cancel when done."));
-    asprintf(&header_text, "%-24s    %s", _("Device"), _("Index"));
-    asprintf(&title_of_window, _("%s contains..."), raidrec->raid_device);
+    mr_asprintf(&header_text, "%-24s    %s", _("Device"), _("Index"));
+    mr_asprintf(&title_of_window, _("%s contains..."), raidrec->raid_device);
     newtPushHelpLine(help_text);
-    paranoid_free(help_text);
+    mr_free(help_text);
     for (b_res = (newtComponent) 12345; b_res != bOK && b_res != bCancel;) {
         headerMsg = newtLabel(1, 1, header_text);
@@ -2896 +2897 @@
                     redraw_disklist(disklist, keylist, partitionsListbox);
                 } else {
-                    asprintf(&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);
-                    asprintf(&sz_res, "%d", disklist->el[currline].index);
+                    mr_asprintf(&sz_res, "%d", disklist->el[currline].index);
                     if (popup_and_get_string
                         (_("Set index"), tmp, sz_res)) {
                         disklist->el[currline].index = atoi(sz_res);
                     }
-                    paranoid_free(tmp);
-                    paranoid_free(sz_res);
+                    mr_free(tmp);
+                    mr_free(sz_res);
                     redraw_disklist(disklist, keylist, partitionsListbox);
                 }
@@ -2913 +2914 @@
         newtPopWindow();
     }
-    paranoid_free(title_of_window);
-    paranoid_free(header_text);
+    mr_free(title_of_window);
+    mr_free(header_text);
 
     newtPopHelpLine();
@@ -2925 +2926 @@
                sizeof(struct list_of_disks));
     }
-    paranoid_free(bkp_raidrec);
-    paranoid_free(bkp_disklist);
-    paranoid_free(bkp_raidlist);
-    paranoid_free(unallocated_raid_partitions);
+    mr_free(bkp_raidrec);
+    mr_free(bkp_disklist);
+    mr_free(bkp_raidlist);
+    mr_free(unallocated_raid_partitions);
 }
 #endif
@@ -2960 +2961 @@
                 (_
                  ("Which mode - (A)utomatic, (I)nteractive, \n(C)ompare only, or (E)xit to shell?\n--> "));
-            getline(&tmp, &n, stdin);
-        }
-        paranoid_free(tmp);
+            mr_getline(&tmp, &n, stdin);
+        }
+        mr_free(tmp);
         return (output);
     }