Changeset 900 in MondoRescue for trunk/mondo/src/mondorestore

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.

Location:

trunk/mondo/src/mondorestore

Files:

• Makefile.am (modified) (2 diffs)
• mondo-prep.c (modified) (88 diffs)
• mondo-restore.c (modified) (108 diffs)
• mondo-rstr-compare.c (modified) (28 diffs)
• mondo-rstr-newt.c (modified) (74 diffs)
• mondo-rstr-tools.c (modified) (93 diffs)

trunk/mondo/src/mondorestore/Makefile.am

@@ +1 @@
+## $Id$
 ##
 ## Process with Automake to generate Makefile.in
@@ -14 +15 @@
 mondorestore_SOURCES  = mondo-prep.c mondo-restore.c mondo-rstr-newt.c \
                         mondo-rstr-compare.c mondo-rstr-tools.c
-mondorestore_LDADD    = ${top_builddir}/src/common/libmondo.a  ${top_builddir}/src/lib/libmr.a @MONDORESTORE_STATIC@
-
-
+mondorestore_LDADD    = ${top_builddir}/src/common/libmondo.a ${top_builddir}/src/lib/libmr.a @MONDORESTORE_STATIC@

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

@@ -19 +19 @@
 #include <math.h>
 #include <unistd.h>
+#include "mr_mem.h"
 
 
@@ -63 +64 @@
         make_list_of_drives_in_mountlist(mountlist, drivelist);
         for (lino = 0; lino < drivelist->entries; lino++) {
-            asprintf(&command,
+            mr_asprintf(&command,
                      "dd if=%s bs=512 count=1 2> /dev/null | grep \"%s\"",
                      drivelist->el[lino].device, MONDO_WAS_HERE);
@@ -69 +70 @@
                 log_msg(1, "Found MONDO_WAS_HERE marker on drive#%d (%s)",
                         lino, drivelist->el[lino].device);
-                paranoid_free(command);
+                mr_free(command);
                 break;
             }
-            paranoid_free(command);
+            mr_free(command);
         }
 
@@ -86 +87 @@
             log_to_screen("Please hit 'Enter' to reboot.");
             for (lino = 0; lino < drivelist->entries; lino++) {
-                asprintf(&buf, "%s\n", MONDO_WAS_HERE);
+                mr_asprintf(&buf, "%s\n", MONDO_WAS_HERE);
                 fout = fopen(drivelist->el[lino].device, "w+");
                 if (!fout) {
@@ -101 +102 @@
                     fclose(fout);
                 }
-                paranoid_free(buf);
+                mr_free(buf);
             }
             sync();
@@ -201 +202 @@
     if (tmp)    // found it :) cool
     {
-        asprintf(&lvscan_sz, "lvm lvscan");
-        asprintf(&lvremove_sz, "lvm lvremove");
-        asprintf(&vgscan_sz, "lvm vgscan");
-        asprintf(&pvscan_sz, "lvm pvscan");
-        asprintf(&vgchange_sz, "lvm vgchange");
-        asprintf(&vgremove_sz, "lvm vgremove");
+        mr_asprintf(&lvscan_sz, "lvm lvscan");
+        mr_asprintf(&lvremove_sz, "lvm lvremove");
+        mr_asprintf(&vgscan_sz, "lvm vgscan");
+        mr_asprintf(&pvscan_sz, "lvm pvscan");
+        mr_asprintf(&vgchange_sz, "lvm vgchange");
+        mr_asprintf(&vgremove_sz, "lvm vgremove");
     } else {
-        asprintf(&lvscan_sz, "lvscan");
-        asprintf(&lvremove_sz, "lvremove");
-        asprintf(&vgscan_sz, "vgscan");
-        asprintf(&pvscan_sz, "pvscan");
-        asprintf(&vgchange_sz, "vgchange");
-        asprintf(&vgremove_sz, "vgremove");
-    }
-    paranoid_free(tmp);
-
-    asprintf(&command,
+        mr_asprintf(&lvscan_sz, "lvscan");
+        mr_asprintf(&lvremove_sz, "lvremove");
+        mr_asprintf(&vgscan_sz, "vgscan");
+        mr_asprintf(&pvscan_sz, "pvscan");
+        mr_asprintf(&vgchange_sz, "vgchange");
+        mr_asprintf(&vgremove_sz, "vgremove");
+    }
+    mr_free(tmp);
+
+    mr_asprintf(&command,
             "for i in `%s | cut -d\"'\" -f2 | sort -r` ; do echo \"Shutting down lv $i\" >> "
             MONDO_LOGFILE "; %s -f $i; done", lvscan_sz, lvremove_sz);
-    paranoid_free(lvscan_sz);
-    paranoid_free(lvremove_sz);
+    mr_free(lvscan_sz);
+    mr_free(lvremove_sz);
 
     run_program_and_log_output(command, 5);
-    paranoid_free(command);
+    mr_free(command);
 
     sleep(1);
