Ignore:
Timestamp:
Oct 24, 2006, 8:49:18 AM (14 years ago)
Author:
Bruno Cornec
Message:

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/mondo/src/common/libmondo-devices.c

    r839 r900  
    1717#include "libmondo-fork-EXT.h"
    1818#include "libmondo-stream-EXT.h"
     19#include "mr_mem.h"
    1920
    2021#include <sys/ioctl.h>
     
    6263{
    6364    if (bkpinfo->media_device != NULL) {
    64         paranoid_alloc(g_cdrom_drive_is_here, bkpinfo->media_device);   // just in case
    65         paranoid_alloc(g_dvd_drive_is_here, bkpinfo->media_device); // just in case
     65        mr_allocstr(g_cdrom_drive_is_here, bkpinfo->media_device);  // just in case
     66        mr_allocstr(g_dvd_drive_is_here, bkpinfo->media_device);    // just in case
    6667    }
    6768}
     
    113114    make_hole_for_dir(mountpoint);
    114115    if (isdigit(device[0])) {
    115         paranoid_free(device);
     116        mr_free(device);
    116117        device = find_cdrom_device(FALSE);
    117118    }
     
    123124        dev = make_vn(device));
    124125        if (!dev) {
    125             asprintf(&command, "Unable to mount ISO (make_vn(%s) failed)",
     126            mr_asprintf(&command, "Unable to mount ISO (make_vn(%s) failed)",
    126127                    device);
    127128            fatal_error(command);
    128129        }
    129         paranoid_free(device);
     130        mr_free(device);
    130131        device = dev;
    131132#endif
     
    137138
    138139#ifdef __FreeBSD__
    139     asprintf(&command, "mount_cd9660 -r %s %s 2>> %s",
     140    mr_asprintf(&command, "mount_cd9660 -r %s %s 2>> %s",
    140141            device, mountpoint, MONDO_LOGFILE);
    141142#else
    142     asprintf(&command, "mount %s -o ro,loop -t iso9660 %s 2>> %s",
     143    mr_asprintf(&command, "mount %s -o ro,loop -t iso9660 %s 2>> %s",
    143144            device, mountpoint, MONDO_LOGFILE);
    144145#endif
     
    150151    retval = system(command);
    151152    log_msg(1, "system(%s) returned %d", command, retval);
    152     paranoid_free(command);
     153    mr_free(command);
    153154
    154155    if (retval == 0) {
     
    171172    bool is_this_a_ramdisk = FALSE;
    172173
    173     asprintf(&tmp, where_is_root_mounted());
    174     asprintf(&comment, "root is mounted at %s\n", tmp);
     174    mr_asprintf(&tmp, where_is_root_mounted());
     175    mr_asprintf(&comment, "root is mounted at %s\n", tmp);
    175176    log_msg(0, comment);
    176     paranoid_free(comment);
     177    mr_free(comment);
    177178
    178179    log_msg(0,
     
    194195    }
    195196#endif
    196     paranoid_free(tmp);
     197    mr_free(tmp);
    197198
    198199    if (is_this_a_ramdisk) {
     
    222223    char *output = NULL;
    223224
    224     paranoid_free(output);
     225    mr_free(output);
    225226
    226227    switch (bt) {
    227228    case none:
    228         asprintf(&output, _("none"));
     229        mr_asprintf(&output, _("none"));
    229230        break;
    230231    case iso:
    231         asprintf(&output, _("iso"));
     232        mr_asprintf(&output, _("iso"));
    232233        break;
    233234    case cdr:
    234         asprintf(&output, _("cdr"));
     235        mr_asprintf(&output, _("cdr"));
    235236        break;
    236237    case cdrw:
    237         asprintf(&output, _("cdrw"));
     238        mr_asprintf(&output, _("cdrw"));
    238239        break;
    239240    case cdstream:
    240         asprintf(&output, _("cdstream"));
     241        mr_asprintf(&output, _("cdstream"));
    241242        break;
    242243    case nfs:
    243         asprintf(&output, _("nfs"));
     244        mr_asprintf(&output, _("nfs"));
    244245        break;
    245246    case tape:
    246         asprintf(&output, _("tape"));
     247        mr_asprintf(&output, _("tape"));
    247248        break;
    248249    case udev:
    249         asprintf(&output, _("udev"));
     250        mr_asprintf(&output, _("udev"));
    250251        break;
    251252    default:
    252         asprintf(&output, _("default"));
     253        mr_asprintf(&output, _("default"));
    253254    }
    254255    return (output);
     
    272273    if (IS_THIS_A_STREAMING_BACKUP(g_backup_media_type)
    273274        && g_backup_media_type != udev) {
    274         asprintf(&command, "mt -f %s offline", dev);
     275        mr_asprintf(&command, "mt -f %s offline", dev);
    275276        res1 = run_program_and_log_output(command, 1);
    276         paranoid_free(command);
     277        mr_free(command);
    277278    } else {
    278279        res1 = 0;
     
    281282#ifdef __FreeBSD__
    282283    if (strstr(dev, "acd")) {
    283         asprintf(&command, "cdcontrol -f %s eject", dev);
    284     } else {
    285         asprintf(&command, "camcontrol eject `echo %s | sed 's|/dev/||'`",
     284        mr_asprintf(&command, "cdcontrol -f %s eject", dev);
     285    } else {
     286        mr_asprintf(&command, "camcontrol eject `echo %s | sed 's|/dev/||'`",
    286287                dev);
    287288    }
    288289#else
    289     asprintf(&command, "eject %s", dev);
     290    mr_asprintf(&command, "eject %s", dev);
    290291#endif
    291292
    292293    log_msg(3, "Ejecting %s", dev);
    293294    res2 = run_program_and_log_output(command, 1);
    294     paranoid_free(command);
     295    mr_free(command);
    295296    if (res1 && res2) {
    296297        return (1);
     
    313314#ifdef __FreeBSD__
    314315    if (strstr(dev, "acd")) {
    315         asprintf(&command, "cdcontrol -f %s close", dev);
    316     } else {
    317         asprintf(&command, "camcontrol load `echo %s | sed 's|/dev/||'`",
     316        mr_asprintf(&command, "cdcontrol -f %s close", dev);
     317    } else {
     318        mr_asprintf(&command, "camcontrol load `echo %s | sed 's|/dev/||'`",
    318319                dev);
    319320    }
    320321#else
    321     asprintf(&command, "eject -t %s", dev);
     322    mr_asprintf(&command, "eject -t %s", dev);
    322323#endif
    323324    i = run_program_and_log_output(command, FALSE);
    324     paranoid_free(command);
     325    mr_free(command);
    325326    return (i);
    326327}
     
    341342    assert_string_is_neither_NULL_nor_zerolength(device);
    342343
    343     asprintf(&tmp, "ls %s > /dev/null 2> /dev/null", device);
     344    mr_asprintf(&tmp, "ls %s > /dev/null 2> /dev/null", device);
    344345
    345346    if (system(tmp)) {
     
    348349        ret = TRUE;
    349350    }
    350     paranoid_free(tmp);
     351    mr_free(tmp);
    351352    return(ret);
    352353}
     
    398399#ifdef __FreeBSD__
    399400    // We assume here that this is running from mondorestore. (It is.)
    400     asprintf(&program, "ls %s >/dev/null 2>&1", drive);
     401    mr_asprintf(&program, "ls %s >/dev/null 2>&1", drive);
    401402    res = system(program);
    402     paranoid_free(program);
     403    mr_free(program);
    403404    return(res);
    404405#endif
    405406
    406     asprintf(&program, "parted2fdisk -l %s 2> /dev/null", drive);
     407    mr_asprintf(&program, "parted2fdisk -l %s 2> /dev/null", drive);
    407408    fin = popen(program, "r");
    408409    if (!fin) {
    409410        log_it("program=%s", program);
    410411        log_OS_error("Cannot popen-in program");
    411         paranoid_free(program);
     412        mr_free(program);
    412413        return (0);
    413414    }
    414     paranoid_free(program);
     415    mr_free(program);
    415416
    416417    searchstr = build_partition_name(drive, partno);
    417     asprintf(&tmp, "%s ", searchstr);
    418     paranoid_free(searchstr);
    419 
    420     for (res = 0; !res && getline(&incoming, &n, fin);) {
     418    mr_asprintf(&tmp, "%s ", searchstr);
     419    mr_free(searchstr);
     420
     421    for (res = 0; !res ;) {
     422        mr_getline(&incoming, &n, fin);
    421423        if (strstr(incoming, tmp)) {
    422424            res = 1;
    423425        }
    424426    }
    425     paranoid_free(incoming);
     427    mr_free(incoming);
    426428
    427429    if (pclose(fin)) {
    428430        log_OS_error("Cannot pclose fin");
    429431    }
    430     paranoid_free(tmp);
     432    mr_free(tmp);
    431433    return (res);
    432434}
     
    450452    assert_string_is_neither_NULL_nor_zerolength(str);
    451453
    452     asprintf(&command,
     454    mr_asprintf(&command,
    453455            "dd if=%s bs=446 count=1 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null",
    454456            dev, str);
    455457    ret = system(command);
    456     paranoid_free(command);
     458    mr_free(command);
    457459    if (ret) {
    458460        return (FALSE);
     
    477479    int ret;
    478480
    479     asprintf(&command,
     481    mr_asprintf(&command,
    480482            "dd if=%s bs=512 count=%i 2> /dev/null | strings | grep \"%s\" > /dev/null 2> /dev/null",
    481483            dev, n, str);
    482484    ret = system(command);
    483     paranoid_free(command);
     485    mr_free(command);
    484486
    485487    if (ret) {
     
    514516    if (g_backup_media_type == dvd) {
    515517        if (g_dvd_drive_is_here != NULL) {
    516             asprintf(&dev, g_dvd_drive_is_here);
     518            mr_asprintf(&dev, g_dvd_drive_is_here);
    517519        } else {
    518520            dev = find_dvd_device();
     
    520522    } else {
    521523        if (g_cdrom_drive_is_here != NULL) {
    522             asprintf(&dev, g_cdrom_drive_is_here);
     524            mr_asprintf(&dev, g_cdrom_drive_is_here);
    523525        } else {
    524526            // find_cdrom_device allocates the string
     
    532534
    533535    if ((dev == NULL) || (! mount_CDROM_here(dev, mountpoint))) {
    534         paranoid_free(dev);
     536        mr_free(dev);
    535537        if (!popup_and_get_string
    536538            (_("CD-ROM device"), _("Please enter your CD-ROM's /dev device"), dev)) {
     
    545547        log_msg(1, _("mount succeeded with %s"), dev);
    546548    }
    547     paranoid_free(dev);
     549    mr_free(dev);
    548550    return(res);
    549551}
     
    565567
    566568    if (g_cdrw_drive_is_here != NULL) {
    567         asprintf(&cdrw_device, g_cdrw_drive_is_here);
     569        mr_asprintf(&cdrw_device, g_cdrw_drive_is_here);
    568570        log_msg(3, "Been there, done that. Returning %s", cdrw_device);
    569571        return(cdrw_device);
     
    577579    tmp = find_home_of_exe("cdrecord");
    578580    if (tmp) {
    579         asprintf(&cdr_exe, "cdrecord");
    580     } else {
    581         asprintf(&cdr_exe, "dvdrecord");
    582     }
    583     paranoid_free(tmp);
     581        mr_asprintf(&cdr_exe, "cdrecord");
     582    } else {
     583        mr_asprintf(&cdr_exe, "dvdrecord");
     584    }
     585    mr_free(tmp);
    584586
    585587    tmp1 = find_home_of_exe(cdr_exe);
    586588    if (tmp1) {
    587         asprintf(&command,
     589        mr_asprintf(&command,
    588590                "%s -scanbus 2> /dev/null | tr -s '\t' ' ' | grep \"[0-9]*,[0-9]*,[0-9]*\" | grep -v \"[0-9]*) \\*\" | grep CD | cut -d' ' -f2 | head -n1",
    589591                cdr_exe);
    590         asprintf(&tmp, call_program_and_get_last_line_of_output(command));
    591         paranoid_free(command);
    592     } else {
    593         asprintf(&tmp, " ");
    594     }
    595     paranoid_free(tmp1);
    596     paranoid_free(cdr_exe);
     592        mr_asprintf(&tmp, call_program_and_get_last_line_of_output(command));
     593        mr_free(command);
     594    } else {
     595        mr_asprintf(&tmp, " ");
     596    }
     597    mr_free(tmp1);
     598    mr_free(cdr_exe);
    597599
    598600    if (strlen(tmp) < 2) {
    599         paranoid_free(tmp);
     601        mr_free(tmp);
    600602        return(NULL);
    601603    } else {
    602604        cdrw_device = tmp;
    603605
    604         asprintf(&comment, "Found CDRW device - %s", cdrw_device);
     606        mr_asprintf(&comment, "Found CDRW device - %s", cdrw_device);
    605607        log_it(comment);
    606         paranoid_free(comment);
    607 
    608         paranoid_free(g_cdrw_drive_is_here);
    609         asprintf(&g_cdrw_drive_is_here, cdrw_device);
     608        mr_free(comment);
     609
     610        mr_free(g_cdrw_drive_is_here);
     611        mr_asprintf(&g_cdrw_drive_is_here, cdrw_device);
    610612        return(cdrw_device);
    611613    }
     
    649651
    650652    if ((g_cdrom_drive_is_here != NULL) && !isdigit(g_cdrom_drive_is_here[0])) {
    651         asprintf(&output, g_cdrom_drive_is_here);
     653        mr_asprintf(&output, g_cdrom_drive_is_here);
    652654        log_msg(3, "Been there, done that. Returning %s", output);
    653655        return(output);
    654656    }
    655657    if ((the_last_place_i_found_it != NULL) && !try_to_mount) {
    656         asprintf(&output, the_last_place_i_found_it);
     658        mr_asprintf(&output, the_last_place_i_found_it);
    657659        log_msg(3,
    658660                "find_cdrom_device() --- returning last found location - '%s'",
     
    663665    tmp = find_home_of_exe("cdrecord");
    664666    if (tmp) {
    665         asprintf(&cdr_exe, "cdrecord");
    666     } else {
    667         asprintf(&cdr_exe, "dvdrecord");
    668     }
    669     paranoid_free(tmp);
     667        mr_asprintf(&cdr_exe, "cdrecord");
     668    } else {
     669        mr_asprintf(&cdr_exe, "dvdrecord");
     670    }
     671    mr_free(tmp);
    670672
    671673    tmp = find_home_of_exe(cdr_exe);
    672674    if (!tmp) {
    673         asprintf(&output, "/dev/cdrom");
     675        mr_asprintf(&output, "/dev/cdrom");
    674676        log_msg(4, "Can't find cdrecord; assuming %s", output);
    675677        if (!does_device_exist(output)) {
    676678            log_msg(4, "That didn't work. Sorry.");
    677             paranoid_free(cdr_exe);
    678             paranoid_free(output);
     679            mr_free(cdr_exe);
     680            mr_free(output);
    679681            return(NULL);
    680682        } else {
    681             paranoid_free(cdr_exe);
     683            mr_free(cdr_exe);
    682684            return(output);
    683685        }
    684686    }
    685     paranoid_free(tmp);
    686 
    687     asprintf(&command, "%s -scanbus 2> /dev/null", cdr_exe);
     687    mr_free(tmp);
     688
     689    mr_asprintf(&command, "%s -scanbus 2> /dev/null", cdr_exe);
    688690    fin = popen(command, "r");
    689691    if (!fin) {
    690692        log_msg(4, "command=%s", command);
    691693        log_OS_error("Cannot popen command");
    692         paranoid_free(cdr_exe);
    693         paranoid_free(command);
     694        mr_free(cdr_exe);
     695        mr_free(command);
    694696        return (NULL);
    695697    }
    696     paranoid_free(command);
    697 
    698     for (getline(&tmp, &n, fin); !feof(fin);
    699          getline(&tmp, &n, fin)) {
     698    mr_free(command);
     699
     700    for (mr_getline(&tmp, &n, fin); !feof(fin);
     701         mr_getline(&tmp, &n, fin)) {
    700702        p = strchr(tmp, '\'');
    701703        if (p) {
     
    713715                        *q = '\0';
    714716#ifndef __FreeBSD__
    715                         paranoid_free(phrase_two);
    716                         asprintf(&phrase_two, p);
     717                        mr_free(phrase_two);
     718                        mr_asprintf(&phrase_two, p);
    717719#endif
    718720                    }
     
    722724    }
    723725    paranoid_pclose(fin);
    724     paranoid_free(tmp);
     726    mr_free(tmp);
    725727    tmp = NULL;
    726728    n = 0;
     
    730732        log_msg(4, "Not running phase two. String is empty.");
    731733    } else {
    732         asprintf(&command, "dmesg | grep \"%s\" 2> /dev/null", phrase_two);
     734        mr_asprintf(&command, "dmesg | grep \"%s\" 2> /dev/null", phrase_two);
    733735        fin = popen(command, "r");
    734736        if (!fin) {
    735737            log_msg(4, "Cannot run 2nd command - non-fatal, fortunately");
    736738        } else {
    737             for (getline(&tmp, &n, fin); !feof(fin);
    738                  getline(&tmp, &n, fin)) {
     739            for (mr_getline(&tmp, &n, fin); !feof(fin);
     740                 mr_getline(&tmp, &n, fin)) {
    739741                log_msg(5, "--> '%s'", tmp);
    740742                if (tmp[0] != ' ' && tmp[1] != ' ') {
     
    743745                        *p = '\0';
    744746                        if (strstr(tmp, "DVD")) {
    745                             paranoid_free(dvd_last_resort);
    746                             asprintf(&dvd_last_resort, "/dev/%s", tmp);
     747                            mr_free(dvd_last_resort);
     748                            mr_asprintf(&dvd_last_resort, "/dev/%s", tmp);
    747749                            log_msg(4,
    748750                                    "Ignoring '%s' because it's a DVD drive",
    749751                                    tmp);
    750752                        } else {
    751                             asprintf(&output, "/dev/%s", tmp);
     753                            mr_asprintf(&output, "/dev/%s", tmp);
    752754                            found_it = TRUE;
    753755                        }
     
    755757                }
    756758            }
    757             paranoid_free(tmp);
     759            mr_free(tmp);
    758760            paranoid_pclose(fin);
    759761        }
    760         paranoid_free(command);
    761     }
    762     paranoid_free(phrase_two);
     762        mr_free(command);
     763    }
     764    mr_free(phrase_two);
    763765
    764766#endif
     
    789791                                                              "/dev/cd1")))
    790792                                {
    791                                     paranoid_free(cdr_exe);
     793                                    mr_free(cdr_exe);
    792794                                    return(NULL);
    793795                                }
     
    804806            log_msg(4, "Well, I'll use the DVD - %s - as a last resort",
    805807                    dvd_last_resort);
    806             paranoid_free(output);
    807             asprintf(&output, dvd_last_resort);
     808            mr_free(output);
     809            mr_asprintf(&output, dvd_last_resort);
    808810            found_it = TRUE;
    809811        }
    810812    }
    811     paranoid_free(dvd_last_resort);
     813    mr_free(dvd_last_resort);
    812814
    813815    if (found_it) {
    814         asprintf(&tmp, "grep \"%s=ide-scsi\" /proc/cmdline &> /dev/null",
     816        mr_asprintf(&tmp, "grep \"%s=ide-scsi\" /proc/cmdline &> /dev/null",
    815817                strrchr(output, '/') + 1);
    816818        if (system(tmp) == 0) {
     
    819821                    output);
    820822            found_it = FALSE;
    821             paranoid_free(output);
    822         }
    823         paranoid_free(tmp);
     823            mr_free(output);
     824        }
     825        mr_free(tmp);
    824826    }
    825827
     
    829831            log_msg(4, "OK, I was wrong, I haven't found it... yet.");
    830832            found_it = FALSE;
    831             paranoid_free(output);
     833            mr_free(output);
    832834        }
    833835    }
     
    862864                                                                  g_cdrw_drive_is_here)))
    863865                                    {
    864                                         paranoid_free(cdr_exe);
     866                                        mr_free(cdr_exe);
    865867                                        return(NULL);
    866868                                    }
     
    875877#endif
    876878
    877     asprintf(&mountpoint, "/tmp/cd.%d", (int) (random() % 32767));
     879    mr_asprintf(&mountpoint, "/tmp/cd.%d", (int) (random() % 32767));
    878880    make_hole_for_dir(mountpoint);
    879881
     
    882884            log_msg(4, "[Cardigans] I've changed my mind");
    883885            found_it = FALSE;
    884             paranoid_free(output);
     886            mr_free(output);
    885887        } else {
    886             asprintf(&tmp, "%s/archives", mountpoint);
     888            mr_asprintf(&tmp, "%s/archives", mountpoint);
    887889            if (!does_file_exist(tmp)) {
    888890                log_msg(4, "[Cardigans] I'll take it back");
    889891                found_it = FALSE;
    890                 paranoid_free(output);
     892                mr_free(output);
    891893            } else {
    892                 asprintf(&command, "umount %s", output);
     894                mr_asprintf(&command, "umount %s", output);
    893895                paranoid_system(command);
    894                 paranoid_free(command);
     896                mr_free(command);
    895897                log_msg(4, "I'm confident the Mondo CD is in %s", output);
    896898            }
    897             paranoid_free(tmp);
     899            mr_free(tmp);
    898900        }
    899901    }
    900902    unlink(mountpoint);
    901     paranoid_free(mountpoint);
     903    mr_free(mountpoint);
    902904
    903905    if (found_it) {
    904906        if (!does_file_exist(output)) {
    905907            log_msg(3, "I still haven't found it.");
    906             paranoid_free(output);
     908            mr_free(output);
    907909            return(NULL);
    908910        }
    909911        log_msg(3, "(find_cdrom_device) --> '%s'", output);
    910         asprintf(&the_last_place_i_found_it, output);
    911         paranoid_free(g_cdrom_drive_is_here);
    912         asprintf(&g_cdrom_drive_is_here, output);
     912        mr_asprintf(&the_last_place_i_found_it, output);
     913        mr_free(g_cdrom_drive_is_here);
     914        mr_asprintf(&g_cdrom_drive_is_here, output);
    913915        return(output);
    914916    }
    915917
    916     asprintf(&command,
     918    mr_asprintf(&command,
    917919            "%s -scanbus | grep \"[0-9],[0-9],[0-9]\" | grep \"[D|C][V|D]\" | grep -n \"\" | grep \"%s\" | cut -d':' -f2",
    918920            cdr_exe, g_cdrw_drive_is_here);
    919     paranoid_free(cdr_exe);
     921    mr_free(cdr_exe);
    920922
    921923    log_msg(1, "command=%s", command);
    922     asprintf(&tmp, call_program_and_get_last_line_of_output(command));
    923     paranoid_free(command);
     924    mr_asprintf(&tmp, call_program_and_get_last_line_of_output(command));
     925    mr_free(command);
    924926
    925927    if (tmp[0]) {
     
    927929        log_msg(4, "Finally found it at %s", output);
    928930    } else {
    929         paranoid_free(tmp);
    930         paranoid_free(output);
     931        mr_free(tmp);
     932        mr_free(output);
    931933        log_msg(4, "Still couldn't find it.");
    932934    }
     
    942944
    943945    if (g_dvd_drive_is_here != NULL) {
    944         asprintf(&output, g_dvd_drive_is_here);
     946        mr_asprintf(&output, g_dvd_drive_is_here);
    945947        log_msg(3, "Been there, done that. Returning %s", output);
    946948        return (output);
    947949    }
    948950
    949     asprintf(&tmp, call_program_and_get_last_line_of_output
     951    mr_asprintf(&tmp, call_program_and_get_last_line_of_output
    950952            ("dvdrecord -scanbus 2> /dev/null | grep \") '\" | grep -n \"\" | grep DVD | cut -d':' -f1")
    951953        );
    952954    log_msg(5, "tmp = '%s'", tmp);
    953955    if (!tmp[0]) {
    954         paranoid_free(tmp);
    955         asprintf(&tmp, call_program_and_get_last_line_of_output
     956        mr_free(tmp);
     957        mr_asprintf(&tmp, call_program_and_get_last_line_of_output
    956958                ("cdrecord -scanbus 2> /dev/null | grep \") '\" | grep -n \"\" | grep DVD | cut -d':' -f1")
    957959            );
     
    960962        devno = atoi(tmp) - 1;
    961963    }
    962     paranoid_free(tmp);
     964    mr_free(tmp);
    963965
    964966    if (devno >= 0) {
    965967        retval = 0;
    966         asprintf(&output, "/dev/scd%d", devno);
    967         paranoid_free(g_dvd_drive_is_here);
    968         asprintf(&g_dvd_drive_is_here, output);
     968        mr_asprintf(&output, "/dev/scd%d", devno);
     969        mr_free(g_dvd_drive_is_here);
     970        mr_asprintf(&g_dvd_drive_is_here, output);
    969971        log_msg(2, "I think DVD is at %s", output);
    970972    } else {
     
    10921094    assert_string_is_neither_NULL_nor_zerolength(format);
    10931095
    1094     asprintf(&format_sz, "%s ", format);
     1096    mr_asprintf(&format_sz, "%s ", format);
    10951097
    10961098#ifdef __FreeBSD__
    1097     asprintf(&command,
     1099    mr_asprintf(&command,
    10981100            "lsvfs | tr -s '\t' ' ' | grep -v Filesys | grep -v -- -- | cut -d' ' -f1 | tr -s '\n' ' '");
    10991101#else
    1100     asprintf(&command,
     1102    mr_asprintf(&command,
    11011103            "grep -v nodev /proc/filesystems | tr -s '\t' ' ' | cut -d' ' -f2 | tr -s '\n' ' '");
    11021104#endif
    11031105
    11041106    pin = popen(command, "r");
    1105     paranoid_free(command);
     1107    mr_free(command);
    11061108
    11071109    if (!pin) {
     
    11091111        retval = FALSE;
    11101112    } else {
    1111         getline(&good_formats, &n , pin);
     1113        mr_getline(&good_formats, &n , pin);
    11121114        if (pclose(pin)) {
    11131115            log_OS_error("Cannot pclose good formats");
     
    11151117        strip_spaces(good_formats);
    11161118        // " ntfs 7 " -- um, cheating much? :)
    1117         asprintf(&tmp, " %s swap lvm raid ntfs 7 ",good_formats);
    1118         paranoid_free(good_formats);
     1119        mr_asprintf(&tmp, " %s swap lvm raid ntfs 7 ",good_formats);
     1120        mr_free(good_formats);
    11191121        good_formats = tmp;
    11201122
     
    11241126            retval = FALSE;
    11251127        }
    1126         paranoid_free(good_formats);
    1127     }
    1128     paranoid_free(format_sz);
     1128        mr_free(good_formats);
     1129    }
     1130    mr_free(format_sz);
    11291131    return (retval);
    11301132}
     
    11641166        log_msg(1, "%s needs to have a '/' prefixed - I'll do it",
    11651167                device_raw);
    1166         asprintf(&tmp, "/%s", device_raw);
    1167     } else {
    1168         asprintf(&tmp, device_raw);
     1168        mr_asprintf(&tmp, "/%s", device_raw);
     1169    } else {
     1170        mr_asprintf(&tmp, device_raw);
    11691171    }
    11701172    log_msg(1, "Is %s mounted?", tmp);
     
    11741176        return (FALSE);
    11751177    }
    1176     asprintf(&device_with_tab, "%s\t", tmp);
    1177     asprintf(&device_with_space, "%s ", tmp);
    1178     paranoid_free(tmp);
     1178    mr_asprintf(&device_with_tab, "%s\t", tmp);
     1179    mr_asprintf(&device_with_space, "%s ", tmp);
     1180    mr_free(tmp);
    11791181
    11801182    if (!(fin = popen("mount", "r"))) {
     
    11821184        return (FALSE);
    11831185    }
    1184     for (getline(&incoming, &n, fin); !feof(fin);
    1185          getline(&incoming, &n, fin)) {
     1186    for (mr_getline(&incoming, &n, fin); !feof(fin);
     1187         mr_getline(&incoming, &n, fin)) {
    11861188        if (strstr(incoming, device_with_space) //> incoming
    11871189            || strstr(incoming, device_with_tab))   // > incoming)
     
    11911193        }
    11921194    }
    1193     paranoid_free(incoming);
    1194     paranoid_free(device_with_tab);
     1195    mr_free(incoming);
     1196    mr_free(device_with_tab);
    11951197    paranoid_pclose(fin);
    11961198
    1197     asprintf(&tmp, "%s | grep -w \"%s\" > /dev/null 2> /dev/null",
     1199    mr_asprintf(&tmp, "%s | grep -w \"%s\" > /dev/null 2> /dev/null",
    11981200            SWAPLIST_COMMAND, device_with_space);
    1199     paranoid_free(device_with_space);
     1201    mr_free(device_with_space);
    12001202
    12011203    log_msg(4, "tmp (command) = '%s'", tmp);
    12021204    if (!system(tmp)) {
    1203         paranoid_free(tmp);
     1205        mr_free(tmp);
    12041206        return(TRUE);
    12051207    }
    1206     paranoid_free(tmp);
     1208    mr_free(tmp);
    12071209    return (FALSE);
    12081210}
     
    12281230         ("/sbin/sysctl -n kern.osreldate")) < 500000) {
    12291231        do {
    1230             paranoid_free(mddevice);
    1231             asprintf(&mddevice, "vn%ic", vndev++);
    1232 
    1233             paranoid_free(command);
    1234             asprintf(&command, "vnconfig %s %s", mddevice, fname);
     1232            mr_free(mddevice);
     1233            mr_asprintf(&mddevice, "vn%ic", vndev++);
     1234
     1235            mr_free(command);
     1236            mr_asprintf(&command, "vnconfig %s %s", mddevice, fname);
    12351237
    12361238            if (vndev > 10) {
    1237                 paranoid_free(command);
    1238                 paranoid_free(mddevice);
     1239                mr_free(command);
     1240                mr_free(mddevice);
    12391241                return NULL;
    12401242            }
    12411243        }
    12421244        while (system(command));
    1243         paranoid_free(command);
    1244     } else {
    1245         asprintf(&command, "mdconfig -a -t vnode -f %s", fname);
    1246         asprintf(&mddevice, call_program_and_get_last_line_of_output(command));
    1247         paranoid_free(command);
     1245        mr_free(command);
     1246    } else {
     1247        mr_asprintf(&command, "mdconfig -a -t vnode -f %s", fname);
     1248        mr_asprintf(&mddevice, call_program_and_get_last_line_of_output(command));
     1249        mr_free(command);
    12481250
    12491251        if (!strstr(mddevice, "md")) {
    1250             paranoid_free(mddevice);
     1252            mr_free(mddevice);
    12511253            return NULL;
    12521254        }
    12531255    }
    1254     asprintf(&device, "/dev/%s", mddevice);
    1255     paranoid_free(mddevice);
     1256    mr_asprintf(&device, "/dev/%s", mddevice);
     1257    mr_free(mddevice);
    12561258    return(device);
    12571259}
     
    12781280        (call_program_and_get_last_line_of_output
    12791281         ("/sbin/sysctl -n kern.osreldate")) < 500000) {
    1280         asprintf(&command, "vnconfig -d %s", dname);
     1282        mr_asprintf(&command, "vnconfig -d %s", dname);
    12811283        ret = system(command);
    1282         paranoid_free(command);
     1284        mr_free(command);
    12831285        return(ret);
    12841286    } else {
    1285         asprintf(&command, "mdconfig -d -u %s", dname);
     1287        mr_asprintf(&command, "mdconfig -d -u %s", dname);
    12861288        ret = system(command);
    1287         paranoid_free(command);
     1289        mr_free(command);
    12881290        return(ret);
    12891291    }
     
    13271329    }
    13281330
    1329     asprintf(&tmp, "mkdir -p " MNT_CDROM);
     1331    mr_asprintf(&tmp, "mkdir -p " MNT_CDROM);
    13301332    run_program_and_log_output(tmp, 5);
    1331     paranoid_free(tmp);
     1333    mr_free(tmp);
    13321334
    13331335    if (g_ISO_restore_mode || bkpinfo->backup_media_type == iso
     
    13411343        }
    13421344        system("mkdir -p /tmp/isodir &> /dev/null");
    1343         asprintf(&tmp, "%s/%s/%s-%d.iso", bkpinfo->isodir,
     1345        mr_asprintf(&tmp, "%s/%s/%s-%d.iso", bkpinfo->isodir,
    13441346                bkpinfo->nfs_remote_dir, bkpinfo->prefix,
    13451347                cd_number_i_want);
    13461348        if (!does_file_exist(tmp)) {
    1347             paranoid_free(tmp);
    1348             asprintf(&tmp, "/tmp/isodir/%s/%s-%d.iso",
     1349            mr_free(tmp);
     1350            mr_asprintf(&tmp, "/tmp/isodir/%s/%s-%d.iso",
    13491351                    bkpinfo->nfs_remote_dir, bkpinfo->prefix,
    13501352                    cd_number_i_want);
     
    13531355                        "FIXME - hacking bkpinfo->isodir from '%s' to /tmp/isodir",
    13541356                        bkpinfo->isodir);
    1355                 paranoid_alloc(bkpinfo->isodir, "/tmp/isodir");
     1357                mr_allocstr(bkpinfo->isodir, "/tmp/isodir");
    13561358            }
    13571359        }
     
    13601362            fatal_error("Mommy!");
    13611363        }
    1362         paranoid_free(tmp);
     1364        mr_free(tmp);
    13631365    }
    13641366    if ((res = what_number_cd_is_this(bkpinfo)) != cd_number_i_want) {
    13651367        log_msg(3, "Currently, we hold %d but we want %d", res,
    13661368                cd_number_i_want);
    1367         asprintf(&tmp, "Insisting on %s #%d",
     1369        mr_asprintf(&tmp, "Insisting on %s #%d",
    13681370                bkpinfo->backup_media_string,
    13691371                cd_number_i_want);
    1370         asprintf(&request, "Please insert %s #%d and press Enter.",
     1372        mr_asprintf(&request, "Please insert %s #%d and press Enter.",
    13711373                bkpinfo->backup_media_string,
    13721374                cd_number_i_want);
    13731375        log_msg(3, tmp);
    1374         paranoid_free(tmp);
     1376        mr_free(tmp);
    13751377
    13761378        while (what_number_cd_is_this(bkpinfo) != cd_number_i_want) {
     
    13991401            sync();
    14001402        }
    1401         paranoid_free(request);
     1403        mr_free(request);
    14021404
    14031405        log_msg(1, "Thankyou. Proceeding...");
     
    14941496                finish(1);
    14951497            }
    1496             asprintf(&comment, _("What speed is your %s (re)writer?"),
     1498            mr_asprintf(&comment, _("What speed is your %s (re)writer?"),
    14971499                    bkpinfo->backup_media_string);
    14981500            if (bkpinfo->backup_media_type == dvd) {
    1499                 paranoid_free(bkpinfo->media_device);
     1501                mr_free(bkpinfo->media_device);
    15001502                bkpinfo->media_device = find_dvd_device();
    1501                 asprintf(&tmp, "1");
    1502                 asprintf(&sz_size, "%d", DEFAULT_DVD_DISK_SIZE);    // 4.7 salesman's GB = 4.482 real GB = 4582 MB
     1503                mr_asprintf(&tmp, "1");
     1504                mr_asprintf(&sz_size, "%d", DEFAULT_DVD_DISK_SIZE); // 4.7 salesman's GB = 4.482 real GB = 4582 MB
    15031505                log_msg(1, "Setting to DVD defaults");
    15041506            } else {
    1505                 paranoid_alloc(bkpinfo->media_device,VANILLA_SCSI_CDROM );
    1506                 asprintf(&tmp, "4");
    1507                 asprintf(&sz_size, "650");
     1507                mr_allocstr(bkpinfo->media_device,VANILLA_SCSI_CDROM );
     1508                mr_asprintf(&tmp, "4");
     1509                mr_asprintf(&sz_size, "650");
    15081510                log_msg(1, "Setting to CD defaults");
    15091511            }
     
    15141516                }
    15151517            }
    1516             paranoid_free(comment);
     1518            mr_free(comment);
    15171519
    15181520            bkpinfo->cdrw_speed = atoi(tmp);    // if DVD then this shouldn't ever be used anyway :)
    1519             paranoid_free(tmp);
    1520 
    1521             asprintf(&comment,
     1521            mr_free(tmp);
     1522
     1523            mr_asprintf(&comment,
    15221524                    _("How much data (in Megabytes) will each %s store?"),
    15231525                    bkpinfo->backup_media_string);
     
    15271529                finish(1);
    15281530            }
    1529             paranoid_free(comment);
     1531            mr_free(comment);
    15301532
    15311533            for (i = 0; i <= MAX_NOOF_MEDIA; i++) {
    15321534                bkpinfo->media_size[i] = atoi(sz_size);
    15331535            }
    1534             paranoid_free(sz_size);
     1536            mr_free(sz_size);
    15351537
    15361538            if (bkpinfo->media_size[0] <= 0) {
     
    15411543    case cdstream:
    15421544        if (bkpinfo->disaster_recovery) {
    1543             paranoid_alloc(bkpinfo->media_device, "/dev/cdrom");
     1545            mr_allocstr(bkpinfo->media_device, "/dev/cdrom");
    15441546            log_msg(2, "CD-ROM device assumed to be at %s",
    15451547                    bkpinfo->media_device);
     
    15471549                   || bkpinfo->backup_media_type == dvd) {
    15481550            if (bkpinfo->media_device == NULL) {
    1549                 asprintf(&bkpinfo->media_device, "/dev/cdrom");
     1551                mr_asprintf(&bkpinfo->media_device, "/dev/cdrom");
    15501552            }                   // just for the heck of it :)
    15511553            log_msg(1, "bkpinfo->media_device = %s",
     
    15541556            if ((bkpinfo->backup_media_type == dvd)
    15551557                || (tmp != NULL)) {
    1556                 paranoid_alloc(bkpinfo->media_device, tmp);
     1558                mr_allocstr(bkpinfo->media_device, tmp);
    15571559                log_msg(1, "bkpinfo->media_device = %s",
    15581560                        bkpinfo->media_device);
    1559                 asprintf(&comment,
     1561                mr_asprintf(&comment,
    15601562                        _("Please specify your %s drive's /dev entry"),
    15611563                        bkpinfo->backup_media_string);
     
    15651567                    finish(1);
    15661568                }
    1567                 paranoid_free(comment);
    1568             }
    1569             paranoid_free(tmp);
     1569                mr_free(comment);
     1570            }
     1571            mr_free(tmp);
    15701572
    15711573            log_msg(2, "%s device found at %s",
     
    15751577            bkpinfo->media_device = find_cdrw_device();
    15761578            if (bkpinfo->media_device != NULL) {
    1577                 asprintf(&tmp,
     1579                mr_asprintf(&tmp,
    15781580                        _("I think I've found your %s burner at SCSI node %s; am I right on the money? Say no if you have an IDE burner and you are running a 2.6 kernel. Instead, specify the IDE burner's /dev address at the next screen."),
    15791581                        bkpinfo->backup_media_string,
    15801582                        bkpinfo->media_device);
    15811583                if (!ask_me_yes_or_no(tmp)) {
    1582                     paranoid_free(bkpinfo->media_device);
     1584                    mr_free(bkpinfo->media_device);
    15831585                }
    1584                 paranoid_free(tmp);
     1586                mr_free(tmp);
    15851587            } else {
    15861588                if (g_kernel_version < 2.6) {
     
    16131615    case tape:
    16141616
    1615         paranoid_free(bkpinfo->media_device);
     1617        mr_free(bkpinfo->media_device);
    16161618        if (find_tape_device_and_size(bkpinfo->media_device, sz_size)) {
    16171619            log_msg(3, _("Ok, using vanilla scsi tape."));
    1618             paranoid_alloc(bkpinfo->media_device,VANILLA_SCSI_TAPE"0" );
     1620            mr_allocstr(bkpinfo->media_device,VANILLA_SCSI_TAPE"0" );
    16191621            if ((fin = fopen(bkpinfo->media_device, "r"))) {
    16201622                paranoid_fclose(fin);
    16211623            } else {
    1622                 paranoid_alloc(bkpinfo->media_device,"/dev/osst0");
     1624                mr_allocstr(bkpinfo->media_device,"/dev/osst0");
    16231625            }
    16241626        }
     
    16281630            } else {
    16291631                if (does_file_exist("/tmp/mondo-restore.cfg")) {
    1630                     paranoid_free(bkpinfo->media_device);
     1632                    mr_free(bkpinfo->media_device);
    16311633                    read_cfg_var("/tmp/mondo-restore.cfg", "media-dev",
    16321634                                 bkpinfo->media_device);
    16331635                }
    16341636            }
    1635             asprintf(&tmp,
     1637            mr_asprintf(&tmp,
    16361638                    _("I think I've found your tape streamer at %s; am I right on the money?"),
    16371639                    bkpinfo->media_device);
    16381640            if (!ask_me_yes_or_no(tmp)) {
    1639                 paranoid_free(bkpinfo->media_device);
    1640             }
    1641             paranoid_free(tmp);
     1641                mr_free(bkpinfo->media_device);
     1642            }
     1643            mr_free(tmp);
    16421644        } else {
    16431645            if (!popup_and_get_string
     
    16491651            }
    16501652        }
    1651         asprintf(&tmp, "ls -l %s", bkpinfo->media_device);
     1653        mr_asprintf(&tmp, "ls -l %s", bkpinfo->media_device);
    16521654        if (run_program_and_log_output(tmp, FALSE)) {
    16531655            log_to_screen(_("User has not specified a valid /dev entry"));
    16541656            finish(1);
    16551657        }
    1656         paranoid_free(tmp);
     1658        mr_free(tmp);
    16571659        log_msg(4, "sz_size = %s", sz_size);
    1658         paranoid_free(sz_size);
     1660        mr_free(sz_size);
    16591661        bkpinfo->media_size[0] = 0;
    16601662        log_msg(4, "media_size[0] = %ld", bkpinfo->media_size[0]);
     
    17081710            if (bkpinfo->nfs_mount[strlen(bkpinfo->nfs_mount) - 1] == '/')
    17091711                bkpinfo->nfs_mount[strlen(bkpinfo->nfs_mount) - 1] = '\0';
    1710             asprintf(&command, "mount | grep \"%s \" | cut -d' ' -f3",
     1712            mr_asprintf(&command, "mount | grep \"%s \" | cut -d' ' -f3",
    17111713                    bkpinfo->nfs_mount);
    1712             paranoid_free(bkpinfo->isodir);
     1714            mr_free(bkpinfo->isodir);
    17131715            bkpinfo->isodir = call_program_and_get_last_line_of_output(command);
    1714             paranoid_free(command);
    1715 
    1716             asprintf(&comment,
     1716            mr_free(command);
     1717
     1718            mr_asprintf(&comment,
    17171719                    _("How much data (in Megabytes) will each media store?"));
    17181720            if (!popup_and_get_string(_("Size"), comment, sz_size)) {
     
    17271729                finish(1);
    17281730            }
    1729             paranoid_free(comment);
     1731            mr_free(comment);
    17301732        }
    17311733        if (bkpinfo->disaster_recovery) {
     
    17391741        }
    17401742        if (!is_this_device_mounted(bkpinfo->nfs_mount)) {
    1741             paranoid_free(bkpinfo->isodir);
    1742             asprintf(&bkpinfo->isodir, "/tmp/isodir.mondo.%d",
     1743            mr_free(bkpinfo->isodir);
     1744            mr_asprintf(&bkpinfo->isodir, "/tmp/isodir.mondo.%d",
    17431745                    (int) (random() % 32768));
    1744             asprintf(&command, "mkdir -p %s", bkpinfo->isodir);
     1746            mr_asprintf(&command, "mkdir -p %s", bkpinfo->isodir);
    17451747            run_program_and_log_output(command, 5);
    1746             paranoid_free(command);
    1747 
    1748             asprintf(&tmp, "mount -t nfs -o nolock %s %s", bkpinfo->nfs_mount,
     1748            mr_free(command);
     1749
     1750            mr_asprintf(&tmp, "mount -t nfs -o nolock %s %s", bkpinfo->nfs_mount,
    17491751                    bkpinfo->isodir);
    17501752            run_program_and_log_output(tmp, 5);
    1751             paranoid_free(tmp);
    1752             asprintf(&g_selfmounted_isodir, bkpinfo->isodir);
     1753            mr_free(tmp);
     1754            mr_asprintf(&g_selfmounted_isodir, bkpinfo->isodir);
    17531755        }
    17541756        if (!is_this_device_mounted(bkpinfo->nfs_mount)) {
     
    17631765        }
    17641766
    1765         asprintf(&command, "echo hi > '%s/%s/.dummy.txt'", bkpinfo->isodir,
     1767        mr_asprintf(&command, "echo hi > '%s/%s/.dummy.txt'", bkpinfo->isodir,
    17661768                bkpinfo->nfs_remote_dir);
    17671769        while (run_program_and_log_output(command, FALSE)) {
    1768             asprintf(&prompt,
     1770            mr_asprintf(&prompt,
    17691771                     _("Directory '%s' under mountpoint '%s' does not exist or is not writable. You can fix this or change the directory and retry or cancel the backup."),
    17701772                     bkpinfo->nfs_remote_dir, bkpinfo->isodir);
     
    17741776                finish(1);
    17751777            }
    1776             paranoid_free(prompt);
    1777 
    1778             paranoid_free(command);
    1779             asprintf(&command, "echo hi > %s/%s/.dummy.txt",
     1778            mr_free(prompt);
     1779
     1780            mr_free(command);
     1781            mr_asprintf(&command, "echo hi > %s/%s/.dummy.txt",
    17801782                     bkpinfo->isodir, bkpinfo->nfs_remote_dir);
    17811783        }
    1782         paranoid_free(command);
     1784        mr_free(command);
    17831785
    17841786        if (!popup_and_get_string
     
    18451847
    18461848        if (bkpinfo->boot_device) {
    1847             paranoid_free(bkpinfo->boot_device);
     1849            mr_free(bkpinfo->boot_device);
    18481850        }
    18491851#ifdef __FreeBSD__
     
    19031905        }
    19041906        bkpinfo->boot_loader = i;
    1905         asprintf(&bkpinfo->include_paths, "/");
     1907        mr_asprintf(&bkpinfo->include_paths, "/");
    19061908        if (!popup_and_get_string
    19071909            (_("Backup paths"),
     
    19161918            if (bkpinfo->exclude_paths != NULL) {
    19171919                tmp1 = bkpinfo->exclude_paths;
    1918                 asprintf(&bkpinfo->exclude_paths, "%s %s", tmp1, tmp);
    1919                 paranoid_free(tmp1);
     1920                mr_asprintf(&bkpinfo->exclude_paths, "%s %s", tmp1, tmp);
     1921                mr_free(tmp1);
    19201922            } else {
    19211923                bkpinfo->exclude_paths = tmp;
    19221924            }
    19231925        }
    1924         paranoid_free(tmp);
     1926        mr_free(tmp);
    19251927// NTFS
    19261928        tmp = call_program_and_get_last_line_of_output
     
    19361938            if (bkpinfo->image_devs != NULL) {
    19371939                tmp2 = bkpinfo->image_devs;
    1938                 asprintf(&bkpinfo->image_devs, "%s %s", tmp2, tmp1);
    1939                 paranoid_free(tmp2);
     1940                mr_asprintf(&bkpinfo->image_devs, "%s %s", tmp2, tmp1);
     1941                mr_free(tmp2);
    19401942            } else {
    19411943                bkpinfo->image_devs = tmp1;
    19421944            }
    1943             paranoid_free(tmp1);
    1944         }
    1945         paranoid_free(tmp);
     1945            mr_free(tmp1);
     1946        }
     1947        mr_free(tmp);
    19461948
    19471949        if (!popup_and_get_string
     
    19611963        if (!ask_me_yes_or_no
    19621964            (_("Are you confident that your kernel is a sane, sensible, standard Linux kernel? Say 'no' if you are using a Gentoo <1.4 or Debian <3.0, please."))){
    1963             paranoid_alloc(bkpinfo->kernel_path, "FAILSAFE");
     1965            mr_allocstr(bkpinfo->kernel_path, "FAILSAFE");
    19641966        }
    19651967#endif
     
    19921994    log_it("media size = %ld", bkpinfo->media_size[1]);
    19931995    log_it("media type = %s", bkpinfo->backup_media_string);
    1994     paranoid_free(tmp);
     1996    mr_free(tmp);
    19951997    log_it("prefix = %s", bkpinfo->prefix);
    19961998    log_it("compression = %ld", bkpinfo->compression_level);
     
    20242026           ("mount -t coda,ncpfs,nfs,smbfs,cifs,afs,mvfs | tr -s '\t' ' ' | cut -d' ' -f3 | tr -s '\n' ' ' | awk '{print $0;}'"));
    20252027    /* BERLIOS : Useless
    2026     asprintf(&exclude_these_devices,
     2028    mr_asprintf(&exclude_these_devices,
    20272029           call_program_and_get_last_line_of_output
    20282030           ("tr -s '\t' ' ' < /etc/fstab | grep -E '( (coda|ncpfs|nfs|smbfs|cifs|mvfs) )' | cut -d' ' -f1 | tr -s '\n' ' ' | awk '{print $0;}'"));
     
    20572059
    20582060    if (tmp[0] != '/') {
    2059         asprintf(&sz, "/%s", tmp);
    2060         paranoid_free(tmp);
     2061        mr_asprintf(&sz, "/%s", tmp);
     2062        mr_free(tmp);
    20612063        tmp = sz;
    20622064    }
     
    20652067    }
    20662068    i = (int) (random() % 32768);
    2067     paranoid_free(bkpinfo->tmpdir);
    2068     asprintf(&bkpinfo->tmpdir, "%s/mondo.tmp.%d", tmp, i);
     2069    mr_free(bkpinfo->tmpdir);
     2070    mr_asprintf(&bkpinfo->tmpdir, "%s/mondo.tmp.%d", tmp, i);
    20692071    log_it("bkpinfo->tmpdir is being set to %s", bkpinfo->tmpdir);
    20702072
    2071     paranoid_free(bkpinfo->scratchdir);
    2072     asprintf(&bkpinfo->scratchdir, "%s/mondo.scratch.%d", tmp, i);
     2073    mr_free(bkpinfo->scratchdir);
     2074    mr_asprintf(&bkpinfo->scratchdir, "%s/mondo.scratch.%d", tmp, i);
    20732075    log_it("bkpinfo->scratchdir is being set to %s", bkpinfo->scratchdir);
    20742076
    2075     asprintf(&g_erase_tmpdir_and_scratchdir, "rm -Rf %s %s", bkpinfo->tmpdir,
     2077    mr_asprintf(&g_erase_tmpdir_and_scratchdir, "rm -Rf %s %s", bkpinfo->tmpdir,
    20762078            bkpinfo->scratchdir);
    20772079
    2078     asprintf(&command, "rm -Rf %s/mondo.tmp.* %s/mondo.scratch.*", tmp, tmp);
    2079     paranoid_free(tmp);
     2080    mr_asprintf(&command, "rm -Rf %s/mondo.tmp.* %s/mondo.scratch.*", tmp, tmp);
     2081    mr_free(tmp);
    20802082
    20812083    paranoid_system(command);
    2082     paranoid_free(command);
     2084    mr_free(command);
    20832085}
    20842086
     
    20992101    char *command;
    21002102
    2101     paranoid_free(output);
     2103    mr_free(output);
    21022104    if (!dev || dev[0] == '\0') {
    21032105        return (FALSE);
     
    21092111        return (FALSE);
    21102112    }
    2111     asprintf(&command, "dd bs=%ld count=1 if=%s of=/dev/null &> /dev/null",
     2113    mr_asprintf(&command, "dd bs=%ld count=1 if=%s of=/dev/null &> /dev/null",
    21122114            512L, dev);
    21132115    if (!run_program_and_log_output(command, FALSE)
    21142116        && !run_program_and_log_output(command, FALSE)) {
    2115         asprintf(&output, dev);
     2117        mr_asprintf(&output, dev);
    21162118        log_msg(4, "Found it - %s", dev);
    2117         paranoid_free(command);
     2119        mr_free(command);
    21182120        return (TRUE);
    21192121    } else {
    21202122        log_msg(4, "It's not %s", dev);
    2121         paranoid_free(command);
     2123        mr_free(command);
    21222124        return (FALSE);
    21232125    }
     
    21412143    assert(bkpinfo != NULL);
    21422144    if (g_ISO_restore_mode) {
    2143         asprintf(&tmp, "mount | grep iso9660 | awk '{print $3;}'");
     2145        mr_asprintf(&tmp, "mount | grep iso9660 | awk '{print $3;}'");
    21442146
    21452147        tmp1 = call_program_and_get_last_line_of_output(tmp);
    2146         paranoid_free(tmp);
    2147 
    2148         asprintf(&mountdev, "%s/archives/THIS-CD-NUMBER", tmp1);
    2149         paranoid_free(tmp1);
     2148        mr_free(tmp);
     2149
     2150        mr_asprintf(&mountdev, "%s/archives/THIS-CD-NUMBER", tmp1);
     2151        mr_free(tmp1);
    21502152
    21512153        tmp = last_line_of_file(mountdev);
    21522154        cd_number = atoi(tmp);
    2153         paranoid_free(mountdev);
    2154         paranoid_free(tmp);
     2155        mr_free(mountdev);
     2156        mr_free(tmp);
    21552157
    21562158        return (cd_number);
     
    21672169    tmp = last_line_of_file(MNT_CDROM "/archives/THIS-CD-NUMBER");
    21682170    cd_number = atoi(tmp);
    2169     paranoid_free(tmp);
     2171    mr_free(tmp);
    21702172    return (cd_number);
    21712173}
     
    21902192           ("mount | grep \" on / \" | cut -d' ' -f1 | sed s/[0-9]// | sed s/[0-9]//");
    21912193    if (strstr(tmp, "/dev/cciss/")) {
    2192         paranoid_free(tmp);
     2194        mr_free(tmp);
    21932195        tmp = call_program_and_get_last_line_of_output
    21942196               ("mount | grep \" on / \" | cut -d' ' -f1 | cut -dp -f1");
    21952197    }
    21962198    if (strstr(tmp, "/dev/md")) {
    2197         paranoid_free(tmp);
     2199        mr_free(tmp);
    21982200        tmp = call_program_and_get_last_line_of_output
    21992201               ("mount | grep \" on / \" | cut -d' ' -f1");
     
    22782280#endif
    22792281    assert(which_device != NULL);
    2280     asprintf(&list_drives_cmd,
     2282    mr_asprintf(&list_drives_cmd,
    22812283            "parted2fdisk -l 2>/dev/null | grep \"/dev/.*:\" | tr -s ':' ' ' | tr -s ' ' '\n' | grep /dev/; echo %s",
    22822284            where_is_root_mounted());
     
    22852287    if (!(pdrives = popen(list_drives_cmd, "r"))) {
    22862288        log_OS_error("Unable to open list of drives");
    2287         paranoid_free(list_drives_cmd);
     2289        mr_free(list_drives_cmd);
    22882290        return ('\0');
    22892291    }
    2290     paranoid_free(list_drives_cmd);
    2291 
    2292     for (getline(&current_drive, &n, pdrives); !feof(pdrives);
    2293          getline(&current_drive, &n, pdrives)) {
     2292    mr_free(list_drives_cmd);
     2293
     2294    for (mr_getline(&current_drive, &n, pdrives); !feof(pdrives);
     2295         mr_getline(&current_drive, &n, pdrives)) {
    22942296        strip_spaces(current_drive);
    22952297        log_it("looking at drive %s's MBR", current_drive);
    22962298        if (does_string_exist_in_boot_block(current_drive, "GRUB")) {
    22972299            count_grubs++;
    2298             paranoid_alloc(which_device,current_drive);
     2300            mr_allocstr(which_device,current_drive);
    22992301            break;
    23002302        }
    23012303        if (does_string_exist_in_boot_block(current_drive, "LILO")) {
    23022304            count_lilos++;
    2303             paranoid_alloc(which_device,current_drive);
     2305            mr_allocstr(which_device,current_drive);
    23042306            break;
    23052307        }
     
    23712373        log_it
    23722374            ("resolve_softlinks_to_get_to_actual_device_file --- device not found");
    2373         asprintf(&output, incoming);
    2374     } else {
    2375         asprintf(&curr_fname, incoming);
     2375        mr_asprintf(&output, incoming);
     2376    } else {
     2377        mr_asprintf(&curr_fname, incoming);
    23762378        lstat(curr_fname, &statbuf);
    23772379        while (S_ISLNK(statbuf.st_mode)) {
    23782380            log_msg(1, "curr_fname = %s", curr_fname);
    2379             asprintf(&command, "file %s", curr_fname);
     2381            mr_asprintf(&command, "file %s", curr_fname);
    23802382            tmp = call_program_and_get_last_line_of_output(command);
    2381             paranoid_free(command);
     2383            mr_free(command);
    23822384
    23832385            for (p = tmp + strlen(tmp); p != tmp && *p != '`' && *p != ' ';
    23842386                 p--);
    23852387            p++;
    2386             asprintf(&scratch, p);
     2388            mr_asprintf(&scratch, p);
    23872389            for (p = scratch; *p != '\0' && *p != '\''; p++);
    23882390            *p = '\0';
    23892391            log_msg(0, "curr_fname %s --> '%s' --> %s", curr_fname, tmp, scratch);
    2390             paranoid_free(tmp);
     2392            mr_free(tmp);
    23912393
    23922394            if (scratch[0] == '/') {
    2393                 paranoid_free(curr_fname);
    2394                 asprintf(&curr_fname, scratch); // copy whole thing because it's an absolute softlink
     2395                mr_free(curr_fname);
     2396                mr_asprintf(&curr_fname, scratch);  // copy whole thing because it's an absolute softlink
    23952397            } else {            // copy over the basename cos it's a relative softlink
    23962398                p = curr_fname + strlen(curr_fname);
     
    24022404                }
    24032405                *p = '\0';
    2404                 asprintf(&tmp, "%s%s", curr_fname, scratch);
    2405                 paranoid_free(curr_fname);
     2406                mr_asprintf(&tmp, "%s%s", curr_fname, scratch);
     2407                mr_free(curr_fname);
    24062408                curr_fname = tmp;
    24072409            }
    2408             paranoid_free(scratch);
     2410            mr_free(scratch);
    24092411            lstat(curr_fname, &statbuf);
    24102412        }
    2411         asprintf(&output, curr_fname);
     2413        mr_asprintf(&output, curr_fname);
    24122414        log_it("resolved %s to %s", incoming, output);
    2413         paranoid_free(curr_fname);
     2415        mr_free(curr_fname);
    24142416    }
    24152417    return (output);
     
    24312433
    24322434    log_msg(0, "Looking for partition table format type");
    2433     asprintf(&fdisk, "/sbin/parted2fdisk");
     2435    mr_asprintf(&fdisk, "/sbin/parted2fdisk");
    24342436    log_msg(1, "Using %s", fdisk);
    2435     asprintf(&command, "%s -l %s | grep 'EFI GPT'", fdisk, drive);
    2436     paranoid_free(fdisk);
     2437    mr_asprintf(&command, "%s -l %s | grep 'EFI GPT'", fdisk, drive);
     2438    mr_free(fdisk);
    24372439
    24382440    tmp = call_program_and_get_last_line_of_output(command);
    2439     paranoid_free(command);
     2441    mr_free(command);
    24402442
    24412443    if (strstr(tmp, "GPT") == NULL) {
    2442         asprintf(&output, "MBR");
    2443     } else {
    2444         asprintf(&output, "GPT");
    2445     }
    2446     paranoid_free(tmp);
     2444        mr_asprintf(&output, "MBR");
     2445    } else {
     2446        mr_asprintf(&output, "GPT");
     2447    }
     2448    mr_free(tmp);
    24472449    log_msg(0, "Found %s partition table format type", output);
    24482450    return (output);
Note: See TracChangeset for help on using the changeset viewer.