-    asprintf(&command,
+    mr_asprintf(&command,
             "for i in `%s | grep -i lvm | cut -d'\"' -f2` ; do %s -a n $i ; %s $i; echo \"Shutting down vg $i\" >> "
             MONDO_LOGFILE "; done", vgscan_sz, vgchange_sz, vgremove_sz);
-    paranoid_free(vgchange_sz);
-    paranoid_free(vgremove_sz);
+    mr_free(vgchange_sz);
+    mr_free(vgremove_sz);
 
     run_program_and_log_output(command, 5);
-    paranoid_free(command);
+    mr_free(command);
 
     if (just_erase_existing_volumes) {
@@ -250 +251 @@
     log_msg(1, "OK, rewound i-want-my-lvm. Doing funky stuff...");
     rewind(fin);
-    for (getline(&incoming, &n1, fin); !feof(fin); getline(&incoming, &n1, fin)) {
+    for (mr_getline(&incoming, &n1, fin); !feof(fin); mr_getline(&incoming, &n1, fin)) {
         fgetpos(fin, &orig_pos);
         /* we want to execute lines begining with a # */
@@ -264 +265 @@
         if ((p = strstr(incoming, "vgcreate"))) {
             // include next line(s) if they end in /dev (cos we've got a broken i-want-my-lvm)
-            for (getline(&tmp, &n, fin); !feof(fin); getline(&tmp, &n, fin)) {
+            for (mr_getline(&tmp, &n, fin); !feof(fin); mr_getline(&tmp, &n, fin)) {
                 if (tmp[0] == '#') {
                     fsetpos(fin, &orig_pos);
@@ -270 +271 @@
                 } else {
                     fgetpos(fin, &orig_pos);
-                    asprintf(&tmp1, "%s%s", incoming, tmp);
-                    paranoid_free(incoming);
+                    mr_asprintf(&tmp1, "%s%s", incoming, tmp);
+                    mr_free(incoming);
                     incoming = tmp1;
                 }
             }
-            paranoid_free(tmp);
+            mr_free(tmp);
 
             for (q = incoming; *q != '\0'; q++) {
@@ -282 +283 @@
                 }
             }
-            asprintf(&tmp1, p + strlen("vgcreate") + 1);
+            mr_asprintf(&tmp1, p + strlen("vgcreate") + 1);
             for (q = tmp1; *q > 32; q++);
             *q = '\0';
             log_msg(1, "Deleting old entries at /dev/%s", tmp1);
-            asprintf(&tmp, "rm -Rf /dev/%s", tmp1);
-            paranoid_free(tmp1);
+            mr_asprintf(&tmp, "rm -Rf /dev/%s", tmp1);
+            mr_free(tmp1);
 
             run_program_and_log_output(tmp, 1);
-            paranoid_free(tmp);
+            mr_free(tmp);
 
             run_program_and_log_output(vgscan_sz, 1);
@@ -299 +300 @@
         }
         for (p = incoming + 1; *p == ' '; p++);
-        paranoid_alloc(command,p);
+        mr_allocstr(command,p);
         for (p = command; *p != '\0'; p++);
         for (; *(p - 1) < 32; p--);
@@ -333 +334 @@
             extents = atol(p);
             log_msg(5, "p='%s' --> extents=%ld", p, extents);
-            paranoid_free(tmp);
+            mr_free(tmp);
 
             p = strstr(command, "-L");
@@ -384 +385 @@
             retval++;
         }
-        asprintf(&tmp, "echo \"%s\" >> /tmp/out.sh", command);
+        mr_asprintf(&tmp, "echo \"%s\" >> /tmp/out.sh", command);
         system(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         sleep(1);
     }
     paranoid_fclose(fin);
-    paranoid_free(vgscan_sz);
-    paranoid_free(pvscan_sz);
-    paranoid_free(command);
-    paranoid_free(incoming);
+    mr_free(vgscan_sz);
+    mr_free(pvscan_sz);
+    mr_free(command);
+    mr_free(incoming);
 
     log_msg(1, "Closed i-want-my-lvm. Finished doing funky stuff.");
@@ -460 +461 @@
                 finish(1);
             }
-            for (getline(&incoming, &n, fin); !feof(fin)
+            for (mr_getline(&incoming, &n, fin); !feof(fin)
                  && !strstr(incoming, old_mountlist->el[lino].device);
-                 getline(&incoming, &n, fin));
+                 mr_getline(&incoming, &n, fin));
             if (!feof(fin)) {
-                asprintf(&tmp, "Investigating %s",
+                mr_asprintf(&tmp, "Investigating %s",
                         old_mountlist->el[lino].device);
                 log_it(tmp);
-                paranoid_free(tmp);
-
-                for (getline(&incoming, &n, fin); !feof(fin)
+                mr_free(tmp);
+
+                for (mr_getline(&incoming, &n, fin); !feof(fin)
                      && !strstr(incoming, "raiddev");
-                     getline(&incoming, &n, fin)) {
+                     mr_getline(&incoming, &n, fin)) {
                     if (strstr(incoming, OSSWAP("device", "drive"))
                         && !strchr(incoming, '#')) {
@@ -478 +479 @@
                         *p = '\0';
                         for (p--; p > incoming && *(p - 1) > 32; p--);
-                        asprintf(&tmp, "Extrapolating %s", p);
+                        mr_asprintf(&tmp, "Extrapolating %s", p);
                         log_it(tmp);
-                        paranoid_free(tmp);
+                        mr_free(tmp);
 
                         for (j = 0;
@@ -499 +500 @@
                             new_mountlist->entries++;
                         } else {
-                            asprintf(&tmp,
+                            mr_asprintf(&tmp,
                                     "Not adding %s to mountlist: it's already there", p);
                             log_it(tmp);
-                            paranoid_free(tmp);
+                            mr_free(tmp);
                         }
                     }
                 }
             }
-            paranoid_free(incoming);
+            mr_free(incoming);
             paranoid_fclose(fin);
         } else {
@@ -566 +567 @@
     }
     // create device list from normal disks followed by spare ones
-    asprintf(&devices, raidlist->el[i].data_disks.el[0].device);
+    mr_asprintf(&devices, raidlist->el[i].data_disks.el[0].device);
     for (j = 1; j < raidlist->el[i].data_disks.entries; j++) {
-        asprintf(&strtmp, "%s", devices);
-        paranoid_free(devices);
-        asprintf(&devices, "%s %s", strtmp,
+        mr_asprintf(&strtmp, "%s", devices);
+        mr_free(devices);
+        mr_asprintf(&devices, "%s %s", strtmp,
                  raidlist->el[i].data_disks.el[j].device);
-        paranoid_free(strtmp);
+        mr_free(strtmp);
     }
     for (j = 0; j < raidlist->el[i].spare_disks.entries; j++) {
-        asprintf(&strtmp, "%s", devices);
-        paranoid_free(devices);
-        asprintf(&devices, "%s %s", strtmp,
+        mr_asprintf(&strtmp, "%s", devices);
+        mr_free(devices);
+        mr_asprintf(&devices, "%s %s", strtmp,
                  raidlist->el[i].spare_disks.el[j].device);
-        paranoid_free(strtmp);
+        mr_free(strtmp);
     }
     // translate RAID level
     if (raidlist->el[i].raid_level == -2) {
-        asprintf(&level, "multipath");
+        mr_asprintf(&level, "multipath");
     } else if (raidlist->el[i].raid_level == -1) {
-        asprintf(&level, "linear");
+        mr_asprintf(&level, "linear");
     } else {
-        asprintf(&level, "raid%d", raidlist->el[i].raid_level);
+        mr_asprintf(&level, "raid%d", raidlist->el[i].raid_level);
     }
     // create RAID device:
@@ -594 +595 @@
     // - faulty devices ignored
     // - persistent superblock always used as this is recommended
-    asprintf(&program,
+    mr_asprintf(&program,
              "mdadm --create --force --run --auto=yes %s --level=%s --raid-devices=%d",
              raidlist->el[i].raid_device, level,
              raidlist->el[i].data_disks.entries);
     if (raidlist->el[i].parity != -1) {
-        asprintf(&strtmp, "%s", program);
-        paranoid_free(program);
+        mr_asprintf(&strtmp, "%s", program);
+        mr_free(program);
         switch (raidlist->el[i].parity) {
         case 0:
-            asprintf(&program, "%s --parity=%s", strtmp, "la");
+            mr_asprintf(&program, "%s --parity=%s", strtmp, "la");
             break;
         case 1:
-            asprintf(&program, "%s --parity=%s", strtmp, "ra");
+            mr_asprintf(&program, "%s --parity=%s", strtmp, "ra");
             break;
         case 2:
-            asprintf(&program, "%s --parity=%s", strtmp, "ls");
+            mr_asprintf(&program, "%s --parity=%s", strtmp, "ls");
             break;
         case 3:
-            asprintf(&program, "%s --parity=%s", strtmp, "rs");
+            mr_asprintf(&program, "%s --parity=%s", strtmp, "rs");
             break;
         default:
@@ -618 +619 @@
             break;
         }
-        paranoid_free(strtmp);
+        mr_free(strtmp);
     }
     if (raidlist->el[i].chunk_size != -1) {
-        asprintf(&strtmp, "%s", program);
-        paranoid_free(program);
-        asprintf(&program, "%s --chunk=%d", strtmp,
+        mr_asprintf(&strtmp, "%s", program);
+        mr_free(program);
+        mr_asprintf(&program, "%s --chunk=%d", strtmp,
                  raidlist->el[i].chunk_size);
-        paranoid_free(strtmp);
+        mr_free(strtmp);
     }
     if (raidlist->el[i].spare_disks.entries > 0) {
-        asprintf(&strtmp, "%s", program);
-        paranoid_free(program);
-        asprintf(&program, "%s --spare-devices=%d", strtmp,
+        mr_asprintf(&strtmp, "%s", program);
+        mr_free(program);
+        mr_asprintf(&program, "%s --spare-devices=%d", strtmp,
                  raidlist->el[i].spare_disks.entries);
-        paranoid_free(strtmp);
-    }
-    asprintf(&strtmp, "%s", program);
-    paranoid_free(program);
-    asprintf(&program, "%s %s", strtmp, devices);
-    paranoid_free(strtmp);
+        mr_free(strtmp);
+    }
+    mr_asprintf(&strtmp, "%s", program);
+    mr_free(program);
+    mr_asprintf(&program, "%s %s", strtmp, devices);
+    mr_free(strtmp);
     res = run_program_and_log_output(program, 1);
     // free memory
-    paranoid_free(devices);
-    paranoid_free(level);
-    paranoid_free(program);
+    mr_free(devices);
+    mr_free(level);
+    mr_free(program);
     // return to calling instance
     return res;
@@ -687 +688 @@
 
     if (strstr(format, "raid")) {   // do not form RAID disks; do it to /dev/md* instead
-        asprintf(&tmp, "Not formatting %s (it is a RAID disk)", device);
+        mr_asprintf(&tmp, "Not formatting %s (it is a RAID disk)", device);
         log_it(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         return (0);
     }
@@ -699 +700 @@
 #endif
     if (strlen(format) <= 2) {
-        asprintf(&tmp,
+        mr_asprintf(&tmp,
                 "%s has a really small format type ('%s') - this is probably a hexadecimal string, which would suggest the partition is an image --- I shouldn't format it",
                 device, format);
         log_it(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         return (0);
     }
     if (is_this_device_mounted(device)) {
-        asprintf(&tmp, _("%s is mounted - cannot format it       "), device);
+        mr_asprintf(&tmp, _("%s is mounted - cannot format it       "), device);
         log_to_screen(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         return (1);
     }
@@ -736 +737 @@
 
         if (vinum_started_yet) {
-            asprintf(&tmp,
+            mr_asprintf(&tmp,
                     _
                     ("Initializing Vinum device %s (this may take a *long* time)"),
                     device);
             log_to_screen(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
 
             /* format raid partition */
-            asprintf(&program,
+            mr_asprintf(&program,
                     "for plex in `vinum lv -r %s | grep '^P' | tr '\t' ' ' | tr -s ' ' | cut -d' ' -f2`; do echo $plex; done > /tmp/plexes",
                     basename(device));
@@ -752 +753 @@
                 fprintf(g_fprep, "%s\n", program);
             }
-            paranoid_free(program);
+            mr_free(program);
 
             fin = fopen("/tmp/plexes", "r");
-            while (getline(&line, &n, fin)) {
+            while (mr_getline(&line, &n, fin)) {
                 if (strchr(line, '\n'))
                     *(strchr(line, '\n')) = '\0';   // get rid of the \n on the end
 
-                asprintf(&tmp, "Initializing plex: %s", line);
+                mr_asprintf(&tmp, "Initializing plex: %s", line);
                 open_evalcall_form(tmp);
-                paranoid_free(tmp);
-
-                asprintf(&tmp, "vinum init %s", line);
+                mr_free(tmp);
+
+                mr_asprintf(&tmp, "vinum init %s", line);
                 system(tmp);
-                paranoid_free(tmp);
+                mr_free(tmp);
 
                 while (1) {
-                    asprintf(&tmp,
+                    mr_asprintf(&tmp,
                             "vinum lp -r %s | grep '^S' | head -1 | tr -s ' ' | cut -d: -f2 | cut -f1 | sed 's/^ //' | sed 's/I //' | sed 's/%%//'",
                             line);
                     pin = popen(tmp, "r");
-                    paranoid_free(tmp);
-
-                    getline(&status, &n1, pin);
+                    mr_free(tmp);
+
+                    mr_getline(&status, &n1, pin);
                     pclose(pin);
 
@@ -782 +783 @@
                     update_evalcall_form(atoi(status));
                     usleep(250000);
-                    paranoid_free(status);
+                    mr_free(status);
                 }
                 close_evalcall_form();
             }
-            paranoid_free(line);
+            mr_free(line);
             fclose(fin);
             unlink("/tmp/plexes");
@@ -792 +793 @@
         }
 #else
-        asprintf(&tmp, _("Initializing RAID device %s"), device);
+        mr_asprintf(&tmp, _("Initializing RAID device %s"), device);
         log_to_screen(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
 
 // Shouldn't be necessary.
@@ -814 +815 @@
                     device, res);
         } else {
-            asprintf(&program, "mkraid --really-force %s", device);
+            mr_asprintf(&program, "mkraid --really-force %s", device);
             res = run_program_and_log_output(program, 1);
             log_msg(1, "%s returned %d", program, res);
@@ -823 +824 @@
                 fprintf(g_fprep, "%s\n", program);
             }
-            paranoid_free(program);
+            mr_free(program);
         }
         sync();
@@ -842 +843 @@
     res = which_format_command_do_i_need(format, program);
     if (strstr(program, "kludge")) {
-        asprintf(&tmp, "%s %s /", program, device);
+        mr_asprintf(&tmp, "%s %s /", program, device);
     } else {
-        asprintf(&tmp, "%s %s", program, device);
-    }
-    paranoid_free(program);
-
-    asprintf(&program, "sh -c 'echo -en \"y\\ny\\ny\\n\" | %s'", tmp);
-    paranoid_free(tmp);
-
-    asprintf(&tmp, "Formatting %s as %s", device, format);
+        mr_asprintf(&tmp, "%s %s", program, device);
+    }
+    mr_free(program);
+
+    mr_asprintf(&program, "sh -c 'echo -en \"y\\ny\\ny\\n\" | %s'", tmp);
+    mr_free(tmp);
+
+    mr_asprintf(&tmp, "Formatting %s as %s", device, format);
     update_progress_form(tmp);
 
@@ -857 +858 @@
     if (res && strstr(program, "kludge")) {
 #ifdef __FreeBSD__
-        paranoid_free(program);
-        asprintf(&program, "newfs_msdos -F 32 %s", device);
+        mr_free(program);
+        mr_asprintf(&program, "newfs_msdos -F 32 %s", device);
 #else
 #ifdef __IA64__
         /* For EFI partitions take fat16 
          * as we want to make small ones */
-        paranoid_free(program);
-        asprintf(&program, "mkfs -t %s -F 16 %s", format, device);
+        mr_free(program);
+        mr_asprintf(&program, "mkfs -t %s -F 16 %s", format, device);
 #else
-        paranoid_free(program);
-        asprintf(&program, "mkfs -t %s -F 32 %s", format, device);
+        mr_free(program);
+        mr_asprintf(&program, "mkfs -t %s -F 32 %s", format, device);
 #endif
 #endif
@@ -875 +876 @@
         }
     }
-    paranoid_free(program);
+    mr_free(program);
 
     retval += res;
     if (retval) {
-        asprintf(&tmp1, "%s%s",tmp, _("...failed"));
+        mr_asprintf(&tmp1, "%s%s",tmp, _("...failed"));
     } else {
-        asprintf(&tmp1, "%s%s",tmp, _("...OK"));
-    }
-    paranoid_free(tmp);
+        mr_asprintf(&tmp1, "%s%s",tmp, _("...OK"));
+    }
+    mr_free(tmp);
 
     log_to_screen(tmp1);
-    paranoid_free(tmp1);
+    mr_free(tmp1);
     sync();
     sleep(1);
@@ -923 +924 @@
 
     assert(mountlist != NULL);
-    asprintf(&tmp, "format_everything (mountlist, interactively = %s",
+    mr_asprintf(&tmp, "format_everything (mountlist, interactively = %s",
             (interactively) ? "true" : "false");
     log_it(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     mvaddstr_and_log_it(g_currentY, 0, _("Formatting partitions     "));
@@ -952 +953 @@
             if (interactively) {
                 // ask user if we should format the current device
-                asprintf(&tmp, "Shall I format %s (%s) ?", me->device,
+                mr_asprintf(&tmp, "Shall I format %s (%s) ?", me->device,
                         me->mountpoint);
                 do_it = ask_me_yes_or_no(tmp);
-                paranoid_free(tmp);
+                mr_free(tmp);
             } else {
                 do_it = TRUE;
@@ -1003 +1004 @@
         me = &mountlist->el[lino];  // the current mountlist entry
         if (!strcmp(me->mountpoint, "image")) {
-            asprintf(&tmp, "Not formatting %s - it's an image", me->device);
+            mr_asprintf(&tmp, "Not formatting %s - it's an image", me->device);
             log_it(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
         } else if (!strcmp(me->format, "raid")) {
-            asprintf(&tmp, "Not formatting %s - it's a raid-let",
+            mr_asprintf(&tmp, "Not formatting %s - it's a raid-let",
                     me->device);
             log_it(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
             continue;
         } else if (!strcmp(me->format, "lvm")) {
-            asprintf(&tmp, "Not formatting %s - it's an LVM", me->device);
+            mr_asprintf(&tmp, "Not formatting %s - it's an LVM", me->device);
             log_it(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
             continue;
         } else if (!strncmp(me->device, "/dev/md", 7)) {
-            asprintf(&tmp, "Already formatted %s - it's a soft-RAID dev",
+            mr_asprintf(&tmp, "Already formatted %s - it's a soft-RAID dev",
                     me->device);
             log_it(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
             continue;
         } else if (!does_file_exist(me->device)
                    && strncmp(me->device, "/dev/hd", 7)
                    && strncmp(me->device, "/dev/sd", 7)) {
-            asprintf(&tmp,
+            mr_asprintf(&tmp,
                     "Not formatting %s yet - doesn't exist - probably an LVM",
                     me->device);
             log_it(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
             continue;
         } else {
             if (interactively) {
                 // ask user if we should format the current device
-                asprintf(&tmp, "Shall I format %s (%s) ?", me->device,
+                mr_asprintf(&tmp, "Shall I format %s (%s) ?", me->device,
                         me->mountpoint);
                 do_it = ask_me_yes_or_no(tmp);
-                paranoid_free(tmp);
+                mr_free(tmp);
             } else {
                 do_it = TRUE;
@@ -1068 +1069 @@
     }
 
-    asprintf(&tmp, "format_everything () - %s",
+    mr_asprintf(&tmp, "format_everything () - %s",
             (retval) ? "failed!" : "finished successfully");
     log_it(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     if (g_partition_table_locked_up > 0) {
@@ -1135 +1136 @@
 
     if (devno_we_must_allow_for >= 5) {
-        asprintf(&tmp, "Making dummy primary %s%d", drivename, 1);
+        mr_asprintf(&tmp, "Making dummy primary %s%d", drivename, 1);
         log_it(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
 
         g_maximum_progress++;
@@ -1151 +1152 @@
     }
     for (; current_devno < devno_we_must_allow_for; current_devno++) {
-        asprintf(&tmp, "Creating dummy partition %s%d", drivename,
+        mr_asprintf(&tmp, "Creating dummy partition %s%d", drivename,
                 current_devno);
         log_it(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
 
         g_maximum_progress++;
@@ -1301 +1302 @@
     off_t mediasize;
 
-    asprintf(&lnamebuf, "%s", dkname);
+    mr_asprintf(&lnamebuf, "%s", dkname);
     if ((f = open(lnamebuf, O_RDONLY)) == -1) {
         warn("cannot open %s", lnamebuf);
-        paranoid_free(lnamebuf);
+        mr_free(lnamebuf);
         return (NULL);
     }
-    paranoid_free(lnamebuf);
+    mr_free(lnamebuf);
 
     /* New world order */
@@ -1389 +1390 @@
     for (c = 'a'; c <= 'z'; ++c) {
         int idx;
-        asprintf(&subdev_str, "%s%c", drivename, c);
+        mr_asprintf(&subdev_str, "%s%c", drivename, c);
         if ((idx = find_device_in_mountlist(mountlist, subdev_str)) < 0) {
             lp->d_partitions[c - 'a'].p_size = 0;
@@ -1414 +1415 @@
                 lp->d_partitions[c - 'a'].p_fstype = FS_OTHER;
         }
-        paranoid_free(subdev_str);
+        mr_free(subdev_str);
     }
 
@@ -1445 +1446 @@
     display_disklabel(ftmp, lp);
     fclose(ftmp);
-    asprintf(&command, "disklabel -wr %s auto", canonical_name(drivename));
+    mr_asprintf(&command, "disklabel -wr %s auto", canonical_name(drivename));
     retval += run_program_and_log_output(command, TRUE);
-    paranoid_free(command);
-
-    asprintf(&command, "disklabel -R %s /tmp/disklabel",
+    mr_free(command);
+
+    mr_asprintf(&command, "disklabel -R %s /tmp/disklabel",
             canonical_name(drivename));
     retval += run_program_and_log_output(command, TRUE);
-    paranoid_free(command);
+    mr_free(command);
     if (ret)
         *ret = *lp;
@@ -1495 +1496 @@
     assert_string_is_neither_NULL_nor_zerolength(drivename);
 
-    asprintf(&tmp, "Partitioning drive %s", drivename);
+    mr_asprintf(&tmp, "Partitioning drive %s", drivename);
     log_it(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
 #if __FreeBSD__
@@ -1504 +1505 @@
 #else
     make_hole_for_file(FDISK_LOG);
-    asprintf(&tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG,
+    mr_asprintf(&tmp, "parted2fdisk %s >> %s 2>> %s", drivename, FDISK_LOG,
             FDISK_LOG);
     pout_to_fdisk = popen(tmp, "w");
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     if (!pout_to_fdisk) {
@@ -1531 +1532 @@
                 // try DangerouslyDedicated mode
                 for (c = 'a'; c <= 'z'; c++) {
-                    asprintf(&subdev_str, "%s%c", drivename, c);
+                    mr_asprintf(&subdev_str, "%s%c", drivename, c);
                     if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
                         fbsd_part = TRUE;
                     }
-                    paranoid_free(subdev_str);
+                    mr_free(subdev_str);
                 }
                 if (fbsd_part) {
@@ -1541 +1542 @@
                                                  drivename,
                                                  0);
-                    asprintf(&command, "disklabel -B %s",
+                    mr_asprintf(&command, "disklabel -B %s",
                             basename(drivename));
                     if (system(command)) {
@@ -1548 +1549 @@
                              ("Warning! Unable to make the drive bootable."));
                     }
-                    paranoid_free(command);
-                    paranoid_free(device_str);
+                    mr_free(command);
+                    mr_free(device_str);
 
                     return r;
@@ -1555 +1556 @@
             }
             for (c = 'a'; c <= 'z'; c++) {
-                asprintf(&subdev_str, "%s%c", device_str, c);
+                mr_asprintf(&subdev_str, "%s%c", device_str, c);
                 if (find_device_in_mountlist(mountlist, subdev_str) > 0) {
                     fbsd_part = TRUE;
                 }
-                paranoid_free(subdev_str);
+                mr_free(subdev_str);
             }
             // Now we check the subpartitions of the current partition.
@@ -1565 +1566 @@
                 int i, line;
 
-                asprintf(&format, "ufs");
+                mr_asprintf(&format, "ufs");
                 partsize = 0;
                 for (i = 'a'; i < 'z'; ++i) {
-                    asprintf(&subdev_str, "%s%c", device_str, i);
+                    mr_asprintf(&subdev_str, "%s%c", device_str, i);
                     line = find_device_in_mountlist(mountlist, subdev_str);
-                    paranoid_free(subdev_str);
+                    mr_free(subdev_str);
 
                     if (line > 0) {
@@ -1596 +1597 @@
             file = open(drivename, O_WRONLY);
             if (!file) {
-                asprintf(&tmp,
+                mr_asprintf(&tmp,
                         _("Warning - unable to open %s for wiping it's partition table"),
                         drivename);
                 log_to_screen(tmp);
-                paranoid_free(tmp);
+                mr_free(tmp);
             }
 
             for (i = 0; i < 512; i++) {
                 if (!write(file, "\0", 1)) {
-                    asprintf(&tmp, _("Warning - unable to write to %s"),
+                    mr_asprintf(&tmp, _("Warning - unable to write to %s"),
                             drivename);
                     log_to_screen(tmp);
-                    paranoid_free(tmp);
+                    mr_free(tmp);
                 }
             }
@@ -1629 +1630 @@
 #endif
 
-            asprintf(&format, mountlist->el[lino].format);
+            mr_asprintf(&format, mountlist->el[lino].format);
             partsize = mountlist->el[lino].size;
 
@@ -1640 +1641 @@
                 (_
                  ("You must leave at least one partition spare as the Extended partition."));
-            paranoid_free(device_str);
-            paranoid_free(format);
+            mr_free(device_str);
+            mr_free(format);
 
             return (1);
@@ -1652 +1653 @@
 #ifdef __FreeBSD__
         if ((current_devno <= 4) && fbsd_part) {
-            asprintf(&tmp, "disklabel -B %s", basename(device_str));
+            mr_asprintf(&tmp, "disklabel -B %s", basename(device_str));
             retval += label_drive_or_slice(mountlist, device_str, 0);
             if (system(tmp)) {
@@ -1658 +1659 @@
                     (_("Warning! Unable to make the slice bootable."));
             }
-            paranoid_free(tmp);
+            mr_free(tmp);
         }
 #endif
@@ -1664 +1665 @@
         previous_devno = current_devno;
     }
-    paranoid_free(device_str);
-    paranoid_free(format);
+    mr_free(device_str);
+    mr_free(format);
 
     if (pout_to_fdisk) {
@@ -1671 +1672 @@
         tmp1 = call_program_and_get_last_line_of_output
                 ("make-me-bootable /tmp/mountlist.txt dummy");
-        asprintf(&tmp, "a\n%s\n", tmp1);
-        paranoid_free(tmp1);
+        mr_asprintf(&tmp, "a\n%s\n", tmp1);
+        mr_free(tmp1);
 
         fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
 
         // close fdisk
@@ -1683 +1684 @@
         log_msg(0,
                 "------------------- fdisk.log looks like this ------------------");
-        asprintf(&tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
+        mr_asprintf(&tmp, "cat %s >> %s", FDISK_LOG, MONDO_LOGFILE);
         system(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
 
         log_msg(0,
                 "------------------- end of fdisk.log... word! ------------------");
-        asprintf(&tmp, "tail -n6 %s | grep -F \"16: \"", FDISK_LOG);
+        mr_asprintf(&tmp, "tail -n6 %s | grep -F \"16: \"", FDISK_LOG);
         if (!run_program_and_log_output(tmp, 5)) {
             g_partition_table_locked_up++;
@@ -1696 +1697 @@
                  ("A flaw in the Linux kernel has locked the partition table."));
         }
-        paranoid_free(tmp);
+        mr_free(tmp);
     }
     return (retval);
@@ -1739 +1740 @@
 
     if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
-        asprintf(&tmp, "Not partitioning %s - it is a virtual drive", drive);
+        mr_asprintf(&tmp, "Not partitioning %s - it is a virtual drive", drive);
         log_it(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         return (0);
     }
     partition_name = build_partition_name(drive, partno);
     if (partsize <= 0) {
-        asprintf(&tmp, "Partitioning device %s (max size)", partition_name);
+        mr_asprintf(&tmp, "Partitioning device %s (max size)", partition_name);
     } else {
-        asprintf(&tmp, "Partitioning device %s (%lld MB)", partition_name,
+        mr_asprintf(&tmp, "Partitioning device %s (%lld MB)", partition_name,
                 (long long) partsize / 1024);
     }
     update_progress_form(tmp);
     log_it(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     if (is_this_device_mounted(partition_name)) {
-        asprintf(&tmp, _("%s is mounted, and should not be partitioned"),
+        mr_asprintf(&tmp, _("%s is mounted, and should not be partitioned"),
                 partition_name);
-        paranoid_free(partition_name);
+        mr_free(partition_name);
 
         log_to_screen(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         return (1);
     }
 
     p = (char *) strrchr(partition_name, '/');
-    asprintf(&program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE,
+    mr_asprintf(&program, "parted2fdisk %s >> %s 2>> %s", drive, MONDO_LOGFILE,
             MONDO_LOGFILE);
 
@@ -1773 +1774 @@
     /* make it a primary/extended/logical */
     if (partno <= 4) {
-        asprintf(&output,"n\np\n%d\n", partno);
+        mr_asprintf(&output,"n\np\n%d\n", partno);
     } else {
         /* MBR needs an extended partition if more than 4 partitions */
@@ -1782 +1783 @@
                         (_
                          ("You need to leave at least one partition free, for 'extended/logical'"));
-                    paranoid_free(partition_name);
-                    paranoid_free(program);
-
-                    paranoid_free(output);
+                    mr_free(partition_name);
+                    mr_free(program);
+
+                    mr_free(output);
                     return (1);
                 } else {
-                    asprintf(&output,"n\ne\n%d\n\n\n",prev_partno + 1);
+                    mr_asprintf(&output,"n\ne\n%d\n\n\n",prev_partno + 1);
                 }
             }
-            asprintf(&tmp,"%sn\nl\n",output);
-            paranoid_free(output);
+            mr_asprintf(&tmp,"%sn\nl\n",output);
+            mr_free(output);
             output = tmp;
         } else {
             /* GPT allows more than 4 primary partitions */
-            asprintf(&output,"n\np\n%d\n",partno);
-        }
-    }
-    paranoid_free(part_table_fmt);
+            mr_asprintf(&output,"n\np\n%d\n",partno);
+        }
+    }
+    mr_free(part_table_fmt);
     /*start block (ENTER for next free blk */
-    asprintf(&tmp,"%s\n",output);
-    paranoid_free(output);
+    mr_asprintf(&tmp,"%s\n",output);
+    mr_free(output);
     output = tmp;
 
@@ -1810 +1811 @@
             partsize += 512;
         }
-        asprintf(&tmp,"%s+%lldK", output,  (long long) (partsize));
-        paranoid_free(output);
+        mr_asprintf(&tmp,"%s+%lldK", output,  (long long) (partsize));
+        mr_free(output);
         output = tmp;
     }
-    asprintf(&tmp,"%s\n",output);
-    paranoid_free(output);
+    mr_asprintf(&tmp,"%s\n",output);
+    mr_free(output);
     output = tmp;
 #if 0
 /*
 #endif
-    asprintf(&tmp,"PARTSIZE = +%ld",(long)partsize);
+    mr_asprintf(&tmp,"PARTSIZE = +%ld",(long)partsize);
     log_it(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     log_it("---fdisk command---");
@@ -1845 +1846 @@
                     partno);
         }
-        paranoid_free(tmp);
+        mr_free(tmp);
 
         if (!retval) {
@@ -1864 +1865 @@
         }
     } else {
-        asprintf(&tmp,"%sw\n\n",output);
-        paranoid_free(output);
+        mr_asprintf(&tmp,"%sw\n\n",output);
+        mr_free(output);
         output = tmp;
 
@@ -1885 +1886 @@
                                  format, -1);
             if (res) {
-                asprintf(&tmp, "Failed to vacuum-pack %s", partition_name);
+                mr_asprintf(&tmp, "Failed to vacuum-pack %s", partition_name);
                 log_it(tmp);
-                paranoid_free(tmp);
+                mr_free(tmp);
 
                 retval++;
@@ -1899 +1900 @@
                                    partsize);
             if (retval) {
-                asprintf(&tmp, "Partitioned %s but failed to set its type",
+                mr_asprintf(&tmp, "Partitioned %s but failed to set its type",
                         partition_name);
                 log_it(tmp);
-                paranoid_free(tmp);
+                mr_free(tmp);
             } else {
                 if (partsize > 0) {
-                    asprintf(&tmp, "Partition %s created+configured OK",
+                    mr_asprintf(&tmp, "Partition %s created+configured OK",
                             partition_name);
                     log_to_screen(tmp);
-                    paranoid_free(tmp);
+                    mr_free(tmp);
                 } else {
                     log_it("Returning from a successful vacuum-pack");
@@ -1914 +1915 @@
             }
         } else {
-            asprintf(&tmp, "Failed to partition %s", partition_name);
+            mr_asprintf(&tmp, "Failed to partition %s", partition_name);
             if (partsize > 0) {
                 log_to_screen(tmp);
@@ -1920 +1921 @@
                 log_it(tmp);
             }
-            paranoid_free(tmp);
+            mr_free(tmp);
             retval++;
         }
@@ -1926 +1927 @@
     g_current_progress++;
     log_it("partition_device() --- leaving");
-    paranoid_free(partition_name);
-    paranoid_free(program);
-    paranoid_free(output);
+    mr_free(partition_name);
+    mr_free(program);
+    mr_free(output);
     return (retval);
 }
@@ -2014 +2015 @@
     system("clear");
     newtResume();
-    paranoid_free(drivelist);
+    mr_free(drivelist);
     return (retval);
 }
@@ -2058 +2059 @@
     p = (char *) strrchr(partition, '/');
     if (strcmp(format, "swap") == 0) {
-        asprintf(&partcode, "82");
+        mr_asprintf(&partcode, "82");
     } else if (strcmp(format, "vfat") == 0) {
         if (partsize / 1024 > 8192) {
-            asprintf(&partcode, "c");
+            mr_asprintf(&partcode, "c");
         } else {
-            asprintf(&partcode, "b");
+            mr_asprintf(&partcode, "b");
         }
     } else if (strcmp(format, "ext2") == 0
@@ -2069 +2070 @@
                || strcmp(format, "ext3") == 0 || strcmp(format, "xfs") == 0
                || strcmp(format, "jfs") == 0) {
-        asprintf(&partcode, "83");
+        mr_asprintf(&partcode, "83");
     } else if (strcmp(format, "minix") == 0) {
-        asprintf(&partcode, "81");
+        mr_asprintf(&partcode, "81");
     } else if (strcmp(format, "raid") == 0) {
-        asprintf(&partcode, "fd");
+        mr_asprintf(&partcode, "fd");
     } else if ((strcmp(format, "ufs") == 0)
                || (strcmp(format, "ffs") == 0)) {   /* raid autodetect */
-        asprintf(&partcode, "a5");
+        mr_asprintf(&partcode, "a5");
     } else if (strcmp(format, "lvm") == 0) {
-        asprintf(&partcode, "8e");
+        mr_asprintf(&partcode, "8e");
     } else if (format[0] == '\0') { /* LVM physical partition */
-        asprintf(&partcode, "%s", "");
+        mr_asprintf(&partcode, "%s", "");
     } else if (strlen(format) >= 1 && strlen(format) <= 2) {
-        asprintf(&partcode, format);
+        mr_asprintf(&partcode, format);
     } else {
         /* probably an image */
-        asprintf(&tmp,
+        mr_asprintf(&tmp,
                 "Unknown format ('%s') - using supplied string anyway",
                 format);
         mvaddstr_and_log_it(g_currentY++, 0, tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
 #ifdef __FreeBSD__
-        asprintf(&partcode, format);    // was a5
+        mr_asprintf(&partcode, format); // was a5
 #else
-        asprintf(&partcode, format);    // was 83
-#endif
-    }
-    asprintf(&tmp, "Setting %s's type to %s (%s)", partition, format,
+        mr_asprintf(&partcode, format); // was 83
+#endif
+    }
+    mr_asprintf(&tmp, "Setting %s's type to %s (%s)", partition, format,
             partcode);
-    paranoid_free(partition);
+    mr_free(partition);
 
     log_msg(1, tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
     if (partcode[0] != '\0' && strcmp(partcode, "83")) {    /* no need to set type if 83: 83 is default */
 
@@ -2111 +2112 @@
                 || strstr(tmp1, " (1-4)")) {
                 log_msg(5, "Specifying partno (%d) - yay", partno);
-                asprintf(&tmp, "%d\n", partno);
+                mr_asprintf(&tmp, "%d\n", partno);
                 fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
-                paranoid_free(tmp);
-                paranoid_free(tmp1);
+                mr_free(tmp);
+                mr_free(tmp1);
                 tmp1 = last_line_of_file(FDISK_LOG);
                 log_msg(5, "A - last line = '%s'", tmp1);
             }
-            paranoid_free(tmp1);
-
-            asprintf(&tmp, "%s\n", partcode);
+            mr_free(tmp1);
+
+            mr_asprintf(&tmp, "%s\n", partcode);
             fput_string_one_char_at_a_time(pout_to_fdisk, tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
             tmp1 = last_line_of_file(FDISK_LOG);
             log_msg(5, "B - last line = '%s'",tmp1);
-            paranoid_free(tmp1);
+            mr_free(tmp1);
 
             fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
             tmp1 = last_line_of_file(FDISK_LOG);
             log_msg(5, "C - last line = '%s'",tmp1);
-            paranoid_free(tmp1);
+            mr_free(tmp1);
 
             tmp = last_line_of_file(FDISK_LOG);
@@ -2138 +2139 @@
                 fput_string_one_char_at_a_time(pout_to_fdisk, "\n");
             }
-            paranoid_free(tmp);
+            mr_free(tmp);
             fput_string_one_char_at_a_time(pout_to_fdisk, "p\n");
         } else {
-            asprintf(&output, "t\n%d\n%s\nw\n", partno, partcode);
-            asprintf(&command, "parted2fdisk %s >> %s 2>> %s", drive,
+            mr_asprintf(&output, "t\n%d\n%s\nw\n", partno, partcode);
+            mr_asprintf(&command, "parted2fdisk %s >> %s 2>> %s", drive,
                     MONDO_LOGFILE, MONDO_LOGFILE);
             log_msg(5, "output = '%s'", output);
@@ -2156 +2157 @@
                 paranoid_pclose(fout);
             }
-            paranoid_free(command);
-            paranoid_free(output);
+            mr_free(command);
+            mr_free(output);
         }
         /* BERLIOS: Useless as command not initialized in all cases
@@ -2165 +2166 @@
         */
     }
-    paranoid_free(partcode);
+    mr_free(partcode);
 
 
@@ -2190 +2191 @@
         return 1;
     }
-    asprintf(&program, "vinum start -f %s", raid_device);
+    mr_asprintf(&program, "vinum start -f %s", raid_device);
 #else
-    asprintf(&program, "raidstart %s", raid_device);
+    mr_asprintf(&program, "raidstart %s", raid_device);
 #endif
     log_msg(1, "program = %s", program);
@@ -2199 +2200 @@
         fprintf(g_fprep, "%s\n", program);
     }
-    paranoid_free(program);
+    mr_free(program);
 
     if (res) {
@@ -2234 +2235 @@
         return 1;
     }
-    asprintf(&program, "vinum stop -f %s", raid_device);
+    mr_asprintf(&program, "vinum stop -f %s", raid_device);
 #else
     // use raidstop if it exists, otherwise use mdadm
     if (run_program_and_log_output("which raidstop", FALSE)) {
-        asprintf(&program, "mdadm -S %s", raid_device);
+        mr_asprintf(&program, "mdadm -S %s", raid_device);
     } else {
-        asprintf(&program, "raidstop %s", raid_device);
+        mr_asprintf(&program, "raidstop %s", raid_device);
     }
 #endif
@@ -2248 +2249 @@
         fprintf(g_fprep, "%s\n", program);
     }
-    paranoid_free(program);
+    mr_free(program);
 
     if (res) {
@@ -2322 +2323 @@
             return (1);
         }
-        for (getline(&incoming, &n, fin); !feof(fin);
-             getline(&incoming, &n, fin)) {
+        for (mr_getline(&incoming, &n, fin); !feof(fin);
+             mr_getline(&incoming, &n, fin)) {
             retval += stop_raid_device(incoming);
         }
@@ -2332 +2333 @@
             return (1);
         }
-        for (getline(&incoming, &n, fin); !feof(fin);
-             getline(&incoming, &n, fin)) {
+        for (mr_getline(&incoming, &n, fin); !feof(fin);
+             mr_getline(&incoming, &n, fin)) {
             for (p = incoming;
                  *p != '\0' && (*p != 'm' || *(p + 1) != 'd'
                                 || !isdigit(*(p + 2))); p++);
             if (*p != '\0') {
-                asprintf(&dev, "/dev/%s", p);
+                mr_asprintf(&dev, "/dev/%s", p);
                 /* BERLIOS : 32 Hard coded value */
                 for (p = dev; *p > 32; p++);
                 *p = '\0';
                 res = stop_raid_device(dev);
-                paranoid_free(dev);
-            }
-        }
-#endif
-        paranoid_free(incoming);
+                mr_free(dev);
+            }
+        }
+#endif
+        mr_free(incoming);
     }
     paranoid_fclose(fin);
@@ -2381 +2382 @@
     if (strcmp(format, "swap") == 0) {
 #ifdef __FreeBSD__
-        asprintf(&program, "true");
+        mr_asprintf(&program, "true");
 #else
-        asprintf(&program, "mkswap");
+        mr_asprintf(&program, "mkswap");
 #endif
     } else if (strcmp(format, "vfat") == 0) {
-        asprintf(&program, "format-and-kludge-vfat");
+        mr_asprintf(&program, "format-and-kludge-vfat");
 #ifndef __FreeBSD__
     } else if (strcmp(format, "reiserfs") == 0) {
-        asprintf(&program, "mkreiserfs -ff");
+        mr_asprintf(&program, "mkreiserfs -ff");
     } else if (strcmp(format, "xfs") == 0) {
-        asprintf(&program, "mkfs.xfs -f -q");
+        mr_asprintf(&program, "mkfs.xfs -f -q");
     } else if (strcmp(format, "jfs") == 0) {
-        asprintf(&program, "mkfs.jfs");
+        mr_asprintf(&program, "mkfs.jfs");
     } else if (strcmp(format, "ext3") == 0) {
-        asprintf(&program, "mkfs -t ext2 -F -j -q");
+        mr_asprintf(&program, "mkfs -t ext2 -F -j -q");
     } else if (strcmp(format, "minix") == 0) {
-        asprintf(&program, "mkfs.minix");
+        mr_asprintf(&program, "mkfs.minix");
 #endif
     } else if (strcmp(format, "ext2") == 0) {
-        asprintf(&program, "mke2fs -F -q");
+        mr_asprintf(&program, "mke2fs -F -q");
     } else {
 #ifdef __FreeBSD__
-        asprintf(&program, "newfs_%s", format);
+        mr_asprintf(&program, "newfs_%s", format);
 #else
-        asprintf(&program, "mkfs -t %s -c", format);    // -c checks for bad blocks
-#endif
-        asprintf(&tmp, "Unknown format (%s) - assuming '%s' will do", format,
+        mr_asprintf(&program, "mkfs -t %s -c", format); // -c checks for bad blocks
+#endif
+        mr_asprintf(&tmp, "Unknown format (%s) - assuming '%s' will do", format,
                 program);
         log_it(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         res = 0;
     }
@@ -2448 +2449 @@
             original_size_of_drive += mountlist->el[partno].size;
         } else {
-            asprintf(&tmp, "Skipping %s", mountlist->el[partno].device);
+            mr_asprintf(&tmp, "Skipping %s", mountlist->el[partno].device);
 //                      log_to_screen(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
         }
     }
@@ -2512 +2513 @@
         return;
     }
-    asprintf(&tmp, _("Expanding entries to suit drive %s (%ld MB)"),
+    mr_asprintf(&tmp, _("Expanding entries to suit drive %s (%ld MB)"),
             drive_name, current_size_of_drive);
     log_to_screen(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     drivemntlist = malloc(sizeof(struct mountlist_reference));
@@ -2532 +2533 @@
 
     if (original_size_of_drive <= 0) {
-        asprintf(&tmp, _("Cannot resize %s's entries. Drive not found."),
+        mr_asprintf(&tmp, _("Cannot resize %s's entries. Drive not found."),
                 drive_name);
         log_to_screen(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         return;
     }
     factor =
         (float) (current_size_of_drive) / (float) (original_size_of_drive);
-    asprintf(&tmp, "Disk %s was %ld MB; is now %ld MB; factor = %f",
+    mr_asprintf(&tmp, "Disk %s was %ld MB; is now %ld MB; factor = %f",
             drive_name, original_size_of_drive, current_size_of_drive,
             factor);
     log_to_screen(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     lastpart = drivemntlist->entries - 1;
@@ -2563 +2564 @@
             newsizL = (long) new_size;
         }
-        asprintf(&tmp, _("Changing %s from %lld KB to %ld KB"),
+        mr_asprintf(&tmp, _("Changing %s from %lld KB to %ld KB"),
                 drivemntlist->el[partno]->device,
                 drivemntlist->el[partno]->size, newsizL);
         log_to_screen(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         drivemntlist->el[partno]->size = newsizL;
     }
     final_size = get_phys_size_of_drive(drive_name);
-    asprintf(&tmp, _("final_size = %ld MB"), final_size);
+    mr_asprintf(&tmp, _("final_size = %ld MB"), final_size);
     log_to_screen(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 }
 
@@ -2613 +2614 @@
     }
     log_to_screen(_("Mountlist adjusted to suit current hard drive(s)"));
-    paranoid_free(drivelist);
+    mr_free(drivelist);
 }
 
@@ -2637 +2638 @@
     log_msg(1, "Creating list of partitions for drive %s", drive_name);
 
-    asprintf(&tmp_drive_name,drive_name);
+    mr_asprintf(&tmp_drive_name,drive_name);
     if (!tmp_drive_name)
         fatal_error("Out of memory");
@@ -2657 +2658 @@
         }
     }
-    paranoid_free(tmp_drive_name);
+    mr_free(tmp_drive_name);
 }
 

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

@@ -23 +23 @@
 #include <pthread.h>
 #endif
+#include "mr_mem.h"
 
 extern void twenty_seconds_til_yikes(void);
@@ -160 +161 @@
     assert(raidlist != NULL);
     if (!bkpinfo->disaster_recovery) {
-        paranoid_alloc(g_mountlist_fname, "/tmp/mountlist.txt");
+        mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
         log_msg(2, "I guess you're testing edit_mountlist()");
     }
@@ -274 +275 @@
         }
         if (g_ISO_restore_mode) {
-            asprintf(&tmp, "umount %s", bkpinfo->isodir);
+            mr_asprintf(&tmp, "umount %s", bkpinfo->isodir);
             run_program_and_log_output(tmp, FALSE);
-            paranoid_free(tmp);
+            mr_free(tmp);
         }
         paranoid_MR_finish(0);
@@ -386 +387 @@
             save_mountlist_to_disk(mountlist, g_mountlist_fname);
             tmp1 = find_my_editor();
-            asprintf(&tmp, "%s %s", tmp1, g_mountlist_fname);
-            paranoid_free(tmp1);
+            mr_asprintf(&tmp, "%s %s", tmp1, g_mountlist_fname);
+            mr_free(tmp1);
 
             res = system(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
             load_mountlist(mountlist, g_mountlist_fname);
         } else {
@@ -500 +501 @@
              ask_me_yes_or_no
              (_("Do you want me to restore _some_ of your data?")))) {
-        asprintf(&old_restpath,bkpinfo->restore_path);
+        mr_asprintf(&old_restpath,bkpinfo->restore_path);
         for (done = FALSE; !done;) {
             unlink("/tmp/filelist.full");
@@ -514 +515 @@
                     if (!strcmp(bkpinfo->restore_path, "/")) {
                         if (!ask_me_yes_or_no(_("Are you sure?"))) {
-                            paranoid_alloc(bkpinfo->restore_path, old_restpath);
+                            mr_allocstr(bkpinfo->restore_path, old_restpath);
                             goto gotos_suck;
                         }
-                        paranoid_alloc(bkpinfo->restore_path, "");  // so we restore to [blank]/file/name :)
+                        mr_allocstr(bkpinfo->restore_path, ""); // so we restore to [blank]/file/name :)
                     }
                     log_msg(1, "Restoring subset");
@@ -523 +524 @@
                     free_filelist(filelist);
                 } else {
-                    paranoid_alloc(bkpinfo->restore_path,old_restpath);
+                    mr_allocstr(bkpinfo->restore_path,old_restpath);
                     free_filelist(filelist);
                 }
@@ -534 +535 @@
             }
         }
-        paranoid_free(old_restpath);
+        mr_free(old_restpath);
     } else {
         mvaddstr_and_log_it(g_currentY++,
@@ -567 +568 @@
                             ("Using e2label to label your ext2,3 partitions"));
         if (does_file_exist("/tmp/fstab.new")) {
-            asprintf(&fstab_fname, "/tmp/fstab.new");
+            mr_asprintf(&fstab_fname, "/tmp/fstab.new");
         } else {
-            asprintf(&fstab_fname, "/tmp/fstab");
-        }
-        asprintf(&tmp,
+            mr_asprintf(&fstab_fname, "/tmp/fstab");
+        }
+        mr_asprintf(&tmp,
                 "label-partitions-as-necessary %s < %s >> %s 2>> %s",
                 g_mountlist_fname, fstab_fname, MONDO_LOGFILE,
                 MONDO_LOGFILE);
-        paranoid_free(fstab_fname);
+        mr_free(fstab_fname);
 
         res = system(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         if (res) {
             log_to_screen
@@ -679 +680 @@
             (strstr(tmp1,"RESTORE") == NULL)) {
                 /* -H option */
-                asprintf(&tmp,
+                mr_asprintf(&tmp,
                     _
                     (" Mondo has restored your system. Please remove the backup media and reboot.\n\nPlease visit our website at http://www.mondorescue.org for more information."));
                 popup_and_OK(tmp);
-                paranoid_free(tmp);
-        }
-        paranoid_free(tmp1);
+                mr_free(tmp);
+        }
+        mr_free(tmp1);
 
         log_to_screen(_
@@ -739 +740 @@
         resize_mountlist_proportionately_to_suit_new_drives(mountlist);
     }
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     if (!evaluate_mountlist(mountlist, tmpA, tmpB, tmpC)) {
-        asprintf(&tmp,
+        mr_asprintf(&tmp,
                 _
                 ("Mountlist analyzed. Result: \"%s %s %s\" Switch to Interactive Mode?"),
                 tmpA, tmpB, tmpC);
         if (ask_me_yes_or_no(tmp)) {
-            paranoid_free(tmp);
+            mr_free(tmp);
             retval = interactive_mode(bkpinfo, mountlist, raidlist);
             goto after_the_nuke;
         } else {
-            paranoid_free(tmp);
+            mr_free(tmp);
             fatal_error("Nuke Mode aborted. ");
         }
@@ -787 +788 @@
                 }
             }
-            paranoid_free(tmp);
+            mr_free(tmp);
 
             retval += res;
@@ -840 +841 @@
                         ("Using e2label to label your ext2,3 partitions"));
 
-    asprintf(&tmp, "label-partitions-as-necessary %s < /tmp/fstab",
+    mr_asprintf(&tmp, "label-partitions-as-necessary %s < /tmp/fstab",
             g_mountlist_fname);
     res = run_program_and_log_output(tmp, TRUE);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     if (res) {
@@ -916 +917 @@
     }
 
-    paranoid_alloc(bkpinfo->restore_path, "/");
+    mr_allocstr(bkpinfo->restore_path, "/");
     if (!g_restoring_live_from_cd) {
         popup_and_OK
@@ -945 +946 @@
     if (filelist) {
         save_filelist(filelist, "/tmp/selected-files.txt");
-        asprintf(&old_restpath,bkpinfo->restore_path);
+        mr_asprintf(&old_restpath,bkpinfo->restore_path);
         if (popup_and_get_string(_("Restore path"),
                                  _("Restore files to where? )"),
@@ -953 +954 @@
         }
         free_filelist(filelist);
-        paranoid_alloc(bkpinfo->restore_path,old_restpath);
+        mr_allocstr(bkpinfo->restore_path,old_restpath);
     }
     if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
@@ -1034 +1035 @@
     if (!(fin = fopen(tmp,"r"))) {
         log_to_screen(_("Cannot even open bigfile's info file"));
-        paranoid_free(tmp);
+        mr_free(tmp);
         return (pathname_of_last_file_restored);
     }
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     memset((void *) &biggiestruct, 0, sizeof(biggiestruct));
@@ -1047 +1048 @@
     paranoid_fclose(fin);
 
-    asprintf(&checksum, biggiestruct.checksum);
+    mr_asprintf(&checksum, biggiestruct.checksum);
 
     if (!checksum[0]) {
-        asprintf(&tmp, "Warning - bigfile %ld does not have a checksum",
+        mr_asprintf(&tmp, "Warning - bigfile %ld does not have a checksum",
                 bigfileno + 1);
         log_msg(3, tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         /* BERLIOS : Useless ???
         p = checksum;
         */
     }
-    paranoid_free(checksum);
+    mr_free(checksum);
 
     if (!strncmp(biggiestruct.filename, "/dev/", 5))    // Whether NTFS or not :)
     {
-        asprintf(&outfile_fname, biggiestruct.filename);
+        mr_asprintf(&outfile_fname, biggiestruct.filename);
     } else {
-        asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
+        mr_asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
                 biggiestruct.filename);
     }
@@ -1101 +1102 @@
                 "Calling ntfsclone in background because %s is an NTFS /dev entry",
                 outfile_fname);
-        asprintf(&ntfsprog_fifo, "/tmp/%d.%d.000", (int) (random() % 32768),
+        mr_asprintf(&ntfsprog_fifo, "/tmp/%d.%d.000", (int) (random() % 32768),
                 (int) (random() % 32768));
         mkfifo(ntfsprog_fifo, 0x770);
@@ -1125 +1126 @@
         }
         // BERLIOS: Is it the right place ??
-        paranoid_free(ntfsprog_fifo);
+        mr_free(ntfsprog_fifo);
     } else {
         use_ntfsprog_hack = FALSE;
@@ -1135 +1136 @@
     }
 
-    asprintf(&tmp, "Reassembling big file %ld (%s)", bigfileno + 1,
+    mr_asprintf(&tmp, "Reassembling big file %ld (%s)", bigfileno + 1,
             outfile_fname);
     log_msg(2, tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     /*
@@ -1146 +1147 @@
      */
 
-    asprintf(&pathname_of_last_file_restored, biggiestruct.filename);
+    mr_asprintf(&pathname_of_last_file_restored, biggiestruct.filename);
 
     log_msg(3, "file_to_openout = %s", file_to_openout);
@@ -1165 +1166 @@
                     g_current_media_number);
             g_current_media_number++;
-            asprintf(&tmp3,
+            mr_asprintf(&tmp3,
                     "Asking for %s #%d so that I may read slice #%ld\n",
                     bkpinfo->backup_media_string,
                     g_current_media_number, sliceno);
             log_msg(2, tmp3);
-            paranoid_free(tmp3);
-
-            asprintf(&tmp3, _("Restoring from %s #%d"),
+            mr_free(tmp3);
+
+            mr_asprintf(&tmp3, _("Restoring from %s #%d"),
                     bkpinfo->backup_media_string,
                     g_current_media_number);
             log_to_screen(tmp3);
-            paranoid_free(tmp3);
+            mr_free(tmp3);
 
             insist_on_this_cd_number(bkpinfo, g_current_media_number);
@@ -1189 +1190 @@
             } else {
                 if (does_file_exist(tmp1)) {
-                    asprintf(&bzip2_command, "lzop -dc %s 2>> %s",tmp1, MONDO_LOGFILE);
+                    mr_asprintf(&bzip2_command, "lzop -dc %s 2>> %s",tmp1, MONDO_LOGFILE);
                 } else if (does_file_exist(tmp2)) {
-                        asprintf(&bzip2_command, "bzip2 -dc %s 2>> %s",tmp2, MONDO_LOGFILE);
+                        mr_asprintf(&bzip2_command, "bzip2 -dc %s 2>> %s",tmp2, MONDO_LOGFILE);
                 } else if (does_file_exist(tmp)) {
-                        asprintf(&bzip2_command, "%s", "");
+                        mr_asprintf(&bzip2_command, "%s", "");
                 } else {
                     log_to_screen(_("OK, that's pretty fsck0red..."));
@@ -1201 +1202 @@
 
             if (bzip2_command == NULL) {
-                asprintf(&bzip2_command, "cat %s 2>> %s", tmp, MONDO_LOGFILE);
-            }
-            asprintf(&tmp3, "Working on %s #%d, file #%ld, slice #%ld ",
+                mr_asprintf(&bzip2_command, "cat %s 2>> %s", tmp, MONDO_LOGFILE);
+            }
+            mr_asprintf(&tmp3, "Working on %s #%d, file #%ld, slice #%ld ",
                     bkpinfo->backup_media_string,
                     g_current_media_number, bigfileno + 1, sliceno);
@@ -1212 +1213 @@
                 update_progress_form(tmp3);
             }
-            paranoid_free(tmp3);
+            mr_free(tmp3);
 
             if (!(fbzip2 = popen(bzip2_command, "r"))) {
                 fatal_error("Can't run popen command");
             }
-            paranoid_free(bzip2_command);
+            mr_free(bzip2_command);
 
             while (!feof(fbzip2)) {
@@ -1223 +1224 @@
                 if (siz > 0) {
                     siz1 = fwrite(bigblk, 1, siz, fout);
-                    asprintf(&sz_msg, "Read %ld from fbzip2; written %ld to fout", siz, siz1);
+                    mr_asprintf(&sz_msg, "Read %ld from fbzip2; written %ld to fout", siz, siz1);
                     log_it(sz_msg);
-                    paranoid_free(sz_msg);
+                    mr_free(sz_msg);
                 }
             }
@@ -1234 +1235 @@
             g_current_progress++;
         }
-        paranoid_free(tmp);
-        paranoid_free(tmp1);
-        paranoid_free(tmp2);
+        mr_free(tmp);
+        mr_free(tmp1);
+        mr_free(tmp2);
     }
     paranoid_fclose(fout);
@@ -1243 +1244 @@
     if (use_ntfsprog_hack) {
         log_msg(3, "Waiting for ntfsclone to finish");
-        asprintf(&tmp,
+        mr_asprintf(&tmp,
                 " ps | grep \" ntfsclone \" | grep -v grep > /dev/null 2> /dev/null");
         while (system(tmp) == 0) {
             sleep(1);
         }
-        paranoid_free(tmp);
+        mr_free(tmp);
         log_it("OK, ntfsclone has really finished");
     }
@@ -1260 +1261 @@
         utime(outfile_fname, ubuf);
     }
-    paranoid_free(outfile_fname);
-    paranoid_free(bigblk);
+    mr_free(outfile_fname);
+    mr_free(bigblk);
 
     return (pathname_of_last_file_restored);
@@ -1329 +1330 @@
     }
 
-    asprintf(&pathname_of_last_file_restored, orig_bf_fname);
+    mr_asprintf(&pathname_of_last_file_restored, orig_bf_fname);
 
     /* open out to biggiefile to be restored (or /dev/null if biggiefile is not to be restored) */
@@ -1359 +1360 @@
     if (use_ntfsprog) {
         g_loglevel = 4;
-        asprintf(&outfile_fname, orig_bf_fname);
+        mr_asprintf(&outfile_fname, orig_bf_fname);
         use_ntfsprog_hack = TRUE;
         log_msg(2,
                 "Calling ntfsclone in background because %s is a /dev entry",
                 outfile_fname);
-        asprintf(&ntfsprog_fifo, "%s/%d.%d.000", 
+        mr_asprintf(&ntfsprog_fifo, "%s/%d.%d.000", 
                 bkpinfo->tmpdir,
                 (int) (random() % 32768),
@@ -1387 +1388 @@
                     (long int) (pid));
         }
-        paranoid_free(ntfsprog_fifo);
+        mr_free(ntfsprog_fifo);
     } else {
         if (!strncmp(orig_bf_fname, "/dev/", 5))    // non-NTFS partition
         {
-            asprintf(&outfile_fname, orig_bf_fname);
+            mr_asprintf(&outfile_fname, orig_bf_fname);
         } else                  // biggiefile
         {
-            asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
+            mr_asprintf(&outfile_fname, "%s/%s", bkpinfo->restore_path,
                     orig_bf_fname);
         }
@@ -1403 +1404 @@
             make_hole_for_file(outfile_fname);
         }
-        asprintf(&tmp1, "Reassembling big file %ld (%s)",
+        mr_asprintf(&tmp1, "Reassembling big file %ld (%s)",
                 biggiefile_number + 1, orig_bf_fname);
         log_msg(2, tmp1);
-        paranoid_free(tmp1);
+        mr_free(tmp1);
     }
 
     if (dummy_restore) {
-        paranoid_free(outfile_fname);
-        asprintf(&outfile_fname, "/dev/null");
+        mr_free(outfile_fname);
+        mr_asprintf(&outfile_fname, "/dev/null");
     }
 
     if (bkpinfo->zip_exe == NULL) {
-        asprintf(&command, "cat > \"%s\"", file_to_openout);
+        mr_asprintf(&command, "cat > \"%s\"", file_to_openout);
     } else {
-        asprintf(&command, "%s -dc > \"%s\" 2>> %s", bkpinfo->zip_exe,
+        mr_asprintf(&command, "%s -dc > \"%s\" 2>> %s", bkpinfo->zip_exe,
                 file_to_openout, MONDO_LOGFILE);
     }
-    asprintf(&tmp1, "Pipe command = '%s'", command);
+    mr_asprintf(&tmp1, "Pipe command = '%s'", command);
     log_msg(3, tmp1);
-    paranoid_free(tmp1);
+    mr_free(tmp1);
 
     /* restore biggiefile, one slice at a time */
@@ -1428 +1429 @@
         fatal_error("Cannot pipe out");
     }
-    paranoid_free(command);
+    mr_free(command);
 
     for (res = read_header_block_from_stream(&slice_siz, tmp, &ctrl_chr);
@@ -1436 +1437 @@
             wrong_marker(BLK_START_AN_AFIO_OR_SLICE, ctrl_chr);
         }
-        asprintf(&tmp1, "Working on file #%ld, slice #%ld    ",
+        mr_asprintf(&tmp1, "Working on file #%ld, slice #%ld    ",
                 biggiefile_number + 1, current_slice_number);
         log_msg(2, tmp1);
@@ -1446 +1447 @@
         strip_spaces(tmp1);
         update_progress_form(tmp1);
-        paranoid_free(tmp1);
+        mr_free(tmp1);
 
         if (current_slice_number == 0) {
@@ -1477 +1478 @@
         g_current_progress++;
     }
-    paranoid_free(tmp);
+    mr_free(tmp);
     paranoid_pclose(pout);
 
@@ -1485 +1486 @@
     if (use_ntfsprog_hack) {
         log_msg(3, "Waiting for ntfsclone to finish");
-        asprintf(&tmp,
+        mr_asprintf(&tmp,
                 " ps | grep \" ntfsclone \" | grep -v grep > /dev/null 2> /dev/null");
         while (system(tmp) == 0) {
             sleep(1);
         }   
-        paranoid_free(tmp);
+        mr_free(tmp);
         log_msg(3, "OK, ntfsclone has really finished");
     }
@@ -1505 +1506 @@
     }
 
-    paranoid_free(outfile_fname);
+    mr_free(outfile_fname);
     g_loglevel = old_loglevel;
     return (pathname_of_last_file_restored);
@@ -1551 +1552 @@
     log_msg(5, "Entering");
     use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
-    asprintf(&command, "mkdir -p %s/tmp", MNT_RESTORING);
+    mr_asprintf(&command, "mkdir -p %s/tmp", MNT_RESTORING);
     run_program_and_log_output(command, 9);
-    paranoid_free(command);
-
-    asprintf(&filelist_name, MNT_CDROM "/archives/filelist.%ld",
+    mr_free(command);
+
+    mr_asprintf(&filelist_name, MNT_CDROM "/archives/filelist.%ld",
             current_tarball_number);
     if (length_of_file(filelist_name) <= 2) {
@@ -1572 +1573 @@
         log_msg(3, "length_of_file(%s) = %llu", tarball_fname,
                 length_of_file(tarball_fname));
-        asprintf(&tmp, "Unable to restore fileset #%ld (CD I/O error)",
+        mr_asprintf(&tmp, "Unable to restore fileset #%ld (CD I/O error)",
                 current_tarball_number);
         log_to_screen(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         retval = 1;
         log_msg(5, "Leaving");
@@ -1582 +1583 @@
 
     if (filelist) {
-        asprintf(&filelist_subset_fname, "/tmp/filelist-subset-%ld.tmp",
+        mr_asprintf(&filelist_subset_fname, "/tmp/filelist-subset-%ld.tmp",
                 current_tarball_number);
         if ((matches =
@@ -1589 +1590 @@
                                              use_star))
             <= 0) {
-            asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
+            mr_asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
             log_msg(1, tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
         } else {
             log_msg(3, "Saved fileset %ld's subset to %s",
                     current_tarball_number, filelist_subset_fname);
         }
-        asprintf(&tmp, "Tarball #%ld --- %ld matches",
+        mr_asprintf(&tmp, "Tarball #%ld --- %ld matches",
                 current_tarball_number, matches);
         log_to_screen(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
     } else {
         filelist_subset_fname = NULL;
     }
-    paranoid_free(filelist_name);
+    mr_free(filelist_name);
 
     if (filelist == NULL || matches > 0) {
-        asprintf(&xattr_fname, XATTR_LIST_FNAME_RAW_SZ,
+        mr_asprintf(&xattr_fname, XATTR_LIST_FNAME_RAW_SZ,
                 MNT_CDROM "/archives", current_tarball_number);
-        asprintf(&acl_fname, ACL_LIST_FNAME_RAW_SZ, MNT_CDROM "/archives",
+        mr_asprintf(&acl_fname, ACL_LIST_FNAME_RAW_SZ, MNT_CDROM "/archives",
                 current_tarball_number);
         if (strstr(tarball_fname, ".bz2")) {
-            asprintf(&executable, "bzip2");
+            mr_asprintf(&executable, "bzip2");
         } else if (strstr(tarball_fname, ".lzo")) {
-            asprintf(&executable, "lzop");
+            mr_asprintf(&executable, "lzop");
         } else {
             executable = NULL;
@@ -1619 +1620 @@
 
         if (executable == NULL) {
-            asprintf(&tmp, "which %s > /dev/null 2> /dev/null", executable);
+            mr_asprintf(&tmp, "which %s > /dev/null 2> /dev/null", executable);
             if (run_program_and_log_output(tmp, FALSE)) {
                 log_to_screen
@@ -1626 +1627 @@
                 paranoid_MR_finish(1);
             }
-            paranoid_free(tmp);
-
-            asprintf(&tmp, executable);
-            asprintf(&executable, "-P %s -Z", tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
+
+            mr_asprintf(&tmp, executable);
+            mr_asprintf(&executable, "-P %s -Z", tmp);
+            mr_free(tmp);
         }
 #ifdef __FreeBSD__
@@ -1638 +1639 @@
 #endif
 
-        asprintf(&temp_log, "/tmp/%d.%d", (int) (random() % 32768),
+        mr_asprintf(&temp_log, "/tmp/%d.%d", (int) (random() % 32768),
             (int) (random() % 32768));
 
         if (use_star) {
             if (strstr(tarball_fname, ".bz2")) {
-                asprintf(&tmp, " -bz");
+                mr_asprintf(&tmp, " -bz");
             } else {
-                asprintf(&tmp, "%s", "");
-            }
-            asprintf(&command,
+                mr_asprintf(&tmp, "%s", "");
+            }
+            mr_asprintf(&command,
                     "star -x -force-remove -U " STAR_ACL_SZ
                     " errctl= file=%s %s 2>> %s >> %s", tarball_fname, tmp, temp_log, temp_log);
-            paranoid_free(tmp);
+            mr_free(tmp);
         } else {
             if (filelist_subset_fname != NULL) {
-                asprintf(&command,
+                mr_asprintf(&command,
                         "afio -i -M 8m -b %ld -c %ld %s -w '%s' %s 2>> %s >> %s",
                         TAPE_BLOCK_SIZE,
@@ -1660 +1661 @@
                         tarball_fname, temp_log, temp_log);
             } else {
-                asprintf(&command,
+                mr_asprintf(&command,
                         "afio -i -b %ld -c %ld -M 8m %s %s 2>> %s >> %s",
                         TAPE_BLOCK_SIZE,
@@ -1666 +1667 @@
             }
         }
-        paranoid_free(executable);
+        mr_free(executable);
 
 #undef BUFSIZE
@@ -1680 +1681 @@
             }
         }
-        paranoid_free(command);
+        mr_free(command);
 
         if (res && length_of_file(temp_log) < 5) {
@@ -1711 +1712 @@
         }
         if (retval) {
-            asprintf(&command, "cat %s >> %s", temp_log, MONDO_LOGFILE);
+            mr_asprintf(&command, "cat %s >> %s", temp_log, MONDO_LOGFILE);
             system(command);
-            paranoid_free(command);
+            mr_free(command);
             log_msg(2, "Errors occurred while processing fileset #%d",
                     current_tarball_number);
@@ -1720 +1721 @@
         }
         unlink(xattr_fname);
-        paranoid_free(xattr_fname);
+        mr_free(xattr_fname);
     }
     if (does_file_exist("/PAUSE")) {
@@ -1731 +1732 @@
     unlink(temp_log);
 
-    paranoid_free(filelist_subset_fname);
-    paranoid_free(acl_fname);
-    paranoid_free(temp_log);
+    mr_free(filelist_subset_fname);
+    mr_free(acl_fname);
+    mr_free(temp_log);
 
     log_msg(5, "Leaving");
@@ -1785 +1786 @@
     /* to do it with a file... */
     use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
-    asprintf(&tmp,
+    mr_asprintf(&tmp,
             "Restoring from fileset #%ld (%ld KB) on %s #%d",
             current_tarball_number, (long) size >> 10,
@@ -1791 +1792 @@
             g_current_media_number);
     log_msg(2, tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
     run_program_and_log_output("mkdir -p " MNT_RESTORING "/tmp", FALSE);
 
@@ -1799 +1800 @@
    * in afio or someting; oh darn.. OK, use tmpfs :-)                         *
    ****************************************************************************/
-    asprintf(&afio_fname, "/tmp/tmpfs/archive.tmp.%ld",
+    mr_asprintf(&afio_fname, "/tmp/tmpfs/archive.tmp.%ld",
             current_tarball_number);
-    asprintf(&filelist_fname, "%s/filelist.%ld", bkpinfo->tmpdir,
+    mr_asprintf(&filelist_fname, "%s/filelist.%ld", bkpinfo->tmpdir,
             current_tarball_number);
-    asprintf(&filelist_subset_fname, "%s/filelist-subset-%ld.tmp",
+    mr_asprintf(&filelist_subset_fname, "%s/filelist-subset-%ld.tmp",
             bkpinfo->tmpdir, current_tarball_number);
     res = read_file_from_stream_to_file(bkpinfo, afio_fname, size);
@@ -1814 +1815 @@
     if (bkpinfo->compression_level != 0) {
         if (bkpinfo->use_star) {
-            asprintf(&executable, " -bz");
+            mr_asprintf(&executable, " -bz");
         } else {
-            asprintf(&executable, "-P %s -Z", bkpinfo->zip_exe);
+            mr_asprintf(&executable, "-P %s -Z", bkpinfo->zip_exe);
         }
     }
@@ -1827 +1828 @@
         if (strstr(tarball_fname, ".star.")) {
             use_star = TRUE;
-            asprintf(&command, "star -t file=%s %s > %s 2>> %s", afio_fname, executable, filelist_fname, MONDO_LOGFILE);
+            mr_asprintf(&command, "star -t file=%s %s > %s 2>> %s", afio_fname, executable, filelist_fname, MONDO_LOGFILE);
         } else {
             use_star = FALSE;
-            asprintf(&command, "afio -t -M 8m -b %ld %s %s > %s 2>> %s", TAPE_BLOCK_SIZE,
+            mr_asprintf(&command, "afio -t -M 8m -b %ld %s %s > %s 2>> %s", TAPE_BLOCK_SIZE,
                     executable, afio_fname, filelist_fname, MONDO_LOGFILE);
         }
@@ -1837 +1838 @@
             log_msg(4, "Warning - error occurred while retrieving TOC");
         }
-        paranoid_free(command);
+        mr_free(command);
         if ((matches =
              save_filelist_entries_in_common(filelist_fname, filelist,
@@ -1847 +1848 @@
                         current_tarball_number);
             }
-            asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
+            mr_asprintf(&tmp, "Skipping fileset %ld", current_tarball_number);
             log_msg(2, tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
             restore_this_fileset = FALSE;
         } else {
@@ -1859 +1860 @@
     }
     unlink(filelist_fname);
-    paranoid_free(filelist_fname);
+    mr_free(filelist_fname);
 
 // Concoct the call to star/afio to restore files
@@ -1865 +1866 @@
         // star
         if (filelist) {
-            asprintf(&command, "star -x file=%s %s list=%s 2>> %s", afio_fname, executable,
+            mr_asprintf(&command, "star -x file=%s %s list=%s 2>> %s", afio_fname, executable,
                     filelist_subset_fname,MONDO_LOGFILE);
         } else {
-            asprintf(&command,"star -x file=%s %s 2>> %s", afio_fname, executable,MONDO_LOGFILE);
+            mr_asprintf(&command,"star -x file=%s %s 2>> %s", afio_fname, executable,MONDO_LOGFILE);
         }
     } else {
         // afio
         if (filelist) {
-            asprintf(&command, "afio -i -M 8m -b %ld %s -w %s %s 2>> %s", TAPE_BLOCK_SIZE, executable, filelist_subset_fname,afio_fname,MONDO_LOGFILE);
+            mr_asprintf(&command, "afio -i -M 8m -b %ld %s -w %s %s 2>> %s", TAPE_BLOCK_SIZE, executable, filelist_subset_fname,afio_fname,MONDO_LOGFILE);
         } else {
-            asprintf(&command, "afio -i -M 8m -b %ld %s %s 2>> %s", TAPE_BLOCK_SIZE, executable,afio_fname,MONDO_LOGFILE);
-        }
-    }
-    paranoid_free(executable);
+            mr_asprintf(&command, "afio -i -M 8m -b %ld %s %s 2>> %s", TAPE_BLOCK_SIZE, executable,afio_fname,MONDO_LOGFILE);
+        }
+    }
+    mr_free(executable);
 
     // Call if IF there are files to restore (selectively/unconditionally)
@@ -1905 +1906 @@
         log_msg(1, "NOT CALLING '%s'", command);
     }
-    paranoid_free(command);
+    mr_free(command);
 
     if (does_file_exist("/PAUSE") && current_tarball_number >= 50) {
@@ -1915 +1916 @@
     unlink(afio_fname);
 
-    paranoid_free(filelist_subset_fname);
-    paranoid_free(afio_fname);
+    mr_free(filelist_subset_fname);
+    mr_free(afio_fname);
     return (retval);
 }
@@ -1952 +1953 @@
     assert(bkpinfo != NULL);
 
-    asprintf(&biggies_whose_EXATs_we_should_set,
+    mr_asprintf(&biggies_whose_EXATs_we_should_set,
             "%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
     if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w"))) {
@@ -1961 +1962 @@
     read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
     total_slices = atol(tmp);
-    paranoid_free(tmp);
-
-    asprintf(&tmp, _("Reassembling large files      "));
+    mr_free(tmp);
+
+    mr_asprintf(&tmp, _("Reassembling large files      "));
     mvaddstr_and_log_it(g_currentY, 0, tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     if (length_of_file(BIGGIELIST) < 6) {
@@ -1977 +1978 @@
         return (0);
     }
-    asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
+    mr_asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
             noof_biggiefiles);
     log_msg(2, tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     open_progress_form(_("Reassembling large files"),
@@ -1998 +1999 @@
             tmp1 = slice_fname(bigfileno + 1, 0, ARCHIVES_PATH, "");
             log_msg(3, "Slicename would have been %s", tmp1);
-            paranoid_free(tmp1);
+            mr_free(tmp1);
 
             // I'm not positive 'just_changed_cds' is even necessary...
@@ -2008 +2009 @@
                 insist_on_this_cd_number(bkpinfo,
                                          ++g_current_media_number);
-                asprintf(&tmp, _("Restoring from %s #%d"),
+                mr_asprintf(&tmp, _("Restoring from %s #%d"),
                         bkpinfo->backup_media_string,
                         g_current_media_number);
                 log_to_screen(tmp);
-                paranoid_free(tmp);
+                mr_free(tmp);
 
                 just_changed_cds = TRUE;
@@ -2023 +2024 @@
         } else {
             just_changed_cds = FALSE;
-            asprintf(&tmp, _("Restoring big file %ld"), bigfileno + 1);
+            mr_asprintf(&tmp, _("Restoring big file %ld"), bigfileno + 1);
             update_progress_form(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
 
             pathname_of_last_biggie_restored =
@@ -2033 +2034 @@
                 fprintf(fbw, "%s\n", pathname_of_last_biggie_restored);
             }
-            paranoid_free(pathname_of_last_biggie_restored);
+            mr_free(pathname_of_last_biggie_restored);
             retval += res;
             bigfileno++;
 
         }
-        paranoid_free(tmp);
+        mr_free(tmp);
     }
 
     if (fbw) {
         fclose(fbw);
-        asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
-        asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
+        mr_asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
+        mr_asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, ARCHIVES_PATH);
         tmp = find_home_of_exe("setfacl");
         if (length_of_file(acl_fname) > 0 && tmp) {
             set_acl_list(biggies_whose_EXATs_we_should_set, acl_fname);
         }
-        paranoid_free(tmp);
+        mr_free(tmp);
 
         tmp = find_home_of_exe("setfattr");
@@ -2055 +2056 @@
             set_fattr_list(biggies_whose_EXATs_we_should_set, xattr_fname);
         }
-        paranoid_free(tmp);
-        paranoid_free(acl_fname);
-        paranoid_free(xattr_fname);
-    }
-    paranoid_free(biggies_whose_EXATs_we_should_set);
+        mr_free(tmp);
+        mr_free(acl_fname);
+        mr_free(xattr_fname);
+    }
+    mr_free(biggies_whose_EXATs_we_should_set);
 
     if (does_file_exist("/PAUSE")) {
@@ -2117 +2118 @@
     read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
     max_val = atol(tmp) + 1;
-    paranoid_free(tmp);
-
-    asprintf(&progress_str, _("Restoring from %s #%d"),
+    mr_free(tmp);
+
+    mr_asprintf(&progress_str, _("Restoring from %s #%d"),
             bkpinfo->backup_media_string,
             g_current_media_number);
@@ -2131 +2132 @@
         update_progress_form(progress_str);
 
-        asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.bz2",
+        mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.bz2",
                 current_tarball_number);
         if (!does_file_exist(tarball_fname)) {
-            paranoid_free(tarball_fname);
-            asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.lzo",
+            mr_free(tarball_fname);
+            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.lzo",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            paranoid_free(tarball_fname);
-            asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.",
+            mr_free(tarball_fname);
+            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.afio.",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            paranoid_free(tarball_fname);
-            asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.bz2",
+            mr_free(tarball_fname);
+            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.bz2",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            paranoid_free(tarball_fname);
-            asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.",
+            mr_free(tarball_fname);
+            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%ld.star.",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            paranoid_free(tarball_fname);
+            mr_free(tarball_fname);
             if (current_tarball_number == 0) {
                 log_to_screen
@@ -2168 +2169 @@
             }
             g_current_media_number++;
-            paranoid_free(progress_str);
-            asprintf(&progress_str, _("Restoring from %s #%d"),
+            mr_free(progress_str);
+            mr_asprintf(&progress_str, _("Restoring from %s #%d"),
                     bkpinfo->backup_media_string,
                     g_current_media_number);
             log_to_screen(progress_str);
         } else {
-            paranoid_free(progress_str);
-            asprintf(&progress_str,
+            mr_free(progress_str);
+            mr_asprintf(&progress_str,
                     _("Restoring from fileset #%ld on %s #%d"),
                     current_tarball_number,
@@ -2189 +2190 @@
             }
             if (res) {
-                asprintf(&tmp1, _("reported errors"));
+                mr_asprintf(&tmp1, _("reported errors"));
             } else {
-                asprintf(&tmp1, _("succeeded"));
-            }
-            asprintf(&tmp, _("%s #%d, fileset #%ld - restore %s"),
+                mr_asprintf(&tmp1, _("succeeded"));
+            }
+            mr_asprintf(&tmp, _("%s #%d, fileset #%ld - restore %s"),
                     bkpinfo->backup_media_string,
                     g_current_media_number, current_tarball_number,tmp1);
-            paranoid_free(tmp1);
+            mr_free(tmp1);
             
             if (attempts > 1) {
-                asprintf(&tmp1, _(" (%d attempts) - review logs"), attempts);
-            }
-            asprintf(&comment, "%s%s", tmp, tmp1);
-            paranoid_free(tmp);
-            paranoid_free(tmp1);
+                mr_asprintf(&tmp1, _(" (%d attempts) - review logs"), attempts);
+            }
+            mr_asprintf(&comment, "%s%s", tmp, tmp1);
+            mr_free(tmp);
+            mr_free(tmp1);
             if (attempts > 1) {
                 log_to_screen(comment);
             }
-            paranoid_free(comment);
+            mr_free(comment);
 
             retval += res;
@@ -2213 +2214 @@
             g_current_progress++;
         }
-        paranoid_free(tarball_fname);
-    }
-    paranoid_free(progress_str);
+        mr_free(tarball_fname);
+    }
+    mr_free(progress_str);
     close_progress_form();
 
@@ -2265 +2266 @@
     read_cfg_var(g_mondo_cfg_file, "total-slices", tmp);
     total_slices = atol(tmp);
-    paranoid_free(tmp);
-
-    asprintf(&tmp, "Reassembling large files      ");
-    asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
-    asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
+    mr_free(tmp);
+
+    mr_asprintf(&tmp, "Reassembling large files      ");
+    mr_asprintf(&xattr_fname, XATTR_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
+    mr_asprintf(&acl_fname, ACL_BIGGLST_FNAME_RAW_SZ, bkpinfo->tmpdir);
     mvaddstr_and_log_it(g_currentY, 0, tmp);
-    paranoid_free(tmp);
-
-    asprintf(&biggies_whose_EXATs_we_should_set,
+    mr_free(tmp);
+
+    mr_asprintf(&biggies_whose_EXATs_we_should_set,
             "%s/biggies-whose-EXATs-we-should-set", bkpinfo->tmpdir);
     if (!(fbw = fopen(biggies_whose_EXATs_we_should_set, "w"))) {
@@ -2290 +2291 @@
 
     noof_biggiefiles = atol(biggie_fname);
-    asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
+    mr_asprintf(&tmp, "OK, there are %ld biggiefiles in the archives",
             noof_biggiefiles);
     log_msg(2, tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     open_progress_form(_("Reassembling large files"),
@@ -2319 +2320 @@
         }
         */
-        asprintf(&tmp, _("Restoring big file %ld (%lld K)"),
+        mr_asprintf(&tmp, _("Restoring big file %ld (%lld K)"),
                 current_bigfile_number + 1, biggie_size / 1024);
         update_progress_form(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
 
         pathname_of_last_biggie_restored = restore_a_biggiefile_from_stream(bkpinfo, biggie_fname,
@@ -2332 +2333 @@
             fprintf(fbw, "%s\n", pathname_of_last_biggie_restored);
         }
-        paranoid_free(pathname_of_last_biggie_restored);
+        mr_free(pathname_of_last_biggie_restored);
 
         retval += res;
@@ -2340 +2341 @@
     if (current_bigfile_number != noof_biggiefiles
         && noof_biggiefiles != 0) {
-        asprintf(&tmp, "Warning - bigfileno=%ld but noof_biggiefiles=%ld\n",
+        mr_asprintf(&tmp, "Warning - bigfileno=%ld but noof_biggiefiles=%ld\n",
                 current_bigfile_number, noof_biggiefiles);
     } else {
-        asprintf(&tmp,
+        mr_asprintf(&tmp,
                 "%ld biggiefiles in biggielist.txt; %ld biggiefiles processed today.",
                 noof_biggiefiles, current_bigfile_number);
     }
     log_msg(1, tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     if (fbw) {
@@ -2370 +2371 @@
         }
     }
-    paranoid_free(xattr_fname);
-    paranoid_free(acl_fname);
-    paranoid_free(biggies_whose_EXATs_we_should_set);
+    mr_free(xattr_fname);
+    mr_free(acl_fname);
+    mr_free(biggies_whose_EXATs_we_should_set);
 
     if (does_file_exist("/PAUSE")) {
@@ -2386 +2387 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     }
-    paranoid_free(biggie_fname);
+    mr_free(biggie_fname);
     return (retval);
 }
@@ -2428 +2429 @@
     read_cfg_var(g_mondo_cfg_file, "last-filelist-number", tmp);
     max_val = atol(tmp) + 1;
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     chdir(bkpinfo->restore_path);   /* I don't know why this is needed _here_ but it seems to be. -HR, 02/04/2002 */
@@ -2434 +2435 @@
     run_program_and_log_output("pwd", 5);
 
-    asprintf(&progress_str, _("Restoring from media #%d"),
+    mr_asprintf(&progress_str, _("Restoring from media #%d"),
             g_current_media_number);
     log_to_screen(progress_str);
@@ -2456 +2457 @@
     while (ctrl_chr != BLK_STOP_AFIOBALLS) {
         update_progress_form(progress_str);
-        asprintf(&xattr_fname, "%s/xattr-subset-%ld.tmp", bkpinfo->tmpdir,
+        mr_asprintf(&xattr_fname, "%s/xattr-subset-%ld.tmp", bkpinfo->tmpdir,
                 current_afioball_number);
-        asprintf(&acl_fname, "%s/acl-subset-%ld.tmp", bkpinfo->tmpdir,
+        mr_asprintf(&acl_fname, "%s/acl-subset-%ld.tmp", bkpinfo->tmpdir,
                 current_afioball_number);
         unlink(xattr_fname);
@@ -2473 +2474 @@
         }
         /* BERLIOS: useless ?
-        asprintf(&tmp,
+        mr_asprintf(&tmp,
                 _("Restoring from fileset #%ld (name=%s, size=%ld K)"),
                 current_afioball_number, tmp_fname, (long) tmp_size >> 10);
@@ -2484 +2485 @@
         retval += res;
         if (res) {
-            asprintf(&tmp, _("Fileset %ld - errors occurred"),
+            mr_asprintf(&tmp, _("Fileset %ld - errors occurred"),
                     current_afioball_number);
             log_to_screen(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
         }
         res =
@@ -2498 +2499 @@
         g_current_progress++;
 
-        paranoid_free(progress_str);
-        asprintf(&progress_str, _("Restoring from fileset #%ld on %s #%d"),
+        mr_free(progress_str);
+        mr_asprintf(&progress_str, _("Restoring from fileset #%ld on %s #%d"),
                 current_afioball_number,
                 bkpinfo->backup_media_string,
@@ -2507 +2508 @@
         unlink(xattr_fname);
         unlink(acl_fname);
-        paranoid_free(xattr_fname);
-        paranoid_free(acl_fname);
+        mr_free(xattr_fname);
+        mr_free(acl_fname);
     }                           // next
-    paranoid_free(progress_str);
-    paranoid_free(tmp_fname);
+    mr_free(progress_str);
+    mr_free(tmp_fname);
 
     log_msg(1, "All done with afioballs");
@@ -2555 +2556 @@
     /* BERLIOS: should test return value, or better change the function */
     getcwd(cwd, MAX_STR_LEN - 1);
-    asprintf(&tmp, "mkdir -p %s", bkpinfo->restore_path);
+    mr_asprintf(&tmp, "mkdir -p %s", bkpinfo->restore_path);
     run_program_and_log_output(tmp, FALSE);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     log_msg(1, "Changing dir to %s", bkpinfo->restore_path);
@@ -2572 +2573 @@
         newtRefresh();
     }
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     mvaddstr_and_log_it(g_currentY, 0,
@@ -2613 +2614 @@
     kill_petris();
     log_msg(2, "restore_everything() --- leaving");
-    paranoid_free(cwd);
-    paranoid_free(newpath);
+    mr_free(cwd);
+    mr_free(newpath);
     return (resA + resB);
 }
@@ -2715 +2716 @@
         g_text_mode = FALSE;
     }                           // newt :-)
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     if (!
@@ -2732 +2733 @@
 
     g_mondo_home = call_program_and_get_last_line_of_output("which mondorestore");
-    paranoid_alloc(g_tmpfs_mountpt, "/tmp/tmpfs");
+    mr_allocstr(g_tmpfs_mountpt, "/tmp/tmpfs");
     make_hole_for_dir(g_tmpfs_mountpt);
     g_current_media_number = 1; // precaution
@@ -2757 +2758 @@
 
 /* Backup original mountlist.txt */
-    asprintf(&tmp, "%s.orig", g_mountlist_fname);
+    mr_asprintf(&tmp, "%s.orig", g_mountlist_fname);
     if (!does_file_exist(g_mountlist_fname)) {
         log_msg(2,
@@ -2763 +2764 @@
                 __LINE__, g_mountlist_fname);
     } else if (!does_file_exist(tmp)) {
-        paranoid_free(tmp);
-        asprintf(&tmp, "cp -f %s %s.orig", g_mountlist_fname,
+        mr_free(tmp);
+        mr_asprintf(&tmp, "cp -f %s %s.orig", g_mountlist_fname,
                 g_mountlist_fname);
         run_program_and_log_output(tmp, FALSE);
     }
-    paranoid_free(tmp);
+    mr_free(tmp);
 
 /* Init directories */
     make_hole_for_dir(bkpinfo->tmpdir);
-    asprintf(&tmp, "mkdir -p %s", bkpinfo->tmpdir);
+    mr_asprintf(&tmp, "mkdir -p %s", bkpinfo->tmpdir);
     run_program_and_log_output(tmp, FALSE);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     make_hole_for_dir("/var/log");
@@ -2805 +2806 @@
         load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
         if (!does_file_exist(g_mountlist_fname)) {
-            paranoid_alloc(g_mountlist_fname, "/tmp/mountlist.txt");
+            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
         }
         res = let_user_edit_the_mountlist(bkpinfo, mountlist, raidlist);
@@ -2832 +2833 @@
         bkpinfo->compression_level = 1;
         g_current_media_number = 2;
-        paranoid_alloc(bkpinfo->restore_path, "/tmp/TESTING");
+        mr_allocstr(bkpinfo->restore_path, "/tmp/TESTING");
         bkpinfo->backup_media_type = dvd;
-        paranoid_free(bkpinfo->backup_media_string);
+        mr_free(bkpinfo->backup_media_string);
         bkpinfo->backup_media_string = bkptype_to_string(bkpinfo->backup_media_type);
         open_progress_form(_("Reassembling /dev/hda1"),
@@ -2859 +2860 @@
 //      finish(0);
 //      toggle_path_selection (filelist, "/root/stuff", TRUE);
-        asprintf(&a, argv[3]);
-        asprintf(&b, argv[4]);
+        mr_asprintf(&a, argv[3]);
+        mr_asprintf(&b, argv[4]);
 
         res = save_filelist_entries_in_common(a, filelist, b, FALSE);
         free_filelist(filelist);
-        paranoid_free(a);
-        paranoid_free(b);
+        mr_free(a);
+        mr_free(b);
         printf("res = %d", res);
         finish(0);
@@ -2944 +2945 @@
         log_msg(2, "Still here. Yay.");
         if (strlen(bkpinfo->tmpdir) > 0) {
-            asprintf(&tmp, "rm -Rf %s/*", bkpinfo->tmpdir);
+            mr_asprintf(&tmp, "rm -Rf %s/*", bkpinfo->tmpdir);
             run_program_and_log_output(tmp, FALSE);
-            paranoid_free(tmp);
+            mr_free(tmp);
         }
         unmount_boot_if_necessary();    /* for Gentoo users */
@@ -2960 +2961 @@
 
         iamhere("About to call load_mountlist and load_raidtab");
-        paranoid_alloc(bkpinfo->restore_path, MNT_RESTORING);
+        mr_allocstr(bkpinfo->restore_path, MNT_RESTORING);
         read_cfg_file_into_bkpinfo(g_mondo_cfg_file, bkpinfo);
         retval = load_mountlist(mountlist, g_mountlist_fname);
@@ -2973 +2974 @@
                 && !is_this_device_mounted(bkpinfo->nfs_mount)) {
                 log_msg(1, "Mounting nfs dir");
-                paranoid_alloc(bkpinfo->isodir, "/tmp/isodir");
+                mr_allocstr(bkpinfo->isodir, "/tmp/isodir");
                 run_program_and_log_output("mkdir -p /tmp/isodir", 5);
-                asprintf(&tmp, "mount %s -t nfs -o nolock /tmp/isodir",
+                mr_asprintf(&tmp, "mount %s -t nfs -o nolock /tmp/isodir",
                         bkpinfo->nfs_mount);
                 run_program_and_log_output(tmp, 1);
-                paranoid_free(tmp);
+                mr_free(tmp);
             }
         }
@@ -2995 +2996 @@
             log_msg(0, "Partitioning only.");
             load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
-            paranoid_alloc(g_mountlist_fname, "/tmp/mountlist.txt");
+            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
             load_mountlist(mountlist, g_mountlist_fname);
             res = partition_everything(mountlist);
@@ -3004 +3005 @@
             log_msg(0, "Formatting only.");
             load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
-            paranoid_alloc(g_mountlist_fname, "/tmp/mountlist.txt");
+            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
             load_mountlist(mountlist, g_mountlist_fname);
             res = format_everything(mountlist, FALSE, raidlist);
@@ -3013 +3014 @@
             log_msg(0, "Stopping LVM and RAID");
             load_raidtab_into_raidlist(raidlist, RAIDTAB_FNAME);
-            paranoid_alloc(g_mountlist_fname, "/tmp/mountlist.txt");
+            mr_allocstr(g_mountlist_fname, "/tmp/mountlist.txt");
             load_mountlist(mountlist, g_mountlist_fname);
             res = do_my_funky_lvm_stuff(TRUE, FALSE);
@@ -3139 +3140 @@
     unlink("/tmp/mondo-run-prog.tmp");
     set_signals(FALSE);
-    asprintf(&tmp, "rm -Rf %s", bkpinfo->tmpdir);
+    mr_asprintf(&tmp, "rm -Rf %s", bkpinfo->tmpdir);
     run_program_and_log_output(tmp, FALSE);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     log_to_screen
         (_
          ("Restore log copied to /tmp/mondo-restore.log on your hard disk"));
-    asprintf(&tmp,
+    mr_asprintf(&tmp,
             _
             ("Mondo-restore is exiting (retval=%d)                                      "),
             retval);
     log_to_screen(tmp);
-    paranoid_free(tmp);
-
-    asprintf(&tmp, "umount %s", bkpinfo->isodir);
+    mr_free(tmp);
+
+    mr_asprintf(&tmp, "umount %s", bkpinfo->isodir);
     run_program_and_log_output(tmp, 5);
-    paranoid_free(tmp);
-
-    paranoid_free(mountlist);
-    paranoid_free(raidlist);
+    mr_free(tmp);
+
+    mr_free(mountlist);
+    mr_free(raidlist);
     if (am_I_in_disaster_recovery_mode()) {
         run_program_and_log_output("mount / -o remount,rw", 2);

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

@@ -14 +14 @@
 #include <pthread.h>
 #endif
+#include "mr_mem.h"
 
 void popup_changelist_from_file(char *);
@@ -61 +62 @@
     }
     if (!(fin = fopen(tmp1, "r"))) {
-        asprintf(&tmp, _("Cannot open bigfile %ld (%s)'s info file"),
+        mr_asprintf(&tmp, _("Cannot open bigfile %ld (%s)'s info file"),
                 bigfileno + 1, tmp);
         log_to_screen(tmp);
-        paranoid_free(tmp);
-        paranoid_free(tmp1);
+        mr_free(tmp);
+        mr_free(tmp1);
         return (1);
     }
-    paranoid_free(tmp1);
+    mr_free(tmp1);
 
     fread((void *) &biggiestruct, 1, sizeof(biggiestruct), fin);
     paranoid_fclose(fin);
 
-    asprintf(&checksum, biggiestruct.checksum);
-    asprintf(&bigfile_fname, biggiestruct.filename);
+    mr_asprintf(&checksum, biggiestruct.checksum);
+    mr_asprintf(&bigfile_fname, biggiestruct.filename);
 
     log_msg(2, "biggiestruct.filename = %s", bigfile_fname);
@@ -80 +81 @@
 
     if (!g_text_mode) {
-        asprintf(&tmp, _("Comparing %s"), bigfile_fname);
+        mr_asprintf(&tmp, _("Comparing %s"), bigfile_fname);
         newtDrawRootText(0, 22, tmp);
         newtRefresh();
-        paranoid_free(tmp);
+        mr_free(tmp);
     }
     /* BERLIOS: Useless ?
@@ -93 +94 @@
         return(0);
     } else {
-        asprintf(&command,
+        mr_asprintf(&command,
                 "md5sum \"%s%s\" > /tmp/md5sum.txt 2> /tmp/errors.txt",
                 MNT_RESTORING, bigfile_fname);
@@ -101 +102 @@
     if (system(command)) {
         log_OS_error("Warning - command failed");
-        paranoid_free(command);
-        paranoid_free(bigfile_fname);
+        mr_free(command);
+        mr_free(bigfile_fname);
         return (1);
     } else {
-        paranoid_free(command);
+        mr_free(command);
         if (!(fin = fopen("/tmp/md5sum.txt", "r"))) {
             log_msg(2, "Unable to open /tmp/md5sum.txt; can't get live checksum");
-            paranoid_free(bigfile_fname);
+            mr_free(bigfile_fname);
             return (1);
         } else {
-            getline(&original_cksum, &n, fin);
+            mr_getline(&original_cksum, &n, fin);
             paranoid_fclose(fin);
             for (i = strlen(original_cksum);
@@ -128 +129 @@
         retval++;
     }
-    paranoid_free(original_cksum);
-    paranoid_free(checksum);
+    mr_free(original_cksum);
+    mr_free(checksum);
 
     if (retval) {
@@ -138 +139 @@
         paranoid_fclose(fout);
     }
-    paranoid_free(bigfile_fname);
+    mr_free(bigfile_fname);
 
     return (retval);
@@ -181 +182 @@
                        noof_biggiefiles);
     for (bigfileno = 0; bigfileno < noof_biggiefiles; bigfileno++) {
-        asprintf(&tmp, "Comparing big file #%ld", bigfileno + 1);
+        mr_asprintf(&tmp, "Comparing big file #%ld", bigfileno + 1);
         log_msg(1, tmp);
         update_progress_form(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         res = compare_a_biggiefile(bkpinfo, bigfileno);
         retval += res;
@@ -232 +233 @@
     use_star = (strstr(tarball_fname, ".star")) ? TRUE : FALSE;
     assert_string_is_neither_NULL_nor_zerolength(tarball_fname);
-    asprintf(&filelist_name, MNT_CDROM "/archives/filelist.%d",
+    mr_asprintf(&filelist_name, MNT_CDROM "/archives/filelist.%d",
             current_tarball_number);
 
     noof_lines = count_lines_in_file(filelist_name);
-    paranoid_free(filelist_name);
+    mr_free(filelist_name);
 
     if (strstr(tarball_fname, ".bz2")) {
-        asprintf(&compressor_exe, "bzip2");
+        mr_asprintf(&compressor_exe, "bzip2");
     } else if (strstr(tarball_fname, ".lzo")) {
-        asprintf(&compressor_exe, "lzop");
+        mr_asprintf(&compressor_exe, "lzop");
     } else {
         compressor_exe = NULL;
@@ -247 +248 @@
 
     if (use_star) {
-        asprintf(&archiver_exe, "star -bz");
-    } else {
-        asprintf(&archiver_exe, "afio");
+        mr_asprintf(&archiver_exe, "star -bz");
+    } else {
+        mr_asprintf(&archiver_exe, "afio");
     }
 
@@ -257 +258 @@
             fatal_error("(compare_a_tarball) Compression program missing");
         }
-        paranoid_free(tmp);
+        mr_free(tmp);
 
         if (use_star) {
@@ -266 +267 @@
         } else {
             tmp = compressor_exe;
-            asprintf(&compressor_exe, "-P %s -Z", tmp);
-            paranoid_free(tmp);
+            mr_asprintf(&compressor_exe, "-P %s -Z", tmp);
+            mr_free(tmp);
         }
     }
@@ -278 +279 @@
 #endif
 
-    asprintf(&logfile, "/tmp/afio.log.%d", current_tarball_number);
+    mr_asprintf(&logfile, "/tmp/afio.log.%d", current_tarball_number);
     if (use_star)               // doesn't use compressor_exe
     {
-        asprintf(&command,
+        mr_asprintf(&command,
                 "%s -diff H=star file=%s >> %s 2>> %s",
                 archiver_exe, tarball_fname, logfile, logfile);
     } else {
-        asprintf(&command,
+        mr_asprintf(&command,
                 "%s -r -b %ld -M 16m -c %ld %s %s >> %s 2>> %s",
                 archiver_exe,
@@ -292 +293 @@
     }
 #undef BUFSIZE
-    paranoid_free(archiver_exe);
-    paranoid_free(compressor_exe);
+    mr_free(archiver_exe);
+    mr_free(compressor_exe);
 
     res = system(command);
@@ -300 +301 @@
         log_OS_error(command);
     }
-    paranoid_free(command);
+    mr_free(command);
 
     if (length_of_file(logfile) > 5) {
-        asprintf(&command,
+        mr_asprintf(&command,
                 "sed s/': \\\"'/\\|/ %s | sed s/'\\\": '/\\|/ | cut -d'|' -f2 | sort -u | grep -vx \"dev/.*\" >> /tmp/changed.txt",
                 logfile);
         system(command);
-        paranoid_free(command);
+        mr_free(command);
         archiver_errors = count_lines_in_file(logfile);
     } else {
@@ -314 +315 @@
 
     if (archiver_errors) {
-        asprintf(&tmp,
+        mr_asprintf(&tmp,
                 "Differences found while processing fileset #%d       ",
                 current_tarball_number);
         log_msg(1, tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
     }
     unlink(logfile);
-    paranoid_free(logfile);
+    mr_free(logfile);
     return (retval);
 }
@@ -353 +354 @@
 
     max_val = atol(tmp);
-    paranoid_free(tmp);
-
-    asprintf(&progress_str, _("Comparing with %s #%d "),
+    mr_free(tmp);
+
+    mr_asprintf(&progress_str, _("Comparing with %s #%d "),
             bkpinfo->backup_media_string,
             g_current_media_number);
@@ -369 +370 @@
         insist_on_this_cd_number(bkpinfo, g_current_media_number);
         update_progress_form(progress_str);
-        asprintf(&tarball_fname,
+        mr_asprintf(&tarball_fname,
                 MNT_CDROM "/archives/%d.afio.bz2", current_tarball_number);
 
         if (!does_file_exist(tarball_fname)) {
-            paranoid_free(tarball_fname);
-            asprintf(&tarball_fname, MNT_CDROM "/archives/%d.afio.lzo",
+            mr_free(tarball_fname);
+            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%d.afio.lzo",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            paranoid_free(tarball_fname);
-            asprintf(&tarball_fname, MNT_CDROM "/archives/%d.afio.",
+            mr_free(tarball_fname);
+            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%d.afio.",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            paranoid_free(tarball_fname);
-            asprintf(&tarball_fname, MNT_CDROM "/archives/%d.star.bz2",
+            mr_free(tarball_fname);
+            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%d.star.bz2",
                     current_tarball_number);
         }
         if (!does_file_exist(tarball_fname)) {
-            paranoid_free(tarball_fname);
-            asprintf(&tarball_fname, MNT_CDROM "/archives/%d.star.",
+            mr_free(tarball_fname);
+            mr_asprintf(&tarball_fname, MNT_CDROM "/archives/%d.star.",
                     current_tarball_number);
         }
@@ -398 +399 @@
                 == 0) {
                 log_msg(2, "OK, I think I'm done with tarballs...");
-                paranoid_free(tarball_fname);
+                mr_free(tarball_fname);
                 break;
             }
             log_msg(2, "OK, I think it's time for another CD...");
             g_current_media_number++;
-            paranoid_free(progress_str);
-            asprintf(&progress_str, _("Comparing with %s #%d "),
+            mr_free(progress_str);
+            mr_asprintf(&progress_str, _("Comparing with %s #%d "),
                     bkpinfo->backup_media_string,
                     g_current_media_number);
@@ -410 +411 @@
         } else {
             res = compare_a_tarball(tarball_fname, current_tarball_number);
-            paranoid_free(tarball_fname);
+            mr_free(tarball_fname);
 
             g_current_progress++;
@@ -416 +417 @@
         }
     }
-    paranoid_free(progress_str);
+    mr_free(progress_str);
     close_progress_form();
 
@@ -470 +471 @@
     noof_changed_files = count_lines_in_file("/tmp/changed.txt");
     if (noof_changed_files) {
-        asprintf(&tmp, _("%ld files do not match the backup            "),
+        mr_asprintf(&tmp, _("%ld files do not match the backup            "),
                 noof_changed_files);
         //      mvaddstr_and_log_it( g_currentY++, 0, tmp );
         log_to_screen(tmp);
-        paranoid_free(tmp);
-
-        asprintf(&command, "cat /tmp/changed.txt >> %s", MONDO_LOGFILE);
+        mr_free(tmp);
+
+        mr_asprintf(&command, "cat /tmp/changed.txt >> %s", MONDO_LOGFILE);
         paranoid_system(command);
-        paranoid_free(command);
-    } else {
-        asprintf(&tmp, _("All files match the backup                     "));
+        mr_free(command);
+    } else {
+        mr_asprintf(&tmp, _("All files match the backup                     "));
         mvaddstr_and_log_it(g_currentY++, 0, tmp);
         log_to_screen(tmp);
-        paranoid_free(tmp);
-    }
-
-    paranoid_free(cwd);
-    paranoid_free(new);
+        mr_free(tmp);
+    }
+
+    mr_free(cwd);
+    mr_free(new);
 
     return (resA + resB);
@@ -573 +574 @@
         } else {
             q = count_lines_in_file("/tmp/changed.files");
-            asprintf(&tmp, _("%ld significant difference%s found."), q,
+            mr_asprintf(&tmp, _("%ld significant difference%s found."), q,
                     (q != 1) ? "s" : "");
             mvaddstr_and_log_it(g_currentY++, 0, tmp);
             log_to_screen(tmp);
-            paranoid_free(tmp);
-
-            asprintf(&tmp,
+            mr_free(tmp);
+
+            mr_asprintf(&tmp,
                    _("Type 'less /tmp/changed.files' for a list of non-matching files"));
             mvaddstr_and_log_it(g_currentY++, 0, tmp);
             log_to_screen(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
 
             log_msg(2, "calling popup_changelist_from_file()");
@@ -624 +625 @@
     chdir(bkpinfo->restore_path);
 
-    asprintf(&command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp",
+    mr_asprintf(&command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp",
             bkpinfo->restore_path);
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
+    mr_free(command);
     mvaddstr_and_log_it(g_currentY,
                         0, _("Verifying archives against filesystem"));
@@ -633 +634 @@
     if (bkpinfo->disaster_recovery
         && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
-        paranoid_free(bkpinfo->media_device);
+        mr_free(bkpinfo->media_device);
         // last_line_of_file allocates the string
         bkpinfo->media_device = last_line_of_file("/tmp/CDROM-LIVES-HERE");
     } else {
-        paranoid_free(bkpinfo->media_device);
+        mr_free(bkpinfo->media_device);
         // find_cdrom_device allocates the string
         bkpinfo->media_device = find_cdrom_device(FALSE);
@@ -653 +654 @@
 
     mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
-    paranoid_free(dir);
+    mr_free(dir);
     return (res);
 }
@@ -684 +685 @@
     getcwd(dir, MAX_STR_LEN);
     chdir(bkpinfo->restore_path);
-    asprintf(&command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp",
+    mr_asprintf(&command, "cp -f /tmp/LAST-FILELIST-NUMBER %s/tmp",
             bkpinfo->restore_path);
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
+    mr_free(command);
 
     mvaddstr_and_log_it(g_currentY,
@@ -698 +699 @@
         mvaddstr_and_log_it(g_currentY++, 74, _("Done."));
     }
-    paranoid_free(dir);
+    mr_free(dir);
     return (res);
 }

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);
     }

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

@@ -13 +13 @@
 #include <pthread.h>
 #endif
+#include "mr_mem.h"
 
 extern bool g_sigpipe_caught;
@@ -52 +53 @@
 void free_MR_global_filenames()
 {
-    paranoid_free(g_biggielist_txt);
-    paranoid_free(g_filelist_full);
-    paranoid_free(g_filelist_imagedevs);
-    paranoid_free(g_imagedevs_restthese);
-    paranoid_free(g_mondo_cfg_file);
-    paranoid_free(g_mountlist_fname);
-    paranoid_free(g_mondo_home);
-    paranoid_free(g_tmpfs_mountpt);
-    paranoid_free(g_isodir_device);
-    paranoid_free(g_isodir_format);
+    mr_free(g_biggielist_txt);
+    mr_free(g_filelist_full);
+    mr_free(g_filelist_imagedevs);
+    mr_free(g_imagedevs_restthese);
+    mr_free(g_mondo_cfg_file);
+    mr_free(g_mountlist_fname);
+    mr_free(g_mondo_home);
+    mr_free(g_tmpfs_mountpt);
+    mr_free(g_isodir_device);
+    mr_free(g_isodir_format);
 
 }
@@ -94 +95 @@
         fatal_error("Cannot openin outfname");
     }
-    for (getline(&incoming, &n, fin);
-         !feof(fin); getline(&incoming, &n, fin)) {
+    for (mr_getline(&incoming, &n, fin);
+         !feof(fin); mr_getline(&incoming, &n, fin)) {
         strip_spaces(incoming);
 
@@ -102 +103 @@
         }
 
-        asprintf(&question,
+        mr_asprintf(&question,
                  _("Should I restore the image of %s ?"), incoming);
 
@@ -108 +109 @@
             fprintf(fout, "%s\n", incoming);
         }
-        paranoid_free(question);
+        mr_free(question);
     }
 
   /*** free memory ***********/
-    paranoid_free(incoming);
+    mr_free(incoming);
 
     paranoid_fclose(fout);
@@ -147 +148 @@
     assert_string_is_neither_NULL_nor_zerolength(output_cfg_file);
     assert_string_is_neither_NULL_nor_zerolength(output_mountlist_file);
-    asprintf(&mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
-    asprintf(&command, "mkdir -p %s", mountpt);
+    mr_asprintf(&mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
+    mr_asprintf(&command, "mkdir -p %s", mountpt);
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
-
-    asprintf(&command, "gzip -dc %s > %s/mindi.rd 2> /dev/null",
+    mr_free(command);
+
+    mr_asprintf(&command, "gzip -dc %s > %s/mindi.rd 2> /dev/null",
             ramdisk_fname, bkpinfo->tmpdir);
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
-
-    asprintf(&command, "umount %s", mountpt);
+    mr_free(command);
+
+    mr_asprintf(&command, "umount %s", mountpt);
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
-
-    asprintf(&command, "mount -o loop %s/mindi.rd -t ext2 %s",
+    mr_free(command);
+
+    mr_asprintf(&command, "mount -o loop %s/mindi.rd -t ext2 %s",
             bkpinfo->tmpdir, mountpt);
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
-
-    asprintf(&command, "mkdir -p %s/tmp", bkpinfo->tmpdir);
+    mr_free(command);
+
+    mr_asprintf(&command, "mkdir -p %s/tmp", bkpinfo->tmpdir);
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
-
-    asprintf(&command, "cp -f %s/%s %s",    // %s/%s becomes {mountpt}/tmp/m*ndo-restore.cfg
+    mr_free(command);
+
+    mr_asprintf(&command, "cp -f %s/%s %s", // %s/%s becomes {mountpt}/tmp/m*ndo-restore.cfg
             mountpt, g_mondo_cfg_file, output_cfg_file);
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
-
-    asprintf(&orig_fname, "%s/%s", mountpt, g_mountlist_fname);
+    mr_free(command);
+
+    mr_asprintf(&orig_fname, "%s/%s", mountpt, g_mountlist_fname);
     if (does_file_exist(orig_fname)) {
-        asprintf(&command, "cp -f %s %s", orig_fname, output_mountlist_file);
+        mr_asprintf(&command, "cp -f %s %s", orig_fname, output_mountlist_file);
         run_program_and_log_output(command, FALSE);
-        paranoid_free(command);
-    }
-    asprintf(&command, "umount %s", mountpt);
-    paranoid_free(mountpt);
+        mr_free(command);
+    }
+    mr_asprintf(&command, "umount %s", mountpt);
+    mr_free(mountpt);
 
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
+    mr_free(command);
 
     if (!does_file_exist(output_cfg_file)
@@ -196 +197 @@
         retval = 0;
     }
-    paranoid_free(orig_fname);
+    mr_free(orig_fname);
     return (retval);
 }
@@ -240 +241 @@
 
     if (strncmp(preamble, f, strlen(preamble)) == 0) {
-        asprintf(&file, f + strlen(preamble));
-    } else {
-        asprintf(&file, f);
+        mr_asprintf(&file, f + strlen(preamble));
+    } else {
+        mr_asprintf(&file, f);
     }
     if (file[0] == '/' && file[1] == '/') {
-        asprintf(&tmp, file);
-        paranoid_free(file);
-        asprintf(&file, tmp + 1);
-        paranoid_free(tmp);
-    }
-    asprintf(&tmp,
+        mr_asprintf(&tmp, file);
+        mr_free(file);
+        mr_asprintf(&file, tmp + 1);
+        mr_free(tmp);
+    }
+    mr_asprintf(&tmp,
             "Checking to see if f=%s, file=%s, is in the list of biggiefiles",
             f, file);
     log_msg(2, tmp);
-    paranoid_free(tmp);
-
-    asprintf(&command, "grep -x \"%s\" %s", file, list_fname);
-    paranoid_free(file);
+    mr_free(tmp);
+
+    mr_asprintf(&command, "grep -x \"%s\" %s", file, list_fname);
+    mr_free(file);
 
     res = run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
+    mr_free(command);
     if (res) {
         return (FALSE);
@@ -292 +293 @@
     g_ISO_restore_mode = TRUE;
 
-    paranoid_free(g_isodir_device);
+    mr_free(g_isodir_device);
     read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
     if (bkpinfo->disaster_recovery) {
@@ -298 +299 @@
  * Don't let this clobber an existing bkpinfo->isodir */
         if (!bkpinfo->isodir) {
-            paranoid_alloc(bkpinfo->isodir, "/tmp/isodir");
+            mr_allocstr(bkpinfo->isodir, "/tmp/isodir");
         }
 /* End patch */
-        asprintf(&command, "mkdir -p %s", bkpinfo->isodir);
+        mr_asprintf(&command, "mkdir -p %s", bkpinfo->isodir);
         run_program_and_log_output(command, 5);
-        paranoid_free(command);
+        mr_free(command);
         log_msg(2, "Setting isodir to %s", bkpinfo->isodir);
     }
@@ -319 +320 @@
     } else {
         if (g_isodir_format != NULL) {
-            asprintf(&mount_isodir_command, "mount %s -t %s -o ro %s", g_isodir_device, g_isodir_format, bkpinfo->isodir);
+            mr_asprintf(&mount_isodir_command, "mount %s -t %s -o ro %s", g_isodir_device, g_isodir_format, bkpinfo->isodir);
         } else {
-            asprintf(&mount_isodir_command, "mount %s -o ro %s", g_isodir_device, bkpinfo->isodir);
+            mr_asprintf(&mount_isodir_command, "mount %s -o ro %s", g_isodir_device, bkpinfo->isodir);
         }
         run_program_and_log_output("df -m", FALSE);
-        asprintf(&tmp,
+        mr_asprintf(&tmp,
                 "The 'mount' command is '%s'. PLEASE report this command to be if you have problems, ok?",
                 mount_isodir_command);
         log_msg(1, tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
 
         if (run_program_and_log_output(mount_isodir_command, FALSE)) {
@@ -334 +335 @@
                 (_
                  ("Cannot mount the device where the ISO files are stored."));
-            paranoid_free(mount_isodir_command);
+            mr_free(mount_isodir_command);
             return (1);
         }
-        paranoid_free(mount_isodir_command);
+        mr_free(mount_isodir_command);
         log_to_screen
             (_
@@ -346 +347 @@
     }
     i = what_number_cd_is_this(bkpinfo);    /* has the side-effect of calling mount_cdrom() */
-    asprintf(&tmp, "%s #%d has been mounted via loopback mount",
+    mr_asprintf(&tmp, "%s #%d has been mounted via loopback mount",
             bkpinfo->backup_media_string, i);
     log_msg(1, tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     if (i < 0) {
@@ -368 +369 @@
 {
     char *command;
-    asprintf(&command,
+    mr_asprintf(&command,
             "kill `ps 2> /dev/null | grep petris 2> /dev/null | grep -v grep | cut -d' ' -f2` 2> /dev/null");
     paranoid_system(command);
-    paranoid_free(command);
+    mr_free(command);
 }
 
@@ -413 +414 @@
                     "Again with the /proc - why is this in your mountlist?");
         } else if (is_this_device_mounted(mountlist->el[lino].device)) {
-            asprintf(&tmp, _("%s is already mounted"),
+            mr_asprintf(&tmp, _("%s is already mounted"),
                     mountlist->el[lino].device);
             log_to_screen(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
         } else if (strcmp(mountlist->el[lino].mountpoint, "none")
                    && strcmp(mountlist->el[lino].mountpoint, "lvm")
                    && strcmp(mountlist->el[lino].mountpoint, "raid")
                    && strcmp(mountlist->el[lino].mountpoint, "image")) {
-            asprintf(&tmp, "Mounting %s", mountlist->el[lino].device);
+            mr_asprintf(&tmp, "Mounting %s", mountlist->el[lino].device);
             update_progress_form(tmp);
-            paranoid_free(tmp);
-
-            asprintf(&format, mountlist->el[lino].format);
+            mr_free(tmp);
+
+            mr_asprintf(&format, mountlist->el[lino].format);
             if (!strcmp(format, "ext3")) {
-                paranoid_free(format);
-                asprintf(&format, "ext2");
+                mr_free(format);
+                mr_asprintf(&format, "ext2");
             }
             res = mount_device(mountlist->el[lino].device,
@@ -436 +437 @@
             if (res) {
                 if (these_failed != NULL) { /* not the first time */
-                    asprintf(&tmp, "%s %s", these_failed, mountlist->el[lino].device);
-                    paranoid_free(these_failed);
+                    mr_asprintf(&tmp, "%s %s", these_failed, mountlist->el[lino].device);
+                    mr_free(these_failed);
                     these_failed = tmp;
                 } else { /* The first time */
-                    asprintf(&these_failed, "%s ", mountlist->el[lino].device);
+                    mr_asprintf(&these_failed, "%s ", mountlist->el[lino].device);
                 }
             }
-            paranoid_free(format);
+            mr_free(format);
         }
         g_current_progress++;
@@ -459 +460 @@
                           ("format and restore *without* partitioning first. Sorry for the inconvenience."));
         }
-        asprintf(&tmp, _("Could not mount devices %s- shall I abort?"),
+        mr_asprintf(&tmp, _("Could not mount devices %s- shall I abort?"),
                 these_failed);
-        paranoid_free(these_failed);
+        mr_free(these_failed);
 
         if (!ask_me_yes_or_no(tmp)) {
@@ -474 +475 @@
                 (_("Unable to mount some or all of your partitions."));
         }
-        paranoid_free(tmp);
+        mr_free(tmp);
     } else {
         log_to_screen(_("All partitions were mounted OK."));
@@ -480 +481 @@
     }
     run_program_and_log_output("df -m", 3);
-    paranoid_free(mountlist);
+    mr_free(mountlist);
     return (retval);
 }
@@ -523 +524 @@
         if ((!bkpinfo->isodir || !strcmp(bkpinfo->isodir, "/"))
             && am_I_in_disaster_recovery_mode()) {
-            paranoid_alloc(bkpinfo->isodir, "/tmp/isodir");
+            mr_allocstr(bkpinfo->isodir, "/tmp/isodir");
             log_msg(1, "isodir is being set to %s", bkpinfo->isodir);
         }
 #ifdef __FreeBSD__
-        asprintf(&mount_cmd, "/mnt/isodir/%s/%s/%s-%d.iso", bkpinfo->isodir,
+        mr_asprintf(&mount_cmd, "/mnt/isodir/%s/%s/%s-%d.iso", bkpinfo->isodir,
                 bkpinfo->nfs_remote_dir, bkpinfo->prefix,
                 g_current_media_number);
         mddev = make_vn(mount_cmd);
-        paranoid_free(mount_cmd);
-
-        asprintf(&mount_cmd, "mount_cd9660 -r %s " MNT_CDROM, mddev);
-        paranoid_free(mddev);
+        mr_free(mount_cmd);
+
+        mr_asprintf(&mount_cmd, "mount_cd9660 -r %s " MNT_CDROM, mddev);
+        mr_free(mddev);
 #else
-        asprintf(&mount_cmd,
+        mr_asprintf(&mount_cmd,
                 "mount %s/%s/%s-%d.iso -t iso9660 -o loop,ro %s",
                 bkpinfo->isodir, bkpinfo->nfs_remote_dir, bkpinfo->prefix,
@@ -544 +545 @@
     } else if (bkpinfo->backup_media_type == iso) {
 #ifdef __FreeBSD__
-        asprintf(&mount_cmd, "%s/%s-%d.iso", bkpinfo->isodir,
+        mr_asprintf(&mount_cmd, "%s/%s-%d.iso", bkpinfo->isodir,
                 bkpinfo->prefix, g_current_media_number);
         mddev = make_vn(mount_cmd);
-        paranoid_free(mount_cmd);
-
-        asprintf(&mount_cmd, "mount_cd9660 -r %s %s", mddev, MNT_CDROM);
-        paranoid_free(mddev);
+        mr_free(mount_cmd);
+
+        mr_asprintf(&mount_cmd, "mount_cd9660 -r %s %s", mddev, MNT_CDROM);
+        mr_free(mddev);
 #else
-        asprintf(&mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s",
+        mr_asprintf(&mount_cmd, "mount %s/%s-%d.iso -t iso9660 -o loop,ro %s",
                 bkpinfo->isodir, bkpinfo->prefix, g_current_media_number,
                 MNT_CDROM);
@@ -559 +560 @@
 #ifdef __FreeBSD__
     {
-        asprintf(&mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
+        mr_asprintf(&mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
                 MNT_CDROM);
     }
 #else
     {
-        asprintf(&mount_cmd, "mount %s -t iso9660 -o ro %s",
+        mr_asprintf(&mount_cmd, "mount %s -t iso9660 -o ro %s",
                 bkpinfo->media_device, MNT_CDROM);
     }
@@ -572 +573 @@
         if (bkpinfo->disaster_recovery
             && does_file_exist("/tmp/CDROM-LIVES-HERE")) {
-            paranoid_free(bkpinfo->media_device);
+            mr_free(bkpinfo->media_device);
             bkpinfo->media_device = last_line_of_file("/tmp/CDROM-LIVES-HERE");
         } else {
-            paranoid_free(bkpinfo->media_device);
+            mr_free(bkpinfo->media_device);
             bkpinfo->media_device = find_cdrom_device(TRUE);
         }
 
 #ifdef __FreeBSD__
-        asprintf(&mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
+        mr_asprintf(&mount_cmd, "mount_cd9660 -r %s %s", bkpinfo->media_device,
                 MNT_CDROM);
 #else
-        asprintf(&mount_cmd, "mount %s -t iso9660 -o ro %s",
+        mr_asprintf(&mount_cmd, "mount %s -t iso9660 -o ro %s",
                 bkpinfo->media_device, MNT_CDROM);
 #endif
@@ -599 +600 @@
         }
     }
-    paranoid_free(mount_cmd);
+    mr_free(mount_cmd);
 
     if (res) {
@@ -639 +640 @@
 
     if (!strcmp(mpt, "/1")) {
-        asprintf(&mountpoint, "/");
+        mr_asprintf(&mountpoint, "/");
         log_msg(3, "Mommm! SME is being a dildo!");
     } else {
-        asprintf(&mountpoint, mpt);
+        mr_asprintf(&mountpoint, mpt);
     }
 
     if (!strcmp(mountpoint, "lvm")) {
-        paranoid_free(mountpoint);
+        mr_free(mountpoint);
         return (0);
     }
     if (!strcmp(mountpoint, "image")) {
-        paranoid_free(mountpoint);
+        mr_free(mountpoint);
         return (0);
     }
-    asprintf(&tmp, "Mounting device %s   ", device);
+    mr_asprintf(&tmp, "Mounting device %s   ", device);
     log_msg(1, tmp);
 
     if (writeable) {
-        asprintf(&p1, "-o rw");
-    } else {
-        asprintf(&p1, "-o ro");
+        mr_asprintf(&p1, "-o rw");
+    } else {
+        mr_asprintf(&p1, "-o ro");
     }
     tmp = find_home_of_exe("setfattr");
     if (tmp) {
-        asprintf(&p2, ",user_xattr");
-    } else {
-        asprintf(&p2, "%s", "");
-    }
-    paranoid_free(tmp);
+        mr_asprintf(&p2, ",user_xattr");
+    } else {
+        mr_asprintf(&p2, "%s", "");
+    }
+    mr_free(tmp);
 
     tmp = find_home_of_exe("setfacl");
     if (tmp) {
-        asprintf(&p3, ",acl");
-    } else {
-        asprintf(&p3, "%s", "");
-    }
-    paranoid_free(tmp);
-
-    asprintf(&additional_parameters, "%s%s%s", p1, p2, p3);
-    paranoid_free(p1);
-    paranoid_free(p2);
-    paranoid_free(p3);
+        mr_asprintf(&p3, ",acl");
+    } else {
+        mr_asprintf(&p3, "%s", "");
+    }
+    mr_free(tmp);
+
+    mr_asprintf(&additional_parameters, "%s%s%s", p1, p2, p3);
+    mr_free(p1);
+    mr_free(p2);
+    mr_free(p3);
 
     if (!strcmp(mountpoint, "swap")) {
-        asprintf(&command, "swapon %s", device);
+        mr_asprintf(&command, "swapon %s", device);
     } else {
         if (!strcmp(mountpoint, "/")) {
-            asprintf(&mountdir, MNT_RESTORING);
+            mr_asprintf(&mountdir, MNT_RESTORING);
         } else {
-            asprintf(&mountdir, "%s%s", MNT_RESTORING, mountpoint);
-        }
-        asprintf(&command, "mkdir -p %s", mountdir);
+            mr_asprintf(&mountdir, "%s%s", MNT_RESTORING, mountpoint);
+        }
+        mr_asprintf(&command, "mkdir -p %s", mountdir);
         run_program_and_log_output(command, FALSE);
-        paranoid_free(command);
-
-        asprintf(&command, "mount -t %s %s %s %s 2>> %s", format, device,
+        mr_free(command);
+
+        mr_asprintf(&command, "mount -t %s %s %s %s 2>> %s", format, device,
                 additional_parameters, mountdir, MONDO_LOGFILE);
         log_msg(2, "command='%s'", command);
     }
-    paranoid_free(additional_parameters);
+    mr_free(additional_parameters);
 
     res = run_program_and_log_output(command, TRUE);
     if (res && (strstr(command, "xattr") || strstr(command, "acl"))) {
         log_msg(1, "Re-trying without the fancy extra parameters");
-        paranoid_free(command);
-
-        asprintf(&command, "mount -t %s %s %s 2>> %s", format, device,
+        mr_free(command);
+
+        mr_asprintf(&command, "mount -t %s %s %s 2>> %s", format, device,
                 mountdir, MONDO_LOGFILE);
         res = run_program_and_log_output(command, TRUE);
@@ -717 +718 @@
         } else {
             log_msg(2, "Retrying w/o the '-t' switch");
-            paranoid_free(command);
-
-            asprintf(&command, "mount %s %s 2>> %s", device, mountdir,
+            mr_free(command);
+
+            mr_asprintf(&command, "mount %s %s 2>> %s", device, mountdir,
                     MONDO_LOGFILE);
             log_msg(2, "2nd command = '%s'", command);
@@ -731 +732 @@
         }
     }
-    paranoid_free(tmp);
-    paranoid_free(command);
-    paranoid_free(mountdir);
+    mr_free(tmp);
+    mr_free(command);
+    mr_free(mountdir);
 
     if (res && !strcmp(mountpoint, "swap")) {
@@ -740 +741 @@
         res = 0;
     }
-    paranoid_free(mountpoint);
+    mr_free(mountpoint);
 
     return (res);
@@ -836 +837 @@
                 }
             }
-            paranoid_free(value);
+            mr_free(value);
 
             if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
-                paranoid_alloc(bkpinfo->prefix,value);
+                mr_allocstr(bkpinfo->prefix,value);
             } else {
-                paranoid_alloc(bkpinfo->prefix, STD_PREFIX);
+                mr_allocstr(bkpinfo->prefix, STD_PREFIX);
             }
         } else if (!strcmp(value, "nfs")) {
             bkpinfo->backup_media_type = nfs;
-            paranoid_free(value);
+            mr_free(value);
             if (read_cfg_var(cfg_file, "iso-prefix", value) == 0) {
-                paranoid_alloc(bkpinfo->prefix,value);
+                mr_allocstr(bkpinfo->prefix,value);
             } else {
-                paranoid_alloc(bkpinfo->prefix, STD_PREFIX);
+                mr_allocstr(bkpinfo->prefix, STD_PREFIX);
             }
             /* We need to override prefix value in PXE mode as it's 
@@ -868 +869 @@
         fatal_error("backup-media-type not specified!");
     }
-    paranoid_free(value);
+    mr_free(value);
 
     if (bkpinfo->disaster_recovery) {
         if (bkpinfo->backup_media_type == cdstream) {
-            paranoid_alloc(bkpinfo->media_device, "/dev/cdrom");
+            mr_allocstr(bkpinfo->media_device, "/dev/cdrom");
             bkpinfo->media_size[0] = 1999 * 1024;
             bkpinfo->media_size[1] = 650;   /* good guess */
         } else if (bkpinfo->backup_media_type == tape
                    || bkpinfo->backup_media_type == udev) {
-            paranoid_free(bkpinfo->media_device);
+            mr_free(bkpinfo->media_device);
             if (read_cfg_var(cfg_file, "media-dev", bkpinfo->media_device)) {
                 fatal_error("Cannot get tape device name from cfg file");
@@ -883 +884 @@
             read_cfg_var(cfg_file, "media-size", value);
             bkpinfo->media_size[1] = atol(value);
-            paranoid_free(value);
-
-            asprintf(&tmp, "Backup medium is TAPE --- dev=%s",
+            mr_free(value);
+
+            mr_asprintf(&tmp, "Backup medium is TAPE --- dev=%s",
                     bkpinfo->media_device);
             log_msg(2, tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
         } else {
-            paranoid_alloc(bkpinfo->media_device, "/dev/cdrom");
+            mr_allocstr(bkpinfo->media_device, "/dev/cdrom");
             bkpinfo->media_size[0] = 1999 * 1024;   /* 650, probably, but we don't need this var anyway */
             bkpinfo->media_size[1] = 1999 * 1024;   /* 650, probably, but we don't need this var anyway */
@@ -905 +906 @@
         log_msg(1, "Goody! ... bkpinfo->use_star is now true.");
     }
-    paranoid_free(value);
+    mr_free(value);
 
     if (0 == read_cfg_var(cfg_file, "internal-tape-block-size", value)) {
@@ -917 +918 @@
                 DEFAULT_INTERNAL_TAPE_BLOCK_SIZE);
     }
-    paranoid_free(value);
+    mr_free(value);
 
     read_cfg_var(cfg_file, "use-lzo", value);
     if (strstr(value, "yes")) {
         bkpinfo->use_lzo = TRUE;
-        paranoid_alloc(bkpinfo->zip_exe, "lzop");
-        paranoid_alloc(bkpinfo->zip_suffix, "lzo");
-    } else {
-        paranoid_free(value);
+        mr_allocstr(bkpinfo->zip_exe, "lzop");
+        mr_allocstr(bkpinfo->zip_suffix, "lzo");
+    } else {
+        mr_free(value);
         read_cfg_var(cfg_file, "use-comp", value);
         if (strstr(value, "yes")) {
             bkpinfo->use_lzo = FALSE;
-            paranoid_alloc(bkpinfo->zip_exe, "bzip2");
-            paranoid_alloc(bkpinfo->zip_suffix, "bz2");
+            mr_allocstr(bkpinfo->zip_exe, "bzip2");
+            mr_allocstr(bkpinfo->zip_suffix, "bz2");
         } else {
             // Just to be sure
@@ -937 +938 @@
         }
     }
-    paranoid_free(value);
+    mr_free(value);
 
     read_cfg_var(cfg_file, "differential", value);
@@ -944 +945 @@
     }
     log_msg(2, "differential var = '%s'", value);
-    paranoid_free(value);
+    mr_free(value);
 
     if (bkpinfo->differential) {
@@ -962 +963 @@
         log_msg(2, "Ok, I shan't eject when restoring! Groovy.");
     }
-    paranoid_free(tmp);
-    paranoid_free(tmp1);
+    mr_free(tmp);
+    mr_free(tmp1);
 
     if (bkpinfo->backup_media_type == nfs) {
@@ -973 +974 @@
                     "...cos it wouldn't make sense to abandon the values that GOT ME to this config file in the first place");
         } else {
-            paranoid_free(bkpinfo->nfs_mount);
-            paranoid_free(bkpinfo->nfs_remote_dir);
+            mr_free(bkpinfo->nfs_mount);
+            mr_free(bkpinfo->nfs_remote_dir);
             read_cfg_var(g_mondo_cfg_file, "nfs-server-mount",
                          bkpinfo->nfs_mount);
@@ -994 +995 @@
          * isodir in disaster recovery mode
          */
-        paranoid_alloc(old_isodir,bkpinfo->isodir);
+        mr_allocstr(old_isodir,bkpinfo->isodir);
         read_cfg_var(g_mondo_cfg_file, "iso-mnt", iso_mnt);
         read_cfg_var(g_mondo_cfg_file, "isodir", iso_path);
         if (iso_mnt && iso_path) {
-            paranoid_free(bkpinfo->isodir);
-            asprintf(&bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
-        }
-        paranoid_free(iso_mnt);
-        paranoid_free(iso_path);
+            mr_free(bkpinfo->isodir);
+            mr_asprintf(&bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
+        }
+        mr_free(iso_mnt);
+        mr_free(iso_path);
 
         if (!bkpinfo->disaster_recovery) {
@@ -1011 +1012 @@
             }
         }
-        paranoid_free(old_isodir);
-
-        paranoid_free(g_isodir_device);
+        mr_free(old_isodir);
+
+        mr_free(g_isodir_device);
         read_cfg_var(g_mondo_cfg_file, "iso-dev", g_isodir_device);
         log_msg(2, "isodir=%s; iso-dev=%s", bkpinfo->isodir, g_isodir_device);
@@ -1020 +1021 @@
                 log_msg(2, "NB: isodir is already mounted");
                 /* Find out where it's mounted */
-                asprintf(&command,
+                mr_asprintf(&command,
                         "mount | grep -w %s | tail -n1 | cut -d' ' -f3",
                         g_isodir_device);
@@ -1027 +1028 @@
                 log_it("res of it = %s", tmp);
                 iso_mnt = tmp;
-                paranoid_free(command);
+                mr_free(command);
             } else {
-                asprintf(&iso_mnt, "/tmp/isodir");
-                asprintf(&tmp, "mkdir -p %s", iso_mnt);
+                mr_asprintf(&iso_mnt, "/tmp/isodir");
+                mr_asprintf(&tmp, "mkdir -p %s", iso_mnt);
                 run_program_and_log_output(tmp, 5);
-                paranoid_free(tmp);
-
-                asprintf(&tmp, "mount %s %s", g_isodir_device, iso_mnt);
+                mr_free(tmp);
+
+                mr_asprintf(&tmp, "mount %s %s", g_isodir_device, iso_mnt);
                 if (run_program_and_log_output(tmp, 3)) {
                     log_msg(1,
                             "Unable to mount isodir. Perhaps this is really a CD backup?");
                     bkpinfo->backup_media_type = cdr;
-                    paranoid_alloc(bkpinfo->media_device, "/dev/cdrom");
-                    paranoid_free(bkpinfo->isodir);
-                    paranoid_free(iso_mnt);
-                    paranoid_free(iso_path);
-                    asprintf(&iso_mnt, "%s", "");
-                    asprintf(&iso_path, "%s", "");
+                    mr_allocstr(bkpinfo->media_device, "/dev/cdrom");
+                    mr_free(bkpinfo->isodir);
+                    mr_free(iso_mnt);
+                    mr_free(iso_path);
+                    mr_asprintf(&iso_mnt, "%s", "");
+                    mr_asprintf(&iso_path, "%s", "");
 
                     if (mount_cdrom(bkpinfo)) {
@@ -1054 +1055 @@
                     }
                 }
-                paranoid_free(tmp);
+                mr_free(tmp);
             }
             /* bkpinfo->isodir should now be the true path to prefix-1.iso etc... */
             if (bkpinfo->backup_media_type == iso) {
-                paranoid_free(bkpinfo->isodir);
-                asprintf(&bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
-            }
-            paranoid_free(iso_mnt);
-            paranoid_free(iso_path);
+                mr_free(bkpinfo->isodir);
+                mr_asprintf(&bkpinfo->isodir, "%s%s", iso_mnt, iso_path);
+            }
+            mr_free(iso_mnt);
+            mr_free(iso_path);
         }
     }
@@ -1131 +1132 @@
         unlink("/tmp/i-want-my-lvm");
         if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) {
-            asprintf(&command,
+            mr_asprintf(&command,
                     "tar -zxf %s %s %s %s %s %s",
                     bkpinfo->media_device,
@@ -1140 +1141 @@
             log_msg(1, "tarcommand = %s", command);
             run_program_and_log_output(command, 1);
-            paranoid_free(command);
+            mr_free(command);
         } else {
             log_msg(2,
@@ -1148 +1149 @@
             log_msg(2, "Back from iotcn");
             run_program_and_log_output("mount", 1);
-            asprintf(&command,
+            mr_asprintf(&command,
                     "tar -zxf %s/images/all.tar.gz %s %s %s %s %s",
                     MNT_CDROM,
@@ -1158 +1159 @@
             log_msg(1, "tarcommand = %s", command);
             run_program_and_log_output(command, 1);
-            paranoid_free(command);
+            mr_free(command);
 
             if (!does_file_exist(BIGGIELIST_TXT_STUB)) {
@@ -1169 +1170 @@
             }
         }
-        asprintf(&command, "cp -f %s %s", MONDO_CFG_FILE_STUB,
+        mr_asprintf(&command, "cp -f %s %s", MONDO_CFG_FILE_STUB,
                 g_mondo_cfg_file);
         run_program_and_log_output(command, FALSE);
-        paranoid_free(command);
-
-        asprintf(&command, "cp -f %s/%s %s", bkpinfo->tmpdir,
+        mr_free(command);
+
+        mr_asprintf(&command, "cp -f %s/%s %s", bkpinfo->tmpdir,
                 BIGGIELIST_TXT_STUB, g_biggielist_txt);
         log_msg(1, "command = %s", command);
         paranoid_system(command);
-        paranoid_free(command);
-
-        asprintf(&command, "ln -sf %s/%s %s", bkpinfo->tmpdir,
+        mr_free(command);
+
+        mr_asprintf(&command, "ln -sf %s/%s %s", bkpinfo->tmpdir,
                 FILELIST_FULL_STUB, g_filelist_full);
         log_msg(1, "command = %s", command);
         paranoid_system(command);
-        paranoid_free(command);
+        mr_free(command);
     }
 
@@ -1192 +1193 @@
                          ("Do you want to retrieve the mountlist as well?")))
     {
-        asprintf(&command, "ln -sf %s/%s /tmp", MOUNTLIST_FNAME_STUB,
+        mr_asprintf(&command, "ln -sf %s/%s /tmp", MOUNTLIST_FNAME_STUB,
                 bkpinfo->tmpdir);
         paranoid_system(command);
-        paranoid_free(command);
+        mr_free(command);
     }
 
     chdir(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     if (!does_file_exist(g_biggielist_txt)) {
@@ -1219 +1220 @@
         log_to_screen(("Pre-processing filelist"));
         if (!does_file_exist(g_biggielist_txt)) {
-            asprintf(&command, "> %s", g_biggielist_txt);
+            mr_asprintf(&command, "> %s", g_biggielist_txt);
             paranoid_system(command);
-            paranoid_free(command);
-        }
-        asprintf(&command, "grep  -x \"/dev/.*\" %s > %s",
+            mr_free(command);
+        }
+        mr_asprintf(&command, "grep  -x \"/dev/.*\" %s > %s",
                 g_biggielist_txt, g_filelist_imagedevs);
         paranoid_system(command);
-        paranoid_free(command);
+        mr_free(command);
         exit(0);
         break;
@@ -1245 +1246 @@
     if (g_text_mode) {
         printf(_("Restore which directory? --> "));
-        getline(&tmp, &n, stdin);
+        mr_getline(&tmp, &n, stdin);
         toggle_path_selection(filelist, tmp, TRUE);
         if (strlen(tmp) == 0) {
@@ -1252 +1253 @@
             res = 0;
         }
-        paranoid_free(tmp);
+        mr_free(tmp);
     } else {
         res = edit_filelist(filelist);
@@ -1296 +1297 @@
     assert_string_is_neither_NULL_nor_zerolength(filename);
 
-    asprintf(&command, "cp -f %s/%s %s/%s.pristine", path_root, filename,path_root, filename);
+    mr_asprintf(&command, "cp -f %s/%s %s/%s.pristine", path_root, filename,path_root, filename);
     res = run_program_and_log_output(command, 5);
-    paranoid_free(command);
+    mr_free(command);
     return (res);
 }
@@ -1324 +1325 @@
     read_cfg_var(g_mondo_cfg_file, "bootloader.device", device);
     read_cfg_var(g_mondo_cfg_file, "bootloader.name", name);
-    asprintf(&tmp, "run_boot_loader: device='%s', name='%s'", device, name);
+    mr_asprintf(&tmp, "run_boot_loader: device='%s', name='%s'", device, name);
     log_msg(2, tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     sync();
@@ -1349 +1350 @@
 #ifdef __FreeBSD__
     else if (!strcmp(name, "BOOT0")) {
-        asprintf(&tmp, "boot0cfg -B %s", device);
+        mr_asprintf(&tmp, "boot0cfg -B %s", device);
         res = run_program_and_log_output(tmp, FALSE);
-        paranoid_free(tmp);
-    } else {
-        asprintf(&tmp, "ls /dev | grep -xq %ss[1-4].*", device);
+        mr_free(tmp);
+    } else {
+        mr_asprintf(&tmp, "ls /dev | grep -xq %ss[1-4].*", device);
         if (!system(tmp)) {
-            paranoid_free(tmp);
-            asprintf(&tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
+            mr_free(tmp);
+            mr_asprintf(&tmp, MNT_RESTORING "/sbin/fdisk -B %s", device);
             res = run_program_and_log_output(tmp, 3);
         } else {
@@ -1362 +1363 @@
                     "I'm not running any boot loader. You have a DD boot drive. It's already loaded up.");
         }
-        paranoid_free(tmp);
+        mr_free(tmp);
     }
 #else
@@ -1372 +1373 @@
     }
 #endif
-    paranoid_free(device);
-    paranoid_free(name);
+    mr_free(device);
+    mr_free(name);
 
     retval += res;
@@ -1401 +1402 @@
     tmp = find_home_of_exe("pico");
     if (tmp) {
-        asprintf(&output, "pico");
+        mr_asprintf(&output, "pico");
     } else {
         tmp = find_home_of_exe("nano");
         if (tmp) {
-            asprintf(&output, "nano");
+            mr_asprintf(&output, "nano");
         } else {
             tmp = find_home_of_exe("vi");
             if (tmp) {
-                asprintf(&output, "vi");
+                mr_asprintf(&output, "vi");
             } else {
-                asprintf(&output, "emacs");
-            }
-        }
-    }
-    paranoid_free(tmp);
+                mr_asprintf(&output, "emacs");
+            }
+        }
+    }
+    mr_free(tmp);
 
     tmp = find_home_of_exe(output);
@@ -1421 +1422 @@
         log_msg(2, " (find_my_editor) --- warning - %s not found", output);
     }
-    paranoid_free(tmp);
+    mr_free(tmp);
     return (output);
 }
@@ -1454 +1455 @@
             popup_and_get_string(_("Boot device"),
                                  _("Please confirm/enter the boot device. If in doubt, try /dev/hda"), bd);
-            asprintf(&command, "stabgrub-me %s", bd);
+            mr_asprintf(&command, "stabgrub-me %s", bd);
             res = run_program_and_log_output(command, 1);
-            paranoid_free(command);
+            mr_free(command);
 
             if (res) {
@@ -1474 +1475 @@
             }
             editor = find_my_editor();
-            asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+            mr_asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
             paranoid_system(tmp);
-            paranoid_free(tmp);
-
-            asprintf(&tmp, "%s " MNT_RESTORING "/etc/grub.conf", editor);
-            paranoid_free(editor);
+            mr_free(tmp);
+
+            mr_asprintf(&tmp, "%s " MNT_RESTORING "/etc/grub.conf", editor);
+            mr_free(editor);
 
             paranoid_system(tmp);
-            paranoid_free(tmp);
+            mr_free(tmp);
 
             if (!g_text_mode) {
@@ -1492 +1493 @@
         if (!run_program_and_log_output("which grub-MR", FALSE)) {
             log_msg(1, "Yay! grub-MR found...");
-            asprintf(&command, "grub-MR %s /tmp/mountlist.txt", bd);
+            mr_asprintf(&command, "grub-MR %s /tmp/mountlist.txt", bd);
             log_msg(1, "command = %s", command);
         } else {
-            asprintf(&command, "chroot " MNT_RESTORING " grub-install %s", bd);
+            mr_asprintf(&command, "chroot " MNT_RESTORING " grub-install %s", bd);
             log_msg(1, "WARNING - grub-MR not found; using grub-install");
         }
@@ -1504 +1505 @@
         iamhere(command);
         res = run_program_and_log_output(command, 1);
-        paranoid_free(command);
+        mr_free(command);
 
         if (res) {
@@ -1563 +1564 @@
                             _
                             ("Modifying fstab and elilo.conf...                             "));
-        asprintf(&command, "stabelilo-me");
+        mr_asprintf(&command, "stabelilo-me");
         res = run_program_and_log_output(command, 3);
-        paranoid_free(command);
+        mr_free(command);
 
         if (res) {
@@ -1576 +1577 @@
                 }
                 editor = find_my_editor();
-                asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+                mr_asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
                 paranoid_system(tmp);
-                paranoid_free(tmp);
-
-                asprintf(&tmp, "%s " MNT_RESTORING "/etc/elilo.conf", editor);
-                paranoid_free(editor);
+                mr_free(tmp);
+
+                mr_asprintf(&tmp, "%s " MNT_RESTORING "/etc/elilo.conf", editor);
+                mr_free(editor);
 
                 paranoid_system(tmp);
-                paranoid_free(tmp);
+                mr_free(tmp);
 
                 if (!g_text_mode) {
@@ -1638 +1639 @@
                             _
                             ("Modifying fstab and lilo.conf, and running LILO...                             "));
-        asprintf(&command, "stablilo-me");
+        mr_asprintf(&command, "stablilo-me");
         res = run_program_and_log_output(command, 3);
-        paranoid_free(command);
+        mr_free(command);
 
         if (res) {
@@ -1651 +1652 @@
                 }
                 editor = find_my_editor();
-                asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+                mr_asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
                 paranoid_system(tmp);
-                paranoid_free(tmp);
-
-                asprintf(&tmp, "%s " MNT_RESTORING "/etc/lilo.conf", editor);
-                paranoid_free(editor);
+                mr_free(tmp);
+
+                mr_asprintf(&tmp, "%s " MNT_RESTORING "/etc/lilo.conf", editor);
+                mr_free(editor);
 
                 paranoid_system(tmp);
-                paranoid_free(tmp);
+                mr_free(tmp);
 
                 if (!g_text_mode) {
@@ -1753 +1754 @@
                 }
                 editor = find_my_editor();
-                asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
-                paranoid_free(editor);
+                mr_asprintf(&tmp, "%s " MNT_RESTORING "/etc/fstab", editor);
+                mr_free(editor);
 
                 paranoid_system(tmp);
-                paranoid_free(tmp);
+                mr_free(tmp);
 
                 if (!g_text_mode) {
@@ -1767 +1768 @@
                                  _
                                  ("Please confirm/enter the boot device. If in doubt, try /dev/hda"), bd);
-            asprintf(&command, "stabraw-me %s", bd);
+            mr_asprintf(&command, "stabraw-me %s", bd);
             res = run_program_and_log_output(command, 3);
-            paranoid_free(command);
+            mr_free(command);
 
             if (res) {
@@ -1783 +1784 @@
                             _
                             ("Restoring MBR...                                               "));
-        asprintf(&command, "raw-MR %s /tmp/mountlist.txt", bd);
+        mr_asprintf(&command, "raw-MR %s /tmp/mountlist.txt", bd);
         log_msg(2, "run_raw_mbr() --- command='%s'", command);
         res = run_program_and_log_output(command, 3);
-        paranoid_free(command);
+        mr_free(command);
     }
     if (res) {
@@ -1839 +1840 @@
     assert(bkpinfo != NULL);
 
-    asprintf(&g_biggielist_txt, "%s/%s",bkpinfo->tmpdir , BIGGIELIST_TXT_STUB);
-    asprintf(&g_filelist_full, "%s/%s", bkpinfo->tmpdir, FILELIST_FULL_STUB);
-    asprintf(&g_filelist_imagedevs, "%s/tmp/filelist.imagedevs", bkpinfo->tmpdir);
-    asprintf(&g_imagedevs_restthese, "%s/tmp/imagedevs.restore-these",
+    mr_asprintf(&g_biggielist_txt, "%s/%s",bkpinfo->tmpdir , BIGGIELIST_TXT_STUB);
+    mr_asprintf(&g_filelist_full, "%s/%s", bkpinfo->tmpdir, FILELIST_FULL_STUB);
+    mr_asprintf(&g_filelist_imagedevs, "%s/tmp/filelist.imagedevs", bkpinfo->tmpdir);
+    mr_asprintf(&g_imagedevs_restthese, "%s/tmp/imagedevs.restore-these",
             bkpinfo->tmpdir);
-    paranoid_free(g_mondo_cfg_file);
-    paranoid_free(g_mountlist_fname);
+    mr_free(g_mondo_cfg_file);
+    mr_free(g_mountlist_fname);
     if (bkpinfo->disaster_recovery) {
-        asprintf(&g_mondo_cfg_file, "/%s", MONDO_CFG_FILE_STUB);
-        asprintf(&g_mountlist_fname, "/%s", MOUNTLIST_FNAME_STUB);
-    } else {
-        asprintf(&g_mondo_cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
-        asprintf(&g_mountlist_fname, "%s/%s", bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
+        mr_asprintf(&g_mondo_cfg_file, "/%s", MONDO_CFG_FILE_STUB);
+        mr_asprintf(&g_mountlist_fname, "/%s", MOUNTLIST_FNAME_STUB);
+    } else {
+        mr_asprintf(&g_mondo_cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
+        mr_asprintf(&g_mountlist_fname, "%s/%s", bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
     }
 }
@@ -1882 +1883 @@
         fatal_error("cannot open output_file");
     }
-    for (getline(&incoming, &n, fin); !feof(fin);
-         getline(&incoming, &n, fin)) {
+    for (mr_getline(&incoming, &n, fin); !feof(fin);
+         mr_getline(&incoming, &n, fin)) {
         if (strncmp(incoming, "etc/adjtime", 11)
             && strncmp(incoming, "etc/mtab", 8)
@@ -1893 +1894 @@
             fprintf(fout, "%s", incoming);  /* don't need \n here, for some reason.. */
     }
-    paranoid_free(incoming);
+    mr_free(incoming);
     paranoid_fclose(fout);
     paranoid_fclose(fin);
@@ -1936 +1937 @@
     for (i = 0; i < 20; i++) {
         g_current_progress = i;
-        asprintf(&tmp, _("You have %d seconds left to abort."), 20 - i);
+        mr_asprintf(&tmp, _("You have %d seconds left to abort."), 20 - i);
         update_progress_form(tmp);
-        paranoid_free(tmp);
+        mr_free(tmp);
         sleep(1);
     }
@@ -2025 +2026 @@
             continue;
         }
-        asprintf(&tmp, _("Unmounting device %s  "),
+        mr_asprintf(&tmp, _("Unmounting device %s  "),
                 mountlist->el[lino].device);
 
@@ -2032 +2033 @@
         if (is_this_device_mounted(mountlist->el[lino].device)) {
             if (!strcmp(mountlist->el[lino].mountpoint, "swap")) {
-                asprintf(&command, "swapoff %s", mountlist->el[lino].device);
+                mr_asprintf(&command, "swapoff %s", mountlist->el[lino].device);
             } else {
                 if (!strcmp(mountlist->el[lino].mountpoint, "/1")) {
-                    asprintf(&command, "umount %s/", MNT_RESTORING);
+                    mr_asprintf(&command, "umount %s/", MNT_RESTORING);
                     log_msg(3,
                             "Well, I know a certain kitty-kitty who'll be sleeping with Mommy tonight...");
                 } else {
-                    asprintf(&command, "umount " MNT_RESTORING "%s",
+                    mr_asprintf(&command, "umount " MNT_RESTORING "%s",
                             mountlist->el[lino].mountpoint);
                 }
@@ -2045 +2046 @@
             log_msg(10, "The 'umount' command is '%s'", command);
             res = run_program_and_log_output(command, 3);
-            paranoid_free(command);
+            mr_free(command);
         } else {
-            asprintf(&tmp1, "%s%s", tmp, _("...not mounted anyway :-) OK"));
-            paranoid_free(tmp);
+            mr_asprintf(&tmp1, "%s%s", tmp, _("...not mounted anyway :-) OK"));
+            mr_free(tmp);
             tmp = tmp1;
             res = 0;
@@ -2054 +2055 @@
         g_current_progress++;
         if (res) {
-            asprintf(&tmp1, "%s%s", tmp, _("...Failed"));
-            paranoid_free(tmp);
+            mr_asprintf(&tmp1, "%s%s", tmp, _("...Failed"));
+            mr_free(tmp);
             tmp = tmp1;
             retval++;
@@ -2062 +2063 @@
             log_msg(2, tmp);
         }
-        paranoid_free(tmp);
+        mr_free(tmp);
     }
     close_progress_form();
@@ -2097 +2098 @@
 
     // tar -zxvf-
-    asprintf(&command,
+    mr_asprintf(&command,
             "dd if=%s bs=%ld count=%ld 2> /dev/null | tar -zx %s %s %s %s %s",
             dev,
@@ -2106 +2107 @@
     log_msg(2, "command = '%s'", command);
     res = run_program_and_log_output(command, -1);
-    paranoid_free(command);
+    mr_free(command);
 
     if (res != 0 && does_file_exist(MONDO_CFG_FILE_STUB)) {
@@ -2142 +2143 @@
     log_msg(2, "gcffa --- starting");
     log_to_screen(_("I'm thinking..."));
-    asprintf(&mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
+    mr_asprintf(&mountpt, "%s/mount.bootdisk", bkpinfo->tmpdir);
     chdir(bkpinfo->tmpdir);
     // MONDO_CFG_FILE_STUB is missing the '/' at the start, FYI, by intent
@@ -2150 +2151 @@
     unlink(BIGGIELIST_TXT_STUB);
     unlink("tmp/i-want-my-lvm");
-    asprintf(&command, "mkdir -p %s", mountpt);
+    mr_asprintf(&command, "mkdir -p %s", mountpt);
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
-
-    asprintf(&cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
-    asprintf(&mountlist_file, "%s/%s", bkpinfo->tmpdir,
+    mr_free(command);
+
+    mr_asprintf(&cfg_file, "%s/%s", bkpinfo->tmpdir, MONDO_CFG_FILE_STUB);
+    mr_asprintf(&mountlist_file, "%s/%s", bkpinfo->tmpdir,
             MOUNTLIST_FNAME_STUB);
     log_msg(2, "mountpt = %s; cfg_file=%s", mountpt, cfg_file);
 
     /* Floppy? */
-    asprintf(&tmp, "mkdir -p %s", mountpt);
+    mr_asprintf(&tmp, "mkdir -p %s", mountpt);
     run_program_and_log_output(tmp, FALSE);
-    paranoid_free(tmp);
-
-    asprintf(&tmp, "mkdir -p %s/tmp", bkpinfo->tmpdir);
+    mr_free(tmp);
+
+    mr_asprintf(&tmp, "mkdir -p %s/tmp", bkpinfo->tmpdir);
     run_program_and_log_output(tmp, FALSE);
-    paranoid_free(tmp);
-
-    asprintf(&command, "mount /dev/fd0u1722 %s", mountpt);
-    asprintf(&tmp,
+    mr_free(tmp);
+
+    mr_asprintf(&command, "mount /dev/fd0u1722 %s", mountpt);
+    mr_asprintf(&tmp,
             "(sleep 15; kill `ps | grep \"%s\" | cut -d' ' -f1` 2> /dev/null) &",
             command);
     log_msg(1, "tmp = '%s'", tmp);
     system(tmp);
-    paranoid_free(tmp);
+    mr_free(tmp);
 
     res = run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
+    mr_free(command);
 
     if (res) {
-        asprintf(&command, "mount /dev/fd0H1440 %s", mountpt);
+        mr_asprintf(&command, "mount /dev/fd0H1440 %s", mountpt);
         res = run_program_and_log_output(command, FALSE);
-        paranoid_free(command);
+        mr_free(command);
     }
     if (res) {
@@ -2192 +2193 @@
 // NB: If busybox does not support 'mount -o loop' then Plan A WILL NOT WORK.
         log_msg(2, "Processing floppy (plan A?)");
-        asprintf(&ramdisk_fname, "%s/mindi.rdz", mountpt);
+        mr_asprintf(&ramdisk_fname, "%s/mindi.rdz", mountpt);
         if (!does_file_exist(ramdisk_fname)) {
-            paranoid_free(ramdisk_fname);
-            asprintf(&ramdisk_fname, "%s/initrd.img", mountpt);
+            mr_free(ramdisk_fname);
+            mr_asprintf(&ramdisk_fname, "%s/initrd.img", mountpt);
         }
         if (!does_file_exist(ramdisk_fname)) {
@@ -2206 +2207 @@
                     "Warning - failed to extract config file from ramdisk. I think this boot disk is mangled.");
         }
-        asprintf(&command, "umount %s", mountpt);
+        mr_asprintf(&command, "umount %s", mountpt);
         run_program_and_log_output(command, 5);
-        paranoid_free(command);
+        mr_free(command);
 
         unlink(ramdisk_fname);
-        paranoid_free(ramdisk_fname);
+        mr_free(ramdisk_fname);
     }
     if (!does_file_exist(cfg_file)) {
@@ -2237 +2238 @@
 
             if (bkpinfo->media_device == NULL) {
-                asprintf(&bkpinfo->media_device, "/dev/st0");
+                mr_asprintf(&bkpinfo->media_device, "/dev/st0");
                 log_msg(2, "media_device is blank; assuming %s",
                         bkpinfo->media_device);
             }
-            asprintf(&sav, bkpinfo->media_device);
+            mr_asprintf(&sav, bkpinfo->media_device);
             if (extract_cfg_file_and_mountlist_from_tape_dev
                 (bkpinfo->media_device)) {
-                paranoid_alloc(bkpinfo->media_device, "/dev/st0");
+                mr_allocstr(bkpinfo->media_device, "/dev/st0");
                 if (extract_cfg_file_and_mountlist_from_tape_dev
                     (bkpinfo->media_device)) {
-                    paranoid_alloc(bkpinfo->media_device, "/dev/osst0");
+                    mr_allocstr(bkpinfo->media_device, "/dev/osst0");
                     if (extract_cfg_file_and_mountlist_from_tape_dev
                         (bkpinfo->media_device)) {
-                        paranoid_alloc(bkpinfo->media_device, "/dev/ht0");
+                        mr_allocstr(bkpinfo->media_device, "/dev/ht0");
                         if (extract_cfg_file_and_mountlist_from_tape_dev
                             (bkpinfo->media_device)) {
                             log_msg(3,
                                     "I tried lots of devices but none worked.");
-                            paranoid_alloc(bkpinfo->media_device, sav);
+                            mr_allocstr(bkpinfo->media_device, sav);
                         }
                     }
                 }
             }
-            paranoid_free(sav);
+            mr_free(sav);
 
             if (!does_file_exist("tmp/mondo-restore.cfg")) {
@@ -2271 +2272 @@
                     "gcffa --- looking at mounted CD for mindi-boot.2880.img");
             /* BERLIOS : Useless ?
-            asprintf(&command,
+            mr_asprintf(&command,
                     "mount " MNT_CDROM
                     "/images/mindi-boot.2880.img -o loop %s", mountpt);
                     */
-            asprintf(&mounted_cfgf_path, "%s/%s", mountpt, cfg_file);
+            mr_asprintf(&mounted_cfgf_path, "%s/%s", mountpt, cfg_file);
             if (!does_file_exist(mounted_cfgf_path)) {
                 log_msg(2,
                         "gcffa --- Plan C, a.k.a. untarring some file from all.tar.gz");
-                asprintf(&command, "tar -zxvf " MNT_CDROM "/images/all.tar.gz %s %s %s %s %s", MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, "tmp/i-want-my-lvm");    // add -b TAPE_BLOCK_SIZE if you _really_ think it's necessary
+                mr_asprintf(&command, "tar -zxvf " MNT_CDROM "/images/all.tar.gz %s %s %s %s %s", MOUNTLIST_FNAME_STUB, MONDO_CFG_FILE_STUB, BIGGIELIST_TXT_STUB, FILELIST_FULL_STUB, "tmp/i-want-my-lvm"); // add -b TAPE_BLOCK_SIZE if you _really_ think it's necessary
                 run_program_and_log_output(command, TRUE);
-                paranoid_free(command);
+                mr_free(command);
 
                 if (!does_file_exist(MONDO_CFG_FILE_STUB)) {
@@ -2288 +2289 @@
                 }
             }
-            paranoid_free(mounted_cfgf_path);
-        }
-    }
-    paranoid_free(mountpt);
+            mr_free(mounted_cfgf_path);
+        }
+    }
+    mr_free(mountpt);
 
     if (does_file_exist(MONDO_CFG_FILE_STUB)) {
         log_msg(1, "gcffa --- great! We've got the config file");
         tmp1 = call_program_and_get_last_line_of_output("pwd");
-        asprintf(&tmp, "%s/%s", tmp1,MONDO_CFG_FILE_STUB);
-        asprintf(&command, "cp -f %s %s", tmp, cfg_file);
+        mr_asprintf(&tmp, "%s/%s", tmp1,MONDO_CFG_FILE_STUB);
+        mr_asprintf(&command, "cp -f %s %s", tmp, cfg_file);
         iamhere(command);
 
@@ -2308 +2309 @@
             log_msg(1, "... and I moved it successfully to %s", cfg_file);
         }
-        paranoid_free(command);
-
-        asprintf(&command, "cp -f %s/%s %s",tmp1,
+        mr_free(command);
+
+        mr_asprintf(&command, "cp -f %s/%s %s",tmp1,
                 MOUNTLIST_FNAME_STUB, mountlist_file);
-        paranoid_free(tmp1);
+        mr_free(tmp1);
 
         iamhere(command);
@@ -2320 +2321 @@
         } else {
             log_msg(1, "Got mountlist too");
-            paranoid_free(command);
-            asprintf(&command, "cp -f %s %s", mountlist_file,
+            mr_free(command);
+            mr_asprintf(&command, "cp -f %s %s", mountlist_file,
                     g_mountlist_fname);
             if (run_program_and_log_output(command, 1)) {
@@ -2327 +2328 @@
             } else {
                 log_msg(1, "Copied mountlist to /tmp as well OK");
-                paranoid_free(command);
-                asprintf(&command, "cp -f tmp/i-want-my-lvm /tmp/");
+                mr_free(command);
+                mr_asprintf(&command, "cp -f tmp/i-want-my-lvm /tmp/");
                 run_program_and_log_output(command, 1);
             }
         }
-        paranoid_free(command);
-        paranoid_free(tmp);
+        mr_free(command);
+        mr_free(tmp);
     }
     run_program_and_log_output("umount " MNT_CDROM, FALSE);
@@ -2351 +2352 @@
 /* start SAH */
     else {
-        asprintf(&command, "cp -f %s %s/%s", MOUNTLIST_FNAME_STUB,
+        mr_asprintf(&command, "cp -f %s %s/%s", MOUNTLIST_FNAME_STUB,
                 bkpinfo->tmpdir, MOUNTLIST_FNAME_STUB);
         run_program_and_log_output(command, FALSE);
-        paranoid_free(command);
+        mr_free(command);
     }
 /* end SAH */
 
-    asprintf(&command, "cp -f %s /%s", cfg_file, MONDO_CFG_FILE_STUB);
-    paranoid_free(cfg_file);
+    mr_asprintf(&command, "cp -f %s /%s", cfg_file, MONDO_CFG_FILE_STUB);
+    mr_free(cfg_file);
 
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
-
-    asprintf(&command, "cp -f %s /%s", mountlist_file, MOUNTLIST_FNAME_STUB);
-    paranoid_free(mountlist_file);
+    mr_free(command);
+
+    mr_asprintf(&command, "cp -f %s /%s", mountlist_file, MOUNTLIST_FNAME_STUB);
+    mr_free(mountlist_file);
 
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
-
-    asprintf(&command, "cp -f etc/raidtab /etc/");
+    mr_free(command);
+
+    mr_asprintf(&command, "cp -f etc/raidtab /etc/");
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
-
-    asprintf(&command, "cp -f tmp/i-want-my-lvm /tmp/");
+    mr_free(command);
+
+    mr_asprintf(&command, "cp -f tmp/i-want-my-lvm /tmp/");
     run_program_and_log_output(command, FALSE);
-    paranoid_free(command);
+    mr_free(command);
 
     g_backup_media_type = bkpinfo->backup_media_type;
@@ -2412 +2413 @@
                 log_msg(1, "Sync'ing %s (i=%d)",
                         raidlist->el[i].raid_device, i);
-                asprintf(&screen_message, "Sync'ing %s",
+                mr_asprintf(&screen_message, "Sync'ing %s",
                         raidlist->el[i].raid_device);
                 open_evalcall_form(screen_message);
-                paranoid_free(screen_message);
+                mr_free(screen_message);
 
                 if (raidlist->el[i].progress == -1) { // delayed while another partition inits
@@ -2434 +2435 @@
         }
     }
-    paranoid_free(raidlist);
-}
+    mr_free(raidlist);
+}